From 997ed9267271e8d4d069b381cf6b1d2ea715041b Mon Sep 17 00:00:00 2001
From: Tom Close <tom.g.close@gmail.com>
Date: Tue, 7 Nov 2023 10:19:36 +1100
Subject: [PATCH 01/78] changed generated module names to snake_case

---
 nipype2pydra/task.py                          | 36 ++++++++++++-------
 scripts/pkg_gen/create_packages.py            |  2 +-
 scripts/pkg_gen/resources/README.rst          |  4 +--
 .../pkg_gen/resources/nipype-auto-convert.py  |  8 +++--
 4 files changed, 32 insertions(+), 18 deletions(-)

diff --git a/nipype2pydra/task.py b/nipype2pydra/task.py
index 9ee053a8..b91a1703 100644
--- a/nipype2pydra/task.py
+++ b/nipype2pydra/task.py
@@ -14,7 +14,7 @@
 from nipype.interfaces.base import traits_extension
 from pydra.engine import specs
 from pydra.engine.helpers import ensure_list
-from .utils import import_module_from_path, is_fileset
+from .utils import import_module_from_path, is_fileset, to_snake_case
 from fileformats.core import from_mime
 from fileformats.generic import File
 
@@ -385,7 +385,9 @@ def __attrs_post_init__(self):
         if self.output_module is None:
             if self.nipype_module.__name__.startswith("nipype.interfaces."):
                 pkg_name = self.nipype_module.__name__.split(".")[2]
-                self.output_module = f"pydra.tasks.{pkg_name}.auto.{self.task_name}"
+                self.output_module = (
+                    f"pydra.tasks.{pkg_name}.auto.{to_snake_case(self.task_name)}"
+                )
             else:
                 raise RuntimeError(
                     "Output-module needs to be explicitly provided to task converter "
@@ -400,11 +402,19 @@ def nipype_interface(self) -> nipype.interfaces.base.BaseInterface:
 
     @property
     def nipype_input_spec(self) -> nipype.interfaces.base.BaseInterfaceInputSpec:
-        return self.nipype_interface.input_spec() if self.nipype_interface.input_spec else None
+        return (
+            self.nipype_interface.input_spec()
+            if self.nipype_interface.input_spec
+            else None
+        )
 
     @property
     def nipype_output_spec(self) -> nipype.interfaces.base.BaseTraitedSpec:
-        return self.nipype_interface.output_spec() if self.nipype_interface.output_spec else None
+        return (
+            self.nipype_interface.output_spec()
+            if self.nipype_interface.output_spec
+            else None
+        )
 
     def generate(self, package_root: Path):
         """creating pydra input/output spec from nipype specs
@@ -500,9 +510,7 @@ def pydra_fld_input(self, field, nm):
             template = getattr(field, "name_template")
             name_source = ensure_list(getattr(field, "name_source"))
             if name_source:
-                tmpl = self.string_formats(
-                    argstr=template, name=name_source[0]
-                )
+                tmpl = self.string_formats(argstr=template, name=name_source[0])
             else:
                 tmpl = template
             metadata_pdr["output_file_template"] = tmpl
@@ -687,15 +695,15 @@ def types_to_names(spec_fields):
                 spec_fields_str.append(tuple(el))
             return spec_fields_str
 
-
-        base_imports = ["from pydra.engine import specs",]
+        base_imports = [
+            "from pydra.engine import specs",
+        ]
         if hasattr(self.nipype_interface, "_cmd"):
             task_base = "ShellCommandTask"
             base_imports.append("from pydra.engine import ShellCommandTask")
         else:
             task_base = "FunctionTask"
             base_imports.append("from pydra.engine.task import FunctionTask")
-            
 
         input_fields_str = types_to_names(spec_fields=input_fields)
         output_fields_str = types_to_names(spec_fields=output_fields)
@@ -742,7 +750,7 @@ def construct_imports(
         def add_import(stmt):
             match = re.match(r".*\s+as\s+(\w+)\s*", stmt)
             if not match:
-                match = re.match(r".*import\s+(\w+)\s*$", stmt)
+                match = re.match(r".*import\s+([\w\.]+)\s*$", stmt)
             if not match:
                 raise ValueError(f"Unrecognised import statment {stmt}")
             token = match.group(1)
@@ -780,6 +788,8 @@ def add_import(stmt):
                     add_import(f"from {stmt.module} import {nm}")
         for tp in nonstd_types:
             add_import(f"from {tp.__module__} import {tp.__name__}")
+        # For debugging
+        add_import(f"import {'.'.join(self.output_module.split('.')[:-2])}")
         if include_task:
             add_import(f"from {self.output_module} import {self.task_name}")
 
@@ -828,7 +838,9 @@ def write_tests(self, filename_test, input_fields, nonstd_types, run=False):
                     if value is None:
                         if is_fileset(tp):
                             value = f"{tp.__name__}.sample()"
-                        elif ty.get_origin(tp) in (list, ty.Union) and is_fileset(ty.get_args(tp)[0]):
+                        elif ty.get_origin(tp) in (list, ty.Union) and is_fileset(
+                            ty.get_args(tp)[0]
+                        ):
                             arg_tp = ty.get_args(tp)[0]
                             value = f"{arg_tp.__name__}.sample()"
                 if value is not attrs.NOTHING:
diff --git a/scripts/pkg_gen/create_packages.py b/scripts/pkg_gen/create_packages.py
index 8b1a0c2c..30bb47bb 100644
--- a/scripts/pkg_gen/create_packages.py
+++ b/scripts/pkg_gen/create_packages.py
@@ -36,7 +36,7 @@
 
 
 def download_tasks_template(output_path: Path):
-    """Downloads the latest pydra-tasks-template to the output path"""
+    """Downloads the latest pydra-template to the output path"""
 
     release_url = (
         "https://api.github.com/repos/nipype/pydra-tasks-template/releases/latest"
diff --git a/scripts/pkg_gen/resources/README.rst b/scripts/pkg_gen/resources/README.rst
index 4e5f72bd..d9af9070 100644
--- a/scripts/pkg_gen/resources/README.rst
+++ b/scripts/pkg_gen/resources/README.rst
@@ -2,8 +2,8 @@
 Pydra task package for CHANGEME
 ===============================
 
-.. image:: https://github.com/nipype/pydra-CHANGEME/actions/workflows/pythonpackage.yml/badge.svg
-   :target: https://github.com/nipype/pydra-CHANGEME/actions/workflows/pythonpackage.yml
+.. image:: https://github.com/nipype/pydra-CHANGEME/actions/workflows/pythonpackage.yaml/badge.svg
+   :target: https://github.com/nipype/pydra-CHANGEME/actions/workflows/pythonpackage.yaml
 .. .. image:: https://codecov.io/gh/nipype/pydra-CHANGEME/branch/main/graph/badge.svg?token=UIS0OGPST7
 ..    :target: https://codecov.io/gh/nipype/pydra-CHANGEME
 .. image:: https://img.shields.io/pypi/pyversions/pydra-CHANGEME.svg
diff --git a/scripts/pkg_gen/resources/nipype-auto-convert.py b/scripts/pkg_gen/resources/nipype-auto-convert.py
index 5c0a10f8..72dc760f 100644
--- a/scripts/pkg_gen/resources/nipype-auto-convert.py
+++ b/scripts/pkg_gen/resources/nipype-auto-convert.py
@@ -7,7 +7,7 @@
 from importlib import import_module
 import yaml
 import nipype
-import nipype2pydra
+import nipype2pydra.utils
 from nipype2pydra.task import TaskConverter
 
 
@@ -47,13 +47,15 @@
 
     callables = import_module(rel_pkg_path + "_callables")
 
+    module_name = nipype2pydra.utils.to_snake_case(spec["task_name"])
+
     converter = TaskConverter(
-        output_module=f"pydra.tasks.{PKG_NAME}.auto.{spec['task_name']}",
+        output_module=f"pydra.tasks.{PKG_NAME}.auto.{module_name}",
         callables_module=callables,  # type: ignore
         **spec,
     )
     converter.generate(PKG_ROOT)
-    auto_init += f"from .{spec['task_name']} import {converter.task_name}\n"
+    auto_init += f"from .{module_name} import {converter.task_name}\n"
 
 
 with open(PKG_ROOT / "pydra" / "tasks" / PKG_NAME / "auto" / "_version.py", "w") as f:

From c93ab631335006798064153719793e17882e4f81 Mon Sep 17 00:00:00 2001
From: Tom Close <tom.g.close@gmail.com>
Date: Wed, 22 Nov 2023 09:41:21 +1100
Subject: [PATCH 02/78] reworked ci-cd workflow template

---
 scripts/pkg_gen/create_packages.py            |  52 ++-
 .../pkg_gen/resources/gh_workflows/ci-cd.yaml | 305 ++++++++++++++++++
 .../resources/gh_workflows/pythonpackage.yaml | 169 ----------
 3 files changed, 354 insertions(+), 172 deletions(-)
 create mode 100644 scripts/pkg_gen/resources/gh_workflows/ci-cd.yaml
 delete mode 100644 scripts/pkg_gen/resources/gh_workflows/pythonpackage.yaml

diff --git a/scripts/pkg_gen/create_packages.py b/scripts/pkg_gen/create_packages.py
index 30bb47bb..48dc4923 100644
--- a/scripts/pkg_gen/create_packages.py
+++ b/scripts/pkg_gen/create_packages.py
@@ -103,6 +103,7 @@ def generate_packages(
 
     for pkg in to_import["packages"]:
         pkg_dir = initialise_task_repo(output_dir, task_template, pkg)
+        pkg_formats = set()
 
         spec_dir = pkg_dir / "nipype-auto-conv" / "specs"
         spec_dir.mkdir(parents=True, exist_ok=True)
@@ -221,9 +222,16 @@ def guess_type(fspath):
                                     return Bval
                                 if fspath == "bvecs":
                                     return Bvec
+                                format_class_name = File.decompose_fspath(
+                                    fspath.strip(),
+                                    mode=File.ExtensionDecomposition.single,
+                                )[2][1:].capitalize()
+                                pkg_formats.add(format_class_name)
                                 unmatched_formats.append(
                                     f"{module}.{interface}: {fspath}"
                                 )
+                                if format_class_name:
+                                    return f"fileformats.medimage_{pkg}.{format_class_name}"
                                 return File
 
                             for expected in EXPECTED_FORMATS:
@@ -261,7 +269,7 @@ def combine_types(type_, prev_type):
 
                         test_inpts: ty.Dict[str, ty.Optional[ty.Type]] = {}
                         for name, val in inpts.items():
-                            if name in file_inputs:
+                            if name in file_inputs and name != "flags":
                                 guessed_type = guess_type(val)
                                 input_types[name] = combine_types(
                                     guessed_type, input_types[name]
@@ -393,6 +401,18 @@ def combine_types(type_, prev_type):
                         f'"""Module to put any functions that are referred to in {interface}.yaml"""\n'
                     )
 
+        with open(
+            pkg_dir / "fileformats" / "src" / "fileformats" / f"medimage_{pkg}" / "__init__.py",
+            "w",
+        ) as f:
+            f.write(gen_fileformats_module(pkg_formats))
+
+        with open(
+            pkg_dir / "fileformats" / "extras" / "fileformats" / "extras" / f"medimage_{pkg}" / "__init__.py",
+            "w",
+        ) as f:
+            f.write(gen_fileformats_extras_module(pkg_formats))
+
         sp.check_call("git init", shell=True, cwd=pkg_dir)
         sp.check_call("git add --all", shell=True, cwd=pkg_dir)
         sp.check_call(
@@ -443,8 +463,8 @@ def copy_ignore(_, names):
     gh_workflows_dir = pkg_dir / ".github" / "workflows"
     gh_workflows_dir.mkdir(parents=True, exist_ok=True)
     shutil.copy(
-        RESOURCES_DIR / "gh_workflows" / "pythonpackage.yaml",
-        gh_workflows_dir / "pythonpackage.yaml",
+        RESOURCES_DIR / "gh_workflows" / "ci-cd.yaml",
+        gh_workflows_dir / "ci-cd.yaml",
     )
 
     # Add modified README
@@ -462,6 +482,8 @@ def copy_ignore(_, names):
 
     # rename tasks directory
     (pkg_dir / "pydra" / "tasks" / "CHANGEME").rename(pkg_dir / "pydra" / "tasks" / pkg)
+    (pkg_dir / "fileformats" / "src" / "fileformats" / "medimage_CHANGEME").rename(pkg_dir / "fileformats" / "src" / "fileformats" / f"medimage_{pkg}")
+    (pkg_dir / "fileformats" / "extras" / "fileformats" / "extras" / "medimage_CHANGEME").rename(pkg_dir / "fileformats" / "extras" / "fileformats" / "extras" / f"medimage_{pkg}")
 
     # Add in modified __init__.py
     shutil.copy(
@@ -648,6 +670,30 @@ def extract_doctest_inputs(
     return cmdline, doctest_inpts, directive, imports
 
 
+def gen_fileformats_module(pkg_formats: ty.Set[str]):
+    code_str = "from fileformats.generic import File"
+    for frmt in pkg_formats:
+        code_str += f"""
+
+class {frmt}(File):
+    ext = ".{frmt.lower()}"
+    binary = True
+"""
+    return code_str
+
+
+def gen_fileformats_extras_module(pkg_formats: ty.Set[str]):
+    code_str = "from fileformats.core import FileSet"
+    for frmt in pkg_formats:
+        code_str += f"""
+
+@FileSet.generate_sample_data.register
+def gen_sample_{frmt.lower()}_data({frmt.lower()}: {frmt}, dest_dir: Path, seed: ty.Union[int, Random], stem: ty.Optional[str]):
+    raise NotImplementedError
+"""
+    return code_str
+
+
 if __name__ == "__main__":
     import sys
 
diff --git a/scripts/pkg_gen/resources/gh_workflows/ci-cd.yaml b/scripts/pkg_gen/resources/gh_workflows/ci-cd.yaml
new file mode 100644
index 00000000..12b99866
--- /dev/null
+++ b/scripts/pkg_gen/resources/gh_workflows/ci-cd.yaml
@@ -0,0 +1,305 @@
+#This workflow will install Python dependencies, run tests and lint with a variety of Python versions
+# For more information see: https://help.github.com/actions/language-and-framework-guides/using-python-with-github-actions
+
+# For deployment, it will be necessary to create a PyPI API token and store it as a secret
+# https://docs.github.com/en/actions/reference/encrypted-secrets
+
+name: CI/CD
+
+on:
+  push:
+    branches: [ main, develop ]
+    tags: [ '*' ]
+  pull_request:
+    branches: [ main, develop ]
+  repository_dispatch:
+    types: [create-release]
+
+jobs:
+
+  nipype-conv:
+    runs-on: ubuntu-latest
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v3
+    - name: Revert version to most recent tag on upstream update
+      if: github.event_name == 'repository_dispatch'
+      run: git checkout $(git tag -l | tail -n 1 | awk -F post '{print $1}')    
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v4
+    - name: Install build dependencies
+      run: python -m pip install --upgrade pip
+    - name: Install requirements
+      run: python -m pip install -r ./nipype-auto-conv/requirements.txt
+    - name: Run automatic Nipype > Pydra conversion
+      run: ./nipype-auto-conv/generate
+    - uses: actions/upload-artifact@v3
+      with:
+        name: converted-nipype
+        path: pydra/tasks/CHANGEME/auto
+
+  devcheck:
+    needs: [nipype-conv]
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ['3.8', '3.11']  # Check oldest and newest versions
+        pip-flags: ['', '--editable']
+        pydra:
+        - 'pydra'
+        - '--editable git+https://github.com/nipype/pydra.git#egg=pydra'
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v3
+    - name: Revert version to most recent tag on upstream update
+      if: github.event_name == 'repository_dispatch'
+      run: git checkout $(git tag -l | tail -n 1 | awk -F post '{print $1}')    
+    - name: Download tasks converted from Nipype 
+      uses: actions/download-artifact@v3
+      with:
+        name: converted-nipype
+        path: pydra/tasks/CHANGEME/auto
+    - name: Strip auto package from gitignore so it is included in package
+      run: |
+        sed -i '/\/pydra\/tasks\/CHANGEME\/auto/d' .gitignore
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v4
+      with:
+        python-version: ${{ matrix.python-version }}
+    - name: Install build dependencies
+      run: |
+        python -m pip install --upgrade pip
+    - name: Install Pydra
+      run: |
+        pushd $HOME
+        pip install ${{ matrix.pydra }}
+        popd
+        python -c "import pydra as m; print(f'{m.__name__} {m.__version__} @ {m.__file__}')"
+    - name: Install task package
+      run: |
+        pip install "./fileformats/src[dev]" "fileformats/extras[dev]"
+        pip install ${{ matrix.pip-flags }} ".[dev]"
+        python -c "import pydra.tasks.CHANGEME as m; print(f'{m.__name__} {m.__version__} @ {m.__file__}')"
+        python -c "import pydra as m; print(f'{m.__name__} {m.__version__} @ {m.__file__}')"
+        python -c "import fileformats.medimage_CHANGEME as m; print(f'{m.__name__} {m.__version__} @ {m.__file__}')"
+        python -c "import fileformats.extras.medimage_CHANGEME as m; print(f'{m.__name__} {m.__version__} @ {m.__file__}')"
+  
+  fileformats-test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ['3.8', '3.11']
+    steps:
+    - uses: actions/checkout@v3
+    - name: Revert version to most recent tag on upstream update
+      if: github.event_name == 'repository_dispatch'
+      run: git checkout $(git tag -l | tail -n 1 | awk -F post '{print $1}')
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v4
+      with:
+        python-version: ${{ matrix.python-version }}
+    - name: Install build dependencies
+      run: |
+        python -m pip install --upgrade pip
+    - name: Install task package
+      run: |
+        pip install "./fileformats/src[test]" "./fileformats/extras[test]"
+        python -c "import fileformats.medimage_CHANGEME as m; print(f'{m.__name__} {m.__version__} @ {m.__file__}')"
+    - name: Test fileformats with pytest
+      run: |
+        cd ./fileformats
+        pytest -sv --cov fileformats.medimage_CHANGEME --cov fileformats.extras.medimage_CHANGEME --cov-report xml .
+
+  test:
+    needs: [nipype-conv, fileformats-test]
+    runs-on: ubuntu-22.04
+    strategy:
+      matrix:
+        python-version: ['3.8']  # '3.11'
+    steps:
+    - name: Removed unnecessary tools to free space
+      run: |
+        sudo rm -rf /usr/share/dotnet
+        sudo rm -rf "$AGENT_TOOLSDIRECTORY"      
+    - name: Get Download cache Key
+      id: cache-key
+      run: echo "::set-output name=key::CHANGEME-linux-ubuntu22_amd64-7.4.1"
+    - name: Cache FreeSurfer
+      uses: actions/cache@v2
+      with:
+        path: $HOME/downloads/CHANGEME
+        key: ${{ steps.cache-key.outputs.key }}
+        restore-keys: |
+          CHANGEME-linux-ubuntu22_amd64-7.4.1
+    - name: Download FreeSurfer
+      if: steps.cache-key.outputs.key != steps.cache-hit.outputs.key
+      run: |
+        mkdir -p $HOME/downloads/CHANGEME
+        curl -s -o $HOME/downloads/CHANGEME/CHANGEME-linux-ubuntu22_amd64-7.4.1.tar.gz https://surfer.nmr.mgh.harvard.edu/pub/dist/CHANGEME/7.4.1/CHANGEME-linux-ubuntu22_amd64-7.4.1.tar.gz
+      shell: bash
+    - name: Install Freesurfer
+      env:
+        FREESURFER_LICENCE: ${{ secrets.FREESURFER_LICENCE }}
+      run: |
+        pushd $HOME/downloads/CHANGEME
+        tar -zxpf CHANGEME-linux-ubuntu22_amd64-7.4.1.tar.gz
+        mv CHANGEME $HOME/
+        popd
+        export FREESURFER_HOME=$HOME/CHANGEME
+        source $FREESURFER_HOME/SetUpFreeSurfer.sh
+        echo $FREESURFER_LICENCE > $FREESURFER_HOME/license.txt
+        export PATH=$FREESURFER_HOME/bin:$PATH
+    - uses: actions/checkout@v3
+    - name: Revert version to most recent tag on upstream update
+      if: github.event_name == 'repository_dispatch'
+      run: git checkout $(git tag -l | tail -n 1 | awk -F post '{print $1}')
+    - name: Download tasks converted from Nipype 
+      uses: actions/download-artifact@v3
+      with:
+        name: converted-nipype
+        path: pydra/tasks/CHANGEME/auto
+    - name: Strip auto package from gitignore so it is included in package
+      run: |
+        sed -i '/\/src\/pydra\/tasks\/CHANGEME\/auto/d' .gitignore
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v4
+      with:
+        python-version: ${{ matrix.python-version }}
+    - name: Install build dependencies
+      run: |
+        python -m pip install --upgrade pip
+    - name: Install task package
+      run: |
+        pip install "./fileformats/src" "./fileformats/extras" ".[test]"
+        python -c "import pydra.tasks.CHANGEME as m; print(f'{m.__name__} {m.__version__} @ {m.__file__}')"
+        python -c "import pydra as m; print(f'{m.__name__} {m.__version__} @ {m.__file__}')"
+    - name: Test with pytest
+      run: |
+        pytest -sv --doctest-modules ./pydra/tasks/CHANGEME \
+            --cov pydra.tasks.CHANGEME --cov-report xml
+    - uses: codecov/codecov-action@v3
+      if: ${{ always() }}
+      with:
+        files: coverage.xml,./fileformats/coverage.xml
+        name: pydra-CHANGEME
+
+  deploy-fileformats:
+    needs: [devcheck, test]
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v3
+      with:
+        submodules: recursive
+        fetch-depth: 0 
+    - name: Set up Python
+      uses: actions/setup-python@v4
+      with:
+        python-version: '3.11'
+    - name: Install build tools
+      run: python -m pip install build twine
+    - name: Build source and wheel distributions
+      run: python -m build ./fileformats/src
+    - name: Check distributions
+      run: twine check ./fileformats/src/dist/*
+    - name: Check for PyPI token on tag
+      id: deployable
+      if: (github.event_name == 'push' && startsWith(github.ref, 'refs/tags')) || github.event_name == 'repository_dispatch'
+      env:
+        PYPI_API_TOKEN: "${{ secrets.PYPI_FILEFORMATS_API_TOKEN }}"
+      run: if [ -n "$PYPI_API_TOKEN" ]; then echo "DEPLOY=true" >> $GITHUB_OUTPUT; fi
+    - name: Upload to PyPI
+      if: steps.deployable.outputs.DEPLOY
+      uses: pypa/gh-action-pypi-publish@release/v1
+      with:
+        user: __token__
+        password: ${{ secrets.PYPI_FILEFORMATS_API_TOKEN }}
+        packages-dir: ./fileformats/src/dist 
+
+  deploy-fileformats-extras:
+    needs: [deploy-fileformats]
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v3
+      with:
+        submodules: recursive
+        fetch-depth: 0 
+    - name: Set up Python
+      uses: actions/setup-python@v4
+      with:
+        python-version: '3.11'
+    - name: Install build tools
+      run: python -m pip install build twine
+    - name: Build source and wheel distributions
+      run: python -m build ./fileformats/extras
+    - name: Check distributions
+      run: twine check ./fileformats/extras/dist/*
+    - name: Check for PyPI token on tag
+      id: deployable
+      if: (github.event_name == 'push' && startsWith(github.ref, 'refs/tags')) || github.event_name == 'repository_dispatch'
+      env:
+        PYPI_API_TOKEN: "${{ secrets.PYPI_FILEFORMATS_EXTRAS_API_TOKEN }}"
+      run: if [ -n "$PYPI_API_TOKEN" ]; then echo "DEPLOY=true" >> $GITHUB_OUTPUT; fi
+    - name: Upload to PyPI
+      if: steps.deployable.outputs.DEPLOY
+      uses: pypa/gh-action-pypi-publish@release/v1
+      with:
+        user: __token__
+        password: ${{ secrets.PYPI_FILEFORMATS_EXTRAS_API_TOKEN }}
+        packages-dir: ./fileformats/extras/dist 
+
+  deploy:
+    needs: [deploy-fileformats-extras]
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v3
+      with:
+        submodules: recursive
+        fetch-depth: 0
+    - name: Download tasks converted from Nipype 
+      uses: actions/download-artifact@v3
+      with:
+        name: converted-nipype
+        path: pydra/tasks/CHANGEME/auto
+    - name: Tag release with a post-release based on Nipype and Nipype2Pydra versions
+      if: github.event_name == 'repository_dispatch'
+      run: |
+        TAG=$(git tag -l | tail -n 1 | awk -F post '{print $1}')
+        POST=$(python -c "from pydra.tasks.CHANGEME.auto._version import *; print(post_release)")
+        git checkout $TAG
+        git add -f pydra/tasks/CHANGEME/auto/_version.py
+        git commit -am"added auto-generated version to make new tag for package version"
+        git tag ${TAG}post${POST}    
+    - name: Set up Python
+      uses: actions/setup-python@v4
+      with:
+        python-version: '3.11'
+    - name: Install build tools
+      run: python -m pip install build twine
+    - name: Strip auto package from gitignore so it is included in package
+      run: |
+        sed -i '/\/pydra\/tasks\/CHANGEME\/auto/d' .gitignore
+    - name: Build source and wheel distributions
+      run: python -m build .
+    - name: Check distributions
+      run: twine check dist/*
+    - uses: actions/upload-artifact@v3
+      with:
+        name: distributions
+        path: dist/
+    - name: Check for PyPI token on tag
+      id: deployable
+      if: (github.event_name == 'push' && startsWith(github.ref, 'refs/tags')) || github.event_name == 'repository_dispatch'
+      env:
+        PYPI_API_TOKEN: "${{ secrets.PYPI_API_TOKEN }}"
+      run: if [ -n "$PYPI_API_TOKEN" ]; then echo "DEPLOY=true" >> $GITHUB_OUTPUT; fi
+    - name: Upload to PyPI
+      if: steps.deployable.outputs.DEPLOY
+      uses: pypa/gh-action-pypi-publish@release/v1
+      with:
+        user: __token__
+        password: ${{ secrets.PYPI_API_TOKEN }}   
+
+# Deploy on tags if PYPI_API_TOKEN is defined in the repository secrets.
+# Secrets are not accessible in the if: condition [0], so set an output variable [1]
+# [0] https://github.community/t/16928
+# [1] https://docs.github.com/en/actions/reference/workflow-commands-for-github-actions#setting-an-output-parameter        
\ No newline at end of file
diff --git a/scripts/pkg_gen/resources/gh_workflows/pythonpackage.yaml b/scripts/pkg_gen/resources/gh_workflows/pythonpackage.yaml
deleted file mode 100644
index aa1a7a7b..00000000
--- a/scripts/pkg_gen/resources/gh_workflows/pythonpackage.yaml
+++ /dev/null
@@ -1,169 +0,0 @@
-#This workflow will install Python dependencies, run tests and lint with a variety of Python versions
-# For more information see: https://help.github.com/actions/language-and-framework-guides/using-python-with-github-actions
-
-# For deployment, it will be necessary to create a PyPI API token and store it as a secret
-# https://docs.github.com/en/actions/reference/encrypted-secrets
-
-name: Python package
-
-on:
-  push:
-    branches: [ main, develop ]
-    tags: [ '*' ]
-  pull_request:
-    branches: [ main, develop ]
-  repository_dispatch:
-    types: [create-release]
-
-jobs:
-
-  nipype-conv:
-    runs-on: ubuntu-latest
-    steps:
-    - name: Checkout
-      uses: actions/checkout@v3
-    - name: Revert version to most recent tag on upstream update
-      if: github.event_name == 'repository_dispatch'
-      run: git checkout $(git tag -l | tail -n 1 | awk -F post '{print $1}')    
-    - name: Set up Python ${{ matrix.python-version }}
-      uses: actions/setup-python@v4
-    - name: Install build dependencies
-      run: python -m pip install --upgrade pip
-    - name: Install requirements
-      run: python -m pip install -r ./nipype-auto-conv/requirements.txt
-    - name: Run automatic Nipype > Pydra conversion
-      run: ./nipype-auto-conv/generate
-    - uses: actions/upload-artifact@v3
-      with:
-        name: converted-nipype
-        path: pydra/tasks/CHANGEME/auto
-
-  devcheck:
-    needs: [nipype-conv]
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        python-version: ['3.8', '3.11']  # Check oldest and newest versions
-        pip-flags: ['', '--editable']
-        pydra:
-        - 'pydra'
-        - '--editable git+https://github.com/nipype/pydra.git#egg=pydra'
-    steps:
-    - name: Checkout
-      uses: actions/checkout@v3
-    - name: Revert version to most recent tag on upstream update
-      if: github.event_name == 'repository_dispatch'
-      run: git checkout $(git tag -l | tail -n 1 | awk -F post '{print $1}')    
-    - name: Download tasks converted from Nipype 
-      uses: actions/download-artifact@v3
-      with:
-        name: converted-nipype
-        path: pydra/tasks/CHANGEME/auto
-    - name: Set up Python ${{ matrix.python-version }}
-      uses: actions/setup-python@v4
-      with:
-        python-version: ${{ matrix.python-version }}
-    - name: Install build dependencies
-      run: |
-        python -m pip install --upgrade pip
-    - name: Install Pydra
-      run: |
-        pip install ${{ matrix.pydra }}
-        python -c "import pydra as m; print(f'{m.__name__} {m.__version__} @ {m.__file__}')"
-    - name: Install task package
-      run: |
-        pip install ${{ matrix.pip-flags }} ".[dev]"
-        python -c "import pydra.tasks.CHANGEME as m; print(f'{m.__name__} {m.__version__} @ {m.__file__}')"
-        python -c "import pydra as m; print(f'{m.__name__} {m.__version__} @ {m.__file__}')"
-
-  test:
-    needs: [nipype-conv]
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        python-version: ['3.8', '3.11']
-
-    steps:
-    - uses: actions/checkout@v3
-    - name: Revert version to most recent tag on upstream update
-      if: github.event_name == 'repository_dispatch'
-      run: git checkout $(git tag -l | tail -n 1 | awk -F post '{print $1}')
-    - name: Download tasks converted from Nipype 
-      uses: actions/download-artifact@v3
-      with:
-        name: converted-nipype
-        path: pydra/tasks/CHANGEME/auto
-    - name: Set up Python ${{ matrix.python-version }}
-      uses: actions/setup-python@v4
-      with:
-        python-version: ${{ matrix.python-version }}
-    - name: Install build dependencies
-      run: |
-        python -m pip install --upgrade pip
-    - name: Install task package
-      run: |
-        pip install ".[test]"
-        python -c "import pydra.tasks.CHANGEME as m; print(f'{m.__name__} {m.__version__} @ {m.__file__}')"
-        python -c "import pydra as m; print(f'{m.__name__} {m.__version__} @ {m.__file__}')"
-    - name: Test with pytest
-      run: |
-        pytest -sv --doctest-modules pydra/tasks/CHANGEME \
-            --cov pydra.tasks.CHANGEME --cov-report xml
-    - uses: codecov/codecov-action@v3
-      if: ${{ always() }}
-
-  deploy:
-    needs: [devcheck, test]
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        python-version: ['3.11']
-    steps:
-    - uses: actions/checkout@v3
-      with:
-        submodules: recursive
-        fetch-depth: 0
-    - name: Download tasks converted from Nipype 
-      uses: actions/download-artifact@v3
-      with:
-        name: converted-nipype
-        path: pydra/tasks/CHANGEME/auto
-    - name: Tag release with a post-release based on Nipype and Nipype2Pydra versions
-      if: github.event_name == 'repository_dispatch'
-      run: |
-        TAG=$(git tag -l | tail -n 1 | awk -F post '{print $1}')
-        POST=$(python -c "from pydra.tasks.CHANGEME.auto._version import *; print(post_release)")
-        git checkout $TAG
-        git add -f pydra/tasks/CHANGEME/auto/_version.py
-        git commit -am"added auto-generated version to make new tag for package version"
-        git tag ${TAG}post${POST}    
-    - name: Set up Python ${{ matrix.python-version }}
-      uses: actions/setup-python@v4
-      with:
-        python-version: ${{ matrix.python-version }}
-    - name: Install build tools
-      run: python -m pip install build twine
-    - name: Build source and wheel distributions
-      run: python -m build
-    - name: Check distributions
-      run: twine check dist/*
-    - uses: actions/upload-artifact@v3
-      with:
-        name: distributions
-        path: dist/
-    # Deploy on tags if PYPI_API_TOKEN is defined in the repository secrets.
-    # Secrets are not accessible in the if: condition [0], so set an output variable [1]
-    # [0] https://github.community/t/16928
-    # [1] https://docs.github.com/en/actions/reference/workflow-commands-for-github-actions#setting-an-output-parameter
-    - name: Check for PyPI token on tag
-      id: deployable
-      if: (github.event_name == 'push' && startsWith(github.ref, 'refs/tags')) || github.event_name == 'repository_dispatch'
-      env:
-        PYPI_API_TOKEN: "${{ secrets.PYPI_API_TOKEN }}"
-      run: if [ -n "$PYPI_API_TOKEN" ]; then echo "DEPLOY=true" >> $GITHUB_OUTPUT; fi
-    - name: Upload to PyPI
-      if: steps.deployable.outputs.DEPLOY
-      uses: pypa/gh-action-pypi-publish@v1
-      with:
-        user: __token__
-        password: ${{ secrets.PYPI_API_TOKEN }}

From 76f0732b14b82e5e91f077696c2310b9c31a5e2f Mon Sep 17 00:00:00 2001
From: Tom Close <tom.g.close@gmail.com>
Date: Wed, 22 Nov 2023 09:51:31 +1100
Subject: [PATCH 03/78] touched up generation of fileformats packages

---
 scripts/pkg_gen/create_packages.py | 16 ++++++++++++----
 1 file changed, 12 insertions(+), 4 deletions(-)

diff --git a/scripts/pkg_gen/create_packages.py b/scripts/pkg_gen/create_packages.py
index 48dc4923..3aa65f8b 100644
--- a/scripts/pkg_gen/create_packages.py
+++ b/scripts/pkg_gen/create_packages.py
@@ -226,11 +226,11 @@ def guess_type(fspath):
                                     fspath.strip(),
                                     mode=File.ExtensionDecomposition.single,
                                 )[2][1:].capitalize()
-                                pkg_formats.add(format_class_name)
                                 unmatched_formats.append(
                                     f"{module}.{interface}: {fspath}"
                                 )
                                 if format_class_name:
+                                    pkg_formats.add(format_class_name)   
                                     return f"fileformats.medimage_{pkg}.{format_class_name}"
                                 return File
 
@@ -411,7 +411,7 @@ def combine_types(type_, prev_type):
             pkg_dir / "fileformats" / "extras" / "fileformats" / "extras" / f"medimage_{pkg}" / "__init__.py",
             "w",
         ) as f:
-            f.write(gen_fileformats_extras_module(pkg_formats))
+            f.write(gen_fileformats_extras_module(pkg, pkg_formats))
 
         sp.check_call("git init", shell=True, cwd=pkg_dir)
         sp.check_call("git add --all", shell=True, cwd=pkg_dir)
@@ -682,8 +682,16 @@ class {frmt}(File):
     return code_str
 
 
-def gen_fileformats_extras_module(pkg_formats: ty.Set[str]):
-    code_str = "from fileformats.core import FileSet"
+def gen_fileformats_extras_module(pkg: str, pkg_formats: ty.Set[str]):
+    code_str = """from pathlib import Path
+import typing as ty
+from random import Random
+from fileformats.core import FileSet
+"""
+    code_str += f"from fileformats.medimage_{pkg} import (\n"
+    for frmt in pkg_formats:
+        code_str += f"    {frmt},\n"
+    code_str += ")\n\n"
     for frmt in pkg_formats:
         code_str += f"""
 

From e3b75b63ddc513c44173f5699bb45eed0f3e7d7f Mon Sep 17 00:00:00 2001
From: Tom Close <tom.g.close@gmail.com>
Date: Wed, 22 Nov 2023 10:36:07 +1100
Subject: [PATCH 04/78] added package fileformats to nipype-conv

---
 scripts/pkg_gen/resources/gh_workflows/ci-cd.yaml              | 2 +-
 scripts/pkg_gen/resources/nipype-auto-convert-requirements.txt | 1 +
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/scripts/pkg_gen/resources/gh_workflows/ci-cd.yaml b/scripts/pkg_gen/resources/gh_workflows/ci-cd.yaml
index 12b99866..190e5012 100644
--- a/scripts/pkg_gen/resources/gh_workflows/ci-cd.yaml
+++ b/scripts/pkg_gen/resources/gh_workflows/ci-cd.yaml
@@ -30,7 +30,7 @@ jobs:
     - name: Install build dependencies
       run: python -m pip install --upgrade pip
     - name: Install requirements
-      run: python -m pip install -r ./nipype-auto-conv/requirements.txt
+      run: python -m pip install ./fileformats/src -r ./nipype-auto-conv/requirements.txt
     - name: Run automatic Nipype > Pydra conversion
       run: ./nipype-auto-conv/generate
     - uses: actions/upload-artifact@v3
diff --git a/scripts/pkg_gen/resources/nipype-auto-convert-requirements.txt b/scripts/pkg_gen/resources/nipype-auto-convert-requirements.txt
index fae44d4c..9048c8e7 100644
--- a/scripts/pkg_gen/resources/nipype-auto-convert-requirements.txt
+++ b/scripts/pkg_gen/resources/nipype-auto-convert-requirements.txt
@@ -6,5 +6,6 @@ PyYAML>=6.0
 fileformats >=0.8
 fileformats-medimage >=0.4
 fileformats-datascience >= 0.1
+fileformats-medimage-CHANGEME
 traits
 nipype2pydra
\ No newline at end of file

From 847632ac110fc2c7ad3c114ebf1cb033846100fd Mon Sep 17 00:00:00 2001
From: Tom Close <tom.g.close@gmail.com>
Date: Wed, 22 Nov 2023 15:54:49 +1100
Subject: [PATCH 05/78] fixed up handling of extensions starting with digits in
 package generation

---
 scripts/pkg_gen/create_packages.py            | 86 ++++++++++++++++---
 .../pkg_gen/resources/gh_workflows/ci-cd.yaml | 20 ++---
 2 files changed, 83 insertions(+), 23 deletions(-)

diff --git a/scripts/pkg_gen/create_packages.py b/scripts/pkg_gen/create_packages.py
index 3aa65f8b..f543a4a5 100644
--- a/scripts/pkg_gen/create_packages.py
+++ b/scripts/pkg_gen/create_packages.py
@@ -35,6 +35,30 @@
 EXPECTED_FORMATS = [Nifti1, NiftiGz, TextFile, TextMatrix, DatFile, Xml]
 
 
+def ext2format_name(ext: str) -> str:
+    return escape_leading_digits(ext[1:]).capitalize()
+
+
+def escape_leading_digits(name: str) -> str:
+    for k, v in ESCAPE_DIGITS.items():
+        if name.startswith(k):
+            name = v + name[1:]
+            return name
+    return name
+
+
+ESCAPE_DIGITS = {
+    "1": "one",
+    "2": "two",
+    "3": "three",
+    "4": "four",
+    "5": "five",
+    "6": "six",
+    "7": "seven",
+    "8": "eight",
+    "9": "nine",
+}
+
 def download_tasks_template(output_path: Path):
     """Downloads the latest pydra-template to the output path"""
 
@@ -222,16 +246,16 @@ def guess_type(fspath):
                                     return Bval
                                 if fspath == "bvecs":
                                     return Bvec
-                                format_class_name = File.decompose_fspath(
+                                format_ext = File.decompose_fspath(
                                     fspath.strip(),
                                     mode=File.ExtensionDecomposition.single,
-                                )[2][1:].capitalize()
+                                )[2]
                                 unmatched_formats.append(
                                     f"{module}.{interface}: {fspath}"
                                 )
-                                if format_class_name:
-                                    pkg_formats.add(format_class_name)   
-                                    return f"fileformats.medimage_{pkg}.{format_class_name}"
+                                if format_ext:
+                                    pkg_formats.add(format_ext)
+                                    return f"fileformats.medimage_{pkg}.{ext2format_name(format_ext)}"
                                 return File
 
                             for expected in EXPECTED_FORMATS:
@@ -402,13 +426,24 @@ def combine_types(type_, prev_type):
                     )
 
         with open(
-            pkg_dir / "fileformats" / "src" / "fileformats" / f"medimage_{pkg}" / "__init__.py",
+            pkg_dir
+            / "related-packages"
+            / "fileformats"
+            / "fileformats"
+            / f"medimage_{pkg}"
+            / "__init__.py",
             "w",
         ) as f:
             f.write(gen_fileformats_module(pkg_formats))
 
         with open(
-            pkg_dir / "fileformats" / "extras" / "fileformats" / "extras" / f"medimage_{pkg}" / "__init__.py",
+            pkg_dir
+            / "related-packages"
+            / "fileformats-extras"
+            / "fileformats"
+            / "extras"
+            / f"medimage_{pkg}"
+            / "__init__.py",
             "w",
         ) as f:
             f.write(gen_fileformats_extras_module(pkg, pkg_formats))
@@ -482,8 +517,30 @@ def copy_ignore(_, names):
 
     # rename tasks directory
     (pkg_dir / "pydra" / "tasks" / "CHANGEME").rename(pkg_dir / "pydra" / "tasks" / pkg)
-    (pkg_dir / "fileformats" / "src" / "fileformats" / "medimage_CHANGEME").rename(pkg_dir / "fileformats" / "src" / "fileformats" / f"medimage_{pkg}")
-    (pkg_dir / "fileformats" / "extras" / "fileformats" / "extras" / "medimage_CHANGEME").rename(pkg_dir / "fileformats" / "extras" / "fileformats" / "extras" / f"medimage_{pkg}")
+    (
+        pkg_dir
+        / "related-packages"
+        / "fileformats"
+        / "fileformats"
+        / "medimage_CHANGEME"
+    ).rename(
+        pkg_dir / "related-packages" / "fileformats" / "fileformats" / f"medimage_{pkg}"
+    )
+    (
+        pkg_dir
+        / "related-packages"
+        / "fileformats-extras"
+        / "fileformats"
+        / "extras"
+        / "medimage_CHANGEME"
+    ).rename(
+        pkg_dir
+        / "related-packages"
+        / "fileformats-extras"
+        / "fileformats"
+        / "extras"
+        / f"medimage_{pkg}"
+    )
 
     # Add in modified __init__.py
     shutil.copy(
@@ -672,11 +729,12 @@ def extract_doctest_inputs(
 
 def gen_fileformats_module(pkg_formats: ty.Set[str]):
     code_str = "from fileformats.generic import File"
-    for frmt in pkg_formats:
+    for ext in pkg_formats:
+        frmt = ext2format_name(ext)
         code_str += f"""
 
 class {frmt}(File):
-    ext = ".{frmt.lower()}"
+    ext = "{ext}"
     binary = True
 """
     return code_str
@@ -689,10 +747,12 @@ def gen_fileformats_extras_module(pkg: str, pkg_formats: ty.Set[str]):
 from fileformats.core import FileSet
 """
     code_str += f"from fileformats.medimage_{pkg} import (\n"
-    for frmt in pkg_formats:
+    for ext in pkg_formats:
+        frmt = ext2format_name(ext)
         code_str += f"    {frmt},\n"
     code_str += ")\n\n"
-    for frmt in pkg_formats:
+    for ext in pkg_formats:
+        frmt = ext2format_name(ext)
         code_str += f"""
 
 @FileSet.generate_sample_data.register
diff --git a/scripts/pkg_gen/resources/gh_workflows/ci-cd.yaml b/scripts/pkg_gen/resources/gh_workflows/ci-cd.yaml
index 190e5012..4d7e8644 100644
--- a/scripts/pkg_gen/resources/gh_workflows/ci-cd.yaml
+++ b/scripts/pkg_gen/resources/gh_workflows/ci-cd.yaml
@@ -30,7 +30,7 @@ jobs:
     - name: Install build dependencies
       run: python -m pip install --upgrade pip
     - name: Install requirements
-      run: python -m pip install ./fileformats/src -r ./nipype-auto-conv/requirements.txt
+      run: python -m pip install ./related-packages/fileformats -r ./nipype-auto-conv/requirements.txt
     - name: Run automatic Nipype > Pydra conversion
       run: ./nipype-auto-conv/generate
     - uses: actions/upload-artifact@v3
@@ -77,7 +77,7 @@ jobs:
         python -c "import pydra as m; print(f'{m.__name__} {m.__version__} @ {m.__file__}')"
     - name: Install task package
       run: |
-        pip install "./fileformats/src[dev]" "fileformats/extras[dev]"
+        pip install "./related-packages/fileformats[dev]" "related-packages/fileformats-extras[dev]"
         pip install ${{ matrix.pip-flags }} ".[dev]"
         python -c "import pydra.tasks.CHANGEME as m; print(f'{m.__name__} {m.__version__} @ {m.__file__}')"
         python -c "import pydra as m; print(f'{m.__name__} {m.__version__} @ {m.__file__}')"
@@ -103,7 +103,7 @@ jobs:
         python -m pip install --upgrade pip
     - name: Install task package
       run: |
-        pip install "./fileformats/src[test]" "./fileformats/extras[test]"
+        pip install "./related-packages/fileformats[test]" "./related-packages/fileformats-extras[test]"
         python -c "import fileformats.medimage_CHANGEME as m; print(f'{m.__name__} {m.__version__} @ {m.__file__}')"
     - name: Test fileformats with pytest
       run: |
@@ -170,7 +170,7 @@ jobs:
         python -m pip install --upgrade pip
     - name: Install task package
       run: |
-        pip install "./fileformats/src" "./fileformats/extras" ".[test]"
+        pip install "./related-packages/fileformats" "./related-packages/fileformats-extras" ".[test]"
         python -c "import pydra.tasks.CHANGEME as m; print(f'{m.__name__} {m.__version__} @ {m.__file__}')"
         python -c "import pydra as m; print(f'{m.__name__} {m.__version__} @ {m.__file__}')"
     - name: Test with pytest
@@ -198,9 +198,9 @@ jobs:
     - name: Install build tools
       run: python -m pip install build twine
     - name: Build source and wheel distributions
-      run: python -m build ./fileformats/src
+      run: python -m build ./related-packages/fileformats
     - name: Check distributions
-      run: twine check ./fileformats/src/dist/*
+      run: twine check ./related-packages/fileformats/dist/*
     - name: Check for PyPI token on tag
       id: deployable
       if: (github.event_name == 'push' && startsWith(github.ref, 'refs/tags')) || github.event_name == 'repository_dispatch'
@@ -213,7 +213,7 @@ jobs:
       with:
         user: __token__
         password: ${{ secrets.PYPI_FILEFORMATS_API_TOKEN }}
-        packages-dir: ./fileformats/src/dist 
+        packages-dir: ./related-packages/fileformats/dist 
 
   deploy-fileformats-extras:
     needs: [deploy-fileformats]
@@ -230,9 +230,9 @@ jobs:
     - name: Install build tools
       run: python -m pip install build twine
     - name: Build source and wheel distributions
-      run: python -m build ./fileformats/extras
+      run: python -m build ./related-packages/fileformats-extras
     - name: Check distributions
-      run: twine check ./fileformats/extras/dist/*
+      run: twine check ./related-packages/fileformats-extras/dist/*
     - name: Check for PyPI token on tag
       id: deployable
       if: (github.event_name == 'push' && startsWith(github.ref, 'refs/tags')) || github.event_name == 'repository_dispatch'
@@ -245,7 +245,7 @@ jobs:
       with:
         user: __token__
         password: ${{ secrets.PYPI_FILEFORMATS_EXTRAS_API_TOKEN }}
-        packages-dir: ./fileformats/extras/dist 
+        packages-dir: ./related-packages/fileformats-extras/dist 
 
   deploy:
     needs: [deploy-fileformats-extras]

From e91103744f6e0fc87fd2bbbcaac5fff93810fad3 Mon Sep 17 00:00:00 2001
From: Tom Close <tom.g.close@gmail.com>
Date: Thu, 23 Nov 2023 16:14:23 +1100
Subject: [PATCH 06/78] fixed up issue with lists not being given lists in
 tests

---
 nipype2pydra/task.py      |  2 ++
 scripts/port_interface.py | 19 +++++++++++++++++++
 2 files changed, 21 insertions(+)
 create mode 100644 scripts/port_interface.py

diff --git a/nipype2pydra/task.py b/nipype2pydra/task.py
index b91a1703..5fe92317 100644
--- a/nipype2pydra/task.py
+++ b/nipype2pydra/task.py
@@ -843,6 +843,8 @@ def write_tests(self, filename_test, input_fields, nonstd_types, run=False):
                         ):
                             arg_tp = ty.get_args(tp)[0]
                             value = f"{arg_tp.__name__}.sample()"
+                            if ty.get_origin(tp) is list:
+                                value = "[" + value + "]"
                 if value is not attrs.NOTHING:
                     spec_str += f"    task.inputs.{nm} = {value}\n"
             if hasattr(self.nipype_interface, "_cmd"):
diff --git a/scripts/port_interface.py b/scripts/port_interface.py
new file mode 100644
index 00000000..468ca0c0
--- /dev/null
+++ b/scripts/port_interface.py
@@ -0,0 +1,19 @@
+import sys
+import yaml
+from pathlib import Path
+import nipype2pydra.task
+import nipype2pydra.utils
+
+outputs_path = Path(__file__).parent.parent / "outputs" / "testing"
+
+outputs_path.mkdir(parents=True, exist_ok=True)
+
+spec_file = sys.argv[1]
+with open(spec_file) as f:
+    spec = yaml.load(f, Loader=yaml.SafeLoader)
+
+converter = nipype2pydra.task.TaskConverter(
+    output_module=spec["nipype_module"].split("interfaces.")[-1] + "." + spec["task_name"],
+    **spec
+)
+converter.generate(outputs_path)

From f516b38f46cef0d8c3776b1e3d5520fd226fa6a6 Mon Sep 17 00:00:00 2001
From: Tom Close <tom.g.close@gmail.com>
Date: Thu, 23 Nov 2023 16:31:30 +1100
Subject: [PATCH 07/78] fixed issue with command not being set

---
 nipype2pydra/task.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/nipype2pydra/task.py b/nipype2pydra/task.py
index 5fe92317..080141fe 100644
--- a/nipype2pydra/task.py
+++ b/nipype2pydra/task.py
@@ -722,7 +722,7 @@ def types_to_names(spec_fields):
         spec_str += f"    input_spec = {self.task_name}_input_spec\n"
         spec_str += f"    output_spec = {self.task_name}_output_spec\n"
         if task_base == "ShellCommandTask":
-            spec_str += f"    executable='{self.nipype_interface._cmd}'\n"
+            spec_str += f"    executable='{self.nipype_interface.cmd}'\n"
 
         spec_str = re.sub(r"'#([^'#]+)#'", r"\1", spec_str)
 

From d63ce048becf70c325286b44d97d56838965c262 Mon Sep 17 00:00:00 2001
From: Tom Close <tom.g.close@gmail.com>
Date: Thu, 23 Nov 2023 17:19:57 +1100
Subject: [PATCH 08/78] fixed executable detection

---
 nipype2pydra/task.py | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/nipype2pydra/task.py b/nipype2pydra/task.py
index 080141fe..1b1f9bc9 100644
--- a/nipype2pydra/task.py
+++ b/nipype2pydra/task.py
@@ -705,6 +705,12 @@ def types_to_names(spec_fields):
             task_base = "FunctionTask"
             base_imports.append("from pydra.engine.task import FunctionTask")
 
+        executable = self.nipype_interface._cmd
+        if not executable:
+            executable = self.nipype_interface.cmd
+            if not isinstance(executable, str):
+                raise RuntimeError(f"Could not find executable for {self.nipype_interface}")
+
         input_fields_str = types_to_names(spec_fields=input_fields)
         output_fields_str = types_to_names(spec_fields=output_fields)
         functions_str = self.function_callables()
@@ -722,7 +728,7 @@ def types_to_names(spec_fields):
         spec_str += f"    input_spec = {self.task_name}_input_spec\n"
         spec_str += f"    output_spec = {self.task_name}_output_spec\n"
         if task_base == "ShellCommandTask":
-            spec_str += f"    executable='{self.nipype_interface.cmd}'\n"
+            spec_str += f"    executable='{executable}'\n"
 
         spec_str = re.sub(r"'#([^'#]+)#'", r"\1", spec_str)
 

From a8c34d9f82a5fb0e443e01b6a707f8a407cc01c1 Mon Sep 17 00:00:00 2001
From: Tom Close <tom.g.close@gmail.com>
Date: Thu, 23 Nov 2023 17:56:26 +1100
Subject: [PATCH 09/78] gave fileset samples seeds

---
 nipype2pydra/task.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/nipype2pydra/task.py b/nipype2pydra/task.py
index 1b1f9bc9..8f6cf713 100644
--- a/nipype2pydra/task.py
+++ b/nipype2pydra/task.py
@@ -809,7 +809,7 @@ def write_tests(self, filename_test, input_fields, nonstd_types, run=False):
             spec_str += f"@pass_after_timeout(seconds={test.timeout})\n"
             spec_str += f"def test_{self.task_name.lower()}_{i}():\n"
             spec_str += f"    task = {self.task_name}()\n"
-            for field in input_fields:
+            for i, field in enumerate(input_fields):
                 nm, tp = field[:2]
                 # Try to get a sensible value for the traits value
                 try:
@@ -843,12 +843,12 @@ def write_tests(self, filename_test, input_fields, nonstd_types, run=False):
                 else:
                     if value is None:
                         if is_fileset(tp):
-                            value = f"{tp.__name__}.sample()"
+                            value = f"{tp.__name__}.sample(seed={i})"
                         elif ty.get_origin(tp) in (list, ty.Union) and is_fileset(
                             ty.get_args(tp)[0]
                         ):
                             arg_tp = ty.get_args(tp)[0]
-                            value = f"{arg_tp.__name__}.sample()"
+                            value = f"{arg_tp.__name__}.sample(seed={i})"
                             if ty.get_origin(tp) is list:
                                 value = "[" + value + "]"
                 if value is not attrs.NOTHING:

From 0ee39df612e50bc112dae09986588b411c226b99 Mon Sep 17 00:00:00 2001
From: Tom Close <tom.g.close@gmail.com>
Date: Thu, 23 Nov 2023 17:59:13 +1100
Subject: [PATCH 10/78] catch attribute error on executable

---
 nipype2pydra/task.py | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/nipype2pydra/task.py b/nipype2pydra/task.py
index 8f6cf713..39aeabde 100644
--- a/nipype2pydra/task.py
+++ b/nipype2pydra/task.py
@@ -705,7 +705,10 @@ def types_to_names(spec_fields):
             task_base = "FunctionTask"
             base_imports.append("from pydra.engine.task import FunctionTask")
 
-        executable = self.nipype_interface._cmd
+        try:
+            executable = self.nipype_interface._cmd
+        except AttributeError:
+            executable = None
         if not executable:
             executable = self.nipype_interface.cmd
             if not isinstance(executable, str):

From 91c2899686d5e7f1ca7630f3fef0dc36a33ae2db Mon Sep 17 00:00:00 2001
From: Tom Close <tom.g.close@gmail.com>
Date: Wed, 10 Jan 2024 13:27:59 +1100
Subject: [PATCH 11/78] detect directory input/output types in create_packages
 script

---
 scripts/pkg_gen/create_packages.py | 27 +++++++++++++++++++++++----
 scripts/pkg_gen/fsl-only.yaml      |  6 ++++++
 2 files changed, 29 insertions(+), 4 deletions(-)
 create mode 100644 scripts/pkg_gen/fsl-only.yaml

diff --git a/scripts/pkg_gen/create_packages.py b/scripts/pkg_gen/create_packages.py
index f543a4a5..14548da5 100644
--- a/scripts/pkg_gen/create_packages.py
+++ b/scripts/pkg_gen/create_packages.py
@@ -15,7 +15,7 @@
 import yaml
 import fileformats.core.utils
 import fileformats.core.mixin
-from fileformats.generic import File
+from fileformats.generic import File, Directory
 from fileformats.medimage import Nifti1, NiftiGz, Bval, Bvec
 from fileformats.application import Dicom, Xml
 from fileformats.text import TextFile
@@ -59,6 +59,7 @@ def escape_leading_digits(name: str) -> str:
     "9": "nine",
 }
 
+
 def download_tasks_template(output_path: Path):
     """Downloads the latest pydra-template to the output path"""
 
@@ -161,6 +162,8 @@ def generate_packages(
                     file_outputs,
                     genfile_outputs,
                     multi_inputs,
+                    dir_inputs,
+                    dir_outputs,
                 ) = parse_nipype_interface(nipype_interface)
 
                 # Create "stubs" for each of the available fields
@@ -188,7 +191,9 @@ def fields_stub(name, category_class, values=None):
                     return dct
 
                 input_types = {i: File for i in file_inputs}
+                input_types.update({i: Directory for i in dir_inputs})
                 output_types = {o: File for o in file_outputs}
+                output_types.update({o: Directory for o in dir_outputs})
                 output_templates = {}
 
                 # Attempt to parse doctest to pull out sensible defaults for input/output
@@ -574,6 +579,7 @@ def parse_nipype_interface(
     """Generate preamble comments at start of file with args and doc strings"""
     input_helps = {}
     file_inputs = []
+    dir_inputs = []
     genfile_outputs = []
     multi_inputs = []
     if nipype_interface.input_spec:
@@ -589,16 +595,25 @@ def parse_nipype_interface(
                 genfile_outputs.append(inpt_name)
             elif type(inpt.trait_type).__name__ == "File":
                 file_inputs.append(inpt_name)
+            elif type(inpt.trait_type).__name__ == "Directory":
+                dir_inputs.append(inpt_name)
             elif type(inpt.trait_type).__name__ == "InputMultiObject":
-                file_inputs.append(inpt_name)
+                if inpt.trait_type.item_trait and inpt.trait_type.item_trait.trait_type._is_dir:
+                    dir_inputs.append(inpt_name)
+                else:
+                    file_inputs.append(inpt_name)
                 multi_inputs.append(inpt_name)
             elif (
                 type(inpt.trait_type).__name__ == "List"
-                and type(inpt.trait_type.inner_traits()[0].handler).__name__ == "File"
+                and type(inpt.trait_type.inner_traits()[0].handler).__name__ in ("File", "Directory")
             ):
-                file_inputs.append(inpt_name)
+                if type(inpt.trait_type.inner_traits()[0].handler).__name__ == "File":
+                    file_inputs.append(inpt_name)
+                else:
+                    dir_inputs.append(inpt_name)
                 multi_inputs.append(inpt_name)
     file_outputs = []
+    dir_outputs = []
     output_helps = {}
     if nipype_interface.output_spec:
         for outpt_name, outpt in nipype_interface.output_spec().traits().items():
@@ -610,6 +625,8 @@ def parse_nipype_interface(
             ] = f"type={type(outpt.trait_type).__name__.lower()}: {outpt_desc}"
             if type(outpt.trait_type).__name__ == "File":
                 file_outputs.append(outpt_name)
+            elif type(outpt.trait_type).__name__ == "Directory":
+                dir_outputs.append(outpt_name)
     doc_string = nipype_interface.__doc__ if nipype_interface.__doc__ else ""
     doc_string = doc_string.replace("\n", "\n# ")
     # Create a preamble at the top of the specificaiton explaining what to do
@@ -631,6 +648,8 @@ def parse_nipype_interface(
         file_outputs,
         genfile_outputs,
         multi_inputs,
+        dir_inputs,
+        dir_outputs,
     )
 
 
diff --git a/scripts/pkg_gen/fsl-only.yaml b/scripts/pkg_gen/fsl-only.yaml
new file mode 100644
index 00000000..25708f6b
--- /dev/null
+++ b/scripts/pkg_gen/fsl-only.yaml
@@ -0,0 +1,6 @@
+packages:
+- fsl
+interfaces:
+  fsl:
+  - AccuracyTester
+  
\ No newline at end of file

From 4de5a824ca71505214be2d97fc9bf879445bdd02 Mon Sep 17 00:00:00 2001
From: Tom Close <tom.g.close@gmail.com>
Date: Wed, 10 Jan 2024 16:16:43 +1100
Subject: [PATCH 12/78] fixed up parsing of doctest strings split over multiple
 paras

---
 nipype-interfaces-to-import.yaml   |  1 -
 nipype2pydra/task.py               | 11 ++++++++---
 scripts/pkg_gen/create_packages.py | 21 ++++++++++++---------
 scripts/pkg_gen/fsl-only.yaml      |  2 +-
 4 files changed, 21 insertions(+), 14 deletions(-)

diff --git a/nipype-interfaces-to-import.yaml b/nipype-interfaces-to-import.yaml
index 535ae29b..dc22011b 100644
--- a/nipype-interfaces-to-import.yaml
+++ b/nipype-interfaces-to-import.yaml
@@ -472,7 +472,6 @@ interfaces:
   - FEAT
   - FEATModel
   - FILMGLS
-  - FEATRegister
   - FLAMEO
   - ContrastMgr
   - L2Model
diff --git a/nipype2pydra/task.py b/nipype2pydra/task.py
index 39aeabde..dd2b702f 100644
--- a/nipype2pydra/task.py
+++ b/nipype2pydra/task.py
@@ -871,9 +871,14 @@ def write_tests(self, filename_test, input_fields, nonstd_types, run=False):
         )
         spec_str = "\n".join(imports) + "\n\n" + spec_str
 
-        spec_str_black = black.format_file_contents(
-            spec_str, fast=False, mode=black.FileMode()
-        )
+        try:
+            spec_str_black = black.format_file_contents(
+                spec_str, fast=False, mode=black.FileMode()
+            )
+        except black.parsing.InvalidInput as e:
+            raise RuntimeError(
+                f"Black could not parse generated code: {e}\n\n{spec_str}"
+            )
 
         with open(filename_test, "w") as f:
             f.write(spec_str_black)
diff --git a/scripts/pkg_gen/create_packages.py b/scripts/pkg_gen/create_packages.py
index 14548da5..23f3cae1 100644
--- a/scripts/pkg_gen/create_packages.py
+++ b/scripts/pkg_gen/create_packages.py
@@ -204,10 +204,10 @@ def fields_stub(name, category_class, values=None):
                 doctest_blocks = []
                 for para in doc_str.split("\n\n"):
                     if "cmdline" in para:
-                        doctest_blocks.append(prev_block + para)
+                        doctest_blocks.append(prev_block + "\n" + para)
                         prev_block = ""
-                    else:
-                        prev_block += para
+                    elif ">>>" in para:
+                        prev_block += "\n" + para
 
                 doctests: ty.List[DocTestGenerator] = []
                 tests: ty.List[TestGenerator] = [
@@ -591,23 +591,26 @@ def parse_nipype_interface(
             if isinstance(inpt.trait_type, nipype.interfaces.base.core.traits.Enum):
                 inpt_mdata += f"|allowed[{','.join(sorted(repr(v) for v in inpt.trait_type.values))}]"
             input_helps[inpt_name] = f"{inpt_mdata}: {inpt_desc}"
+            trait_type_name = type(inpt.trait_type).__name__
             if inpt.genfile:
                 genfile_outputs.append(inpt_name)
-            elif type(inpt.trait_type).__name__ == "File":
+            elif trait_type_name == "File":
                 file_inputs.append(inpt_name)
-            elif type(inpt.trait_type).__name__ == "Directory":
+            elif trait_type_name == "Directory":
                 dir_inputs.append(inpt_name)
-            elif type(inpt.trait_type).__name__ == "InputMultiObject":
-                if inpt.trait_type.item_trait and inpt.trait_type.item_trait.trait_type._is_dir:
+            elif trait_type_name == "InputMultiObject":
+                inner_trait_type_name = type(inpt.trait_type.item_trait.trait_type).__name__
+                if inner_trait_type_name == "Directory":
                     dir_inputs.append(inpt_name)
-                else:
+                elif inner_trait_type_name == "File":
                     file_inputs.append(inpt_name)
                 multi_inputs.append(inpt_name)
             elif (
                 type(inpt.trait_type).__name__ == "List"
                 and type(inpt.trait_type.inner_traits()[0].handler).__name__ in ("File", "Directory")
             ):
-                if type(inpt.trait_type.inner_traits()[0].handler).__name__ == "File":
+                item_type_name = type(inpt.trait_type.inner_traits()[0].handler).__name__
+                if item_type_name == "File":
                     file_inputs.append(inpt_name)
                 else:
                     dir_inputs.append(inpt_name)
diff --git a/scripts/pkg_gen/fsl-only.yaml b/scripts/pkg_gen/fsl-only.yaml
index 25708f6b..062c9e49 100644
--- a/scripts/pkg_gen/fsl-only.yaml
+++ b/scripts/pkg_gen/fsl-only.yaml
@@ -2,5 +2,5 @@ packages:
 - fsl
 interfaces:
   fsl:
-  - AccuracyTester
+  - FNIRT
   
\ No newline at end of file

From df105333bdb321099fd6d256739ddd70009cf5f2 Mon Sep 17 00:00:00 2001
From: Tom Close <tom.g.close@gmail.com>
Date: Thu, 11 Jan 2024 14:54:49 +1100
Subject: [PATCH 13/78] dropped python based fsl commands from list to import

---
 nipype-interfaces-to-import.yaml | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/nipype-interfaces-to-import.yaml b/nipype-interfaces-to-import.yaml
index dc22011b..f4c0cca9 100644
--- a/nipype-interfaces-to-import.yaml
+++ b/nipype-interfaces-to-import.yaml
@@ -418,7 +418,6 @@ interfaces:
   - ICA_AROMA
   fsl/dti:
   - DTIFit
-  - FSLXCommand
   - BEDPOSTX5
   - XFibres5
   - ProbTrackX
@@ -440,7 +439,6 @@ interfaces:
   - EddyCorrect
   - EddyQuad
   fsl/fix:
-  - TrainingSetCreator
   - FeatureExtractor
   - Training
   - AccuracyTester
@@ -468,14 +466,11 @@ interfaces:
   - MultiImageMaths
   - TemporalFilter
   fsl/model:
-  - Level1Design
   - FEAT
   - FEATModel
   - FILMGLS
   - FLAMEO
   - ContrastMgr
-  - L2Model
-  - MultipleRegressDesign
   - SMM
   - MELODIC
   - SmoothEstimate

From 6b20bd0683216edd2a9771f3670dc047945a65e2 Mon Sep 17 00:00:00 2001
From: Tom Close <tom.g.close@gmail.com>
Date: Thu, 11 Jan 2024 14:55:17 +1100
Subject: [PATCH 14/78] dropped pass_after_timeout in favour of "with-timeout"
 plugin

---
 nipype2pydra/task.py | 62 +++++++++++++++++++++++---------------------
 1 file changed, 32 insertions(+), 30 deletions(-)

diff --git a/nipype2pydra/task.py b/nipype2pydra/task.py
index dd2b702f..fe1699fd 100644
--- a/nipype2pydra/task.py
+++ b/nipype2pydra/task.py
@@ -809,7 +809,7 @@ def write_tests(self, filename_test, input_fields, nonstd_types, run=False):
         for i, test in enumerate(self.tests, start=1):
             if test.xfail:
                 spec_str += "@pytest.mark.xfail\n"
-            spec_str += f"@pass_after_timeout(seconds={test.timeout})\n"
+            # spec_str += f"@pass_after_timeout(seconds={test.timeout})\n"
             spec_str += f"def test_{self.task_name.lower()}_{i}():\n"
             spec_str += f"    task = {self.task_name}()\n"
             for i, field in enumerate(input_fields):
@@ -818,31 +818,7 @@ def write_tests(self, filename_test, input_fields, nonstd_types, run=False):
                 try:
                     value = test.inputs[nm]
                 except KeyError:
-                    if len(field) == 4:  # field has default
-                        if isinstance(field[2], bool):
-                            value = str(field[2])
-                        else:
-                            value = json.dumps(field[2])
-                    else:
-                        assert len(field) == 3
-                        # Attempt to pick a sensible value for field
-                        trait = self.nipype_interface.input_spec.class_traits()[nm]
-                        if isinstance(trait, traits.trait_types.Enum):
-                            value = trait.values[0]
-                        elif isinstance(trait, traits.trait_types.Range):
-                            value = (trait.high - trait.low) / 2.0
-                        elif isinstance(trait, traits.trait_types.Bool):
-                            value = True
-                        elif isinstance(trait, traits.trait_types.Int):
-                            value = 1
-                        elif isinstance(trait, traits.trait_types.Float):
-                            value = 1.0
-                        elif isinstance(trait, traits.trait_types.List):
-                            value = [1] * trait.minlen
-                        elif isinstance(trait, traits.trait_types.Tuple):
-                            value = tuple([1] * len(trait.types))
-                        else:
-                            value = attrs.NOTHING
+                    pass
                 else:
                     if value is None:
                         if is_fileset(tp):
@@ -854,11 +830,37 @@ def write_tests(self, filename_test, input_fields, nonstd_types, run=False):
                             value = f"{arg_tp.__name__}.sample(seed={i})"
                             if ty.get_origin(tp) is list:
                                 value = "[" + value + "]"
-                if value is not attrs.NOTHING:
-                    spec_str += f"    task.inputs.{nm} = {value}\n"
+                        else:
+                            if len(field) == 4:  # field has default
+                                if isinstance(field[2], bool):
+                                    value = str(field[2])
+                                else:
+                                    value = json.dumps(field[2])
+                            else:
+                                assert len(field) == 3
+                                # Attempt to pick a sensible value for field
+                                trait = self.nipype_interface.input_spec.class_traits()[nm]
+                                if isinstance(trait, traits.trait_types.Enum):
+                                    value = trait.values[0]
+                                elif isinstance(trait, traits.trait_types.Range):
+                                    value = (trait.high - trait.low) / 2.0
+                                elif isinstance(trait, traits.trait_types.Bool):
+                                    value = True
+                                elif isinstance(trait, traits.trait_types.Int):
+                                    value = 1
+                                elif isinstance(trait, traits.trait_types.Float):
+                                    value = 1.0
+                                elif isinstance(trait, traits.trait_types.List):
+                                    value = [1] * trait.minlen
+                                elif isinstance(trait, traits.trait_types.Tuple):
+                                    value = tuple([1] * len(trait.types))
+                                else:
+                                    value = attrs.NOTHING
+                    if value is not attrs.NOTHING:
+                        spec_str += f"    task.inputs.{nm} = {value}\n"
             if hasattr(self.nipype_interface, "_cmd"):
                 spec_str += r'    print(f"CMDLINE: {task.cmdline}\n\n")' + "\n"
-            spec_str += "    res = task()\n"
+            spec_str += "    res = task(plugin=\"with-timeout\")\n"
             spec_str += "    print('RESULT: ', res)\n"
             for name, value in test.expected_outputs.items():
                 spec_str += f"    assert res.output.{name} == {value}\n"
@@ -867,7 +869,7 @@ def write_tests(self, filename_test, input_fields, nonstd_types, run=False):
         imports = self.construct_imports(
             nonstd_types,
             spec_str,
-            base={"import pytest", "from conftest import pass_after_timeout"},
+            base={"import pytest"}  # , "from conftest import pass_after_timeout"},
         )
         spec_str = "\n".join(imports) + "\n\n" + spec_str
 

From c8d9fca03ef6839029e1e38b57fc5017c8fb2ee4 Mon Sep 17 00:00:00 2001
From: Tom Close <tom.g.close@gmail.com>
Date: Mon, 15 Jan 2024 14:45:29 +1100
Subject: [PATCH 15/78] handle classified fileformats in task modules

---
 nipype2pydra/task.py | 171 ++++++++++++++++++++++++-------------------
 1 file changed, 96 insertions(+), 75 deletions(-)

diff --git a/nipype2pydra/task.py b/nipype2pydra/task.py
index fe1699fd..3817675b 100644
--- a/nipype2pydra/task.py
+++ b/nipype2pydra/task.py
@@ -4,6 +4,7 @@
 import re
 from importlib import import_module
 from types import ModuleType
+import itertools
 import inspect
 import black
 import traits.trait_types
@@ -16,6 +17,7 @@
 from pydra.engine.helpers import ensure_list
 from .utils import import_module_from_path, is_fileset, to_snake_case
 from fileformats.core import from_mime
+from fileformats.core.mixin import WithClassifiers
 from fileformats.generic import File
 
 
@@ -460,7 +462,7 @@ def add_nonstd_types(tp):
 
     def convert_input_fields(self):
         """creating fields list for pydra input spec"""
-        fields_pdr_dict = {}
+        pydra_fields_dict = {}
         position_dict = {}
         has_template = []
         for name, fld in self.nipype_input_spec.traits().items():
@@ -468,43 +470,43 @@ def convert_input_fields(self):
                 continue
             if name in self.inputs.omit:
                 continue
-            fld_pdr, pos = self.pydra_fld_input(fld, name)
-            meta_pdr = fld_pdr[-1]
-            if "output_file_template" in meta_pdr:
+            pydra_fld, pos = self.pydra_fld_input(fld, name)
+            pydra_meta = pydra_fld[-1]
+            if "output_file_template" in pydra_meta:
                 has_template.append(name)
-            fields_pdr_dict[name] = (name,) + fld_pdr
+            pydra_fields_dict[name] = (name,) + pydra_fld
             if pos is not None:
                 position_dict[name] = pos
 
-        fields_pdr_l = list(fields_pdr_dict.values())
-        return fields_pdr_l, has_template
+        pydra_fields_l = list(pydra_fields_dict.values())
+        return pydra_fields_l, has_template
 
     def pydra_fld_input(self, field, nm):
         """converting a single nipype field to one element of fields for pydra input_spec"""
-        tp_pdr = self.pydra_type_converter(field, spec_type="input", name=nm)
+        pydra_type = self.pydra_type_converter(field, spec_type="input", name=nm)
         if nm in self.inputs.metadata:
             metadata_extra_spec = self.inputs.metadata[nm]
         else:
             metadata_extra_spec = {}
 
         if "default" in metadata_extra_spec:
-            default_pdr = metadata_extra_spec.pop("default")
+            pydra_default = metadata_extra_spec.pop("default")
         elif (
             getattr(field, "usedefault")
             and field.default is not traits.ctrait.Undefined
         ):
-            default_pdr = field.default
+            pydra_default = field.default
         else:
-            default_pdr = None
+            pydra_default = None
 
-        metadata_pdr = {"help_string": ""}
+        pydra_metadata = {"help_string": ""}
         for key in self.INPUT_KEYS:
-            key_nm_pdr = self.NAME_MAPPING.get(key, key)
+            pydra_key_nm = self.NAME_MAPPING.get(key, key)
             val = getattr(field, key)
             if val is not None:
                 if key == "argstr" and "%" in val:
                     val = self.string_formats(argstr=val, name=nm)
-                metadata_pdr[key_nm_pdr] = val
+                pydra_metadata[pydra_key_nm] = val
 
         if getattr(field, "name_template"):
             template = getattr(field, "name_template")
@@ -513,57 +515,57 @@ def pydra_fld_input(self, field, nm):
                 tmpl = self.string_formats(argstr=template, name=name_source[0])
             else:
                 tmpl = template
-            metadata_pdr["output_file_template"] = tmpl
-            if tp_pdr in [specs.File, specs.Directory]:
-                tp_pdr = str
+            pydra_metadata["output_file_template"] = tmpl
+            if pydra_type in [specs.File, specs.Directory]:
+                pydra_type = str
         elif getattr(field, "genfile"):
             if nm in self.outputs.templates:
                 try:
-                    metadata_pdr["output_file_template"] = self.outputs.templates[nm]
+                    pydra_metadata["output_file_template"] = self.outputs.templates[nm]
                 except KeyError:
                     raise Exception(
                         f"{nm} is has genfile=True and therefore needs an 'output_file_template' value"
                     )
-                if tp_pdr in [
+                if pydra_type in [
                     specs.File,
                     specs.Directory,
                 ]:  # since this is a template, the file doesn't exist
-                    tp_pdr = Path
+                    pydra_type = Path
             elif nm not in self.outputs.callables:
                 raise Exception(
                     f"the filed {nm} has genfile=True, but no output template or callables_module provided"
                 )
 
-        metadata_pdr.update(metadata_extra_spec)
+        pydra_metadata.update(metadata_extra_spec)
 
-        pos = metadata_pdr.get("position", None)
+        pos = pydra_metadata.get("position", None)
 
-        if default_pdr is not None and not metadata_pdr.get("mandatory", None):
-            return (tp_pdr, default_pdr, metadata_pdr), pos
+        if pydra_default is not None and not pydra_metadata.get("mandatory", None):
+            return (pydra_type, pydra_default, pydra_metadata), pos
         else:
-            return (tp_pdr, metadata_pdr), pos
+            return (pydra_type, pydra_metadata), pos
 
     def convert_output_spec(self, fields_from_template):
         """creating fields list for pydra input spec"""
-        fields_pdr_l = []
+        pydra_fields_l = []
         if not self.nipype_output_spec:
-            return fields_pdr_l
+            return pydra_fields_l
         for name, fld in self.nipype_output_spec.traits().items():
             if name in self.outputs.requirements and name not in fields_from_template:
-                fld_pdr = self.pydra_fld_output(fld, name)
-                fields_pdr_l.append((name,) + fld_pdr)
-        return fields_pdr_l
+                pydra_fld = self.pydra_fld_output(fld, name)
+                pydra_fields_l.append((name,) + pydra_fld)
+        return pydra_fields_l
 
     def pydra_fld_output(self, field, name):
         """converting a single nipype field to one element of fields for pydra output_spec"""
-        tp_pdr = self.pydra_type_converter(field, spec_type="output", name=name)
+        pydra_type = self.pydra_type_converter(field, spec_type="output", name=name)
 
-        metadata_pdr = {}
+        pydra_metadata = {}
         for key in self.OUTPUT_KEYS:
-            key_nm_pdr = self.NAME_MAPPING.get(key, key)
+            pydra_key_nm = self.NAME_MAPPING.get(key, key)
             val = getattr(field, key)
             if val:
-                metadata_pdr[key_nm_pdr] = val
+                pydra_metadata[pydra_key_nm] = val
 
         if self.outputs.requirements[name]:
             if all([isinstance(el, list) for el in self.outputs.requirements[name]]):
@@ -577,7 +579,7 @@ def pydra_fld_output(self, field, name):
             else:
                 Exception("has to be either list of list or list of str/dict")
 
-            metadata_pdr["requires"] = []
+            pydra_metadata["requires"] = []
             for requires in requires_l:
                 requires_mod = []
                 for el in requires:
@@ -585,17 +587,17 @@ def pydra_fld_output(self, field, name):
                         requires_mod.append(el)
                     elif isinstance(el, dict):
                         requires_mod += list(el.items())
-                metadata_pdr["requires"].append(requires_mod)
+                pydra_metadata["requires"].append(requires_mod)
             if nested_flag is False:
-                metadata_pdr["requires"] = metadata_pdr["requires"][0]
+                pydra_metadata["requires"] = pydra_metadata["requires"][0]
 
         if name in self.outputs.templates:
-            metadata_pdr["output_file_template"] = self.interface_spec[
+            pydra_metadata["output_file_template"] = self.interface_spec[
                 "output_templates"
             ][name]
         elif name in self.outputs.callables:
-            metadata_pdr["callable"] = self.outputs.callables[name]
-        return (tp_pdr, metadata_pdr)
+            pydra_metadata["callable"] = self.outputs.callables[name]
+        return (pydra_type, pydra_metadata)
 
     def function_callables(self):
         if not self.outputs.callables:
@@ -626,45 +628,45 @@ def pydra_type_converter(self, field, spec_type, name):
             return types_dict[name]
         except KeyError:
             pass
-        tp = field.trait_type
-        if isinstance(tp, traits.trait_types.Int):
-            tp_pdr = int
-        elif isinstance(tp, traits.trait_types.Float):
-            tp_pdr = float
-        elif isinstance(tp, traits.trait_types.Str):
-            tp_pdr = str
-        elif isinstance(tp, traits.trait_types.Bool):
-            tp_pdr = bool
-        elif isinstance(tp, traits.trait_types.Dict):
-            tp_pdr = dict
-        elif isinstance(tp, traits_extension.InputMultiObject):
+        trait_tp = field.trait_type
+        if isinstance(trait_tp, traits.trait_types.Int):
+            pydra_type = int
+        elif isinstance(trait_tp, traits.trait_types.Float):
+            pydra_type = float
+        elif isinstance(trait_tp, traits.trait_types.Str):
+            pydra_type = str
+        elif isinstance(trait_tp, traits.trait_types.Bool):
+            pydra_type = bool
+        elif isinstance(trait_tp, traits.trait_types.Dict):
+            pydra_type = dict
+        elif isinstance(trait_tp, traits_extension.InputMultiObject):
             if isinstance(field.inner_traits[0].trait_type, traits_extension.File):
-                tp_pdr = ty.List[File]
+                pydra_type = ty.List[File]
             else:
-                tp_pdr = specs.MultiInputObj
-        elif isinstance(tp, traits_extension.OutputMultiObject):
+                pydra_type = specs.MultiInputObj
+        elif isinstance(trait_tp, traits_extension.OutputMultiObject):
             if isinstance(field.inner_traits[0].trait_type, traits_extension.File):
-                tp_pdr = specs.MultiOutputFile
+                pydra_type = specs.MultiOutputFile
             else:
-                tp_pdr = specs.MultiOutputObj
-        elif isinstance(tp, traits.trait_types.List):
+                pydra_type = specs.MultiOutputObj
+        elif isinstance(trait_tp, traits.trait_types.List):
             if isinstance(field.inner_traits[0].trait_type, traits_extension.File):
                 if spec_type == "input":
-                    tp_pdr = ty.List[File]
+                    pydra_type = ty.List[File]
                 else:
-                    tp_pdr = specs.MultiOutputFile
+                    pydra_type = specs.MultiOutputFile
             else:
-                tp_pdr = list
-        elif isinstance(tp, traits_extension.File):
+                pydra_type = list
+        elif isinstance(trait_tp, traits_extension.File):
             if (
-                spec_type == "output" or tp.exists is True
+                spec_type == "output" or trait_tp.exists is True
             ):  # TODO check the hash_file metadata in nipype
-                tp_pdr = specs.File
+                pydra_type = specs.File
             else:
-                tp_pdr = Path
+                pydra_type = Path
         else:
-            tp_pdr = ty.Any
-        return tp_pdr
+            pydra_type = ty.Any
+        return pydra_type
 
     def string_formats(self, argstr, name):
         keys = re.findall(r"(%[0-9\.]*(?:s|d|i|g|f))", argstr)
@@ -680,18 +682,28 @@ def string_formats(self, argstr, name):
     def write_task(self, filename, input_fields, nonstd_types, output_fields):
         """writing pydra task to the dile based on the input and output spec"""
 
+        def unwrap_field_type(t):
+            if issubclass(t, WithClassifiers) and t.is_classified:
+                unwraped_classifiers = ", ".join(unwrap_field_type(c) for c in t.classifiers)
+                return f"{t.unclassified.__name__}[{unwraped_classifiers}]"
+            return t.__name__
+
         def types_to_names(spec_fields):
             spec_fields_str = []
             for el in spec_fields:
                 el = list(el)
-                tp_str = str(el[1])
-                if tp_str.startswith("<class "):
-                    tp_str = el[1].__name__
+                field_type = el[1]
+                if inspect.isclass(field_type) and issubclass(field_type, WithClassifiers):
+                    field_type_str = unwrap_field_type(field_type)
                 else:
-                    # Alter modules in type string to match those that will be imported
-                    tp_str = tp_str.replace("typing", "ty")
-                    tp_str = re.sub(r"(\w+\.)+(?<!ty\.)(\w+)", r"\2", tp_str)
-                el[1] = "#" + tp_str + "#"
+                    field_type_str = str(field_type)
+                    if field_type_str.startswith("<class "):
+                        field_type_str = el[1].__name__
+                    else:
+                        # Alter modules in type string to match those that will be imported
+                        field_type_str = field_type_str.replace("typing", "ty")
+                        field_type_str = re.sub(r"(\w+\.)+(?<!ty\.)(\w+)", r"\2", field_type_str)
+                el[1] = "#" + field_type_str + "#"
                 spec_fields_str.append(tuple(el))
             return spec_fields_str
 
@@ -795,7 +807,16 @@ def add_import(stmt):
                         else f"{stmt.name} as {stmt.alias}"
                     )
                     add_import(f"from {stmt.module} import {nm}")
-        for tp in nonstd_types:
+
+        def unwrap_nested_type(t: type) -> ty.List[type]:
+            if issubclass(t, WithClassifiers) and t.is_classified:
+                unwrapped = [t.unclassified]
+                for c in t.classifiers:
+                    unwrapped.extend(unwrap_nested_type(c))
+                return unwrapped
+            return [t]
+
+        for tp in itertools.chain(*(unwrap_nested_type(t) for t in nonstd_types)):
             add_import(f"from {tp.__module__} import {tp.__name__}")
         # For debugging
         add_import(f"import {'.'.join(self.output_module.split('.')[:-2])}")

From 7ca8dae819fd82bfc1aeb0761f6c3400a292eac1 Mon Sep 17 00:00:00 2001
From: Tom Close <tom.g.close@gmail.com>
Date: Mon, 5 Feb 2024 17:10:47 +1100
Subject: [PATCH 16/78] added all venvs to gitignore

---
 .gitignore | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.gitignore b/.gitignore
index 8632e2b7..b727c5a1 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,4 +1,4 @@
-.venv*
+*.venv*
 /.project
 /.pydevproject
 *.pyc
@@ -22,4 +22,4 @@ __pycache__
 /outputs
 /Test.venv
 /test-data
-/nipype2pydra/_version.py
\ No newline at end of file
+/nipype2pydra/_version.py

From b419cf628b10edfe17bfd03e53c6d664b824922f Mon Sep 17 00:00:00 2001
From: Tom Close <tom.g.close@gmail.com>
Date: Mon, 5 Feb 2024 17:25:28 +1100
Subject: [PATCH 17/78] Revert "dropped python based fsl commands from list to
 import"

This reverts commit df105333bdb321099fd6d256739ddd70009cf5f2.
---
 nipype-interfaces-to-import.yaml | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/nipype-interfaces-to-import.yaml b/nipype-interfaces-to-import.yaml
index f4c0cca9..dc22011b 100644
--- a/nipype-interfaces-to-import.yaml
+++ b/nipype-interfaces-to-import.yaml
@@ -418,6 +418,7 @@ interfaces:
   - ICA_AROMA
   fsl/dti:
   - DTIFit
+  - FSLXCommand
   - BEDPOSTX5
   - XFibres5
   - ProbTrackX
@@ -439,6 +440,7 @@ interfaces:
   - EddyCorrect
   - EddyQuad
   fsl/fix:
+  - TrainingSetCreator
   - FeatureExtractor
   - Training
   - AccuracyTester
@@ -466,11 +468,14 @@ interfaces:
   - MultiImageMaths
   - TemporalFilter
   fsl/model:
+  - Level1Design
   - FEAT
   - FEATModel
   - FILMGLS
   - FLAMEO
   - ContrastMgr
+  - L2Model
+  - MultipleRegressDesign
   - SMM
   - MELODIC
   - SmoothEstimate

From 55a9b7623faf57f5d58ad3740ac100fd6a87ea47 Mon Sep 17 00:00:00 2001
From: Tom Close <tom.g.close@gmail.com>
Date: Fri, 24 Nov 2023 09:23:37 +1100
Subject: [PATCH 18/78] Revert "removed workflow from main branch"

This reverts commit 1679df10e01ce58f8434b1eae778814d4c3c8c5b.
---
 example-specs/workflow/smriprep.yaml |   40 +
 nipype2pydra/cli.py                  |   12 +
 nipype2pydra/workflow.py             |  100 +
 port_smriprep.py                     |   89 +
 workflow-graph.dot                   |  562 +++++
 workflow-graph.svg                   | 3215 ++++++++++++++++++++++++++
 6 files changed, 4018 insertions(+)
 create mode 100644 example-specs/workflow/smriprep.yaml
 create mode 100644 nipype2pydra/workflow.py
 create mode 100644 port_smriprep.py
 create mode 100644 workflow-graph.dot
 create mode 100644 workflow-graph.svg

diff --git a/example-specs/workflow/smriprep.yaml b/example-specs/workflow/smriprep.yaml
new file mode 100644
index 00000000..0b196a0c
--- /dev/null
+++ b/example-specs/workflow/smriprep.yaml
@@ -0,0 +1,40 @@
+module: smriprep.workflows.base
+workflows:
+    init_single_subject_wf:
+        args:
+            debug: false
+            freesurfer: true
+            fast_track: false
+            hires: true
+            layout:
+                type: bids:BIDSLayout
+                args:
+                    root: test-data/bids-data/ds000113
+            longitudinal: false
+            low_mem: false
+            name: single_subject_wf
+            omp_nthreads: 1
+            output_dir: .
+            skull_strip_fixed_seed: false
+            skull_strip_mode: force
+            skull_strip_template:
+                type: niworkflows.utils.spaces:Reference
+                args:
+                    space: OASIS30ANTs
+            spaces:
+                type: niworkflows.utils.spaces:SpatialReferences
+                args:
+                    spaces:
+                    - MNI152NLin2009cAsym
+                    - fsaverage5
+            subject_id: test
+            bids_filters: null
+    splits:
+        - func_name: registration
+            first_node: ds_surfs
+        - func_name: segmentation
+            first_node: lta2itk_fwd
+    ignore_tasks:
+        - smriprep.interfaces.DerivativesDataSink
+        - nipype.interfaces.utility.base.IdentityInterface
+
diff --git a/nipype2pydra/cli.py b/nipype2pydra/cli.py
index 92e47d53..d61a202b 100644
--- a/nipype2pydra/cli.py
+++ b/nipype2pydra/cli.py
@@ -3,6 +3,7 @@
 import yaml
 from nipype2pydra import __version__
 from .task import TaskConverter
+from .workflow import WorkflowConverter
 
 
 # Define the base CLI entrypoint
@@ -51,3 +52,14 @@ def task(yaml_spec, package_root, callables, output_module):
         output_module=output_module, callables_module=callables, **spec
     )
     converter.generate(package_root)
+
+
+@cli.command(help="Port Nipype workflow creation functions to Pydra")
+@click.argument("yaml-spec", type=click.File())
+@click.argument("package-root", type=click.File(mode="w"))
+def workflow(yaml_spec, package_root):
+
+    spec = yaml.safe_load(yaml_spec)
+
+    converter = WorkflowConverter(spec)
+    converter.generate(package_root)
diff --git a/nipype2pydra/workflow.py b/nipype2pydra/workflow.py
new file mode 100644
index 00000000..5debe661
--- /dev/null
+++ b/nipype2pydra/workflow.py
@@ -0,0 +1,100 @@
+from __future__ import annotations
+import json
+import tempfile
+from pathlib import Path
+import subprocess as sp
+from collections import defaultdict
+import black
+from nipype.interfaces.base import isdefined
+from .utils import load_class_or_func
+
+
+class WorkflowConverter:
+    # creating the wf
+    def __init__(self, spec):
+        self.spec = spec
+
+        self.wf = load_class_or_func(self.spec["function"])(
+            **self._parse_workflow_args(self.spec["args"])
+        )  # loads the 'function' in smriprep.yaml, and implement the args (creates a dictionary)
+
+    def node_connections(self, workflow, functions: dict[str, dict], wf_inputs: dict[str, str], wf_outputs: dict[str, str]):
+        connections = defaultdict(dict)
+
+        # iterates over wf graph, Get connections from workflow graph, store connections in a dictionary
+        for edge, props in workflow._graph.edges.items():
+            src_node = edge[0].name
+            dest_node = edge[1].name
+            dest_node_fullname = workflow.get_node(dest_node).fullname
+            for node_conn in props["connect"]:
+                src_field = node_conn[0]
+                dest_field = node_conn[1]
+                if src_field.startswith("def"):
+                    functions[dest_node_fullname][dest_field] = src_field
+                else:
+                    connections[dest_node_fullname][
+                        dest_field
+                    ] = f"{src_node}.lzout.{src_field}"
+
+        for nested_wf in workflow._nested_workflows_cache:
+            connections.update(self.node_connections(nested_wf, functions=functions))
+        return connections
+
+    def generate(self, package_root: str, format_with_black: bool = False):
+
+        functions = defaultdict(dict)
+        connections = self.node_connections(self.wf, functions=functions)
+        out_text = ""
+        for node_name in self.wf.list_node_names():
+            node = self.wf.get_node(node_name)
+
+            interface_type = type(node.interface)
+
+            task_type = interface_type.__module__ + "." + interface_type.__name__
+            node_args = ""
+            for arg in node.inputs.visible_traits():
+                val = getattr(node.inputs, arg)  # Enclose strings in quotes
+                if isdefined(val):
+                    try:
+                        val = json.dumps(val)
+                    except TypeError:
+                        pass
+                    if isinstance(val, str) and "\n" in val:
+                        val = '"""' + val + '""""'
+                    node_args += f",\n        {arg}={val}"
+
+            for arg, val in connections[node.fullname].items():
+                node_args += f",\n        {arg}=wf.{val}"
+
+            out_text += f"""
+    wf.add({task_type}(
+        name="{node.name}"{node_args}
+)"""
+
+        if format_with_black:
+            out_text = black.format_file_contents(
+                out_text, fast=False, mode=black.FileMode()
+            )
+        return out_text
+
+    @classmethod
+    def _parse_workflow_args(cls, args):
+        dct = {}
+        for name, val in args.items():
+            if isinstance(val, dict) and sorted(val.keys()) == ["args", "type"]:
+                val = load_class_or_func(val["type"])(
+                    **cls._parse_workflow_args(val["args"])
+                )
+            dct[name] = val
+        return dct
+
+    def save_graph(self, out_path: Path, format: str = "svg", work_dir: Path = None):
+        if work_dir is None:
+            work_dir = tempfile.mkdtemp()
+        work_dir = Path(work_dir)
+        graph_dot_path = work_dir / "wf-graph.dot"
+        self.wf.write_hierarchical_dotfile(graph_dot_path)
+        dot_path = sp.check_output("which dot", shell=True).decode("utf-8").strip()
+        sp.check_call(
+            f"{dot_path} -T{format} {str(graph_dot_path)} > {str(out_path)}", shell=True
+        )
diff --git a/port_smriprep.py b/port_smriprep.py
new file mode 100644
index 00000000..304f9a3f
--- /dev/null
+++ b/port_smriprep.py
@@ -0,0 +1,89 @@
+import json
+from collections import defaultdict
+import click
+from bids import BIDSLayout
+from nipype.interfaces.base import isdefined
+from niworkflows.utils.spaces import SpatialReferences, Reference
+from smriprep.workflows.base import init_single_subject_wf
+
+
+@click.command("Print out auto-generated port of Nipype to Pydra")
+@click.argument("out-file")
+@click.argument("bids-dataset")
+def port(out_file, bids_dataset):
+
+    wf = build_workflow(bids_dataset)
+
+    connections = defaultdict(dict)
+
+    for edge, props in wf._graph.edges.items():
+        src_node = edge[0].name
+        dest_node = edge[1].name
+        for node_conn in props['connect']:
+            src_field = node_conn[1]
+            dest_field = node_conn[0]
+            if src_field.startswith('def'):
+                print(f"Not sure how to deal with {src_field} in {src_node} to "
+                      f"{dest_node}.{dest_field}")
+                continue
+            else:
+                src_field = src_field.split('.')[-1]
+            connections[dest_node][dest_field] = f"{src_node}.lzout.{src_field}"
+
+    out_text = ""
+    for node_name in wf.list_node_names():
+        node = wf.get_node(node_name)
+
+        interface_type = type(node.interface)
+
+        task_type = interface_type.__module__ + "." + interface_type.__name__
+        node_args = ""
+        for arg in node.inputs.visible_traits():
+            val = getattr(node.inputs, arg)  # Enclose strings in quotes
+            if isdefined(val):
+                try:
+                    val = json.dumps(val)
+                except TypeError:
+                    pass
+                if isinstance(val, str) and '\n' in val:
+                    val = '"""' + val + '""""'
+                node_args += f",\n        {arg}={val}"
+
+        for arg, val in connections[node.name].items():
+            node_args += f",\n        {arg}={val}"
+
+        out_text += f"""
+    wf.add({task_type}(
+        name="{node.name}"{node_args}
+    )"""
+
+    with open(out_file, "w") as f:
+        f.write(out_text)
+
+
+def build_workflow(bids_dataset):
+
+    wf = init_single_subject_wf(
+        debug=False,
+        freesurfer=True,
+        fast_track=False,
+        hires=True,
+        layout=BIDSLayout(bids_dataset),
+        longitudinal=False,
+        low_mem=False,
+        name="single_subject_wf",
+        omp_nthreads=1,
+        output_dir=".",
+        skull_strip_fixed_seed=False,
+        skull_strip_mode="force",
+        skull_strip_template=Reference("OASIS30ANTs"),
+        spaces=SpatialReferences(spaces=["MNI152NLin2009cAsym", "fsaverage5"]),
+        subject_id="test",
+        bids_filters=None,
+    )
+
+    return wf
+
+
+if __name__ == "__main__":
+    port()
diff --git a/workflow-graph.dot b/workflow-graph.dot
new file mode 100644
index 00000000..a3cc3f43
--- /dev/null
+++ b/workflow-graph.dot
@@ -0,0 +1,562 @@
+digraph single_subject_wf{
+  label="single_subject_wf";
+  single_subject_wf_inputnode[label="inputnode (utility)"];
+  single_subject_wf_bidssrc[label="bidssrc (bids)"];
+  single_subject_wf_about[label="about (reports)"];
+  single_subject_wf_bids_info[label="bids_info (bids)"];
+  single_subject_wf_ds_report_about[label="ds_report_about"];
+  single_subject_wf_summary[label="summary (reports)"];
+  single_subject_wf_ds_report_summary[label="ds_report_summary"];
+  single_subject_wf_inputnode -> single_subject_wf_summary;
+  single_subject_wf_bidssrc -> single_subject_wf_bids_info;
+  single_subject_wf_bidssrc -> single_subject_wf_summary;
+  single_subject_wf_bidssrc -> single_subject_wf_summary;
+  single_subject_wf_bidssrc -> single_subject_wf_ds_report_summary;
+  single_subject_wf_bidssrc -> single_subject_wf_ds_report_about;
+  single_subject_wf_about -> single_subject_wf_ds_report_about;
+  single_subject_wf_bids_info -> single_subject_wf_summary;
+  single_subject_wf_summary -> single_subject_wf_ds_report_summary;
+  subgraph cluster_single_subject_wf_anat_preproc_wf {
+      label="anat_preproc_wf";
+    single_subject_wf_anat_preproc_wf_inputnode[label="inputnode (utility)"];
+    single_subject_wf_anat_preproc_wf_fs_isrunning[label="fs_isrunning (utility)"];
+    single_subject_wf_anat_preproc_wf_anat_validate[label="anat_validate (header)"];
+    single_subject_wf_anat_preproc_wf_applyrefined[label="applyrefined (fsl)"];
+    single_subject_wf_anat_preproc_wf_buffernode[label="buffernode (utility)"];
+    single_subject_wf_anat_preproc_wf_t1w_dseg[label="t1w_dseg (fsl)"];
+    single_subject_wf_anat_preproc_wf_lut_t1w_dseg[label="lut_t1w_dseg (utility)"];
+    single_subject_wf_anat_preproc_wf_fast2bids[label="fast2bids (utility)"];
+    single_subject_wf_anat_preproc_wf_outputnode[label="outputnode (utility)"];
+    single_subject_wf_anat_preproc_wf_inputnode -> single_subject_wf_anat_preproc_wf_fs_isrunning;
+    single_subject_wf_anat_preproc_wf_inputnode -> single_subject_wf_anat_preproc_wf_fs_isrunning;
+    subgraph cluster_single_subject_wf_anat_preproc_wf_anat_template_wf {
+            label="anat_template_wf";
+        single_subject_wf_anat_preproc_wf_anat_template_wf_inputnode[label="inputnode (utility)"];
+        single_subject_wf_anat_preproc_wf_anat_template_wf_t1w_ref_dimensions[label="t1w_ref_dimensions (images)"];
+        single_subject_wf_anat_preproc_wf_anat_template_wf_t1w_conform[label="t1w_conform (images)"];
+        single_subject_wf_anat_preproc_wf_anat_template_wf_get1st[label="get1st (utility)"];
+        single_subject_wf_anat_preproc_wf_anat_template_wf_outputnode[label="outputnode (utility)"];
+        single_subject_wf_anat_preproc_wf_anat_template_wf_inputnode -> single_subject_wf_anat_preproc_wf_anat_template_wf_t1w_ref_dimensions;
+        single_subject_wf_anat_preproc_wf_anat_template_wf_t1w_ref_dimensions -> single_subject_wf_anat_preproc_wf_anat_template_wf_t1w_conform;
+        single_subject_wf_anat_preproc_wf_anat_template_wf_t1w_ref_dimensions -> single_subject_wf_anat_preproc_wf_anat_template_wf_t1w_conform;
+        single_subject_wf_anat_preproc_wf_anat_template_wf_t1w_ref_dimensions -> single_subject_wf_anat_preproc_wf_anat_template_wf_t1w_conform;
+        single_subject_wf_anat_preproc_wf_anat_template_wf_t1w_ref_dimensions -> single_subject_wf_anat_preproc_wf_anat_template_wf_outputnode;
+        single_subject_wf_anat_preproc_wf_anat_template_wf_t1w_ref_dimensions -> single_subject_wf_anat_preproc_wf_anat_template_wf_outputnode;
+        single_subject_wf_anat_preproc_wf_anat_template_wf_t1w_conform -> single_subject_wf_anat_preproc_wf_anat_template_wf_get1st;
+        single_subject_wf_anat_preproc_wf_anat_template_wf_get1st -> single_subject_wf_anat_preproc_wf_anat_template_wf_outputnode;
+    }
+    subgraph cluster_single_subject_wf_anat_preproc_wf_brain_extraction_wf {
+            label="brain_extraction_wf";
+        single_subject_wf_anat_preproc_wf_brain_extraction_wf_inputnode[label="inputnode (utility)"];
+        single_subject_wf_anat_preproc_wf_brain_extraction_wf_res_tmpl[label="res_tmpl (nibabel)"];
+        single_subject_wf_anat_preproc_wf_brain_extraction_wf_full_wm[label="full_wm (utility)"];
+        single_subject_wf_anat_preproc_wf_brain_extraction_wf_lap_tmpl[label="lap_tmpl (ants)"];
+        single_subject_wf_anat_preproc_wf_brain_extraction_wf_truncate_images[label="truncate_images (ants)"];
+        single_subject_wf_anat_preproc_wf_brain_extraction_wf_mrg_tmpl[label="mrg_tmpl (utility)"];
+        single_subject_wf_anat_preproc_wf_brain_extraction_wf_inu_n4[label="inu_n4 (ants)"];
+        single_subject_wf_anat_preproc_wf_brain_extraction_wf_res_target[label="res_target (nibabel)"];
+        single_subject_wf_anat_preproc_wf_brain_extraction_wf_lap_target[label="lap_target (ants)"];
+        single_subject_wf_anat_preproc_wf_brain_extraction_wf_init_aff[label="init_aff (ants)"];
+        single_subject_wf_anat_preproc_wf_brain_extraction_wf_mrg_target[label="mrg_target (utility)"];
+        single_subject_wf_anat_preproc_wf_brain_extraction_wf_norm[label="norm (fixes)"];
+        single_subject_wf_anat_preproc_wf_brain_extraction_wf_map_brainmask[label="map_brainmask (fixes)"];
+        single_subject_wf_anat_preproc_wf_brain_extraction_wf_map_wmmask[label="map_wmmask (fixes)"];
+        single_subject_wf_anat_preproc_wf_brain_extraction_wf_thr_brainmask[label="thr_brainmask (ants)"];
+        single_subject_wf_anat_preproc_wf_brain_extraction_wf_inu_n4_final[label="inu_n4_final (ants)"];
+        single_subject_wf_anat_preproc_wf_brain_extraction_wf_apply_mask[label="apply_mask (nibabel)"];
+        single_subject_wf_anat_preproc_wf_brain_extraction_wf_outputnode[label="outputnode (utility)"];
+        single_subject_wf_anat_preproc_wf_brain_extraction_wf_inputnode -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_truncate_images;
+        single_subject_wf_anat_preproc_wf_brain_extraction_wf_inputnode -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_inu_n4_final;
+        single_subject_wf_anat_preproc_wf_brain_extraction_wf_inputnode -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_init_aff;
+        single_subject_wf_anat_preproc_wf_brain_extraction_wf_inputnode -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_norm;
+        single_subject_wf_anat_preproc_wf_brain_extraction_wf_inputnode -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_map_brainmask;
+        single_subject_wf_anat_preproc_wf_brain_extraction_wf_inputnode -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_map_wmmask;
+        single_subject_wf_anat_preproc_wf_brain_extraction_wf_res_tmpl -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_init_aff;
+        single_subject_wf_anat_preproc_wf_brain_extraction_wf_full_wm -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_map_wmmask;
+        single_subject_wf_anat_preproc_wf_brain_extraction_wf_lap_tmpl -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_mrg_tmpl;
+        single_subject_wf_anat_preproc_wf_brain_extraction_wf_truncate_images -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_inu_n4;
+        single_subject_wf_anat_preproc_wf_brain_extraction_wf_mrg_tmpl -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_norm;
+        single_subject_wf_anat_preproc_wf_brain_extraction_wf_inu_n4 -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_res_target;
+        single_subject_wf_anat_preproc_wf_brain_extraction_wf_inu_n4 -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_lap_target;
+        single_subject_wf_anat_preproc_wf_brain_extraction_wf_inu_n4 -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_mrg_target;
+        single_subject_wf_anat_preproc_wf_brain_extraction_wf_res_target -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_init_aff;
+        single_subject_wf_anat_preproc_wf_brain_extraction_wf_lap_target -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_mrg_target;
+        single_subject_wf_anat_preproc_wf_brain_extraction_wf_init_aff -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_norm;
+        single_subject_wf_anat_preproc_wf_brain_extraction_wf_mrg_target -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_norm;
+        single_subject_wf_anat_preproc_wf_brain_extraction_wf_norm -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_map_brainmask;
+        single_subject_wf_anat_preproc_wf_brain_extraction_wf_norm -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_map_brainmask;
+        single_subject_wf_anat_preproc_wf_brain_extraction_wf_norm -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_map_wmmask;
+        single_subject_wf_anat_preproc_wf_brain_extraction_wf_norm -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_map_wmmask;
+        single_subject_wf_anat_preproc_wf_brain_extraction_wf_map_brainmask -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_thr_brainmask;
+        single_subject_wf_anat_preproc_wf_brain_extraction_wf_map_wmmask -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_inu_n4_final;
+        single_subject_wf_anat_preproc_wf_brain_extraction_wf_thr_brainmask -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_apply_mask;
+        single_subject_wf_anat_preproc_wf_brain_extraction_wf_inu_n4_final -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_apply_mask;
+        subgraph cluster_single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf {
+                        label="atropos_wf";
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_inputnode[label="inputnode (utility)"];
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_dil_brainmask[label="dil_brainmask (ants)"];
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_03_pad_mask[label="03_pad_mask (ants)"];
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_get_brainmask[label="get_brainmask (ants)"];
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_01_atropos[label="01_atropos (ants)"];
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_02_pad_segm[label="02_pad_segm (ants)"];
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_match_wm[label="match_wm (utility)"];
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_04_sel_labels[label="04_sel_labels (utility)"];
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_overlap[label="overlap (metrics)"];
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_05_get_wm[label="05_get_wm (ants)"];
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_06_get_gm[label="06_get_gm (ants)"];
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_10_me_csf[label="10_me_csf (ants)"];
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_27_depad_csf[label="27_depad_csf (ants)"];
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_sel_wm[label="sel_wm (utility)"];
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_09_relabel_wm[label="09_relabel_wm (ants)"];
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_07_fill_gm[label="07_fill_gm (ants)"];
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_copy_xform_wm[label="copy_xform_wm (header)"];
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_26_depad_wm[label="26_depad_wm (ants)"];
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_08_mult_gm[label="08_mult_gm (ants)"];
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_apply_wm_prior[label="apply_wm_prior (utility)"];
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_11_add_gm[label="11_add_gm (ants)"];
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_inu_n4_final[label="inu_n4_final (ants)"];
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_12_relabel_gm[label="12_relabel_gm (ants)"];
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_13_add_gm_wm[label="13_add_gm_wm (ants)"];
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_25_depad_gm[label="25_depad_gm (ants)"];
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_14_sel_labels2[label="14_sel_labels2 (utility)"];
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_24_depad_segm[label="24_depad_segm (ants)"];
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_merge_tpms[label="merge_tpms (utility)"];
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_15_add_7[label="15_add_7 (ants)"];
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_16_me_7[label="16_me_7 (ants)"];
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_17_comp_7[label="17_comp_7 (ants)"];
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_18_md_7[label="18_md_7 (ants)"];
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_19_fill_7[label="19_fill_7 (ants)"];
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_20_add_7_2[label="20_add_7_2 (ants)"];
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_21_md_7_2[label="21_md_7_2 (ants)"];
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_22_me_7_2[label="22_me_7_2 (ants)"];
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_23_depad_mask[label="23_depad_mask (ants)"];
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_msk_conform[label="msk_conform (utility)"];
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_copy_xform[label="copy_xform (header)"];
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_apply_mask[label="apply_mask (nibabel)"];
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_outputnode[label="outputnode (utility)"];
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_inputnode -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_dil_brainmask;
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_inputnode -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_copy_xform;
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_inputnode -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_copy_xform_wm;
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_inputnode -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_03_pad_mask;
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_inputnode -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_01_atropos;
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_inputnode -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_inu_n4_final;
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_inputnode -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_msk_conform;
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_inputnode -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_apply_wm_prior;
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_inputnode -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_apply_wm_prior;
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_inputnode -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_match_wm;
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_dil_brainmask -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_get_brainmask;
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_03_pad_mask -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_20_add_7_2;
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_get_brainmask -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_01_atropos;
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_01_atropos -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_02_pad_segm;
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_01_atropos -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_sel_wm;
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_01_atropos -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_match_wm;
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_01_atropos -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_overlap;
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_02_pad_segm -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_04_sel_labels;
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_match_wm -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_overlap;
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_04_sel_labels -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_05_get_wm;
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_04_sel_labels -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_06_get_gm;
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_04_sel_labels -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_10_me_csf;
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_04_sel_labels -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_27_depad_csf;
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_overlap -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_sel_wm;
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_05_get_wm -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_09_relabel_wm;
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_06_get_gm -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_07_fill_gm;
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_06_get_gm -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_08_mult_gm;
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_10_me_csf -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_11_add_gm;
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_27_depad_csf -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_merge_tpms;
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_sel_wm -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_copy_xform_wm;
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_09_relabel_wm -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_13_add_gm_wm;
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_09_relabel_wm -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_26_depad_wm;
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_07_fill_gm -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_08_mult_gm;
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_copy_xform_wm -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_apply_wm_prior;
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_26_depad_wm -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_merge_tpms;
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_08_mult_gm -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_11_add_gm;
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_apply_wm_prior -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_inu_n4_final;
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_11_add_gm -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_12_relabel_gm;
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_inu_n4_final -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_copy_xform;
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_inu_n4_final -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_copy_xform;
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_12_relabel_gm -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_13_add_gm_wm;
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_12_relabel_gm -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_25_depad_gm;
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_13_add_gm_wm -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_14_sel_labels2;
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_13_add_gm_wm -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_24_depad_segm;
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_25_depad_gm -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_merge_tpms;
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_14_sel_labels2 -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_15_add_7;
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_14_sel_labels2 -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_15_add_7;
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_24_depad_segm -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_copy_xform;
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_merge_tpms -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_copy_xform;
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_15_add_7 -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_16_me_7;
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_16_me_7 -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_17_comp_7;
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_17_comp_7 -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_18_md_7;
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_18_md_7 -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_19_fill_7;
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_19_fill_7 -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_20_add_7_2;
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_20_add_7_2 -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_21_md_7_2;
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_21_md_7_2 -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_22_me_7_2;
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_22_me_7_2 -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_23_depad_mask;
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_23_depad_mask -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_msk_conform;
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_msk_conform -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_copy_xform;
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_copy_xform -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_apply_mask;
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_copy_xform -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_apply_mask;
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_copy_xform -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_outputnode;
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_copy_xform -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_outputnode;
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_copy_xform -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_outputnode;
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_copy_xform -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_outputnode;
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_copy_xform -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_outputnode;
+                single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_apply_mask -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_outputnode;
+        }
+        single_subject_wf_anat_preproc_wf_brain_extraction_wf_inputnode -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_inputnode;
+        single_subject_wf_anat_preproc_wf_brain_extraction_wf_inu_n4_final -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_inputnode;
+        single_subject_wf_anat_preproc_wf_brain_extraction_wf_thr_brainmask -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_inputnode;
+        single_subject_wf_anat_preproc_wf_brain_extraction_wf_map_wmmask -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_inputnode;
+        single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_outputnode -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_outputnode;
+        single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_outputnode -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_outputnode;
+        single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_outputnode -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_outputnode;
+        single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_outputnode -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_outputnode;
+        single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_outputnode -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_outputnode;
+        single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_outputnode -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_outputnode;
+    }
+    subgraph cluster_single_subject_wf_anat_preproc_wf_surface_recon_wf {
+            label="surface_recon_wf";
+        single_subject_wf_anat_preproc_wf_surface_recon_wf_inputnode[label="inputnode (utility)"];
+        single_subject_wf_anat_preproc_wf_surface_recon_wf_recon_config[label="recon_config (freesurfer)"];
+        single_subject_wf_anat_preproc_wf_surface_recon_wf_fov_check[label="fov_check (utility)"];
+        single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon1[label="autorecon1 (freesurfer)"];
+        single_subject_wf_anat_preproc_wf_surface_recon_wf_skull_strip_extern[label="skull_strip_extern (freesurfer)"];
+        single_subject_wf_anat_preproc_wf_surface_recon_wf_fsnative2t1w_xfm[label="fsnative2t1w_xfm (freesurfer)"];
+        single_subject_wf_anat_preproc_wf_surface_recon_wf_t1w2fsnative_xfm[label="t1w2fsnative_xfm (freesurfer)"];
+        single_subject_wf_anat_preproc_wf_surface_recon_wf_refine[label="refine (freesurfer)"];
+        single_subject_wf_anat_preproc_wf_surface_recon_wf_outputnode[label="outputnode (utility)"];
+        single_subject_wf_anat_preproc_wf_surface_recon_wf_inputnode -> single_subject_wf_anat_preproc_wf_surface_recon_wf_recon_config;
+        single_subject_wf_anat_preproc_wf_surface_recon_wf_inputnode -> single_subject_wf_anat_preproc_wf_surface_recon_wf_recon_config;
+        single_subject_wf_anat_preproc_wf_surface_recon_wf_inputnode -> single_subject_wf_anat_preproc_wf_surface_recon_wf_recon_config;
+        single_subject_wf_anat_preproc_wf_surface_recon_wf_inputnode -> single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon1;
+        single_subject_wf_anat_preproc_wf_surface_recon_wf_inputnode -> single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon1;
+        single_subject_wf_anat_preproc_wf_surface_recon_wf_inputnode -> single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon1;
+        single_subject_wf_anat_preproc_wf_surface_recon_wf_inputnode -> single_subject_wf_anat_preproc_wf_surface_recon_wf_fov_check;
+        single_subject_wf_anat_preproc_wf_surface_recon_wf_inputnode -> single_subject_wf_anat_preproc_wf_surface_recon_wf_skull_strip_extern;
+        single_subject_wf_anat_preproc_wf_surface_recon_wf_inputnode -> single_subject_wf_anat_preproc_wf_surface_recon_wf_fsnative2t1w_xfm;
+        single_subject_wf_anat_preproc_wf_surface_recon_wf_inputnode -> single_subject_wf_anat_preproc_wf_surface_recon_wf_refine;
+        single_subject_wf_anat_preproc_wf_surface_recon_wf_inputnode -> single_subject_wf_anat_preproc_wf_surface_recon_wf_refine;
+        single_subject_wf_anat_preproc_wf_surface_recon_wf_recon_config -> single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon1;
+        single_subject_wf_anat_preproc_wf_surface_recon_wf_recon_config -> single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon1;
+        single_subject_wf_anat_preproc_wf_surface_recon_wf_recon_config -> single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon1;
+        single_subject_wf_anat_preproc_wf_surface_recon_wf_recon_config -> single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon1;
+        single_subject_wf_anat_preproc_wf_surface_recon_wf_fov_check -> single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon1;
+        single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon1 -> single_subject_wf_anat_preproc_wf_surface_recon_wf_skull_strip_extern;
+        single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon1 -> single_subject_wf_anat_preproc_wf_surface_recon_wf_skull_strip_extern;
+        single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon1 -> single_subject_wf_anat_preproc_wf_surface_recon_wf_fsnative2t1w_xfm;
+        single_subject_wf_anat_preproc_wf_surface_recon_wf_fsnative2t1w_xfm -> single_subject_wf_anat_preproc_wf_surface_recon_wf_t1w2fsnative_xfm;
+        single_subject_wf_anat_preproc_wf_surface_recon_wf_fsnative2t1w_xfm -> single_subject_wf_anat_preproc_wf_surface_recon_wf_outputnode;
+        subgraph cluster_single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf {
+                        label="autorecon_resume_wf";
+                single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_inputnode[label="inputnode (utility)"];
+                single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_autorecon2_vol[label="autorecon2_vol (freesurfer)"];
+                single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_autorecon_surfs[label="autorecon_surfs (freesurfer)"];
+                single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_cortribbon[label="cortribbon (freesurfer)"];
+                single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_parcstats[label="parcstats (freesurfer)"];
+                single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_autorecon3[label="autorecon3 (freesurfer)"];
+                single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_outputnode[label="outputnode (utility)"];
+                single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_inputnode -> single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_cortribbon;
+                single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_inputnode -> single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_cortribbon;
+                single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_inputnode -> single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_autorecon2_vol;
+                single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_inputnode -> single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_autorecon2_vol;
+                single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_autorecon2_vol -> single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_autorecon_surfs;
+                single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_autorecon2_vol -> single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_autorecon_surfs;
+                single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_autorecon_surfs -> single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_cortribbon;
+                single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_autorecon_surfs -> single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_cortribbon;
+                single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_cortribbon -> single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_parcstats;
+                single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_cortribbon -> single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_parcstats;
+                single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_parcstats -> single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_autorecon3;
+                single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_parcstats -> single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_autorecon3;
+                single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_autorecon3 -> single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_outputnode;
+                single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_autorecon3 -> single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_outputnode;
+        }
+        single_subject_wf_anat_preproc_wf_surface_recon_wf_t1w2fsnative_xfm -> single_subject_wf_anat_preproc_wf_surface_recon_wf_outputnode;
+        subgraph cluster_single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf {
+                        label="gifti_surface_wf";
+                single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_inputnode[label="inputnode (utility)"];
+                single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_get_surfaces[label="get_surfaces (io)"];
+                single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_midthickness[label="midthickness (freesurfer)"];
+                single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_save_midthickness[label="save_midthickness (io)"];
+                single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_surface_list[label="surface_list (utility)"];
+                single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_fs2gii[label="fs2gii (freesurfer)"];
+                single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_fix_surfs[label="fix_surfs (surf)"];
+                single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_outputnode[label="outputnode (utility)"];
+                single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_inputnode -> single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_get_surfaces;
+                single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_inputnode -> single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_get_surfaces;
+                single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_inputnode -> single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_save_midthickness;
+                single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_inputnode -> single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_save_midthickness;
+                single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_inputnode -> single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_fix_surfs;
+                single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_get_surfaces -> single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_midthickness;
+                single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_get_surfaces -> single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_midthickness;
+                single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_get_surfaces -> single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_surface_list;
+                single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_get_surfaces -> single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_surface_list;
+                single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_get_surfaces -> single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_surface_list;
+                single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_midthickness -> single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_save_midthickness;
+                single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_save_midthickness -> single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_surface_list;
+                single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_surface_list -> single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_fs2gii;
+                single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_fs2gii -> single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_fix_surfs;
+                single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_fix_surfs -> single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_outputnode;
+        }
+        subgraph cluster_single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aseg {
+                        label="segs_to_native_aseg";
+                single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aseg_inputnode[label="inputnode (utility)"];
+                single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aseg_fs_datasource[label="fs_datasource (io)"];
+                single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aseg_resample[label="resample (freesurfer)"];
+                single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aseg_outputnode[label="outputnode (utility)"];
+                single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aseg_inputnode -> single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aseg_fs_datasource;
+                single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aseg_inputnode -> single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aseg_fs_datasource;
+                single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aseg_inputnode -> single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aseg_resample;
+                single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aseg_inputnode -> single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aseg_resample;
+                single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aseg_fs_datasource -> single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aseg_resample;
+                single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aseg_resample -> single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aseg_outputnode;
+        }
+        subgraph cluster_single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aparc_aseg {
+                        label="segs_to_native_aparc_aseg";
+                single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aparc_aseg_inputnode[label="inputnode (utility)"];
+                single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aparc_aseg_fs_datasource[label="fs_datasource (io)"];
+                single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aparc_aseg_resample[label="resample (freesurfer)"];
+                single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aparc_aseg_outputnode[label="outputnode (utility)"];
+                single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aparc_aseg_inputnode -> single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aparc_aseg_fs_datasource;
+                single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aparc_aseg_inputnode -> single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aparc_aseg_fs_datasource;
+                single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aparc_aseg_inputnode -> single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aparc_aseg_resample;
+                single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aparc_aseg_inputnode -> single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aparc_aseg_resample;
+                single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aparc_aseg_fs_datasource -> single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aparc_aseg_resample;
+                single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aparc_aseg_resample -> single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aparc_aseg_outputnode;
+        }
+        single_subject_wf_anat_preproc_wf_surface_recon_wf_refine -> single_subject_wf_anat_preproc_wf_surface_recon_wf_outputnode;
+        single_subject_wf_anat_preproc_wf_surface_recon_wf_inputnode -> single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aseg_inputnode;
+        single_subject_wf_anat_preproc_wf_surface_recon_wf_inputnode -> single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aparc_aseg_inputnode;
+        single_subject_wf_anat_preproc_wf_surface_recon_wf_recon_config -> single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_inputnode;
+        single_subject_wf_anat_preproc_wf_surface_recon_wf_recon_config -> single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_inputnode;
+        single_subject_wf_anat_preproc_wf_surface_recon_wf_skull_strip_extern -> single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_inputnode;
+        single_subject_wf_anat_preproc_wf_surface_recon_wf_skull_strip_extern -> single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_inputnode;
+        single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_outputnode -> single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_inputnode;
+        single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_outputnode -> single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_inputnode;
+        single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_outputnode -> single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aseg_inputnode;
+        single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_outputnode -> single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aseg_inputnode;
+        single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_outputnode -> single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aparc_aseg_inputnode;
+        single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_outputnode -> single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aparc_aseg_inputnode;
+        single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_outputnode -> single_subject_wf_anat_preproc_wf_surface_recon_wf_outputnode;
+        single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_outputnode -> single_subject_wf_anat_preproc_wf_surface_recon_wf_outputnode;
+        single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_outputnode -> single_subject_wf_anat_preproc_wf_surface_recon_wf_outputnode;
+        single_subject_wf_anat_preproc_wf_surface_recon_wf_fsnative2t1w_xfm -> single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_inputnode;
+        single_subject_wf_anat_preproc_wf_surface_recon_wf_fsnative2t1w_xfm -> single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aseg_inputnode;
+        single_subject_wf_anat_preproc_wf_surface_recon_wf_fsnative2t1w_xfm -> single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aparc_aseg_inputnode;
+        single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aseg_outputnode -> single_subject_wf_anat_preproc_wf_surface_recon_wf_refine;
+        single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aseg_outputnode -> single_subject_wf_anat_preproc_wf_surface_recon_wf_outputnode;
+        single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aparc_aseg_outputnode -> single_subject_wf_anat_preproc_wf_surface_recon_wf_outputnode;
+    }
+    single_subject_wf_anat_preproc_wf_applyrefined -> single_subject_wf_anat_preproc_wf_buffernode;
+    single_subject_wf_anat_preproc_wf_buffernode -> single_subject_wf_anat_preproc_wf_outputnode;
+    single_subject_wf_anat_preproc_wf_buffernode -> single_subject_wf_anat_preproc_wf_outputnode;
+    single_subject_wf_anat_preproc_wf_buffernode -> single_subject_wf_anat_preproc_wf_t1w_dseg;
+    single_subject_wf_anat_preproc_wf_t1w_dseg -> single_subject_wf_anat_preproc_wf_lut_t1w_dseg;
+    single_subject_wf_anat_preproc_wf_t1w_dseg -> single_subject_wf_anat_preproc_wf_fast2bids;
+    single_subject_wf_anat_preproc_wf_lut_t1w_dseg -> single_subject_wf_anat_preproc_wf_outputnode;
+    single_subject_wf_anat_preproc_wf_fast2bids -> single_subject_wf_anat_preproc_wf_outputnode;
+    subgraph cluster_single_subject_wf_anat_preproc_wf_anat_norm_wf {
+            label="anat_norm_wf";
+        single_subject_wf_anat_preproc_wf_anat_norm_wf_inputnode[label="inputnode (utility)", shape=box3d,style=filled, color=black, colorscheme=greys7 fillcolor=2];
+        single_subject_wf_anat_preproc_wf_anat_norm_wf_split_desc[label="split_desc (templateflow)"];
+        single_subject_wf_anat_preproc_wf_anat_norm_wf_trunc_mov[label="trunc_mov (ants)"];
+        single_subject_wf_anat_preproc_wf_anat_norm_wf_tf_select[label="tf_select (templateflow)"];
+        single_subject_wf_anat_preproc_wf_anat_norm_wf_registration[label="registration (norm)"];
+        single_subject_wf_anat_preproc_wf_anat_norm_wf_tpl_moving[label="tpl_moving (fixes)"];
+        single_subject_wf_anat_preproc_wf_anat_norm_wf_std_mask[label="std_mask (fixes)"];
+        single_subject_wf_anat_preproc_wf_anat_norm_wf_std_dseg[label="std_dseg (fixes)"];
+        single_subject_wf_anat_preproc_wf_anat_norm_wf_std_tpms[label="std_tpms (fixes)"];
+        single_subject_wf_anat_preproc_wf_anat_norm_wf_poutputnode[label="poutputnode (utility)"];
+        single_subject_wf_anat_preproc_wf_anat_norm_wf_outputnode[label="outputnode (utility)"];
+        single_subject_wf_anat_preproc_wf_anat_norm_wf_inputnode -> single_subject_wf_anat_preproc_wf_anat_norm_wf_split_desc;
+        single_subject_wf_anat_preproc_wf_anat_norm_wf_inputnode -> single_subject_wf_anat_preproc_wf_anat_norm_wf_poutputnode;
+        single_subject_wf_anat_preproc_wf_anat_norm_wf_inputnode -> single_subject_wf_anat_preproc_wf_anat_norm_wf_trunc_mov;
+        single_subject_wf_anat_preproc_wf_anat_norm_wf_inputnode -> single_subject_wf_anat_preproc_wf_anat_norm_wf_registration;
+        single_subject_wf_anat_preproc_wf_anat_norm_wf_inputnode -> single_subject_wf_anat_preproc_wf_anat_norm_wf_registration;
+        single_subject_wf_anat_preproc_wf_anat_norm_wf_inputnode -> single_subject_wf_anat_preproc_wf_anat_norm_wf_tpl_moving;
+        single_subject_wf_anat_preproc_wf_anat_norm_wf_inputnode -> single_subject_wf_anat_preproc_wf_anat_norm_wf_std_mask;
+        single_subject_wf_anat_preproc_wf_anat_norm_wf_inputnode -> single_subject_wf_anat_preproc_wf_anat_norm_wf_std_dseg;
+        single_subject_wf_anat_preproc_wf_anat_norm_wf_inputnode -> single_subject_wf_anat_preproc_wf_anat_norm_wf_std_tpms;
+        single_subject_wf_anat_preproc_wf_anat_norm_wf_split_desc -> single_subject_wf_anat_preproc_wf_anat_norm_wf_tf_select;
+        single_subject_wf_anat_preproc_wf_anat_norm_wf_split_desc -> single_subject_wf_anat_preproc_wf_anat_norm_wf_tf_select;
+        single_subject_wf_anat_preproc_wf_anat_norm_wf_split_desc -> single_subject_wf_anat_preproc_wf_anat_norm_wf_registration;
+        single_subject_wf_anat_preproc_wf_anat_norm_wf_split_desc -> single_subject_wf_anat_preproc_wf_anat_norm_wf_registration;
+        single_subject_wf_anat_preproc_wf_anat_norm_wf_split_desc -> single_subject_wf_anat_preproc_wf_anat_norm_wf_poutputnode;
+        single_subject_wf_anat_preproc_wf_anat_norm_wf_trunc_mov -> single_subject_wf_anat_preproc_wf_anat_norm_wf_registration;
+        single_subject_wf_anat_preproc_wf_anat_norm_wf_tf_select -> single_subject_wf_anat_preproc_wf_anat_norm_wf_tpl_moving;
+        single_subject_wf_anat_preproc_wf_anat_norm_wf_tf_select -> single_subject_wf_anat_preproc_wf_anat_norm_wf_std_mask;
+        single_subject_wf_anat_preproc_wf_anat_norm_wf_tf_select -> single_subject_wf_anat_preproc_wf_anat_norm_wf_std_dseg;
+        single_subject_wf_anat_preproc_wf_anat_norm_wf_tf_select -> single_subject_wf_anat_preproc_wf_anat_norm_wf_std_tpms;
+        single_subject_wf_anat_preproc_wf_anat_norm_wf_registration -> single_subject_wf_anat_preproc_wf_anat_norm_wf_tpl_moving;
+        single_subject_wf_anat_preproc_wf_anat_norm_wf_registration -> single_subject_wf_anat_preproc_wf_anat_norm_wf_std_mask;
+        single_subject_wf_anat_preproc_wf_anat_norm_wf_registration -> single_subject_wf_anat_preproc_wf_anat_norm_wf_std_dseg;
+        single_subject_wf_anat_preproc_wf_anat_norm_wf_registration -> single_subject_wf_anat_preproc_wf_anat_norm_wf_std_tpms;
+        single_subject_wf_anat_preproc_wf_anat_norm_wf_registration -> single_subject_wf_anat_preproc_wf_anat_norm_wf_poutputnode;
+        single_subject_wf_anat_preproc_wf_anat_norm_wf_registration -> single_subject_wf_anat_preproc_wf_anat_norm_wf_poutputnode;
+        single_subject_wf_anat_preproc_wf_anat_norm_wf_tpl_moving -> single_subject_wf_anat_preproc_wf_anat_norm_wf_poutputnode;
+        single_subject_wf_anat_preproc_wf_anat_norm_wf_std_mask -> single_subject_wf_anat_preproc_wf_anat_norm_wf_poutputnode;
+        single_subject_wf_anat_preproc_wf_anat_norm_wf_std_dseg -> single_subject_wf_anat_preproc_wf_anat_norm_wf_poutputnode;
+        single_subject_wf_anat_preproc_wf_anat_norm_wf_std_tpms -> single_subject_wf_anat_preproc_wf_anat_norm_wf_poutputnode;
+        single_subject_wf_anat_preproc_wf_anat_norm_wf_poutputnode -> single_subject_wf_anat_preproc_wf_anat_norm_wf_outputnode;
+        single_subject_wf_anat_preproc_wf_anat_norm_wf_poutputnode -> single_subject_wf_anat_preproc_wf_anat_norm_wf_outputnode;
+        single_subject_wf_anat_preproc_wf_anat_norm_wf_poutputnode -> single_subject_wf_anat_preproc_wf_anat_norm_wf_outputnode;
+        single_subject_wf_anat_preproc_wf_anat_norm_wf_poutputnode -> single_subject_wf_anat_preproc_wf_anat_norm_wf_outputnode;
+        single_subject_wf_anat_preproc_wf_anat_norm_wf_poutputnode -> single_subject_wf_anat_preproc_wf_anat_norm_wf_outputnode;
+        single_subject_wf_anat_preproc_wf_anat_norm_wf_poutputnode -> single_subject_wf_anat_preproc_wf_anat_norm_wf_outputnode;
+        single_subject_wf_anat_preproc_wf_anat_norm_wf_poutputnode -> single_subject_wf_anat_preproc_wf_anat_norm_wf_outputnode;
+        single_subject_wf_anat_preproc_wf_anat_norm_wf_poutputnode -> single_subject_wf_anat_preproc_wf_anat_norm_wf_outputnode;
+    }
+    subgraph cluster_single_subject_wf_anat_preproc_wf_anat_reports_wf {
+            label="anat_reports_wf";
+        single_subject_wf_anat_preproc_wf_anat_reports_wf_inputnode[label="inputnode (utility)"];
+        single_subject_wf_anat_preproc_wf_anat_reports_wf_t1w_conform_check[label="t1w_conform_check (utility)"];
+        single_subject_wf_anat_preproc_wf_anat_reports_wf_seg_rpt[label="seg_rpt (reportlets)"];
+        single_subject_wf_anat_preproc_wf_anat_reports_wf_tf_select[label="tf_select (templateflow)"];
+        single_subject_wf_anat_preproc_wf_anat_reports_wf_recon_report[label="recon_report (reports)"];
+        single_subject_wf_anat_preproc_wf_anat_reports_wf_ds_t1w_conform_report[label="ds_t1w_conform_report"];
+        single_subject_wf_anat_preproc_wf_anat_reports_wf_ds_t1w_dseg_mask_report[label="ds_t1w_dseg_mask_report"];
+        single_subject_wf_anat_preproc_wf_anat_reports_wf_norm_msk[label="norm_msk (utility)"];
+        single_subject_wf_anat_preproc_wf_anat_reports_wf_ds_recon_report[label="ds_recon_report"];
+        single_subject_wf_anat_preproc_wf_anat_reports_wf_norm_rpt[label="norm_rpt (reportlets)"];
+        single_subject_wf_anat_preproc_wf_anat_reports_wf_ds_std_t1w_report[label="ds_std_t1w_report"];
+        single_subject_wf_anat_preproc_wf_anat_reports_wf_inputnode -> single_subject_wf_anat_preproc_wf_anat_reports_wf_t1w_conform_check;
+        single_subject_wf_anat_preproc_wf_anat_reports_wf_inputnode -> single_subject_wf_anat_preproc_wf_anat_reports_wf_ds_t1w_conform_report;
+        single_subject_wf_anat_preproc_wf_anat_reports_wf_inputnode -> single_subject_wf_anat_preproc_wf_anat_reports_wf_ds_t1w_dseg_mask_report;
+        single_subject_wf_anat_preproc_wf_anat_reports_wf_inputnode -> single_subject_wf_anat_preproc_wf_anat_reports_wf_seg_rpt;
+        single_subject_wf_anat_preproc_wf_anat_reports_wf_inputnode -> single_subject_wf_anat_preproc_wf_anat_reports_wf_seg_rpt;
+        single_subject_wf_anat_preproc_wf_anat_reports_wf_inputnode -> single_subject_wf_anat_preproc_wf_anat_reports_wf_seg_rpt;
+        single_subject_wf_anat_preproc_wf_anat_reports_wf_inputnode -> single_subject_wf_anat_preproc_wf_anat_reports_wf_tf_select;
+        single_subject_wf_anat_preproc_wf_anat_reports_wf_inputnode -> single_subject_wf_anat_preproc_wf_anat_reports_wf_tf_select;
+        single_subject_wf_anat_preproc_wf_anat_reports_wf_inputnode -> single_subject_wf_anat_preproc_wf_anat_reports_wf_norm_rpt;
+        single_subject_wf_anat_preproc_wf_anat_reports_wf_inputnode -> single_subject_wf_anat_preproc_wf_anat_reports_wf_norm_msk;
+        single_subject_wf_anat_preproc_wf_anat_reports_wf_inputnode -> single_subject_wf_anat_preproc_wf_anat_reports_wf_norm_msk;
+        single_subject_wf_anat_preproc_wf_anat_reports_wf_inputnode -> single_subject_wf_anat_preproc_wf_anat_reports_wf_ds_std_t1w_report;
+        single_subject_wf_anat_preproc_wf_anat_reports_wf_inputnode -> single_subject_wf_anat_preproc_wf_anat_reports_wf_ds_std_t1w_report;
+        single_subject_wf_anat_preproc_wf_anat_reports_wf_inputnode -> single_subject_wf_anat_preproc_wf_anat_reports_wf_recon_report;
+        single_subject_wf_anat_preproc_wf_anat_reports_wf_inputnode -> single_subject_wf_anat_preproc_wf_anat_reports_wf_recon_report;
+        single_subject_wf_anat_preproc_wf_anat_reports_wf_inputnode -> single_subject_wf_anat_preproc_wf_anat_reports_wf_ds_recon_report;
+        single_subject_wf_anat_preproc_wf_anat_reports_wf_t1w_conform_check -> single_subject_wf_anat_preproc_wf_anat_reports_wf_ds_t1w_conform_report;
+        single_subject_wf_anat_preproc_wf_anat_reports_wf_seg_rpt -> single_subject_wf_anat_preproc_wf_anat_reports_wf_ds_t1w_dseg_mask_report;
+        single_subject_wf_anat_preproc_wf_anat_reports_wf_tf_select -> single_subject_wf_anat_preproc_wf_anat_reports_wf_norm_msk;
+        single_subject_wf_anat_preproc_wf_anat_reports_wf_tf_select -> single_subject_wf_anat_preproc_wf_anat_reports_wf_norm_msk;
+        single_subject_wf_anat_preproc_wf_anat_reports_wf_recon_report -> single_subject_wf_anat_preproc_wf_anat_reports_wf_ds_recon_report;
+        single_subject_wf_anat_preproc_wf_anat_reports_wf_norm_msk -> single_subject_wf_anat_preproc_wf_anat_reports_wf_norm_rpt;
+        single_subject_wf_anat_preproc_wf_anat_reports_wf_norm_msk -> single_subject_wf_anat_preproc_wf_anat_reports_wf_norm_rpt;
+        single_subject_wf_anat_preproc_wf_anat_reports_wf_norm_rpt -> single_subject_wf_anat_preproc_wf_anat_reports_wf_ds_std_t1w_report;
+    }
+    subgraph cluster_single_subject_wf_anat_preproc_wf_anat_derivatives_wf {
+            label="anat_derivatives_wf";
+        single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode[label="inputnode (utility)"];
+        single_subject_wf_anat_preproc_wf_anat_derivatives_wf_raw_sources[label="raw_sources (utility)"];
+        single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_t1w_preproc[label="ds_t1w_preproc"];
+        single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_t1w_tpms[label="ds_t1w_tpms"];
+        single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_t1w_dseg[label="ds_t1w_dseg"];
+        single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_t1w2std_xfm[label="ds_t1w2std_xfm"];
+        single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_std2t1w_xfm[label="ds_std2t1w_xfm"];
+        single_subject_wf_anat_preproc_wf_anat_derivatives_wf_lta2itk_fwd[label="lta2itk_fwd (nitransforms)"];
+        single_subject_wf_anat_preproc_wf_anat_derivatives_wf_lta2itk_inv[label="lta2itk_inv (nitransforms)"];
+        single_subject_wf_anat_preproc_wf_anat_derivatives_wf_name_surfs[label="name_surfs (surf)"];
+        single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_t1w_fsaseg[label="ds_t1w_fsaseg"];
+        single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_t1w_fsparc[label="ds_t1w_fsparc"];
+        single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_t1w_mask[label="ds_t1w_mask"];
+        single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_t1w_fsnative[label="ds_t1w_fsnative"];
+        single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_fsnative_t1w[label="ds_fsnative_t1w"];
+        single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_surfs[label="ds_surfs"];
+        single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode -> single_subject_wf_anat_preproc_wf_anat_derivatives_wf_raw_sources;
+        single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode -> single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_t1w_preproc;
+        single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode -> single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_t1w_preproc;
+        single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode -> single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_t1w_mask;
+        single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode -> single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_t1w_mask;
+        single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode -> single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_t1w_tpms;
+        single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode -> single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_t1w_tpms;
+        single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode -> single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_t1w_dseg;
+        single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode -> single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_t1w_dseg;
+        single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode -> single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_t1w2std_xfm;
+        single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode -> single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_t1w2std_xfm;
+        single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode -> single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_t1w2std_xfm;
+        single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode -> single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_std2t1w_xfm;
+        single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode -> single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_std2t1w_xfm;
+        single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode -> single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_std2t1w_xfm;
+        single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode -> single_subject_wf_anat_preproc_wf_anat_derivatives_wf_lta2itk_fwd;
+        single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode -> single_subject_wf_anat_preproc_wf_anat_derivatives_wf_lta2itk_inv;
+        single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode -> single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_t1w_fsnative;
+        single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode -> single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_fsnative_t1w;
+        single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode -> single_subject_wf_anat_preproc_wf_anat_derivatives_wf_name_surfs;
+        single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode -> single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_surfs;
+        single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode -> single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_surfs;
+        single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode -> single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_t1w_fsaseg;
+        single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode -> single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_t1w_fsaseg;
+        single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode -> single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_t1w_fsparc;
+        single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode -> single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_t1w_fsparc;
+        single_subject_wf_anat_preproc_wf_anat_derivatives_wf_raw_sources -> single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_t1w_mask;
+        single_subject_wf_anat_preproc_wf_anat_derivatives_wf_lta2itk_fwd -> single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_t1w_fsnative;
+        single_subject_wf_anat_preproc_wf_anat_derivatives_wf_lta2itk_inv -> single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_fsnative_t1w;
+        single_subject_wf_anat_preproc_wf_anat_derivatives_wf_name_surfs -> single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_surfs;
+        single_subject_wf_anat_preproc_wf_anat_derivatives_wf_name_surfs -> single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_surfs;
+    }
+    single_subject_wf_anat_preproc_wf_outputnode -> single_subject_wf_anat_preproc_wf_anat_reports_wf_inputnode;
+    single_subject_wf_anat_preproc_wf_outputnode -> single_subject_wf_anat_preproc_wf_anat_reports_wf_inputnode;
+    single_subject_wf_anat_preproc_wf_outputnode -> single_subject_wf_anat_preproc_wf_anat_reports_wf_inputnode;
+    single_subject_wf_anat_preproc_wf_outputnode -> single_subject_wf_anat_preproc_wf_anat_reports_wf_inputnode;
+    single_subject_wf_anat_preproc_wf_outputnode -> single_subject_wf_anat_preproc_wf_anat_reports_wf_inputnode;
+    single_subject_wf_anat_preproc_wf_outputnode -> single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode;
+    single_subject_wf_anat_preproc_wf_outputnode -> single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode;
+    single_subject_wf_anat_preproc_wf_outputnode -> single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode;
+    single_subject_wf_anat_preproc_wf_outputnode -> single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode;
+    single_subject_wf_anat_preproc_wf_outputnode -> single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode;
+    single_subject_wf_anat_preproc_wf_outputnode -> single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode;
+    single_subject_wf_anat_preproc_wf_outputnode -> single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode;
+    single_subject_wf_anat_preproc_wf_outputnode -> single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode;
+    single_subject_wf_anat_preproc_wf_inputnode -> single_subject_wf_anat_preproc_wf_anat_template_wf_inputnode;
+    single_subject_wf_anat_preproc_wf_inputnode -> single_subject_wf_anat_preproc_wf_anat_norm_wf_inputnode;
+    single_subject_wf_anat_preproc_wf_inputnode -> single_subject_wf_anat_preproc_wf_anat_norm_wf_inputnode;
+    single_subject_wf_anat_preproc_wf_inputnode -> single_subject_wf_anat_preproc_wf_anat_reports_wf_inputnode;
+    single_subject_wf_anat_preproc_wf_inputnode -> single_subject_wf_anat_preproc_wf_surface_recon_wf_inputnode;
+    single_subject_wf_anat_preproc_wf_inputnode -> single_subject_wf_anat_preproc_wf_surface_recon_wf_inputnode;
+    single_subject_wf_anat_preproc_wf_inputnode -> single_subject_wf_anat_preproc_wf_surface_recon_wf_inputnode;
+    single_subject_wf_anat_preproc_wf_anat_template_wf_outputnode -> single_subject_wf_anat_preproc_wf_anat_validate;
+    single_subject_wf_anat_preproc_wf_anat_template_wf_outputnode -> single_subject_wf_anat_preproc_wf_outputnode;
+    single_subject_wf_anat_preproc_wf_anat_template_wf_outputnode -> single_subject_wf_anat_preproc_wf_anat_reports_wf_inputnode;
+    single_subject_wf_anat_preproc_wf_anat_template_wf_outputnode -> single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode;
+    single_subject_wf_anat_preproc_wf_anat_validate -> single_subject_wf_anat_preproc_wf_brain_extraction_wf_inputnode;
+    single_subject_wf_anat_preproc_wf_anat_validate -> single_subject_wf_anat_preproc_wf_surface_recon_wf_inputnode;
+    single_subject_wf_anat_preproc_wf_brain_extraction_wf_outputnode -> single_subject_wf_anat_preproc_wf_outputnode;
+    single_subject_wf_anat_preproc_wf_brain_extraction_wf_outputnode -> single_subject_wf_anat_preproc_wf_anat_norm_wf_inputnode;
+    single_subject_wf_anat_preproc_wf_brain_extraction_wf_outputnode -> single_subject_wf_anat_preproc_wf_surface_recon_wf_inputnode;
+    single_subject_wf_anat_preproc_wf_brain_extraction_wf_outputnode -> single_subject_wf_anat_preproc_wf_surface_recon_wf_inputnode;
+    single_subject_wf_anat_preproc_wf_brain_extraction_wf_outputnode -> single_subject_wf_anat_preproc_wf_surface_recon_wf_inputnode;
+    single_subject_wf_anat_preproc_wf_brain_extraction_wf_outputnode -> single_subject_wf_anat_preproc_wf_applyrefined;
+    single_subject_wf_anat_preproc_wf_buffernode -> single_subject_wf_anat_preproc_wf_anat_norm_wf_inputnode;
+    single_subject_wf_anat_preproc_wf_anat_norm_wf_poutputnode -> single_subject_wf_anat_preproc_wf_outputnode;
+    single_subject_wf_anat_preproc_wf_anat_norm_wf_poutputnode -> single_subject_wf_anat_preproc_wf_outputnode;
+    single_subject_wf_anat_preproc_wf_anat_norm_wf_poutputnode -> single_subject_wf_anat_preproc_wf_outputnode;
+    single_subject_wf_anat_preproc_wf_anat_norm_wf_poutputnode -> single_subject_wf_anat_preproc_wf_outputnode;
+    single_subject_wf_anat_preproc_wf_anat_norm_wf_outputnode -> single_subject_wf_anat_preproc_wf_outputnode;
+    single_subject_wf_anat_preproc_wf_anat_norm_wf_outputnode -> single_subject_wf_anat_preproc_wf_outputnode;
+    single_subject_wf_anat_preproc_wf_anat_norm_wf_outputnode -> single_subject_wf_anat_preproc_wf_outputnode;
+    single_subject_wf_anat_preproc_wf_anat_norm_wf_poutputnode -> single_subject_wf_anat_preproc_wf_anat_reports_wf_inputnode;
+    single_subject_wf_anat_preproc_wf_anat_norm_wf_outputnode -> single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode;
+    single_subject_wf_anat_preproc_wf_anat_norm_wf_outputnode -> single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode;
+    single_subject_wf_anat_preproc_wf_anat_norm_wf_outputnode -> single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode;
+    single_subject_wf_anat_preproc_wf_lut_t1w_dseg -> single_subject_wf_anat_preproc_wf_anat_norm_wf_inputnode;
+    single_subject_wf_anat_preproc_wf_fast2bids -> single_subject_wf_anat_preproc_wf_anat_norm_wf_inputnode;
+    single_subject_wf_anat_preproc_wf_fs_isrunning -> single_subject_wf_anat_preproc_wf_surface_recon_wf_inputnode;
+    single_subject_wf_anat_preproc_wf_surface_recon_wf_outputnode -> single_subject_wf_anat_preproc_wf_applyrefined;
+    single_subject_wf_anat_preproc_wf_surface_recon_wf_outputnode -> single_subject_wf_anat_preproc_wf_outputnode;
+    single_subject_wf_anat_preproc_wf_surface_recon_wf_outputnode -> single_subject_wf_anat_preproc_wf_outputnode;
+    single_subject_wf_anat_preproc_wf_surface_recon_wf_outputnode -> single_subject_wf_anat_preproc_wf_outputnode;
+    single_subject_wf_anat_preproc_wf_surface_recon_wf_outputnode -> single_subject_wf_anat_preproc_wf_outputnode;
+    single_subject_wf_anat_preproc_wf_surface_recon_wf_outputnode -> single_subject_wf_anat_preproc_wf_outputnode;
+    single_subject_wf_anat_preproc_wf_surface_recon_wf_outputnode -> single_subject_wf_anat_preproc_wf_outputnode;
+    single_subject_wf_anat_preproc_wf_surface_recon_wf_outputnode -> single_subject_wf_anat_preproc_wf_outputnode;
+    single_subject_wf_anat_preproc_wf_surface_recon_wf_outputnode -> single_subject_wf_anat_preproc_wf_buffernode;
+    single_subject_wf_anat_preproc_wf_surface_recon_wf_outputnode -> single_subject_wf_anat_preproc_wf_anat_reports_wf_inputnode;
+    single_subject_wf_anat_preproc_wf_surface_recon_wf_outputnode -> single_subject_wf_anat_preproc_wf_anat_reports_wf_inputnode;
+    single_subject_wf_anat_preproc_wf_surface_recon_wf_outputnode -> single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode;
+    single_subject_wf_anat_preproc_wf_surface_recon_wf_outputnode -> single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode;
+  }
+  single_subject_wf_inputnode -> single_subject_wf_anat_preproc_wf_inputnode;
+  single_subject_wf_bidssrc -> single_subject_wf_anat_preproc_wf_inputnode;
+  single_subject_wf_bidssrc -> single_subject_wf_anat_preproc_wf_inputnode;
+  single_subject_wf_bidssrc -> single_subject_wf_anat_preproc_wf_inputnode;
+  single_subject_wf_bidssrc -> single_subject_wf_anat_preproc_wf_inputnode;
+  single_subject_wf_bids_info -> single_subject_wf_anat_preproc_wf_inputnode;
+}
\ No newline at end of file
diff --git a/workflow-graph.svg b/workflow-graph.svg
new file mode 100644
index 00000000..c9c45719
--- /dev/null
+++ b/workflow-graph.svg
@@ -0,0 +1,3215 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN"
+ "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<!-- Generated by graphviz version 7.0.1 (20221109.1506)
+ -->
+<!-- Title: single_subject_wf Pages: 1 -->
+<svg width="3427pt" height="4534pt"
+ viewBox="0.00 0.00 3426.59 4534.00" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
+<g id="graph0" class="graph" transform="scale(1 1) rotate(0) translate(4 4530)">
+<title>single_subject_wf</title>
+<polygon fill="white" stroke="none" points="-4,4 -4,-4530 3422.59,-4530 3422.59,4 -4,4"/>
+<text text-anchor="middle" x="1709.3" y="-7.8" font-family="Times,serif" font-size="14.00">single_subject_wf</text>
+<g id="clust1" class="cluster">
+<title>cluster_single_subject_wf_anat_preproc_wf</title>
+<polygon fill="none" stroke="black" points="8,-31 8,-4518 2861,-4518 2861,-31 8,-31"/>
+<text text-anchor="middle" x="1434.5" y="-4502.8" font-family="Times,serif" font-size="14.00">anat_preproc_wf</text>
+</g>
+<g id="clust2" class="cluster">
+<title>cluster_single_subject_wf_anat_preproc_wf_anat_template_wf</title>
+<polygon fill="none" stroke="black" points="2605,-1651 2605,-2025 2853,-2025 2853,-1651 2605,-1651"/>
+<text text-anchor="middle" x="2729" y="-2009.8" font-family="Times,serif" font-size="14.00">anat_template_wf</text>
+</g>
+<g id="clust3" class="cluster">
+<title>cluster_single_subject_wf_anat_preproc_wf_brain_extraction_wf</title>
+<polygon fill="none" stroke="black" points="1069,-1950 1069,-4487 1997,-4487 1997,-1950 1069,-1950"/>
+<text text-anchor="middle" x="1533" y="-4471.8" font-family="Times,serif" font-size="14.00">brain_extraction_wf</text>
+</g>
+<g id="clust4" class="cluster">
+<title>cluster_single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf</title>
+<polygon fill="none" stroke="black" points="1261,-2033 1261,-3908 1989,-3908 1989,-2033 1261,-2033"/>
+<text text-anchor="middle" x="1625" y="-3892.8" font-family="Times,serif" font-size="14.00">atropos_wf</text>
+</g>
+<g id="clust5" class="cluster">
+<title>cluster_single_subject_wf_anat_preproc_wf_surface_recon_wf</title>
+<polygon fill="none" stroke="black" points="1595,-474 1595,-1942 2563,-1942 2563,-474 1595,-474"/>
+<text text-anchor="middle" x="2079" y="-1926.8" font-family="Times,serif" font-size="14.00">surface_recon_wf</text>
+</g>
+<g id="clust6" class="cluster">
+<title>cluster_single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf</title>
+<polygon fill="none" stroke="black" points="1858,-1136 1858,-1643 2112,-1643 2112,-1136 1858,-1136"/>
+<text text-anchor="middle" x="1985" y="-1627.8" font-family="Times,serif" font-size="14.00">autorecon_resume_wf</text>
+</g>
+<g id="clust7" class="cluster">
+<title>cluster_single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf</title>
+<polygon fill="none" stroke="black" points="1615,-546 1615,-1128 1891,-1128 1891,-546 1615,-546"/>
+<text text-anchor="middle" x="1753" y="-1112.8" font-family="Times,serif" font-size="14.00">gifti_surface_wf</text>
+</g>
+<g id="clust8" class="cluster">
+<title>cluster_single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aseg</title>
+<polygon fill="none" stroke="black" points="2357,-834 2357,-1128 2543,-1128 2543,-834 2357,-834"/>
+<text text-anchor="middle" x="2450" y="-1112.8" font-family="Times,serif" font-size="14.00">segs_to_native_aseg</text>
+</g>
+<g id="clust9" class="cluster">
+<title>cluster_single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aparc_aseg</title>
+<polygon fill="none" stroke="black" points="1899,-834 1899,-1128 2085,-1128 2085,-834 1899,-834"/>
+<text text-anchor="middle" x="1992" y="-1112.8" font-family="Times,serif" font-size="14.00">segs_to_native_aparc_aseg</text>
+</g>
+<g id="clust10" class="cluster">
+<title>cluster_single_subject_wf_anat_preproc_wf_anat_norm_wf</title>
+<polygon fill="none" stroke="black" points="533,-474 533,-909 1224,-909 1224,-474 533,-474"/>
+<text text-anchor="middle" x="878.5" y="-893.8" font-family="Times,serif" font-size="14.00">anat_norm_wf</text>
+</g>
+<g id="clust11" class="cluster">
+<title>cluster_single_subject_wf_anat_preproc_wf_anat_reports_wf</title>
+<polygon fill="none" stroke="black" points="1917,-39 1917,-402 2853,-402 2853,-39 1917,-39"/>
+<text text-anchor="middle" x="2385" y="-386.8" font-family="Times,serif" font-size="14.00">anat_reports_wf</text>
+</g>
+<g id="clust12" class="cluster">
+<title>cluster_single_subject_wf_anat_preproc_wf_anat_derivatives_wf</title>
+<polygon fill="none" stroke="black" points="16,-183 16,-402 1909,-402 1909,-183 16,-183"/>
+<text text-anchor="middle" x="962.5" y="-386.8" font-family="Times,serif" font-size="14.00">anat_derivatives_wf</text>
+</g>
+<!-- single_subject_wf_inputnode -->
+<g id="node1" class="node">
+<title>single_subject_wf_inputnode</title>
+<ellipse fill="none" stroke="black" cx="2944" cy="-2131" rx="75.29" ry="18"/>
+<text text-anchor="middle" x="2944" y="-2127.3" font-family="Times,serif" font-size="14.00">inputnode (utility)</text>
+</g>
+<!-- single_subject_wf_summary -->
+<g id="node6" class="node">
+<title>single_subject_wf_summary</title>
+<ellipse fill="none" stroke="black" cx="3150" cy="-2059" rx="77.19" ry="18"/>
+<text text-anchor="middle" x="3150" y="-2055.3" font-family="Times,serif" font-size="14.00">summary (reports)</text>
+</g>
+<!-- single_subject_wf_inputnode&#45;&gt;single_subject_wf_summary -->
+<g id="edge1" class="edge">
+<title>single_subject_wf_inputnode&#45;&gt;single_subject_wf_summary</title>
+<path fill="none" stroke="black" d="M2986.18,-2115.67C3018.16,-2104.8 3062.31,-2089.8 3096.72,-2078.11"/>
+<polygon fill="black" stroke="black" points="3097.74,-2081.45 3106.09,-2074.92 3095.49,-2074.83 3097.74,-2081.45"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_inputnode -->
+<g id="node8" class="node">
+<title>single_subject_wf_anat_preproc_wf_inputnode</title>
+<ellipse fill="none" stroke="black" cx="2574" cy="-2059" rx="75.29" ry="18"/>
+<text text-anchor="middle" x="2574" y="-2055.3" font-family="Times,serif" font-size="14.00">inputnode (utility)</text>
+</g>
+<!-- single_subject_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_inputnode -->
+<g id="edge368" class="edge">
+<title>single_subject_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_inputnode</title>
+<path fill="none" stroke="black" d="M2890.08,-2118.16C2881.69,-2116.38 2873.12,-2114.61 2865,-2113 2790,-2098.1 2703.8,-2082.61 2644.8,-2072.25"/>
+<polygon fill="black" stroke="black" points="2645.68,-2068.85 2635.23,-2070.57 2644.48,-2075.74 2645.68,-2068.85"/>
+</g>
+<!-- single_subject_wf_bidssrc -->
+<g id="node2" class="node">
+<title>single_subject_wf_bidssrc</title>
+<ellipse fill="none" stroke="black" cx="2927" cy="-2203" rx="58.49" ry="18"/>
+<text text-anchor="middle" x="2927" y="-2199.3" font-family="Times,serif" font-size="14.00">bidssrc (bids)</text>
+</g>
+<!-- single_subject_wf_bids_info -->
+<g id="node4" class="node">
+<title>single_subject_wf_bids_info</title>
+<ellipse fill="none" stroke="black" cx="3104" cy="-2131" rx="66.89" ry="18"/>
+<text text-anchor="middle" x="3104" y="-2127.3" font-family="Times,serif" font-size="14.00">bids_info (bids)</text>
+</g>
+<!-- single_subject_wf_bidssrc&#45;&gt;single_subject_wf_bids_info -->
+<g id="edge2" class="edge">
+<title>single_subject_wf_bidssrc&#45;&gt;single_subject_wf_bids_info</title>
+<path fill="none" stroke="black" d="M2961.97,-2188.17C2989.16,-2177.42 3027.14,-2162.4 3056.99,-2150.59"/>
+<polygon fill="black" stroke="black" points="3058.16,-2153.89 3066.17,-2146.96 3055.59,-2147.38 3058.16,-2153.89"/>
+</g>
+<!-- single_subject_wf_ds_report_about -->
+<g id="node5" class="node">
+<title>single_subject_wf_ds_report_about</title>
+<ellipse fill="none" stroke="black" cx="3351" cy="-2131" rx="67.69" ry="18"/>
+<text text-anchor="middle" x="3351" y="-2127.3" font-family="Times,serif" font-size="14.00">ds_report_about</text>
+</g>
+<!-- single_subject_wf_bidssrc&#45;&gt;single_subject_wf_ds_report_about -->
+<g id="edge6" class="edge">
+<title>single_subject_wf_bidssrc&#45;&gt;single_subject_wf_ds_report_about</title>
+<path fill="none" stroke="black" d="M2979.58,-2194.7C3046.84,-2185.16 3166.87,-2167.49 3269,-2149 3275.32,-2147.86 3281.91,-2146.6 3288.48,-2145.3"/>
+<polygon fill="black" stroke="black" points="3288.86,-2148.8 3297.98,-2143.4 3287.48,-2141.93 3288.86,-2148.8"/>
+</g>
+<!-- single_subject_wf_bidssrc&#45;&gt;single_subject_wf_summary -->
+<g id="edge3" class="edge">
+<title>single_subject_wf_bidssrc&#45;&gt;single_subject_wf_summary</title>
+<path fill="none" stroke="black" d="M2983.28,-2197.7C3047.81,-2191.66 3147.48,-2177.96 3171,-2149 3185.49,-2131.17 3174.94,-2106 3164.02,-2086.98"/>
+<polygon fill="black" stroke="black" points="3167.02,-2085.18 3158.86,-2078.42 3161.03,-2088.79 3167.02,-2085.18"/>
+</g>
+<!-- single_subject_wf_bidssrc&#45;&gt;single_subject_wf_summary -->
+<g id="edge4" class="edge">
+<title>single_subject_wf_bidssrc&#45;&gt;single_subject_wf_summary</title>
+<path fill="none" stroke="black" d="M2984.16,-2198.71C3053.54,-2193.25 3164.07,-2179.7 3189,-2149 3203.84,-2130.73 3192.4,-2104.76 3177.99,-2085.58"/>
+<polygon fill="black" stroke="black" points="3180.78,-2083.47 3171.74,-2077.95 3175.37,-2087.91 3180.78,-2083.47"/>
+</g>
+<!-- single_subject_wf_ds_report_summary -->
+<g id="node7" class="node">
+<title>single_subject_wf_ds_report_summary</title>
+<ellipse fill="none" stroke="black" cx="3202" cy="-1976" rx="81.79" ry="18"/>
+<text text-anchor="middle" x="3202" y="-1972.3" font-family="Times,serif" font-size="14.00">ds_report_summary</text>
+</g>
+<!-- single_subject_wf_bidssrc&#45;&gt;single_subject_wf_ds_report_summary -->
+<g id="edge5" class="edge">
+<title>single_subject_wf_bidssrc&#45;&gt;single_subject_wf_ds_report_summary</title>
+<path fill="none" stroke="black" d="M2983.37,-2197.58C3054.76,-2190.93 3172.55,-2176.15 3206,-2149 3247.34,-2115.44 3250.35,-2084.28 3236,-2033 3233.11,-2022.65 3227.72,-2012.32 3222.07,-2003.4"/>
+<polygon fill="black" stroke="black" points="3225.06,-2001.57 3216.55,-1995.25 3219.26,-2005.49 3225.06,-2001.57"/>
+</g>
+<!-- single_subject_wf_bidssrc&#45;&gt;single_subject_wf_anat_preproc_wf_inputnode -->
+<g id="edge369" class="edge">
+<title>single_subject_wf_bidssrc&#45;&gt;single_subject_wf_anat_preproc_wf_inputnode</title>
+<path fill="none" stroke="black" d="M2885.32,-2190.02C2815.14,-2165.83 2677.71,-2110.94 2610.87,-2080.79"/>
+<polygon fill="black" stroke="black" points="2612.69,-2077.78 2602.14,-2076.8 2609.78,-2084.15 2612.69,-2077.78"/>
+</g>
+<!-- single_subject_wf_bidssrc&#45;&gt;single_subject_wf_anat_preproc_wf_inputnode -->
+<g id="edge370" class="edge">
+<title>single_subject_wf_bidssrc&#45;&gt;single_subject_wf_anat_preproc_wf_inputnode</title>
+<path fill="none" stroke="black" d="M2889.98,-2188.77C2824.47,-2163.72 2688.82,-2109.25 2618.42,-2079.82"/>
+<polygon fill="black" stroke="black" points="2620.08,-2076.72 2609.5,-2076.08 2617.37,-2083.18 2620.08,-2076.72"/>
+</g>
+<!-- single_subject_wf_bidssrc&#45;&gt;single_subject_wf_anat_preproc_wf_inputnode -->
+<g id="edge371" class="edge">
+<title>single_subject_wf_bidssrc&#45;&gt;single_subject_wf_anat_preproc_wf_inputnode</title>
+<path fill="none" stroke="black" d="M2895.17,-2187.47C2833.81,-2161.53 2699.14,-2107.3 2625.1,-2078.65"/>
+<polygon fill="black" stroke="black" points="2626.63,-2075.49 2616.05,-2075.16 2624.12,-2082.02 2626.63,-2075.49"/>
+</g>
+<!-- single_subject_wf_bidssrc&#45;&gt;single_subject_wf_anat_preproc_wf_inputnode -->
+<g id="edge372" class="edge">
+<title>single_subject_wf_bidssrc&#45;&gt;single_subject_wf_anat_preproc_wf_inputnode</title>
+<path fill="none" stroke="black" d="M2901.46,-2186.4C2844.07,-2159.63 2708.83,-2105.16 2630.75,-2077.28"/>
+<polygon fill="black" stroke="black" points="2632.15,-2074.06 2621.56,-2074.03 2629.82,-2080.66 2632.15,-2074.06"/>
+</g>
+<!-- single_subject_wf_about -->
+<g id="node3" class="node">
+<title>single_subject_wf_about</title>
+<ellipse fill="none" stroke="black" cx="3351" cy="-2203" rx="63.09" ry="18"/>
+<text text-anchor="middle" x="3351" y="-2199.3" font-family="Times,serif" font-size="14.00">about (reports)</text>
+</g>
+<!-- single_subject_wf_about&#45;&gt;single_subject_wf_ds_report_about -->
+<g id="edge7" class="edge">
+<title>single_subject_wf_about&#45;&gt;single_subject_wf_ds_report_about</title>
+<path fill="none" stroke="black" d="M3351,-2184.7C3351,-2177.41 3351,-2168.73 3351,-2160.54"/>
+<polygon fill="black" stroke="black" points="3354.5,-2160.62 3351,-2150.62 3347.5,-2160.62 3354.5,-2160.62"/>
+</g>
+<!-- single_subject_wf_bids_info&#45;&gt;single_subject_wf_summary -->
+<g id="edge8" class="edge">
+<title>single_subject_wf_bids_info&#45;&gt;single_subject_wf_summary</title>
+<path fill="none" stroke="black" d="M3115.14,-2113.05C3120.31,-2105.18 3126.59,-2095.62 3132.39,-2086.79"/>
+<polygon fill="black" stroke="black" points="3135.25,-2088.82 3137.82,-2078.54 3129.4,-2084.98 3135.25,-2088.82"/>
+</g>
+<!-- single_subject_wf_bids_info&#45;&gt;single_subject_wf_anat_preproc_wf_inputnode -->
+<g id="edge373" class="edge">
+<title>single_subject_wf_bids_info&#45;&gt;single_subject_wf_anat_preproc_wf_inputnode</title>
+<path fill="none" stroke="black" d="M3055.09,-2118.27C3046.11,-2116.35 3036.8,-2114.49 3028,-2113 2898.39,-2091 2746.41,-2075.28 2655.28,-2066.92"/>
+<polygon fill="black" stroke="black" points="2655.71,-2063.45 2645.44,-2066.03 2655.08,-2070.42 2655.71,-2063.45"/>
+</g>
+<!-- single_subject_wf_summary&#45;&gt;single_subject_wf_ds_report_summary -->
+<g id="edge9" class="edge">
+<title>single_subject_wf_summary&#45;&gt;single_subject_wf_ds_report_summary</title>
+<path fill="none" stroke="black" d="M3161.03,-2040.82C3167.92,-2030.08 3176.95,-2016.03 3184.77,-2003.84"/>
+<polygon fill="black" stroke="black" points="3187.71,-2005.73 3190.17,-1995.43 3181.82,-2001.95 3187.71,-2005.73"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_fs_isrunning -->
+<g id="node9" class="node">
+<title>single_subject_wf_anat_preproc_wf_fs_isrunning</title>
+<ellipse fill="none" stroke="black" cx="2471" cy="-1976" rx="83.69" ry="18"/>
+<text text-anchor="middle" x="2471" y="-1972.3" font-family="Times,serif" font-size="14.00">fs_isrunning (utility)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_fs_isrunning -->
+<g id="edge10" class="edge">
+<title>single_subject_wf_anat_preproc_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_fs_isrunning</title>
+<path fill="none" stroke="black" d="M2547.88,-2041.8C2531.82,-2030.23 2511.51,-2014.44 2495.72,-2001.35"/>
+<polygon fill="black" stroke="black" points="2498.07,-1998.75 2488.17,-1994.98 2493.55,-2004.1 2498.07,-1998.75"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_fs_isrunning -->
+<g id="edge11" class="edge">
+<title>single_subject_wf_anat_preproc_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_fs_isrunning</title>
+<path fill="none" stroke="black" d="M2558.25,-2041.22C2544.42,-2029.3 2524.08,-2013.15 2506.45,-2000.03"/>
+<polygon fill="black" stroke="black" points="2508.87,-1997.47 2498.74,-1994.38 2504.73,-2003.12 2508.87,-1997.47"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_template_wf_inputnode -->
+<g id="node17" class="node">
+<title>single_subject_wf_anat_preproc_wf_anat_template_wf_inputnode</title>
+<ellipse fill="none" stroke="black" cx="2708" cy="-1976" rx="75.29" ry="18"/>
+<text text-anchor="middle" x="2708" y="-1972.3" font-family="Times,serif" font-size="14.00">inputnode (utility)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_template_wf_inputnode -->
+<g id="edge321" class="edge">
+<title>single_subject_wf_anat_preproc_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_template_wf_inputnode</title>
+<path fill="none" stroke="black" d="M2601.15,-2041.75C2610.04,-2036.42 2619.94,-2030.47 2629,-2025 2642.9,-2016.61 2658.16,-2007.35 2671.53,-1999.22"/>
+<polygon fill="black" stroke="black" points="2673.31,-2002.23 2680.04,-1994.04 2669.67,-1996.25 2673.31,-2002.23"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_inputnode -->
+<g id="node81" class="node">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_inputnode</title>
+<ellipse fill="none" stroke="black" cx="2265" cy="-1893" rx="75.29" ry="18"/>
+<text text-anchor="middle" x="2265" y="-1889.3" font-family="Times,serif" font-size="14.00">inputnode (utility)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_inputnode -->
+<g id="edge325" class="edge">
+<title>single_subject_wf_anat_preproc_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_inputnode</title>
+<path fill="none" stroke="black" d="M2502.91,-2052.72C2449.81,-2047.39 2383.23,-2038.08 2360,-2025 2316.41,-2000.45 2281.71,-1952.4 2267.74,-1921.82"/>
+<polygon fill="black" stroke="black" points="2271.1,-1920.79 2264.12,-1912.82 2264.61,-1923.4 2271.1,-1920.79"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_inputnode -->
+<g id="edge326" class="edge">
+<title>single_subject_wf_anat_preproc_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_inputnode</title>
+<path fill="none" stroke="black" d="M2505.21,-2051.41C2457.73,-2045.92 2399.42,-2037.06 2378,-2025 2333.8,-2000.1 2298.73,-1951.03 2279.99,-1920.53"/>
+<polygon fill="black" stroke="black" points="2283.18,-1919.04 2275.05,-1912.25 2277.17,-1922.63 2283.18,-1919.04"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_inputnode -->
+<g id="edge327" class="edge">
+<title>single_subject_wf_anat_preproc_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_inputnode</title>
+<path fill="none" stroke="black" d="M2508.14,-2049.89C2465.78,-2044.34 2415.54,-2036.01 2396,-2025 2351.18,-1999.75 2315.75,-1949.65 2291.82,-1919.25"/>
+<polygon fill="black" stroke="black" points="2294.71,-1917.27 2285.71,-1911.68 2289.26,-1921.66 2294.71,-1917.27"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_norm_wf_inputnode -->
+<g id="node113" class="node">
+<title>single_subject_wf_anat_preproc_wf_anat_norm_wf_inputnode</title>
+<polygon fill="#d9d9d9" stroke="black" points="1148,-878 1036,-878 1032,-874 1032,-842 1144,-842 1148,-846 1148,-878"/>
+<polyline fill="none" stroke="black" points="1144,-874 1032,-874"/>
+<polyline fill="none" stroke="black" points="1144,-874 1144,-842"/>
+<polyline fill="none" stroke="black" points="1144,-874 1148,-878"/>
+<text text-anchor="middle" x="1090" y="-856.3" font-family="Times,serif" font-size="14.00">inputnode (utility)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_inputnode -->
+<g id="edge322" class="edge">
+<title>single_subject_wf_anat_preproc_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_inputnode</title>
+<path fill="none" stroke="black" d="M2568.56,-2040.76C2565,-2010.88 2565,-1947.53 2565,-1894 2565,-1894 2565,-1894 2565,-1006 2565,-964.66 2571.13,-941.72 2538,-917 2522.47,-905.41 1161.32,-915.32 1143,-909 1129.4,-904.31 1116.47,-895.31 1106.6,-886.37"/>
+<polygon fill="black" stroke="black" points="1109.1,-883.92 1099.54,-879.35 1104.17,-888.88 1109.1,-883.92"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_inputnode -->
+<g id="edge323" class="edge">
+<title>single_subject_wf_anat_preproc_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_inputnode</title>
+<path fill="none" stroke="black" d="M2579.44,-2040.76C2583,-2010.88 2583,-1947.53 2583,-1894 2583,-1894 2583,-1894 2583,-1006 2583,-964.66 2589.13,-941.72 2556,-917 2540.47,-905.41 1179.32,-915.32 1161,-909 1146.99,-904.16 1133.68,-894.76 1122.32,-885.54"/>
+<polygon fill="black" stroke="black" points="1124.72,-882.99 1114.81,-879.26 1120.23,-888.36 1124.72,-882.99"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_reports_wf_inputnode -->
+<g id="node124" class="node">
+<title>single_subject_wf_anat_preproc_wf_anat_reports_wf_inputnode</title>
+<ellipse fill="none" stroke="black" cx="2314" cy="-353" rx="75.29" ry="18"/>
+<text text-anchor="middle" x="2314" y="-349.3" font-family="Times,serif" font-size="14.00">inputnode (utility)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_reports_wf_inputnode -->
+<g id="edge324" class="edge">
+<title>single_subject_wf_anat_preproc_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_reports_wf_inputnode</title>
+<path fill="none" stroke="black" d="M2577.48,-2040.85C2583.21,-2011.09 2594,-1947.92 2594,-1894 2594,-1894 2594,-1894 2594,-1748 2594,-1704.78 2591.05,-1693.06 2601,-1651 2615.18,-1591.08 2654,-1584.57 2654,-1523 2654,-1523 2654,-1523 2654,-499 2654,-389.01 2501.6,-361.31 2400.86,-355"/>
+<polygon fill="black" stroke="black" points="2401.15,-351.52 2390.97,-354.45 2400.76,-358.5 2401.15,-351.52"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_fs_isrunning&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_inputnode -->
+<g id="edge354" class="edge">
+<title>single_subject_wf_anat_preproc_wf_fs_isrunning&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_inputnode</title>
+<path fill="none" stroke="black" d="M2418.62,-1961.57C2384.46,-1952.78 2345.86,-1942.78 2344,-1942 2328.06,-1935.26 2311.53,-1925.68 2297.74,-1916.85"/>
+<polygon fill="black" stroke="black" points="2299.78,-1914 2289.5,-1911.44 2295.93,-1919.85 2299.78,-1914"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_validate -->
+<g id="node10" class="node">
+<title>single_subject_wf_anat_preproc_wf_anat_validate</title>
+<ellipse fill="none" stroke="black" cx="2094" cy="-1976" rx="89.08" ry="18"/>
+<text text-anchor="middle" x="2094" y="-1972.3" font-family="Times,serif" font-size="14.00">anat_validate (header)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_inputnode -->
+<g id="node22" class="node">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_inputnode</title>
+<ellipse fill="none" stroke="black" cx="1876" cy="-4438" rx="75.29" ry="18"/>
+<text text-anchor="middle" x="1876" y="-4434.3" font-family="Times,serif" font-size="14.00">inputnode (utility)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_validate&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_inputnode -->
+<g id="edge332" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_validate&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_inputnode</title>
+<path fill="none" stroke="black" d="M2085.91,-1994C2073.46,-2021.78 2051,-2078.96 2051,-2130 2051,-4295 2051,-4295 2051,-4295 2051,-4358.01 1981.74,-4397.94 1930.37,-4418.89"/>
+<polygon fill="black" stroke="black" points="1929.15,-4415.61 1921.12,-4422.52 1931.7,-4422.13 1929.15,-4415.61"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_validate&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_inputnode -->
+<g id="edge333" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_validate&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_inputnode</title>
+<path fill="none" stroke="black" d="M2140.6,-1960.33C2155.38,-1955.14 2171.6,-1948.87 2186,-1942 2201.38,-1934.66 2217.6,-1925.15 2231.31,-1916.53"/>
+<polygon fill="black" stroke="black" points="2233,-1919.61 2239.53,-1911.27 2229.22,-1913.71 2233,-1919.61"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_applyrefined -->
+<g id="node11" class="node">
+<title>single_subject_wf_anat_preproc_wf_applyrefined</title>
+<ellipse fill="none" stroke="black" cx="1514" cy="-1007" rx="71.49" ry="18"/>
+<text text-anchor="middle" x="1514" y="-1003.3" font-family="Times,serif" font-size="14.00">applyrefined (fsl)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_buffernode -->
+<g id="node12" class="node">
+<title>single_subject_wf_anat_preproc_wf_buffernode</title>
+<ellipse fill="none" stroke="black" cx="939" cy="-935" rx="78.79" ry="18"/>
+<text text-anchor="middle" x="939" y="-931.3" font-family="Times,serif" font-size="14.00">buffernode (utility)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_applyrefined&#45;&gt;single_subject_wf_anat_preproc_wf_buffernode -->
+<g id="edge208" class="edge">
+<title>single_subject_wf_anat_preproc_wf_applyrefined&#45;&gt;single_subject_wf_anat_preproc_wf_buffernode</title>
+<path fill="none" stroke="black" d="M1450.54,-998.27C1344.97,-985.42 1133.5,-959.68 1018.28,-945.65"/>
+<polygon fill="black" stroke="black" points="1018.95,-942.21 1008.6,-944.47 1018.1,-949.16 1018.95,-942.21"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_t1w_dseg -->
+<g id="node13" class="node">
+<title>single_subject_wf_anat_preproc_wf_t1w_dseg</title>
+<ellipse fill="none" stroke="black" cx="1319" cy="-860" rx="61.99" ry="18"/>
+<text text-anchor="middle" x="1319" y="-856.3" font-family="Times,serif" font-size="14.00">t1w_dseg (fsl)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_buffernode&#45;&gt;single_subject_wf_anat_preproc_wf_t1w_dseg -->
+<g id="edge211" class="edge">
+<title>single_subject_wf_anat_preproc_wf_buffernode&#45;&gt;single_subject_wf_anat_preproc_wf_t1w_dseg</title>
+<path fill="none" stroke="black" d="M1016.17,-930.78C1088.05,-927.16 1189.71,-920.25 1228,-909 1248.01,-903.12 1268.7,-892.62 1285.28,-882.93"/>
+<polygon fill="black" stroke="black" points="1286.98,-886 1293.74,-877.84 1283.37,-880 1286.98,-886"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_outputnode -->
+<g id="node16" class="node">
+<title>single_subject_wf_anat_preproc_wf_outputnode</title>
+<ellipse fill="none" stroke="black" cx="1228" cy="-428" rx="79.09" ry="18"/>
+<text text-anchor="middle" x="1228" y="-424.3" font-family="Times,serif" font-size="14.00">outputnode (utility)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_buffernode&#45;&gt;single_subject_wf_anat_preproc_wf_outputnode -->
+<g id="edge209" class="edge">
+<title>single_subject_wf_anat_preproc_wf_buffernode&#45;&gt;single_subject_wf_anat_preproc_wf_outputnode</title>
+<path fill="none" stroke="black" d="M860.94,-932.31C737.56,-929.17 510.38,-921.58 498,-909 460.56,-870.95 493,-842.38 493,-789 493,-789 493,-789 493,-571 493,-526.25 485.25,-502.2 520,-474 566.59,-436.18 956.91,-429.93 1137.32,-429.05"/>
+<polygon fill="black" stroke="black" points="1137.13,-432.55 1147.12,-429.01 1137.1,-425.55 1137.13,-432.55"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_buffernode&#45;&gt;single_subject_wf_anat_preproc_wf_outputnode -->
+<g id="edge210" class="edge">
+<title>single_subject_wf_anat_preproc_wf_buffernode&#45;&gt;single_subject_wf_anat_preproc_wf_outputnode</title>
+<path fill="none" stroke="black" d="M860.84,-932.01C741.86,-928.7 528,-921.2 516,-909 478.56,-870.95 511,-842.38 511,-789 511,-789 511,-789 511,-571 511,-526.25 503.25,-502.2 538,-474 583.73,-436.88 960.61,-430.17 1137.31,-429.1"/>
+<polygon fill="black" stroke="black" points="1137.16,-432.6 1147.14,-429.05 1137.12,-425.6 1137.16,-432.6"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_buffernode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_inputnode -->
+<g id="edge340" class="edge">
+<title>single_subject_wf_anat_preproc_wf_buffernode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_inputnode</title>
+<path fill="none" stroke="black" d="M994.84,-921.87C1006.12,-918.45 1017.68,-914.2 1028,-909 1040.32,-902.8 1052.6,-893.99 1062.94,-885.6"/>
+<polygon fill="black" stroke="black" points="1064.92,-888.51 1070.32,-879.4 1060.42,-883.15 1064.92,-888.51"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_lut_t1w_dseg -->
+<g id="node14" class="node">
+<title>single_subject_wf_anat_preproc_wf_lut_t1w_dseg</title>
+<ellipse fill="none" stroke="black" cx="1319" cy="-788" rx="87.18" ry="18"/>
+<text text-anchor="middle" x="1319" y="-784.3" font-family="Times,serif" font-size="14.00">lut_t1w_dseg (utility)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_t1w_dseg&#45;&gt;single_subject_wf_anat_preproc_wf_lut_t1w_dseg -->
+<g id="edge212" class="edge">
+<title>single_subject_wf_anat_preproc_wf_t1w_dseg&#45;&gt;single_subject_wf_anat_preproc_wf_lut_t1w_dseg</title>
+<path fill="none" stroke="black" d="M1319,-841.7C1319,-834.41 1319,-825.73 1319,-817.54"/>
+<polygon fill="black" stroke="black" points="1322.5,-817.62 1319,-807.62 1315.5,-817.62 1322.5,-817.62"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_fast2bids -->
+<g id="node15" class="node">
+<title>single_subject_wf_anat_preproc_wf_fast2bids</title>
+<ellipse fill="none" stroke="black" cx="1496" cy="-788" rx="71.49" ry="18"/>
+<text text-anchor="middle" x="1496" y="-784.3" font-family="Times,serif" font-size="14.00">fast2bids (utility)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_t1w_dseg&#45;&gt;single_subject_wf_anat_preproc_wf_fast2bids -->
+<g id="edge213" class="edge">
+<title>single_subject_wf_anat_preproc_wf_t1w_dseg&#45;&gt;single_subject_wf_anat_preproc_wf_fast2bids</title>
+<path fill="none" stroke="black" d="M1354.39,-845C1381.35,-834.34 1418.73,-819.56 1448.32,-807.86"/>
+<polygon fill="black" stroke="black" points="1449.42,-811.19 1457.43,-804.25 1446.84,-804.68 1449.42,-811.19"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_lut_t1w_dseg&#45;&gt;single_subject_wf_anat_preproc_wf_outputnode -->
+<g id="edge214" class="edge">
+<title>single_subject_wf_anat_preproc_wf_lut_t1w_dseg&#45;&gt;single_subject_wf_anat_preproc_wf_outputnode</title>
+<path fill="none" stroke="black" d="M1312.32,-769.81C1302.68,-743.4 1286,-691.06 1286,-645 1286,-645 1286,-645 1286,-571 1286,-528.26 1263.2,-483.3 1246.19,-455.7"/>
+<polygon fill="black" stroke="black" points="1249.16,-453.84 1240.83,-447.29 1243.26,-457.6 1249.16,-453.84"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_lut_t1w_dseg&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_inputnode -->
+<g id="edge352" class="edge">
+<title>single_subject_wf_anat_preproc_wf_lut_t1w_dseg&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_inputnode</title>
+<path fill="none" stroke="black" d="M1263.22,-802.25C1230.52,-810.45 1188.59,-821.74 1152,-834 1148.59,-835.14 1145.09,-836.38 1141.59,-837.66"/>
+<polygon fill="black" stroke="black" points="1140.63,-834.28 1132.51,-841.09 1143.1,-840.83 1140.63,-834.28"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_fast2bids&#45;&gt;single_subject_wf_anat_preproc_wf_outputnode -->
+<g id="edge215" class="edge">
+<title>single_subject_wf_anat_preproc_wf_fast2bids&#45;&gt;single_subject_wf_anat_preproc_wf_outputnode</title>
+<path fill="none" stroke="black" d="M1470.87,-770.85C1437.84,-747.45 1384,-700.73 1384,-645 1384,-645 1384,-645 1384,-571 1384,-512.22 1322.68,-471.33 1276.93,-449"/>
+<polygon fill="black" stroke="black" points="1278.47,-445.86 1267.93,-444.77 1275.49,-452.19 1278.47,-445.86"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_fast2bids&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_inputnode -->
+<g id="edge353" class="edge">
+<title>single_subject_wf_anat_preproc_wf_fast2bids&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_inputnode</title>
+<path fill="none" stroke="black" d="M1443.86,-800.75C1434.29,-802.68 1424.37,-804.52 1415,-806 1298.89,-824.32 1266.05,-805.52 1152,-834 1147.75,-835.06 1143.41,-836.35 1139.09,-837.78"/>
+<polygon fill="black" stroke="black" points="1138.14,-834.4 1129.9,-841.07 1140.5,-841 1138.14,-834.4"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_reports_wf_inputnode -->
+<g id="edge308" class="edge">
+<title>single_subject_wf_anat_preproc_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_reports_wf_inputnode</title>
+<path fill="none" stroke="black" d="M1304.43,-423.07C1389.85,-419.59 1529.47,-414.4 1651,-410 1751.44,-406.36 1776.79,-409.76 1877,-402 2000.56,-392.43 2144.66,-373.2 2233.88,-362.2"/>
+<polygon fill="black" stroke="black" points="2234.29,-365.68 2243.79,-360.99 2233.44,-358.73 2234.29,-365.68"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_reports_wf_inputnode -->
+<g id="edge309" class="edge">
+<title>single_subject_wf_anat_preproc_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_reports_wf_inputnode</title>
+<path fill="none" stroke="black" d="M1305.01,-423.6C1393.15,-420.14 1541.1,-414.63 1669,-410 1769.44,-406.36 1794.79,-409.76 1895,-402 2014.13,-392.78 2152.35,-374.56 2236.77,-363.41"/>
+<polygon fill="black" stroke="black" points="2237.1,-366.9 2246.56,-362.12 2236.19,-359.96 2237.1,-366.9"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_reports_wf_inputnode -->
+<g id="edge310" class="edge">
+<title>single_subject_wf_anat_preproc_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_reports_wf_inputnode</title>
+<path fill="none" stroke="black" d="M1305.56,-424.09C1396.82,-420.67 1552.92,-414.86 1687,-410 1787.44,-406.36 1812.79,-409.76 1913,-402 2027.5,-393.14 2159.64,-375.96 2239.98,-364.75"/>
+<polygon fill="black" stroke="black" points="2240.04,-368.27 2249.46,-363.41 2239.07,-361.34 2240.04,-368.27"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_reports_wf_inputnode -->
+<g id="edge311" class="edge">
+<title>single_subject_wf_anat_preproc_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_reports_wf_inputnode</title>
+<path fill="none" stroke="black" d="M1305.92,-424.53C1400.86,-421.19 1564.95,-415.07 1705,-410 1805.44,-406.36 1830.79,-409.76 1931,-402 2040.94,-393.49 2167.13,-377.32 2243.95,-366.11"/>
+<polygon fill="black" stroke="black" points="2244.04,-369.64 2253.42,-364.72 2243.02,-362.71 2244.04,-369.64"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_reports_wf_inputnode -->
+<g id="edge312" class="edge">
+<title>single_subject_wf_anat_preproc_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_reports_wf_inputnode</title>
+<path fill="none" stroke="black" d="M1306.37,-424.92C1405.75,-421.68 1577.37,-415.27 1723,-410 1823.44,-406.36 1848.79,-409.76 1949,-402 2054.56,-393.83 2175.1,-378.6 2248.84,-367.48"/>
+<polygon fill="black" stroke="black" points="2248.97,-371 2258.32,-366.03 2247.91,-364.08 2248.97,-371"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode -->
+<g id="node135" class="node">
+<title>single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode</title>
+<ellipse fill="none" stroke="black" cx="1179" cy="-353" rx="75.29" ry="18"/>
+<text text-anchor="middle" x="1179" y="-349.3" font-family="Times,serif" font-size="14.00">inputnode (utility)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode -->
+<g id="edge313" class="edge">
+<title>single_subject_wf_anat_preproc_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode</title>
+<path fill="none" stroke="black" d="M1180.9,-413.27C1166.17,-404.23 1155.37,-392.09 1151.38,-381.15"/>
+<polygon fill="black" stroke="black" points="1154.88,-380.9 1150.07,-371.46 1147.94,-381.84 1154.88,-380.9"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode -->
+<g id="edge314" class="edge">
+<title>single_subject_wf_anat_preproc_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode</title>
+<path fill="none" stroke="black" d="M1189.88,-411.87C1178.71,-403.2 1169.57,-392.03 1164.79,-381.82"/>
+<polygon fill="black" stroke="black" points="1168.14,-380.83 1161.81,-372.34 1161.47,-382.93 1168.14,-380.83"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode -->
+<g id="edge315" class="edge">
+<title>single_subject_wf_anat_preproc_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode</title>
+<path fill="none" stroke="black" d="M1199.97,-410.8C1191.28,-402.22 1183.21,-391.46 1177.83,-381.61"/>
+<polygon fill="black" stroke="black" points="1181.13,-380.42 1173.77,-372.81 1174.78,-383.35 1181.13,-380.42"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode -->
+<g id="edge316" class="edge">
+<title>single_subject_wf_anat_preproc_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode</title>
+<path fill="none" stroke="black" d="M1210.83,-410.07C1204.11,-401.44 1196.69,-390.74 1190.59,-381.01"/>
+<polygon fill="black" stroke="black" points="1193.72,-379.42 1185.58,-372.64 1187.71,-383.02 1193.72,-379.42"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode -->
+<g id="edge317" class="edge">
+<title>single_subject_wf_anat_preproc_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode</title>
+<path fill="none" stroke="black" d="M1222.23,-409.7C1217.19,-400.82 1210.03,-389.81 1202.9,-379.94"/>
+<polygon fill="black" stroke="black" points="1205.86,-378.05 1197.07,-372.14 1200.25,-382.24 1205.86,-378.05"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode -->
+<g id="edge318" class="edge">
+<title>single_subject_wf_anat_preproc_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode</title>
+<path fill="none" stroke="black" d="M1233.91,-409.7C1230.57,-400.35 1223.27,-388.64 1214.58,-378.37"/>
+<polygon fill="black" stroke="black" points="1217.39,-376.26 1208.04,-371.29 1212.25,-381.01 1217.39,-376.26"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode -->
+<g id="edge319" class="edge">
+<title>single_subject_wf_anat_preproc_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode</title>
+<path fill="none" stroke="black" d="M1245.64,-410.07C1244.3,-400.04 1236.48,-387.2 1225.39,-376.35"/>
+<polygon fill="black" stroke="black" points="1227.76,-373.77 1217.92,-369.85 1223.17,-379.06 1227.76,-373.77"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode -->
+<g id="edge320" class="edge">
+<title>single_subject_wf_anat_preproc_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode</title>
+<path fill="none" stroke="black" d="M1257.17,-410.8C1258.52,-399.91 1249.7,-385.5 1234.98,-373.91"/>
+<polygon fill="black" stroke="black" points="1237.12,-371.14 1226.91,-368.33 1233.14,-376.9 1237.12,-371.14"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_template_wf_t1w_ref_dimensions -->
+<g id="node18" class="node">
+<title>single_subject_wf_anat_preproc_wf_anat_template_wf_t1w_ref_dimensions</title>
+<ellipse fill="none" stroke="black" cx="2729" cy="-1893" rx="116.18" ry="18"/>
+<text text-anchor="middle" x="2729" y="-1889.3" font-family="Times,serif" font-size="14.00">t1w_ref_dimensions (images)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_template_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_template_wf_t1w_ref_dimensions -->
+<g id="edge12" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_template_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_template_wf_t1w_ref_dimensions</title>
+<path fill="none" stroke="black" d="M2712.45,-1957.82C2715.11,-1947.58 2718.55,-1934.33 2721.6,-1922.55"/>
+<polygon fill="black" stroke="black" points="2724.98,-1923.46 2724.1,-1912.9 2718.2,-1921.7 2724.98,-1923.46"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_template_wf_t1w_conform -->
+<g id="node19" class="node">
+<title>single_subject_wf_anat_preproc_wf_anat_template_wf_t1w_conform</title>
+<ellipse fill="none" stroke="black" cx="2705" cy="-1821" rx="92.08" ry="18"/>
+<text text-anchor="middle" x="2705" y="-1817.3" font-family="Times,serif" font-size="14.00">t1w_conform (images)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_template_wf_t1w_ref_dimensions&#45;&gt;single_subject_wf_anat_preproc_wf_anat_template_wf_t1w_conform -->
+<g id="edge13" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_template_wf_t1w_ref_dimensions&#45;&gt;single_subject_wf_anat_preproc_wf_anat_template_wf_t1w_conform</title>
+<path fill="none" stroke="black" d="M2711.43,-1875.05C2707.34,-1867.68 2703.8,-1858.84 2701.48,-1850.51"/>
+<polygon fill="black" stroke="black" points="2704.91,-1849.81 2699.41,-1840.76 2698.07,-1851.26 2704.91,-1849.81"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_template_wf_t1w_ref_dimensions&#45;&gt;single_subject_wf_anat_preproc_wf_anat_template_wf_t1w_conform -->
+<g id="edge14" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_template_wf_t1w_ref_dimensions&#45;&gt;single_subject_wf_anat_preproc_wf_anat_template_wf_t1w_conform</title>
+<path fill="none" stroke="black" d="M2723.07,-1874.7C2720.51,-1867.24 2717.45,-1858.32 2714.59,-1849.97"/>
+<polygon fill="black" stroke="black" points="2717.91,-1848.86 2711.36,-1840.54 2711.29,-1851.13 2717.91,-1848.86"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_template_wf_t1w_ref_dimensions&#45;&gt;single_subject_wf_anat_preproc_wf_anat_template_wf_t1w_conform -->
+<g id="edge15" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_template_wf_t1w_ref_dimensions&#45;&gt;single_subject_wf_anat_preproc_wf_anat_template_wf_t1w_conform</title>
+<path fill="none" stroke="black" d="M2734.9,-1874.7C2733.86,-1867.07 2731.18,-1857.92 2727.61,-1849.4"/>
+<polygon fill="black" stroke="black" points="2730.8,-1847.96 2723.31,-1840.47 2724.49,-1851 2730.8,-1847.96"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_template_wf_outputnode -->
+<g id="node21" class="node">
+<title>single_subject_wf_anat_preproc_wf_anat_template_wf_outputnode</title>
+<ellipse fill="none" stroke="black" cx="2692" cy="-1677" rx="79.09" ry="18"/>
+<text text-anchor="middle" x="2692" y="-1673.3" font-family="Times,serif" font-size="14.00">outputnode (utility)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_template_wf_t1w_ref_dimensions&#45;&gt;single_subject_wf_anat_preproc_wf_anat_template_wf_outputnode -->
+<g id="edge16" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_template_wf_t1w_ref_dimensions&#45;&gt;single_subject_wf_anat_preproc_wf_anat_template_wf_outputnode</title>
+<path fill="none" stroke="black" d="M2759.18,-1875.37C2773.31,-1866.81 2788.69,-1854.8 2797,-1839 2804.44,-1824.84 2800.76,-1818.55 2797,-1803 2788.54,-1768.03 2783.76,-1758.02 2760,-1731 2749.85,-1719.46 2736.68,-1709.21 2724.56,-1700.87"/>
+<polygon fill="black" stroke="black" points="2726.67,-1698.07 2716.4,-1695.44 2722.79,-1703.89 2726.67,-1698.07"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_template_wf_t1w_ref_dimensions&#45;&gt;single_subject_wf_anat_preproc_wf_anat_template_wf_outputnode -->
+<g id="edge17" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_template_wf_t1w_ref_dimensions&#45;&gt;single_subject_wf_anat_preproc_wf_anat_template_wf_outputnode</title>
+<path fill="none" stroke="black" d="M2774.48,-1876.06C2790.46,-1867.46 2806.47,-1855.23 2815,-1839 2822.44,-1824.84 2818.76,-1818.55 2815,-1803 2806.54,-1768.03 2801.76,-1758.02 2778,-1731 2767.03,-1718.52 2752.52,-1707.55 2738.48,-1698.87"/>
+<polygon fill="black" stroke="black" points="2740.58,-1696.05 2730.19,-1694.01 2737.04,-1702.09 2740.58,-1696.05"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_template_wf_get1st -->
+<g id="node20" class="node">
+<title>single_subject_wf_anat_preproc_wf_anat_template_wf_get1st</title>
+<ellipse fill="none" stroke="black" cx="2699" cy="-1749" rx="61.19" ry="18"/>
+<text text-anchor="middle" x="2699" y="-1745.3" font-family="Times,serif" font-size="14.00">get1st (utility)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_template_wf_t1w_conform&#45;&gt;single_subject_wf_anat_preproc_wf_anat_template_wf_get1st -->
+<g id="edge18" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_template_wf_t1w_conform&#45;&gt;single_subject_wf_anat_preproc_wf_anat_template_wf_get1st</title>
+<path fill="none" stroke="black" d="M2703.52,-1802.7C2702.89,-1795.41 2702.15,-1786.73 2701.45,-1778.54"/>
+<polygon fill="black" stroke="black" points="2704.94,-1778.28 2700.6,-1768.61 2697.96,-1778.87 2704.94,-1778.28"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_template_wf_get1st&#45;&gt;single_subject_wf_anat_preproc_wf_anat_template_wf_outputnode -->
+<g id="edge19" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_template_wf_get1st&#45;&gt;single_subject_wf_anat_preproc_wf_anat_template_wf_outputnode</title>
+<path fill="none" stroke="black" d="M2697.27,-1730.7C2696.54,-1723.41 2695.67,-1714.73 2694.85,-1706.54"/>
+<polygon fill="black" stroke="black" points="2698.34,-1706.21 2693.86,-1696.61 2691.37,-1706.91 2698.34,-1706.21"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_template_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_validate -->
+<g id="edge328" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_template_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_validate</title>
+<path fill="none" stroke="black" d="M2627.9,-1687.95C2608.39,-1690.64 2586.86,-1693.29 2567,-1695 2512.94,-1699.66 1628.65,-1691.93 1591,-1731 1558.46,-1764.76 1558.17,-1908.52 1591,-1942 1598.98,-1950.13 1989.72,-1948.4 2001,-1950 2012.79,-1951.67 2025.22,-1954.35 2037.02,-1957.35"/>
+<polygon fill="black" stroke="black" points="2036.07,-1960.72 2046.64,-1959.9 2037.87,-1953.95 2036.07,-1960.72"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_template_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_outputnode -->
+<g id="edge329" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_template_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_outputnode</title>
+<path fill="none" stroke="black" d="M2637.3,-1663.82C2626.45,-1659.02 2616.21,-1652.32 2609,-1643 2576.12,-1600.49 2594,-1576.75 2594,-1523 2594,-1523 2594,-1523 2594,-571 2594,-526.25 2602.17,-501.66 2567,-474 2518.01,-435.47 1612.01,-429.91 1318.76,-429.13"/>
+<polygon fill="black" stroke="black" points="1318.86,-425.63 1308.85,-429.1 1318.84,-432.63 1318.86,-425.63"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_template_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_reports_wf_inputnode -->
+<g id="edge330" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_template_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_reports_wf_inputnode</title>
+<path fill="none" stroke="black" d="M2650.29,-1661.44C2642.07,-1656.75 2634.35,-1650.71 2629,-1643 2598.37,-1598.83 2614,-1576.75 2614,-1523 2614,-1523 2614,-1523 2614,-499 2614,-402.57 2486.8,-370.24 2398.06,-359.42"/>
+<polygon fill="black" stroke="black" points="2398.46,-355.94 2388.13,-358.29 2397.67,-362.9 2398.46,-355.94"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_template_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode -->
+<g id="edge331" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_template_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode</title>
+<path fill="none" stroke="black" d="M2680.82,-1658.9C2663.96,-1631.44 2634,-1575.27 2634,-1523 2634,-1523 2634,-1523 2634,-499 2634,-487.67 2637.46,-481.54 2629,-474 2603.27,-451.07 1566.88,-379.98 1262.33,-359.54"/>
+<polygon fill="black" stroke="black" points="1262.67,-356.06 1252.46,-358.88 1262.2,-363.04 1262.67,-356.06"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_truncate_images -->
+<g id="node26" class="node">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_truncate_images</title>
+<ellipse fill="none" stroke="black" cx="1838" cy="-4366" rx="90.98" ry="18"/>
+<text text-anchor="middle" x="1838" y="-4362.3" font-family="Times,serif" font-size="14.00">truncate_images (ants)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_truncate_images -->
+<g id="edge20" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_truncate_images</title>
+<path fill="none" stroke="black" d="M1866.61,-4419.7C1862.42,-4411.98 1857.39,-4402.71 1852.72,-4394.11"/>
+<polygon fill="black" stroke="black" points="1855.85,-4392.55 1848.01,-4385.43 1849.7,-4395.89 1855.85,-4392.55"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_init_aff -->
+<g id="node31" class="node">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_init_aff</title>
+<ellipse fill="none" stroke="black" cx="1523" cy="-4150" rx="59.29" ry="18"/>
+<text text-anchor="middle" x="1523" y="-4146.3" font-family="Times,serif" font-size="14.00">init_aff (ants)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_init_aff -->
+<g id="edge22" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_init_aff</title>
+<path fill="none" stroke="black" d="M1806.79,-4430.63C1701.27,-4416.76 1503.36,-4373.39 1417,-4240 1408.3,-4226.57 1408.59,-4217.61 1417,-4204 1428.13,-4185.98 1447.45,-4173.89 1466.57,-4165.86"/>
+<polygon fill="black" stroke="black" points="1467.63,-4169.21 1475.71,-4162.35 1465.12,-4162.67 1467.63,-4169.21"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_norm -->
+<g id="node33" class="node">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_norm</title>
+<ellipse fill="none" stroke="black" cx="1545" cy="-4078" rx="54.69" ry="18"/>
+<text text-anchor="middle" x="1545" y="-4074.3" font-family="Times,serif" font-size="14.00">norm (fixes)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_norm -->
+<g id="edge23" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_norm</title>
+<path fill="none" stroke="black" d="M1903.16,-4420.73C1915.92,-4411.6 1930.04,-4399.01 1938,-4384 1956.65,-4348.84 1948,-4334.8 1948,-4295 1948,-4295 1948,-4295 1948,-4221 1948,-4180.55 1958.83,-4159.32 1929,-4132 1880.79,-4087.84 1701.62,-4105.94 1637,-4096 1625.68,-4094.26 1613.62,-4092.19 1602.08,-4090.1"/>
+<polygon fill="black" stroke="black" points="1602.72,-4086.66 1592.26,-4088.29 1601.46,-4093.54 1602.72,-4086.66"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_map_brainmask -->
+<g id="node34" class="node">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_map_brainmask</title>
+<ellipse fill="none" stroke="black" cx="1517" cy="-4006" rx="92.88" ry="18"/>
+<text text-anchor="middle" x="1517" y="-4002.3" font-family="Times,serif" font-size="14.00">map_brainmask (fixes)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_map_brainmask -->
+<g id="edge24" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_map_brainmask</title>
+<path fill="none" stroke="black" d="M1800.74,-4435.93C1632.18,-4431.5 1239,-4408.94 1239,-4295 1239,-4295 1239,-4295 1239,-4149 1239,-4064.37 1342.44,-4030.15 1423.12,-4016.33"/>
+<polygon fill="black" stroke="black" points="1423.54,-4019.81 1432.85,-4014.76 1422.42,-4012.9 1423.54,-4019.81"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_map_wmmask -->
+<g id="node35" class="node">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_map_wmmask</title>
+<ellipse fill="none" stroke="black" cx="1716" cy="-4006" rx="88.28" ry="18"/>
+<text text-anchor="middle" x="1716" y="-4002.3" font-family="Times,serif" font-size="14.00">map_wmmask (fixes)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_map_wmmask -->
+<g id="edge25" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_map_wmmask</title>
+<path fill="none" stroke="black" d="M1907.24,-4421.36C1922.07,-4412.39 1938.75,-4399.76 1949,-4384 1971.05,-4350.09 1968,-4335.45 1968,-4295 1968,-4295 1968,-4295 1968,-4149 1968,-4070.07 1873,-4034.53 1799.66,-4018.86"/>
+<polygon fill="black" stroke="black" points="1800.53,-4015.46 1790.03,-4016.9 1799.14,-4022.32 1800.53,-4015.46"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_inu_n4_final -->
+<g id="node37" class="node">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_inu_n4_final</title>
+<ellipse fill="none" stroke="black" cx="1706" cy="-3934" rx="77.19" ry="18"/>
+<text text-anchor="middle" x="1706" y="-3930.3" font-family="Times,serif" font-size="14.00">inu_n4_final (ants)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_inu_n4_final -->
+<g id="edge21" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_inu_n4_final</title>
+<path fill="none" stroke="black" d="M1802.23,-4433.99C1652.46,-4427.37 1323.11,-4410.03 1279,-4384 1237.91,-4359.76 1219,-4342.7 1219,-4295 1219,-4295 1219,-4295 1219,-4077 1219,-4059.31 1238.93,-4067.41 1255,-4060 1325.81,-4027.35 1340.54,-4011.16 1415,-3988 1420.29,-3986.36 1550.58,-3962.86 1635.01,-3947.71"/>
+<polygon fill="black" stroke="black" points="1635.38,-3951.2 1644.6,-3945.99 1634.14,-3944.31 1635.38,-3951.2"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_inputnode -->
+<g id="node40" class="node">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_inputnode</title>
+<ellipse fill="none" stroke="black" cx="1872" cy="-3859" rx="75.29" ry="18"/>
+<text text-anchor="middle" x="1872" y="-3855.3" font-family="Times,serif" font-size="14.00">inputnode (utility)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_inputnode -->
+<g id="edge113" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_inputnode</title>
+<path fill="none" stroke="black" d="M1913.16,-4422.12C1930.59,-4413.4 1950.28,-4400.77 1963,-4384 1987.82,-4351.26 1988,-4336.09 1988,-4295 1988,-4295 1988,-4295 1988,-4005 1988,-3952.55 1941.14,-3908.2 1906.99,-3882.84"/>
+<polygon fill="black" stroke="black" points="1909.14,-3880.07 1898.97,-3877.08 1905.05,-3885.76 1909.14,-3880.07"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_res_tmpl -->
+<g id="node23" class="node">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_res_tmpl</title>
+<ellipse fill="none" stroke="black" cx="1502" cy="-4222" rx="76.09" ry="18"/>
+<text text-anchor="middle" x="1502" y="-4218.3" font-family="Times,serif" font-size="14.00">res_tmpl (nibabel)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_res_tmpl&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_init_aff -->
+<g id="edge26" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_res_tmpl&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_init_aff</title>
+<path fill="none" stroke="black" d="M1507.19,-4203.7C1509.43,-4196.24 1512.1,-4187.32 1514.61,-4178.97"/>
+<polygon fill="black" stroke="black" points="1517.91,-4180.14 1517.43,-4169.55 1511.21,-4178.13 1517.91,-4180.14"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_full_wm -->
+<g id="node24" class="node">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_full_wm</title>
+<ellipse fill="none" stroke="black" cx="1716" cy="-4078" rx="70.39" ry="18"/>
+<text text-anchor="middle" x="1716" y="-4074.3" font-family="Times,serif" font-size="14.00">full_wm (utility)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_full_wm&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_map_wmmask -->
+<g id="edge27" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_full_wm&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_map_wmmask</title>
+<path fill="none" stroke="black" d="M1716,-4059.7C1716,-4052.41 1716,-4043.73 1716,-4035.54"/>
+<polygon fill="black" stroke="black" points="1719.5,-4035.62 1716,-4025.62 1712.5,-4035.62 1719.5,-4035.62"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_lap_tmpl -->
+<g id="node25" class="node">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_lap_tmpl</title>
+<ellipse fill="none" stroke="black" cx="1323" cy="-4222" rx="64.99" ry="18"/>
+<text text-anchor="middle" x="1323" y="-4218.3" font-family="Times,serif" font-size="14.00">lap_tmpl (ants)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_mrg_tmpl -->
+<g id="node27" class="node">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_mrg_tmpl</title>
+<ellipse fill="none" stroke="black" cx="1362" cy="-4150" rx="75.29" ry="18"/>
+<text text-anchor="middle" x="1362" y="-4146.3" font-family="Times,serif" font-size="14.00">mrg_tmpl (utility)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_lap_tmpl&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_mrg_tmpl -->
+<g id="edge28" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_lap_tmpl&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_mrg_tmpl</title>
+<path fill="none" stroke="black" d="M1332.44,-4204.05C1336.78,-4196.26 1342.04,-4186.82 1346.91,-4178.08"/>
+<polygon fill="black" stroke="black" points="1349.83,-4180.04 1351.64,-4169.6 1343.71,-4176.63 1349.83,-4180.04"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_inu_n4 -->
+<g id="node28" class="node">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_inu_n4</title>
+<ellipse fill="none" stroke="black" cx="1839" cy="-4294" rx="57.69" ry="18"/>
+<text text-anchor="middle" x="1839" y="-4290.3" font-family="Times,serif" font-size="14.00">inu_n4 (ants)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_truncate_images&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_inu_n4 -->
+<g id="edge29" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_truncate_images&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_inu_n4</title>
+<path fill="none" stroke="black" d="M1838.25,-4347.7C1838.35,-4340.41 1838.48,-4331.73 1838.59,-4323.54"/>
+<polygon fill="black" stroke="black" points="1842.09,-4323.67 1838.73,-4313.62 1835.09,-4323.57 1842.09,-4323.67"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_mrg_tmpl&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_norm -->
+<g id="edge30" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_mrg_tmpl&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_norm</title>
+<path fill="none" stroke="black" d="M1400.81,-4134.15C1429.68,-4123.11 1469.18,-4108 1499.53,-4096.39"/>
+<polygon fill="black" stroke="black" points="1500.76,-4099.67 1508.85,-4092.83 1498.26,-4093.13 1500.76,-4099.67"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_res_target -->
+<g id="node29" class="node">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_res_target</title>
+<ellipse fill="none" stroke="black" cx="1675" cy="-4222" rx="79.09" ry="18"/>
+<text text-anchor="middle" x="1675" y="-4218.3" font-family="Times,serif" font-size="14.00">res_target (nibabel)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_inu_n4&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_res_target -->
+<g id="edge31" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_inu_n4&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_res_target</title>
+<path fill="none" stroke="black" d="M1805.81,-4278.83C1781.52,-4268.47 1748.24,-4254.26 1721.33,-4242.77"/>
+<polygon fill="black" stroke="black" points="1722.95,-4239.66 1712.38,-4238.95 1720.2,-4246.1 1722.95,-4239.66"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_lap_target -->
+<g id="node30" class="node">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_lap_target</title>
+<ellipse fill="none" stroke="black" cx="1841" cy="-4222" rx="68.49" ry="18"/>
+<text text-anchor="middle" x="1841" y="-4218.3" font-family="Times,serif" font-size="14.00">lap_target (ants)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_inu_n4&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_lap_target -->
+<g id="edge32" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_inu_n4&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_lap_target</title>
+<path fill="none" stroke="black" d="M1839.49,-4275.7C1839.7,-4268.41 1839.95,-4259.73 1840.18,-4251.54"/>
+<polygon fill="black" stroke="black" points="1843.68,-4251.71 1840.47,-4241.62 1836.68,-4251.51 1843.68,-4251.71"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_mrg_target -->
+<g id="node32" class="node">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_mrg_target</title>
+<ellipse fill="none" stroke="black" cx="1841" cy="-4150" rx="79.09" ry="18"/>
+<text text-anchor="middle" x="1841" y="-4146.3" font-family="Times,serif" font-size="14.00">mrg_target (utility)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_inu_n4&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_mrg_target -->
+<g id="edge33" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_inu_n4&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_mrg_target</title>
+<path fill="none" stroke="black" d="M1873.48,-4279.25C1890.13,-4270.65 1908.52,-4257.78 1918,-4240 1925.53,-4225.88 1925.44,-4218.16 1918,-4204 1911.02,-4190.72 1899.04,-4180.12 1886.58,-4172"/>
+<polygon fill="black" stroke="black" points="1888.71,-4169.19 1878.34,-4167.04 1885.11,-4175.19 1888.71,-4169.19"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_res_target&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_init_aff -->
+<g id="edge34" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_res_target&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_init_aff</title>
+<path fill="none" stroke="black" d="M1640.89,-4205.29C1618.4,-4194.93 1588.78,-4181.3 1564.87,-4170.28"/>
+<polygon fill="black" stroke="black" points="1566.59,-4167.22 1556.04,-4166.22 1563.66,-4173.58 1566.59,-4167.22"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_lap_target&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_mrg_target -->
+<g id="edge35" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_lap_target&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_mrg_target</title>
+<path fill="none" stroke="black" d="M1841,-4203.7C1841,-4196.41 1841,-4187.73 1841,-4179.54"/>
+<polygon fill="black" stroke="black" points="1844.5,-4179.62 1841,-4169.62 1837.5,-4179.62 1844.5,-4179.62"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_init_aff&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_norm -->
+<g id="edge36" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_init_aff&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_norm</title>
+<path fill="none" stroke="black" d="M1528.44,-4131.7C1530.78,-4124.24 1533.58,-4115.32 1536.21,-4106.97"/>
+<polygon fill="black" stroke="black" points="1539.51,-4108.14 1539.17,-4097.55 1532.83,-4106.04 1539.51,-4108.14"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_mrg_target&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_norm -->
+<g id="edge37" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_mrg_target&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_norm</title>
+<path fill="none" stroke="black" d="M1787.74,-4136.4C1734.44,-4123.8 1652.86,-4104.51 1599.22,-4091.82"/>
+<polygon fill="black" stroke="black" points="1600.23,-4088.46 1589.69,-4089.57 1598.62,-4095.28 1600.23,-4088.46"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_norm&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_map_brainmask -->
+<g id="edge38" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_norm&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_map_brainmask</title>
+<path fill="none" stroke="black" d="M1532.34,-4060.05C1528.53,-4052.52 1524.65,-4043.44 1521.55,-4034.94"/>
+<polygon fill="black" stroke="black" points="1524.96,-4034.09 1518.48,-4025.71 1518.32,-4036.3 1524.96,-4034.09"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_norm&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_map_brainmask -->
+<g id="edge39" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_norm&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_map_brainmask</title>
+<path fill="none" stroke="black" d="M1543.99,-4059.7C1541.73,-4052.07 1538.3,-4042.92 1534.56,-4034.4"/>
+<polygon fill="black" stroke="black" points="1537.8,-4033.04 1530.38,-4025.47 1531.46,-4036.01 1537.8,-4033.04"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_norm&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_map_wmmask -->
+<g id="edge40" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_norm&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_map_wmmask</title>
+<path fill="none" stroke="black" d="M1574.84,-4062.5C1599.19,-4051.97 1634.04,-4037.64 1663.07,-4026.17"/>
+<polygon fill="black" stroke="black" points="1664.03,-4029.55 1672.06,-4022.64 1661.47,-4023.04 1664.03,-4029.55"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_norm&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_map_wmmask -->
+<g id="edge41" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_norm&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_map_wmmask</title>
+<path fill="none" stroke="black" d="M1581.31,-4064.32C1607.92,-4054.05 1644.05,-4039.38 1672.25,-4027.45"/>
+<polygon fill="black" stroke="black" points="1673.41,-4030.76 1681.23,-4023.62 1670.66,-4024.32 1673.41,-4030.76"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_thr_brainmask -->
+<g id="node36" class="node">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_thr_brainmask</title>
+<ellipse fill="none" stroke="black" cx="1517" cy="-3934" rx="84.49" ry="18"/>
+<text text-anchor="middle" x="1517" y="-3930.3" font-family="Times,serif" font-size="14.00">thr_brainmask (ants)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_map_brainmask&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_thr_brainmask -->
+<g id="edge42" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_map_brainmask&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_thr_brainmask</title>
+<path fill="none" stroke="black" d="M1517,-3987.7C1517,-3980.41 1517,-3971.73 1517,-3963.54"/>
+<polygon fill="black" stroke="black" points="1520.5,-3963.62 1517,-3953.62 1513.5,-3963.62 1520.5,-3963.62"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_map_wmmask&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_inu_n4_final -->
+<g id="edge43" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_map_wmmask&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_inu_n4_final</title>
+<path fill="none" stroke="black" d="M1713.53,-3987.7C1712.47,-3980.32 1711.22,-3971.52 1710.04,-3963.25"/>
+<polygon fill="black" stroke="black" points="1713.54,-3963.01 1708.66,-3953.6 1706.61,-3964 1713.54,-3963.01"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_map_wmmask&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_inputnode -->
+<g id="edge116" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_map_wmmask&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_inputnode</title>
+<path fill="none" stroke="black" d="M1742.87,-3988.59C1757.98,-3978.8 1776.8,-3965.65 1792,-3952 1814.6,-3931.7 1837,-3905.24 1852.32,-3885.92"/>
+<polygon fill="black" stroke="black" points="1854.91,-3888.29 1858.32,-3878.25 1849.4,-3883.98 1854.91,-3888.29"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_apply_mask -->
+<g id="node38" class="node">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_apply_mask</title>
+<ellipse fill="none" stroke="black" cx="1165" cy="-3859" rx="87.99" ry="18"/>
+<text text-anchor="middle" x="1165" y="-3855.3" font-family="Times,serif" font-size="14.00">apply_mask (nibabel)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_thr_brainmask&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_apply_mask -->
+<g id="edge44" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_thr_brainmask&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_apply_mask</title>
+<path fill="none" stroke="black" d="M1432.3,-3933.02C1380.7,-3931.04 1313.95,-3924.89 1257,-3908 1237.26,-3902.14 1216.81,-3891.95 1200.22,-3882.46"/>
+<polygon fill="black" stroke="black" points="1202.12,-3879.52 1191.73,-3877.46 1198.57,-3885.55 1202.12,-3879.52"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_thr_brainmask&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_inputnode -->
+<g id="edge115" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_thr_brainmask&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_inputnode</title>
+<path fill="none" stroke="black" d="M1579.48,-3921.48C1592.81,-3919.36 1606.84,-3917.39 1620,-3916 1658.27,-3911.97 1756.19,-3919.23 1793,-3908 1810.46,-3902.67 1828,-3892.6 1842.1,-3883.06"/>
+<polygon fill="black" stroke="black" points="1843.88,-3886.09 1850.04,-3877.47 1839.85,-3880.37 1843.88,-3886.09"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_inu_n4_final&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_apply_mask -->
+<g id="edge45" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_inu_n4_final&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_apply_mask</title>
+<path fill="none" stroke="black" d="M1649.09,-3921.45C1636.28,-3919.26 1622.72,-3917.26 1610,-3916 1570.96,-3912.12 1295,-3917.77 1257,-3908 1236.77,-3902.8 1216,-3892.46 1199.32,-3882.71"/>
+<polygon fill="black" stroke="black" points="1201.17,-3879.74 1190.8,-3877.55 1197.54,-3885.72 1201.17,-3879.74"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_inu_n4_final&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_inputnode -->
+<g id="edge114" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_inu_n4_final&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_inputnode</title>
+<path fill="none" stroke="black" d="M1758.32,-3920.41C1769.95,-3916.94 1782.06,-3912.79 1793,-3908 1808.85,-3901.06 1825.36,-3891.45 1839.17,-3882.65"/>
+<polygon fill="black" stroke="black" points="1840.96,-3885.66 1847.43,-3877.26 1837.14,-3879.79 1840.96,-3885.66"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_outputnode -->
+<g id="node39" class="node">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_outputnode</title>
+<ellipse fill="none" stroke="black" cx="1846" cy="-1976" rx="79.09" ry="18"/>
+<text text-anchor="middle" x="1846" y="-1972.3" font-family="Times,serif" font-size="14.00">outputnode (utility)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_applyrefined -->
+<g id="edge339" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_applyrefined</title>
+<path fill="none" stroke="black" d="M1766.58,-1975.71C1693.96,-1974.63 1593.63,-1968.2 1565,-1942 1524.81,-1905.22 1540,-1876.48 1540,-1822 1540,-1822 1540,-1822 1540,-1161 1540,-1117 1529.42,-1066.87 1521.76,-1036.34"/>
+<polygon fill="black" stroke="black" points="1525.17,-1035.54 1519.27,-1026.74 1518.39,-1037.3 1525.17,-1035.54"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_outputnode -->
+<g id="edge334" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_outputnode</title>
+<path fill="none" stroke="black" d="M1766.77,-1974.49C1475.66,-1971.59 482,-1952.17 482,-1822 482,-1822 482,-1822 482,-571 482,-527.23 466.37,-503.17 499,-474 545.59,-432.35 952.67,-428.16 1137.45,-428.44"/>
+<polygon fill="black" stroke="black" points="1137.24,-431.94 1147.24,-428.46 1137.25,-424.94 1137.24,-431.94"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_inputnode -->
+<g id="edge336" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_inputnode</title>
+<path fill="none" stroke="black" d="M1874.62,-1958.81C1885.93,-1955.27 1898.82,-1951.99 1911,-1950 1967.39,-1940.79 2113.22,-1958.26 2168,-1942 2186.65,-1936.46 2205.35,-1925.41 2221.78,-1915.3"/>
+<polygon fill="black" stroke="black" points="2223.21,-1918.53 2229.89,-1910.31 2219.54,-1912.57 2223.21,-1918.53"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_inputnode -->
+<g id="edge337" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_inputnode</title>
+<path fill="none" stroke="black" d="M1887.3,-1960.24C1900.46,-1956.17 1915.19,-1952.26 1929,-1950 1985.39,-1940.79 2131.22,-1958.26 2186,-1942 2203.5,-1936.81 2221.05,-1926.75 2235.14,-1917.18"/>
+<polygon fill="black" stroke="black" points="2236.93,-1920.2 2243.07,-1911.57 2232.88,-1914.49 2236.93,-1920.2"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_inputnode -->
+<g id="edge338" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_inputnode</title>
+<path fill="none" stroke="black" d="M1898.16,-1962.09C1914,-1957.39 1931.11,-1952.59 1947,-1950 2003.39,-1940.79 2149.22,-1958.26 2204,-1942 2220.63,-1937.06 2237.3,-1927.74 2249.66,-1918.61"/>
+<polygon fill="black" stroke="black" points="2251.81,-1921.37 2257.39,-1912.37 2247.41,-1915.93 2251.81,-1921.37"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_inputnode -->
+<g id="edge335" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_inputnode</title>
+<path fill="none" stroke="black" d="M1767.22,-1973.45C1608.35,-1969.96 1263.05,-1960.29 1245,-1942 1226.25,-1923 1240,-1848.69 1240,-1822 1240,-1822 1240,-1822 1240,-1006 1240,-986.19 1248.72,-931.28 1235,-917 1222.16,-903.64 1169.23,-915.83 1152,-909 1138.79,-903.76 1126.04,-894.81 1115.57,-886.05"/>
+<polygon fill="black" stroke="black" points="1117.96,-883.49 1108.14,-879.5 1113.33,-888.74 1117.96,-883.49"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_dil_brainmask -->
+<g id="node41" class="node">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_dil_brainmask</title>
+<ellipse fill="none" stroke="black" cx="1796" cy="-3787" rx="83.69" ry="18"/>
+<text text-anchor="middle" x="1796" y="-3783.3" font-family="Times,serif" font-size="14.00">dil_brainmask (ants)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_dil_brainmask -->
+<g id="edge46" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_dil_brainmask</title>
+<path fill="none" stroke="black" d="M1853.6,-3841.05C1844.34,-3832.52 1832.93,-3822.01 1822.72,-3812.61"/>
+<polygon fill="black" stroke="black" points="1825.33,-3810.26 1815.6,-3806.06 1820.59,-3815.41 1825.33,-3810.26"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_03_pad_mask -->
+<g id="node42" class="node">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_03_pad_mask</title>
+<ellipse fill="none" stroke="black" cx="1481" cy="-3715" rx="82.59" ry="18"/>
+<text text-anchor="middle" x="1481" y="-3711.3" font-family="Times,serif" font-size="14.00">03_pad_mask (ants)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_03_pad_mask -->
+<g id="edge49" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_03_pad_mask</title>
+<path fill="none" stroke="black" d="M1821.19,-3845.33C1783.71,-3835.53 1731.67,-3820.97 1687,-3805 1629.63,-3784.49 1565.48,-3755.82 1524.24,-3736.62"/>
+<polygon fill="black" stroke="black" points="1525.92,-3733.54 1515.38,-3732.48 1522.95,-3739.88 1525.92,-3733.54"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_01_atropos -->
+<g id="node44" class="node">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_01_atropos</title>
+<ellipse fill="none" stroke="black" cx="1791" cy="-3643" rx="72.29" ry="18"/>
+<text text-anchor="middle" x="1791" y="-3639.3" font-family="Times,serif" font-size="14.00">01_atropos (ants)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_01_atropos -->
+<g id="edge50" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_01_atropos</title>
+<path fill="none" stroke="black" d="M1880.23,-3841.05C1894,-3810.02 1917.6,-3743.09 1890,-3697 1880.5,-3681.14 1864.46,-3669.76 1848.02,-3661.71"/>
+<polygon fill="black" stroke="black" points="1849.73,-3658.64 1839.17,-3657.74 1846.86,-3665.03 1849.73,-3658.64"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_match_wm -->
+<g id="node46" class="node">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_match_wm</title>
+<ellipse fill="none" stroke="black" cx="1841" cy="-3571" rx="79.89" ry="18"/>
+<text text-anchor="middle" x="1841" y="-3567.3" font-family="Times,serif" font-size="14.00">match_wm (utility)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_match_wm -->
+<g id="edge55" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_match_wm</title>
+<path fill="none" stroke="black" d="M1885.15,-3840.91C1891.92,-3831.01 1899.49,-3817.96 1903,-3805 1906.71,-3791.31 1905.31,-3717.7 1901,-3697 1893.48,-3660.91 1873.49,-3623.28 1858.64,-3598.85"/>
+<polygon fill="black" stroke="black" points="1861.7,-3597.15 1853.44,-3590.52 1855.77,-3600.86 1861.7,-3597.15"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_copy_xform_wm -->
+<g id="node56" class="node">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_copy_xform_wm</title>
+<ellipse fill="none" stroke="black" cx="1817" cy="-3355" rx="103.98" ry="18"/>
+<text text-anchor="middle" x="1817" y="-3351.3" font-family="Times,serif" font-size="14.00">copy_xform_wm (header)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_copy_xform_wm -->
+<g id="edge48" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_copy_xform_wm</title>
+<path fill="none" stroke="black" d="M1821.19,-3845.28C1774.13,-3832.99 1710.33,-3814.83 1703,-3805 1616.49,-3688.9 1688.59,-3617.46 1737,-3481 1738.52,-3476.71 1773.52,-3412.81 1776,-3409 1781.91,-3399.94 1788.93,-3390.46 1795.48,-3382.07"/>
+<polygon fill="black" stroke="black" points="1798.16,-3384.33 1801.65,-3374.33 1792.69,-3379.97 1798.16,-3384.33"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_apply_wm_prior -->
+<g id="node59" class="node">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_apply_wm_prior</title>
+<ellipse fill="none" stroke="black" cx="1842" cy="-3283" rx="98.58" ry="18"/>
+<text text-anchor="middle" x="1842" y="-3279.3" font-family="Times,serif" font-size="14.00">apply_wm_prior (utility)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_apply_wm_prior -->
+<g id="edge53" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_apply_wm_prior</title>
+<path fill="none" stroke="black" d="M1880.55,-3840.89C1897.38,-3815.42 1931,-3765.2 1931,-3716 1931,-3716 1931,-3716 1931,-3426 1931,-3386.2 1942.49,-3370.5 1921,-3337 1912.64,-3323.96 1899.82,-3313.67 1886.88,-3305.76"/>
+<polygon fill="black" stroke="black" points="1888.78,-3302.81 1878.35,-3300.92 1885.32,-3308.9 1888.78,-3302.81"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_apply_wm_prior -->
+<g id="edge54" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_apply_wm_prior</title>
+<path fill="none" stroke="black" d="M1891.91,-3841.32C1915.01,-3815.97 1949,-3765.47 1949,-3716 1949,-3716 1949,-3716 1949,-3426 1949,-3386.2 1960.49,-3370.5 1939,-3337 1930.08,-3323.09 1916.1,-3312.31 1901.45,-3304.22"/>
+<polygon fill="black" stroke="black" points="1903.11,-3301.13 1892.61,-3299.72 1899.94,-3307.37 1903.11,-3301.13"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_inu_n4_final -->
+<g id="node61" class="node">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_inu_n4_final</title>
+<ellipse fill="none" stroke="black" cx="1876" cy="-2923" rx="77.19" ry="18"/>
+<text text-anchor="middle" x="1876" y="-2919.3" font-family="Times,serif" font-size="14.00">inu_n4_final (ants)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_inu_n4_final -->
+<g id="edge51" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_inu_n4_final</title>
+<path fill="none" stroke="black" d="M1892.88,-3841.36C1903.92,-3831.69 1917,-3818.74 1926,-3805 1949.2,-3769.58 1960,-3758.34 1960,-3716 1960,-3716 1960,-3716 1960,-3066 1960,-3019.94 1926.85,-2975.71 1902.2,-2949.19"/>
+<polygon fill="black" stroke="black" points="1904.73,-2946.77 1895.28,-2941.99 1899.68,-2951.62 1904.73,-2946.77"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_msk_conform -->
+<g id="node77" class="node">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_msk_conform</title>
+<ellipse fill="none" stroke="black" cx="1383" cy="-2275" rx="89.88" ry="18"/>
+<text text-anchor="middle" x="1383" y="-2271.3" font-family="Times,serif" font-size="14.00">msk_conform (utility)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_msk_conform -->
+<g id="edge52" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_msk_conform</title>
+<path fill="none" stroke="black" d="M1818.07,-3846.17C1809.69,-3844.4 1801.12,-3842.62 1793,-3841 1675.82,-3817.58 1270,-3835.5 1270,-3716 1270,-3716 1270,-3716 1270,-2418 1270,-2378.02 1259.96,-2361.67 1283,-2329 1293.31,-2314.38 1308.94,-2303.45 1324.8,-2295.45"/>
+<polygon fill="black" stroke="black" points="1326.24,-2298.63 1333.82,-2291.23 1323.28,-2292.29 1326.24,-2298.63"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_copy_xform -->
+<g id="node78" class="node">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_copy_xform</title>
+<ellipse fill="none" stroke="black" cx="1846" cy="-2203" rx="85.59" ry="18"/>
+<text text-anchor="middle" x="1846" y="-2199.3" font-family="Times,serif" font-size="14.00">copy_xform (header)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_copy_xform -->
+<g id="edge47" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_copy_xform</title>
+<path fill="none" stroke="black" d="M1900.16,-3842.03C1914.53,-3832.74 1931.37,-3819.93 1943,-3805 1969.32,-3771.21 1980,-3758.84 1980,-3716 1980,-3716 1980,-3716 1980,-2346 1980,-2291.59 1927.31,-2249.58 1888.01,-2225.82"/>
+<polygon fill="black" stroke="black" points="1889.8,-2222.81 1879.4,-2220.79 1886.28,-2228.85 1889.8,-2222.81"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_get_brainmask -->
+<g id="node43" class="node">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_get_brainmask</title>
+<ellipse fill="none" stroke="black" cx="1796" cy="-3715" rx="85.29" ry="18"/>
+<text text-anchor="middle" x="1796" y="-3711.3" font-family="Times,serif" font-size="14.00">get_brainmask (ants)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_dil_brainmask&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_get_brainmask -->
+<g id="edge56" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_dil_brainmask&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_get_brainmask</title>
+<path fill="none" stroke="black" d="M1796,-3768.7C1796,-3761.41 1796,-3752.73 1796,-3744.54"/>
+<polygon fill="black" stroke="black" points="1799.5,-3744.62 1796,-3734.62 1792.5,-3744.62 1799.5,-3744.62"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_20_add_7_2 -->
+<g id="node73" class="node">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_20_add_7_2</title>
+<ellipse fill="none" stroke="black" cx="1383" cy="-2563" rx="76.89" ry="18"/>
+<text text-anchor="middle" x="1383" y="-2559.3" font-family="Times,serif" font-size="14.00">20_add_7_2 (ants)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_03_pad_mask&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_20_add_7_2 -->
+<g id="edge57" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_03_pad_mask&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_20_add_7_2</title>
+<path fill="none" stroke="black" d="M1430.57,-3700.39C1373.98,-3681.7 1290,-3642.14 1290,-3572 1290,-3572 1290,-3572 1290,-2706 1290,-2664.66 1293.85,-2651.25 1317,-2617 1324.84,-2605.4 1336,-2595.09 1346.9,-2586.71"/>
+<polygon fill="black" stroke="black" points="1348.68,-2589.75 1354.71,-2581.04 1344.56,-2584.09 1348.68,-2589.75"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_get_brainmask&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_01_atropos -->
+<g id="edge58" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_get_brainmask&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_01_atropos</title>
+<path fill="none" stroke="black" d="M1794.76,-3696.7C1794.24,-3689.41 1793.62,-3680.73 1793.04,-3672.54"/>
+<polygon fill="black" stroke="black" points="1796.53,-3672.34 1792.33,-3662.61 1789.55,-3672.84 1796.53,-3672.34"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_02_pad_segm -->
+<g id="node45" class="node">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_02_pad_segm</title>
+<ellipse fill="none" stroke="black" cx="1586" cy="-3571" rx="82.59" ry="18"/>
+<text text-anchor="middle" x="1586" y="-3567.3" font-family="Times,serif" font-size="14.00">02_pad_segm (ants)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_01_atropos&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_02_pad_segm -->
+<g id="edge59" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_01_atropos&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_02_pad_segm</title>
+<path fill="none" stroke="black" d="M1749.52,-3627.83C1717.95,-3617.06 1674.25,-3602.13 1639.96,-3590.43"/>
+<polygon fill="black" stroke="black" points="1641.22,-3587.16 1630.62,-3587.24 1638.95,-3593.78 1641.22,-3587.16"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_01_atropos&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_match_wm -->
+<g id="edge61" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_01_atropos&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_match_wm</title>
+<path fill="none" stroke="black" d="M1803.1,-3625.05C1808.79,-3617.09 1815.71,-3607.41 1822.06,-3598.51"/>
+<polygon fill="black" stroke="black" points="1824.82,-3600.68 1827.78,-3590.51 1819.12,-3596.61 1824.82,-3600.68"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_overlap -->
+<g id="node48" class="node">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_overlap</title>
+<ellipse fill="none" stroke="black" cx="1841" cy="-3499" rx="71.49" ry="18"/>
+<text text-anchor="middle" x="1841" y="-3495.3" font-family="Times,serif" font-size="14.00">overlap (metrics)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_01_atropos&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_overlap -->
+<g id="edge62" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_01_atropos&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_overlap</title>
+<path fill="none" stroke="black" d="M1774.21,-3625.1C1758.18,-3606.81 1738.33,-3577.05 1752,-3553 1760.38,-3538.26 1774.65,-3527.2 1789.34,-3519.09"/>
+<polygon fill="black" stroke="black" points="1790.82,-3522.26 1798.16,-3514.63 1787.66,-3516.02 1790.82,-3522.26"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_sel_wm -->
+<g id="node53" class="node">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_sel_wm</title>
+<ellipse fill="none" stroke="black" cx="1853" cy="-3427" rx="67.69" ry="18"/>
+<text text-anchor="middle" x="1853" y="-3423.3" font-family="Times,serif" font-size="14.00">sel_wm (utility)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_01_atropos&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_sel_wm -->
+<g id="edge60" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_01_atropos&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_sel_wm</title>
+<path fill="none" stroke="black" d="M1770.71,-3625.63C1760.61,-3616.14 1749.41,-3603.26 1744,-3589 1726.76,-3543.57 1731.98,-3519.97 1761,-3481 1771.84,-3466.45 1787.94,-3455.25 1803.66,-3446.98"/>
+<polygon fill="black" stroke="black" points="1805.09,-3450.18 1812.52,-3442.63 1802,-3443.89 1805.09,-3450.18"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_04_sel_labels -->
+<g id="node47" class="node">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_04_sel_labels</title>
+<ellipse fill="none" stroke="black" cx="1578" cy="-3499" rx="87.99" ry="18"/>
+<text text-anchor="middle" x="1578" y="-3495.3" font-family="Times,serif" font-size="14.00">04_sel_labels (utility)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_02_pad_segm&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_04_sel_labels -->
+<g id="edge63" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_02_pad_segm&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_04_sel_labels</title>
+<path fill="none" stroke="black" d="M1584.02,-3552.7C1583.19,-3545.41 1582.2,-3536.73 1581.26,-3528.54"/>
+<polygon fill="black" stroke="black" points="1584.74,-3528.15 1580.13,-3518.61 1577.78,-3528.94 1584.74,-3528.15"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_match_wm&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_overlap -->
+<g id="edge64" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_match_wm&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_overlap</title>
+<path fill="none" stroke="black" d="M1841,-3552.7C1841,-3545.41 1841,-3536.73 1841,-3528.54"/>
+<polygon fill="black" stroke="black" points="1844.5,-3528.62 1841,-3518.62 1837.5,-3528.62 1844.5,-3528.62"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_05_get_wm -->
+<g id="node49" class="node">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_05_get_wm</title>
+<ellipse fill="none" stroke="black" cx="1672" cy="-3427" rx="75.29" ry="18"/>
+<text text-anchor="middle" x="1672" y="-3423.3" font-family="Times,serif" font-size="14.00">05_get_wm (ants)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_04_sel_labels&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_05_get_wm -->
+<g id="edge65" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_04_sel_labels&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_05_get_wm</title>
+<path fill="none" stroke="black" d="M1600.28,-3481.41C1612.33,-3472.43 1627.43,-3461.19 1640.65,-3451.34"/>
+<polygon fill="black" stroke="black" points="1642.74,-3454.15 1648.67,-3445.37 1638.56,-3448.54 1642.74,-3454.15"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_06_get_gm -->
+<g id="node50" class="node">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_06_get_gm</title>
+<ellipse fill="none" stroke="black" cx="1486" cy="-3427" rx="73.39" ry="18"/>
+<text text-anchor="middle" x="1486" y="-3423.3" font-family="Times,serif" font-size="14.00">06_get_gm (ants)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_04_sel_labels&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_06_get_gm -->
+<g id="edge66" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_04_sel_labels&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_06_get_gm</title>
+<path fill="none" stroke="black" d="M1556.2,-3481.41C1544.4,-3472.43 1529.62,-3461.19 1516.68,-3451.34"/>
+<polygon fill="black" stroke="black" points="1518.93,-3448.66 1508.85,-3445.39 1514.69,-3454.23 1518.93,-3448.66"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_10_me_csf -->
+<g id="node51" class="node">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_10_me_csf</title>
+<ellipse fill="none" stroke="black" cx="1603" cy="-3283" rx="72.29" ry="18"/>
+<text text-anchor="middle" x="1603" y="-3279.3" font-family="Times,serif" font-size="14.00">10_me_csf (ants)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_04_sel_labels&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_10_me_csf -->
+<g id="edge67" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_04_sel_labels&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_10_me_csf</title>
+<path fill="none" stroke="black" d="M1575.53,-3480.69C1573.72,-3461.52 1573.67,-3430.47 1588,-3409 1606.33,-3381.53 1636.23,-3401.45 1653,-3373 1661.12,-3359.22 1658.91,-3351.87 1653,-3337 1648.77,-3326.36 1641.28,-3316.61 1633.36,-3308.46"/>
+<polygon fill="black" stroke="black" points="1635.83,-3305.98 1626.17,-3301.62 1631,-3311.05 1635.83,-3305.98"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_27_depad_csf -->
+<g id="node52" class="node">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_27_depad_csf</title>
+<ellipse fill="none" stroke="black" cx="1391" cy="-3355" rx="81.79" ry="18"/>
+<text text-anchor="middle" x="1391" y="-3351.3" font-family="Times,serif" font-size="14.00">27_depad_csf (ants)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_04_sel_labels&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_27_depad_csf -->
+<g id="edge68" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_04_sel_labels&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_27_depad_csf</title>
+<path fill="none" stroke="black" d="M1496.66,-3492.02C1463.24,-3485.32 1427.06,-3471.82 1404,-3445 1389.9,-3428.6 1387.25,-3403.91 1387.79,-3384.68"/>
+<polygon fill="black" stroke="black" points="1391.28,-3384.97 1388.4,-3374.78 1384.29,-3384.55 1391.28,-3384.97"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_overlap&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_sel_wm -->
+<g id="edge69" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_overlap&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_sel_wm</title>
+<path fill="none" stroke="black" d="M1843.97,-3480.7C1845.23,-3473.32 1846.74,-3464.52 1848.16,-3456.25"/>
+<polygon fill="black" stroke="black" points="1851.57,-3457.04 1849.81,-3446.6 1844.67,-3455.86 1851.57,-3457.04"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_09_relabel_wm -->
+<g id="node54" class="node">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_09_relabel_wm</title>
+<ellipse fill="none" stroke="black" cx="1694" cy="-3139" rx="88.28" ry="18"/>
+<text text-anchor="middle" x="1694" y="-3135.3" font-family="Times,serif" font-size="14.00">09_relabel_wm (ants)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_05_get_wm&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_09_relabel_wm -->
+<g id="edge70" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_05_get_wm&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_09_relabel_wm</title>
+<path fill="none" stroke="black" d="M1673.85,-3408.63C1676.39,-3384.5 1680.96,-3339.47 1684,-3301 1687.66,-3254.71 1690.77,-3200.84 1692.51,-3168.63"/>
+<polygon fill="black" stroke="black" points="1695.99,-3169.09 1693.03,-3158.92 1689,-3168.72 1695.99,-3169.09"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_07_fill_gm -->
+<g id="node55" class="node">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_07_fill_gm</title>
+<ellipse fill="none" stroke="black" cx="1563" cy="-3355" rx="72.29" ry="18"/>
+<text text-anchor="middle" x="1563" y="-3351.3" font-family="Times,serif" font-size="14.00">07_fill_gm (ants)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_06_get_gm&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_07_fill_gm -->
+<g id="edge71" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_06_get_gm&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_07_fill_gm</title>
+<path fill="none" stroke="black" d="M1504.25,-3409.41C1513.77,-3400.76 1525.6,-3390 1536.14,-3380.42"/>
+<polygon fill="black" stroke="black" points="1538.45,-3383.05 1543.5,-3373.73 1533.74,-3377.87 1538.45,-3383.05"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_08_mult_gm -->
+<g id="node58" class="node">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_08_mult_gm</title>
+<ellipse fill="none" stroke="black" cx="1434" cy="-3283" rx="79.09" ry="18"/>
+<text text-anchor="middle" x="1434" y="-3279.3" font-family="Times,serif" font-size="14.00">08_mult_gm (ants)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_06_get_gm&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_08_mult_gm -->
+<g id="edge72" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_06_get_gm&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_08_mult_gm</title>
+<path fill="none" stroke="black" d="M1544.32,-3415.68C1601.51,-3402.95 1675.83,-3377.86 1644,-3337 1639.43,-3331.13 1560.12,-3312.23 1500.31,-3298.68"/>
+<polygon fill="black" stroke="black" points="1501.39,-3295.33 1490.87,-3296.55 1499.85,-3302.16 1501.39,-3295.33"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_11_add_gm -->
+<g id="node60" class="node">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_11_add_gm</title>
+<ellipse fill="none" stroke="black" cx="1467" cy="-3211" rx="75.29" ry="18"/>
+<text text-anchor="middle" x="1467" y="-3207.3" font-family="Times,serif" font-size="14.00">11_add_gm (ants)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_10_me_csf&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_11_add_gm -->
+<g id="edge73" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_10_me_csf&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_11_add_gm</title>
+<path fill="none" stroke="black" d="M1572.48,-3266.29C1553.32,-3256.43 1528.38,-3243.59 1507.57,-3232.88"/>
+<polygon fill="black" stroke="black" points="1509.26,-3229.81 1498.76,-3228.35 1506.05,-3236.04 1509.26,-3229.81"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_merge_tpms -->
+<g id="node67" class="node">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_merge_tpms</title>
+<ellipse fill="none" stroke="black" cx="1647" cy="-2995" rx="84.49" ry="18"/>
+<text text-anchor="middle" x="1647" y="-2991.3" font-family="Times,serif" font-size="14.00">merge_tpms (utility)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_27_depad_csf&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_merge_tpms -->
+<g id="edge74" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_27_depad_csf&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_merge_tpms</title>
+<path fill="none" stroke="black" d="M1373.42,-3336.98C1349.6,-3311.99 1310,-3262.8 1310,-3212 1310,-3212 1310,-3212 1310,-3138 1310,-3098.2 1292.55,-3077.82 1320,-3049 1322.16,-3046.73 1473.05,-3022.97 1569.08,-3008.04"/>
+<polygon fill="black" stroke="black" points="1569.38,-3011.54 1578.72,-3006.55 1568.3,-3004.62 1569.38,-3011.54"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_sel_wm&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_copy_xform_wm -->
+<g id="edge75" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_sel_wm&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_copy_xform_wm</title>
+<path fill="none" stroke="black" d="M1844.1,-3408.7C1840.13,-3400.98 1835.37,-3391.71 1830.94,-3383.11"/>
+<polygon fill="black" stroke="black" points="1834.17,-3381.74 1826.49,-3374.45 1827.95,-3384.94 1834.17,-3381.74"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_26_depad_wm -->
+<g id="node57" class="node">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_26_depad_wm</title>
+<ellipse fill="none" stroke="black" cx="1802" cy="-3067" rx="85.29" ry="18"/>
+<text text-anchor="middle" x="1802" y="-3063.3" font-family="Times,serif" font-size="14.00">26_depad_wm (ants)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_09_relabel_wm&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_26_depad_wm -->
+<g id="edge77" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_09_relabel_wm&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_26_depad_wm</title>
+<path fill="none" stroke="black" d="M1719.59,-3121.41C1733.85,-3112.17 1751.8,-3100.54 1767.31,-3090.49"/>
+<polygon fill="black" stroke="black" points="1768.83,-3093.67 1775.32,-3085.29 1765.02,-3087.8 1768.83,-3093.67"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_13_add_gm_wm -->
+<g id="node63" class="node">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_13_add_gm_wm</title>
+<ellipse fill="none" stroke="black" cx="1606" cy="-3067" rx="92.88" ry="18"/>
+<text text-anchor="middle" x="1606" y="-3063.3" font-family="Times,serif" font-size="14.00">13_add_gm_wm (ants)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_09_relabel_wm&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_13_add_gm_wm -->
+<g id="edge76" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_09_relabel_wm&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_13_add_gm_wm</title>
+<path fill="none" stroke="black" d="M1672.7,-3121.05C1661.67,-3112.28 1648.03,-3101.43 1635.96,-3091.83"/>
+<polygon fill="black" stroke="black" points="1638.3,-3089.22 1628.29,-3085.73 1633.94,-3094.7 1638.3,-3089.22"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_07_fill_gm&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_08_mult_gm -->
+<g id="edge78" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_07_fill_gm&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_08_mult_gm</title>
+<path fill="none" stroke="black" d="M1533.73,-3338.12C1515.96,-3328.47 1493.04,-3316.04 1473.66,-3305.52"/>
+<polygon fill="black" stroke="black" points="1475.39,-3302.48 1464.93,-3300.79 1472.05,-3308.63 1475.39,-3302.48"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_copy_xform_wm&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_apply_wm_prior -->
+<g id="edge79" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_copy_xform_wm&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_apply_wm_prior</title>
+<path fill="none" stroke="black" d="M1823.18,-3336.7C1825.87,-3329.15 1829.1,-3320.12 1832.11,-3311.68"/>
+<polygon fill="black" stroke="black" points="1835.31,-3313.12 1835.38,-3302.53 1828.72,-3310.77 1835.31,-3313.12"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_26_depad_wm&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_merge_tpms -->
+<g id="edge80" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_26_depad_wm&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_merge_tpms</title>
+<path fill="none" stroke="black" d="M1767.21,-3050.29C1745.06,-3040.28 1716.12,-3027.22 1692.19,-3016.41"/>
+<polygon fill="black" stroke="black" points="1693.87,-3013.33 1683.32,-3012.4 1690.99,-3019.71 1693.87,-3013.33"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_08_mult_gm&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_11_add_gm -->
+<g id="edge81" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_08_mult_gm&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_11_add_gm</title>
+<path fill="none" stroke="black" d="M1442.16,-3264.7C1445.75,-3257.07 1450.07,-3247.92 1454.08,-3239.4"/>
+<polygon fill="black" stroke="black" points="1457.19,-3241.01 1458.29,-3230.47 1450.86,-3238.03 1457.19,-3241.01"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_apply_wm_prior&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_inu_n4_final -->
+<g id="edge82" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_apply_wm_prior&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_inu_n4_final</title>
+<path fill="none" stroke="black" d="M1855.57,-3264.76C1874.36,-3239.1 1906,-3188.67 1906,-3140 1906,-3140 1906,-3140 1906,-3066 1906,-3025.69 1894.29,-2980.32 1885.5,-2951.94"/>
+<polygon fill="black" stroke="black" points="1888.92,-2951.14 1882.53,-2942.68 1882.25,-2953.27 1888.92,-2951.14"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_12_relabel_gm -->
+<g id="node62" class="node">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_12_relabel_gm</title>
+<ellipse fill="none" stroke="black" cx="1467" cy="-3139" rx="86.38" ry="18"/>
+<text text-anchor="middle" x="1467" y="-3135.3" font-family="Times,serif" font-size="14.00">12_relabel_gm (ants)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_11_add_gm&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_12_relabel_gm -->
+<g id="edge83" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_11_add_gm&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_12_relabel_gm</title>
+<path fill="none" stroke="black" d="M1467,-3192.7C1467,-3185.41 1467,-3176.73 1467,-3168.54"/>
+<polygon fill="black" stroke="black" points="1470.5,-3168.62 1467,-3158.62 1463.5,-3168.62 1470.5,-3168.62"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_inu_n4_final&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_copy_xform -->
+<g id="edge84" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_inu_n4_final&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_copy_xform</title>
+<path fill="none" stroke="black" d="M1869.89,-2904.95C1866.02,-2878.29 1865,-2825.12 1865,-2780 1865,-2780 1865,-2780 1865,-2346 1865,-2305.98 1854.16,-2260.8 1848.14,-2232.37"/>
+<polygon fill="black" stroke="black" points="1851.61,-2231.86 1846.2,-2222.76 1844.75,-2233.25 1851.61,-2231.86"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_inu_n4_final&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_copy_xform -->
+<g id="edge85" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_inu_n4_final&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_copy_xform</title>
+<path fill="none" stroke="black" d="M1881.32,-2904.95C1884.02,-2878.29 1883,-2825.12 1883,-2780 1883,-2780 1883,-2780 1883,-2346 1883,-2305.63 1871.97,-2260 1861.53,-2231.61"/>
+<polygon fill="black" stroke="black" points="1864.93,-2230.69 1857.99,-2222.68 1858.42,-2233.27 1864.93,-2230.69"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_12_relabel_gm&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_13_add_gm_wm -->
+<g id="edge86" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_12_relabel_gm&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_13_add_gm_wm</title>
+<path fill="none" stroke="black" d="M1498.89,-3121.94C1518.09,-3112.27 1542.77,-3099.84 1563.6,-3089.35"/>
+<polygon fill="black" stroke="black" points="1565.07,-3092.53 1572.43,-3084.91 1561.92,-3086.28 1565.07,-3092.53"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_25_depad_gm -->
+<g id="node64" class="node">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_25_depad_gm</title>
+<ellipse fill="none" stroke="black" cx="1412" cy="-3067" rx="83.39" ry="18"/>
+<text text-anchor="middle" x="1412" y="-3063.3" font-family="Times,serif" font-size="14.00">25_depad_gm (ants)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_12_relabel_gm&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_25_depad_gm -->
+<g id="edge87" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_12_relabel_gm&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_25_depad_gm</title>
+<path fill="none" stroke="black" d="M1453.69,-3121.05C1447.27,-3112.89 1439.43,-3102.91 1432.29,-3093.82"/>
+<polygon fill="black" stroke="black" points="1435.06,-3091.68 1426.13,-3085.98 1429.55,-3096 1435.06,-3091.68"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_14_sel_labels2 -->
+<g id="node65" class="node">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_14_sel_labels2</title>
+<ellipse fill="none" stroke="black" cx="1435" cy="-2995" rx="92.08" ry="18"/>
+<text text-anchor="middle" x="1435" y="-2991.3" font-family="Times,serif" font-size="14.00">14_sel_labels2 (utility)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_13_add_gm_wm&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_14_sel_labels2 -->
+<g id="edge88" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_13_add_gm_wm&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_14_sel_labels2</title>
+<path fill="none" stroke="black" d="M1567.62,-3050.29C1542.96,-3040.19 1510.68,-3026.98 1484.15,-3016.12"/>
+<polygon fill="black" stroke="black" points="1485.52,-3012.9 1474.94,-3012.35 1482.87,-3019.38 1485.52,-3012.9"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_24_depad_segm -->
+<g id="node66" class="node">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_24_depad_segm</title>
+<ellipse fill="none" stroke="black" cx="1762" cy="-2851" rx="90.98" ry="18"/>
+<text text-anchor="middle" x="1762" y="-2847.3" font-family="Times,serif" font-size="14.00">24_depad_segm (ants)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_13_add_gm_wm&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_24_depad_segm -->
+<g id="edge89" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_13_add_gm_wm&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_24_depad_segm</title>
+<path fill="none" stroke="black" d="M1673.25,-3054.23C1697.85,-3046.54 1723.64,-3033.87 1740,-3013 1769.82,-2974.97 1769.58,-2915.75 1766.16,-2880.72"/>
+<polygon fill="black" stroke="black" points="1769.65,-2880.45 1765.04,-2870.92 1762.7,-2881.25 1769.65,-2880.45"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_25_depad_gm&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_merge_tpms -->
+<g id="edge90" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_25_depad_gm&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_merge_tpms</title>
+<path fill="none" stroke="black" d="M1459.56,-3051.83C1496.7,-3040.77 1548.51,-3025.34 1588.25,-3013.5"/>
+<polygon fill="black" stroke="black" points="1589.08,-3016.91 1597.66,-3010.7 1587.08,-3010.2 1589.08,-3016.91"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_15_add_7 -->
+<g id="node68" class="node">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_15_add_7</title>
+<ellipse fill="none" stroke="black" cx="1435" cy="-2923" rx="67.69" ry="18"/>
+<text text-anchor="middle" x="1435" y="-2919.3" font-family="Times,serif" font-size="14.00">15_add_7 (ants)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_14_sel_labels2&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_15_add_7 -->
+<g id="edge91" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_14_sel_labels2&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_15_add_7</title>
+<path fill="none" stroke="black" d="M1429.08,-2976.7C1428.33,-2969.41 1428.09,-2960.73 1428.35,-2952.54"/>
+<polygon fill="black" stroke="black" points="1431.84,-2952.82 1429.01,-2942.61 1424.86,-2952.36 1431.84,-2952.82"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_14_sel_labels2&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_15_add_7 -->
+<g id="edge92" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_14_sel_labels2&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_15_add_7</title>
+<path fill="none" stroke="black" d="M1440.92,-2976.7C1441.67,-2969.41 1441.91,-2960.73 1441.65,-2952.54"/>
+<polygon fill="black" stroke="black" points="1445.14,-2952.36 1440.99,-2942.61 1438.16,-2952.82 1445.14,-2952.36"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_24_depad_segm&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_copy_xform -->
+<g id="edge93" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_24_depad_segm&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_copy_xform</title>
+<path fill="none" stroke="black" d="M1767.67,-2832.73C1775.85,-2806.21 1790,-2753.73 1790,-2708 1790,-2708 1790,-2708 1790,-2346 1790,-2303.47 1812.01,-2258.45 1828.43,-2230.78"/>
+<polygon fill="black" stroke="black" points="1831.36,-2232.71 1833.6,-2222.36 1825.39,-2229.05 1831.36,-2232.71"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_merge_tpms&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_copy_xform -->
+<g id="edge94" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_merge_tpms&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_copy_xform</title>
+<path fill="none" stroke="black" d="M1647.2,-2976.51C1647.49,-2949.71 1648,-2896.87 1648,-2852 1648,-2852 1648,-2852 1648,-2346 1648,-2279.04 1723.71,-2240.59 1781.49,-2221"/>
+<polygon fill="black" stroke="black" points="1782.55,-2224.34 1790.98,-2217.91 1780.39,-2217.68 1782.55,-2224.34"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_16_me_7 -->
+<g id="node69" class="node">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_16_me_7</title>
+<ellipse fill="none" stroke="black" cx="1410" cy="-2851" rx="66.09" ry="18"/>
+<text text-anchor="middle" x="1410" y="-2847.3" font-family="Times,serif" font-size="14.00">16_me_7 (ants)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_15_add_7&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_16_me_7 -->
+<g id="edge95" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_15_add_7&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_16_me_7</title>
+<path fill="none" stroke="black" d="M1428.82,-2904.7C1426.13,-2897.15 1422.9,-2888.12 1419.89,-2879.68"/>
+<polygon fill="black" stroke="black" points="1423.28,-2878.77 1416.62,-2870.53 1416.69,-2881.12 1423.28,-2878.77"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_17_comp_7 -->
+<g id="node70" class="node">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_17_comp_7</title>
+<ellipse fill="none" stroke="black" cx="1397" cy="-2779" rx="75.29" ry="18"/>
+<text text-anchor="middle" x="1397" y="-2775.3" font-family="Times,serif" font-size="14.00">17_comp_7 (ants)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_16_me_7&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_17_comp_7 -->
+<g id="edge96" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_16_me_7&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_17_comp_7</title>
+<path fill="none" stroke="black" d="M1406.79,-2832.7C1405.42,-2825.32 1403.78,-2816.52 1402.25,-2808.25"/>
+<polygon fill="black" stroke="black" points="1405.72,-2807.79 1400.45,-2798.59 1398.84,-2809.06 1405.72,-2807.79"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_18_md_7 -->
+<g id="node71" class="node">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_18_md_7</title>
+<ellipse fill="none" stroke="black" cx="1395" cy="-2707" rx="66.89" ry="18"/>
+<text text-anchor="middle" x="1395" y="-2703.3" font-family="Times,serif" font-size="14.00">18_md_7 (ants)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_17_comp_7&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_18_md_7 -->
+<g id="edge97" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_17_comp_7&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_18_md_7</title>
+<path fill="none" stroke="black" d="M1396.51,-2760.7C1396.3,-2753.41 1396.05,-2744.73 1395.82,-2736.54"/>
+<polygon fill="black" stroke="black" points="1399.32,-2736.51 1395.53,-2726.62 1392.32,-2736.71 1399.32,-2736.51"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_19_fill_7 -->
+<g id="node72" class="node">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_19_fill_7</title>
+<ellipse fill="none" stroke="black" cx="1391" cy="-2635" rx="64.99" ry="18"/>
+<text text-anchor="middle" x="1391" y="-2631.3" font-family="Times,serif" font-size="14.00">19_fill_7 (ants)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_18_md_7&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_19_fill_7 -->
+<g id="edge98" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_18_md_7&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_19_fill_7</title>
+<path fill="none" stroke="black" d="M1394.01,-2688.7C1393.59,-2681.41 1393.1,-2672.73 1392.63,-2664.54"/>
+<polygon fill="black" stroke="black" points="1396.13,-2664.4 1392.06,-2654.62 1389.14,-2664.8 1396.13,-2664.4"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_19_fill_7&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_20_add_7_2 -->
+<g id="edge99" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_19_fill_7&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_20_add_7_2</title>
+<path fill="none" stroke="black" d="M1389.02,-2616.7C1388.19,-2609.41 1387.2,-2600.73 1386.26,-2592.54"/>
+<polygon fill="black" stroke="black" points="1389.74,-2592.15 1385.13,-2582.61 1382.78,-2592.94 1389.74,-2592.15"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_21_md_7_2 -->
+<g id="node74" class="node">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_21_md_7_2</title>
+<ellipse fill="none" stroke="black" cx="1383" cy="-2491" rx="75.29" ry="18"/>
+<text text-anchor="middle" x="1383" y="-2487.3" font-family="Times,serif" font-size="14.00">21_md_7_2 (ants)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_20_add_7_2&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_21_md_7_2 -->
+<g id="edge100" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_20_add_7_2&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_21_md_7_2</title>
+<path fill="none" stroke="black" d="M1383,-2544.7C1383,-2537.41 1383,-2528.73 1383,-2520.54"/>
+<polygon fill="black" stroke="black" points="1386.5,-2520.62 1383,-2510.62 1379.5,-2520.62 1386.5,-2520.62"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_22_me_7_2 -->
+<g id="node75" class="node">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_22_me_7_2</title>
+<ellipse fill="none" stroke="black" cx="1383" cy="-2419" rx="75.29" ry="18"/>
+<text text-anchor="middle" x="1383" y="-2415.3" font-family="Times,serif" font-size="14.00">22_me_7_2 (ants)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_21_md_7_2&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_22_me_7_2 -->
+<g id="edge101" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_21_md_7_2&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_22_me_7_2</title>
+<path fill="none" stroke="black" d="M1383,-2472.7C1383,-2465.41 1383,-2456.73 1383,-2448.54"/>
+<polygon fill="black" stroke="black" points="1386.5,-2448.62 1383,-2438.62 1379.5,-2448.62 1386.5,-2448.62"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_23_depad_mask -->
+<g id="node76" class="node">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_23_depad_mask</title>
+<ellipse fill="none" stroke="black" cx="1383" cy="-2347" rx="90.98" ry="18"/>
+<text text-anchor="middle" x="1383" y="-2343.3" font-family="Times,serif" font-size="14.00">23_depad_mask (ants)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_22_me_7_2&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_23_depad_mask -->
+<g id="edge102" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_22_me_7_2&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_23_depad_mask</title>
+<path fill="none" stroke="black" d="M1383,-2400.7C1383,-2393.41 1383,-2384.73 1383,-2376.54"/>
+<polygon fill="black" stroke="black" points="1386.5,-2376.62 1383,-2366.62 1379.5,-2376.62 1386.5,-2376.62"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_23_depad_mask&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_msk_conform -->
+<g id="edge103" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_23_depad_mask&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_msk_conform</title>
+<path fill="none" stroke="black" d="M1383,-2328.7C1383,-2321.41 1383,-2312.73 1383,-2304.54"/>
+<polygon fill="black" stroke="black" points="1386.5,-2304.62 1383,-2294.62 1379.5,-2304.62 1386.5,-2304.62"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_msk_conform&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_copy_xform -->
+<g id="edge104" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_msk_conform&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_copy_xform</title>
+<path fill="none" stroke="black" d="M1453.07,-2263.41C1537.35,-2250.66 1678.47,-2229.33 1766.68,-2215.99"/>
+<polygon fill="black" stroke="black" points="1767.1,-2219.47 1776.46,-2214.51 1766.05,-2212.55 1767.1,-2219.47"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_apply_mask -->
+<g id="node79" class="node">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_apply_mask</title>
+<ellipse fill="none" stroke="black" cx="1739" cy="-2131" rx="87.99" ry="18"/>
+<text text-anchor="middle" x="1739" y="-2127.3" font-family="Times,serif" font-size="14.00">apply_mask (nibabel)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_copy_xform&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_apply_mask -->
+<g id="edge105" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_copy_xform&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_apply_mask</title>
+<path fill="none" stroke="black" d="M1815.38,-2185.76C1800.49,-2176.69 1782.76,-2165.22 1768.08,-2155.21"/>
+<polygon fill="black" stroke="black" points="1770.39,-2152.55 1760.17,-2149.74 1766.41,-2158.31 1770.39,-2152.55"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_copy_xform&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_apply_mask -->
+<g id="edge106" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_copy_xform&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_apply_mask</title>
+<path fill="none" stroke="black" d="M1825.98,-2185.05C1812.82,-2175.81 1795.3,-2164.24 1779.38,-2154.27"/>
+<polygon fill="black" stroke="black" points="1781.37,-2151.39 1771.02,-2149.1 1777.69,-2157.34 1781.37,-2151.39"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_outputnode -->
+<g id="node80" class="node">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_outputnode</title>
+<ellipse fill="none" stroke="black" cx="1846" cy="-2059" rx="79.09" ry="18"/>
+<text text-anchor="middle" x="1846" y="-2055.3" font-family="Times,serif" font-size="14.00">outputnode (utility)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_copy_xform&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_outputnode -->
+<g id="edge107" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_copy_xform&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_outputnode</title>
+<path fill="none" stroke="black" d="M1827.78,-2185.15C1817.44,-2161.03 1816.23,-2116.36 1824.15,-2087.43"/>
+<polygon fill="black" stroke="black" points="1827.37,-2088.85 1827.3,-2078.26 1820.75,-2086.58 1827.37,-2088.85"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_copy_xform&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_outputnode -->
+<g id="edge108" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_copy_xform&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_outputnode</title>
+<path fill="none" stroke="black" d="M1836.83,-2184.87C1831.78,-2160.99 1831.15,-2117.38 1834.93,-2088.54"/>
+<polygon fill="black" stroke="black" points="1838.38,-2089.12 1836.57,-2078.68 1831.47,-2087.97 1838.38,-2089.12"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_copy_xform&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_outputnode -->
+<g id="edge109" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_copy_xform&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_outputnode</title>
+<path fill="none" stroke="black" d="M1846,-2184.59C1846,-2160.61 1846,-2117.14 1846,-2088.42"/>
+<polygon fill="black" stroke="black" points="1849.5,-2088.62 1846,-2078.62 1842.5,-2088.62 1849.5,-2088.62"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_copy_xform&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_outputnode -->
+<g id="edge110" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_copy_xform&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_outputnode</title>
+<path fill="none" stroke="black" d="M1855.17,-2184.87C1860.22,-2160.99 1860.85,-2117.38 1857.07,-2088.54"/>
+<polygon fill="black" stroke="black" points="1860.53,-2087.97 1855.43,-2078.68 1853.62,-2089.12 1860.53,-2087.97"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_copy_xform&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_outputnode -->
+<g id="edge111" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_copy_xform&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_outputnode</title>
+<path fill="none" stroke="black" d="M1864.22,-2185.15C1874.56,-2161.03 1875.77,-2116.36 1867.85,-2087.43"/>
+<polygon fill="black" stroke="black" points="1871.25,-2086.58 1864.7,-2078.26 1864.63,-2088.85 1871.25,-2086.58"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_apply_mask&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_outputnode -->
+<g id="edge112" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_apply_mask&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_outputnode</title>
+<path fill="none" stroke="black" d="M1764.36,-2113.41C1778.35,-2104.26 1795.93,-2092.76 1811.19,-2082.77"/>
+<polygon fill="black" stroke="black" points="1813.11,-2085.7 1819.56,-2077.3 1809.27,-2079.84 1813.11,-2085.7"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_outputnode -->
+<g id="edge117" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_outputnode</title>
+<path fill="none" stroke="black" d="M1818.48,-2042C1812.09,-2031.09 1810.62,-2016.37 1814.05,-2003.71"/>
+<polygon fill="black" stroke="black" points="1817.21,-2005.23 1817.77,-1994.65 1810.74,-2002.57 1817.21,-2005.23"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_outputnode -->
+<g id="edge118" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_outputnode</title>
+<path fill="none" stroke="black" d="M1829.22,-2041.22C1825.74,-2030.75 1824.87,-2017.03 1826.64,-2004.95"/>
+<polygon fill="black" stroke="black" points="1829.98,-2006.04 1828.8,-1995.52 1823.16,-2004.48 1829.98,-2006.04"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_outputnode -->
+<g id="edge119" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_outputnode</title>
+<path fill="none" stroke="black" d="M1840.36,-2040.82C1839.26,-2030.58 1838.97,-2017.33 1839.52,-2005.55"/>
+<polygon fill="black" stroke="black" points="1842.98,-2006.17 1840.23,-1995.94 1836,-2005.66 1842.98,-2006.17"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_outputnode -->
+<g id="edge120" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_outputnode</title>
+<path fill="none" stroke="black" d="M1851.64,-2040.82C1852.74,-2030.58 1853.03,-2017.33 1852.48,-2005.55"/>
+<polygon fill="black" stroke="black" points="1856,-2005.66 1851.77,-1995.94 1849.02,-2006.17 1856,-2005.66"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_outputnode -->
+<g id="edge121" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_outputnode</title>
+<path fill="none" stroke="black" d="M1862.78,-2041.22C1866.26,-2030.75 1867.13,-2017.03 1865.36,-2004.95"/>
+<polygon fill="black" stroke="black" points="1868.84,-2004.48 1863.2,-1995.52 1862.02,-2006.04 1868.84,-2004.48"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_outputnode -->
+<g id="edge122" class="edge">
+<title>single_subject_wf_anat_preproc_wf_brain_extraction_wf_atropos_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_brain_extraction_wf_outputnode</title>
+<path fill="none" stroke="black" d="M1873.52,-2042C1879.91,-2031.09 1881.38,-2016.37 1877.95,-2003.71"/>
+<polygon fill="black" stroke="black" points="1881.26,-2002.57 1874.23,-1994.65 1874.79,-2005.23 1881.26,-2002.57"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_recon_config -->
+<g id="node82" class="node">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_recon_config</title>
+<ellipse fill="none" stroke="black" cx="1976" cy="-1821" rx="98.58" ry="18"/>
+<text text-anchor="middle" x="1976" y="-1817.3" font-family="Times,serif" font-size="14.00">recon_config (freesurfer)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_recon_config -->
+<g id="edge123" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_recon_config</title>
+<path fill="none" stroke="black" d="M2208.34,-1880.75C2158.95,-1869.69 2087.94,-1852.62 2037.28,-1839.73"/>
+<polygon fill="black" stroke="black" points="2038.17,-1836.35 2027.62,-1837.26 2036.44,-1843.13 2038.17,-1836.35"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_recon_config -->
+<g id="edge124" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_recon_config</title>
+<path fill="none" stroke="black" d="M2213.33,-1879.49C2166.29,-1868.09 2096.49,-1851.18 2044.75,-1838.65"/>
+<polygon fill="black" stroke="black" points="2045.68,-1835.28 2035.14,-1836.32 2044.03,-1842.08 2045.68,-1835.28"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_recon_config -->
+<g id="edge125" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_recon_config</title>
+<path fill="none" stroke="black" d="M2219.55,-1878.34C2174.39,-1866.62 2104.85,-1849.74 2051.48,-1837.51"/>
+<polygon fill="black" stroke="black" points="2052.35,-1834.12 2041.82,-1835.31 2050.8,-1840.95 2052.35,-1834.12"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_fov_check -->
+<g id="node83" class="node">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_fov_check</title>
+<ellipse fill="none" stroke="black" cx="2169" cy="-1821" rx="76.89" ry="18"/>
+<text text-anchor="middle" x="2169" y="-1817.3" font-family="Times,serif" font-size="14.00">fov_check (utility)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_fov_check -->
+<g id="edge129" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_fov_check</title>
+<path fill="none" stroke="black" d="M2242.25,-1875.41C2229.82,-1866.34 2214.22,-1854.97 2200.62,-1845.06"/>
+<polygon fill="black" stroke="black" points="2202.95,-1842.43 2192.81,-1839.36 2198.83,-1848.08 2202.95,-1842.43"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon1 -->
+<g id="node84" class="node">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon1</title>
+<ellipse fill="none" stroke="black" cx="2111" cy="-1749" rx="92.08" ry="18"/>
+<text text-anchor="middle" x="2111" y="-1745.3" font-family="Times,serif" font-size="14.00">autorecon1 (freesurfer)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon1 -->
+<g id="edge126" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon1</title>
+<path fill="none" stroke="black" d="M2255.07,-1874.97C2252.39,-1855.46 2253.12,-1823.56 2237,-1803 2223.55,-1785.85 2204,-1774.25 2184.2,-1766.4"/>
+<polygon fill="black" stroke="black" points="2185.55,-1763.17 2174.95,-1763.04 2183.16,-1769.75 2185.55,-1763.17"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon1 -->
+<g id="edge127" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon1</title>
+<path fill="none" stroke="black" d="M2268.02,-1874.62C2270.4,-1855.08 2271.02,-1823.43 2255,-1803 2239.96,-1783.82 2217.27,-1771.58 2194.32,-1763.77"/>
+<polygon fill="black" stroke="black" points="2195.47,-1760.46 2184.88,-1760.83 2193.39,-1767.14 2195.47,-1760.46"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon1 -->
+<g id="edge128" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon1</title>
+<path fill="none" stroke="black" d="M2280.89,-1874.97C2288.39,-1855.46 2289.12,-1823.56 2273,-1803 2255.95,-1781.26 2229.07,-1768.43 2201.94,-1760.87"/>
+<polygon fill="black" stroke="black" points="2203.16,-1757.57 2192.61,-1758.5 2201.44,-1764.35 2203.16,-1757.57"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_skull_strip_extern -->
+<g id="node85" class="node">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_skull_strip_extern</title>
+<ellipse fill="none" stroke="black" cx="2111" cy="-1677" rx="116.18" ry="18"/>
+<text text-anchor="middle" x="2111" y="-1673.3" font-family="Times,serif" font-size="14.00">skull_strip_extern (freesurfer)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_skull_strip_extern -->
+<g id="edge130" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_skull_strip_extern</title>
+<path fill="none" stroke="black" d="M2212.02,-1879.84C2203.35,-1878.07 2194.45,-1876.38 2186,-1875 2115.82,-1863.51 1915.38,-1892.04 1868,-1839 1808.47,-1772.36 1946.67,-1721.05 2038.15,-1695.63"/>
+<polygon fill="black" stroke="black" points="2038.87,-1699.06 2047.6,-1693.06 2037.03,-1692.31 2038.87,-1699.06"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_fsnative2t1w_xfm -->
+<g id="node86" class="node">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_fsnative2t1w_xfm</title>
+<ellipse fill="none" stroke="black" cx="2305" cy="-1162" rx="117.78" ry="18"/>
+<text text-anchor="middle" x="2305" y="-1158.3" font-family="Times,serif" font-size="14.00">fsnative2t1w_xfm (freesurfer)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_fsnative2t1w_xfm -->
+<g id="edge131" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_fsnative2t1w_xfm</title>
+<path fill="none" stroke="black" d="M2274.58,-1874.82C2279.85,-1864.68 2286.1,-1851.43 2290,-1839 2302,-1800.72 2305,-1790.11 2305,-1750 2305,-1750 2305,-1750 2305,-1305 2305,-1265.74 2305,-1220.38 2305,-1191.69"/>
+<polygon fill="black" stroke="black" points="2308.5,-1192 2305,-1182 2301.5,-1192 2308.5,-1192"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_refine -->
+<g id="node88" class="node">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_refine</title>
+<ellipse fill="none" stroke="black" cx="2476" cy="-788" rx="73.39" ry="18"/>
+<text text-anchor="middle" x="2476" y="-784.3" font-family="Times,serif" font-size="14.00">refine (freesurfer)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_refine -->
+<g id="edge132" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_refine</title>
+<path fill="none" stroke="black" d="M2310.22,-1878.29C2389.55,-1854.36 2545,-1802.48 2545,-1750 2545,-1750 2545,-1750 2545,-934 2545,-911.72 2549.41,-853.13 2538,-834 2532.51,-824.8 2524.33,-817.17 2515.66,-810.97"/>
+<polygon fill="black" stroke="black" points="2517.73,-808.14 2507.44,-805.63 2513.91,-814.01 2517.73,-808.14"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_refine -->
+<g id="edge133" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_refine</title>
+<path fill="none" stroke="black" d="M2316.69,-1879.51C2402.13,-1856.16 2563,-1803.39 2563,-1750 2563,-1750 2563,-1750 2563,-934 2563,-911.72 2567.41,-853.13 2556,-834 2549.7,-823.44 2539.87,-814.96 2529.18,-808.34"/>
+<polygon fill="black" stroke="black" points="2530.96,-805.32 2520.52,-803.5 2527.54,-811.43 2530.96,-805.32"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aseg_inputnode -->
+<g id="node105" class="node">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aseg_inputnode</title>
+<ellipse fill="none" stroke="black" cx="2442" cy="-1079" rx="75.29" ry="18"/>
+<text text-anchor="middle" x="2442" y="-1075.3" font-family="Times,serif" font-size="14.00">inputnode (utility)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aseg_inputnode -->
+<g id="edge187" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aseg_inputnode</title>
+<path fill="none" stroke="black" d="M2309.21,-1878.22C2361.63,-1858.81 2442,-1817.96 2442,-1750 2442,-1750 2442,-1750 2442,-1233 2442,-1189.62 2442,-1139.32 2442,-1108.58"/>
+<polygon fill="black" stroke="black" points="2445.5,-1108.95 2442,-1098.95 2438.5,-1108.95 2445.5,-1108.95"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aparc_aseg_inputnode -->
+<g id="node109" class="node">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aparc_aseg_inputnode</title>
+<ellipse fill="none" stroke="black" cx="1991" cy="-1079" rx="75.29" ry="18"/>
+<text text-anchor="middle" x="1991" y="-1075.3" font-family="Times,serif" font-size="14.00">inputnode (utility)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aparc_aseg_inputnode -->
+<g id="edge188" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aparc_aseg_inputnode</title>
+<path fill="none" stroke="black" d="M2268.22,-1874.94C2280.23,-1807.6 2318.8,-1554.51 2260,-1360 2225.75,-1246.71 2214.62,-1201.44 2116,-1136 2098.71,-1124.53 2089.43,-1135.29 2070,-1128 2053.28,-1121.72 2036.16,-1111.83 2022.15,-1102.65"/>
+<polygon fill="black" stroke="black" points="2024.5,-1100.01 2014.25,-1097.31 2020.58,-1105.81 2024.5,-1100.01"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_recon_config&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon1 -->
+<g id="edge134" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_recon_config&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon1</title>
+<path fill="none" stroke="black" d="M1991.33,-1802.88C2007.54,-1792.84 2031.83,-1780.12 2054.65,-1769.67"/>
+<polygon fill="black" stroke="black" points="2055.92,-1772.94 2063.62,-1765.66 2053.06,-1766.55 2055.92,-1772.94"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_recon_config&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon1 -->
+<g id="edge135" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_recon_config&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon1</title>
+<path fill="none" stroke="black" d="M2002.48,-1803.23C2020.12,-1793.54 2043.66,-1781.27 2064.35,-1770.95"/>
+<polygon fill="black" stroke="black" points="2065.78,-1774.15 2073.2,-1766.58 2062.68,-1767.87 2065.78,-1774.15"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_recon_config&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon1 -->
+<g id="edge136" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_recon_config&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon1</title>
+<path fill="none" stroke="black" d="M2012.75,-1803.94C2032.04,-1794.5 2055.51,-1782.42 2074.72,-1772.09"/>
+<polygon fill="black" stroke="black" points="2076.17,-1775.29 2083.29,-1767.44 2072.83,-1769.14 2076.17,-1775.29"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_recon_config&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon1 -->
+<g id="edge137" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_recon_config&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon1</title>
+<path fill="none" stroke="black" d="M2022.33,-1804.81C2043.71,-1795.49 2067.77,-1783.38 2085.96,-1772.91"/>
+<polygon fill="black" stroke="black" points="2087.56,-1776.03 2094.36,-1767.9 2083.98,-1770.01 2087.56,-1776.03"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_inputnode -->
+<g id="node90" class="node">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_inputnode</title>
+<ellipse fill="none" stroke="black" cx="1981" cy="-1594" rx="75.29" ry="18"/>
+<text text-anchor="middle" x="1981" y="-1590.3" font-family="Times,serif" font-size="14.00">inputnode (utility)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_recon_config&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_inputnode -->
+<g id="edge189" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_recon_config&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_inputnode</title>
+<path fill="none" stroke="black" d="M1972.58,-1802.72C1969.83,-1764.19 1971.61,-1670.93 1975.69,-1623.59"/>
+<polygon fill="black" stroke="black" points="1979.15,-1624.14 1976.65,-1613.85 1972.18,-1623.45 1979.15,-1624.14"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_recon_config&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_inputnode -->
+<g id="edge190" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_recon_config&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_inputnode</title>
+<path fill="none" stroke="black" d="M1980.19,-1802.72C1984.66,-1764.19 1987.02,-1670.93 1985.04,-1623.59"/>
+<polygon fill="black" stroke="black" points="1988.55,-1623.65 1984.51,-1613.85 1981.56,-1624.03 1988.55,-1623.65"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_fov_check&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon1 -->
+<g id="edge138" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_fov_check&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon1</title>
+<path fill="none" stroke="black" d="M2154.96,-1803.05C2148.22,-1794.92 2140,-1785 2132.5,-1775.94"/>
+<polygon fill="black" stroke="black" points="2135.35,-1773.91 2126.28,-1768.44 2129.96,-1778.37 2135.35,-1773.91"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon1&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_skull_strip_extern -->
+<g id="edge139" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon1&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_skull_strip_extern</title>
+<path fill="none" stroke="black" d="M2105.08,-1730.7C2104.33,-1723.41 2104.09,-1714.73 2104.35,-1706.54"/>
+<polygon fill="black" stroke="black" points="2107.84,-1706.82 2105.01,-1696.61 2100.86,-1706.36 2107.84,-1706.82"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon1&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_skull_strip_extern -->
+<g id="edge140" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon1&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_skull_strip_extern</title>
+<path fill="none" stroke="black" d="M2116.92,-1730.7C2117.67,-1723.41 2117.91,-1714.73 2117.65,-1706.54"/>
+<polygon fill="black" stroke="black" points="2121.14,-1706.36 2116.99,-1696.61 2114.16,-1706.82 2121.14,-1706.36"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon1&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_fsnative2t1w_xfm -->
+<g id="edge141" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon1&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_fsnative2t1w_xfm</title>
+<path fill="none" stroke="black" d="M2172,-1735.21C2195.27,-1727.34 2220.02,-1714.81 2236,-1695 2264.4,-1659.79 2255,-1640.24 2255,-1595 2255,-1595 2255,-1595 2255,-1305 2255,-1263.05 2274.65,-1217.89 2289.32,-1190.03"/>
+<polygon fill="black" stroke="black" points="2292.21,-1192.03 2293.92,-1181.57 2286.06,-1188.68 2292.21,-1192.03"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_skull_strip_extern&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_inputnode -->
+<g id="edge191" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_skull_strip_extern&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_inputnode</title>
+<path fill="none" stroke="black" d="M2078.81,-1659.41C2058.18,-1647.4 2031.69,-1631.02 2011.42,-1617.78"/>
+<polygon fill="black" stroke="black" points="2013.55,-1614.99 2003.28,-1612.4 2009.69,-1620.83 2013.55,-1614.99"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_skull_strip_extern&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_inputnode -->
+<g id="edge192" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_skull_strip_extern&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_inputnode</title>
+<path fill="none" stroke="black" d="M2089.36,-1659.02C2070.95,-1646.71 2044.22,-1629.96 2021.86,-1616.69"/>
+<polygon fill="black" stroke="black" points="2023.64,-1613.67 2013.24,-1611.62 2020.09,-1619.71 2023.64,-1613.67"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_t1w2fsnative_xfm -->
+<g id="node87" class="node">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_t1w2fsnative_xfm</title>
+<ellipse fill="none" stroke="black" cx="2211" cy="-1079" rx="117.78" ry="18"/>
+<text text-anchor="middle" x="2211" y="-1075.3" font-family="Times,serif" font-size="14.00">t1w2fsnative_xfm (freesurfer)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_fsnative2t1w_xfm&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_t1w2fsnative_xfm -->
+<g id="edge142" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_fsnative2t1w_xfm&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_t1w2fsnative_xfm</title>
+<path fill="none" stroke="black" d="M2285.07,-1143.82C2271.85,-1132.44 2254.32,-1117.33 2239.62,-1104.66"/>
+<polygon fill="black" stroke="black" points="2241.91,-1102.02 2232.05,-1098.14 2237.34,-1107.32 2241.91,-1102.02"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_outputnode -->
+<g id="node89" class="node">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_outputnode</title>
+<ellipse fill="none" stroke="black" cx="1682" cy="-500" rx="79.09" ry="18"/>
+<text text-anchor="middle" x="1682" y="-496.3" font-family="Times,serif" font-size="14.00">outputnode (utility)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_fsnative2t1w_xfm&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_outputnode -->
+<g id="edge143" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_fsnative2t1w_xfm&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_outputnode</title>
+<path fill="none" stroke="black" d="M2326.65,-1144.07C2331.2,-1139.38 2335.4,-1133.94 2338,-1128 2355.16,-1088.9 2346,-978.7 2346,-936 2346,-936 2346,-936 2346,-643 2346,-480.56 1859.62,-531.21 1765,-518 1759.5,-517.23 1753.81,-516.32 1748.11,-515.32"/>
+<polygon fill="black" stroke="black" points="1749.15,-511.96 1738.68,-513.59 1747.89,-518.84 1749.15,-511.96"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_inputnode -->
+<g id="node97" class="node">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_inputnode</title>
+<ellipse fill="none" stroke="black" cx="1808" cy="-1079" rx="75.29" ry="18"/>
+<text text-anchor="middle" x="1808" y="-1075.3" font-family="Times,serif" font-size="14.00">inputnode (utility)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_fsnative2t1w_xfm&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_inputnode -->
+<g id="edge202" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_fsnative2t1w_xfm&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_inputnode</title>
+<path fill="none" stroke="black" d="M2224.25,-1148.6C2190.82,-1143.91 2151.62,-1138.99 2116,-1136 2067.03,-1131.88 1942.36,-1141.12 1895,-1128 1875.59,-1122.62 1855.78,-1112.17 1839.99,-1102.38"/>
+<polygon fill="black" stroke="black" points="1842.29,-1099.7 1831.98,-1097.24 1838.51,-1105.59 1842.29,-1099.7"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_fsnative2t1w_xfm&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aseg_inputnode -->
+<g id="edge203" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_fsnative2t1w_xfm&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aseg_inputnode</title>
+<path fill="none" stroke="black" d="M2334.9,-1144.21C2343.96,-1139.06 2353.91,-1133.34 2363,-1128 2377.25,-1119.62 2392.82,-1110.21 2406.34,-1101.96"/>
+<polygon fill="black" stroke="black" points="2407.78,-1105.18 2414.49,-1096.98 2404.13,-1099.21 2407.78,-1105.18"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_fsnative2t1w_xfm&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aparc_aseg_inputnode -->
+<g id="edge204" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_fsnative2t1w_xfm&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aparc_aseg_inputnode</title>
+<path fill="none" stroke="black" d="M2237.74,-1146.79C2217.05,-1142.81 2194.15,-1138.82 2173,-1136 2127.49,-1129.94 2113.7,-1142.08 2070,-1128 2052.75,-1122.44 2035.34,-1112.44 2021.28,-1103.01"/>
+<polygon fill="black" stroke="black" points="2023.56,-1100.34 2013.36,-1097.49 2019.56,-1106.08 2023.56,-1100.34"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_t1w2fsnative_xfm&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_outputnode -->
+<g id="edge158" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_t1w2fsnative_xfm&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_outputnode</title>
+<path fill="none" stroke="black" d="M2199.19,-1060.96C2182.49,-1035.16 2154,-984.08 2154,-936 2154,-936 2154,-936 2154,-643 2154,-461.4 1943.33,-552.26 1765,-518 1760.07,-517.05 1754.99,-516.06 1749.87,-515.04"/>
+<polygon fill="black" stroke="black" points="1750.64,-511.63 1740.15,-513.1 1749.27,-518.49 1750.64,-511.63"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_refine&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_outputnode -->
+<g id="edge186" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_refine&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_outputnode</title>
+<path fill="none" stroke="black" d="M2463.44,-770.01C2456.43,-759.93 2447.93,-746.68 2442,-734 2404.92,-654.66 2452.4,-599.41 2383,-546 2328.53,-504.07 1833.21,-526.48 1765,-518 1759.31,-517.29 1753.42,-516.41 1747.54,-515.41"/>
+<polygon fill="black" stroke="black" points="1748.22,-511.98 1737.76,-513.65 1746.98,-518.87 1748.22,-511.98"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_applyrefined -->
+<g id="edge355" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_applyrefined</title>
+<path fill="none" stroke="black" d="M1639.94,-515.44C1625.44,-522.47 1610.47,-532.41 1601,-546 1576.06,-581.79 1586,-599.38 1586,-643 1586,-717 1586,-717 1586,-717 1586,-815.55 1546.09,-927.54 1525.7,-978.34"/>
+<polygon fill="black" stroke="black" points="1522.55,-976.8 1522.01,-987.38 1529.03,-979.45 1522.55,-976.8"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_buffernode -->
+<g id="edge363" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_buffernode</title>
+<path fill="none" stroke="black" d="M1629.62,-513.83C1545.52,-533.84 1374.9,-572.05 1228,-590 1150.8,-599.43 584.73,-571.76 529,-626 500.57,-653.67 522,-675.32 522,-715 522,-789 522,-789 522,-789 522,-842.42 491.27,-871.17 529,-909 551.03,-931.09 734.51,-934.66 848.43,-934.71"/>
+<polygon fill="black" stroke="black" points="848.4,-938.21 858.4,-934.7 848.4,-931.21 848.4,-938.21"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_outputnode -->
+<g id="edge356" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_outputnode</title>
+<path fill="none" stroke="black" d="M1613.31,-490.8C1588.18,-485.29 1565.47,-478.29 1545,-474 1464.26,-457.08 1372.21,-445.86 1306.61,-438.86"/>
+<polygon fill="black" stroke="black" points="1307.31,-435.42 1297,-437.85 1306.58,-442.38 1307.31,-435.42"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_outputnode -->
+<g id="edge357" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_outputnode</title>
+<path fill="none" stroke="black" d="M1619.77,-488.59C1600.34,-483.53 1580.82,-477.74 1563,-474 1477.13,-456 1378.46,-444.46 1309.78,-437.58"/>
+<polygon fill="black" stroke="black" points="1310.4,-434.12 1300.11,-436.62 1309.71,-441.09 1310.4,-434.12"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_outputnode -->
+<g id="edge358" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_outputnode</title>
+<path fill="none" stroke="black" d="M1628.37,-486.42C1612.89,-481.94 1596.32,-477.21 1581,-474 1489.83,-454.89 1384.23,-443.06 1312.24,-436.36"/>
+<polygon fill="black" stroke="black" points="1312.77,-432.89 1302.49,-435.46 1312.13,-439.86 1312.77,-432.89"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_outputnode -->
+<g id="edge359" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_outputnode</title>
+<path fill="none" stroke="black" d="M1638.86,-484.47C1626.13,-480.61 1612.11,-476.75 1599,-474 1502.36,-453.74 1389.51,-441.67 1313.87,-435.2"/>
+<polygon fill="black" stroke="black" points="1314.29,-431.73 1304.03,-434.38 1313.7,-438.7 1314.29,-431.73"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_outputnode -->
+<g id="edge360" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_outputnode</title>
+<path fill="none" stroke="black" d="M1651.57,-483.04C1640.68,-479.67 1628.49,-476.41 1617,-474 1515.17,-452.65 1395.33,-440.39 1315.59,-434.21"/>
+<polygon fill="black" stroke="black" points="1315.86,-430.72 1305.63,-433.46 1315.33,-437.7 1315.86,-430.72"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_outputnode -->
+<g id="edge361" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_outputnode</title>
+<path fill="none" stroke="black" d="M1665.82,-482.01C1656.19,-479.01 1645.31,-476.16 1635,-474 1527.85,-451.54 1400.76,-439.14 1316.27,-433.29"/>
+<polygon fill="black" stroke="black" points="1316.61,-429.81 1306.4,-432.63 1316.14,-436.79 1316.61,-429.81"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_outputnode -->
+<g id="edge362" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_outputnode</title>
+<path fill="none" stroke="black" d="M1682.25,-481.62C1673.26,-478.77 1662.87,-476.07 1653,-474 1540.95,-450.51 1407.11,-438.02 1317.06,-432.53"/>
+<polygon fill="black" stroke="black" points="1317.45,-429.05 1307.27,-431.95 1317.04,-436.04 1317.45,-429.05"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_reports_wf_inputnode -->
+<g id="edge364" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_reports_wf_inputnode</title>
+<path fill="none" stroke="black" d="M1734.31,-486.07C1848.97,-458.95 2121.93,-396.31 2248.08,-368.16"/>
+<polygon fill="black" stroke="black" points="2248.62,-371.62 2257.62,-366.03 2247.1,-364.79 2248.62,-371.62"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_reports_wf_inputnode -->
+<g id="edge365" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_reports_wf_inputnode</title>
+<path fill="none" stroke="black" d="M1738.19,-487.01C1856.23,-460.76 2128.94,-398.22 2251.93,-369.24"/>
+<polygon fill="black" stroke="black" points="2252.6,-372.67 2261.53,-366.97 2251,-365.86 2252.6,-372.67"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode -->
+<g id="edge366" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode</title>
+<path fill="none" stroke="black" d="M1678.24,-481.82C1677.6,-461.56 1677.33,-428.33 1658,-410 1629.74,-383.19 1393.18,-366.12 1263.36,-358.55"/>
+<polygon fill="black" stroke="black" points="1263.6,-355.05 1253.42,-357.97 1263.2,-362.04 1263.6,-355.05"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode -->
+<g id="edge367" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode</title>
+<path fill="none" stroke="black" d="M1690.97,-481.82C1695.6,-461.56 1695.33,-428.33 1676,-410 1646.97,-382.47 1398.28,-365.21 1264.02,-357.96"/>
+<polygon fill="black" stroke="black" points="1264.27,-354.46 1254.09,-357.43 1263.89,-361.45 1264.27,-354.46"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_autorecon2_vol -->
+<g id="node91" class="node">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_autorecon2_vol</title>
+<ellipse fill="none" stroke="black" cx="1975" cy="-1522" rx="107.78" ry="18"/>
+<text text-anchor="middle" x="1975" y="-1518.3" font-family="Times,serif" font-size="14.00">autorecon2_vol (freesurfer)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_autorecon2_vol -->
+<g id="edge146" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_autorecon2_vol</title>
+<path fill="none" stroke="black" d="M1973.6,-1575.7C1972.22,-1568.41 1971.24,-1559.73 1970.8,-1551.54"/>
+<polygon fill="black" stroke="black" points="1974.3,-1551.55 1970.6,-1541.62 1967.3,-1551.69 1974.3,-1551.55"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_autorecon2_vol -->
+<g id="edge147" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_autorecon2_vol</title>
+<path fill="none" stroke="black" d="M1985.43,-1575.7C1985.56,-1568.32 1985.05,-1559.52 1984.06,-1551.25"/>
+<polygon fill="black" stroke="black" points="1987.55,-1550.96 1982.59,-1541.6 1980.63,-1552.01 1987.55,-1550.96"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_cortribbon -->
+<g id="node93" class="node">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_cortribbon</title>
+<ellipse fill="none" stroke="black" cx="1981" cy="-1378" rx="89.88" ry="18"/>
+<text text-anchor="middle" x="1981" y="-1374.3" font-family="Times,serif" font-size="14.00">cortribbon (freesurfer)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_cortribbon -->
+<g id="edge144" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_cortribbon</title>
+<path fill="none" stroke="black" d="M2028.89,-1579.7C2049.06,-1571.77 2070.62,-1559.33 2083,-1540 2095.94,-1519.79 2096.84,-1452.28 2084,-1432 2074.23,-1416.57 2058.63,-1405.55 2042.46,-1397.7"/>
+<polygon fill="black" stroke="black" points="2044.31,-1394.7 2033.75,-1393.83 2041.47,-1401.09 2044.31,-1394.7"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_cortribbon -->
+<g id="edge145" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_cortribbon</title>
+<path fill="none" stroke="black" d="M2038.66,-1582.1C2062.35,-1574.36 2087.3,-1561.4 2101,-1540 2113.94,-1519.79 2114.84,-1452.28 2102,-1432 2091.17,-1414.9 2073.18,-1403.21 2054.3,-1395.27"/>
+<polygon fill="black" stroke="black" points="2055.76,-1392.08 2045.17,-1391.77 2053.26,-1398.61 2055.76,-1392.08"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_autorecon_surfs -->
+<g id="node92" class="node">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_autorecon_surfs</title>
+<ellipse fill="none" stroke="black" cx="1975" cy="-1450" rx="109.38" ry="18"/>
+<text text-anchor="middle" x="1975" y="-1446.3" font-family="Times,serif" font-size="14.00">autorecon_surfs (freesurfer)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_autorecon2_vol&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_autorecon_surfs -->
+<g id="edge148" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_autorecon2_vol&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_autorecon_surfs</title>
+<path fill="none" stroke="black" d="M1969.08,-1503.7C1968.33,-1496.41 1968.09,-1487.73 1968.35,-1479.54"/>
+<polygon fill="black" stroke="black" points="1971.84,-1479.82 1969.01,-1469.61 1964.86,-1479.36 1971.84,-1479.82"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_autorecon2_vol&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_autorecon_surfs -->
+<g id="edge149" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_autorecon2_vol&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_autorecon_surfs</title>
+<path fill="none" stroke="black" d="M1980.92,-1503.7C1981.67,-1496.41 1981.91,-1487.73 1981.65,-1479.54"/>
+<polygon fill="black" stroke="black" points="1985.14,-1479.36 1980.99,-1469.61 1978.16,-1479.82 1985.14,-1479.36"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_autorecon_surfs&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_cortribbon -->
+<g id="edge150" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_autorecon_surfs&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_cortribbon</title>
+<path fill="none" stroke="black" d="M1970.57,-1431.7C1970.44,-1424.32 1970.95,-1415.52 1971.94,-1407.25"/>
+<polygon fill="black" stroke="black" points="1975.37,-1408.01 1973.41,-1397.6 1968.45,-1406.96 1975.37,-1408.01"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_autorecon_surfs&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_cortribbon -->
+<g id="edge151" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_autorecon_surfs&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_cortribbon</title>
+<path fill="none" stroke="black" d="M1982.4,-1431.7C1983.78,-1424.41 1984.76,-1415.73 1985.2,-1407.54"/>
+<polygon fill="black" stroke="black" points="1988.7,-1407.69 1985.4,-1397.62 1981.7,-1407.55 1988.7,-1407.69"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_parcstats -->
+<g id="node94" class="node">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_parcstats</title>
+<ellipse fill="none" stroke="black" cx="1981" cy="-1306" rx="83.69" ry="18"/>
+<text text-anchor="middle" x="1981" y="-1302.3" font-family="Times,serif" font-size="14.00">parcstats (freesurfer)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_cortribbon&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_parcstats -->
+<g id="edge152" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_cortribbon&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_parcstats</title>
+<path fill="none" stroke="black" d="M1975.08,-1359.7C1974.33,-1352.41 1974.09,-1343.73 1974.35,-1335.54"/>
+<polygon fill="black" stroke="black" points="1977.84,-1335.82 1975.01,-1325.61 1970.86,-1335.36 1977.84,-1335.82"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_cortribbon&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_parcstats -->
+<g id="edge153" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_cortribbon&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_parcstats</title>
+<path fill="none" stroke="black" d="M1986.92,-1359.7C1987.67,-1352.41 1987.91,-1343.73 1987.65,-1335.54"/>
+<polygon fill="black" stroke="black" points="1991.14,-1335.36 1986.99,-1325.61 1984.16,-1335.82 1991.14,-1335.36"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_autorecon3 -->
+<g id="node95" class="node">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_autorecon3</title>
+<ellipse fill="none" stroke="black" cx="1981" cy="-1234" rx="92.08" ry="18"/>
+<text text-anchor="middle" x="1981" y="-1230.3" font-family="Times,serif" font-size="14.00">autorecon3 (freesurfer)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_parcstats&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_autorecon3 -->
+<g id="edge154" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_parcstats&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_autorecon3</title>
+<path fill="none" stroke="black" d="M1975.08,-1287.7C1974.33,-1280.41 1974.09,-1271.73 1974.35,-1263.54"/>
+<polygon fill="black" stroke="black" points="1977.84,-1263.82 1975.01,-1253.61 1970.86,-1263.36 1977.84,-1263.82"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_parcstats&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_autorecon3 -->
+<g id="edge155" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_parcstats&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_autorecon3</title>
+<path fill="none" stroke="black" d="M1986.92,-1287.7C1987.67,-1280.41 1987.91,-1271.73 1987.65,-1263.54"/>
+<polygon fill="black" stroke="black" points="1991.14,-1263.36 1986.99,-1253.61 1984.16,-1263.82 1991.14,-1263.36"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_outputnode -->
+<g id="node96" class="node">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_outputnode</title>
+<ellipse fill="none" stroke="black" cx="1981" cy="-1162" rx="79.09" ry="18"/>
+<text text-anchor="middle" x="1981" y="-1158.3" font-family="Times,serif" font-size="14.00">outputnode (utility)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_autorecon3&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_outputnode -->
+<g id="edge156" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_autorecon3&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_outputnode</title>
+<path fill="none" stroke="black" d="M1975.08,-1215.7C1974.33,-1208.41 1974.09,-1199.73 1974.35,-1191.54"/>
+<polygon fill="black" stroke="black" points="1977.84,-1191.82 1975.01,-1181.61 1970.86,-1191.36 1977.84,-1191.82"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_autorecon3&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_outputnode -->
+<g id="edge157" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_autorecon3&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_outputnode</title>
+<path fill="none" stroke="black" d="M1986.92,-1215.7C1987.67,-1208.41 1987.91,-1199.73 1987.65,-1191.54"/>
+<polygon fill="black" stroke="black" points="1991.14,-1191.36 1986.99,-1181.61 1984.16,-1191.82 1991.14,-1191.36"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_outputnode -->
+<g id="edge199" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_outputnode</title>
+<path fill="none" stroke="black" d="M1934.19,-1147.14C1919.77,-1142.74 1903.86,-1138.4 1889,-1136 1873.25,-1133.46 1613.45,-1139.11 1602,-1128 1582.83,-1109.4 1595,-1034.71 1595,-1008 1595,-1008 1595,-1008 1595,-934 1595,-837.55 1597,-813.45 1597,-717 1597,-717 1597,-717 1597,-643 1597,-621.42 1591.11,-564.64 1602,-546 1608.03,-535.68 1617.47,-527.35 1627.82,-520.8"/>
+<polygon fill="black" stroke="black" points="1629.23,-524.03 1636.19,-516.03 1625.77,-517.95 1629.23,-524.03"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_outputnode -->
+<g id="edge200" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_outputnode</title>
+<path fill="none" stroke="black" d="M1945.79,-1145.43C1933.65,-1141.65 1919.93,-1138.09 1907,-1136 1891.25,-1133.46 1631.45,-1139.11 1620,-1128 1600.83,-1109.4 1613,-1034.71 1613,-1008 1613,-1008 1613,-1008 1613,-934 1613,-837.55 1615,-813.45 1615,-717 1615,-717 1615,-717 1615,-643 1615,-621.42 1609.11,-564.64 1620,-546 1625.35,-536.84 1633.39,-529.25 1641.95,-523.08"/>
+<polygon fill="black" stroke="black" points="1643.62,-526.17 1650.08,-517.77 1639.79,-520.31 1643.62,-526.17"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_inputnode -->
+<g id="edge193" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_inputnode</title>
+<path fill="none" stroke="black" d="M1933.6,-1147.33C1918.1,-1141.77 1901.08,-1135.01 1886,-1128 1869.76,-1120.45 1852.39,-1111.13 1838.07,-1102.72"/>
+<polygon fill="black" stroke="black" points="1839.91,-1099.74 1829.54,-1097.57 1836.3,-1105.73 1839.91,-1099.74"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_inputnode -->
+<g id="edge194" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_inputnode</title>
+<path fill="none" stroke="black" d="M1945.77,-1145.53C1932.52,-1140.34 1917.49,-1134.27 1904,-1128 1886.51,-1119.87 1867.71,-1109.68 1851.32,-1100.79"/>
+<polygon fill="black" stroke="black" points="1853.25,-1097.86 1842.79,-1096.17 1849.92,-1104.01 1853.25,-1097.86"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aseg_inputnode -->
+<g id="edge195" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aseg_inputnode</title>
+<path fill="none" stroke="black" d="M2016.21,-1145.42C2028.35,-1141.64 2042.07,-1138.08 2055,-1136 2087.81,-1130.72 2322.12,-1137.39 2354,-1128 2372.06,-1122.68 2390.16,-1112.16 2405.33,-1102.32"/>
+<polygon fill="black" stroke="black" points="2407.18,-1105.29 2413.59,-1096.85 2403.32,-1099.45 2407.18,-1105.29"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aseg_inputnode -->
+<g id="edge196" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aseg_inputnode</title>
+<path fill="none" stroke="black" d="M2027.81,-1147.13C2042.23,-1142.73 2058.14,-1138.39 2073,-1136 2105.81,-1130.72 2340.12,-1137.39 2372,-1128 2389.22,-1122.93 2406.47,-1113.13 2419.69,-1103.69"/>
+<polygon fill="black" stroke="black" points="2421.5,-1106.72 2427.34,-1097.88 2417.26,-1101.15 2421.5,-1106.72"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aparc_aseg_inputnode -->
+<g id="edge197" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aparc_aseg_inputnode</title>
+<path fill="none" stroke="black" d="M1977.48,-1143.82C1977.64,-1133.51 1979.02,-1120.14 1981.03,-1108.31"/>
+<polygon fill="black" stroke="black" points="1984.44,-1109.13 1982.95,-1098.64 1977.57,-1107.76 1984.44,-1109.13"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aparc_aseg_inputnode -->
+<g id="edge198" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_autorecon_resume_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aparc_aseg_inputnode</title>
+<path fill="none" stroke="black" d="M1988.76,-1143.82C1991.1,-1133.69 1993.01,-1120.6 1993.93,-1108.92"/>
+<polygon fill="black" stroke="black" points="1997.42,-1109.11 1994.43,-1098.94 1990.43,-1108.75 1997.42,-1109.11"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_get_surfaces -->
+<g id="node98" class="node">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_get_surfaces</title>
+<ellipse fill="none" stroke="black" cx="1743" cy="-1007" rx="69.59" ry="18"/>
+<text text-anchor="middle" x="1743" y="-1003.3" font-family="Times,serif" font-size="14.00">get_surfaces (io)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_get_surfaces -->
+<g id="edge159" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_get_surfaces</title>
+<path fill="none" stroke="black" d="M1786.76,-1061.41C1778.11,-1053.08 1768.33,-1042.8 1760.14,-1033.49"/>
+<polygon fill="black" stroke="black" points="1763,-1031.44 1753.85,-1026.11 1757.68,-1035.99 1763,-1031.44"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_get_surfaces -->
+<g id="edge160" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_get_surfaces</title>
+<path fill="none" stroke="black" d="M1797.85,-1060.7C1790.89,-1052.27 1781.52,-1041.97 1772.45,-1032.73"/>
+<polygon fill="black" stroke="black" points="1774.92,-1030.25 1765.35,-1025.69 1769.99,-1035.22 1774.92,-1030.25"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_save_midthickness -->
+<g id="node100" class="node">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_save_midthickness</title>
+<ellipse fill="none" stroke="black" cx="1757" cy="-860" rx="92.88" ry="18"/>
+<text text-anchor="middle" x="1757" y="-856.3" font-family="Times,serif" font-size="14.00">save_midthickness (io)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_save_midthickness -->
+<g id="edge161" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_save_midthickness</title>
+<path fill="none" stroke="black" d="M1815.39,-1060.95C1832.85,-1030.33 1870.31,-964.8 1843,-917 1834.43,-902.01 1820.11,-890.63 1805.55,-882.18"/>
+<polygon fill="black" stroke="black" points="1807.3,-879.14 1796.83,-877.5 1803.99,-885.31 1807.3,-879.14"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_save_midthickness -->
+<g id="edge162" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_save_midthickness</title>
+<path fill="none" stroke="black" d="M1825.64,-1061.43C1850.45,-1031.02 1888.46,-965.05 1861,-917 1851.67,-900.67 1835.52,-888.63 1818.64,-879.99"/>
+<polygon fill="black" stroke="black" points="1820.57,-877.03 1810.03,-875.93 1817.58,-883.36 1820.57,-877.03"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_fix_surfs -->
+<g id="node103" class="node">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_fix_surfs</title>
+<ellipse fill="none" stroke="black" cx="1706" cy="-644" rx="63.89" ry="18"/>
+<text text-anchor="middle" x="1706" y="-640.3" font-family="Times,serif" font-size="14.00">fix_surfs (surf)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_fix_surfs -->
+<g id="edge163" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_fix_surfs</title>
+<path fill="none" stroke="black" d="M1826.2,-1061.34C1835.93,-1051.57 1847.44,-1038.52 1855,-1025 1875.18,-988.92 1882,-977.34 1882,-936 1882,-936 1882,-936 1882,-787 1882,-722.86 1810.32,-682.75 1758.44,-662.12"/>
+<polygon fill="black" stroke="black" points="1759.71,-658.86 1749.12,-658.56 1757.21,-665.4 1759.71,-658.86"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_midthickness -->
+<g id="node99" class="node">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_midthickness</title>
+<ellipse fill="none" stroke="black" cx="1743" cy="-935" rx="100.18" ry="18"/>
+<text text-anchor="middle" x="1743" y="-931.3" font-family="Times,serif" font-size="14.00">midthickness (freesurfer)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_get_surfaces&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_midthickness -->
+<g id="edge164" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_get_surfaces&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_midthickness</title>
+<path fill="none" stroke="black" d="M1737.08,-988.7C1736.33,-981.41 1736.09,-972.73 1736.35,-964.54"/>
+<polygon fill="black" stroke="black" points="1739.84,-964.82 1737.01,-954.61 1732.86,-964.36 1739.84,-964.82"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_get_surfaces&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_midthickness -->
+<g id="edge165" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_get_surfaces&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_midthickness</title>
+<path fill="none" stroke="black" d="M1748.92,-988.7C1749.67,-981.41 1749.91,-972.73 1749.65,-964.54"/>
+<polygon fill="black" stroke="black" points="1753.14,-964.36 1748.99,-954.61 1746.16,-964.82 1753.14,-964.36"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_surface_list -->
+<g id="node101" class="node">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_surface_list</title>
+<ellipse fill="none" stroke="black" cx="1706" cy="-788" rx="80.69" ry="18"/>
+<text text-anchor="middle" x="1706" y="-784.3" font-family="Times,serif" font-size="14.00">surface_list (utility)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_get_surfaces&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_surface_list -->
+<g id="edge166" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_get_surfaces&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_surface_list</title>
+<path fill="none" stroke="black" d="M1684.38,-996.89C1658.18,-989.39 1630.45,-976.1 1616,-953 1599.01,-925.85 1628.52,-847.9 1637,-834 1642.24,-825.41 1649.64,-817.56 1657.84,-810.9"/>
+<polygon fill="black" stroke="black" points="1659.8,-813.81 1665.78,-805.06 1655.65,-808.17 1659.8,-813.81"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_get_surfaces&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_surface_list -->
+<g id="edge167" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_get_surfaces&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_surface_list</title>
+<path fill="none" stroke="black" d="M1692.47,-994.35C1670.54,-986.51 1646.95,-973.69 1634,-953 1617.01,-925.85 1646.52,-847.9 1655,-834 1659.71,-826.27 1666.18,-819.14 1672.92,-812.94"/>
+<polygon fill="black" stroke="black" points="1675.02,-815.75 1680.34,-806.59 1670.47,-810.43 1675.02,-815.75"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_get_surfaces&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_surface_list -->
+<g id="edge168" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_get_surfaces&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_surface_list</title>
+<path fill="none" stroke="black" d="M1702.69,-991.87C1683.97,-983.89 1663.66,-971.64 1652,-953 1635.01,-925.85 1664.52,-847.9 1673,-834 1677.48,-826.65 1683.54,-819.84 1689.51,-813.86"/>
+<polygon fill="black" stroke="black" points="1691.56,-816.74 1696.34,-807.29 1686.7,-811.7 1691.56,-816.74"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_midthickness&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_save_midthickness -->
+<g id="edge169" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_midthickness&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_save_midthickness</title>
+<path fill="none" stroke="black" d="M1746.32,-916.7C1747.88,-908.58 1749.77,-898.68 1751.54,-889.5"/>
+<polygon fill="black" stroke="black" points="1754.93,-890.4 1753.37,-879.92 1748.05,-889.08 1754.93,-890.4"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_save_midthickness&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_surface_list -->
+<g id="edge170" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_save_midthickness&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_surface_list</title>
+<path fill="none" stroke="black" d="M1744.39,-841.7C1738.59,-833.73 1731.57,-824.1 1725.14,-815.26"/>
+<polygon fill="black" stroke="black" points="1728.07,-813.35 1719.35,-807.33 1722.41,-817.47 1728.07,-813.35"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_fs2gii -->
+<g id="node102" class="node">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_fs2gii</title>
+<ellipse fill="none" stroke="black" cx="1706" cy="-716" rx="73.39" ry="18"/>
+<text text-anchor="middle" x="1706" y="-712.3" font-family="Times,serif" font-size="14.00">fs2gii (freesurfer)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_surface_list&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_fs2gii -->
+<g id="edge171" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_surface_list&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_fs2gii</title>
+<path fill="none" stroke="black" d="M1706,-769.7C1706,-762.41 1706,-753.73 1706,-745.54"/>
+<polygon fill="black" stroke="black" points="1709.5,-745.62 1706,-735.62 1702.5,-745.62 1709.5,-745.62"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_fs2gii&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_fix_surfs -->
+<g id="edge172" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_fs2gii&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_fix_surfs</title>
+<path fill="none" stroke="black" d="M1706,-697.7C1706,-690.41 1706,-681.73 1706,-673.54"/>
+<polygon fill="black" stroke="black" points="1709.5,-673.62 1706,-663.62 1702.5,-673.62 1709.5,-673.62"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_outputnode -->
+<g id="node104" class="node">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_outputnode</title>
+<ellipse fill="none" stroke="black" cx="1705" cy="-572" rx="79.09" ry="18"/>
+<text text-anchor="middle" x="1705" y="-568.3" font-family="Times,serif" font-size="14.00">outputnode (utility)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_fix_surfs&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_outputnode -->
+<g id="edge173" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_fix_surfs&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_outputnode</title>
+<path fill="none" stroke="black" d="M1705.75,-625.7C1705.65,-618.41 1705.52,-609.73 1705.41,-601.54"/>
+<polygon fill="black" stroke="black" points="1708.91,-601.57 1705.27,-591.62 1701.91,-601.67 1708.91,-601.57"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_outputnode -->
+<g id="edge201" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_gifti_surface_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_outputnode</title>
+<path fill="none" stroke="black" d="M1699.31,-553.7C1696.86,-546.24 1693.93,-537.32 1691.19,-528.97"/>
+<polygon fill="black" stroke="black" points="1694.54,-527.95 1688.09,-519.54 1687.89,-530.14 1694.54,-527.95"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aseg_fs_datasource -->
+<g id="node106" class="node">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aseg_fs_datasource</title>
+<ellipse fill="none" stroke="black" cx="2439" cy="-1007" rx="74.19" ry="18"/>
+<text text-anchor="middle" x="2439" y="-1003.3" font-family="Times,serif" font-size="14.00">fs_datasource (io)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aseg_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aseg_fs_datasource -->
+<g id="edge174" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aseg_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aseg_fs_datasource</title>
+<path fill="none" stroke="black" d="M2435.34,-1060.7C2434.28,-1053.41 2433.66,-1044.73 2433.58,-1036.54"/>
+<polygon fill="black" stroke="black" points="2437.07,-1036.69 2433.8,-1026.62 2430.08,-1036.53 2437.07,-1036.69"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aseg_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aseg_fs_datasource -->
+<g id="edge175" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aseg_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aseg_fs_datasource</title>
+<path fill="none" stroke="black" d="M2447.17,-1060.7C2447.61,-1053.41 2447.49,-1044.73 2446.87,-1036.54"/>
+<polygon fill="black" stroke="black" points="2450.35,-1036.17 2445.79,-1026.61 2443.39,-1036.93 2450.35,-1036.17"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aseg_resample -->
+<g id="node107" class="node">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aseg_resample</title>
+<ellipse fill="none" stroke="black" cx="2450" cy="-935" rx="85.29" ry="18"/>
+<text text-anchor="middle" x="2450" y="-931.3" font-family="Times,serif" font-size="14.00">resample (freesurfer)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aseg_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aseg_resample -->
+<g id="edge176" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aseg_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aseg_resample</title>
+<path fill="none" stroke="black" d="M2472.83,-1062.16C2487.76,-1053.64 2504.17,-1041.44 2513,-1025 2520.57,-1010.9 2520.22,-1003.28 2513,-989 2506.88,-976.89 2496.55,-966.88 2485.95,-958.93"/>
+<polygon fill="black" stroke="black" points="2488.12,-956.18 2477.91,-953.35 2484.12,-961.93 2488.12,-956.18"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aseg_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aseg_resample -->
+<g id="edge177" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aseg_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aseg_resample</title>
+<path fill="none" stroke="black" d="M2485.81,-1063.93C2503.37,-1055.36 2521.54,-1042.61 2531,-1025 2538.57,-1010.9 2538.22,-1003.28 2531,-989 2524.36,-975.86 2512.76,-965.19 2500.33,-956.95"/>
+<polygon fill="black" stroke="black" points="2502.39,-954.11 2492.02,-951.91 2498.75,-960.09 2502.39,-954.11"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aseg_fs_datasource&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aseg_resample -->
+<g id="edge178" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aseg_fs_datasource&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aseg_resample</title>
+<path fill="none" stroke="black" d="M2441.72,-988.7C2442.88,-981.32 2444.26,-972.52 2445.56,-964.25"/>
+<polygon fill="black" stroke="black" points="2448.98,-965.02 2447.08,-954.6 2442.07,-963.93 2448.98,-965.02"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aseg_outputnode -->
+<g id="node108" class="node">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aseg_outputnode</title>
+<ellipse fill="none" stroke="black" cx="2450" cy="-860" rx="79.09" ry="18"/>
+<text text-anchor="middle" x="2450" y="-856.3" font-family="Times,serif" font-size="14.00">outputnode (utility)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aseg_resample&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aseg_outputnode -->
+<g id="edge179" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aseg_resample&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aseg_outputnode</title>
+<path fill="none" stroke="black" d="M2450,-916.7C2450,-908.67 2450,-898.9 2450,-889.8"/>
+<polygon fill="black" stroke="black" points="2453.5,-889.94 2450,-879.94 2446.5,-889.94 2453.5,-889.94"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aseg_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_refine -->
+<g id="edge205" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aseg_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_refine</title>
+<path fill="none" stroke="black" d="M2456.43,-841.7C2459.23,-834.15 2462.58,-825.12 2465.72,-816.68"/>
+<polygon fill="black" stroke="black" points="2468.92,-818.12 2469.12,-807.52 2462.36,-815.68 2468.92,-818.12"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aseg_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_outputnode -->
+<g id="edge206" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aseg_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_outputnode</title>
+<path fill="none" stroke="black" d="M2426.41,-842.45C2414.85,-833.08 2401.76,-820.37 2394,-806 2374.89,-770.64 2378,-757.19 2378,-717 2378,-717 2378,-717 2378,-643 2378,-598.25 2385.98,-573.91 2351,-546 2300.05,-505.34 1829.68,-526.12 1765,-518 1759.31,-517.29 1753.42,-516.39 1747.54,-515.4"/>
+<polygon fill="black" stroke="black" points="1748.22,-511.96 1737.76,-513.63 1746.98,-518.85 1748.22,-511.96"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aparc_aseg_fs_datasource -->
+<g id="node110" class="node">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aparc_aseg_fs_datasource</title>
+<ellipse fill="none" stroke="black" cx="1981" cy="-1007" rx="74.19" ry="18"/>
+<text text-anchor="middle" x="1981" y="-1003.3" font-family="Times,serif" font-size="14.00">fs_datasource (io)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aparc_aseg_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aparc_aseg_fs_datasource -->
+<g id="edge180" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aparc_aseg_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aparc_aseg_fs_datasource</title>
+<path fill="none" stroke="black" d="M1982.61,-1060.7C1980.82,-1053.41 1979.34,-1044.73 1978.43,-1036.54"/>
+<polygon fill="black" stroke="black" points="1981.92,-1036.31 1977.66,-1026.61 1974.94,-1036.85 1981.92,-1036.31"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aparc_aseg_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aparc_aseg_fs_datasource -->
+<g id="edge181" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aparc_aseg_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aparc_aseg_fs_datasource</title>
+<path fill="none" stroke="black" d="M1994.44,-1060.7C1994.15,-1053.32 1993.13,-1044.52 1991.67,-1036.25"/>
+<polygon fill="black" stroke="black" points="1995.12,-1035.66 1989.65,-1026.59 1988.27,-1037.09 1995.12,-1035.66"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aparc_aseg_resample -->
+<g id="node111" class="node">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aparc_aseg_resample</title>
+<ellipse fill="none" stroke="black" cx="1992" cy="-935" rx="85.29" ry="18"/>
+<text text-anchor="middle" x="1992" y="-931.3" font-family="Times,serif" font-size="14.00">resample (freesurfer)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aparc_aseg_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aparc_aseg_resample -->
+<g id="edge182" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aparc_aseg_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aparc_aseg_resample</title>
+<path fill="none" stroke="black" d="M2017.77,-1061.85C2031.53,-1053.16 2046.89,-1040.91 2055,-1025 2062.27,-1010.75 2062.22,-1003.28 2055,-989 2048.88,-976.89 2038.55,-966.88 2027.95,-958.93"/>
+<polygon fill="black" stroke="black" points="2030.12,-956.18 2019.91,-953.35 2026.12,-961.93 2030.12,-956.18"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aparc_aseg_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aparc_aseg_resample -->
+<g id="edge183" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aparc_aseg_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aparc_aseg_resample</title>
+<path fill="none" stroke="black" d="M2031.36,-1063.41C2047.61,-1054.65 2064.39,-1041.88 2073,-1025 2080.27,-1010.75 2080.22,-1003.28 2073,-989 2066.36,-975.86 2054.76,-965.19 2042.33,-956.95"/>
+<polygon fill="black" stroke="black" points="2044.39,-954.11 2034.02,-951.91 2040.75,-960.09 2044.39,-954.11"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aparc_aseg_fs_datasource&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aparc_aseg_resample -->
+<g id="edge184" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aparc_aseg_fs_datasource&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aparc_aseg_resample</title>
+<path fill="none" stroke="black" d="M1983.72,-988.7C1984.88,-981.32 1986.26,-972.52 1987.56,-964.25"/>
+<polygon fill="black" stroke="black" points="1990.98,-965.02 1989.08,-954.6 1984.07,-963.93 1990.98,-965.02"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aparc_aseg_outputnode -->
+<g id="node112" class="node">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aparc_aseg_outputnode</title>
+<ellipse fill="none" stroke="black" cx="1989" cy="-860" rx="79.09" ry="18"/>
+<text text-anchor="middle" x="1989" y="-856.3" font-family="Times,serif" font-size="14.00">outputnode (utility)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aparc_aseg_resample&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aparc_aseg_outputnode -->
+<g id="edge185" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aparc_aseg_resample&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aparc_aseg_outputnode</title>
+<path fill="none" stroke="black" d="M1991.29,-916.7C1990.96,-908.67 1990.56,-898.9 1990.18,-889.8"/>
+<polygon fill="black" stroke="black" points="1993.69,-889.79 1989.78,-879.94 1986.69,-890.08 1993.69,-889.79"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aparc_aseg_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_outputnode -->
+<g id="edge207" class="edge">
+<title>single_subject_wf_anat_preproc_wf_surface_recon_wf_segs_to_native_aparc_aseg_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_surface_recon_wf_outputnode</title>
+<path fill="none" stroke="black" d="M1980.5,-841.99C1968.23,-815.82 1947,-763.79 1947,-717 1947,-717 1947,-717 1947,-643 1947,-594.08 1934.13,-575.35 1895,-546 1893.5,-544.88 1812.32,-527.92 1750.63,-515.15"/>
+<polygon fill="black" stroke="black" points="1751.35,-511.72 1740.84,-513.12 1749.93,-518.58 1751.35,-511.72"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_norm_wf_split_desc -->
+<g id="node114" class="node">
+<title>single_subject_wf_anat_preproc_wf_anat_norm_wf_split_desc</title>
+<ellipse fill="none" stroke="black" cx="790" cy="-788" rx="100.98" ry="18"/>
+<text text-anchor="middle" x="790" y="-784.3" font-family="Times,serif" font-size="14.00">split_desc (templateflow)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_norm_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_split_desc -->
+<g id="edge216" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_norm_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_split_desc</title>
+<path fill="none" stroke="black" d="M1050.05,-841.56C1042.8,-838.78 1035.24,-836.12 1028,-834 999.44,-825.63 929.69,-812.76 873.03,-802.92"/>
+<polygon fill="black" stroke="black" points="873.84,-799.51 863.39,-801.25 872.64,-806.4 873.84,-799.51"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_norm_wf_trunc_mov -->
+<g id="node115" class="node">
+<title>single_subject_wf_anat_preproc_wf_anat_norm_wf_trunc_mov</title>
+<ellipse fill="none" stroke="black" cx="980" cy="-788" rx="71.49" ry="18"/>
+<text text-anchor="middle" x="980" y="-784.3" font-family="Times,serif" font-size="14.00">trunc_mov (ants)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_norm_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_trunc_mov -->
+<g id="edge218" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_norm_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_trunc_mov</title>
+<path fill="none" stroke="black" d="M1062.53,-841.52C1048.12,-832.35 1030.32,-821.02 1014.94,-811.23"/>
+<polygon fill="black" stroke="black" points="1016.84,-808.29 1006.52,-805.88 1013.08,-814.2 1016.84,-808.29"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_norm_wf_registration -->
+<g id="node117" class="node">
+<title>single_subject_wf_anat_preproc_wf_anat_norm_wf_registration</title>
+<ellipse fill="none" stroke="black" cx="975" cy="-716" rx="77.99" ry="18"/>
+<text text-anchor="middle" x="975" y="-712.3" font-family="Times,serif" font-size="14.00">registration (norm)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_norm_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_registration -->
+<g id="edge219" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_norm_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_registration</title>
+<path fill="none" stroke="black" d="M1081.16,-841.61C1075.42,-822.35 1067.79,-791.23 1051,-770 1041.03,-757.39 1027.17,-746.98 1013.97,-738.82"/>
+<polygon fill="black" stroke="black" points="1015.77,-735.82 1005.37,-733.78 1012.23,-741.86 1015.77,-735.82"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_norm_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_registration -->
+<g id="edge220" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_norm_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_registration</title>
+<path fill="none" stroke="black" d="M1094.26,-841.61C1093.42,-822.35 1085.79,-791.23 1069,-770 1058.11,-756.24 1042.61,-745.09 1027.26,-736.64"/>
+<polygon fill="black" stroke="black" points="1029.08,-733.64 1018.59,-732.16 1025.87,-739.86 1029.08,-733.64"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_norm_wf_tpl_moving -->
+<g id="node118" class="node">
+<title>single_subject_wf_anat_preproc_wf_anat_norm_wf_tpl_moving</title>
+<ellipse fill="none" stroke="black" cx="962" cy="-644" rx="76.89" ry="18"/>
+<text text-anchor="middle" x="962" y="-640.3" font-family="Times,serif" font-size="14.00">tpl_moving (fixes)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_norm_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_tpl_moving -->
+<g id="edge221" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_norm_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_tpl_moving</title>
+<path fill="none" stroke="black" d="M1091.66,-841.61C1093.75,-809.89 1093.83,-741.86 1062,-698 1051.01,-682.86 1034.36,-671.64 1017.78,-663.54"/>
+<polygon fill="black" stroke="black" points="1019.44,-660.45 1008.89,-659.51 1016.55,-666.82 1019.44,-660.45"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_norm_wf_std_mask -->
+<g id="node119" class="node">
+<title>single_subject_wf_anat_preproc_wf_anat_norm_wf_std_mask</title>
+<ellipse fill="none" stroke="black" cx="1126" cy="-644" rx="69.59" ry="18"/>
+<text text-anchor="middle" x="1126" y="-640.3" font-family="Times,serif" font-size="14.00">std_mask (fixes)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_norm_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_std_mask -->
+<g id="edge222" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_norm_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_std_mask</title>
+<path fill="none" stroke="black" d="M1092.89,-841.85C1099.06,-805.14 1113.61,-718.66 1121.2,-673.53"/>
+<polygon fill="black" stroke="black" points="1124.64,-674.17 1122.85,-663.73 1117.74,-673.01 1124.64,-674.17"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_norm_wf_std_dseg -->
+<g id="node120" class="node">
+<title>single_subject_wf_anat_preproc_wf_anat_norm_wf_std_dseg</title>
+<ellipse fill="none" stroke="black" cx="627" cy="-644" rx="66.09" ry="18"/>
+<text text-anchor="middle" x="627" y="-640.3" font-family="Times,serif" font-size="14.00">std_dseg (fixes)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_norm_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_std_dseg -->
+<g id="edge223" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_norm_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_std_dseg</title>
+<path fill="none" stroke="black" d="M1051.9,-841.51C1044.13,-838.55 1035.91,-835.85 1028,-834 987.63,-824.58 686.78,-833.76 656,-806 654.77,-804.89 639.89,-719.67 631.94,-673.68"/>
+<polygon fill="black" stroke="black" points="635.4,-673.13 630.25,-663.88 628.5,-674.32 635.4,-673.13"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_norm_wf_std_tpms -->
+<g id="node121" class="node">
+<title>single_subject_wf_anat_preproc_wf_anat_norm_wf_std_tpms</title>
+<ellipse fill="none" stroke="black" cx="779" cy="-644" rx="67.69" ry="18"/>
+<text text-anchor="middle" x="779" y="-640.3" font-family="Times,serif" font-size="14.00">std_tpms (fixes)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_norm_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_std_tpms -->
+<g id="edge224" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_norm_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_std_tpms</title>
+<path fill="none" stroke="black" d="M1051.89,-841.54C1044.13,-838.58 1035.91,-835.87 1028,-834 990.25,-825.09 706.31,-834.51 680,-806 647.45,-770.72 655.34,-739.18 680,-698 689.66,-681.86 706.1,-670.36 722.84,-662.29"/>
+<polygon fill="black" stroke="black" points="724.12,-665.56 731.86,-658.32 721.3,-659.15 724.12,-665.56"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_norm_wf_poutputnode -->
+<g id="node122" class="node">
+<title>single_subject_wf_anat_preproc_wf_anat_norm_wf_poutputnode</title>
+<ellipse fill="none" stroke="black" cx="1130" cy="-572" rx="83.69" ry="18"/>
+<text text-anchor="middle" x="1130" y="-568.3" font-family="Times,serif" font-size="14.00">poutputnode (utility)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_norm_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_poutputnode -->
+<g id="edge217" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_norm_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_poutputnode</title>
+<path fill="none" stroke="black" d="M1104.45,-841.73C1130.67,-809.13 1185.2,-735.21 1205,-662 1209.18,-646.56 1212.36,-640.21 1205,-626 1198.35,-613.15 1186.99,-602.75 1175.09,-594.68"/>
+<polygon fill="black" stroke="black" points="1177.14,-591.83 1166.8,-589.51 1173.43,-597.77 1177.14,-591.83"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_norm_wf_tf_select -->
+<g id="node116" class="node">
+<title>single_subject_wf_anat_preproc_wf_anat_norm_wf_tf_select</title>
+<ellipse fill="none" stroke="black" cx="784" cy="-716" rx="94.78" ry="18"/>
+<text text-anchor="middle" x="784" y="-712.3" font-family="Times,serif" font-size="14.00">tf_select (templateflow)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_norm_wf_split_desc&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_tf_select -->
+<g id="edge225" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_norm_wf_split_desc&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_tf_select</title>
+<path fill="none" stroke="black" d="M782.6,-769.7C781.22,-762.41 780.24,-753.73 779.8,-745.54"/>
+<polygon fill="black" stroke="black" points="783.3,-745.55 779.6,-735.62 776.3,-745.69 783.3,-745.55"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_norm_wf_split_desc&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_tf_select -->
+<g id="edge226" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_norm_wf_split_desc&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_tf_select</title>
+<path fill="none" stroke="black" d="M794.43,-769.7C794.56,-762.32 794.05,-753.52 793.06,-745.25"/>
+<polygon fill="black" stroke="black" points="796.55,-744.96 791.59,-735.6 789.63,-746.01 796.55,-744.96"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_norm_wf_split_desc&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_registration -->
+<g id="edge227" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_norm_wf_split_desc&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_registration</title>
+<path fill="none" stroke="black" d="M826.66,-770.94C853.69,-760.25 890.78,-746.19 921.15,-735.11"/>
+<polygon fill="black" stroke="black" points="921.95,-738.54 930.16,-731.84 919.57,-731.96 921.95,-738.54"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_norm_wf_split_desc&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_registration -->
+<g id="edge228" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_norm_wf_split_desc&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_registration</title>
+<path fill="none" stroke="black" d="M836.3,-771.64C864.79,-761.32 901.08,-747.65 929.44,-736.56"/>
+<polygon fill="black" stroke="black" points="930.45,-739.92 938.48,-733 927.89,-733.41 930.45,-739.92"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_norm_wf_split_desc&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_poutputnode -->
+<g id="edge229" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_norm_wf_split_desc&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_poutputnode</title>
+<path fill="none" stroke="black" d="M732.54,-772.82C643.51,-748.31 488.75,-694.06 552,-626 589.16,-586.01 987.88,-597.19 1042,-590 1048.07,-589.19 1054.36,-588.23 1060.65,-587.18"/>
+<polygon fill="black" stroke="black" points="1061.19,-590.64 1070.44,-585.48 1059.99,-583.75 1061.19,-590.64"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_norm_wf_trunc_mov&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_registration -->
+<g id="edge230" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_norm_wf_trunc_mov&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_registration</title>
+<path fill="none" stroke="black" d="M978.76,-769.7C978.24,-762.41 977.62,-753.73 977.04,-745.54"/>
+<polygon fill="black" stroke="black" points="980.53,-745.34 976.33,-735.61 973.55,-745.84 980.53,-745.34"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_norm_wf_tf_select&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_tpl_moving -->
+<g id="edge231" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_norm_wf_tf_select&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_tpl_moving</title>
+<path fill="none" stroke="black" d="M823.95,-699.29C850.4,-688.89 885.25,-675.18 913.32,-664.14"/>
+<polygon fill="black" stroke="black" points="914.28,-667.53 922.3,-660.61 911.72,-661.01 914.28,-667.53"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_norm_wf_tf_select&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_std_mask -->
+<g id="edge232" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_norm_wf_tf_select&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_std_mask</title>
+<path fill="none" stroke="black" d="M848.35,-702.39C901.84,-691.83 979.94,-676.25 1048,-662 1052.94,-660.97 1058.05,-659.88 1063.19,-658.78"/>
+<polygon fill="black" stroke="black" points="1063.9,-662.21 1072.94,-656.69 1062.43,-655.37 1063.9,-662.21"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_norm_wf_tf_select&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_std_dseg -->
+<g id="edge233" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_norm_wf_tf_select&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_std_dseg</title>
+<path fill="none" stroke="black" d="M747.98,-698.94C725.03,-688.71 695.15,-675.39 670.83,-664.54"/>
+<polygon fill="black" stroke="black" points="672.38,-661.4 661.82,-660.52 669.53,-667.79 672.38,-661.4"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_norm_wf_tf_select&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_std_tpms -->
+<g id="edge234" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_norm_wf_tf_select&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_std_tpms</title>
+<path fill="none" stroke="black" d="M782.76,-697.7C782.24,-690.41 781.62,-681.73 781.04,-673.54"/>
+<polygon fill="black" stroke="black" points="784.53,-673.34 780.33,-663.61 777.55,-673.84 784.53,-673.34"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_norm_wf_registration&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_tpl_moving -->
+<g id="edge235" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_norm_wf_registration&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_tpl_moving</title>
+<path fill="none" stroke="black" d="M971.79,-697.7C970.42,-690.32 968.78,-681.52 967.25,-673.25"/>
+<polygon fill="black" stroke="black" points="970.72,-672.79 965.45,-663.59 963.84,-674.06 970.72,-672.79"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_norm_wf_registration&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_std_mask -->
+<g id="edge236" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_norm_wf_registration&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_std_mask</title>
+<path fill="none" stroke="black" d="M1008.51,-699.46C1030.36,-689.34 1059.09,-676.02 1082.67,-665.09"/>
+<polygon fill="black" stroke="black" points="1084.13,-668.27 1091.73,-660.89 1081.18,-661.92 1084.13,-668.27"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_norm_wf_registration&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_std_dseg -->
+<g id="edge237" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_norm_wf_registration&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_std_dseg</title>
+<path fill="none" stroke="black" d="M916.97,-703.65C907.3,-701.76 897.37,-699.82 888,-698 805.35,-681.93 784.4,-679.31 702,-662 697.17,-660.98 692.16,-659.91 687.14,-658.81"/>
+<polygon fill="black" stroke="black" points="688.17,-655.45 677.65,-656.71 686.65,-662.29 688.17,-655.45"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_norm_wf_registration&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_std_tpms -->
+<g id="edge238" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_norm_wf_registration&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_std_tpms</title>
+<path fill="none" stroke="black" d="M933.91,-700.33C903.35,-689.41 861.5,-674.46 829,-662.86"/>
+<polygon fill="black" stroke="black" points="830.38,-659.63 819.79,-659.57 828.03,-666.23 830.38,-659.63"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_norm_wf_registration&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_poutputnode -->
+<g id="edge239" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_norm_wf_registration&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_poutputnode</title>
+<path fill="none" stroke="black" d="M921.63,-702.5C900.59,-694.43 878.77,-681.65 867,-662 858.78,-648.27 856.91,-638.42 867,-626 869.99,-622.32 978.73,-600.59 1055.5,-586.12"/>
+<polygon fill="black" stroke="black" points="1055.91,-589.61 1065.1,-584.32 1054.62,-582.73 1055.91,-589.61"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_norm_wf_registration&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_poutputnode -->
+<g id="edge240" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_norm_wf_registration&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_poutputnode</title>
+<path fill="none" stroke="black" d="M933.16,-700.45C915.13,-692.32 895.82,-680.06 885,-662 876.78,-648.27 874.91,-638.42 885,-626 887.89,-622.45 989.52,-602.04 1061.03,-587.61"/>
+<polygon fill="black" stroke="black" points="1061.63,-591.06 1070.74,-585.65 1060.25,-584.2 1061.63,-591.06"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_norm_wf_tpl_moving&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_poutputnode -->
+<g id="edge241" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_norm_wf_tpl_moving&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_poutputnode</title>
+<path fill="none" stroke="black" d="M998.45,-627.81C1022.97,-617.6 1055.53,-604.03 1082.13,-592.95"/>
+<polygon fill="black" stroke="black" points="1083.46,-596.18 1091.35,-589.1 1080.77,-589.72 1083.46,-596.18"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_norm_wf_std_mask&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_poutputnode -->
+<g id="edge242" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_norm_wf_std_mask&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_poutputnode</title>
+<path fill="none" stroke="black" d="M1126.99,-625.7C1127.41,-618.41 1127.9,-609.73 1128.37,-601.54"/>
+<polygon fill="black" stroke="black" points="1131.86,-601.8 1128.94,-591.62 1124.87,-601.4 1131.86,-601.8"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_norm_wf_std_dseg&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_poutputnode -->
+<g id="edge243" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_norm_wf_std_dseg&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_poutputnode</title>
+<path fill="none" stroke="black" d="M674.85,-631.27C683.83,-629.32 693.18,-627.46 702,-626 851.91,-601.16 891.71,-612.43 1042,-590 1047.87,-589.12 1053.94,-588.13 1060.02,-587.08"/>
+<polygon fill="black" stroke="black" points="1060.23,-590.6 1069.46,-585.39 1059,-583.71 1060.23,-590.6"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_norm_wf_std_tpms&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_poutputnode -->
+<g id="edge244" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_norm_wf_std_tpms&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_poutputnode</title>
+<path fill="none" stroke="black" d="M831.04,-632.13C840.98,-630.08 851.31,-627.96 861,-626 927.75,-612.51 1003.91,-597.54 1058.12,-586.96"/>
+<polygon fill="black" stroke="black" points="1058.71,-590.41 1067.85,-585.06 1057.37,-583.54 1058.71,-590.41"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_norm_wf_poutputnode&#45;&gt;single_subject_wf_anat_preproc_wf_outputnode -->
+<g id="edge341" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_norm_wf_poutputnode&#45;&gt;single_subject_wf_anat_preproc_wf_outputnode</title>
+<path fill="none" stroke="black" d="M1149.64,-554.13C1163.95,-545.73 1180.79,-533.91 1191,-518 1202.55,-499.99 1204.57,-475.61 1208.17,-456.93"/>
+<polygon fill="black" stroke="black" points="1211.54,-457.88 1210.44,-447.34 1204.73,-456.26 1211.54,-457.88"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_norm_wf_poutputnode&#45;&gt;single_subject_wf_anat_preproc_wf_outputnode -->
+<g id="edge342" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_norm_wf_poutputnode&#45;&gt;single_subject_wf_anat_preproc_wf_outputnode</title>
+<path fill="none" stroke="black" d="M1164.16,-555.29C1180.35,-546.84 1198.31,-534.66 1209,-518 1220.43,-500.18 1222.53,-476.13 1223.35,-457.53"/>
+<polygon fill="black" stroke="black" points="1226.84,-457.85 1223.72,-447.72 1219.84,-457.58 1226.84,-457.85"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_norm_wf_poutputnode&#45;&gt;single_subject_wf_anat_preproc_wf_outputnode -->
+<g id="edge343" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_norm_wf_poutputnode&#45;&gt;single_subject_wf_anat_preproc_wf_outputnode</title>
+<path fill="none" stroke="black" d="M1177.36,-556.84C1196.05,-548.36 1215.64,-535.71 1227,-518 1238.43,-500.18 1240.53,-476.13 1238.64,-457.53"/>
+<polygon fill="black" stroke="black" points="1242.1,-457.05 1237.11,-447.71 1235.19,-458.13 1242.1,-457.05"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_norm_wf_poutputnode&#45;&gt;single_subject_wf_anat_preproc_wf_outputnode -->
+<g id="edge344" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_norm_wf_poutputnode&#45;&gt;single_subject_wf_anat_preproc_wf_outputnode</title>
+<path fill="none" stroke="black" d="M1188.64,-558.81C1210.85,-550.36 1232.72,-537.14 1245,-518 1256.68,-499.79 1258.62,-475.09 1253.62,-456.33"/>
+<polygon fill="black" stroke="black" points="1256.9,-455.12 1250.16,-446.95 1250.34,-457.54 1256.9,-455.12"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_norm_wf_outputnode -->
+<g id="node123" class="node">
+<title>single_subject_wf_anat_preproc_wf_anat_norm_wf_outputnode</title>
+<ellipse fill="none" stroke="black" cx="1130" cy="-500" rx="79.09" ry="18"/>
+<text text-anchor="middle" x="1130" y="-496.3" font-family="Times,serif" font-size="14.00">outputnode (utility)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_norm_wf_poutputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_outputnode -->
+<g id="edge245" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_norm_wf_poutputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_outputnode</title>
+<path fill="none" stroke="black" d="M1090.25,-555.81C1082.64,-546.88 1080.82,-535.39 1084.79,-525.24"/>
+<polygon fill="black" stroke="black" points="1087.63,-527.32 1089.9,-516.97 1081.67,-523.64 1087.63,-527.32"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_norm_wf_poutputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_outputnode -->
+<g id="edge246" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_norm_wf_poutputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_outputnode</title>
+<path fill="none" stroke="black" d="M1101,-554.76C1096.49,-546.72 1095.19,-536.81 1097.11,-527.69"/>
+<polygon fill="black" stroke="black" points="1100.3,-529.16 1100.52,-518.57 1093.74,-526.71 1100.3,-529.16"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_norm_wf_poutputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_outputnode -->
+<g id="edge247" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_norm_wf_poutputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_outputnode</title>
+<path fill="none" stroke="black" d="M1112.37,-554.05C1109.96,-546.49 1109.21,-537.37 1110.13,-528.85"/>
+<polygon fill="black" stroke="black" points="1113.51,-529.77 1112.11,-519.27 1106.66,-528.36 1113.51,-529.77"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_norm_wf_poutputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_outputnode -->
+<g id="edge248" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_norm_wf_poutputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_outputnode</title>
+<path fill="none" stroke="black" d="M1124.08,-553.7C1123.33,-546.41 1123.09,-537.73 1123.35,-529.54"/>
+<polygon fill="black" stroke="black" points="1126.84,-529.82 1124.01,-519.61 1119.86,-529.36 1126.84,-529.82"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_norm_wf_poutputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_outputnode -->
+<g id="edge249" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_norm_wf_poutputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_outputnode</title>
+<path fill="none" stroke="black" d="M1135.92,-553.7C1136.67,-546.41 1136.91,-537.73 1136.65,-529.54"/>
+<polygon fill="black" stroke="black" points="1140.14,-529.36 1135.99,-519.61 1133.16,-529.82 1140.14,-529.36"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_norm_wf_poutputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_outputnode -->
+<g id="edge250" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_norm_wf_poutputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_outputnode</title>
+<path fill="none" stroke="black" d="M1147.63,-554.05C1150.04,-546.49 1150.79,-537.37 1149.87,-528.85"/>
+<polygon fill="black" stroke="black" points="1153.34,-528.36 1147.89,-519.27 1146.49,-529.77 1153.34,-528.36"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_norm_wf_poutputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_outputnode -->
+<g id="edge251" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_norm_wf_poutputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_outputnode</title>
+<path fill="none" stroke="black" d="M1159,-554.76C1163.51,-546.72 1164.81,-536.81 1162.89,-527.69"/>
+<polygon fill="black" stroke="black" points="1166.26,-526.71 1159.48,-518.57 1159.7,-529.16 1166.26,-526.71"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_norm_wf_poutputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_outputnode -->
+<g id="edge252" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_norm_wf_poutputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_norm_wf_outputnode</title>
+<path fill="none" stroke="black" d="M1169.75,-555.81C1177.36,-546.88 1179.18,-535.39 1175.21,-525.24"/>
+<polygon fill="black" stroke="black" points="1178.33,-523.64 1170.1,-516.97 1172.37,-527.32 1178.33,-523.64"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_norm_wf_poutputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_reports_wf_inputnode -->
+<g id="edge348" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_norm_wf_poutputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_reports_wf_inputnode</title>
+<path fill="none" stroke="black" d="M1088.15,-555.96C1070.9,-547.53 1052.52,-535.19 1042,-518 1016.92,-477.01 1003.18,-444.13 1037,-410 1045.56,-401.36 1900.86,-402.78 1913,-402 2028.11,-394.61 2160.88,-376.89 2241.07,-365.18"/>
+<polygon fill="black" stroke="black" points="2241.14,-368.7 2250.53,-363.79 2240.13,-361.78 2241.14,-368.7"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_norm_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_outputnode -->
+<g id="edge345" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_norm_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_outputnode</title>
+<path fill="none" stroke="black" d="M1141.97,-482.05C1153.19,-472.61 1169.53,-460.74 1185.14,-450.63"/>
+<polygon fill="black" stroke="black" points="1186.84,-453.69 1193.44,-445.4 1183.11,-447.77 1186.84,-453.69"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_norm_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_outputnode -->
+<g id="edge346" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_norm_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_outputnode</title>
+<path fill="none" stroke="black" d="M1153.22,-482.41C1165.92,-473.34 1181.84,-461.97 1195.72,-452.06"/>
+<polygon fill="black" stroke="black" points="1197.61,-455.01 1203.71,-446.35 1193.54,-449.31 1197.61,-455.01"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_norm_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_outputnode -->
+<g id="edge347" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_norm_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_outputnode</title>
+<path fill="none" stroke="black" d="M1163.47,-483.29C1178,-474.4 1194.29,-463.1 1207.14,-453.11"/>
+<polygon fill="black" stroke="black" points="1209.05,-456.08 1214.64,-447.08 1204.65,-450.62 1209.05,-456.08"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_norm_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode -->
+<g id="edge349" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_norm_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode</title>
+<path fill="none" stroke="black" d="M1114.73,-481.98C1108.5,-463.59 1108.03,-433.74 1117,-410 1121.49,-398.1 1129.48,-386.72 1138.59,-377.37"/>
+<polygon fill="black" stroke="black" points="1140.79,-380.11 1145.73,-370.74 1136.02,-374.98 1140.79,-380.11"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_norm_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode -->
+<g id="edge350" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_norm_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode</title>
+<path fill="none" stroke="black" d="M1127.97,-481.64C1126.5,-463.23 1126.09,-433.6 1135,-410 1139.15,-399.01 1146.28,-388.47 1153.6,-379.55"/>
+<polygon fill="black" stroke="black" points="1156.23,-381.86 1160.2,-372.03 1150.97,-377.24 1156.23,-381.86"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_norm_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode -->
+<g id="edge351" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_norm_wf_outputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode</title>
+<path fill="none" stroke="black" d="M1141.27,-481.98C1144.5,-463.59 1144.03,-433.74 1153,-410 1157,-399.41 1163.76,-389.23 1169.98,-380.53"/>
+<polygon fill="black" stroke="black" points="1172.69,-382.76 1175.71,-372.61 1167.01,-378.66 1172.69,-382.76"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_reports_wf_t1w_conform_check -->
+<g id="node125" class="node">
+<title>single_subject_wf_anat_preproc_wf_anat_reports_wf_t1w_conform_check</title>
+<ellipse fill="none" stroke="black" cx="2037" cy="-281" rx="112.38" ry="18"/>
+<text text-anchor="middle" x="2037" y="-277.3" font-family="Times,serif" font-size="14.00">t1w_conform_check (utility)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_reports_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_reports_wf_t1w_conform_check -->
+<g id="edge253" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_reports_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_reports_wf_t1w_conform_check</title>
+<path fill="none" stroke="black" d="M2263.52,-339.24C2219.51,-328.12 2155.25,-311.88 2106.41,-299.54"/>
+<polygon fill="black" stroke="black" points="2107.31,-296.16 2096.76,-297.1 2105.59,-302.94 2107.31,-296.16"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_reports_wf_seg_rpt -->
+<g id="node126" class="node">
+<title>single_subject_wf_anat_preproc_wf_anat_reports_wf_seg_rpt</title>
+<ellipse fill="none" stroke="black" cx="2265" cy="-281" rx="77.99" ry="18"/>
+<text text-anchor="middle" x="2265" y="-277.3" font-family="Times,serif" font-size="14.00">seg_rpt (reportlets)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_reports_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_reports_wf_seg_rpt -->
+<g id="edge256" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_reports_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_reports_wf_seg_rpt</title>
+<path fill="none" stroke="black" d="M2290.71,-335.41C2283.56,-327.62 2276.41,-318.14 2270.92,-309.33"/>
+<polygon fill="black" stroke="black" points="2274.05,-307.76 2266.1,-300.77 2267.96,-311.2 2274.05,-307.76"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_reports_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_reports_wf_seg_rpt -->
+<g id="edge257" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_reports_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_reports_wf_seg_rpt</title>
+<path fill="none" stroke="black" d="M2302.14,-335.05C2296.56,-327.09 2289.79,-317.41 2283.56,-308.51"/>
+<polygon fill="black" stroke="black" points="2286.56,-306.7 2277.96,-300.52 2280.83,-310.71 2286.56,-306.7"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_reports_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_reports_wf_seg_rpt -->
+<g id="edge258" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_reports_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_reports_wf_seg_rpt</title>
+<path fill="none" stroke="black" d="M2313.72,-334.7C2309.64,-326.44 2303.01,-316.39 2295.74,-307.3"/>
+<polygon fill="black" stroke="black" points="2298.46,-305.1 2289.31,-299.77 2293.14,-309.65 2298.46,-305.1"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_reports_wf_tf_select -->
+<g id="node127" class="node">
+<title>single_subject_wf_anat_preproc_wf_anat_reports_wf_tf_select</title>
+<ellipse fill="none" stroke="black" cx="2476" cy="-281" rx="94.78" ry="18"/>
+<text text-anchor="middle" x="2476" y="-277.3" font-family="Times,serif" font-size="14.00">tf_select (templateflow)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_reports_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_reports_wf_tf_select -->
+<g id="edge259" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_reports_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_reports_wf_tf_select</title>
+<path fill="none" stroke="black" d="M2344.62,-336.29C2366.96,-326.12 2397.66,-312.8 2423.81,-301.89"/>
+<polygon fill="black" stroke="black" points="2425.03,-305.18 2432.93,-298.12 2422.35,-298.71 2425.03,-305.18"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_reports_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_reports_wf_tf_select -->
+<g id="edge260" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_reports_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_reports_wf_tf_select</title>
+<path fill="none" stroke="black" d="M2353.57,-337.33C2377.89,-327.36 2408.94,-314.04 2433.73,-302.96"/>
+<polygon fill="black" stroke="black" points="2434.87,-306.29 2442.55,-298.99 2432,-299.9 2434.87,-306.29"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_reports_wf_recon_report -->
+<g id="node128" class="node">
+<title>single_subject_wf_anat_preproc_wf_anat_reports_wf_recon_report</title>
+<ellipse fill="none" stroke="black" cx="2697" cy="-281" rx="88.28" ry="18"/>
+<text text-anchor="middle" x="2697" y="-277.3" font-family="Times,serif" font-size="14.00">recon_report (reports)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_reports_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_reports_wf_recon_report -->
+<g id="edge266" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_reports_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_reports_wf_recon_report</title>
+<path fill="none" stroke="black" d="M2370.42,-340.75C2436.33,-328.33 2545.58,-308.34 2619.43,-295.19"/>
+<polygon fill="black" stroke="black" points="2619.78,-298.68 2629.02,-293.48 2618.56,-291.79 2619.78,-298.68"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_reports_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_reports_wf_recon_report -->
+<g id="edge267" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_reports_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_reports_wf_recon_report</title>
+<path fill="none" stroke="black" d="M2374.2,-341.9C2441.88,-329.93 2551.64,-309.91 2624.11,-296.34"/>
+<polygon fill="black" stroke="black" points="2624.74,-299.78 2633.92,-294.5 2623.44,-292.9 2624.74,-299.78"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_reports_wf_ds_t1w_conform_report -->
+<g id="node129" class="node">
+<title>single_subject_wf_anat_preproc_wf_anat_reports_wf_ds_t1w_conform_report</title>
+<ellipse fill="none" stroke="black" cx="2090" cy="-209" rx="96.38" ry="18"/>
+<text text-anchor="middle" x="2090" y="-205.3" font-family="Times,serif" font-size="14.00">ds_t1w_conform_report</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_reports_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_reports_wf_ds_t1w_conform_report -->
+<g id="edge254" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_reports_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_reports_wf_ds_t1w_conform_report</title>
+<path fill="none" stroke="black" d="M2259.7,-340.15C2232.75,-332.11 2201.1,-319.16 2178,-299 2164.21,-286.96 2169.9,-276.91 2158,-263 2148.65,-252.07 2136.73,-241.88 2125.5,-233.41"/>
+<polygon fill="black" stroke="black" points="2127.67,-230.66 2117.52,-227.62 2123.56,-236.32 2127.67,-230.66"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_reports_wf_ds_t1w_dseg_mask_report -->
+<g id="node130" class="node">
+<title>single_subject_wf_anat_preproc_wf_anat_reports_wf_ds_t1w_dseg_mask_report</title>
+<ellipse fill="none" stroke="black" cx="2313" cy="-209" rx="105.08" ry="18"/>
+<text text-anchor="middle" x="2313" y="-205.3" font-family="Times,serif" font-size="14.00">ds_t1w_dseg_mask_report</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_reports_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_reports_wf_ds_t1w_dseg_mask_report -->
+<g id="edge255" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_reports_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_reports_wf_ds_t1w_dseg_mask_report</title>
+<path fill="none" stroke="black" d="M2330.07,-335.39C2338.36,-325.63 2347.63,-312.58 2352,-299 2356.9,-283.77 2356.99,-278.2 2352,-263 2348.82,-253.33 2343.13,-243.96 2337.06,-235.87"/>
+<polygon fill="black" stroke="black" points="2339.85,-233.75 2330.84,-228.18 2334.41,-238.16 2339.85,-233.75"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_reports_wf_norm_msk -->
+<g id="node131" class="node">
+<title>single_subject_wf_anat_preproc_wf_anat_reports_wf_norm_msk</title>
+<ellipse fill="none" stroke="black" cx="2573" cy="-209" rx="78.79" ry="18"/>
+<text text-anchor="middle" x="2573" y="-205.3" font-family="Times,serif" font-size="14.00">norm_msk (utility)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_reports_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_reports_wf_norm_msk -->
+<g id="edge262" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_reports_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_reports_wf_norm_msk</title>
+<path fill="none" stroke="black" d="M2385.78,-347.11C2453.42,-340.95 2547.63,-327.49 2571,-299 2584.68,-282.33 2581.42,-257.49 2577.04,-238.29"/>
+<polygon fill="black" stroke="black" points="2580.46,-237.53 2574.67,-228.65 2573.66,-239.2 2580.46,-237.53"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_reports_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_reports_wf_norm_msk -->
+<g id="edge263" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_reports_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_reports_wf_norm_msk</title>
+<path fill="none" stroke="black" d="M2386.87,-348.16C2459.72,-342.53 2564.21,-329.22 2589,-299 2602.87,-282.09 2599.33,-256.79 2591.84,-237.48"/>
+<polygon fill="black" stroke="black" points="2595.13,-236.26 2587.84,-228.56 2588.74,-239.12 2595.13,-236.26"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_reports_wf_ds_recon_report -->
+<g id="node132" class="node">
+<title>single_subject_wf_anat_preproc_wf_anat_reports_wf_ds_recon_report</title>
+<ellipse fill="none" stroke="black" cx="2737" cy="-209" rx="67.69" ry="18"/>
+<text text-anchor="middle" x="2737" y="-205.3" font-family="Times,serif" font-size="14.00">ds_recon_report</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_reports_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_reports_wf_ds_recon_report -->
+<g id="edge268" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_reports_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_reports_wf_ds_recon_report</title>
+<path fill="none" stroke="black" d="M2387.96,-349.16C2515.9,-343.49 2767.43,-328.66 2794,-299 2812.08,-278.82 2790.34,-252.31 2768.7,-233.49"/>
+<polygon fill="black" stroke="black" points="2770.97,-230.82 2761.03,-227.14 2766.51,-236.21 2770.97,-230.82"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_reports_wf_norm_rpt -->
+<g id="node133" class="node">
+<title>single_subject_wf_anat_preproc_wf_anat_reports_wf_norm_rpt</title>
+<ellipse fill="none" stroke="black" cx="2657" cy="-137" rx="85.29" ry="18"/>
+<text text-anchor="middle" x="2657" y="-133.3" font-family="Times,serif" font-size="14.00">norm_rpt (reportlets)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_reports_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_reports_wf_norm_rpt -->
+<g id="edge261" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_reports_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_reports_wf_norm_rpt</title>
+<path fill="none" stroke="black" d="M2387.89,-348.89C2517.19,-342.74 2773.62,-327.12 2803,-299 2840.41,-263.19 2845.17,-224.36 2814,-183 2803.76,-169.41 2768.62,-158.67 2734.17,-151.1"/>
+<polygon fill="black" stroke="black" points="2735.03,-147.71 2724.52,-149.07 2733.59,-154.56 2735.03,-147.71"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_reports_wf_ds_std_t1w_report -->
+<g id="node134" class="node">
+<title>single_subject_wf_anat_preproc_wf_anat_reports_wf_ds_std_t1w_report</title>
+<ellipse fill="none" stroke="black" cx="2769" cy="-65" rx="76.09" ry="18"/>
+<text text-anchor="middle" x="2769" y="-61.3" font-family="Times,serif" font-size="14.00">ds_std_t1w_report</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_reports_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_reports_wf_ds_std_t1w_report -->
+<g id="edge264" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_reports_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_reports_wf_ds_std_t1w_report</title>
+<path fill="none" stroke="black" d="M2388.01,-349.09C2519.43,-343.35 2782.3,-328.51 2812,-299 2868.02,-243.35 2811.86,-141.48 2783.17,-93.01"/>
+<polygon fill="black" stroke="black" points="2786.25,-91.34 2778.13,-84.54 2780.24,-94.93 2786.25,-91.34"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_reports_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_reports_wf_ds_std_t1w_report -->
+<g id="edge265" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_reports_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_reports_wf_ds_std_t1w_report</title>
+<path fill="none" stroke="black" d="M2388.27,-349.51C2523.74,-344.11 2799.53,-329.27 2830,-299 2886.51,-242.86 2828.86,-139.69 2792.81,-91.75"/>
+<polygon fill="black" stroke="black" points="2795.77,-89.85 2786.86,-84.12 2790.25,-94.16 2795.77,-89.85"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_reports_wf_t1w_conform_check&#45;&gt;single_subject_wf_anat_preproc_wf_anat_reports_wf_ds_t1w_conform_report -->
+<g id="edge269" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_reports_wf_t1w_conform_check&#45;&gt;single_subject_wf_anat_preproc_wf_anat_reports_wf_ds_t1w_conform_report</title>
+<path fill="none" stroke="black" d="M2050.1,-262.7C2056.13,-254.73 2063.42,-245.1 2070.11,-236.26"/>
+<polygon fill="black" stroke="black" points="2072.89,-238.4 2076.14,-228.31 2067.31,-234.17 2072.89,-238.4"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_reports_wf_seg_rpt&#45;&gt;single_subject_wf_anat_preproc_wf_anat_reports_wf_ds_t1w_dseg_mask_report -->
+<g id="edge270" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_reports_wf_seg_rpt&#45;&gt;single_subject_wf_anat_preproc_wf_anat_reports_wf_ds_t1w_dseg_mask_report</title>
+<path fill="none" stroke="black" d="M2276.62,-263.05C2282.08,-255.09 2288.72,-245.41 2294.82,-236.51"/>
+<polygon fill="black" stroke="black" points="2297.53,-238.75 2300.3,-228.52 2291.76,-234.79 2297.53,-238.75"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_reports_wf_tf_select&#45;&gt;single_subject_wf_anat_preproc_wf_anat_reports_wf_norm_msk -->
+<g id="edge271" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_reports_wf_tf_select&#45;&gt;single_subject_wf_anat_preproc_wf_anat_reports_wf_norm_msk</title>
+<path fill="none" stroke="black" d="M2493.6,-263.05C2505.41,-253.83 2521.24,-242.29 2535.7,-232.34"/>
+<polygon fill="black" stroke="black" points="2537.39,-235.43 2543.7,-226.92 2533.46,-229.63 2537.39,-235.43"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_reports_wf_tf_select&#45;&gt;single_subject_wf_anat_preproc_wf_anat_reports_wf_norm_msk -->
+<g id="edge272" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_reports_wf_tf_select&#45;&gt;single_subject_wf_anat_preproc_wf_anat_reports_wf_norm_msk</title>
+<path fill="none" stroke="black" d="M2504.83,-263.41C2518.06,-254.56 2533.56,-243.52 2546.49,-233.77"/>
+<polygon fill="black" stroke="black" points="2548.37,-236.74 2554.18,-227.88 2544.12,-231.18 2548.37,-236.74"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_reports_wf_recon_report&#45;&gt;single_subject_wf_anat_preproc_wf_anat_reports_wf_ds_recon_report -->
+<g id="edge273" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_reports_wf_recon_report&#45;&gt;single_subject_wf_anat_preproc_wf_anat_reports_wf_ds_recon_report</title>
+<path fill="none" stroke="black" d="M2706.89,-262.7C2711.34,-254.9 2716.71,-245.51 2721.67,-236.83"/>
+<polygon fill="black" stroke="black" points="2724.55,-238.84 2726.48,-228.42 2718.47,-235.36 2724.55,-238.84"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_reports_wf_norm_msk&#45;&gt;single_subject_wf_anat_preproc_wf_anat_reports_wf_norm_rpt -->
+<g id="edge274" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_reports_wf_norm_msk&#45;&gt;single_subject_wf_anat_preproc_wf_anat_reports_wf_norm_rpt</title>
+<path fill="none" stroke="black" d="M2587.46,-191.05C2597.12,-182.22 2610.08,-171.27 2622.23,-161.62"/>
+<polygon fill="black" stroke="black" points="2624.38,-164.39 2630.11,-155.48 2620.08,-158.86 2624.38,-164.39"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_reports_wf_norm_msk&#45;&gt;single_subject_wf_anat_preproc_wf_anat_reports_wf_norm_rpt -->
+<g id="edge275" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_reports_wf_norm_msk&#45;&gt;single_subject_wf_anat_preproc_wf_anat_reports_wf_norm_rpt</title>
+<path fill="none" stroke="black" d="M2598.28,-191.76C2609.66,-183.1 2622.9,-172.25 2633.99,-162.57"/>
+<polygon fill="black" stroke="black" points="2636.08,-165.4 2641.22,-156.13 2631.42,-160.17 2636.08,-165.4"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_reports_wf_norm_rpt&#45;&gt;single_subject_wf_anat_preproc_wf_anat_reports_wf_ds_std_t1w_report -->
+<g id="edge276" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_reports_wf_norm_rpt&#45;&gt;single_subject_wf_anat_preproc_wf_anat_reports_wf_ds_std_t1w_report</title>
+<path fill="none" stroke="black" d="M2683.54,-119.41C2698.43,-110.1 2717.21,-98.37 2733.37,-88.27"/>
+<polygon fill="black" stroke="black" points="2735.13,-91.3 2741.75,-83.03 2731.42,-85.36 2735.13,-91.3"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_derivatives_wf_raw_sources -->
+<g id="node136" class="node">
+<title>single_subject_wf_anat_preproc_wf_anat_derivatives_wf_raw_sources</title>
+<ellipse fill="none" stroke="black" cx="108" cy="-281" rx="83.69" ry="18"/>
+<text text-anchor="middle" x="108" y="-277.3" font-family="Times,serif" font-size="14.00">raw_sources (utility)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_raw_sources -->
+<g id="edge277" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_raw_sources</title>
+<path fill="none" stroke="black" d="M1103.8,-351.22C939.32,-348.79 535.51,-338.91 200,-299 193.01,-298.17 185.76,-297.13 178.52,-295.98"/>
+<polygon fill="black" stroke="black" points="179.15,-292.54 168.71,-294.35 178,-299.44 179.15,-292.54"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_t1w_preproc -->
+<g id="node137" class="node">
+<title>single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_t1w_preproc</title>
+<ellipse fill="none" stroke="black" cx="277" cy="-281" rx="67.69" ry="18"/>
+<text text-anchor="middle" x="277" y="-277.3" font-family="Times,serif" font-size="14.00">ds_t1w_preproc</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_t1w_preproc -->
+<g id="edge278" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_t1w_preproc</title>
+<path fill="none" stroke="black" d="M1103.73,-351.18C956.74,-348.7 621.92,-338.75 344,-299 340.14,-298.45 336.18,-297.8 332.2,-297.09"/>
+<polygon fill="black" stroke="black" points="333.02,-293.69 322.54,-295.24 331.7,-300.56 333.02,-293.69"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_t1w_preproc -->
+<g id="edge279" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_t1w_preproc</title>
+<path fill="none" stroke="black" d="M1103.82,-351C959.34,-348.22 633.52,-337.84 362,-299 354.89,-297.98 347.46,-296.66 340.06,-295.19"/>
+<polygon fill="black" stroke="black" points="340.9,-291.79 330.4,-293.19 339.48,-298.65 340.9,-291.79"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_t1w_tpms -->
+<g id="node138" class="node">
+<title>single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_t1w_tpms</title>
+<ellipse fill="none" stroke="black" cx="420" cy="-281" rx="57.69" ry="18"/>
+<text text-anchor="middle" x="420" y="-277.3" font-family="Times,serif" font-size="14.00">ds_t1w_tpms</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_t1w_tpms -->
+<g id="edge282" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_t1w_tpms</title>
+<path fill="none" stroke="black" d="M1103.83,-350.71C974.64,-347.49 702.88,-336.43 477,-299 474.19,-298.53 471.33,-298.01 468.45,-297.43"/>
+<polygon fill="black" stroke="black" points="469.38,-294.05 458.86,-295.34 467.89,-300.89 469.38,-294.05"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_t1w_tpms -->
+<g id="edge283" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_t1w_tpms</title>
+<path fill="none" stroke="black" d="M1104.05,-350.42C977.64,-346.86 714.63,-335.39 495,-299 488.79,-297.97 482.32,-296.64 475.87,-295.17"/>
+<polygon fill="black" stroke="black" points="477.12,-291.87 466.58,-292.95 475.49,-298.68 477.12,-291.87"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_t1w_dseg -->
+<g id="node139" class="node">
+<title>single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_t1w_dseg</title>
+<ellipse fill="none" stroke="black" cx="552" cy="-281" rx="56.59" ry="18"/>
+<text text-anchor="middle" x="552" y="-277.3" font-family="Times,serif" font-size="14.00">ds_t1w_dseg</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_t1w_dseg -->
+<g id="edge284" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_t1w_dseg</title>
+<path fill="none" stroke="black" d="M1105.34,-349.14C995.9,-343.88 784.61,-330.21 608,-299 605.38,-298.54 602.72,-298.02 600.04,-297.47"/>
+<polygon fill="black" stroke="black" points="601.04,-294.11 590.52,-295.33 599.51,-300.94 601.04,-294.11"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_t1w_dseg -->
+<g id="edge285" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_t1w_dseg</title>
+<path fill="none" stroke="black" d="M1105.85,-348.57C999.51,-342.93 796.58,-329.14 626,-299 620.04,-297.95 613.83,-296.62 607.63,-295.18"/>
+<polygon fill="black" stroke="black" points="608.58,-291.81 598.04,-292.85 606.93,-298.61 608.58,-291.81"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_t1w2std_xfm -->
+<g id="node140" class="node">
+<title>single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_t1w2std_xfm</title>
+<ellipse fill="none" stroke="black" cx="696" cy="-281" rx="69.59" ry="18"/>
+<text text-anchor="middle" x="696" y="-277.3" font-family="Times,serif" font-size="14.00">ds_t1w2std_xfm</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_t1w2std_xfm -->
+<g id="edge286" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_t1w2std_xfm</title>
+<path fill="none" stroke="black" d="M1108.94,-345.98C1024.27,-337.43 878.96,-320.4 756,-299 753.94,-298.64 751.85,-298.27 749.75,-297.88"/>
+<polygon fill="black" stroke="black" points="750.42,-294.44 739.93,-295.97 749.08,-301.31 750.42,-294.44"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_t1w2std_xfm -->
+<g id="edge287" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_t1w2std_xfm</title>
+<path fill="none" stroke="black" d="M1111.02,-344.88C1030.34,-336.02 891.89,-319.52 774,-299 768.73,-298.08 763.28,-297.06 757.81,-295.97"/>
+<polygon fill="black" stroke="black" points="758.63,-292.57 748.13,-293.99 757.23,-299.42 758.63,-292.57"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_t1w2std_xfm -->
+<g id="edge288" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_t1w2std_xfm</title>
+<path fill="none" stroke="black" d="M1113.79,-343.7C1036.48,-334.59 904.83,-318.64 792,-299 783.26,-297.48 774.02,-295.66 764.79,-293.78"/>
+<polygon fill="black" stroke="black" points="765.56,-290.36 755.06,-291.78 764.15,-297.22 765.56,-290.36"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_std2t1w_xfm -->
+<g id="node141" class="node">
+<title>single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_std2t1w_xfm</title>
+<ellipse fill="none" stroke="black" cx="853" cy="-281" rx="69.59" ry="18"/>
+<text text-anchor="middle" x="853" y="-277.3" font-family="Times,serif" font-size="14.00">ds_std2t1w_xfm</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_std2t1w_xfm -->
+<g id="edge289" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_std2t1w_xfm</title>
+<path fill="none" stroke="black" d="M1119.85,-341.44C1060.69,-329.64 970.76,-310.42 911.76,-297.05"/>
+<polygon fill="black" stroke="black" points="912.76,-293.69 902.23,-294.87 911.2,-300.51 912.76,-293.69"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_std2t1w_xfm -->
+<g id="edge290" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_std2t1w_xfm</title>
+<path fill="none" stroke="black" d="M1124.43,-340.28C1067.02,-327.95 976.74,-308.57 916.25,-295.58"/>
+<polygon fill="black" stroke="black" points="917.31,-292.23 906.79,-293.55 915.84,-299.07 917.31,-292.23"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_std2t1w_xfm -->
+<g id="edge291" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_std2t1w_xfm</title>
+<path fill="none" stroke="black" d="M1129.58,-339.08C1073.53,-326.24 982.46,-306.7 920.08,-294.14"/>
+<polygon fill="black" stroke="black" points="921.14,-290.79 910.65,-292.26 919.76,-297.65 921.14,-290.79"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_derivatives_wf_lta2itk_fwd -->
+<g id="node142" class="node">
+<title>single_subject_wf_anat_preproc_wf_anat_derivatives_wf_lta2itk_fwd</title>
+<ellipse fill="none" stroke="black" cx="1086" cy="-281" rx="104.78" ry="18"/>
+<text text-anchor="middle" x="1086" y="-277.3" font-family="Times,serif" font-size="14.00">lta2itk_fwd (nitransforms)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_lta2itk_fwd -->
+<g id="edge292" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_lta2itk_fwd</title>
+<path fill="none" stroke="black" d="M1156.96,-335.41C1145.2,-326.56 1130.53,-315.52 1117.58,-305.77"/>
+<polygon fill="black" stroke="black" points="1119.83,-303.08 1109.74,-299.87 1115.62,-308.68 1119.83,-303.08"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_derivatives_wf_lta2itk_inv -->
+<g id="node143" class="node">
+<title>single_subject_wf_anat_preproc_wf_anat_derivatives_wf_lta2itk_inv</title>
+<ellipse fill="none" stroke="black" cx="1595" cy="-281" rx="102.08" ry="18"/>
+<text text-anchor="middle" x="1595" y="-277.3" font-family="Times,serif" font-size="14.00">lta2itk_inv (nitransforms)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_lta2itk_inv -->
+<g id="edge293" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_lta2itk_inv</title>
+<path fill="none" stroke="black" d="M1239.05,-341.9C1310.82,-329.82 1431.33,-309.54 1511.99,-295.97"/>
+<polygon fill="black" stroke="black" points="1512.32,-299.46 1521.6,-294.35 1511.16,-292.56 1512.32,-299.46"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_derivatives_wf_name_surfs -->
+<g id="node144" class="node">
+<title>single_subject_wf_anat_preproc_wf_anat_derivatives_wf_name_surfs</title>
+<ellipse fill="none" stroke="black" cx="1828" cy="-281" rx="73.39" ry="18"/>
+<text text-anchor="middle" x="1828" y="-277.3" font-family="Times,serif" font-size="14.00">name_surfs (surf)</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_name_surfs -->
+<g id="edge296" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_name_surfs</title>
+<path fill="none" stroke="black" d="M1251.13,-347.49C1358.34,-340.27 1565.92,-324.3 1741,-299 1748,-297.99 1755.28,-296.79 1762.53,-295.51"/>
+<polygon fill="black" stroke="black" points="1763.15,-298.96 1772.35,-293.71 1761.89,-292.07 1763.15,-298.96"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_t1w_fsaseg -->
+<g id="node145" class="node">
+<title>single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_t1w_fsaseg</title>
+<ellipse fill="none" stroke="black" cx="1271" cy="-281" rx="62.29" ry="18"/>
+<text text-anchor="middle" x="1271" y="-277.3" font-family="Times,serif" font-size="14.00">ds_t1w_fsaseg</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_t1w_fsaseg -->
+<g id="edge299" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_t1w_fsaseg</title>
+<path fill="none" stroke="black" d="M1195.39,-335.05C1206.59,-325.78 1221.69,-314.19 1235.49,-304.2"/>
+<polygon fill="black" stroke="black" points="1237.43,-307.12 1243.55,-298.47 1233.37,-301.41 1237.43,-307.12"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_t1w_fsaseg -->
+<g id="edge300" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_t1w_fsaseg</title>
+<path fill="none" stroke="black" d="M1206.14,-335.76C1218.81,-326.88 1233.71,-315.71 1246.09,-305.85"/>
+<polygon fill="black" stroke="black" points="1248.25,-308.61 1253.81,-299.59 1243.84,-303.17 1248.25,-308.61"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_t1w_fsparc -->
+<g id="node146" class="node">
+<title>single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_t1w_fsparc</title>
+<ellipse fill="none" stroke="black" cx="1413" cy="-281" rx="61.99" ry="18"/>
+<text text-anchor="middle" x="1413" y="-277.3" font-family="Times,serif" font-size="14.00">ds_t1w_fsparc</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_t1w_fsparc -->
+<g id="edge301" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_t1w_fsparc</title>
+<path fill="none" stroke="black" d="M1221.35,-337.67C1259.57,-325.77 1315.9,-308.91 1357.66,-296.87"/>
+<polygon fill="black" stroke="black" points="1358.38,-300.3 1367.03,-294.18 1356.45,-293.57 1358.38,-300.3"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_t1w_fsparc -->
+<g id="edge302" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_t1w_fsparc</title>
+<path fill="none" stroke="black" d="M1227.85,-339C1267.56,-327.61 1323.22,-311.01 1363.18,-298.65"/>
+<polygon fill="black" stroke="black" points="1364.05,-302.05 1372.56,-295.74 1361.97,-295.36 1364.05,-302.05"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_t1w_mask -->
+<g id="node147" class="node">
+<title>single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_t1w_mask</title>
+<ellipse fill="none" stroke="black" cx="940" cy="-209" rx="59.59" ry="18"/>
+<text text-anchor="middle" x="940" y="-205.3" font-family="Times,serif" font-size="14.00">ds_t1w_mask</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_t1w_mask -->
+<g id="edge280" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_t1w_mask</title>
+<path fill="none" stroke="black" d="M1112.26,-344.39C1053.75,-336.04 974.9,-320.84 953,-299 937.23,-283.27 932.12,-258.14 932.21,-238.59"/>
+<polygon fill="black" stroke="black" points="935.69,-238.97 932.8,-228.78 928.71,-238.55 935.69,-238.97"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_t1w_mask -->
+<g id="edge281" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_t1w_mask</title>
+<path fill="none" stroke="black" d="M1115.98,-342.83C1062.56,-334.2 991.6,-319.54 971,-299 955.23,-283.27 950.12,-258.14 947.27,-238.59"/>
+<polygon fill="black" stroke="black" points="950.75,-238.2 945.91,-228.77 943.81,-239.15 950.75,-238.2"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_t1w_fsnative -->
+<g id="node148" class="node">
+<title>single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_t1w_fsnative</title>
+<ellipse fill="none" stroke="black" cx="1086" cy="-209" rx="68.49" ry="18"/>
+<text text-anchor="middle" x="1086" y="-205.3" font-family="Times,serif" font-size="14.00">ds_t1w_fsnative</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_t1w_fsnative -->
+<g id="edge294" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_t1w_fsnative</title>
+<path fill="none" stroke="black" d="M1113.09,-343.93C1059.25,-335.83 989.32,-321.31 972,-299 962.19,-286.36 963.4,-276.49 972,-263 983.59,-244.83 1003.2,-232.79 1022.92,-224.86"/>
+<polygon fill="black" stroke="black" points="1023.92,-228.22 1032.1,-221.49 1021.51,-221.65 1023.92,-228.22"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_fsnative_t1w -->
+<g id="node149" class="node">
+<title>single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_fsnative_t1w</title>
+<ellipse fill="none" stroke="black" cx="1648" cy="-209" rx="68.49" ry="18"/>
+<text text-anchor="middle" x="1648" y="-205.3" font-family="Times,serif" font-size="14.00">ds_fsnative_t1w</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_fsnative_t1w -->
+<g id="edge295" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_fsnative_t1w</title>
+<path fill="none" stroke="black" d="M1253.63,-349.93C1391.82,-345.32 1676.24,-331.91 1706,-299 1724.35,-278.71 1701.97,-252.06 1679.9,-233.23"/>
+<polygon fill="black" stroke="black" points="1682.36,-230.72 1672.39,-227.13 1677.94,-236.15 1682.36,-230.72"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_surfs -->
+<g id="node150" class="node">
+<title>single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_surfs</title>
+<ellipse fill="none" stroke="black" cx="1782" cy="-209" rx="40.09" ry="18"/>
+<text text-anchor="middle" x="1782" y="-205.3" font-family="Times,serif" font-size="14.00">ds_surfs</text>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_surfs -->
+<g id="edge297" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_surfs</title>
+<path fill="none" stroke="black" d="M1254.5,-351.84C1381.26,-350.29 1630.14,-341.64 1706,-299 1712.94,-295.1 1738.7,-259.35 1758.58,-234.37"/>
+<polygon fill="black" stroke="black" points="1761.06,-236.87 1764.64,-226.9 1755.62,-232.46 1761.06,-236.87"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_surfs -->
+<g id="edge298" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_derivatives_wf_inputnode&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_surfs</title>
+<path fill="none" stroke="black" d="M1254.55,-351.95C1385.08,-350.75 1646,-342.84 1724,-299 1730.74,-295.21 1755.22,-261.41 1770.44,-236.58"/>
+<polygon fill="black" stroke="black" points="1773.29,-238.62 1775.36,-228.23 1767.27,-235.07 1773.29,-238.62"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_derivatives_wf_raw_sources&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_t1w_mask -->
+<g id="edge303" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_derivatives_wf_raw_sources&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_t1w_mask</title>
+<path fill="none" stroke="black" d="M167.73,-267.97C178.44,-266.09 189.53,-264.34 200,-263 444.87,-231.71 737.87,-217.56 869.68,-212.43"/>
+<polygon fill="black" stroke="black" points="869.41,-215.94 879.27,-212.06 869.15,-208.95 869.41,-215.94"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_derivatives_wf_lta2itk_fwd&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_t1w_fsnative -->
+<g id="edge304" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_derivatives_wf_lta2itk_fwd&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_t1w_fsnative</title>
+<path fill="none" stroke="black" d="M1086,-262.7C1086,-255.41 1086,-246.73 1086,-238.54"/>
+<polygon fill="black" stroke="black" points="1089.5,-238.62 1086,-228.62 1082.5,-238.62 1089.5,-238.62"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_derivatives_wf_lta2itk_inv&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_fsnative_t1w -->
+<g id="edge305" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_derivatives_wf_lta2itk_inv&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_fsnative_t1w</title>
+<path fill="none" stroke="black" d="M1608.1,-262.7C1614.13,-254.73 1621.42,-245.1 1628.11,-236.26"/>
+<polygon fill="black" stroke="black" points="1630.89,-238.4 1634.14,-228.31 1625.31,-234.17 1630.89,-238.4"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_derivatives_wf_name_surfs&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_surfs -->
+<g id="edge306" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_derivatives_wf_name_surfs&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_surfs</title>
+<path fill="none" stroke="black" d="M1810.99,-263.05C1805.04,-255.26 1798.6,-245.82 1793.2,-237.08"/>
+<polygon fill="black" stroke="black" points="1796.29,-235.43 1788.21,-228.58 1790.26,-238.98 1796.29,-235.43"/>
+</g>
+<!-- single_subject_wf_anat_preproc_wf_anat_derivatives_wf_name_surfs&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_surfs -->
+<g id="edge307" class="edge">
+<title>single_subject_wf_anat_preproc_wf_anat_derivatives_wf_name_surfs&#45;&gt;single_subject_wf_anat_preproc_wf_anat_derivatives_wf_ds_surfs</title>
+<path fill="none" stroke="black" d="M1822.54,-262.7C1817.88,-254.28 1811.33,-244.02 1804.78,-234.79"/>
+<polygon fill="black" stroke="black" points="1807.69,-232.85 1798.93,-226.89 1802.07,-237.01 1807.69,-232.85"/>
+</g>
+</g>
+</svg>

From c8cc5e734a39778849ee98cdfe7c99cbd01937a0 Mon Sep 17 00:00:00 2001
From: Tom Close <tom.g.close@gmail.com>
Date: Fri, 24 Nov 2023 09:23:37 +1100
Subject: [PATCH 19/78] Revert "deleted workflow test"

This reverts commit 8a0128dd780ffdf269fc16349a7339847c41ad5e.
---
 tests/test_workflow.py | 32 ++++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)
 create mode 100644 tests/test_workflow.py

diff --git a/tests/test_workflow.py b/tests/test_workflow.py
new file mode 100644
index 00000000..0d3164b6
--- /dev/null
+++ b/tests/test_workflow.py
@@ -0,0 +1,32 @@
+import yaml
+import pytest
+from nipype2pydra.cli import workflow
+from nipype2pydra.utils import show_cli_trace
+from nipype2pydra.workflow import WorkflowConverter
+
+
+@pytest.mark.xfail(reason="Workflow conversion hasn't been fully implemented yet")
+def test_workflow_conversion(workflow_spec_file, cli_runner, work_dir):
+
+    output_file = work_dir / "pydra_module.py"
+
+    result = cli_runner(
+        workflow,
+        [
+            str(workflow_spec_file),
+            str(output_file)
+        ]
+    )
+
+    assert result.exit_code == 0, show_cli_trace(result)
+
+
+@pytest.mark.xfail(reason="Workflow conversion hasn't been fully implemented yet")
+def test_workflow_graph(workflow_spec_file, work_dir):
+
+    with open(workflow_spec_file) as f:
+        spec = yaml.safe_load(f)
+
+    converter = WorkflowConverter(spec)
+
+    converter.save_graph(work_dir / "smriprep-graph.svg")

From e89299f88d82c3da57dd5f9cd4b5518cc8833e50 Mon Sep 17 00:00:00 2001
From: Tom Close <tom.g.close@gmail.com>
Date: Fri, 24 Nov 2023 09:23:37 +1100
Subject: [PATCH 20/78] tidied up workflows linting

---
 nipype2pydra/workflow.py | 24 ++++++++++++++++++------
 pyproject.toml           |  1 +
 pytest.ini               |  2 +-
 3 files changed, 20 insertions(+), 7 deletions(-)

diff --git a/nipype2pydra/workflow.py b/nipype2pydra/workflow.py
index 5debe661..2cee3f46 100644
--- a/nipype2pydra/workflow.py
+++ b/nipype2pydra/workflow.py
@@ -1,4 +1,5 @@
 from __future__ import annotations
+import typing as ty
 import json
 import tempfile
 from pathlib import Path
@@ -16,12 +17,21 @@ def __init__(self, spec):
 
         self.wf = load_class_or_func(self.spec["function"])(
             **self._parse_workflow_args(self.spec["args"])
-        )  # loads the 'function' in smriprep.yaml, and implement the args (creates a dictionary)
+        ) 
+        # loads the 'function' in smriprep.yaml, and implement the args (creates a
+        # dictionary)
 
-    def node_connections(self, workflow, functions: dict[str, dict], wf_inputs: dict[str, str], wf_outputs: dict[str, str]):
-        connections = defaultdict(dict)
+    def node_connections(
+        self,
+        workflow,
+        functions: dict[str, dict],
+        wf_inputs: dict[str, str],
+        wf_outputs: dict[str, str],
+    ):
+        connections: defaultdict = defaultdict(dict)
 
-        # iterates over wf graph, Get connections from workflow graph, store connections in a dictionary
+        # iterates over wf graph, Get connections from workflow graph, store connections
+        # in a dictionary
         for edge, props in workflow._graph.edges.items():
             src_node = edge[0].name
             dest_node = edge[1].name
@@ -88,9 +98,11 @@ def _parse_workflow_args(cls, args):
             dct[name] = val
         return dct
 
-    def save_graph(self, out_path: Path, format: str = "svg", work_dir: Path = None):
+    def save_graph(
+        self, out_path: Path, format: str = "svg", work_dir: ty.Optional[Path] = None
+    ):
         if work_dir is None:
-            work_dir = tempfile.mkdtemp()
+            work_dir = Path(tempfile.mkdtemp())
         work_dir = Path(work_dir)
         graph_dot_path = work_dir / "wf-graph.dot"
         self.wf.write_hierarchical_dotfile(graph_dot_path)
diff --git a/pyproject.toml b/pyproject.toml
index 540c91da..14e7c129 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -96,6 +96,7 @@ exclude = [
 ]
 
 [tool.black]
+line-length = 88
 target-version = ['py37']
 exclude = "nipype2pydra/_version.py"
 
diff --git a/pytest.ini b/pytest.ini
index 0d9fb769..ca0c9f17 100644
--- a/pytest.ini
+++ b/pytest.ini
@@ -1,2 +1,2 @@
 [pytest]
-addopts = -s
\ No newline at end of file
+addopts = -s

From cd73529fd28d0e57078005782799b2ccf0804a66 Mon Sep 17 00:00:00 2001
From: Tom Close <tom.g.close@gmail.com>
Date: Tue, 6 Feb 2024 14:22:27 +1100
Subject: [PATCH 21/78] removed debugging line

---
 .gitignore           | 4 ++++
 nipype2pydra/task.py | 2 --
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/.gitignore b/.gitignore
index b727c5a1..c1c78a84 100644
--- a/.gitignore
+++ b/.gitignore
@@ -23,3 +23,7 @@ __pycache__
 /Test.venv
 /test-data
 /nipype2pydra/_version.py
+<<<<<<< HEAD
+=======
+*.venv-py38
+>>>>>>> 9611b94 (added py38 to gitignore)
diff --git a/nipype2pydra/task.py b/nipype2pydra/task.py
index 3817675b..5ac196b1 100644
--- a/nipype2pydra/task.py
+++ b/nipype2pydra/task.py
@@ -818,8 +818,6 @@ def unwrap_nested_type(t: type) -> ty.List[type]:
 
         for tp in itertools.chain(*(unwrap_nested_type(t) for t in nonstd_types)):
             add_import(f"from {tp.__module__} import {tp.__name__}")
-        # For debugging
-        add_import(f"import {'.'.join(self.output_module.split('.')[:-2])}")
         if include_task:
             add_import(f"from {self.output_module} import {self.task_name}")
 

From 2f30a35461376ab4a0371170f95cb6b35ca77108 Mon Sep 17 00:00:00 2001
From: Tom Close <tom.g.close@gmail.com>
Date: Wed, 20 Dec 2023 17:31:34 +1100
Subject: [PATCH 22/78] updated extras module generation template

---
 scripts/pkg_gen/create_packages.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/scripts/pkg_gen/create_packages.py b/scripts/pkg_gen/create_packages.py
index 23f3cae1..c80cc1b2 100644
--- a/scripts/pkg_gen/create_packages.py
+++ b/scripts/pkg_gen/create_packages.py
@@ -778,7 +778,7 @@ def gen_fileformats_extras_module(pkg: str, pkg_formats: ty.Set[str]):
         code_str += f"""
 
 @FileSet.generate_sample_data.register
-def gen_sample_{frmt.lower()}_data({frmt.lower()}: {frmt}, dest_dir: Path, seed: ty.Union[int, Random], stem: ty.Optional[str]):
+def gen_sample_{frmt.lower()}_data({frmt.lower()}: {frmt}, dest_dir: Path, seed: ty.Union[int, Random] = 0, stem: ty.Optional[str] = None) -> ty.Iterable[Path]:
     raise NotImplementedError
 """
     return code_str

From 313c6ea8469eb95c8ebb467aec89db8223599b84 Mon Sep 17 00:00:00 2001
From: Tom Close <tom.g.close@gmail.com>
Date: Wed, 20 Dec 2023 17:31:51 +1100
Subject: [PATCH 23/78] updated smriprep template

---
 example-specs/workflow/smriprep.yaml | 76 ++++++++++++++--------------
 1 file changed, 37 insertions(+), 39 deletions(-)

diff --git a/example-specs/workflow/smriprep.yaml b/example-specs/workflow/smriprep.yaml
index 0b196a0c..d1454320 100644
--- a/example-specs/workflow/smriprep.yaml
+++ b/example-specs/workflow/smriprep.yaml
@@ -1,40 +1,38 @@
-module: smriprep.workflows.base
-workflows:
-    init_single_subject_wf:
-        args:
-            debug: false
-            freesurfer: true
-            fast_track: false
-            hires: true
-            layout:
-                type: bids:BIDSLayout
-                args:
-                    root: test-data/bids-data/ds000113
-            longitudinal: false
-            low_mem: false
-            name: single_subject_wf
-            omp_nthreads: 1
-            output_dir: .
-            skull_strip_fixed_seed: false
-            skull_strip_mode: force
-            skull_strip_template:
-                type: niworkflows.utils.spaces:Reference
-                args:
-                    space: OASIS30ANTs
-            spaces:
-                type: niworkflows.utils.spaces:SpatialReferences
-                args:
-                    spaces:
-                    - MNI152NLin2009cAsym
-                    - fsaverage5
-            subject_id: test
-            bids_filters: null
-    splits:
-        - func_name: registration
-            first_node: ds_surfs
-        - func_name: segmentation
-            first_node: lta2itk_fwd
-    ignore_tasks:
-        - smriprep.interfaces.DerivativesDataSink
-        - nipype.interfaces.utility.base.IdentityInterface
+function: smriprep.workflows.base:init_single_subject_wf
+args:
+  debug: false
+  freesurfer: true
+  fast_track: false
+  hires: true
+  layout:
+    type: bids:BIDSLayout
+    args:
+      root: test-data/bids-data/ds000113
+  longitudinal: false
+  low_mem: false
+  name: single_subject_wf
+  omp_nthreads: 1
+  output_dir: .
+  skull_strip_fixed_seed: false
+  skull_strip_mode: force
+  skull_strip_template:
+    type: niworkflows.utils.spaces:Reference
+    args:
+      space: OASIS30ANTs
+  spaces:
+    type: niworkflows.utils.spaces:SpatialReferences
+    args:
+      spaces:
+      - MNI152NLin2009cAsym
+      - fsaverage5
+  subject_id: test
+  bids_filters: null
+splits:
+- func_name: registration
+  first_node: ds_surfs
+- func_name: segmentation
+  first_node: lta2itk_fwd
+ignore_tasks:
+- smriprep.interfaces.DerivativesDataSink
+- nipype.interfaces.utility.base.IdentityInterface
 

From 8161493775523c32f0faf7b6587089601c9af949 Mon Sep 17 00:00:00 2001
From: Tom Close <tom.g.close@gmail.com>
Date: Wed, 20 Dec 2023 17:37:04 +1100
Subject: [PATCH 24/78] updated test_workflow

---
 tests/test_workflow.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/test_workflow.py b/tests/test_workflow.py
index 0d3164b6..fb07f908 100644
--- a/tests/test_workflow.py
+++ b/tests/test_workflow.py
@@ -21,7 +21,7 @@ def test_workflow_conversion(workflow_spec_file, cli_runner, work_dir):
     assert result.exit_code == 0, show_cli_trace(result)
 
 
-@pytest.mark.xfail(reason="Workflow conversion hasn't been fully implemented yet")
+# @pytest.mark.xfail(reason="Workflow conversion hasn't been fully implemented yet")
 def test_workflow_graph(workflow_spec_file, work_dir):
 
     with open(workflow_spec_file) as f:

From 910a79ee1daf12cdc9ae44cae849bf42793a0fbc Mon Sep 17 00:00:00 2001
From: Tom Close <tom.g.close@gmail.com>
Date: Fri, 19 Jan 2024 09:04:31 +1100
Subject: [PATCH 25/78] cleaned up workflow conversion and added example specs
 for *prep workflows

---
 .gitignore                           |  2 +-
 conftest.py                          |  8 +++-
 example-specs/workflow/dmriprep.yaml | 62 ++++++++++++++++++++++++++++
 example-specs/workflow/fmriprep.yaml | 62 ++++++++++++++++++++++++++++
 example-specs/workflow/qsiprep.yaml  | 59 ++++++++++++++++++++++++++
 nipype2pydra/cli.py                  |  7 ++--
 nipype2pydra/workflow.py             | 18 ++++----
 tests/test_workflow.py               | 11 ++---
 8 files changed, 211 insertions(+), 18 deletions(-)
 create mode 100644 example-specs/workflow/dmriprep.yaml
 create mode 100644 example-specs/workflow/fmriprep.yaml
 create mode 100644 example-specs/workflow/qsiprep.yaml

diff --git a/.gitignore b/.gitignore
index c1c78a84..a05acc53 100644
--- a/.gitignore
+++ b/.gitignore
@@ -20,7 +20,7 @@ __pycache__
 *.egg-info
 ~*
 /outputs
-/Test.venv
+*.venv
 /test-data
 /nipype2pydra/_version.py
 <<<<<<< HEAD
diff --git a/conftest.py b/conftest.py
index 9cad16c8..ba659727 100644
--- a/conftest.py
+++ b/conftest.py
@@ -4,7 +4,6 @@
 import tempfile
 import pytest
 from click.testing import CliRunner
-from fileformats.generic import File
 
 
 PKG_DIR = Path(__file__).parent
@@ -34,6 +33,13 @@ def work_dir():
     return Path(work_dir)
 
 
+@pytest.fixture
+def outputs_dir():
+    outputs_dir = PKG_DIR / "outputs" / 'workflows'
+    outputs_dir.mkdir(parents=True, exist_ok=True)
+    return outputs_dir
+
+
 @pytest.fixture
 def cli_runner(catch_cli_exceptions):
     def invoke(*args, catch_exceptions=catch_cli_exceptions, **kwargs):
diff --git a/example-specs/workflow/dmriprep.yaml b/example-specs/workflow/dmriprep.yaml
new file mode 100644
index 00000000..06a326eb
--- /dev/null
+++ b/example-specs/workflow/dmriprep.yaml
@@ -0,0 +1,62 @@
+function: dmriprep.default:default_workflow
+args:
+  subject_id: test
+  # bids_dir:
+  # bids_filters:
+  # debug:
+  # derivatives:
+  # echo_idx:
+  # fmriprep_dir:
+  # get:
+  layout:
+    type: bids:BIDSLayout
+    args:
+      root: /Users/tclose/Data/openneuro/ds000114
+  # output_dir:
+  # sloppy:
+  # task_id:
+  # version:
+  # nipype_version:
+  # anat_only:
+  # cifti_output:
+  # force_syn:
+  # hires:
+  ignore: []
+  # level:
+  # longitudinal:
+  # run_msmsulc:
+  # run_reconall:
+  # skull_strip_t1w:
+  # skull_strip_template:
+  # skull_strip_fixed_seed:
+  # spaces:
+  # use_syn_sdc:
+splits:
+- func_name: registration
+  first_node: ds_surfs
+- func_name: segmentation
+  first_node: lta2itk_fwd
+ignore_tasks:
+- smriprep.interfaces.DerivativesDataSink
+- nipype.interfaces.utility.base.IdentityInterface
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/example-specs/workflow/fmriprep.yaml b/example-specs/workflow/fmriprep.yaml
new file mode 100644
index 00000000..8ef18130
--- /dev/null
+++ b/example-specs/workflow/fmriprep.yaml
@@ -0,0 +1,62 @@
+function: fmriprep.default:default_workflow
+args:
+  subject_id: test
+  # bids_dir:
+  # bids_filters:
+  # debug:
+  # derivatives:
+  # echo_idx:
+  # fmriprep_dir:
+  # get:
+  layout:
+    type: bids:BIDSLayout
+    args:
+      root: /Users/tclose/Data/openneuro/ds000114
+  # output_dir:
+  # sloppy:
+  # task_id:
+  # version:
+  # nipype_version:
+  # anat_only:
+  # cifti_output:
+  # force_syn:
+  # hires:
+  ignore: []
+  # level:
+  # longitudinal:
+  # run_msmsulc:
+  # run_reconall:
+  # skull_strip_t1w:
+  # skull_strip_template:
+  # skull_strip_fixed_seed:
+  # spaces:
+  # use_syn_sdc:
+splits:
+- func_name: registration
+  first_node: ds_surfs
+- func_name: segmentation
+  first_node: lta2itk_fwd
+ignore_tasks:
+- smriprep.interfaces.DerivativesDataSink
+- nipype.interfaces.utility.base.IdentityInterface
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/example-specs/workflow/qsiprep.yaml b/example-specs/workflow/qsiprep.yaml
new file mode 100644
index 00000000..649f7035
--- /dev/null
+++ b/example-specs/workflow/qsiprep.yaml
@@ -0,0 +1,59 @@
+function: qsiprep.workflows.base:init_single_subject_wf
+args:
+  subject_id: test
+  name: single_subject_qsipreptest_wf
+  reportlets_dir: .
+  output_dir: .
+  bids_dir: .
+  bids_filters: null
+  anatomical_contrast: T1w
+  ignore: []
+  debug: false
+  low_mem: false
+  output_resolution: 1.25
+  denoise_before_combining: true
+  dwi_denoise_window: 7
+  denoise_method: patch2self
+  unringing_method: mrdegibbs
+  b1_biascorrect_stage: false
+  no_b0_harmonization: false
+  dwi_only: false
+  anat_only: false
+  longitudinal: false
+  b0_threshold: 100
+  freesurfer: false
+  hires: false
+  raw_image_sdc: false
+  force_spatial_normalization: true
+  combine_all_dwis: true
+  distortion_group_merge: none
+  pepolar_method: TOPUP
+  omp_nthreads: 1
+  skull_strip_template: OASIS
+  skull_strip_fixed_seed: false
+  template: MNI152NLin2009cAsym
+  prefer_dedicated_fmaps: false
+  motion_corr_to: iterative
+  b0_to_t1w_transform: Rigid
+  intramodal_template_iters: 0
+  intramodal_template_transform: Rigid
+  hmc_model: 3dSHORE
+  hmc_transform: Affine
+  eddy_config: null
+  shoreline_iters: 2
+  infant_mode: false
+  impute_slice_threshold: 0.0
+  write_local_bvecs: false
+  fmap_bspline: false
+  fmap_demean: true
+  use_syn: false
+  force_syn: false
+splits:
+# - func_name: registration
+#   first_node: ds_surfs
+# - func_name: segmentation
+#   first_node: lta2itk_fwd
+ignore_tasks:
+# - smriprep.interfaces.DerivativesDataSink
+- nipype.interfaces.utility.base.IdentityInterface
+
diff --git a/nipype2pydra/cli.py b/nipype2pydra/cli.py
index d61a202b..11d054a0 100644
--- a/nipype2pydra/cli.py
+++ b/nipype2pydra/cli.py
@@ -56,10 +56,11 @@ def task(yaml_spec, package_root, callables, output_module):
 
 @cli.command(help="Port Nipype workflow creation functions to Pydra")
 @click.argument("yaml-spec", type=click.File())
-@click.argument("package-root", type=click.File(mode="w"))
-def workflow(yaml_spec, package_root):
+@click.argument("output_file", type=click.Path(path_type=Path))
+def workflow(yaml_spec, output_file):
 
     spec = yaml.safe_load(yaml_spec)
 
     converter = WorkflowConverter(spec)
-    converter.generate(package_root)
+    out_str = converter.generate()
+    output_file.write_text(out_str)
diff --git a/nipype2pydra/workflow.py b/nipype2pydra/workflow.py
index 2cee3f46..95ae89ad 100644
--- a/nipype2pydra/workflow.py
+++ b/nipype2pydra/workflow.py
@@ -25,8 +25,8 @@ def node_connections(
         self,
         workflow,
         functions: dict[str, dict],
-        wf_inputs: dict[str, str],
-        wf_outputs: dict[str, str],
+        # wf_inputs: dict[str, str],
+        # wf_outputs: dict[str, str],
     ):
         connections: defaultdict = defaultdict(dict)
 
@@ -39,8 +39,8 @@ def node_connections(
             for node_conn in props["connect"]:
                 src_field = node_conn[0]
                 dest_field = node_conn[1]
-                if src_field.startswith("def"):
-                    functions[dest_node_fullname][dest_field] = src_field
+                if src_field[1].startswith("def"):
+                    functions[dest_node_fullname][dest_field] = src_field[1]
                 else:
                     connections[dest_node_fullname][
                         dest_field
@@ -50,7 +50,7 @@ def node_connections(
             connections.update(self.node_connections(nested_wf, functions=functions))
         return connections
 
-    def generate(self, package_root: str, format_with_black: bool = False):
+    def generate(self, format_with_black: bool = False):
 
         functions = defaultdict(dict)
         connections = self.node_connections(self.wf, functions=functions)
@@ -77,9 +77,11 @@ def generate(self, package_root: str, format_with_black: bool = False):
                 node_args += f",\n        {arg}=wf.{val}"
 
             out_text += f"""
-    wf.add({task_type}(
-        name="{node.name}"{node_args}
-)"""
+    wf.add(
+        {task_type}(
+            name="{node.name}"{node_args}
+        )
+    )"""
 
         if format_with_black:
             out_text = black.format_file_contents(
diff --git a/tests/test_workflow.py b/tests/test_workflow.py
index fb07f908..8cffebf4 100644
--- a/tests/test_workflow.py
+++ b/tests/test_workflow.py
@@ -1,3 +1,4 @@
+from pathlib import Path
 import yaml
 import pytest
 from nipype2pydra.cli import workflow
@@ -5,10 +6,10 @@
 from nipype2pydra.workflow import WorkflowConverter
 
 
-@pytest.mark.xfail(reason="Workflow conversion hasn't been fully implemented yet")
-def test_workflow_conversion(workflow_spec_file, cli_runner, work_dir):
+# @pytest.mark.xfail(reason="Workflow conversion hasn't been fully implemented yet")
+def test_workflow_conversion(workflow_spec_file: Path, cli_runner, outputs_dir: Path):
 
-    output_file = work_dir / "pydra_module.py"
+    output_file = outputs_dir / f"{workflow_spec_file.stem}.py"
 
     result = cli_runner(
         workflow,
@@ -22,11 +23,11 @@ def test_workflow_conversion(workflow_spec_file, cli_runner, work_dir):
 
 
 # @pytest.mark.xfail(reason="Workflow conversion hasn't been fully implemented yet")
-def test_workflow_graph(workflow_spec_file, work_dir):
+def test_workflow_graph(workflow_spec_file, outputs_dir):
 
     with open(workflow_spec_file) as f:
         spec = yaml.safe_load(f)
 
     converter = WorkflowConverter(spec)
 
-    converter.save_graph(work_dir / "smriprep-graph.svg")
+    converter.save_graph(outputs_dir / f"{workflow_spec_file.stem}.svg")

From fc9b21dd175e7599c093fbcad6eaf809b99d3c4b Mon Sep 17 00:00:00 2001
From: Tom Close <tom.g.close@gmail.com>
Date: Thu, 25 Jan 2024 22:36:13 +1100
Subject: [PATCH 26/78] added 'base-package' option to create packages

---
 scripts/pkg_gen/create_packages.py | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/scripts/pkg_gen/create_packages.py b/scripts/pkg_gen/create_packages.py
index c80cc1b2..44ceccbb 100644
--- a/scripts/pkg_gen/create_packages.py
+++ b/scripts/pkg_gen/create_packages.py
@@ -91,11 +91,18 @@ def download_tasks_template(output_path: Path):
 @click.option("--work-dir", type=click.Path(path_type=Path), default=None)
 @click.option("--task-template", type=click.Path(path_type=Path), default=None)
 @click.option("--packages-to-import", type=click.Path(path_type=Path), default=None)
+@click.option(
+    "--base-package",
+    type=str,
+    default="nipype.interfaces",
+    help=("the base package which the sub-packages are relative to"),
+)
 def generate_packages(
     output_dir: Path,
     work_dir: ty.Optional[Path],
     task_template: ty.Optional[Path],
     packages_to_import: ty.Optional[Path],
+    base_package: str,
 ):
     if work_dir is None:
         work_dir = Path(tempfile.mkdtemp())
@@ -145,7 +152,7 @@ def generate_packages(
                 spec_stub = {}
 
                 # Import interface from module
-                nipype_module_str = "nipype.interfaces." + ".".join(module.split("/"))
+                nipype_module_str = base_package + "." + ".".join(module.split("/"))
                 nipype_module = import_module(nipype_module_str)
                 nipype_interface = getattr(nipype_module, interface)
                 if not issubclass(

From 4d51d4198064541f5623c3794f8a56dfd67f7469 Mon Sep 17 00:00:00 2001
From: Tom Close <tom.g.close@gmail.com>
Date: Thu, 25 Jan 2024 22:37:02 +1100
Subject: [PATCH 27/78] added list of qsiprep interfaces

---
 scripts/pkg_gen/qsiprep.yaml | 230 +++++++++++++++++++++++++++++++++++
 1 file changed, 230 insertions(+)
 create mode 100644 scripts/pkg_gen/qsiprep.yaml

diff --git a/scripts/pkg_gen/qsiprep.yaml b/scripts/pkg_gen/qsiprep.yaml
new file mode 100644
index 00000000..6f62d6dc
--- /dev/null
+++ b/scripts/pkg_gen/qsiprep.yaml
@@ -0,0 +1,230 @@
+packages:
+- amico
+- anatomical
+- ants
+- bids
+- confounds
+- connectivity
+- converters
+- denoise
+- dipy
+- dsi_studio
+- dwi_merge
+- eddy
+- fmap
+- freesurfer
+- gradients
+- images
+- ingress
+- itk
+- mrtrix
+- nilearn
+- niworkflows
+# - pyafq
+- reports
+- shoreline
+- surf
+- tortoise
+interfaces:
+  amico:
+  - AmicoReconInterface
+  - NODDI
+  anatomical:
+  - CalculateSOP
+  - CustomApplyMask
+  - DesaturateSkull
+  - DiceOverlap
+  - FakeSegmentation
+  - GetTemplate
+  - QsiprepAnatomicalIngress
+  ants:
+  - ANTsBBR
+  - ConvertTransformFile
+  - GetImageType
+  - ImageMath
+  - MultivariateTemplateConstruction2
+  - N3BiasFieldCorrection
+  bids:
+  - BIDSDataGrabber
+  - BIDSFreeSurferDir
+  - BIDSInfo
+  - DerivativesDataSink
+  - DerivativesMaybeDataSink
+  - QsiReconIngress
+  - ReadSidecarJSON
+  - ReconDerivativesDataSink
+  confounds:
+  - DMRISummary
+  - GatherConfounds
+  connectivity:
+  - Controllability
+  converters:
+  - DSIStudioTrkToTck
+  - FIBGZtoFOD
+  - FODtoFIBGZ
+  - NODDItoFIBGZ
+  denoise:
+  - SeriesPreprocReport
+  - SeriesPreprocReport
+  - SeriesPreprocReport
+  - SeriesPreprocReport
+  dipy:
+  - BrainSuiteShoreReconstruction
+  - DipyReconInterface
+  - HistEQ
+  - KurtosisReconstruction
+  - MAPMRIReconstruction
+  - MedianOtsu
+  - Patch2Self
+  - TensorReconstruction
+  dsi_studio:
+  - AggregateAutoTrackResults
+  - AutoTrack
+  - AutoTrackInit
+  - DSIStudioAtlasGraph
+  - DSIStudioBTable
+  - DSIStudioConnectivityMatrix
+  - DSIStudioCreateSrc
+  - DSIStudioDTIReconstruction
+  - DSIStudioExport
+  - DSIStudioFibQC
+  - DSIStudioGQIReconstruction
+  - DSIStudioMergeQC
+  - DSIStudioQC
+  - DSIStudioReconstruction
+  - DSIStudioSrcQC
+  - DSIStudioTracking
+  - FixDSIStudioExportHeader
+  dwi_merge:
+  - AveragePEPairs
+  - MergeDWIs
+  - MergeFinalConfounds
+  - SplitResampledDWIs
+  - StackConfounds
+  eddy:
+  - Eddy2SPMMotion
+  - ExtendedEddy
+  - GatherEddyInputs
+  fmap:
+  - ApplyScalingImages
+  - B0RPEFieldmap
+  - FieldToHz
+  - FieldToRadS
+  - PEPOLARReport
+  - Phasediff2Fieldmap
+  - Phases2Fieldmap
+  freesurfer:
+  - FSDetectInputs
+  - FSInjectBrainExtracted
+  - FixHeaderSynthStrip
+  - MakeMidthickness
+  - MedialNaNs
+  - PatchedBBRegisterRPT
+  - PatchedConcatenateLTA
+  - PatchedLTAConvert
+  - PatchedMRICoregRPT
+  - PatchedRobustRegister
+  - PrepareSynthStripGrid
+  - RefineBrainMask
+  - StructuralReference
+  - SynthSeg
+  - SynthStrip
+  gradients:
+  - CombineMotions
+  - ComposeTransforms
+  - ExtractB0s
+  - GradientRotation
+  - LocalGradientRotation
+  - MatchTransforms
+  - RemoveDuplicates
+  - SliceQC
+  - SplitIntramodalTransform
+  images:
+  - ChooseInterpolator
+  - Conform
+  - ConformDwi
+  - ExtractWM
+  - IntraModalMerge
+  - NiftiInfo
+  - SplitDWIsBvals
+  - SplitDWIsFSL
+  - TSplit
+  - ValidateImage
+  ingress:
+  - QsiReconIngress
+  itk:
+  - ACPCReport
+  - AffineToRigid
+  - DisassembleTransform
+  - MultiApplyTransforms
+  mrtrix:
+  - BuildConnectome
+  - CompressConnectome2Tck
+  - Connectome2Tck
+  - DWIBiasCorrect
+  - DWIDenoise
+  - Dwi2Response
+  - EstimateFOD
+  - GenerateMasked5tt
+  - GlobalTractography
+  - ITKTransformConvert
+  - MRDeGibbs
+  - MRTrixAtlasGraph
+  - MRTrixGradientTable
+  - MRTrixIngress
+  - MTNormalize
+  - SIFT2
+  - SS3TBase
+  - SS3TDwi2Response
+  - SS3TEstimateFOD
+  - TckGen
+  - TransformHeader
+  nilearn:
+  - EnhanceAndSkullstripB0
+  - EnhanceB0
+  - MaskB0Series
+  - MaskEPI
+  - Merge
+  niworkflows:
+  - ANTSRegistrationRPT
+  pyafq:
+  - PyAFQRecon
+  reports:
+  - AboutSummary
+  - CLIReconPeaksReport
+  - ConnectivityReport
+  - DiffusionSummary
+  - GradientPlot
+  - InteractiveReport
+  - SeriesQC
+  - SubjectSummary
+  - SummaryInterface
+  - SummaryInterface
+  - TopupSummary
+  shoreline:
+  - B0Mean
+  - CalculateCNR
+  - ExtractDWIsForModel
+  - GroupImages
+  - IterationSummary
+  - ReorderOutputs
+  - SHORELineReport
+  - SignalPrediction
+  surf:
+  - GiftiNameSource
+  - GiftiSetAnatomicalStructure
+  - NormalizeSurf
+  tortoise:
+  - DRBUDDI
+  - DRBUDDIAggregateOutputs
+  - GatherDRBUDDIInputs
+  - Gibbs
+  - TORTOISECommandLine
+  utils:
+  - AddTPMs
+  - AddTSVHeader
+  - ConcatAffines
+  - GetConnectivityAtlases
+  - JoinTSVColumns
+  - TPM2ROI
+  - TestInput

From f289147e4876da9ac5deb84dfa3a168c2b087e66 Mon Sep 17 00:00:00 2001
From: Tom Close <tom.g.close@gmail.com>
Date: Thu, 25 Jan 2024 22:37:37 +1100
Subject: [PATCH 28/78] implemented function task importer

---
 nipype2pydra/cli.py       |   2 +-
 nipype2pydra/task.py      | 299 +++++++++++++++++++++++++++++++++++++-
 scripts/port_interface.py |   8 +-
 3 files changed, 302 insertions(+), 7 deletions(-)

diff --git a/nipype2pydra/cli.py b/nipype2pydra/cli.py
index 11d054a0..6860ba12 100644
--- a/nipype2pydra/cli.py
+++ b/nipype2pydra/cli.py
@@ -48,7 +48,7 @@ def task(yaml_spec, package_root, callables, output_module):
 
     spec = yaml.safe_load(yaml_spec)
 
-    converter = TaskConverter(
+    converter = TaskConverter.load(
         output_module=output_module, callables_module=callables, **spec
     )
     converter.generate(package_root)
diff --git a/nipype2pydra/task.py b/nipype2pydra/task.py
index 5ac196b1..dd9dd2aa 100644
--- a/nipype2pydra/task.py
+++ b/nipype2pydra/task.py
@@ -6,6 +6,7 @@
 from types import ModuleType
 import itertools
 import inspect
+from functools import cached_property
 import black
 import traits.trait_types
 import json
@@ -418,6 +419,18 @@ def nipype_output_spec(self) -> nipype.interfaces.base.BaseTraitedSpec:
             else None
         )
 
+    @classmethod
+    def load(cls, nipype_module: str, nipype_name: str, **kwargs):
+        nipype_interface = getattr(import_module(nipype_module), nipype_name)
+
+        if hasattr(nipype_interface, "_cmd"):
+            converter_cls = ShellCommandTaskConverter
+        else:
+            converter_cls = FunctionTaskConverter
+        return converter_cls(
+            nipype_module=nipype_module, nipype_name=nipype_name, **kwargs
+        )
+
     def generate(self, package_root: Path):
         """creating pydra input/output spec from nipype specs
         if write is True, a pydra Task class will be written to the file together with tests
@@ -551,7 +564,7 @@ def convert_output_spec(self, fields_from_template):
         if not self.nipype_output_spec:
             return pydra_fields_l
         for name, fld in self.nipype_output_spec.traits().items():
-            if name in self.outputs.requirements and name not in fields_from_template:
+            if name not in self.TRAITS_IRREL and name not in fields_from_template:
                 pydra_fld = self.pydra_fld_output(fld, name)
                 pydra_fields_l.append((name,) + pydra_fld)
         return pydra_fields_l
@@ -567,7 +580,7 @@ def pydra_fld_output(self, field, name):
             if val:
                 pydra_metadata[pydra_key_nm] = val
 
-        if self.outputs.requirements[name]:
+        if name in self.outputs.requirements and self.outputs.requirements[name]:
             if all([isinstance(el, list) for el in self.outputs.requirements[name]]):
                 requires_l = self.outputs.requirements[name]
                 nested_flag = True
@@ -724,7 +737,9 @@ def types_to_names(spec_fields):
         if not executable:
             executable = self.nipype_interface.cmd
             if not isinstance(executable, str):
-                raise RuntimeError(f"Could not find executable for {self.nipype_interface}")
+                raise RuntimeError(
+                    f"Could not find executable for {self.nipype_interface}"
+                )
 
         input_fields_str = types_to_names(spec_fields=input_fields)
         output_fields_str = types_to_names(spec_fields=output_fields)
@@ -1034,3 +1049,281 @@ def test_runner():
 
     return decorator
 """
+
+
+@attrs.define
+class FunctionTaskConverter(TaskConverter):
+    def write_task(self, filename, input_fields, nonstd_types, output_fields):
+        """writing pydra task to the dile based on the input and output spec"""
+
+        base_imports = [
+            "from pydra.engine import specs",
+            "from pydra.engine.task import FunctionTask",
+        ]
+
+        def types_to_names(spec_fields):
+            spec_fields_str = []
+            for el in spec_fields:
+                el = list(el)
+                tp_str = str(el[1])
+                if tp_str.startswith("<class "):
+                    tp_str = el[1].__name__
+                else:
+                    # Alter modules in type string to match those that will be imported
+                    tp_str = tp_str.replace("typing", "ty")
+                    tp_str = re.sub(r"(\w+\.)+(?<!ty\.)(\w+)", r"\2", tp_str)
+                el[1] = tp_str
+                spec_fields_str.append(tuple(el))
+            return spec_fields_str
+
+        input_fields_str = types_to_names(spec_fields=input_fields)
+        output_fields_str = types_to_names(spec_fields=output_fields)
+        input_names = [i[0] for i in input_fields]
+        output_names = [o[0] for o in output_fields]
+        output_type_names = [o[1] for o in output_fields_str]
+        function_body = self.get_function_body(input_names, output_names)
+        functions_str = self.function_callables()
+
+        # Create the spec string
+        spec_str = functions_str
+        spec_str += "@pydra.mark.task\n"
+        spec_str += "@pydra.mark.annotate({'return': {"
+        spec_str += ", ".join(f"'{n}': {t}" for n, t, _ in output_fields_str)
+        spec_str += "}})\n"
+        spec_str += f"def {self.task_name}("
+        spec_str += ", ".join(f"{n}: {t}" for n, t, _ in input_fields_str)
+        spec_str += ") -> "
+        if len(output_type_names) > 1:
+            spec_str += "ty.Tuple[" + ", ".join(output_type_names) + "]"
+        else:
+            spec_str += output_type_names[0]
+        spec_str += ':\n    """\n'
+        spec_str += self.create_doctests(
+            input_fields=input_fields, nonstd_types=nonstd_types
+        )
+        spec_str += '    """\n'
+        spec_str += "    " + function_body + "\n"
+        spec_str += "\n    return {}".format(", ".join(output_names))
+        spec_str += "\n\n" + "\n\n".join(self.referenced_local_functions)
+
+        # Replace hash escapes
+        spec_str = re.sub(r"'#([^'#]+)#'", r"\1", spec_str)
+
+        other_imports = self.get_imports([function_body] + self.referenced_local_functions)
+
+        imports = self.construct_imports(
+            nonstd_types,
+            spec_str,
+            include_task=False,
+            base=base_imports + other_imports,
+        )
+        spec_str = "\n".join(imports) + "\n\n" + spec_str
+
+        spec_str = black.format_file_contents(
+            spec_str, fast=False, mode=black.FileMode()
+        )
+
+        with open(filename, "w") as f:
+            f.write(spec_str)
+
+    def get_function_body(self, input_names: ty.List[str], output_names: ty.List[str]):
+        ri_src = inspect.getsource(self.nipype_interface._run_interface).strip()
+        ri_src = "\n".join(ri_src.split("\n")[1:-1])
+        lo_src = inspect.getsource(self.nipype_interface._list_outputs).strip()
+        lo_lines = lo_src.split("\n")
+        return_line = lo_lines[-1]
+        match = re.match(r"\s*return (.*)", return_line)
+        return_value = match.group(1)
+        lo_src = "\n".join(lo_lines[1:-1])
+        src = ri_src + lo_src
+        input_re = re.compile(r"self\.inputs\.(\w+)")
+        unrecognised_inputs = set(
+            m for m in input_re.findall(src) if m not in input_names
+        )
+        assert (
+            not unrecognised_inputs
+        ), f"Found the following unrecognised inputs {unrecognised_inputs}"
+        src = input_re.sub(r"\1", src)
+        output_re = re.compile(return_value + r"\[(?:'|\")(\w+)(?:'|\")\]")
+        unrecognised_outputs = set(
+            m for m in output_re.findall(src) if m not in output_names
+        )
+        assert (
+            not unrecognised_outputs
+        ), f"Found the following unrecognised outputs {unrecognised_outputs}"
+        src = output_re.sub(r"\1", src)
+        # Detect the indentation of the source code in src and reduce it to 4 spaces
+        indents = re.findall(r"^\s+", src, flags=re.MULTILINE)
+        min_indent = min(len(i) for i in indents if i)
+        indent_reduction = min_indent - 4
+        src = re.sub(r"^" + " " * indent_reduction, "", src, flags=re.MULTILINE)
+        return src.strip()
+
+    def get_imports(
+        self, function_bodies: ty.List[str]
+    ) -> ty.Tuple[ty.List[str], ty.List[str]]:
+        """Get the imports required for the function body
+
+        Parameters
+        ----------
+        src: str
+            the source of the file to extract the import statements from
+        """
+        imports = []
+        block = ""
+        for line in self.source_code.split("\n"):
+            if line.startswith("from") or line.startswith("import"):
+                if "(" in line:
+                    block = line
+                else:
+                    imports.append(line)
+            if ")" in line and block:
+                imports.append(block + line)
+                block = ""
+        # extract imported symbols from import statements
+        used_symbols = set()
+        for function_body in function_bodies:
+            # Strip comments from function body
+            function_body = re.sub(r"\s*#.*", "", function_body)
+            used_symbols.update(re.findall(r"(\w+)", function_body))
+        used_imports = []
+        for stmt in imports:
+            stmt = stmt.replace("\n", "")
+            stmt = stmt.replace("(", "")
+            stmt = stmt.replace(")", "")
+            base_stmt, symbol_str = stmt.split("import ")
+            symbol_parts = symbol_str.split(",")
+            split_parts = [p.split(" as ") for p in symbol_parts]
+            split_parts = [p for p in split_parts if p[-1] in used_symbols]
+            if split_parts:
+                used_imports.append(
+                    base_stmt
+                    + "import "
+                    + ",".join(" as ".join(p) for p in split_parts)
+                )
+        return used_imports
+
+    @cached_property
+    def referenced_local_functions(self):
+        referenced = set()
+        self._get_referenced_local_functions(self.nipype_interface._run_interface, referenced)
+        self._get_referenced_local_functions(self.nipype_interface._list_outputs, referenced)
+        return [inspect.getsource(f) for f in referenced]
+
+    def _get_referenced_local_functions(
+        self, function: ty.Callable, referenced: ty.Set[ty.Callable]
+    ):
+        """Get the local functions referenced in the source code
+
+        Parameters
+        ----------
+        src: str
+            the source of the file to extract the import statements from
+        referenced: set[function]
+            the set of functions that have been referenced so far
+        """
+        function_body = inspect.getsource(function)
+        function_body = re.sub(r"\s*#.*", "", function_body)
+        referenced_symbols = re.findall(r"(\w+)\(", function_body)
+        referenced_locals = set(
+            f
+            for f in self.local_functions
+            if f.__name__ in referenced_symbols and f not in referenced
+        )
+        referenced.update(referenced_locals)
+        for func in referenced_locals:
+            self._get_referenced_local_functions(func, referenced)
+
+    @cached_property
+    def source_code(self):
+        with open(inspect.getsourcefile(self.nipype_interface)) as f:
+            return f.read()
+
+    @cached_property
+    def local_functions(self):
+        """Get the functions defined in the same file as the interface"""
+        functions = []
+        for attr_name in dir(self.nipype_module):
+            attr = getattr(self.nipype_module, attr_name)
+            if inspect.isfunction(attr):
+                functions.append(attr)
+        return functions
+
+    @cached_property
+    def local_function_names(self):
+        return [f.__name__ for f in self.local_functions]
+
+
+@attrs.define
+class ShellCommandTaskConverter(TaskConverter):
+    def write_task(self, filename, input_fields, nonstd_types, output_fields):
+        """writing pydra task to the dile based on the input and output spec"""
+
+        base_imports = [
+            "from pydra.engine import specs",
+        ]
+
+        task_base = "ShellCommandTask"
+        base_imports.append("from pydra.engine import ShellCommandTask")
+
+        try:
+            executable = self.nipype_interface._cmd
+        except AttributeError:
+            executable = None
+        if not executable:
+            executable = self.nipype_interface.cmd
+            if not isinstance(executable, str):
+                raise RuntimeError(
+                    f"Could not find executable for {self.nipype_interface}"
+                )
+
+        def types_to_names(spec_fields):
+            spec_fields_str = []
+            for el in spec_fields:
+                el = list(el)
+                tp_str = str(el[1])
+                if tp_str.startswith("<class "):
+                    tp_str = el[1].__name__
+                else:
+                    # Alter modules in type string to match those that will be imported
+                    tp_str = tp_str.replace("typing", "ty")
+                    tp_str = re.sub(r"(\w+\.)+(?<!ty\.)(\w+)", r"\2", tp_str)
+                el[1] = "#" + tp_str + "#"
+                spec_fields_str.append(tuple(el))
+            return spec_fields_str
+
+        input_fields_str = types_to_names(spec_fields=input_fields)
+        output_fields_str = types_to_names(spec_fields=output_fields)
+        functions_str = self.function_callables()
+        spec_str = functions_str
+        spec_str += f"input_fields = {input_fields_str}\n"
+        spec_str += f"{self.task_name}_input_spec = specs.SpecInfo(name='Input', fields=input_fields, bases=(specs.ShellSpec,))\n\n"
+        spec_str += f"output_fields = {output_fields_str}\n"
+        spec_str += f"{self.task_name}_output_spec = specs.SpecInfo(name='Output', fields=output_fields, bases=(specs.ShellOutSpec,))\n\n"
+        spec_str += f"class {self.task_name}({task_base}):\n"
+        spec_str += '    """\n'
+        spec_str += self.create_doctests(
+            input_fields=input_fields, nonstd_types=nonstd_types
+        )
+        spec_str += '    """\n'
+        spec_str += f"    input_spec = {self.task_name}_input_spec\n"
+        spec_str += f"    output_spec = {self.task_name}_output_spec\n"
+        if task_base == "ShellCommandTask":
+            spec_str += f"    executable='{executable}'\n"
+
+        spec_str = re.sub(r"'#([^'#]+)#'", r"\1", spec_str)
+
+        imports = self.construct_imports(
+            nonstd_types,
+            spec_str,
+            include_task=False,
+            base=base_imports,
+        )
+        spec_str = "\n".join(imports) + "\n\n" + spec_str
+
+        spec_str = black.format_file_contents(
+            spec_str, fast=False, mode=black.FileMode()
+        )
+
+        with open(filename, "w") as f:
+            f.write(spec_str)
diff --git a/scripts/port_interface.py b/scripts/port_interface.py
index 468ca0c0..495b257e 100644
--- a/scripts/port_interface.py
+++ b/scripts/port_interface.py
@@ -12,8 +12,10 @@
 with open(spec_file) as f:
     spec = yaml.load(f, Loader=yaml.SafeLoader)
 
-converter = nipype2pydra.task.TaskConverter(
-    output_module=spec["nipype_module"].split("interfaces.")[-1] + "." + spec["task_name"],
-    **spec
+converter = nipype2pydra.task.TaskConverter.load(
+    output_module=spec["nipype_module"].split("interfaces.")[-1]
+    + ".auto."
+    + nipype2pydra.utils.to_snake_case(spec["task_name"]),
+    **spec,
 )
 converter.generate(outputs_path)

From f4cfcd63aa5c8eed0057332c6b23fd4831e4b235 Mon Sep 17 00:00:00 2001
From: Tom Close <tom.g.close@gmail.com>
Date: Tue, 30 Jan 2024 14:35:37 +1100
Subject: [PATCH 29/78] implemented passing of inputs to methods

---
 nipype2pydra/task.py | 277 +++++++++++++++++++++++++++++++++++--------
 1 file changed, 228 insertions(+), 49 deletions(-)

diff --git a/nipype2pydra/task.py b/nipype2pydra/task.py
index dd9dd2aa..8f179b46 100644
--- a/nipype2pydra/task.py
+++ b/nipype2pydra/task.py
@@ -7,6 +7,7 @@
 import itertools
 import inspect
 from functools import cached_property
+import itertools
 import black
 import traits.trait_types
 import json
@@ -1057,8 +1058,7 @@ def write_task(self, filename, input_fields, nonstd_types, output_fields):
         """writing pydra task to the dile based on the input and output spec"""
 
         base_imports = [
-            "from pydra.engine import specs",
-            "from pydra.engine.task import FunctionTask",
+            "import pydra.mark",
         ]
 
         def types_to_names(spec_fields):
@@ -1081,17 +1081,37 @@ def types_to_names(spec_fields):
         input_names = [i[0] for i in input_fields]
         output_names = [o[0] for o in output_fields]
         output_type_names = [o[1] for o in output_fields_str]
-        function_body = self.get_function_body(input_names, output_names)
-        functions_str = self.function_callables()
+
+        # Combined src of run_interface and list_outputs
+        function_body = inspect.getsource(self.nipype_interface._run_interface).strip()
+        function_body = "\n".join(function_body.split("\n")[1:-1])
+        lo_src = inspect.getsource(self.nipype_interface._list_outputs).strip()
+        lo_lines = lo_src.split("\n")
+        lo_src = "\n".join(lo_lines[1:-1])
+        function_body += lo_src
+
+        # Replace return outputs dictionary with individual outputs
+        return_line = lo_lines[-1]
+        match = re.match(r"\s*return(.*)", return_line)
+        return_value = match.group(1).strip()
+        output_re = re.compile(return_value + r"\[(?:'|\")(\w+)(?:'|\")\]")
+        unrecognised_outputs = set(
+            m for m in output_re.findall(function_body) if m not in output_names
+        )
+        assert (
+            not unrecognised_outputs
+        ), f"Found the following unrecognised outputs {unrecognised_outputs}"
+        function_body = output_re.sub(r"\1", function_body)
+        function_body = self.process_function_body(function_body, input_names)
 
         # Create the spec string
-        spec_str = functions_str
+        spec_str = self.function_callables()
         spec_str += "@pydra.mark.task\n"
         spec_str += "@pydra.mark.annotate({'return': {"
         spec_str += ", ".join(f"'{n}': {t}" for n, t, _ in output_fields_str)
         spec_str += "}})\n"
         spec_str += f"def {self.task_name}("
-        spec_str += ", ".join(f"{n}: {t}" for n, t, _ in input_fields_str)
+        spec_str += ", ".join(f"{i[0]}: {i[1]}" for i in input_fields_str)
         spec_str += ") -> "
         if len(output_type_names) > 1:
             spec_str += "ty.Tuple[" + ", ".join(output_type_names) + "]"
@@ -1102,20 +1122,36 @@ def types_to_names(spec_fields):
             input_fields=input_fields, nonstd_types=nonstd_types
         )
         spec_str += '    """\n'
-        spec_str += "    " + function_body + "\n"
+        spec_str += function_body + "\n"
         spec_str += "\n    return {}".format(", ".join(output_names))
-        spec_str += "\n\n" + "\n\n".join(self.referenced_local_functions)
 
-        # Replace hash escapes
-        spec_str = re.sub(r"'#([^'#]+)#'", r"\1", spec_str)
+        for f in self.local_functions:
+            spec_str += "\n\n" + inspect.getsource(f)
+        spec_str += "\n\n".join(
+            inspect.getsource(f) for f in self.local_functions
+        )
+
+        spec_str += "\n\n" + "\n\n".join(
+            self.process_method(m, input_names, output_names) for m in self.referenced_methods
+        )
 
-        other_imports = self.get_imports([function_body] + self.referenced_local_functions)
+        # Replace runtime attributes
+        additional_imports = set()
+        for attr, repl, imprt in self.RUNTIME_ATTRS:
+            repl_spec_str = spec_str.replace(f"runtime.{attr}", repl)
+            if repl_spec_str != spec_str:
+                additional_imports.add(imprt)
+                spec_str = repl_spec_str
+
+        other_imports = self.get_imports(
+            [function_body] + [inspect.getsource(f) for f in itertools.chain(self.referenced_local_functions, self.referenced_methods)]
+        )
 
         imports = self.construct_imports(
             nonstd_types,
             spec_str,
             include_task=False,
-            base=base_imports + other_imports,
+            base=base_imports + other_imports + list(additional_imports),
         )
         spec_str = "\n".join(imports) + "\n\n" + spec_str
 
@@ -1126,38 +1162,67 @@ def types_to_names(spec_fields):
         with open(filename, "w") as f:
             f.write(spec_str)
 
-    def get_function_body(self, input_names: ty.List[str], output_names: ty.List[str]):
-        ri_src = inspect.getsource(self.nipype_interface._run_interface).strip()
-        ri_src = "\n".join(ri_src.split("\n")[1:-1])
-        lo_src = inspect.getsource(self.nipype_interface._list_outputs).strip()
-        lo_lines = lo_src.split("\n")
-        return_line = lo_lines[-1]
-        match = re.match(r"\s*return (.*)", return_line)
-        return_value = match.group(1)
-        lo_src = "\n".join(lo_lines[1:-1])
-        src = ri_src + lo_src
+    def process_method(
+        self,
+        func: str,
+        input_names: ty.List[str],
+        output_names: ty.List[str],
+    ):
+        src = inspect.getsource(func)
+        pre, arglist, post = self.split_parens_contents(src)
+        if func.__name__ in self.method_args:
+            arglist = (arglist + ", " if arglist else "") + ", ".join(f"{a}=None" for a in self.method_args[func.__name__])
+        # Insert method args in signature if present
+        return_types, function_body = post.split(":", maxsplit=1)
+        function_body = function_body.split("\n", maxsplit=1)[1]
+        function_body = self.process_function_body(function_body, input_names)
+        return f"{pre.strip()}{arglist}{return_types}:\n{function_body}"
+
+    def process_function_body(self, function_body: str, input_names: ty.List[str]) -> str:
+        """Replace self.inputs.<name> with <name> in the function body and add args to the
+        function signature
+
+        Parameters
+        ----------
+        function_body: str
+            The source code of the function to process
+        input_names: list[str]
+            The names of the inputs to the function
+
+        Returns
+        -------
+        function_body: str
+            The processed source code
+        """
+        # Replace self.inputs.<name> with <name> in the function body
         input_re = re.compile(r"self\.inputs\.(\w+)")
         unrecognised_inputs = set(
-            m for m in input_re.findall(src) if m not in input_names
+            m for m in input_re.findall(function_body) if m not in input_names
         )
         assert (
             not unrecognised_inputs
         ), f"Found the following unrecognised inputs {unrecognised_inputs}"
-        src = input_re.sub(r"\1", src)
-        output_re = re.compile(return_value + r"\[(?:'|\")(\w+)(?:'|\")\]")
-        unrecognised_outputs = set(
-            m for m in output_re.findall(src) if m not in output_names
+        function_body = input_re.sub(r"\1", function_body)
+        # Add args to the function signature of method calls
+        method_re = re.compile(r"self\.(\w+)(?=\()", flags=re.MULTILINE | re.DOTALL)
+        method_names = [m.__name__ for m in self.referenced_methods]
+        unrecognised_methods = set(
+            m for m in method_re.findall(function_body) if m not in method_names
         )
         assert (
-            not unrecognised_outputs
-        ), f"Found the following unrecognised outputs {unrecognised_outputs}"
-        src = output_re.sub(r"\1", src)
+            not unrecognised_methods
+        ), f"Found the following unrecognised methods {unrecognised_methods}"
+        splits = method_re.split(function_body)
+        new_body = splits[0]
+        for name, args in zip(splits[1::2], splits[2::2]):
+            new_body += name + self.insert_args_in_signature(args, [f"{a}={a}" for a in self.method_args[name]])
+        function_body = new_body
         # Detect the indentation of the source code in src and reduce it to 4 spaces
-        indents = re.findall(r"^\s+", src, flags=re.MULTILINE)
+        indents = re.findall(r"^\s+", function_body, flags=re.MULTILINE)
         min_indent = min(len(i) for i in indents if i)
         indent_reduction = min_indent - 4
-        src = re.sub(r"^" + " " * indent_reduction, "", src, flags=re.MULTILINE)
-        return src.strip()
+        function_body = re.sub(r"^" + " " * indent_reduction, "", function_body, flags=re.MULTILINE)
+        return function_body
 
     def get_imports(
         self, function_bodies: ty.List[str]
@@ -1203,15 +1268,48 @@ def get_imports(
                 )
         return used_imports
 
-    @cached_property
+    @property
     def referenced_local_functions(self):
-        referenced = set()
-        self._get_referenced_local_functions(self.nipype_interface._run_interface, referenced)
-        self._get_referenced_local_functions(self.nipype_interface._list_outputs, referenced)
-        return [inspect.getsource(f) for f in referenced]
+        return self._referenced_funcs_and_methods[0]
+
+    @property
+    def referenced_methods(self):
+        return self._referenced_funcs_and_methods[1]
 
-    def _get_referenced_local_functions(
-        self, function: ty.Callable, referenced: ty.Set[ty.Callable]
+    @property
+    def method_args(self):
+        return self._referenced_funcs_and_methods[2]
+
+    @cached_property
+    def _referenced_funcs_and_methods(self):
+        referenced_funcs = set()
+        referenced_methods = set()
+        method_args = {}
+        self._get_referenced(
+            self.nipype_interface._run_interface,
+            referenced_funcs,
+            referenced_methods,
+            method_args,
+        )
+        self._get_referenced(
+            self.nipype_interface._list_outputs,
+            referenced_funcs,
+            referenced_methods,
+            method_args,
+        )
+        return referenced_funcs, referenced_methods, method_args
+
+    def replace_attributes(self, function_body: ty.Callable) -> str:
+        """Replace self.inputs.<name> with <name> in the function body and add args to the
+        function signature"""
+        function_body = re.sub(r"self\.inputs\.(\w+)", r"\1", function_body)
+
+    def _get_referenced(
+        self,
+        function: ty.Callable,
+        referenced_funcs: ty.Set[ty.Callable],
+        referenced_methods: ty.Set[ty.Callable],
+        method_args: ty.Dict[str, ty.List[str]],
     ):
         """Get the local functions referenced in the source code
 
@@ -1219,20 +1317,38 @@ def _get_referenced_local_functions(
         ----------
         src: str
             the source of the file to extract the import statements from
-        referenced: set[function]
-            the set of functions that have been referenced so far
+        referenced_funcs: set[function]
+            the set of local functions that have been referenced so far
+        referenced_methods: set[function]
+            the set of methods that have been referenced so far
         """
         function_body = inspect.getsource(function)
         function_body = re.sub(r"\s*#.*", "", function_body)
-        referenced_symbols = re.findall(r"(\w+)\(", function_body)
-        referenced_locals = set(
+        ref_local_func_names = re.findall(r"(?<!self\.)(\w+)\(", function_body)
+        ref_local_funcs = set(
             f
             for f in self.local_functions
-            if f.__name__ in referenced_symbols and f not in referenced
+            if f.__name__ in ref_local_func_names and f not in referenced_funcs
         )
-        referenced.update(referenced_locals)
-        for func in referenced_locals:
-            self._get_referenced_local_functions(func, referenced)
+
+        ref_method_names = re.findall(r"(?<=self\.)(\w+)\(", function_body)
+        ref_methods = set(m for m in self.methods if m.__name__ in ref_method_names)
+
+        referenced_funcs.update(ref_local_funcs)
+        referenced_methods.update(ref_methods)
+
+        referenced_inputs = set(re.findall(r"(?<=self\.inputs\.)(\w+)", function_body))
+        for func in ref_local_funcs:
+            referenced_inputs.update(
+                self._get_referenced(func, referenced_funcs, referenced_methods)
+            )
+        for meth in ref_methods:
+            ref_inputs = self._get_referenced(
+                meth, referenced_funcs, referenced_methods, method_args=method_args
+            )
+            method_args[meth.__name__] = ref_inputs
+            referenced_inputs.update(ref_inputs)
+        return referenced_inputs
 
     @cached_property
     def source_code(self):
@@ -1245,14 +1361,77 @@ def local_functions(self):
         functions = []
         for attr_name in dir(self.nipype_module):
             attr = getattr(self.nipype_module, attr_name)
-            if inspect.isfunction(attr):
+            if (
+                inspect.isfunction(attr)
+                and attr.__module__ == self.nipype_module.__name__
+            ):
                 functions.append(attr)
         return functions
 
+    @cached_property
+    def methods(self):
+        """Get the functions defined in the interface"""
+        methods = []
+        for attr_name in dir(self.nipype_interface):
+            if attr_name.startswith("__"):
+                continue
+            attr = getattr(self.nipype_interface, attr_name)
+            if inspect.isfunction(attr):
+                methods.append(attr)
+        return methods
+
     @cached_property
     def local_function_names(self):
         return [f.__name__ for f in self.local_functions]
 
+    RUNTIME_ATTRS = (
+        ("cwd", "os.getcwd()", "import os"),
+        ("environ", "os.environ", "import os"),
+        ("hostname", "platform.node()", "import platform"),
+        ("platform", "platform.platform()", "import platform"),
+    )
+
+    @classmethod
+    def insert_args_in_signature(cls, snippet: str, args: ty.Iterable[str]) -> str:
+        """Insert the arguments into the function signature"""
+        # Insert method args in signature if present
+        pre, contents, post = cls.split_parens_contents(snippet)
+        return pre + (contents + ", " if contents else "") + ", ".join(args) + post
+
+    @classmethod
+    def split_parens_contents(cls, snippet):
+        """Splits the code snippet at the first opening parenthesis into a 3-tuple
+        consisting of the pre-paren text, the contents of the parens and the post-paren
+
+        Parameters
+        ----------
+        snippet: str
+            the code snippet to split
+
+        Returns
+        -------
+        pre: str
+            the text before the opening parenthesis
+        contents: str
+            the contents of the parens
+        post: str
+            the text after the closing parenthesis
+        """
+        splits = re.split(r"(\(|\))", snippet, flags=re.MULTILINE | re.DOTALL)
+        depth = 1
+        pre = "".join(splits[:2])
+        contents = ""
+        for i, s in enumerate(splits[2:], start=2):
+            if s == "(":
+                depth += 1
+            else:
+                if s == ")":
+                    depth -= 1
+                    if depth == 0:
+                        return pre, contents, "".join(splits[i:])
+                contents += s
+        raise ValueError(f"No matching parenthesis found in '{snippet}'")
+
 
 @attrs.define
 class ShellCommandTaskConverter(TaskConverter):

From 75583203abc6b936483be456ffe337922e8b5841 Mon Sep 17 00:00:00 2001
From: Tom Close <tom.g.close@gmail.com>
Date: Tue, 30 Jan 2024 16:28:18 +1100
Subject: [PATCH 30/78] split task converter into shell-command and function
 converters

---
 nipype2pydra/task/__init__.py          |   2 +
 nipype2pydra/{task.py => task/base.py} | 467 +------------------------
 nipype2pydra/task/function.py          | 389 ++++++++++++++++++++
 nipype2pydra/task/shell_command.py     |  79 +++++
 4 files changed, 475 insertions(+), 462 deletions(-)
 create mode 100644 nipype2pydra/task/__init__.py
 rename nipype2pydra/{task.py => task/base.py} (69%)
 create mode 100644 nipype2pydra/task/function.py
 create mode 100644 nipype2pydra/task/shell_command.py

diff --git a/nipype2pydra/task/__init__.py b/nipype2pydra/task/__init__.py
new file mode 100644
index 00000000..8d420878
--- /dev/null
+++ b/nipype2pydra/task/__init__.py
@@ -0,0 +1,2 @@
+from .function import FunctionTaskConverter
+from .shell_command import ShellCommandTaskConverter
\ No newline at end of file
diff --git a/nipype2pydra/task.py b/nipype2pydra/task/base.py
similarity index 69%
rename from nipype2pydra/task.py
rename to nipype2pydra/task/base.py
index 8f179b46..957152f1 100644
--- a/nipype2pydra/task.py
+++ b/nipype2pydra/task/base.py
@@ -6,8 +6,6 @@
 from types import ModuleType
 import itertools
 import inspect
-from functools import cached_property
-import itertools
 import black
 import traits.trait_types
 import json
@@ -17,7 +15,7 @@
 from nipype.interfaces.base import traits_extension
 from pydra.engine import specs
 from pydra.engine.helpers import ensure_list
-from .utils import import_module_from_path, is_fileset, to_snake_case
+from ..utils import import_module_from_path, is_fileset, to_snake_case
 from fileformats.core import from_mime
 from fileformats.core.mixin import WithClassifiers
 from fileformats.generic import File
@@ -425,10 +423,11 @@ def load(cls, nipype_module: str, nipype_name: str, **kwargs):
         nipype_interface = getattr(import_module(nipype_module), nipype_name)
 
         if hasattr(nipype_interface, "_cmd"):
-            converter_cls = ShellCommandTaskConverter
+            from .shell_command import ShellCommandTaskConverter as Converter
         else:
-            converter_cls = FunctionTaskConverter
-        return converter_cls(
+            from .function import FunctionTaskConverter as Converter
+
+        return Converter(
             nipype_module=nipype_module, nipype_name=nipype_name, **kwargs
         )
 
@@ -1050,459 +1049,3 @@ def test_runner():
 
     return decorator
 """
-
-
-@attrs.define
-class FunctionTaskConverter(TaskConverter):
-    def write_task(self, filename, input_fields, nonstd_types, output_fields):
-        """writing pydra task to the dile based on the input and output spec"""
-
-        base_imports = [
-            "import pydra.mark",
-        ]
-
-        def types_to_names(spec_fields):
-            spec_fields_str = []
-            for el in spec_fields:
-                el = list(el)
-                tp_str = str(el[1])
-                if tp_str.startswith("<class "):
-                    tp_str = el[1].__name__
-                else:
-                    # Alter modules in type string to match those that will be imported
-                    tp_str = tp_str.replace("typing", "ty")
-                    tp_str = re.sub(r"(\w+\.)+(?<!ty\.)(\w+)", r"\2", tp_str)
-                el[1] = tp_str
-                spec_fields_str.append(tuple(el))
-            return spec_fields_str
-
-        input_fields_str = types_to_names(spec_fields=input_fields)
-        output_fields_str = types_to_names(spec_fields=output_fields)
-        input_names = [i[0] for i in input_fields]
-        output_names = [o[0] for o in output_fields]
-        output_type_names = [o[1] for o in output_fields_str]
-
-        # Combined src of run_interface and list_outputs
-        function_body = inspect.getsource(self.nipype_interface._run_interface).strip()
-        function_body = "\n".join(function_body.split("\n")[1:-1])
-        lo_src = inspect.getsource(self.nipype_interface._list_outputs).strip()
-        lo_lines = lo_src.split("\n")
-        lo_src = "\n".join(lo_lines[1:-1])
-        function_body += lo_src
-
-        # Replace return outputs dictionary with individual outputs
-        return_line = lo_lines[-1]
-        match = re.match(r"\s*return(.*)", return_line)
-        return_value = match.group(1).strip()
-        output_re = re.compile(return_value + r"\[(?:'|\")(\w+)(?:'|\")\]")
-        unrecognised_outputs = set(
-            m for m in output_re.findall(function_body) if m not in output_names
-        )
-        assert (
-            not unrecognised_outputs
-        ), f"Found the following unrecognised outputs {unrecognised_outputs}"
-        function_body = output_re.sub(r"\1", function_body)
-        function_body = self.process_function_body(function_body, input_names)
-
-        # Create the spec string
-        spec_str = self.function_callables()
-        spec_str += "@pydra.mark.task\n"
-        spec_str += "@pydra.mark.annotate({'return': {"
-        spec_str += ", ".join(f"'{n}': {t}" for n, t, _ in output_fields_str)
-        spec_str += "}})\n"
-        spec_str += f"def {self.task_name}("
-        spec_str += ", ".join(f"{i[0]}: {i[1]}" for i in input_fields_str)
-        spec_str += ") -> "
-        if len(output_type_names) > 1:
-            spec_str += "ty.Tuple[" + ", ".join(output_type_names) + "]"
-        else:
-            spec_str += output_type_names[0]
-        spec_str += ':\n    """\n'
-        spec_str += self.create_doctests(
-            input_fields=input_fields, nonstd_types=nonstd_types
-        )
-        spec_str += '    """\n'
-        spec_str += function_body + "\n"
-        spec_str += "\n    return {}".format(", ".join(output_names))
-
-        for f in self.local_functions:
-            spec_str += "\n\n" + inspect.getsource(f)
-        spec_str += "\n\n".join(
-            inspect.getsource(f) for f in self.local_functions
-        )
-
-        spec_str += "\n\n" + "\n\n".join(
-            self.process_method(m, input_names, output_names) for m in self.referenced_methods
-        )
-
-        # Replace runtime attributes
-        additional_imports = set()
-        for attr, repl, imprt in self.RUNTIME_ATTRS:
-            repl_spec_str = spec_str.replace(f"runtime.{attr}", repl)
-            if repl_spec_str != spec_str:
-                additional_imports.add(imprt)
-                spec_str = repl_spec_str
-
-        other_imports = self.get_imports(
-            [function_body] + [inspect.getsource(f) for f in itertools.chain(self.referenced_local_functions, self.referenced_methods)]
-        )
-
-        imports = self.construct_imports(
-            nonstd_types,
-            spec_str,
-            include_task=False,
-            base=base_imports + other_imports + list(additional_imports),
-        )
-        spec_str = "\n".join(imports) + "\n\n" + spec_str
-
-        spec_str = black.format_file_contents(
-            spec_str, fast=False, mode=black.FileMode()
-        )
-
-        with open(filename, "w") as f:
-            f.write(spec_str)
-
-    def process_method(
-        self,
-        func: str,
-        input_names: ty.List[str],
-        output_names: ty.List[str],
-    ):
-        src = inspect.getsource(func)
-        pre, arglist, post = self.split_parens_contents(src)
-        if func.__name__ in self.method_args:
-            arglist = (arglist + ", " if arglist else "") + ", ".join(f"{a}=None" for a in self.method_args[func.__name__])
-        # Insert method args in signature if present
-        return_types, function_body = post.split(":", maxsplit=1)
-        function_body = function_body.split("\n", maxsplit=1)[1]
-        function_body = self.process_function_body(function_body, input_names)
-        return f"{pre.strip()}{arglist}{return_types}:\n{function_body}"
-
-    def process_function_body(self, function_body: str, input_names: ty.List[str]) -> str:
-        """Replace self.inputs.<name> with <name> in the function body and add args to the
-        function signature
-
-        Parameters
-        ----------
-        function_body: str
-            The source code of the function to process
-        input_names: list[str]
-            The names of the inputs to the function
-
-        Returns
-        -------
-        function_body: str
-            The processed source code
-        """
-        # Replace self.inputs.<name> with <name> in the function body
-        input_re = re.compile(r"self\.inputs\.(\w+)")
-        unrecognised_inputs = set(
-            m for m in input_re.findall(function_body) if m not in input_names
-        )
-        assert (
-            not unrecognised_inputs
-        ), f"Found the following unrecognised inputs {unrecognised_inputs}"
-        function_body = input_re.sub(r"\1", function_body)
-        # Add args to the function signature of method calls
-        method_re = re.compile(r"self\.(\w+)(?=\()", flags=re.MULTILINE | re.DOTALL)
-        method_names = [m.__name__ for m in self.referenced_methods]
-        unrecognised_methods = set(
-            m for m in method_re.findall(function_body) if m not in method_names
-        )
-        assert (
-            not unrecognised_methods
-        ), f"Found the following unrecognised methods {unrecognised_methods}"
-        splits = method_re.split(function_body)
-        new_body = splits[0]
-        for name, args in zip(splits[1::2], splits[2::2]):
-            new_body += name + self.insert_args_in_signature(args, [f"{a}={a}" for a in self.method_args[name]])
-        function_body = new_body
-        # Detect the indentation of the source code in src and reduce it to 4 spaces
-        indents = re.findall(r"^\s+", function_body, flags=re.MULTILINE)
-        min_indent = min(len(i) for i in indents if i)
-        indent_reduction = min_indent - 4
-        function_body = re.sub(r"^" + " " * indent_reduction, "", function_body, flags=re.MULTILINE)
-        return function_body
-
-    def get_imports(
-        self, function_bodies: ty.List[str]
-    ) -> ty.Tuple[ty.List[str], ty.List[str]]:
-        """Get the imports required for the function body
-
-        Parameters
-        ----------
-        src: str
-            the source of the file to extract the import statements from
-        """
-        imports = []
-        block = ""
-        for line in self.source_code.split("\n"):
-            if line.startswith("from") or line.startswith("import"):
-                if "(" in line:
-                    block = line
-                else:
-                    imports.append(line)
-            if ")" in line and block:
-                imports.append(block + line)
-                block = ""
-        # extract imported symbols from import statements
-        used_symbols = set()
-        for function_body in function_bodies:
-            # Strip comments from function body
-            function_body = re.sub(r"\s*#.*", "", function_body)
-            used_symbols.update(re.findall(r"(\w+)", function_body))
-        used_imports = []
-        for stmt in imports:
-            stmt = stmt.replace("\n", "")
-            stmt = stmt.replace("(", "")
-            stmt = stmt.replace(")", "")
-            base_stmt, symbol_str = stmt.split("import ")
-            symbol_parts = symbol_str.split(",")
-            split_parts = [p.split(" as ") for p in symbol_parts]
-            split_parts = [p for p in split_parts if p[-1] in used_symbols]
-            if split_parts:
-                used_imports.append(
-                    base_stmt
-                    + "import "
-                    + ",".join(" as ".join(p) for p in split_parts)
-                )
-        return used_imports
-
-    @property
-    def referenced_local_functions(self):
-        return self._referenced_funcs_and_methods[0]
-
-    @property
-    def referenced_methods(self):
-        return self._referenced_funcs_and_methods[1]
-
-    @property
-    def method_args(self):
-        return self._referenced_funcs_and_methods[2]
-
-    @cached_property
-    def _referenced_funcs_and_methods(self):
-        referenced_funcs = set()
-        referenced_methods = set()
-        method_args = {}
-        self._get_referenced(
-            self.nipype_interface._run_interface,
-            referenced_funcs,
-            referenced_methods,
-            method_args,
-        )
-        self._get_referenced(
-            self.nipype_interface._list_outputs,
-            referenced_funcs,
-            referenced_methods,
-            method_args,
-        )
-        return referenced_funcs, referenced_methods, method_args
-
-    def replace_attributes(self, function_body: ty.Callable) -> str:
-        """Replace self.inputs.<name> with <name> in the function body and add args to the
-        function signature"""
-        function_body = re.sub(r"self\.inputs\.(\w+)", r"\1", function_body)
-
-    def _get_referenced(
-        self,
-        function: ty.Callable,
-        referenced_funcs: ty.Set[ty.Callable],
-        referenced_methods: ty.Set[ty.Callable],
-        method_args: ty.Dict[str, ty.List[str]],
-    ):
-        """Get the local functions referenced in the source code
-
-        Parameters
-        ----------
-        src: str
-            the source of the file to extract the import statements from
-        referenced_funcs: set[function]
-            the set of local functions that have been referenced so far
-        referenced_methods: set[function]
-            the set of methods that have been referenced so far
-        """
-        function_body = inspect.getsource(function)
-        function_body = re.sub(r"\s*#.*", "", function_body)
-        ref_local_func_names = re.findall(r"(?<!self\.)(\w+)\(", function_body)
-        ref_local_funcs = set(
-            f
-            for f in self.local_functions
-            if f.__name__ in ref_local_func_names and f not in referenced_funcs
-        )
-
-        ref_method_names = re.findall(r"(?<=self\.)(\w+)\(", function_body)
-        ref_methods = set(m for m in self.methods if m.__name__ in ref_method_names)
-
-        referenced_funcs.update(ref_local_funcs)
-        referenced_methods.update(ref_methods)
-
-        referenced_inputs = set(re.findall(r"(?<=self\.inputs\.)(\w+)", function_body))
-        for func in ref_local_funcs:
-            referenced_inputs.update(
-                self._get_referenced(func, referenced_funcs, referenced_methods)
-            )
-        for meth in ref_methods:
-            ref_inputs = self._get_referenced(
-                meth, referenced_funcs, referenced_methods, method_args=method_args
-            )
-            method_args[meth.__name__] = ref_inputs
-            referenced_inputs.update(ref_inputs)
-        return referenced_inputs
-
-    @cached_property
-    def source_code(self):
-        with open(inspect.getsourcefile(self.nipype_interface)) as f:
-            return f.read()
-
-    @cached_property
-    def local_functions(self):
-        """Get the functions defined in the same file as the interface"""
-        functions = []
-        for attr_name in dir(self.nipype_module):
-            attr = getattr(self.nipype_module, attr_name)
-            if (
-                inspect.isfunction(attr)
-                and attr.__module__ == self.nipype_module.__name__
-            ):
-                functions.append(attr)
-        return functions
-
-    @cached_property
-    def methods(self):
-        """Get the functions defined in the interface"""
-        methods = []
-        for attr_name in dir(self.nipype_interface):
-            if attr_name.startswith("__"):
-                continue
-            attr = getattr(self.nipype_interface, attr_name)
-            if inspect.isfunction(attr):
-                methods.append(attr)
-        return methods
-
-    @cached_property
-    def local_function_names(self):
-        return [f.__name__ for f in self.local_functions]
-
-    RUNTIME_ATTRS = (
-        ("cwd", "os.getcwd()", "import os"),
-        ("environ", "os.environ", "import os"),
-        ("hostname", "platform.node()", "import platform"),
-        ("platform", "platform.platform()", "import platform"),
-    )
-
-    @classmethod
-    def insert_args_in_signature(cls, snippet: str, args: ty.Iterable[str]) -> str:
-        """Insert the arguments into the function signature"""
-        # Insert method args in signature if present
-        pre, contents, post = cls.split_parens_contents(snippet)
-        return pre + (contents + ", " if contents else "") + ", ".join(args) + post
-
-    @classmethod
-    def split_parens_contents(cls, snippet):
-        """Splits the code snippet at the first opening parenthesis into a 3-tuple
-        consisting of the pre-paren text, the contents of the parens and the post-paren
-
-        Parameters
-        ----------
-        snippet: str
-            the code snippet to split
-
-        Returns
-        -------
-        pre: str
-            the text before the opening parenthesis
-        contents: str
-            the contents of the parens
-        post: str
-            the text after the closing parenthesis
-        """
-        splits = re.split(r"(\(|\))", snippet, flags=re.MULTILINE | re.DOTALL)
-        depth = 1
-        pre = "".join(splits[:2])
-        contents = ""
-        for i, s in enumerate(splits[2:], start=2):
-            if s == "(":
-                depth += 1
-            else:
-                if s == ")":
-                    depth -= 1
-                    if depth == 0:
-                        return pre, contents, "".join(splits[i:])
-                contents += s
-        raise ValueError(f"No matching parenthesis found in '{snippet}'")
-
-
-@attrs.define
-class ShellCommandTaskConverter(TaskConverter):
-    def write_task(self, filename, input_fields, nonstd_types, output_fields):
-        """writing pydra task to the dile based on the input and output spec"""
-
-        base_imports = [
-            "from pydra.engine import specs",
-        ]
-
-        task_base = "ShellCommandTask"
-        base_imports.append("from pydra.engine import ShellCommandTask")
-
-        try:
-            executable = self.nipype_interface._cmd
-        except AttributeError:
-            executable = None
-        if not executable:
-            executable = self.nipype_interface.cmd
-            if not isinstance(executable, str):
-                raise RuntimeError(
-                    f"Could not find executable for {self.nipype_interface}"
-                )
-
-        def types_to_names(spec_fields):
-            spec_fields_str = []
-            for el in spec_fields:
-                el = list(el)
-                tp_str = str(el[1])
-                if tp_str.startswith("<class "):
-                    tp_str = el[1].__name__
-                else:
-                    # Alter modules in type string to match those that will be imported
-                    tp_str = tp_str.replace("typing", "ty")
-                    tp_str = re.sub(r"(\w+\.)+(?<!ty\.)(\w+)", r"\2", tp_str)
-                el[1] = "#" + tp_str + "#"
-                spec_fields_str.append(tuple(el))
-            return spec_fields_str
-
-        input_fields_str = types_to_names(spec_fields=input_fields)
-        output_fields_str = types_to_names(spec_fields=output_fields)
-        functions_str = self.function_callables()
-        spec_str = functions_str
-        spec_str += f"input_fields = {input_fields_str}\n"
-        spec_str += f"{self.task_name}_input_spec = specs.SpecInfo(name='Input', fields=input_fields, bases=(specs.ShellSpec,))\n\n"
-        spec_str += f"output_fields = {output_fields_str}\n"
-        spec_str += f"{self.task_name}_output_spec = specs.SpecInfo(name='Output', fields=output_fields, bases=(specs.ShellOutSpec,))\n\n"
-        spec_str += f"class {self.task_name}({task_base}):\n"
-        spec_str += '    """\n'
-        spec_str += self.create_doctests(
-            input_fields=input_fields, nonstd_types=nonstd_types
-        )
-        spec_str += '    """\n'
-        spec_str += f"    input_spec = {self.task_name}_input_spec\n"
-        spec_str += f"    output_spec = {self.task_name}_output_spec\n"
-        if task_base == "ShellCommandTask":
-            spec_str += f"    executable='{executable}'\n"
-
-        spec_str = re.sub(r"'#([^'#]+)#'", r"\1", spec_str)
-
-        imports = self.construct_imports(
-            nonstd_types,
-            spec_str,
-            include_task=False,
-            base=base_imports,
-        )
-        spec_str = "\n".join(imports) + "\n\n" + spec_str
-
-        spec_str = black.format_file_contents(
-            spec_str, fast=False, mode=black.FileMode()
-        )
-
-        with open(filename, "w") as f:
-            f.write(spec_str)
diff --git a/nipype2pydra/task/function.py b/nipype2pydra/task/function.py
new file mode 100644
index 00000000..b8d80fd4
--- /dev/null
+++ b/nipype2pydra/task/function.py
@@ -0,0 +1,389 @@
+import typing as ty
+import re
+import inspect
+from functools import cached_property
+import itertools
+import black
+import attrs
+from .base import TaskConverter
+
+
+@attrs.define
+class FunctionTaskConverter(TaskConverter):
+    def write_task(self, filename, input_fields, nonstd_types, output_fields):
+        """writing pydra task to the dile based on the input and output spec"""
+
+        base_imports = [
+            "import pydra.mark",
+        ]
+
+        def types_to_names(spec_fields):
+            spec_fields_str = []
+            for el in spec_fields:
+                el = list(el)
+                tp_str = str(el[1])
+                if tp_str.startswith("<class "):
+                    tp_str = el[1].__name__
+                else:
+                    # Alter modules in type string to match those that will be imported
+                    tp_str = tp_str.replace("typing", "ty")
+                    tp_str = re.sub(r"(\w+\.)+(?<!ty\.)(\w+)", r"\2", tp_str)
+                el[1] = tp_str
+                spec_fields_str.append(tuple(el))
+            return spec_fields_str
+
+        input_fields_str = types_to_names(spec_fields=input_fields)
+        output_fields_str = types_to_names(spec_fields=output_fields)
+        input_names = [i[0] for i in input_fields]
+        output_names = [o[0] for o in output_fields]
+        output_type_names = [o[1] for o in output_fields_str]
+
+        # Combined src of run_interface and list_outputs
+        function_body = inspect.getsource(self.nipype_interface._run_interface).strip()
+        function_body = "\n".join(function_body.split("\n")[1:-1])
+        lo_src = inspect.getsource(self.nipype_interface._list_outputs).strip()
+        lo_lines = lo_src.split("\n")
+        lo_src = "\n".join(lo_lines[1:-1])
+        function_body += lo_src
+
+        # Replace return outputs dictionary with individual outputs
+        return_line = lo_lines[-1]
+        match = re.match(r"\s*return(.*)", return_line)
+        return_value = match.group(1).strip()
+        output_re = re.compile(return_value + r"\[(?:'|\")(\w+)(?:'|\")\]")
+        unrecognised_outputs = set(
+            m for m in output_re.findall(function_body) if m not in output_names
+        )
+        assert (
+            not unrecognised_outputs
+        ), f"Found the following unrecognised outputs {unrecognised_outputs}"
+        function_body = output_re.sub(r"\1", function_body)
+        function_body = self.process_function_body(function_body, input_names)
+
+        # Create the spec string
+        spec_str = self.function_callables()
+        spec_str += "@pydra.mark.task\n"
+        spec_str += "@pydra.mark.annotate({'return': {"
+        spec_str += ", ".join(f"'{n}': {t}" for n, t, _ in output_fields_str)
+        spec_str += "}})\n"
+        spec_str += f"def {self.task_name}("
+        spec_str += ", ".join(f"{i[0]}: {i[1]}" for i in input_fields_str)
+        spec_str += ") -> "
+        if len(output_type_names) > 1:
+            spec_str += "ty.Tuple[" + ", ".join(output_type_names) + "]"
+        else:
+            spec_str += output_type_names[0]
+        spec_str += ':\n    """\n'
+        spec_str += self.create_doctests(
+            input_fields=input_fields, nonstd_types=nonstd_types
+        )
+        spec_str += '    """\n'
+        spec_str += function_body + "\n"
+        spec_str += "\n    return {}".format(", ".join(output_names))
+
+        for f in self.local_functions:
+            spec_str += "\n\n" + inspect.getsource(f)
+        spec_str += "\n\n".join(
+            inspect.getsource(f) for f in self.local_functions
+        )
+
+        spec_str += "\n\n" + "\n\n".join(
+            self.process_method(m, input_names, output_names) for m in self.referenced_methods
+        )
+
+        # Replace runtime attributes
+        additional_imports = set()
+        for attr, repl, imprt in self.RUNTIME_ATTRS:
+            repl_spec_str = spec_str.replace(f"runtime.{attr}", repl)
+            if repl_spec_str != spec_str:
+                additional_imports.add(imprt)
+                spec_str = repl_spec_str
+
+        other_imports = self.get_imports(
+            [function_body] + [inspect.getsource(f) for f in itertools.chain(self.referenced_local_functions, self.referenced_methods)]
+        )
+
+        imports = self.construct_imports(
+            nonstd_types,
+            spec_str,
+            include_task=False,
+            base=base_imports + other_imports + list(additional_imports),
+        )
+        spec_str = "\n".join(imports) + "\n\n" + spec_str
+
+        spec_str = black.format_file_contents(
+            spec_str, fast=False, mode=black.FileMode()
+        )
+
+        with open(filename, "w") as f:
+            f.write(spec_str)
+
+    def process_method(
+        self,
+        func: str,
+        input_names: ty.List[str],
+        output_names: ty.List[str],
+    ):
+        src = inspect.getsource(func)
+        pre, arglist, post = self.split_parens_contents(src)
+        if func.__name__ in self.method_args:
+            arglist = (arglist + ", " if arglist else "") + ", ".join(f"{a}=None" for a in self.method_args[func.__name__])
+        # Insert method args in signature if present
+        return_types, function_body = post.split(":", maxsplit=1)
+        function_body = function_body.split("\n", maxsplit=1)[1]
+        function_body = self.process_function_body(function_body, input_names)
+        return f"{pre.strip()}{arglist}{return_types}:\n{function_body}"
+
+    def process_function_body(self, function_body: str, input_names: ty.List[str]) -> str:
+        """Replace self.inputs.<name> with <name> in the function body and add args to the
+        function signature
+
+        Parameters
+        ----------
+        function_body: str
+            The source code of the function to process
+        input_names: list[str]
+            The names of the inputs to the function
+
+        Returns
+        -------
+        function_body: str
+            The processed source code
+        """
+        # Replace self.inputs.<name> with <name> in the function body
+        input_re = re.compile(r"self\.inputs\.(\w+)")
+        unrecognised_inputs = set(
+            m for m in input_re.findall(function_body) if m not in input_names
+        )
+        assert (
+            not unrecognised_inputs
+        ), f"Found the following unrecognised inputs {unrecognised_inputs}"
+        function_body = input_re.sub(r"\1", function_body)
+        # Add args to the function signature of method calls
+        method_re = re.compile(r"self\.(\w+)(?=\()", flags=re.MULTILINE | re.DOTALL)
+        method_names = [m.__name__ for m in self.referenced_methods]
+        unrecognised_methods = set(
+            m for m in method_re.findall(function_body) if m not in method_names
+        )
+        assert (
+            not unrecognised_methods
+        ), f"Found the following unrecognised methods {unrecognised_methods}"
+        splits = method_re.split(function_body)
+        new_body = splits[0]
+        for name, args in zip(splits[1::2], splits[2::2]):
+            new_body += name + self.insert_args_in_signature(args, [f"{a}={a}" for a in self.method_args[name]])
+        function_body = new_body
+        # Detect the indentation of the source code in src and reduce it to 4 spaces
+        indents = re.findall(r"^\s+", function_body, flags=re.MULTILINE)
+        min_indent = min(len(i) for i in indents if i)
+        indent_reduction = min_indent - 4
+        function_body = re.sub(r"^" + " " * indent_reduction, "", function_body, flags=re.MULTILINE)
+        return function_body
+
+    def get_imports(
+        self, function_bodies: ty.List[str]
+    ) -> ty.Tuple[ty.List[str], ty.List[str]]:
+        """Get the imports required for the function body
+
+        Parameters
+        ----------
+        src: str
+            the source of the file to extract the import statements from
+        """
+        imports = []
+        block = ""
+        for line in self.source_code.split("\n"):
+            if line.startswith("from") or line.startswith("import"):
+                if "(" in line:
+                    block = line
+                else:
+                    imports.append(line)
+            if ")" in line and block:
+                imports.append(block + line)
+                block = ""
+        # extract imported symbols from import statements
+        used_symbols = set()
+        for function_body in function_bodies:
+            # Strip comments from function body
+            function_body = re.sub(r"\s*#.*", "", function_body)
+            used_symbols.update(re.findall(r"(\w+)", function_body))
+        used_imports = []
+        for stmt in imports:
+            stmt = stmt.replace("\n", "")
+            stmt = stmt.replace("(", "")
+            stmt = stmt.replace(")", "")
+            base_stmt, symbol_str = stmt.split("import ")
+            symbol_parts = symbol_str.split(",")
+            split_parts = [p.split(" as ") for p in symbol_parts]
+            split_parts = [p for p in split_parts if p[-1] in used_symbols]
+            if split_parts:
+                used_imports.append(
+                    base_stmt
+                    + "import "
+                    + ",".join(" as ".join(p) for p in split_parts)
+                )
+        return used_imports
+
+    @property
+    def referenced_local_functions(self):
+        return self._referenced_funcs_and_methods[0]
+
+    @property
+    def referenced_methods(self):
+        return self._referenced_funcs_and_methods[1]
+
+    @property
+    def method_args(self):
+        return self._referenced_funcs_and_methods[2]
+
+    @cached_property
+    def _referenced_funcs_and_methods(self):
+        referenced_funcs = set()
+        referenced_methods = set()
+        method_args = {}
+        self._get_referenced(
+            self.nipype_interface._run_interface,
+            referenced_funcs,
+            referenced_methods,
+            method_args,
+        )
+        self._get_referenced(
+            self.nipype_interface._list_outputs,
+            referenced_funcs,
+            referenced_methods,
+            method_args,
+        )
+        return referenced_funcs, referenced_methods, method_args
+
+    def replace_attributes(self, function_body: ty.Callable) -> str:
+        """Replace self.inputs.<name> with <name> in the function body and add args to the
+        function signature"""
+        function_body = re.sub(r"self\.inputs\.(\w+)", r"\1", function_body)
+
+    def _get_referenced(
+        self,
+        function: ty.Callable,
+        referenced_funcs: ty.Set[ty.Callable],
+        referenced_methods: ty.Set[ty.Callable],
+        method_args: ty.Dict[str, ty.List[str]],
+    ):
+        """Get the local functions referenced in the source code
+
+        Parameters
+        ----------
+        src: str
+            the source of the file to extract the import statements from
+        referenced_funcs: set[function]
+            the set of local functions that have been referenced so far
+        referenced_methods: set[function]
+            the set of methods that have been referenced so far
+        """
+        function_body = inspect.getsource(function)
+        function_body = re.sub(r"\s*#.*", "", function_body)
+        ref_local_func_names = re.findall(r"(?<!self\.)(\w+)\(", function_body)
+        ref_local_funcs = set(
+            f
+            for f in self.local_functions
+            if f.__name__ in ref_local_func_names and f not in referenced_funcs
+        )
+
+        ref_method_names = re.findall(r"(?<=self\.)(\w+)\(", function_body)
+        ref_methods = set(m for m in self.methods if m.__name__ in ref_method_names)
+
+        referenced_funcs.update(ref_local_funcs)
+        referenced_methods.update(ref_methods)
+
+        referenced_inputs = set(re.findall(r"(?<=self\.inputs\.)(\w+)", function_body))
+        for func in ref_local_funcs:
+            referenced_inputs.update(
+                self._get_referenced(func, referenced_funcs, referenced_methods)
+            )
+        for meth in ref_methods:
+            ref_inputs = self._get_referenced(
+                meth, referenced_funcs, referenced_methods, method_args=method_args
+            )
+            method_args[meth.__name__] = ref_inputs
+            referenced_inputs.update(ref_inputs)
+        return referenced_inputs
+
+    @cached_property
+    def source_code(self):
+        with open(inspect.getsourcefile(self.nipype_interface)) as f:
+            return f.read()
+
+    @cached_property
+    def local_functions(self):
+        """Get the functions defined in the same file as the interface"""
+        functions = []
+        for attr_name in dir(self.nipype_module):
+            attr = getattr(self.nipype_module, attr_name)
+            if (
+                inspect.isfunction(attr)
+                and attr.__module__ == self.nipype_module.__name__
+            ):
+                functions.append(attr)
+        return functions
+
+    @cached_property
+    def methods(self):
+        """Get the functions defined in the interface"""
+        methods = []
+        for attr_name in dir(self.nipype_interface):
+            if attr_name.startswith("__"):
+                continue
+            attr = getattr(self.nipype_interface, attr_name)
+            if inspect.isfunction(attr):
+                methods.append(attr)
+        return methods
+
+    @cached_property
+    def local_function_names(self):
+        return [f.__name__ for f in self.local_functions]
+
+    RUNTIME_ATTRS = (
+        ("cwd", "os.getcwd()", "import os"),
+        ("environ", "os.environ", "import os"),
+        ("hostname", "platform.node()", "import platform"),
+        ("platform", "platform.platform()", "import platform"),
+    )
+
+    @classmethod
+    def insert_args_in_signature(cls, snippet: str, args: ty.Iterable[str]) -> str:
+        """Insert the arguments into the function signature"""
+        # Insert method args in signature if present
+        pre, contents, post = cls.split_parens_contents(snippet)
+        return pre + (contents + ", " if contents else "") + ", ".join(args) + post
+
+    @classmethod
+    def split_parens_contents(cls, snippet):
+        """Splits the code snippet at the first opening parenthesis into a 3-tuple
+        consisting of the pre-paren text, the contents of the parens and the post-paren
+
+        Parameters
+        ----------
+        snippet: str
+            the code snippet to split
+
+        Returns
+        -------
+        pre: str
+            the text before the opening parenthesis
+        contents: str
+            the contents of the parens
+        post: str
+            the text after the closing parenthesis
+        """
+        splits = re.split(r"(\(|\))", snippet, flags=re.MULTILINE | re.DOTALL)
+        depth = 1
+        pre = "".join(splits[:2])
+        contents = ""
+        for i, s in enumerate(splits[2:], start=2):
+            if s == "(":
+                depth += 1
+            else:
+                if s == ")":
+                    depth -= 1
+                    if depth == 0:
+                        return pre, contents, "".join(splits[i:])
+                contents += s
+        raise ValueError(f"No matching parenthesis found in '{snippet}'")
diff --git a/nipype2pydra/task/shell_command.py b/nipype2pydra/task/shell_command.py
new file mode 100644
index 00000000..0697d49d
--- /dev/null
+++ b/nipype2pydra/task/shell_command.py
@@ -0,0 +1,79 @@
+import re
+import black
+import attrs
+from .base import TaskConverter
+
+
+@attrs.define
+class ShellCommandTaskConverter(TaskConverter):
+    def write_task(self, filename, input_fields, nonstd_types, output_fields):
+        """writing pydra task to the dile based on the input and output spec"""
+
+        base_imports = [
+            "from pydra.engine import specs",
+        ]
+
+        task_base = "ShellCommandTask"
+        base_imports.append("from pydra.engine import ShellCommandTask")
+
+        try:
+            executable = self.nipype_interface._cmd
+        except AttributeError:
+            executable = None
+        if not executable:
+            executable = self.nipype_interface.cmd
+            if not isinstance(executable, str):
+                raise RuntimeError(
+                    f"Could not find executable for {self.nipype_interface}"
+                )
+
+        def types_to_names(spec_fields):
+            spec_fields_str = []
+            for el in spec_fields:
+                el = list(el)
+                tp_str = str(el[1])
+                if tp_str.startswith("<class "):
+                    tp_str = el[1].__name__
+                else:
+                    # Alter modules in type string to match those that will be imported
+                    tp_str = tp_str.replace("typing", "ty")
+                    tp_str = re.sub(r"(\w+\.)+(?<!ty\.)(\w+)", r"\2", tp_str)
+                el[1] = "#" + tp_str + "#"
+                spec_fields_str.append(tuple(el))
+            return spec_fields_str
+
+        input_fields_str = types_to_names(spec_fields=input_fields)
+        output_fields_str = types_to_names(spec_fields=output_fields)
+        functions_str = self.function_callables()
+        spec_str = functions_str
+        spec_str += f"input_fields = {input_fields_str}\n"
+        spec_str += f"{self.task_name}_input_spec = specs.SpecInfo(name='Input', fields=input_fields, bases=(specs.ShellSpec,))\n\n"
+        spec_str += f"output_fields = {output_fields_str}\n"
+        spec_str += f"{self.task_name}_output_spec = specs.SpecInfo(name='Output', fields=output_fields, bases=(specs.ShellOutSpec,))\n\n"
+        spec_str += f"class {self.task_name}({task_base}):\n"
+        spec_str += '    """\n'
+        spec_str += self.create_doctests(
+            input_fields=input_fields, nonstd_types=nonstd_types
+        )
+        spec_str += '    """\n'
+        spec_str += f"    input_spec = {self.task_name}_input_spec\n"
+        spec_str += f"    output_spec = {self.task_name}_output_spec\n"
+        if task_base == "ShellCommandTask":
+            spec_str += f"    executable='{executable}'\n"
+
+        spec_str = re.sub(r"'#([^'#]+)#'", r"\1", spec_str)
+
+        imports = self.construct_imports(
+            nonstd_types,
+            spec_str,
+            include_task=False,
+            base=base_imports,
+        )
+        spec_str = "\n".join(imports) + "\n\n" + spec_str
+
+        spec_str = black.format_file_contents(
+            spec_str, fast=False, mode=black.FileMode()
+        )
+
+        with open(filename, "w") as f:
+            f.write(spec_str)

From 6098051d32007cbf837128d9630a85a644cce93f Mon Sep 17 00:00:00 2001
From: Tom Close <tom.g.close@gmail.com>
Date: Wed, 31 Jan 2024 10:37:26 +1100
Subject: [PATCH 31/78] finished splitting task converter into function and
 shell command tasks

---
 nipype2pydra/cli.py                |  4 ++--
 nipype2pydra/task/__init__.py      | 19 +++++++++++++++-
 nipype2pydra/task/base.py          | 15 +------------
 nipype2pydra/task/function.py      | 35 ++++++++++++++++++++++--------
 nipype2pydra/task/shell_command.py |  4 ++--
 scripts/port_interface.py          |  2 +-
 6 files changed, 50 insertions(+), 29 deletions(-)

diff --git a/nipype2pydra/cli.py b/nipype2pydra/cli.py
index 6860ba12..de08de41 100644
--- a/nipype2pydra/cli.py
+++ b/nipype2pydra/cli.py
@@ -2,7 +2,7 @@
 import click
 import yaml
 from nipype2pydra import __version__
-from .task import TaskConverter
+import nipype2pydra.task
 from .workflow import WorkflowConverter
 
 
@@ -48,7 +48,7 @@ def task(yaml_spec, package_root, callables, output_module):
 
     spec = yaml.safe_load(yaml_spec)
 
-    converter = TaskConverter.load(
+    converter = nipype2pydra.task.get_converter(
         output_module=output_module, callables_module=callables, **spec
     )
     converter.generate(package_root)
diff --git a/nipype2pydra/task/__init__.py b/nipype2pydra/task/__init__.py
index 8d420878..c486f6d3 100644
--- a/nipype2pydra/task/__init__.py
+++ b/nipype2pydra/task/__init__.py
@@ -1,2 +1,19 @@
 from .function import FunctionTaskConverter
-from .shell_command import ShellCommandTaskConverter
\ No newline at end of file
+from .shell_command import ShellCommandTaskConverter
+from importlib import import_module
+
+
+def get_converter(nipype_module: str, nipype_name: str, **kwargs):
+    """Loads the appropriate converter for the given nipype interface."""
+    nipype_interface = getattr(import_module(nipype_module), nipype_name)
+
+    if hasattr(nipype_interface, "_cmd"):
+        from .shell_command import ShellCommandTaskConverter as Converter
+    else:
+        from .function import FunctionTaskConverter as Converter
+
+    return Converter(
+        nipype_module=nipype_module, nipype_name=nipype_name, **kwargs
+    )
+
+__all__ = ["FunctionTaskConverter", "ShellCommandTaskConverter", "get_converter"]
diff --git a/nipype2pydra/task/base.py b/nipype2pydra/task/base.py
index 957152f1..7471fbd2 100644
--- a/nipype2pydra/task/base.py
+++ b/nipype2pydra/task/base.py
@@ -332,7 +332,7 @@ def from_list_to_doctests(
 
 
 @attrs.define
-class TaskConverter:
+class BaseTaskConverter:
     """Specifies how the semi-automatic conversion from Nipype to Pydra should
     be performed
 
@@ -418,19 +418,6 @@ def nipype_output_spec(self) -> nipype.interfaces.base.BaseTraitedSpec:
             else None
         )
 
-    @classmethod
-    def load(cls, nipype_module: str, nipype_name: str, **kwargs):
-        nipype_interface = getattr(import_module(nipype_module), nipype_name)
-
-        if hasattr(nipype_interface, "_cmd"):
-            from .shell_command import ShellCommandTaskConverter as Converter
-        else:
-            from .function import FunctionTaskConverter as Converter
-
-        return Converter(
-            nipype_module=nipype_module, nipype_name=nipype_name, **kwargs
-        )
-
     def generate(self, package_root: Path):
         """creating pydra input/output spec from nipype specs
         if write is True, a pydra Task class will be written to the file together with tests
diff --git a/nipype2pydra/task/function.py b/nipype2pydra/task/function.py
index b8d80fd4..69161db0 100644
--- a/nipype2pydra/task/function.py
+++ b/nipype2pydra/task/function.py
@@ -5,16 +5,18 @@
 import itertools
 import black
 import attrs
-from .base import TaskConverter
+from .base import BaseTaskConverter
 
 
 @attrs.define
-class FunctionTaskConverter(TaskConverter):
+class FunctionTaskConverter(BaseTaskConverter):
     def write_task(self, filename, input_fields, nonstd_types, output_fields):
         """writing pydra task to the dile based on the input and output spec"""
 
         base_imports = [
             "import pydra.mark",
+            "from logging import getLogger",
+            "import attrs",
         ]
 
         def types_to_names(spec_fields):
@@ -62,6 +64,7 @@ def types_to_names(spec_fields):
 
         # Create the spec string
         spec_str = self.function_callables()
+        spec_str += "logger = getLogger(__name__)\n\n"
         spec_str += "@pydra.mark.task\n"
         spec_str += "@pydra.mark.annotate({'return': {"
         spec_str += ", ".join(f"'{n}': {t}" for n, t, _ in output_fields_str)
@@ -111,6 +114,7 @@ def types_to_names(spec_fields):
         )
         spec_str = "\n".join(imports) + "\n\n" + spec_str
 
+        print(spec_str)
         spec_str = black.format_file_contents(
             spec_str, fast=False, mode=black.FileMode()
         )
@@ -125,14 +129,18 @@ def process_method(
         output_names: ty.List[str],
     ):
         src = inspect.getsource(func)
-        pre, arglist, post = self.split_parens_contents(src)
+        pre, argstr, post = self.split_parens_contents(src)
+        args = re.split(r" *, *", argstr)
+        args.remove("self")
+        if "runtime" in args:
+            args.remove("runtime")
         if func.__name__ in self.method_args:
-            arglist = (arglist + ", " if arglist else "") + ", ".join(f"{a}=None" for a in self.method_args[func.__name__])
+            args += [f"{a}=None" for a in self.method_args[func.__name__]]
         # Insert method args in signature if present
         return_types, function_body = post.split(":", maxsplit=1)
         function_body = function_body.split("\n", maxsplit=1)[1]
         function_body = self.process_function_body(function_body, input_names)
-        return f"{pre.strip()}{arglist}{return_types}:\n{function_body}"
+        return f"{pre.strip()}{', '.join(args)}{return_types}:\n{function_body}"
 
     def process_function_body(self, function_body: str, input_names: ty.List[str]) -> str:
         """Replace self.inputs.<name> with <name> in the function body and add args to the
@@ -178,6 +186,9 @@ def process_function_body(self, function_body: str, input_names: ty.List[str]) -
         min_indent = min(len(i) for i in indents if i)
         indent_reduction = min_indent - 4
         function_body = re.sub(r"^" + " " * indent_reduction, "", function_body, flags=re.MULTILINE)
+        # Other misc replacements
+        function_body = function_body.replace("LOGGER.", "logger.")
+        function_body = re.sub(r"isdefined\((\w+)\)", r"\1 is not attrs.NOTHING", function_body)
         return function_body
 
     def get_imports(
@@ -348,11 +359,17 @@ def local_function_names(self):
     )
 
     @classmethod
-    def insert_args_in_signature(cls, snippet: str, args: ty.Iterable[str]) -> str:
+    def insert_args_in_signature(cls, snippet: str, new_args: ty.Iterable[str]) -> str:
         """Insert the arguments into the function signature"""
-        # Insert method args in signature if present
-        pre, contents, post = cls.split_parens_contents(snippet)
-        return pre + (contents + ", " if contents else "") + ", ".join(args) + post
+        # Split out the argstring from the rest of the code snippet
+        pre, argstr, post = cls.split_parens_contents(snippet)
+        if argstr:
+            args = re.split(r" *, *", argstr)
+            if "runtime" in args:
+                args.remove("runtime")
+        else:
+            args = []
+        return pre + ", ".join(args + new_args) + post
 
     @classmethod
     def split_parens_contents(cls, snippet):
diff --git a/nipype2pydra/task/shell_command.py b/nipype2pydra/task/shell_command.py
index 0697d49d..ac92ceb0 100644
--- a/nipype2pydra/task/shell_command.py
+++ b/nipype2pydra/task/shell_command.py
@@ -1,11 +1,11 @@
 import re
 import black
 import attrs
-from .base import TaskConverter
+from .base import BaseTaskConverter
 
 
 @attrs.define
-class ShellCommandTaskConverter(TaskConverter):
+class ShellCommandTaskConverter(BaseTaskConverter):
     def write_task(self, filename, input_fields, nonstd_types, output_fields):
         """writing pydra task to the dile based on the input and output spec"""
 
diff --git a/scripts/port_interface.py b/scripts/port_interface.py
index 495b257e..f65ddc3b 100644
--- a/scripts/port_interface.py
+++ b/scripts/port_interface.py
@@ -12,7 +12,7 @@
 with open(spec_file) as f:
     spec = yaml.load(f, Loader=yaml.SafeLoader)
 
-converter = nipype2pydra.task.TaskConverter.load(
+converter = nipype2pydra.task.get_converter(
     output_module=spec["nipype_module"].split("interfaces.")[-1]
     + ".auto."
     + nipype2pydra.utils.to_snake_case(spec["task_name"]),

From ec1d4303a54701044e33ce2fbec2f5e5fdd71409 Mon Sep 17 00:00:00 2001
From: Tom Close <tom.g.close@gmail.com>
Date: Fri, 2 Feb 2024 12:18:04 +1100
Subject: [PATCH 32/78] added find/replace for Multi(Input|Output) and prepend
 specs. module to them

---
 nipype2pydra/task/base.py          | 42 +++++++++++++++++++++++-------
 nipype2pydra/task/function.py      | 11 ++------
 nipype2pydra/task/shell_command.py | 10 ++-----
 3 files changed, 36 insertions(+), 27 deletions(-)

diff --git a/nipype2pydra/task/base.py b/nipype2pydra/task/base.py
index 7471fbd2..934b3dbd 100644
--- a/nipype2pydra/task/base.py
+++ b/nipype2pydra/task/base.py
@@ -2,6 +2,7 @@
 from pathlib import Path
 import typing as ty
 import re
+from abc import ABCMeta, abstractmethod
 from importlib import import_module
 from types import ModuleType
 import itertools
@@ -52,16 +53,31 @@ def str_to_type(type_str: str) -> type:
             tp = tp.primitive  # type: ignore
         except AttributeError:
             pass
-    elif "." in type_str:
-        parts = type_str.split(".")
-        module = import_module(".".join(parts[:-1]))
-        tp = getattr(module, parts[-1])
-        if not inspect.isclass(tp):
-            raise TypeError(f"Designated type at {type_str} is not a class {tp}")
-    elif re.match(r"^\w+$", type_str):
-        tp = eval(type_str)
     else:
-        raise ValueError(f"Cannot parse {type_str} to a type safely")
+        def resolve_type(type_str: str) -> type:
+            if "." in type_str:
+                parts = type_str.split(".")
+                module = import_module(".".join(parts[:-1]))
+                class_str = parts[-1]
+            else:
+                class_str = type_str
+                module = None
+            match = re.match(r"(\w+)(\[.*\])?", class_str)
+            class_str = match.group(1)
+            if module:
+                t = getattr(module, match.group(1))
+            else:
+                if not re.match(r"^\w+$", class_str):
+                    raise ValueError(f"Cannot parse {class_str} to a type safely")
+                t = eval(class_str)
+            if match.group(2):
+                args = tuple(resolve_type(arg) for arg in match.group(2)[1:-1].split(','))
+                t = t.__getitem__(args)
+            return t
+
+        tp = resolve_type(type_str)
+        if not inspect.isclass(tp) and type(tp).__module__ != "typing":
+            raise TypeError(f"Designated type at {type_str} is not a class {tp}")
     return tp
 
 
@@ -332,7 +348,7 @@ def from_list_to_doctests(
 
 
 @attrs.define
-class BaseTaskConverter:
+class BaseTaskConverter(metaclass=ABCMeta):
     """Specifies how the semi-automatic conversion from Nipype to Pydra should
     be performed
 
@@ -761,9 +777,15 @@ def types_to_names(spec_fields):
             spec_str, fast=False, mode=black.FileMode()
         )
 
+        spec_str = re.sub(r"(?<!specs\.)Multi(Input|Output)", r"specs.Multi\1", spec_str)
+
         with open(filename, "w") as f:
             f.write(spec_str)
 
+    @abstractmethod
+    def generate_task_str(self, filename, input_fields, nonstd_types, output_fields):
+        raise NotImplementedError
+
     def construct_imports(
         self, nonstd_types: ty.List[type], spec_str="", base=(), include_task=True
     ) -> ty.List[str]:
diff --git a/nipype2pydra/task/function.py b/nipype2pydra/task/function.py
index 69161db0..2f61a134 100644
--- a/nipype2pydra/task/function.py
+++ b/nipype2pydra/task/function.py
@@ -3,14 +3,13 @@
 import inspect
 from functools import cached_property
 import itertools
-import black
 import attrs
 from .base import BaseTaskConverter
 
 
 @attrs.define
 class FunctionTaskConverter(BaseTaskConverter):
-    def write_task(self, filename, input_fields, nonstd_types, output_fields):
+    def generate_task_str(self, filename, input_fields, nonstd_types, output_fields):
         """writing pydra task to the dile based on the input and output spec"""
 
         base_imports = [
@@ -114,13 +113,7 @@ def types_to_names(spec_fields):
         )
         spec_str = "\n".join(imports) + "\n\n" + spec_str
 
-        print(spec_str)
-        spec_str = black.format_file_contents(
-            spec_str, fast=False, mode=black.FileMode()
-        )
-
-        with open(filename, "w") as f:
-            f.write(spec_str)
+        return spec_str
 
     def process_method(
         self,
diff --git a/nipype2pydra/task/shell_command.py b/nipype2pydra/task/shell_command.py
index ac92ceb0..c84ca73c 100644
--- a/nipype2pydra/task/shell_command.py
+++ b/nipype2pydra/task/shell_command.py
@@ -1,12 +1,11 @@
 import re
-import black
 import attrs
 from .base import BaseTaskConverter
 
 
 @attrs.define
 class ShellCommandTaskConverter(BaseTaskConverter):
-    def write_task(self, filename, input_fields, nonstd_types, output_fields):
+    def generate_task_str(self, filename, input_fields, nonstd_types, output_fields):
         """writing pydra task to the dile based on the input and output spec"""
 
         base_imports = [
@@ -71,9 +70,4 @@ def types_to_names(spec_fields):
         )
         spec_str = "\n".join(imports) + "\n\n" + spec_str
 
-        spec_str = black.format_file_contents(
-            spec_str, fast=False, mode=black.FileMode()
-        )
-
-        with open(filename, "w") as f:
-            f.write(spec_str)
+        return spec_str

From b85c570248e622833d8fff01d1e6b1220b5f6b2c Mon Sep 17 00:00:00 2001
From: Tom Close <tom.g.close@gmail.com>
Date: Mon, 5 Feb 2024 07:20:31 +1100
Subject: [PATCH 33/78] fixed up recursive inclusion of local functions in
 function task converter

---
 nipype2pydra/task/base.py     |   4 +-
 nipype2pydra/task/function.py | 187 +++++++++++++++++++++++++++-------
 2 files changed, 151 insertions(+), 40 deletions(-)

diff --git a/nipype2pydra/task/base.py b/nipype2pydra/task/base.py
index 934b3dbd..f11b34aa 100644
--- a/nipype2pydra/task/base.py
+++ b/nipype2pydra/task/base.py
@@ -795,7 +795,7 @@ def construct_imports(
         def add_import(stmt):
             match = re.match(r".*\s+as\s+(\w+)\s*", stmt)
             if not match:
-                match = re.match(r".*import\s+([\w\.]+)\s*$", stmt)
+                match = re.match(r".*import\s+([\w\., ]+)\s*$", stmt)
             if not match:
                 raise ValueError(f"Unrecognised import statment {stmt}")
             token = match.group(1)
@@ -845,7 +845,7 @@ def unwrap_nested_type(t: type) -> ty.List[type]:
         if include_task:
             add_import(f"from {self.output_module} import {self.task_name}")
 
-        return list(stmts.values())
+        return sorted(stmts.values())
 
     def write_tests(self, filename_test, input_fields, nonstd_types, run=False):
         spec_str = ""
diff --git a/nipype2pydra/task/function.py b/nipype2pydra/task/function.py
index 2f61a134..997b7606 100644
--- a/nipype2pydra/task/function.py
+++ b/nipype2pydra/task/function.py
@@ -1,8 +1,10 @@
 import typing as ty
 import re
 import inspect
+from operator import attrgetter, itemgetter
 from functools import cached_property
 import itertools
+from importlib import import_module
 import attrs
 from .base import BaseTaskConverter
 
@@ -83,15 +85,22 @@ def types_to_names(spec_fields):
         spec_str += function_body + "\n"
         spec_str += "\n    return {}".format(", ".join(output_names))
 
-        for f in self.local_functions:
-            spec_str += "\n\n" + inspect.getsource(f)
-        spec_str += "\n\n".join(
-            inspect.getsource(f) for f in self.local_functions
+        (other_imports, funcs_to_include, used_local_functions) = (
+            self.get_imports_and_functions_to_include(
+                [function_body]
+                + [
+                    inspect.getsource(f)
+                    for f in itertools.chain(
+                        self.referenced_local_functions, self.referenced_methods
+                    )
+                ]
+            )
         )
 
-        spec_str += "\n\n" + "\n\n".join(
-            self.process_method(m, input_names, output_names) for m in self.referenced_methods
-        )
+        spec_str += "\n\n# Nipype methods converted into functions\n\n"
+
+        for m in sorted(self.referenced_methods, key=attrgetter("__name__")):
+            spec_str += "\n\n" + self.process_method(m, input_names, output_names)
 
         # Replace runtime attributes
         additional_imports = set()
@@ -101,15 +110,30 @@ def types_to_names(spec_fields):
                 additional_imports.add(imprt)
                 spec_str = repl_spec_str
 
-        other_imports = self.get_imports(
-            [function_body] + [inspect.getsource(f) for f in itertools.chain(self.referenced_local_functions, self.referenced_methods)]
-        )
+        spec_str += "\n\n# Functions defined locally in the original module\n\n"
+
+        for func in sorted(used_local_functions, key=attrgetter("__name__")):
+            spec_str += "\n\n" + self.process_function_body(
+                inspect.getsource(func), input_names
+            )
+
+        spec_str += "\n\n# Functions defined in neighbouring modules that have been included inline instead of imported\n\n"
+
+        for func_name, func in sorted(funcs_to_include, key=itemgetter(0)):
+            func_src = inspect.getsource(func)
+            func_src = re.sub(
+                r"^(def|class) (\w+)(?=\()",
+                r"\1 " + func_name,
+                func_src,
+                flags=re.MULTILINE,
+            )
+            spec_str += "\n\n" + self.process_function_body(func_src, input_names)
 
         imports = self.construct_imports(
             nonstd_types,
             spec_str,
             include_task=False,
-            base=base_imports + other_imports + list(additional_imports),
+            base=base_imports + list(other_imports) + list(additional_imports),
         )
         spec_str = "\n".join(imports) + "\n\n" + spec_str
 
@@ -133,9 +157,12 @@ def process_method(
         return_types, function_body = post.split(":", maxsplit=1)
         function_body = function_body.split("\n", maxsplit=1)[1]
         function_body = self.process_function_body(function_body, input_names)
+
         return f"{pre.strip()}{', '.join(args)}{return_types}:\n{function_body}"
 
-    def process_function_body(self, function_body: str, input_names: ty.List[str]) -> str:
+    def process_function_body(
+        self, function_body: str, input_names: ty.List[str]
+    ) -> str:
         """Replace self.inputs.<name> with <name> in the function body and add args to the
         function signature
 
@@ -172,31 +199,61 @@ def process_function_body(self, function_body: str, input_names: ty.List[str]) -
         splits = method_re.split(function_body)
         new_body = splits[0]
         for name, args in zip(splits[1::2], splits[2::2]):
-            new_body += name + self.insert_args_in_signature(args, [f"{a}={a}" for a in self.method_args[name]])
+            new_body += name + self.insert_args_in_signature(
+                args, [f"{a}={a}" for a in self.method_args[name]]
+            )
         function_body = new_body
         # Detect the indentation of the source code in src and reduce it to 4 spaces
         indents = re.findall(r"^\s+", function_body, flags=re.MULTILINE)
         min_indent = min(len(i) for i in indents if i)
         indent_reduction = min_indent - 4
-        function_body = re.sub(r"^" + " " * indent_reduction, "", function_body, flags=re.MULTILINE)
+        function_body = re.sub(
+            r"^" + " " * indent_reduction, "", function_body, flags=re.MULTILINE
+        )
         # Other misc replacements
         function_body = function_body.replace("LOGGER.", "logger.")
-        function_body = re.sub(r"isdefined\((\w+)\)", r"\1 is not attrs.NOTHING", function_body)
+        function_body = re.sub(
+            r"not isdefined\((\w+)\)", r"\1 is attrs.NOTHING", function_body
+        )
+        function_body = re.sub(
+            r"isdefined\((\w+)\)", r"\1 is not attrs.NOTHING", function_body
+        )
         return function_body
 
-    def get_imports(
-        self, function_bodies: ty.List[str]
-    ) -> ty.Tuple[ty.List[str], ty.List[str]]:
+    def get_imports_and_functions_to_include(
+        self,
+        function_bodies: ty.List[str],
+        source_code: str = None,
+        local_functions: ty.List[ty.Callable] = None,
+    ) -> ty.Tuple[ty.List[str], ty.List[ty.Tuple[str, ty.Any]]]:
         """Get the imports required for the function body
 
         Parameters
         ----------
-        src: str
-            the source of the file to extract the import statements from
+        function_bodies: list[str]
+            the source of all functions that need to be checked for used imports
+        source_code: str, optional
+            the source code containing the relevant import statements, by default the source
+            file containing the interface to be converted
+
+        Returns
+        -------
+        used_imports : list[str]
+            the import statements that need to be included in the converted file
+        external_functions: list[tuple[str, Any]]
+            list of objects (e.g. classes, functions and variables) that are defined
+            in neighbouring modules that need to be included in the converted file
+            (as opposed of just imported from independent packages) along with the name
+            that they were imported as and therefore should be named as in the converted
+            module
         """
+        if source_code is None:
+            source_code = self.source_code
+        if local_functions is None:
+            local_functions = self.local_functions
         imports = []
         block = ""
-        for line in self.source_code.split("\n"):
+        for line in source_code.split("\n"):
             if line.startswith("from") or line.startswith("import"):
                 if "(" in line:
                     block = line
@@ -211,22 +268,74 @@ def get_imports(
             # Strip comments from function body
             function_body = re.sub(r"\s*#.*", "", function_body)
             used_symbols.update(re.findall(r"(\w+)", function_body))
-        used_imports = []
+        used_imports = set()
+        used_local_functions = set()
+        # Keep looping through local function source until all local functions are added
+        new_symbols = True
+        while new_symbols:
+            new_symbols = False
+            for local_func in local_functions:
+                if (
+                    local_func.__name__ in used_symbols
+                    and local_func not in used_local_functions
+                ):
+                    used_local_functions.add(local_func)
+                    func_body = inspect.getsource(local_func)
+                    func_body = re.sub(r"\s*#.*", "", func_body)
+                    local_func_symbols = re.findall(r"(\w+)", func_body)
+                    used_symbols.update(local_func_symbols)
+                    new_symbols = True
+        # functions to copy from a relative or nipype module into the output module
+        external_functions = set()
         for stmt in imports:
             stmt = stmt.replace("\n", "")
             stmt = stmt.replace("(", "")
             stmt = stmt.replace(")", "")
             base_stmt, symbol_str = stmt.split("import ")
-            symbol_parts = symbol_str.split(",")
-            split_parts = [p.split(" as ") for p in symbol_parts]
-            split_parts = [p for p in split_parts if p[-1] in used_symbols]
-            if split_parts:
-                used_imports.append(
+            symbol_parts = re.split(r" *, *", symbol_str)
+            split_parts = [re.split(r" +as +", p) for p in symbol_parts]
+            used_parts = [p for p in split_parts if p[-1] in used_symbols]
+            if used_parts:
+                required_stmt = (
                     base_stmt
                     + "import "
-                    + ",".join(" as ".join(p) for p in split_parts)
+                    + ", ".join(" as ".join(p) for p in used_parts)
                 )
-        return used_imports
+                match = re.match(r"from ([\w\.]+)", base_stmt)
+                import_mod = match.group(1) if match else ""
+                if import_mod.startswith(".") or import_mod.startswith("nipype."):
+                    if import_mod.startswith("."):
+                        match = re.match(r"(\.*)(.*)", import_mod)
+                        mod_parts = self.nipype_module.__name__.split(".")
+                        nparents = len(match.group(1))
+                        if nparents:
+                            mod_parts = mod_parts[:-nparents]
+                        mod_name = ".".join(mod_parts) + "." + match.group(2)
+                    elif import_mod.startswith("nipype."):
+                        mod_name = import_mod
+                    else:
+                        assert False
+                    mod = import_module(mod_name)
+                    mod_func_bodies = []
+                    for used_part in used_parts:
+                        func = getattr(mod, used_part[0])
+                        external_functions.add((used_part[-1], func))
+                        mod_func_bodies.append(inspect.getsource(func))
+                    # Recursively include neighbouring objects imported in the module
+                    (mod_used_imports, mod_external_funcs, mod_local_funcs) = (
+                        self.get_imports_and_functions_to_include(
+                            function_bodies=mod_func_bodies,
+                            source_code=inspect.getsource(mod),
+                            local_functions=get_local_functions(mod)
+                        )
+                    )
+                    used_imports.update(mod_used_imports)
+                    external_functions.update(mod_external_funcs)
+                    external_functions.update((f.__name__, f) for f in mod_local_funcs)
+                else:
+                    used_imports.add(required_stmt)
+
+        return used_imports, external_functions, used_local_functions
 
     @property
     def referenced_local_functions(self):
@@ -318,15 +427,7 @@ def source_code(self):
     @cached_property
     def local_functions(self):
         """Get the functions defined in the same file as the interface"""
-        functions = []
-        for attr_name in dir(self.nipype_module):
-            attr = getattr(self.nipype_module, attr_name)
-            if (
-                inspect.isfunction(attr)
-                and attr.__module__ == self.nipype_module.__name__
-            ):
-                functions.append(attr)
-        return functions
+        return get_local_functions(self.nipype_module)
 
     @cached_property
     def methods(self):
@@ -397,3 +498,13 @@ def split_parens_contents(cls, snippet):
                         return pre, contents, "".join(splits[i:])
                 contents += s
         raise ValueError(f"No matching parenthesis found in '{snippet}'")
+
+
+def get_local_functions(mod):
+    """Get the functions defined in the same file as the interface"""
+    functions = []
+    for attr_name in dir(mod):
+        attr = getattr(mod, attr_name)
+        if inspect.isfunction(attr) and attr.__module__ == mod.__name__:
+            functions.append(attr)
+    return functions

From dda62bde3a4ddedca169b7c064060be96087acf5 Mon Sep 17 00:00:00 2001
From: Tom Close <tom.g.close@gmail.com>
Date: Mon, 5 Feb 2024 11:59:48 +1100
Subject: [PATCH 34/78] added in constants defined within the file body

---
 nipype2pydra/task/base.py     |  17 ++-
 nipype2pydra/task/function.py | 240 ++++++++++++++++++++--------------
 2 files changed, 158 insertions(+), 99 deletions(-)

diff --git a/nipype2pydra/task/base.py b/nipype2pydra/task/base.py
index f11b34aa..11a7715c 100644
--- a/nipype2pydra/task/base.py
+++ b/nipype2pydra/task/base.py
@@ -54,6 +54,7 @@ def str_to_type(type_str: str) -> type:
         except AttributeError:
             pass
     else:
+
         def resolve_type(type_str: str) -> type:
             if "." in type_str:
                 parts = type_str.split(".")
@@ -71,7 +72,9 @@ def resolve_type(type_str: str) -> type:
                     raise ValueError(f"Cannot parse {class_str} to a type safely")
                 t = eval(class_str)
             if match.group(2):
-                args = tuple(resolve_type(arg) for arg in match.group(2)[1:-1].split(','))
+                args = tuple(
+                    resolve_type(arg) for arg in match.group(2)[1:-1].split(",")
+                )
                 t = t.__getitem__(args)
             return t
 
@@ -567,7 +570,11 @@ def convert_output_spec(self, fields_from_template):
         if not self.nipype_output_spec:
             return pydra_fields_l
         for name, fld in self.nipype_output_spec.traits().items():
-            if name not in self.TRAITS_IRREL and name not in fields_from_template:
+            if (
+                name not in self.TRAITS_IRREL
+                and name not in fields_from_template
+                and name not in self.outputs.omit
+            ):
                 pydra_fld = self.pydra_fld_output(fld, name)
                 pydra_fields_l.append((name,) + pydra_fld)
         return pydra_fields_l
@@ -777,7 +784,9 @@ def types_to_names(spec_fields):
             spec_str, fast=False, mode=black.FileMode()
         )
 
-        spec_str = re.sub(r"(?<!specs\.)Multi(Input|Output)", r"specs.Multi\1", spec_str)
+        spec_str = re.sub(
+            r"(?<!specs\.)Multi(Input|Output)", r"specs.Multi\1", spec_str
+        )
 
         with open(filename, "w") as f:
             f.write(spec_str)
@@ -793,6 +802,8 @@ def construct_imports(
         stmts: ty.Dict[str, str] = {}
 
         def add_import(stmt):
+            if stmt == "from nipype import logging":
+                return
             match = re.match(r".*\s+as\s+(\w+)\s*", stmt)
             if not match:
                 match = re.match(r".*import\s+([\w\., ]+)\s*$", stmt)
diff --git a/nipype2pydra/task/function.py b/nipype2pydra/task/function.py
index 997b7606..bdebb954 100644
--- a/nipype2pydra/task/function.py
+++ b/nipype2pydra/task/function.py
@@ -42,29 +42,30 @@ def types_to_names(spec_fields):
         output_type_names = [o[1] for o in output_fields_str]
 
         # Combined src of run_interface and list_outputs
-        function_body = inspect.getsource(self.nipype_interface._run_interface).strip()
-        function_body = "\n".join(function_body.split("\n")[1:-1])
+        method_body = inspect.getsource(self.nipype_interface._run_interface).strip()
+        method_body = "\n".join(method_body.split("\n")[1:-1])
         lo_src = inspect.getsource(self.nipype_interface._list_outputs).strip()
         lo_lines = lo_src.split("\n")
         lo_src = "\n".join(lo_lines[1:-1])
-        function_body += lo_src
+        method_body += lo_src
+        method_body = self.process_method_body(method_body, input_names, output_names)
 
-        # Replace return outputs dictionary with individual outputs
-        return_line = lo_lines[-1]
-        match = re.match(r"\s*return(.*)", return_line)
-        return_value = match.group(1).strip()
-        output_re = re.compile(return_value + r"\[(?:'|\")(\w+)(?:'|\")\]")
-        unrecognised_outputs = set(
-            m for m in output_re.findall(function_body) if m not in output_names
+        (other_imports, funcs_to_include, used_local_functions, used_constants) = (
+            self.get_imports_and_functions_to_include(
+                [method_body]
+                + [
+                    inspect.getsource(f)
+                    for f in itertools.chain(
+                        self.referenced_local_functions, self.referenced_methods
+                    )
+                ]
+            )
         )
-        assert (
-            not unrecognised_outputs
-        ), f"Found the following unrecognised outputs {unrecognised_outputs}"
-        function_body = output_re.sub(r"\1", function_body)
-        function_body = self.process_function_body(function_body, input_names)
+
+        spec_str = "\n".join(f"{n} = {d}" for n, d in used_constants)
 
         # Create the spec string
-        spec_str = self.function_callables()
+        spec_str += "\n\n" + self.function_callables()
         spec_str += "logger = getLogger(__name__)\n\n"
         spec_str += "@pydra.mark.task\n"
         spec_str += "@pydra.mark.annotate({'return': {"
@@ -82,21 +83,9 @@ def types_to_names(spec_fields):
             input_fields=input_fields, nonstd_types=nonstd_types
         )
         spec_str += '    """\n'
-        spec_str += function_body + "\n"
+        spec_str += method_body + "\n"
         spec_str += "\n    return {}".format(", ".join(output_names))
 
-        (other_imports, funcs_to_include, used_local_functions) = (
-            self.get_imports_and_functions_to_include(
-                [function_body]
-                + [
-                    inspect.getsource(f)
-                    for f in itertools.chain(
-                        self.referenced_local_functions, self.referenced_methods
-                    )
-                ]
-            )
-        )
-
         spec_str += "\n\n# Nipype methods converted into functions\n\n"
 
         for m in sorted(self.referenced_methods, key=attrgetter("__name__")):
@@ -146,7 +135,7 @@ def process_method(
         output_names: ty.List[str],
     ):
         src = inspect.getsource(func)
-        pre, argstr, post = self.split_parens_contents(src)
+        pre, argstr, post = split_parens_contents(src)
         args = re.split(r" *, *", argstr)
         args.remove("self")
         if "runtime" in args:
@@ -154,55 +143,68 @@ def process_method(
         if func.__name__ in self.method_args:
             args += [f"{a}=None" for a in self.method_args[func.__name__]]
         # Insert method args in signature if present
-        return_types, function_body = post.split(":", maxsplit=1)
-        function_body = function_body.split("\n", maxsplit=1)[1]
-        function_body = self.process_function_body(function_body, input_names)
-
-        return f"{pre.strip()}{', '.join(args)}{return_types}:\n{function_body}"
+        return_types, method_body = post.split(":", maxsplit=1)
+        method_body = method_body.split("\n", maxsplit=1)[1]
+        method_body = self.process_method_body(method_body, input_names, output_names)
+        return f"{pre.strip()}{', '.join(args)}{return_types}:\n{method_body}"
 
-    def process_function_body(
-        self, function_body: str, input_names: ty.List[str]
+    def process_method_body(
+        self, method_body: str, input_names: ty.List[str], output_names: ty.List[str]
     ) -> str:
-        """Replace self.inputs.<name> with <name> in the function body and add args to the
-        function signature
-
-        Parameters
-        ----------
-        function_body: str
-            The source code of the function to process
-        input_names: list[str]
-            The names of the inputs to the function
-
-        Returns
-        -------
-        function_body: str
-            The processed source code
-        """
         # Replace self.inputs.<name> with <name> in the function body
         input_re = re.compile(r"self\.inputs\.(\w+)")
         unrecognised_inputs = set(
-            m for m in input_re.findall(function_body) if m not in input_names
+            m for m in input_re.findall(method_body) if m not in input_names
         )
         assert (
             not unrecognised_inputs
         ), f"Found the following unrecognised inputs {unrecognised_inputs}"
-        function_body = input_re.sub(r"\1", function_body)
+        method_body = input_re.sub(r"\1", method_body)
+
+        output_re = re.compile(self.return_value + r"\[(?:'|\")(\w+)(?:'|\")\]")
+        unrecognised_outputs = set(
+            m for m in output_re.findall(method_body) if m not in output_names
+        )
+        assert (
+            not unrecognised_outputs
+        ), f"Found the following unrecognised outputs {unrecognised_outputs}"
+        method_body = output_re.sub(r"\1", method_body)
         # Add args to the function signature of method calls
         method_re = re.compile(r"self\.(\w+)(?=\()", flags=re.MULTILINE | re.DOTALL)
         method_names = [m.__name__ for m in self.referenced_methods]
         unrecognised_methods = set(
-            m for m in method_re.findall(function_body) if m not in method_names
+            m for m in method_re.findall(method_body) if m not in method_names
         )
         assert (
             not unrecognised_methods
         ), f"Found the following unrecognised methods {unrecognised_methods}"
-        splits = method_re.split(function_body)
+        splits = method_re.split(method_body)
         new_body = splits[0]
         for name, args in zip(splits[1::2], splits[2::2]):
             new_body += name + self.insert_args_in_signature(
                 args, [f"{a}={a}" for a in self.method_args[name]]
             )
-        function_body = new_body
+        method_body = new_body
+        return self.process_function_body(method_body, input_names=input_names)
+
+    def process_function_body(
+        self, function_body: str, input_names: ty.List[str]
+    ) -> str:
+        """Replace self.inputs.<name> with <name> in the function body and add args to the
+        function signature
+
+        Parameters
+        ----------
+        function_body: str
+            The source code of the function to process
+        input_names: list[str]
+            The names of the inputs to the function
+
+        Returns
+        -------
+        function_body: str
+            The processed source code
+        """
         # Detect the indentation of the source code in src and reduce it to 4 spaces
         indents = re.findall(r"^\s+", function_body, flags=re.MULTILINE)
         min_indent = min(len(i) for i in indents if i)
@@ -225,6 +227,7 @@ def get_imports_and_functions_to_include(
         function_bodies: ty.List[str],
         source_code: str = None,
         local_functions: ty.List[ty.Callable] = None,
+        local_constants: ty.List[ty.Tuple[str, str]] = None,
     ) -> ty.Tuple[ty.List[str], ty.List[ty.Tuple[str, ty.Any]]]:
         """Get the imports required for the function body
 
@@ -233,8 +236,14 @@ def get_imports_and_functions_to_include(
         function_bodies: list[str]
             the source of all functions that need to be checked for used imports
         source_code: str, optional
-            the source code containing the relevant import statements, by default the source
-            file containing the interface to be converted
+            the source code containing the relevant import statements, by default the
+            source file containing the interface to be converted
+        local_functions: list[callable], optional
+            local functions defined in the source code, by default the functions in the
+            same file as the interface
+        local_constants: list[tuple[str, str]], optional
+            local constants defined in the source code with their definitions,
+            by default the functions in the same file as the interface
 
         Returns
         -------
@@ -251,6 +260,8 @@ def get_imports_and_functions_to_include(
             source_code = self.source_code
         if local_functions is None:
             local_functions = self.local_functions
+        if local_constants is None:
+            local_constants = self.local_constants
         imports = []
         block = ""
         for line in source_code.split("\n"):
@@ -270,7 +281,9 @@ def get_imports_and_functions_to_include(
             used_symbols.update(re.findall(r"(\w+)", function_body))
         used_imports = set()
         used_local_functions = set()
-        # Keep looping through local function source until all local functions are added
+        used_constants = set()
+        # Keep looping through local function source until all local functions and constants
+        # are added to the used symbols
         new_symbols = True
         while new_symbols:
             new_symbols = False
@@ -285,6 +298,12 @@ def get_imports_and_functions_to_include(
                     local_func_symbols = re.findall(r"(\w+)", func_body)
                     used_symbols.update(local_func_symbols)
                     new_symbols = True
+            for const_name, const_def in local_constants:
+                if const_name in used_symbols and (const_name, const_def) not in used_constants:
+                    used_constants.add((const_name, const_def))
+                    const_def_symbols = re.findall(r"(\w+)", const_def)
+                    used_symbols.update(const_def_symbols)
+                    new_symbols = True
         # functions to copy from a relative or nipype module into the output module
         external_functions = set()
         for stmt in imports:
@@ -322,20 +341,22 @@ def get_imports_and_functions_to_include(
                         external_functions.add((used_part[-1], func))
                         mod_func_bodies.append(inspect.getsource(func))
                     # Recursively include neighbouring objects imported in the module
-                    (mod_used_imports, mod_external_funcs, mod_local_funcs) = (
+                    (mod_used_imports, mod_external_funcs, mod_local_funcs, mod_constants) = (
                         self.get_imports_and_functions_to_include(
                             function_bodies=mod_func_bodies,
                             source_code=inspect.getsource(mod),
-                            local_functions=get_local_functions(mod)
+                            local_functions=get_local_functions(mod),
+                            local_constants=get_local_constants(mod),
                         )
                     )
                     used_imports.update(mod_used_imports)
                     external_functions.update(mod_external_funcs)
                     external_functions.update((f.__name__, f) for f in mod_local_funcs)
+                    used_constants.update(mod_constants)
                 else:
                     used_imports.add(required_stmt)
 
-        return used_imports, external_functions, used_local_functions
+        return used_imports, external_functions, used_local_functions, used_constants
 
     @property
     def referenced_local_functions(self):
@@ -429,6 +450,20 @@ def local_functions(self):
         """Get the functions defined in the same file as the interface"""
         return get_local_functions(self.nipype_module)
 
+    @cached_property
+    def local_constants(self):
+        return get_local_constants(self.nipype_module)
+
+    @cached_property
+    def return_value(self):
+        return_line = (
+            inspect.getsource(self.nipype_interface._list_outputs)
+            .strip()
+            .split("\n")[-1]
+        )
+        match = re.match(r"\s*return(.*)", return_line)
+        return match.group(1).strip()
+
     @cached_property
     def methods(self):
         """Get the functions defined in the interface"""
@@ -456,7 +491,7 @@ def local_function_names(self):
     def insert_args_in_signature(cls, snippet: str, new_args: ty.Iterable[str]) -> str:
         """Insert the arguments into the function signature"""
         # Split out the argstring from the rest of the code snippet
-        pre, argstr, post = cls.split_parens_contents(snippet)
+        pre, argstr, post = split_parens_contents(snippet)
         if argstr:
             args = re.split(r" *, *", argstr)
             if "runtime" in args:
@@ -465,39 +500,39 @@ def insert_args_in_signature(cls, snippet: str, new_args: ty.Iterable[str]) -> s
             args = []
         return pre + ", ".join(args + new_args) + post
 
-    @classmethod
-    def split_parens_contents(cls, snippet):
-        """Splits the code snippet at the first opening parenthesis into a 3-tuple
-        consisting of the pre-paren text, the contents of the parens and the post-paren
 
-        Parameters
-        ----------
-        snippet: str
-            the code snippet to split
-
-        Returns
-        -------
-        pre: str
-            the text before the opening parenthesis
-        contents: str
-            the contents of the parens
-        post: str
-            the text after the closing parenthesis
-        """
-        splits = re.split(r"(\(|\))", snippet, flags=re.MULTILINE | re.DOTALL)
-        depth = 1
-        pre = "".join(splits[:2])
-        contents = ""
-        for i, s in enumerate(splits[2:], start=2):
-            if s == "(":
-                depth += 1
-            else:
-                if s == ")":
-                    depth -= 1
-                    if depth == 0:
-                        return pre, contents, "".join(splits[i:])
-                contents += s
-        raise ValueError(f"No matching parenthesis found in '{snippet}'")
+def split_parens_contents(snippet):
+    """Splits the code snippet at the first opening parenthesis into a 3-tuple
+    consisting of the pre-paren text, the contents of the parens and the post-paren
+
+    Parameters
+    ----------
+    snippet: str
+        the code snippet to split
+
+    Returns
+    -------
+    pre: str
+        the text before the opening parenthesis
+    contents: str
+        the contents of the parens
+    post: str
+        the text after the closing parenthesis
+    """
+    splits = re.split(r"(\(|\))", snippet, flags=re.MULTILINE | re.DOTALL)
+    depth = 1
+    pre = "".join(splits[:2])
+    contents = ""
+    for i, s in enumerate(splits[2:], start=2):
+        if s == "(":
+            depth += 1
+        else:
+            if s == ")":
+                depth -= 1
+                if depth == 0:
+                    return pre, contents, "".join(splits[i:])
+            contents += s
+    raise ValueError(f"No matching parenthesis found in '{snippet}'")
 
 
 def get_local_functions(mod):
@@ -508,3 +543,16 @@ def get_local_functions(mod):
         if inspect.isfunction(attr) and attr.__module__ == mod.__name__:
             functions.append(attr)
     return functions
+
+
+def get_local_constants(mod):
+    source_code = inspect.getsource(mod)
+    parts = re.split(r"^(\w+) *= *", source_code, flags=re.MULTILINE)
+    local_vars = []
+    for attr_name, following in zip(parts[1::2], parts[2::2]):
+        if "(" in following.splitlines()[0]:
+            pre, args, _ = split_parens_contents(following)
+            local_vars.append((attr_name, pre + re.sub(r"\n *", "", args) + ")"))
+        else:
+            local_vars.append((attr_name, following.splitlines()[0]))
+    return local_vars

From 109114e5da863b2c36da0fdea50557002e5bcbdd Mon Sep 17 00:00:00 2001
From: Tom Close <tom.g.close@gmail.com>
Date: Mon, 5 Feb 2024 15:40:31 +1100
Subject: [PATCH 35/78] function converter now works for mapmri_reconstruction

---
 nipype2pydra/task/function.py | 120 +++++++++++++++++++++++++++-------
 1 file changed, 96 insertions(+), 24 deletions(-)

diff --git a/nipype2pydra/task/function.py b/nipype2pydra/task/function.py
index bdebb954..1c316023 100644
--- a/nipype2pydra/task/function.py
+++ b/nipype2pydra/task/function.py
@@ -130,22 +130,34 @@ def types_to_names(spec_fields):
 
     def process_method(
         self,
-        func: str,
+        method: str,
         input_names: ty.List[str],
         output_names: ty.List[str],
+        method_args: ty.Dict[str, ty.List[str]] = None,
+        method_returns: ty.Dict[str, ty.List[str]] = None,
     ):
-        src = inspect.getsource(func)
+        src = inspect.getsource(method)
         pre, argstr, post = split_parens_contents(src)
         args = re.split(r" *, *", argstr)
         args.remove("self")
         if "runtime" in args:
             args.remove("runtime")
-        if func.__name__ in self.method_args:
-            args += [f"{a}=None" for a in self.method_args[func.__name__]]
+        if method.__name__ in self.method_args:
+            args += [f"{a}=None" for a in self.method_args[method.__name__]]
         # Insert method args in signature if present
         return_types, method_body = post.split(":", maxsplit=1)
         method_body = method_body.split("\n", maxsplit=1)[1]
         method_body = self.process_method_body(method_body, input_names, output_names)
+        if self.method_returns.get(method.__name__):
+            return_args = self.method_returns[method.__name__]
+            method_body = ("    " + " = ".join(return_args) + " = attrs.NOTHING\n" + method_body)
+            method_lines = method_body.splitlines()
+            method_body = "\n".join(method_lines[:-1])
+            last_line = method_lines[-1]
+            if "return" in last_line:
+                method_body += "," + ",".join(return_args)
+            else:
+                method_body += "\n" + last_line + "\n    return " + ",".join(return_args)
         return f"{pre.strip()}{', '.join(args)}{return_types}:\n{method_body}"
 
     def process_method_body(
@@ -181,10 +193,37 @@ def process_method_body(
         splits = method_re.split(method_body)
         new_body = splits[0]
         for name, args in zip(splits[1::2], splits[2::2]):
+            if self.method_returns[name]:
+                match = re.match(r".*\n *([a-zA-Z0-9\,\. ]+ *=)? *$", new_body, flags=re.MULTILINE | re.DOTALL)
+                if match:
+                    if match.group(1):
+                        new_body_lines = new_body.splitlines()
+                        new_body = '\n'.join(new_body_lines[:-1])
+                        last_line = new_body_lines[-1]
+                        new_body += "\n" + re.sub(
+                            r"^ *([a-zA-Z0-9\,\. ]+) *= *$",
+                            r"\1, =" + ",".join(self.method_returns[name]),
+                            last_line,
+                            flags=re.MULTILINE,
+                        )
+                    else:
+                        new_body += ",".join(self.method_returns[name]) + " = "
+                else:
+                    raise NotImplementedError(
+                        "Could not augment the return value of the method converted from "
+                        "a function with the previously assigned attributes as it is used "
+                        "directly. Need to replace the method call with a variable and "
+                        "assign the return value to it on a previous line"
+                    )
             new_body += name + self.insert_args_in_signature(
                 args, [f"{a}={a}" for a in self.method_args[name]]
             )
         method_body = new_body
+        # Convert assignment to self attributes into method-scoped variables (hopefully
+        # there aren't any name clashes)
+        method_body = re.sub(
+            r"self\.(\w+ *)(?==)", r"\1", method_body, flags=re.MULTILINE | re.DOTALL
+        )
         return self.process_function_body(method_body, input_names=input_names)
 
     def process_function_body(
@@ -299,7 +338,10 @@ def get_imports_and_functions_to_include(
                     used_symbols.update(local_func_symbols)
                     new_symbols = True
             for const_name, const_def in local_constants:
-                if const_name in used_symbols and (const_name, const_def) not in used_constants:
+                if (
+                    const_name in used_symbols
+                    and (const_name, const_def) not in used_constants
+                ):
                     used_constants.add((const_name, const_def))
                     const_def_symbols = re.findall(r"(\w+)", const_def)
                     used_symbols.update(const_def_symbols)
@@ -341,13 +383,16 @@ def get_imports_and_functions_to_include(
                         external_functions.add((used_part[-1], func))
                         mod_func_bodies.append(inspect.getsource(func))
                     # Recursively include neighbouring objects imported in the module
-                    (mod_used_imports, mod_external_funcs, mod_local_funcs, mod_constants) = (
-                        self.get_imports_and_functions_to_include(
-                            function_bodies=mod_func_bodies,
-                            source_code=inspect.getsource(mod),
-                            local_functions=get_local_functions(mod),
-                            local_constants=get_local_constants(mod),
-                        )
+                    (
+                        mod_used_imports,
+                        mod_external_funcs,
+                        mod_local_funcs,
+                        mod_constants,
+                    ) = self.get_imports_and_functions_to_include(
+                        function_bodies=mod_func_bodies,
+                        source_code=inspect.getsource(mod),
+                        local_functions=get_local_functions(mod),
+                        local_constants=get_local_constants(mod),
                     )
                     used_imports.update(mod_used_imports)
                     external_functions.update(mod_external_funcs)
@@ -370,24 +415,31 @@ def referenced_methods(self):
     def method_args(self):
         return self._referenced_funcs_and_methods[2]
 
+    @property
+    def method_returns(self):
+        return self._referenced_funcs_and_methods[3]
+
     @cached_property
     def _referenced_funcs_and_methods(self):
         referenced_funcs = set()
         referenced_methods = set()
         method_args = {}
+        method_returns = {}
         self._get_referenced(
             self.nipype_interface._run_interface,
             referenced_funcs,
             referenced_methods,
             method_args,
+            method_returns,
         )
         self._get_referenced(
             self.nipype_interface._list_outputs,
             referenced_funcs,
             referenced_methods,
             method_args,
+            method_returns,
         )
-        return referenced_funcs, referenced_methods, method_args
+        return referenced_funcs, referenced_methods, method_args, method_returns
 
     def replace_attributes(self, function_body: ty.Callable) -> str:
         """Replace self.inputs.<name> with <name> in the function body and add args to the
@@ -396,10 +448,11 @@ def replace_attributes(self, function_body: ty.Callable) -> str:
 
     def _get_referenced(
         self,
-        function: ty.Callable,
+        method: ty.Callable,
         referenced_funcs: ty.Set[ty.Callable],
-        referenced_methods: ty.Set[ty.Callable],
-        method_args: ty.Dict[str, ty.List[str]],
+        referenced_methods: ty.Set[ty.Callable] = None,
+        method_args: ty.Dict[str, ty.List[str]] = None,
+        method_returns: ty.Dict[str, ty.List[str]] = None,
     ):
         """Get the local functions referenced in the source code
 
@@ -411,34 +464,53 @@ def _get_referenced(
             the set of local functions that have been referenced so far
         referenced_methods: set[function]
             the set of methods that have been referenced so far
+        method_args: dict[str, list[str]]
+            a dictionary to hold additional arguments that need to be added to each method,
+            where the dictionary key is the names of the methods
+        method_returns: dict[str, list[str]]
+            a dictionary to hold the return values of each method,
+            where the dictionary key is the names of the methods
         """
-        function_body = inspect.getsource(function)
-        function_body = re.sub(r"\s*#.*", "", function_body)
-        ref_local_func_names = re.findall(r"(?<!self\.)(\w+)\(", function_body)
+        method_body = inspect.getsource(method)
+        method_body = re.sub(r"\s*#.*", "", method_body)
+        ref_local_func_names = re.findall(r"(?<!self\.)(\w+)\(", method_body)
         ref_local_funcs = set(
             f
             for f in self.local_functions
             if f.__name__ in ref_local_func_names and f not in referenced_funcs
         )
 
-        ref_method_names = re.findall(r"(?<=self\.)(\w+)\(", function_body)
+        ref_method_names = re.findall(r"(?<=self\.)(\w+)\(", method_body)
         ref_methods = set(m for m in self.methods if m.__name__ in ref_method_names)
 
         referenced_funcs.update(ref_local_funcs)
         referenced_methods.update(ref_methods)
 
-        referenced_inputs = set(re.findall(r"(?<=self\.inputs\.)(\w+)", function_body))
+        referenced_inputs = set(re.findall(r"(?<=self\.inputs\.)(\w+)", method_body))
+        referenced_outputs = set(re.findall(r"self\.(\w+) *=", method_body))
+        if self.return_value.startswith("self."):
+            referenced_outputs.update(
+                re.findall(
+                    self.return_value + r"\[(?:'|\")(\w+)(?:'|\")\] *=", method_body
+                )
+            )
         for func in ref_local_funcs:
             referenced_inputs.update(
                 self._get_referenced(func, referenced_funcs, referenced_methods)
             )
         for meth in ref_methods:
-            ref_inputs = self._get_referenced(
-                meth, referenced_funcs, referenced_methods, method_args=method_args
+            ref_inputs, ref_outputs = self._get_referenced(
+                meth,
+                referenced_funcs,
+                referenced_methods,
+                method_args=method_args,
+                method_returns=method_returns,
             )
             method_args[meth.__name__] = ref_inputs
+            method_returns[meth.__name__] = ref_outputs
             referenced_inputs.update(ref_inputs)
-        return referenced_inputs
+            referenced_outputs.update(ref_outputs)
+        return referenced_inputs, sorted(referenced_outputs)
 
     @cached_property
     def source_code(self):

From bd7a5c1dee792484dd91fda9ca00c4097e4d534f Mon Sep 17 00:00:00 2001
From: Tom Close <tom.g.close@gmail.com>
Date: Mon, 5 Feb 2024 17:13:30 +1100
Subject: [PATCH 36/78] renamed *_pdr to pydra_*

---
 nipype2pydra/task/base.py | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)

diff --git a/nipype2pydra/task/base.py b/nipype2pydra/task/base.py
index 11a7715c..5c0a5586 100644
--- a/nipype2pydra/task/base.py
+++ b/nipype2pydra/task/base.py
@@ -482,6 +482,7 @@ def add_nonstd_types(tp):
     def convert_input_fields(self):
         """creating fields list for pydra input spec"""
         pydra_fields_dict = {}
+        pydra_fields_dict = {}
         position_dict = {}
         has_template = []
         for name, fld in self.nipype_input_spec.traits().items():
@@ -491,14 +492,20 @@ def convert_input_fields(self):
                 continue
             pydra_fld, pos = self.pydra_fld_input(fld, name)
             pydra_meta = pydra_fld[-1]
+            if "output_file_template" in pydra_meta:
+            pydra_fld, pos = self.pydra_fld_input(fld, name)
+            pydra_meta = pydra_fld[-1]
             if "output_file_template" in pydra_meta:
                 has_template.append(name)
             pydra_fields_dict[name] = (name,) + pydra_fld
+            pydra_fields_dict[name] = (name,) + pydra_fld
             if pos is not None:
                 position_dict[name] = pos
 
         pydra_fields_l = list(pydra_fields_dict.values())
         return pydra_fields_l, has_template
+        pydra_fields_l = list(pydra_fields_dict.values())
+        return pydra_fields_l, has_template
 
     def pydra_fld_input(self, field, nm):
         """converting a single nipype field to one element of fields for pydra input_spec"""
@@ -510,22 +517,28 @@ def pydra_fld_input(self, field, nm):
 
         if "default" in metadata_extra_spec:
             pydra_default = metadata_extra_spec.pop("default")
+            pydra_default = metadata_extra_spec.pop("default")
         elif (
             getattr(field, "usedefault")
             and field.default is not traits.ctrait.Undefined
         ):
             pydra_default = field.default
+            pydra_default = field.default
         else:
             pydra_default = None
+            pydra_default = None
 
+        pydra_metadata = {"help_string": ""}
         pydra_metadata = {"help_string": ""}
         for key in self.INPUT_KEYS:
+            pydra_key_nm = self.NAME_MAPPING.get(key, key)
             pydra_key_nm = self.NAME_MAPPING.get(key, key)
             val = getattr(field, key)
             if val is not None:
                 if key == "argstr" and "%" in val:
                     val = self.string_formats(argstr=val, name=nm)
                 pydra_metadata[pydra_key_nm] = val
+                pydra_metadata[pydra_key_nm] = val
 
         if getattr(field, "name_template"):
             template = getattr(field, "name_template")
@@ -541,6 +554,7 @@ def pydra_fld_input(self, field, nm):
             if nm in self.outputs.templates:
                 try:
                     pydra_metadata["output_file_template"] = self.outputs.templates[nm]
+                    pydra_metadata["output_file_template"] = self.outputs.templates[nm]
                 except KeyError:
                     raise Exception(
                         f"{nm} is has genfile=True and therefore needs an 'output_file_template' value"
@@ -556,19 +570,26 @@ def pydra_fld_input(self, field, nm):
                 )
 
         pydra_metadata.update(metadata_extra_spec)
+        pydra_metadata.update(metadata_extra_spec)
 
+        pos = pydra_metadata.get("position", None)
         pos = pydra_metadata.get("position", None)
 
         if pydra_default is not None and not pydra_metadata.get("mandatory", None):
             return (pydra_type, pydra_default, pydra_metadata), pos
+        if pydra_default is not None and not pydra_metadata.get("mandatory", None):
+            return (pydra_tp, pydra_default, pydra_metadata), pos
         else:
             return (pydra_type, pydra_metadata), pos
+            return (pydra_tp, pydra_metadata), pos
 
     def convert_output_spec(self, fields_from_template):
         """creating fields list for pydra input spec"""
         pydra_fields_l = []
+        pydra_fields_l = []
         if not self.nipype_output_spec:
             return pydra_fields_l
+            return pydra_fields_l
         for name, fld in self.nipype_output_spec.traits().items():
             if (
                 name not in self.TRAITS_IRREL
@@ -577,18 +598,24 @@ def convert_output_spec(self, fields_from_template):
             ):
                 pydra_fld = self.pydra_fld_output(fld, name)
                 pydra_fields_l.append((name,) + pydra_fld)
+        return pydra_fields_l
+                pydra_fld = self.pydra_fld_output(fld, name)
+                pydra_fields_l.append((name,) + pydra_fld)
         return pydra_fields_l
 
     def pydra_fld_output(self, field, name):
         """converting a single nipype field to one element of fields for pydra output_spec"""
         pydra_type = self.pydra_type_converter(field, spec_type="output", name=name)
 
+        pydra_metadata = {}
         pydra_metadata = {}
         for key in self.OUTPUT_KEYS:
+            pydra_key_nm = self.NAME_MAPPING.get(key, key)
             pydra_key_nm = self.NAME_MAPPING.get(key, key)
             val = getattr(field, key)
             if val:
                 pydra_metadata[pydra_key_nm] = val
+                pydra_metadata[pydra_key_nm] = val
 
         if name in self.outputs.requirements and self.outputs.requirements[name]:
             if all([isinstance(el, list) for el in self.outputs.requirements[name]]):
@@ -602,6 +629,7 @@ def pydra_fld_output(self, field, name):
             else:
                 Exception("has to be either list of list or list of str/dict")
 
+            pydra_metadata["requires"] = []
             pydra_metadata["requires"] = []
             for requires in requires_l:
                 requires_mod = []
@@ -611,8 +639,10 @@ def pydra_fld_output(self, field, name):
                     elif isinstance(el, dict):
                         requires_mod += list(el.items())
                 pydra_metadata["requires"].append(requires_mod)
+                pydra_metadata["requires"].append(requires_mod)
             if nested_flag is False:
                 pydra_metadata["requires"] = pydra_metadata["requires"][0]
+                pydra_metadata["requires"] = pydra_metadata["requires"][0]
 
         if name in self.outputs.templates:
             pydra_metadata["output_file_template"] = self.interface_spec[

From bd478e243d42ec546e583a75fbb403b0de666740 Mon Sep 17 00:00:00 2001
From: Tom Close <tom.g.close@gmail.com>
Date: Tue, 6 Feb 2024 14:38:21 +1100
Subject: [PATCH 37/78] cleaned up duplicate lines introduced in rebase

---
 nipype2pydra/task/base.py | 105 +-------------------------------------
 1 file changed, 2 insertions(+), 103 deletions(-)

diff --git a/nipype2pydra/task/base.py b/nipype2pydra/task/base.py
index 5c0a5586..61e0c295 100644
--- a/nipype2pydra/task/base.py
+++ b/nipype2pydra/task/base.py
@@ -482,7 +482,6 @@ def add_nonstd_types(tp):
     def convert_input_fields(self):
         """creating fields list for pydra input spec"""
         pydra_fields_dict = {}
-        pydra_fields_dict = {}
         position_dict = {}
         has_template = []
         for name, fld in self.nipype_input_spec.traits().items():
@@ -492,20 +491,14 @@ def convert_input_fields(self):
                 continue
             pydra_fld, pos = self.pydra_fld_input(fld, name)
             pydra_meta = pydra_fld[-1]
-            if "output_file_template" in pydra_meta:
-            pydra_fld, pos = self.pydra_fld_input(fld, name)
-            pydra_meta = pydra_fld[-1]
             if "output_file_template" in pydra_meta:
                 has_template.append(name)
             pydra_fields_dict[name] = (name,) + pydra_fld
-            pydra_fields_dict[name] = (name,) + pydra_fld
             if pos is not None:
                 position_dict[name] = pos
 
         pydra_fields_l = list(pydra_fields_dict.values())
         return pydra_fields_l, has_template
-        pydra_fields_l = list(pydra_fields_dict.values())
-        return pydra_fields_l, has_template
 
     def pydra_fld_input(self, field, nm):
         """converting a single nipype field to one element of fields for pydra input_spec"""
@@ -517,28 +510,22 @@ def pydra_fld_input(self, field, nm):
 
         if "default" in metadata_extra_spec:
             pydra_default = metadata_extra_spec.pop("default")
-            pydra_default = metadata_extra_spec.pop("default")
         elif (
             getattr(field, "usedefault")
             and field.default is not traits.ctrait.Undefined
         ):
             pydra_default = field.default
-            pydra_default = field.default
         else:
             pydra_default = None
-            pydra_default = None
 
-        pydra_metadata = {"help_string": ""}
         pydra_metadata = {"help_string": ""}
         for key in self.INPUT_KEYS:
-            pydra_key_nm = self.NAME_MAPPING.get(key, key)
             pydra_key_nm = self.NAME_MAPPING.get(key, key)
             val = getattr(field, key)
             if val is not None:
                 if key == "argstr" and "%" in val:
                     val = self.string_formats(argstr=val, name=nm)
                 pydra_metadata[pydra_key_nm] = val
-                pydra_metadata[pydra_key_nm] = val
 
         if getattr(field, "name_template"):
             template = getattr(field, "name_template")
@@ -554,7 +541,6 @@ def pydra_fld_input(self, field, nm):
             if nm in self.outputs.templates:
                 try:
                     pydra_metadata["output_file_template"] = self.outputs.templates[nm]
-                    pydra_metadata["output_file_template"] = self.outputs.templates[nm]
                 except KeyError:
                     raise Exception(
                         f"{nm} is has genfile=True and therefore needs an 'output_file_template' value"
@@ -570,26 +556,19 @@ def pydra_fld_input(self, field, nm):
                 )
 
         pydra_metadata.update(metadata_extra_spec)
-        pydra_metadata.update(metadata_extra_spec)
 
-        pos = pydra_metadata.get("position", None)
         pos = pydra_metadata.get("position", None)
 
-        if pydra_default is not None and not pydra_metadata.get("mandatory", None):
-            return (pydra_type, pydra_default, pydra_metadata), pos
         if pydra_default is not None and not pydra_metadata.get("mandatory", None):
             return (pydra_tp, pydra_default, pydra_metadata), pos
         else:
-            return (pydra_type, pydra_metadata), pos
             return (pydra_tp, pydra_metadata), pos
 
     def convert_output_spec(self, fields_from_template):
         """creating fields list for pydra input spec"""
         pydra_fields_l = []
-        pydra_fields_l = []
         if not self.nipype_output_spec:
             return pydra_fields_l
-            return pydra_fields_l
         for name, fld in self.nipype_output_spec.traits().items():
             if (
                 name not in self.TRAITS_IRREL
@@ -598,24 +577,18 @@ def convert_output_spec(self, fields_from_template):
             ):
                 pydra_fld = self.pydra_fld_output(fld, name)
                 pydra_fields_l.append((name,) + pydra_fld)
-        return pydra_fields_l
-                pydra_fld = self.pydra_fld_output(fld, name)
-                pydra_fields_l.append((name,) + pydra_fld)
         return pydra_fields_l
 
     def pydra_fld_output(self, field, name):
         """converting a single nipype field to one element of fields for pydra output_spec"""
         pydra_type = self.pydra_type_converter(field, spec_type="output", name=name)
 
-        pydra_metadata = {}
         pydra_metadata = {}
         for key in self.OUTPUT_KEYS:
-            pydra_key_nm = self.NAME_MAPPING.get(key, key)
             pydra_key_nm = self.NAME_MAPPING.get(key, key)
             val = getattr(field, key)
             if val:
                 pydra_metadata[pydra_key_nm] = val
-                pydra_metadata[pydra_key_nm] = val
 
         if name in self.outputs.requirements and self.outputs.requirements[name]:
             if all([isinstance(el, list) for el in self.outputs.requirements[name]]):
@@ -629,7 +602,6 @@ def pydra_fld_output(self, field, name):
             else:
                 Exception("has to be either list of list or list of str/dict")
 
-            pydra_metadata["requires"] = []
             pydra_metadata["requires"] = []
             for requires in requires_l:
                 requires_mod = []
@@ -639,10 +611,8 @@ def pydra_fld_output(self, field, name):
                     elif isinstance(el, dict):
                         requires_mod += list(el.items())
                 pydra_metadata["requires"].append(requires_mod)
-                pydra_metadata["requires"].append(requires_mod)
             if nested_flag is False:
                 pydra_metadata["requires"] = pydra_metadata["requires"][0]
-                pydra_metadata["requires"] = pydra_metadata["requires"][0]
 
         if name in self.outputs.templates:
             pydra_metadata["output_file_template"] = self.interface_spec[
@@ -735,80 +705,9 @@ def string_formats(self, argstr, name):
     def write_task(self, filename, input_fields, nonstd_types, output_fields):
         """writing pydra task to the dile based on the input and output spec"""
 
-        def unwrap_field_type(t):
-            if issubclass(t, WithClassifiers) and t.is_classified:
-                unwraped_classifiers = ", ".join(unwrap_field_type(c) for c in t.classifiers)
-                return f"{t.unclassified.__name__}[{unwraped_classifiers}]"
-            return t.__name__
-
-        def types_to_names(spec_fields):
-            spec_fields_str = []
-            for el in spec_fields:
-                el = list(el)
-                field_type = el[1]
-                if inspect.isclass(field_type) and issubclass(field_type, WithClassifiers):
-                    field_type_str = unwrap_field_type(field_type)
-                else:
-                    field_type_str = str(field_type)
-                    if field_type_str.startswith("<class "):
-                        field_type_str = el[1].__name__
-                    else:
-                        # Alter modules in type string to match those that will be imported
-                        field_type_str = field_type_str.replace("typing", "ty")
-                        field_type_str = re.sub(r"(\w+\.)+(?<!ty\.)(\w+)", r"\2", field_type_str)
-                el[1] = "#" + field_type_str + "#"
-                spec_fields_str.append(tuple(el))
-            return spec_fields_str
-
-        base_imports = [
-            "from pydra.engine import specs",
-        ]
-        if hasattr(self.nipype_interface, "_cmd"):
-            task_base = "ShellCommandTask"
-            base_imports.append("from pydra.engine import ShellCommandTask")
-        else:
-            task_base = "FunctionTask"
-            base_imports.append("from pydra.engine.task import FunctionTask")
-
-        try:
-            executable = self.nipype_interface._cmd
-        except AttributeError:
-            executable = None
-        if not executable:
-            executable = self.nipype_interface.cmd
-            if not isinstance(executable, str):
-                raise RuntimeError(
-                    f"Could not find executable for {self.nipype_interface}"
-                )
-
-        input_fields_str = types_to_names(spec_fields=input_fields)
-        output_fields_str = types_to_names(spec_fields=output_fields)
-        functions_str = self.function_callables()
-        spec_str = functions_str
-        spec_str += f"input_fields = {input_fields_str}\n"
-        spec_str += f"{self.task_name}_input_spec = specs.SpecInfo(name='Input', fields=input_fields, bases=(specs.ShellSpec,))\n\n"
-        spec_str += f"output_fields = {output_fields_str}\n"
-        spec_str += f"{self.task_name}_output_spec = specs.SpecInfo(name='Output', fields=output_fields, bases=(specs.ShellOutSpec,))\n\n"
-        spec_str += f"class {self.task_name}({task_base}):\n"
-        spec_str += '    """\n'
-        spec_str += self.create_doctests(
-            input_fields=input_fields, nonstd_types=nonstd_types
+        spec_str = self.generate_task_str(
+            filename, input_fields, nonstd_types, output_fields
         )
-        spec_str += '    """\n'
-        spec_str += f"    input_spec = {self.task_name}_input_spec\n"
-        spec_str += f"    output_spec = {self.task_name}_output_spec\n"
-        if task_base == "ShellCommandTask":
-            spec_str += f"    executable='{executable}'\n"
-
-        spec_str = re.sub(r"'#([^'#]+)#'", r"\1", spec_str)
-
-        imports = self.construct_imports(
-            nonstd_types,
-            spec_str,
-            include_task=False,
-            base=base_imports,
-        )
-        spec_str = "\n".join(imports) + "\n\n" + spec_str
 
         spec_str = black.format_file_contents(
             spec_str, fast=False, mode=black.FileMode()

From 3e97cc79ff5d89cf493277738560143de6752ed2 Mon Sep 17 00:00:00 2001
From: Tom Close <tom.g.close@gmail.com>
Date: Tue, 6 Feb 2024 14:44:57 +1100
Subject: [PATCH 38/78] cleaning up rebase, reintroduced with-classifier
 handling

---
 nipype2pydra/task/base.py          |  4 ++--
 nipype2pydra/task/shell_command.py | 29 +++++++++++++++++++++--------
 2 files changed, 23 insertions(+), 10 deletions(-)

diff --git a/nipype2pydra/task/base.py b/nipype2pydra/task/base.py
index 61e0c295..6946b45f 100644
--- a/nipype2pydra/task/base.py
+++ b/nipype2pydra/task/base.py
@@ -560,9 +560,9 @@ def pydra_fld_input(self, field, nm):
         pos = pydra_metadata.get("position", None)
 
         if pydra_default is not None and not pydra_metadata.get("mandatory", None):
-            return (pydra_tp, pydra_default, pydra_metadata), pos
+            return (pydra_type, pydra_default, pydra_metadata), pos
         else:
-            return (pydra_tp, pydra_metadata), pos
+            return (pydra_type, pydra_metadata), pos
 
     def convert_output_spec(self, fields_from_template):
         """creating fields list for pydra input spec"""
diff --git a/nipype2pydra/task/shell_command.py b/nipype2pydra/task/shell_command.py
index c84ca73c..c877c733 100644
--- a/nipype2pydra/task/shell_command.py
+++ b/nipype2pydra/task/shell_command.py
@@ -1,6 +1,8 @@
 import re
 import attrs
+import inspect
 from .base import BaseTaskConverter
+from fileformats.core.mixin import WithClassifiers
 
 
 @attrs.define
@@ -23,21 +25,32 @@ def generate_task_str(self, filename, input_fields, nonstd_types, output_fields)
             executable = self.nipype_interface.cmd
             if not isinstance(executable, str):
                 raise RuntimeError(
-                    f"Could not find executable for {self.nipype_interface}"
+                    f"Could not find executable for {self.nipype_interface}, "
+                    "try the FunctionTaskConverter class instead"
                 )
 
+        def unwrap_field_type(t):
+            if issubclass(t, WithClassifiers) and t.is_classified:
+                unwraped_classifiers = ", ".join(unwrap_field_type(c) for c in t.classifiers)
+                return f"{t.unclassified.__name__}[{unwraped_classifiers}]"
+            return t.__name__
+
         def types_to_names(spec_fields):
             spec_fields_str = []
             for el in spec_fields:
                 el = list(el)
-                tp_str = str(el[1])
-                if tp_str.startswith("<class "):
-                    tp_str = el[1].__name__
+                field_type = el[1]
+                if inspect.isclass(field_type) and issubclass(field_type, WithClassifiers):
+                    field_type_str = unwrap_field_type(field_type)
                 else:
-                    # Alter modules in type string to match those that will be imported
-                    tp_str = tp_str.replace("typing", "ty")
-                    tp_str = re.sub(r"(\w+\.)+(?<!ty\.)(\w+)", r"\2", tp_str)
-                el[1] = "#" + tp_str + "#"
+                    field_type_str = str(field_type)
+                    if field_type_str.startswith("<class "):
+                        field_type_str = el[1].__name__
+                    else:
+                        # Alter modules in type string to match those that will be imported
+                        field_type_str = field_type_str.replace("typing", "ty")
+                        field_type_str = re.sub(r"(\w+\.)+(?<!ty\.)(\w+)", r"\2", field_type_str)
+                el[1] = "#" + field_type_str + "#"
                 spec_fields_str.append(tuple(el))
             return spec_fields_str
 

From f8de6fa4e54aed6ef77a0a13183c4b5b12b126e1 Mon Sep 17 00:00:00 2001
From: Tom Close <tom.g.close@gmail.com>
Date: Tue, 6 Feb 2024 19:24:21 +1100
Subject: [PATCH 39/78] debugged function and shell command task conversion

---
 conftest.py                                   |  11 +-
 .../task/function/mapmri_reconstruction.yaml  | 161 ++++++++++++++++++
 .../mapmri_reconstruction_callables.py        |   1 +
 .../task/function/tensor_reconstruction.yaml  | 122 +++++++++++++
 .../tensor_reconstruction_callables.py        |   1 +
 .../ants_n4_bias_field_correction.yaml        |   0
 .../ants_registration.yaml                    |   0
 .../apply_vol_transform.yaml                  |   0
 .../task/{ => shell_command}/extract_roi.yaml |   0
 nipype2pydra/task/function.py                 |   4 +-
 tests/test_task.py                            |  25 ++-
 11 files changed, 316 insertions(+), 9 deletions(-)
 create mode 100644 example-specs/task/function/mapmri_reconstruction.yaml
 create mode 100644 example-specs/task/function/mapmri_reconstruction_callables.py
 create mode 100644 example-specs/task/function/tensor_reconstruction.yaml
 create mode 100644 example-specs/task/function/tensor_reconstruction_callables.py
 rename example-specs/task/{ => shell_command}/ants_n4_bias_field_correction.yaml (100%)
 rename example-specs/task/{ => shell_command}/ants_registration.yaml (100%)
 rename example-specs/task/{ => shell_command}/apply_vol_transform.yaml (100%)
 rename example-specs/task/{ => shell_command}/extract_roi.yaml (100%)

diff --git a/conftest.py b/conftest.py
index ba659727..1757e882 100644
--- a/conftest.py
+++ b/conftest.py
@@ -17,9 +17,14 @@ def gen_test_conftest():
     return PKG_DIR / "scripts" / "pkg_gen" / "resources" / "conftest.py"
 
 
-@pytest.fixture(params=[str(p.stem) for p in (EXAMPLE_TASKS_DIR).glob("*.yaml")])
+@pytest.fixture(
+    params=[
+        str(p.relative_to(EXAMPLE_TASKS_DIR)).replace("/", "-")[:-5]
+        for p in (EXAMPLE_TASKS_DIR).glob("**/*.yaml")
+    ]
+)
 def task_spec_file(request):
-    return (EXAMPLE_TASKS_DIR / request.param).with_suffix(".yaml")
+    return EXAMPLE_TASKS_DIR.joinpath(*request.param.split("-")).with_suffix(".yaml")
 
 
 @pytest.fixture(params=[str(p.stem) for p in EXAMPLE_WORKFLOWS_DIR.glob("*.yaml")])
@@ -35,7 +40,7 @@ def work_dir():
 
 @pytest.fixture
 def outputs_dir():
-    outputs_dir = PKG_DIR / "outputs" / 'workflows'
+    outputs_dir = PKG_DIR / "outputs" / "workflows"
     outputs_dir.mkdir(parents=True, exist_ok=True)
     return outputs_dir
 
diff --git a/example-specs/task/function/mapmri_reconstruction.yaml b/example-specs/task/function/mapmri_reconstruction.yaml
new file mode 100644
index 00000000..b7514892
--- /dev/null
+++ b/example-specs/task/function/mapmri_reconstruction.yaml
@@ -0,0 +1,161 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'qsiprep.interfaces.dipy.MAPMRIReconstruction' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+task_name: MAPMRIReconstruction
+nipype_name: MAPMRIReconstruction
+nipype_module: qsiprep.interfaces.dipy
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    bval_file: generic/file
+    # type=file|default=<undefined>: 
+    bvec_file: generic/file
+    # type=file|default=<undefined>: 
+    dwi_file: generic/file
+    # type=file|default=<undefined>: 
+    mask_file: generic/file
+    # type=file|default=<undefined>: 
+    local_bvec_file: generic/file
+    # type=file|default=<undefined>: 
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  - ng
+  - perng
+  - parng
+  - extrapolated_dwi
+  - extrapolated_bvals
+  - extrapolated_bvecs
+  - extrapolated_b
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    rtop: generic/file
+    # type=file: 
+    lapnorm: generic/file
+    # type=file: 
+    msd: generic/file
+    # type=file: 
+    qiv: generic/file
+    # type=file: 
+    rtap: generic/file
+    # type=file: 
+    rtpp: generic/file
+    # type=file: 
+    ng: generic/file
+    # type=file: 
+    perng: generic/file
+    # type=file: 
+    parng: generic/file
+    # type=file: 
+    mapmri_coeffs: generic/file
+    # type=file: 
+    fibgz: generic/file
+    # type=file: 
+    fod_sh_mif: generic/file
+    # type=file: 
+    extrapolated_dwi: generic/file
+    # type=file: 
+    extrapolated_bvals: generic/file
+    # type=file: 
+    extrapolated_bvecs: generic/file
+    # type=file: 
+    extrapolated_b: generic/file
+    # type=file: 
+    odf_amplitudes: generic/file
+    # type=file: 
+    odf_directions: generic/file
+    # type=file: 
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    radial_order:
+    # type=int|default=6: 
+    laplacian_regularization:
+    # type=bool|default=True: 
+    laplacian_weighting:
+    # type=traitcompound|default=None: 
+    positivity_constraint:
+    # type=bool|default=False: 
+    pos_grid:
+    # type=int|default=15: 
+    pos_radius:
+    # type=traitcompound|default='adaptive': 
+    anisotropic_scaling:
+    # type=bool|default=True: 
+    eigenvalue_threshold:
+    # type=float|default=0.0001: 
+    bval_threshold:
+    # type=float|default=0.0: 
+    dti_scale_estimation:
+    # type=bool|default=True: 
+    static_diffusivity:
+    # type=float|default=0.0007: 
+    cvxpy_solver:
+    # type=str|default='': 
+    bval_file:
+    # type=file|default=<undefined>: 
+    bvec_file:
+    # type=file|default=<undefined>: 
+    dwi_file:
+    # type=file|default=<undefined>: 
+    mask_file:
+    # type=file|default=<undefined>: 
+    local_bvec_file:
+    # type=file|default=<undefined>: 
+    big_delta:
+    # type=traitcompound|default=None: 
+    little_delta:
+    # type=traitcompound|default=None: 
+    b0_threshold:
+    # type=cfloat|default=50: 
+    write_fibgz:
+    # type=bool|default=True: 
+    write_mif:
+    # type=bool|default=True: 
+    extrapolate_scheme:
+    # type=enum|default='HCP'|allowed['ABCD','HCP']: 
+  imports:
+  # list[nipype2pydra.task.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/function/mapmri_reconstruction_callables.py b/example-specs/task/function/mapmri_reconstruction_callables.py
new file mode 100644
index 00000000..e45eec6a
--- /dev/null
+++ b/example-specs/task/function/mapmri_reconstruction_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in MAPMRIReconstruction.yaml"""
diff --git a/example-specs/task/function/tensor_reconstruction.yaml b/example-specs/task/function/tensor_reconstruction.yaml
new file mode 100644
index 00000000..6d14f923
--- /dev/null
+++ b/example-specs/task/function/tensor_reconstruction.yaml
@@ -0,0 +1,122 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'qsiprep.interfaces.dipy.TensorReconstruction' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+task_name: TensorReconstruction
+nipype_name: TensorReconstruction
+nipype_module: qsiprep.interfaces.dipy
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    bval_file: generic/file
+    # type=file|default=<undefined>: 
+    bvec_file: generic/file
+    # type=file|default=<undefined>: 
+    dwi_file: generic/file
+    # type=file|default=<undefined>: 
+    mask_file: generic/file
+    # type=file|default=<undefined>: 
+    local_bvec_file: generic/file
+    # type=file|default=<undefined>: 
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    color_fa_image: generic/file
+    # type=file: 
+    fa_image: generic/file
+    # type=file: 
+    md_image: generic/file
+    # type=file: 
+    rd_image: generic/file
+    # type=file: 
+    ad_image: generic/file
+    # type=file: 
+    cnr_image: generic/file
+    # type=file: 
+    fibgz: generic/file
+    # type=file: 
+    fod_sh_mif: generic/file
+    # type=file: 
+    extrapolated_dwi: generic/file
+    # type=file: 
+    extrapolated_bvals: generic/file
+    # type=file: 
+    extrapolated_bvecs: generic/file
+    # type=file: 
+    extrapolated_b: generic/file
+    # type=file: 
+    odf_amplitudes: generic/file
+    # type=file: 
+    odf_directions: generic/file
+    # type=file: 
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    bval_file:
+    # type=file|default=<undefined>: 
+    bvec_file:
+    # type=file|default=<undefined>: 
+    dwi_file:
+    # type=file|default=<undefined>: 
+    mask_file:
+    # type=file|default=<undefined>: 
+    local_bvec_file:
+    # type=file|default=<undefined>: 
+    big_delta:
+    # type=traitcompound|default=None: 
+    little_delta:
+    # type=traitcompound|default=None: 
+    b0_threshold:
+    # type=cfloat|default=50: 
+    write_fibgz:
+    # type=bool|default=True: 
+    write_mif:
+    # type=bool|default=True: 
+    extrapolate_scheme:
+    # type=enum|default='HCP'|allowed['ABCD','HCP']: 
+  imports:
+  # list[nipype2pydra.task.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/function/tensor_reconstruction_callables.py b/example-specs/task/function/tensor_reconstruction_callables.py
new file mode 100644
index 00000000..d954e084
--- /dev/null
+++ b/example-specs/task/function/tensor_reconstruction_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in TensorReconstruction.yaml"""
diff --git a/example-specs/task/ants_n4_bias_field_correction.yaml b/example-specs/task/shell_command/ants_n4_bias_field_correction.yaml
similarity index 100%
rename from example-specs/task/ants_n4_bias_field_correction.yaml
rename to example-specs/task/shell_command/ants_n4_bias_field_correction.yaml
diff --git a/example-specs/task/ants_registration.yaml b/example-specs/task/shell_command/ants_registration.yaml
similarity index 100%
rename from example-specs/task/ants_registration.yaml
rename to example-specs/task/shell_command/ants_registration.yaml
diff --git a/example-specs/task/apply_vol_transform.yaml b/example-specs/task/shell_command/apply_vol_transform.yaml
similarity index 100%
rename from example-specs/task/apply_vol_transform.yaml
rename to example-specs/task/shell_command/apply_vol_transform.yaml
diff --git a/example-specs/task/extract_roi.yaml b/example-specs/task/shell_command/extract_roi.yaml
similarity index 100%
rename from example-specs/task/extract_roi.yaml
rename to example-specs/task/shell_command/extract_roi.yaml
diff --git a/nipype2pydra/task/function.py b/nipype2pydra/task/function.py
index 1c316023..eb3474fb 100644
--- a/nipype2pydra/task/function.py
+++ b/nipype2pydra/task/function.py
@@ -9,7 +9,7 @@
 from .base import BaseTaskConverter
 
 
-@attrs.define
+@attrs.define(slots=False)
 class FunctionTaskConverter(BaseTaskConverter):
     def generate_task_str(self, filename, input_fields, nonstd_types, output_fields):
         """writing pydra task to the dile based on the input and output spec"""
@@ -342,6 +342,8 @@ def get_imports_and_functions_to_include(
                     const_name in used_symbols
                     and (const_name, const_def) not in used_constants
                 ):
+                    if const_name == "LOGGER":
+                        continue
                     used_constants.add((const_name, const_def))
                     const_def_symbols = re.findall(r"(\w+)", const_def)
                     used_symbols.update(const_def_symbols)
diff --git a/tests/test_task.py b/tests/test_task.py
index cc18b982..a66f283c 100644
--- a/tests/test_task.py
+++ b/tests/test_task.py
@@ -1,8 +1,8 @@
 from importlib import import_module
 import yaml
-from conftest import show_cli_trace
 import pytest
 import logging
+from conftest import show_cli_trace
 from nipype2pydra.cli import task as task_cli
 from nipype2pydra.utils import add_to_sys_path
 
@@ -49,17 +49,32 @@ def test_task_conversion(task_spec_file, cli_runner, work_dir, gen_test_conftest
         import_module(task_spec["nipype_module"]), task_spec["nipype_name"]
     )
 
-    nipype_trait_names = nipype_interface.input_spec().all_trait_names()
+    nipype_input_names = nipype_interface.input_spec().all_trait_names()
+    inputs_omit = task_spec["inputs"]["omit"] if task_spec["inputs"]["omit"] else []
 
-    assert sorted(f[0] for f in pydra_task.input_spec.fields) == sorted(
+    assert sorted(f[0] for f in pydra_task().input_spec.fields if not f[0].startswith("_")) == sorted(
         n
-        for n in nipype_trait_names
+        for n in nipype_input_names
         if not (
             n in INBUILT_NIPYPE_TRAIT_NAMES
-            or (n.endswith("_items") and n[: -len("_items")] in nipype_trait_names)
+            or n in inputs_omit
+            or (n.endswith("_items") and n[: -len("_items")] in nipype_input_names)
         )
     )
 
+    nipype_output_names = nipype_interface.output_spec().all_trait_names()
+    outputs_omit = task_spec["outputs"]["omit"] if task_spec["outputs"]["omit"] else []
+
+    assert sorted(f[0] for f in pydra_task().output_spec.fields if not f[0].startswith("_")) == sorted(
+        n
+        for n in nipype_output_names
+        if not (
+            n in INBUILT_NIPYPE_TRAIT_NAMES
+            or n in outputs_omit
+            or (n.endswith("_items") and n[: -len("_items")] in nipype_output_names)
+        )
+    )    
+
     tests_fspath = pkg_root.joinpath(*output_module_path.split(".")).parent / "tests"
 
     logging.info("Running generated tests for %s", output_module_path)

From 3c63562534e16ad6071ac8e42406bf9a2e38e262 Mon Sep 17 00:00:00 2001
From: Tom Close <tom.g.close@gmail.com>
Date: Tue, 6 Feb 2024 19:27:15 +1100
Subject: [PATCH 40/78] stripped out workflow code

---
 example-specs/workflow/dmriprep.yaml |  62 ---------------
 example-specs/workflow/fmriprep.yaml |  62 ---------------
 example-specs/workflow/qsiprep.yaml  |  59 --------------
 example-specs/workflow/smriprep.yaml |  38 ---------
 nipype2pydra/cli.py                  |  13 ---
 nipype2pydra/workflow.py             | 114 ---------------------------
 pyproject.toml                       |   1 +
 tests/test_workflow.py               |  33 --------
 8 files changed, 1 insertion(+), 381 deletions(-)
 delete mode 100644 example-specs/workflow/dmriprep.yaml
 delete mode 100644 example-specs/workflow/fmriprep.yaml
 delete mode 100644 example-specs/workflow/qsiprep.yaml
 delete mode 100644 example-specs/workflow/smriprep.yaml
 delete mode 100644 nipype2pydra/workflow.py
 delete mode 100644 tests/test_workflow.py

diff --git a/example-specs/workflow/dmriprep.yaml b/example-specs/workflow/dmriprep.yaml
deleted file mode 100644
index 06a326eb..00000000
--- a/example-specs/workflow/dmriprep.yaml
+++ /dev/null
@@ -1,62 +0,0 @@
-function: dmriprep.default:default_workflow
-args:
-  subject_id: test
-  # bids_dir:
-  # bids_filters:
-  # debug:
-  # derivatives:
-  # echo_idx:
-  # fmriprep_dir:
-  # get:
-  layout:
-    type: bids:BIDSLayout
-    args:
-      root: /Users/tclose/Data/openneuro/ds000114
-  # output_dir:
-  # sloppy:
-  # task_id:
-  # version:
-  # nipype_version:
-  # anat_only:
-  # cifti_output:
-  # force_syn:
-  # hires:
-  ignore: []
-  # level:
-  # longitudinal:
-  # run_msmsulc:
-  # run_reconall:
-  # skull_strip_t1w:
-  # skull_strip_template:
-  # skull_strip_fixed_seed:
-  # spaces:
-  # use_syn_sdc:
-splits:
-- func_name: registration
-  first_node: ds_surfs
-- func_name: segmentation
-  first_node: lta2itk_fwd
-ignore_tasks:
-- smriprep.interfaces.DerivativesDataSink
-- nipype.interfaces.utility.base.IdentityInterface
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
diff --git a/example-specs/workflow/fmriprep.yaml b/example-specs/workflow/fmriprep.yaml
deleted file mode 100644
index 8ef18130..00000000
--- a/example-specs/workflow/fmriprep.yaml
+++ /dev/null
@@ -1,62 +0,0 @@
-function: fmriprep.default:default_workflow
-args:
-  subject_id: test
-  # bids_dir:
-  # bids_filters:
-  # debug:
-  # derivatives:
-  # echo_idx:
-  # fmriprep_dir:
-  # get:
-  layout:
-    type: bids:BIDSLayout
-    args:
-      root: /Users/tclose/Data/openneuro/ds000114
-  # output_dir:
-  # sloppy:
-  # task_id:
-  # version:
-  # nipype_version:
-  # anat_only:
-  # cifti_output:
-  # force_syn:
-  # hires:
-  ignore: []
-  # level:
-  # longitudinal:
-  # run_msmsulc:
-  # run_reconall:
-  # skull_strip_t1w:
-  # skull_strip_template:
-  # skull_strip_fixed_seed:
-  # spaces:
-  # use_syn_sdc:
-splits:
-- func_name: registration
-  first_node: ds_surfs
-- func_name: segmentation
-  first_node: lta2itk_fwd
-ignore_tasks:
-- smriprep.interfaces.DerivativesDataSink
-- nipype.interfaces.utility.base.IdentityInterface
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
diff --git a/example-specs/workflow/qsiprep.yaml b/example-specs/workflow/qsiprep.yaml
deleted file mode 100644
index 649f7035..00000000
--- a/example-specs/workflow/qsiprep.yaml
+++ /dev/null
@@ -1,59 +0,0 @@
-function: qsiprep.workflows.base:init_single_subject_wf
-args:
-  subject_id: test
-  name: single_subject_qsipreptest_wf
-  reportlets_dir: .
-  output_dir: .
-  bids_dir: .
-  bids_filters: null
-  anatomical_contrast: T1w
-  ignore: []
-  debug: false
-  low_mem: false
-  output_resolution: 1.25
-  denoise_before_combining: true
-  dwi_denoise_window: 7
-  denoise_method: patch2self
-  unringing_method: mrdegibbs
-  b1_biascorrect_stage: false
-  no_b0_harmonization: false
-  dwi_only: false
-  anat_only: false
-  longitudinal: false
-  b0_threshold: 100
-  freesurfer: false
-  hires: false
-  raw_image_sdc: false
-  force_spatial_normalization: true
-  combine_all_dwis: true
-  distortion_group_merge: none
-  pepolar_method: TOPUP
-  omp_nthreads: 1
-  skull_strip_template: OASIS
-  skull_strip_fixed_seed: false
-  template: MNI152NLin2009cAsym
-  prefer_dedicated_fmaps: false
-  motion_corr_to: iterative
-  b0_to_t1w_transform: Rigid
-  intramodal_template_iters: 0
-  intramodal_template_transform: Rigid
-  hmc_model: 3dSHORE
-  hmc_transform: Affine
-  eddy_config: null
-  shoreline_iters: 2
-  infant_mode: false
-  impute_slice_threshold: 0.0
-  write_local_bvecs: false
-  fmap_bspline: false
-  fmap_demean: true
-  use_syn: false
-  force_syn: false
-splits:
-# - func_name: registration
-#   first_node: ds_surfs
-# - func_name: segmentation
-#   first_node: lta2itk_fwd
-ignore_tasks:
-# - smriprep.interfaces.DerivativesDataSink
-- nipype.interfaces.utility.base.IdentityInterface
-
diff --git a/example-specs/workflow/smriprep.yaml b/example-specs/workflow/smriprep.yaml
deleted file mode 100644
index d1454320..00000000
--- a/example-specs/workflow/smriprep.yaml
+++ /dev/null
@@ -1,38 +0,0 @@
-function: smriprep.workflows.base:init_single_subject_wf
-args:
-  debug: false
-  freesurfer: true
-  fast_track: false
-  hires: true
-  layout:
-    type: bids:BIDSLayout
-    args:
-      root: test-data/bids-data/ds000113
-  longitudinal: false
-  low_mem: false
-  name: single_subject_wf
-  omp_nthreads: 1
-  output_dir: .
-  skull_strip_fixed_seed: false
-  skull_strip_mode: force
-  skull_strip_template:
-    type: niworkflows.utils.spaces:Reference
-    args:
-      space: OASIS30ANTs
-  spaces:
-    type: niworkflows.utils.spaces:SpatialReferences
-    args:
-      spaces:
-      - MNI152NLin2009cAsym
-      - fsaverage5
-  subject_id: test
-  bids_filters: null
-splits:
-- func_name: registration
-  first_node: ds_surfs
-- func_name: segmentation
-  first_node: lta2itk_fwd
-ignore_tasks:
-- smriprep.interfaces.DerivativesDataSink
-- nipype.interfaces.utility.base.IdentityInterface
-
diff --git a/nipype2pydra/cli.py b/nipype2pydra/cli.py
index de08de41..39fd406f 100644
--- a/nipype2pydra/cli.py
+++ b/nipype2pydra/cli.py
@@ -3,7 +3,6 @@
 import yaml
 from nipype2pydra import __version__
 import nipype2pydra.task
-from .workflow import WorkflowConverter
 
 
 # Define the base CLI entrypoint
@@ -52,15 +51,3 @@ def task(yaml_spec, package_root, callables, output_module):
         output_module=output_module, callables_module=callables, **spec
     )
     converter.generate(package_root)
-
-
-@cli.command(help="Port Nipype workflow creation functions to Pydra")
-@click.argument("yaml-spec", type=click.File())
-@click.argument("output_file", type=click.Path(path_type=Path))
-def workflow(yaml_spec, output_file):
-
-    spec = yaml.safe_load(yaml_spec)
-
-    converter = WorkflowConverter(spec)
-    out_str = converter.generate()
-    output_file.write_text(out_str)
diff --git a/nipype2pydra/workflow.py b/nipype2pydra/workflow.py
deleted file mode 100644
index 95ae89ad..00000000
--- a/nipype2pydra/workflow.py
+++ /dev/null
@@ -1,114 +0,0 @@
-from __future__ import annotations
-import typing as ty
-import json
-import tempfile
-from pathlib import Path
-import subprocess as sp
-from collections import defaultdict
-import black
-from nipype.interfaces.base import isdefined
-from .utils import load_class_or_func
-
-
-class WorkflowConverter:
-    # creating the wf
-    def __init__(self, spec):
-        self.spec = spec
-
-        self.wf = load_class_or_func(self.spec["function"])(
-            **self._parse_workflow_args(self.spec["args"])
-        ) 
-        # loads the 'function' in smriprep.yaml, and implement the args (creates a
-        # dictionary)
-
-    def node_connections(
-        self,
-        workflow,
-        functions: dict[str, dict],
-        # wf_inputs: dict[str, str],
-        # wf_outputs: dict[str, str],
-    ):
-        connections: defaultdict = defaultdict(dict)
-
-        # iterates over wf graph, Get connections from workflow graph, store connections
-        # in a dictionary
-        for edge, props in workflow._graph.edges.items():
-            src_node = edge[0].name
-            dest_node = edge[1].name
-            dest_node_fullname = workflow.get_node(dest_node).fullname
-            for node_conn in props["connect"]:
-                src_field = node_conn[0]
-                dest_field = node_conn[1]
-                if src_field[1].startswith("def"):
-                    functions[dest_node_fullname][dest_field] = src_field[1]
-                else:
-                    connections[dest_node_fullname][
-                        dest_field
-                    ] = f"{src_node}.lzout.{src_field}"
-
-        for nested_wf in workflow._nested_workflows_cache:
-            connections.update(self.node_connections(nested_wf, functions=functions))
-        return connections
-
-    def generate(self, format_with_black: bool = False):
-
-        functions = defaultdict(dict)
-        connections = self.node_connections(self.wf, functions=functions)
-        out_text = ""
-        for node_name in self.wf.list_node_names():
-            node = self.wf.get_node(node_name)
-
-            interface_type = type(node.interface)
-
-            task_type = interface_type.__module__ + "." + interface_type.__name__
-            node_args = ""
-            for arg in node.inputs.visible_traits():
-                val = getattr(node.inputs, arg)  # Enclose strings in quotes
-                if isdefined(val):
-                    try:
-                        val = json.dumps(val)
-                    except TypeError:
-                        pass
-                    if isinstance(val, str) and "\n" in val:
-                        val = '"""' + val + '""""'
-                    node_args += f",\n        {arg}={val}"
-
-            for arg, val in connections[node.fullname].items():
-                node_args += f",\n        {arg}=wf.{val}"
-
-            out_text += f"""
-    wf.add(
-        {task_type}(
-            name="{node.name}"{node_args}
-        )
-    )"""
-
-        if format_with_black:
-            out_text = black.format_file_contents(
-                out_text, fast=False, mode=black.FileMode()
-            )
-        return out_text
-
-    @classmethod
-    def _parse_workflow_args(cls, args):
-        dct = {}
-        for name, val in args.items():
-            if isinstance(val, dict) and sorted(val.keys()) == ["args", "type"]:
-                val = load_class_or_func(val["type"])(
-                    **cls._parse_workflow_args(val["args"])
-                )
-            dct[name] = val
-        return dct
-
-    def save_graph(
-        self, out_path: Path, format: str = "svg", work_dir: ty.Optional[Path] = None
-    ):
-        if work_dir is None:
-            work_dir = Path(tempfile.mkdtemp())
-        work_dir = Path(work_dir)
-        graph_dot_path = work_dir / "wf-graph.dot"
-        self.wf.write_hierarchical_dotfile(graph_dot_path)
-        dot_path = sp.check_output("which dot", shell=True).decode("utf-8").strip()
-        sp.check_call(
-            f"{dot_path} -T{format} {str(graph_dot_path)} > {str(out_path)}", shell=True
-        )
diff --git a/pyproject.toml b/pyproject.toml
index 14e7c129..0c08157e 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -60,6 +60,7 @@ test = [
     "pytest-env>=0.6.2",
     "pytest-cov>=2.12.1",
     "fileformats-medimage-extras",
+    "qsiprep",
 ]
 docs = [
     "packaging",
diff --git a/tests/test_workflow.py b/tests/test_workflow.py
deleted file mode 100644
index 8cffebf4..00000000
--- a/tests/test_workflow.py
+++ /dev/null
@@ -1,33 +0,0 @@
-from pathlib import Path
-import yaml
-import pytest
-from nipype2pydra.cli import workflow
-from nipype2pydra.utils import show_cli_trace
-from nipype2pydra.workflow import WorkflowConverter
-
-
-# @pytest.mark.xfail(reason="Workflow conversion hasn't been fully implemented yet")
-def test_workflow_conversion(workflow_spec_file: Path, cli_runner, outputs_dir: Path):
-
-    output_file = outputs_dir / f"{workflow_spec_file.stem}.py"
-
-    result = cli_runner(
-        workflow,
-        [
-            str(workflow_spec_file),
-            str(output_file)
-        ]
-    )
-
-    assert result.exit_code == 0, show_cli_trace(result)
-
-
-# @pytest.mark.xfail(reason="Workflow conversion hasn't been fully implemented yet")
-def test_workflow_graph(workflow_spec_file, outputs_dir):
-
-    with open(workflow_spec_file) as f:
-        spec = yaml.safe_load(f)
-
-    converter = WorkflowConverter(spec)
-
-    converter.save_graph(outputs_dir / f"{workflow_spec_file.stem}.svg")

From 958f5c12e86875f1f7de09920eec3b5538c28e20 Mon Sep 17 00:00:00 2001
From: Tom Close <tom.g.close@gmail.com>
Date: Tue, 6 Feb 2024 20:19:13 +1100
Subject: [PATCH 41/78] cleaned up merge artefacts in gitignore

---
 .gitignore | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/.gitignore b/.gitignore
index a05acc53..73f0fdb6 100644
--- a/.gitignore
+++ b/.gitignore
@@ -20,10 +20,6 @@ __pycache__
 *.egg-info
 ~*
 /outputs
-*.venv
 /test-data
 /nipype2pydra/_version.py
-<<<<<<< HEAD
-=======
-*.venv-py38
->>>>>>> 9611b94 (added py38 to gitignore)
+

From b9e3ee9d888ab574f0cbc77667725f5eb101cbec Mon Sep 17 00:00:00 2001
From: Tom Close <tom.g.close@gmail.com>
Date: Tue, 20 Feb 2024 10:30:30 +1100
Subject: [PATCH 42/78] added example specs for all nipype internal interfaces

---
 conftest.py                                   |    4 +-
 example-specs/task/ghislains/bet.yaml         |  217 ++++
 .../pydra-afni/a_boverlap.yaml                |  153 +++
 .../pydra-afni/a_boverlap_callables.py        |    1 +
 .../pydra-afni/afn_ito_nifti.yaml             |  146 +++
 .../pydra-afni/afn_ito_nifti_callables.py     |    1 +
 .../pydra-afni/align_epi_anat_py.yaml         |  221 ++++
 .../pydra-afni/align_epi_anat_py_callables.py |    1 +
 .../nipype_internal/pydra-afni/allineate.yaml |  377 ++++++
 .../pydra-afni/allineate_callables.py         |    1 +
 .../pydra-afni/auto_tcorrelate.yaml           |  165 +++
 .../pydra-afni/auto_tcorrelate_callables.py   |    1 +
 .../nipype_internal/pydra-afni/auto_tlrc.yaml |  135 ++
 .../pydra-afni/auto_tlrc_callables.py         |    1 +
 .../nipype_internal/pydra-afni/autobox.yaml   |  140 +++
 .../pydra-afni/autobox_callables.py           |    1 +
 .../nipype_internal/pydra-afni/automask.yaml  |  155 +++
 .../pydra-afni/automask_callables.py          |    1 +
 .../nipype_internal/pydra-afni/axialize.yaml  |  148 +++
 .../pydra-afni/axialize_callables.py          |    1 +
 .../nipype_internal/pydra-afni/bandpass.yaml  |  179 +++
 .../pydra-afni/bandpass_callables.py          |    1 +
 .../pydra-afni/blur_in_mask.yaml              |  158 +++
 .../pydra-afni/blur_in_mask_callables.py      |    1 +
 .../pydra-afni/blur_to_fwhm.yaml              |  150 +++
 .../pydra-afni/blur_to_fwhm_callables.py      |    1 +
 .../pydra-afni/brick_stat.yaml                |  146 +++
 .../pydra-afni/brick_stat_callables.py        |    1 +
 .../nipype_internal/pydra-afni/bucket.yaml    |  146 +++
 .../pydra-afni/bucket_callables.py            |    1 +
 .../task/nipype_internal/pydra-afni/calc.yaml |  231 ++++
 .../pydra-afni/calc_callables.py              |    1 +
 .../task/nipype_internal/pydra-afni/cat.yaml  |  164 +++
 .../pydra-afni/cat_callables.py               |    1 +
 .../pydra-afni/cat_matvec.yaml                |  141 +++
 .../pydra-afni/cat_matvec_callables.py        |    1 +
 .../pydra-afni/center_mass.yaml               |  160 +++
 .../pydra-afni/center_mass_callables.py       |    1 +
 .../pydra-afni/clip_level.yaml                |  126 ++
 .../pydra-afni/clip_level_callables.py        |    1 +
 .../pydra-afni/convert_dset.yaml              |  144 +++
 .../pydra-afni/convert_dset_callables.py      |    1 +
 .../task/nipype_internal/pydra-afni/copy.yaml |  256 ++++
 .../pydra-afni/copy_callables.py              |    1 +
 .../pydra-afni/deconvolve.yaml                |  267 ++++
 .../pydra-afni/deconvolve_callables.py        |    1 +
 .../pydra-afni/degree_centrality.yaml         |  168 +++
 .../pydra-afni/degree_centrality_callables.py |    1 +
 .../nipype_internal/pydra-afni/despike.yaml   |  130 ++
 .../pydra-afni/despike_callables.py           |    1 +
 .../nipype_internal/pydra-afni/detrend.yaml   |  141 +++
 .../pydra-afni/detrend_callables.py           |    1 +
 .../task/nipype_internal/pydra-afni/dot.yaml  |  172 +++
 .../pydra-afni/dot_callables.py               |    1 +
 .../task/nipype_internal/pydra-afni/ecm.yaml  |  176 +++
 .../pydra-afni/ecm_callables.py               |    1 +
 .../nipype_internal/pydra-afni/edge_3.yaml    |  155 +++
 .../pydra-afni/edge_3_callables.py            |    1 +
 .../task/nipype_internal/pydra-afni/eval.yaml |  175 +++
 .../pydra-afni/eval_callables.py              |    1 +
 .../task/nipype_internal/pydra-afni/fim.yaml  |  161 +++
 .../pydra-afni/fim_callables.py               |    1 +
 .../nipype_internal/pydra-afni/fourier.yaml   |  152 +++
 .../pydra-afni/fourier_callables.py           |    1 +
 .../nipype_internal/pydra-afni/fwh_mx.yaml    |  247 ++++
 .../pydra-afni/fwh_mx_callables.py            |    1 +
 .../task/nipype_internal/pydra-afni/gcor.yaml |  133 ++
 .../pydra-afni/gcor_callables.py              |    1 +
 .../task/nipype_internal/pydra-afni/hist.yaml |  150 +++
 .../pydra-afni/hist_callables.py              |    1 +
 .../task/nipype_internal/pydra-afni/lfcd.yaml |  159 +++
 .../pydra-afni/lfcd_callables.py              |    1 +
 .../pydra-afni/local_bistat.yaml              |  169 +++
 .../pydra-afni/local_bistat_callables.py      |    1 +
 .../nipype_internal/pydra-afni/localstat.yaml |  180 +++
 .../pydra-afni/localstat_callables.py         |    1 +
 .../nipype_internal/pydra-afni/mask_tool.yaml |  155 +++
 .../pydra-afni/mask_tool_callables.py         |    1 +
 .../nipype_internal/pydra-afni/maskave.yaml   |  147 +++
 .../pydra-afni/maskave_callables.py           |    1 +
 .../nipype_internal/pydra-afni/means.yaml     |  216 ++++
 .../pydra-afni/means_callables.py             |    1 +
 .../nipype_internal/pydra-afni/merge.yaml     |  151 +++
 .../pydra-afni/merge_callables.py             |    1 +
 .../nipype_internal/pydra-afni/net_corr.yaml  |  194 +++
 .../pydra-afni/net_corr_callables.py          |    1 +
 .../nipype_internal/pydra-afni/notes.yaml     |  150 +++
 .../pydra-afni/notes_callables.py             |    1 +
 .../pydra-afni/nwarp_adjust.yaml              |  139 +++
 .../pydra-afni/nwarp_adjust_callables.py      |    1 +
 .../pydra-afni/nwarp_apply.yaml               |  154 +++
 .../pydra-afni/nwarp_apply_callables.py       |    1 +
 .../nipype_internal/pydra-afni/nwarp_cat.yaml |  179 +++
 .../pydra-afni/nwarp_cat_callables.py         |    1 +
 .../pydra-afni/one_d_tool_py.yaml             |  163 +++
 .../pydra-afni/one_d_tool_py_callables.py     |    1 +
 .../pydra-afni/outlier_count.yaml             |  153 +++
 .../pydra-afni/outlier_count_callables.py     |    1 +
 .../pydra-afni/quality_index.yaml             |  146 +++
 .../pydra-afni/quality_index_callables.py     |    1 +
 .../nipype_internal/pydra-afni/qwarp.yaml     |  622 ++++++++++
 .../pydra-afni/qwarp_callables.py             |    1 +
 .../pydra-afni/qwarp_plus_minus.yaml          |  254 ++++
 .../pydra-afni/qwarp_plus_minus_callables.py  |    1 +
 .../nipype_internal/pydra-afni/re_ho.yaml     |  159 +++
 .../pydra-afni/re_ho_callables.py             |    1 +
 .../nipype_internal/pydra-afni/refit.yaml     |  202 +++
 .../pydra-afni/refit_callables.py             |    1 +
 .../nipype_internal/pydra-afni/remlfit.yaml   |  317 +++++
 .../pydra-afni/remlfit_callables.py           |    1 +
 .../nipype_internal/pydra-afni/resample.yaml  |  150 +++
 .../pydra-afni/resample_callables.py          |    1 +
 .../nipype_internal/pydra-afni/retroicor.yaml |  180 +++
 .../pydra-afni/retroicor_callables.py         |    1 +
 .../nipype_internal/pydra-afni/roi_stats.yaml |  173 +++
 .../pydra-afni/roi_stats_callables.py         |    1 +
 .../task/nipype_internal/pydra-afni/seg.yaml  |  146 +++
 .../pydra-afni/seg_callables.py               |    1 +
 .../pydra-afni/skull_strip.yaml               |  137 ++
 .../pydra-afni/skull_strip_callables.py       |    1 +
 .../nipype_internal/pydra-afni/svm_test.yaml  |  115 ++
 .../pydra-afni/svm_test_callables.py          |    1 +
 .../nipype_internal/pydra-afni/svm_train.yaml |  143 +++
 .../pydra-afni/svm_train_callables.py         |    1 +
 .../pydra-afni/synthesize.yaml                |  154 +++
 .../pydra-afni/synthesize_callables.py        |    1 +
 .../nipype_internal/pydra-afni/t_cat.yaml     |  149 +++
 .../pydra-afni/t_cat_callables.py             |    1 +
 .../pydra-afni/t_cat_sub_brick.yaml           |  143 +++
 .../pydra-afni/t_cat_sub_brick_callables.py   |    1 +
 .../nipype_internal/pydra-afni/t_corr_1d.yaml |  146 +++
 .../pydra-afni/t_corr_1d_callables.py         |    1 +
 .../pydra-afni/t_corr_map.yaml                |  278 +++++
 .../pydra-afni/t_corr_map_callables.py        |    1 +
 .../pydra-afni/t_correlate.yaml               |  161 +++
 .../pydra-afni/t_correlate_callables.py       |    1 +
 .../nipype_internal/pydra-afni/t_norm.yaml    |  155 +++
 .../pydra-afni/t_norm_callables.py            |    1 +
 .../nipype_internal/pydra-afni/t_project.yaml |  202 +++
 .../pydra-afni/t_project_callables.py         |    1 +
 .../nipype_internal/pydra-afni/t_shift.yaml   |  405 ++++++
 .../pydra-afni/t_shift_callables.py           |    1 +
 .../nipype_internal/pydra-afni/t_smooth.yaml  |  160 +++
 .../pydra-afni/t_smooth_callables.py          |    1 +
 .../nipype_internal/pydra-afni/t_stat.yaml    |  148 +++
 .../pydra-afni/t_stat_callables.py            |    1 +
 .../nipype_internal/pydra-afni/to_3d.yaml     |  157 +++
 .../pydra-afni/to_3d_callables.py             |    1 +
 .../nipype_internal/pydra-afni/undump.yaml    |  173 +++
 .../pydra-afni/undump_callables.py            |    1 +
 .../nipype_internal/pydra-afni/unifize.yaml   |  189 +++
 .../pydra-afni/unifize_callables.py           |    1 +
 .../nipype_internal/pydra-afni/volreg.yaml    |  269 ++++
 .../pydra-afni/volreg_callables.py            |    1 +
 .../task/nipype_internal/pydra-afni/warp.yaml |  225 ++++
 .../pydra-afni/warp_callables.py              |    1 +
 .../nipype_internal/pydra-afni/z_cut_up.yaml  |  144 +++
 .../pydra-afni/z_cut_up_callables.py          |    1 +
 .../task/nipype_internal/pydra-afni/zcat.yaml |  146 +++
 .../pydra-afni/zcat_callables.py              |    1 +
 .../nipype_internal/pydra-afni/zeropad.yaml   |  193 +++
 .../pydra-afni/zeropad_callables.py           |    1 +
 .../pydra-ants/affine_initializer.yaml        |  142 +++
 .../affine_initializer_callables.py           |    1 +
 .../task/nipype_internal/pydra-ants/ai.yaml   |  130 ++
 .../pydra-ants/ai_callables.py                |    1 +
 .../task/nipype_internal/pydra-ants/ants.yaml |  245 ++++
 .../pydra-ants/ants_callables.py              |    1 +
 .../pydra-ants/ants_introduction.yaml         |  158 +++
 .../pydra-ants/ants_introduction_callables.py |    1 +
 .../pydra-ants/apply_transforms.yaml          |  391 ++++++
 .../pydra-ants/apply_transforms_callables.py  |    1 +
 .../apply_transforms_to_points.yaml           |  147 +++
 .../apply_transforms_to_points_callables.py   |    1 +
 .../nipype_internal/pydra-ants/atropos.yaml   |  576 +++++++++
 .../pydra-ants/atropos_callables.py           |    1 +
 .../pydra-ants/average_affine_transform.yaml  |  132 ++
 .../average_affine_transform_callables.py     |    1 +
 .../pydra-ants/average_images.yaml            |  143 +++
 .../pydra-ants/average_images_callables.py    |    1 +
 .../pydra-ants/brain_extraction.yaml          |  194 +++
 .../pydra-ants/brain_extraction_callables.py  |    1 +
 .../pydra-ants/buildtemplateparallel.yaml     |  151 +++
 .../buildtemplateparallel_callables.py        |    1 +
 .../pydra-ants/compose_multi_transform.yaml   |  137 ++
 .../compose_multi_transform_callables.py      |    1 +
 .../pydra-ants/composite_transform_util.yaml  |  194 +++
 .../composite_transform_util_callables.py     |    1 +
 .../convert_scalar_image_to_rgb.yaml          |  158 +++
 .../convert_scalar_image_to_rgb_callables.py  |    1 +
 .../pydra-ants/cortical_thickness.yaml        |  220 ++++
 .../cortical_thickness_callables.py           |    1 +
 .../create_jacobian_determinant_image.yaml    |  135 ++
 ...te_jacobian_determinant_image_callables.py |    1 +
 .../pydra-ants/create_tiled_mosaic.yaml       |  183 +++
 .../create_tiled_mosaic_callables.py          |    1 +
 .../pydra-ants/denoise_image.yaml             |  242 ++++
 .../pydra-ants/denoise_image_callables.py     |    1 +
 .../pydra-ants/gen_warp_fields.yaml           |  104 ++
 .../pydra-ants/gen_warp_fields_callables.py   |    1 +
 .../pydra-ants/image_math.yaml                |  307 +++++
 .../pydra-ants/image_math_callables.py        |    1 +
 .../pydra-ants/joint_fusion.yaml              |  452 +++++++
 .../pydra-ants/joint_fusion_callables.py      |    1 +
 .../pydra-ants/kelly_kapowski.yaml            |  192 +++
 .../pydra-ants/kelly_kapowski_callables.py    |    1 +
 .../pydra-ants/label_geometry.yaml            |  170 +++
 .../pydra-ants/label_geometry_callables.py    |    1 +
 .../pydra-ants/laplacian_thickness.yaml       |  180 +++
 .../laplacian_thickness_callables.py          |    1 +
 .../pydra-ants/measure_image_similarity.yaml  |  185 +++
 .../measure_image_similarity_callables.py     |    1 +
 .../pydra-ants/multiply_images.yaml           |  143 +++
 .../pydra-ants/multiply_images_callables.py   |    1 +
 .../pydra-ants/n4_bias_field_correction.yaml  |  378 ++++++
 .../n4_bias_field_correction_callables.py     |    1 +
 .../pydra-ants/registration.yaml              | 1105 +++++++++++++++++
 .../pydra-ants/registration_callables.py      |    1 +
 .../pydra-ants/registration_syn_quick.yaml    |  211 ++++
 .../registration_syn_quick_callables.py       |    1 +
 .../pydra-ants/resample_image_by_spacing.yaml |  278 +++++
 .../resample_image_by_spacing_callables.py    |    1 +
 .../pydra-ants/threshold_image.yaml           |  234 ++++
 .../pydra-ants/threshold_image_callables.py   |    1 +
 .../warp_image_multi_transform.yaml           |  212 ++++
 .../warp_image_multi_transform_callables.py   |    1 +
 ...arp_time_series_image_multi_transform.yaml |  202 +++
 ..._series_image_multi_transform_callables.py |    1 +
 .../nipype_internal/pydra-brainsuite/bdp.yaml |  206 +++
 .../pydra-brainsuite/bdp_callables.py         |    1 +
 .../nipype_internal/pydra-brainsuite/bfc.yaml |  160 +++
 .../pydra-brainsuite/bfc_callables.py         |    1 +
 .../nipype_internal/pydra-brainsuite/bse.yaml |  157 +++
 .../pydra-brainsuite/bse_callables.py         |    1 +
 .../pydra-brainsuite/cerebro.yaml             |  156 +++
 .../pydra-brainsuite/cerebro_callables.py     |    1 +
 .../pydra-brainsuite/cortex.yaml              |  112 ++
 .../pydra-brainsuite/cortex_callables.py      |    1 +
 .../pydra-brainsuite/dewisp.yaml              |  107 ++
 .../pydra-brainsuite/dewisp_callables.py      |    1 +
 .../nipype_internal/pydra-brainsuite/dfs.yaml |  122 ++
 .../pydra-brainsuite/dfs_callables.py         |    1 +
 .../pydra-brainsuite/hemisplit.yaml           |  135 ++
 .../pydra-brainsuite/hemisplit_callables.py   |    1 +
 .../pydra-brainsuite/pialmesh.yaml            |  130 ++
 .../pydra-brainsuite/pialmesh_callables.py    |    1 +
 .../nipype_internal/pydra-brainsuite/pvc.yaml |  117 ++
 .../pydra-brainsuite/pvc_callables.py         |    1 +
 .../pydra-brainsuite/scrubmask.yaml           |  105 ++
 .../pydra-brainsuite/scrubmask_callables.py   |    1 +
 .../pydra-brainsuite/skullfinder.yaml         |  116 ++
 .../pydra-brainsuite/skullfinder_callables.py |    1 +
 .../pydra-brainsuite/sv_reg.yaml              |  131 ++
 .../pydra-brainsuite/sv_reg_callables.py      |    1 +
 .../nipype_internal/pydra-brainsuite/tca.yaml |  103 ++
 .../pydra-brainsuite/tca_callables.py         |    1 +
 .../pydra-brainsuite/thickness_pvc.yaml       |   88 ++
 .../thickness_pvc_callables.py                |    1 +
 .../nipype_internal/pydra-bru2nii/bru_2.yaml  |  127 ++
 .../pydra-bru2nii/bru_2_callables.py          |    1 +
 .../task/nipype_internal/pydra-c3/c_3d.yaml   |  165 +++
 .../pydra-c3/c_3d_affine_tool.yaml            |  141 +++
 .../pydra-c3/c_3d_affine_tool_callables.py    |    1 +
 .../pydra-c3/c_3d_callables.py                |    1 +
 .../pydra-camino/analyze_header.yaml          |  152 +++
 .../pydra-camino/analyze_header_callables.py  |    1 +
 .../pydra-camino/compute_eigensystem.yaml     |  102 ++
 .../compute_eigensystem_callables.py          |    1 +
 .../compute_fractional_anisotropy.yaml        |  103 ++
 ...compute_fractional_anisotropy_callables.py |    1 +
 .../compute_mean_diffusivity.yaml             |   97 ++
 .../compute_mean_diffusivity_callables.py     |    1 +
 .../pydra-camino/compute_tensor_trace.yaml    |  105 ++
 .../compute_tensor_trace_callables.py         |    1 +
 .../nipype_internal/pydra-camino/conmat.yaml  |  166 +++
 .../pydra-camino/conmat_callables.py          |    1 +
 .../pydra-camino/dt2n_if_ti.yaml              |   88 ++
 .../pydra-camino/dt2n_if_ti_callables.py      |    1 +
 .../pydra-camino/dt_metric.yaml               |  120 ++
 .../pydra-camino/dt_metric_callables.py       |    1 +
 .../nipype_internal/pydra-camino/dti_fit.yaml |  112 ++
 .../pydra-camino/dti_fit_callables.py         |    1 +
 .../pydra-camino/dtlut_gen.yaml               |  118 ++
 .../pydra-camino/dtlut_gen_callables.py       |    1 +
 .../pydra-camino/fsl2_scheme.yaml             |  108 ++
 .../pydra-camino/fsl2_scheme_callables.py     |    1 +
 .../pydra-camino/image_2_voxel.yaml           |   92 ++
 .../pydra-camino/image_2_voxel_callables.py   |    1 +
 .../pydra-camino/image_stats.yaml             |   93 ++
 .../pydra-camino/image_stats_callables.py     |    1 +
 .../pydra-camino/lin_recon.yaml               |  134 ++
 .../pydra-camino/lin_recon_callables.py       |    1 +
 .../nipype_internal/pydra-camino/mesd.yaml    |  170 +++
 .../pydra-camino/mesd_callables.py            |    1 +
 .../pydra-camino/model_fit.yaml               |  134 ++
 .../pydra-camino/model_fit_callables.py       |    1 +
 .../pydra-camino/n_if_tidt2_camino.yaml       |  116 ++
 .../n_if_tidt2_camino_callables.py            |    1 +
 .../pydra-camino/pico_pd_fs.yaml              |  102 ++
 .../pydra-camino/pico_pd_fs_callables.py      |    1 +
 .../pydra-camino/proc_streamlines.yaml        |  161 +++
 .../proc_streamlines_callables.py             |    1 +
 .../pydra-camino/q_ball_mx.yaml               |  122 ++
 .../pydra-camino/q_ball_mx_callables.py       |    1 +
 .../pydra-camino/sf_peaks.yaml                |  179 +++
 .../pydra-camino/sf_peaks_callables.py        |    1 +
 .../pydra-camino/sflut_gen.yaml               |  141 +++
 .../pydra-camino/sflut_gen_callables.py       |    1 +
 .../pydra-camino/sfpico_calib_data.yaml       |  153 +++
 .../sfpico_calib_data_callables.py            |    1 +
 .../pydra-camino/shredder.yaml                |  103 ++
 .../pydra-camino/shredder_callables.py        |    1 +
 .../nipype_internal/pydra-camino/track.yaml   |  131 ++
 .../pydra-camino/track_ball_stick.yaml        |  129 ++
 .../track_ball_stick_callables.py             |    1 +
 .../pydra-camino/track_bayes_dirac.yaml       |  153 +++
 .../track_bayes_dirac_callables.py            |    1 +
 .../pydra-camino/track_bedpostx_deter.yaml    |  145 +++
 .../track_bedpostx_deter_callables.py         |    1 +
 .../pydra-camino/track_bedpostx_proba.yaml    |  152 +++
 .../track_bedpostx_proba_callables.py         |    1 +
 .../pydra-camino/track_bootstrap.yaml         |  147 +++
 .../pydra-camino/track_bootstrap_callables.py |    1 +
 .../pydra-camino/track_callables.py           |    1 +
 .../pydra-camino/track_dt.yaml                |  129 ++
 .../pydra-camino/track_dt_callables.py        |    1 +
 .../pydra-camino/track_pi_co.yaml             |  133 ++
 .../pydra-camino/track_pi_co_callables.py     |    1 +
 .../pydra-camino/tract_shredder.yaml          |  101 ++
 .../pydra-camino/tract_shredder_callables.py  |    1 +
 .../pydra-camino/vtk_streamlines.yaml         |  109 ++
 .../pydra-camino/vtk_streamlines_callables.py |    1 +
 .../camino_2_trackvis.yaml                    |  106 ++
 .../camino_2_trackvis_callables.py            |    1 +
 .../trackvis_2_camino.yaml                    |   80 ++
 .../trackvis_2_camino_callables.py            |    1 +
 .../pydra-cat12/cat12_segment.yaml            |  225 ++++
 .../pydra-cat12/cat12_segment_callables.py    |    1 +
 .../pydra-cat12/cat12sanlm_denoising.yaml     |  116 ++
 .../cat12sanlm_denoising_callables.py         |    1 +
 ...extract_additional_surface_parameters.yaml |  118 ++
 ...additional_surface_parameters_callables.py |    1 +
 .../extract_roi_based_surface_measures.yaml   |  117 ++
 ...ct_roi_based_surface_measures_callables.py |    1 +
 .../pydra-cmtk/average_networks.yaml          |   97 ++
 .../pydra-cmtk/average_networks_callables.py  |    1 +
 .../pydra-cmtk/cff_converter.yaml             |  137 ++
 .../pydra-cmtk/cff_converter_callables.py     |    1 +
 .../pydra-cmtk/create_matrix.yaml             |  145 +++
 .../pydra-cmtk/create_matrix_callables.py     |    1 +
 .../pydra-cmtk/create_nodes.yaml              |   87 ++
 .../pydra-cmtk/create_nodes_callables.py      |    1 +
 .../pydra-cmtk/merge_c_networks.yaml          |   82 ++
 .../pydra-cmtk/merge_c_networks_callables.py  |    1 +
 .../pydra-cmtk/network_based_statistic.yaml   |  110 ++
 .../network_based_statistic_callables.py      |    1 +
 .../pydra-cmtk/network_x_metrics.yaml         |  122 ++
 .../pydra-cmtk/network_x_metrics_callables.py |    1 +
 .../pydra-cmtk/parcellate.yaml                |  113 ++
 .../pydra-cmtk/parcellate_callables.py        |    1 +
 .../nipype_internal/pydra-cmtk/roi_gen.yaml   |  107 ++
 .../pydra-cmtk/roi_gen_callables.py           |    1 +
 .../pydra-dcmstack/copy_meta.yaml             |   80 ++
 .../pydra-dcmstack/copy_meta_callables.py     |    1 +
 .../pydra-dcmstack/dcm_stack.yaml             |   94 ++
 .../pydra-dcmstack/dcm_stack_callables.py     |    1 +
 .../pydra-dcmstack/group_and_stack.yaml       |   80 ++
 .../group_and_stack_callables.py              |    1 +
 .../pydra-dcmstack/lookup_meta.yaml           |   82 ++
 .../pydra-dcmstack/lookup_meta_callables.py   |    1 +
 .../pydra-dcmstack/merge_nifti.yaml           |   79 ++
 .../pydra-dcmstack/merge_nifti_callables.py   |    1 +
 .../pydra-dcmstack/nifti_generator_base.yaml  |   63 +
 .../nifti_generator_base_callables.py         |    1 +
 .../pydra-dcmstack/split_nifti.yaml           |   79 ++
 .../pydra-dcmstack/split_nifti_callables.py   |    1 +
 .../pydra-diffusion_toolkit/dti_recon.yaml    |  114 ++
 .../dti_recon_callables.py                    |    1 +
 .../pydra-diffusion_toolkit/dti_tracker.yaml  |  122 ++
 .../dti_tracker_callables.py                  |    1 +
 .../pydra-diffusion_toolkit/hardi_mat.yaml    |  101 ++
 .../hardi_mat_callables.py                    |    1 +
 .../pydra-diffusion_toolkit/odf_recon.yaml    |  111 ++
 .../odf_recon_callables.py                    |    1 +
 .../pydra-diffusion_toolkit/odf_tracker.yaml  |  128 ++
 .../odf_tracker_callables.py                  |    1 +
 .../spline_filter.yaml                        |   94 ++
 .../spline_filter_callables.py                |    1 +
 .../pydra-diffusion_toolkit/track_merge.yaml  |   94 ++
 .../track_merge_callables.py                  |    1 +
 .../nipype_internal/pydra-dipy/apm_qball.yaml |   96 ++
 .../pydra-dipy/apm_qball_callables.py         |    1 +
 .../task/nipype_internal/pydra-dipy/csd.yaml  |  120 ++
 .../pydra-dipy/csd_callables.py               |    1 +
 .../nipype_internal/pydra-dipy/denoise.yaml   |  106 ++
 .../pydra-dipy/denoise_callables.py           |    1 +
 .../task/nipype_internal/pydra-dipy/dti.yaml  |  106 ++
 .../pydra-dipy/dti_callables.py               |    1 +
 .../pydra-dipy/estimate_response_sh.yaml      |  130 ++
 .../estimate_response_sh_callables.py         |    1 +
 .../nipype_internal/pydra-dipy/resample.yaml  |   84 ++
 .../pydra-dipy/resample_callables.py          |    1 +
 .../nipype_internal/pydra-dipy/restore.yaml   |  120 ++
 .../pydra-dipy/restore_callables.py           |    1 +
 .../pydra-dipy/simulate_multi_tensor.yaml     |  159 +++
 .../simulate_multi_tensor_callables.py        |    1 +
 .../pydra-dipy/streamline_tractography.yaml   |  123 ++
 .../streamline_tractography_callables.py      |    1 +
 .../pydra-dipy/tensor_mode.yaml               |  106 ++
 .../pydra-dipy/tensor_mode_callables.py       |    1 +
 .../pydra-dipy/track_density_map.yaml         |   94 ++
 .../pydra-dipy/track_density_map_callables.py |    1 +
 .../pydra-dtitk/aff_scalar_vol.yaml           |  146 +++
 .../pydra-dtitk/aff_scalar_vol_callables.py   |    1 +
 .../pydra-dtitk/aff_scalar_vol_task.yaml      |   95 ++
 .../aff_scalar_vol_task_callables.py          |    1 +
 .../pydra-dtitk/aff_sym_tensor_3d_vol.yaml    |  148 +++
 .../aff_sym_tensor_3d_vol_callables.py        |    1 +
 .../aff_sym_tensor_3d_vol_task.yaml           |   97 ++
 .../aff_sym_tensor_3d_vol_task_callables.py   |    1 +
 .../nipype_internal/pydra-dtitk/affine.yaml   |  157 +++
 .../pydra-dtitk/affine_callables.py           |    1 +
 .../pydra-dtitk/affine_task.yaml              |   88 ++
 .../pydra-dtitk/affine_task_callables.py      |    1 +
 .../pydra-dtitk/bin_thresh.yaml               |  152 +++
 .../pydra-dtitk/bin_thresh_callables.py       |    1 +
 .../pydra-dtitk/bin_thresh_task.yaml          |   87 ++
 .../pydra-dtitk/bin_thresh_task_callables.py  |    1 +
 .../pydra-dtitk/compose_xfm.yaml              |  134 ++
 .../pydra-dtitk/compose_xfm_callables.py      |    1 +
 .../pydra-dtitk/compose_xfm_task.yaml         |   83 ++
 .../pydra-dtitk/compose_xfm_task_callables.py |    1 +
 .../nipype_internal/pydra-dtitk/diffeo.yaml   |  157 +++
 .../pydra-dtitk/diffeo_callables.py           |    1 +
 .../pydra-dtitk/diffeo_scalar_vol.yaml        |  146 +++
 .../diffeo_scalar_vol_callables.py            |    1 +
 .../pydra-dtitk/diffeo_scalar_vol_task.yaml   |   95 ++
 .../diffeo_scalar_vol_task_callables.py       |    1 +
 .../pydra-dtitk/diffeo_sym_tensor_3d_vol.yaml |  150 +++
 .../diffeo_sym_tensor_3d_vol_callables.py     |    1 +
 .../diffeo_sym_tensor_3d_vol_task.yaml        |   99 ++
 ...diffeo_sym_tensor_3d_vol_task_callables.py |    1 +
 .../pydra-dtitk/diffeo_task.yaml              |   88 ++
 .../pydra-dtitk/diffeo_task_callables.py      |    1 +
 .../nipype_internal/pydra-dtitk/rigid.yaml    |  152 +++
 .../pydra-dtitk/rigid_callables.py            |    1 +
 .../pydra-dtitk/rigid_task.yaml               |   88 ++
 .../pydra-dtitk/rigid_task_callables.py       |    1 +
 .../pydra-dtitk/sv_adjust_vox_sp.yaml         |  137 ++
 .../pydra-dtitk/sv_adjust_vox_sp_callables.py |    1 +
 .../pydra-dtitk/sv_adjust_vox_sp_task.yaml    |   87 ++
 .../sv_adjust_vox_sp_task_callables.py        |    1 +
 .../pydra-dtitk/sv_resample.yaml              |  141 +++
 .../pydra-dtitk/sv_resample_callables.py      |    1 +
 .../pydra-dtitk/sv_resample_task.yaml         |   91 ++
 .../pydra-dtitk/sv_resample_task_callables.py |    1 +
 .../nipype_internal/pydra-dtitk/t_vtool.yaml  |  131 ++
 .../pydra-dtitk/t_vtool_callables.py          |    1 +
 .../pydra-dtitk/t_vtool_task.yaml             |   81 ++
 .../pydra-dtitk/t_vtool_task_callables.py     |    1 +
 .../pydra-dtitk/tv_adjust_origin_task.yaml    |   87 ++
 .../tv_adjust_origin_task_callables.py        |    1 +
 .../pydra-dtitk/tv_adjust_vox_sp.yaml         |  137 ++
 .../pydra-dtitk/tv_adjust_vox_sp_callables.py |    1 +
 .../pydra-dtitk/tv_adjust_vox_sp_task.yaml    |   87 ++
 .../tv_adjust_vox_sp_task_callables.py        |    1 +
 .../pydra-dtitk/tv_resample.yaml              |  143 +++
 .../pydra-dtitk/tv_resample_callables.py      |    1 +
 .../pydra-dtitk/tv_resample_task.yaml         |   93 ++
 .../pydra-dtitk/tv_resample_task_callables.py |    1 +
 .../slicer_command_line.yaml                  |   68 +
 .../slicer_command_line_callables.py          |    1 +
 .../pydra-elastix/analyze_warp.yaml           |  140 +++
 .../pydra-elastix/analyze_warp_callables.py   |    1 +
 .../pydra-elastix/apply_warp.yaml             |  134 ++
 .../pydra-elastix/apply_warp_callables.py     |    1 +
 .../pydra-elastix/edit_transform.yaml         |   98 ++
 .../pydra-elastix/edit_transform_callables.py |    1 +
 .../pydra-elastix/points_warp.yaml            |  133 ++
 .../pydra-elastix/points_warp_callables.py    |    1 +
 .../pydra-elastix/registration.yaml           |  154 +++
 .../pydra-elastix/registration_callables.py   |    1 +
 .../add_x_form_to_header.yaml                 |  187 +++
 .../add_x_form_to_header_callables.py         |    1 +
 .../pydra-freesurfer/aparc_2_aseg.yaml        |  255 ++++
 .../aparc_2_aseg_callables.py                 |    1 +
 .../pydra-freesurfer/apas_2_aseg.yaml         |  137 ++
 .../pydra-freesurfer/apas_2_aseg_callables.py |    1 +
 .../pydra-freesurfer/apply_mask.yaml          |  115 ++
 .../pydra-freesurfer/apply_mask_callables.py  |    1 +
 .../pydra-freesurfer/apply_vol_transform.yaml |  194 +++
 .../apply_vol_transform_callables.py          |    1 +
 .../pydra-freesurfer/bb_register.yaml         |  194 +++
 .../pydra-freesurfer/bb_register_callables.py |    1 +
 .../pydra-freesurfer/binarize.yaml            |  190 +++
 .../pydra-freesurfer/binarize_callables.py    |    1 +
 .../pydra-freesurfer/ca_label.yaml            |  182 +++
 .../pydra-freesurfer/ca_label_callables.py    |    1 +
 .../pydra-freesurfer/ca_normalize.yaml        |  167 +++
 .../ca_normalize_callables.py                 |    1 +
 .../pydra-freesurfer/ca_register.yaml         |  166 +++
 .../pydra-freesurfer/ca_register_callables.py |    1 +
 .../check_talairach_alignment.yaml            |  132 ++
 .../check_talairach_alignment_callables.py    |    1 +
 .../pydra-freesurfer/concatenate.yaml         |  170 +++
 .../pydra-freesurfer/concatenate_callables.py |    1 +
 .../pydra-freesurfer/concatenate_lta.yaml     |  243 ++++
 .../concatenate_lta_callables.py              |    1 +
 .../pydra-freesurfer/contrast.yaml            |  184 +++
 .../pydra-freesurfer/contrast_callables.py    |    1 +
 .../pydra-freesurfer/curvature.yaml           |  140 +++
 .../pydra-freesurfer/curvature_callables.py   |    1 +
 .../pydra-freesurfer/curvature_stats.yaml     |  202 +++
 .../curvature_stats_callables.py              |    1 +
 .../pydra-freesurfer/dicom_convert.yaml       |  104 ++
 .../dicom_convert_callables.py                |    1 +
 .../pydra-freesurfer/edit_w_mwith_aseg.yaml   |  158 +++
 .../edit_w_mwith_aseg_callables.py            |    1 +
 .../pydra-freesurfer/em_register.yaml         |  165 +++
 .../pydra-freesurfer/em_register_callables.py |    1 +
 .../pydra-freesurfer/euler_number.yaml        |  117 ++
 .../euler_number_callables.py                 |    1 +
 .../extract_main_component.yaml               |  122 ++
 .../extract_main_component_callables.py       |    1 +
 .../pydra-freesurfer/fit_ms_params.yaml       |  142 +++
 .../fit_ms_params_callables.py                |    1 +
 .../pydra-freesurfer/fix_topology.yaml        |  179 +++
 .../fix_topology_callables.py                 |    1 +
 .../pydra-freesurfer/fuse_segmentations.yaml  |  164 +++
 .../fuse_segmentations_callables.py           |    1 +
 .../pydra-freesurfer/glm_fit.yaml             |  295 +++++
 .../pydra-freesurfer/glm_fit_callables.py     |    1 +
 .../pydra-freesurfer/gtm_seg.yaml             |  154 +++
 .../pydra-freesurfer/gtm_seg_callables.py     |    1 +
 .../pydra-freesurfer/gtmpvc.yaml              |  394 ++++++
 .../pydra-freesurfer/gtmpvc_callables.py      |    1 +
 .../pydra-freesurfer/image_info.yaml          |   76 ++
 .../pydra-freesurfer/image_info_callables.py  |    1 +
 .../pydra-freesurfer/jacobian.yaml            |  135 ++
 .../pydra-freesurfer/jacobian_callables.py    |    1 +
 .../pydra-freesurfer/label_2_annot.yaml       |  157 +++
 .../label_2_annot_callables.py                |    1 +
 .../pydra-freesurfer/label_2_label.yaml       |  195 +++
 .../label_2_label_callables.py                |    1 +
 .../pydra-freesurfer/label_2_vol.yaml         |  190 +++
 .../pydra-freesurfer/label_2_vol_callables.py |    1 +
 .../pydra-freesurfer/logan_ref.yaml           |  300 +++++
 .../pydra-freesurfer/logan_ref_callables.py   |    1 +
 .../pydra-freesurfer/lta_convert.yaml         |  138 ++
 .../pydra-freesurfer/lta_convert_callables.py |    1 +
 .../make_average_subject.yaml                 |  119 ++
 .../make_average_subject_callables.py         |    1 +
 .../pydra-freesurfer/make_surfaces.yaml       |  222 ++++
 .../make_surfaces_callables.py                |    1 +
 .../pydra-freesurfer/mni_bias_correction.yaml |  174 +++
 .../mni_bias_correction_callables.py          |    1 +
 .../pydra-freesurfer/mp_rto_mni305.yaml       |  145 +++
 .../mp_rto_mni305_callables.py                |    1 +
 .../pydra-freesurfer/mr_is_ca_label.yaml      |  198 +++
 .../mr_is_ca_label_callables.py               |    1 +
 .../pydra-freesurfer/mr_is_calc.yaml          |  162 +++
 .../pydra-freesurfer/mr_is_calc_callables.py  |    1 +
 .../pydra-freesurfer/mr_is_combine.yaml       |  146 +++
 .../mr_is_combine_callables.py                |    1 +
 .../pydra-freesurfer/mr_is_convert.yaml       |  139 +++
 .../mr_is_convert_callables.py                |    1 +
 .../pydra-freesurfer/mr_is_expand.yaml        |  157 +++
 .../mr_is_expand_callables.py                 |    1 +
 .../pydra-freesurfer/mr_is_inflate.yaml       |  142 +++
 .../mr_is_inflate_callables.py                |    1 +
 .../pydra-freesurfer/mri_convert.yaml         |  316 +++++
 .../pydra-freesurfer/mri_convert_callables.py |    1 +
 .../pydra-freesurfer/mri_coreg.yaml           |  329 +++++
 .../pydra-freesurfer/mri_coreg_callables.py   |    1 +
 .../pydra-freesurfer/mri_fill.yaml            |  151 +++
 .../pydra-freesurfer/mri_fill_callables.py    |    1 +
 .../pydra-freesurfer/mri_marching_cubes.yaml  |   96 ++
 .../mri_marching_cubes_callables.py           |    1 +
 .../pydra-freesurfer/mri_pretess.yaml         |  155 +++
 .../pydra-freesurfer/mri_pretess_callables.py |    1 +
 .../pydra-freesurfer/mri_tessellate.yaml      |   98 ++
 .../mri_tessellate_callables.py               |    1 +
 .../pydra-freesurfer/mris_preproc.yaml        |  179 +++
 .../mris_preproc_callables.py                 |    1 +
 .../mris_preproc_recon_all.yaml               |  194 +++
 .../mris_preproc_recon_all_callables.py       |    1 +
 .../pydra-freesurfer/mrtm.yaml                |  301 +++++
 .../pydra-freesurfer/mrtm2.yaml               |  300 +++++
 .../pydra-freesurfer/mrtm2_callables.py       |    1 +
 .../pydra-freesurfer/mrtm_callables.py        |    1 +
 .../pydra-freesurfer/ms__lda.yaml             |  184 +++
 .../pydra-freesurfer/ms__lda_callables.py     |    1 +
 .../pydra-freesurfer/normalize.yaml           |  147 +++
 .../pydra-freesurfer/normalize_callables.py   |    1 +
 .../pydra-freesurfer/one_sample_t_test.yaml   |  248 ++++
 .../one_sample_t_test_callables.py            |    1 +
 .../pydra-freesurfer/paint.yaml               |  155 +++
 .../pydra-freesurfer/paint_callables.py       |    1 +
 .../pydra-freesurfer/parcellation_stats.yaml  |  277 +++++
 .../parcellation_stats_callables.py           |    1 +
 .../pydra-freesurfer/parse_dicom_dir.yaml     |  141 +++
 .../parse_dicom_dir_callables.py              |    1 +
 .../pydra-freesurfer/recon_all.yaml           |  548 ++++++++
 .../pydra-freesurfer/recon_all_callables.py   |    1 +
 .../pydra-freesurfer/register.yaml            |  166 +++
 .../register_av_ito_talairach.yaml            |  158 +++
 .../register_av_ito_talairach_callables.py    |    1 +
 .../pydra-freesurfer/register_callables.py    |    1 +
 .../relabel_hypointensities.yaml              |  153 +++
 .../relabel_hypointensities_callables.py      |    1 +
 .../pydra-freesurfer/remove_intersection.yaml |  126 ++
 .../remove_intersection_callables.py          |    1 +
 .../pydra-freesurfer/remove_neck.yaml         |  147 +++
 .../pydra-freesurfer/remove_neck_callables.py |    1 +
 .../pydra-freesurfer/resample.yaml            |  141 +++
 .../pydra-freesurfer/resample_callables.py    |    1 +
 .../pydra-freesurfer/robust_register.yaml     |  234 ++++
 .../robust_register_callables.py              |    1 +
 .../pydra-freesurfer/robust_template.yaml     |  297 +++++
 .../robust_template_callables.py              |    1 +
 .../pydra-freesurfer/sample_to_surface.yaml   |  245 ++++
 .../sample_to_surface_callables.py            |    1 +
 .../pydra-freesurfer/seg_stats.yaml           |  253 ++++
 .../pydra-freesurfer/seg_stats_callables.py   |    1 +
 .../pydra-freesurfer/seg_stats_recon_all.yaml |  394 ++++++
 .../seg_stats_recon_all_callables.py          |    1 +
 .../pydra-freesurfer/segment_cc.yaml          |  167 +++
 .../pydra-freesurfer/segment_cc_callables.py  |    1 +
 .../pydra-freesurfer/segment_wm.yaml          |  136 ++
 .../pydra-freesurfer/segment_wm_callables.py  |    1 +
 .../pydra-freesurfer/smooth.yaml              |  167 +++
 .../pydra-freesurfer/smooth_callables.py      |    1 +
 .../pydra-freesurfer/smooth_tessellation.yaml |  123 ++
 .../smooth_tessellation_callables.py          |    1 +
 .../pydra-freesurfer/sphere.yaml              |  136 ++
 .../pydra-freesurfer/sphere_callables.py      |    1 +
 .../pydra-freesurfer/spherical_average.yaml   |  189 +++
 .../spherical_average_callables.py            |    1 +
 .../surface_2_vol_transform.yaml              |  173 +++
 .../surface_2_vol_transform_callables.py      |    1 +
 .../pydra-freesurfer/surface_smooth.yaml      |  166 +++
 .../surface_smooth_callables.py               |    1 +
 .../pydra-freesurfer/surface_snapshots.yaml   |  170 +++
 .../surface_snapshots_callables.py            |    1 +
 .../pydra-freesurfer/surface_transform.yaml   |  120 ++
 .../surface_transform_callables.py            |    1 +
 .../pydra-freesurfer/synthesize_flash.yaml    |  162 +++
 .../synthesize_flash_callables.py             |    1 +
 .../pydra-freesurfer/talairach_avi.yaml       |  146 +++
 .../talairach_avi_callables.py                |    1 +
 .../pydra-freesurfer/talairach_qc.yaml        |  123 ++
 .../talairach_qc_callables.py                 |    1 +
 .../pydra-freesurfer/tkregister_2.yaml        |  236 ++++
 .../tkregister_2_callables.py                 |    1 +
 .../pydra-freesurfer/unpack_sdicom_dir.yaml   |  165 +++
 .../unpack_sdicom_dir_callables.py            |    1 +
 .../pydra-freesurfer/volume_mask.yaml         |  208 ++++
 .../pydra-freesurfer/volume_mask_callables.py |    1 +
 .../watershed_skull_strip.yaml                |  163 +++
 .../watershed_skull_strip_callables.py        |    1 +
 .../pydra-fsl/accuracy_tester.yaml            |   86 ++
 .../pydra-fsl/accuracy_tester_callables.py    |    1 +
 .../nipype_internal/pydra-fsl/apply_mask.yaml |   91 ++
 .../pydra-fsl/apply_mask_callables.py         |    1 +
 .../pydra-fsl/apply_topup.yaml                |  173 +++
 .../pydra-fsl/apply_topup_callables.py        |    1 +
 .../nipype_internal/pydra-fsl/apply_warp.yaml |  126 ++
 .../pydra-fsl/apply_warp_callables.py         |    1 +
 .../nipype_internal/pydra-fsl/apply_xfm.yaml  |  224 ++++
 .../pydra-fsl/apply_xfm_callables.py          |    1 +
 .../nipype_internal/pydra-fsl/ar1_image.yaml  |   92 ++
 .../pydra-fsl/ar1_image_callables.py          |    1 +
 .../nipype_internal/pydra-fsl/av_scale.yaml   |   86 ++
 .../pydra-fsl/av_scale_callables.py           |    1 +
 .../nipype_internal/pydra-fsl/b0_calc.yaml    |  163 +++
 .../pydra-fsl/b0_calc_callables.py            |    1 +
 .../nipype_internal/pydra-fsl/bedpostx5.yaml  |  212 ++++
 .../pydra-fsl/bedpostx5_callables.py          |    1 +
 .../task/nipype_internal/pydra-fsl/bet.yaml   |  208 ++++
 .../pydra-fsl/bet_callables.py                |    1 +
 .../pydra-fsl/binary_maths.yaml               |   98 ++
 .../pydra-fsl/binary_maths_callables.py       |    1 +
 .../pydra-fsl/change_data_type.yaml           |   87 ++
 .../pydra-fsl/change_data_type_callables.py   |    1 +
 .../nipype_internal/pydra-fsl/classifier.yaml |   87 ++
 .../pydra-fsl/classifier_callables.py         |    1 +
 .../nipype_internal/pydra-fsl/cleaner.yaml    |   92 ++
 .../pydra-fsl/cleaner_callables.py            |    1 +
 .../nipype_internal/pydra-fsl/cluster.yaml    |  202 +++
 .../pydra-fsl/cluster_callables.py            |    1 +
 .../nipype_internal/pydra-fsl/complex.yaml    |  164 +++
 .../pydra-fsl/complex_callables.py            |    1 +
 .../pydra-fsl/contrast_mgr.yaml               |  101 ++
 .../pydra-fsl/contrast_mgr_callables.py       |    1 +
 .../pydra-fsl/convert_warp.yaml               |  184 +++
 .../pydra-fsl/convert_warp_callables.py       |    1 +
 .../pydra-fsl/convert_xfm.yaml                |  149 +++
 .../pydra-fsl/convert_xfm_callables.py        |    1 +
 .../nipype_internal/pydra-fsl/copy_geom.yaml  |   87 ++
 .../pydra-fsl/copy_geom_callables.py          |    1 +
 .../pydra-fsl/dilate_image.yaml               |   97 ++
 .../pydra-fsl/dilate_image_callables.py       |    1 +
 .../pydra-fsl/distance_map.yaml               |  104 ++
 .../pydra-fsl/distance_map_callables.py       |    1 +
 .../nipype_internal/pydra-fsl/dti_fit.yaml    |  203 +++
 .../pydra-fsl/dti_fit_callables.py            |    1 +
 .../pydra-fsl/dual_regression.yaml            |  170 +++
 .../pydra-fsl/dual_regression_callables.py    |    1 +
 .../task/nipype_internal/pydra-fsl/eddy.yaml  |  375 ++++++
 .../pydra-fsl/eddy_callables.py               |    1 +
 .../pydra-fsl/eddy_correct.yaml               |  135 ++
 .../pydra-fsl/eddy_correct_callables.py       |    1 +
 .../nipype_internal/pydra-fsl/eddy_quad.yaml  |  172 +++
 .../pydra-fsl/eddy_quad_callables.py          |    1 +
 .../pydra-fsl/epi_de_warp.yaml                |  185 +++
 .../pydra-fsl/epi_de_warp_callables.py        |    1 +
 .../nipype_internal/pydra-fsl/epi_reg.yaml    |  229 ++++
 .../pydra-fsl/epi_reg_callables.py            |    1 +
 .../pydra-fsl/erode_image.yaml                |   97 ++
 .../pydra-fsl/erode_image_callables.py        |    1 +
 .../pydra-fsl/extract_roi.yaml                |  172 +++
 .../pydra-fsl/extract_roi_callables.py        |    1 +
 .../task/nipype_internal/pydra-fsl/fast.yaml  |  181 +++
 .../pydra-fsl/fast_callables.py               |    1 +
 .../task/nipype_internal/pydra-fsl/feat.yaml  |   74 ++
 .../pydra-fsl/feat_callables.py               |    1 +
 .../nipype_internal/pydra-fsl/feat_model.yaml |   86 ++
 .../pydra-fsl/feat_model_callables.py         |    1 +
 .../pydra-fsl/feature_extractor.yaml          |   77 ++
 .../pydra-fsl/feature_extractor_callables.py  |    1 +
 .../nipype_internal/pydra-fsl/filmgls.yaml    |  158 +++
 .../pydra-fsl/filmgls_callables.py            |    1 +
 .../pydra-fsl/filter_regressor.yaml           |  100 ++
 .../pydra-fsl/filter_regressor_callables.py   |    1 +
 .../pydra-fsl/find_the_biggest.yaml           |  135 ++
 .../pydra-fsl/find_the_biggest_callables.py   |    1 +
 .../task/nipype_internal/pydra-fsl/first.yaml |  109 ++
 .../pydra-fsl/first_callables.py              |    1 +
 .../nipype_internal/pydra-fsl/flameo.yaml     |  200 +++
 .../pydra-fsl/flameo_callables.py             |    1 +
 .../task/nipype_internal/pydra-fsl/flirt.yaml |  277 +++++
 .../pydra-fsl/flirt_callables.py              |    1 +
 .../task/nipype_internal/pydra-fsl/fnirt.yaml |  268 ++++
 .../pydra-fsl/fnirt_callables.py              |    1 +
 .../pydra-fsl/fslx_command.yaml               |  132 ++
 .../pydra-fsl/fslx_command_callables.py       |    1 +
 .../task/nipype_internal/pydra-fsl/fugue.yaml |  387 ++++++
 .../pydra-fsl/fugue_callables.py              |    1 +
 .../task/nipype_internal/pydra-fsl/glm.yaml   |  201 +++
 .../pydra-fsl/glm_callables.py                |    1 +
 .../nipype_internal/pydra-fsl/ica__aroma.yaml |  201 +++
 .../pydra-fsl/ica__aroma_callables.py         |    1 +
 .../pydra-fsl/image_maths.yaml                |  156 +++
 .../pydra-fsl/image_maths_callables.py        |    1 +
 .../pydra-fsl/image_meants.yaml               |  103 ++
 .../pydra-fsl/image_meants_callables.py       |    1 +
 .../pydra-fsl/image_stats.yaml                |  139 +++
 .../pydra-fsl/image_stats_callables.py        |    1 +
 .../nipype_internal/pydra-fsl/inv_warp.yaml   |  157 +++
 .../pydra-fsl/inv_warp_callables.py           |    1 +
 .../pydra-fsl/isotropic_smooth.yaml           |   91 ++
 .../pydra-fsl/isotropic_smooth_callables.py   |    1 +
 .../nipype_internal/pydra-fsl/l2_model.yaml   |   78 ++
 .../pydra-fsl/l2_model_callables.py           |    1 +
 .../pydra-fsl/level_1_design.yaml             |   85 ++
 .../pydra-fsl/level_1_design_callables.py     |    1 +
 .../pydra-fsl/make_dyadic_vectors.yaml        |   91 ++
 .../make_dyadic_vectors_callables.py          |    1 +
 .../pydra-fsl/maths_command.yaml              |   87 ++
 .../pydra-fsl/maths_command_callables.py      |    1 +
 .../nipype_internal/pydra-fsl/max_image.yaml  |  133 ++
 .../pydra-fsl/max_image_callables.py          |    1 +
 .../nipype_internal/pydra-fsl/maxn_image.yaml |   92 ++
 .../pydra-fsl/maxn_image_callables.py         |    1 +
 .../nipype_internal/pydra-fsl/mcflirt.yaml    |  188 +++
 .../pydra-fsl/mcflirt_callables.py            |    1 +
 .../nipype_internal/pydra-fsl/mean_image.yaml |   89 ++
 .../pydra-fsl/mean_image_callables.py         |    1 +
 .../pydra-fsl/median_image.yaml               |   89 ++
 .../pydra-fsl/median_image_callables.py       |    1 +
 .../nipype_internal/pydra-fsl/melodic.yaml    |  296 +++++
 .../pydra-fsl/melodic_callables.py            |    1 +
 .../task/nipype_internal/pydra-fsl/merge.yaml |  154 +++
 .../pydra-fsl/merge_callables.py              |    1 +
 .../nipype_internal/pydra-fsl/min_image.yaml  |   89 ++
 .../pydra-fsl/min_image_callables.py          |    1 +
 .../pydra-fsl/motion_outliers.yaml            |  154 +++
 .../pydra-fsl/motion_outliers_callables.py    |    1 +
 .../pydra-fsl/multi_image_maths.yaml          |  153 +++
 .../pydra-fsl/multi_image_maths_callables.py  |    1 +
 .../pydra-fsl/multiple_regress_design.yaml    |   94 ++
 .../multiple_regress_design_callables.py      |    1 +
 .../nipype_internal/pydra-fsl/overlay.yaml    |  124 ++
 .../pydra-fsl/overlay_callables.py            |    1 +
 .../pydra-fsl/percentile_image.yaml           |  136 ++
 .../pydra-fsl/percentile_image_callables.py   |    1 +
 .../pydra-fsl/plot_motion_params.yaml         |  110 ++
 .../pydra-fsl/plot_motion_params_callables.py |    1 +
 .../pydra-fsl/plot_time_series.yaml           |  120 ++
 .../pydra-fsl/plot_time_series_callables.py   |    1 +
 .../pydra-fsl/power_spectrum.yaml             |   92 ++
 .../pydra-fsl/power_spectrum_callables.py     |    1 +
 .../nipype_internal/pydra-fsl/prelude.yaml    |  128 ++
 .../pydra-fsl/prelude_callables.py            |    1 +
 .../pydra-fsl/prepare_fieldmap.yaml           |  153 +++
 .../pydra-fsl/prepare_fieldmap_callables.py   |    1 +
 .../pydra-fsl/prob_track_x.yaml               |  273 ++++
 .../pydra-fsl/prob_track_x2.yaml              |  296 +++++
 .../pydra-fsl/prob_track_x2_callables.py      |    1 +
 .../pydra-fsl/prob_track_x_callables.py       |    1 +
 .../pydra-fsl/proj_thresh.yaml                |  124 ++
 .../pydra-fsl/proj_thresh_callables.py        |    1 +
 .../nipype_internal/pydra-fsl/randomise.yaml  |  191 +++
 .../pydra-fsl/randomise_callables.py          |    1 +
 .../pydra-fsl/reorient_2_std.yaml             |   93 ++
 .../pydra-fsl/reorient_2_std_callables.py     |    1 +
 .../nipype_internal/pydra-fsl/robust_fov.yaml |   96 ++
 .../pydra-fsl/robust_fov_callables.py         |    1 +
 .../nipype_internal/pydra-fsl/sig_loss.yaml   |  100 ++
 .../pydra-fsl/sig_loss_callables.py           |    1 +
 .../task/nipype_internal/pydra-fsl/slice.yaml |  125 ++
 .../pydra-fsl/slice_callables.py              |    1 +
 .../pydra-fsl/slice_timer.yaml                |  107 ++
 .../pydra-fsl/slice_timer_callables.py        |    1 +
 .../nipype_internal/pydra-fsl/slicer.yaml     |  130 ++
 .../pydra-fsl/slicer_callables.py             |    1 +
 .../task/nipype_internal/pydra-fsl/smm.yaml   |   88 ++
 .../pydra-fsl/smm_callables.py                |    1 +
 .../nipype_internal/pydra-fsl/smooth.yaml     |  239 ++++
 .../pydra-fsl/smooth_callables.py             |    1 +
 .../pydra-fsl/smooth_estimate.yaml            |  130 ++
 .../pydra-fsl/smooth_estimate_callables.py    |    1 +
 .../pydra-fsl/spatial_filter.yaml             |   97 ++
 .../pydra-fsl/spatial_filter_callables.py     |    1 +
 .../task/nipype_internal/pydra-fsl/split.yaml |   78 ++
 .../pydra-fsl/split_callables.py              |    1 +
 .../nipype_internal/pydra-fsl/std_image.yaml  |   91 ++
 .../pydra-fsl/std_image_callables.py          |    1 +
 .../task/nipype_internal/pydra-fsl/susan.yaml |  105 ++
 .../pydra-fsl/susan_callables.py              |    1 +
 .../pydra-fsl/swap_dimensions.yaml            |   90 ++
 .../pydra-fsl/swap_dimensions_callables.py    |    1 +
 .../pydra-fsl/temporal_filter.yaml            |   94 ++
 .../pydra-fsl/temporal_filter_callables.py    |    1 +
 .../pydra-fsl/text_2_vest.yaml                |  133 ++
 .../pydra-fsl/text_2_vest_callables.py        |    1 +
 .../nipype_internal/pydra-fsl/threshold.yaml  |   95 ++
 .../pydra-fsl/threshold_callables.py          |    1 +
 .../task/nipype_internal/pydra-fsl/topup.yaml |  215 ++++
 .../pydra-fsl/topup_callables.py              |    1 +
 .../pydra-fsl/tract_skeleton.yaml             |  135 ++
 .../pydra-fsl/tract_skeleton_callables.py     |    1 +
 .../nipype_internal/pydra-fsl/training.yaml   |   78 ++
 .../pydra-fsl/training_callables.py           |    1 +
 .../pydra-fsl/training_set_creator.yaml       |   73 ++
 .../training_set_creator_callables.py         |    1 +
 .../pydra-fsl/unary_maths.yaml                |   89 ++
 .../pydra-fsl/unary_maths_callables.py        |    1 +
 .../nipype_internal/pydra-fsl/vec_reg.yaml    |  170 +++
 .../pydra-fsl/vec_reg_callables.py            |    1 +
 .../pydra-fsl/vest_2_text.yaml                |  126 ++
 .../pydra-fsl/vest_2_text_callables.py        |    1 +
 .../pydra-fsl/warp_points.yaml                |  169 +++
 .../pydra-fsl/warp_points_callables.py        |    1 +
 .../pydra-fsl/warp_points_from_std.yaml       |  162 +++
 .../warp_points_from_std_callables.py         |    1 +
 .../pydra-fsl/warp_points_to_std.yaml         |  175 +++
 .../pydra-fsl/warp_points_to_std_callables.py |    1 +
 .../nipype_internal/pydra-fsl/warp_utils.yaml |  172 +++
 .../pydra-fsl/warp_utils_callables.py         |    1 +
 .../nipype_internal/pydra-fsl/x_fibres_5.yaml |  137 ++
 .../pydra-fsl/x_fibres_5_callables.py         |    1 +
 .../pydra-meshfix/mesh_fix.yaml               |  198 +++
 .../pydra-meshfix/mesh_fix_callables.py       |    1 +
 .../nipype_internal/pydra-minc/average.yaml   |  155 +++
 .../pydra-minc/average_callables.py           |    1 +
 .../nipype_internal/pydra-minc/b_box.yaml     |  106 ++
 .../pydra-minc/b_box_callables.py             |    1 +
 .../nipype_internal/pydra-minc/beast.yaml     |  131 ++
 .../pydra-minc/beast_callables.py             |    1 +
 .../pydra-minc/best_lin_reg.yaml              |  112 ++
 .../pydra-minc/best_lin_reg_callables.py      |    1 +
 .../pydra-minc/big_average.yaml               |  130 ++
 .../pydra-minc/big_average_callables.py       |    1 +
 .../task/nipype_internal/pydra-minc/blob.yaml |   97 ++
 .../pydra-minc/blob_callables.py              |    1 +
 .../task/nipype_internal/pydra-minc/blur.yaml |  140 +++
 .../pydra-minc/blur_callables.py              |    1 +
 .../task/nipype_internal/pydra-minc/calc.yaml |  155 +++
 .../pydra-minc/calc_callables.py              |    1 +
 .../nipype_internal/pydra-minc/convert.yaml   |   98 ++
 .../pydra-minc/convert_callables.py           |    1 +
 .../task/nipype_internal/pydra-minc/copy.yaml |   92 ++
 .../pydra-minc/copy_callables.py              |    1 +
 .../task/nipype_internal/pydra-minc/dump.yaml |  113 ++
 .../pydra-minc/dump_callables.py              |    1 +
 .../nipype_internal/pydra-minc/extract.yaml   |  154 +++
 .../pydra-minc/extract_callables.py           |    1 +
 .../nipype_internal/pydra-minc/gennlxfm.yaml  |  104 ++
 .../pydra-minc/gennlxfm_callables.py          |    1 +
 .../task/nipype_internal/pydra-minc/math.yaml |  205 +++
 .../pydra-minc/math_callables.py              |    1 +
 .../nipype_internal/pydra-minc/nlp_fit.yaml   |  125 ++
 .../pydra-minc/nlp_fit_callables.py           |    1 +
 .../task/nipype_internal/pydra-minc/norm.yaml |  124 ++
 .../pydra-minc/norm_callables.py              |    1 +
 .../task/nipype_internal/pydra-minc/pik.yaml  |  140 +++
 .../pydra-minc/pik_callables.py               |    1 +
 .../nipype_internal/pydra-minc/resample.yaml  |  202 +++
 .../pydra-minc/resample_callables.py          |    1 +
 .../nipype_internal/pydra-minc/reshape.yaml   |  100 ++
 .../pydra-minc/reshape_callables.py           |    1 +
 .../nipype_internal/pydra-minc/to_ecat.yaml   |  110 ++
 .../pydra-minc/to_ecat_callables.py           |    1 +
 .../nipype_internal/pydra-minc/to_raw.yaml    |  119 ++
 .../pydra-minc/to_raw_callables.py            |    1 +
 .../nipype_internal/pydra-minc/vol_symm.yaml  |  132 ++
 .../pydra-minc/vol_symm_callables.py          |    1 +
 .../nipype_internal/pydra-minc/volcentre.yaml |   98 ++
 .../pydra-minc/volcentre_callables.py         |    1 +
 .../nipype_internal/pydra-minc/voliso.yaml    |   99 ++
 .../pydra-minc/voliso_callables.py            |    1 +
 .../nipype_internal/pydra-minc/volpad.yaml    |  102 ++
 .../pydra-minc/volpad_callables.py            |    1 +
 .../nipype_internal/pydra-minc/xfm_avg.yaml   |  115 ++
 .../pydra-minc/xfm_avg_callables.py           |    1 +
 .../pydra-minc/xfm_concat.yaml                |   98 ++
 .../pydra-minc/xfm_concat_callables.py        |    1 +
 .../pydra-minc/xfm_invert.yaml                |   96 ++
 .../pydra-minc/xfm_invert_callables.py        |    1 +
 .../jist_brain_mgdm_segmentation.yaml         |  146 +++
 .../jist_brain_mgdm_segmentation_callables.py |    1 +
 .../jist_brain_mp_2rage_dura_estimation.yaml  |   91 ++
 ...rain_mp_2rage_dura_estimation_callables.py |    1 +
 .../jist_brain_mp_2rage_skull_stripping.yaml  |  119 ++
 ...rain_mp_2rage_skull_stripping_callables.py |    1 +
 .../jist_brain_partial_volume_filter.yaml     |   91 ++
 ...t_brain_partial_volume_filter_callables.py |    1 +
 .../jist_cortex_surface_mesh_inflation.yaml   |  108 ++
 ...cortex_surface_mesh_inflation_callables.py |    1 +
 .../jist_intensity_mp_2rage_masking.yaml      |  115 ++
 ...st_intensity_mp_2rage_masking_callables.py |    1 +
 .../jist_laminar_profile_calculator.yaml      |   89 ++
 ...st_laminar_profile_calculator_callables.py |    1 +
 .../jist_laminar_profile_geometry.yaml        |   91 ++
 ...jist_laminar_profile_geometry_callables.py |    1 +
 .../jist_laminar_profile_sampling.yaml        |   97 ++
 ...jist_laminar_profile_sampling_callables.py |    1 +
 .../jist_laminar_roi_averaging.yaml           |   93 ++
 .../jist_laminar_roi_averaging_callables.py   |    1 +
 .../jist_laminar_volumetric_layering.yaml     |  127 ++
 ...t_laminar_volumetric_layering_callables.py |    1 +
 .../medic_algorithm_image_calculator.yaml     |   93 ++
 ...ic_algorithm_image_calculator_callables.py |    1 +
 .../medic_algorithm_lesion_toads.yaml         |  192 +++
 .../medic_algorithm_lesion_toads_callables.py |    1 +
 .../medic_algorithm_mipav_reorient.yaml       |   99 ++
 ...edic_algorithm_mipav_reorient_callables.py |    1 +
 .../pydra-mipav/medic_algorithm_n3.yaml       |  105 ++
 .../medic_algorithm_n3_callables.py           |    1 +
 .../medic_algorithm_spectre2010.yaml          |  212 ++++
 .../medic_algorithm_spectre2010_callables.py  |    1 +
 ...ic_algorithm_threshold_to_binary_mask.yaml |   91 ++
 ...ithm_threshold_to_binary_mask_callables.py |    1 +
 .../pydra-mipav/random_vol.yaml               |   97 ++
 .../pydra-mipav/random_vol_callables.py       |    1 +
 .../pydra-niftyfit/dwi_tool.yaml              |  252 ++++
 .../pydra-niftyfit/dwi_tool_callables.py      |    1 +
 .../pydra-niftyfit/fit_asl.yaml               |  227 ++++
 .../pydra-niftyfit/fit_asl_callables.py       |    1 +
 .../pydra-niftyfit/fit_dwi.yaml               |  328 +++++
 .../pydra-niftyfit/fit_dwi_callables.py       |    1 +
 .../pydra-niftyfit/fit_qt_1.yaml              |  248 ++++
 .../pydra-niftyfit/fit_qt_1_callables.py      |    1 +
 .../pydra-niftyreg/reg_aladin.yaml            |  209 ++++
 .../pydra-niftyreg/reg_aladin_callables.py    |    1 +
 .../pydra-niftyreg/reg_average.yaml           |  161 +++
 .../pydra-niftyreg/reg_average_callables.py   |    1 +
 .../pydra-niftyreg/reg_f3d.yaml               |  262 ++++
 .../pydra-niftyreg/reg_f3d_callables.py       |    1 +
 .../pydra-niftyreg/reg_jacobian.yaml          |  145 +++
 .../pydra-niftyreg/reg_jacobian_callables.py  |    1 +
 .../pydra-niftyreg/reg_measure.yaml           |  149 +++
 .../pydra-niftyreg/reg_measure_callables.py   |    1 +
 .../pydra-niftyreg/reg_resample.yaml          |  172 +++
 .../pydra-niftyreg/reg_resample_callables.py  |    1 +
 .../pydra-niftyreg/reg_tools.yaml             |  174 +++
 .../pydra-niftyreg/reg_tools_callables.py     |    1 +
 .../pydra-niftyreg/reg_transform.yaml         |  184 +++
 .../pydra-niftyreg/reg_transform_callables.py |    1 +
 .../pydra-niftyseg/binary_maths.yaml          |  295 +++++
 .../pydra-niftyseg/binary_maths_callables.py  |    1 +
 .../pydra-niftyseg/binary_maths_integer.yaml  |  167 +++
 .../binary_maths_integer_callables.py         |    1 +
 .../pydra-niftyseg/binary_stats.yaml          |  165 +++
 .../pydra-niftyseg/binary_stats_callables.py  |    1 +
 .../pydra-niftyseg/calc_top_ncc.yaml          |  140 +++
 .../pydra-niftyseg/calc_top_ncc_callables.py  |    1 +
 .../nipype_internal/pydra-niftyseg/em.yaml    |  180 +++
 .../pydra-niftyseg/em_callables.py            |    1 +
 .../pydra-niftyseg/fill_lesions.yaml          |  162 +++
 .../pydra-niftyseg/fill_lesions_callables.py  |    1 +
 .../pydra-niftyseg/label_fusion.yaml          |  208 ++++
 .../pydra-niftyseg/label_fusion_callables.py  |    1 +
 .../pydra-niftyseg/maths_command.yaml         |   96 ++
 .../pydra-niftyseg/maths_command_callables.py |    1 +
 .../nipype_internal/pydra-niftyseg/merge.yaml |  151 +++
 .../pydra-niftyseg/merge_callables.py         |    1 +
 .../pydra-niftyseg/patch_match.yaml           |  165 +++
 .../pydra-niftyseg/patch_match_callables.py   |    1 +
 .../pydra-niftyseg/stats_command.yaml         |   88 ++
 .../pydra-niftyseg/stats_command_callables.py |    1 +
 .../pydra-niftyseg/tuple_maths.yaml           |  269 ++++
 .../pydra-niftyseg/tuple_maths_callables.py   |    1 +
 .../pydra-niftyseg/unary_maths.yaml           |  307 +++++
 .../pydra-niftyseg/unary_maths_callables.py   |    1 +
 .../pydra-niftyseg/unary_stats.yaml           |  217 ++++
 .../pydra-niftyseg/unary_stats_callables.py   |    1 +
 .../pydra-nilearn/nilearn_base_interface.yaml |   62 +
 .../nilearn_base_interface_callables.py       |    1 +
 .../pydra-nilearn/signal_extraction.yaml      |   98 ++
 .../signal_extraction_callables.py            |    1 +
 .../pydra-nitime/coherence_analyzer.yaml      |   94 ++
 .../coherence_analyzer_callables.py           |    1 +
 .../nipype_internal/pydra-petpvc/petpvc.yaml  |  128 ++
 .../pydra-petpvc/petpvc_callables.py          |    1 +
 .../pydra-quickshear/quickshear.yaml          |  155 +++
 .../pydra-quickshear/quickshear_callables.py  |    1 +
 .../pydra-robex/robex_segment.yaml            |  142 +++
 .../pydra-robex/robex_segment_callables.py    |    1 +
 ...binary_mask_editor_based_on_landmarks.yaml |   95 ++
 ...ask_editor_based_on_landmarks_callables.py |    1 +
 .../pydra-semtools/brains_align_msp.yaml      |  105 ++
 .../brains_align_msp_callables.py             |    1 +
 .../pydra-semtools/brains_clip_inferior.yaml  |   89 ++
 .../brains_clip_inferior_callables.py         |    1 +
 .../brains_constellation_detector.yaml        |  209 ++++
 ...brains_constellation_detector_callables.py |    1 +
 .../brains_constellation_modeler.yaml         |  107 ++
 .../brains_constellation_modeler_callables.py |    1 +
 ...reate_label_map_from_probability_maps.yaml |   97 ++
 ...bel_map_from_probability_maps_callables.py |    1 +
 .../pydra-semtools/brains_cut.yaml            |  115 ++
 .../pydra-semtools/brains_cut_callables.py    |    1 +
 .../pydra-semtools/brains_demon_warp.yaml     |  185 +++
 .../brains_demon_warp_callables.py            |    1 +
 .../pydra-semtools/brains_eye_detector.yaml   |   87 ++
 .../brains_eye_detector_callables.py          |    1 +
 .../pydra-semtools/brains_fit.yaml            |  257 ++++
 .../pydra-semtools/brains_fit_callables.py    |    1 +
 .../brains_initialized_control_points.yaml    |   97 ++
 ...ns_initialized_control_points_callables.py |    1 +
 .../brains_landmark_initializer.yaml          |   95 ++
 .../brains_landmark_initializer_callables.py  |    1 +
 .../brains_linear_modeler_epca.yaml           |   81 ++
 .../brains_linear_modeler_epca_callables.py   |    1 +
 .../pydra-semtools/brains_lmk_transform.yaml  |  105 ++
 .../brains_lmk_transform_callables.py         |    1 +
 .../pydra-semtools/brains_multi_staple.yaml   |  101 ++
 .../brains_multi_staple_callables.py          |    1 +
 .../pydra-semtools/brains_mush.yaml           |  131 ++
 .../pydra-semtools/brains_mush_callables.py   |    1 +
 .../brains_posterior_to_continuous_class.yaml |  115 ++
 ...posterior_to_continuous_class_callables.py |    1 +
 .../pydra-semtools/brains_resample.yaml       |  115 ++
 .../brains_resample_callables.py              |    1 +
 .../pydra-semtools/brains_resize.yaml         |   93 ++
 .../pydra-semtools/brains_resize_callables.py |    1 +
 .../brains_snap_shot_writer.yaml              |   99 ++
 .../brains_snap_shot_writer_callables.py      |    1 +
 .../pydra-semtools/brains_talairach.yaml      |  113 ++
 .../brains_talairach_callables.py             |    1 +
 .../pydra-semtools/brains_talairach_mask.yaml |  103 ++
 .../brains_talairach_mask_callables.py        |    1 +
 .../brains_transform_convert.yaml             |  103 ++
 .../brains_transform_convert_callables.py     |    1 +
 .../brains_transform_from_fiducials.yaml      |  101 ++
 ...ains_transform_from_fiducials_callables.py |    1 +
 .../brains_trim_foreground_in_direction.yaml  |   97 ++
 ..._trim_foreground_in_direction_callables.py |    1 +
 .../pydra-semtools/brainsabc.yaml             |  167 +++
 .../pydra-semtools/brainsabc_callables.py     |    1 +
 .../pydra-semtools/brainsroi_auto.yaml        |  111 ++
 .../brainsroi_auto_callables.py               |    1 +
 .../pydra-semtools/canny_edge.yaml            |   95 ++
 .../pydra-semtools/canny_edge_callables.py    |    1 +
 ...y_segmentation_level_set_image_filter.yaml |  109 ++
 ...tation_level_set_image_filter_callables.py |    1 +
 .../clean_up_overlap_labels.yaml              |   82 ++
 .../clean_up_overlap_labels_callables.py      |    1 +
 .../compare_tract_inclusion.yaml              |  101 ++
 .../compare_tract_inclusion_callables.py      |    1 +
 .../pydra-semtools/dilate_image.yaml          |   95 ++
 .../pydra-semtools/dilate_image_callables.py  |    1 +
 .../pydra-semtools/dilate_mask.yaml           |   97 ++
 .../pydra-semtools/dilate_mask_callables.py   |    1 +
 .../pydra-semtools/distance_maps.yaml         |   95 ++
 .../pydra-semtools/distance_maps_callables.py |    1 +
 .../pydra-semtools/dtiaverage.yaml            |   98 ++
 .../pydra-semtools/dtiaverage_callables.py    |    1 +
 .../pydra-semtools/dtiestim.yaml              |  163 +++
 .../pydra-semtools/dtiestim_callables.py      |    1 +
 .../pydra-semtools/dtiprocess.yaml            |  225 ++++
 .../pydra-semtools/dtiprocess_callables.py    |    1 +
 .../dump_binary_training_vectors.yaml         |   87 ++
 .../dump_binary_training_vectors_callables.py |    1 +
 .../pydra-semtools/dwi_compare.yaml           |   89 ++
 .../pydra-semtools/dwi_compare_callables.py   |    1 +
 .../pydra-semtools/dwi_convert.yaml           |  147 +++
 .../pydra-semtools/dwi_convert_callables.py   |    1 +
 .../pydra-semtools/dwi_simple_compare.yaml    |   91 ++
 .../dwi_simple_compare_callables.py           |    1 +
 .../pydra-semtools/erode_image.yaml           |   95 ++
 .../pydra-semtools/erode_image_callables.py   |    1 +
 .../nipype_internal/pydra-semtools/eslr.yaml  |   95 ++
 .../pydra-semtools/eslr_callables.py          |    1 +
 .../extract_nrrd_vector_index.yaml            |   97 ++
 .../extract_nrrd_vector_index_callables.py    |    1 +
 .../pydra-semtools/fcsv_to_hdf_5.yaml         |   93 ++
 .../pydra-semtools/fcsv_to_hdf_5_callables.py |    1 +
 .../pydra-semtools/fiberprocess.yaml          |  129 ++
 .../pydra-semtools/fiberprocess_callables.py  |    1 +
 .../pydra-semtools/fiberstats.yaml            |   91 ++
 .../pydra-semtools/fiberstats_callables.py    |    1 +
 .../pydra-semtools/fibertrack.yaml            |  122 ++
 .../pydra-semtools/fibertrack_callables.py    |    1 +
 .../pydra-semtools/find_center_of_brain.yaml  |  139 +++
 .../find_center_of_brain_callables.py         |    1 +
 .../pydra-semtools/flipped_difference.yaml    |   93 ++
 .../flipped_difference_callables.py           |    1 +
 .../generate_average_lmk_file.yaml            |   81 ++
 .../generate_average_lmk_file_callables.py    |    1 +
 .../generate_brain_clipped_image.yaml         |   93 ++
 .../generate_brain_clipped_image_callables.py |    1 +
 ...ate_csf_clipped_from_classified_image.yaml |   89 ++
 ...clipped_from_classified_image_callables.py |    1 +
 .../generate_edge_map_image.yaml              |  105 ++
 .../generate_edge_map_image_callables.py      |    1 +
 ...nerate_label_map_from_probability_map.yaml |   87 ++
 ...abel_map_from_probability_map_callables.py |    1 +
 .../generate_pure_plug_mask.yaml              |   89 ++
 .../generate_pure_plug_mask_callables.py      |    1 +
 .../generate_summed_gradient_image.yaml       |   95 ++
 ...enerate_summed_gradient_image_callables.py |    1 +
 .../pydra-semtools/generate_test_image.yaml   |   93 ++
 .../generate_test_image_callables.py          |    1 +
 ...nt_anisotropic_diffusion_image_filter.yaml |   89 ++
 ...tropic_diffusion_image_filter_callables.py |    1 +
 .../pydra-semtools/gtract_anisotropy_map.yaml |   95 ++
 .../gtract_anisotropy_map_callables.py        |    1 +
 .../gtract_average_bvalues.yaml               |   97 ++
 .../gtract_average_bvalues_callables.py       |    1 +
 .../gtract_clip_anisotropy.yaml               |   97 ++
 .../gtract_clip_anisotropy_callables.py       |    1 +
 .../pydra-semtools/gtract_co_reg_anatomy.yaml |  139 +++
 .../gtract_co_reg_anatomy_callables.py        |    1 +
 .../pydra-semtools/gtract_concat_dwi.yaml     |   95 ++
 .../gtract_concat_dwi_callables.py            |    1 +
 .../gtract_copy_image_orientation.yaml        |   97 ++
 ...gtract_copy_image_orientation_callables.py |    1 +
 .../pydra-semtools/gtract_coreg_bvalues.yaml  |  125 ++
 .../gtract_coreg_bvalues_callables.py         |    1 +
 .../gtract_cost_fast_marching.yaml            |  115 ++
 .../gtract_cost_fast_marching_callables.py    |    1 +
 .../gtract_create_guide_fiber.yaml            |   97 ++
 .../gtract_create_guide_fiber_callables.py    |    1 +
 .../gtract_fast_marching_tracking.yaml        |  121 ++
 ...gtract_fast_marching_tracking_callables.py |    1 +
 .../pydra-semtools/gtract_fiber_tracking.yaml |  151 +++
 .../gtract_fiber_tracking_callables.py        |    1 +
 .../gtract_image_conformity.yaml              |   97 ++
 .../gtract_image_conformity_callables.py      |    1 +
 .../gtract_invert_b_spline_transform.yaml     |   99 ++
 ...act_invert_b_spline_transform_callables.py |    1 +
 .../gtract_invert_displacement_field.yaml     |   99 ++
 ...act_invert_displacement_field_callables.py |    1 +
 .../gtract_invert_rigid_transform.yaml        |   93 ++
 ...gtract_invert_rigid_transform_callables.py |    1 +
 .../gtract_resample_anisotropy.yaml           |  103 ++
 .../gtract_resample_anisotropy_callables.py   |    1 +
 .../pydra-semtools/gtract_resample_b0.yaml    |  105 ++
 .../gtract_resample_b0_callables.py           |    1 +
 .../gtract_resample_code_image.yaml           |  103 ++
 .../gtract_resample_code_image_callables.py   |    1 +
 .../gtract_resample_dwi_in_place.yaml         |  115 ++
 .../gtract_resample_dwi_in_place_callables.py |    1 +
 .../gtract_resample_fibers.yaml               |  103 ++
 .../gtract_resample_fibers_callables.py       |    1 +
 .../pydra-semtools/gtract_tensor.yaml         |  113 ++
 .../pydra-semtools/gtract_tensor_callables.py |    1 +
 ...tract_transform_to_displacement_field.yaml |   97 ++
 ...ansform_to_displacement_field_callables.py |    1 +
 .../hammer_attribute_creator.yaml             |   97 ++
 .../hammer_attribute_creator_callables.py     |    1 +
 .../histogram_matching_filter.yaml            |  107 ++
 .../histogram_matching_filter_callables.py    |    1 +
 .../pydra-semtools/image_region_plotter.yaml  |  101 ++
 .../image_region_plotter_callables.py         |    1 +
 .../pydra-semtools/insert_mid_acp_cpoint.yaml |   83 ++
 .../insert_mid_acp_cpoint_callables.py        |    1 +
 .../pydra-semtools/joint_histogram.yaml       |   95 ++
 .../joint_histogram_callables.py              |    1 +
 .../pydra-semtools/landmarks_compare.yaml     |   83 ++
 .../landmarks_compare_callables.py            |    1 +
 .../landmarks_constellation_aligner.yaml      |   83 ++
 ...ndmarks_constellation_aligner_callables.py |    1 +
 .../landmarks_constellation_weights.yaml      |   89 ++
 ...ndmarks_constellation_weights_callables.py |    1 +
 .../pydra-semtools/maxcurvature.yaml          |   99 ++
 .../pydra-semtools/maxcurvature_callables.py  |    1 +
 .../pydra-semtools/neighborhood_mean.yaml     |   95 ++
 .../neighborhood_mean_callables.py            |    1 +
 .../pydra-semtools/neighborhood_median.yaml   |   95 ++
 .../neighborhood_median_callables.py          |    1 +
 .../pydra-semtools/scalartransform.yaml       |  107 ++
 .../scalartransform_callables.py              |    1 +
 .../shuffle_vectors_module.yaml               |   89 ++
 .../shuffle_vectors_module_callables.py       |    1 +
 .../pydra-semtools/similarity_index.yaml      |   91 ++
 .../similarity_index_callables.py             |    1 +
 .../spherical_coordinate_generation.yaml      |   81 ++
 ...herical_coordinate_generation_callables.py |    1 +
 .../pydra-semtools/staple_analysis.yaml       |   91 ++
 .../staple_analysis_callables.py              |    1 +
 .../texture_from_noise_image_filter.yaml      |   91 ++
 ...xture_from_noise_image_filter_callables.py |    1 +
 .../texture_measure_filter.yaml               |   97 ++
 .../texture_measure_filter_callables.py       |    1 +
 .../pydra-semtools/ukf_tractography.yaml      |  159 +++
 .../ukf_tractography_callables.py             |    1 +
 .../unbiased_non_local_means.yaml             |  107 ++
 .../unbiased_non_local_means_callables.py     |    1 +
 .../pydra-semtools/vbrains_demon_warp.yaml    |  187 +++
 .../vbrains_demon_warp_callables.py           |    1 +
 .../pydra-slicer/acpc_transform.yaml          |   93 ++
 .../pydra-slicer/acpc_transform_callables.py  |    1 +
 .../pydra-slicer/add_scalar_volumes.yaml      |   95 ++
 .../add_scalar_volumes_callables.py           |    1 +
 .../pydra-slicer/affine_registration.yaml     |  121 ++
 .../affine_registration_callables.py          |    1 +
 .../b_spline_deformable_registration.yaml     |  123 ++
 ...pline_deformable_registration_callables.py |    1 +
 .../b_spline_to_deformation_field.yaml        |   93 ++
 ...b_spline_to_deformation_field_callables.py |    1 +
 .../pydra-slicer/brains_demon_warp.yaml       |  188 +++
 .../brains_demon_warp_callables.py            |    1 +
 .../pydra-slicer/brains_fit.yaml              |  241 ++++
 .../pydra-slicer/brains_fit_callables.py      |    1 +
 .../pydra-slicer/brains_resample.yaml         |  117 ++
 .../pydra-slicer/brains_resample_callables.py |    1 +
 .../pydra-slicer/brainsroi_auto.yaml          |  108 ++
 .../pydra-slicer/brainsroi_auto_callables.py  |    1 +
 .../pydra-slicer/cast_scalar_volume.yaml      |   93 ++
 .../cast_scalar_volume_callables.py           |    1 +
 .../pydra-slicer/checker_board_filter.yaml    |   95 ++
 .../checker_board_filter_callables.py         |    1 +
 .../curvature_anisotropic_diffusion.yaml      |   99 ++
 ...rvature_anisotropic_diffusion_callables.py |    1 +
 .../pydra-slicer/dicom_to_nrrd_converter.yaml |  101 ++
 .../dicom_to_nrrd_converter_callables.py      |    1 +
 .../diffusion_tensor_scalar_measurements.yaml |   91 ++
 ...on_tensor_scalar_measurements_callables.py |    1 +
 .../diffusion_weighted_volume_masking.yaml    |   99 ++
 ...usion_weighted_volume_masking_callables.py |    1 +
 .../pydra-slicer/dt_iexport.yaml              |   89 ++
 .../pydra-slicer/dt_iexport_callables.py      |    1 +
 .../pydra-slicer/dt_iimport.yaml              |   91 ++
 .../pydra-slicer/dt_iimport_callables.py      |    1 +
 .../dwi_joint_rician_lmmse_filter.yaml        |  100 ++
 ...dwi_joint_rician_lmmse_filter_callables.py |    1 +
 .../pydra-slicer/dwi_rician_lmmse_filter.yaml |  112 ++
 .../dwi_rician_lmmse_filter_callables.py      |    1 +
 .../pydra-slicer/dwi_to_dti_estimation.yaml   |  107 ++
 .../dwi_to_dti_estimation_callables.py        |    1 +
 .../dwi_unbiased_non_local_means_filter.yaml  |  103 ++
 ...biased_non_local_means_filter_callables.py |    1 +
 .../pydra-slicer/em_segment_command_line.yaml |  148 +++
 .../em_segment_command_line_callables.py      |    1 +
 .../em_segment_transform_to_new_format.yaml   |   89 ++
 ...gment_transform_to_new_format_callables.py |    1 +
 .../expert_automated_registration.yaml        |  151 +++
 ...expert_automated_registration_callables.py |    1 +
 .../pydra-slicer/extract_skeleton.yaml        |   97 ++
 .../extract_skeleton_callables.py             |    1 +
 .../pydra-slicer/fiducial_registration.yaml   |   95 ++
 .../fiducial_registration_callables.py        |    1 +
 .../gaussian_blur_image_filter.yaml           |   91 ++
 .../gaussian_blur_image_filter_callables.py   |    1 +
 .../gradient_anisotropic_diffusion.yaml       |   97 ++
 ...radient_anisotropic_diffusion_callables.py |    1 +
 .../grayscale_fill_hole_image_filter.yaml     |   97 ++
 ...yscale_fill_hole_image_filter_callables.py |    1 +
 .../grayscale_grind_peak_image_filter.yaml    |   99 ++
 ...scale_grind_peak_image_filter_callables.py |    1 +
 .../pydra-slicer/grayscale_model_maker.yaml   |  103 ++
 .../grayscale_model_maker_callables.py        |    1 +
 .../pydra-slicer/histogram_matching.yaml      |  105 ++
 .../histogram_matching_callables.py           |    1 +
 .../pydra-slicer/image_label_combine.yaml     |   93 ++
 .../image_label_combine_callables.py          |    1 +
 .../intensity_difference_metric.yaml          |  112 ++
 .../intensity_difference_metric_callables.py  |    1 +
 .../pydra-slicer/label_map_smoothing.yaml     |   97 ++
 .../label_map_smoothing_callables.py          |    1 +
 .../pydra-slicer/linear_registration.yaml     |  117 ++
 .../linear_registration_callables.py          |    1 +
 .../pydra-slicer/mask_scalar_volume.yaml      |   97 ++
 .../mask_scalar_volume_callables.py           |    1 +
 .../pydra-slicer/median_image_filter.yaml     |   91 ++
 .../median_image_filter_callables.py          |    1 +
 .../pydra-slicer/merge_models.yaml            |   93 ++
 .../pydra-slicer/merge_models_callables.py    |    1 +
 .../pydra-slicer/model_maker.yaml             |  122 ++
 .../pydra-slicer/model_maker_callables.py     |    1 +
 .../pydra-slicer/model_to_label_map.yaml      |   95 ++
 .../model_to_label_map_callables.py           |    1 +
 .../multi_resolution_affine_registration.yaml |  115 ++
 ...esolution_affine_registration_callables.py |    1 +
 .../pydra-slicer/multiply_scalar_volumes.yaml |   95 ++
 .../multiply_scalar_volumes_callables.py      |    1 +
 .../n4itk_bias_field_correction.yaml          |  117 ++
 .../n4itk_bias_field_correction_callables.py  |    1 +
 .../pydra-slicer/orient_scalar_volume.yaml    |   91 ++
 .../orient_scalar_volume_callables.py         |    1 +
 .../otsu_threshold_image_filter.yaml          |   99 ++
 .../otsu_threshold_image_filter_callables.py  |    1 +
 .../otsu_threshold_segmentation.yaml          |   97 ++
 .../otsu_threshold_segmentation_callables.py  |    1 +
 ...pet_standard_uptake_value_computation.yaml |  111 ++
 ...dard_uptake_value_computation_callables.py |    1 +
 .../pydra-slicer/probe_volume_with_model.yaml |   93 ++
 .../probe_volume_with_model_callables.py      |    1 +
 .../pydra-slicer/resample_dti_volume.yaml     |  143 +++
 .../resample_dti_volume_callables.py          |    1 +
 .../resample_scalar_vector_dwi_volume.yaml    |  143 +++
 ...mple_scalar_vector_dwi_volume_callables.py |    1 +
 .../pydra-slicer/resample_scalar_volume.yaml  |   93 ++
 .../resample_scalar_volume_callables.py       |    1 +
 .../pydra-slicer/rigid_registration.yaml      |  129 ++
 .../rigid_registration_callables.py           |    1 +
 .../robust_statistics_segmenter.yaml          |  103 ++
 .../robust_statistics_segmenter_callables.py  |    1 +
 .../simple_region_growing_segmentation.yaml   |  103 ++
 ...e_region_growing_segmentation_callables.py |    1 +
 .../pydra-slicer/subtract_scalar_volumes.yaml |   95 ++
 .../subtract_scalar_volumes_callables.py      |    1 +
 .../pydra-slicer/threshold_scalar_volume.yaml |   99 ++
 .../threshold_scalar_volume_callables.py      |    1 +
 .../tractography_label_map_seeding.yaml       |  127 ++
 ...ractography_label_map_seeding_callables.py |    1 +
 .../pydra-slicer/vbrains_demon_warp.yaml      |  190 +++
 .../vbrains_demon_warp_callables.py           |    1 +
 ...ting_binary_hole_filling_image_filter.yaml |   97 ++
 ...ary_hole_filling_image_filter_callables.py |    1 +
 .../pydra-spm/analyze_2nii.yaml               |   86 ++
 .../pydra-spm/analyze_2nii_callables.py       |    1 +
 .../pydra-spm/apply_deformations.yaml         |   84 ++
 .../pydra-spm/apply_deformations_callables.py |    1 +
 .../pydra-spm/apply_inverse_deformation.yaml  |  108 ++
 .../apply_inverse_deformation_callables.py    |    1 +
 .../pydra-spm/apply_transform.yaml            |  102 ++
 .../pydra-spm/apply_transform_callables.py    |    1 +
 .../nipype_internal/pydra-spm/apply_vdm.yaml  |  103 ++
 .../pydra-spm/apply_vdm_callables.py          |    1 +
 .../pydra-spm/calc_coreg_affine.yaml          |  120 ++
 .../pydra-spm/calc_coreg_affine_callables.py  |    1 +
 .../nipype_internal/pydra-spm/coregister.yaml |  113 ++
 .../pydra-spm/coregister_callables.py         |    1 +
 .../pydra-spm/create_warped.yaml              |   96 ++
 .../pydra-spm/create_warped_callables.py      |    1 +
 .../nipype_internal/pydra-spm/dartel.yaml     |   97 ++
 .../pydra-spm/dartel_callables.py             |    1 +
 .../pydra-spm/dartel_norm_2mni.yaml           |  104 ++
 .../pydra-spm/dartel_norm_2mni_callables.py   |    1 +
 .../pydra-spm/dicom_import.yaml               |   95 ++
 .../pydra-spm/dicom_import_callables.py       |    1 +
 .../pydra-spm/estimate_contrast.yaml          |  110 ++
 .../pydra-spm/estimate_contrast_callables.py  |    1 +
 .../pydra-spm/estimate_model.yaml             |   99 ++
 .../pydra-spm/estimate_model_callables.py     |    1 +
 .../pydra-spm/factorial_design.yaml           |  108 ++
 .../pydra-spm/factorial_design_callables.py   |    1 +
 .../nipype_internal/pydra-spm/field_map.yaml  |  157 +++
 .../pydra-spm/field_map_callables.py          |    1 +
 .../pydra-spm/level_1_design.yaml             |  123 ++
 .../pydra-spm/level_1_design_callables.py     |    1 +
 .../pydra-spm/multi_channel_new_segment.yaml  |  113 ++
 .../multi_channel_new_segment_callables.py    |    1 +
 .../pydra-spm/multiple_regression_design.yaml |  120 ++
 .../multiple_regression_design_callables.py   |    1 +
 .../pydra-spm/new_segment.yaml                |  116 ++
 .../pydra-spm/new_segment_callables.py        |    1 +
 .../nipype_internal/pydra-spm/normalize.yaml  |  131 ++
 .../pydra-spm/normalize_12.yaml               |  122 ++
 .../pydra-spm/normalize_12_callables.py       |    1 +
 .../pydra-spm/normalize_callables.py          |    1 +
 .../pydra-spm/one_sample_t_test_design.yaml   |  116 ++
 .../one_sample_t_test_design_callables.py     |    1 +
 .../pydra-spm/paired_t_test_design.yaml       |  118 ++
 .../paired_t_test_design_callables.py         |    1 +
 .../nipype_internal/pydra-spm/realign.yaml    |  119 ++
 .../pydra-spm/realign_callables.py            |    1 +
 .../pydra-spm/realign_unwarp.yaml             |  145 +++
 .../pydra-spm/realign_unwarp_callables.py     |    1 +
 .../nipype_internal/pydra-spm/reslice.yaml    |   93 ++
 .../pydra-spm/reslice_callables.py            |    1 +
 .../pydra-spm/reslice_to_reference.yaml       |   99 ++
 .../reslice_to_reference_callables.py         |    1 +
 .../nipype_internal/pydra-spm/segment.yaml    |  146 +++
 .../pydra-spm/segment_callables.py            |    1 +
 .../pydra-spm/slice_timing.yaml               |  105 ++
 .../pydra-spm/slice_timing_callables.py       |    1 +
 .../nipype_internal/pydra-spm/smooth.yaml     |   95 ++
 .../pydra-spm/smooth_callables.py             |    1 +
 .../nipype_internal/pydra-spm/threshold.yaml  |  117 ++
 .../pydra-spm/threshold_callables.py          |    1 +
 .../pydra-spm/threshold_statistics.yaml       |  100 ++
 .../threshold_statistics_callables.py         |    1 +
 .../pydra-spm/two_sample_t_test_design.yaml   |  125 ++
 .../two_sample_t_test_design_callables.py     |    1 +
 .../pydra-spm/vbm_segment.yaml                |  156 +++
 .../pydra-spm/vbm_segment_callables.py        |    1 +
 .../pydra-vista/vnifti_2_image.yaml           |  127 ++
 .../pydra-vista/vnifti_2_image_callables.py   |    1 +
 .../nipype_internal/pydra-vista/vto_mat.yaml  |  123 ++
 .../pydra-vista/vto_mat_callables.py          |    1 +
 .../pydra-workbench/cifti_smooth.yaml         |  203 +++
 .../pydra-workbench/cifti_smooth_callables.py |    1 +
 .../pydra-workbench/metric_resample.yaml      |  200 +++
 .../metric_resample_callables.py              |    1 +
 nipype2pydra/task/__init__.py                 |   21 +-
 1431 files changed, 103825 insertions(+), 6 deletions(-)
 create mode 100644 example-specs/task/ghislains/bet.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/a_boverlap.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/a_boverlap_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/afn_ito_nifti.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/afn_ito_nifti_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/align_epi_anat_py.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/align_epi_anat_py_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/allineate.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/allineate_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/auto_tcorrelate.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/auto_tcorrelate_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/auto_tlrc.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/auto_tlrc_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/autobox.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/autobox_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/automask.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/automask_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/axialize.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/axialize_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/bandpass.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/bandpass_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/blur_in_mask.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/blur_in_mask_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/blur_to_fwhm.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/blur_to_fwhm_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/brick_stat.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/brick_stat_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/bucket.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/bucket_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/calc.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/calc_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/cat.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/cat_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/cat_matvec.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/cat_matvec_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/center_mass.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/center_mass_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/clip_level.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/clip_level_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/convert_dset.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/convert_dset_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/copy.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/copy_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/deconvolve.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/deconvolve_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/degree_centrality.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/degree_centrality_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/despike.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/despike_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/detrend.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/detrend_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/dot.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/dot_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/ecm.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/ecm_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/edge_3.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/edge_3_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/eval.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/eval_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/fim.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/fim_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/fourier.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/fourier_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/fwh_mx.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/fwh_mx_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/gcor.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/gcor_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/hist.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/hist_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/lfcd.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/lfcd_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/local_bistat.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/local_bistat_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/localstat.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/localstat_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/mask_tool.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/mask_tool_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/maskave.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/maskave_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/means.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/means_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/merge.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/merge_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/net_corr.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/net_corr_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/notes.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/notes_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/nwarp_adjust.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/nwarp_adjust_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/nwarp_apply.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/nwarp_apply_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/nwarp_cat.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/nwarp_cat_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/one_d_tool_py.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/one_d_tool_py_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/outlier_count.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/outlier_count_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/quality_index.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/quality_index_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/qwarp.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/qwarp_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/qwarp_plus_minus.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/qwarp_plus_minus_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/re_ho.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/re_ho_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/refit.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/refit_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/remlfit.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/remlfit_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/resample.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/resample_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/retroicor.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/retroicor_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/roi_stats.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/roi_stats_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/seg.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/seg_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/skull_strip.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/skull_strip_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/svm_test.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/svm_test_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/svm_train.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/svm_train_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/synthesize.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/synthesize_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/t_cat.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/t_cat_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/t_cat_sub_brick.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/t_cat_sub_brick_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/t_corr_1d.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/t_corr_1d_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/t_corr_map.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/t_corr_map_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/t_correlate.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/t_correlate_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/t_norm.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/t_norm_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/t_project.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/t_project_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/t_shift.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/t_shift_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/t_smooth.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/t_smooth_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/t_stat.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/t_stat_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/to_3d.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/to_3d_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/undump.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/undump_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/unifize.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/unifize_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/volreg.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/volreg_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/warp.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/warp_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/z_cut_up.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/z_cut_up_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/zcat.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/zcat_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/zeropad.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-afni/zeropad_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-ants/affine_initializer.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-ants/affine_initializer_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-ants/ai.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-ants/ai_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-ants/ants.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-ants/ants_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-ants/ants_introduction.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-ants/ants_introduction_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-ants/apply_transforms.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-ants/apply_transforms_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-ants/apply_transforms_to_points.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-ants/apply_transforms_to_points_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-ants/atropos.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-ants/atropos_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-ants/average_affine_transform.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-ants/average_affine_transform_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-ants/average_images.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-ants/average_images_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-ants/brain_extraction.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-ants/brain_extraction_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-ants/buildtemplateparallel.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-ants/buildtemplateparallel_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-ants/compose_multi_transform.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-ants/compose_multi_transform_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-ants/composite_transform_util.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-ants/composite_transform_util_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-ants/convert_scalar_image_to_rgb.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-ants/convert_scalar_image_to_rgb_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-ants/cortical_thickness.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-ants/cortical_thickness_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-ants/create_jacobian_determinant_image.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-ants/create_jacobian_determinant_image_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-ants/create_tiled_mosaic.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-ants/create_tiled_mosaic_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-ants/denoise_image.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-ants/denoise_image_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-ants/gen_warp_fields.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-ants/gen_warp_fields_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-ants/image_math.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-ants/image_math_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-ants/joint_fusion.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-ants/joint_fusion_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-ants/kelly_kapowski.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-ants/kelly_kapowski_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-ants/label_geometry.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-ants/label_geometry_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-ants/laplacian_thickness.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-ants/laplacian_thickness_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-ants/measure_image_similarity.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-ants/measure_image_similarity_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-ants/multiply_images.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-ants/multiply_images_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-ants/n4_bias_field_correction.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-ants/n4_bias_field_correction_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-ants/registration.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-ants/registration_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-ants/registration_syn_quick.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-ants/registration_syn_quick_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-ants/resample_image_by_spacing.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-ants/resample_image_by_spacing_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-ants/threshold_image.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-ants/threshold_image_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-ants/warp_image_multi_transform.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-ants/warp_image_multi_transform_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-ants/warp_time_series_image_multi_transform.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-ants/warp_time_series_image_multi_transform_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-brainsuite/bdp.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-brainsuite/bdp_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-brainsuite/bfc.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-brainsuite/bfc_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-brainsuite/bse.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-brainsuite/bse_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-brainsuite/cerebro.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-brainsuite/cerebro_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-brainsuite/cortex.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-brainsuite/cortex_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-brainsuite/dewisp.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-brainsuite/dewisp_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-brainsuite/dfs.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-brainsuite/dfs_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-brainsuite/hemisplit.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-brainsuite/hemisplit_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-brainsuite/pialmesh.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-brainsuite/pialmesh_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-brainsuite/pvc.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-brainsuite/pvc_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-brainsuite/scrubmask.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-brainsuite/scrubmask_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-brainsuite/skullfinder.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-brainsuite/skullfinder_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-brainsuite/sv_reg.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-brainsuite/sv_reg_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-brainsuite/tca.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-brainsuite/tca_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-brainsuite/thickness_pvc.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-brainsuite/thickness_pvc_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-bru2nii/bru_2.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-bru2nii/bru_2_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-c3/c_3d.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-c3/c_3d_affine_tool.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-c3/c_3d_affine_tool_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-c3/c_3d_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-camino/analyze_header.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-camino/analyze_header_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-camino/compute_eigensystem.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-camino/compute_eigensystem_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-camino/compute_fractional_anisotropy.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-camino/compute_fractional_anisotropy_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-camino/compute_mean_diffusivity.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-camino/compute_mean_diffusivity_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-camino/compute_tensor_trace.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-camino/compute_tensor_trace_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-camino/conmat.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-camino/conmat_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-camino/dt2n_if_ti.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-camino/dt2n_if_ti_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-camino/dt_metric.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-camino/dt_metric_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-camino/dti_fit.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-camino/dti_fit_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-camino/dtlut_gen.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-camino/dtlut_gen_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-camino/fsl2_scheme.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-camino/fsl2_scheme_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-camino/image_2_voxel.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-camino/image_2_voxel_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-camino/image_stats.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-camino/image_stats_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-camino/lin_recon.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-camino/lin_recon_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-camino/mesd.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-camino/mesd_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-camino/model_fit.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-camino/model_fit_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-camino/n_if_tidt2_camino.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-camino/n_if_tidt2_camino_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-camino/pico_pd_fs.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-camino/pico_pd_fs_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-camino/proc_streamlines.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-camino/proc_streamlines_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-camino/q_ball_mx.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-camino/q_ball_mx_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-camino/sf_peaks.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-camino/sf_peaks_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-camino/sflut_gen.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-camino/sflut_gen_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-camino/sfpico_calib_data.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-camino/sfpico_calib_data_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-camino/shredder.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-camino/shredder_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-camino/track.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-camino/track_ball_stick.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-camino/track_ball_stick_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-camino/track_bayes_dirac.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-camino/track_bayes_dirac_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-camino/track_bedpostx_deter.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-camino/track_bedpostx_deter_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-camino/track_bedpostx_proba.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-camino/track_bedpostx_proba_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-camino/track_bootstrap.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-camino/track_bootstrap_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-camino/track_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-camino/track_dt.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-camino/track_dt_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-camino/track_pi_co.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-camino/track_pi_co_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-camino/tract_shredder.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-camino/tract_shredder_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-camino/vtk_streamlines.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-camino/vtk_streamlines_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-camino2trackvis/camino_2_trackvis.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-camino2trackvis/camino_2_trackvis_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-camino2trackvis/trackvis_2_camino.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-camino2trackvis/trackvis_2_camino_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-cat12/cat12_segment.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-cat12/cat12_segment_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-cat12/cat12sanlm_denoising.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-cat12/cat12sanlm_denoising_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-cat12/extract_additional_surface_parameters.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-cat12/extract_additional_surface_parameters_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-cat12/extract_roi_based_surface_measures.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-cat12/extract_roi_based_surface_measures_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-cmtk/average_networks.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-cmtk/average_networks_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-cmtk/cff_converter.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-cmtk/cff_converter_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-cmtk/create_matrix.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-cmtk/create_matrix_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-cmtk/create_nodes.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-cmtk/create_nodes_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-cmtk/merge_c_networks.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-cmtk/merge_c_networks_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-cmtk/network_based_statistic.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-cmtk/network_based_statistic_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-cmtk/network_x_metrics.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-cmtk/network_x_metrics_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-cmtk/parcellate.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-cmtk/parcellate_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-cmtk/roi_gen.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-cmtk/roi_gen_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-dcmstack/copy_meta.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-dcmstack/copy_meta_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-dcmstack/dcm_stack.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-dcmstack/dcm_stack_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-dcmstack/group_and_stack.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-dcmstack/group_and_stack_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-dcmstack/lookup_meta.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-dcmstack/lookup_meta_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-dcmstack/merge_nifti.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-dcmstack/merge_nifti_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-dcmstack/nifti_generator_base.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-dcmstack/nifti_generator_base_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-dcmstack/split_nifti.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-dcmstack/split_nifti_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-diffusion_toolkit/dti_recon.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-diffusion_toolkit/dti_recon_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-diffusion_toolkit/dti_tracker.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-diffusion_toolkit/dti_tracker_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-diffusion_toolkit/hardi_mat.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-diffusion_toolkit/hardi_mat_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-diffusion_toolkit/odf_recon.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-diffusion_toolkit/odf_recon_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-diffusion_toolkit/odf_tracker.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-diffusion_toolkit/odf_tracker_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-diffusion_toolkit/spline_filter.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-diffusion_toolkit/spline_filter_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-diffusion_toolkit/track_merge.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-diffusion_toolkit/track_merge_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-dipy/apm_qball.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-dipy/apm_qball_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-dipy/csd.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-dipy/csd_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-dipy/denoise.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-dipy/denoise_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-dipy/dti.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-dipy/dti_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-dipy/estimate_response_sh.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-dipy/estimate_response_sh_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-dipy/resample.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-dipy/resample_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-dipy/restore.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-dipy/restore_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-dipy/simulate_multi_tensor.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-dipy/simulate_multi_tensor_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-dipy/streamline_tractography.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-dipy/streamline_tractography_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-dipy/tensor_mode.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-dipy/tensor_mode_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-dipy/track_density_map.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-dipy/track_density_map_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-dtitk/aff_scalar_vol.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-dtitk/aff_scalar_vol_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-dtitk/aff_scalar_vol_task.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-dtitk/aff_scalar_vol_task_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-dtitk/aff_sym_tensor_3d_vol.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-dtitk/aff_sym_tensor_3d_vol_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-dtitk/aff_sym_tensor_3d_vol_task.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-dtitk/aff_sym_tensor_3d_vol_task_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-dtitk/affine.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-dtitk/affine_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-dtitk/affine_task.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-dtitk/affine_task_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-dtitk/bin_thresh.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-dtitk/bin_thresh_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-dtitk/bin_thresh_task.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-dtitk/bin_thresh_task_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-dtitk/compose_xfm.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-dtitk/compose_xfm_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-dtitk/compose_xfm_task.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-dtitk/compose_xfm_task_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-dtitk/diffeo.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-dtitk/diffeo_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-dtitk/diffeo_scalar_vol.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-dtitk/diffeo_scalar_vol_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-dtitk/diffeo_scalar_vol_task.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-dtitk/diffeo_scalar_vol_task_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-dtitk/diffeo_sym_tensor_3d_vol.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-dtitk/diffeo_sym_tensor_3d_vol_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-dtitk/diffeo_sym_tensor_3d_vol_task.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-dtitk/diffeo_sym_tensor_3d_vol_task_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-dtitk/diffeo_task.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-dtitk/diffeo_task_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-dtitk/rigid.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-dtitk/rigid_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-dtitk/rigid_task.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-dtitk/rigid_task_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-dtitk/sv_adjust_vox_sp.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-dtitk/sv_adjust_vox_sp_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-dtitk/sv_adjust_vox_sp_task.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-dtitk/sv_adjust_vox_sp_task_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-dtitk/sv_resample.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-dtitk/sv_resample_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-dtitk/sv_resample_task.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-dtitk/sv_resample_task_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-dtitk/t_vtool.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-dtitk/t_vtool_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-dtitk/t_vtool_task.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-dtitk/t_vtool_task_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-dtitk/tv_adjust_origin_task.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-dtitk/tv_adjust_origin_task_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-dtitk/tv_adjust_vox_sp.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-dtitk/tv_adjust_vox_sp_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-dtitk/tv_adjust_vox_sp_task.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-dtitk/tv_adjust_vox_sp_task_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-dtitk/tv_resample.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-dtitk/tv_resample_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-dtitk/tv_resample_task.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-dtitk/tv_resample_task_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-dynamic_slicer/slicer_command_line.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-dynamic_slicer/slicer_command_line_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-elastix/analyze_warp.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-elastix/analyze_warp_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-elastix/apply_warp.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-elastix/apply_warp_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-elastix/edit_transform.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-elastix/edit_transform_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-elastix/points_warp.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-elastix/points_warp_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-elastix/registration.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-elastix/registration_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/add_x_form_to_header.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/add_x_form_to_header_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/aparc_2_aseg.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/aparc_2_aseg_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/apas_2_aseg.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/apas_2_aseg_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/apply_mask.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/apply_mask_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/apply_vol_transform.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/apply_vol_transform_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/bb_register.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/bb_register_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/binarize.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/binarize_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/ca_label.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/ca_label_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/ca_normalize.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/ca_normalize_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/ca_register.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/ca_register_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/check_talairach_alignment.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/check_talairach_alignment_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/concatenate.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/concatenate_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/concatenate_lta.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/concatenate_lta_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/contrast.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/contrast_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/curvature.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/curvature_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/curvature_stats.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/curvature_stats_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/dicom_convert.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/dicom_convert_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/edit_w_mwith_aseg.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/edit_w_mwith_aseg_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/em_register.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/em_register_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/euler_number.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/euler_number_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/extract_main_component.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/extract_main_component_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/fit_ms_params.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/fit_ms_params_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/fix_topology.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/fix_topology_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/fuse_segmentations.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/fuse_segmentations_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/glm_fit.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/glm_fit_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/gtm_seg.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/gtm_seg_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/gtmpvc.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/gtmpvc_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/image_info.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/image_info_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/jacobian.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/jacobian_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/label_2_annot.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/label_2_annot_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/label_2_label.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/label_2_label_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/label_2_vol.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/label_2_vol_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/logan_ref.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/logan_ref_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/lta_convert.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/lta_convert_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/make_average_subject.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/make_average_subject_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/make_surfaces.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/make_surfaces_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/mni_bias_correction.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/mni_bias_correction_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/mp_rto_mni305.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/mp_rto_mni305_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/mr_is_ca_label.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/mr_is_ca_label_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/mr_is_calc.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/mr_is_calc_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/mr_is_combine.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/mr_is_combine_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/mr_is_convert.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/mr_is_convert_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/mr_is_expand.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/mr_is_expand_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/mr_is_inflate.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/mr_is_inflate_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/mri_convert.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/mri_convert_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/mri_coreg.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/mri_coreg_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/mri_fill.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/mri_fill_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/mri_marching_cubes.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/mri_marching_cubes_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/mri_pretess.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/mri_pretess_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/mri_tessellate.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/mri_tessellate_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/mris_preproc.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/mris_preproc_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/mris_preproc_recon_all.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/mris_preproc_recon_all_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/mrtm.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/mrtm2.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/mrtm2_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/mrtm_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/ms__lda.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/ms__lda_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/normalize.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/normalize_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/one_sample_t_test.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/one_sample_t_test_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/paint.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/paint_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/parcellation_stats.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/parcellation_stats_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/parse_dicom_dir.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/parse_dicom_dir_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/recon_all.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/recon_all_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/register.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/register_av_ito_talairach.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/register_av_ito_talairach_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/register_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/relabel_hypointensities.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/relabel_hypointensities_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/remove_intersection.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/remove_intersection_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/remove_neck.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/remove_neck_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/resample.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/resample_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/robust_register.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/robust_register_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/robust_template.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/robust_template_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/sample_to_surface.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/sample_to_surface_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/seg_stats.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/seg_stats_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/seg_stats_recon_all.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/seg_stats_recon_all_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/segment_cc.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/segment_cc_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/segment_wm.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/segment_wm_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/smooth.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/smooth_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/smooth_tessellation.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/smooth_tessellation_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/sphere.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/sphere_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/spherical_average.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/spherical_average_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/surface_2_vol_transform.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/surface_2_vol_transform_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/surface_smooth.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/surface_smooth_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/surface_snapshots.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/surface_snapshots_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/surface_transform.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/surface_transform_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/synthesize_flash.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/synthesize_flash_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/talairach_avi.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/talairach_avi_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/talairach_qc.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/talairach_qc_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/tkregister_2.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/tkregister_2_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/unpack_sdicom_dir.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/unpack_sdicom_dir_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/volume_mask.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/volume_mask_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/watershed_skull_strip.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/watershed_skull_strip_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/accuracy_tester.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/accuracy_tester_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/apply_mask.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/apply_mask_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/apply_topup.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/apply_topup_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/apply_warp.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/apply_warp_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/apply_xfm.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/apply_xfm_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/ar1_image.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/ar1_image_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/av_scale.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/av_scale_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/b0_calc.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/b0_calc_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/bedpostx5.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/bedpostx5_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/bet.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/bet_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/binary_maths.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/binary_maths_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/change_data_type.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/change_data_type_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/classifier.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/classifier_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/cleaner.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/cleaner_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/cluster.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/cluster_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/complex.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/complex_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/contrast_mgr.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/contrast_mgr_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/convert_warp.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/convert_warp_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/convert_xfm.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/convert_xfm_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/copy_geom.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/copy_geom_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/dilate_image.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/dilate_image_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/distance_map.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/distance_map_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/dti_fit.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/dti_fit_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/dual_regression.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/dual_regression_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/eddy.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/eddy_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/eddy_correct.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/eddy_correct_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/eddy_quad.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/eddy_quad_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/epi_de_warp.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/epi_de_warp_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/epi_reg.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/epi_reg_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/erode_image.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/erode_image_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/extract_roi.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/extract_roi_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/fast.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/fast_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/feat.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/feat_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/feat_model.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/feat_model_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/feature_extractor.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/feature_extractor_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/filmgls.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/filmgls_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/filter_regressor.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/filter_regressor_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/find_the_biggest.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/find_the_biggest_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/first.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/first_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/flameo.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/flameo_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/flirt.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/flirt_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/fnirt.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/fnirt_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/fslx_command.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/fslx_command_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/fugue.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/fugue_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/glm.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/glm_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/ica__aroma.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/ica__aroma_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/image_maths.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/image_maths_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/image_meants.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/image_meants_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/image_stats.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/image_stats_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/inv_warp.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/inv_warp_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/isotropic_smooth.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/isotropic_smooth_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/l2_model.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/l2_model_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/level_1_design.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/level_1_design_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/make_dyadic_vectors.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/make_dyadic_vectors_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/maths_command.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/maths_command_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/max_image.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/max_image_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/maxn_image.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/maxn_image_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/mcflirt.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/mcflirt_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/mean_image.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/mean_image_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/median_image.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/median_image_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/melodic.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/melodic_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/merge.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/merge_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/min_image.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/min_image_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/motion_outliers.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/motion_outliers_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/multi_image_maths.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/multi_image_maths_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/multiple_regress_design.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/multiple_regress_design_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/overlay.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/overlay_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/percentile_image.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/percentile_image_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/plot_motion_params.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/plot_motion_params_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/plot_time_series.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/plot_time_series_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/power_spectrum.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/power_spectrum_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/prelude.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/prelude_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/prepare_fieldmap.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/prepare_fieldmap_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/prob_track_x.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/prob_track_x2.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/prob_track_x2_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/prob_track_x_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/proj_thresh.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/proj_thresh_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/randomise.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/randomise_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/reorient_2_std.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/reorient_2_std_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/robust_fov.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/robust_fov_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/sig_loss.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/sig_loss_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/slice.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/slice_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/slice_timer.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/slice_timer_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/slicer.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/slicer_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/smm.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/smm_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/smooth.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/smooth_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/smooth_estimate.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/smooth_estimate_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/spatial_filter.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/spatial_filter_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/split.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/split_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/std_image.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/std_image_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/susan.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/susan_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/swap_dimensions.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/swap_dimensions_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/temporal_filter.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/temporal_filter_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/text_2_vest.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/text_2_vest_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/threshold.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/threshold_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/topup.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/topup_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/tract_skeleton.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/tract_skeleton_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/training.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/training_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/training_set_creator.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/training_set_creator_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/unary_maths.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/unary_maths_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/vec_reg.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/vec_reg_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/vest_2_text.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/vest_2_text_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/warp_points.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/warp_points_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/warp_points_from_std.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/warp_points_from_std_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/warp_points_to_std.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/warp_points_to_std_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/warp_utils.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/warp_utils_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/x_fibres_5.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-fsl/x_fibres_5_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-meshfix/mesh_fix.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-meshfix/mesh_fix_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-minc/average.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-minc/average_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-minc/b_box.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-minc/b_box_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-minc/beast.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-minc/beast_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-minc/best_lin_reg.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-minc/best_lin_reg_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-minc/big_average.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-minc/big_average_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-minc/blob.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-minc/blob_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-minc/blur.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-minc/blur_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-minc/calc.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-minc/calc_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-minc/convert.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-minc/convert_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-minc/copy.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-minc/copy_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-minc/dump.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-minc/dump_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-minc/extract.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-minc/extract_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-minc/gennlxfm.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-minc/gennlxfm_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-minc/math.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-minc/math_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-minc/nlp_fit.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-minc/nlp_fit_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-minc/norm.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-minc/norm_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-minc/pik.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-minc/pik_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-minc/resample.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-minc/resample_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-minc/reshape.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-minc/reshape_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-minc/to_ecat.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-minc/to_ecat_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-minc/to_raw.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-minc/to_raw_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-minc/vol_symm.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-minc/vol_symm_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-minc/volcentre.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-minc/volcentre_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-minc/voliso.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-minc/voliso_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-minc/volpad.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-minc/volpad_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-minc/xfm_avg.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-minc/xfm_avg_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-minc/xfm_concat.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-minc/xfm_concat_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-minc/xfm_invert.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-minc/xfm_invert_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-mipav/jist_brain_mgdm_segmentation.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-mipav/jist_brain_mgdm_segmentation_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-mipav/jist_brain_mp_2rage_dura_estimation.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-mipav/jist_brain_mp_2rage_dura_estimation_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-mipav/jist_brain_mp_2rage_skull_stripping.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-mipav/jist_brain_mp_2rage_skull_stripping_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-mipav/jist_brain_partial_volume_filter.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-mipav/jist_brain_partial_volume_filter_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-mipav/jist_cortex_surface_mesh_inflation.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-mipav/jist_cortex_surface_mesh_inflation_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-mipav/jist_intensity_mp_2rage_masking.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-mipav/jist_intensity_mp_2rage_masking_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-mipav/jist_laminar_profile_calculator.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-mipav/jist_laminar_profile_calculator_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-mipav/jist_laminar_profile_geometry.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-mipav/jist_laminar_profile_geometry_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-mipav/jist_laminar_profile_sampling.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-mipav/jist_laminar_profile_sampling_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-mipav/jist_laminar_roi_averaging.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-mipav/jist_laminar_roi_averaging_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-mipav/jist_laminar_volumetric_layering.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-mipav/jist_laminar_volumetric_layering_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_image_calculator.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_image_calculator_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_lesion_toads.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_lesion_toads_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_mipav_reorient.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_mipav_reorient_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_n3.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_n3_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_spectre2010.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_spectre2010_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_threshold_to_binary_mask.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_threshold_to_binary_mask_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-mipav/random_vol.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-mipav/random_vol_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-niftyfit/dwi_tool.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-niftyfit/dwi_tool_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-niftyfit/fit_asl.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-niftyfit/fit_asl_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-niftyfit/fit_dwi.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-niftyfit/fit_dwi_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-niftyfit/fit_qt_1.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-niftyfit/fit_qt_1_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-niftyreg/reg_aladin.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-niftyreg/reg_aladin_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-niftyreg/reg_average.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-niftyreg/reg_average_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-niftyreg/reg_f3d.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-niftyreg/reg_f3d_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-niftyreg/reg_jacobian.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-niftyreg/reg_jacobian_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-niftyreg/reg_measure.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-niftyreg/reg_measure_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-niftyreg/reg_resample.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-niftyreg/reg_resample_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-niftyreg/reg_tools.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-niftyreg/reg_tools_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-niftyreg/reg_transform.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-niftyreg/reg_transform_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-niftyseg/binary_maths.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-niftyseg/binary_maths_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-niftyseg/binary_maths_integer.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-niftyseg/binary_maths_integer_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-niftyseg/binary_stats.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-niftyseg/binary_stats_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-niftyseg/calc_top_ncc.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-niftyseg/calc_top_ncc_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-niftyseg/em.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-niftyseg/em_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-niftyseg/fill_lesions.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-niftyseg/fill_lesions_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-niftyseg/label_fusion.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-niftyseg/label_fusion_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-niftyseg/maths_command.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-niftyseg/maths_command_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-niftyseg/merge.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-niftyseg/merge_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-niftyseg/patch_match.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-niftyseg/patch_match_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-niftyseg/stats_command.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-niftyseg/stats_command_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-niftyseg/tuple_maths.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-niftyseg/tuple_maths_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-niftyseg/unary_maths.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-niftyseg/unary_maths_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-niftyseg/unary_stats.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-niftyseg/unary_stats_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-nilearn/nilearn_base_interface.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-nilearn/nilearn_base_interface_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-nilearn/signal_extraction.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-nilearn/signal_extraction_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-nitime/coherence_analyzer.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-nitime/coherence_analyzer_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-petpvc/petpvc.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-petpvc/petpvc_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-quickshear/quickshear.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-quickshear/quickshear_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-robex/robex_segment.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-robex/robex_segment_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/binary_mask_editor_based_on_landmarks.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/binary_mask_editor_based_on_landmarks_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_align_msp.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_align_msp_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_clip_inferior.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_clip_inferior_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_constellation_detector.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_constellation_detector_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_constellation_modeler.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_constellation_modeler_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_create_label_map_from_probability_maps.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_create_label_map_from_probability_maps_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_cut.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_cut_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_demon_warp.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_demon_warp_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_eye_detector.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_eye_detector_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_fit.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_fit_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_initialized_control_points.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_initialized_control_points_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_landmark_initializer.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_landmark_initializer_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_linear_modeler_epca.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_linear_modeler_epca_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_lmk_transform.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_lmk_transform_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_multi_staple.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_multi_staple_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_mush.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_mush_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_posterior_to_continuous_class.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_posterior_to_continuous_class_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_resample.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_resample_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_resize.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_resize_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_snap_shot_writer.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_snap_shot_writer_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_talairach.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_talairach_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_talairach_mask.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_talairach_mask_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_transform_convert.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_transform_convert_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_transform_from_fiducials.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_transform_from_fiducials_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_trim_foreground_in_direction.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_trim_foreground_in_direction_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/brainsabc.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/brainsabc_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/brainsroi_auto.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/brainsroi_auto_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/canny_edge.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/canny_edge_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/canny_segmentation_level_set_image_filter.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/canny_segmentation_level_set_image_filter_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/clean_up_overlap_labels.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/clean_up_overlap_labels_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/compare_tract_inclusion.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/compare_tract_inclusion_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/dilate_image.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/dilate_image_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/dilate_mask.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/dilate_mask_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/distance_maps.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/distance_maps_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/dtiaverage.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/dtiaverage_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/dtiestim.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/dtiestim_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/dtiprocess.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/dtiprocess_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/dump_binary_training_vectors.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/dump_binary_training_vectors_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/dwi_compare.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/dwi_compare_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/dwi_convert.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/dwi_convert_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/dwi_simple_compare.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/dwi_simple_compare_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/erode_image.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/erode_image_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/eslr.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/eslr_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/extract_nrrd_vector_index.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/extract_nrrd_vector_index_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/fcsv_to_hdf_5.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/fcsv_to_hdf_5_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/fiberprocess.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/fiberprocess_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/fiberstats.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/fiberstats_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/fibertrack.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/fibertrack_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/find_center_of_brain.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/find_center_of_brain_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/flipped_difference.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/flipped_difference_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/generate_average_lmk_file.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/generate_average_lmk_file_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/generate_brain_clipped_image.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/generate_brain_clipped_image_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/generate_csf_clipped_from_classified_image.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/generate_csf_clipped_from_classified_image_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/generate_edge_map_image.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/generate_edge_map_image_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/generate_label_map_from_probability_map.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/generate_label_map_from_probability_map_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/generate_pure_plug_mask.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/generate_pure_plug_mask_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/generate_summed_gradient_image.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/generate_summed_gradient_image_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/generate_test_image.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/generate_test_image_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/gradient_anisotropic_diffusion_image_filter.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/gradient_anisotropic_diffusion_image_filter_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_anisotropy_map.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_anisotropy_map_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_average_bvalues.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_average_bvalues_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_clip_anisotropy.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_clip_anisotropy_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_co_reg_anatomy.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_co_reg_anatomy_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_concat_dwi.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_concat_dwi_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_copy_image_orientation.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_copy_image_orientation_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_coreg_bvalues.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_coreg_bvalues_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_cost_fast_marching.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_cost_fast_marching_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_create_guide_fiber.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_create_guide_fiber_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_fast_marching_tracking.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_fast_marching_tracking_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_fiber_tracking.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_fiber_tracking_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_image_conformity.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_image_conformity_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_invert_b_spline_transform.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_invert_b_spline_transform_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_invert_displacement_field.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_invert_displacement_field_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_invert_rigid_transform.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_invert_rigid_transform_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_resample_anisotropy.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_resample_anisotropy_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_resample_b0.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_resample_b0_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_resample_code_image.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_resample_code_image_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_resample_dwi_in_place.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_resample_dwi_in_place_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_resample_fibers.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_resample_fibers_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_tensor.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_tensor_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_transform_to_displacement_field.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_transform_to_displacement_field_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/hammer_attribute_creator.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/hammer_attribute_creator_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/histogram_matching_filter.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/histogram_matching_filter_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/image_region_plotter.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/image_region_plotter_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/insert_mid_acp_cpoint.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/insert_mid_acp_cpoint_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/joint_histogram.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/joint_histogram_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/landmarks_compare.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/landmarks_compare_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/landmarks_constellation_aligner.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/landmarks_constellation_aligner_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/landmarks_constellation_weights.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/landmarks_constellation_weights_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/maxcurvature.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/maxcurvature_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/neighborhood_mean.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/neighborhood_mean_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/neighborhood_median.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/neighborhood_median_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/scalartransform.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/scalartransform_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/shuffle_vectors_module.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/shuffle_vectors_module_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/similarity_index.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/similarity_index_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/spherical_coordinate_generation.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/spherical_coordinate_generation_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/staple_analysis.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/staple_analysis_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/texture_from_noise_image_filter.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/texture_from_noise_image_filter_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/texture_measure_filter.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/texture_measure_filter_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/ukf_tractography.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/ukf_tractography_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/unbiased_non_local_means.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/unbiased_non_local_means_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/vbrains_demon_warp.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-semtools/vbrains_demon_warp_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/acpc_transform.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/acpc_transform_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/add_scalar_volumes.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/add_scalar_volumes_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/affine_registration.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/affine_registration_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/b_spline_deformable_registration.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/b_spline_deformable_registration_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/b_spline_to_deformation_field.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/b_spline_to_deformation_field_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/brains_demon_warp.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/brains_demon_warp_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/brains_fit.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/brains_fit_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/brains_resample.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/brains_resample_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/brainsroi_auto.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/brainsroi_auto_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/cast_scalar_volume.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/cast_scalar_volume_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/checker_board_filter.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/checker_board_filter_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/curvature_anisotropic_diffusion.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/curvature_anisotropic_diffusion_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/dicom_to_nrrd_converter.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/dicom_to_nrrd_converter_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/diffusion_tensor_scalar_measurements.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/diffusion_tensor_scalar_measurements_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/diffusion_weighted_volume_masking.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/diffusion_weighted_volume_masking_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/dt_iexport.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/dt_iexport_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/dt_iimport.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/dt_iimport_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/dwi_joint_rician_lmmse_filter.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/dwi_joint_rician_lmmse_filter_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/dwi_rician_lmmse_filter.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/dwi_rician_lmmse_filter_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/dwi_to_dti_estimation.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/dwi_to_dti_estimation_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/dwi_unbiased_non_local_means_filter.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/dwi_unbiased_non_local_means_filter_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/em_segment_command_line.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/em_segment_command_line_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/em_segment_transform_to_new_format.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/em_segment_transform_to_new_format_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/expert_automated_registration.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/expert_automated_registration_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/extract_skeleton.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/extract_skeleton_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/fiducial_registration.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/fiducial_registration_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/gaussian_blur_image_filter.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/gaussian_blur_image_filter_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/gradient_anisotropic_diffusion.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/gradient_anisotropic_diffusion_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/grayscale_fill_hole_image_filter.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/grayscale_fill_hole_image_filter_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/grayscale_grind_peak_image_filter.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/grayscale_grind_peak_image_filter_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/grayscale_model_maker.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/grayscale_model_maker_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/histogram_matching.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/histogram_matching_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/image_label_combine.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/image_label_combine_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/intensity_difference_metric.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/intensity_difference_metric_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/label_map_smoothing.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/label_map_smoothing_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/linear_registration.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/linear_registration_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/mask_scalar_volume.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/mask_scalar_volume_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/median_image_filter.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/median_image_filter_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/merge_models.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/merge_models_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/model_maker.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/model_maker_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/model_to_label_map.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/model_to_label_map_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/multi_resolution_affine_registration.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/multi_resolution_affine_registration_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/multiply_scalar_volumes.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/multiply_scalar_volumes_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/n4itk_bias_field_correction.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/n4itk_bias_field_correction_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/orient_scalar_volume.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/orient_scalar_volume_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/otsu_threshold_image_filter.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/otsu_threshold_image_filter_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/otsu_threshold_segmentation.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/otsu_threshold_segmentation_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/pet_standard_uptake_value_computation.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/pet_standard_uptake_value_computation_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/probe_volume_with_model.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/probe_volume_with_model_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/resample_dti_volume.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/resample_dti_volume_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/resample_scalar_vector_dwi_volume.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/resample_scalar_vector_dwi_volume_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/resample_scalar_volume.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/resample_scalar_volume_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/rigid_registration.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/rigid_registration_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/robust_statistics_segmenter.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/robust_statistics_segmenter_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/simple_region_growing_segmentation.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/simple_region_growing_segmentation_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/subtract_scalar_volumes.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/subtract_scalar_volumes_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/threshold_scalar_volume.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/threshold_scalar_volume_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/tractography_label_map_seeding.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/tractography_label_map_seeding_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/vbrains_demon_warp.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/vbrains_demon_warp_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/voting_binary_hole_filling_image_filter.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-slicer/voting_binary_hole_filling_image_filter_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-spm/analyze_2nii.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-spm/analyze_2nii_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-spm/apply_deformations.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-spm/apply_deformations_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-spm/apply_inverse_deformation.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-spm/apply_inverse_deformation_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-spm/apply_transform.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-spm/apply_transform_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-spm/apply_vdm.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-spm/apply_vdm_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-spm/calc_coreg_affine.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-spm/calc_coreg_affine_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-spm/coregister.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-spm/coregister_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-spm/create_warped.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-spm/create_warped_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-spm/dartel.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-spm/dartel_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-spm/dartel_norm_2mni.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-spm/dartel_norm_2mni_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-spm/dicom_import.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-spm/dicom_import_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-spm/estimate_contrast.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-spm/estimate_contrast_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-spm/estimate_model.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-spm/estimate_model_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-spm/factorial_design.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-spm/factorial_design_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-spm/field_map.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-spm/field_map_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-spm/level_1_design.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-spm/level_1_design_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-spm/multi_channel_new_segment.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-spm/multi_channel_new_segment_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-spm/multiple_regression_design.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-spm/multiple_regression_design_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-spm/new_segment.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-spm/new_segment_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-spm/normalize.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-spm/normalize_12.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-spm/normalize_12_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-spm/normalize_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-spm/one_sample_t_test_design.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-spm/one_sample_t_test_design_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-spm/paired_t_test_design.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-spm/paired_t_test_design_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-spm/realign.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-spm/realign_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-spm/realign_unwarp.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-spm/realign_unwarp_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-spm/reslice.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-spm/reslice_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-spm/reslice_to_reference.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-spm/reslice_to_reference_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-spm/segment.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-spm/segment_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-spm/slice_timing.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-spm/slice_timing_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-spm/smooth.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-spm/smooth_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-spm/threshold.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-spm/threshold_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-spm/threshold_statistics.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-spm/threshold_statistics_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-spm/two_sample_t_test_design.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-spm/two_sample_t_test_design_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-spm/vbm_segment.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-spm/vbm_segment_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-vista/vnifti_2_image.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-vista/vnifti_2_image_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-vista/vto_mat.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-vista/vto_mat_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-workbench/cifti_smooth.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-workbench/cifti_smooth_callables.py
 create mode 100644 example-specs/task/nipype_internal/pydra-workbench/metric_resample.yaml
 create mode 100644 example-specs/task/nipype_internal/pydra-workbench/metric_resample_callables.py

diff --git a/conftest.py b/conftest.py
index 1757e882..0e1fb2e5 100644
--- a/conftest.py
+++ b/conftest.py
@@ -19,12 +19,12 @@ def gen_test_conftest():
 
 @pytest.fixture(
     params=[
-        str(p.relative_to(EXAMPLE_TASKS_DIR)).replace("/", "-")[:-5]
+        str(p.relative_to(EXAMPLE_TASKS_DIR)).replace("/", "__")[:-5]
         for p in (EXAMPLE_TASKS_DIR).glob("**/*.yaml")
     ]
 )
 def task_spec_file(request):
-    return EXAMPLE_TASKS_DIR.joinpath(*request.param.split("-")).with_suffix(".yaml")
+    return EXAMPLE_TASKS_DIR.joinpath(*request.param.split("__")).with_suffix(".yaml")
 
 
 @pytest.fixture(params=[str(p.stem) for p in EXAMPLE_WORKFLOWS_DIR.glob("*.yaml")])
diff --git a/example-specs/task/ghislains/bet.yaml b/example-specs/task/ghislains/bet.yaml
new file mode 100644
index 00000000..d4ff98bc
--- /dev/null
+++ b/example-specs/task/ghislains/bet.yaml
@@ -0,0 +1,217 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.preprocess.BET' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# FSL BET wrapper for skull stripping
+# 
+#     For complete details, see the `BET Documentation.
+#     <https://fsl.fmrib.ox.ac.uk/fsl/fslwiki/BET/UserGuide>`_
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import fsl
+#     >>> btr = fsl.BET()
+#     >>> btr.inputs.in_file = 'structural.nii'
+#     >>> btr.inputs.frac = 0.7
+#     >>> btr.inputs.out_file = 'brain_anat.nii'
+#     >>> btr.cmdline
+#     'bet structural.nii brain_anat.nii -f 0.70'
+#     >>> res = btr.run() # doctest: +SKIP
+# 
+#     
+task_name: BET
+nipype_name: BET
+nipype_module: nipype.interfaces.fsl.preprocess
+inputs:
+  omit:
+  - surfaces
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+    in_file: input_image
+    out_file: output_image
+    outline: save_brain_surface_outline
+    mask: save_brain_mask
+    skull: save_skull_image
+    mesh: save_brain_surface_mesh
+    frac: fractional_intensity_threshold
+    radius: head_radius
+    center: center_of_gravity
+    threshold: apply_thresholding
+    robust: with_robust_brain_center_estimation
+    remove_eyes: with_eye_and_optic_nerve_cleanup
+    padding: with_small_fov_in_z
+    functional: with_4d_fmri_data
+    reduce_bias: with_bias_field_and_neck_cleanup
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: input file to skull strip
+    t2_guided: generic/file
+    # type=file|default=<undefined>: as with creating surfaces, when also feeding in non-brain-extracted T2 (includes registrations)
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+    mask_file: brain_mask
+    outline_file: brain_surface_outline
+    
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: medimage/nifti1
+    # type=file: path/name of skullstripped file (if generated)
+    # type=file|default=<undefined>: name of output skull stripped image
+    mask_file: generic/file
+    # type=file: path/name of binary brain mask (if generated)
+    outline_file: generic/file
+    # type=file: path/name of outline file (if generated)
+    meshfile: generic/file
+    # type=file: path/name of vtk mesh file (if generated)
+    inskull_mask_file: generic/file
+    # type=file: path/name of inskull mask (if generated)
+    inskull_mesh_file: generic/file
+    # type=file: path/name of inskull mesh outline (if generated)
+    outskull_mask_file: generic/file
+    # type=file: path/name of outskull mask (if generated)
+    outskull_mesh_file: generic/file
+    # type=file: path/name of outskull mesh outline (if generated)
+    outskin_mask_file: generic/file
+    # type=file: path/name of outskin mask (if generated)
+    outskin_mesh_file: generic/file
+    # type=file: path/name of outskin mesh outline (if generated)
+    skull_mask_file: generic/file
+    # type=file: path/name of skull mask (if generated)
+    skull_file: generic/file
+    # type=file: path/name of skull file (if generated)
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: '"brain_anat.nii"'
+    # type=file: path/name of skullstripped file (if generated)
+    # type=file|default=<undefined>: name of output skull stripped image
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to skull strip
+    out_file:
+    # type=file: path/name of skullstripped file (if generated)
+    # type=file|default=<undefined>: name of output skull stripped image
+    outline:
+    # type=bool|default=False: create surface outline image
+    mask:
+    # type=bool|default=False: create binary mask image
+    skull:
+    # type=bool|default=False: create skull image
+    no_output:
+    # type=bool|default=False: Don't generate segmented output
+    frac:
+    # type=float|default=0.0: fractional intensity threshold
+    vertical_gradient:
+    # type=float|default=0.0: vertical gradient in fractional intensity threshold (-1, 1)
+    radius:
+    # type=int|default=0: head radius
+    center:
+    # type=list|default=[]: center of gravity in voxels
+    threshold:
+    # type=bool|default=False: apply thresholding to segmented brain image and mask
+    mesh:
+    # type=bool|default=False: generate a vtk mesh brain surface
+    robust:
+    # type=bool|default=False: robust brain centre estimation (iterates BET several times)
+    padding:
+    # type=bool|default=False: improve BET if FOV is very small in Z (by temporarily padding end slices)
+    remove_eyes:
+    # type=bool|default=False: eye & optic nerve cleanup (can be useful in SIENA)
+    surfaces:
+    # type=bool|default=False: run bet2 and then betsurf to get additional skull and scalp surfaces (includes registrations)
+    t2_guided:
+    # type=file|default=<undefined>: as with creating surfaces, when also feeding in non-brain-extracted T2 (includes registrations)
+    functional:
+    # type=bool|default=False: apply to 4D fMRI data
+    reduce_bias:
+    # type=bool|default=False: bias field and neck cleanup
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to skull strip
+    frac: '0.7'
+    # type=float|default=0.0: fractional intensity threshold
+    out_file: '"brain_anat.nii"'
+    # type=file: path/name of skullstripped file (if generated)
+    # type=file|default=<undefined>: name of output skull stripped image
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: bet structural.nii brain_anat.nii -f 0.70
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: input file to skull strip
+    frac: '0.7'
+    # type=float|default=0.0: fractional intensity threshold
+    out_file: '"brain_anat.nii"'
+    # type=file: path/name of skullstripped file (if generated)
+    # type=file|default=<undefined>: name of output skull stripped image
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-afni/a_boverlap.yaml b/example-specs/task/nipype_internal/pydra-afni/a_boverlap.yaml
new file mode 100644
index 00000000..03a86944
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/a_boverlap.yaml
@@ -0,0 +1,153 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.afni.utils.ABoverlap' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Output (to screen) is a count of various things about how
+#     the automasks of datasets A and B overlap or don't overlap.
+# 
+#     For complete details, see the `3dABoverlap Documentation.
+#     <https://afni.nimh.nih.gov/pub/dist/doc/program_help/3dABoverlap.html>`_
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import afni
+#     >>> aboverlap = afni.ABoverlap()
+#     >>> aboverlap.inputs.in_file_a = 'functional.nii'
+#     >>> aboverlap.inputs.in_file_b = 'structural.nii'
+#     >>> aboverlap.inputs.out_file =  'out.mask_ae_overlap.txt'
+#     >>> aboverlap.cmdline
+#     '3dABoverlap functional.nii structural.nii  |& tee out.mask_ae_overlap.txt'
+#     >>> res = aboverlap.run()  # doctest: +SKIP
+# 
+#     
+task_name: ABoverlap
+nipype_name: ABoverlap
+nipype_module: nipype.interfaces.afni.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file_a: medimage/nifti1
+    # type=file|default=<undefined>: input file A
+    in_file_b: medimage/nifti1
+    # type=file|default=<undefined>: input file B
+    out_file: text/text-file
+    # type=file: output file
+    # type=file|default=<undefined>: collect output to a file
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: text/text-file
+    # type=file: output file
+    # type=file|default=<undefined>: collect output to a file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file_a:
+    # type=file|default=<undefined>: input file A
+    in_file_b:
+    # type=file|default=<undefined>: input file B
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: collect output to a file
+    no_automask:
+    # type=bool|default=False: consider input datasets as masks
+    quiet:
+    # type=bool|default=False: be as quiet as possible (without being entirely mute)
+    verb:
+    # type=bool|default=False: print out some progress reports (to stderr)
+    num_threads:
+    # type=int|default=1: set number of threads
+    outputtype:
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file_a:
+    # type=file|default=<undefined>: input file A
+    in_file_b:
+    # type=file|default=<undefined>: input file B
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: collect output to a file
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: 3dABoverlap functional.nii structural.nii |& tee out.mask_ae_overlap.txt
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file_a:
+    # type=file|default=<undefined>: input file A
+    in_file_b:
+    # type=file|default=<undefined>: input file B
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: collect output to a file
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-afni/a_boverlap_callables.py b/example-specs/task/nipype_internal/pydra-afni/a_boverlap_callables.py
new file mode 100644
index 00000000..d93ad85b
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/a_boverlap_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in ABoverlap.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-afni/afn_ito_nifti.yaml b/example-specs/task/nipype_internal/pydra-afni/afn_ito_nifti.yaml
new file mode 100644
index 00000000..527707b8
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/afn_ito_nifti.yaml
@@ -0,0 +1,146 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.afni.utils.AFNItoNIFTI' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Converts AFNI format files to NIFTI format. This can also convert 2D or
+#     1D data, which you can numpy.squeeze() to remove extra dimensions.
+# 
+#     For complete details, see the `3dAFNItoNIFTI Documentation.
+#     <https://afni.nimh.nih.gov/pub/dist/doc/program_help/3dAFNItoNIFTI.html>`_
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import afni
+#     >>> a2n = afni.AFNItoNIFTI()
+#     >>> a2n.inputs.in_file = 'afni_output.3D'
+#     >>> a2n.inputs.out_file =  'afni_output.nii'
+#     >>> a2n.cmdline
+#     '3dAFNItoNIFTI -prefix afni_output.nii afni_output.3D'
+#     >>> res = a2n.run()  # doctest: +SKIP
+# 
+#     
+task_name: AFNItoNIFTI
+nipype_name: AFNItoNIFTI
+nipype_module: nipype.interfaces.afni.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage-afni/threed
+    # type=file|default=<undefined>: input file to 3dAFNItoNIFTI
+    out_file: medimage/nifti1
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: medimage/nifti1
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to 3dAFNItoNIFTI
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+    pure:
+    # type=bool|default=False: Do NOT write an AFNI extension field into the output file. Only use this option if needed. You can also use the 'nifti_tool' program to strip extensions from a file.
+    denote:
+    # type=bool|default=False: When writing the AFNI extension field, remove text notes that might contain subject identifying information.
+    oldid:
+    # type=bool|default=False: Give the new dataset the input datasets AFNI ID code.
+    newid:
+    # type=bool|default=False: Give the new dataset a new AFNI ID code, to distinguish it from the input dataset.
+    num_threads:
+    # type=int|default=1: set number of threads
+    outputtype:
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to 3dAFNItoNIFTI
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: 3dAFNItoNIFTI -prefix afni_output.nii afni_output.3D
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: input file to 3dAFNItoNIFTI
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-afni/afn_ito_nifti_callables.py b/example-specs/task/nipype_internal/pydra-afni/afn_ito_nifti_callables.py
new file mode 100644
index 00000000..b9cccca4
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/afn_ito_nifti_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in AFNItoNIFTI.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-afni/align_epi_anat_py.yaml b/example-specs/task/nipype_internal/pydra-afni/align_epi_anat_py.yaml
new file mode 100644
index 00000000..73884358
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/align_epi_anat_py.yaml
@@ -0,0 +1,221 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.afni.preprocess.AlignEpiAnatPy' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Align EPI to anatomical datasets or vice versa.
+# 
+#     This Python script computes the alignment between two datasets, typically
+#     an EPI and an anatomical structural dataset, and applies the resulting
+#     transformation to one or the other to bring them into alignment.
+# 
+#     This script computes the transforms needed to align EPI and
+#     anatomical datasets using a cost function designed for this purpose. The
+#     script combines multiple transformations, thereby minimizing the amount of
+#     interpolation applied to the data.
+# 
+#     Basic Usage::
+# 
+#         align_epi_anat.py -anat anat+orig -epi epi+orig -epi_base 5
+# 
+#     The user must provide :abbr:`EPI (echo-planar imaging)` and anatomical datasets
+#     and specify the EPI sub-brick to use as a base in the alignment.
+# 
+#     Internally, the script always aligns the anatomical to the EPI dataset,
+#     and the resulting transformation is saved to a 1D file.
+#     As a user option, the inverse of this transformation may be applied to the
+#     EPI dataset in order to align it to the anatomical data instead.
+# 
+#     This program generates several kinds of output in the form of datasets
+#     and transformation matrices which can be applied to other datasets if
+#     needed. Time-series volume registration, oblique data transformations and
+#     Talairach (standard template) transformations will be combined as needed
+#     and requested (with options to turn on and off each of the steps) in
+#     order to create the aligned datasets.
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import afni
+#     >>> al_ea = afni.AlignEpiAnatPy()
+#     >>> al_ea.inputs.anat = "structural.nii"
+#     >>> al_ea.inputs.in_file = "functional.nii"
+#     >>> al_ea.inputs.epi_base = 0
+#     >>> al_ea.inputs.epi_strip = '3dAutomask'
+#     >>> al_ea.inputs.volreg = 'off'
+#     >>> al_ea.inputs.tshift = 'off'
+#     >>> al_ea.inputs.save_skullstrip = True
+#     >>> al_ea.cmdline # doctest: +ELLIPSIS
+#     'python2 ...align_epi_anat.py -anat structural.nii -epi_base 0 -epi_strip 3dAutomask -epi functional.nii -save_skullstrip -suffix _al -tshift off -volreg off'
+#     >>> res = allineate.run()  # doctest: +SKIP
+# 
+#     See Also
+#     --------
+#     For complete details, see the `align_epi_anat.py documentation.
+#     <https://afni.nimh.nih.gov/pub/dist/doc/program_help/align_epi_anat.py.html>`__.
+# 
+#     
+task_name: AlignEpiAnatPy
+nipype_name: AlignEpiAnatPy
+nipype_module: nipype.interfaces.afni.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: EPI dataset to align
+    anat: medimage/nifti1
+    # type=file|default=<undefined>: name of structural dataset
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    anat_al_orig: generic/file
+    # type=file: A version of the anatomy that is aligned to the EPI
+    epi_al_orig: generic/file
+    # type=file: A version of the EPI dataset aligned to the anatomy
+    epi_tlrc_al: generic/file
+    # type=file: A version of the EPI dataset aligned to a standard template
+    anat_al_mat: generic/file
+    # type=file: matrix to align anatomy to the EPI
+    epi_al_mat: generic/file
+    # type=file: matrix to align EPI to anatomy
+    epi_vr_al_mat: generic/file
+    # type=file: matrix to volume register EPI
+    epi_reg_al_mat: generic/file
+    # type=file: matrix to volume register and align epi to anatomy
+    epi_al_tlrc_mat: generic/file
+    # type=file: matrix to volume register and align epito anatomy and put into standard space
+    epi_vr_motion: generic/file
+    # type=file: motion parameters from EPI time-seriesregistration (tsh included in name if slicetiming correction is also included).
+    skullstrip: generic/file
+    # type=file: skull-stripped (not aligned) volume
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: EPI dataset to align
+    anat:
+    # type=file|default=<undefined>: name of structural dataset
+    epi_base:
+    # type=traitcompound|default=None: the epi base used in alignmentshould be one of (0/mean/median/max/subbrick#)
+    anat2epi:
+    # type=bool|default=False: align anatomical to EPI dataset (default)
+    epi2anat:
+    # type=bool|default=False: align EPI to anatomical dataset
+    save_skullstrip:
+    # type=bool|default=False: save skull-stripped (not aligned)
+    suffix:
+    # type=str|default='_al': append suffix to the original anat/epi dataset to usein the resulting dataset names (default is "_al")
+    epi_strip:
+    # type=enum|default='3dSkullStrip'|allowed['3dAutomask','3dSkullStrip','None']: method to mask brain in EPI datashould be one of[3dSkullStrip]/3dAutomask/None)
+    volreg:
+    # type=enum|default='on'|allowed['off','on']: do volume registration on EPI dataset before alignmentshould be 'on' or 'off', defaults to 'on'
+    tshift:
+    # type=enum|default='on'|allowed['off','on']: do time shifting of EPI dataset before alignmentshould be 'on' or 'off', defaults to 'on'
+    outputtype:
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+    py27_path:
+    # type=traitcompound|default='python2': 
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    anat:
+    # type=file|default=<undefined>: name of structural dataset
+    in_file:
+    # type=file|default=<undefined>: EPI dataset to align
+    epi_base: '0'
+    # type=traitcompound|default=None: the epi base used in alignmentshould be one of (0/mean/median/max/subbrick#)
+    epi_strip: '"3dAutomask"'
+    # type=enum|default='3dSkullStrip'|allowed['3dAutomask','3dSkullStrip','None']: method to mask brain in EPI datashould be one of[3dSkullStrip]/3dAutomask/None)
+    volreg: '"off"'
+    # type=enum|default='on'|allowed['off','on']: do volume registration on EPI dataset before alignmentshould be 'on' or 'off', defaults to 'on'
+    tshift: '"off"'
+    # type=enum|default='on'|allowed['off','on']: do time shifting of EPI dataset before alignmentshould be 'on' or 'off', defaults to 'on'
+    save_skullstrip: 'True'
+    # type=bool|default=False: save skull-stripped (not aligned)
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: python2 ...align_epi_anat.py -anat structural.nii -epi_base 0 -epi_strip 3dAutomask -epi functional.nii -save_skullstrip -suffix _al -tshift off -volreg off
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    anat:
+    # type=file|default=<undefined>: name of structural dataset
+    in_file:
+    # type=file|default=<undefined>: EPI dataset to align
+    epi_base: '0'
+    # type=traitcompound|default=None: the epi base used in alignmentshould be one of (0/mean/median/max/subbrick#)
+    epi_strip: '"3dAutomask"'
+    # type=enum|default='3dSkullStrip'|allowed['3dAutomask','3dSkullStrip','None']: method to mask brain in EPI datashould be one of[3dSkullStrip]/3dAutomask/None)
+    volreg: '"off"'
+    # type=enum|default='on'|allowed['off','on']: do volume registration on EPI dataset before alignmentshould be 'on' or 'off', defaults to 'on'
+    tshift: '"off"'
+    # type=enum|default='on'|allowed['off','on']: do time shifting of EPI dataset before alignmentshould be 'on' or 'off', defaults to 'on'
+    save_skullstrip: 'True'
+    # type=bool|default=False: save skull-stripped (not aligned)
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-afni/align_epi_anat_py_callables.py b/example-specs/task/nipype_internal/pydra-afni/align_epi_anat_py_callables.py
new file mode 100644
index 00000000..0a532bcc
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/align_epi_anat_py_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in AlignEpiAnatPy.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-afni/allineate.yaml b/example-specs/task/nipype_internal/pydra-afni/allineate.yaml
new file mode 100644
index 00000000..0f25b762
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/allineate.yaml
@@ -0,0 +1,377 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.afni.preprocess.Allineate' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Program to align one dataset (the 'source') to a base dataset
+# 
+#     For complete details, see the `3dAllineate Documentation.
+#     <https://afni.nimh.nih.gov/pub/dist/doc/program_help/3dAllineate.html>`_
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import afni
+#     >>> allineate = afni.Allineate()
+#     >>> allineate.inputs.in_file = 'functional.nii'
+#     >>> allineate.inputs.out_file = 'functional_allineate.nii'
+#     >>> allineate.inputs.in_matrix = 'cmatrix.mat'
+#     >>> allineate.cmdline
+#     '3dAllineate -source functional.nii -prefix functional_allineate.nii -1Dmatrix_apply cmatrix.mat'
+#     >>> res = allineate.run()  # doctest: +SKIP
+# 
+#     >>> allineate = afni.Allineate()
+#     >>> allineate.inputs.in_file = 'functional.nii'
+#     >>> allineate.inputs.reference = 'structural.nii'
+#     >>> allineate.inputs.allcostx = 'out.allcostX.txt'
+#     >>> allineate.cmdline
+#     '3dAllineate -source functional.nii -base structural.nii -allcostx |& tee out.allcostX.txt'
+#     >>> res = allineate.run()  # doctest: +SKIP
+# 
+#     >>> allineate = afni.Allineate()
+#     >>> allineate.inputs.in_file = 'functional.nii'
+#     >>> allineate.inputs.reference = 'structural.nii'
+#     >>> allineate.inputs.nwarp_fixmot = ['X', 'Y']
+#     >>> allineate.cmdline
+#     '3dAllineate -source functional.nii -nwarp_fixmotX -nwarp_fixmotY -prefix functional_allineate -base structural.nii'
+#     >>> res = allineate.run()  # doctest: +SKIP
+#     
+task_name: Allineate
+nipype_name: Allineate
+nipype_module: nipype.interfaces.afni.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: input file to 3dAllineate
+    reference: medimage/nifti1
+    # type=file|default=<undefined>: file to be used as reference, the first volume will be used if not given the reference will be the first volume of in_file.
+    out_file: medimage/nifti1
+    # type=file: output image file name
+    # type=file|default=<undefined>: output file from 3dAllineate
+    out_param_file: generic/file
+    # type=file: warp parameters
+    # type=file|default=<undefined>: Save the warp parameters in ASCII (.1D) format.
+    in_param_file: generic/file
+    # type=file|default=<undefined>: Read warp parameters from file and apply them to the source dataset, and produce a new dataset
+    out_matrix: generic/file
+    # type=file: matrix to align input file
+    # type=file|default=<undefined>: Save the transformation matrix for each volume.
+    in_matrix: datascience/text-matrix
+    # type=file|default=<undefined>: matrix to align input file
+    allcostx: text/text-file
+    # type=file: Compute and print ALL available cost functionals for the un-warped inputs
+    # type=file|default=<undefined>: Compute and print ALL available cost functionals for the un-warped inputsAND THEN QUIT. If you use this option none of the other expected outputs will be produced
+    weight_file: generic/file
+    # type=file|default=<undefined>: Set the weighting for each voxel in the base dataset; larger weights mean that voxel count more in the cost function. Must be defined on the same grid as the base dataset
+    out_weight_file: generic/file
+    # type=file: weight volume
+    # type=file|default=<undefined>: Write the weight volume to disk as a dataset
+    source_mask: generic/file
+    # type=file|default=<undefined>: mask the input dataset
+    master: generic/file
+    # type=file|default=<undefined>: Write the output dataset on the same grid as this file.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: medimage/nifti1
+    # type=file: output image file name
+    # type=file|default=<undefined>: output file from 3dAllineate
+    out_matrix: generic/file
+    # type=file: matrix to align input file
+    # type=file|default=<undefined>: Save the transformation matrix for each volume.
+    out_param_file: generic/file
+    # type=file: warp parameters
+    # type=file|default=<undefined>: Save the warp parameters in ASCII (.1D) format.
+    out_weight_file: generic/file
+    # type=file: weight volume
+    # type=file|default=<undefined>: Write the weight volume to disk as a dataset
+    allcostx: text/text-file
+    # type=file: Compute and print ALL available cost functionals for the un-warped inputs
+    # type=file|default=<undefined>: Compute and print ALL available cost functionals for the un-warped inputsAND THEN QUIT. If you use this option none of the other expected outputs will be produced
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to 3dAllineate
+    reference:
+    # type=file|default=<undefined>: file to be used as reference, the first volume will be used if not given the reference will be the first volume of in_file.
+    out_file:
+    # type=file: output image file name
+    # type=file|default=<undefined>: output file from 3dAllineate
+    out_param_file:
+    # type=file: warp parameters
+    # type=file|default=<undefined>: Save the warp parameters in ASCII (.1D) format.
+    in_param_file:
+    # type=file|default=<undefined>: Read warp parameters from file and apply them to the source dataset, and produce a new dataset
+    out_matrix:
+    # type=file: matrix to align input file
+    # type=file|default=<undefined>: Save the transformation matrix for each volume.
+    in_matrix:
+    # type=file|default=<undefined>: matrix to align input file
+    overwrite:
+    # type=bool|default=False: overwrite output file if it already exists
+    allcostx:
+    # type=file: Compute and print ALL available cost functionals for the un-warped inputs
+    # type=file|default=<undefined>: Compute and print ALL available cost functionals for the un-warped inputsAND THEN QUIT. If you use this option none of the other expected outputs will be produced
+    cost:
+    # type=enum|default='leastsq'|allowed['corratio_add','corratio_mul','corratio_uns','crA','crM','crU','hel','hellinger','leastsq','ls','mi','mutualinfo','nmi','norm_mutualinfo']: Defines the 'cost' function that defines the matching between the source and the base
+    interpolation:
+    # type=enum|default='nearestneighbour'|allowed['cubic','linear','nearestneighbour','quintic']: Defines interpolation method to use during matching
+    final_interpolation:
+    # type=enum|default='nearestneighbour'|allowed['cubic','linear','nearestneighbour','quintic','wsinc5']: Defines interpolation method used to create the output dataset
+    nmatch:
+    # type=int|default=0: Use at most n scattered points to match the datasets.
+    no_pad:
+    # type=bool|default=False: Do not use zero-padding on the base image.
+    zclip:
+    # type=bool|default=False: Replace negative values in the input datasets (source & base) with zero.
+    convergence:
+    # type=float|default=0.0: Convergence test in millimeters (default 0.05mm).
+    usetemp:
+    # type=bool|default=False: temporary file use
+    check:
+    # type=list|default=[]: After cost functional optimization is done, start at the final parameters and RE-optimize using this new cost functions. If the results are too different, a warning message will be printed. However, the final parameters from the original optimization will be used to create the output dataset.
+    one_pass:
+    # type=bool|default=False: Use only the refining pass -- do not try a coarse resolution pass first.  Useful if you know that only small amounts of image alignment are needed.
+    two_pass:
+    # type=bool|default=False: Use a two pass alignment strategy for all volumes, searching for a large rotation+shift and then refining the alignment.
+    two_blur:
+    # type=float|default=0.0: Set the blurring radius for the first pass in mm.
+    two_first:
+    # type=bool|default=False: Use -twopass on the first image to be registered, and then on all subsequent images from the source dataset, use results from the first image's coarse pass to start the fine pass.
+    two_best:
+    # type=int|default=0: In the coarse pass, use the best 'bb' set of initialpoints to search for the starting point for the finepass.  If bb==0, then no search is made for the beststarting point, and the identity transformation isused as the starting point.  [Default=5; min=0 max=11]
+    fine_blur:
+    # type=float|default=0.0: Set the blurring radius to use in the fine resolution pass to 'x' mm.  A small amount (1-2 mm?) of blurring at the fine step may help with convergence, if there is some problem, especially if the base volume is very noisy. [Default == 0 mm = no blurring at the final alignment pass]
+    center_of_mass:
+    # type=str|default='': Use the center-of-mass calculation to bracket the shifts.
+    autoweight:
+    # type=str|default='': Compute a weight function using the 3dAutomask algorithm plus some blurring of the base image.
+    automask:
+    # type=int|default=0: Compute a mask function, set a value for dilation or 0.
+    autobox:
+    # type=bool|default=False: Expand the -automask function to enclose a rectangular box that holds the irregular mask.
+    nomask:
+    # type=bool|default=False: Don't compute the autoweight/mask; if -weight is not also used, then every voxel will be counted equally.
+    weight_file:
+    # type=file|default=<undefined>: Set the weighting for each voxel in the base dataset; larger weights mean that voxel count more in the cost function. Must be defined on the same grid as the base dataset
+    weight:
+    # type=traitcompound|default=None: Set the weighting for each voxel in the base dataset; larger weights mean that voxel count more in the cost function. If an image file is given, the volume must be defined on the same grid as the base dataset
+    out_weight_file:
+    # type=file: weight volume
+    # type=file|default=<undefined>: Write the weight volume to disk as a dataset
+    source_mask:
+    # type=file|default=<undefined>: mask the input dataset
+    source_automask:
+    # type=int|default=0: Automatically mask the source dataset with dilation or 0.
+    warp_type:
+    # type=enum|default='shift_only'|allowed['affine_general','shift_only','shift_rotate','shift_rotate_scale']: Set the warp type.
+    warpfreeze:
+    # type=bool|default=False: Freeze the non-rigid body parameters after first volume.
+    replacebase:
+    # type=bool|default=False: If the source has more than one volume, then after the first volume is aligned to the base.
+    replacemeth:
+    # type=enum|default='leastsq'|allowed['corratio_add','corratio_mul','corratio_uns','crA','crM','crU','hel','hellinger','leastsq','ls','mi','mutualinfo','nmi','norm_mutualinfo']: After first volume is aligned, switch method for later volumes. For use with '-replacebase'.
+    epi:
+    # type=bool|default=False: Treat the source dataset as being composed of warped EPI slices, and the base as comprising anatomically 'true' images.  Only phase-encoding direction image shearing and scaling will be allowed with this option.
+    maxrot:
+    # type=float|default=0.0: Maximum allowed rotation in degrees.
+    maxshf:
+    # type=float|default=0.0: Maximum allowed shift in mm.
+    maxscl:
+    # type=float|default=0.0: Maximum allowed scaling factor.
+    maxshr:
+    # type=float|default=0.0: Maximum allowed shearing factor.
+    master:
+    # type=file|default=<undefined>: Write the output dataset on the same grid as this file.
+    newgrid:
+    # type=float|default=0.0: Write the output dataset using isotropic grid spacing in mm.
+    nwarp:
+    # type=enum|default='bilinear'|allowed['bilinear','cubic','heptic','nonic','poly3','poly5','poly7','poly9','quintic']: Experimental nonlinear warping: bilinear or legendre poly.
+    nwarp_fixmot:
+    # type=list|default=[]: To fix motion along directions.
+    nwarp_fixdep:
+    # type=list|default=[]: To fix non-linear warp dependency along directions.
+    verbose:
+    # type=bool|default=False: Print out verbose progress reports.
+    quiet:
+    # type=bool|default=False: Don't print out verbose progress reports.
+    num_threads:
+    # type=int|default=1: set number of threads
+    outputtype:
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to 3dAllineate
+    out_file:
+    # type=file: output image file name
+    # type=file|default=<undefined>: output file from 3dAllineate
+    in_matrix:
+    # type=file|default=<undefined>: matrix to align input file
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to 3dAllineate
+    reference:
+    # type=file|default=<undefined>: file to be used as reference, the first volume will be used if not given the reference will be the first volume of in_file.
+    allcostx:
+    # type=file: Compute and print ALL available cost functionals for the un-warped inputs
+    # type=file|default=<undefined>: Compute and print ALL available cost functionals for the un-warped inputsAND THEN QUIT. If you use this option none of the other expected outputs will be produced
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to 3dAllineate
+    reference:
+    # type=file|default=<undefined>: file to be used as reference, the first volume will be used if not given the reference will be the first volume of in_file.
+    nwarp_fixmot: '["X", "Y"]'
+    # type=list|default=[]: To fix motion along directions.
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: 3dAllineate -source functional.nii -prefix functional_allineate.nii -1Dmatrix_apply cmatrix.mat
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: input file to 3dAllineate
+    out_file:
+    # type=file: output image file name
+    # type=file|default=<undefined>: output file from 3dAllineate
+    in_matrix:
+    # type=file|default=<undefined>: matrix to align input file
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: 3dAllineate -source functional.nii -base structural.nii -allcostx |& tee out.allcostX.txt
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: input file to 3dAllineate
+    reference:
+    # type=file|default=<undefined>: file to be used as reference, the first volume will be used if not given the reference will be the first volume of in_file.
+    allcostx:
+    # type=file: Compute and print ALL available cost functionals for the un-warped inputs
+    # type=file|default=<undefined>: Compute and print ALL available cost functionals for the un-warped inputsAND THEN QUIT. If you use this option none of the other expected outputs will be produced
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: 3dAllineate -source functional.nii -nwarp_fixmotX -nwarp_fixmotY -prefix functional_allineate -base structural.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: input file to 3dAllineate
+    reference:
+    # type=file|default=<undefined>: file to be used as reference, the first volume will be used if not given the reference will be the first volume of in_file.
+    nwarp_fixmot: '["X", "Y"]'
+    # type=list|default=[]: To fix motion along directions.
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-afni/allineate_callables.py b/example-specs/task/nipype_internal/pydra-afni/allineate_callables.py
new file mode 100644
index 00000000..ef04a59b
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/allineate_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Allineate.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-afni/auto_tcorrelate.yaml b/example-specs/task/nipype_internal/pydra-afni/auto_tcorrelate.yaml
new file mode 100644
index 00000000..76d7e1d6
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/auto_tcorrelate.yaml
@@ -0,0 +1,165 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.afni.preprocess.AutoTcorrelate' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Computes the correlation coefficient between the time series of each
+#     pair of voxels in the input dataset, and stores the output into a
+#     new anatomical bucket dataset [scaled to shorts to save memory space].
+# 
+#     For complete details, see the `3dAutoTcorrelate Documentation.
+#     <https://afni.nimh.nih.gov/pub/dist/doc/program_help/3dAutoTcorrelate.html>`_
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import afni
+#     >>> corr = afni.AutoTcorrelate()
+#     >>> corr.inputs.in_file = 'functional.nii'
+#     >>> corr.inputs.polort = -1
+#     >>> corr.inputs.eta2 = True
+#     >>> corr.inputs.mask = 'mask.nii'
+#     >>> corr.inputs.mask_only_targets = True
+#     >>> corr.cmdline  # doctest: +ELLIPSIS
+#     '3dAutoTcorrelate -eta2 -mask mask.nii -mask_only_targets -prefix functional_similarity_matrix.1D -polort -1 functional.nii'
+#     >>> res = corr.run()  # doctest: +SKIP
+#     
+task_name: AutoTcorrelate
+nipype_name: AutoTcorrelate
+nipype_module: nipype.interfaces.afni.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: timeseries x space (volume or surface) file
+    mask: medimage/nifti1
+    # type=file|default=<undefined>: mask of voxels
+    mask_source: generic/file
+    # type=file|default=<undefined>: mask for source voxels
+    out_file: generic/file
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: timeseries x space (volume or surface) file
+    polort:
+    # type=int|default=0: Remove polynomical trend of order m or -1 for no detrending
+    eta2:
+    # type=bool|default=False: eta^2 similarity
+    mask:
+    # type=file|default=<undefined>: mask of voxels
+    mask_only_targets:
+    # type=bool|default=False: use mask only on targets voxels
+    mask_source:
+    # type=file|default=<undefined>: mask for source voxels
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+    num_threads:
+    # type=int|default=1: set number of threads
+    outputtype:
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: timeseries x space (volume or surface) file
+    polort: '-1'
+    # type=int|default=0: Remove polynomical trend of order m or -1 for no detrending
+    eta2: 'True'
+    # type=bool|default=False: eta^2 similarity
+    mask:
+    # type=file|default=<undefined>: mask of voxels
+    mask_only_targets: 'True'
+    # type=bool|default=False: use mask only on targets voxels
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: 3dAutoTcorrelate -eta2 -mask mask.nii -mask_only_targets -prefix functional_similarity_matrix.1D -polort -1 functional.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: timeseries x space (volume or surface) file
+    polort: '-1'
+    # type=int|default=0: Remove polynomical trend of order m or -1 for no detrending
+    eta2: 'True'
+    # type=bool|default=False: eta^2 similarity
+    mask:
+    # type=file|default=<undefined>: mask of voxels
+    mask_only_targets: 'True'
+    # type=bool|default=False: use mask only on targets voxels
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-afni/auto_tcorrelate_callables.py b/example-specs/task/nipype_internal/pydra-afni/auto_tcorrelate_callables.py
new file mode 100644
index 00000000..2ab2ba4e
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/auto_tcorrelate_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in AutoTcorrelate.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-afni/auto_tlrc.yaml b/example-specs/task/nipype_internal/pydra-afni/auto_tlrc.yaml
new file mode 100644
index 00000000..9decfcbe
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/auto_tlrc.yaml
@@ -0,0 +1,135 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.afni.preprocess.AutoTLRC' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# A minimal wrapper for the AutoTLRC script
+#     The only option currently supported is no_ss.
+#     For complete details, see the `3dQwarp Documentation.
+#     <https://afni.nimh.nih.gov/pub/dist/doc/program_help/@auto_tlrc.html>`_
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import afni
+#     >>> autoTLRC = afni.AutoTLRC()
+#     >>> autoTLRC.inputs.in_file = 'structural.nii'
+#     >>> autoTLRC.inputs.no_ss = True
+#     >>> autoTLRC.inputs.base = "TT_N27+tlrc"
+#     >>> autoTLRC.cmdline
+#     '@auto_tlrc -base TT_N27+tlrc -input structural.nii -no_ss'
+#     >>> res = autoTLRC.run()  # doctest: +SKIP
+# 
+#     
+task_name: AutoTLRC
+nipype_name: AutoTLRC
+nipype_module: nipype.interfaces.afni.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: Original anatomical volume (+orig).The skull is removed by this scriptunless instructed otherwise (-no_ss).
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: output file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    outputtype:
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+    in_file:
+    # type=file|default=<undefined>: Original anatomical volume (+orig).The skull is removed by this scriptunless instructed otherwise (-no_ss).
+    base:
+    # type=str|default='': Reference anatomical volume. Usually this volume is in some standard space like TLRC or MNI space and with afni dataset view of (+tlrc). Preferably, this reference volume should have had the skull removed but that is not mandatory. AFNI's distribution contains several templates. For a longer list, use "whereami -show_templates" TT_N27+tlrc --> Single subject, skull stripped volume. This volume is also known as N27_SurfVol_NoSkull+tlrc elsewhere in AFNI and SUMA land. (www.loni.ucla.edu, www.bic.mni.mcgill.ca) This template has a full set of FreeSurfer (surfer.nmr.mgh.harvard.edu) surface models that can be used in SUMA. For details, see Talairach-related link: https://afni.nimh.nih.gov/afni/suma TT_icbm452+tlrc --> Average volume of 452 normal brains. Skull Stripped. (www.loni.ucla.edu) TT_avg152T1+tlrc --> Average volume of 152 normal brains. Skull Stripped.(www.bic.mni.mcgill.ca) TT_EPI+tlrc --> EPI template from spm2, masked as TT_avg152T1 TT_avg152 and TT_EPI volume sources are from SPM's distribution. (www.fil.ion.ucl.ac.uk/spm/) If you do not specify a path for the template, the script will attempt to locate the template AFNI's binaries directory. NOTE: These datasets have been slightly modified from their original size to match the standard TLRC dimensions (Jean Talairach and Pierre Tournoux Co-Planar Stereotaxic Atlas of the Human Brain Thieme Medical Publishers, New York, 1988). That was done for internal consistency in AFNI. You may use the original form of these volumes if you choose but your TLRC coordinates will not be consistent with AFNI's TLRC database (San Antonio Talairach Daemon database), for example.
+    no_ss:
+    # type=bool|default=False: Do not strip skull of input data set (because skull has already been removed or because template still has the skull) NOTE: The ``-no_ss`` option is not all that optional. Here is a table of when you should and should not use ``-no_ss``    +------------------+------------+---------------+   | Dataset          | Template                   |   +==================+============+===============+   |                  | w/ skull   | wo/ skull     |   +------------------+------------+---------------+   | WITH skull       | ``-no_ss`` | xxx           |   +------------------+------------+---------------+   | WITHOUT skull    | No Cigar   | ``-no_ss``    |   +------------------+------------+---------------+  Template means: Your template of choice Dset. means: Your anatomical dataset ``-no_ss`` means: Skull stripping should not be attempted on Dset xxx means: Don't put anything, the script will strip Dset No Cigar means: Don't try that combination, it makes no sense.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: Original anatomical volume (+orig).The skull is removed by this scriptunless instructed otherwise (-no_ss).
+    no_ss: 'True'
+    # type=bool|default=False: Do not strip skull of input data set (because skull has already been removed or because template still has the skull) NOTE: The ``-no_ss`` option is not all that optional. Here is a table of when you should and should not use ``-no_ss``    +------------------+------------+---------------+   | Dataset          | Template                   |   +==================+============+===============+   |                  | w/ skull   | wo/ skull     |   +------------------+------------+---------------+   | WITH skull       | ``-no_ss`` | xxx           |   +------------------+------------+---------------+   | WITHOUT skull    | No Cigar   | ``-no_ss``    |   +------------------+------------+---------------+  Template means: Your template of choice Dset. means: Your anatomical dataset ``-no_ss`` means: Skull stripping should not be attempted on Dset xxx means: Don't put anything, the script will strip Dset No Cigar means: Don't try that combination, it makes no sense.
+    base: '"TT_N27+tlrc"'
+    # type=str|default='': Reference anatomical volume. Usually this volume is in some standard space like TLRC or MNI space and with afni dataset view of (+tlrc). Preferably, this reference volume should have had the skull removed but that is not mandatory. AFNI's distribution contains several templates. For a longer list, use "whereami -show_templates" TT_N27+tlrc --> Single subject, skull stripped volume. This volume is also known as N27_SurfVol_NoSkull+tlrc elsewhere in AFNI and SUMA land. (www.loni.ucla.edu, www.bic.mni.mcgill.ca) This template has a full set of FreeSurfer (surfer.nmr.mgh.harvard.edu) surface models that can be used in SUMA. For details, see Talairach-related link: https://afni.nimh.nih.gov/afni/suma TT_icbm452+tlrc --> Average volume of 452 normal brains. Skull Stripped. (www.loni.ucla.edu) TT_avg152T1+tlrc --> Average volume of 152 normal brains. Skull Stripped.(www.bic.mni.mcgill.ca) TT_EPI+tlrc --> EPI template from spm2, masked as TT_avg152T1 TT_avg152 and TT_EPI volume sources are from SPM's distribution. (www.fil.ion.ucl.ac.uk/spm/) If you do not specify a path for the template, the script will attempt to locate the template AFNI's binaries directory. NOTE: These datasets have been slightly modified from their original size to match the standard TLRC dimensions (Jean Talairach and Pierre Tournoux Co-Planar Stereotaxic Atlas of the Human Brain Thieme Medical Publishers, New York, 1988). That was done for internal consistency in AFNI. You may use the original form of these volumes if you choose but your TLRC coordinates will not be consistent with AFNI's TLRC database (San Antonio Talairach Daemon database), for example.
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: '@auto_tlrc -base TT_N27+tlrc -input structural.nii -no_ss'
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: Original anatomical volume (+orig).The skull is removed by this scriptunless instructed otherwise (-no_ss).
+    no_ss: 'True'
+    # type=bool|default=False: Do not strip skull of input data set (because skull has already been removed or because template still has the skull) NOTE: The ``-no_ss`` option is not all that optional. Here is a table of when you should and should not use ``-no_ss``    +------------------+------------+---------------+   | Dataset          | Template                   |   +==================+============+===============+   |                  | w/ skull   | wo/ skull     |   +------------------+------------+---------------+   | WITH skull       | ``-no_ss`` | xxx           |   +------------------+------------+---------------+   | WITHOUT skull    | No Cigar   | ``-no_ss``    |   +------------------+------------+---------------+  Template means: Your template of choice Dset. means: Your anatomical dataset ``-no_ss`` means: Skull stripping should not be attempted on Dset xxx means: Don't put anything, the script will strip Dset No Cigar means: Don't try that combination, it makes no sense.
+    base: '"TT_N27+tlrc"'
+    # type=str|default='': Reference anatomical volume. Usually this volume is in some standard space like TLRC or MNI space and with afni dataset view of (+tlrc). Preferably, this reference volume should have had the skull removed but that is not mandatory. AFNI's distribution contains several templates. For a longer list, use "whereami -show_templates" TT_N27+tlrc --> Single subject, skull stripped volume. This volume is also known as N27_SurfVol_NoSkull+tlrc elsewhere in AFNI and SUMA land. (www.loni.ucla.edu, www.bic.mni.mcgill.ca) This template has a full set of FreeSurfer (surfer.nmr.mgh.harvard.edu) surface models that can be used in SUMA. For details, see Talairach-related link: https://afni.nimh.nih.gov/afni/suma TT_icbm452+tlrc --> Average volume of 452 normal brains. Skull Stripped. (www.loni.ucla.edu) TT_avg152T1+tlrc --> Average volume of 152 normal brains. Skull Stripped.(www.bic.mni.mcgill.ca) TT_EPI+tlrc --> EPI template from spm2, masked as TT_avg152T1 TT_avg152 and TT_EPI volume sources are from SPM's distribution. (www.fil.ion.ucl.ac.uk/spm/) If you do not specify a path for the template, the script will attempt to locate the template AFNI's binaries directory. NOTE: These datasets have been slightly modified from their original size to match the standard TLRC dimensions (Jean Talairach and Pierre Tournoux Co-Planar Stereotaxic Atlas of the Human Brain Thieme Medical Publishers, New York, 1988). That was done for internal consistency in AFNI. You may use the original form of these volumes if you choose but your TLRC coordinates will not be consistent with AFNI's TLRC database (San Antonio Talairach Daemon database), for example.
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-afni/auto_tlrc_callables.py b/example-specs/task/nipype_internal/pydra-afni/auto_tlrc_callables.py
new file mode 100644
index 00000000..873f7172
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/auto_tlrc_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in AutoTLRC.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-afni/autobox.yaml b/example-specs/task/nipype_internal/pydra-afni/autobox.yaml
new file mode 100644
index 00000000..869bb440
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/autobox.yaml
@@ -0,0 +1,140 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.afni.utils.Autobox' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Computes size of a box that fits around the volume.
+#     Also can be used to crop the volume to that box.
+# 
+#     For complete details, see the `3dAutobox Documentation.
+#     <https://afni.nimh.nih.gov/pub/dist/doc/program_help/3dAutobox.html>`_
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import afni
+#     >>> abox = afni.Autobox()
+#     >>> abox.inputs.in_file = 'structural.nii'
+#     >>> abox.inputs.padding = 5
+#     >>> abox.cmdline
+#     '3dAutobox -input structural.nii -prefix structural_autobox -npad 5'
+#     >>> res = abox.run()  # doctest: +SKIP
+# 
+#     
+task_name: Autobox
+nipype_name: Autobox
+nipype_module: nipype.interfaces.afni.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: input file
+    out_file: generic/file
+    # type=file: output file
+    # type=file|default=<undefined>: 
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: output file
+    # type=file|default=<undefined>: 
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file
+    padding:
+    # type=int|default=0: Number of extra voxels to pad on each side of box
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: 
+    no_clustering:
+    # type=bool|default=False: Don't do any clustering to find box. Any non-zero voxel will be preserved in the cropped volume. The default method uses some clustering to find the cropping box, and will clip off small isolated blobs.
+    num_threads:
+    # type=int|default=1: set number of threads
+    outputtype:
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file
+    padding: '5'
+    # type=int|default=0: Number of extra voxels to pad on each side of box
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: 3dAutobox -input structural.nii -prefix structural_autobox -npad 5
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: input file
+    padding: '5'
+    # type=int|default=0: Number of extra voxels to pad on each side of box
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-afni/autobox_callables.py b/example-specs/task/nipype_internal/pydra-afni/autobox_callables.py
new file mode 100644
index 00000000..f24b937c
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/autobox_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Autobox.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-afni/automask.yaml b/example-specs/task/nipype_internal/pydra-afni/automask.yaml
new file mode 100644
index 00000000..b34a7371
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/automask.yaml
@@ -0,0 +1,155 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.afni.preprocess.Automask' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Create a brain-only mask of the image using AFNI 3dAutomask command
+# 
+#     For complete details, see the `3dAutomask Documentation.
+#     <https://afni.nimh.nih.gov/pub/dist/doc/program_help/3dAutomask.html>`_
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import afni
+#     >>> automask = afni.Automask()
+#     >>> automask.inputs.in_file = 'functional.nii'
+#     >>> automask.inputs.dilate = 1
+#     >>> automask.inputs.outputtype = 'NIFTI'
+#     >>> automask.cmdline  # doctest: +ELLIPSIS
+#     '3dAutomask -apply_prefix functional_masked.nii -dilate 1 -prefix functional_mask.nii functional.nii'
+#     >>> res = automask.run()  # doctest: +SKIP
+# 
+#     
+task_name: Automask
+nipype_name: Automask
+nipype_module: nipype.interfaces.afni.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: input file to 3dAutomask
+    out_file: generic/file
+    # type=file: mask file
+    # type=file|default=<undefined>: output image file name
+    brain_file: generic/file
+    # type=file: brain file (skull stripped)
+    # type=file|default=<undefined>: output file from 3dAutomask
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: mask file
+    # type=file|default=<undefined>: output image file name
+    brain_file: generic/file
+    # type=file: brain file (skull stripped)
+    # type=file|default=<undefined>: output file from 3dAutomask
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to 3dAutomask
+    out_file:
+    # type=file: mask file
+    # type=file|default=<undefined>: output image file name
+    brain_file:
+    # type=file: brain file (skull stripped)
+    # type=file|default=<undefined>: output file from 3dAutomask
+    clfrac:
+    # type=float|default=0.0: sets the clip level fraction (must be 0.1-0.9). A small value will tend to make the mask larger [default = 0.5].
+    dilate:
+    # type=int|default=0: dilate the mask outwards
+    erode:
+    # type=int|default=0: erode the mask inwards
+    num_threads:
+    # type=int|default=1: set number of threads
+    outputtype:
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to 3dAutomask
+    dilate: '1'
+    # type=int|default=0: dilate the mask outwards
+    outputtype: '"NIFTI"'
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: 3dAutomask -apply_prefix functional_masked.nii -dilate 1 -prefix functional_mask.nii functional.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: input file to 3dAutomask
+    dilate: '1'
+    # type=int|default=0: dilate the mask outwards
+    outputtype: '"NIFTI"'
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-afni/automask_callables.py b/example-specs/task/nipype_internal/pydra-afni/automask_callables.py
new file mode 100644
index 00000000..a19deb68
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/automask_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Automask.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-afni/axialize.yaml b/example-specs/task/nipype_internal/pydra-afni/axialize.yaml
new file mode 100644
index 00000000..387861b4
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/axialize.yaml
@@ -0,0 +1,148 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.afni.utils.Axialize' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Read in a dataset and write it out as a new dataset
+#          with the data brick oriented as axial slices.
+# 
+#     For complete details, see the `3dcopy Documentation.
+#     <https://afni.nimh.nih.gov/pub/dist/doc/program_help/3daxialize.html>`__
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import afni
+#     >>> axial3d = afni.Axialize()
+#     >>> axial3d.inputs.in_file = 'functional.nii'
+#     >>> axial3d.inputs.out_file = 'axialized.nii'
+#     >>> axial3d.cmdline
+#     '3daxialize -prefix axialized.nii functional.nii'
+#     >>> res = axial3d.run()  # doctest: +SKIP
+# 
+#     
+task_name: Axialize
+nipype_name: Axialize
+nipype_module: nipype.interfaces.afni.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: input file to 3daxialize
+    out_file: medimage/nifti1
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: medimage/nifti1
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to 3daxialize
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+    verb:
+    # type=bool|default=False: Print out a progerss report
+    sagittal:
+    # type=bool|default=False: Do sagittal slice order [-orient ASL]
+    coronal:
+    # type=bool|default=False: Do coronal slice order  [-orient RSA]
+    axial:
+    # type=bool|default=False: Do axial slice order    [-orient RAI]This is the default AFNI axial order, andis the one currently required by thevolume rendering plugin; this is alsothe default orientation output by thisprogram (hence the program's name).
+    orientation:
+    # type=str|default='': new orientation code
+    num_threads:
+    # type=int|default=1: set number of threads
+    outputtype:
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to 3daxialize
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: 3daxialize -prefix axialized.nii functional.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: input file to 3daxialize
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-afni/axialize_callables.py b/example-specs/task/nipype_internal/pydra-afni/axialize_callables.py
new file mode 100644
index 00000000..368125b2
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/axialize_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Axialize.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-afni/bandpass.yaml b/example-specs/task/nipype_internal/pydra-afni/bandpass.yaml
new file mode 100644
index 00000000..9929fabf
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/bandpass.yaml
@@ -0,0 +1,179 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.afni.preprocess.Bandpass' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Program to lowpass and/or highpass each voxel time series in a
+#     dataset, offering more/different options than Fourier
+# 
+#     For complete details, see the `3dBandpass Documentation.
+#     <https://afni.nimh.nih.gov/pub/dist/doc/program_help/3dBandpass.html>`_
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import afni
+#     >>> from nipype.testing import  example_data
+#     >>> bandpass = afni.Bandpass()
+#     >>> bandpass.inputs.in_file = 'functional.nii'
+#     >>> bandpass.inputs.highpass = 0.005
+#     >>> bandpass.inputs.lowpass = 0.1
+#     >>> bandpass.cmdline
+#     '3dBandpass -prefix functional_bp 0.005000 0.100000 functional.nii'
+#     >>> res = bandpass.run()  # doctest: +SKIP
+# 
+#     
+task_name: Bandpass
+nipype_name: Bandpass
+nipype_module: nipype.interfaces.afni.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: input file to 3dBandpass
+    out_file: generic/file
+    # type=file: output file
+    # type=file|default=<undefined>: output file from 3dBandpass
+    mask: generic/file
+    # type=file|default=<undefined>: mask file
+    orthogonalize_file: generic/file+list-of
+    # type=inputmultiobject|default=[]: Also orthogonalize input to columns in f.1D. Multiple '-ort' options are allowed.
+    orthogonalize_dset: generic/file
+    # type=file|default=<undefined>: Orthogonalize each voxel to the corresponding voxel time series in dataset 'fset', which must have the same spatial and temporal grid structure as the main input dataset. At present, only one '-dsort' option is allowed.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: output file
+    # type=file|default=<undefined>: output file from 3dBandpass
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to 3dBandpass
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output file from 3dBandpass
+    lowpass:
+    # type=float|default=0.0: lowpass
+    highpass:
+    # type=float|default=0.0: highpass
+    mask:
+    # type=file|default=<undefined>: mask file
+    despike:
+    # type=bool|default=False: Despike each time series before other processing. Hopefully, you don't actually need to do this, which is why it is optional.
+    orthogonalize_file:
+    # type=inputmultiobject|default=[]: Also orthogonalize input to columns in f.1D. Multiple '-ort' options are allowed.
+    orthogonalize_dset:
+    # type=file|default=<undefined>: Orthogonalize each voxel to the corresponding voxel time series in dataset 'fset', which must have the same spatial and temporal grid structure as the main input dataset. At present, only one '-dsort' option is allowed.
+    no_detrend:
+    # type=bool|default=False: Skip the quadratic detrending of the input that occurs before the FFT-based bandpassing. You would only want to do this if the dataset had been detrended already in some other program.
+    tr:
+    # type=float|default=0.0: Set time step (TR) in sec [default=from dataset header].
+    nfft:
+    # type=int|default=0: Set the FFT length [must be a legal value].
+    normalize:
+    # type=bool|default=False: Make all output time series have L2 norm = 1 (i.e., sum of squares = 1).
+    automask:
+    # type=bool|default=False: Create a mask from the input dataset.
+    blur:
+    # type=float|default=0.0: Blur (inside the mask only) with a filter width (FWHM) of 'fff' millimeters.
+    localPV:
+    # type=float|default=0.0: Replace each vector by the local Principal Vector (AKA first singular vector) from a neighborhood of radius 'rrr' millimeters. Note that the PV time series is L2 normalized. This option is mostly for Bob Cox to have fun with.
+    notrans:
+    # type=bool|default=False: Don't check for initial positive transients in the data. The test is a little slow, so skipping it is OK, if you KNOW the data time series are transient-free.
+    num_threads:
+    # type=int|default=1: set number of threads
+    outputtype:
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to 3dBandpass
+    highpass: '0.005'
+    # type=float|default=0.0: highpass
+    lowpass: '0.1'
+    # type=float|default=0.0: lowpass
+  imports: &id001
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  - module: nipype.testing
+    name: ' example_data'
+    alias:
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: 3dBandpass -prefix functional_bp 0.005000 0.100000 functional.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: input file to 3dBandpass
+    highpass: '0.005'
+    # type=float|default=0.0: highpass
+    lowpass: '0.1'
+    # type=float|default=0.0: lowpass
+  imports: *id001
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-afni/bandpass_callables.py b/example-specs/task/nipype_internal/pydra-afni/bandpass_callables.py
new file mode 100644
index 00000000..232d1740
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/bandpass_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Bandpass.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-afni/blur_in_mask.yaml b/example-specs/task/nipype_internal/pydra-afni/blur_in_mask.yaml
new file mode 100644
index 00000000..ce948125
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/blur_in_mask.yaml
@@ -0,0 +1,158 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.afni.preprocess.BlurInMask' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Blurs a dataset spatially inside a mask.  That's all.  Experimental.
+# 
+#     For complete details, see the `3dBlurInMask Documentation.
+#     <https://afni.nimh.nih.gov/pub/dist/doc/program_help/3dBlurInMask.html>`_
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import afni
+#     >>> bim = afni.BlurInMask()
+#     >>> bim.inputs.in_file = 'functional.nii'
+#     >>> bim.inputs.mask = 'mask.nii'
+#     >>> bim.inputs.fwhm = 5.0
+#     >>> bim.cmdline  # doctest: +ELLIPSIS
+#     '3dBlurInMask -input functional.nii -FWHM 5.000000 -mask mask.nii -prefix functional_blur'
+#     >>> res = bim.run()  # doctest: +SKIP
+# 
+#     
+task_name: BlurInMask
+nipype_name: BlurInMask
+nipype_module: nipype.interfaces.afni.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: input file to 3dSkullStrip
+    out_file: generic/file
+    # type=file: output file
+    # type=file|default=<undefined>: output to the file
+    mask: medimage/nifti1
+    # type=file|default=<undefined>: Mask dataset, if desired.  Blurring will occur only within the mask. Voxels NOT in the mask will be set to zero in the output.
+    multimask: generic/file
+    # type=file|default=<undefined>: Multi-mask dataset -- each distinct nonzero value in dataset will be treated as a separate mask for blurring purposes.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: output file
+    # type=file|default=<undefined>: output to the file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to 3dSkullStrip
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output to the file
+    mask:
+    # type=file|default=<undefined>: Mask dataset, if desired.  Blurring will occur only within the mask. Voxels NOT in the mask will be set to zero in the output.
+    multimask:
+    # type=file|default=<undefined>: Multi-mask dataset -- each distinct nonzero value in dataset will be treated as a separate mask for blurring purposes.
+    automask:
+    # type=bool|default=False: Create an automask from the input dataset.
+    fwhm:
+    # type=float|default=0.0: fwhm kernel size
+    preserve:
+    # type=bool|default=False: Normally, voxels not in the mask will be set to zero in the output. If you want the original values in the dataset to be preserved in the output, use this option.
+    float_out:
+    # type=bool|default=False: Save dataset as floats, no matter what the input data type is.
+    options:
+    # type=str|default='': options
+    num_threads:
+    # type=int|default=1: set number of threads
+    outputtype:
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to 3dSkullStrip
+    mask:
+    # type=file|default=<undefined>: Mask dataset, if desired.  Blurring will occur only within the mask. Voxels NOT in the mask will be set to zero in the output.
+    fwhm: '5.0'
+    # type=float|default=0.0: fwhm kernel size
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: 3dBlurInMask -input functional.nii -FWHM 5.000000 -mask mask.nii -prefix functional_blur
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: input file to 3dSkullStrip
+    mask:
+    # type=file|default=<undefined>: Mask dataset, if desired.  Blurring will occur only within the mask. Voxels NOT in the mask will be set to zero in the output.
+    fwhm: '5.0'
+    # type=float|default=0.0: fwhm kernel size
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-afni/blur_in_mask_callables.py b/example-specs/task/nipype_internal/pydra-afni/blur_in_mask_callables.py
new file mode 100644
index 00000000..7872f88f
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/blur_in_mask_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in BlurInMask.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-afni/blur_to_fwhm.yaml b/example-specs/task/nipype_internal/pydra-afni/blur_to_fwhm.yaml
new file mode 100644
index 00000000..db53cecd
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/blur_to_fwhm.yaml
@@ -0,0 +1,150 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.afni.preprocess.BlurToFWHM' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Blurs a 'master' dataset until it reaches a specified FWHM smoothness
+#     (approximately).
+# 
+#     For complete details, see the `3dBlurToFWHM Documentation
+#     <https://afni.nimh.nih.gov/pub/dist/doc/program_help/3dBlurToFWHM.html>`_
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import afni
+#     >>> blur = afni.preprocess.BlurToFWHM()
+#     >>> blur.inputs.in_file = 'epi.nii'
+#     >>> blur.inputs.fwhm = 2.5
+#     >>> blur.cmdline  # doctest: +ELLIPSIS
+#     '3dBlurToFWHM -FWHM 2.500000 -input epi.nii -prefix epi_afni'
+#     >>> res = blur.run()  # doctest: +SKIP
+# 
+#     
+task_name: BlurToFWHM
+nipype_name: BlurToFWHM
+nipype_module: nipype.interfaces.afni.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: The dataset that will be smoothed
+    blurmaster: generic/file
+    # type=file|default=<undefined>: The dataset whose smoothness controls the process.
+    mask: generic/file
+    # type=file|default=<undefined>: Mask dataset, if desired. Voxels NOT in mask will be set to zero in output.
+    out_file: generic/file
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: The dataset that will be smoothed
+    automask:
+    # type=bool|default=False: Create an automask from the input dataset.
+    fwhm:
+    # type=float|default=0.0: Blur until the 3D FWHM reaches this value (in mm)
+    fwhmxy:
+    # type=float|default=0.0: Blur until the 2D (x,y)-plane FWHM reaches this value (in mm)
+    blurmaster:
+    # type=file|default=<undefined>: The dataset whose smoothness controls the process.
+    mask:
+    # type=file|default=<undefined>: Mask dataset, if desired. Voxels NOT in mask will be set to zero in output.
+    num_threads:
+    # type=int|default=1: set number of threads
+    outputtype:
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: The dataset that will be smoothed
+    fwhm: '2.5'
+    # type=float|default=0.0: Blur until the 3D FWHM reaches this value (in mm)
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: 3dBlurToFWHM -FWHM 2.500000 -input epi.nii -prefix epi_afni
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: The dataset that will be smoothed
+    fwhm: '2.5'
+    # type=float|default=0.0: Blur until the 3D FWHM reaches this value (in mm)
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-afni/blur_to_fwhm_callables.py b/example-specs/task/nipype_internal/pydra-afni/blur_to_fwhm_callables.py
new file mode 100644
index 00000000..cc29ac1b
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/blur_to_fwhm_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in BlurToFWHM.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-afni/brick_stat.yaml b/example-specs/task/nipype_internal/pydra-afni/brick_stat.yaml
new file mode 100644
index 00000000..bbf57a2c
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/brick_stat.yaml
@@ -0,0 +1,146 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.afni.utils.BrickStat' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Computes maximum and/or minimum voxel values of an input dataset.
+#     TODO Add optional arguments.
+# 
+#     For complete details, see the `3dBrickStat Documentation.
+#     <https://afni.nimh.nih.gov/pub/dist/doc/program_help/3dBrickStat.html>`_
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import afni
+#     >>> brickstat = afni.BrickStat()
+#     >>> brickstat.inputs.in_file = 'functional.nii'
+#     >>> brickstat.inputs.mask = 'skeleton_mask.nii.gz'
+#     >>> brickstat.inputs.min = True
+#     >>> brickstat.cmdline
+#     '3dBrickStat -min -mask skeleton_mask.nii.gz functional.nii'
+#     >>> res = brickstat.run()  # doctest: +SKIP
+# 
+#     
+task_name: BrickStat
+nipype_name: BrickStat
+nipype_module: nipype.interfaces.afni.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: input file to 3dmaskave
+    mask: medimage/nifti-gz
+    # type=file|default=<undefined>: -mask dset = use dset as mask to include/exclude voxels
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to 3dmaskave
+    mask:
+    # type=file|default=<undefined>: -mask dset = use dset as mask to include/exclude voxels
+    min:
+    # type=bool|default=False: print the minimum value in dataset
+    slow:
+    # type=bool|default=False: read the whole dataset to find the min and max values
+    max:
+    # type=bool|default=False: print the maximum value in the dataset
+    mean:
+    # type=bool|default=False: print the mean value in the dataset
+    sum:
+    # type=bool|default=False: print the sum of values in the dataset
+    var:
+    # type=bool|default=False: print the variance in the dataset
+    percentile:
+    # type=tuple|default=(0.0, 0.0, 0.0): p0 ps p1 write the percentile values starting at p0% and ending at p1% at a step of ps%. only one sub-brick is accepted.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to 3dmaskave
+    mask:
+    # type=file|default=<undefined>: -mask dset = use dset as mask to include/exclude voxels
+    min: 'True'
+    # type=bool|default=False: print the minimum value in dataset
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: 3dBrickStat -min -mask skeleton_mask.nii.gz functional.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: input file to 3dmaskave
+    mask:
+    # type=file|default=<undefined>: -mask dset = use dset as mask to include/exclude voxels
+    min: 'True'
+    # type=bool|default=False: print the minimum value in dataset
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-afni/brick_stat_callables.py b/example-specs/task/nipype_internal/pydra-afni/brick_stat_callables.py
new file mode 100644
index 00000000..91c3ac98
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/brick_stat_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in BrickStat.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-afni/bucket.yaml b/example-specs/task/nipype_internal/pydra-afni/bucket.yaml
new file mode 100644
index 00000000..3a516360
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/bucket.yaml
@@ -0,0 +1,146 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.afni.utils.Bucket' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Concatenate sub-bricks from input datasets into one big
+#     'bucket' dataset.
+# 
+#     .. danger::
+# 
+#         Using this program, it is possible to create a dataset that
+#         has different basic datum types for different sub-bricks
+#         (e.g., shorts for brick 0, floats for brick 1).
+#         Do NOT do this!  Very few AFNI programs will work correctly
+#         with such datasets!
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import afni
+#     >>> bucket = afni.Bucket()
+#     >>> bucket.inputs.in_file = [('functional.nii',"{2..$}"), ('functional.nii',"{1}")]
+#     >>> bucket.inputs.out_file = 'vr_base'
+#     >>> bucket.cmdline
+#     "3dbucket -prefix vr_base functional.nii'{2..$}' functional.nii'{1}'"
+#     >>> res = bucket.run()  # doctest: +SKIP
+# 
+#     See Also
+#     --------
+#     For complete details, see the `3dbucket Documentation.
+#     <https://afni.nimh.nih.gov/pub/dist/doc/program_help/3dbucket.html>`__.
+# 
+#     
+task_name: Bucket
+nipype_name: Bucket
+nipype_module: nipype.interfaces.afni.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: output file
+    # type=file|default=<undefined>: 
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: output file
+    # type=file|default=<undefined>: 
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=list|default=[]: List of tuples of input datasets and subbrick selection strings as described in more detail in the following afni help string Input dataset specified using one of these forms: ``prefix+view``, ``prefix+view.HEAD``, or ``prefix+view.BRIK``. You can also add a sub-brick selection list after the end of the dataset name.  This allows only a subset of the sub-bricks to be included into the output (by default, all of the input dataset is copied into the output).  A sub-brick selection list looks like one of the following forms::      fred+orig[5]                     ==> use only sub-brick #5     fred+orig[5,9,17]                ==> use #5, #9, and #17     fred+orig[5..8]     or [5-8]     ==> use #5, #6, #7, and #8     fred+orig[5..13(2)] or [5-13(2)] ==> use #5, #7, #9, #11, and #13  Sub-brick indexes start at 0.  You can use the character '$' to indicate the last sub-brick in a dataset; for example, you can select every third sub-brick by using the selection list ``fred+orig[0..$(3)]`` N.B.: The sub-bricks are output in the order specified, which may not be the order in the original datasets.  For example, using ``fred+orig[0..$(2),1..$(2)]`` will cause the sub-bricks in fred+orig to be output into the new dataset in an interleaved fashion. Using ``fred+orig[$..0]`` will reverse the order of the sub-bricks in the output. N.B.: Bucket datasets have multiple sub-bricks, but do NOT have a time dimension.  You can input sub-bricks from a 3D+time dataset into a bucket dataset.  You can use the '3dinfo' program to see how many sub-bricks a 3D+time or a bucket dataset contains. N.B.: In non-bucket functional datasets (like the 'fico' datasets output by FIM, or the 'fitt' datasets output by 3dttest), sub-brick ``[0]`` is the 'intensity' and sub-brick [1] is the statistical parameter used as a threshold.  Thus, to create a bucket dataset using the intensity from dataset A and the threshold from dataset B, and calling the output dataset C, you would type::      3dbucket -prefix C -fbuc 'A+orig[0]' -fbuc 'B+orig[1]  
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: 
+    num_threads:
+    # type=int|default=1: set number of threads
+    outputtype:
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file: '[(''functional.nii'',"{2..$}"), (''functional.nii'',"{1}")]'
+    # type=list|default=[]: List of tuples of input datasets and subbrick selection strings as described in more detail in the following afni help string Input dataset specified using one of these forms: ``prefix+view``, ``prefix+view.HEAD``, or ``prefix+view.BRIK``. You can also add a sub-brick selection list after the end of the dataset name.  This allows only a subset of the sub-bricks to be included into the output (by default, all of the input dataset is copied into the output).  A sub-brick selection list looks like one of the following forms::      fred+orig[5]                     ==> use only sub-brick #5     fred+orig[5,9,17]                ==> use #5, #9, and #17     fred+orig[5..8]     or [5-8]     ==> use #5, #6, #7, and #8     fred+orig[5..13(2)] or [5-13(2)] ==> use #5, #7, #9, #11, and #13  Sub-brick indexes start at 0.  You can use the character '$' to indicate the last sub-brick in a dataset; for example, you can select every third sub-brick by using the selection list ``fred+orig[0..$(3)]`` N.B.: The sub-bricks are output in the order specified, which may not be the order in the original datasets.  For example, using ``fred+orig[0..$(2),1..$(2)]`` will cause the sub-bricks in fred+orig to be output into the new dataset in an interleaved fashion. Using ``fred+orig[$..0]`` will reverse the order of the sub-bricks in the output. N.B.: Bucket datasets have multiple sub-bricks, but do NOT have a time dimension.  You can input sub-bricks from a 3D+time dataset into a bucket dataset.  You can use the '3dinfo' program to see how many sub-bricks a 3D+time or a bucket dataset contains. N.B.: In non-bucket functional datasets (like the 'fico' datasets output by FIM, or the 'fitt' datasets output by 3dttest), sub-brick ``[0]`` is the 'intensity' and sub-brick [1] is the statistical parameter used as a threshold.  Thus, to create a bucket dataset using the intensity from dataset A and the threshold from dataset B, and calling the output dataset C, you would type::      3dbucket -prefix C -fbuc 'A+orig[0]' -fbuc 'B+orig[1]  
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: 
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: 3dbucket -prefix vr_base functional.nii"{2..$}" functional.nii"{1}"
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file: '[(''functional.nii'',"{2..$}"), (''functional.nii'',"{1}")]'
+    # type=list|default=[]: List of tuples of input datasets and subbrick selection strings as described in more detail in the following afni help string Input dataset specified using one of these forms: ``prefix+view``, ``prefix+view.HEAD``, or ``prefix+view.BRIK``. You can also add a sub-brick selection list after the end of the dataset name.  This allows only a subset of the sub-bricks to be included into the output (by default, all of the input dataset is copied into the output).  A sub-brick selection list looks like one of the following forms::      fred+orig[5]                     ==> use only sub-brick #5     fred+orig[5,9,17]                ==> use #5, #9, and #17     fred+orig[5..8]     or [5-8]     ==> use #5, #6, #7, and #8     fred+orig[5..13(2)] or [5-13(2)] ==> use #5, #7, #9, #11, and #13  Sub-brick indexes start at 0.  You can use the character '$' to indicate the last sub-brick in a dataset; for example, you can select every third sub-brick by using the selection list ``fred+orig[0..$(3)]`` N.B.: The sub-bricks are output in the order specified, which may not be the order in the original datasets.  For example, using ``fred+orig[0..$(2),1..$(2)]`` will cause the sub-bricks in fred+orig to be output into the new dataset in an interleaved fashion. Using ``fred+orig[$..0]`` will reverse the order of the sub-bricks in the output. N.B.: Bucket datasets have multiple sub-bricks, but do NOT have a time dimension.  You can input sub-bricks from a 3D+time dataset into a bucket dataset.  You can use the '3dinfo' program to see how many sub-bricks a 3D+time or a bucket dataset contains. N.B.: In non-bucket functional datasets (like the 'fico' datasets output by FIM, or the 'fitt' datasets output by 3dttest), sub-brick ``[0]`` is the 'intensity' and sub-brick [1] is the statistical parameter used as a threshold.  Thus, to create a bucket dataset using the intensity from dataset A and the threshold from dataset B, and calling the output dataset C, you would type::      3dbucket -prefix C -fbuc 'A+orig[0]' -fbuc 'B+orig[1]  
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: 
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-afni/bucket_callables.py b/example-specs/task/nipype_internal/pydra-afni/bucket_callables.py
new file mode 100644
index 00000000..d394d4d3
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/bucket_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Bucket.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-afni/calc.yaml b/example-specs/task/nipype_internal/pydra-afni/calc.yaml
new file mode 100644
index 00000000..c8593533
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/calc.yaml
@@ -0,0 +1,231 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.afni.utils.Calc' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# This program does voxel-by-voxel arithmetic on 3D datasets.
+# 
+#     For complete details, see the `3dcalc Documentation.
+#     <https://afni.nimh.nih.gov/pub/dist/doc/program_help/3dcalc.html>`_
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import afni
+#     >>> calc = afni.Calc()
+#     >>> calc.inputs.in_file_a = 'functional.nii'
+#     >>> calc.inputs.in_file_b = 'functional2.nii'
+#     >>> calc.inputs.expr='a*b'
+#     >>> calc.inputs.out_file =  'functional_calc.nii.gz'
+#     >>> calc.inputs.outputtype = 'NIFTI'
+#     >>> calc.cmdline  # doctest: +ELLIPSIS
+#     '3dcalc -a functional.nii -b functional2.nii -expr "a*b" -prefix functional_calc.nii.gz'
+#     >>> res = calc.run()  # doctest: +SKIP
+# 
+#     >>> from nipype.interfaces import afni
+#     >>> calc = afni.Calc()
+#     >>> calc.inputs.in_file_a = 'functional.nii'
+#     >>> calc.inputs.expr = '1'
+#     >>> calc.inputs.out_file = 'rm.epi.all1'
+#     >>> calc.inputs.overwrite = True
+#     >>> calc.cmdline
+#     '3dcalc -a functional.nii -expr "1" -prefix rm.epi.all1 -overwrite'
+#     >>> res = calc.run() # doctest: +SKIP
+# 
+#     
+task_name: Calc
+nipype_name: Calc
+nipype_module: nipype.interfaces.afni.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file_a: medimage/nifti1
+    # type=file|default=<undefined>: input file to 3dcalc
+    in_file_b: medimage/nifti1
+    # type=file|default=<undefined>: operand file to 3dcalc
+    in_file_c: generic/file
+    # type=file|default=<undefined>: operand file to 3dcalc
+    out_file: medimage-afni/all1,medimage/nifti-gz
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+    other: generic/file
+    # type=file|default=<undefined>: other options
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: medimage-afni/all1,medimage/nifti-gz
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file_a:
+    # type=file|default=<undefined>: input file to 3dcalc
+    in_file_b:
+    # type=file|default=<undefined>: operand file to 3dcalc
+    in_file_c:
+    # type=file|default=<undefined>: operand file to 3dcalc
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+    expr:
+    # type=str|default='': expr
+    start_idx:
+    # type=int|default=0: start index for in_file_a
+    stop_idx:
+    # type=int|default=0: stop index for in_file_a
+    single_idx:
+    # type=int|default=0: volume index for in_file_a
+    overwrite:
+    # type=bool|default=False: overwrite output
+    other:
+    # type=file|default=<undefined>: other options
+    num_threads:
+    # type=int|default=1: set number of threads
+    outputtype:
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file_a:
+    # type=file|default=<undefined>: input file to 3dcalc
+    in_file_b:
+    # type=file|default=<undefined>: operand file to 3dcalc
+    expr: '"a*b"'
+    # type=str|default='': expr
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+    outputtype: '"NIFTI"'
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file_a:
+    # type=file|default=<undefined>: input file to 3dcalc
+    expr: '"1"'
+    # type=str|default='': expr
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+    overwrite: 'True'
+    # type=bool|default=False: overwrite output
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: 3dcalc -a functional.nii -b functional2.nii -expr "a*b" -prefix functional_calc.nii.gz
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file_a:
+    # type=file|default=<undefined>: input file to 3dcalc
+    in_file_b:
+    # type=file|default=<undefined>: operand file to 3dcalc
+    expr: '"a*b"'
+    # type=str|default='': expr
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+    outputtype: '"NIFTI"'
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: 3dcalc -a functional.nii -expr "1" -prefix rm.epi.all1 -overwrite
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file_a:
+    # type=file|default=<undefined>: input file to 3dcalc
+    expr: '"1"'
+    # type=str|default='': expr
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+    overwrite: 'True'
+    # type=bool|default=False: overwrite output
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-afni/calc_callables.py b/example-specs/task/nipype_internal/pydra-afni/calc_callables.py
new file mode 100644
index 00000000..e7ff3fa7
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/calc_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Calc.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-afni/cat.yaml b/example-specs/task/nipype_internal/pydra-afni/cat.yaml
new file mode 100644
index 00000000..ca8da574
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/cat.yaml
@@ -0,0 +1,164 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.afni.utils.Cat' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 1dcat takes as input one or more 1D files, and writes out a 1D file
+#     containing the side-by-side concatenation of all or a subset of the
+#     columns from the input files.
+# 
+#     For complete details, see the `1dcat Documentation.
+#     <https://afni.nimh.nih.gov/pub/dist/doc/program_help/1dcat.html>`_
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import afni
+#     >>> cat1d = afni.Cat()
+#     >>> cat1d.inputs.sel = "'[0,2]'"
+#     >>> cat1d.inputs.in_files = ['f1.1D', 'f2.1D']
+#     >>> cat1d.inputs.out_file = 'catout.1d'
+#     >>> cat1d.cmdline
+#     "1dcat -sel '[0,2]' f1.1D f2.1D > catout.1d"
+#     >>> res = cat1d.run()  # doctest: +SKIP
+# 
+#     
+task_name: Cat
+nipype_name: Cat
+nipype_module: nipype.interfaces.afni.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_files: medimage-afni/oned+list-of
+    # type=list|default=[]: 
+    out_file: medimage-afni/oned
+    # type=file: output file
+    # type=file|default='catout.1d': output (concatenated) file name
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: medimage-afni/oned
+    # type=file: output file
+    # type=file|default='catout.1d': output (concatenated) file name
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_files:
+    # type=list|default=[]: 
+    out_file:
+    # type=file: output file
+    # type=file|default='catout.1d': output (concatenated) file name
+    omitconst:
+    # type=bool|default=False: Omit columns that are identically constant from output.
+    keepfree:
+    # type=bool|default=False: Keep only columns that are marked as 'free' in the 3dAllineate header from '-1Dparam_save'. If there is no such header, all columns are kept.
+    out_format:
+    # type=enum|default='int'|allowed['cint','double','fint','int','nice']: specify data type for output.
+    stack:
+    # type=bool|default=False: Stack the columns of the resultant matrix in the output.
+    sel:
+    # type=str|default='': Apply the same column/row selection string to all filenames on the command line.
+    out_int:
+    # type=bool|default=False: specify int data type for output
+    out_nice:
+    # type=bool|default=False: specify nice data type for output
+    out_double:
+    # type=bool|default=False: specify double data type for output
+    out_fint:
+    # type=bool|default=False: specify int, rounded down, data type for output
+    out_cint:
+    # type=bool|default=False: specify int, rounded up, data type for output
+    num_threads:
+    # type=int|default=1: set number of threads
+    outputtype:
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    sel: '"''[0,2]''"'
+    # type=str|default='': Apply the same column/row selection string to all filenames on the command line.
+    in_files:
+    # type=list|default=[]: 
+    out_file:
+    # type=file: output file
+    # type=file|default='catout.1d': output (concatenated) file name
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: 1dcat -sel "[0,2]" f1.1D f2.1D > catout.1d
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    sel: '"''[0,2]''"'
+    # type=str|default='': Apply the same column/row selection string to all filenames on the command line.
+    in_files:
+    # type=list|default=[]: 
+    out_file:
+    # type=file: output file
+    # type=file|default='catout.1d': output (concatenated) file name
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-afni/cat_callables.py b/example-specs/task/nipype_internal/pydra-afni/cat_callables.py
new file mode 100644
index 00000000..6a4e9a64
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/cat_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Cat.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-afni/cat_matvec.yaml b/example-specs/task/nipype_internal/pydra-afni/cat_matvec.yaml
new file mode 100644
index 00000000..6bba9947
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/cat_matvec.yaml
@@ -0,0 +1,141 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.afni.utils.CatMatvec' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Catenates 3D rotation+shift matrix+vector transformations.
+# 
+#     For complete details, see the `cat_matvec Documentation.
+#     <https://afni.nimh.nih.gov/pub/dist/doc/program_help/cat_matvec.html>`_
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import afni
+#     >>> cmv = afni.CatMatvec()
+#     >>> cmv.inputs.in_file = [('structural.BRIK::WARP_DATA','I')]
+#     >>> cmv.inputs.out_file = 'warp.anat.Xat.1D'
+#     >>> cmv.cmdline
+#     'cat_matvec structural.BRIK::WARP_DATA -I  > warp.anat.Xat.1D'
+#     >>> res = cmv.run()  # doctest: +SKIP
+# 
+#     
+task_name: CatMatvec
+nipype_name: CatMatvec
+nipype_module: nipype.interfaces.afni.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: medimage-afni/oned
+    # type=file: output file
+    # type=file|default=<undefined>: File to write concattenated matvecs to
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: medimage-afni/oned
+    # type=file: output file
+    # type=file|default=<undefined>: File to write concattenated matvecs to
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=list|default=[]: list of tuples of mfiles and associated opkeys
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: File to write concattenated matvecs to
+    matrix:
+    # type=bool|default=False: indicates that the resulting matrix willbe written to outfile in the 'MATRIX(...)' format (FORM 3).This feature could be used, with clever scripting, to inputa matrix directly on the command line to program 3dWarp.
+    oneline:
+    # type=bool|default=False: indicates that the resulting matrixwill simply be written as 12 numbers on one line.
+    fourxfour:
+    # type=bool|default=False: Output matrix in augmented form (last row is 0 0 0 1)This option does not work with -MATRIX or -ONELINE
+    num_threads:
+    # type=int|default=1: set number of threads
+    outputtype:
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file: '[("structural.BRIK::WARP_DATA","I")]'
+    # type=list|default=[]: list of tuples of mfiles and associated opkeys
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: File to write concattenated matvecs to
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: cat_matvec structural.BRIK::WARP_DATA -I > warp.anat.Xat.1D
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file: '[("structural.BRIK::WARP_DATA","I")]'
+    # type=list|default=[]: list of tuples of mfiles and associated opkeys
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: File to write concattenated matvecs to
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-afni/cat_matvec_callables.py b/example-specs/task/nipype_internal/pydra-afni/cat_matvec_callables.py
new file mode 100644
index 00000000..455c4f69
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/cat_matvec_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in CatMatvec.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-afni/center_mass.yaml b/example-specs/task/nipype_internal/pydra-afni/center_mass.yaml
new file mode 100644
index 00000000..5358c109
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/center_mass.yaml
@@ -0,0 +1,160 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.afni.utils.CenterMass' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Computes center of mass using 3dCM command
+# 
+#     .. note::
+# 
+#       By default, the output is (x,y,z) values in DICOM coordinates. But
+#       as of Dec, 2016, there are now command line switches for other options.
+# 
+# 
+#     For complete details, see the `3dCM Documentation.
+#     <https://afni.nimh.nih.gov/pub/dist/doc/program_help/3dCM.html>`_
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import afni
+#     >>> cm = afni.CenterMass()
+#     >>> cm.inputs.in_file = 'structural.nii'
+#     >>> cm.inputs.cm_file = 'cm.txt'
+#     >>> cm.inputs.roi_vals = [2, 10]
+#     >>> cm.cmdline
+#     '3dCM -roi_vals 2 10 structural.nii > cm.txt'
+#     >>> res = 3dcm.run()  # doctest: +SKIP
+# 
+#     
+task_name: CenterMass
+nipype_name: CenterMass
+nipype_module: nipype.interfaces.afni.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: input file to 3dCM
+    cm_file: text/text-file
+    # type=file: file with the center of mass coordinates
+    # type=file|default=<undefined>: File to write center of mass to
+    mask_file: generic/file
+    # type=file|default=<undefined>: Only voxels with nonzero values in the provided mask will be averaged.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: output file
+    cm_file: text/text-file
+    # type=file: file with the center of mass coordinates
+    # type=file|default=<undefined>: File to write center of mass to
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to 3dCM
+    cm_file:
+    # type=file: file with the center of mass coordinates
+    # type=file|default=<undefined>: File to write center of mass to
+    mask_file:
+    # type=file|default=<undefined>: Only voxels with nonzero values in the provided mask will be averaged.
+    automask:
+    # type=bool|default=False: Generate the mask automatically
+    set_cm:
+    # type=tuple|default=(<traits.trait_types.Float object at 0x11cfc68d0>, <traits.trait_types.Float object at 0x11cfc69d0>, <traits.trait_types.Float object at 0x11cfc6a50>): After computing the center of mass, set the origin fields in the header so that the center of mass will be at (x,y,z) in DICOM coords.
+    local_ijk:
+    # type=bool|default=False: Output values as (i,j,k) in local orientation
+    roi_vals:
+    # type=list|default=[]: Compute center of mass for each blob with voxel value of v0, v1, v2, etc. This option is handy for getting ROI centers of mass.
+    all_rois:
+    # type=bool|default=False: Don't bother listing the values of ROIs you want: The program will find all of them and produce a full list
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to 3dCM
+    cm_file:
+    # type=file: file with the center of mass coordinates
+    # type=file|default=<undefined>: File to write center of mass to
+    roi_vals: '[2, 10]'
+    # type=list|default=[]: Compute center of mass for each blob with voxel value of v0, v1, v2, etc. This option is handy for getting ROI centers of mass.
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: 3dCM -roi_vals 2 10 structural.nii > cm.txt
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: input file to 3dCM
+    cm_file:
+    # type=file: file with the center of mass coordinates
+    # type=file|default=<undefined>: File to write center of mass to
+    roi_vals: '[2, 10]'
+    # type=list|default=[]: Compute center of mass for each blob with voxel value of v0, v1, v2, etc. This option is handy for getting ROI centers of mass.
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-afni/center_mass_callables.py b/example-specs/task/nipype_internal/pydra-afni/center_mass_callables.py
new file mode 100644
index 00000000..6b6f0e54
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/center_mass_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in CenterMass.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-afni/clip_level.yaml b/example-specs/task/nipype_internal/pydra-afni/clip_level.yaml
new file mode 100644
index 00000000..93ddaceb
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/clip_level.yaml
@@ -0,0 +1,126 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.afni.preprocess.ClipLevel' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Estimates the value at which to clip the anatomical dataset so
+#        that background regions are set to zero.
+# 
+#     For complete details, see the `3dClipLevel Documentation.
+#     <https://afni.nimh.nih.gov/pub/dist/doc/program_help/3dClipLevel.html>`_
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces.afni import preprocess
+#     >>> cliplevel = preprocess.ClipLevel()
+#     >>> cliplevel.inputs.in_file = 'anatomical.nii'
+#     >>> cliplevel.cmdline
+#     '3dClipLevel anatomical.nii'
+#     >>> res = cliplevel.run()  # doctest: +SKIP
+# 
+#     
+task_name: ClipLevel
+nipype_name: ClipLevel
+nipype_module: nipype.interfaces.afni.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: input file to 3dClipLevel
+    grad: generic/file
+    # type=file|default=<undefined>: Also compute a 'gradual' clip level as a function of voxel position, and output that to a dataset.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to 3dClipLevel
+    mfrac:
+    # type=float|default=0.0: Use the number ff instead of 0.50 in the algorithm
+    doall:
+    # type=bool|default=False: Apply the algorithm to each sub-brick separately.
+    grad:
+    # type=file|default=<undefined>: Also compute a 'gradual' clip level as a function of voxel position, and output that to a dataset.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to 3dClipLevel
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: 3dClipLevel anatomical.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: input file to 3dClipLevel
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-afni/clip_level_callables.py b/example-specs/task/nipype_internal/pydra-afni/clip_level_callables.py
new file mode 100644
index 00000000..a6b60fcd
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/clip_level_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in ClipLevel.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-afni/convert_dset.yaml b/example-specs/task/nipype_internal/pydra-afni/convert_dset.yaml
new file mode 100644
index 00000000..e943fa02
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/convert_dset.yaml
@@ -0,0 +1,144 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.afni.utils.ConvertDset' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Converts a surface dataset from one format to another.
+# 
+#     For complete details, see the `ConvertDset Documentation.
+#     <https://afni.nimh.nih.gov/pub/dist/doc/program_help/ConvertDset.html>`_
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import afni
+#     >>> convertdset = afni.ConvertDset()
+#     >>> convertdset.inputs.in_file = 'lh.pial_converted.gii'
+#     >>> convertdset.inputs.out_type = 'niml_asc'
+#     >>> convertdset.inputs.out_file = 'lh.pial_converted.niml.dset'
+#     >>> convertdset.cmdline
+#     'ConvertDset -o_niml_asc -input lh.pial_converted.gii -prefix lh.pial_converted.niml.dset'
+#     >>> res = convertdset.run()  # doctest: +SKIP
+# 
+#     
+task_name: ConvertDset
+nipype_name: ConvertDset
+nipype_module: nipype.interfaces.afni.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/gifti
+    # type=file|default=<undefined>: input file to ConvertDset
+    out_file: medimage-afni/dset
+    # type=file: output file
+    # type=file|default=<undefined>: output file for ConvertDset
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: medimage-afni/dset
+    # type=file: output file
+    # type=file|default=<undefined>: output file for ConvertDset
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to ConvertDset
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output file for ConvertDset
+    out_type:
+    # type=enum|default='niml'|allowed['1D','1Dp','1Dpt','gii','gii_asc','gii_b64','gii_b64gz','niml','niml_asc','niml_bi']: output type
+    num_threads:
+    # type=int|default=1: set number of threads
+    outputtype:
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to ConvertDset
+    out_type: '"niml_asc"'
+    # type=enum|default='niml'|allowed['1D','1Dp','1Dpt','gii','gii_asc','gii_b64','gii_b64gz','niml','niml_asc','niml_bi']: output type
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output file for ConvertDset
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: ConvertDset -o_niml_asc -input lh.pial_converted.gii -prefix lh.pial_converted.niml.dset
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: input file to ConvertDset
+    out_type: '"niml_asc"'
+    # type=enum|default='niml'|allowed['1D','1Dp','1Dpt','gii','gii_asc','gii_b64','gii_b64gz','niml','niml_asc','niml_bi']: output type
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output file for ConvertDset
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-afni/convert_dset_callables.py b/example-specs/task/nipype_internal/pydra-afni/convert_dset_callables.py
new file mode 100644
index 00000000..8cd28c71
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/convert_dset_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in ConvertDset.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-afni/copy.yaml b/example-specs/task/nipype_internal/pydra-afni/copy.yaml
new file mode 100644
index 00000000..4ad5ff85
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/copy.yaml
@@ -0,0 +1,256 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.afni.utils.Copy' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Copies an image of one type to an image of the same
+#     or different type using 3dcopy command
+# 
+#     For complete details, see the `3dcopy Documentation.
+#     <https://afni.nimh.nih.gov/pub/dist/doc/program_help/3dcopy.html>`__
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import afni
+#     >>> copy3d = afni.Copy()
+#     >>> copy3d.inputs.in_file = 'functional.nii'
+#     >>> copy3d.cmdline
+#     '3dcopy functional.nii functional_copy'
+#     >>> res = copy3d.run()  # doctest: +SKIP
+# 
+#     >>> from copy import deepcopy
+#     >>> copy3d_2 = deepcopy(copy3d)
+#     >>> copy3d_2.inputs.outputtype = 'NIFTI'
+#     >>> copy3d_2.cmdline
+#     '3dcopy functional.nii functional_copy.nii'
+#     >>> res = copy3d_2.run()  # doctest: +SKIP
+# 
+#     >>> copy3d_3 = deepcopy(copy3d)
+#     >>> copy3d_3.inputs.outputtype = 'NIFTI_GZ'
+#     >>> copy3d_3.cmdline
+#     '3dcopy functional.nii functional_copy.nii.gz'
+#     >>> res = copy3d_3.run()  # doctest: +SKIP
+# 
+#     >>> copy3d_4 = deepcopy(copy3d)
+#     >>> copy3d_4.inputs.out_file = 'new_func.nii'
+#     >>> copy3d_4.cmdline
+#     '3dcopy functional.nii new_func.nii'
+#     >>> res = copy3d_4.run()  # doctest: +SKIP
+# 
+#     
+task_name: Copy
+nipype_name: Copy
+nipype_module: nipype.interfaces.afni.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: input file to 3dcopy
+    out_file: medimage/nifti1
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: medimage/nifti1
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to 3dcopy
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+    verbose:
+    # type=bool|default=False: print progress reports
+    num_threads:
+    # type=int|default=1: set number of threads
+    outputtype:
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to 3dcopy
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    outputtype: '"NIFTI"'
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+  imports: &id001
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  - module: copy
+    name: deepcopy
+    alias:
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    outputtype: '"NIFTI_GZ"'
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: 3dcopy functional.nii functional_copy
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: input file to 3dcopy
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: 3dcopy functional.nii functional_copy.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    outputtype: '"NIFTI"'
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+  imports: *id001
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: 3dcopy functional.nii functional_copy.nii.gz
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    outputtype: '"NIFTI_GZ"'
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: 3dcopy functional.nii new_func.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-afni/copy_callables.py b/example-specs/task/nipype_internal/pydra-afni/copy_callables.py
new file mode 100644
index 00000000..df0aabd9
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/copy_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Copy.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-afni/deconvolve.yaml b/example-specs/task/nipype_internal/pydra-afni/deconvolve.yaml
new file mode 100644
index 00000000..3128b9b7
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/deconvolve.yaml
@@ -0,0 +1,267 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.afni.model.Deconvolve' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Performs OLS regression given a 4D neuroimage file and stimulus timings
+# 
+#     For complete details, see the `3dDeconvolve Documentation.
+#     <https://afni.nimh.nih.gov/pub/dist/doc/program_help/3dDeconvolve.html>`_
+# 
+#     Examples
+#     ========
+# 
+#     >>> from nipype.interfaces import afni
+#     >>> deconvolve = afni.Deconvolve()
+#     >>> deconvolve.inputs.in_files = ['functional.nii', 'functional2.nii']
+#     >>> deconvolve.inputs.out_file = 'output.nii'
+#     >>> deconvolve.inputs.x1D = 'output.1D'
+#     >>> deconvolve.inputs.stim_times = [(1, 'timeseries.txt', 'SPMG1(4)')]
+#     >>> deconvolve.inputs.stim_label = [(1, 'Houses')]
+#     >>> deconvolve.inputs.gltsym = ['SYM: +Houses']
+#     >>> deconvolve.inputs.glt_label = [(1, 'Houses')]
+#     >>> deconvolve.cmdline
+#     "3dDeconvolve -input functional.nii functional2.nii -bucket output.nii -x1D output.1D -num_stimts 1 -stim_times 1 timeseries.txt 'SPMG1(4)' -stim_label 1 Houses -num_glt 1 -gltsym 'SYM: +Houses' -glt_label 1 Houses"
+#     >>> res = deconvolve.run()  # doctest: +SKIP
+#     
+task_name: Deconvolve
+nipype_name: Deconvolve
+nipype_module: nipype.interfaces.afni.model
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_files: medimage/nifti1+list-of
+    # type=inputmultiobject|default=[]: filenames of 3D+time input datasets. More than one filename can be given and the datasets will be auto-catenated in time. You can input a 1D time series file here, but the time axis should run along the ROW direction, not the COLUMN direction as in the 'input1D' option.
+    input1D: generic/file
+    # type=file|default=<undefined>: filename of single (fMRI) .1D time series where time runs down the column.
+    mask: generic/file
+    # type=file|default=<undefined>: filename of 3D mask dataset; only data time series from within the mask will be analyzed; results for voxels outside the mask will be set to zero.
+    STATmask: generic/file
+    # type=file|default=<undefined>: build a mask from provided file, and use this mask for the purpose of reporting truncation-to float issues AND for computing the FDR curves. The actual results ARE not masked with this option (only with 'mask' or 'automask' options).
+    censor: generic/file
+    # type=file|default=<undefined>: filename of censor .1D time series. This is a file of 1s and 0s, indicating which time points are to be included (1) and which are to be excluded (0).
+    x1D: medimage-afni/oned
+    # type=file: save out X matrix
+    # type=file|default=<undefined>: specify name for saved X matrix
+    out_file: medimage/nifti1
+    # type=file: output statistics file
+    # type=file|default=<undefined>: output statistics file
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: medimage/nifti1
+    # type=file: output statistics file
+    # type=file|default=<undefined>: output statistics file
+    reml_script: generic/file
+    # type=file: automatically generated script to run 3dREMLfit
+    x1D: medimage-afni/oned
+    # type=file: save out X matrix
+    # type=file|default=<undefined>: specify name for saved X matrix
+    cbucket: generic/file
+    # type=file: output regression coefficients file (if generated)
+    # type=str|default='': Name for dataset in which to save the regression coefficients (no statistics). This dataset will be used in a -xrestore run [not yet implemented] instead of the bucket dataset, if possible.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_files:
+    # type=inputmultiobject|default=[]: filenames of 3D+time input datasets. More than one filename can be given and the datasets will be auto-catenated in time. You can input a 1D time series file here, but the time axis should run along the ROW direction, not the COLUMN direction as in the 'input1D' option.
+    sat:
+    # type=bool|default=False: check the dataset time series for initial saturation transients, which should normally have been excised before data analysis.
+    trans:
+    # type=bool|default=False: check the dataset time series for initial saturation transients, which should normally have been excised before data analysis.
+    noblock:
+    # type=bool|default=False: normally, if you input multiple datasets with 'input', then the separate datasets are taken to be separate image runs that get separate baseline models. Use this options if you want to have the program consider these to be all one big run.* If any of the input dataset has only 1 sub-brick, then this option is automatically invoked!* If the auto-catenation feature isn't used, then this option has no effect, no how, no way.
+    force_TR:
+    # type=float|default=0.0: use this value instead of the TR in the 'input' dataset. (It's better to fix the input using Refit.)
+    input1D:
+    # type=file|default=<undefined>: filename of single (fMRI) .1D time series where time runs down the column.
+    TR_1D:
+    # type=float|default=0.0: TR to use with 'input1D'. This option has no effect if you do not also use 'input1D'.
+    legendre:
+    # type=bool|default=False: use Legendre polynomials for null hypothesis (baseline model)
+    nolegendre:
+    # type=bool|default=False: use power polynomials for null hypotheses. Don't do this unless you are crazy!
+    nodmbase:
+    # type=bool|default=False: don't de-mean baseline time series
+    dmbase:
+    # type=bool|default=False: de-mean baseline time series (default if 'polort' >= 0)
+    svd:
+    # type=bool|default=False: use SVD instead of Gaussian elimination (default)
+    nosvd:
+    # type=bool|default=False: use Gaussian elimination instead of SVD
+    rmsmin:
+    # type=float|default=0.0: minimum rms error to reject reduced model (default = 0; don't use this option normally!)
+    nocond:
+    # type=bool|default=False: DON'T calculate matrix condition number
+    singvals:
+    # type=bool|default=False: print out the matrix singular values
+    goforit:
+    # type=int|default=0: use this to proceed even if the matrix has bad problems (e.g., duplicate columns, large condition number, etc.).
+    allzero_OK:
+    # type=bool|default=False: don't consider all zero matrix columns to be the type of error that 'gotforit' is needed to ignore.
+    dname:
+    # type=tuple|default=('', ''): set environmental variable to provided value
+    mask:
+    # type=file|default=<undefined>: filename of 3D mask dataset; only data time series from within the mask will be analyzed; results for voxels outside the mask will be set to zero.
+    automask:
+    # type=bool|default=False: build a mask automatically from input data (will be slow for long time series datasets)
+    STATmask:
+    # type=file|default=<undefined>: build a mask from provided file, and use this mask for the purpose of reporting truncation-to float issues AND for computing the FDR curves. The actual results ARE not masked with this option (only with 'mask' or 'automask' options).
+    censor:
+    # type=file|default=<undefined>: filename of censor .1D time series. This is a file of 1s and 0s, indicating which time points are to be included (1) and which are to be excluded (0).
+    polort:
+    # type=int|default=0: degree of polynomial corresponding to the null hypothesis [default: 1]
+    ortvec:
+    # type=tuple|default=(<undefined>, ''): this option lets you input a rectangular array of 1 or more baseline vectors from a file. This method is a fast way to include a lot of baseline regressors in one step. 
+    x1D:
+    # type=file: save out X matrix
+    # type=file|default=<undefined>: specify name for saved X matrix
+    x1D_stop:
+    # type=bool|default=False: stop running after writing .xmat.1D file
+    cbucket:
+    # type=file: output regression coefficients file (if generated)
+    # type=str|default='': Name for dataset in which to save the regression coefficients (no statistics). This dataset will be used in a -xrestore run [not yet implemented] instead of the bucket dataset, if possible.
+    out_file:
+    # type=file: output statistics file
+    # type=file|default=<undefined>: output statistics file
+    num_threads:
+    # type=int|default=0: run the program with provided number of sub-processes
+    fout:
+    # type=bool|default=False: output F-statistic for each stimulus
+    rout:
+    # type=bool|default=False: output the R^2 statistic for each stimulus
+    tout:
+    # type=bool|default=False: output the T-statistic for each stimulus
+    vout:
+    # type=bool|default=False: output the sample variance (MSE) for each stimulus
+    nofdr:
+    # type=bool|default=False: Don't compute the statistic-vs-FDR curves for the bucket dataset.
+    global_times:
+    # type=bool|default=False: use global timing for stimulus timing files
+    local_times:
+    # type=bool|default=False: use local timing for stimulus timing files
+    num_stimts:
+    # type=int|default=0: number of stimulus timing files
+    stim_times:
+    # type=list|default=[]: generate a response model from a set of stimulus times given in file.
+    stim_label:
+    # type=list|default=[]: label for kth input stimulus (e.g., Label1)
+    stim_times_subtract:
+    # type=float|default=0.0: this option means to subtract specified seconds from each time encountered in any 'stim_times' option. The purpose of this option is to make it simple to adjust timing files for the removal of images from the start of each imaging run.
+    num_glt:
+    # type=int|default=0: number of general linear tests (i.e., contrasts)
+    gltsym:
+    # type=list|default=[]: general linear tests (i.e., contrasts) using symbolic conventions (e.g., '+Label1 -Label2')
+    glt_label:
+    # type=list|default=[]: general linear test (i.e., contrast) labels
+    outputtype:
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_files:
+    # type=inputmultiobject|default=[]: filenames of 3D+time input datasets. More than one filename can be given and the datasets will be auto-catenated in time. You can input a 1D time series file here, but the time axis should run along the ROW direction, not the COLUMN direction as in the 'input1D' option.
+    out_file:
+    # type=file: output statistics file
+    # type=file|default=<undefined>: output statistics file
+    x1D:
+    # type=file: save out X matrix
+    # type=file|default=<undefined>: specify name for saved X matrix
+    stim_times: '[(1, "timeseries.txt", "SPMG1(4)")]'
+    # type=list|default=[]: generate a response model from a set of stimulus times given in file.
+    stim_label: '[(1, "Houses")]'
+    # type=list|default=[]: label for kth input stimulus (e.g., Label1)
+    gltsym: '["SYM: +Houses"]'
+    # type=list|default=[]: general linear tests (i.e., contrasts) using symbolic conventions (e.g., '+Label1 -Label2')
+    glt_label: '[(1, "Houses")]'
+    # type=list|default=[]: general linear test (i.e., contrast) labels
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: '3dDeconvolve -input functional.nii functional2.nii -bucket output.nii -x1D output.1D -num_stimts 1 -stim_times 1 timeseries.txt "SPMG1(4)" -stim_label 1 Houses -num_glt 1 -gltsym "SYM: +Houses" -glt_label 1 Houses'
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_files:
+    # type=inputmultiobject|default=[]: filenames of 3D+time input datasets. More than one filename can be given and the datasets will be auto-catenated in time. You can input a 1D time series file here, but the time axis should run along the ROW direction, not the COLUMN direction as in the 'input1D' option.
+    out_file:
+    # type=file: output statistics file
+    # type=file|default=<undefined>: output statistics file
+    x1D:
+    # type=file: save out X matrix
+    # type=file|default=<undefined>: specify name for saved X matrix
+    stim_times: '[(1, "timeseries.txt", "SPMG1(4)")]'
+    # type=list|default=[]: generate a response model from a set of stimulus times given in file.
+    stim_label: '[(1, "Houses")]'
+    # type=list|default=[]: label for kth input stimulus (e.g., Label1)
+    gltsym: '["SYM: +Houses"]'
+    # type=list|default=[]: general linear tests (i.e., contrasts) using symbolic conventions (e.g., '+Label1 -Label2')
+    glt_label: '[(1, "Houses")]'
+    # type=list|default=[]: general linear test (i.e., contrast) labels
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-afni/deconvolve_callables.py b/example-specs/task/nipype_internal/pydra-afni/deconvolve_callables.py
new file mode 100644
index 00000000..7c50d913
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/deconvolve_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Deconvolve.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-afni/degree_centrality.yaml b/example-specs/task/nipype_internal/pydra-afni/degree_centrality.yaml
new file mode 100644
index 00000000..ce9098ef
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/degree_centrality.yaml
@@ -0,0 +1,168 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.afni.preprocess.DegreeCentrality' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Performs degree centrality on a dataset using a given maskfile
+#     via 3dDegreeCentrality
+# 
+#     For complete details, see the `3dDegreeCentrality Documentation.
+#     <https://afni.nimh.nih.gov/pub/dist/doc/program_help/3dDegreeCentrality.html>`_
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import afni
+#     >>> degree = afni.DegreeCentrality()
+#     >>> degree.inputs.in_file = 'functional.nii'
+#     >>> degree.inputs.mask = 'mask.nii'
+#     >>> degree.inputs.sparsity = 1 # keep the top one percent of connections
+#     >>> degree.inputs.out_file = 'out.nii'
+#     >>> degree.cmdline
+#     '3dDegreeCentrality -mask mask.nii -prefix out.nii -sparsity 1.000000 functional.nii'
+#     >>> res = degree.run()  # doctest: +SKIP
+# 
+#     
+task_name: DegreeCentrality
+nipype_name: DegreeCentrality
+nipype_module: nipype.interfaces.afni.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: input file to 3dDegreeCentrality
+    mask: medimage/nifti1
+    # type=file|default=<undefined>: mask file to mask input data
+    out_file: medimage/nifti1
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    oned_file: generic/file
+    # type=file: The text output of the similarity matrix computed after thresholding with one-dimensional and ijk voxel indices, correlations, image extents, and affine matrix.
+    # type=str|default='': output filepath to text dump of correlation matrix
+    out_file: medimage/nifti1
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to 3dDegreeCentrality
+    sparsity:
+    # type=float|default=0.0: only take the top percent of connections
+    oned_file:
+    # type=file: The text output of the similarity matrix computed after thresholding with one-dimensional and ijk voxel indices, correlations, image extents, and affine matrix.
+    # type=str|default='': output filepath to text dump of correlation matrix
+    mask:
+    # type=file|default=<undefined>: mask file to mask input data
+    thresh:
+    # type=float|default=0.0: threshold to exclude connections where corr <= thresh
+    polort:
+    # type=int|default=0: 
+    autoclip:
+    # type=bool|default=False: Clip off low-intensity regions in the dataset
+    automask:
+    # type=bool|default=False: Mask the dataset to target brain-only voxels
+    num_threads:
+    # type=int|default=1: set number of threads
+    outputtype:
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to 3dDegreeCentrality
+    mask:
+    # type=file|default=<undefined>: mask file to mask input data
+    sparsity: '1 # keep the top one percent of connections'
+    # type=float|default=0.0: only take the top percent of connections
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: 3dDegreeCentrality -mask mask.nii -prefix out.nii -sparsity 1.000000 functional.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: input file to 3dDegreeCentrality
+    mask:
+    # type=file|default=<undefined>: mask file to mask input data
+    sparsity: '1 # keep the top one percent of connections'
+    # type=float|default=0.0: only take the top percent of connections
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-afni/degree_centrality_callables.py b/example-specs/task/nipype_internal/pydra-afni/degree_centrality_callables.py
new file mode 100644
index 00000000..a13ac89d
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/degree_centrality_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in DegreeCentrality.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-afni/despike.yaml b/example-specs/task/nipype_internal/pydra-afni/despike.yaml
new file mode 100644
index 00000000..35b7a555
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/despike.yaml
@@ -0,0 +1,130 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.afni.preprocess.Despike' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Removes 'spikes' from the 3D+time input dataset
+# 
+#     For complete details, see the `3dDespike Documentation.
+#     <https://afni.nimh.nih.gov/pub/dist/doc/program_help/3dDespike.html>`_
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import afni
+#     >>> despike = afni.Despike()
+#     >>> despike.inputs.in_file = 'functional.nii'
+#     >>> despike.cmdline
+#     '3dDespike -prefix functional_despike functional.nii'
+#     >>> res = despike.run()  # doctest: +SKIP
+# 
+#     
+task_name: Despike
+nipype_name: Despike
+nipype_module: nipype.interfaces.afni.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: input file to 3dDespike
+    out_file: generic/file
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to 3dDespike
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+    num_threads:
+    # type=int|default=1: set number of threads
+    outputtype:
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to 3dDespike
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: 3dDespike -prefix functional_despike functional.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: input file to 3dDespike
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-afni/despike_callables.py b/example-specs/task/nipype_internal/pydra-afni/despike_callables.py
new file mode 100644
index 00000000..59a29b61
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/despike_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Despike.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-afni/detrend.yaml b/example-specs/task/nipype_internal/pydra-afni/detrend.yaml
new file mode 100644
index 00000000..659dab4d
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/detrend.yaml
@@ -0,0 +1,141 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.afni.preprocess.Detrend' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# This program removes components from voxel time series using
+#     linear least squares
+# 
+#     For complete details, see the `3dDetrend Documentation.
+#     <https://afni.nimh.nih.gov/pub/dist/doc/program_help/3dDetrend.html>`_
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import afni
+#     >>> detrend = afni.Detrend()
+#     >>> detrend.inputs.in_file = 'functional.nii'
+#     >>> detrend.inputs.args = '-polort 2'
+#     >>> detrend.inputs.outputtype = 'AFNI'
+#     >>> detrend.cmdline
+#     '3dDetrend -polort 2 -prefix functional_detrend functional.nii'
+#     >>> res = detrend.run()  # doctest: +SKIP
+# 
+#     
+task_name: Detrend
+nipype_name: Detrend
+nipype_module: nipype.interfaces.afni.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: input file to 3dDetrend
+    out_file: generic/file
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to 3dDetrend
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+    num_threads:
+    # type=int|default=1: set number of threads
+    outputtype:
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to 3dDetrend
+    args: '"-polort 2"'
+    # type=str|default='': Additional parameters to the command
+    outputtype: '"AFNI"'
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: 3dDetrend -polort 2 -prefix functional_detrend functional.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: input file to 3dDetrend
+    args: '"-polort 2"'
+    # type=str|default='': Additional parameters to the command
+    outputtype: '"AFNI"'
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-afni/detrend_callables.py b/example-specs/task/nipype_internal/pydra-afni/detrend_callables.py
new file mode 100644
index 00000000..cae6cbf3
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/detrend_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Detrend.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-afni/dot.yaml b/example-specs/task/nipype_internal/pydra-afni/dot.yaml
new file mode 100644
index 00000000..591bd16d
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/dot.yaml
@@ -0,0 +1,172 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.afni.utils.Dot' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Correlation coefficient between sub-brick pairs.
+#     All datasets in in_files list will be concatenated.
+#     You can use sub-brick selectors in the file specification.
+# 
+#     .. warning::
+# 
+#         This program is not efficient when more than two subbricks are input.
+# 
+#     For complete details, see the `3ddot Documentation.
+#     <https://afni.nimh.nih.gov/pub/dist/doc/program_help/3ddot.html>`_
+# 
+#     >>> from nipype.interfaces import afni
+#     >>> dot = afni.Dot()
+#     >>> dot.inputs.in_files = ['functional.nii[0]', 'structural.nii']
+#     >>> dot.inputs.dodice = True
+#     >>> dot.inputs.out_file = 'out.mask_ae_dice.txt'
+#     >>> dot.cmdline
+#     '3dDot -dodice functional.nii[0]  structural.nii   |& tee out.mask_ae_dice.txt'
+#     >>> res = copy3d.run()  # doctest: +SKIP
+# 
+#     
+task_name: Dot
+nipype_name: Dot
+nipype_module: nipype.interfaces.afni.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_files: medimage-afni/nii[0]+list-of
+    # type=list|default=[]: list of input files, possibly with subbrick selectors
+    out_file: text/text-file
+    # type=file: output file
+    # type=file|default=<undefined>: collect output to a file
+    mask: generic/file
+    # type=file|default=<undefined>: Use this dataset as a mask
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: text/text-file
+    # type=file: output file
+    # type=file|default=<undefined>: collect output to a file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_files:
+    # type=list|default=[]: list of input files, possibly with subbrick selectors
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: collect output to a file
+    mask:
+    # type=file|default=<undefined>: Use this dataset as a mask
+    mrange:
+    # type=tuple|default=(<traits.trait_types.Float object at 0x11cfd1250>, <traits.trait_types.Float object at 0x11cfd1150>): Means to further restrict the voxels from 'mset' so thatonly those mask values within this range (inclusive) willbe used.
+    demean:
+    # type=bool|default=False: Remove the mean from each volume prior to computing the correlation
+    docor:
+    # type=bool|default=False: Return the correlation coefficient (default).
+    dodot:
+    # type=bool|default=False: Return the dot product (unscaled).
+    docoef:
+    # type=bool|default=False: Return the least square fit coefficients {{a,b}} so that dset2 is approximately a + b\*dset1
+    dosums:
+    # type=bool|default=False: Return the 6 numbers xbar=<x> ybar=<y> <(x-xbar)^2> <(y-ybar)^2> <(x-xbar)(y-ybar)> and the correlation coefficient.
+    dodice:
+    # type=bool|default=False: Return the Dice coefficient (the Sorensen-Dice index).
+    doeta2:
+    # type=bool|default=False: Return eta-squared (Cohen, NeuroImage 2008).
+    full:
+    # type=bool|default=False: Compute the whole matrix. A waste of time, but handy for parsing.
+    show_labels:
+    # type=bool|default=False: Print sub-brick labels to help identify what is being correlated. This option is useful whenyou have more than 2 sub-bricks at input.
+    upper:
+    # type=bool|default=False: Compute upper triangular matrix
+    num_threads:
+    # type=int|default=1: set number of threads
+    outputtype:
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_files:
+    # type=list|default=[]: list of input files, possibly with subbrick selectors
+    dodice: 'True'
+    # type=bool|default=False: Return the Dice coefficient (the Sorensen-Dice index).
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: collect output to a file
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: 3dDot -dodice functional.nii[0] structural.nii |& tee out.mask_ae_dice.txt
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_files:
+    # type=list|default=[]: list of input files, possibly with subbrick selectors
+    dodice: 'True'
+    # type=bool|default=False: Return the Dice coefficient (the Sorensen-Dice index).
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: collect output to a file
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-afni/dot_callables.py b/example-specs/task/nipype_internal/pydra-afni/dot_callables.py
new file mode 100644
index 00000000..1ecb48b1
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/dot_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Dot.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-afni/ecm.yaml b/example-specs/task/nipype_internal/pydra-afni/ecm.yaml
new file mode 100644
index 00000000..abbb056a
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/ecm.yaml
@@ -0,0 +1,176 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.afni.preprocess.ECM' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Performs degree centrality on a dataset using a given maskfile
+#     via the 3dECM command
+# 
+#     For complete details, see the `3dECM Documentation.
+#     <https://afni.nimh.nih.gov/pub/dist/doc/program_help/3dECM.html>`_
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import afni
+#     >>> ecm = afni.ECM()
+#     >>> ecm.inputs.in_file = 'functional.nii'
+#     >>> ecm.inputs.mask = 'mask.nii'
+#     >>> ecm.inputs.sparsity = 0.1 # keep top 0.1% of connections
+#     >>> ecm.inputs.out_file = 'out.nii'
+#     >>> ecm.cmdline
+#     '3dECM -mask mask.nii -prefix out.nii -sparsity 0.100000 functional.nii'
+#     >>> res = ecm.run()  # doctest: +SKIP
+# 
+#     
+task_name: ECM
+nipype_name: ECM
+nipype_module: nipype.interfaces.afni.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: input file to 3dECM
+    mask: medimage/nifti1
+    # type=file|default=<undefined>: mask file to mask input data
+    out_file: medimage/nifti1
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: medimage/nifti1
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to 3dECM
+    sparsity:
+    # type=float|default=0.0: only take the top percent of connections
+    full:
+    # type=bool|default=False: Full power method; enables thresholding; automatically selected if -thresh or -sparsity are set
+    fecm:
+    # type=bool|default=False: Fast centrality method; substantial speed increase but cannot accommodate thresholding; automatically selected if -thresh or -sparsity are not set
+    shift:
+    # type=float|default=0.0: shift correlation coefficients in similarity matrix to enforce non-negativity, s >= 0.0; default = 0.0 for -full, 1.0 for -fecm
+    scale:
+    # type=float|default=0.0: scale correlation coefficients in similarity matrix to after shifting, x >= 0.0; default = 1.0 for -full, 0.5 for -fecm
+    eps:
+    # type=float|default=0.0: sets the stopping criterion for the power iteration; :math:`l2\|v_\text{old} - v_\text{new}\| < eps\|v_\text{old}\|`; default = 0.001
+    max_iter:
+    # type=int|default=0: sets the maximum number of iterations to use in the power iteration; default = 1000
+    memory:
+    # type=float|default=0.0: Limit memory consumption on system by setting the amount of GB to limit the algorithm to; default = 2GB
+    mask:
+    # type=file|default=<undefined>: mask file to mask input data
+    thresh:
+    # type=float|default=0.0: threshold to exclude connections where corr <= thresh
+    polort:
+    # type=int|default=0: 
+    autoclip:
+    # type=bool|default=False: Clip off low-intensity regions in the dataset
+    automask:
+    # type=bool|default=False: Mask the dataset to target brain-only voxels
+    num_threads:
+    # type=int|default=1: set number of threads
+    outputtype:
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to 3dECM
+    mask:
+    # type=file|default=<undefined>: mask file to mask input data
+    sparsity: '0.1 # keep top 0.1% of connections'
+    # type=float|default=0.0: only take the top percent of connections
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: 3dECM -mask mask.nii -prefix out.nii -sparsity 0.100000 functional.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: input file to 3dECM
+    mask:
+    # type=file|default=<undefined>: mask file to mask input data
+    sparsity: '0.1 # keep top 0.1% of connections'
+    # type=float|default=0.0: only take the top percent of connections
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-afni/ecm_callables.py b/example-specs/task/nipype_internal/pydra-afni/ecm_callables.py
new file mode 100644
index 00000000..55c619b1
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/ecm_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in ECM.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-afni/edge_3.yaml b/example-specs/task/nipype_internal/pydra-afni/edge_3.yaml
new file mode 100644
index 00000000..4f595ea9
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/edge_3.yaml
@@ -0,0 +1,155 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.afni.utils.Edge3' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Does 3D Edge detection using the library 3DEdge
+#     by Gregoire Malandain.
+# 
+#     For complete details, see the `3dedge3 Documentation.
+#     <https://afni.nimh.nih.gov/pub/dist/doc/program_help/3dedge3.html>`_
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import afni
+#     >>> edge3 = afni.Edge3()
+#     >>> edge3.inputs.in_file = 'functional.nii'
+#     >>> edge3.inputs.out_file = 'edges.nii'
+#     >>> edge3.inputs.datum = 'byte'
+#     >>> edge3.cmdline
+#     '3dedge3 -input functional.nii -datum byte -prefix edges.nii'
+#     >>> res = edge3.run()  # doctest: +SKIP
+# 
+#     
+task_name: Edge3
+nipype_name: Edge3
+nipype_module: nipype.interfaces.afni.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: input file to 3dedge3
+    out_file: medimage/nifti1
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: medimage/nifti1
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to 3dedge3
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+    datum:
+    # type=enum|default='byte'|allowed['byte','float','short']: specify data type for output. Valid types are 'byte', 'short' and 'float'.
+    fscale:
+    # type=bool|default=False: Force scaling of the output to the maximum integer range.
+    gscale:
+    # type=bool|default=False: Same as '-fscale', but also forces each output sub-brick to to get the same scaling factor.
+    nscale:
+    # type=bool|default=False: Don't do any scaling on output to byte or short datasets.
+    scale_floats:
+    # type=float|default=0.0: Multiply input by VAL, but only if the input datum is float. This is needed when the input dataset has a small range, like 0 to 2.0 for instance. With such a range, very few edges are detected due to what I suspect to be truncation problems. Multiplying such a dataset by 10000 fixes the problem and the scaling is undone at the output.
+    verbose:
+    # type=bool|default=False: Print out some information along the way.
+    num_threads:
+    # type=int|default=1: set number of threads
+    outputtype:
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to 3dedge3
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+    datum: '"byte"'
+    # type=enum|default='byte'|allowed['byte','float','short']: specify data type for output. Valid types are 'byte', 'short' and 'float'.
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: 3dedge3 -input functional.nii -datum byte -prefix edges.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: input file to 3dedge3
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+    datum: '"byte"'
+    # type=enum|default='byte'|allowed['byte','float','short']: specify data type for output. Valid types are 'byte', 'short' and 'float'.
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-afni/edge_3_callables.py b/example-specs/task/nipype_internal/pydra-afni/edge_3_callables.py
new file mode 100644
index 00000000..7836b475
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/edge_3_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Edge3.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-afni/eval.yaml b/example-specs/task/nipype_internal/pydra-afni/eval.yaml
new file mode 100644
index 00000000..041d2776
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/eval.yaml
@@ -0,0 +1,175 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.afni.utils.Eval' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Evaluates an expression that may include columns of data from one or
+#     more text files.
+# 
+#     For complete details, see the `1deval Documentation.
+#     <https://afni.nimh.nih.gov/pub/dist/doc/program_help/1deval.html>`_
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import afni
+#     >>> eval = afni.Eval()
+#     >>> eval.inputs.in_file_a = 'seed.1D'
+#     >>> eval.inputs.in_file_b = 'resp.1D'
+#     >>> eval.inputs.expr = 'a*b'
+#     >>> eval.inputs.out1D = True
+#     >>> eval.inputs.out_file =  'data_calc.1D'
+#     >>> eval.cmdline
+#     '1deval -a seed.1D -b resp.1D -expr "a*b" -1D -prefix data_calc.1D'
+#     >>> res = eval.run()  # doctest: +SKIP
+# 
+#     
+task_name: Eval
+nipype_name: Eval
+nipype_module: nipype.interfaces.afni.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file_a: medimage-afni/oned
+    # type=file|default=<undefined>: input file to 1deval
+    in_file_b: medimage-afni/oned
+    # type=file|default=<undefined>: operand file to 1deval
+    in_file_c: generic/file
+    # type=file|default=<undefined>: operand file to 1deval
+    out_file: medimage-afni/oned
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+    other: generic/file
+    # type=file|default=<undefined>: other options
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: medimage-afni/oned
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file_a:
+    # type=file|default=<undefined>: input file to 1deval
+    in_file_b:
+    # type=file|default=<undefined>: operand file to 1deval
+    in_file_c:
+    # type=file|default=<undefined>: operand file to 1deval
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+    out1D:
+    # type=bool|default=False: output in 1D
+    expr:
+    # type=str|default='': expr
+    start_idx:
+    # type=int|default=0: start index for in_file_a
+    stop_idx:
+    # type=int|default=0: stop index for in_file_a
+    single_idx:
+    # type=int|default=0: volume index for in_file_a
+    other:
+    # type=file|default=<undefined>: other options
+    num_threads:
+    # type=int|default=1: set number of threads
+    outputtype:
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file_a:
+    # type=file|default=<undefined>: input file to 1deval
+    in_file_b:
+    # type=file|default=<undefined>: operand file to 1deval
+    expr: '"a*b"'
+    # type=str|default='': expr
+    out1D: 'True'
+    # type=bool|default=False: output in 1D
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: 1deval -a seed.1D -b resp.1D -expr "a*b" -1D -prefix data_calc.1D
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file_a:
+    # type=file|default=<undefined>: input file to 1deval
+    in_file_b:
+    # type=file|default=<undefined>: operand file to 1deval
+    expr: '"a*b"'
+    # type=str|default='': expr
+    out1D: 'True'
+    # type=bool|default=False: output in 1D
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-afni/eval_callables.py b/example-specs/task/nipype_internal/pydra-afni/eval_callables.py
new file mode 100644
index 00000000..8bae81cc
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/eval_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Eval.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-afni/fim.yaml b/example-specs/task/nipype_internal/pydra-afni/fim.yaml
new file mode 100644
index 00000000..0a8344b0
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/fim.yaml
@@ -0,0 +1,161 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.afni.preprocess.Fim' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Program to calculate the cross-correlation of an ideal reference
+#     waveform with the measured FMRI time series for each voxel.
+# 
+#     For complete details, see the `3dfim+ Documentation.
+#     <https://afni.nimh.nih.gov/pub/dist/doc/program_help/3dfim+.html>`_
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import afni
+#     >>> fim = afni.Fim()
+#     >>> fim.inputs.in_file = 'functional.nii'
+#     >>> fim.inputs.ideal_file= 'seed.1D'
+#     >>> fim.inputs.out_file = 'functional_corr.nii'
+#     >>> fim.inputs.out = 'Correlation'
+#     >>> fim.inputs.fim_thr = 0.0009
+#     >>> fim.cmdline
+#     '3dfim+ -input functional.nii -ideal_file seed.1D -fim_thr 0.000900 -out Correlation -bucket functional_corr.nii'
+#     >>> res = fim.run()  # doctest: +SKIP
+# 
+#     
+task_name: Fim
+nipype_name: Fim
+nipype_module: nipype.interfaces.afni.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: input file to 3dfim+
+    out_file: medimage/nifti1
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+    ideal_file: medimage-afni/oned
+    # type=file|default=<undefined>: ideal time series file name
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: medimage/nifti1
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to 3dfim+
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+    ideal_file:
+    # type=file|default=<undefined>: ideal time series file name
+    fim_thr:
+    # type=float|default=0.0: fim internal mask threshold value
+    out:
+    # type=str|default='': Flag to output the specified parameter
+    num_threads:
+    # type=int|default=1: set number of threads
+    outputtype:
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to 3dfim+
+    ideal_file:
+    # type=file|default=<undefined>: ideal time series file name
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+    out: '"Correlation"'
+    # type=str|default='': Flag to output the specified parameter
+    fim_thr: '0.0009'
+    # type=float|default=0.0: fim internal mask threshold value
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: 3dfim+ -input functional.nii -ideal_file seed.1D -fim_thr 0.000900 -out Correlation -bucket functional_corr.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: input file to 3dfim+
+    ideal_file:
+    # type=file|default=<undefined>: ideal time series file name
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+    out: '"Correlation"'
+    # type=str|default='': Flag to output the specified parameter
+    fim_thr: '0.0009'
+    # type=float|default=0.0: fim internal mask threshold value
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-afni/fim_callables.py b/example-specs/task/nipype_internal/pydra-afni/fim_callables.py
new file mode 100644
index 00000000..e01594a5
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/fim_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Fim.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-afni/fourier.yaml b/example-specs/task/nipype_internal/pydra-afni/fourier.yaml
new file mode 100644
index 00000000..f59aa2a8
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/fourier.yaml
@@ -0,0 +1,152 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.afni.preprocess.Fourier' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Program to lowpass and/or highpass each voxel time series in a
+#     dataset, via the FFT
+# 
+#     For complete details, see the `3dFourier Documentation.
+#     <https://afni.nimh.nih.gov/pub/dist/doc/program_help/3dFourier.html>`_
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import afni
+#     >>> fourier = afni.Fourier()
+#     >>> fourier.inputs.in_file = 'functional.nii'
+#     >>> fourier.inputs.retrend = True
+#     >>> fourier.inputs.highpass = 0.005
+#     >>> fourier.inputs.lowpass = 0.1
+#     >>> fourier.cmdline
+#     '3dFourier -highpass 0.005000 -lowpass 0.100000 -prefix functional_fourier -retrend functional.nii'
+#     >>> res = fourier.run()  # doctest: +SKIP
+# 
+#     
+task_name: Fourier
+nipype_name: Fourier
+nipype_module: nipype.interfaces.afni.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: input file to 3dFourier
+    out_file: generic/file
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to 3dFourier
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+    lowpass:
+    # type=float|default=0.0: lowpass
+    highpass:
+    # type=float|default=0.0: highpass
+    retrend:
+    # type=bool|default=False: Any mean and linear trend are removed before filtering. This will restore the trend after filtering.
+    num_threads:
+    # type=int|default=1: set number of threads
+    outputtype:
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to 3dFourier
+    retrend: 'True'
+    # type=bool|default=False: Any mean and linear trend are removed before filtering. This will restore the trend after filtering.
+    highpass: '0.005'
+    # type=float|default=0.0: highpass
+    lowpass: '0.1'
+    # type=float|default=0.0: lowpass
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: 3dFourier -highpass 0.005000 -lowpass 0.100000 -prefix functional_fourier -retrend functional.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: input file to 3dFourier
+    retrend: 'True'
+    # type=bool|default=False: Any mean and linear trend are removed before filtering. This will restore the trend after filtering.
+    highpass: '0.005'
+    # type=float|default=0.0: highpass
+    lowpass: '0.1'
+    # type=float|default=0.0: lowpass
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-afni/fourier_callables.py b/example-specs/task/nipype_internal/pydra-afni/fourier_callables.py
new file mode 100644
index 00000000..fef4f76e
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/fourier_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Fourier.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-afni/fwh_mx.yaml b/example-specs/task/nipype_internal/pydra-afni/fwh_mx.yaml
new file mode 100644
index 00000000..d32bdd7f
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/fwh_mx.yaml
@@ -0,0 +1,247 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.afni.utils.FWHMx' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Unlike the older 3dFWHM, this program computes FWHMs for all sub-bricks
+#     in the input dataset, each one separately.  The output for each one is
+#     written to the file specified by '-out'.  The mean (arithmetic or geometric)
+#     of all the FWHMs along each axis is written to stdout.  (A non-positive
+#     output value indicates something bad happened; e.g., FWHM in z is meaningless
+#     for a 2D dataset; the estimation method computed incoherent intermediate results.)
+# 
+#     For complete details, see the `3dFWHMx Documentation.
+#     <https://afni.nimh.nih.gov/pub../pub/dist/doc/program_help/3dFWHMx.html>`_
+# 
+#     (Classic) METHOD:
+# 
+#       * Calculate ratio of variance of first differences to data variance.
+#       * Should be the same as 3dFWHM for a 1-brick dataset.
+#         (But the output format is simpler to use in a script.)
+# 
+# 
+#     .. note:: IMPORTANT NOTE [AFNI > 16]
+# 
+#       A completely new method for estimating and using noise smoothness values is
+#       now available in 3dFWHMx and 3dClustSim. This method is implemented in the
+#       '-acf' options to both programs.  'ACF' stands for (spatial) AutoCorrelation
+#       Function, and it is estimated by calculating moments of differences out to
+#       a larger radius than before.
+# 
+#       Notably, real FMRI data does not actually have a Gaussian-shaped ACF, so the
+#       estimated ACF is then fit (in 3dFWHMx) to a mixed model (Gaussian plus
+#       mono-exponential) of the form
+# 
+#         .. math::
+# 
+#           ACF(r) = a * exp(-r*r/(2*b*b)) + (1-a)*exp(-r/c)
+# 
+# 
+#       where :math:`r` is the radius, and :math:`a, b, c` are the fitted parameters.
+#       The apparent FWHM from this model is usually somewhat larger in real data
+#       than the FWHM estimated from just the nearest-neighbor differences used
+#       in the 'classic' analysis.
+# 
+#       The longer tails provided by the mono-exponential are also significant.
+#       3dClustSim has also been modified to use the ACF model given above to generate
+#       noise random fields.
+# 
+#     .. note:: TL;DR or summary
+# 
+#       The take-awaymessage is that the 'classic' 3dFWHMx and
+#       3dClustSim analysis, using a pure Gaussian ACF, is not very correct for
+#       FMRI data -- I cannot speak for PET or MEG data.
+# 
+#     .. warning::
+# 
+#       Do NOT use 3dFWHMx on the statistical results (e.g., '-bucket') from
+#       3dDeconvolve or 3dREMLfit!!!  The function of 3dFWHMx is to estimate
+#       the smoothness of the time series NOISE, not of the statistics. This
+#       proscription is especially true if you plan to use 3dClustSim next!!
+# 
+#     .. note:: Recommendations
+# 
+#       * For FMRI statistical purposes, you DO NOT want the FWHM to reflect
+#         the spatial structure of the underlying anatomy.  Rather, you want
+#         the FWHM to reflect the spatial structure of the noise.  This means
+#         that the input dataset should not have anatomical (spatial) structure.
+#       * One good form of input is the output of '3dDeconvolve -errts', which is
+#         the dataset of residuals left over after the GLM fitted signal model is
+#         subtracted out from each voxel's time series.
+#       * If you don't want to go to that much trouble, use '-detrend' to approximately
+#         subtract out the anatomical spatial structure, OR use the output of 3dDetrend
+#         for the same purpose.
+#       * If you do not use '-detrend', the program attempts to find non-zero spatial
+#         structure in the input, and will print a warning message if it is detected.
+# 
+#     .. note:: Notes on -demend
+# 
+#       * I recommend this option, and it is not the default only for historical
+#         compatibility reasons.  It may become the default someday.
+#       * It is already the default in program 3dBlurToFWHM. This is the same detrending
+#         as done in 3dDespike; using 2*q+3 basis functions for q > 0.
+#       * If you don't use '-detrend', the program now [Aug 2010] checks if a large number
+#         of voxels are have significant nonzero means. If so, the program will print a
+#         warning message suggesting the use of '-detrend', since inherent spatial
+#         structure in the image will bias the estimation of the FWHM of the image time
+#         series NOISE (which is usually the point of using 3dFWHMx).
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import afni
+#     >>> fwhm = afni.FWHMx()
+#     >>> fwhm.inputs.in_file = 'functional.nii'
+#     >>> fwhm.cmdline
+#     '3dFWHMx -input functional.nii -out functional_subbricks.out > functional_fwhmx.out'
+#     >>> res = fwhm.run()  # doctest: +SKIP
+# 
+#     
+task_name: FWHMx
+nipype_name: FWHMx
+nipype_module: nipype.interfaces.afni.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: input dataset
+    out_file: generic/file
+    # type=file: output file
+    # type=file|default=<undefined>: output file
+    out_subbricks: generic/file
+    # type=file: output file (subbricks)
+    # type=file|default=<undefined>: output file listing the subbricks FWHM
+    mask: generic/file
+    # type=file|default=<undefined>: use only voxels that are nonzero in mask
+    out_detrend: generic/file
+    # type=file: output file, detrended
+    # type=file|default=<undefined>: Save the detrended file into a dataset
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: output file
+    # type=file|default=<undefined>: output file
+    out_subbricks: generic/file
+    # type=file: output file (subbricks)
+    # type=file|default=<undefined>: output file listing the subbricks FWHM
+    out_detrend: generic/file
+    # type=file: output file, detrended
+    # type=file|default=<undefined>: Save the detrended file into a dataset
+    out_acf: generic/file
+    # type=file: output acf file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input dataset
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output file
+    out_subbricks:
+    # type=file: output file (subbricks)
+    # type=file|default=<undefined>: output file listing the subbricks FWHM
+    mask:
+    # type=file|default=<undefined>: use only voxels that are nonzero in mask
+    automask:
+    # type=bool|default=False: compute a mask from THIS dataset, a la 3dAutomask
+    detrend:
+    # type=traitcompound|default=False: instead of demed (0th order detrending), detrend to the specified order.  If order is not given, the program picks q=NT/30. -detrend disables -demed, and includes -unif.
+    demed:
+    # type=bool|default=False: If the input dataset has more than one sub-brick (e.g., has a time axis), then subtract the median of each voxel's time series before processing FWHM. This will tend to remove intrinsic spatial structure and leave behind the noise.
+    unif:
+    # type=bool|default=False: If the input dataset has more than one sub-brick, then normalize each voxel's time series to have the same MAD before processing FWHM.
+    out_detrend:
+    # type=file: output file, detrended
+    # type=file|default=<undefined>: Save the detrended file into a dataset
+    geom:
+    # type=bool|default=False: if in_file has more than one sub-brick, compute the final estimate as the geometric mean of the individual sub-brick FWHM estimates
+    arith:
+    # type=bool|default=False: if in_file has more than one sub-brick, compute the final estimate as the arithmetic mean of the individual sub-brick FWHM estimates
+    combine:
+    # type=bool|default=False: combine the final measurements along each axis
+    compat:
+    # type=bool|default=False: be compatible with the older 3dFWHM
+    acf:
+    # type=traitcompound|default=False: computes the spatial autocorrelation
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input dataset
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: 3dFWHMx -input functional.nii -out functional_subbricks.out > functional_fwhmx.out
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: input dataset
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-afni/fwh_mx_callables.py b/example-specs/task/nipype_internal/pydra-afni/fwh_mx_callables.py
new file mode 100644
index 00000000..4714fc62
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/fwh_mx_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in FWHMx.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-afni/gcor.yaml b/example-specs/task/nipype_internal/pydra-afni/gcor.yaml
new file mode 100644
index 00000000..66760420
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/gcor.yaml
@@ -0,0 +1,133 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.afni.utils.GCOR' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Computes the average correlation between every voxel
+#     and ever other voxel, over any give mask.
+# 
+# 
+#     For complete details, see the `@compute_gcor Documentation.
+#     <https://afni.nimh.nih.gov/pub/dist/doc/program_help/@compute_gcor.html>`_
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import afni
+#     >>> gcor = afni.GCOR()
+#     >>> gcor.inputs.in_file = 'structural.nii'
+#     >>> gcor.inputs.nfirst = 4
+#     >>> gcor.cmdline
+#     '@compute_gcor -nfirst 4 -input structural.nii'
+#     >>> res = gcor.run()  # doctest: +SKIP
+# 
+#     
+task_name: GCOR
+nipype_name: GCOR
+nipype_module: nipype.interfaces.afni.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: input dataset to compute the GCOR over
+    mask: generic/file
+    # type=file|default=<undefined>: mask dataset, for restricting the computation
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input dataset to compute the GCOR over
+    mask:
+    # type=file|default=<undefined>: mask dataset, for restricting the computation
+    nfirst:
+    # type=int|default=0: specify number of initial TRs to ignore
+    no_demean:
+    # type=bool|default=False: do not (need to) demean as first step
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input dataset to compute the GCOR over
+    nfirst: '4'
+    # type=int|default=0: specify number of initial TRs to ignore
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: '@compute_gcor -nfirst 4 -input structural.nii'
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: input dataset to compute the GCOR over
+    nfirst: '4'
+    # type=int|default=0: specify number of initial TRs to ignore
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-afni/gcor_callables.py b/example-specs/task/nipype_internal/pydra-afni/gcor_callables.py
new file mode 100644
index 00000000..d268a028
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/gcor_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in GCOR.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-afni/hist.yaml b/example-specs/task/nipype_internal/pydra-afni/hist.yaml
new file mode 100644
index 00000000..c54fb070
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/hist.yaml
@@ -0,0 +1,150 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.afni.preprocess.Hist' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Computes average of all voxels in the input dataset
+#     which satisfy the criterion in the options list
+# 
+#     For complete details, see the `3dHist Documentation.
+#     <https://afni.nimh.nih.gov/pub/dist/doc/program_help/3dHist.html>`_
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import afni
+#     >>> hist = afni.Hist()
+#     >>> hist.inputs.in_file = 'functional.nii'
+#     >>> hist.cmdline
+#     '3dHist -input functional.nii -prefix functional_hist'
+#     >>> res = hist.run()  # doctest: +SKIP
+# 
+#     
+task_name: Hist
+nipype_name: Hist
+nipype_module: nipype.interfaces.afni.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: input file to 3dHist
+    out_file: generic/file
+    # type=file: output file
+    # type=file|default=<undefined>: Write histogram to niml file with this prefix
+    out_show: generic/file
+    # type=file: output visual histogram
+    # type=file|default=<undefined>: output image file name
+    mask: generic/file
+    # type=file|default=<undefined>: matrix to align input file
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: output file
+    # type=file|default=<undefined>: Write histogram to niml file with this prefix
+    out_show: generic/file
+    # type=file: output visual histogram
+    # type=file|default=<undefined>: output image file name
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to 3dHist
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: Write histogram to niml file with this prefix
+    showhist:
+    # type=bool|default=False: write a text visual histogram
+    out_show:
+    # type=file: output visual histogram
+    # type=file|default=<undefined>: output image file name
+    mask:
+    # type=file|default=<undefined>: matrix to align input file
+    nbin:
+    # type=int|default=0: number of bins
+    max_value:
+    # type=float|default=0.0: maximum intensity value
+    min_value:
+    # type=float|default=0.0: minimum intensity value
+    bin_width:
+    # type=float|default=0.0: bin width
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to 3dHist
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: 3dHist -input functional.nii -prefix functional_hist
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: input file to 3dHist
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-afni/hist_callables.py b/example-specs/task/nipype_internal/pydra-afni/hist_callables.py
new file mode 100644
index 00000000..f6578ac1
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/hist_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Hist.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-afni/lfcd.yaml b/example-specs/task/nipype_internal/pydra-afni/lfcd.yaml
new file mode 100644
index 00000000..5e3343f6
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/lfcd.yaml
@@ -0,0 +1,159 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.afni.preprocess.LFCD' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Performs degree centrality on a dataset using a given maskfile
+#     via the 3dLFCD command
+# 
+#     For complete details, see the `3dLFCD Documentation.
+#     <https://afni.nimh.nih.gov/pub/dist/doc/program_help/3dLFCD.html>`_
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import afni
+#     >>> lfcd = afni.LFCD()
+#     >>> lfcd.inputs.in_file = 'functional.nii'
+#     >>> lfcd.inputs.mask = 'mask.nii'
+#     >>> lfcd.inputs.thresh = 0.8 # keep all connections with corr >= 0.8
+#     >>> lfcd.inputs.out_file = 'out.nii'
+#     >>> lfcd.cmdline
+#     '3dLFCD -mask mask.nii -prefix out.nii -thresh 0.800000 functional.nii'
+#     >>> res = lfcd.run()  # doctest: +SKIP
+#     
+task_name: LFCD
+nipype_name: LFCD
+nipype_module: nipype.interfaces.afni.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: input file to 3dLFCD
+    mask: medimage/nifti1
+    # type=file|default=<undefined>: mask file to mask input data
+    out_file: medimage/nifti1
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: medimage/nifti1
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to 3dLFCD
+    mask:
+    # type=file|default=<undefined>: mask file to mask input data
+    thresh:
+    # type=float|default=0.0: threshold to exclude connections where corr <= thresh
+    polort:
+    # type=int|default=0: 
+    autoclip:
+    # type=bool|default=False: Clip off low-intensity regions in the dataset
+    automask:
+    # type=bool|default=False: Mask the dataset to target brain-only voxels
+    num_threads:
+    # type=int|default=1: set number of threads
+    outputtype:
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to 3dLFCD
+    mask:
+    # type=file|default=<undefined>: mask file to mask input data
+    thresh: '0.8 # keep all connections with corr >= 0.8'
+    # type=float|default=0.0: threshold to exclude connections where corr <= thresh
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: 3dLFCD -mask mask.nii -prefix out.nii -thresh 0.800000 functional.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: input file to 3dLFCD
+    mask:
+    # type=file|default=<undefined>: mask file to mask input data
+    thresh: '0.8 # keep all connections with corr >= 0.8'
+    # type=float|default=0.0: threshold to exclude connections where corr <= thresh
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-afni/lfcd_callables.py b/example-specs/task/nipype_internal/pydra-afni/lfcd_callables.py
new file mode 100644
index 00000000..96a6755d
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/lfcd_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in LFCD.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-afni/local_bistat.yaml b/example-specs/task/nipype_internal/pydra-afni/local_bistat.yaml
new file mode 100644
index 00000000..f5c0558c
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/local_bistat.yaml
@@ -0,0 +1,169 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.afni.utils.LocalBistat' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 3dLocalBistat - computes statistics between 2 datasets, at each voxel,
+#     based on a local neighborhood of that voxel.
+# 
+#     For complete details, see the `3dLocalBistat Documentation.
+#     <https://afni.nimh.nih.gov/pub../pub/dist/doc/program_help/3dLocalBistat.html>`_
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import afni
+#     >>> bistat = afni.LocalBistat()
+#     >>> bistat.inputs.in_file1 = 'functional.nii'
+#     >>> bistat.inputs.in_file2 = 'structural.nii'
+#     >>> bistat.inputs.neighborhood = ('SPHERE', 1.2)
+#     >>> bistat.inputs.stat = 'pearson'
+#     >>> bistat.inputs.outputtype = 'NIFTI'
+#     >>> bistat.cmdline
+#     "3dLocalBistat -prefix functional_bistat.nii -nbhd 'SPHERE(1.2)' -stat pearson functional.nii structural.nii"
+#     >>> res = automask.run()  # doctest: +SKIP
+# 
+#     
+task_name: LocalBistat
+nipype_name: LocalBistat
+nipype_module: nipype.interfaces.afni.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file1: medimage/nifti1
+    # type=file|default=<undefined>: Filename of the first image
+    in_file2: medimage/nifti1
+    # type=file|default=<undefined>: Filename of the second image
+    mask_file: generic/file
+    # type=file|default=<undefined>: mask image file name. Voxels NOT in the mask will not be used in the neighborhood of any voxel. Also, a voxel NOT in the mask will have its statistic(s) computed as zero (0).
+    weight_file: generic/file
+    # type=file|default=<undefined>: File name of an image to use as a weight.  Only applies to 'pearson' statistics.
+    out_file: generic/file
+    # type=file: output file
+    # type=file|default=<undefined>: Output dataset.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: output file
+    # type=file|default=<undefined>: Output dataset.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file1:
+    # type=file|default=<undefined>: Filename of the first image
+    in_file2:
+    # type=file|default=<undefined>: Filename of the second image
+    neighborhood:
+    # type=traitcompound|default=None: The region around each voxel that will be extracted for the statistics calculation. Possible regions are: 'SPHERE', 'RHDD' (rhombic dodecahedron), 'TOHD' (truncated octahedron) with a given radius in mm or 'RECT' (rectangular block) with dimensions to specify in mm.
+    stat:
+    # type=inputmultiobject|default=[]: Statistics to compute. Possible names are:    * pearson  = Pearson correlation coefficient   * spearman = Spearman correlation coefficient   * quadrant = Quadrant correlation coefficient   * mutinfo  = Mutual Information   * normuti  = Normalized Mutual Information   * jointent = Joint entropy   * hellinger= Hellinger metric   * crU      = Correlation ratio (Unsymmetric)   * crM      = Correlation ratio (symmetrized by Multiplication)   * crA      = Correlation ratio (symmetrized by Addition)   * L2slope  = slope of least-squares (L2) linear regression of                the data from dataset1 vs. the dataset2                (i.e., d2 = a + b*d1 ==> this is 'b')   * L1slope  = slope of least-absolute-sum (L1) linear                regression of the data from dataset1 vs.                the dataset2   * num      = number of the values in the region:                with the use of -mask or -automask,                the size of the region around any given                voxel will vary; this option lets you                map that size.   * ALL      = all of the above, in that order  More than one option can be used.
+    mask_file:
+    # type=file|default=<undefined>: mask image file name. Voxels NOT in the mask will not be used in the neighborhood of any voxel. Also, a voxel NOT in the mask will have its statistic(s) computed as zero (0).
+    automask:
+    # type=bool|default=False: Compute the mask as in program 3dAutomask.
+    weight_file:
+    # type=file|default=<undefined>: File name of an image to use as a weight.  Only applies to 'pearson' statistics.
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: Output dataset.
+    num_threads:
+    # type=int|default=1: set number of threads
+    outputtype:
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file1:
+    # type=file|default=<undefined>: Filename of the first image
+    in_file2:
+    # type=file|default=<undefined>: Filename of the second image
+    neighborhood: ("SPHERE", 1.2)
+    # type=traitcompound|default=None: The region around each voxel that will be extracted for the statistics calculation. Possible regions are: 'SPHERE', 'RHDD' (rhombic dodecahedron), 'TOHD' (truncated octahedron) with a given radius in mm or 'RECT' (rectangular block) with dimensions to specify in mm.
+    stat: '"pearson"'
+    # type=inputmultiobject|default=[]: Statistics to compute. Possible names are:    * pearson  = Pearson correlation coefficient   * spearman = Spearman correlation coefficient   * quadrant = Quadrant correlation coefficient   * mutinfo  = Mutual Information   * normuti  = Normalized Mutual Information   * jointent = Joint entropy   * hellinger= Hellinger metric   * crU      = Correlation ratio (Unsymmetric)   * crM      = Correlation ratio (symmetrized by Multiplication)   * crA      = Correlation ratio (symmetrized by Addition)   * L2slope  = slope of least-squares (L2) linear regression of                the data from dataset1 vs. the dataset2                (i.e., d2 = a + b*d1 ==> this is 'b')   * L1slope  = slope of least-absolute-sum (L1) linear                regression of the data from dataset1 vs.                the dataset2   * num      = number of the values in the region:                with the use of -mask or -automask,                the size of the region around any given                voxel will vary; this option lets you                map that size.   * ALL      = all of the above, in that order  More than one option can be used.
+    outputtype: '"NIFTI"'
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: 3dLocalBistat -prefix functional_bistat.nii -nbhd "SPHERE(1.2)" -stat pearson functional.nii structural.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file1:
+    # type=file|default=<undefined>: Filename of the first image
+    in_file2:
+    # type=file|default=<undefined>: Filename of the second image
+    neighborhood: ("SPHERE", 1.2)
+    # type=traitcompound|default=None: The region around each voxel that will be extracted for the statistics calculation. Possible regions are: 'SPHERE', 'RHDD' (rhombic dodecahedron), 'TOHD' (truncated octahedron) with a given radius in mm or 'RECT' (rectangular block) with dimensions to specify in mm.
+    stat: '"pearson"'
+    # type=inputmultiobject|default=[]: Statistics to compute. Possible names are:    * pearson  = Pearson correlation coefficient   * spearman = Spearman correlation coefficient   * quadrant = Quadrant correlation coefficient   * mutinfo  = Mutual Information   * normuti  = Normalized Mutual Information   * jointent = Joint entropy   * hellinger= Hellinger metric   * crU      = Correlation ratio (Unsymmetric)   * crM      = Correlation ratio (symmetrized by Multiplication)   * crA      = Correlation ratio (symmetrized by Addition)   * L2slope  = slope of least-squares (L2) linear regression of                the data from dataset1 vs. the dataset2                (i.e., d2 = a + b*d1 ==> this is 'b')   * L1slope  = slope of least-absolute-sum (L1) linear                regression of the data from dataset1 vs.                the dataset2   * num      = number of the values in the region:                with the use of -mask or -automask,                the size of the region around any given                voxel will vary; this option lets you                map that size.   * ALL      = all of the above, in that order  More than one option can be used.
+    outputtype: '"NIFTI"'
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-afni/local_bistat_callables.py b/example-specs/task/nipype_internal/pydra-afni/local_bistat_callables.py
new file mode 100644
index 00000000..c94b1bab
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/local_bistat_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in LocalBistat.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-afni/localstat.yaml b/example-specs/task/nipype_internal/pydra-afni/localstat.yaml
new file mode 100644
index 00000000..ca394570
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/localstat.yaml
@@ -0,0 +1,180 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.afni.utils.Localstat' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 3dLocalstat - computes statistics at each voxel,
+#     based on a local neighborhood of that voxel.
+# 
+#     For complete details, see the `3dLocalstat Documentation.
+#     <https://afni.nimh.nih.gov/pub/dist/doc/program_help/3dLocalstat.html>`_
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import afni
+#     >>> localstat = afni.Localstat()
+#     >>> localstat.inputs.in_file = 'functional.nii'
+#     >>> localstat.inputs.mask_file = 'skeleton_mask.nii.gz'
+#     >>> localstat.inputs.neighborhood = ('SPHERE', 45)
+#     >>> localstat.inputs.stat = 'mean'
+#     >>> localstat.inputs.nonmask = True
+#     >>> localstat.inputs.outputtype = 'NIFTI_GZ'
+#     >>> localstat.cmdline
+#     "3dLocalstat -prefix functional_localstat.nii -mask skeleton_mask.nii.gz -nbhd 'SPHERE(45.0)' -use_nonmask -stat mean functional.nii"
+#     >>> res = localstat.run()  # doctest: +SKIP
+# 
+#     
+task_name: Localstat
+nipype_name: Localstat
+nipype_module: nipype.interfaces.afni.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: input dataset
+    mask_file: medimage/nifti-gz
+    # type=file|default=<undefined>: Mask image file name. Voxels NOT in the mask will not be used in the neighborhood of any voxel. Also, a voxel NOT in the mask will have its statistic(s) computed as zero (0) unless the parameter 'nonmask' is set to true.
+    out_file: generic/file
+    # type=file: output file
+    # type=file|default=<undefined>: Output dataset.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: output file
+    # type=file|default=<undefined>: Output dataset.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input dataset
+    neighborhood:
+    # type=traitcompound|default=None: The region around each voxel that will be extracted for the statistics calculation. Possible regions are: 'SPHERE', 'RHDD' (rhombic dodecahedron), 'TOHD' (truncated octahedron) with a given radius in mm or 'RECT' (rectangular block) with dimensions to specify in mm.
+    stat:
+    # type=inputmultiobject|default=[]: statistics to compute. Possible names are:   * mean   = average of the values  * stdev  = standard deviation  * var    = variance (stdev\*stdev)  * cvar   = coefficient of variation = stdev/fabs(mean)  * median = median of the values  * MAD    = median absolute deviation  * min    = minimum  * max    = maximum  * absmax = maximum of the absolute values  * num    = number of the values in the region:             with the use of -mask or -automask,             the size of the region around any given             voxel will vary; this option lets you             map that size.  It may be useful if you             plan to compute a t-statistic (say) from             the mean and stdev outputs.  * sum    = sum of the values in the region  * FWHM   = compute (like 3dFWHM) image smoothness             inside each voxel's neighborhood.  Results             are in 3 sub-bricks: FWHMx, FHWMy, and FWHMz.             Places where an output is -1 are locations             where the FWHM value could not be computed             (e.g., outside the mask).  * FWHMbar= Compute just the average of the 3 FWHM values             (normally would NOT do this with FWHM also).  * perc:P0:P1:Pstep =             Compute percentiles between P0 and P1 with a             step of Pstep.             Default P1 is equal to P0 and default P2 = 1  * rank   = rank of the voxel's intensity  * frank  = rank / number of voxels in neighborhood  * P2skew = Pearson's second skewness coefficient              3 \* (mean - median) / stdev  * ALL    = all of the above, in that order             (except for FWHMbar and perc).  * mMP2s  = Exactly the same output as:             median, MAD, P2skew,             but a little faster  * mmMP2s = Exactly the same output as:             mean, median, MAD, P2skew  More than one option can be used.
+    mask_file:
+    # type=file|default=<undefined>: Mask image file name. Voxels NOT in the mask will not be used in the neighborhood of any voxel. Also, a voxel NOT in the mask will have its statistic(s) computed as zero (0) unless the parameter 'nonmask' is set to true.
+    automask:
+    # type=bool|default=False: Compute the mask as in program 3dAutomask.
+    nonmask:
+    # type=bool|default=False: Voxels not in the mask WILL have their local statistics computed from all voxels in their neighborhood that ARE in the mask. For instance, this option can be used to compute the average local white matter time series, even at non-WM voxels.
+    reduce_grid:
+    # type=traitcompound|default=None: Compute output on a grid that is reduced by the specified factors. If a single value is passed, output is resampled to the specified isotropic grid. Otherwise, the 3 inputs describe the reduction in the X, Y, and Z directions. This option speeds up computations at the expense of resolution. It should only be used when the nbhd is quite large with respect to the input's resolution, and the resultant stats are expected to be smooth.
+    reduce_restore_grid:
+    # type=traitcompound|default=None: Like reduce_grid, but also resample output back to input grid.
+    reduce_max_vox:
+    # type=float|default=0.0: Like reduce_restore_grid, but automatically set Rx Ry Rz sothat the computation grid is at a resolution of nbhd/MAX_VOXvoxels.
+    grid_rmode:
+    # type=enum|default='NN'|allowed['Bk','Cu','Li','NN']: Interpolant to use when resampling the output with thereduce_restore_grid option. The resampling method string RESAM should come from the set {'NN', 'Li', 'Cu', 'Bk'}. These stand for 'Nearest Neighbor', 'Linear', 'Cubic', and 'Blocky' interpolation, respectively.
+    quiet:
+    # type=bool|default=False: Stop the highly informative progress reports.
+    overwrite:
+    # type=bool|default=False: overwrite output file if it already exists
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: Output dataset.
+    num_threads:
+    # type=int|default=1: set number of threads
+    outputtype:
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input dataset
+    mask_file:
+    # type=file|default=<undefined>: Mask image file name. Voxels NOT in the mask will not be used in the neighborhood of any voxel. Also, a voxel NOT in the mask will have its statistic(s) computed as zero (0) unless the parameter 'nonmask' is set to true.
+    neighborhood: ("SPHERE", 45)
+    # type=traitcompound|default=None: The region around each voxel that will be extracted for the statistics calculation. Possible regions are: 'SPHERE', 'RHDD' (rhombic dodecahedron), 'TOHD' (truncated octahedron) with a given radius in mm or 'RECT' (rectangular block) with dimensions to specify in mm.
+    stat: '"mean"'
+    # type=inputmultiobject|default=[]: statistics to compute. Possible names are:   * mean   = average of the values  * stdev  = standard deviation  * var    = variance (stdev\*stdev)  * cvar   = coefficient of variation = stdev/fabs(mean)  * median = median of the values  * MAD    = median absolute deviation  * min    = minimum  * max    = maximum  * absmax = maximum of the absolute values  * num    = number of the values in the region:             with the use of -mask or -automask,             the size of the region around any given             voxel will vary; this option lets you             map that size.  It may be useful if you             plan to compute a t-statistic (say) from             the mean and stdev outputs.  * sum    = sum of the values in the region  * FWHM   = compute (like 3dFWHM) image smoothness             inside each voxel's neighborhood.  Results             are in 3 sub-bricks: FWHMx, FHWMy, and FWHMz.             Places where an output is -1 are locations             where the FWHM value could not be computed             (e.g., outside the mask).  * FWHMbar= Compute just the average of the 3 FWHM values             (normally would NOT do this with FWHM also).  * perc:P0:P1:Pstep =             Compute percentiles between P0 and P1 with a             step of Pstep.             Default P1 is equal to P0 and default P2 = 1  * rank   = rank of the voxel's intensity  * frank  = rank / number of voxels in neighborhood  * P2skew = Pearson's second skewness coefficient              3 \* (mean - median) / stdev  * ALL    = all of the above, in that order             (except for FWHMbar and perc).  * mMP2s  = Exactly the same output as:             median, MAD, P2skew,             but a little faster  * mmMP2s = Exactly the same output as:             mean, median, MAD, P2skew  More than one option can be used.
+    nonmask: 'True'
+    # type=bool|default=False: Voxels not in the mask WILL have their local statistics computed from all voxels in their neighborhood that ARE in the mask. For instance, this option can be used to compute the average local white matter time series, even at non-WM voxels.
+    outputtype: '"NIFTI_GZ"'
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: 3dLocalstat -prefix functional_localstat.nii -mask skeleton_mask.nii.gz -nbhd "SPHERE(45.0)" -use_nonmask -stat mean functional.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: input dataset
+    mask_file:
+    # type=file|default=<undefined>: Mask image file name. Voxels NOT in the mask will not be used in the neighborhood of any voxel. Also, a voxel NOT in the mask will have its statistic(s) computed as zero (0) unless the parameter 'nonmask' is set to true.
+    neighborhood: ("SPHERE", 45)
+    # type=traitcompound|default=None: The region around each voxel that will be extracted for the statistics calculation. Possible regions are: 'SPHERE', 'RHDD' (rhombic dodecahedron), 'TOHD' (truncated octahedron) with a given radius in mm or 'RECT' (rectangular block) with dimensions to specify in mm.
+    stat: '"mean"'
+    # type=inputmultiobject|default=[]: statistics to compute. Possible names are:   * mean   = average of the values  * stdev  = standard deviation  * var    = variance (stdev\*stdev)  * cvar   = coefficient of variation = stdev/fabs(mean)  * median = median of the values  * MAD    = median absolute deviation  * min    = minimum  * max    = maximum  * absmax = maximum of the absolute values  * num    = number of the values in the region:             with the use of -mask or -automask,             the size of the region around any given             voxel will vary; this option lets you             map that size.  It may be useful if you             plan to compute a t-statistic (say) from             the mean and stdev outputs.  * sum    = sum of the values in the region  * FWHM   = compute (like 3dFWHM) image smoothness             inside each voxel's neighborhood.  Results             are in 3 sub-bricks: FWHMx, FHWMy, and FWHMz.             Places where an output is -1 are locations             where the FWHM value could not be computed             (e.g., outside the mask).  * FWHMbar= Compute just the average of the 3 FWHM values             (normally would NOT do this with FWHM also).  * perc:P0:P1:Pstep =             Compute percentiles between P0 and P1 with a             step of Pstep.             Default P1 is equal to P0 and default P2 = 1  * rank   = rank of the voxel's intensity  * frank  = rank / number of voxels in neighborhood  * P2skew = Pearson's second skewness coefficient              3 \* (mean - median) / stdev  * ALL    = all of the above, in that order             (except for FWHMbar and perc).  * mMP2s  = Exactly the same output as:             median, MAD, P2skew,             but a little faster  * mmMP2s = Exactly the same output as:             mean, median, MAD, P2skew  More than one option can be used.
+    nonmask: 'True'
+    # type=bool|default=False: Voxels not in the mask WILL have their local statistics computed from all voxels in their neighborhood that ARE in the mask. For instance, this option can be used to compute the average local white matter time series, even at non-WM voxels.
+    outputtype: '"NIFTI_GZ"'
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-afni/localstat_callables.py b/example-specs/task/nipype_internal/pydra-afni/localstat_callables.py
new file mode 100644
index 00000000..b625977e
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/localstat_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Localstat.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-afni/mask_tool.yaml b/example-specs/task/nipype_internal/pydra-afni/mask_tool.yaml
new file mode 100644
index 00000000..a00cb5c3
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/mask_tool.yaml
@@ -0,0 +1,155 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.afni.utils.MaskTool' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 3dmask_tool - for combining/dilating/eroding/filling masks
+# 
+#     For complete details, see the `3dmask_tool Documentation.
+#     <https://afni.nimh.nih.gov/pub../pub/dist/doc/program_help/3dmask_tool.html>`_
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import afni
+#     >>> masktool = afni.MaskTool()
+#     >>> masktool.inputs.in_file = 'functional.nii'
+#     >>> masktool.inputs.outputtype = 'NIFTI'
+#     >>> masktool.cmdline
+#     '3dmask_tool -prefix functional_mask.nii -input functional.nii'
+#     >>> res = automask.run()  # doctest: +SKIP
+# 
+#     
+task_name: MaskTool
+nipype_name: MaskTool
+nipype_module: nipype.interfaces.afni.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1+list-of
+    # type=inputmultiobject|default=[]: input file or files to 3dmask_tool
+    out_file: generic/file
+    # type=file: mask file
+    # type=file|default=<undefined>: output image file name
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: mask file
+    # type=file|default=<undefined>: output image file name
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=inputmultiobject|default=[]: input file or files to 3dmask_tool
+    out_file:
+    # type=file: mask file
+    # type=file|default=<undefined>: output image file name
+    count:
+    # type=bool|default=False: Instead of created a binary 0/1 mask dataset, create one with counts of voxel overlap, i.e., each voxel will contain the number of masks that it is set in.
+    datum:
+    # type=enum|default='byte'|allowed['byte','float','short']: specify data type for output.
+    dilate_inputs:
+    # type=str|default='': Use this option to dilate and/or erode datasets as they are read. ex. '5 -5' to dilate and erode 5 times
+    dilate_results:
+    # type=str|default='': dilate and/or erode combined mask at the given levels.
+    frac:
+    # type=float|default=0.0: When combining masks (across datasets and sub-bricks), use this option to restrict the result to a certain fraction of the set of volumes
+    inter:
+    # type=bool|default=False: intersection, this means -frac 1.0
+    union:
+    # type=bool|default=False: union, this means -frac 0
+    fill_holes:
+    # type=bool|default=False: This option can be used to fill holes in the resulting mask, i.e. after all other processing has been done.
+    fill_dirs:
+    # type=str|default='': fill holes only in the given directions. This option is for use with -fill holes. should be a single string that specifies 1-3 of the axes using {x,y,z} labels (i.e. dataset axis order), or using the labels in {R,L,A,P,I,S}.
+    verbose:
+    # type=int|default=0: specify verbosity level, for 0 to 3
+    num_threads:
+    # type=int|default=1: set number of threads
+    outputtype:
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=inputmultiobject|default=[]: input file or files to 3dmask_tool
+    outputtype: '"NIFTI"'
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: 3dmask_tool -prefix functional_mask.nii -input functional.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=inputmultiobject|default=[]: input file or files to 3dmask_tool
+    outputtype: '"NIFTI"'
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-afni/mask_tool_callables.py b/example-specs/task/nipype_internal/pydra-afni/mask_tool_callables.py
new file mode 100644
index 00000000..788061ff
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/mask_tool_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in MaskTool.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-afni/maskave.yaml b/example-specs/task/nipype_internal/pydra-afni/maskave.yaml
new file mode 100644
index 00000000..f1dfc3b0
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/maskave.yaml
@@ -0,0 +1,147 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.afni.preprocess.Maskave' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Computes average of all voxels in the input dataset
+#     which satisfy the criterion in the options list
+# 
+#     For complete details, see the `3dmaskave Documentation.
+#     <https://afni.nimh.nih.gov/pub/dist/doc/program_help/3dmaskave.html>`_
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import afni
+#     >>> maskave = afni.Maskave()
+#     >>> maskave.inputs.in_file = 'functional.nii'
+#     >>> maskave.inputs.mask= 'seed_mask.nii'
+#     >>> maskave.inputs.quiet= True
+#     >>> maskave.cmdline  # doctest: +ELLIPSIS
+#     '3dmaskave -mask seed_mask.nii -quiet functional.nii > functional_maskave.1D'
+#     >>> res = maskave.run()  # doctest: +SKIP
+# 
+#     
+task_name: Maskave
+nipype_name: Maskave
+nipype_module: nipype.interfaces.afni.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: input file to 3dmaskave
+    out_file: generic/file
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+    mask: medimage/nifti1
+    # type=file|default=<undefined>: matrix to align input file
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to 3dmaskave
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+    mask:
+    # type=file|default=<undefined>: matrix to align input file
+    quiet:
+    # type=bool|default=False: matrix to align input file
+    num_threads:
+    # type=int|default=1: set number of threads
+    outputtype:
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to 3dmaskave
+    mask:
+    # type=file|default=<undefined>: matrix to align input file
+    quiet: 'True'
+    # type=bool|default=False: matrix to align input file
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: 3dmaskave -mask seed_mask.nii -quiet functional.nii > functional_maskave.1D
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: input file to 3dmaskave
+    mask:
+    # type=file|default=<undefined>: matrix to align input file
+    quiet: 'True'
+    # type=bool|default=False: matrix to align input file
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-afni/maskave_callables.py b/example-specs/task/nipype_internal/pydra-afni/maskave_callables.py
new file mode 100644
index 00000000..bfb2eb35
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/maskave_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Maskave.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-afni/means.yaml b/example-specs/task/nipype_internal/pydra-afni/means.yaml
new file mode 100644
index 00000000..97492f66
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/means.yaml
@@ -0,0 +1,216 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.afni.preprocess.Means' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Takes the voxel-by-voxel mean of all input datasets using 3dMean
+# 
+#     For complete details, see the `3dMean Documentation.
+#     <https://afni.nimh.nih.gov/pub/dist/doc/program_help/3dMean.html>`_
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import afni
+#     >>> means = afni.Means()
+#     >>> means.inputs.in_file_a = 'im1.nii'
+#     >>> means.inputs.in_file_b = 'im2.nii'
+#     >>> means.inputs.out_file =  'output.nii'
+#     >>> means.cmdline
+#     '3dMean -prefix output.nii im1.nii im2.nii'
+#     >>> res = means.run()  # doctest: +SKIP
+# 
+#     >>> from nipype.interfaces import afni
+#     >>> means = afni.Means()
+#     >>> means.inputs.in_file_a = 'im1.nii'
+#     >>> means.inputs.out_file =  'output.nii'
+#     >>> means.inputs.datum = 'short'
+#     >>> means.cmdline
+#     '3dMean -datum short -prefix output.nii im1.nii'
+#     >>> res = means.run()  # doctest: +SKIP
+# 
+#     
+task_name: Means
+nipype_name: Means
+nipype_module: nipype.interfaces.afni.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file_a: medimage/nifti1
+    # type=file|default=<undefined>: input file to 3dMean
+    in_file_b: medimage/nifti1
+    # type=file|default=<undefined>: another input file to 3dMean
+    out_file: medimage/nifti1
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: medimage/nifti1
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file_a:
+    # type=file|default=<undefined>: input file to 3dMean
+    in_file_b:
+    # type=file|default=<undefined>: another input file to 3dMean
+    datum:
+    # type=str|default='': Sets the data type of the output dataset
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+    scale:
+    # type=str|default='': scaling of output
+    non_zero:
+    # type=bool|default=False: use only non-zero values
+    std_dev:
+    # type=bool|default=False: calculate std dev
+    sqr:
+    # type=bool|default=False: mean square instead of value
+    summ:
+    # type=bool|default=False: take sum, (not average)
+    count:
+    # type=bool|default=False: compute count of non-zero voxels
+    mask_inter:
+    # type=bool|default=False: create intersection mask
+    mask_union:
+    # type=bool|default=False: create union mask
+    num_threads:
+    # type=int|default=1: set number of threads
+    outputtype:
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file_a:
+    # type=file|default=<undefined>: input file to 3dMean
+    in_file_b:
+    # type=file|default=<undefined>: another input file to 3dMean
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file_a:
+    # type=file|default=<undefined>: input file to 3dMean
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+    datum: '"short"'
+    # type=str|default='': Sets the data type of the output dataset
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: 3dMean -prefix output.nii im1.nii im2.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file_a:
+    # type=file|default=<undefined>: input file to 3dMean
+    in_file_b:
+    # type=file|default=<undefined>: another input file to 3dMean
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: 3dMean -datum short -prefix output.nii im1.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file_a:
+    # type=file|default=<undefined>: input file to 3dMean
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+    datum: '"short"'
+    # type=str|default='': Sets the data type of the output dataset
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-afni/means_callables.py b/example-specs/task/nipype_internal/pydra-afni/means_callables.py
new file mode 100644
index 00000000..4e09bd79
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/means_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Means.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-afni/merge.yaml b/example-specs/task/nipype_internal/pydra-afni/merge.yaml
new file mode 100644
index 00000000..994ce9be
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/merge.yaml
@@ -0,0 +1,151 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.afni.utils.Merge' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Merge or edit volumes using AFNI 3dmerge command
+# 
+#     For complete details, see the `3dmerge Documentation.
+#     <https://afni.nimh.nih.gov/pub/dist/doc/program_help/3dmerge.html>`_
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import afni
+#     >>> merge = afni.Merge()
+#     >>> merge.inputs.in_files = ['functional.nii', 'functional2.nii']
+#     >>> merge.inputs.blurfwhm = 4
+#     >>> merge.inputs.doall = True
+#     >>> merge.inputs.out_file = 'e7.nii'
+#     >>> merge.cmdline
+#     '3dmerge -1blur_fwhm 4 -doall -prefix e7.nii functional.nii functional2.nii'
+#     >>> res = merge.run()  # doctest: +SKIP
+# 
+#     
+task_name: Merge
+nipype_name: Merge
+nipype_module: nipype.interfaces.afni.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_files: medimage/nifti1+list-of
+    # type=inputmultiobject|default=[]: 
+    out_file: medimage/nifti1
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: medimage/nifti1
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_files:
+    # type=inputmultiobject|default=[]: 
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+    doall:
+    # type=bool|default=False: apply options to all sub-bricks in dataset
+    blurfwhm:
+    # type=int|default=0: FWHM blur value (mm)
+    num_threads:
+    # type=int|default=1: set number of threads
+    outputtype:
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_files:
+    # type=inputmultiobject|default=[]: 
+    blurfwhm: '4'
+    # type=int|default=0: FWHM blur value (mm)
+    doall: 'True'
+    # type=bool|default=False: apply options to all sub-bricks in dataset
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: 3dmerge -1blur_fwhm 4 -doall -prefix e7.nii functional.nii functional2.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_files:
+    # type=inputmultiobject|default=[]: 
+    blurfwhm: '4'
+    # type=int|default=0: FWHM blur value (mm)
+    doall: 'True'
+    # type=bool|default=False: apply options to all sub-bricks in dataset
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-afni/merge_callables.py b/example-specs/task/nipype_internal/pydra-afni/merge_callables.py
new file mode 100644
index 00000000..1950a89d
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/merge_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Merge.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-afni/net_corr.yaml b/example-specs/task/nipype_internal/pydra-afni/net_corr.yaml
new file mode 100644
index 00000000..93e00dba
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/net_corr.yaml
@@ -0,0 +1,194 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.afni.preprocess.NetCorr' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Calculate correlation matrix of a set of ROIs (using mean time series of
+#     each). Several networks may be analyzed simultaneously, one per brick.
+# 
+#     For complete details, see the `3dNetCorr Documentation
+#     <https://afni.nimh.nih.gov/pub/dist/doc/program_help/3dNetCorr.html>`_.
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import afni
+#     >>> ncorr = afni.NetCorr()
+#     >>> ncorr.inputs.in_file = 'functional.nii'
+#     >>> ncorr.inputs.mask = 'mask.nii'
+#     >>> ncorr.inputs.in_rois = 'maps.nii'
+#     >>> ncorr.inputs.ts_wb_corr = True
+#     >>> ncorr.inputs.ts_wb_Z = True
+#     >>> ncorr.inputs.fish_z = True
+#     >>> ncorr.inputs.out_file = 'sub0.tp1.ncorr'
+#     >>> ncorr.cmdline
+#     '3dNetCorr -prefix sub0.tp1.ncorr -fish_z -inset functional.nii -in_rois maps.nii -mask mask.nii -ts_wb_Z -ts_wb_corr'
+#     >>> res = ncorr.run()  # doctest: +SKIP
+# 
+#     
+task_name: NetCorr
+nipype_name: NetCorr
+nipype_module: nipype.interfaces.afni.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: input time series file (4D data set)
+    in_rois: medimage/nifti1
+    # type=file|default=<undefined>: input set of ROIs, each labelled with distinct integers
+    mask: medimage/nifti1
+    # type=file|default=<undefined>: can include a whole brain mask within which to calculate correlation. Otherwise, data should be masked already
+    weight_ts: generic/file
+    # type=file|default=<undefined>: input a 1D file WTS of weights that will be applied multiplicatively to each ROI's average time series. WTS can be a column- or row-file of values, but it must have the same length as the input time series volume. If the initial average time series was A[n] for n=0,..,(N-1) time points, then applying a set of weights W[n] of the same length from WTS would produce a new time series:  B[n] = A[n] * W[n]
+    out_file: medimage-afni/ncorr
+    # type=file|default=<undefined>: output file name part
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_corr_matrix: generic/file
+    # type=file: output correlation matrix between ROIs written to a text file with .netcc suffix
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input time series file (4D data set)
+    in_rois:
+    # type=file|default=<undefined>: input set of ROIs, each labelled with distinct integers
+    mask:
+    # type=file|default=<undefined>: can include a whole brain mask within which to calculate correlation. Otherwise, data should be masked already
+    weight_ts:
+    # type=file|default=<undefined>: input a 1D file WTS of weights that will be applied multiplicatively to each ROI's average time series. WTS can be a column- or row-file of values, but it must have the same length as the input time series volume. If the initial average time series was A[n] for n=0,..,(N-1) time points, then applying a set of weights W[n] of the same length from WTS would produce a new time series:  B[n] = A[n] * W[n]
+    fish_z:
+    # type=bool|default=False: switch to also output a matrix of Fisher Z-transform values for the corr coefs (r): Z = atanh(r) , (with Z=4 being output along matrix diagonals where r=1, as the r-to-Z conversion is ceilinged at Z = atanh(r=0.999329) = 4, which is still *quite* a high Pearson-r value
+    part_corr:
+    # type=bool|default=False: output the partial correlation matrix
+    ts_out:
+    # type=bool|default=False: switch to output the mean time series of the ROIs that have been used to generate the correlation matrices. Output filenames mirror those of the correlation matrix files, with a '.netts' postfix
+    ts_label:
+    # type=bool|default=False: additional switch when using '-ts_out'. Using this option will insert the integer ROI label at the start of each line of the *.netts file created. Thus, for a time series of length N, each line will have N+1 numbers, where the first is the integer ROI label and the subsequent N are scientific notation values
+    ts_indiv:
+    # type=bool|default=False: switch to create a directory for each network that contains the average time series for each ROI in individual files (each file has one line). The directories are labelled PREFIX_000_INDIV/, PREFIX_001_INDIV/, etc. (one per network). Within each directory, the files are labelled ROI_001.netts, ROI_002.netts, etc., with the numbers given by the actual ROI integer labels
+    ts_wb_corr:
+    # type=bool|default=False: switch to create a set of whole brain correlation maps. Performs whole brain correlation for each ROI's average time series; this will automatically create a directory for each network that contains the set of whole brain correlation maps (Pearson 'r's). The directories are labelled as above for '-ts_indiv' Within each directory, the files are labelled WB_CORR_ROI_001+orig, WB_CORR_ROI_002+orig, etc., with the numbers given by the actual ROI integer labels
+    ts_wb_Z:
+    # type=bool|default=False: same as above in '-ts_wb_corr', except that the maps have been Fisher transformed to Z-scores the relation: Z=atanh(r). To avoid infinities in the transform, Pearson values are effectively capped at |r| = 0.999329 (where |Z| = 4.0). Files are labelled WB_Z_ROI_001+orig, etc
+    ts_wb_strlabel:
+    # type=bool|default=False: by default, '-ts_wb_{corr,Z}' output files are named using the int number of a given ROI, such as: WB_Z_ROI_001+orig. With this option, one can replace the int (such as '001') with the string label (such as 'L-thalamus') *if* one has a labeltable attached to the file
+    nifti:
+    # type=bool|default=False: output any correlation map files as NIFTI files (default is BRIK/HEAD). Only useful if using '-ts_wb_corr' and/or '-ts_wb_Z'
+    output_mask_nonnull:
+    # type=bool|default=False: internally, this program checks for where there are nonnull time series, because we don't like those, in general.  With this flag, the user can output the determined mask of non-null time series.
+    push_thru_many_zeros:
+    # type=bool|default=False: by default, this program will grind to a halt and refuse to calculate if any ROI contains >10 percent of voxels with null times series (i.e., each point is 0), as of April, 2017.  This is because it seems most likely that hidden badness is responsible. However, if the user still wants to carry on the calculation anyways, then this option will allow one to push on through.  However, if any ROI *only* has null time series, then the program will not calculate and the user will really, really, really need to address their masking
+    ignore_LT:
+    # type=bool|default=False: switch to ignore any label table labels in the '-in_rois' file, if there are any labels attached
+    out_file:
+    # type=file|default=<undefined>: output file name part
+    num_threads:
+    # type=int|default=1: set number of threads
+    outputtype:
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input time series file (4D data set)
+    mask:
+    # type=file|default=<undefined>: can include a whole brain mask within which to calculate correlation. Otherwise, data should be masked already
+    in_rois:
+    # type=file|default=<undefined>: input set of ROIs, each labelled with distinct integers
+    ts_wb_corr: 'True'
+    # type=bool|default=False: switch to create a set of whole brain correlation maps. Performs whole brain correlation for each ROI's average time series; this will automatically create a directory for each network that contains the set of whole brain correlation maps (Pearson 'r's). The directories are labelled as above for '-ts_indiv' Within each directory, the files are labelled WB_CORR_ROI_001+orig, WB_CORR_ROI_002+orig, etc., with the numbers given by the actual ROI integer labels
+    ts_wb_Z: 'True'
+    # type=bool|default=False: same as above in '-ts_wb_corr', except that the maps have been Fisher transformed to Z-scores the relation: Z=atanh(r). To avoid infinities in the transform, Pearson values are effectively capped at |r| = 0.999329 (where |Z| = 4.0). Files are labelled WB_Z_ROI_001+orig, etc
+    fish_z: 'True'
+    # type=bool|default=False: switch to also output a matrix of Fisher Z-transform values for the corr coefs (r): Z = atanh(r) , (with Z=4 being output along matrix diagonals where r=1, as the r-to-Z conversion is ceilinged at Z = atanh(r=0.999329) = 4, which is still *quite* a high Pearson-r value
+    out_file:
+    # type=file|default=<undefined>: output file name part
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: 3dNetCorr -prefix sub0.tp1.ncorr -fish_z -inset functional.nii -in_rois maps.nii -mask mask.nii -ts_wb_Z -ts_wb_corr
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: input time series file (4D data set)
+    mask:
+    # type=file|default=<undefined>: can include a whole brain mask within which to calculate correlation. Otherwise, data should be masked already
+    in_rois:
+    # type=file|default=<undefined>: input set of ROIs, each labelled with distinct integers
+    ts_wb_corr: 'True'
+    # type=bool|default=False: switch to create a set of whole brain correlation maps. Performs whole brain correlation for each ROI's average time series; this will automatically create a directory for each network that contains the set of whole brain correlation maps (Pearson 'r's). The directories are labelled as above for '-ts_indiv' Within each directory, the files are labelled WB_CORR_ROI_001+orig, WB_CORR_ROI_002+orig, etc., with the numbers given by the actual ROI integer labels
+    ts_wb_Z: 'True'
+    # type=bool|default=False: same as above in '-ts_wb_corr', except that the maps have been Fisher transformed to Z-scores the relation: Z=atanh(r). To avoid infinities in the transform, Pearson values are effectively capped at |r| = 0.999329 (where |Z| = 4.0). Files are labelled WB_Z_ROI_001+orig, etc
+    fish_z: 'True'
+    # type=bool|default=False: switch to also output a matrix of Fisher Z-transform values for the corr coefs (r): Z = atanh(r) , (with Z=4 being output along matrix diagonals where r=1, as the r-to-Z conversion is ceilinged at Z = atanh(r=0.999329) = 4, which is still *quite* a high Pearson-r value
+    out_file:
+    # type=file|default=<undefined>: output file name part
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-afni/net_corr_callables.py b/example-specs/task/nipype_internal/pydra-afni/net_corr_callables.py
new file mode 100644
index 00000000..7202de6d
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/net_corr_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in NetCorr.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-afni/notes.yaml b/example-specs/task/nipype_internal/pydra-afni/notes.yaml
new file mode 100644
index 00000000..8654f5fc
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/notes.yaml
@@ -0,0 +1,150 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.afni.utils.Notes' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# A program to add, delete, and show notes for AFNI datasets.
+# 
+#     For complete details, see the `3dNotes Documentation.
+#     <https://afni.nimh.nih.gov/pub/dist/doc/program_help/3dNotes.html>`_
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import afni
+#     >>> notes = afni.Notes()
+#     >>> notes.inputs.in_file = 'functional.HEAD'
+#     >>> notes.inputs.add = 'This note is added.'
+#     >>> notes.inputs.add_history = 'This note is added to history.'
+#     >>> notes.cmdline
+#     '3dNotes -a "This note is added." -h "This note is added to history." functional.HEAD'
+#     >>> res = notes.run()  # doctest: +SKIP
+# 
+#     
+task_name: Notes
+nipype_name: Notes
+nipype_module: nipype.interfaces.afni.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage-afni/head
+    # type=file|default=<undefined>: input file to 3dNotes
+    out_file: generic/file
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to 3dNotes
+    add:
+    # type=str|default='': note to add
+    add_history:
+    # type=str|default='': note to add to history
+    rep_history:
+    # type=str|default='': note with which to replace history
+    delete:
+    # type=int|default=0: delete note number num
+    ses:
+    # type=bool|default=False: print to stdout the expanded notes
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+    num_threads:
+    # type=int|default=1: set number of threads
+    outputtype:
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to 3dNotes
+    add: '"This note is added."'
+    # type=str|default='': note to add
+    add_history: '"This note is added to history."'
+    # type=str|default='': note to add to history
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: 3dNotes -a "This note is added." -h "This note is added to history." functional.HEAD
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: input file to 3dNotes
+    add: '"This note is added."'
+    # type=str|default='': note to add
+    add_history: '"This note is added to history."'
+    # type=str|default='': note to add to history
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-afni/notes_callables.py b/example-specs/task/nipype_internal/pydra-afni/notes_callables.py
new file mode 100644
index 00000000..1735c99c
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/notes_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Notes.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-afni/nwarp_adjust.yaml b/example-specs/task/nipype_internal/pydra-afni/nwarp_adjust.yaml
new file mode 100644
index 00000000..304c4791
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/nwarp_adjust.yaml
@@ -0,0 +1,139 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.afni.utils.NwarpAdjust' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# This program takes as input a bunch of 3D warps, averages them,
+#     and computes the inverse of this average warp.  It then composes
+#     each input warp with this inverse average to 'adjust' the set of
+#     warps.  Optionally, it can also read in a set of 1-brick datasets
+#     corresponding to the input warps, and warp each of them, and average
+#     those.
+# 
+#     For complete details, see the `3dNwarpAdjust Documentation.
+#     <https://afni.nimh.nih.gov/pub/dist/doc/program_help/3dNwarpAdjust.html>`_
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import afni
+#     >>> adjust = afni.NwarpAdjust()
+#     >>> adjust.inputs.warps = ['func2anat_InverseWarp.nii.gz', 'func2anat_InverseWarp.nii.gz', 'func2anat_InverseWarp.nii.gz', 'func2anat_InverseWarp.nii.gz', 'func2anat_InverseWarp.nii.gz']
+#     >>> adjust.cmdline
+#     '3dNwarpAdjust -nwarp func2anat_InverseWarp.nii.gz func2anat_InverseWarp.nii.gz func2anat_InverseWarp.nii.gz func2anat_InverseWarp.nii.gz func2anat_InverseWarp.nii.gz'
+#     >>> res = adjust.run()  # doctest: +SKIP
+# 
+#     
+task_name: NwarpAdjust
+nipype_name: NwarpAdjust
+nipype_module: nipype.interfaces.afni.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    warps: medimage/nifti-gz+list-of
+    # type=inputmultiobject|default=[]: List of input 3D warp datasets
+    in_files: generic/file+list-of
+    # type=inputmultiobject|default=[]: List of input 3D datasets to be warped by the adjusted warp datasets.  There must be exactly as many of these datasets as there are input warps.
+    out_file: generic/file
+    # type=file: output file
+    # type=file|default=<undefined>: Output mean dataset, only needed if in_files are also given. The output dataset will be on the common grid shared by the source datasets.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: output file
+    # type=file|default=<undefined>: Output mean dataset, only needed if in_files are also given. The output dataset will be on the common grid shared by the source datasets.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    warps:
+    # type=inputmultiobject|default=[]: List of input 3D warp datasets
+    in_files:
+    # type=inputmultiobject|default=[]: List of input 3D datasets to be warped by the adjusted warp datasets.  There must be exactly as many of these datasets as there are input warps.
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: Output mean dataset, only needed if in_files are also given. The output dataset will be on the common grid shared by the source datasets.
+    num_threads:
+    # type=int|default=1: set number of threads
+    outputtype:
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    warps:
+    # type=inputmultiobject|default=[]: List of input 3D warp datasets
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: 3dNwarpAdjust -nwarp func2anat_InverseWarp.nii.gz func2anat_InverseWarp.nii.gz func2anat_InverseWarp.nii.gz func2anat_InverseWarp.nii.gz func2anat_InverseWarp.nii.gz
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    warps:
+    # type=inputmultiobject|default=[]: List of input 3D warp datasets
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-afni/nwarp_adjust_callables.py b/example-specs/task/nipype_internal/pydra-afni/nwarp_adjust_callables.py
new file mode 100644
index 00000000..7d24d4c1
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/nwarp_adjust_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in NwarpAdjust.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-afni/nwarp_apply.yaml b/example-specs/task/nipype_internal/pydra-afni/nwarp_apply.yaml
new file mode 100644
index 00000000..3e6f321b
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/nwarp_apply.yaml
@@ -0,0 +1,154 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.afni.utils.NwarpApply' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Program to apply a nonlinear 3D warp saved from 3dQwarp
+#     (or 3dNwarpCat, etc.) to a 3D dataset, to produce a warped
+#     version of the source dataset.
+# 
+#     For complete details, see the `3dNwarpApply Documentation.
+#     <https://afni.nimh.nih.gov/pub/dist/doc/program_help/3dNwarpApply.html>`_
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import afni
+#     >>> nwarp = afni.NwarpApply()
+#     >>> nwarp.inputs.in_file = 'Fred+orig'
+#     >>> nwarp.inputs.master = 'NWARP'
+#     >>> nwarp.inputs.warp = "'Fred_WARP+tlrc Fred.Xaff12.1D'"
+#     >>> nwarp.cmdline
+#     "3dNwarpApply -source Fred+orig -interp wsinc5 -master NWARP -prefix Fred+orig_Nwarp -nwarp 'Fred_WARP+tlrc Fred.Xaff12.1D'"
+#     >>> res = nwarp.run()  # doctest: +SKIP
+# 
+#     
+task_name: NwarpApply
+nipype_name: NwarpApply
+nipype_module: nipype.interfaces.afni.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    master: generic/file
+    # type=file|default=<undefined>: the name of the master dataset, which defines the output grid
+    out_file: generic/file
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=traitcompound|default=None: the name of the dataset to be warped can be multiple datasets
+    warp:
+    # type=string|default='': the name of the warp dataset. multiple warps can be concatenated (make sure they exist)
+    inv_warp:
+    # type=bool|default=False: After the warp specified in '-nwarp' is computed, invert it
+    master:
+    # type=file|default=<undefined>: the name of the master dataset, which defines the output grid
+    interp:
+    # type=enum|default='wsinc5'|allowed['NN','cubic','linear','nearestneighbor','nearestneighbour','quintic','tricubic','trilinear','triquintic','wsinc5']: defines interpolation method to use during warp
+    ainterp:
+    # type=enum|default='NN'|allowed['NN','cubic','linear','nearestneighbor','nearestneighbour','quintic','tricubic','trilinear','triquintic','wsinc5']: specify a different interpolation method than might be used for the warp
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+    short:
+    # type=bool|default=False: Write output dataset using 16-bit short integers, rather than the usual 32-bit floats.
+    quiet:
+    # type=bool|default=False: don't be verbose :(
+    verb:
+    # type=bool|default=False: be extra verbose :)
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file: '"Fred+orig"'
+    # type=traitcompound|default=None: the name of the dataset to be warped can be multiple datasets
+    master:
+    # type=file|default=<undefined>: the name of the master dataset, which defines the output grid
+    warp: '"''Fred_WARP+tlrc Fred.Xaff12.1D''"'
+    # type=string|default='': the name of the warp dataset. multiple warps can be concatenated (make sure they exist)
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: 3dNwarpApply -source Fred+orig -interp wsinc5 -master NWARP -prefix Fred+orig_Nwarp -nwarp "Fred_WARP+tlrc Fred.Xaff12.1D"
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file: '"Fred+orig"'
+    # type=traitcompound|default=None: the name of the dataset to be warped can be multiple datasets
+    master:
+    # type=file|default=<undefined>: the name of the master dataset, which defines the output grid
+    warp: '"''Fred_WARP+tlrc Fred.Xaff12.1D''"'
+    # type=string|default='': the name of the warp dataset. multiple warps can be concatenated (make sure they exist)
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-afni/nwarp_apply_callables.py b/example-specs/task/nipype_internal/pydra-afni/nwarp_apply_callables.py
new file mode 100644
index 00000000..79d1bed8
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/nwarp_apply_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in NwarpApply.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-afni/nwarp_cat.yaml b/example-specs/task/nipype_internal/pydra-afni/nwarp_cat.yaml
new file mode 100644
index 00000000..7b957472
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/nwarp_cat.yaml
@@ -0,0 +1,179 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.afni.utils.NwarpCat' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Catenates (composes) 3D warps defined on a grid, OR via a matrix.
+# 
+#     .. note::
+# 
+#       * All transformations are from DICOM xyz (in mm) to DICOM xyz.
+# 
+#       * Matrix warps are in files that end in '.1D' or in '.txt'.  A matrix
+#         warp file should have 12 numbers in it, as output (for example), by
+#         '3dAllineate -1Dmatrix_save'.
+# 
+#       * Nonlinear warps are in dataset files (AFNI .HEAD/.BRIK or NIfTI .nii)
+#         with 3 sub-bricks giving the DICOM order xyz grid displacements in mm.
+# 
+#       * If all the input warps are matrices, then the output is a matrix
+#         and will be written to the file 'prefix.aff12.1D'.
+#         Unless the prefix already contains the string '.1D', in which case
+#         the filename is just the prefix.
+# 
+#       * If 'prefix' is just 'stdout', then the output matrix is written
+#         to standard output.
+#         In any of these cases, the output format is 12 numbers in one row.
+# 
+#       * If any of the input warps are datasets, they must all be defined on
+#         the same 3D grid!
+#         And of course, then the output will be a dataset on the same grid.
+#         However, you can expand the grid using the '-expad' option.
+# 
+#       * The order of operations in the final (output) warp is, for the
+#         case of 3 input warps:
+# 
+#             OUTPUT(x) = warp3( warp2( warp1(x) ) )
+# 
+#        That is, warp1 is applied first, then warp2, et cetera.
+#        The 3D x coordinates are taken from each grid location in the
+#        first dataset defined on a grid.
+# 
+#     For complete details, see the `3dNwarpCat Documentation.
+#     <https://afni.nimh.nih.gov/pub/dist/doc/program_help/3dNwarpCat.html>`_
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import afni
+#     >>> nwarpcat = afni.NwarpCat()
+#     >>> nwarpcat.inputs.in_files = ['Q25_warp+tlrc.HEAD', ('IDENT', 'structural.nii')]
+#     >>> nwarpcat.inputs.out_file = 'Fred_total_WARP'
+#     >>> nwarpcat.cmdline
+#     "3dNwarpCat -interp wsinc5 -prefix Fred_total_WARP Q25_warp+tlrc.HEAD 'IDENT(structural.nii)'"
+#     >>> res = nwarpcat.run()  # doctest: +SKIP
+# 
+#     
+task_name: NwarpCat
+nipype_name: NwarpCat
+nipype_module: nipype.interfaces.afni.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_files:
+    # type=list|default=[]: list of tuples of 3D warps and associated functions
+    space:
+    # type=string|default='': string to attach to the output dataset as its atlas space marker.
+    inv_warp:
+    # type=bool|default=False: invert the final warp before output
+    interp:
+    # type=enum|default='wsinc5'|allowed['linear','quintic','wsinc5']: specify a different interpolation method than might be used for the warp
+    expad:
+    # type=int|default=0: Pad the nonlinear warps by the given number of voxels in all directions. The warp displacements are extended by linear extrapolation from the faces of the input grid..
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+    verb:
+    # type=bool|default=False: be verbose
+    num_threads:
+    # type=int|default=1: set number of threads
+    outputtype:
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_files: '["Q25_warp+tlrc.HEAD", ("IDENT", "structural.nii")]'
+    # type=list|default=[]: list of tuples of 3D warps and associated functions
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: 3dNwarpCat -interp wsinc5 -prefix Fred_total_WARP Q25_warp+tlrc.HEAD "IDENT(structural.nii)"
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_files: '["Q25_warp+tlrc.HEAD", ("IDENT", "structural.nii")]'
+    # type=list|default=[]: list of tuples of 3D warps and associated functions
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-afni/nwarp_cat_callables.py b/example-specs/task/nipype_internal/pydra-afni/nwarp_cat_callables.py
new file mode 100644
index 00000000..fb01a71b
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/nwarp_cat_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in NwarpCat.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-afni/one_d_tool_py.yaml b/example-specs/task/nipype_internal/pydra-afni/one_d_tool_py.yaml
new file mode 100644
index 00000000..a93c9468
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/one_d_tool_py.yaml
@@ -0,0 +1,163 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.afni.utils.OneDToolPy' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# This program is meant to read/manipulate/write/diagnose 1D datasets.
+#     Input can be specified using AFNI sub-brick[]/time{} selectors.
+# 
+#     >>> from nipype.interfaces import afni
+#     >>> odt = afni.OneDToolPy()
+#     >>> odt.inputs.in_file = 'f1.1D'
+#     >>> odt.inputs.set_nruns = 3
+#     >>> odt.inputs.demean = True
+#     >>> odt.inputs.out_file = 'motion_dmean.1D'
+#     >>> odt.cmdline # doctest: +ELLIPSIS
+#     'python2 ...1d_tool.py -demean -infile f1.1D -write motion_dmean.1D -set_nruns 3'
+#      >>> res = odt.run()  # doctest: +SKIP
+task_name: OneDToolPy
+nipype_name: OneDToolPy
+nipype_module: nipype.interfaces.afni.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage-afni/oned
+    # type=file|default=<undefined>: input file to OneDTool
+    out_file: medimage-afni/oned
+    # type=file: output of 1D_tool.py
+    # type=file|default=<undefined>: write the current 1D data to FILE
+    show_cormat_warnings: generic/file
+    # type=file|default=<undefined>: Write cormat warnings to a file
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: medimage-afni/oned
+    # type=file: output of 1D_tool.py
+    # type=file|default=<undefined>: write the current 1D data to FILE
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to OneDTool
+    set_nruns:
+    # type=int|default=0: treat the input data as if it has nruns
+    derivative:
+    # type=bool|default=False: take the temporal derivative of each vector (done as first backward difference)
+    demean:
+    # type=bool|default=False: demean each run (new mean of each run = 0.0)
+    out_file:
+    # type=file: output of 1D_tool.py
+    # type=file|default=<undefined>: write the current 1D data to FILE
+    show_censor_count:
+    # type=bool|default=False: display the total number of censored TRs  Note : if input is a valid xmat.1D dataset, then the count will come from the header.  Otherwise the input is assumed to be a binary censorfile, and zeros are simply counted.
+    censor_motion:
+    # type=tuple|default=(<traits.trait_types.Float object at 0x11cffdc50>, <nipype.interfaces.base.traits_extension.File object at 0x11cffdd10>): Tuple of motion limit and outfile prefix. need to also set set_nruns -r set_run_lengths
+    censor_prev_TR:
+    # type=bool|default=False: for each censored TR, also censor previous
+    show_trs_uncensored:
+    # type=enum|default='comma'|allowed['comma','encoded','space','verbose']: display a list of TRs which were not censored in the specified style
+    show_cormat_warnings:
+    # type=file|default=<undefined>: Write cormat warnings to a file
+    show_indices_interest:
+    # type=bool|default=False: display column indices for regs of interest
+    show_trs_run:
+    # type=int|default=0: restrict -show_trs_[un]censored to the given 1-based run
+    outputtype:
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+    py27_path:
+    # type=traitcompound|default='python2': 
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to OneDTool
+    set_nruns: '3'
+    # type=int|default=0: treat the input data as if it has nruns
+    demean: 'True'
+    # type=bool|default=False: demean each run (new mean of each run = 0.0)
+    out_file:
+    # type=file: output of 1D_tool.py
+    # type=file|default=<undefined>: write the current 1D data to FILE
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: python2 ...1d_tool.py -demean -infile f1.1D -write motion_dmean.1D -set_nruns 3
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: input file to OneDTool
+    set_nruns: '3'
+    # type=int|default=0: treat the input data as if it has nruns
+    demean: 'True'
+    # type=bool|default=False: demean each run (new mean of each run = 0.0)
+    out_file:
+    # type=file: output of 1D_tool.py
+    # type=file|default=<undefined>: write the current 1D data to FILE
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-afni/one_d_tool_py_callables.py b/example-specs/task/nipype_internal/pydra-afni/one_d_tool_py_callables.py
new file mode 100644
index 00000000..979a9988
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/one_d_tool_py_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in OneDToolPy.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-afni/outlier_count.yaml b/example-specs/task/nipype_internal/pydra-afni/outlier_count.yaml
new file mode 100644
index 00000000..2f1f197b
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/outlier_count.yaml
@@ -0,0 +1,153 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.afni.preprocess.OutlierCount' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Calculates number of 'outliers' at each time point of a
+#     a 3D+time dataset.
+# 
+#     For complete details, see the `3dToutcount Documentation
+#     <https://afni.nimh.nih.gov/pub/dist/doc/program_help/3dToutcount.html>`_
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import afni
+#     >>> toutcount = afni.OutlierCount()
+#     >>> toutcount.inputs.in_file = 'functional.nii'
+#     >>> toutcount.cmdline  # doctest: +ELLIPSIS
+#     '3dToutcount -qthr 0.00100 functional.nii'
+#     >>> res = toutcount.run()  # doctest: +SKIP
+# 
+#     
+task_name: OutlierCount
+nipype_name: OutlierCount
+nipype_module: nipype.interfaces.afni.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: input dataset
+    mask: generic/file
+    # type=file|default=<undefined>: only count voxels within the given mask
+    outliers_file: generic/file
+    # type=file|default=<undefined>: output image file name
+    out_file: generic/file
+    # type=file: capture standard output
+    # type=file|default=<undefined>: capture standard output
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_outliers: generic/file
+    # type=file: output image file name
+    out_file: generic/file
+    # type=file: capture standard output
+    # type=file|default=<undefined>: capture standard output
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input dataset
+    mask:
+    # type=file|default=<undefined>: only count voxels within the given mask
+    qthr:
+    # type=range|default=0.001: indicate a value for q to compute alpha
+    autoclip:
+    # type=bool|default=False: clip off small voxels
+    automask:
+    # type=bool|default=False: clip off small voxels
+    fraction:
+    # type=bool|default=False: write out the fraction of masked voxels which are outliers at each timepoint
+    interval:
+    # type=bool|default=False: write out the median + 3.5 MAD of outlier count with each timepoint
+    save_outliers:
+    # type=bool|default=False: enables out_file option
+    outliers_file:
+    # type=file|default=<undefined>: output image file name
+    polort:
+    # type=int|default=0: detrend each voxel timeseries with polynomials
+    legendre:
+    # type=bool|default=False: use Legendre polynomials
+    out_file:
+    # type=file: capture standard output
+    # type=file|default=<undefined>: capture standard output
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input dataset
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: 3dToutcount -qthr 0.00100 functional.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: input dataset
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-afni/outlier_count_callables.py b/example-specs/task/nipype_internal/pydra-afni/outlier_count_callables.py
new file mode 100644
index 00000000..48231b09
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/outlier_count_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in OutlierCount.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-afni/quality_index.yaml b/example-specs/task/nipype_internal/pydra-afni/quality_index.yaml
new file mode 100644
index 00000000..1437cf53
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/quality_index.yaml
@@ -0,0 +1,146 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.afni.preprocess.QualityIndex' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Computes a quality index for each sub-brick in a 3D+time dataset.
+#     The output is a 1D time series with the index for each sub-brick.
+#     The results are written to stdout.
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import afni
+#     >>> tqual = afni.QualityIndex()
+#     >>> tqual.inputs.in_file = 'functional.nii'
+#     >>> tqual.cmdline  # doctest: +ELLIPSIS
+#     '3dTqual functional.nii > functional_tqual'
+#     >>> res = tqual.run()  # doctest: +SKIP
+# 
+#     See Also
+#     --------
+#     For complete details, see the `3dTqual Documentation
+#     <https://afni.nimh.nih.gov/pub/dist/doc/program_help/3dTqual.html>`_
+# 
+#     
+task_name: QualityIndex
+nipype_name: QualityIndex
+nipype_module: nipype.interfaces.afni.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: input dataset
+    mask: generic/file
+    # type=file|default=<undefined>: compute correlation only across masked voxels
+    out_file: generic/file
+    # type=file: file containing the captured standard output
+    # type=file|default=<undefined>: capture standard output
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: file containing the captured standard output
+    # type=file|default=<undefined>: capture standard output
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input dataset
+    mask:
+    # type=file|default=<undefined>: compute correlation only across masked voxels
+    spearman:
+    # type=bool|default=False: Quality index is 1 minus the Spearman (rank) correlation coefficient of each sub-brick with the median sub-brick. (default).
+    quadrant:
+    # type=bool|default=False: Similar to -spearman, but using 1 minus the quadrant correlation coefficient as the quality index.
+    autoclip:
+    # type=bool|default=False: clip off small voxels
+    automask:
+    # type=bool|default=False: clip off small voxels
+    clip:
+    # type=float|default=0.0: clip off values below
+    interval:
+    # type=bool|default=False: write out the median + 3.5 MAD of outlier count with each timepoint
+    out_file:
+    # type=file: file containing the captured standard output
+    # type=file|default=<undefined>: capture standard output
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input dataset
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: 3dTqual functional.nii > functional_tqual
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: input dataset
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-afni/quality_index_callables.py b/example-specs/task/nipype_internal/pydra-afni/quality_index_callables.py
new file mode 100644
index 00000000..dc347515
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/quality_index_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in QualityIndex.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-afni/qwarp.yaml b/example-specs/task/nipype_internal/pydra-afni/qwarp.yaml
new file mode 100644
index 00000000..d56c4622
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/qwarp.yaml
@@ -0,0 +1,622 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.afni.preprocess.Qwarp' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Allineate your images prior to passing them to this workflow.
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import afni
+#     >>> qwarp = afni.Qwarp()
+#     >>> qwarp.inputs.in_file = 'sub-01_dir-LR_epi.nii.gz'
+#     >>> qwarp.inputs.nopadWARP = True
+#     >>> qwarp.inputs.base_file = 'sub-01_dir-RL_epi.nii.gz'
+#     >>> qwarp.inputs.plusminus = True
+#     >>> qwarp.cmdline
+#     '3dQwarp -base sub-01_dir-RL_epi.nii.gz -source sub-01_dir-LR_epi.nii.gz -nopadWARP -prefix ppp_sub-01_dir-LR_epi -plusminus'
+#     >>> res = qwarp.run()  # doctest: +SKIP
+# 
+#     >>> from nipype.interfaces import afni
+#     >>> qwarp = afni.Qwarp()
+#     >>> qwarp.inputs.in_file = 'structural.nii'
+#     >>> qwarp.inputs.base_file = 'mni.nii'
+#     >>> qwarp.inputs.resample = True
+#     >>> qwarp.cmdline
+#     '3dQwarp -base mni.nii -source structural.nii -prefix ppp_structural -resample'
+#     >>> res = qwarp.run()  # doctest: +SKIP
+# 
+#     >>> from nipype.interfaces import afni
+#     >>> qwarp = afni.Qwarp()
+#     >>> qwarp.inputs.in_file = 'structural.nii'
+#     >>> qwarp.inputs.base_file = 'epi.nii'
+#     >>> qwarp.inputs.out_file = 'anatSSQ.nii.gz'
+#     >>> qwarp.inputs.resample = True
+#     >>> qwarp.inputs.lpc = True
+#     >>> qwarp.inputs.verb = True
+#     >>> qwarp.inputs.iwarp = True
+#     >>> qwarp.inputs.blur = [0,3]
+#     >>> qwarp.cmdline
+#     '3dQwarp -base epi.nii -blur 0.0 3.0 -source structural.nii -iwarp -prefix anatSSQ.nii.gz -resample -verb -lpc'
+# 
+#     >>> res = qwarp.run()  # doctest: +SKIP
+# 
+#     >>> from nipype.interfaces import afni
+#     >>> qwarp = afni.Qwarp()
+#     >>> qwarp.inputs.in_file = 'structural.nii'
+#     >>> qwarp.inputs.base_file = 'mni.nii'
+#     >>> qwarp.inputs.duplo = True
+#     >>> qwarp.inputs.blur = [0,3]
+#     >>> qwarp.cmdline
+#     '3dQwarp -base mni.nii -blur 0.0 3.0 -duplo -source structural.nii -prefix ppp_structural'
+# 
+#     >>> res = qwarp.run()  # doctest: +SKIP
+# 
+#     >>> from nipype.interfaces import afni
+#     >>> qwarp = afni.Qwarp()
+#     >>> qwarp.inputs.in_file = 'structural.nii'
+#     >>> qwarp.inputs.base_file = 'mni.nii'
+#     >>> qwarp.inputs.duplo = True
+#     >>> qwarp.inputs.minpatch = 25
+#     >>> qwarp.inputs.blur = [0,3]
+#     >>> qwarp.inputs.out_file = 'Q25'
+#     >>> qwarp.cmdline
+#     '3dQwarp -base mni.nii -blur 0.0 3.0 -duplo -source structural.nii -minpatch 25 -prefix Q25'
+# 
+#     >>> res = qwarp.run()  # doctest: +SKIP
+#     >>> qwarp2 = afni.Qwarp()
+#     >>> qwarp2.inputs.in_file = 'structural.nii'
+#     >>> qwarp2.inputs.base_file = 'mni.nii'
+#     >>> qwarp2.inputs.blur = [0,2]
+#     >>> qwarp2.inputs.out_file = 'Q11'
+#     >>> qwarp2.inputs.inilev = 7
+#     >>> qwarp2.inputs.iniwarp = ['Q25_warp+tlrc.HEAD']
+#     >>> qwarp2.cmdline
+#     '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
+#     "3dQwarp -allineate -allineate_opts '-cose lpa -verb' -base mni.nii -source structural.nii -prefix ppp_structural"
+# 
+#     >>> res3 = qwarp3.run()  # doctest: +SKIP
+# 
+#     See Also
+#     --------
+#     For complete details, see the `3dQwarp Documentation.
+#     <https://afni.nimh.nih.gov/pub/dist/doc/program_help/3dQwarp.html>`__
+# 
+#     
+task_name: Qwarp
+nipype_name: Qwarp
+nipype_module: nipype.interfaces.afni.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1,medimage/nifti-gz
+    # type=file|default=<undefined>: Source image (opposite phase encoding direction than base image).
+    base_file: medimage/nifti1,medimage/nifti-gz
+    # type=file|default=<undefined>: Base image (opposite phase encoding direction than source image).
+    out_file: medimage/nifti-gz
+    # type=file|default=<undefined>: Sets the prefix/suffix for the output datasets.  * The source dataset is warped to match the base   and gets prefix 'ppp'. (Except if '-plusminus' is used * The final interpolation to this output dataset is   done using the 'wsinc5' method.  See the output of   3dAllineate -HELP   (in the "Modifying '-final wsinc5'" section) for   the lengthy technical details. * The 3D warp used is saved in a dataset with   prefix 'ppp_WARP' -- this dataset can be used   with 3dNwarpApply and 3dNwarpCat, for example. * To be clear, this is the warp from source dataset   coordinates to base dataset coordinates, where the   values at each base grid point are the xyz displacements   needed to move that grid point's xyz values to the   corresponding xyz values in the source dataset:   base( (x,y,z) + WARP(x,y,z) ) matches source(x,y,z)   Another way to think of this warp is that it 'pulls'   values back from source space to base space. * 3dNwarpApply would use 'ppp_WARP' to transform datasets   aligned with the source dataset to be aligned with the   base dataset.  **If you do NOT want this warp saved, use the option '-nowarp'**. (However, this warp is usually the most valuable possible output!)  * If you want to calculate and save the inverse 3D warp,   use the option '-iwarp'.  This inverse warp will then be   saved in a dataset with prefix 'ppp_WARPINV'. * This inverse warp could be used to transform data from base   space to source space, if you need to do such an operation. * You can easily compute the inverse later, say by a command like   3dNwarpCat -prefix Z_WARPINV 'INV(Z_WARP+tlrc)'   or the inverse can be computed as needed in 3dNwarpApply, like   3dNwarpApply -nwarp 'INV(Z_WARP+tlrc)' -source Dataset.nii ...  
+    weight: generic/file
+    # type=file|default=<undefined>: Instead of computing the weight from the base dataset,directly input the weight volume from dataset 'www'.Useful if you know what over parts of the base image youwant to emphasize or de-emphasize the matching functional.
+    out_weight_file: generic/file
+    # type=file|default=<undefined>: Write the weight volume to disk as a dataset
+    emask: generic/file
+    # type=file|default=<undefined>: Here, 'ee' is a dataset to specify a mask of voxelsto EXCLUDE from the analysis -- all voxels in 'ee'that are NONZERO will not be used in the alignment.The base image always automasked -- the emask isextra, to indicate voxels you definitely DON'T wantincluded in the matching process, even if they areinside the brain.
+    iniwarp: medimage-afni/head+list-of
+    # type=list|default=[]: A dataset with an initial nonlinear warp to use.  * If this option is not used, the initial warp is the identity. * You can specify a catenation of warps (in quotes) here, as in   program 3dNwarpApply. * As a special case, if you just input an affine matrix in a .1D   file, that will work also -- it is treated as giving the initial   warp via the string "IDENT(base_dataset) matrix_file.aff12.1D". * You CANNOT use this option with -duplo !! * -iniwarp is usually used with -inilev to re-start 3dQwarp from   a previous stopping point.  
+    gridlist: generic/file
+    # type=file|default=<undefined>: This option provides an alternate way to specify the patch grid sizes used in the warp optimization process. 'gl' is a 1D file with a list of patches to use -- in most cases, you will want to use it in the following form: ``-gridlist '1D: 0 151 101 75 51'``  * Here, a 0 patch size means the global domain. Patch sizes   otherwise should be odd integers >= 5. * If you use the '0' patch size again after the first position,   you will actually get an iteration at the size of the   default patch level 1, where the patch sizes are 75% of   the volume dimension.  There is no way to force the program   to literally repeat the sui generis step of lev=0.  
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    warped_source: generic/file
+    # type=file: Warped source file. If plusminus is used, this is the undistortedsource file.
+    warped_base: generic/file
+    # type=file: Undistorted base file.
+    source_warp: generic/file
+    # type=file: Displacement in mm for the source image.If plusminus is used this is the field suceptibility correctionwarp (in 'mm') for source image.
+    base_warp: generic/file
+    # type=file: Displacement in mm for the base image.If plus minus is used, this is the field suceptibility correctionwarp (in 'mm') for base image. This is only output if plusminusor iwarp options are passed
+    weights: generic/file
+    # type=file: Auto-computed weight volume.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: Source image (opposite phase encoding direction than base image).
+    base_file:
+    # type=file|default=<undefined>: Base image (opposite phase encoding direction than source image).
+    out_file:
+    # type=file|default=<undefined>: Sets the prefix/suffix for the output datasets.  * The source dataset is warped to match the base   and gets prefix 'ppp'. (Except if '-plusminus' is used * The final interpolation to this output dataset is   done using the 'wsinc5' method.  See the output of   3dAllineate -HELP   (in the "Modifying '-final wsinc5'" section) for   the lengthy technical details. * The 3D warp used is saved in a dataset with   prefix 'ppp_WARP' -- this dataset can be used   with 3dNwarpApply and 3dNwarpCat, for example. * To be clear, this is the warp from source dataset   coordinates to base dataset coordinates, where the   values at each base grid point are the xyz displacements   needed to move that grid point's xyz values to the   corresponding xyz values in the source dataset:   base( (x,y,z) + WARP(x,y,z) ) matches source(x,y,z)   Another way to think of this warp is that it 'pulls'   values back from source space to base space. * 3dNwarpApply would use 'ppp_WARP' to transform datasets   aligned with the source dataset to be aligned with the   base dataset.  **If you do NOT want this warp saved, use the option '-nowarp'**. (However, this warp is usually the most valuable possible output!)  * If you want to calculate and save the inverse 3D warp,   use the option '-iwarp'.  This inverse warp will then be   saved in a dataset with prefix 'ppp_WARPINV'. * This inverse warp could be used to transform data from base   space to source space, if you need to do such an operation. * You can easily compute the inverse later, say by a command like   3dNwarpCat -prefix Z_WARPINV 'INV(Z_WARP+tlrc)'   or the inverse can be computed as needed in 3dNwarpApply, like   3dNwarpApply -nwarp 'INV(Z_WARP+tlrc)' -source Dataset.nii ...  
+    resample:
+    # type=bool|default=False: This option simply resamples the source dataset to match the base dataset grid.  You can use this if the two datasets overlap well (as seen in the AFNI GUI), but are not on the same 3D grid.  * If they don't overlap well, allineate them first * The reampling here is done with the   'wsinc5' method, which has very little blurring artifact. * If the base and source datasets ARE on the same 3D grid,   then the -resample option will be ignored. * You CAN use -resample with these 3dQwarp options:   -plusminus  -inilev  -iniwarp  -duplo  
+    allineate:
+    # type=bool|default=False: 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.
+    allineate_opts:
+    # type=str|default='': add extra options to the 3dAllineate command to be run by 3dQwarp.
+    nowarp:
+    # type=bool|default=False: Do not save the _WARP file.
+    iwarp:
+    # type=bool|default=False: Do compute and save the _WARPINV file.
+    pear:
+    # type=bool|default=False: Use strict Pearson correlation for matching.Not usually recommended, since the 'clipped Pearson' methodused by default will reduce the impact of outlier values.
+    noneg:
+    # type=bool|default=False: Replace negative values in either input volume with 0.  * If there ARE negative input values, and you do NOT use -noneg,   then strict Pearson correlation will be used, since the 'clipped'   method only is implemented for non-negative volumes. * '-noneg' is not the default, since there might be situations where   you want to align datasets with positive and negative values mixed. * But, in many cases, the negative values in a dataset are just the   result of interpolation artifacts (or other peculiarities), and so   they should be ignored.  That is what '-noneg' is for.  
+    nopenalty:
+    # type=bool|default=False: Replace negative values in either input volume with 0.  * If there ARE negative input values, and you do NOT use -noneg,   then strict Pearson correlation will be used, since the 'clipped'   method only is implemented for non-negative volumes. * '-noneg' is not the default, since there might be situations where   you want to align datasets with positive and negative values mixed. * But, in many cases, the negative values in a dataset are just the   result of interpolation artifacts (or other peculiarities), and so   they should be ignored. That is what '-noneg' is for.  
+    penfac:
+    # type=float|default=0.0: Use this value to weight the penalty. The default value is 1. Larger values mean the penalty counts more, reducing grid distortions, insha'Allah; '-nopenalty' is the same as '-penfac 0'. In 23 Sep 2013 Zhark increased the default value of the penalty by a factor of 5, and also made it get progressively larger with each level of refinement. Thus, warping results will vary from earlier instances of 3dQwarp.  * The progressive increase in the penalty at higher levels   means that the 'cost function' can actually look like the   alignment is getting worse when the levels change. * IF you wish to turn off this progression, for whatever   reason (e.g., to keep compatibility with older results),   use the option '-penold'.To be completely compatible with   the older 3dQwarp, you'll also have to use '-penfac 0.2'.  
+    noweight:
+    # type=bool|default=False: If you want a binary weight (the old default), use this option.That is, each voxel in the base volume automask will beweighted the same in the computation of the cost functional.
+    weight:
+    # type=file|default=<undefined>: Instead of computing the weight from the base dataset,directly input the weight volume from dataset 'www'.Useful if you know what over parts of the base image youwant to emphasize or de-emphasize the matching functional.
+    wball:
+    # type=list|default=[]: "``-wball x y z r f`` Enhance automatic weight from '-useweight' by a factor of 1+f\*Gaussian(FWHM=r) centered in the base image at DICOM coordinates (x,y,z) and with radius 'r'. The goal of this option is to try and make the alignment better in a specific part of the brain. Example:  -wball 0 14 6 30 40 to emphasize the thalamic area (in MNI/Talairach space).  * The 'r' parameter must be positive! * The 'f' parameter must be between 1 and 100 (inclusive). * '-wball' does nothing if you input your own weight   with the '-weight' option. * '-wball' does change the binary weight created by   the '-noweight' option. * You can only use '-wball' once in a run of 3dQwarp.  **The effect of '-wball' is not dramatic.** The example above makes the average brain image across a collection of subjects a little sharper in the thalamic area, which might have some small value.  If you care enough about alignment to use '-wball', then you should examine the results from 3dQwarp for each subject, to see if the alignments are good enough for your purposes.
+    wmask:
+    # type=tuple|default=(<nipype.interfaces.base.traits_extension.File object at 0x11cef9410>, <traits.trait_types.Float object at 0x11cef8f10>): Similar to '-wball', but here, you provide a dataset 'ws' that indicates where to increase the weight.  * The 'ws' dataset must be on the same 3D grid as the base dataset. * 'ws' is treated as a mask -- it only matters where it   is nonzero -- otherwise, the values inside are not used. * After 'ws' comes the factor 'f' by which to increase the   automatically computed weight.  Where 'ws' is nonzero,   the weighting will be multiplied by (1+f). * As with '-wball', the factor 'f' should be between 1 and 100.  
+    out_weight_file:
+    # type=file|default=<undefined>: Write the weight volume to disk as a dataset
+    blur:
+    # type=list|default=[]: Gaussian blur the input images by 'bb' (FWHM) voxels before doing the alignment (the output dataset will not be blurred). The default is 2.345 (for no good reason).  * Optionally, you can provide 2 values for 'bb', and then   the first one is applied to the base volume, the second   to the source volume.   e.g., '-blur 0 3' to skip blurring the base image   (if the base is a blurry template, for example). * A negative blur radius means to use 3D median filtering,   rather than Gaussian blurring.  This type of filtering will   better preserve edges, which can be important in alignment. * If the base is a template volume that is already blurry,   you probably don't want to blur it again, but blurring   the source volume a little is probably a good idea, to   help the program avoid trying to match tiny features. * Note that -duplo will blur the volumes some extra   amount for the initial small-scale warping, to make   that phase of the program converge more rapidly.  
+    pblur:
+    # type=list|default=[]: Use progressive blurring; that is, for larger patch sizes, the amount of blurring is larger.  The general idea is to avoid trying to match finer details when the patch size and incremental warps are coarse.  When '-blur' is used as well, it sets a minimum amount of blurring that will be used. [06 Aug 2014 -- '-pblur' may become the default someday].  * You can optionally give the fraction of the patch size that   is used for the progressive blur by providing a value between   0 and 0.25 after '-pblur'.  If you provide TWO values, the   the first fraction is used for progressively blurring the   base image and the second for the source image.  The default   parameters when just '-pblur' is given is the same as giving   the options as '-pblur 0.09 0.09'. * '-pblur' is useful when trying to match 2 volumes with high   amounts of detail; e.g, warping one subject's brain image to   match another's, or trying to warp to match a detailed template. * Note that using negative values with '-blur' means that the   progressive blurring will be done with median filters, rather   than Gaussian linear blurring.  Note: The combination of the -allineate and -pblur options will make the results of using 3dQwarp to align to a template somewhat less sensitive to initial head position and scaling.
+    emask:
+    # type=file|default=<undefined>: Here, 'ee' is a dataset to specify a mask of voxelsto EXCLUDE from the analysis -- all voxels in 'ee'that are NONZERO will not be used in the alignment.The base image always automasked -- the emask isextra, to indicate voxels you definitely DON'T wantincluded in the matching process, even if they areinside the brain.
+    noXdis:
+    # type=bool|default=False: Warp will not displace in x direction
+    noYdis:
+    # type=bool|default=False: Warp will not displace in y direction
+    noZdis:
+    # type=bool|default=False: Warp will not displace in z direction
+    iniwarp:
+    # type=list|default=[]: A dataset with an initial nonlinear warp to use.  * If this option is not used, the initial warp is the identity. * You can specify a catenation of warps (in quotes) here, as in   program 3dNwarpApply. * As a special case, if you just input an affine matrix in a .1D   file, that will work also -- it is treated as giving the initial   warp via the string "IDENT(base_dataset) matrix_file.aff12.1D". * You CANNOT use this option with -duplo !! * -iniwarp is usually used with -inilev to re-start 3dQwarp from   a previous stopping point.  
+    inilev:
+    # type=int|default=0: The initial refinement 'level' at which to start.  * Usually used with -iniwarp; CANNOT be used with -duplo. * The combination of -inilev and -iniwarp lets you take the   results of a previous 3dQwarp run and refine them further:   Note that the source dataset in the second run is the SAME as   in the first run.  If you don't see why this is necessary,   then you probably need to seek help from an AFNI guru.  
+    minpatch:
+    # type=int|default=0: The value of mm should be an odd integer.  * The default value of mm is 25. * For more accurate results than mm=25, try 19 or 13. * The smallest allowed patch size is 5. * You may want stop at a larger patch size (say 7 or 9) and use   the -Qfinal option to run that final level with quintic warps,   which might run faster and provide the same degree of warp detail. * Trying to make two different brain volumes match in fine detail   is usually a waste of time, especially in humans.  There is too   much variability in anatomy to match gyrus to gyrus accurately.   For this reason, the default minimum patch size is 25 voxels.   Using a smaller '-minpatch' might try to force the warp to   match features that do not match, and the result can be useless   image distortions -- another reason to LOOK AT THE RESULTS.  
+    maxlev:
+    # type=int|default=0: The initial refinement 'level' at which to start.  * Usually used with -iniwarp; CANNOT be used with -duplo. * The combination of -inilev and -iniwarp lets you take the   results of a previous 3dQwarp run and refine them further:   Note that the source dataset in the second run is the SAME as   in the first run.  If you don't see why this is necessary,   then you probably need to seek help from an AFNI guru.  
+    gridlist:
+    # type=file|default=<undefined>: This option provides an alternate way to specify the patch grid sizes used in the warp optimization process. 'gl' is a 1D file with a list of patches to use -- in most cases, you will want to use it in the following form: ``-gridlist '1D: 0 151 101 75 51'``  * Here, a 0 patch size means the global domain. Patch sizes   otherwise should be odd integers >= 5. * If you use the '0' patch size again after the first position,   you will actually get an iteration at the size of the   default patch level 1, where the patch sizes are 75% of   the volume dimension.  There is no way to force the program   to literally repeat the sui generis step of lev=0.  
+    allsave:
+    # type=bool|default=False:  This option lets you save the output warps from each level" of the refinement process.  Mostly used for experimenting." Will only save all the outputs if the program terminates" normally -- if it crashes, or freezes, then all these" warps are lost.
+    duplo:
+    # type=bool|default=False: Start off with 1/2 scale versions of the volumes," for getting a speedy coarse first alignment."  * Then scales back up to register the full volumes."   The goal is greater speed, and it seems to help this"   positively piggish program to be more expeditious." * However, accuracy is somewhat lower with '-duplo',"   for reasons that currently elude Zhark; for this reason,"   the Emperor does not usually use '-duplo'.  
+    workhard:
+    # type=bool|default=False: Iterate more times, which can help when the volumes are hard to align at all, or when you hope to get a more precise alignment.  * Slows the program down (possibly a lot), of course. * When you combine '-workhard'  with '-duplo', only the   full size volumes get the extra iterations. * For finer control over which refinement levels work hard,   you can use this option in the form (for example) ``-workhard:4:7``   which implies the extra iterations will be done at levels   4, 5, 6, and 7, but not otherwise. * You can also use '-superhard' to iterate even more, but   this extra option will REALLY slow things down.    * Under most circumstances, you should not need to use either     ``-workhard`` or ``-superhard``.   * The fastest way to register to a template image is via the     ``-duplo`` option, and without the ``-workhard`` or ``-superhard`` options.   * If you use this option in the form '-Workhard' (first letter     in upper case), then the second iteration at each level is     done with quintic polynomial warps.  
+    Qfinal:
+    # type=bool|default=False: At the finest patch size (the final level), use Hermite quintic polynomials for the warp instead of cubic polynomials.  * In a 3D 'patch', there are 2x2x2x3=24 cubic polynomial basis   function parameters over which to optimize (2 polynomials   dependent on each of the x,y,z directions, and 3 different   directions of displacement). * There are 3x3x3x3=81 quintic polynomial parameters per patch. * With -Qfinal, the final level will have more detail in   the allowed warps, at the cost of yet more CPU time. * However, no patch below 7x7x7 in size will be done with quintic   polynomials. * This option is also not usually needed, and is experimental.  
+    Qonly:
+    # type=bool|default=False: Use Hermite quintic polynomials at all levels.  * Very slow (about 4 times longer).  Also experimental. * Will produce a (discrete representation of a) C2 warp.  
+    plusminus:
+    # type=bool|default=False: Normally, the warp displacements dis(x) are defined to match base(x) to source(x+dis(x)).  With this option, the match is between base(x-dis(x)) and source(x+dis(x)) -- the two images 'meet in the middle'.  * One goal is to mimic the warping done to MRI EPI data by   field inhomogeneities, when registering between a 'blip up'   and a 'blip down' down volume, which will have opposite   distortions. * Define Wp(x) = x+dis(x) and Wm(x) = x-dis(x).  Then since   base(Wm(x)) matches source(Wp(x)), by substituting INV(Wm(x))   wherever we see x, we have base(x) matches source(Wp(INV(Wm(x))));   that is, the warp V(x) that one would get from the 'usual' way   of running 3dQwarp is V(x) = Wp(INV(Wm(x))). * Conversely, we can calculate Wp(x) in terms of V(x) as follows:   If V(x) = x + dv(x), define Vh(x) = x + dv(x)/2;   then Wp(x) = V(INV(Vh(x))) * With the above formulas, it is possible to compute Wp(x) from   V(x) and vice-versa, using program 3dNwarpCalc.  The requisite   commands are left as an exercise for the aspiring AFNI Jedi Master. * You can use the semi-secret '-pmBASE' option to get the V(x)   warp and the source dataset warped to base space, in addition to   the Wp(x) '_PLUS' and Wm(x) '_MINUS' warps.    * Alas: -plusminus does not work with -duplo or -allineate :-(   * However, you can use -iniwarp with -plusminus :-)   * The outputs have _PLUS (from the source dataset) and _MINUS     (from the base dataset) in their filenames, in addition to     the prefix.  The -iwarp option, if present, will be ignored.  
+    nopad:
+    # type=bool|default=False: Do NOT use zero-padding on the 3D base and source images. [Default == zero-pad, if needed]  * The underlying model for deformations goes to zero at the   edge of the volume being warped.  However, if there is   significant data near an edge of the volume, then it won't   get displaced much, and so the results might not be good. * Zero padding is designed as a way to work around this potential   problem.  You should NOT need the '-nopad' option for any   reason that Zhark can think of, but it is here to be symmetrical   with 3dAllineate. * Note that the output (warped from source) dataset will be on the   base dataset grid whether or not zero-padding is allowed.  However,   unless you use the following option, allowing zero-padding (i.e.,   the default operation) will make the output WARP dataset(s) be   on a larger grid (also see '-expad' below).  
+    nopadWARP:
+    # type=bool|default=False: If for some reason you require the warp volume tomatch the base volume, then use this option to have the outputWARP dataset(s) truncated.
+    expad:
+    # type=int|default=0: This option instructs the program to pad the warp by an extra'EE' voxels (and then 3dQwarp starts optimizing it).This option is seldom needed, but can be useful if youmight later catenate the nonlinear warp -- via 3dNwarpCat --with an affine transformation that contains a large shift.Under that circumstance, the nonlinear warp might be shiftedpartially outside its original grid, so expanding that gridcan avoid this problem.Note that this option perforce turns off '-nopadWARP'.
+    ballopt:
+    # type=bool|default=False: Normally, the incremental warp parameters are optimized insidea rectangular 'box' (24 dimensional for cubic patches, 81 forquintic patches), whose limits define the amount of distortionallowed at each step.  Using '-ballopt' switches these limitsto be applied to a 'ball' (interior of a hypersphere), whichcan allow for larger incremental displacements.  Use thisoption if you think things need to be able to move farther.
+    baxopt:
+    # type=bool|default=False: Use the 'box' optimization limits instead of the 'ball'[this is the default at present].Note that if '-workhard' is used, then ball and box optimizationare alternated in the different iterations at each level, sothese two options have no effect in that case.
+    verb:
+    # type=bool|default=False: more detailed description of the process
+    quiet:
+    # type=bool|default=False: Cut out most of the fun fun fun progress messages :-(
+    overwrite:
+    # type=bool|default=False: Overwrite outputs
+    lpc:
+    # type=bool|default=False: Local Pearson minimization (i.e., EPI-T1 registration)This option has not be extensively testedIf you use '-lpc', then '-maxlev 0' is automatically set.If you want to go to more refined levels, you can set '-maxlev'This should be set up to have lpc as the second to last argumentand maxlev as the second to last argument, as needed by AFNIUsing maxlev > 1 is not recommended for EPI-T1 alignment.
+    lpa:
+    # type=bool|default=False: Local Pearson maximization. This option has not be extensively tested
+    hel:
+    # type=bool|default=False: Hellinger distance: a matching function for the adventurousThis option has NOT be extensively tested for usefulnessand should be considered experimental at this infundibulum.
+    mi:
+    # type=bool|default=False: Mutual Information: a matching function for the adventurousThis option has NOT be extensively tested for usefulnessand should be considered experimental at this infundibulum.
+    nmi:
+    # type=bool|default=False: Normalized Mutual Information: a matching function for the adventurousThis option has NOT been extensively tested for usefulnessand should be considered experimental at this infundibulum.
+    num_threads:
+    # type=int|default=1: set number of threads
+    outputtype:
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: Source image (opposite phase encoding direction than base image).
+    nopadWARP: 'True'
+    # type=bool|default=False: If for some reason you require the warp volume tomatch the base volume, then use this option to have the outputWARP dataset(s) truncated.
+    base_file:
+    # type=file|default=<undefined>: Base image (opposite phase encoding direction than source image).
+    plusminus: 'True'
+    # type=bool|default=False: Normally, the warp displacements dis(x) are defined to match base(x) to source(x+dis(x)).  With this option, the match is between base(x-dis(x)) and source(x+dis(x)) -- the two images 'meet in the middle'.  * One goal is to mimic the warping done to MRI EPI data by   field inhomogeneities, when registering between a 'blip up'   and a 'blip down' down volume, which will have opposite   distortions. * Define Wp(x) = x+dis(x) and Wm(x) = x-dis(x).  Then since   base(Wm(x)) matches source(Wp(x)), by substituting INV(Wm(x))   wherever we see x, we have base(x) matches source(Wp(INV(Wm(x))));   that is, the warp V(x) that one would get from the 'usual' way   of running 3dQwarp is V(x) = Wp(INV(Wm(x))). * Conversely, we can calculate Wp(x) in terms of V(x) as follows:   If V(x) = x + dv(x), define Vh(x) = x + dv(x)/2;   then Wp(x) = V(INV(Vh(x))) * With the above formulas, it is possible to compute Wp(x) from   V(x) and vice-versa, using program 3dNwarpCalc.  The requisite   commands are left as an exercise for the aspiring AFNI Jedi Master. * You can use the semi-secret '-pmBASE' option to get the V(x)   warp and the source dataset warped to base space, in addition to   the Wp(x) '_PLUS' and Wm(x) '_MINUS' warps.    * Alas: -plusminus does not work with -duplo or -allineate :-(   * However, you can use -iniwarp with -plusminus :-)   * The outputs have _PLUS (from the source dataset) and _MINUS     (from the base dataset) in their filenames, in addition to     the prefix.  The -iwarp option, if present, will be ignored.  
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: Source image (opposite phase encoding direction than base image).
+    base_file:
+    # type=file|default=<undefined>: Base image (opposite phase encoding direction than source image).
+    resample: 'True'
+    # type=bool|default=False: This option simply resamples the source dataset to match the base dataset grid.  You can use this if the two datasets overlap well (as seen in the AFNI GUI), but are not on the same 3D grid.  * If they don't overlap well, allineate them first * The reampling here is done with the   'wsinc5' method, which has very little blurring artifact. * If the base and source datasets ARE on the same 3D grid,   then the -resample option will be ignored. * You CAN use -resample with these 3dQwarp options:   -plusminus  -inilev  -iniwarp  -duplo  
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: Source image (opposite phase encoding direction than base image).
+    base_file:
+    # type=file|default=<undefined>: Base image (opposite phase encoding direction than source image).
+    out_file:
+    # type=file|default=<undefined>: Sets the prefix/suffix for the output datasets.  * The source dataset is warped to match the base   and gets prefix 'ppp'. (Except if '-plusminus' is used * The final interpolation to this output dataset is   done using the 'wsinc5' method.  See the output of   3dAllineate -HELP   (in the "Modifying '-final wsinc5'" section) for   the lengthy technical details. * The 3D warp used is saved in a dataset with   prefix 'ppp_WARP' -- this dataset can be used   with 3dNwarpApply and 3dNwarpCat, for example. * To be clear, this is the warp from source dataset   coordinates to base dataset coordinates, where the   values at each base grid point are the xyz displacements   needed to move that grid point's xyz values to the   corresponding xyz values in the source dataset:   base( (x,y,z) + WARP(x,y,z) ) matches source(x,y,z)   Another way to think of this warp is that it 'pulls'   values back from source space to base space. * 3dNwarpApply would use 'ppp_WARP' to transform datasets   aligned with the source dataset to be aligned with the   base dataset.  **If you do NOT want this warp saved, use the option '-nowarp'**. (However, this warp is usually the most valuable possible output!)  * If you want to calculate and save the inverse 3D warp,   use the option '-iwarp'.  This inverse warp will then be   saved in a dataset with prefix 'ppp_WARPINV'. * This inverse warp could be used to transform data from base   space to source space, if you need to do such an operation. * You can easily compute the inverse later, say by a command like   3dNwarpCat -prefix Z_WARPINV 'INV(Z_WARP+tlrc)'   or the inverse can be computed as needed in 3dNwarpApply, like   3dNwarpApply -nwarp 'INV(Z_WARP+tlrc)' -source Dataset.nii ...  
+    resample: 'True'
+    # type=bool|default=False: This option simply resamples the source dataset to match the base dataset grid.  You can use this if the two datasets overlap well (as seen in the AFNI GUI), but are not on the same 3D grid.  * If they don't overlap well, allineate them first * The reampling here is done with the   'wsinc5' method, which has very little blurring artifact. * If the base and source datasets ARE on the same 3D grid,   then the -resample option will be ignored. * You CAN use -resample with these 3dQwarp options:   -plusminus  -inilev  -iniwarp  -duplo  
+    lpc: 'True'
+    # type=bool|default=False: Local Pearson minimization (i.e., EPI-T1 registration)This option has not be extensively testedIf you use '-lpc', then '-maxlev 0' is automatically set.If you want to go to more refined levels, you can set '-maxlev'This should be set up to have lpc as the second to last argumentand maxlev as the second to last argument, as needed by AFNIUsing maxlev > 1 is not recommended for EPI-T1 alignment.
+    verb: 'True'
+    # type=bool|default=False: more detailed description of the process
+    iwarp: 'True'
+    # type=bool|default=False: Do compute and save the _WARPINV file.
+    blur: '[0,3]'
+    # type=list|default=[]: Gaussian blur the input images by 'bb' (FWHM) voxels before doing the alignment (the output dataset will not be blurred). The default is 2.345 (for no good reason).  * Optionally, you can provide 2 values for 'bb', and then   the first one is applied to the base volume, the second   to the source volume.   e.g., '-blur 0 3' to skip blurring the base image   (if the base is a blurry template, for example). * A negative blur radius means to use 3D median filtering,   rather than Gaussian blurring.  This type of filtering will   better preserve edges, which can be important in alignment. * If the base is a template volume that is already blurry,   you probably don't want to blur it again, but blurring   the source volume a little is probably a good idea, to   help the program avoid trying to match tiny features. * Note that -duplo will blur the volumes some extra   amount for the initial small-scale warping, to make   that phase of the program converge more rapidly.  
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: Source image (opposite phase encoding direction than base image).
+    base_file:
+    # type=file|default=<undefined>: Base image (opposite phase encoding direction than source image).
+    duplo: 'True'
+    # type=bool|default=False: Start off with 1/2 scale versions of the volumes," for getting a speedy coarse first alignment."  * Then scales back up to register the full volumes."   The goal is greater speed, and it seems to help this"   positively piggish program to be more expeditious." * However, accuracy is somewhat lower with '-duplo',"   for reasons that currently elude Zhark; for this reason,"   the Emperor does not usually use '-duplo'.  
+    blur: '[0,3]'
+    # type=list|default=[]: Gaussian blur the input images by 'bb' (FWHM) voxels before doing the alignment (the output dataset will not be blurred). The default is 2.345 (for no good reason).  * Optionally, you can provide 2 values for 'bb', and then   the first one is applied to the base volume, the second   to the source volume.   e.g., '-blur 0 3' to skip blurring the base image   (if the base is a blurry template, for example). * A negative blur radius means to use 3D median filtering,   rather than Gaussian blurring.  This type of filtering will   better preserve edges, which can be important in alignment. * If the base is a template volume that is already blurry,   you probably don't want to blur it again, but blurring   the source volume a little is probably a good idea, to   help the program avoid trying to match tiny features. * Note that -duplo will blur the volumes some extra   amount for the initial small-scale warping, to make   that phase of the program converge more rapidly.  
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: Source image (opposite phase encoding direction than base image).
+    base_file:
+    # type=file|default=<undefined>: Base image (opposite phase encoding direction than source image).
+    duplo: 'True'
+    # type=bool|default=False: Start off with 1/2 scale versions of the volumes," for getting a speedy coarse first alignment."  * Then scales back up to register the full volumes."   The goal is greater speed, and it seems to help this"   positively piggish program to be more expeditious." * However, accuracy is somewhat lower with '-duplo',"   for reasons that currently elude Zhark; for this reason,"   the Emperor does not usually use '-duplo'.  
+    minpatch: '25'
+    # type=int|default=0: The value of mm should be an odd integer.  * The default value of mm is 25. * For more accurate results than mm=25, try 19 or 13. * The smallest allowed patch size is 5. * You may want stop at a larger patch size (say 7 or 9) and use   the -Qfinal option to run that final level with quintic warps,   which might run faster and provide the same degree of warp detail. * Trying to make two different brain volumes match in fine detail   is usually a waste of time, especially in humans.  There is too   much variability in anatomy to match gyrus to gyrus accurately.   For this reason, the default minimum patch size is 25 voxels.   Using a smaller '-minpatch' might try to force the warp to   match features that do not match, and the result can be useless   image distortions -- another reason to LOOK AT THE RESULTS.  
+    blur: '[0,3]'
+    # type=list|default=[]: Gaussian blur the input images by 'bb' (FWHM) voxels before doing the alignment (the output dataset will not be blurred). The default is 2.345 (for no good reason).  * Optionally, you can provide 2 values for 'bb', and then   the first one is applied to the base volume, the second   to the source volume.   e.g., '-blur 0 3' to skip blurring the base image   (if the base is a blurry template, for example). * A negative blur radius means to use 3D median filtering,   rather than Gaussian blurring.  This type of filtering will   better preserve edges, which can be important in alignment. * If the base is a template volume that is already blurry,   you probably don't want to blur it again, but blurring   the source volume a little is probably a good idea, to   help the program avoid trying to match tiny features. * Note that -duplo will blur the volumes some extra   amount for the initial small-scale warping, to make   that phase of the program converge more rapidly.  
+    out_file:
+    # type=file|default=<undefined>: Sets the prefix/suffix for the output datasets.  * The source dataset is warped to match the base   and gets prefix 'ppp'. (Except if '-plusminus' is used * The final interpolation to this output dataset is   done using the 'wsinc5' method.  See the output of   3dAllineate -HELP   (in the "Modifying '-final wsinc5'" section) for   the lengthy technical details. * The 3D warp used is saved in a dataset with   prefix 'ppp_WARP' -- this dataset can be used   with 3dNwarpApply and 3dNwarpCat, for example. * To be clear, this is the warp from source dataset   coordinates to base dataset coordinates, where the   values at each base grid point are the xyz displacements   needed to move that grid point's xyz values to the   corresponding xyz values in the source dataset:   base( (x,y,z) + WARP(x,y,z) ) matches source(x,y,z)   Another way to think of this warp is that it 'pulls'   values back from source space to base space. * 3dNwarpApply would use 'ppp_WARP' to transform datasets   aligned with the source dataset to be aligned with the   base dataset.  **If you do NOT want this warp saved, use the option '-nowarp'**. (However, this warp is usually the most valuable possible output!)  * If you want to calculate and save the inverse 3D warp,   use the option '-iwarp'.  This inverse warp will then be   saved in a dataset with prefix 'ppp_WARPINV'. * This inverse warp could be used to transform data from base   space to source space, if you need to do such an operation. * You can easily compute the inverse later, say by a command like   3dNwarpCat -prefix Z_WARPINV 'INV(Z_WARP+tlrc)'   or the inverse can be computed as needed in 3dNwarpApply, like   3dNwarpApply -nwarp 'INV(Z_WARP+tlrc)' -source Dataset.nii ...  
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: Source image (opposite phase encoding direction than base image).
+    base_file:
+    # type=file|default=<undefined>: Base image (opposite phase encoding direction than source image).
+    blur: '[0,2]'
+    # type=list|default=[]: Gaussian blur the input images by 'bb' (FWHM) voxels before doing the alignment (the output dataset will not be blurred). The default is 2.345 (for no good reason).  * Optionally, you can provide 2 values for 'bb', and then   the first one is applied to the base volume, the second   to the source volume.   e.g., '-blur 0 3' to skip blurring the base image   (if the base is a blurry template, for example). * A negative blur radius means to use 3D median filtering,   rather than Gaussian blurring.  This type of filtering will   better preserve edges, which can be important in alignment. * If the base is a template volume that is already blurry,   you probably don't want to blur it again, but blurring   the source volume a little is probably a good idea, to   help the program avoid trying to match tiny features. * Note that -duplo will blur the volumes some extra   amount for the initial small-scale warping, to make   that phase of the program converge more rapidly.  
+    out_file:
+    # type=file|default=<undefined>: Sets the prefix/suffix for the output datasets.  * The source dataset is warped to match the base   and gets prefix 'ppp'. (Except if '-plusminus' is used * The final interpolation to this output dataset is   done using the 'wsinc5' method.  See the output of   3dAllineate -HELP   (in the "Modifying '-final wsinc5'" section) for   the lengthy technical details. * The 3D warp used is saved in a dataset with   prefix 'ppp_WARP' -- this dataset can be used   with 3dNwarpApply and 3dNwarpCat, for example. * To be clear, this is the warp from source dataset   coordinates to base dataset coordinates, where the   values at each base grid point are the xyz displacements   needed to move that grid point's xyz values to the   corresponding xyz values in the source dataset:   base( (x,y,z) + WARP(x,y,z) ) matches source(x,y,z)   Another way to think of this warp is that it 'pulls'   values back from source space to base space. * 3dNwarpApply would use 'ppp_WARP' to transform datasets   aligned with the source dataset to be aligned with the   base dataset.  **If you do NOT want this warp saved, use the option '-nowarp'**. (However, this warp is usually the most valuable possible output!)  * If you want to calculate and save the inverse 3D warp,   use the option '-iwarp'.  This inverse warp will then be   saved in a dataset with prefix 'ppp_WARPINV'. * This inverse warp could be used to transform data from base   space to source space, if you need to do such an operation. * You can easily compute the inverse later, say by a command like   3dNwarpCat -prefix Z_WARPINV 'INV(Z_WARP+tlrc)'   or the inverse can be computed as needed in 3dNwarpApply, like   3dNwarpApply -nwarp 'INV(Z_WARP+tlrc)' -source Dataset.nii ...  
+    inilev: '7'
+    # type=int|default=0: The initial refinement 'level' at which to start.  * Usually used with -iniwarp; CANNOT be used with -duplo. * The combination of -inilev and -iniwarp lets you take the   results of a previous 3dQwarp run and refine them further:   Note that the source dataset in the second run is the SAME as   in the first run.  If you don't see why this is necessary,   then you probably need to seek help from an AFNI guru.  
+    iniwarp:
+    # type=list|default=[]: A dataset with an initial nonlinear warp to use.  * If this option is not used, the initial warp is the identity. * You can specify a catenation of warps (in quotes) here, as in   program 3dNwarpApply. * As a special case, if you just input an affine matrix in a .1D   file, that will work also -- it is treated as giving the initial   warp via the string "IDENT(base_dataset) matrix_file.aff12.1D". * You CANNOT use this option with -duplo !! * -iniwarp is usually used with -inilev to re-start 3dQwarp from   a previous stopping point.  
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: Source image (opposite phase encoding direction than base image).
+    base_file:
+    # type=file|default=<undefined>: Base image (opposite phase encoding direction than source image).
+    allineate: 'True'
+    # type=bool|default=False: 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.
+    allineate_opts: '"-cose lpa -verb"'
+    # type=str|default='': add extra options to the 3dAllineate command to be run by 3dQwarp.
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: 3dQwarp -base sub-01_dir-RL_epi.nii.gz -source sub-01_dir-LR_epi.nii.gz -nopadWARP -prefix ppp_sub-01_dir-LR_epi -plusminus
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: Source image (opposite phase encoding direction than base image).
+    nopadWARP: 'True'
+    # type=bool|default=False: If for some reason you require the warp volume tomatch the base volume, then use this option to have the outputWARP dataset(s) truncated.
+    base_file:
+    # type=file|default=<undefined>: Base image (opposite phase encoding direction than source image).
+    plusminus: 'True'
+    # type=bool|default=False: Normally, the warp displacements dis(x) are defined to match base(x) to source(x+dis(x)).  With this option, the match is between base(x-dis(x)) and source(x+dis(x)) -- the two images 'meet in the middle'.  * One goal is to mimic the warping done to MRI EPI data by   field inhomogeneities, when registering between a 'blip up'   and a 'blip down' down volume, which will have opposite   distortions. * Define Wp(x) = x+dis(x) and Wm(x) = x-dis(x).  Then since   base(Wm(x)) matches source(Wp(x)), by substituting INV(Wm(x))   wherever we see x, we have base(x) matches source(Wp(INV(Wm(x))));   that is, the warp V(x) that one would get from the 'usual' way   of running 3dQwarp is V(x) = Wp(INV(Wm(x))). * Conversely, we can calculate Wp(x) in terms of V(x) as follows:   If V(x) = x + dv(x), define Vh(x) = x + dv(x)/2;   then Wp(x) = V(INV(Vh(x))) * With the above formulas, it is possible to compute Wp(x) from   V(x) and vice-versa, using program 3dNwarpCalc.  The requisite   commands are left as an exercise for the aspiring AFNI Jedi Master. * You can use the semi-secret '-pmBASE' option to get the V(x)   warp and the source dataset warped to base space, in addition to   the Wp(x) '_PLUS' and Wm(x) '_MINUS' warps.    * Alas: -plusminus does not work with -duplo or -allineate :-(   * However, you can use -iniwarp with -plusminus :-)   * The outputs have _PLUS (from the source dataset) and _MINUS     (from the base dataset) in their filenames, in addition to     the prefix.  The -iwarp option, if present, will be ignored.  
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: 3dQwarp -base mni.nii -source structural.nii -prefix ppp_structural -resample
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: Source image (opposite phase encoding direction than base image).
+    base_file:
+    # type=file|default=<undefined>: Base image (opposite phase encoding direction than source image).
+    resample: 'True'
+    # type=bool|default=False: This option simply resamples the source dataset to match the base dataset grid.  You can use this if the two datasets overlap well (as seen in the AFNI GUI), but are not on the same 3D grid.  * If they don't overlap well, allineate them first * The reampling here is done with the   'wsinc5' method, which has very little blurring artifact. * If the base and source datasets ARE on the same 3D grid,   then the -resample option will be ignored. * You CAN use -resample with these 3dQwarp options:   -plusminus  -inilev  -iniwarp  -duplo  
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: 3dQwarp -base epi.nii -blur 0.0 3.0 -source structural.nii -iwarp -prefix anatSSQ.nii.gz -resample -verb -lpc
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: Source image (opposite phase encoding direction than base image).
+    base_file:
+    # type=file|default=<undefined>: Base image (opposite phase encoding direction than source image).
+    out_file:
+    # type=file|default=<undefined>: Sets the prefix/suffix for the output datasets.  * The source dataset is warped to match the base   and gets prefix 'ppp'. (Except if '-plusminus' is used * The final interpolation to this output dataset is   done using the 'wsinc5' method.  See the output of   3dAllineate -HELP   (in the "Modifying '-final wsinc5'" section) for   the lengthy technical details. * The 3D warp used is saved in a dataset with   prefix 'ppp_WARP' -- this dataset can be used   with 3dNwarpApply and 3dNwarpCat, for example. * To be clear, this is the warp from source dataset   coordinates to base dataset coordinates, where the   values at each base grid point are the xyz displacements   needed to move that grid point's xyz values to the   corresponding xyz values in the source dataset:   base( (x,y,z) + WARP(x,y,z) ) matches source(x,y,z)   Another way to think of this warp is that it 'pulls'   values back from source space to base space. * 3dNwarpApply would use 'ppp_WARP' to transform datasets   aligned with the source dataset to be aligned with the   base dataset.  **If you do NOT want this warp saved, use the option '-nowarp'**. (However, this warp is usually the most valuable possible output!)  * If you want to calculate and save the inverse 3D warp,   use the option '-iwarp'.  This inverse warp will then be   saved in a dataset with prefix 'ppp_WARPINV'. * This inverse warp could be used to transform data from base   space to source space, if you need to do such an operation. * You can easily compute the inverse later, say by a command like   3dNwarpCat -prefix Z_WARPINV 'INV(Z_WARP+tlrc)'   or the inverse can be computed as needed in 3dNwarpApply, like   3dNwarpApply -nwarp 'INV(Z_WARP+tlrc)' -source Dataset.nii ...  
+    resample: 'True'
+    # type=bool|default=False: This option simply resamples the source dataset to match the base dataset grid.  You can use this if the two datasets overlap well (as seen in the AFNI GUI), but are not on the same 3D grid.  * If they don't overlap well, allineate them first * The reampling here is done with the   'wsinc5' method, which has very little blurring artifact. * If the base and source datasets ARE on the same 3D grid,   then the -resample option will be ignored. * You CAN use -resample with these 3dQwarp options:   -plusminus  -inilev  -iniwarp  -duplo  
+    lpc: 'True'
+    # type=bool|default=False: Local Pearson minimization (i.e., EPI-T1 registration)This option has not be extensively testedIf you use '-lpc', then '-maxlev 0' is automatically set.If you want to go to more refined levels, you can set '-maxlev'This should be set up to have lpc as the second to last argumentand maxlev as the second to last argument, as needed by AFNIUsing maxlev > 1 is not recommended for EPI-T1 alignment.
+    verb: 'True'
+    # type=bool|default=False: more detailed description of the process
+    iwarp: 'True'
+    # type=bool|default=False: Do compute and save the _WARPINV file.
+    blur: '[0,3]'
+    # type=list|default=[]: Gaussian blur the input images by 'bb' (FWHM) voxels before doing the alignment (the output dataset will not be blurred). The default is 2.345 (for no good reason).  * Optionally, you can provide 2 values for 'bb', and then   the first one is applied to the base volume, the second   to the source volume.   e.g., '-blur 0 3' to skip blurring the base image   (if the base is a blurry template, for example). * A negative blur radius means to use 3D median filtering,   rather than Gaussian blurring.  This type of filtering will   better preserve edges, which can be important in alignment. * If the base is a template volume that is already blurry,   you probably don't want to blur it again, but blurring   the source volume a little is probably a good idea, to   help the program avoid trying to match tiny features. * Note that -duplo will blur the volumes some extra   amount for the initial small-scale warping, to make   that phase of the program converge more rapidly.  
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: 3dQwarp -base mni.nii -blur 0.0 3.0 -duplo -source structural.nii -prefix ppp_structural
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: Source image (opposite phase encoding direction than base image).
+    base_file:
+    # type=file|default=<undefined>: Base image (opposite phase encoding direction than source image).
+    duplo: 'True'
+    # type=bool|default=False: Start off with 1/2 scale versions of the volumes," for getting a speedy coarse first alignment."  * Then scales back up to register the full volumes."   The goal is greater speed, and it seems to help this"   positively piggish program to be more expeditious." * However, accuracy is somewhat lower with '-duplo',"   for reasons that currently elude Zhark; for this reason,"   the Emperor does not usually use '-duplo'.  
+    blur: '[0,3]'
+    # type=list|default=[]: Gaussian blur the input images by 'bb' (FWHM) voxels before doing the alignment (the output dataset will not be blurred). The default is 2.345 (for no good reason).  * Optionally, you can provide 2 values for 'bb', and then   the first one is applied to the base volume, the second   to the source volume.   e.g., '-blur 0 3' to skip blurring the base image   (if the base is a blurry template, for example). * A negative blur radius means to use 3D median filtering,   rather than Gaussian blurring.  This type of filtering will   better preserve edges, which can be important in alignment. * If the base is a template volume that is already blurry,   you probably don't want to blur it again, but blurring   the source volume a little is probably a good idea, to   help the program avoid trying to match tiny features. * Note that -duplo will blur the volumes some extra   amount for the initial small-scale warping, to make   that phase of the program converge more rapidly.  
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: 3dQwarp -base mni.nii -blur 0.0 3.0 -duplo -source structural.nii -minpatch 25 -prefix Q25
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: Source image (opposite phase encoding direction than base image).
+    base_file:
+    # type=file|default=<undefined>: Base image (opposite phase encoding direction than source image).
+    duplo: 'True'
+    # type=bool|default=False: Start off with 1/2 scale versions of the volumes," for getting a speedy coarse first alignment."  * Then scales back up to register the full volumes."   The goal is greater speed, and it seems to help this"   positively piggish program to be more expeditious." * However, accuracy is somewhat lower with '-duplo',"   for reasons that currently elude Zhark; for this reason,"   the Emperor does not usually use '-duplo'.  
+    minpatch: '25'
+    # type=int|default=0: The value of mm should be an odd integer.  * The default value of mm is 25. * For more accurate results than mm=25, try 19 or 13. * The smallest allowed patch size is 5. * You may want stop at a larger patch size (say 7 or 9) and use   the -Qfinal option to run that final level with quintic warps,   which might run faster and provide the same degree of warp detail. * Trying to make two different brain volumes match in fine detail   is usually a waste of time, especially in humans.  There is too   much variability in anatomy to match gyrus to gyrus accurately.   For this reason, the default minimum patch size is 25 voxels.   Using a smaller '-minpatch' might try to force the warp to   match features that do not match, and the result can be useless   image distortions -- another reason to LOOK AT THE RESULTS.  
+    blur: '[0,3]'
+    # type=list|default=[]: Gaussian blur the input images by 'bb' (FWHM) voxels before doing the alignment (the output dataset will not be blurred). The default is 2.345 (for no good reason).  * Optionally, you can provide 2 values for 'bb', and then   the first one is applied to the base volume, the second   to the source volume.   e.g., '-blur 0 3' to skip blurring the base image   (if the base is a blurry template, for example). * A negative blur radius means to use 3D median filtering,   rather than Gaussian blurring.  This type of filtering will   better preserve edges, which can be important in alignment. * If the base is a template volume that is already blurry,   you probably don't want to blur it again, but blurring   the source volume a little is probably a good idea, to   help the program avoid trying to match tiny features. * Note that -duplo will blur the volumes some extra   amount for the initial small-scale warping, to make   that phase of the program converge more rapidly.  
+    out_file:
+    # type=file|default=<undefined>: Sets the prefix/suffix for the output datasets.  * The source dataset is warped to match the base   and gets prefix 'ppp'. (Except if '-plusminus' is used * The final interpolation to this output dataset is   done using the 'wsinc5' method.  See the output of   3dAllineate -HELP   (in the "Modifying '-final wsinc5'" section) for   the lengthy technical details. * The 3D warp used is saved in a dataset with   prefix 'ppp_WARP' -- this dataset can be used   with 3dNwarpApply and 3dNwarpCat, for example. * To be clear, this is the warp from source dataset   coordinates to base dataset coordinates, where the   values at each base grid point are the xyz displacements   needed to move that grid point's xyz values to the   corresponding xyz values in the source dataset:   base( (x,y,z) + WARP(x,y,z) ) matches source(x,y,z)   Another way to think of this warp is that it 'pulls'   values back from source space to base space. * 3dNwarpApply would use 'ppp_WARP' to transform datasets   aligned with the source dataset to be aligned with the   base dataset.  **If you do NOT want this warp saved, use the option '-nowarp'**. (However, this warp is usually the most valuable possible output!)  * If you want to calculate and save the inverse 3D warp,   use the option '-iwarp'.  This inverse warp will then be   saved in a dataset with prefix 'ppp_WARPINV'. * This inverse warp could be used to transform data from base   space to source space, if you need to do such an operation. * You can easily compute the inverse later, say by a command like   3dNwarpCat -prefix Z_WARPINV 'INV(Z_WARP+tlrc)'   or the inverse can be computed as needed in 3dNwarpApply, like   3dNwarpApply -nwarp 'INV(Z_WARP+tlrc)' -source Dataset.nii ...  
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: 3dQwarp -base mni.nii -blur 0.0 2.0 -source structural.nii -inilev 7 -iniwarp Q25_warp+tlrc.HEAD -prefix Q11
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: Source image (opposite phase encoding direction than base image).
+    base_file:
+    # type=file|default=<undefined>: Base image (opposite phase encoding direction than source image).
+    blur: '[0,2]'
+    # type=list|default=[]: Gaussian blur the input images by 'bb' (FWHM) voxels before doing the alignment (the output dataset will not be blurred). The default is 2.345 (for no good reason).  * Optionally, you can provide 2 values for 'bb', and then   the first one is applied to the base volume, the second   to the source volume.   e.g., '-blur 0 3' to skip blurring the base image   (if the base is a blurry template, for example). * A negative blur radius means to use 3D median filtering,   rather than Gaussian blurring.  This type of filtering will   better preserve edges, which can be important in alignment. * If the base is a template volume that is already blurry,   you probably don't want to blur it again, but blurring   the source volume a little is probably a good idea, to   help the program avoid trying to match tiny features. * Note that -duplo will blur the volumes some extra   amount for the initial small-scale warping, to make   that phase of the program converge more rapidly.  
+    out_file:
+    # type=file|default=<undefined>: Sets the prefix/suffix for the output datasets.  * The source dataset is warped to match the base   and gets prefix 'ppp'. (Except if '-plusminus' is used * The final interpolation to this output dataset is   done using the 'wsinc5' method.  See the output of   3dAllineate -HELP   (in the "Modifying '-final wsinc5'" section) for   the lengthy technical details. * The 3D warp used is saved in a dataset with   prefix 'ppp_WARP' -- this dataset can be used   with 3dNwarpApply and 3dNwarpCat, for example. * To be clear, this is the warp from source dataset   coordinates to base dataset coordinates, where the   values at each base grid point are the xyz displacements   needed to move that grid point's xyz values to the   corresponding xyz values in the source dataset:   base( (x,y,z) + WARP(x,y,z) ) matches source(x,y,z)   Another way to think of this warp is that it 'pulls'   values back from source space to base space. * 3dNwarpApply would use 'ppp_WARP' to transform datasets   aligned with the source dataset to be aligned with the   base dataset.  **If you do NOT want this warp saved, use the option '-nowarp'**. (However, this warp is usually the most valuable possible output!)  * If you want to calculate and save the inverse 3D warp,   use the option '-iwarp'.  This inverse warp will then be   saved in a dataset with prefix 'ppp_WARPINV'. * This inverse warp could be used to transform data from base   space to source space, if you need to do such an operation. * You can easily compute the inverse later, say by a command like   3dNwarpCat -prefix Z_WARPINV 'INV(Z_WARP+tlrc)'   or the inverse can be computed as needed in 3dNwarpApply, like   3dNwarpApply -nwarp 'INV(Z_WARP+tlrc)' -source Dataset.nii ...  
+    inilev: '7'
+    # type=int|default=0: The initial refinement 'level' at which to start.  * Usually used with -iniwarp; CANNOT be used with -duplo. * The combination of -inilev and -iniwarp lets you take the   results of a previous 3dQwarp run and refine them further:   Note that the source dataset in the second run is the SAME as   in the first run.  If you don't see why this is necessary,   then you probably need to seek help from an AFNI guru.  
+    iniwarp:
+    # type=list|default=[]: A dataset with an initial nonlinear warp to use.  * If this option is not used, the initial warp is the identity. * You can specify a catenation of warps (in quotes) here, as in   program 3dNwarpApply. * As a special case, if you just input an affine matrix in a .1D   file, that will work also -- it is treated as giving the initial   warp via the string "IDENT(base_dataset) matrix_file.aff12.1D". * You CANNOT use this option with -duplo !! * -iniwarp is usually used with -inilev to re-start 3dQwarp from   a previous stopping point.  
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: 3dQwarp -allineate -allineate_opts "-cose lpa -verb" -base mni.nii -source structural.nii -prefix ppp_structural
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: Source image (opposite phase encoding direction than base image).
+    base_file:
+    # type=file|default=<undefined>: Base image (opposite phase encoding direction than source image).
+    allineate: 'True'
+    # type=bool|default=False: 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.
+    allineate_opts: '"-cose lpa -verb"'
+    # type=str|default='': add extra options to the 3dAllineate command to be run by 3dQwarp.
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-afni/qwarp_callables.py b/example-specs/task/nipype_internal/pydra-afni/qwarp_callables.py
new file mode 100644
index 00000000..b40e3b58
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/qwarp_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Qwarp.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-afni/qwarp_plus_minus.yaml b/example-specs/task/nipype_internal/pydra-afni/qwarp_plus_minus.yaml
new file mode 100644
index 00000000..607d022e
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/qwarp_plus_minus.yaml
@@ -0,0 +1,254 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.afni.preprocess.QwarpPlusMinus' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# A version of 3dQwarp for performing field susceptibility correction
+#     using two images with opposing phase encoding directions.
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import afni
+#     >>> qwarp = afni.QwarpPlusMinus()
+#     >>> qwarp.inputs.in_file = 'sub-01_dir-LR_epi.nii.gz'
+#     >>> qwarp.inputs.nopadWARP = True
+#     >>> qwarp.inputs.base_file = 'sub-01_dir-RL_epi.nii.gz'
+#     >>> qwarp.cmdline
+#     '3dQwarp -prefix Qwarp.nii.gz -plusminus -base sub-01_dir-RL_epi.nii.gz -source sub-01_dir-LR_epi.nii.gz -nopadWARP'
+#     >>> res = warp.run()  # doctest: +SKIP
+# 
+#     See Also
+#     --------
+#     For complete details, see the `3dQwarp Documentation.
+#     <https://afni.nimh.nih.gov/pub/dist/doc/program_help/3dQwarp.html>`__
+# 
+#     
+task_name: QwarpPlusMinus
+nipype_name: QwarpPlusMinus
+nipype_module: nipype.interfaces.afni.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    source_file: generic/file
+    # type=file|default=<undefined>: Source image (opposite phase encoding direction than base image)
+    out_file: generic/file
+    # type=file|default='Qwarp.nii.gz': Output file
+    in_file: medimage/nifti-gz
+    # type=file|default=<undefined>: Source image (opposite phase encoding direction than base image).
+    base_file: medimage/nifti-gz
+    # type=file|default=<undefined>: Base image (opposite phase encoding direction than source image).
+    weight: generic/file
+    # type=file|default=<undefined>: Instead of computing the weight from the base dataset,directly input the weight volume from dataset 'www'.Useful if you know what over parts of the base image youwant to emphasize or de-emphasize the matching functional.
+    out_weight_file: generic/file
+    # type=file|default=<undefined>: Write the weight volume to disk as a dataset
+    emask: generic/file
+    # type=file|default=<undefined>: Here, 'ee' is a dataset to specify a mask of voxelsto EXCLUDE from the analysis -- all voxels in 'ee'that are NONZERO will not be used in the alignment.The base image always automasked -- the emask isextra, to indicate voxels you definitely DON'T wantincluded in the matching process, even if they areinside the brain.
+    iniwarp: generic/file+list-of
+    # type=list|default=[]: A dataset with an initial nonlinear warp to use.  * If this option is not used, the initial warp is the identity. * You can specify a catenation of warps (in quotes) here, as in   program 3dNwarpApply. * As a special case, if you just input an affine matrix in a .1D   file, that will work also -- it is treated as giving the initial   warp via the string "IDENT(base_dataset) matrix_file.aff12.1D". * You CANNOT use this option with -duplo !! * -iniwarp is usually used with -inilev to re-start 3dQwarp from   a previous stopping point.  
+    gridlist: generic/file
+    # type=file|default=<undefined>: This option provides an alternate way to specify the patch grid sizes used in the warp optimization process. 'gl' is a 1D file with a list of patches to use -- in most cases, you will want to use it in the following form: ``-gridlist '1D: 0 151 101 75 51'``  * Here, a 0 patch size means the global domain. Patch sizes   otherwise should be odd integers >= 5. * If you use the '0' patch size again after the first position,   you will actually get an iteration at the size of the   default patch level 1, where the patch sizes are 75% of   the volume dimension.  There is no way to force the program   to literally repeat the sui generis step of lev=0.  
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    warped_source: generic/file
+    # type=file: Warped source file. If plusminus is used, this is the undistortedsource file.
+    warped_base: generic/file
+    # type=file: Undistorted base file.
+    source_warp: generic/file
+    # type=file: Displacement in mm for the source image.If plusminus is used this is the field suceptibility correctionwarp (in 'mm') for source image.
+    base_warp: generic/file
+    # type=file: Displacement in mm for the base image.If plus minus is used, this is the field suceptibility correctionwarp (in 'mm') for base image. This is only output if plusminusor iwarp options are passed
+    weights: generic/file
+    # type=file: Auto-computed weight volume.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    source_file:
+    # type=file|default=<undefined>: Source image (opposite phase encoding direction than base image)
+    out_file:
+    # type=file|default='Qwarp.nii.gz': Output file
+    plusminus:
+    # type=bool|default=True: Normally, the warp displacements dis(x) are defined to matchbase(x) to source(x+dis(x)).  With this option, the matchis between base(x-dis(x)) and source(x+dis(x)) -- the twoimages 'meet in the middle'. For more info, view Qwarp` interface
+    in_file:
+    # type=file|default=<undefined>: Source image (opposite phase encoding direction than base image).
+    base_file:
+    # type=file|default=<undefined>: Base image (opposite phase encoding direction than source image).
+    resample:
+    # type=bool|default=False: This option simply resamples the source dataset to match the base dataset grid.  You can use this if the two datasets overlap well (as seen in the AFNI GUI), but are not on the same 3D grid.  * If they don't overlap well, allineate them first * The reampling here is done with the   'wsinc5' method, which has very little blurring artifact. * If the base and source datasets ARE on the same 3D grid,   then the -resample option will be ignored. * You CAN use -resample with these 3dQwarp options:   -plusminus  -inilev  -iniwarp  -duplo  
+    allineate:
+    # type=bool|default=False: 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.
+    allineate_opts:
+    # type=str|default='': add extra options to the 3dAllineate command to be run by 3dQwarp.
+    nowarp:
+    # type=bool|default=False: Do not save the _WARP file.
+    iwarp:
+    # type=bool|default=False: Do compute and save the _WARPINV file.
+    pear:
+    # type=bool|default=False: Use strict Pearson correlation for matching.Not usually recommended, since the 'clipped Pearson' methodused by default will reduce the impact of outlier values.
+    noneg:
+    # type=bool|default=False: Replace negative values in either input volume with 0.  * If there ARE negative input values, and you do NOT use -noneg,   then strict Pearson correlation will be used, since the 'clipped'   method only is implemented for non-negative volumes. * '-noneg' is not the default, since there might be situations where   you want to align datasets with positive and negative values mixed. * But, in many cases, the negative values in a dataset are just the   result of interpolation artifacts (or other peculiarities), and so   they should be ignored.  That is what '-noneg' is for.  
+    nopenalty:
+    # type=bool|default=False: Replace negative values in either input volume with 0.  * If there ARE negative input values, and you do NOT use -noneg,   then strict Pearson correlation will be used, since the 'clipped'   method only is implemented for non-negative volumes. * '-noneg' is not the default, since there might be situations where   you want to align datasets with positive and negative values mixed. * But, in many cases, the negative values in a dataset are just the   result of interpolation artifacts (or other peculiarities), and so   they should be ignored. That is what '-noneg' is for.  
+    penfac:
+    # type=float|default=0.0: Use this value to weight the penalty. The default value is 1. Larger values mean the penalty counts more, reducing grid distortions, insha'Allah; '-nopenalty' is the same as '-penfac 0'. In 23 Sep 2013 Zhark increased the default value of the penalty by a factor of 5, and also made it get progressively larger with each level of refinement. Thus, warping results will vary from earlier instances of 3dQwarp.  * The progressive increase in the penalty at higher levels   means that the 'cost function' can actually look like the   alignment is getting worse when the levels change. * IF you wish to turn off this progression, for whatever   reason (e.g., to keep compatibility with older results),   use the option '-penold'.To be completely compatible with   the older 3dQwarp, you'll also have to use '-penfac 0.2'.  
+    noweight:
+    # type=bool|default=False: If you want a binary weight (the old default), use this option.That is, each voxel in the base volume automask will beweighted the same in the computation of the cost functional.
+    weight:
+    # type=file|default=<undefined>: Instead of computing the weight from the base dataset,directly input the weight volume from dataset 'www'.Useful if you know what over parts of the base image youwant to emphasize or de-emphasize the matching functional.
+    wball:
+    # type=list|default=[]: "``-wball x y z r f`` Enhance automatic weight from '-useweight' by a factor of 1+f\*Gaussian(FWHM=r) centered in the base image at DICOM coordinates (x,y,z) and with radius 'r'. The goal of this option is to try and make the alignment better in a specific part of the brain. Example:  -wball 0 14 6 30 40 to emphasize the thalamic area (in MNI/Talairach space).  * The 'r' parameter must be positive! * The 'f' parameter must be between 1 and 100 (inclusive). * '-wball' does nothing if you input your own weight   with the '-weight' option. * '-wball' does change the binary weight created by   the '-noweight' option. * You can only use '-wball' once in a run of 3dQwarp.  **The effect of '-wball' is not dramatic.** The example above makes the average brain image across a collection of subjects a little sharper in the thalamic area, which might have some small value.  If you care enough about alignment to use '-wball', then you should examine the results from 3dQwarp for each subject, to see if the alignments are good enough for your purposes.
+    wmask:
+    # type=tuple|default=(<nipype.interfaces.base.traits_extension.File object at 0x11cef9410>, <traits.trait_types.Float object at 0x11cef8f10>): Similar to '-wball', but here, you provide a dataset 'ws' that indicates where to increase the weight.  * The 'ws' dataset must be on the same 3D grid as the base dataset. * 'ws' is treated as a mask -- it only matters where it   is nonzero -- otherwise, the values inside are not used. * After 'ws' comes the factor 'f' by which to increase the   automatically computed weight.  Where 'ws' is nonzero,   the weighting will be multiplied by (1+f). * As with '-wball', the factor 'f' should be between 1 and 100.  
+    out_weight_file:
+    # type=file|default=<undefined>: Write the weight volume to disk as a dataset
+    blur:
+    # type=list|default=[]: Gaussian blur the input images by 'bb' (FWHM) voxels before doing the alignment (the output dataset will not be blurred). The default is 2.345 (for no good reason).  * Optionally, you can provide 2 values for 'bb', and then   the first one is applied to the base volume, the second   to the source volume.   e.g., '-blur 0 3' to skip blurring the base image   (if the base is a blurry template, for example). * A negative blur radius means to use 3D median filtering,   rather than Gaussian blurring.  This type of filtering will   better preserve edges, which can be important in alignment. * If the base is a template volume that is already blurry,   you probably don't want to blur it again, but blurring   the source volume a little is probably a good idea, to   help the program avoid trying to match tiny features. * Note that -duplo will blur the volumes some extra   amount for the initial small-scale warping, to make   that phase of the program converge more rapidly.  
+    pblur:
+    # type=list|default=[]: Use progressive blurring; that is, for larger patch sizes, the amount of blurring is larger.  The general idea is to avoid trying to match finer details when the patch size and incremental warps are coarse.  When '-blur' is used as well, it sets a minimum amount of blurring that will be used. [06 Aug 2014 -- '-pblur' may become the default someday].  * You can optionally give the fraction of the patch size that   is used for the progressive blur by providing a value between   0 and 0.25 after '-pblur'.  If you provide TWO values, the   the first fraction is used for progressively blurring the   base image and the second for the source image.  The default   parameters when just '-pblur' is given is the same as giving   the options as '-pblur 0.09 0.09'. * '-pblur' is useful when trying to match 2 volumes with high   amounts of detail; e.g, warping one subject's brain image to   match another's, or trying to warp to match a detailed template. * Note that using negative values with '-blur' means that the   progressive blurring will be done with median filters, rather   than Gaussian linear blurring.  Note: The combination of the -allineate and -pblur options will make the results of using 3dQwarp to align to a template somewhat less sensitive to initial head position and scaling.
+    emask:
+    # type=file|default=<undefined>: Here, 'ee' is a dataset to specify a mask of voxelsto EXCLUDE from the analysis -- all voxels in 'ee'that are NONZERO will not be used in the alignment.The base image always automasked -- the emask isextra, to indicate voxels you definitely DON'T wantincluded in the matching process, even if they areinside the brain.
+    noXdis:
+    # type=bool|default=False: Warp will not displace in x direction
+    noYdis:
+    # type=bool|default=False: Warp will not displace in y direction
+    noZdis:
+    # type=bool|default=False: Warp will not displace in z direction
+    iniwarp:
+    # type=list|default=[]: A dataset with an initial nonlinear warp to use.  * If this option is not used, the initial warp is the identity. * You can specify a catenation of warps (in quotes) here, as in   program 3dNwarpApply. * As a special case, if you just input an affine matrix in a .1D   file, that will work also -- it is treated as giving the initial   warp via the string "IDENT(base_dataset) matrix_file.aff12.1D". * You CANNOT use this option with -duplo !! * -iniwarp is usually used with -inilev to re-start 3dQwarp from   a previous stopping point.  
+    inilev:
+    # type=int|default=0: The initial refinement 'level' at which to start.  * Usually used with -iniwarp; CANNOT be used with -duplo. * The combination of -inilev and -iniwarp lets you take the   results of a previous 3dQwarp run and refine them further:   Note that the source dataset in the second run is the SAME as   in the first run.  If you don't see why this is necessary,   then you probably need to seek help from an AFNI guru.  
+    minpatch:
+    # type=int|default=0: The value of mm should be an odd integer.  * The default value of mm is 25. * For more accurate results than mm=25, try 19 or 13. * The smallest allowed patch size is 5. * You may want stop at a larger patch size (say 7 or 9) and use   the -Qfinal option to run that final level with quintic warps,   which might run faster and provide the same degree of warp detail. * Trying to make two different brain volumes match in fine detail   is usually a waste of time, especially in humans.  There is too   much variability in anatomy to match gyrus to gyrus accurately.   For this reason, the default minimum patch size is 25 voxels.   Using a smaller '-minpatch' might try to force the warp to   match features that do not match, and the result can be useless   image distortions -- another reason to LOOK AT THE RESULTS.  
+    maxlev:
+    # type=int|default=0: The initial refinement 'level' at which to start.  * Usually used with -iniwarp; CANNOT be used with -duplo. * The combination of -inilev and -iniwarp lets you take the   results of a previous 3dQwarp run and refine them further:   Note that the source dataset in the second run is the SAME as   in the first run.  If you don't see why this is necessary,   then you probably need to seek help from an AFNI guru.  
+    gridlist:
+    # type=file|default=<undefined>: This option provides an alternate way to specify the patch grid sizes used in the warp optimization process. 'gl' is a 1D file with a list of patches to use -- in most cases, you will want to use it in the following form: ``-gridlist '1D: 0 151 101 75 51'``  * Here, a 0 patch size means the global domain. Patch sizes   otherwise should be odd integers >= 5. * If you use the '0' patch size again after the first position,   you will actually get an iteration at the size of the   default patch level 1, where the patch sizes are 75% of   the volume dimension.  There is no way to force the program   to literally repeat the sui generis step of lev=0.  
+    allsave:
+    # type=bool|default=False:  This option lets you save the output warps from each level" of the refinement process.  Mostly used for experimenting." Will only save all the outputs if the program terminates" normally -- if it crashes, or freezes, then all these" warps are lost.
+    duplo:
+    # type=bool|default=False: Start off with 1/2 scale versions of the volumes," for getting a speedy coarse first alignment."  * Then scales back up to register the full volumes."   The goal is greater speed, and it seems to help this"   positively piggish program to be more expeditious." * However, accuracy is somewhat lower with '-duplo',"   for reasons that currently elude Zhark; for this reason,"   the Emperor does not usually use '-duplo'.  
+    workhard:
+    # type=bool|default=False: Iterate more times, which can help when the volumes are hard to align at all, or when you hope to get a more precise alignment.  * Slows the program down (possibly a lot), of course. * When you combine '-workhard'  with '-duplo', only the   full size volumes get the extra iterations. * For finer control over which refinement levels work hard,   you can use this option in the form (for example) ``-workhard:4:7``   which implies the extra iterations will be done at levels   4, 5, 6, and 7, but not otherwise. * You can also use '-superhard' to iterate even more, but   this extra option will REALLY slow things down.    * Under most circumstances, you should not need to use either     ``-workhard`` or ``-superhard``.   * The fastest way to register to a template image is via the     ``-duplo`` option, and without the ``-workhard`` or ``-superhard`` options.   * If you use this option in the form '-Workhard' (first letter     in upper case), then the second iteration at each level is     done with quintic polynomial warps.  
+    Qfinal:
+    # type=bool|default=False: At the finest patch size (the final level), use Hermite quintic polynomials for the warp instead of cubic polynomials.  * In a 3D 'patch', there are 2x2x2x3=24 cubic polynomial basis   function parameters over which to optimize (2 polynomials   dependent on each of the x,y,z directions, and 3 different   directions of displacement). * There are 3x3x3x3=81 quintic polynomial parameters per patch. * With -Qfinal, the final level will have more detail in   the allowed warps, at the cost of yet more CPU time. * However, no patch below 7x7x7 in size will be done with quintic   polynomials. * This option is also not usually needed, and is experimental.  
+    Qonly:
+    # type=bool|default=False: Use Hermite quintic polynomials at all levels.  * Very slow (about 4 times longer).  Also experimental. * Will produce a (discrete representation of a) C2 warp.  
+    nopad:
+    # type=bool|default=False: Do NOT use zero-padding on the 3D base and source images. [Default == zero-pad, if needed]  * The underlying model for deformations goes to zero at the   edge of the volume being warped.  However, if there is   significant data near an edge of the volume, then it won't   get displaced much, and so the results might not be good. * Zero padding is designed as a way to work around this potential   problem.  You should NOT need the '-nopad' option for any   reason that Zhark can think of, but it is here to be symmetrical   with 3dAllineate. * Note that the output (warped from source) dataset will be on the   base dataset grid whether or not zero-padding is allowed.  However,   unless you use the following option, allowing zero-padding (i.e.,   the default operation) will make the output WARP dataset(s) be   on a larger grid (also see '-expad' below).  
+    nopadWARP:
+    # type=bool|default=False: If for some reason you require the warp volume tomatch the base volume, then use this option to have the outputWARP dataset(s) truncated.
+    expad:
+    # type=int|default=0: This option instructs the program to pad the warp by an extra'EE' voxels (and then 3dQwarp starts optimizing it).This option is seldom needed, but can be useful if youmight later catenate the nonlinear warp -- via 3dNwarpCat --with an affine transformation that contains a large shift.Under that circumstance, the nonlinear warp might be shiftedpartially outside its original grid, so expanding that gridcan avoid this problem.Note that this option perforce turns off '-nopadWARP'.
+    ballopt:
+    # type=bool|default=False: Normally, the incremental warp parameters are optimized insidea rectangular 'box' (24 dimensional for cubic patches, 81 forquintic patches), whose limits define the amount of distortionallowed at each step.  Using '-ballopt' switches these limitsto be applied to a 'ball' (interior of a hypersphere), whichcan allow for larger incremental displacements.  Use thisoption if you think things need to be able to move farther.
+    baxopt:
+    # type=bool|default=False: Use the 'box' optimization limits instead of the 'ball'[this is the default at present].Note that if '-workhard' is used, then ball and box optimizationare alternated in the different iterations at each level, sothese two options have no effect in that case.
+    verb:
+    # type=bool|default=False: more detailed description of the process
+    quiet:
+    # type=bool|default=False: Cut out most of the fun fun fun progress messages :-(
+    overwrite:
+    # type=bool|default=False: Overwrite outputs
+    lpc:
+    # type=bool|default=False: Local Pearson minimization (i.e., EPI-T1 registration)This option has not be extensively testedIf you use '-lpc', then '-maxlev 0' is automatically set.If you want to go to more refined levels, you can set '-maxlev'This should be set up to have lpc as the second to last argumentand maxlev as the second to last argument, as needed by AFNIUsing maxlev > 1 is not recommended for EPI-T1 alignment.
+    lpa:
+    # type=bool|default=False: Local Pearson maximization. This option has not be extensively tested
+    hel:
+    # type=bool|default=False: Hellinger distance: a matching function for the adventurousThis option has NOT be extensively tested for usefulnessand should be considered experimental at this infundibulum.
+    mi:
+    # type=bool|default=False: Mutual Information: a matching function for the adventurousThis option has NOT be extensively tested for usefulnessand should be considered experimental at this infundibulum.
+    nmi:
+    # type=bool|default=False: Normalized Mutual Information: a matching function for the adventurousThis option has NOT been extensively tested for usefulnessand should be considered experimental at this infundibulum.
+    num_threads:
+    # type=int|default=1: set number of threads
+    outputtype:
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: Source image (opposite phase encoding direction than base image).
+    nopadWARP: 'True'
+    # type=bool|default=False: If for some reason you require the warp volume tomatch the base volume, then use this option to have the outputWARP dataset(s) truncated.
+    base_file:
+    # type=file|default=<undefined>: Base image (opposite phase encoding direction than source image).
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: 3dQwarp -prefix Qwarp.nii.gz -plusminus -base sub-01_dir-RL_epi.nii.gz -source sub-01_dir-LR_epi.nii.gz -nopadWARP
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: Source image (opposite phase encoding direction than base image).
+    nopadWARP: 'True'
+    # type=bool|default=False: If for some reason you require the warp volume tomatch the base volume, then use this option to have the outputWARP dataset(s) truncated.
+    base_file:
+    # type=file|default=<undefined>: Base image (opposite phase encoding direction than source image).
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-afni/qwarp_plus_minus_callables.py b/example-specs/task/nipype_internal/pydra-afni/qwarp_plus_minus_callables.py
new file mode 100644
index 00000000..4b6c49d2
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/qwarp_plus_minus_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in QwarpPlusMinus.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-afni/re_ho.yaml b/example-specs/task/nipype_internal/pydra-afni/re_ho.yaml
new file mode 100644
index 00000000..fca91352
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/re_ho.yaml
@@ -0,0 +1,159 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.afni.utils.ReHo' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Compute regional homogeneity for a given neighbourhood.l,
+#     based on a local neighborhood of that voxel.
+# 
+#     For complete details, see the `3dReHo Documentation.
+#     <https://afni.nimh.nih.gov/pub/dist/doc/program_help/3dReHo.html>`_
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import afni
+#     >>> reho = afni.ReHo()
+#     >>> reho.inputs.in_file = 'functional.nii'
+#     >>> reho.inputs.out_file = 'reho.nii.gz'
+#     >>> reho.inputs.neighborhood = 'vertices'
+#     >>> reho.cmdline
+#     '3dReHo -prefix reho.nii.gz -inset functional.nii -nneigh 27'
+#     >>> res = reho.run()  # doctest: +SKIP
+# 
+#     
+task_name: ReHo
+nipype_name: ReHo
+nipype_module: nipype.interfaces.afni.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: input dataset
+    out_file: medimage/nifti-gz
+    # type=file: Voxelwise regional homogeneity map
+    # type=file|default=<undefined>: Output dataset.
+    mask_file: generic/file
+    # type=file|default=<undefined>: Mask within which ReHo should be calculated voxelwise
+    label_set: generic/file
+    # type=file|default=<undefined>: a set of ROIs, each labelled with distinct integers. ReHo will then be calculated per ROI.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: medimage/nifti-gz
+    # type=file: Voxelwise regional homogeneity map
+    # type=file|default=<undefined>: Output dataset.
+    out_vals: generic/file
+    # type=file: Table of labelwise regional homogeneity values
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input dataset
+    out_file:
+    # type=file: Voxelwise regional homogeneity map
+    # type=file|default=<undefined>: Output dataset.
+    chi_sq:
+    # type=bool|default=False: Output the Friedman chi-squared value in addition to the Kendall's W. This option is currently compatible only with the AFNI (BRIK/HEAD) output type; the chi-squared value will be the second sub-brick of the output dataset.
+    mask_file:
+    # type=file|default=<undefined>: Mask within which ReHo should be calculated voxelwise
+    neighborhood:
+    # type=enum|default='faces'|allowed['edges','faces','vertices']:  voxels in neighborhood. can be: ``faces`` (for voxel and 6 facewise neighbors, only), ``edges`` (for voxel and 18 face- and edge-wise neighbors), ``vertices`` (for voxel and 26 face-, edge-, and node-wise neighbors).
+    sphere:
+    # type=float|default=0.0: \ For additional voxelwise neighborhood control, the radius R of a desired neighborhood can be put in; R is a floating point number, and must be >1. Examples of the numbers of voxels in a given radius are as follows (you can roughly approximate with the ol' :math:`4\pi\,R^3/3` thing):      * R=2.0 -> V=33     * R=2.3 -> V=57,     * R=2.9 -> V=93,     * R=3.1 -> V=123,     * R=3.9 -> V=251,     * R=4.5 -> V=389,     * R=6.1 -> V=949,  but you can choose most any value.
+    ellipsoid:
+    # type=tuple|default=(0.0, 0.0, 0.0): \ Tuple indicating the x, y, and z radius of an ellipsoid defining the neighbourhood of each voxel. The 'hood is then made according to the following relation: :math:`(i/A)^2 + (j/B)^2 + (k/C)^2 \le 1.` which will have approx. :math:`V=4 \pi \, A B C/3`. The impetus for this freedom was for use with data having anisotropic voxel edge lengths.
+    label_set:
+    # type=file|default=<undefined>: a set of ROIs, each labelled with distinct integers. ReHo will then be calculated per ROI.
+    overwrite:
+    # type=bool|default=False: overwrite output file if it already exists
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input dataset
+    out_file:
+    # type=file: Voxelwise regional homogeneity map
+    # type=file|default=<undefined>: Output dataset.
+    neighborhood: '"vertices"'
+    # type=enum|default='faces'|allowed['edges','faces','vertices']:  voxels in neighborhood. can be: ``faces`` (for voxel and 6 facewise neighbors, only), ``edges`` (for voxel and 18 face- and edge-wise neighbors), ``vertices`` (for voxel and 26 face-, edge-, and node-wise neighbors).
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: 3dReHo -prefix reho.nii.gz -inset functional.nii -nneigh 27
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: input dataset
+    out_file:
+    # type=file: Voxelwise regional homogeneity map
+    # type=file|default=<undefined>: Output dataset.
+    neighborhood: '"vertices"'
+    # type=enum|default='faces'|allowed['edges','faces','vertices']:  voxels in neighborhood. can be: ``faces`` (for voxel and 6 facewise neighbors, only), ``edges`` (for voxel and 18 face- and edge-wise neighbors), ``vertices`` (for voxel and 26 face-, edge-, and node-wise neighbors).
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-afni/re_ho_callables.py b/example-specs/task/nipype_internal/pydra-afni/re_ho_callables.py
new file mode 100644
index 00000000..576ca23a
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/re_ho_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in ReHo.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-afni/refit.yaml b/example-specs/task/nipype_internal/pydra-afni/refit.yaml
new file mode 100644
index 00000000..f1a8aa44
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/refit.yaml
@@ -0,0 +1,202 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.afni.utils.Refit' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Changes some of the information inside a 3D dataset's header
+# 
+#     For complete details, see the `3drefit Documentation.
+#     <https://afni.nimh.nih.gov/pub/dist/doc/program_help/3drefit.html>`_
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import afni
+#     >>> refit = afni.Refit()
+#     >>> refit.inputs.in_file = 'structural.nii'
+#     >>> refit.inputs.deoblique = True
+#     >>> refit.cmdline
+#     '3drefit -deoblique structural.nii'
+#     >>> res = refit.run()  # doctest: +SKIP
+# 
+#     >>> refit_2 = afni.Refit()
+#     >>> refit_2.inputs.in_file = 'structural.nii'
+#     >>> refit_2.inputs.atrfloat = ("IJK_TO_DICOM_REAL", "'1 0.2 0 0 -0.2 1 0 0 0 0 1 0'")
+#     >>> refit_2.cmdline
+#     "3drefit -atrfloat IJK_TO_DICOM_REAL '1 0.2 0 0 -0.2 1 0 0 0 0 1 0' structural.nii"
+#     >>> res = refit_2.run()  # doctest: +SKIP
+# 
+#     
+task_name: Refit
+nipype_name: Refit
+nipype_module: nipype.interfaces.afni.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: input file to 3drefit
+    duporigin_file: generic/file
+    # type=file|default=<undefined>: Copies the xorigin, yorigin, and zorigin values from the header of the given dataset
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: output file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to 3drefit
+    deoblique:
+    # type=bool|default=False: replace current transformation matrix with cardinal matrix
+    xorigin:
+    # type=str|default='': x distance for edge voxel offset
+    yorigin:
+    # type=str|default='': y distance for edge voxel offset
+    zorigin:
+    # type=str|default='': z distance for edge voxel offset
+    duporigin_file:
+    # type=file|default=<undefined>: Copies the xorigin, yorigin, and zorigin values from the header of the given dataset
+    xdel:
+    # type=float|default=0.0: new x voxel dimension in mm
+    ydel:
+    # type=float|default=0.0: new y voxel dimension in mm
+    zdel:
+    # type=float|default=0.0: new z voxel dimension in mm
+    xyzscale:
+    # type=float|default=0.0: Scale the size of the dataset voxels by the given factor
+    space:
+    # type=enum|default='TLRC'|allowed['MNI','ORIG','TLRC']: Associates the dataset with a specific template type, e.g. TLRC, MNI, ORIG
+    atrcopy:
+    # type=tuple|default=(<undefined>, ''): Copy AFNI header attribute from the given file into the header of the dataset(s) being modified. For more information on AFNI header attributes, see documentation file README.attributes. More than one '-atrcopy' option can be used. For AFNI advanced users only. Do NOT use -atrcopy or -atrstring with other modification options. See also -copyaux.
+    atrstring:
+    # type=tuple|default=('', ''): Copy the last given string into the dataset(s) being modified, giving it the attribute name given by the last string.To be safe, the last string should be in quotes.
+    atrfloat:
+    # type=tuple|default=('', ''): Create or modify floating point attributes. The input values may be specified as a single string in quotes or as a 1D filename or string, example '1 0.2 0 0 -0.2 1 0 0 0 0 1 0' or flipZ.1D or '1D:1,0.2,2@0,-0.2,1,2@0,2@0,1,0'
+    atrint:
+    # type=tuple|default=('', ''): Create or modify integer attributes. The input values may be specified as a single string in quotes or as a 1D filename or string, example '1 0 0 0 0 1 0 0 0 0 1 0' or flipZ.1D or '1D:1,0,2@0,-0,1,2@0,2@0,1,0'
+    saveatr:
+    # type=bool|default=False: (default) Copy the attributes that are known to AFNI into the dset->dblk structure thereby forcing changes to known attributes to be present in the output. This option only makes sense with -atrcopy.
+    nosaveatr:
+    # type=bool|default=False: Opposite of -saveatr
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to 3drefit
+    deoblique: 'True'
+    # type=bool|default=False: replace current transformation matrix with cardinal matrix
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to 3drefit
+    atrfloat: ("IJK_TO_DICOM_REAL", "'1 0.2 0 0 -0.2 1 0 0 0 0 1 0'")
+    # type=tuple|default=('', ''): Create or modify floating point attributes. The input values may be specified as a single string in quotes or as a 1D filename or string, example '1 0.2 0 0 -0.2 1 0 0 0 0 1 0' or flipZ.1D or '1D:1,0.2,2@0,-0.2,1,2@0,2@0,1,0'
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: 3drefit -deoblique structural.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: input file to 3drefit
+    deoblique: 'True'
+    # type=bool|default=False: replace current transformation matrix with cardinal matrix
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: 3drefit -atrfloat IJK_TO_DICOM_REAL "1 0.2 0 0 -0.2 1 0 0 0 0 1 0" structural.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: input file to 3drefit
+    atrfloat: ("IJK_TO_DICOM_REAL", "'1 0.2 0 0 -0.2 1 0 0 0 0 1 0'")
+    # type=tuple|default=('', ''): Create or modify floating point attributes. The input values may be specified as a single string in quotes or as a 1D filename or string, example '1 0.2 0 0 -0.2 1 0 0 0 0 1 0' or flipZ.1D or '1D:1,0.2,2@0,-0.2,1,2@0,2@0,1,0'
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-afni/refit_callables.py b/example-specs/task/nipype_internal/pydra-afni/refit_callables.py
new file mode 100644
index 00000000..6c854dfa
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/refit_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Refit.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-afni/remlfit.yaml b/example-specs/task/nipype_internal/pydra-afni/remlfit.yaml
new file mode 100644
index 00000000..a3a9f842
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/remlfit.yaml
@@ -0,0 +1,317 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.afni.model.Remlfit' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Performs Generalized least squares time series fit with Restricted
+#     Maximum Likelihood (REML) estimation of the temporal auto-correlation
+#     structure.
+# 
+#     For complete details, see the `3dREMLfit Documentation.
+#     <https://afni.nimh.nih.gov/pub/dist/doc/program_help/3dREMLfit.html>`_
+# 
+#     Examples
+#     ========
+# 
+#     >>> from nipype.interfaces import afni
+#     >>> remlfit = afni.Remlfit()
+#     >>> remlfit.inputs.in_files = ['functional.nii', 'functional2.nii']
+#     >>> remlfit.inputs.out_file = 'output.nii'
+#     >>> remlfit.inputs.matrix = 'output.1D'
+#     >>> remlfit.inputs.gltsym = [('SYM: +Lab1 -Lab2', 'TestSYM'), ('timeseries.txt', 'TestFile')]
+#     >>> remlfit.cmdline
+#     '3dREMLfit -gltsym "SYM: +Lab1 -Lab2" TestSYM -gltsym "timeseries.txt" TestFile -input "functional.nii functional2.nii" -matrix output.1D -Rbuck output.nii'
+#     >>> res = remlfit.run()  # doctest: +SKIP
+#     
+task_name: Remlfit
+nipype_name: Remlfit
+nipype_module: nipype.interfaces.afni.model
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_files: medimage/nifti1+list-of
+    # type=inputmultiobject|default=[]: Read time series dataset
+    matrix: medimage-afni/oned
+    # type=file|default=<undefined>: the design matrix file, which should have been output from Deconvolve via the 'x1D' option
+    matim: generic/file
+    # type=file|default=<undefined>: read a standard file as the matrix. You can use only Col as a name in GLTs with these nonstandard matrix input methods, since the other names come from the 'matrix' file. These mutually exclusive options are ignored if 'matrix' is used.
+    mask: generic/file
+    # type=file|default=<undefined>: filename of 3D mask dataset; only data time series from within the mask will be analyzed; results for voxels outside the mask will be set to zero.
+    STATmask: generic/file
+    # type=file|default=<undefined>: filename of 3D mask dataset to be used for the purpose of reporting truncation-to float issues AND for computing the FDR curves. The actual results ARE not masked with this option (only with 'mask' or 'automask' options).
+    addbase: generic/file+list-of
+    # type=inputmultiobject|default=[]: file(s) to add baseline model columns to the matrix with this option. Each column in the specified file(s) will be appended to the matrix. File(s) must have at least as many rows as the matrix does.
+    slibase: generic/file+list-of
+    # type=inputmultiobject|default=[]: similar to 'addbase' in concept, BUT each specified file must have an integer multiple of the number of slices in the input dataset(s); then, separate regression matrices are generated for each slice, with the first column of the file appended to the matrix for the first slice of the dataset, the second column of the file appended to the matrix for the first slice of the dataset, and so on. Intended to help model physiological noise in FMRI, or other effects you want to regress out that might change significantly in the inter-slice time intervals. This will slow the program down, and make it use a lot more memory (to hold all the matrix stuff).
+    slibase_sm: generic/file+list-of
+    # type=inputmultiobject|default=[]: similar to 'slibase', BUT each file much be in slice major order (i.e. all slice0 columns come first, then all slice1 columns, etc).
+    dsort: generic/file
+    # type=file|default=<undefined>: 4D dataset to be used as voxelwise baseline regressor
+    out_file: medimage/nifti1
+    # type=file: dataset for beta + statistics from the REML estimation (if generated)
+    # type=file|default=<undefined>: output dataset for beta + statistics from the REML estimation; also contains the results of any GLT analysis requested in the Deconvolve setup, similar to the 'bucket' output from Deconvolve. This dataset does NOT get the betas (or statistics) of those regressors marked as 'baseline' in the matrix file.
+    var_file: generic/file
+    # type=file: dataset for REML variance parameters (if generated)
+    # type=file|default=<undefined>: output dataset for REML variance parameters
+    rbeta_file: generic/file
+    # type=file: output dataset for beta weights from the REML estimation (if generated)
+    # type=file|default=<undefined>: output dataset for beta weights from the REML estimation, similar to the 'cbucket' output from Deconvolve. This dataset will contain all the beta weights, for baseline and stimulus regressors alike, unless the '-nobout' option is given -- in that case, this dataset will only get the betas for the stimulus regressors.
+    glt_file: generic/file
+    # type=file: output dataset for beta + statistics from the REML estimation, but ONLY for the GLTs added on the REMLfit command line itself via 'gltsym' (if generated)
+    # type=file|default=<undefined>: output dataset for beta + statistics from the REML estimation, but ONLY for the GLTs added on the REMLfit command line itself via 'gltsym'; GLTs from Deconvolve's command line will NOT be included.
+    fitts_file: generic/file
+    # type=file: output dataset for REML fitted model (if generated)
+    # type=file|default=<undefined>: output dataset for REML fitted model
+    errts_file: generic/file
+    # type=file: output dataset for REML residuals = data - fitted model (if generated)
+    # type=file|default=<undefined>: output dataset for REML residuals = data - fitted model
+    wherr_file: generic/file
+    # type=file: dataset for REML residual, whitened using the estimated ARMA(1,1) correlation matrix of the noise (if generated)
+    # type=file|default=<undefined>: dataset for REML residual, whitened using the estimated ARMA(1,1) correlation matrix of the noise
+    ovar: generic/file
+    # type=file: dataset for OLSQ st.dev. parameter (if generated)
+    # type=file|default=<undefined>: dataset for OLSQ st.dev. parameter (kind of boring)
+    obeta: generic/file
+    # type=file: dataset for beta weights from the OLSQ estimation (if generated)
+    # type=file|default=<undefined>: dataset for beta weights from the OLSQ estimation
+    obuck: generic/file
+    # type=file: dataset for beta + statistics from the OLSQ estimation (if generated)
+    # type=file|default=<undefined>: dataset for beta + statistics from the OLSQ estimation
+    oglt: generic/file
+    # type=file: dataset for beta + statistics from 'gltsym' options (if generated)
+    # type=file|default=<undefined>: dataset for beta + statistics from 'gltsym' options
+    ofitts: generic/file
+    # type=file: dataset for OLSQ fitted model (if generated)
+    # type=file|default=<undefined>: dataset for OLSQ fitted model
+    oerrts: generic/file
+    # type=file: dataset for OLSQ residuals = data - fitted model (if generated)
+    # type=file|default=<undefined>: dataset for OLSQ residuals (data - fitted model)
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: medimage/nifti1
+    # type=file: dataset for beta + statistics from the REML estimation (if generated)
+    # type=file|default=<undefined>: output dataset for beta + statistics from the REML estimation; also contains the results of any GLT analysis requested in the Deconvolve setup, similar to the 'bucket' output from Deconvolve. This dataset does NOT get the betas (or statistics) of those regressors marked as 'baseline' in the matrix file.
+    var_file: generic/file
+    # type=file: dataset for REML variance parameters (if generated)
+    # type=file|default=<undefined>: output dataset for REML variance parameters
+    rbeta_file: generic/file
+    # type=file: output dataset for beta weights from the REML estimation (if generated)
+    # type=file|default=<undefined>: output dataset for beta weights from the REML estimation, similar to the 'cbucket' output from Deconvolve. This dataset will contain all the beta weights, for baseline and stimulus regressors alike, unless the '-nobout' option is given -- in that case, this dataset will only get the betas for the stimulus regressors.
+    glt_file: generic/file
+    # type=file: output dataset for beta + statistics from the REML estimation, but ONLY for the GLTs added on the REMLfit command line itself via 'gltsym' (if generated)
+    # type=file|default=<undefined>: output dataset for beta + statistics from the REML estimation, but ONLY for the GLTs added on the REMLfit command line itself via 'gltsym'; GLTs from Deconvolve's command line will NOT be included.
+    fitts_file: generic/file
+    # type=file: output dataset for REML fitted model (if generated)
+    # type=file|default=<undefined>: output dataset for REML fitted model
+    errts_file: generic/file
+    # type=file: output dataset for REML residuals = data - fitted model (if generated)
+    # type=file|default=<undefined>: output dataset for REML residuals = data - fitted model
+    wherr_file: generic/file
+    # type=file: dataset for REML residual, whitened using the estimated ARMA(1,1) correlation matrix of the noise (if generated)
+    # type=file|default=<undefined>: dataset for REML residual, whitened using the estimated ARMA(1,1) correlation matrix of the noise
+    ovar: generic/file
+    # type=file: dataset for OLSQ st.dev. parameter (if generated)
+    # type=file|default=<undefined>: dataset for OLSQ st.dev. parameter (kind of boring)
+    obeta: generic/file
+    # type=file: dataset for beta weights from the OLSQ estimation (if generated)
+    # type=file|default=<undefined>: dataset for beta weights from the OLSQ estimation
+    obuck: generic/file
+    # type=file: dataset for beta + statistics from the OLSQ estimation (if generated)
+    # type=file|default=<undefined>: dataset for beta + statistics from the OLSQ estimation
+    oglt: generic/file
+    # type=file: dataset for beta + statistics from 'gltsym' options (if generated)
+    # type=file|default=<undefined>: dataset for beta + statistics from 'gltsym' options
+    ofitts: generic/file
+    # type=file: dataset for OLSQ fitted model (if generated)
+    # type=file|default=<undefined>: dataset for OLSQ fitted model
+    oerrts: generic/file
+    # type=file: dataset for OLSQ residuals = data - fitted model (if generated)
+    # type=file|default=<undefined>: dataset for OLSQ residuals (data - fitted model)
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_files:
+    # type=inputmultiobject|default=[]: Read time series dataset
+    matrix:
+    # type=file|default=<undefined>: the design matrix file, which should have been output from Deconvolve via the 'x1D' option
+    polort:
+    # type=int|default=0: if no 'matrix' option is given, AND no 'matim' option, create a matrix with Legendre polynomial regressorsup to the specified order. The default value is 0, whichproduces a matrix with a single column of all ones
+    matim:
+    # type=file|default=<undefined>: read a standard file as the matrix. You can use only Col as a name in GLTs with these nonstandard matrix input methods, since the other names come from the 'matrix' file. These mutually exclusive options are ignored if 'matrix' is used.
+    mask:
+    # type=file|default=<undefined>: filename of 3D mask dataset; only data time series from within the mask will be analyzed; results for voxels outside the mask will be set to zero.
+    automask:
+    # type=bool|default=False: build a mask automatically from input data (will be slow for long time series datasets)
+    STATmask:
+    # type=file|default=<undefined>: filename of 3D mask dataset to be used for the purpose of reporting truncation-to float issues AND for computing the FDR curves. The actual results ARE not masked with this option (only with 'mask' or 'automask' options).
+    addbase:
+    # type=inputmultiobject|default=[]: file(s) to add baseline model columns to the matrix with this option. Each column in the specified file(s) will be appended to the matrix. File(s) must have at least as many rows as the matrix does.
+    slibase:
+    # type=inputmultiobject|default=[]: similar to 'addbase' in concept, BUT each specified file must have an integer multiple of the number of slices in the input dataset(s); then, separate regression matrices are generated for each slice, with the first column of the file appended to the matrix for the first slice of the dataset, the second column of the file appended to the matrix for the first slice of the dataset, and so on. Intended to help model physiological noise in FMRI, or other effects you want to regress out that might change significantly in the inter-slice time intervals. This will slow the program down, and make it use a lot more memory (to hold all the matrix stuff).
+    slibase_sm:
+    # type=inputmultiobject|default=[]: similar to 'slibase', BUT each file much be in slice major order (i.e. all slice0 columns come first, then all slice1 columns, etc).
+    usetemp:
+    # type=bool|default=False: write intermediate stuff to disk, to economize on RAM. Using this option might be necessary to run with 'slibase' and with 'Grid' values above the default, since the program has to store a large number of matrices for such a problem: two for every slice and for every (a,b) pair in the ARMA parameter grid. Temporary files are written to the directory given in environment variable TMPDIR, or in /tmp, or in ./ (preference is in that order)
+    nodmbase:
+    # type=bool|default=False: by default, baseline columns added to the matrix via 'addbase' or 'slibase' or 'dsort' will each have their mean removed (as is done in Deconvolve); this option turns this centering off
+    dsort:
+    # type=file|default=<undefined>: 4D dataset to be used as voxelwise baseline regressor
+    dsort_nods:
+    # type=bool|default=False: if 'dsort' option is used, this command will output additional results files excluding the 'dsort' file
+    fout:
+    # type=bool|default=False: output F-statistic for each stimulus
+    rout:
+    # type=bool|default=False: output the R^2 statistic for each stimulus
+    tout:
+    # type=bool|default=False: output the T-statistic for each stimulus; if you use 'out_file' and do not give any of 'fout', 'tout',or 'rout', then the program assumes 'fout' is activated.
+    nofdr:
+    # type=bool|default=False: do NOT add FDR curve data to bucket datasets; FDR curves can take a long time if 'tout' is used
+    nobout:
+    # type=bool|default=False: do NOT add baseline (null hypothesis) regressor betas to the 'rbeta_file' and/or 'obeta_file' output datasets.
+    gltsym:
+    # type=list|default=[]: read a symbolic GLT from input file and associate it with a label. As in Deconvolve, you can also use the 'SYM:' method to provide the definition of the GLT directly as a string (e.g., with 'SYM: +Label1 -Label2'). Unlike Deconvolve, you MUST specify 'SYM: ' if providing the GLT directly as a string instead of from a file
+    out_file:
+    # type=file: dataset for beta + statistics from the REML estimation (if generated)
+    # type=file|default=<undefined>: output dataset for beta + statistics from the REML estimation; also contains the results of any GLT analysis requested in the Deconvolve setup, similar to the 'bucket' output from Deconvolve. This dataset does NOT get the betas (or statistics) of those regressors marked as 'baseline' in the matrix file.
+    var_file:
+    # type=file: dataset for REML variance parameters (if generated)
+    # type=file|default=<undefined>: output dataset for REML variance parameters
+    rbeta_file:
+    # type=file: output dataset for beta weights from the REML estimation (if generated)
+    # type=file|default=<undefined>: output dataset for beta weights from the REML estimation, similar to the 'cbucket' output from Deconvolve. This dataset will contain all the beta weights, for baseline and stimulus regressors alike, unless the '-nobout' option is given -- in that case, this dataset will only get the betas for the stimulus regressors.
+    glt_file:
+    # type=file: output dataset for beta + statistics from the REML estimation, but ONLY for the GLTs added on the REMLfit command line itself via 'gltsym' (if generated)
+    # type=file|default=<undefined>: output dataset for beta + statistics from the REML estimation, but ONLY for the GLTs added on the REMLfit command line itself via 'gltsym'; GLTs from Deconvolve's command line will NOT be included.
+    fitts_file:
+    # type=file: output dataset for REML fitted model (if generated)
+    # type=file|default=<undefined>: output dataset for REML fitted model
+    errts_file:
+    # type=file: output dataset for REML residuals = data - fitted model (if generated)
+    # type=file|default=<undefined>: output dataset for REML residuals = data - fitted model
+    wherr_file:
+    # type=file: dataset for REML residual, whitened using the estimated ARMA(1,1) correlation matrix of the noise (if generated)
+    # type=file|default=<undefined>: dataset for REML residual, whitened using the estimated ARMA(1,1) correlation matrix of the noise
+    quiet:
+    # type=bool|default=False: turn off most progress messages
+    verb:
+    # type=bool|default=False: turns on more progress messages, including memory usage progress reports at various stages
+    goforit:
+    # type=bool|default=False: With potential issues flagged in the design matrix, an attempt will nevertheless be made to fit the model
+    ovar:
+    # type=file: dataset for OLSQ st.dev. parameter (if generated)
+    # type=file|default=<undefined>: dataset for OLSQ st.dev. parameter (kind of boring)
+    obeta:
+    # type=file: dataset for beta weights from the OLSQ estimation (if generated)
+    # type=file|default=<undefined>: dataset for beta weights from the OLSQ estimation
+    obuck:
+    # type=file: dataset for beta + statistics from the OLSQ estimation (if generated)
+    # type=file|default=<undefined>: dataset for beta + statistics from the OLSQ estimation
+    oglt:
+    # type=file: dataset for beta + statistics from 'gltsym' options (if generated)
+    # type=file|default=<undefined>: dataset for beta + statistics from 'gltsym' options
+    ofitts:
+    # type=file: dataset for OLSQ fitted model (if generated)
+    # type=file|default=<undefined>: dataset for OLSQ fitted model
+    oerrts:
+    # type=file: dataset for OLSQ residuals = data - fitted model (if generated)
+    # type=file|default=<undefined>: dataset for OLSQ residuals (data - fitted model)
+    num_threads:
+    # type=int|default=1: set number of threads
+    outputtype:
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_files:
+    # type=inputmultiobject|default=[]: Read time series dataset
+    out_file:
+    # type=file: dataset for beta + statistics from the REML estimation (if generated)
+    # type=file|default=<undefined>: output dataset for beta + statistics from the REML estimation; also contains the results of any GLT analysis requested in the Deconvolve setup, similar to the 'bucket' output from Deconvolve. This dataset does NOT get the betas (or statistics) of those regressors marked as 'baseline' in the matrix file.
+    matrix:
+    # type=file|default=<undefined>: the design matrix file, which should have been output from Deconvolve via the 'x1D' option
+    gltsym: '[("SYM: +Lab1 -Lab2", "TestSYM"), ("timeseries.txt", "TestFile")]'
+    # type=list|default=[]: read a symbolic GLT from input file and associate it with a label. As in Deconvolve, you can also use the 'SYM:' method to provide the definition of the GLT directly as a string (e.g., with 'SYM: +Label1 -Label2'). Unlike Deconvolve, you MUST specify 'SYM: ' if providing the GLT directly as a string instead of from a file
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: '3dREMLfit -gltsym "SYM: +Lab1 -Lab2" TestSYM -gltsym "timeseries.txt" TestFile -input "functional.nii functional2.nii" -matrix output.1D -Rbuck output.nii'
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_files:
+    # type=inputmultiobject|default=[]: Read time series dataset
+    out_file:
+    # type=file: dataset for beta + statistics from the REML estimation (if generated)
+    # type=file|default=<undefined>: output dataset for beta + statistics from the REML estimation; also contains the results of any GLT analysis requested in the Deconvolve setup, similar to the 'bucket' output from Deconvolve. This dataset does NOT get the betas (or statistics) of those regressors marked as 'baseline' in the matrix file.
+    matrix:
+    # type=file|default=<undefined>: the design matrix file, which should have been output from Deconvolve via the 'x1D' option
+    gltsym: '[("SYM: +Lab1 -Lab2", "TestSYM"), ("timeseries.txt", "TestFile")]'
+    # type=list|default=[]: read a symbolic GLT from input file and associate it with a label. As in Deconvolve, you can also use the 'SYM:' method to provide the definition of the GLT directly as a string (e.g., with 'SYM: +Label1 -Label2'). Unlike Deconvolve, you MUST specify 'SYM: ' if providing the GLT directly as a string instead of from a file
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-afni/remlfit_callables.py b/example-specs/task/nipype_internal/pydra-afni/remlfit_callables.py
new file mode 100644
index 00000000..7dedf957
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/remlfit_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Remlfit.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-afni/resample.yaml b/example-specs/task/nipype_internal/pydra-afni/resample.yaml
new file mode 100644
index 00000000..45c8688d
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/resample.yaml
@@ -0,0 +1,150 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.afni.utils.Resample' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Resample or reorient an image using AFNI 3dresample command
+# 
+#     For complete details, see the `3dresample Documentation.
+#     <https://afni.nimh.nih.gov/pub/dist/doc/program_help/3dresample.html>`_
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import afni
+#     >>> resample = afni.Resample()
+#     >>> resample.inputs.in_file = 'functional.nii'
+#     >>> resample.inputs.orientation= 'RPI'
+#     >>> resample.inputs.outputtype = 'NIFTI'
+#     >>> resample.cmdline
+#     '3dresample -orient RPI -prefix functional_resample.nii -inset functional.nii'
+#     >>> res = resample.run()  # doctest: +SKIP
+# 
+#     
+task_name: Resample
+nipype_name: Resample
+nipype_module: nipype.interfaces.afni.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: input file to 3dresample
+    out_file: generic/file
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+    master: generic/file
+    # type=file|default=<undefined>: align dataset grid to a reference file
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to 3dresample
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+    orientation:
+    # type=str|default='': new orientation code
+    resample_mode:
+    # type=enum|default='NN'|allowed['Bk','Cu','Li','NN']: resampling method from set {"NN", "Li", "Cu", "Bk"}. These are for "Nearest Neighbor", "Linear", "Cubic" and "Blocky"interpolation, respectively. Default is NN.
+    voxel_size:
+    # type=tuple|default=(0.0, 0.0, 0.0): resample to new dx, dy and dz
+    master:
+    # type=file|default=<undefined>: align dataset grid to a reference file
+    num_threads:
+    # type=int|default=1: set number of threads
+    outputtype:
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to 3dresample
+    orientation: '"RPI"'
+    # type=str|default='': new orientation code
+    outputtype: '"NIFTI"'
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: 3dresample -orient RPI -prefix functional_resample.nii -inset functional.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: input file to 3dresample
+    orientation: '"RPI"'
+    # type=str|default='': new orientation code
+    outputtype: '"NIFTI"'
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-afni/resample_callables.py b/example-specs/task/nipype_internal/pydra-afni/resample_callables.py
new file mode 100644
index 00000000..1e012806
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/resample_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Resample.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-afni/retroicor.yaml b/example-specs/task/nipype_internal/pydra-afni/retroicor.yaml
new file mode 100644
index 00000000..40299a22
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/retroicor.yaml
@@ -0,0 +1,180 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.afni.preprocess.Retroicor' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Performs Retrospective Image Correction for physiological
+#     motion effects, using a slightly modified version of the
+#     RETROICOR algorithm
+# 
+#     The durations of the physiological inputs are assumed to equal
+#     the duration of the dataset. Any constant sampling rate may be
+#     used, but 40 Hz seems to be acceptable. This program's cardiac
+#     peak detection algorithm is rather simplistic, so you might try
+#     using the scanner's cardiac gating output (transform it to a
+#     spike wave if necessary).
+# 
+#     This program uses slice timing information embedded in the
+#     dataset to estimate the proper cardiac/respiratory phase for
+#     each slice. It makes sense to run this program before any
+#     program that may destroy the slice timings (e.g. 3dvolreg for
+#     motion correction).
+# 
+#     For complete details, see the `3dretroicor Documentation.
+#     <https://afni.nimh.nih.gov/pub/dist/doc/program_help/3dretroicor.html>`_
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import afni
+#     >>> ret = afni.Retroicor()
+#     >>> ret.inputs.in_file = 'functional.nii'
+#     >>> ret.inputs.card = 'mask.1D'
+#     >>> ret.inputs.resp = 'resp.1D'
+#     >>> ret.inputs.outputtype = 'NIFTI'
+#     >>> ret.cmdline
+#     '3dretroicor -prefix functional_retroicor.nii -resp resp.1D -card mask.1D functional.nii'
+#     >>> res = ret.run()  # doctest: +SKIP
+# 
+#     
+task_name: Retroicor
+nipype_name: Retroicor
+nipype_module: nipype.interfaces.afni.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: input file to 3dretroicor
+    out_file: generic/file
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+    card: medimage-afni/oned
+    # type=file|default=<undefined>: 1D cardiac data file for cardiac correction
+    resp: medimage-afni/oned
+    # type=file|default=<undefined>: 1D respiratory waveform data for correction
+    cardphase: generic/file
+    # type=file|default=<undefined>: Filename for 1D cardiac phase output
+    respphase: generic/file
+    # type=file|default=<undefined>: Filename for 1D resp phase output
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to 3dretroicor
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+    card:
+    # type=file|default=<undefined>: 1D cardiac data file for cardiac correction
+    resp:
+    # type=file|default=<undefined>: 1D respiratory waveform data for correction
+    threshold:
+    # type=int|default=0: Threshold for detection of R-wave peaks in input (Make sure it is above the background noise level, Try 3/4 or 4/5 times range plus minimum)
+    order:
+    # type=int|default=0: The order of the correction (2 is typical)
+    cardphase:
+    # type=file|default=<undefined>: Filename for 1D cardiac phase output
+    respphase:
+    # type=file|default=<undefined>: Filename for 1D resp phase output
+    num_threads:
+    # type=int|default=1: set number of threads
+    outputtype:
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to 3dretroicor
+    card:
+    # type=file|default=<undefined>: 1D cardiac data file for cardiac correction
+    resp:
+    # type=file|default=<undefined>: 1D respiratory waveform data for correction
+    outputtype: '"NIFTI"'
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: 3dretroicor -prefix functional_retroicor.nii -resp resp.1D -card mask.1D functional.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: input file to 3dretroicor
+    card:
+    # type=file|default=<undefined>: 1D cardiac data file for cardiac correction
+    resp:
+    # type=file|default=<undefined>: 1D respiratory waveform data for correction
+    outputtype: '"NIFTI"'
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-afni/retroicor_callables.py b/example-specs/task/nipype_internal/pydra-afni/retroicor_callables.py
new file mode 100644
index 00000000..1b4f7ade
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/retroicor_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Retroicor.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-afni/roi_stats.yaml b/example-specs/task/nipype_internal/pydra-afni/roi_stats.yaml
new file mode 100644
index 00000000..1d9750a5
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/roi_stats.yaml
@@ -0,0 +1,173 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.afni.preprocess.ROIStats' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Display statistics over masked regions
+# 
+#     For complete details, see the `3dROIstats Documentation
+#     <https://afni.nimh.nih.gov/pub/dist/doc/program_help/3dROIstats.html>`_
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import afni
+#     >>> roistats = afni.ROIStats()
+#     >>> roistats.inputs.in_file = 'functional.nii'
+#     >>> roistats.inputs.mask_file = 'skeleton_mask.nii.gz'
+#     >>> roistats.inputs.stat = ['mean', 'median', 'voxels']
+#     >>> roistats.inputs.nomeanout = True
+#     >>> roistats.cmdline
+#     '3dROIstats -mask skeleton_mask.nii.gz -nomeanout -nzmean -nzmedian -nzvoxels functional.nii > functional_roistat.1D'
+#     >>> res = roistats.run()  # doctest: +SKIP
+# 
+#     
+task_name: ROIStats
+nipype_name: ROIStats
+nipype_module: nipype.interfaces.afni.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: input dataset
+    mask: generic/file
+    # type=file|default=<undefined>: input mask
+    mask_file: medimage/nifti-gz
+    # type=file|default=<undefined>: input mask
+    roisel: generic/file
+    # type=file|default=<undefined>: Only considers ROIs denoted by values found in the specified file. Note that the order of the ROIs as specified in the file is not preserved. So an SEL.1D of '2 8 20' produces the same output as '8 20 2'
+    out_file: generic/file
+    # type=file: output tab-separated values file
+    # type=file|default=<undefined>: output file
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: output tab-separated values file
+    # type=file|default=<undefined>: output file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input dataset
+    mask:
+    # type=file|default=<undefined>: input mask
+    mask_file:
+    # type=file|default=<undefined>: input mask
+    mask_f2short:
+    # type=bool|default=False: Tells the program to convert a float mask to short integers, by simple rounding.
+    num_roi:
+    # type=int|default=0: Forces the assumption that the mask dataset's ROIs are denoted by 1 to n inclusive.  Normally, the program figures out the ROIs on its own.  This option is useful if a) you are certain that the mask dataset has no values outside the range [0 n], b) there may be some ROIs missing between [1 n] in the mask data-set and c) you want those columns in the output any-way so the output lines up with the output from other invocations of 3dROIstats.
+    zerofill:
+    # type=str|default='': For ROI labels not found, use the provided string instead of a '0' in the output file. Only active if `num_roi` is enabled.
+    roisel:
+    # type=file|default=<undefined>: Only considers ROIs denoted by values found in the specified file. Note that the order of the ROIs as specified in the file is not preserved. So an SEL.1D of '2 8 20' produces the same output as '8 20 2'
+    debug:
+    # type=bool|default=False: print debug information
+    quiet:
+    # type=bool|default=False: execute quietly
+    nomeanout:
+    # type=bool|default=False: Do not include the (zero-inclusive) mean among computed stats
+    nobriklab:
+    # type=bool|default=False: Do not print the sub-brick label next to its index
+    format1D:
+    # type=bool|default=False: Output results in a 1D format that includes commented labels
+    format1DR:
+    # type=bool|default=False: Output results in a 1D format that includes uncommented labels. May not work optimally with typical 1D functions, but is useful for R functions.
+    stat:
+    # type=inputmultiobject|default=[]: Statistics to compute. Options include:   * mean       =   Compute the mean using only non_zero voxels.                   Implies the opposite for the mean computed                   by default.  * median     =   Compute the median of nonzero voxels  * mode       =   Compute the mode of nonzero voxels.                   (integral valued sets only)  * minmax     =   Compute the min/max of nonzero voxels  * sum        =   Compute the sum using only nonzero voxels.  * voxels     =   Compute the number of nonzero voxels  * sigma      =   Compute the standard deviation of nonzero                   voxels  Statistics that include zero-valued voxels:   * zerominmax =   Compute the min/max of all voxels.  * zerosigma  =   Compute the standard deviation of all                   voxels.  * zeromedian =   Compute the median of all voxels.  * zeromode   =   Compute the mode of all voxels.  * summary    =   Only output a summary line with the grand                   mean across all briks in the input dataset.                   This option cannot be used with nomeanout.  More that one option can be specified.
+    out_file:
+    # type=file: output tab-separated values file
+    # type=file|default=<undefined>: output file
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input dataset
+    mask_file:
+    # type=file|default=<undefined>: input mask
+    stat: '["mean", "median", "voxels"]'
+    # type=inputmultiobject|default=[]: Statistics to compute. Options include:   * mean       =   Compute the mean using only non_zero voxels.                   Implies the opposite for the mean computed                   by default.  * median     =   Compute the median of nonzero voxels  * mode       =   Compute the mode of nonzero voxels.                   (integral valued sets only)  * minmax     =   Compute the min/max of nonzero voxels  * sum        =   Compute the sum using only nonzero voxels.  * voxels     =   Compute the number of nonzero voxels  * sigma      =   Compute the standard deviation of nonzero                   voxels  Statistics that include zero-valued voxels:   * zerominmax =   Compute the min/max of all voxels.  * zerosigma  =   Compute the standard deviation of all                   voxels.  * zeromedian =   Compute the median of all voxels.  * zeromode   =   Compute the mode of all voxels.  * summary    =   Only output a summary line with the grand                   mean across all briks in the input dataset.                   This option cannot be used with nomeanout.  More that one option can be specified.
+    nomeanout: 'True'
+    # type=bool|default=False: Do not include the (zero-inclusive) mean among computed stats
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: 3dROIstats -mask skeleton_mask.nii.gz -nomeanout -nzmean -nzmedian -nzvoxels functional.nii > functional_roistat.1D
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: input dataset
+    mask_file:
+    # type=file|default=<undefined>: input mask
+    stat: '["mean", "median", "voxels"]'
+    # type=inputmultiobject|default=[]: Statistics to compute. Options include:   * mean       =   Compute the mean using only non_zero voxels.                   Implies the opposite for the mean computed                   by default.  * median     =   Compute the median of nonzero voxels  * mode       =   Compute the mode of nonzero voxels.                   (integral valued sets only)  * minmax     =   Compute the min/max of nonzero voxels  * sum        =   Compute the sum using only nonzero voxels.  * voxels     =   Compute the number of nonzero voxels  * sigma      =   Compute the standard deviation of nonzero                   voxels  Statistics that include zero-valued voxels:   * zerominmax =   Compute the min/max of all voxels.  * zerosigma  =   Compute the standard deviation of all                   voxels.  * zeromedian =   Compute the median of all voxels.  * zeromode   =   Compute the mode of all voxels.  * summary    =   Only output a summary line with the grand                   mean across all briks in the input dataset.                   This option cannot be used with nomeanout.  More that one option can be specified.
+    nomeanout: 'True'
+    # type=bool|default=False: Do not include the (zero-inclusive) mean among computed stats
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-afni/roi_stats_callables.py b/example-specs/task/nipype_internal/pydra-afni/roi_stats_callables.py
new file mode 100644
index 00000000..47f34117
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/roi_stats_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in ROIStats.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-afni/seg.yaml b/example-specs/task/nipype_internal/pydra-afni/seg.yaml
new file mode 100644
index 00000000..29aee342
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/seg.yaml
@@ -0,0 +1,146 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.afni.preprocess.Seg' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 3dSeg segments brain volumes into tissue classes. The program allows
+#     for adding a variety of global and voxelwise priors. However for the
+#     moment, only mixing fractions and MRF are documented.
+# 
+#     For complete details, see the `3dSeg Documentation.
+#     <https://afni.nimh.nih.gov/pub/dist/doc/program_help/3dSeg.html>`_
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces.afni import preprocess
+#     >>> seg = preprocess.Seg()
+#     >>> seg.inputs.in_file = 'structural.nii'
+#     >>> seg.inputs.mask = 'AUTO'
+#     >>> seg.cmdline
+#     '3dSeg -mask AUTO -anat structural.nii'
+#     >>> res = seg.run()  # doctest: +SKIP
+# 
+#     
+task_name: Seg
+nipype_name: Seg
+nipype_module: nipype.interfaces.afni.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: ANAT is the volume to segment
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: output file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: ANAT is the volume to segment
+    mask:
+    # type=traitcompound|default=None: only non-zero voxels in mask are analyzed. mask can either be a dataset or the string "AUTO" which would use AFNI's automask function to create the mask.
+    blur_meth:
+    # type=enum|default='BFT'|allowed['BFT','BIM']: set the blurring method for bias field estimation
+    bias_fwhm:
+    # type=float|default=0.0: The amount of blurring used when estimating the field bias with the Wells method
+    classes:
+    # type=str|default='': CLASS_STRING is a semicolon delimited string of class labels
+    bmrf:
+    # type=float|default=0.0: Weighting factor controlling spatial homogeneity of the classifications
+    bias_classes:
+    # type=str|default='': A semicolon delimited string of classes that contribute to the estimation of the bias field
+    prefix:
+    # type=str|default='': the prefix for the output folder containing all output volumes
+    mixfrac:
+    # type=str|default='': MIXFRAC sets up the volume-wide (within mask) tissue fractions while initializing the segmentation (see IGNORE for exception)
+    mixfloor:
+    # type=float|default=0.0: Set the minimum value for any class's mixing fraction
+    main_N:
+    # type=int|default=0: Number of iterations to perform.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: ANAT is the volume to segment
+    mask: '"AUTO"'
+    # type=traitcompound|default=None: only non-zero voxels in mask are analyzed. mask can either be a dataset or the string "AUTO" which would use AFNI's automask function to create the mask.
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: 3dSeg -mask AUTO -anat structural.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: ANAT is the volume to segment
+    mask: '"AUTO"'
+    # type=traitcompound|default=None: only non-zero voxels in mask are analyzed. mask can either be a dataset or the string "AUTO" which would use AFNI's automask function to create the mask.
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-afni/seg_callables.py b/example-specs/task/nipype_internal/pydra-afni/seg_callables.py
new file mode 100644
index 00000000..38eafb08
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/seg_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Seg.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-afni/skull_strip.yaml b/example-specs/task/nipype_internal/pydra-afni/skull_strip.yaml
new file mode 100644
index 00000000..5a0de4ab
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/skull_strip.yaml
@@ -0,0 +1,137 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.afni.preprocess.SkullStrip' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# A program to extract the brain from surrounding tissue from MRI
+#     T1-weighted images.
+#     TODO Add optional arguments.
+# 
+#     For complete details, see the `3dSkullStrip Documentation.
+#     <https://afni.nimh.nih.gov/pub/dist/doc/program_help/3dSkullStrip.html>`_
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import afni
+#     >>> skullstrip = afni.SkullStrip()
+#     >>> skullstrip.inputs.in_file = 'functional.nii'
+#     >>> skullstrip.inputs.args = '-o_ply'
+#     >>> skullstrip.cmdline
+#     '3dSkullStrip -input functional.nii -o_ply -prefix functional_skullstrip'
+#     >>> res = skullstrip.run()  # doctest: +SKIP
+# 
+#     
+task_name: SkullStrip
+nipype_name: SkullStrip
+nipype_module: nipype.interfaces.afni.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: input file to 3dSkullStrip
+    out_file: generic/file
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to 3dSkullStrip
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+    num_threads:
+    # type=int|default=1: set number of threads
+    outputtype:
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to 3dSkullStrip
+    args: '"-o_ply"'
+    # type=str|default='': Additional parameters to the command
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: 3dSkullStrip -input functional.nii -o_ply -prefix functional_skullstrip
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: input file to 3dSkullStrip
+    args: '"-o_ply"'
+    # type=str|default='': Additional parameters to the command
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-afni/skull_strip_callables.py b/example-specs/task/nipype_internal/pydra-afni/skull_strip_callables.py
new file mode 100644
index 00000000..500e8987
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/skull_strip_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in SkullStrip.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-afni/svm_test.yaml b/example-specs/task/nipype_internal/pydra-afni/svm_test.yaml
new file mode 100644
index 00000000..137a78ea
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/svm_test.yaml
@@ -0,0 +1,115 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.afni.svm.SVMTest' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Temporally predictive modeling with the support vector machine
+#     SVM Test Only
+#     For complete details, see the `3dsvm Documentation.
+#     <https://afni.nimh.nih.gov/pub/dist/doc/program_help/3dsvm.html>`_
+# 
+#     Examples
+#     ========
+# 
+#     >>> from nipype.interfaces import afni as afni
+#     >>> svmTest = afni.SVMTest()
+#     >>> svmTest.inputs.in_file= 'run2+orig'
+#     >>> svmTest.inputs.model= 'run1+orig_model'
+#     >>> svmTest.inputs.testlabels= 'run2_categories.1D'
+#     >>> svmTest.inputs.out_file= 'pred2_model1'
+#     >>> res = svmTest.run() # doctest: +SKIP
+# 
+#     
+task_name: SVMTest
+nipype_name: SVMTest
+nipype_module: nipype.interfaces.afni.svm
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: A 3D or 3D+t AFNI brik dataset to be used for testing.
+    out_file: generic/file
+    # type=file: output file
+    # type=file|default=<undefined>: filename for .1D prediction file(s).
+    testlabels: generic/file
+    # type=file|default=<undefined>: *true* class category .1D labels for the test dataset. It is used to calculate the prediction accuracy performance
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: output file
+    # type=file|default=<undefined>: filename for .1D prediction file(s).
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    model:
+    # type=str|default='': modname is the basename for the brik containing the SVM model
+    in_file:
+    # type=file|default=<undefined>: A 3D or 3D+t AFNI brik dataset to be used for testing.
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: filename for .1D prediction file(s).
+    testlabels:
+    # type=file|default=<undefined>: *true* class category .1D labels for the test dataset. It is used to calculate the prediction accuracy performance
+    classout:
+    # type=bool|default=False: Flag to specify that pname files should be integer-valued, corresponding to class category decisions.
+    nopredcensord:
+    # type=bool|default=False: Flag to prevent writing predicted values for censored time-points
+    nodetrend:
+    # type=bool|default=False: Flag to specify that pname files should not be linearly detrended
+    multiclass:
+    # type=bool|default=False: Specifies multiclass algorithm for classification
+    options:
+    # type=str|default='': additional options for SVM-light
+    num_threads:
+    # type=int|default=1: set number of threads
+    outputtype:
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-afni/svm_test_callables.py b/example-specs/task/nipype_internal/pydra-afni/svm_test_callables.py
new file mode 100644
index 00000000..5189ca36
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/svm_test_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in SVMTest.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-afni/svm_train.yaml b/example-specs/task/nipype_internal/pydra-afni/svm_train.yaml
new file mode 100644
index 00000000..316006f5
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/svm_train.yaml
@@ -0,0 +1,143 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.afni.svm.SVMTrain' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Temporally predictive modeling with the support vector machine
+#     SVM Train Only
+#     For complete details, see the `3dsvm Documentation.
+#     <https://afni.nimh.nih.gov/pub/dist/doc/program_help/3dsvm.html>`_
+# 
+#     Examples
+#     ========
+# 
+#     >>> from nipype.interfaces import afni as afni
+#     >>> svmTrain = afni.SVMTrain()
+#     >>> svmTrain.inputs.in_file = 'run1+orig'
+#     >>> svmTrain.inputs.trainlabels = 'run1_categories.1D'
+#     >>> svmTrain.inputs.ttype = 'regression'
+#     >>> svmTrain.inputs.mask = 'mask.nii'
+#     >>> svmTrain.inputs.model = 'model_run1'
+#     >>> svmTrain.inputs.alphas = 'alphas_run1'
+#     >>> res = svmTrain.run() # doctest: +SKIP
+# 
+#     
+task_name: SVMTrain
+nipype_name: SVMTrain
+nipype_module: nipype.interfaces.afni.svm
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: A 3D+t AFNI brik dataset to be used for training.
+    out_file: generic/file
+    # type=file: sum of weighted linear support vectors file name
+    # type=file|default=<undefined>: output sum of weighted linear support vectors file name
+    model: generic/file
+    # type=file: brik containing the SVM model file name
+    # type=file|default=<undefined>: basename for the brik containing the SVM model
+    alphas: generic/file
+    # type=file: output alphas file name
+    # type=file|default=<undefined>: output alphas file name
+    mask: generic/file
+    # type=file|default=<undefined>: byte-format brik file used to mask voxels in the analysis
+    trainlabels: generic/file
+    # type=file|default=<undefined>: .1D labels corresponding to the stimulus paradigm for the training data.
+    censor: generic/file
+    # type=file|default=<undefined>: .1D censor file that allows the user to ignore certain samples in the training data.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: sum of weighted linear support vectors file name
+    # type=file|default=<undefined>: output sum of weighted linear support vectors file name
+    model: generic/file
+    # type=file: brik containing the SVM model file name
+    # type=file|default=<undefined>: basename for the brik containing the SVM model
+    alphas: generic/file
+    # type=file: output alphas file name
+    # type=file|default=<undefined>: output alphas file name
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    ttype:
+    # type=str|default='': tname: classification or regression
+    in_file:
+    # type=file|default=<undefined>: A 3D+t AFNI brik dataset to be used for training.
+    out_file:
+    # type=file: sum of weighted linear support vectors file name
+    # type=file|default=<undefined>: output sum of weighted linear support vectors file name
+    model:
+    # type=file: brik containing the SVM model file name
+    # type=file|default=<undefined>: basename for the brik containing the SVM model
+    alphas:
+    # type=file: output alphas file name
+    # type=file|default=<undefined>: output alphas file name
+    mask:
+    # type=file|default=<undefined>: byte-format brik file used to mask voxels in the analysis
+    nomodelmask:
+    # type=bool|default=False: Flag to enable the omission of a mask file
+    trainlabels:
+    # type=file|default=<undefined>: .1D labels corresponding to the stimulus paradigm for the training data.
+    censor:
+    # type=file|default=<undefined>: .1D censor file that allows the user to ignore certain samples in the training data.
+    kernel:
+    # type=str|default='': string specifying type of kernel function:linear, polynomial, rbf, sigmoid
+    max_iterations:
+    # type=int|default=0: Specify the maximum number of iterations for the optimization.
+    w_out:
+    # type=bool|default=False: output sum of weighted linear support vectors
+    options:
+    # type=str|default='': additional options for SVM-light
+    num_threads:
+    # type=int|default=1: set number of threads
+    outputtype:
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-afni/svm_train_callables.py b/example-specs/task/nipype_internal/pydra-afni/svm_train_callables.py
new file mode 100644
index 00000000..d84f0913
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/svm_train_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in SVMTrain.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-afni/synthesize.yaml b/example-specs/task/nipype_internal/pydra-afni/synthesize.yaml
new file mode 100644
index 00000000..7bcb1446
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/synthesize.yaml
@@ -0,0 +1,154 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.afni.model.Synthesize' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Reads a '-cbucket' dataset and a '.xmat.1D' matrix from 3dDeconvolve,
+#        and synthesizes a fit dataset using user-selected sub-bricks and
+#        matrix columns.
+# 
+#     For complete details, see the `3dSynthesize Documentation.
+#     <https://afni.nimh.nih.gov/pub/dist/doc/program_help/3dSynthesize.html>`_
+# 
+#     Examples
+#     ========
+# 
+#     >>> from nipype.interfaces import afni
+#     >>> synthesize = afni.Synthesize()
+#     >>> synthesize.inputs.cbucket = 'functional.nii'
+#     >>> synthesize.inputs.matrix = 'output.1D'
+#     >>> synthesize.inputs.select = ['baseline']
+#     >>> synthesize.cmdline
+#     '3dSynthesize -cbucket functional.nii -matrix output.1D -select baseline'
+#     >>> syn = synthesize.run()  # doctest: +SKIP
+#     
+task_name: Synthesize
+nipype_name: Synthesize
+nipype_module: nipype.interfaces.afni.model
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    cbucket: medimage/nifti1
+    # type=file|default=<undefined>: Read the dataset output from 3dDeconvolve via the '-cbucket' option.
+    matrix: medimage-afni/oned
+    # type=file|default=<undefined>: Read the matrix output from 3dDeconvolve via the '-x1D' option.
+    out_file: generic/file
+    # type=file: output file
+    # type=file|default=<undefined>: output dataset prefix name (default 'syn')
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: output file
+    # type=file|default=<undefined>: output dataset prefix name (default 'syn')
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    cbucket:
+    # type=file|default=<undefined>: Read the dataset output from 3dDeconvolve via the '-cbucket' option.
+    matrix:
+    # type=file|default=<undefined>: Read the matrix output from 3dDeconvolve via the '-x1D' option.
+    select:
+    # type=list|default=[]: A list of selected columns from the matrix (and the corresponding coefficient sub-bricks from the cbucket). Valid types include 'baseline',  'polort', 'allfunc', 'allstim', 'all', Can also provide 'something' where something matches a stim_label from 3dDeconvolve, and 'digits' where digits are the numbers of the select matrix columns by numbers (starting at 0), or number ranges of the form '3..7' and '3-7'.
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output dataset prefix name (default 'syn')
+    dry_run:
+    # type=bool|default=False: Don't compute the output, just check the inputs.
+    TR:
+    # type=float|default=0.0: TR to set in the output.  The default value of TR is read from the header of the matrix file.
+    cenfill:
+    # type=enum|default='zero'|allowed['nbhr','none','zero']: Determines how censored time points from the 3dDeconvolve run will be filled. Valid types are 'zero', 'nbhr' and 'none'.
+    num_threads:
+    # type=int|default=1: set number of threads
+    outputtype:
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    cbucket:
+    # type=file|default=<undefined>: Read the dataset output from 3dDeconvolve via the '-cbucket' option.
+    matrix:
+    # type=file|default=<undefined>: Read the matrix output from 3dDeconvolve via the '-x1D' option.
+    select: '["baseline"]'
+    # type=list|default=[]: A list of selected columns from the matrix (and the corresponding coefficient sub-bricks from the cbucket). Valid types include 'baseline',  'polort', 'allfunc', 'allstim', 'all', Can also provide 'something' where something matches a stim_label from 3dDeconvolve, and 'digits' where digits are the numbers of the select matrix columns by numbers (starting at 0), or number ranges of the form '3..7' and '3-7'.
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: 3dSynthesize -cbucket functional.nii -matrix output.1D -select baseline
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    cbucket:
+    # type=file|default=<undefined>: Read the dataset output from 3dDeconvolve via the '-cbucket' option.
+    matrix:
+    # type=file|default=<undefined>: Read the matrix output from 3dDeconvolve via the '-x1D' option.
+    select: '["baseline"]'
+    # type=list|default=[]: A list of selected columns from the matrix (and the corresponding coefficient sub-bricks from the cbucket). Valid types include 'baseline',  'polort', 'allfunc', 'allstim', 'all', Can also provide 'something' where something matches a stim_label from 3dDeconvolve, and 'digits' where digits are the numbers of the select matrix columns by numbers (starting at 0), or number ranges of the form '3..7' and '3-7'.
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-afni/synthesize_callables.py b/example-specs/task/nipype_internal/pydra-afni/synthesize_callables.py
new file mode 100644
index 00000000..208f458b
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/synthesize_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Synthesize.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-afni/t_cat.yaml b/example-specs/task/nipype_internal/pydra-afni/t_cat.yaml
new file mode 100644
index 00000000..099585aa
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/t_cat.yaml
@@ -0,0 +1,149 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.afni.utils.TCat' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Concatenate sub-bricks from input datasets into one big 3D+time dataset.
+# 
+#     TODO Replace InputMultiPath in_files with Traits.List, if possible. Current
+#     version adds extra whitespace.
+# 
+#     For complete details, see the `3dTcat Documentation.
+#     <https://afni.nimh.nih.gov/pub/dist/doc/program_help/3dTcat.html>`_
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import afni
+#     >>> tcat = afni.TCat()
+#     >>> tcat.inputs.in_files = ['functional.nii', 'functional2.nii']
+#     >>> tcat.inputs.out_file= 'functional_tcat.nii'
+#     >>> tcat.inputs.rlt = '+'
+#     >>> tcat.cmdline
+#     '3dTcat -rlt+ -prefix functional_tcat.nii functional.nii functional2.nii'
+#     >>> res = tcat.run()  # doctest: +SKIP
+# 
+#     
+task_name: TCat
+nipype_name: TCat
+nipype_module: nipype.interfaces.afni.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_files: medimage/nifti1+list-of
+    # type=inputmultiobject|default=[]: input file to 3dTcat
+    out_file: medimage/nifti1
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: medimage/nifti1
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_files:
+    # type=inputmultiobject|default=[]: input file to 3dTcat
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+    rlt:
+    # type=enum|default=''|allowed['','+','++']: Remove linear trends in each voxel time series loaded from each input dataset, SEPARATELY. Option -rlt removes the least squares fit of 'a+b*t' to each voxel time series. Option -rlt+ adds dataset mean back in. Option -rlt++ adds overall mean of all dataset timeseries back in.
+    verbose:
+    # type=bool|default=False: Print out some verbose output as the program
+    num_threads:
+    # type=int|default=1: set number of threads
+    outputtype:
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_files:
+    # type=inputmultiobject|default=[]: input file to 3dTcat
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+    rlt: '"+"'
+    # type=enum|default=''|allowed['','+','++']: Remove linear trends in each voxel time series loaded from each input dataset, SEPARATELY. Option -rlt removes the least squares fit of 'a+b*t' to each voxel time series. Option -rlt+ adds dataset mean back in. Option -rlt++ adds overall mean of all dataset timeseries back in.
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: 3dTcat -rlt+ -prefix functional_tcat.nii functional.nii functional2.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_files:
+    # type=inputmultiobject|default=[]: input file to 3dTcat
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+    rlt: '"+"'
+    # type=enum|default=''|allowed['','+','++']: Remove linear trends in each voxel time series loaded from each input dataset, SEPARATELY. Option -rlt removes the least squares fit of 'a+b*t' to each voxel time series. Option -rlt+ adds dataset mean back in. Option -rlt++ adds overall mean of all dataset timeseries back in.
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-afni/t_cat_callables.py b/example-specs/task/nipype_internal/pydra-afni/t_cat_callables.py
new file mode 100644
index 00000000..73663106
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/t_cat_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in TCat.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-afni/t_cat_sub_brick.yaml b/example-specs/task/nipype_internal/pydra-afni/t_cat_sub_brick.yaml
new file mode 100644
index 00000000..2da55a99
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/t_cat_sub_brick.yaml
@@ -0,0 +1,143 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.afni.utils.TCatSubBrick' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Hopefully a temporary function to allow sub-brick selection until
+#     afni file management is improved.
+# 
+#     For complete details, see the `3dTcat Documentation.
+#     <https://afni.nimh.nih.gov/pub/dist/doc/program_help/3dTcat.html>`_
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import afni
+#     >>> tcsb = afni.TCatSubBrick()
+#     >>> tcsb.inputs.in_files = [('functional.nii', "'{2..$}'"), ('functional2.nii', "'{2..$}'")]
+#     >>> tcsb.inputs.out_file= 'functional_tcat.nii'
+#     >>> tcsb.inputs.rlt = '+'
+#     >>> tcsb.cmdline
+#     "3dTcat -rlt+ -prefix functional_tcat.nii functional.nii'{2..$}' functional2.nii'{2..$}' "
+#     >>> res = tcsb.run()  # doctest: +SKIP
+# 
+#     
+task_name: TCatSubBrick
+nipype_name: TCatSubBrick
+nipype_module: nipype.interfaces.afni.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: medimage/nifti1
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: '"functional_tcat.nii"'
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_files:
+    # type=list|default=[]: List of tuples of file names and subbrick selectors as strings.Don't forget to protect the single quotes in the subbrick selectorso the contents are protected from the command line interpreter.
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+    rlt:
+    # type=enum|default=''|allowed['','+','++']: Remove linear trends in each voxel time series loaded from each input dataset, SEPARATELY. Option -rlt removes the least squares fit of 'a+b*t' to each voxel time series. Option -rlt+ adds dataset mean back in. Option -rlt++ adds overall mean of all dataset timeseries back in.
+    num_threads:
+    # type=int|default=1: set number of threads
+    outputtype:
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_files: '[(''functional.nii'', "''{2..$}''"), (''functional2.nii'', "''{2..$}''")]'
+    # type=list|default=[]: List of tuples of file names and subbrick selectors as strings.Don't forget to protect the single quotes in the subbrick selectorso the contents are protected from the command line interpreter.
+    out_file: '"functional_tcat.nii"'
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+    rlt: '"+"'
+    # type=enum|default=''|allowed['','+','++']: Remove linear trends in each voxel time series loaded from each input dataset, SEPARATELY. Option -rlt removes the least squares fit of 'a+b*t' to each voxel time series. Option -rlt+ adds dataset mean back in. Option -rlt++ adds overall mean of all dataset timeseries back in.
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: '3dTcat -rlt+ -prefix functional_tcat.nii functional.nii"{2..$}" functional2.nii"{2..$}" '
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_files: '[(''functional.nii'', "''{2..$}''"), (''functional2.nii'', "''{2..$}''")]'
+    # type=list|default=[]: List of tuples of file names and subbrick selectors as strings.Don't forget to protect the single quotes in the subbrick selectorso the contents are protected from the command line interpreter.
+    out_file: '"functional_tcat.nii"'
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+    rlt: '"+"'
+    # type=enum|default=''|allowed['','+','++']: Remove linear trends in each voxel time series loaded from each input dataset, SEPARATELY. Option -rlt removes the least squares fit of 'a+b*t' to each voxel time series. Option -rlt+ adds dataset mean back in. Option -rlt++ adds overall mean of all dataset timeseries back in.
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-afni/t_cat_sub_brick_callables.py b/example-specs/task/nipype_internal/pydra-afni/t_cat_sub_brick_callables.py
new file mode 100644
index 00000000..3554ec89
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/t_cat_sub_brick_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in TCatSubBrick.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-afni/t_corr_1d.yaml b/example-specs/task/nipype_internal/pydra-afni/t_corr_1d.yaml
new file mode 100644
index 00000000..cd1c3ac8
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/t_corr_1d.yaml
@@ -0,0 +1,146 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.afni.preprocess.TCorr1D' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Computes the correlation coefficient between each voxel time series
+#     in the input 3D+time dataset.
+# 
+#     For complete details, see the `3dTcorr1D Documentation.
+#     <https://afni.nimh.nih.gov/pub/dist/doc/program_help/3dTcorr1D.html>`_
+# 
+#     >>> from nipype.interfaces import afni
+#     >>> tcorr1D = afni.TCorr1D()
+#     >>> tcorr1D.inputs.xset= 'u_rc1s1_Template.nii'
+#     >>> tcorr1D.inputs.y_1d = 'seed.1D'
+#     >>> tcorr1D.cmdline
+#     '3dTcorr1D -prefix u_rc1s1_Template_correlation.nii.gz  u_rc1s1_Template.nii  seed.1D'
+#     >>> res = tcorr1D.run()  # doctest: +SKIP
+# 
+#     
+task_name: TCorr1D
+nipype_name: TCorr1D
+nipype_module: nipype.interfaces.afni.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    xset: medimage/nifti1
+    # type=file|default=<undefined>: 3d+time dataset input
+    y_1d: medimage-afni/oned
+    # type=file|default=<undefined>: 1D time series file input
+    out_file: generic/file
+    # type=file: output file containing correlations
+    # type=file|default=<undefined>: output filename prefix
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: output file containing correlations
+    # type=file|default=<undefined>: output filename prefix
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    xset:
+    # type=file|default=<undefined>: 3d+time dataset input
+    y_1d:
+    # type=file|default=<undefined>: 1D time series file input
+    out_file:
+    # type=file: output file containing correlations
+    # type=file|default=<undefined>: output filename prefix
+    pearson:
+    # type=bool|default=False: Correlation is the normal Pearson correlation coefficient
+    spearman:
+    # type=bool|default=False: Correlation is the Spearman (rank) correlation coefficient
+    quadrant:
+    # type=bool|default=False: Correlation is the quadrant correlation coefficient
+    ktaub:
+    # type=bool|default=False: Correlation is the Kendall's tau_b correlation coefficient
+    num_threads:
+    # type=int|default=1: set number of threads
+    outputtype:
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    xset:
+    # type=file|default=<undefined>: 3d+time dataset input
+    y_1d:
+    # type=file|default=<undefined>: 1D time series file input
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: 3dTcorr1D -prefix u_rc1s1_Template_correlation.nii.gz u_rc1s1_Template.nii seed.1D
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    xset:
+    # type=file|default=<undefined>: 3d+time dataset input
+    y_1d:
+    # type=file|default=<undefined>: 1D time series file input
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-afni/t_corr_1d_callables.py b/example-specs/task/nipype_internal/pydra-afni/t_corr_1d_callables.py
new file mode 100644
index 00000000..5e0e5652
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/t_corr_1d_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in TCorr1D.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-afni/t_corr_map.yaml b/example-specs/task/nipype_internal/pydra-afni/t_corr_map.yaml
new file mode 100644
index 00000000..97b52b12
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/t_corr_map.yaml
@@ -0,0 +1,278 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.afni.preprocess.TCorrMap' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# For each voxel time series, computes the correlation between it
+#     and all other voxels, and combines this set of values into the
+#     output dataset(s) in some way.
+# 
+#     For complete details, see the `3dTcorrMap Documentation.
+#     <https://afni.nimh.nih.gov/pub/dist/doc/program_help/3dTcorrMap.html>`_
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import afni
+#     >>> tcm = afni.TCorrMap()
+#     >>> tcm.inputs.in_file = 'functional.nii'
+#     >>> tcm.inputs.mask = 'mask.nii'
+#     >>> tcm.mean_file = 'functional_meancorr.nii'
+#     >>> tcm.cmdline # doctest: +SKIP
+#     '3dTcorrMap -input functional.nii -mask mask.nii -Mean functional_meancorr.nii'
+#     >>> res = tcm.run()  # doctest: +SKIP
+# 
+#     
+task_name: TCorrMap
+nipype_name: TCorrMap
+nipype_module: nipype.interfaces.afni.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: 
+    seeds: generic/file
+    # type=file|default=<undefined>: 
+    mask: medimage/nifti1
+    # type=file|default=<undefined>: 
+    regress_out_timeseries: generic/file
+    # type=file|default=<undefined>: 
+    mean_file: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: 
+    zmean: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: 
+    qmean: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: 
+    pmean: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: 
+    absolute_threshold: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: 
+    var_absolute_threshold: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: 
+    var_absolute_threshold_normalize: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: 
+    correlation_maps: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: 
+    correlation_maps_masked: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: 
+    average_expr: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: 
+    average_expr_nonzero: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: 
+    sum_expr: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: 
+    histogram: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: 
+    out_file: generic/file
+    # type=file|default=<undefined>: output image file name
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    mean_file: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: 
+    zmean: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: 
+    qmean: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: 
+    pmean: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: 
+    absolute_threshold: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: 
+    var_absolute_threshold: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: 
+    var_absolute_threshold_normalize: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: 
+    correlation_maps: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: 
+    correlation_maps_masked: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: 
+    average_expr: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: 
+    average_expr_nonzero: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: 
+    sum_expr: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: 
+    histogram: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: 
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: 
+    seeds:
+    # type=file|default=<undefined>: 
+    mask:
+    # type=file|default=<undefined>: 
+    automask:
+    # type=bool|default=False: 
+    polort:
+    # type=int|default=0: 
+    bandpass:
+    # type=tuple|default=(<traits.trait_types.Float object at 0x11cede190>, <traits.trait_types.Float object at 0x11cede550>): 
+    regress_out_timeseries:
+    # type=file|default=<undefined>: 
+    blur_fwhm:
+    # type=float|default=0.0: 
+    seeds_width:
+    # type=float|default=0.0: 
+    mean_file:
+    # type=file: 
+    # type=file|default=<undefined>: 
+    zmean:
+    # type=file: 
+    # type=file|default=<undefined>: 
+    qmean:
+    # type=file: 
+    # type=file|default=<undefined>: 
+    pmean:
+    # type=file: 
+    # type=file|default=<undefined>: 
+    thresholds:
+    # type=list|default=[]: 
+    absolute_threshold:
+    # type=file: 
+    # type=file|default=<undefined>: 
+    var_absolute_threshold:
+    # type=file: 
+    # type=file|default=<undefined>: 
+    var_absolute_threshold_normalize:
+    # type=file: 
+    # type=file|default=<undefined>: 
+    correlation_maps:
+    # type=file: 
+    # type=file|default=<undefined>: 
+    correlation_maps_masked:
+    # type=file: 
+    # type=file|default=<undefined>: 
+    expr:
+    # type=str|default='': 
+    average_expr:
+    # type=file: 
+    # type=file|default=<undefined>: 
+    average_expr_nonzero:
+    # type=file: 
+    # type=file|default=<undefined>: 
+    sum_expr:
+    # type=file: 
+    # type=file|default=<undefined>: 
+    histogram_bin_numbers:
+    # type=int|default=0: 
+    histogram:
+    # type=file: 
+    # type=file|default=<undefined>: 
+    num_threads:
+    # type=int|default=1: set number of threads
+    outputtype:
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+    out_file:
+    # type=file|default=<undefined>: output image file name
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: 
+    mask:
+    # type=file|default=<undefined>: 
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: 3dTcorrMap -input functional.nii -mask mask.nii -Mean functional_meancorr.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: 
+    mask:
+    # type=file|default=<undefined>: 
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-afni/t_corr_map_callables.py b/example-specs/task/nipype_internal/pydra-afni/t_corr_map_callables.py
new file mode 100644
index 00000000..3e042bc6
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/t_corr_map_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in TCorrMap.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-afni/t_correlate.yaml b/example-specs/task/nipype_internal/pydra-afni/t_correlate.yaml
new file mode 100644
index 00000000..02048c01
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/t_correlate.yaml
@@ -0,0 +1,161 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.afni.preprocess.TCorrelate' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Computes the correlation coefficient between corresponding voxel
+#     time series in two input 3D+time datasets 'xset' and 'yset'
+# 
+#     For complete details, see the `3dTcorrelate Documentation.
+#     <https://afni.nimh.nih.gov/pub/dist/doc/program_help/3dTcorrelate.html>`_
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import afni
+#     >>> tcorrelate = afni.TCorrelate()
+#     >>> tcorrelate.inputs.xset= 'u_rc1s1_Template.nii'
+#     >>> tcorrelate.inputs.yset = 'u_rc1s2_Template.nii'
+#     >>> tcorrelate.inputs.out_file = 'functional_tcorrelate.nii.gz'
+#     >>> tcorrelate.inputs.polort = -1
+#     >>> tcorrelate.inputs.pearson = True
+#     >>> tcorrelate.cmdline
+#     '3dTcorrelate -prefix functional_tcorrelate.nii.gz -pearson -polort -1 u_rc1s1_Template.nii u_rc1s2_Template.nii'
+#     >>> res = tcarrelate.run()  # doctest: +SKIP
+# 
+#     
+task_name: TCorrelate
+nipype_name: TCorrelate
+nipype_module: nipype.interfaces.afni.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    xset: medimage/nifti1
+    # type=file|default=<undefined>: input xset
+    yset: medimage/nifti1
+    # type=file|default=<undefined>: input yset
+    out_file: medimage/nifti-gz
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: medimage/nifti-gz
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    xset:
+    # type=file|default=<undefined>: input xset
+    yset:
+    # type=file|default=<undefined>: input yset
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+    pearson:
+    # type=bool|default=False: Correlation is the normal Pearson correlation coefficient
+    polort:
+    # type=int|default=0: Remove polynomical trend of order m
+    num_threads:
+    # type=int|default=1: set number of threads
+    outputtype:
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    xset:
+    # type=file|default=<undefined>: input xset
+    yset:
+    # type=file|default=<undefined>: input yset
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+    polort: '-1'
+    # type=int|default=0: Remove polynomical trend of order m
+    pearson: 'True'
+    # type=bool|default=False: Correlation is the normal Pearson correlation coefficient
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: 3dTcorrelate -prefix functional_tcorrelate.nii.gz -pearson -polort -1 u_rc1s1_Template.nii u_rc1s2_Template.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    xset:
+    # type=file|default=<undefined>: input xset
+    yset:
+    # type=file|default=<undefined>: input yset
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+    polort: '-1'
+    # type=int|default=0: Remove polynomical trend of order m
+    pearson: 'True'
+    # type=bool|default=False: Correlation is the normal Pearson correlation coefficient
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-afni/t_correlate_callables.py b/example-specs/task/nipype_internal/pydra-afni/t_correlate_callables.py
new file mode 100644
index 00000000..32a0c5ef
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/t_correlate_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in TCorrelate.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-afni/t_norm.yaml b/example-specs/task/nipype_internal/pydra-afni/t_norm.yaml
new file mode 100644
index 00000000..064b244c
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/t_norm.yaml
@@ -0,0 +1,155 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.afni.preprocess.TNorm' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Shifts voxel time series from input so that separate slices are aligned
+#     to the same temporal origin.
+# 
+#     For complete details, see the `3dTnorm Documentation.
+#     <https://afni.nimh.nih.gov/pub/dist/doc/program_help/3dTnorm.html>`_
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import afni
+#     >>> tnorm = afni.TNorm()
+#     >>> tnorm.inputs.in_file = 'functional.nii'
+#     >>> tnorm.inputs.norm2 = True
+#     >>> tnorm.inputs.out_file = 'rm.errts.unit errts+tlrc'
+#     >>> tnorm.cmdline
+#     '3dTnorm -norm2 -prefix rm.errts.unit errts+tlrc functional.nii'
+#     >>> res = tshift.run()  # doctest: +SKIP
+# 
+#     
+task_name: TNorm
+nipype_name: TNorm
+nipype_module: nipype.interfaces.afni.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: input file to 3dTNorm
+    out_file: medimage-afni/unit errts+tlrc
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: medimage-afni/unit errts+tlrc
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to 3dTNorm
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+    norm2:
+    # type=bool|default=False: L2 normalize (sum of squares = 1) [DEFAULT]
+    normR:
+    # type=bool|default=False: normalize so sum of squares = number of time points \* e.g., so RMS = 1.
+    norm1:
+    # type=bool|default=False: L1 normalize (sum of absolute values = 1)
+    normx:
+    # type=bool|default=False: Scale so max absolute value = 1 (L_infinity norm)
+    polort:
+    # type=int|default=0: Detrend with polynomials of order p before normalizing [DEFAULT = don't do this]. Use '-polort 0' to remove the mean, for example
+    L1fit:
+    # type=bool|default=False: Detrend with L1 regression (L2 is the default) This option is here just for the hell of it
+    num_threads:
+    # type=int|default=1: set number of threads
+    outputtype:
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to 3dTNorm
+    norm2: 'True'
+    # type=bool|default=False: L2 normalize (sum of squares = 1) [DEFAULT]
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: 3dTnorm -norm2 -prefix rm.errts.unit errts+tlrc functional.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: input file to 3dTNorm
+    norm2: 'True'
+    # type=bool|default=False: L2 normalize (sum of squares = 1) [DEFAULT]
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-afni/t_norm_callables.py b/example-specs/task/nipype_internal/pydra-afni/t_norm_callables.py
new file mode 100644
index 00000000..83ce70d6
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/t_norm_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in TNorm.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-afni/t_project.yaml b/example-specs/task/nipype_internal/pydra-afni/t_project.yaml
new file mode 100644
index 00000000..914b1867
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/t_project.yaml
@@ -0,0 +1,202 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.afni.preprocess.TProject' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     This program projects (detrends) out various 'nuisance' time series from
+#     each voxel in the input dataset.  Note that all the projections are done
+#     via linear regression, including the frequency-based options such
+#     as ``-passband``.  In this way, you can bandpass time-censored data, and at
+#     the same time, remove other time series of no interest
+#     (e.g., physiological estimates, motion parameters).
+#     Shifts voxel time series from input so that separate slices are aligned to
+#     the same temporal origin.
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import afni
+#     >>> tproject = afni.TProject()
+#     >>> tproject.inputs.in_file = 'functional.nii'
+#     >>> tproject.inputs.bandpass = (0.00667, 99999)
+#     >>> tproject.inputs.polort = 3
+#     >>> tproject.inputs.automask = True
+#     >>> tproject.inputs.out_file = 'projected.nii.gz'
+#     >>> tproject.cmdline
+#     '3dTproject -input functional.nii -automask -bandpass 0.00667 99999 -polort 3 -prefix projected.nii.gz'
+#     >>> res = tproject.run()  # doctest: +SKIP
+# 
+#     See Also
+#     --------
+#     For complete details, see the `3dTproject Documentation.
+#     <https://afni.nimh.nih.gov/pub/dist/doc/program_help/3dTproject.html>`__
+# 
+#     
+task_name: TProject
+nipype_name: TProject
+nipype_module: nipype.interfaces.afni.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: input file to 3dTproject
+    out_file: medimage/nifti-gz
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+    censor: generic/file
+    # type=file|default=<undefined>: Filename of censor .1D time series. This is a file of 1s and 0s, indicating which time points are to be included (1) and which are to be excluded (0).
+    concat: generic/file
+    # type=file|default=<undefined>: The catenation file, as in 3dDeconvolve, containing the TR indexes of the start points for each contiguous run within the input dataset (the first entry should be 0).  * Also as in 3dDeconvolve, if the input dataset is   automatically catenated from a collection of datasets,   then the run start indexes are determined directly,   and '-concat' is not needed (and will be ignored). * Each run must have at least 9 time points AFTER   censoring, or the program will not work! * The only use made of this input is in setting up   the bandpass/stopband regressors. * '-ort' and '-dsort' regressors run through all time   points, as read in.  If you want separate projections   in each run, then you must either break these ort files   into appropriate components, OR you must run 3dTproject   for each run separately, using the appropriate pieces   from the ort files via the ``{...}`` selector for the   1D files and the ``[...]`` selector for the datasets.  
+    ort: generic/file
+    # type=file|default=<undefined>: Remove each column in file. Each column will have its mean removed.
+    dsort: generic/file+list-of
+    # type=inputmultiobject|default=[]: Remove the 3D+time time series in dataset fset.  * That is, 'fset' contains a different nuisance time   series for each voxel (e.g., from AnatICOR). * Multiple -dsort options are allowed.  
+    mask: generic/file
+    # type=file|default=<undefined>: Only operate on voxels nonzero in the mset dataset.  * Voxels outside the mask will be filled with zeros. * If no masking option is given, then all voxels   will be processed.  
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: medimage/nifti-gz
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to 3dTproject
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+    censor:
+    # type=file|default=<undefined>: Filename of censor .1D time series. This is a file of 1s and 0s, indicating which time points are to be included (1) and which are to be excluded (0).
+    censortr:
+    # type=list|default=[]: List of strings that specify time indexes to be removed from the analysis.  Each string is of one of the following forms:  * ``37`` => remove global time index #37 * ``2:37`` => remove time index #37 in run #2 * ``37..47`` => remove global time indexes #37-47 * ``37-47`` => same as above * ``2:37..47`` => remove time indexes #37-47 in run #2 * ``*:0-2`` => remove time indexes #0-2 in all runs    * Time indexes within each run start at 0.   * Run indexes start at 1 (just be to confusing).   * N.B.: 2:37,47 means index #37 in run #2 and     global time index 47; it does NOT mean     index #37 in run #2 AND index #47 in run #2.  
+    cenmode:
+    # type=enum|default='KILL'|allowed['KILL','NTRP','ZERO']: Specifies how censored time points are treated in the output dataset:  * mode = ZERO -- put zero values in their place;   output dataset is same length as input * mode = KILL -- remove those time points;   output dataset is shorter than input * mode = NTRP -- censored values are replaced by interpolated   neighboring (in time) non-censored values,   BEFORE any projections, and then the   analysis proceeds without actual removal   of any time points -- this feature is to   keep the Spanish Inquisition happy. * The default mode is KILL !!!  
+    concat:
+    # type=file|default=<undefined>: The catenation file, as in 3dDeconvolve, containing the TR indexes of the start points for each contiguous run within the input dataset (the first entry should be 0).  * Also as in 3dDeconvolve, if the input dataset is   automatically catenated from a collection of datasets,   then the run start indexes are determined directly,   and '-concat' is not needed (and will be ignored). * Each run must have at least 9 time points AFTER   censoring, or the program will not work! * The only use made of this input is in setting up   the bandpass/stopband regressors. * '-ort' and '-dsort' regressors run through all time   points, as read in.  If you want separate projections   in each run, then you must either break these ort files   into appropriate components, OR you must run 3dTproject   for each run separately, using the appropriate pieces   from the ort files via the ``{...}`` selector for the   1D files and the ``[...]`` selector for the datasets.  
+    noblock:
+    # type=bool|default=False: Also as in 3dDeconvolve, if you want the program to treat an auto-catenated dataset as one long run, use this option. However, '-noblock' will not affect catenation if you use the '-concat' option.
+    ort:
+    # type=file|default=<undefined>: Remove each column in file. Each column will have its mean removed.
+    polort:
+    # type=int|default=0: Remove polynomials up to and including degree pp.  * Default value is 2. * It makes no sense to use a value of pp greater than   2, if you are bandpassing out the lower frequencies! * For catenated datasets, each run gets a separate set   set of pp+1 Legendre polynomial regressors. * Use of -polort -1 is not advised (if data mean != 0),   even if -ort contains constant terms, as all means are   removed.  
+    dsort:
+    # type=inputmultiobject|default=[]: Remove the 3D+time time series in dataset fset.  * That is, 'fset' contains a different nuisance time   series for each voxel (e.g., from AnatICOR). * Multiple -dsort options are allowed.  
+    bandpass:
+    # type=tuple|default=(0.0, 0.0): Remove all frequencies EXCEPT those in the range
+    stopband:
+    # type=tuple|default=(0.0, 0.0): Remove all frequencies in the range
+    TR:
+    # type=float|default=0.0: Use time step dd for the frequency calculations, rather than the value stored in the dataset header.
+    mask:
+    # type=file|default=<undefined>: Only operate on voxels nonzero in the mset dataset.  * Voxels outside the mask will be filled with zeros. * If no masking option is given, then all voxels   will be processed.  
+    automask:
+    # type=bool|default=False: Generate a mask automatically
+    blur:
+    # type=float|default=0.0: Blur (inside the mask only) with a filter that has width (FWHM) of fff millimeters. Spatial blurring (if done) is after the time series filtering.
+    norm:
+    # type=bool|default=False:  Normalize each output time series to have sum of squares = 1. This is the LAST operation.
+    num_threads:
+    # type=int|default=1: set number of threads
+    outputtype:
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to 3dTproject
+    bandpass: (0.00667, 99999)
+    # type=tuple|default=(0.0, 0.0): Remove all frequencies EXCEPT those in the range
+    polort: '3'
+    # type=int|default=0: Remove polynomials up to and including degree pp.  * Default value is 2. * It makes no sense to use a value of pp greater than   2, if you are bandpassing out the lower frequencies! * For catenated datasets, each run gets a separate set   set of pp+1 Legendre polynomial regressors. * Use of -polort -1 is not advised (if data mean != 0),   even if -ort contains constant terms, as all means are   removed.  
+    automask: 'True'
+    # type=bool|default=False: Generate a mask automatically
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: 3dTproject -input functional.nii -automask -bandpass 0.00667 99999 -polort 3 -prefix projected.nii.gz
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: input file to 3dTproject
+    bandpass: (0.00667, 99999)
+    # type=tuple|default=(0.0, 0.0): Remove all frequencies EXCEPT those in the range
+    polort: '3'
+    # type=int|default=0: Remove polynomials up to and including degree pp.  * Default value is 2. * It makes no sense to use a value of pp greater than   2, if you are bandpassing out the lower frequencies! * For catenated datasets, each run gets a separate set   set of pp+1 Legendre polynomial regressors. * Use of -polort -1 is not advised (if data mean != 0),   even if -ort contains constant terms, as all means are   removed.  
+    automask: 'True'
+    # type=bool|default=False: Generate a mask automatically
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-afni/t_project_callables.py b/example-specs/task/nipype_internal/pydra-afni/t_project_callables.py
new file mode 100644
index 00000000..c6350838
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/t_project_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in TProject.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-afni/t_shift.yaml b/example-specs/task/nipype_internal/pydra-afni/t_shift.yaml
new file mode 100644
index 00000000..770d92da
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/t_shift.yaml
@@ -0,0 +1,405 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.afni.preprocess.TShift' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Shifts voxel time series from input so that separate slices are aligned
+#     to the same temporal origin.
+# 
+#     For complete details, see the `3dTshift Documentation.
+#     <https://afni.nimh.nih.gov/pub/dist/doc/program_help/3dTshift.html>`_
+# 
+#     Examples
+#     --------
+#     Slice timing details may be specified explicitly via the ``slice_timing``
+#     input:
+# 
+#     >>> from nipype.interfaces import afni
+#     >>> TR = 2.5
+#     >>> tshift = afni.TShift()
+#     >>> tshift.inputs.in_file = 'functional.nii'
+#     >>> tshift.inputs.tzero = 0.0
+#     >>> tshift.inputs.tr = '%.1fs' % TR
+#     >>> tshift.inputs.slice_timing = list(np.arange(40) / TR)
+#     >>> tshift.cmdline
+#     '3dTshift -prefix functional_tshift -tpattern @slice_timing.1D -TR 2.5s -tzero 0.0 functional.nii'
+# 
+#     When the ``slice_timing`` input is used, the ``timing_file`` output is populated,
+#     in this case with the generated file.
+# 
+#     >>> tshift._list_outputs()['timing_file']  # doctest: +ELLIPSIS
+#     '.../slice_timing.1D'
+# 
+#     >>> np.loadtxt(tshift._list_outputs()['timing_file']).tolist()[:5]
+#     [0.0, 0.4, 0.8, 1.2, 1.6]
+# 
+#     If ``slice_encoding_direction`` is set to ``'k-'``, the slice timing is reversed:
+# 
+#     >>> tshift.inputs.slice_encoding_direction = 'k-'
+#     >>> tshift.cmdline
+#     '3dTshift -prefix functional_tshift -tpattern @slice_timing.1D -TR 2.5s -tzero 0.0 functional.nii'
+#     >>> np.loadtxt(tshift._list_outputs()['timing_file']).tolist()[:5]
+#     [15.6, 15.2, 14.8, 14.4, 14.0]
+# 
+#     This method creates a ``slice_timing.1D`` file to be passed to ``3dTshift``.
+#     A pre-existing slice-timing file may be used in the same way:
+# 
+#     >>> tshift = afni.TShift()
+#     >>> tshift.inputs.in_file = 'functional.nii'
+#     >>> tshift.inputs.tzero = 0.0
+#     >>> tshift.inputs.tr = '%.1fs' % TR
+#     >>> tshift.inputs.slice_timing = 'slice_timing.1D'
+#     >>> tshift.cmdline
+#     '3dTshift -prefix functional_tshift -tpattern @slice_timing.1D -TR 2.5s -tzero 0.0 functional.nii'
+# 
+#     When a pre-existing file is provided, ``timing_file`` is simply passed through.
+# 
+#     >>> tshift._list_outputs()['timing_file']  # doctest: +ELLIPSIS
+#     '.../slice_timing.1D'
+# 
+#     Alternatively, pre-specified slice timing patterns may be specified with the
+#     ``tpattern`` input.
+#     For example, to specify an alternating, ascending slice timing pattern:
+# 
+#     >>> tshift = afni.TShift()
+#     >>> tshift.inputs.in_file = 'functional.nii'
+#     >>> tshift.inputs.tzero = 0.0
+#     >>> tshift.inputs.tr = '%.1fs' % TR
+#     >>> tshift.inputs.tpattern = 'alt+z'
+#     >>> tshift.cmdline
+#     '3dTshift -prefix functional_tshift -tpattern alt+z -TR 2.5s -tzero 0.0 functional.nii'
+# 
+#     For backwards compatibility, ``tpattern`` may also take filenames prefixed
+#     with ``@``.
+#     However, in this case, filenames are not validated, so this usage will be
+#     deprecated in future versions of Nipype.
+# 
+#     >>> tshift = afni.TShift()
+#     >>> tshift.inputs.in_file = 'functional.nii'
+#     >>> tshift.inputs.tzero = 0.0
+#     >>> tshift.inputs.tr = '%.1fs' % TR
+#     >>> tshift.inputs.tpattern = '@slice_timing.1D'
+#     >>> tshift.cmdline
+#     '3dTshift -prefix functional_tshift -tpattern @slice_timing.1D -TR 2.5s -tzero 0.0 functional.nii'
+# 
+#     In these cases, ``timing_file`` is undefined.
+# 
+#     >>> tshift._list_outputs()['timing_file']  # doctest: +ELLIPSIS
+#     <undefined>
+# 
+#     In any configuration, the interface may be run as usual:
+# 
+#     >>> res = tshift.run()  # doctest: +SKIP
+#     
+task_name: TShift
+nipype_name: TShift
+nipype_module: nipype.interfaces.afni.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: input file to 3dTshift
+    out_file: generic/file
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    timing_file: generic/file
+    # type=file: AFNI formatted timing file, if ``slice_timing`` is a list
+    out_file: generic/file
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to 3dTshift
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+    tr:
+    # type=str|default='': manually set the TR. You can attach suffix "s" for seconds or "ms" for milliseconds.
+    tzero:
+    # type=float|default=0.0: align each slice to given time offset
+    tslice:
+    # type=int|default=0: align each slice to time offset of given slice
+    ignore:
+    # type=int|default=0: ignore the first set of points specified
+    interp:
+    # type=enum|default='Fourier'|allowed['Fourier','cubic','heptic','linear','quintic']: different interpolation methods (see 3dTshift for details) default = Fourier
+    tpattern:
+    # type=traitcompound|default=None: use specified slice time pattern rather than one in header
+    slice_timing:
+    # type=traitcompound|default=None: time offsets from the volume acquisition onset for each slice
+    slice_encoding_direction:
+    # type=enum|default='k'|allowed['k','k-']: Direction in which slice_timing is specified (default: k). If negative,slice_timing is defined in reverse order, that is, the first entry corresponds to the slice with the largest index, and the final entry corresponds to slice index zero. Only in effect when slice_timing is passed as list, not when it is passed as file.
+    rlt:
+    # type=bool|default=False: Before shifting, remove the mean and linear trend
+    rltplus:
+    # type=bool|default=False: Before shifting, remove the mean and linear trend and later put back the mean
+    num_threads:
+    # type=int|default=1: set number of threads
+    outputtype:
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to 3dTshift
+    tzero: '0.0'
+    # type=float|default=0.0: align each slice to given time offset
+    tr: '"%.1fs" % TR'
+    # type=str|default='': manually set the TR. You can attach suffix "s" for seconds or "ms" for milliseconds.
+    slice_timing: list(np.arange(40) / TR)
+    # type=traitcompound|default=None: time offsets from the volume acquisition onset for each slice
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    slice_encoding_direction: '"k-"'
+    # type=enum|default='k'|allowed['k','k-']: Direction in which slice_timing is specified (default: k). If negative,slice_timing is defined in reverse order, that is, the first entry corresponds to the slice with the largest index, and the final entry corresponds to slice index zero. Only in effect when slice_timing is passed as list, not when it is passed as file.
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to 3dTshift
+    tzero: '0.0'
+    # type=float|default=0.0: align each slice to given time offset
+    tr: '"%.1fs" % TR'
+    # type=str|default='': manually set the TR. You can attach suffix "s" for seconds or "ms" for milliseconds.
+    slice_timing: '"slice_timing.1D"'
+    # type=traitcompound|default=None: time offsets from the volume acquisition onset for each slice
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to 3dTshift
+    tzero: '0.0'
+    # type=float|default=0.0: align each slice to given time offset
+    tr: '"%.1fs" % TR'
+    # type=str|default='': manually set the TR. You can attach suffix "s" for seconds or "ms" for milliseconds.
+    tpattern: '"alt+z"'
+    # type=traitcompound|default=None: use specified slice time pattern rather than one in header
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to 3dTshift
+    tzero: '0.0'
+    # type=float|default=0.0: align each slice to given time offset
+    tr: '"%.1fs" % TR'
+    # type=str|default='': manually set the TR. You can attach suffix "s" for seconds or "ms" for milliseconds.
+    tpattern: '"@slice_timing.1D"'
+    # type=traitcompound|default=None: use specified slice time pattern rather than one in header
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: 3dTshift -prefix functional_tshift -tpattern @slice_timing.1D -TR 2.5s -tzero 0.0 functional.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: input file to 3dTshift
+    tzero: '0.0'
+    # type=float|default=0.0: align each slice to given time offset
+    tr: '"%.1fs" % TR'
+    # type=str|default='': manually set the TR. You can attach suffix "s" for seconds or "ms" for milliseconds.
+    slice_timing: list(np.arange(40) / TR)
+    # type=traitcompound|default=None: time offsets from the volume acquisition onset for each slice
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: 3dTshift -prefix functional_tshift -tpattern @slice_timing.1D -TR 2.5s -tzero 0.0 functional.nii" >>> np.loadtxt(tshift._list_outputs()["timing_file
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    slice_encoding_direction: '"k-"'
+    # type=enum|default='k'|allowed['k','k-']: Direction in which slice_timing is specified (default: k). If negative,slice_timing is defined in reverse order, that is, the first entry corresponds to the slice with the largest index, and the final entry corresponds to slice index zero. Only in effect when slice_timing is passed as list, not when it is passed as file.
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: 3dTshift -prefix functional_tshift -tpattern @slice_timing.1D -TR 2.5s -tzero 0.0 functional.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: input file to 3dTshift
+    tzero: '0.0'
+    # type=float|default=0.0: align each slice to given time offset
+    tr: '"%.1fs" % TR'
+    # type=str|default='': manually set the TR. You can attach suffix "s" for seconds or "ms" for milliseconds.
+    slice_timing: '"slice_timing.1D"'
+    # type=traitcompound|default=None: time offsets from the volume acquisition onset for each slice
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: 3dTshift -prefix functional_tshift -tpattern alt+z -TR 2.5s -tzero 0.0 functional.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: input file to 3dTshift
+    tzero: '0.0'
+    # type=float|default=0.0: align each slice to given time offset
+    tr: '"%.1fs" % TR'
+    # type=str|default='': manually set the TR. You can attach suffix "s" for seconds or "ms" for milliseconds.
+    tpattern: '"alt+z"'
+    # type=traitcompound|default=None: use specified slice time pattern rather than one in header
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: 3dTshift -prefix functional_tshift -tpattern @slice_timing.1D -TR 2.5s -tzero 0.0 functional.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: input file to 3dTshift
+    tzero: '0.0'
+    # type=float|default=0.0: align each slice to given time offset
+    tr: '"%.1fs" % TR'
+    # type=str|default='': manually set the TR. You can attach suffix "s" for seconds or "ms" for milliseconds.
+    tpattern: '"@slice_timing.1D"'
+    # type=traitcompound|default=None: use specified slice time pattern rather than one in header
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-afni/t_shift_callables.py b/example-specs/task/nipype_internal/pydra-afni/t_shift_callables.py
new file mode 100644
index 00000000..0746bd0d
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/t_shift_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in TShift.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-afni/t_smooth.yaml b/example-specs/task/nipype_internal/pydra-afni/t_smooth.yaml
new file mode 100644
index 00000000..bb08492e
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/t_smooth.yaml
@@ -0,0 +1,160 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.afni.preprocess.TSmooth' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Smooths each voxel time series in a 3D+time dataset and produces
+#     as output a new 3D+time dataset (e.g., lowpass filter in time).
+# 
+#     For complete details, see the `3dTsmooth Documentation.
+#     <https://afni.nimh.nih.gov/pub/dist/doc/program_help/3dTSmooth.html>`_
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import afni
+#     >>> from nipype.testing import  example_data
+#     >>> smooth = afni.TSmooth()
+#     >>> smooth.inputs.in_file = 'functional.nii'
+#     >>> smooth.inputs.adaptive = 5
+#     >>> smooth.cmdline
+#     '3dTsmooth -adaptive 5 -prefix functional_smooth functional.nii'
+#     >>> res = smooth.run()  # doctest: +SKIP
+# 
+#     
+task_name: TSmooth
+nipype_name: TSmooth
+nipype_module: nipype.interfaces.afni.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: input file to 3dTSmooth
+    out_file: generic/file
+    # type=file: output file
+    # type=file|default=<undefined>: output file from 3dTSmooth
+    custom: generic/file
+    # type=file|default=<undefined>: odd # of coefficients must be in a single column in ASCII file
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: output file
+    # type=file|default=<undefined>: output file from 3dTSmooth
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to 3dTSmooth
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output file from 3dTSmooth
+    datum:
+    # type=str|default='': Sets the data type of the output dataset
+    lin:
+    # type=bool|default=False: 3 point linear filter: :math:`0.15\,a + 0.70\,b + 0.15\,c` [This is the default smoother]
+    med:
+    # type=bool|default=False: 3 point median filter: median(a,b,c)
+    osf:
+    # type=bool|default=False: 3 point order statistics filter::math:`0.15\,min(a,b,c) + 0.70\,median(a,b,c) + 0.15\,max(a,b,c)`
+    lin3:
+    # type=int|default=0: 3 point linear filter: :math:`0.5\,(1-m)\,a + m\,b + 0.5\,(1-m)\,c`. Here, 'm' is a number strictly between 0 and 1.
+    hamming:
+    # type=int|default=0: Use N point Hamming windows. (N must be odd and bigger than 1.)
+    blackman:
+    # type=int|default=0: Use N point Blackman windows. (N must be odd and bigger than 1.)
+    custom:
+    # type=file|default=<undefined>: odd # of coefficients must be in a single column in ASCII file
+    adaptive:
+    # type=int|default=0: use adaptive mean filtering of width N (where N must be odd and bigger than 3).
+    num_threads:
+    # type=int|default=1: set number of threads
+    outputtype:
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to 3dTSmooth
+    adaptive: '5'
+    # type=int|default=0: use adaptive mean filtering of width N (where N must be odd and bigger than 3).
+  imports: &id001
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  - module: nipype.testing
+    name: ' example_data'
+    alias:
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: 3dTsmooth -adaptive 5 -prefix functional_smooth functional.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: input file to 3dTSmooth
+    adaptive: '5'
+    # type=int|default=0: use adaptive mean filtering of width N (where N must be odd and bigger than 3).
+  imports: *id001
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-afni/t_smooth_callables.py b/example-specs/task/nipype_internal/pydra-afni/t_smooth_callables.py
new file mode 100644
index 00000000..25307116
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/t_smooth_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in TSmooth.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-afni/t_stat.yaml b/example-specs/task/nipype_internal/pydra-afni/t_stat.yaml
new file mode 100644
index 00000000..37792a7a
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/t_stat.yaml
@@ -0,0 +1,148 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.afni.utils.TStat' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Compute voxel-wise statistics using AFNI 3dTstat command
+# 
+#     For complete details, see the `3dTstat Documentation.
+#     <https://afni.nimh.nih.gov/pub/dist/doc/program_help/3dTstat.html>`_
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import afni
+#     >>> tstat = afni.TStat()
+#     >>> tstat.inputs.in_file = 'functional.nii'
+#     >>> tstat.inputs.args = '-mean'
+#     >>> tstat.inputs.out_file = 'stats'
+#     >>> tstat.cmdline
+#     '3dTstat -mean -prefix stats functional.nii'
+#     >>> res = tstat.run()  # doctest: +SKIP
+# 
+#     
+task_name: TStat
+nipype_name: TStat
+nipype_module: nipype.interfaces.afni.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: input file to 3dTstat
+    out_file: generic/file
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+    mask: generic/file
+    # type=file|default=<undefined>: mask file
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to 3dTstat
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+    mask:
+    # type=file|default=<undefined>: mask file
+    options:
+    # type=str|default='': selected statistical output
+    num_threads:
+    # type=int|default=1: set number of threads
+    outputtype:
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to 3dTstat
+    args: '"-mean"'
+    # type=str|default='': Additional parameters to the command
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: 3dTstat -mean -prefix stats functional.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: input file to 3dTstat
+    args: '"-mean"'
+    # type=str|default='': Additional parameters to the command
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-afni/t_stat_callables.py b/example-specs/task/nipype_internal/pydra-afni/t_stat_callables.py
new file mode 100644
index 00000000..dde13485
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/t_stat_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in TStat.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-afni/to_3d.yaml b/example-specs/task/nipype_internal/pydra-afni/to_3d.yaml
new file mode 100644
index 00000000..ce14d135
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/to_3d.yaml
@@ -0,0 +1,157 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.afni.utils.To3D' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Create a 3D dataset from 2D image files using AFNI to3d command
+# 
+#     For complete details, see the `to3d Documentation
+#     <https://afni.nimh.nih.gov/pub/dist/doc/program_help/to3d.html>`_
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import afni
+#     >>> to3d = afni.To3D()
+#     >>> to3d.inputs.datatype = 'float'
+#     >>> to3d.inputs.in_folder = '.'
+#     >>> to3d.inputs.out_file = 'dicomdir.nii'
+#     >>> to3d.inputs.filetype = 'anat'
+#     >>> to3d.cmdline  # doctest: +ELLIPSIS
+#     'to3d -datum float -anat -prefix dicomdir.nii ./*.dcm'
+#     >>> res = to3d.run()  # doctest: +SKIP
+# 
+#     
+task_name: To3D
+nipype_name: To3D
+nipype_module: nipype.interfaces.afni.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: medimage/nifti1
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+    in_folder: generic/directory
+    # type=directory|default=<undefined>: folder with DICOM images to convert
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: medimage/nifti1
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+    in_folder:
+    # type=directory|default=<undefined>: folder with DICOM images to convert
+    filetype:
+    # type=enum|default='spgr'|allowed['abuc','anat','bmap','ct','diff','epan','fbuc','fibn','fibt','fico','fict','fift','figt','fim','fipt','fith','fitt','fizt','fse','mra','omri','pet','spct','spgr']: type of datafile being converted
+    skipoutliers:
+    # type=bool|default=False: skip the outliers check
+    assumemosaic:
+    # type=bool|default=False: assume that Siemens image is mosaic
+    datatype:
+    # type=enum|default='short'|allowed['byte','complex','float','short']: set output file datatype
+    funcparams:
+    # type=str|default='': parameters for functional data
+    num_threads:
+    # type=int|default=1: set number of threads
+    outputtype:
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    datatype: '"float"'
+    # type=enum|default='short'|allowed['byte','complex','float','short']: set output file datatype
+    in_folder: '"."'
+    # type=directory|default=<undefined>: folder with DICOM images to convert
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+    filetype: '"anat"'
+    # type=enum|default='spgr'|allowed['abuc','anat','bmap','ct','diff','epan','fbuc','fibn','fibt','fico','fict','fift','figt','fim','fipt','fith','fitt','fizt','fse','mra','omri','pet','spct','spgr']: type of datafile being converted
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: to3d -datum float -anat -prefix dicomdir.nii ./*.dcm
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    datatype: '"float"'
+    # type=enum|default='short'|allowed['byte','complex','float','short']: set output file datatype
+    in_folder: '"."'
+    # type=directory|default=<undefined>: folder with DICOM images to convert
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+    filetype: '"anat"'
+    # type=enum|default='spgr'|allowed['abuc','anat','bmap','ct','diff','epan','fbuc','fibn','fibt','fico','fict','fift','figt','fim','fipt','fith','fitt','fizt','fse','mra','omri','pet','spct','spgr']: type of datafile being converted
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-afni/to_3d_callables.py b/example-specs/task/nipype_internal/pydra-afni/to_3d_callables.py
new file mode 100644
index 00000000..bf28f929
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/to_3d_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in To3D.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-afni/undump.yaml b/example-specs/task/nipype_internal/pydra-afni/undump.yaml
new file mode 100644
index 00000000..d6e13819
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/undump.yaml
@@ -0,0 +1,173 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.afni.utils.Undump' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 3dUndump - Assembles a 3D dataset from an ASCII list of coordinates and
+#     (optionally) values.
+# 
+#      The input file(s) are ASCII files, with one voxel specification per
+#      line.  A voxel specification is 3 numbers (-ijk or -xyz coordinates),
+#      with an optional 4th number giving the voxel value.  For example:
+# 
+#      1 2 3
+#      3 2 1 5
+#      5.3 6.2 3.7
+#      // this line illustrates a comment
+# 
+#      The first line puts a voxel (with value given by '-dval') at point
+#      (1,2,3).  The second line puts a voxel (with value 5) at point (3,2,1).
+#      The third line puts a voxel (with value given by '-dval') at point
+#      (5.3,6.2,3.7).  If -ijk is in effect, and fractional coordinates
+#      are given, they will be rounded to the nearest integers; for example,
+#      the third line would be equivalent to (i,j,k) = (5,6,4).
+# 
+# 
+#     For complete details, see the `3dUndump Documentation.
+#     <https://afni.nimh.nih.gov/pub/dist/doc/program_help/3dUndump.html>`_
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import afni
+#     >>> unndump = afni.Undump()
+#     >>> unndump.inputs.in_file = 'structural.nii'
+#     >>> unndump.inputs.out_file = 'structural_undumped.nii'
+#     >>> unndump.cmdline
+#     '3dUndump -prefix structural_undumped.nii -master structural.nii'
+#     >>> res = unndump.run()  # doctest: +SKIP
+# 
+#     
+task_name: Undump
+nipype_name: Undump
+nipype_module: nipype.interfaces.afni.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: input file to 3dUndump, whose geometry will determinethe geometry of the output
+    out_file: medimage/nifti1
+    # type=file: assembled file
+    # type=file|default=<undefined>: output image file name
+    mask_file: generic/file
+    # type=file|default=<undefined>: mask image file name. Only voxels that are nonzero in the mask can be set.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: medimage/nifti1
+    # type=file: assembled file
+    # type=file|default=<undefined>: output image file name
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to 3dUndump, whose geometry will determinethe geometry of the output
+    out_file:
+    # type=file: assembled file
+    # type=file|default=<undefined>: output image file name
+    mask_file:
+    # type=file|default=<undefined>: mask image file name. Only voxels that are nonzero in the mask can be set.
+    datatype:
+    # type=enum|default='short'|allowed['byte','float','short']: set output file datatype
+    default_value:
+    # type=float|default=0.0: default value stored in each input voxel that does not have a value supplied in the input file
+    fill_value:
+    # type=float|default=0.0: value, used for each voxel in the output dataset that is NOT listed in the input file
+    coordinates_specification:
+    # type=enum|default='ijk'|allowed['ijk','xyz']: Coordinates in the input file as index triples (i, j, k) or spatial coordinates (x, y, z) in mm
+    srad:
+    # type=float|default=0.0: radius in mm of the sphere that will be filled about each input (x,y,z) or (i,j,k) voxel. If the radius is not given, or is 0, then each input data line sets the value in only one voxel.
+    orient:
+    # type=tuple|default=('R', 'A', 'I'): Specifies the coordinate order used by -xyz. The code must be 3 letters, one each from the pairs {R,L} {A,P} {I,S}.  The first letter gives the orientation of the x-axis, the second the orientation of the y-axis, the third the z-axis: R = right-to-left         L = left-to-right A = anterior-to-posterior P = posterior-to-anterior I = inferior-to-superior  S = superior-to-inferior If -orient isn't used, then the coordinate order of the -master (in_file) dataset is used to interpret (x,y,z) inputs.
+    head_only:
+    # type=bool|default=False: create only the .HEAD file which gets exploited by the AFNI matlab library function New_HEAD.m
+    num_threads:
+    # type=int|default=1: set number of threads
+    outputtype:
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to 3dUndump, whose geometry will determinethe geometry of the output
+    out_file:
+    # type=file: assembled file
+    # type=file|default=<undefined>: output image file name
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: 3dUndump -prefix structural_undumped.nii -master structural.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: input file to 3dUndump, whose geometry will determinethe geometry of the output
+    out_file:
+    # type=file: assembled file
+    # type=file|default=<undefined>: output image file name
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-afni/undump_callables.py b/example-specs/task/nipype_internal/pydra-afni/undump_callables.py
new file mode 100644
index 00000000..22257d09
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/undump_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Undump.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-afni/unifize.yaml b/example-specs/task/nipype_internal/pydra-afni/unifize.yaml
new file mode 100644
index 00000000..afe444b7
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/unifize.yaml
@@ -0,0 +1,189 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.afni.utils.Unifize' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 3dUnifize - for uniformizing image intensity
+# 
+#     * The input dataset is supposed to be a T1-weighted volume,
+#       possibly already skull-stripped (e.g., via 3dSkullStrip).
+#       However, this program can be a useful step to take BEFORE
+#       3dSkullStrip, since the latter program can fail if the input
+#       volume is strongly shaded -- 3dUnifize will (mostly) remove
+#       such shading artifacts.
+# 
+#     * The output dataset has the white matter (WM) intensity approximately
+#       uniformized across space, and scaled to peak at about 1000.
+# 
+#     * The output dataset is always stored in float format!
+# 
+#     * If the input dataset has more than 1 sub-brick, only sub-brick
+#       #0 will be processed!
+# 
+#     * Want to correct EPI datasets for nonuniformity?
+#       You can try the new and experimental [Mar 2017] '-EPI' option.
+# 
+#     * The principal motive for this program is for use in an image
+#       registration script, and it may or may not be useful otherwise.
+# 
+#     * This program replaces the older (and very different) 3dUniformize,
+#       which is no longer maintained and may sublimate at any moment.
+#       (In other words, we do not recommend the use of 3dUniformize.)
+# 
+#     For complete details, see the `3dUnifize Documentation.
+#     <https://afni.nimh.nih.gov/pub/dist/doc/program_help/3dUnifize.html>`_
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import afni
+#     >>> unifize = afni.Unifize()
+#     >>> unifize.inputs.in_file = 'structural.nii'
+#     >>> unifize.inputs.out_file = 'structural_unifized.nii'
+#     >>> unifize.cmdline
+#     '3dUnifize -prefix structural_unifized.nii -input structural.nii'
+#     >>> res = unifize.run()  # doctest: +SKIP
+# 
+#     
+task_name: Unifize
+nipype_name: Unifize
+nipype_module: nipype.interfaces.afni.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: input file to 3dUnifize
+    out_file: medimage/nifti1
+    # type=file: unifized file
+    # type=file|default=<undefined>: output image file name
+    scale_file: generic/file
+    # type=file: scale factor file
+    # type=file|default=<undefined>: output file name to save the scale factor used at each voxel 
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    scale_file: generic/file
+    # type=file: scale factor file
+    # type=file|default=<undefined>: output file name to save the scale factor used at each voxel 
+    out_file: medimage/nifti1
+    # type=file: unifized file
+    # type=file|default=<undefined>: output image file name
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to 3dUnifize
+    out_file:
+    # type=file: unifized file
+    # type=file|default=<undefined>: output image file name
+    t2:
+    # type=bool|default=False: Treat the input as if it were T2-weighted, rather than T1-weighted. This processing is done simply by inverting the image contrast, processing it as if that result were T1-weighted, and then re-inverting the results counts of voxel overlap, i.e., each voxel will contain the number of masks that it is set in.
+    gm:
+    # type=bool|default=False: Also scale to unifize 'gray matter' = lower intensity voxels (to aid in registering images from different scanners).
+    urad:
+    # type=float|default=0.0: Sets the radius (in voxels) of the ball used for the sneaky trick. Default value is 18.3, and should be changed proportionally if the dataset voxel size differs significantly from 1 mm.
+    scale_file:
+    # type=file: scale factor file
+    # type=file|default=<undefined>: output file name to save the scale factor used at each voxel 
+    no_duplo:
+    # type=bool|default=False: Do NOT use the 'duplo down' step; this can be useful for lower resolution datasets.
+    epi:
+    # type=bool|default=False: Assume the input dataset is a T2 (or T2\*) weighted EPI time series. After computing the scaling, apply it to ALL volumes (TRs) in the input dataset. That is, a given voxel will be scaled by the same factor at each TR. This option also implies '-noduplo' and '-T2'.This option turns off '-GM' if you turned it on.
+    rbt:
+    # type=tuple|default=(0.0, 0.0, 0.0): Option for AFNI experts only.Specify the 3 parameters for the algorithm: R = radius; same as given by option '-Urad', [default=18.3] b = bottom percentile of normalizing data range, [default=70.0] r = top percentile of normalizing data range, [default=80.0] 
+    t2_up:
+    # type=float|default=0.0: Option for AFNI experts only.Set the upper percentile point used for T2-T1 inversion. Allowed to be anything between 90 and 100 (inclusive), with default to 98.5  (for no good reason).
+    cl_frac:
+    # type=float|default=0.0: Option for AFNI experts only.Set the automask 'clip level fraction'. Must be between 0.1 and 0.9. A small fraction means to make the initial threshold for clipping (a la 3dClipLevel) smaller, which will tend to make the mask larger.  [default=0.1]
+    quiet:
+    # type=bool|default=False: Don't print the progress messages.
+    num_threads:
+    # type=int|default=1: set number of threads
+    outputtype:
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to 3dUnifize
+    out_file:
+    # type=file: unifized file
+    # type=file|default=<undefined>: output image file name
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: 3dUnifize -prefix structural_unifized.nii -input structural.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: input file to 3dUnifize
+    out_file:
+    # type=file: unifized file
+    # type=file|default=<undefined>: output image file name
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-afni/unifize_callables.py b/example-specs/task/nipype_internal/pydra-afni/unifize_callables.py
new file mode 100644
index 00000000..0e048ad5
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/unifize_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Unifize.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-afni/volreg.yaml b/example-specs/task/nipype_internal/pydra-afni/volreg.yaml
new file mode 100644
index 00000000..9c419c08
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/volreg.yaml
@@ -0,0 +1,269 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.afni.preprocess.Volreg' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Register input volumes to a base volume using AFNI 3dvolreg command
+# 
+#     For complete details, see the `3dvolreg Documentation.
+#     <https://afni.nimh.nih.gov/pub/dist/doc/program_help/3dvolreg.html>`_
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import afni
+#     >>> volreg = afni.Volreg()
+#     >>> volreg.inputs.in_file = 'functional.nii'
+#     >>> volreg.inputs.args = '-Fourier -twopass'
+#     >>> volreg.inputs.zpad = 4
+#     >>> volreg.inputs.outputtype = 'NIFTI'
+#     >>> volreg.cmdline  # doctest: +ELLIPSIS
+#     '3dvolreg -Fourier -twopass -1Dfile functional.1D -1Dmatrix_save functional.aff12.1D -prefix functional_volreg.nii -zpad 4 -maxdisp1D functional_md.1D functional.nii'
+#     >>> res = volreg.run()  # doctest: +SKIP
+# 
+#     >>> from nipype.interfaces import afni
+#     >>> volreg = afni.Volreg()
+#     >>> volreg.inputs.in_file = 'functional.nii'
+#     >>> volreg.inputs.interp = 'cubic'
+#     >>> volreg.inputs.verbose = True
+#     >>> volreg.inputs.zpad = 1
+#     >>> volreg.inputs.basefile = 'functional.nii'
+#     >>> volreg.inputs.out_file = 'rm.epi.volreg.r1'
+#     >>> volreg.inputs.oned_file = 'dfile.r1.1D'
+#     >>> volreg.inputs.oned_matrix_save = 'mat.r1.tshift+orig.1D'
+#     >>> volreg.cmdline
+#     '3dvolreg -cubic -1Dfile dfile.r1.1D -1Dmatrix_save mat.r1.tshift+orig.1D -prefix rm.epi.volreg.r1 -verbose -base functional.nii -zpad 1 -maxdisp1D functional_md.1D functional.nii'
+#     >>> res = volreg.run()  # doctest: +SKIP
+# 
+#     
+task_name: Volreg
+nipype_name: Volreg
+nipype_module: nipype.interfaces.afni.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: input file to 3dvolreg
+    out_file: medimage-afni/r1
+    # type=file: registered file
+    # type=file|default=<undefined>: output image file name
+    basefile: medimage/nifti1
+    # type=file|default=<undefined>: base file for registration
+    md1d_file: generic/file
+    # type=file: max displacement info file
+    # type=file|default=<undefined>: max displacement output file
+    oned_file: medimage-afni/oned
+    # type=file: movement parameters info file
+    # type=file|default=<undefined>: 1D movement parameters output file
+    oned_matrix_save: medimage-afni/oned
+    # type=file: matrix transformation from base to input
+    # type=file|default=<undefined>: Save the matrix transformation
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: medimage-afni/r1
+    # type=file: registered file
+    # type=file|default=<undefined>: output image file name
+    md1d_file: generic/file
+    # type=file: max displacement info file
+    # type=file|default=<undefined>: max displacement output file
+    oned_file: medimage-afni/oned
+    # type=file: movement parameters info file
+    # type=file|default=<undefined>: 1D movement parameters output file
+    oned_matrix_save: medimage-afni/oned
+    # type=file: matrix transformation from base to input
+    # type=file|default=<undefined>: Save the matrix transformation
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to 3dvolreg
+    in_weight_volume:
+    # type=traitcompound|default=None: weights for each voxel specified by a file with an optional volume number (defaults to 0)
+    out_file:
+    # type=file: registered file
+    # type=file|default=<undefined>: output image file name
+    basefile:
+    # type=file|default=<undefined>: base file for registration
+    zpad:
+    # type=int|default=0: Zeropad around the edges by 'n' voxels during rotations
+    md1d_file:
+    # type=file: max displacement info file
+    # type=file|default=<undefined>: max displacement output file
+    oned_file:
+    # type=file: movement parameters info file
+    # type=file|default=<undefined>: 1D movement parameters output file
+    verbose:
+    # type=bool|default=False: more detailed description of the process
+    timeshift:
+    # type=bool|default=False: time shift to mean slice time offset
+    copyorigin:
+    # type=bool|default=False: copy base file origin coords to output
+    oned_matrix_save:
+    # type=file: matrix transformation from base to input
+    # type=file|default=<undefined>: Save the matrix transformation
+    interp:
+    # type=enum|default='Fourier'|allowed['Fourier','cubic','heptic','linear','quintic']: spatial interpolation methods [default = heptic]
+    num_threads:
+    # type=int|default=1: set number of threads
+    outputtype:
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to 3dvolreg
+    args: '"-Fourier -twopass"'
+    # type=str|default='': Additional parameters to the command
+    zpad: '4'
+    # type=int|default=0: Zeropad around the edges by 'n' voxels during rotations
+    outputtype: '"NIFTI"'
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to 3dvolreg
+    interp: '"cubic"'
+    # type=enum|default='Fourier'|allowed['Fourier','cubic','heptic','linear','quintic']: spatial interpolation methods [default = heptic]
+    verbose: 'True'
+    # type=bool|default=False: more detailed description of the process
+    zpad: '1'
+    # type=int|default=0: Zeropad around the edges by 'n' voxels during rotations
+    basefile:
+    # type=file|default=<undefined>: base file for registration
+    out_file:
+    # type=file: registered file
+    # type=file|default=<undefined>: output image file name
+    oned_file:
+    # type=file: movement parameters info file
+    # type=file|default=<undefined>: 1D movement parameters output file
+    oned_matrix_save:
+    # type=file: matrix transformation from base to input
+    # type=file|default=<undefined>: Save the matrix transformation
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: 3dvolreg -Fourier -twopass -1Dfile functional.1D -1Dmatrix_save functional.aff12.1D -prefix functional_volreg.nii -zpad 4 -maxdisp1D functional_md.1D functional.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: input file to 3dvolreg
+    args: '"-Fourier -twopass"'
+    # type=str|default='': Additional parameters to the command
+    zpad: '4'
+    # type=int|default=0: Zeropad around the edges by 'n' voxels during rotations
+    outputtype: '"NIFTI"'
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: 3dvolreg -cubic -1Dfile dfile.r1.1D -1Dmatrix_save mat.r1.tshift+orig.1D -prefix rm.epi.volreg.r1 -verbose -base functional.nii -zpad 1 -maxdisp1D functional_md.1D functional.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: input file to 3dvolreg
+    interp: '"cubic"'
+    # type=enum|default='Fourier'|allowed['Fourier','cubic','heptic','linear','quintic']: spatial interpolation methods [default = heptic]
+    verbose: 'True'
+    # type=bool|default=False: more detailed description of the process
+    zpad: '1'
+    # type=int|default=0: Zeropad around the edges by 'n' voxels during rotations
+    basefile:
+    # type=file|default=<undefined>: base file for registration
+    out_file:
+    # type=file: registered file
+    # type=file|default=<undefined>: output image file name
+    oned_file:
+    # type=file: movement parameters info file
+    # type=file|default=<undefined>: 1D movement parameters output file
+    oned_matrix_save:
+    # type=file: matrix transformation from base to input
+    # type=file|default=<undefined>: Save the matrix transformation
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-afni/volreg_callables.py b/example-specs/task/nipype_internal/pydra-afni/volreg_callables.py
new file mode 100644
index 00000000..48ce6b3d
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/volreg_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Volreg.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-afni/warp.yaml b/example-specs/task/nipype_internal/pydra-afni/warp.yaml
new file mode 100644
index 00000000..b4233a2f
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/warp.yaml
@@ -0,0 +1,225 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.afni.preprocess.Warp' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Use 3dWarp for spatially transforming a dataset.
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import afni
+#     >>> warp = afni.Warp()
+#     >>> warp.inputs.in_file = 'structural.nii'
+#     >>> warp.inputs.deoblique = True
+#     >>> warp.inputs.out_file = 'trans.nii.gz'
+#     >>> warp.cmdline
+#     '3dWarp -deoblique -prefix trans.nii.gz structural.nii'
+#     >>> res = warp.run()  # doctest: +SKIP
+# 
+#     >>> warp_2 = afni.Warp()
+#     >>> warp_2.inputs.in_file = 'structural.nii'
+#     >>> warp_2.inputs.newgrid = 1.0
+#     >>> warp_2.inputs.out_file = 'trans.nii.gz'
+#     >>> warp_2.cmdline
+#     '3dWarp -newgrid 1.000000 -prefix trans.nii.gz structural.nii'
+#     >>> res = warp_2.run()  # doctest: +SKIP
+# 
+#     See Also
+#     --------
+#     For complete details, see the `3dWarp Documentation.
+#     <https://afni.nimh.nih.gov/pub/dist/doc/program_help/3dWarp.html>`__.
+# 
+#     
+task_name: Warp
+nipype_name: Warp
+nipype_module: nipype.interfaces.afni.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: input file to 3dWarp
+    out_file: medimage/nifti-gz
+    # type=file: Warped file.
+    # type=file|default=<undefined>: output image file name
+    matparent: generic/file
+    # type=file|default=<undefined>: apply transformation from 3dWarpDrive
+    oblique_parent: generic/file
+    # type=file|default=<undefined>: Read in the oblique transformation matrix from an oblique dataset and make cardinal dataset oblique to match
+    gridset: generic/file
+    # type=file|default=<undefined>: copy grid of specified dataset
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: medimage/nifti-gz
+    # type=file: Warped file.
+    # type=file|default=<undefined>: output image file name
+    warp_file: generic/file
+    # type=file: warp transform .mat file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to 3dWarp
+    out_file:
+    # type=file: Warped file.
+    # type=file|default=<undefined>: output image file name
+    tta2mni:
+    # type=bool|default=False: transform dataset from Talairach to MNI152
+    mni2tta:
+    # type=bool|default=False: transform dataset from MNI152 to Talaraich
+    matparent:
+    # type=file|default=<undefined>: apply transformation from 3dWarpDrive
+    oblique_parent:
+    # type=file|default=<undefined>: Read in the oblique transformation matrix from an oblique dataset and make cardinal dataset oblique to match
+    deoblique:
+    # type=bool|default=False: transform dataset from oblique to cardinal
+    interp:
+    # type=enum|default='linear'|allowed['NN','cubic','linear','quintic']: spatial interpolation methods [default = linear]
+    gridset:
+    # type=file|default=<undefined>: copy grid of specified dataset
+    newgrid:
+    # type=float|default=0.0: specify grid of this size (mm)
+    zpad:
+    # type=int|default=0: pad input dataset with N planes of zero on all sides.
+    verbose:
+    # type=bool|default=False: Print out some information along the way.
+    save_warp:
+    # type=bool|default=False: save warp as .mat file
+    num_threads:
+    # type=int|default=1: set number of threads
+    outputtype:
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to 3dWarp
+    deoblique: 'True'
+    # type=bool|default=False: transform dataset from oblique to cardinal
+    out_file:
+    # type=file: Warped file.
+    # type=file|default=<undefined>: output image file name
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to 3dWarp
+    newgrid: '1.0'
+    # type=float|default=0.0: specify grid of this size (mm)
+    out_file:
+    # type=file: Warped file.
+    # type=file|default=<undefined>: output image file name
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: 3dWarp -deoblique -prefix trans.nii.gz structural.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: input file to 3dWarp
+    deoblique: 'True'
+    # type=bool|default=False: transform dataset from oblique to cardinal
+    out_file:
+    # type=file: Warped file.
+    # type=file|default=<undefined>: output image file name
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: 3dWarp -newgrid 1.000000 -prefix trans.nii.gz structural.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: input file to 3dWarp
+    newgrid: '1.0'
+    # type=float|default=0.0: specify grid of this size (mm)
+    out_file:
+    # type=file: Warped file.
+    # type=file|default=<undefined>: output image file name
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-afni/warp_callables.py b/example-specs/task/nipype_internal/pydra-afni/warp_callables.py
new file mode 100644
index 00000000..8001b9c4
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/warp_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Warp.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-afni/z_cut_up.yaml b/example-specs/task/nipype_internal/pydra-afni/z_cut_up.yaml
new file mode 100644
index 00000000..f2b70681
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/z_cut_up.yaml
@@ -0,0 +1,144 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.afni.utils.ZCutUp' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Cut z-slices from a volume using AFNI 3dZcutup command
+# 
+#     For complete details, see the `3dZcutup Documentation.
+#     <https://afni.nimh.nih.gov/pub/dist/doc/program_help/3dZcutup.html>`_
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import afni
+#     >>> zcutup = afni.ZCutUp()
+#     >>> zcutup.inputs.in_file = 'functional.nii'
+#     >>> zcutup.inputs.out_file = 'functional_zcutup.nii'
+#     >>> zcutup.inputs.keep= '0 10'
+#     >>> zcutup.cmdline
+#     '3dZcutup -keep 0 10 -prefix functional_zcutup.nii functional.nii'
+#     >>> res = zcutup.run()  # doctest: +SKIP
+# 
+#     
+task_name: ZCutUp
+nipype_name: ZCutUp
+nipype_module: nipype.interfaces.afni.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: input file to 3dZcutup
+    out_file: medimage/nifti1
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: medimage/nifti1
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to 3dZcutup
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+    keep:
+    # type=str|default='': slice range to keep in output
+    num_threads:
+    # type=int|default=1: set number of threads
+    outputtype:
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to 3dZcutup
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+    keep: '"0 10"'
+    # type=str|default='': slice range to keep in output
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: 3dZcutup -keep 0 10 -prefix functional_zcutup.nii functional.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: input file to 3dZcutup
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
+    keep: '"0 10"'
+    # type=str|default='': slice range to keep in output
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-afni/z_cut_up_callables.py b/example-specs/task/nipype_internal/pydra-afni/z_cut_up_callables.py
new file mode 100644
index 00000000..970f55ba
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/z_cut_up_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in ZCutUp.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-afni/zcat.yaml b/example-specs/task/nipype_internal/pydra-afni/zcat.yaml
new file mode 100644
index 00000000..b2e87a0c
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/zcat.yaml
@@ -0,0 +1,146 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.afni.utils.Zcat' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Copies an image of one type to an image of the same
+#     or different type using 3dZcat command
+# 
+#     For complete details, see the `3dZcat Documentation.
+#     <https://afni.nimh.nih.gov/pub/dist/doc/program_help/3dZcat.html>`_
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import afni
+#     >>> zcat = afni.Zcat()
+#     >>> zcat.inputs.in_files = ['functional2.nii', 'functional3.nii']
+#     >>> zcat.inputs.out_file = 'cat_functional.nii'
+#     >>> zcat.cmdline
+#     '3dZcat -prefix cat_functional.nii functional2.nii functional3.nii'
+#     >>> res = zcat.run()  # doctest: +SKIP
+# 
+#     
+task_name: Zcat
+nipype_name: Zcat
+nipype_module: nipype.interfaces.afni.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_files: medimage/nifti1+list-of
+    # type=inputmultiobject|default=[]: 
+    out_file: medimage/nifti1
+    # type=file: output file
+    # type=file|default=<undefined>: output dataset prefix name (default 'zcat')
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: medimage/nifti1
+    # type=file: output file
+    # type=file|default=<undefined>: output dataset prefix name (default 'zcat')
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_files:
+    # type=inputmultiobject|default=[]: 
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output dataset prefix name (default 'zcat')
+    datum:
+    # type=enum|default='byte'|allowed['byte','float','short']: specify data type for output. Valid types are 'byte', 'short' and 'float'.
+    verb:
+    # type=bool|default=False: print out some verbositiness as the program proceeds.
+    fscale:
+    # type=bool|default=False: Force scaling of the output to the maximum integer range.  This only has effect if the output datum is byte or short (either forced or defaulted). This option is sometimes necessary to eliminate unpleasant truncation artifacts.
+    nscale:
+    # type=bool|default=False: Don't do any scaling on output to byte or short datasets. This may be especially useful when operating on mask datasets whose output values are only 0's and 1's.
+    num_threads:
+    # type=int|default=1: set number of threads
+    outputtype:
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_files:
+    # type=inputmultiobject|default=[]: 
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output dataset prefix name (default 'zcat')
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: 3dZcat -prefix cat_functional.nii functional2.nii functional3.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_files:
+    # type=inputmultiobject|default=[]: 
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output dataset prefix name (default 'zcat')
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-afni/zcat_callables.py b/example-specs/task/nipype_internal/pydra-afni/zcat_callables.py
new file mode 100644
index 00000000..19dc1a13
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/zcat_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Zcat.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-afni/zeropad.yaml b/example-specs/task/nipype_internal/pydra-afni/zeropad.yaml
new file mode 100644
index 00000000..5efa450b
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/zeropad.yaml
@@ -0,0 +1,193 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.afni.utils.Zeropad' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Adds planes of zeros to a dataset (i.e., pads it out).
+# 
+#     For complete details, see the `3dZeropad Documentation.
+#     <https://afni.nimh.nih.gov/pub/dist/doc/program_help/3dZeropad.html>`__
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import afni
+#     >>> zeropad = afni.Zeropad()
+#     >>> zeropad.inputs.in_files = 'functional.nii'
+#     >>> zeropad.inputs.out_file = 'pad_functional.nii'
+#     >>> zeropad.inputs.I = 10
+#     >>> zeropad.inputs.S = 10
+#     >>> zeropad.inputs.A = 10
+#     >>> zeropad.inputs.P = 10
+#     >>> zeropad.inputs.R = 10
+#     >>> zeropad.inputs.L = 10
+#     >>> zeropad.cmdline
+#     '3dZeropad -A 10 -I 10 -L 10 -P 10 -R 10 -S 10 -prefix pad_functional.nii functional.nii'
+#     >>> res = zeropad.run()  # doctest: +SKIP
+# 
+#     
+task_name: Zeropad
+nipype_name: Zeropad
+nipype_module: nipype.interfaces.afni.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_files: medimage/nifti1
+    # type=file|default=<undefined>: input dataset
+    out_file: medimage/nifti1
+    # type=file: output file
+    # type=file|default=<undefined>: output dataset prefix name (default 'zeropad')
+    master: generic/file
+    # type=file|default=<undefined>: match the volume described in dataset 'mset', where mset must have the same orientation and grid spacing as dataset to be padded. the goal of -master is to make the output dataset from 3dZeropad match the spatial 'extents' of mset by adding or subtracting slices as needed. You can't use -I,-S,..., or -mm with -master
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: medimage/nifti1
+    # type=file: output file
+    # type=file|default=<undefined>: output dataset prefix name (default 'zeropad')
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_files:
+    # type=file|default=<undefined>: input dataset
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output dataset prefix name (default 'zeropad')
+    I:
+    # type=int|default=0: adds 'n' planes of zero at the Inferior edge
+    S:
+    # type=int|default=0: adds 'n' planes of zero at the Superior edge
+    A:
+    # type=int|default=0: adds 'n' planes of zero at the Anterior edge
+    P:
+    # type=int|default=0: adds 'n' planes of zero at the Posterior edge
+    L:
+    # type=int|default=0: adds 'n' planes of zero at the Left edge
+    R:
+    # type=int|default=0: adds 'n' planes of zero at the Right edge
+    z:
+    # type=int|default=0: adds 'n' planes of zero on EACH of the dataset z-axis (slice-direction) faces
+    RL:
+    # type=int|default=0: specify that planes should be added or cut symmetrically to make the resulting volume haveN slices in the right-left direction
+    AP:
+    # type=int|default=0: specify that planes should be added or cut symmetrically to make the resulting volume haveN slices in the anterior-posterior direction
+    IS:
+    # type=int|default=0: specify that planes should be added or cut symmetrically to make the resulting volume haveN slices in the inferior-superior direction
+    mm:
+    # type=bool|default=False: pad counts 'n' are in mm instead of slices, where each 'n' is an integer and at least 'n' mm of slices will be added/removed; e.g., n =  3 and slice thickness = 2.5 mm ==> 2 slices added
+    master:
+    # type=file|default=<undefined>: match the volume described in dataset 'mset', where mset must have the same orientation and grid spacing as dataset to be padded. the goal of -master is to make the output dataset from 3dZeropad match the spatial 'extents' of mset by adding or subtracting slices as needed. You can't use -I,-S,..., or -mm with -master
+    num_threads:
+    # type=int|default=1: set number of threads
+    outputtype:
+    # type=enum|default='AFNI'|allowed['AFNI','NIFTI','NIFTI_GZ']: AFNI output filetype
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_files:
+    # type=file|default=<undefined>: input dataset
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output dataset prefix name (default 'zeropad')
+    I: '10'
+    # type=int|default=0: adds 'n' planes of zero at the Inferior edge
+    S: '10'
+    # type=int|default=0: adds 'n' planes of zero at the Superior edge
+    A: '10'
+    # type=int|default=0: adds 'n' planes of zero at the Anterior edge
+    P: '10'
+    # type=int|default=0: adds 'n' planes of zero at the Posterior edge
+    R: '10'
+    # type=int|default=0: adds 'n' planes of zero at the Right edge
+    L: '10'
+    # type=int|default=0: adds 'n' planes of zero at the Left edge
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: 3dZeropad -A 10 -I 10 -L 10 -P 10 -R 10 -S 10 -prefix pad_functional.nii functional.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_files:
+    # type=file|default=<undefined>: input dataset
+    out_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output dataset prefix name (default 'zeropad')
+    I: '10'
+    # type=int|default=0: adds 'n' planes of zero at the Inferior edge
+    S: '10'
+    # type=int|default=0: adds 'n' planes of zero at the Superior edge
+    A: '10'
+    # type=int|default=0: adds 'n' planes of zero at the Anterior edge
+    P: '10'
+    # type=int|default=0: adds 'n' planes of zero at the Posterior edge
+    R: '10'
+    # type=int|default=0: adds 'n' planes of zero at the Right edge
+    L: '10'
+    # type=int|default=0: adds 'n' planes of zero at the Left edge
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-afni/zeropad_callables.py b/example-specs/task/nipype_internal/pydra-afni/zeropad_callables.py
new file mode 100644
index 00000000..15a323c9
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-afni/zeropad_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Zeropad.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-ants/affine_initializer.yaml b/example-specs/task/nipype_internal/pydra-ants/affine_initializer.yaml
new file mode 100644
index 00000000..d0e27959
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-ants/affine_initializer.yaml
@@ -0,0 +1,142 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.ants.utils.AffineInitializer' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Initialize an affine transform (as in antsBrainExtraction.sh)
+# 
+#     >>> from nipype.interfaces.ants import AffineInitializer
+#     >>> init = AffineInitializer()
+#     >>> init.inputs.fixed_image = 'fixed1.nii'
+#     >>> init.inputs.moving_image = 'moving1.nii'
+#     >>> init.cmdline
+#     'antsAffineInitializer 3 fixed1.nii moving1.nii transform.mat 15.000000 0.100000 0 10'
+# 
+#     
+task_name: AffineInitializer
+nipype_name: AffineInitializer
+nipype_module: nipype.interfaces.ants.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    fixed_image: medimage/nifti1
+    # type=file|default=<undefined>: reference image
+    moving_image: medimage/nifti1
+    # type=file|default=<undefined>: moving image
+    out_file: generic/file
+    # type=file: output transform file
+    # type=file|default='transform.mat': output transform file
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: output transform file
+    # type=file|default='transform.mat': output transform file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    dimension:
+    # type=enum|default=3|allowed[2,3]: dimension
+    fixed_image:
+    # type=file|default=<undefined>: reference image
+    moving_image:
+    # type=file|default=<undefined>: moving image
+    out_file:
+    # type=file: output transform file
+    # type=file|default='transform.mat': output transform file
+    search_factor:
+    # type=float|default=15.0: increments (degrees) for affine search
+    radian_fraction:
+    # type=range|default=0.1: search this arc +/- principal axes
+    principal_axes:
+    # type=bool|default=False: whether the rotation is searched around an initial principal axis alignment.
+    local_search:
+    # type=int|default=10:  determines if a local optimization is run at each search point for the set number of iterations
+    num_threads:
+    # type=int|default=1: Number of ITK threads to use
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    fixed_image:
+    # type=file|default=<undefined>: reference image
+    moving_image:
+    # type=file|default=<undefined>: moving image
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: antsAffineInitializer 3 fixed1.nii moving1.nii transform.mat 15.000000 0.100000 0 10
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    fixed_image:
+    # type=file|default=<undefined>: reference image
+    moving_image:
+    # type=file|default=<undefined>: moving image
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-ants/affine_initializer_callables.py b/example-specs/task/nipype_internal/pydra-ants/affine_initializer_callables.py
new file mode 100644
index 00000000..47d5ce0a
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-ants/affine_initializer_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in AffineInitializer.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-ants/ai.yaml b/example-specs/task/nipype_internal/pydra-ants/ai.yaml
new file mode 100644
index 00000000..6394b713
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-ants/ai.yaml
@@ -0,0 +1,130 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.ants.utils.AI' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Calculate the optimal linear transform parameters for aligning two images.
+# 
+#     Examples
+#     --------
+#     >>> AI(
+#     ...     fixed_image='structural.nii',
+#     ...     moving_image='epi.nii',
+#     ...     metric=('Mattes', 32, 'Regular', 1),
+#     ... ).cmdline
+#     'antsAI -c [10,1e-06,10] -d 3 -m Mattes[structural.nii,epi.nii,32,Regular,1]
+#     -o initialization.mat -p 0 -s [20,0.12] -t Affine[0.1] -v 0'
+# 
+#     >>> AI(fixed_image='structural.nii',
+#     ...    moving_image='epi.nii',
+#     ...    metric=('Mattes', 32, 'Regular', 1),
+#     ...    search_grid=(12, (1, 1, 1)),
+#     ... ).cmdline
+#     'antsAI -c [10,1e-06,10] -d 3 -m Mattes[structural.nii,epi.nii,32,Regular,1]
+#     -o initialization.mat -p 0 -s [20,0.12] -g [12.0,1x1x1] -t Affine[0.1] -v 0'
+# 
+#     
+task_name: AI
+nipype_name: AI
+nipype_module: nipype.interfaces.ants.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    fixed_image: generic/file
+    # type=file|default=<undefined>: Image to which the moving_image should be transformed
+    moving_image: generic/file
+    # type=file|default=<undefined>: Image that will be transformed to fixed_image
+    fixed_image_mask: generic/file
+    # type=file|default=<undefined>: fixed mage mask
+    moving_image_mask: generic/file
+    # type=file|default=<undefined>: moving mage mask
+    output_transform: generic/file
+    # type=file: output file name
+    # type=file|default='initialization.mat': output file name
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    output_transform: generic/file
+    # type=file: output file name
+    # type=file|default='initialization.mat': output file name
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    dimension:
+    # type=enum|default=3|allowed[2,3]: dimension of output image
+    verbose:
+    # type=bool|default=False: enable verbosity
+    fixed_image:
+    # type=file|default=<undefined>: Image to which the moving_image should be transformed
+    moving_image:
+    # type=file|default=<undefined>: Image that will be transformed to fixed_image
+    fixed_image_mask:
+    # type=file|default=<undefined>: fixed mage mask
+    moving_image_mask:
+    # type=file|default=<undefined>: moving mage mask
+    metric:
+    # type=tuple|default=('Mattes', 32, 'Regular', 0.2): the metric(s) to use.
+    transform:
+    # type=tuple|default=('Affine', 0.1): Several transform options are available
+    principal_axes:
+    # type=bool|default=False: align using principal axes
+    search_factor:
+    # type=tuple|default=(20, 0.12): search factor
+    search_grid:
+    # type=traitcompound|default=None: Translation search grid in mm
+    convergence:
+    # type=tuple|default=(10, 1e-06, 10): convergence
+    output_transform:
+    # type=file: output file name
+    # type=file|default='initialization.mat': output file name
+    num_threads:
+    # type=int|default=1: Number of ITK threads to use
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-ants/ai_callables.py b/example-specs/task/nipype_internal/pydra-ants/ai_callables.py
new file mode 100644
index 00000000..dafef828
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-ants/ai_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in AI.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-ants/ants.yaml b/example-specs/task/nipype_internal/pydra-ants/ants.yaml
new file mode 100644
index 00000000..a7c9f6ad
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-ants/ants.yaml
@@ -0,0 +1,245 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.ants.registration.ANTS' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# ANTS wrapper for registration of images
+#     (old, use Registration instead)
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces.ants import ANTS
+#     >>> ants = ANTS()
+#     >>> ants.inputs.dimension = 3
+#     >>> ants.inputs.output_transform_prefix = 'MY'
+#     >>> ants.inputs.metric = ['CC']
+#     >>> ants.inputs.fixed_image = ['T1.nii']
+#     >>> ants.inputs.moving_image = ['resting.nii']
+#     >>> ants.inputs.metric_weight = [1.0]
+#     >>> ants.inputs.radius = [5]
+#     >>> ants.inputs.transformation_model = 'SyN'
+#     >>> ants.inputs.gradient_step_length = 0.25
+#     >>> ants.inputs.number_of_iterations = [50, 35, 15]
+#     >>> ants.inputs.use_histogram_matching = True
+#     >>> ants.inputs.mi_option = [32, 16000]
+#     >>> ants.inputs.regularization = 'Gauss'
+#     >>> ants.inputs.regularization_gradient_field_sigma = 3
+#     >>> ants.inputs.regularization_deformation_field_sigma = 0
+#     >>> ants.inputs.number_of_affine_iterations = [10000,10000,10000,10000,10000]
+#     >>> ants.cmdline
+#     'ANTS 3 --MI-option 32x16000 --image-metric CC[ T1.nii, resting.nii, 1, 5 ] --number-of-affine-iterations 10000x10000x10000x10000x10000 --number-of-iterations 50x35x15 --output-naming MY --regularization Gauss[3.0,0.0] --transformation-model SyN[0.25] --use-Histogram-Matching 1'
+#     
+task_name: ANTS
+nipype_name: ANTS
+nipype_module: nipype.interfaces.ants.registration
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    fixed_image: medimage/nifti1+list-of
+    # type=inputmultiobject|default=[]: image to which the moving image is warped
+    moving_image: medimage/nifti1+list-of
+    # type=inputmultiobject|default=[]: image to apply transformation to (generally a coregisteredfunctional)
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    affine_transform: generic/file
+    # type=file: Affine transform file
+    warp_transform: generic/file
+    # type=file: Warping deformation field
+    inverse_warp_transform: generic/file
+    # type=file: Inverse warping deformation field
+    metaheader: generic/file
+    # type=file: VTK metaheader .mhd file
+    metaheader_raw: generic/file
+    # type=file: VTK metaheader .raw file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    dimension:
+    # type=enum|default=3|allowed[2,3]: image dimension (2 or 3)
+    fixed_image:
+    # type=inputmultiobject|default=[]: image to which the moving image is warped
+    moving_image:
+    # type=inputmultiobject|default=[]: image to apply transformation to (generally a coregisteredfunctional)
+    metric:
+    # type=list|default=[]: 
+    metric_weight:
+    # type=list|default=[1.0]: the metric weight(s) for each stage. The weights must sum to 1 per stage.
+    radius:
+    # type=list|default=[]: radius of the region (i.e. number of layers around a voxel/pixel) that is used for computing cross correlation
+    output_transform_prefix:
+    # type=str|default='out': 
+    transformation_model:
+    # type=enum|default='Diff'|allowed['Diff','Elast','Exp','Greedy Exp','SyN']: 
+    gradient_step_length:
+    # type=float|default=0.0: 
+    number_of_time_steps:
+    # type=int|default=0: 
+    delta_time:
+    # type=float|default=0.0: 
+    symmetry_type:
+    # type=float|default=0.0: 
+    use_histogram_matching:
+    # type=bool|default=True: 
+    number_of_iterations:
+    # type=list|default=[]: 
+    smoothing_sigmas:
+    # type=list|default=[]: 
+    subsampling_factors:
+    # type=list|default=[]: 
+    affine_gradient_descent_option:
+    # type=list|default=[]: 
+    mi_option:
+    # type=list|default=[]: 
+    regularization:
+    # type=enum|default='Gauss'|allowed['DMFFD','Gauss']: 
+    regularization_gradient_field_sigma:
+    # type=float|default=0.0: 
+    regularization_deformation_field_sigma:
+    # type=float|default=0.0: 
+    number_of_affine_iterations:
+    # type=list|default=[]: 
+    num_threads:
+    # type=int|default=1: Number of ITK threads to use
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    dimension: '3'
+    # type=enum|default=3|allowed[2,3]: image dimension (2 or 3)
+    output_transform_prefix: '"MY"'
+    # type=str|default='out': 
+    metric: '["CC"]'
+    # type=list|default=[]: 
+    fixed_image:
+    # type=inputmultiobject|default=[]: image to which the moving image is warped
+    moving_image:
+    # type=inputmultiobject|default=[]: image to apply transformation to (generally a coregisteredfunctional)
+    metric_weight: '[1.0]'
+    # type=list|default=[1.0]: the metric weight(s) for each stage. The weights must sum to 1 per stage.
+    radius: '[5]'
+    # type=list|default=[]: radius of the region (i.e. number of layers around a voxel/pixel) that is used for computing cross correlation
+    transformation_model: '"SyN"'
+    # type=enum|default='Diff'|allowed['Diff','Elast','Exp','Greedy Exp','SyN']: 
+    gradient_step_length: '0.25'
+    # type=float|default=0.0: 
+    number_of_iterations: '[50, 35, 15]'
+    # type=list|default=[]: 
+    use_histogram_matching: 'True'
+    # type=bool|default=True: 
+    mi_option: '[32, 16000]'
+    # type=list|default=[]: 
+    regularization: '"Gauss"'
+    # type=enum|default='Gauss'|allowed['DMFFD','Gauss']: 
+    regularization_gradient_field_sigma: '3'
+    # type=float|default=0.0: 
+    regularization_deformation_field_sigma: '0'
+    # type=float|default=0.0: 
+    number_of_affine_iterations: '[10000,10000,10000,10000,10000]'
+    # type=list|default=[]: 
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: ANTS 3 --MI-option 32x16000 --image-metric CC[ T1.nii, resting.nii, 1, 5 ] --number-of-affine-iterations 10000x10000x10000x10000x10000 --number-of-iterations 50x35x15 --output-naming MY --regularization Gauss[3.0,0.0] --transformation-model SyN[0.25] --use-Histogram-Matching 1
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    dimension: '3'
+    # type=enum|default=3|allowed[2,3]: image dimension (2 or 3)
+    output_transform_prefix: '"MY"'
+    # type=str|default='out': 
+    metric: '["CC"]'
+    # type=list|default=[]: 
+    fixed_image:
+    # type=inputmultiobject|default=[]: image to which the moving image is warped
+    moving_image:
+    # type=inputmultiobject|default=[]: image to apply transformation to (generally a coregisteredfunctional)
+    metric_weight: '[1.0]'
+    # type=list|default=[1.0]: the metric weight(s) for each stage. The weights must sum to 1 per stage.
+    radius: '[5]'
+    # type=list|default=[]: radius of the region (i.e. number of layers around a voxel/pixel) that is used for computing cross correlation
+    transformation_model: '"SyN"'
+    # type=enum|default='Diff'|allowed['Diff','Elast','Exp','Greedy Exp','SyN']: 
+    gradient_step_length: '0.25'
+    # type=float|default=0.0: 
+    number_of_iterations: '[50, 35, 15]'
+    # type=list|default=[]: 
+    use_histogram_matching: 'True'
+    # type=bool|default=True: 
+    mi_option: '[32, 16000]'
+    # type=list|default=[]: 
+    regularization: '"Gauss"'
+    # type=enum|default='Gauss'|allowed['DMFFD','Gauss']: 
+    regularization_gradient_field_sigma: '3'
+    # type=float|default=0.0: 
+    regularization_deformation_field_sigma: '0'
+    # type=float|default=0.0: 
+    number_of_affine_iterations: '[10000,10000,10000,10000,10000]'
+    # type=list|default=[]: 
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-ants/ants_callables.py b/example-specs/task/nipype_internal/pydra-ants/ants_callables.py
new file mode 100644
index 00000000..dc14cf02
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-ants/ants_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in ANTS.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-ants/ants_introduction.yaml b/example-specs/task/nipype_internal/pydra-ants/ants_introduction.yaml
new file mode 100644
index 00000000..b119bbbe
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-ants/ants_introduction.yaml
@@ -0,0 +1,158 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.ants.legacy.antsIntroduction' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Uses ANTS to generate matrices to warp data from one space to another.
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces.ants.legacy import antsIntroduction
+#     >>> warp = antsIntroduction()
+#     >>> warp.inputs.reference_image = 'Template_6.nii'
+#     >>> warp.inputs.input_image = 'structural.nii'
+#     >>> warp.inputs.max_iterations = [30,90,20]
+#     >>> warp.cmdline
+#     'antsIntroduction.sh -d 3 -i structural.nii -m 30x90x20 -o ants_ -r Template_6.nii -t GR'
+# 
+#     
+task_name: antsIntroduction
+nipype_name: antsIntroduction
+nipype_module: nipype.interfaces.ants.legacy
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    reference_image: medimage/nifti1
+    # type=file|default=<undefined>: template file to warp to
+    input_image: medimage/nifti1
+    # type=file|default=<undefined>: input image to warp to template
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    affine_transformation: generic/file
+    # type=file: affine (prefix_Affine.txt)
+    warp_field: generic/file
+    # type=file: warp field (prefix_Warp.nii)
+    inverse_warp_field: generic/file
+    # type=file: inverse warp field (prefix_InverseWarp.nii)
+    input_file: generic/file
+    # type=file: input image (prefix_repaired.nii)
+    output_file: generic/file
+    # type=file: output image (prefix_deformed.nii)
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    dimension:
+    # type=enum|default=3|allowed[2,3]: image dimension (2 or 3)
+    reference_image:
+    # type=file|default=<undefined>: template file to warp to
+    input_image:
+    # type=file|default=<undefined>: input image to warp to template
+    force_proceed:
+    # type=bool|default=False: force script to proceed even if headers may be incompatible
+    inverse_warp_template_labels:
+    # type=bool|default=False: Applies inverse warp to the template labels to estimate label positions in target space (use for template-based segmentation)
+    max_iterations:
+    # type=list|default=[]: maximum number of iterations (must be list of integers in the form [J,K,L...]: J = coarsest resolution iterations, K = middle resolution iterations, L = fine resolution iterations
+    bias_field_correction:
+    # type=bool|default=False: Applies bias field correction to moving image
+    similarity_metric:
+    # type=enum|default='PR'|allowed['CC','MI','MSQ','PR']: Type of similartiy metric used for registration (CC = cross correlation, MI = mutual information, PR = probability mapping, MSQ = mean square difference)
+    transformation_model:
+    # type=enum|default='GR'|allowed['DD','EL','EX','GR','RA','RI','S2','SY']: Type of transofmration model used for registration (EL = elastic transformation model, SY = SyN with time, arbitrary number of time points, S2 =  SyN with time optimized for 2 time points, GR = greedy SyN, EX = exponential, DD = diffeomorphic demons style exponential mapping, RI = purely rigid, RA = affine rigid
+    out_prefix:
+    # type=str|default='ants_': Prefix that is prepended to all output files (default = ants_)
+    quality_check:
+    # type=bool|default=False: Perform a quality check of the result
+    num_threads:
+    # type=int|default=1: Number of ITK threads to use
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    reference_image:
+    # type=file|default=<undefined>: template file to warp to
+    input_image:
+    # type=file|default=<undefined>: input image to warp to template
+    max_iterations: '[30,90,20]'
+    # type=list|default=[]: maximum number of iterations (must be list of integers in the form [J,K,L...]: J = coarsest resolution iterations, K = middle resolution iterations, L = fine resolution iterations
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: antsIntroduction.sh -d 3 -i structural.nii -m 30x90x20 -o ants_ -r Template_6.nii -t GR
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    reference_image:
+    # type=file|default=<undefined>: template file to warp to
+    input_image:
+    # type=file|default=<undefined>: input image to warp to template
+    max_iterations: '[30,90,20]'
+    # type=list|default=[]: maximum number of iterations (must be list of integers in the form [J,K,L...]: J = coarsest resolution iterations, K = middle resolution iterations, L = fine resolution iterations
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-ants/ants_introduction_callables.py b/example-specs/task/nipype_internal/pydra-ants/ants_introduction_callables.py
new file mode 100644
index 00000000..d6e4f62c
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-ants/ants_introduction_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in antsIntroduction.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-ants/apply_transforms.yaml b/example-specs/task/nipype_internal/pydra-ants/apply_transforms.yaml
new file mode 100644
index 00000000..4b145ddb
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-ants/apply_transforms.yaml
@@ -0,0 +1,391 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.ants.resampling.ApplyTransforms' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# ApplyTransforms, applied to an input image, transforms it according to a
+#     reference image and a transform (or a set of transforms).
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces.ants import ApplyTransforms
+#     >>> at = ApplyTransforms()
+#     >>> at.inputs.input_image = 'moving1.nii'
+#     >>> at.inputs.reference_image = 'fixed1.nii'
+#     >>> at.inputs.transforms = 'identity'
+#     >>> at.cmdline
+#     'antsApplyTransforms --default-value 0 --float 0 --input moving1.nii --interpolation Linear --output moving1_trans.nii --reference-image fixed1.nii --transform identity'
+# 
+#     >>> at = ApplyTransforms()
+#     >>> at.inputs.dimension = 3
+#     >>> at.inputs.input_image = 'moving1.nii'
+#     >>> at.inputs.reference_image = 'fixed1.nii'
+#     >>> at.inputs.output_image = 'deformed_moving1.nii'
+#     >>> at.inputs.interpolation = 'Linear'
+#     >>> at.inputs.default_value = 0
+#     >>> at.inputs.transforms = ['ants_Warp.nii.gz', 'trans.mat']
+#     >>> at.inputs.invert_transform_flags = [False, True]
+#     >>> at.cmdline
+#     'antsApplyTransforms --default-value 0 --dimensionality 3 --float 0 --input moving1.nii --interpolation Linear --output deformed_moving1.nii --reference-image fixed1.nii --transform ants_Warp.nii.gz --transform [ trans.mat, 1 ]'
+# 
+#     >>> at1 = ApplyTransforms()
+#     >>> at1.inputs.dimension = 3
+#     >>> at1.inputs.input_image = 'moving1.nii'
+#     >>> at1.inputs.reference_image = 'fixed1.nii'
+#     >>> at1.inputs.output_image = 'deformed_moving1.nii'
+#     >>> at1.inputs.interpolation = 'BSpline'
+#     >>> at1.inputs.interpolation_parameters = (5,)
+#     >>> at1.inputs.default_value = 0
+#     >>> at1.inputs.transforms = ['ants_Warp.nii.gz', 'trans.mat']
+#     >>> at1.inputs.invert_transform_flags = [False, False]
+#     >>> at1.cmdline
+#     'antsApplyTransforms --default-value 0 --dimensionality 3 --float 0 --input moving1.nii --interpolation BSpline[ 5 ] --output deformed_moving1.nii --reference-image fixed1.nii --transform ants_Warp.nii.gz --transform trans.mat'
+# 
+#     Identity transforms may be used as part of a chain:
+# 
+#     >>> at2 = ApplyTransforms()
+#     >>> at2.inputs.dimension = 3
+#     >>> at2.inputs.input_image = 'moving1.nii'
+#     >>> at2.inputs.reference_image = 'fixed1.nii'
+#     >>> at2.inputs.output_image = 'deformed_moving1.nii'
+#     >>> at2.inputs.interpolation = 'BSpline'
+#     >>> at2.inputs.interpolation_parameters = (5,)
+#     >>> at2.inputs.default_value = 0
+#     >>> at2.inputs.transforms = ['identity', 'ants_Warp.nii.gz', 'trans.mat']
+#     >>> at2.cmdline
+#     'antsApplyTransforms --default-value 0 --dimensionality 3 --float 0 --input moving1.nii --interpolation BSpline[ 5 ] --output deformed_moving1.nii --reference-image fixed1.nii --transform identity --transform ants_Warp.nii.gz --transform trans.mat'
+#     
+task_name: ApplyTransforms
+nipype_name: ApplyTransforms
+nipype_module: nipype.interfaces.ants.resampling
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    input_image: medimage/nifti1
+    # type=file|default=<undefined>: image to apply transformation to (generally a coregistered functional)
+    reference_image: medimage/nifti1
+    # type=file|default=<undefined>: reference image space that you wish to warp INTO
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    output_image: medimage/nifti1
+    # type=file: Warped image
+    # type=str|default='': output file name
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    output_image: '"deformed_moving1.nii"'
+    # type=file: Warped image
+    # type=str|default='': output file name
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    dimension:
+    # type=enum|default=2|allowed[2,3,4]: This option forces the image to be treated as a specified-dimensional image. If not specified, antsWarp tries to infer the dimensionality from the input image.
+    input_image_type:
+    # type=enum|default=0|allowed[0,1,2,3]: Option specifying the input image type of scalar (default), vector, tensor, or time series.
+    input_image:
+    # type=file|default=<undefined>: image to apply transformation to (generally a coregistered functional)
+    output_image:
+    # type=file: Warped image
+    # type=str|default='': output file name
+    out_postfix:
+    # type=str|default='_trans': Postfix that is appended to all output files (default = _trans)
+    reference_image:
+    # type=file|default=<undefined>: reference image space that you wish to warp INTO
+    interpolation:
+    # type=enum|default='Linear'|allowed['BSpline','CosineWindowedSinc','Gaussian','HammingWindowedSinc','LanczosWindowedSinc','Linear','MultiLabel','NearestNeighbor','WelchWindowedSinc']: 
+    interpolation_parameters:
+    # type=traitcompound|default=None: 
+    transforms:
+    # type=inputmultiobject|default=[]: transform files: will be applied in reverse order. For example, the last specified transform will be applied first.
+    invert_transform_flags:
+    # type=inputmultiobject|default=[]: 
+    default_value:
+    # type=float|default=0.0: 
+    print_out_composite_warp_file:
+    # type=bool|default=False: output a composite warp file instead of a transformed image
+    float:
+    # type=bool|default=False: Use float instead of double for computations.
+    num_threads:
+    # type=int|default=1: Number of ITK threads to use
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    input_image:
+    # type=file|default=<undefined>: image to apply transformation to (generally a coregistered functional)
+    reference_image:
+    # type=file|default=<undefined>: reference image space that you wish to warp INTO
+    transforms: '"identity"'
+    # type=inputmultiobject|default=[]: transform files: will be applied in reverse order. For example, the last specified transform will be applied first.
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    dimension: '3'
+    # type=enum|default=2|allowed[2,3,4]: This option forces the image to be treated as a specified-dimensional image. If not specified, antsWarp tries to infer the dimensionality from the input image.
+    input_image:
+    # type=file|default=<undefined>: image to apply transformation to (generally a coregistered functional)
+    reference_image:
+    # type=file|default=<undefined>: reference image space that you wish to warp INTO
+    output_image: '"deformed_moving1.nii"'
+    # type=file: Warped image
+    # type=str|default='': output file name
+    interpolation: '"Linear"'
+    # type=enum|default='Linear'|allowed['BSpline','CosineWindowedSinc','Gaussian','HammingWindowedSinc','LanczosWindowedSinc','Linear','MultiLabel','NearestNeighbor','WelchWindowedSinc']: 
+    default_value: '0'
+    # type=float|default=0.0: 
+    transforms: '["ants_Warp.nii.gz", "trans.mat"]'
+    # type=inputmultiobject|default=[]: transform files: will be applied in reverse order. For example, the last specified transform will be applied first.
+    invert_transform_flags: '[False, True]'
+    # type=inputmultiobject|default=[]: 
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    dimension: '3'
+    # type=enum|default=2|allowed[2,3,4]: This option forces the image to be treated as a specified-dimensional image. If not specified, antsWarp tries to infer the dimensionality from the input image.
+    input_image:
+    # type=file|default=<undefined>: image to apply transformation to (generally a coregistered functional)
+    reference_image:
+    # type=file|default=<undefined>: reference image space that you wish to warp INTO
+    output_image: '"deformed_moving1.nii"'
+    # type=file: Warped image
+    # type=str|default='': output file name
+    interpolation: '"BSpline"'
+    # type=enum|default='Linear'|allowed['BSpline','CosineWindowedSinc','Gaussian','HammingWindowedSinc','LanczosWindowedSinc','Linear','MultiLabel','NearestNeighbor','WelchWindowedSinc']: 
+    interpolation_parameters: (5,)
+    # type=traitcompound|default=None: 
+    default_value: '0'
+    # type=float|default=0.0: 
+    transforms: '["ants_Warp.nii.gz", "trans.mat"]'
+    # type=inputmultiobject|default=[]: transform files: will be applied in reverse order. For example, the last specified transform will be applied first.
+    invert_transform_flags: '[False, False]'
+    # type=inputmultiobject|default=[]: 
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    dimension: '3'
+    # type=enum|default=2|allowed[2,3,4]: This option forces the image to be treated as a specified-dimensional image. If not specified, antsWarp tries to infer the dimensionality from the input image.
+    input_image:
+    # type=file|default=<undefined>: image to apply transformation to (generally a coregistered functional)
+    reference_image:
+    # type=file|default=<undefined>: reference image space that you wish to warp INTO
+    output_image: '"deformed_moving1.nii"'
+    # type=file: Warped image
+    # type=str|default='': output file name
+    interpolation: '"BSpline"'
+    # type=enum|default='Linear'|allowed['BSpline','CosineWindowedSinc','Gaussian','HammingWindowedSinc','LanczosWindowedSinc','Linear','MultiLabel','NearestNeighbor','WelchWindowedSinc']: 
+    interpolation_parameters: (5,)
+    # type=traitcompound|default=None: 
+    default_value: '0'
+    # type=float|default=0.0: 
+    transforms: '["identity", "ants_Warp.nii.gz", "trans.mat"]'
+    # type=inputmultiobject|default=[]: transform files: will be applied in reverse order. For example, the last specified transform will be applied first.
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: antsApplyTransforms --default-value 0 --float 0 --input moving1.nii --interpolation Linear --output moving1_trans.nii --reference-image fixed1.nii --transform identity
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    input_image:
+    # type=file|default=<undefined>: image to apply transformation to (generally a coregistered functional)
+    reference_image:
+    # type=file|default=<undefined>: reference image space that you wish to warp INTO
+    transforms: '"identity"'
+    # type=inputmultiobject|default=[]: transform files: will be applied in reverse order. For example, the last specified transform will be applied first.
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: antsApplyTransforms --default-value 0 --dimensionality 3 --float 0 --input moving1.nii --interpolation Linear --output deformed_moving1.nii --reference-image fixed1.nii --transform ants_Warp.nii.gz --transform [ trans.mat, 1 ]
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    dimension: '3'
+    # type=enum|default=2|allowed[2,3,4]: This option forces the image to be treated as a specified-dimensional image. If not specified, antsWarp tries to infer the dimensionality from the input image.
+    input_image:
+    # type=file|default=<undefined>: image to apply transformation to (generally a coregistered functional)
+    reference_image:
+    # type=file|default=<undefined>: reference image space that you wish to warp INTO
+    output_image: '"deformed_moving1.nii"'
+    # type=file: Warped image
+    # type=str|default='': output file name
+    interpolation: '"Linear"'
+    # type=enum|default='Linear'|allowed['BSpline','CosineWindowedSinc','Gaussian','HammingWindowedSinc','LanczosWindowedSinc','Linear','MultiLabel','NearestNeighbor','WelchWindowedSinc']: 
+    default_value: '0'
+    # type=float|default=0.0: 
+    transforms: '["ants_Warp.nii.gz", "trans.mat"]'
+    # type=inputmultiobject|default=[]: transform files: will be applied in reverse order. For example, the last specified transform will be applied first.
+    invert_transform_flags: '[False, True]'
+    # type=inputmultiobject|default=[]: 
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: antsApplyTransforms --default-value 0 --dimensionality 3 --float 0 --input moving1.nii --interpolation BSpline[ 5 ] --output deformed_moving1.nii --reference-image fixed1.nii --transform ants_Warp.nii.gz --transform trans.mat
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    dimension: '3'
+    # type=enum|default=2|allowed[2,3,4]: This option forces the image to be treated as a specified-dimensional image. If not specified, antsWarp tries to infer the dimensionality from the input image.
+    input_image:
+    # type=file|default=<undefined>: image to apply transformation to (generally a coregistered functional)
+    reference_image:
+    # type=file|default=<undefined>: reference image space that you wish to warp INTO
+    output_image: '"deformed_moving1.nii"'
+    # type=file: Warped image
+    # type=str|default='': output file name
+    interpolation: '"BSpline"'
+    # type=enum|default='Linear'|allowed['BSpline','CosineWindowedSinc','Gaussian','HammingWindowedSinc','LanczosWindowedSinc','Linear','MultiLabel','NearestNeighbor','WelchWindowedSinc']: 
+    interpolation_parameters: (5,)
+    # type=traitcompound|default=None: 
+    default_value: '0'
+    # type=float|default=0.0: 
+    transforms: '["ants_Warp.nii.gz", "trans.mat"]'
+    # type=inputmultiobject|default=[]: transform files: will be applied in reverse order. For example, the last specified transform will be applied first.
+    invert_transform_flags: '[False, False]'
+    # type=inputmultiobject|default=[]: 
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: antsApplyTransforms --default-value 0 --dimensionality 3 --float 0 --input moving1.nii --interpolation BSpline[ 5 ] --output deformed_moving1.nii --reference-image fixed1.nii --transform identity --transform ants_Warp.nii.gz --transform trans.mat
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    dimension: '3'
+    # type=enum|default=2|allowed[2,3,4]: This option forces the image to be treated as a specified-dimensional image. If not specified, antsWarp tries to infer the dimensionality from the input image.
+    input_image:
+    # type=file|default=<undefined>: image to apply transformation to (generally a coregistered functional)
+    reference_image:
+    # type=file|default=<undefined>: reference image space that you wish to warp INTO
+    output_image: '"deformed_moving1.nii"'
+    # type=file: Warped image
+    # type=str|default='': output file name
+    interpolation: '"BSpline"'
+    # type=enum|default='Linear'|allowed['BSpline','CosineWindowedSinc','Gaussian','HammingWindowedSinc','LanczosWindowedSinc','Linear','MultiLabel','NearestNeighbor','WelchWindowedSinc']: 
+    interpolation_parameters: (5,)
+    # type=traitcompound|default=None: 
+    default_value: '0'
+    # type=float|default=0.0: 
+    transforms: '["identity", "ants_Warp.nii.gz", "trans.mat"]'
+    # type=inputmultiobject|default=[]: transform files: will be applied in reverse order. For example, the last specified transform will be applied first.
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-ants/apply_transforms_callables.py b/example-specs/task/nipype_internal/pydra-ants/apply_transforms_callables.py
new file mode 100644
index 00000000..eaafa83e
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-ants/apply_transforms_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in ApplyTransforms.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-ants/apply_transforms_to_points.yaml b/example-specs/task/nipype_internal/pydra-ants/apply_transforms_to_points.yaml
new file mode 100644
index 00000000..067d5a98
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-ants/apply_transforms_to_points.yaml
@@ -0,0 +1,147 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.ants.resampling.ApplyTransformsToPoints' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# ApplyTransformsToPoints, applied to an CSV file, transforms coordinates
+#     using provided transform (or a set of transforms).
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces.ants import ApplyTransforms
+#     >>> at = ApplyTransformsToPoints()
+#     >>> at.inputs.dimension = 3
+#     >>> at.inputs.input_file = 'moving.csv'
+#     >>> at.inputs.transforms = ['trans.mat', 'ants_Warp.nii.gz']
+#     >>> at.inputs.invert_transform_flags = [False, False]
+#     >>> at.cmdline
+#     'antsApplyTransformsToPoints --dimensionality 3 --input moving.csv --output moving_transformed.csv --transform [ trans.mat, 0 ] --transform [ ants_Warp.nii.gz, 0 ]'
+# 
+# 
+#     
+task_name: ApplyTransformsToPoints
+nipype_name: ApplyTransformsToPoints
+nipype_module: nipype.interfaces.ants.resampling
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    input_file: text/csv
+    # type=file|default=<undefined>: Currently, the only input supported is a csv file with columns including x,y (2D), x,y,z (3D) or x,y,z,t,label (4D) column headers. The points should be defined in physical space. If in doubt how to convert coordinates from your files to the space required by antsApplyTransformsToPoints try creating/drawing a simple label volume with only one voxel set to 1 and all others set to 0. Write down the voxel coordinates. Then use ImageMaths LabelStats to find out what coordinates for this voxel antsApplyTransformsToPoints is expecting.
+    transforms: datascience/text-matrix+list-of
+    # type=list|default=[]: transforms that will be applied to the points
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    output_file: generic/file
+    # type=file: csv file with transformed coordinates
+    # type=str|default='': Name of the output CSV file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    dimension:
+    # type=enum|default=2|allowed[2,3,4]: This option forces the image to be treated as a specified-dimensional image. If not specified, antsWarp tries to infer the dimensionality from the input image.
+    input_file:
+    # type=file|default=<undefined>: Currently, the only input supported is a csv file with columns including x,y (2D), x,y,z (3D) or x,y,z,t,label (4D) column headers. The points should be defined in physical space. If in doubt how to convert coordinates from your files to the space required by antsApplyTransformsToPoints try creating/drawing a simple label volume with only one voxel set to 1 and all others set to 0. Write down the voxel coordinates. Then use ImageMaths LabelStats to find out what coordinates for this voxel antsApplyTransformsToPoints is expecting.
+    output_file:
+    # type=file: csv file with transformed coordinates
+    # type=str|default='': Name of the output CSV file
+    transforms:
+    # type=list|default=[]: transforms that will be applied to the points
+    invert_transform_flags:
+    # type=list|default=[]: list indicating if a transform should be reversed
+    num_threads:
+    # type=int|default=1: Number of ITK threads to use
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    dimension: '3'
+    # type=enum|default=2|allowed[2,3,4]: This option forces the image to be treated as a specified-dimensional image. If not specified, antsWarp tries to infer the dimensionality from the input image.
+    input_file:
+    # type=file|default=<undefined>: Currently, the only input supported is a csv file with columns including x,y (2D), x,y,z (3D) or x,y,z,t,label (4D) column headers. The points should be defined in physical space. If in doubt how to convert coordinates from your files to the space required by antsApplyTransformsToPoints try creating/drawing a simple label volume with only one voxel set to 1 and all others set to 0. Write down the voxel coordinates. Then use ImageMaths LabelStats to find out what coordinates for this voxel antsApplyTransformsToPoints is expecting.
+    transforms:
+    # type=list|default=[]: transforms that will be applied to the points
+    invert_transform_flags: '[False, False]'
+    # type=list|default=[]: list indicating if a transform should be reversed
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: antsApplyTransformsToPoints --dimensionality 3 --input moving.csv --output moving_transformed.csv --transform [ trans.mat, 0 ] --transform [ ants_Warp.nii.gz, 0 ]
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    dimension: '3'
+    # type=enum|default=2|allowed[2,3,4]: This option forces the image to be treated as a specified-dimensional image. If not specified, antsWarp tries to infer the dimensionality from the input image.
+    input_file:
+    # type=file|default=<undefined>: Currently, the only input supported is a csv file with columns including x,y (2D), x,y,z (3D) or x,y,z,t,label (4D) column headers. The points should be defined in physical space. If in doubt how to convert coordinates from your files to the space required by antsApplyTransformsToPoints try creating/drawing a simple label volume with only one voxel set to 1 and all others set to 0. Write down the voxel coordinates. Then use ImageMaths LabelStats to find out what coordinates for this voxel antsApplyTransformsToPoints is expecting.
+    transforms:
+    # type=list|default=[]: transforms that will be applied to the points
+    invert_transform_flags: '[False, False]'
+    # type=list|default=[]: list indicating if a transform should be reversed
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-ants/apply_transforms_to_points_callables.py b/example-specs/task/nipype_internal/pydra-ants/apply_transforms_to_points_callables.py
new file mode 100644
index 00000000..de371e76
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-ants/apply_transforms_to_points_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in ApplyTransformsToPoints.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-ants/atropos.yaml b/example-specs/task/nipype_internal/pydra-ants/atropos.yaml
new file mode 100644
index 00000000..2a95a349
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-ants/atropos.yaml
@@ -0,0 +1,576 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.ants.segmentation.Atropos' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     A multivariate n-class segmentation algorithm.
+# 
+#     A finite mixture modeling (FMM) segmentation approach with possibilities for
+#     specifying prior constraints. These prior constraints include the specification
+#     of a prior label image, prior probability images (one for each class), and/or an
+#     MRF prior to enforce spatial smoothing of the labels. Similar algorithms include
+#     FAST and SPM.
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces.ants import Atropos
+#     >>> at = Atropos(
+#     ...     dimension=3, intensity_images='structural.nii', mask_image='mask.nii',
+#     ...     number_of_tissue_classes=2, likelihood_model='Gaussian', save_posteriors=True,
+#     ...     mrf_smoothing_factor=0.2, mrf_radius=[1, 1, 1], icm_use_synchronous_update=True,
+#     ...     maximum_number_of_icm_terations=1, n_iterations=5, convergence_threshold=0.000001,
+#     ...     posterior_formulation='Socrates', use_mixture_model_proportions=True)
+#     >>> at.inputs.initialization = 'Random'
+#     >>> at.cmdline
+#     'Atropos --image-dimensionality 3 --icm [1,1]
+#     --initialization Random[2] --intensity-image structural.nii
+#     --likelihood-model Gaussian --mask-image mask.nii --mrf [0.2,1x1x1] --convergence [5,1e-06]
+#     --output [structural_labeled.nii,POSTERIOR_%02d.nii.gz] --posterior-formulation Socrates[1]
+#     --use-random-seed 1'
+# 
+#     >>> at = Atropos(
+#     ...     dimension=3, intensity_images='structural.nii', mask_image='mask.nii',
+#     ...     number_of_tissue_classes=2, likelihood_model='Gaussian', save_posteriors=True,
+#     ...     mrf_smoothing_factor=0.2, mrf_radius=[1, 1, 1], icm_use_synchronous_update=True,
+#     ...     maximum_number_of_icm_terations=1, n_iterations=5, convergence_threshold=0.000001,
+#     ...     posterior_formulation='Socrates', use_mixture_model_proportions=True)
+#     >>> at.inputs.initialization = 'KMeans'
+#     >>> at.inputs.kmeans_init_centers = [100, 200]
+#     >>> at.cmdline
+#     'Atropos --image-dimensionality 3 --icm [1,1]
+#     --initialization KMeans[2,100,200] --intensity-image structural.nii
+#     --likelihood-model Gaussian --mask-image mask.nii --mrf [0.2,1x1x1] --convergence [5,1e-06]
+#     --output [structural_labeled.nii,POSTERIOR_%02d.nii.gz] --posterior-formulation Socrates[1]
+#     --use-random-seed 1'
+# 
+#     >>> at = Atropos(
+#     ...     dimension=3, intensity_images='structural.nii', mask_image='mask.nii',
+#     ...     number_of_tissue_classes=2, likelihood_model='Gaussian', save_posteriors=True,
+#     ...     mrf_smoothing_factor=0.2, mrf_radius=[1, 1, 1], icm_use_synchronous_update=True,
+#     ...     maximum_number_of_icm_terations=1, n_iterations=5, convergence_threshold=0.000001,
+#     ...     posterior_formulation='Socrates', use_mixture_model_proportions=True)
+#     >>> at.inputs.initialization = 'PriorProbabilityImages'
+#     >>> at.inputs.prior_image = 'BrainSegmentationPrior%02d.nii.gz'
+#     >>> at.inputs.prior_weighting = 0.8
+#     >>> at.inputs.prior_probability_threshold = 0.0000001
+#     >>> at.cmdline
+#     'Atropos --image-dimensionality 3 --icm [1,1]
+#     --initialization PriorProbabilityImages[2,BrainSegmentationPrior%02d.nii.gz,0.8,1e-07]
+#     --intensity-image structural.nii --likelihood-model Gaussian --mask-image mask.nii
+#     --mrf [0.2,1x1x1] --convergence [5,1e-06]
+#     --output [structural_labeled.nii,POSTERIOR_%02d.nii.gz]
+#     --posterior-formulation Socrates[1] --use-random-seed 1'
+# 
+#     >>> at = Atropos(
+#     ...     dimension=3, intensity_images='structural.nii', mask_image='mask.nii',
+#     ...     number_of_tissue_classes=2, likelihood_model='Gaussian', save_posteriors=True,
+#     ...     mrf_smoothing_factor=0.2, mrf_radius=[1, 1, 1], icm_use_synchronous_update=True,
+#     ...     maximum_number_of_icm_terations=1, n_iterations=5, convergence_threshold=0.000001,
+#     ...     posterior_formulation='Socrates', use_mixture_model_proportions=True)
+#     >>> at.inputs.initialization = 'PriorLabelImage'
+#     >>> at.inputs.prior_image = 'segmentation0.nii.gz'
+#     >>> at.inputs.number_of_tissue_classes = 2
+#     >>> at.inputs.prior_weighting = 0.8
+#     >>> at.cmdline
+#     'Atropos --image-dimensionality 3 --icm [1,1]
+#     --initialization PriorLabelImage[2,segmentation0.nii.gz,0.8] --intensity-image structural.nii
+#     --likelihood-model Gaussian --mask-image mask.nii --mrf [0.2,1x1x1] --convergence [5,1e-06]
+#     --output [structural_labeled.nii,POSTERIOR_%02d.nii.gz] --posterior-formulation Socrates[1]
+#     --use-random-seed 1'
+# 
+#     
+task_name: Atropos
+nipype_name: Atropos
+nipype_module: nipype.interfaces.ants.segmentation
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    intensity_images: medimage/nifti1+list-of
+    # type=inputmultiobject|default=[]: 
+    mask_image: medimage/nifti1
+    # type=file|default=<undefined>: 
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    classified_image: generic/file
+    # type=file: 
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_classified_image_name: out_classified_image_name
+    # type=file|default=<undefined>: 
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    dimension:
+    # type=enum|default=3|allowed[2,3,4]: image dimension (2, 3, or 4)
+    intensity_images:
+    # type=inputmultiobject|default=[]: 
+    mask_image:
+    # type=file|default=<undefined>: 
+    initialization:
+    # type=enum|default='Random'|allowed['KMeans','Otsu','PriorLabelImage','PriorProbabilityImages','Random']: 
+    kmeans_init_centers:
+    # type=list|default=[]: 
+    prior_image:
+    # type=traitcompound|default=None: either a string pattern (e.g., 'prior%02d.nii') or an existing vector-image file.
+    number_of_tissue_classes:
+    # type=int|default=0: 
+    prior_weighting:
+    # type=float|default=0.0: 
+    prior_probability_threshold:
+    # type=float|default=0.0: 
+    likelihood_model:
+    # type=str|default='': 
+    mrf_smoothing_factor:
+    # type=float|default=0.0: 
+    mrf_radius:
+    # type=list|default=[]: 
+    icm_use_synchronous_update:
+    # type=bool|default=False: 
+    maximum_number_of_icm_terations:
+    # type=int|default=0: 
+    n_iterations:
+    # type=int|default=0: 
+    convergence_threshold:
+    # type=float|default=0.0: 
+    posterior_formulation:
+    # type=str|default='': 
+    use_random_seed:
+    # type=bool|default=True: use random seed value over constant
+    use_mixture_model_proportions:
+    # type=bool|default=False: 
+    out_classified_image_name:
+    # type=file|default=<undefined>: 
+    save_posteriors:
+    # type=bool|default=False: 
+    output_posteriors_name_template:
+    # type=str|default='POSTERIOR_%02d.nii.gz': 
+    num_threads:
+    # type=int|default=1: Number of ITK threads to use
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    initialization: '"Random"'
+    # type=enum|default='Random'|allowed['KMeans','Otsu','PriorLabelImage','PriorProbabilityImages','Random']: 
+    dimension: '3'
+    # type=enum|default=3|allowed[2,3,4]: image dimension (2, 3, or 4)
+    intensity_images:
+    # type=inputmultiobject|default=[]: 
+    mask_image:
+    # type=file|default=<undefined>: 
+    number_of_tissue_classes: '2'
+    # type=int|default=0: 
+    likelihood_model: '"Gaussian"'
+    # type=str|default='': 
+    save_posteriors: 'True'
+    # type=bool|default=False: 
+    mrf_smoothing_factor: '0.2'
+    # type=float|default=0.0: 
+    mrf_radius: '[1, 1, 1]'
+    # type=list|default=[]: 
+    icm_use_synchronous_update: 'True'
+    # type=bool|default=False: 
+    maximum_number_of_icm_terations: '1'
+    # type=int|default=0: 
+    n_iterations: '5'
+    # type=int|default=0: 
+    convergence_threshold: '0.000001'
+    # type=float|default=0.0: 
+    posterior_formulation: '"Socrates"'
+    # type=str|default='': 
+    use_mixture_model_proportions: 'True'
+    # type=bool|default=False: 
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    initialization: '"KMeans"'
+    # type=enum|default='Random'|allowed['KMeans','Otsu','PriorLabelImage','PriorProbabilityImages','Random']: 
+    kmeans_init_centers: '[100, 200]'
+    # type=list|default=[]: 
+    dimension: '3'
+    # type=enum|default=3|allowed[2,3,4]: image dimension (2, 3, or 4)
+    intensity_images:
+    # type=inputmultiobject|default=[]: 
+    mask_image:
+    # type=file|default=<undefined>: 
+    number_of_tissue_classes: '2'
+    # type=int|default=0: 
+    likelihood_model: '"Gaussian"'
+    # type=str|default='': 
+    save_posteriors: 'True'
+    # type=bool|default=False: 
+    mrf_smoothing_factor: '0.2'
+    # type=float|default=0.0: 
+    mrf_radius: '[1, 1, 1]'
+    # type=list|default=[]: 
+    icm_use_synchronous_update: 'True'
+    # type=bool|default=False: 
+    maximum_number_of_icm_terations: '1'
+    # type=int|default=0: 
+    n_iterations: '5'
+    # type=int|default=0: 
+    convergence_threshold: '0.000001'
+    # type=float|default=0.0: 
+    posterior_formulation: '"Socrates"'
+    # type=str|default='': 
+    use_mixture_model_proportions: 'True'
+    # type=bool|default=False: 
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    initialization: '"PriorProbabilityImages"'
+    # type=enum|default='Random'|allowed['KMeans','Otsu','PriorLabelImage','PriorProbabilityImages','Random']: 
+    prior_image: '"BrainSegmentationPrior%02d.nii.gz"'
+    # type=traitcompound|default=None: either a string pattern (e.g., 'prior%02d.nii') or an existing vector-image file.
+    prior_weighting: '0.8'
+    # type=float|default=0.0: 
+    prior_probability_threshold: '0.0000001'
+    # type=float|default=0.0: 
+    dimension: '3'
+    # type=enum|default=3|allowed[2,3,4]: image dimension (2, 3, or 4)
+    intensity_images:
+    # type=inputmultiobject|default=[]: 
+    mask_image:
+    # type=file|default=<undefined>: 
+    number_of_tissue_classes: '2'
+    # type=int|default=0: 
+    likelihood_model: '"Gaussian"'
+    # type=str|default='': 
+    save_posteriors: 'True'
+    # type=bool|default=False: 
+    mrf_smoothing_factor: '0.2'
+    # type=float|default=0.0: 
+    mrf_radius: '[1, 1, 1]'
+    # type=list|default=[]: 
+    icm_use_synchronous_update: 'True'
+    # type=bool|default=False: 
+    maximum_number_of_icm_terations: '1'
+    # type=int|default=0: 
+    n_iterations: '5'
+    # type=int|default=0: 
+    convergence_threshold: '0.000001'
+    # type=float|default=0.0: 
+    posterior_formulation: '"Socrates"'
+    # type=str|default='': 
+    use_mixture_model_proportions: 'True'
+    # type=bool|default=False: 
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    initialization: '"PriorLabelImage"'
+    # type=enum|default='Random'|allowed['KMeans','Otsu','PriorLabelImage','PriorProbabilityImages','Random']: 
+    prior_image: '"segmentation0.nii.gz"'
+    # type=traitcompound|default=None: either a string pattern (e.g., 'prior%02d.nii') or an existing vector-image file.
+    number_of_tissue_classes: '2'
+    # type=int|default=0: 
+    prior_weighting: '0.8'
+    # type=float|default=0.0: 
+    dimension: '3'
+    # type=enum|default=3|allowed[2,3,4]: image dimension (2, 3, or 4)
+    intensity_images:
+    # type=inputmultiobject|default=[]: 
+    mask_image:
+    # type=file|default=<undefined>: 
+    likelihood_model: '"Gaussian"'
+    # type=str|default='': 
+    save_posteriors: 'True'
+    # type=bool|default=False: 
+    mrf_smoothing_factor: '0.2'
+    # type=float|default=0.0: 
+    mrf_radius: '[1, 1, 1]'
+    # type=list|default=[]: 
+    icm_use_synchronous_update: 'True'
+    # type=bool|default=False: 
+    maximum_number_of_icm_terations: '1'
+    # type=int|default=0: 
+    n_iterations: '5'
+    # type=int|default=0: 
+    convergence_threshold: '0.000001'
+    # type=float|default=0.0: 
+    posterior_formulation: '"Socrates"'
+    # type=str|default='': 
+    use_mixture_model_proportions: 'True'
+    # type=bool|default=False: 
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: Atropos --image-dimensionality 3 --icm [1,1] --initialization Random[2] --intensity-image structural.nii --likelihood-model Gaussian --mask-image mask.nii --mrf [0.2,1x1x1] --convergence [5,1e-06] --output [structural_labeled.nii,POSTERIOR_%02d.nii.gz] --posterior-formulation Socrates[1] --use-random-seed 1
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    initialization: '"Random"'
+    # type=enum|default='Random'|allowed['KMeans','Otsu','PriorLabelImage','PriorProbabilityImages','Random']: 
+    dimension: '3'
+    # type=enum|default=3|allowed[2,3,4]: image dimension (2, 3, or 4)
+    intensity_images:
+    # type=inputmultiobject|default=[]: 
+    mask_image:
+    # type=file|default=<undefined>: 
+    number_of_tissue_classes: '2'
+    # type=int|default=0: 
+    likelihood_model: '"Gaussian"'
+    # type=str|default='': 
+    save_posteriors: 'True'
+    # type=bool|default=False: 
+    mrf_smoothing_factor: '0.2'
+    # type=float|default=0.0: 
+    mrf_radius: '[1, 1, 1]'
+    # type=list|default=[]: 
+    icm_use_synchronous_update: 'True'
+    # type=bool|default=False: 
+    maximum_number_of_icm_terations: '1'
+    # type=int|default=0: 
+    n_iterations: '5'
+    # type=int|default=0: 
+    convergence_threshold: '0.000001'
+    # type=float|default=0.0: 
+    posterior_formulation: '"Socrates"'
+    # type=str|default='': 
+    use_mixture_model_proportions: 'True'
+    # type=bool|default=False: 
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: Atropos --image-dimensionality 3 --icm [1,1] --initialization KMeans[2,100,200] --intensity-image structural.nii --likelihood-model Gaussian --mask-image mask.nii --mrf [0.2,1x1x1] --convergence [5,1e-06] --output [structural_labeled.nii,POSTERIOR_%02d.nii.gz] --posterior-formulation Socrates[1] --use-random-seed 1
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    initialization: '"KMeans"'
+    # type=enum|default='Random'|allowed['KMeans','Otsu','PriorLabelImage','PriorProbabilityImages','Random']: 
+    kmeans_init_centers: '[100, 200]'
+    # type=list|default=[]: 
+    dimension: '3'
+    # type=enum|default=3|allowed[2,3,4]: image dimension (2, 3, or 4)
+    intensity_images:
+    # type=inputmultiobject|default=[]: 
+    mask_image:
+    # type=file|default=<undefined>: 
+    number_of_tissue_classes: '2'
+    # type=int|default=0: 
+    likelihood_model: '"Gaussian"'
+    # type=str|default='': 
+    save_posteriors: 'True'
+    # type=bool|default=False: 
+    mrf_smoothing_factor: '0.2'
+    # type=float|default=0.0: 
+    mrf_radius: '[1, 1, 1]'
+    # type=list|default=[]: 
+    icm_use_synchronous_update: 'True'
+    # type=bool|default=False: 
+    maximum_number_of_icm_terations: '1'
+    # type=int|default=0: 
+    n_iterations: '5'
+    # type=int|default=0: 
+    convergence_threshold: '0.000001'
+    # type=float|default=0.0: 
+    posterior_formulation: '"Socrates"'
+    # type=str|default='': 
+    use_mixture_model_proportions: 'True'
+    # type=bool|default=False: 
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: Atropos --image-dimensionality 3 --icm [1,1] --initialization PriorProbabilityImages[2,BrainSegmentationPrior%02d.nii.gz,0.8,1e-07] --intensity-image structural.nii --likelihood-model Gaussian --mask-image mask.nii --mrf [0.2,1x1x1] --convergence [5,1e-06] --output [structural_labeled.nii,POSTERIOR_%02d.nii.gz] --posterior-formulation Socrates[1] --use-random-seed 1
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    initialization: '"PriorProbabilityImages"'
+    # type=enum|default='Random'|allowed['KMeans','Otsu','PriorLabelImage','PriorProbabilityImages','Random']: 
+    prior_image: '"BrainSegmentationPrior%02d.nii.gz"'
+    # type=traitcompound|default=None: either a string pattern (e.g., 'prior%02d.nii') or an existing vector-image file.
+    prior_weighting: '0.8'
+    # type=float|default=0.0: 
+    prior_probability_threshold: '0.0000001'
+    # type=float|default=0.0: 
+    dimension: '3'
+    # type=enum|default=3|allowed[2,3,4]: image dimension (2, 3, or 4)
+    intensity_images:
+    # type=inputmultiobject|default=[]: 
+    mask_image:
+    # type=file|default=<undefined>: 
+    number_of_tissue_classes: '2'
+    # type=int|default=0: 
+    likelihood_model: '"Gaussian"'
+    # type=str|default='': 
+    save_posteriors: 'True'
+    # type=bool|default=False: 
+    mrf_smoothing_factor: '0.2'
+    # type=float|default=0.0: 
+    mrf_radius: '[1, 1, 1]'
+    # type=list|default=[]: 
+    icm_use_synchronous_update: 'True'
+    # type=bool|default=False: 
+    maximum_number_of_icm_terations: '1'
+    # type=int|default=0: 
+    n_iterations: '5'
+    # type=int|default=0: 
+    convergence_threshold: '0.000001'
+    # type=float|default=0.0: 
+    posterior_formulation: '"Socrates"'
+    # type=str|default='': 
+    use_mixture_model_proportions: 'True'
+    # type=bool|default=False: 
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: Atropos --image-dimensionality 3 --icm [1,1] --initialization PriorLabelImage[2,segmentation0.nii.gz,0.8] --intensity-image structural.nii --likelihood-model Gaussian --mask-image mask.nii --mrf [0.2,1x1x1] --convergence [5,1e-06] --output [structural_labeled.nii,POSTERIOR_%02d.nii.gz] --posterior-formulation Socrates[1] --use-random-seed 1
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    initialization: '"PriorLabelImage"'
+    # type=enum|default='Random'|allowed['KMeans','Otsu','PriorLabelImage','PriorProbabilityImages','Random']: 
+    prior_image: '"segmentation0.nii.gz"'
+    # type=traitcompound|default=None: either a string pattern (e.g., 'prior%02d.nii') or an existing vector-image file.
+    number_of_tissue_classes: '2'
+    # type=int|default=0: 
+    prior_weighting: '0.8'
+    # type=float|default=0.0: 
+    dimension: '3'
+    # type=enum|default=3|allowed[2,3,4]: image dimension (2, 3, or 4)
+    intensity_images:
+    # type=inputmultiobject|default=[]: 
+    mask_image:
+    # type=file|default=<undefined>: 
+    likelihood_model: '"Gaussian"'
+    # type=str|default='': 
+    save_posteriors: 'True'
+    # type=bool|default=False: 
+    mrf_smoothing_factor: '0.2'
+    # type=float|default=0.0: 
+    mrf_radius: '[1, 1, 1]'
+    # type=list|default=[]: 
+    icm_use_synchronous_update: 'True'
+    # type=bool|default=False: 
+    maximum_number_of_icm_terations: '1'
+    # type=int|default=0: 
+    n_iterations: '5'
+    # type=int|default=0: 
+    convergence_threshold: '0.000001'
+    # type=float|default=0.0: 
+    posterior_formulation: '"Socrates"'
+    # type=str|default='': 
+    use_mixture_model_proportions: 'True'
+    # type=bool|default=False: 
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-ants/atropos_callables.py b/example-specs/task/nipype_internal/pydra-ants/atropos_callables.py
new file mode 100644
index 00000000..93f87cd6
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-ants/atropos_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Atropos.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-ants/average_affine_transform.yaml b/example-specs/task/nipype_internal/pydra-ants/average_affine_transform.yaml
new file mode 100644
index 00000000..57d00c5d
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-ants/average_affine_transform.yaml
@@ -0,0 +1,132 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.ants.utils.AverageAffineTransform' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces.ants import AverageAffineTransform
+#     >>> avg = AverageAffineTransform()
+#     >>> avg.inputs.dimension = 3
+#     >>> avg.inputs.transforms = ['trans.mat', 'func_to_struct.mat']
+#     >>> avg.inputs.output_affine_transform = 'MYtemplatewarp.mat'
+#     >>> avg.cmdline
+#     'AverageAffineTransform 3 MYtemplatewarp.mat trans.mat func_to_struct.mat'
+# 
+#     
+task_name: AverageAffineTransform
+nipype_name: AverageAffineTransform
+nipype_module: nipype.interfaces.ants.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    output_affine_transform: datascience/text-matrix
+    # type=file|default=<undefined>: Outputfname.txt: the name of the resulting transform.
+    transforms: datascience/text-matrix+list-of
+    # type=inputmultiobject|default=[]: transforms to average
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    affine_transform: generic/file
+    # type=file: average transform file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    dimension:
+    # type=enum|default=3|allowed[2,3]: image dimension (2 or 3)
+    output_affine_transform:
+    # type=file|default=<undefined>: Outputfname.txt: the name of the resulting transform.
+    transforms:
+    # type=inputmultiobject|default=[]: transforms to average
+    num_threads:
+    # type=int|default=1: Number of ITK threads to use
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    dimension: '3'
+    # type=enum|default=3|allowed[2,3]: image dimension (2 or 3)
+    transforms:
+    # type=inputmultiobject|default=[]: transforms to average
+    output_affine_transform:
+    # type=file|default=<undefined>: Outputfname.txt: the name of the resulting transform.
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: AverageAffineTransform 3 MYtemplatewarp.mat trans.mat func_to_struct.mat
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    dimension: '3'
+    # type=enum|default=3|allowed[2,3]: image dimension (2 or 3)
+    transforms:
+    # type=inputmultiobject|default=[]: transforms to average
+    output_affine_transform:
+    # type=file|default=<undefined>: Outputfname.txt: the name of the resulting transform.
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-ants/average_affine_transform_callables.py b/example-specs/task/nipype_internal/pydra-ants/average_affine_transform_callables.py
new file mode 100644
index 00000000..5ee02575
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-ants/average_affine_transform_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in AverageAffineTransform.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-ants/average_images.yaml b/example-specs/task/nipype_internal/pydra-ants/average_images.yaml
new file mode 100644
index 00000000..12b3b9ee
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-ants/average_images.yaml
@@ -0,0 +1,143 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.ants.utils.AverageImages' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces.ants import AverageImages
+#     >>> avg = AverageImages()
+#     >>> avg.inputs.dimension = 3
+#     >>> avg.inputs.output_average_image = "average.nii.gz"
+#     >>> avg.inputs.normalize = True
+#     >>> avg.inputs.images = ['rc1s1.nii', 'rc1s1.nii']
+#     >>> avg.cmdline
+#     'AverageImages 3 average.nii.gz 1 rc1s1.nii rc1s1.nii'
+#     
+task_name: AverageImages
+nipype_name: AverageImages
+nipype_module: nipype.interfaces.ants.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    output_average_image: medimage/nifti-gz
+    # type=file: average image file
+    # type=file|default='average.nii': the name of the resulting image.
+    images: medimage/nifti1+list-of
+    # type=inputmultiobject|default=[]: image to apply transformation to (generally a coregistered functional)
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    output_average_image: medimage/nifti-gz
+    # type=file: average image file
+    # type=file|default='average.nii': the name of the resulting image.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    dimension:
+    # type=enum|default=3|allowed[2,3]: image dimension (2 or 3)
+    output_average_image:
+    # type=file: average image file
+    # type=file|default='average.nii': the name of the resulting image.
+    normalize:
+    # type=bool|default=False: Normalize: if true, the 2nd image is divided by its mean. This will select the largest image to average into.
+    images:
+    # type=inputmultiobject|default=[]: image to apply transformation to (generally a coregistered functional)
+    num_threads:
+    # type=int|default=1: Number of ITK threads to use
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    dimension: '3'
+    # type=enum|default=3|allowed[2,3]: image dimension (2 or 3)
+    output_average_image:
+    # type=file: average image file
+    # type=file|default='average.nii': the name of the resulting image.
+    normalize: 'True'
+    # type=bool|default=False: Normalize: if true, the 2nd image is divided by its mean. This will select the largest image to average into.
+    images:
+    # type=inputmultiobject|default=[]: image to apply transformation to (generally a coregistered functional)
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: AverageImages 3 average.nii.gz 1 rc1s1.nii rc1s1.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    dimension: '3'
+    # type=enum|default=3|allowed[2,3]: image dimension (2 or 3)
+    output_average_image:
+    # type=file: average image file
+    # type=file|default='average.nii': the name of the resulting image.
+    normalize: 'True'
+    # type=bool|default=False: Normalize: if true, the 2nd image is divided by its mean. This will select the largest image to average into.
+    images:
+    # type=inputmultiobject|default=[]: image to apply transformation to (generally a coregistered functional)
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-ants/average_images_callables.py b/example-specs/task/nipype_internal/pydra-ants/average_images_callables.py
new file mode 100644
index 00000000..8d6e9a0f
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-ants/average_images_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in AverageImages.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-ants/brain_extraction.yaml b/example-specs/task/nipype_internal/pydra-ants/brain_extraction.yaml
new file mode 100644
index 00000000..0cec473b
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-ants/brain_extraction.yaml
@@ -0,0 +1,194 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.ants.segmentation.BrainExtraction' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Atlas-based brain extraction.
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces.ants.segmentation import BrainExtraction
+#     >>> brainextraction = BrainExtraction()
+#     >>> brainextraction.inputs.dimension = 3
+#     >>> brainextraction.inputs.anatomical_image ='T1.nii.gz'
+#     >>> brainextraction.inputs.brain_template = 'study_template.nii.gz'
+#     >>> brainextraction.inputs.brain_probability_mask ='ProbabilityMaskOfStudyTemplate.nii.gz'
+#     >>> brainextraction.cmdline
+#     'antsBrainExtraction.sh -a T1.nii.gz -m ProbabilityMaskOfStudyTemplate.nii.gz
+#     -e study_template.nii.gz -d 3 -s nii.gz -o highres001_'
+# 
+#     
+task_name: BrainExtraction
+nipype_name: BrainExtraction
+nipype_module: nipype.interfaces.ants.segmentation
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    anatomical_image: medimage/nifti-gz
+    # type=file|default=<undefined>: Structural image, typically T1.  If more than one anatomical image is specified, subsequently specified images are used during the segmentation process.  However, only the first image is used in the registration of priors. Our suggestion would be to specify the T1 as the first image. Anatomical template created using e.g. LPBA40 data set with buildtemplateparallel.sh in ANTs.
+    brain_template: medimage/nifti-gz
+    # type=file|default=<undefined>: Anatomical template created using e.g. LPBA40 data set with buildtemplateparallel.sh in ANTs.
+    brain_probability_mask: medimage/nifti-gz
+    # type=file|default=<undefined>: Brain probability mask created using e.g. LPBA40 data set which have brain masks defined, and warped to anatomical template and averaged resulting in a probability image.
+    extraction_registration_mask: generic/file
+    # type=file|default=<undefined>: Mask (defined in the template space) used during registration for brain extraction. To limit the metric computation to a specific region.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    BrainExtractionMask: generic/file
+    # type=file: brain extraction mask
+    BrainExtractionBrain: generic/file
+    # type=file: brain extraction image
+    BrainExtractionCSF: generic/file
+    # type=file: segmentation mask with only CSF
+    BrainExtractionGM: generic/file
+    # type=file: segmentation mask with only grey matter
+    BrainExtractionInitialAffine: generic/file
+    # type=file: 
+    BrainExtractionInitialAffineFixed: generic/file
+    # type=file: 
+    BrainExtractionInitialAffineMoving: generic/file
+    # type=file: 
+    BrainExtractionLaplacian: generic/file
+    # type=file: 
+    BrainExtractionPrior0GenericAffine: generic/file
+    # type=file: 
+    BrainExtractionPrior1InverseWarp: generic/file
+    # type=file: 
+    BrainExtractionPrior1Warp: generic/file
+    # type=file: 
+    BrainExtractionPriorWarped: generic/file
+    # type=file: 
+    BrainExtractionSegmentation: generic/file
+    # type=file: segmentation mask with CSF, GM, and WM
+    BrainExtractionTemplateLaplacian: generic/file
+    # type=file: 
+    BrainExtractionTmp: generic/file
+    # type=file: 
+    BrainExtractionWM: generic/file
+    # type=file: segmenration mask with only white matter
+    N4Corrected0: generic/file
+    # type=file: N4 bias field corrected image
+    N4Truncated0: generic/file
+    # type=file: 
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    dimension:
+    # type=enum|default=3|allowed[2,3]: image dimension (2 or 3)
+    anatomical_image:
+    # type=file|default=<undefined>: Structural image, typically T1.  If more than one anatomical image is specified, subsequently specified images are used during the segmentation process.  However, only the first image is used in the registration of priors. Our suggestion would be to specify the T1 as the first image. Anatomical template created using e.g. LPBA40 data set with buildtemplateparallel.sh in ANTs.
+    brain_template:
+    # type=file|default=<undefined>: Anatomical template created using e.g. LPBA40 data set with buildtemplateparallel.sh in ANTs.
+    brain_probability_mask:
+    # type=file|default=<undefined>: Brain probability mask created using e.g. LPBA40 data set which have brain masks defined, and warped to anatomical template and averaged resulting in a probability image.
+    out_prefix:
+    # type=str|default='highres001_': Prefix that is prepended to all output files
+    extraction_registration_mask:
+    # type=file|default=<undefined>: Mask (defined in the template space) used during registration for brain extraction. To limit the metric computation to a specific region.
+    image_suffix:
+    # type=str|default='nii.gz': any of standard ITK formats, nii.gz is default
+    use_random_seeding:
+    # type=enum|default=0|allowed[0,1]: Use random number generated from system clock in Atropos (default = 1)
+    keep_temporary_files:
+    # type=int|default=0: Keep brain extraction/segmentation warps, etc (default = 0).
+    use_floatingpoint_precision:
+    # type=enum|default=0|allowed[0,1]: Use floating point precision in registrations (default = 0)
+    debug:
+    # type=bool|default=False: If > 0, runs a faster version of the script. Only for testing. Implies -u 0. Requires single thread computation for complete reproducibility.
+    num_threads:
+    # type=int|default=1: Number of ITK threads to use
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    dimension: '3'
+    # type=enum|default=3|allowed[2,3]: image dimension (2 or 3)
+    anatomical_image:
+    # type=file|default=<undefined>: Structural image, typically T1.  If more than one anatomical image is specified, subsequently specified images are used during the segmentation process.  However, only the first image is used in the registration of priors. Our suggestion would be to specify the T1 as the first image. Anatomical template created using e.g. LPBA40 data set with buildtemplateparallel.sh in ANTs.
+    brain_template:
+    # type=file|default=<undefined>: Anatomical template created using e.g. LPBA40 data set with buildtemplateparallel.sh in ANTs.
+    brain_probability_mask:
+    # type=file|default=<undefined>: Brain probability mask created using e.g. LPBA40 data set which have brain masks defined, and warped to anatomical template and averaged resulting in a probability image.
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: antsBrainExtraction.sh -a T1.nii.gz -m ProbabilityMaskOfStudyTemplate.nii.gz -e study_template.nii.gz -d 3 -s nii.gz -o highres001_
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    dimension: '3'
+    # type=enum|default=3|allowed[2,3]: image dimension (2 or 3)
+    anatomical_image:
+    # type=file|default=<undefined>: Structural image, typically T1.  If more than one anatomical image is specified, subsequently specified images are used during the segmentation process.  However, only the first image is used in the registration of priors. Our suggestion would be to specify the T1 as the first image. Anatomical template created using e.g. LPBA40 data set with buildtemplateparallel.sh in ANTs.
+    brain_template:
+    # type=file|default=<undefined>: Anatomical template created using e.g. LPBA40 data set with buildtemplateparallel.sh in ANTs.
+    brain_probability_mask:
+    # type=file|default=<undefined>: Brain probability mask created using e.g. LPBA40 data set which have brain masks defined, and warped to anatomical template and averaged resulting in a probability image.
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-ants/brain_extraction_callables.py b/example-specs/task/nipype_internal/pydra-ants/brain_extraction_callables.py
new file mode 100644
index 00000000..88a7a0b8
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-ants/brain_extraction_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in BrainExtraction.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-ants/buildtemplateparallel.yaml b/example-specs/task/nipype_internal/pydra-ants/buildtemplateparallel.yaml
new file mode 100644
index 00000000..82938fed
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-ants/buildtemplateparallel.yaml
@@ -0,0 +1,151 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.ants.legacy.buildtemplateparallel' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Generate a optimal average template
+# 
+#     .. warning::
+# 
+#       This can take a VERY long time to complete
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces.ants.legacy import buildtemplateparallel
+#     >>> tmpl = buildtemplateparallel()
+#     >>> tmpl.inputs.in_files = ['T1.nii', 'structural.nii']
+#     >>> tmpl.inputs.max_iterations = [30, 90, 20]
+#     >>> tmpl.cmdline
+#     'buildtemplateparallel.sh -d 3 -i 4 -m 30x90x20 -o antsTMPL_ -c 0 -t GR T1.nii structural.nii'
+# 
+#     
+task_name: buildtemplateparallel
+nipype_name: buildtemplateparallel
+nipype_module: nipype.interfaces.ants.legacy
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_files: medimage/nifti1+list-of
+    # type=list|default=[]: list of images to generate template from
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    final_template_file: generic/file
+    # type=file: final ANTS template
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    dimension:
+    # type=enum|default=3|allowed[2,3,4]: image dimension (2, 3 or 4)
+    out_prefix:
+    # type=str|default='antsTMPL_': Prefix that is prepended to all output files (default = antsTMPL_)
+    in_files:
+    # type=list|default=[]: list of images to generate template from
+    parallelization:
+    # type=enum|default=0|allowed[0,1,2]: control for parallel processing (0 = serial, 1 = use PBS, 2 = use PEXEC, 3 = use Apple XGrid
+    gradient_step_size:
+    # type=float|default=0.0: smaller magnitude results in more cautious steps (default = .25)
+    iteration_limit:
+    # type=int|default=4: iterations of template construction
+    num_cores:
+    # type=int|default=0: Requires parallelization = 2 (PEXEC). Sets number of cpu cores to use
+    max_iterations:
+    # type=list|default=[]: maximum number of iterations (must be list of integers in the form [J,K,L...]: J = coarsest resolution iterations, K = middle resolution iterations, L = fine resolution iterations
+    bias_field_correction:
+    # type=bool|default=False: Applies bias field correction to moving image
+    rigid_body_registration:
+    # type=bool|default=False: registers inputs before creating template (useful if no initial template available)
+    similarity_metric:
+    # type=enum|default='PR'|allowed['CC','MI','MSQ','PR']: Type of similartiy metric used for registration (CC = cross correlation, MI = mutual information, PR = probability mapping, MSQ = mean square difference)
+    transformation_model:
+    # type=enum|default='GR'|allowed['DD','EL','EX','GR','S2','SY']: Type of transofmration model used for registration (EL = elastic transformation model, SY = SyN with time, arbitrary number of time points, S2 =  SyN with time optimized for 2 time points, GR = greedy SyN, EX = exponential, DD = diffeomorphic demons style exponential mapping
+    use_first_as_target:
+    # type=bool|default=False: uses first volume as target of all inputs. When not used, an unbiased average image is used to start.
+    num_threads:
+    # type=int|default=1: Number of ITK threads to use
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_files:
+    # type=list|default=[]: list of images to generate template from
+    max_iterations: '[30, 90, 20]'
+    # type=list|default=[]: maximum number of iterations (must be list of integers in the form [J,K,L...]: J = coarsest resolution iterations, K = middle resolution iterations, L = fine resolution iterations
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: buildtemplateparallel.sh -d 3 -i 4 -m 30x90x20 -o antsTMPL_ -c 0 -t GR T1.nii structural.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_files:
+    # type=list|default=[]: list of images to generate template from
+    max_iterations: '[30, 90, 20]'
+    # type=list|default=[]: maximum number of iterations (must be list of integers in the form [J,K,L...]: J = coarsest resolution iterations, K = middle resolution iterations, L = fine resolution iterations
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-ants/buildtemplateparallel_callables.py b/example-specs/task/nipype_internal/pydra-ants/buildtemplateparallel_callables.py
new file mode 100644
index 00000000..7ba280c9
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-ants/buildtemplateparallel_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in buildtemplateparallel.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-ants/compose_multi_transform.yaml b/example-specs/task/nipype_internal/pydra-ants/compose_multi_transform.yaml
new file mode 100644
index 00000000..77defaa4
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-ants/compose_multi_transform.yaml
@@ -0,0 +1,137 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.ants.utils.ComposeMultiTransform' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Take a set of transformations and convert them to a single transformation matrix/warpfield.
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces.ants import ComposeMultiTransform
+#     >>> compose_transform = ComposeMultiTransform()
+#     >>> compose_transform.inputs.dimension = 3
+#     >>> compose_transform.inputs.transforms = ['struct_to_template.mat', 'func_to_struct.mat']
+#     >>> compose_transform.cmdline
+#     'ComposeMultiTransform 3 struct_to_template_composed.mat
+#     struct_to_template.mat func_to_struct.mat'
+# 
+#     
+task_name: ComposeMultiTransform
+nipype_name: ComposeMultiTransform
+nipype_module: nipype.interfaces.ants.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    output_transform: generic/file
+    # type=file: Composed transform file
+    # type=file|default=<undefined>: the name of the resulting transform.
+    reference_image: generic/file
+    # type=file|default=<undefined>: Reference image (only necessary when output is warpfield)
+    transforms: datascience/text-matrix+list-of
+    # type=inputmultiobject|default=[]: transforms to average
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    output_transform: generic/file
+    # type=file: Composed transform file
+    # type=file|default=<undefined>: the name of the resulting transform.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    dimension:
+    # type=enum|default=3|allowed[2,3]: image dimension (2 or 3)
+    output_transform:
+    # type=file: Composed transform file
+    # type=file|default=<undefined>: the name of the resulting transform.
+    reference_image:
+    # type=file|default=<undefined>: Reference image (only necessary when output is warpfield)
+    transforms:
+    # type=inputmultiobject|default=[]: transforms to average
+    num_threads:
+    # type=int|default=1: Number of ITK threads to use
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    dimension: '3'
+    # type=enum|default=3|allowed[2,3]: image dimension (2 or 3)
+    transforms:
+    # type=inputmultiobject|default=[]: transforms to average
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: ComposeMultiTransform 3 struct_to_template_composed.mat struct_to_template.mat func_to_struct.mat
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    dimension: '3'
+    # type=enum|default=3|allowed[2,3]: image dimension (2 or 3)
+    transforms:
+    # type=inputmultiobject|default=[]: transforms to average
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-ants/compose_multi_transform_callables.py b/example-specs/task/nipype_internal/pydra-ants/compose_multi_transform_callables.py
new file mode 100644
index 00000000..88052b58
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-ants/compose_multi_transform_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in ComposeMultiTransform.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-ants/composite_transform_util.yaml b/example-specs/task/nipype_internal/pydra-ants/composite_transform_util.yaml
new file mode 100644
index 00000000..5dc89255
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-ants/composite_transform_util.yaml
@@ -0,0 +1,194 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.ants.registration.CompositeTransformUtil' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     ANTs utility which can combine or break apart transform files into their individual
+#     constituent components.
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces.ants import CompositeTransformUtil
+#     >>> tran = CompositeTransformUtil()
+#     >>> tran.inputs.process = 'disassemble'
+#     >>> tran.inputs.in_file = 'output_Composite.h5'
+#     >>> tran.cmdline
+#     'CompositeTransformUtil --disassemble output_Composite.h5 transform'
+#     >>> tran.run()  # doctest: +SKIP
+# 
+#     example for assembling transformation files
+# 
+#     >>> from nipype.interfaces.ants import CompositeTransformUtil
+#     >>> tran = CompositeTransformUtil()
+#     >>> tran.inputs.process = 'assemble'
+#     >>> tran.inputs.out_file = 'my.h5'
+#     >>> tran.inputs.in_file = ['AffineTransform.mat', 'DisplacementFieldTransform.nii.gz']
+#     >>> tran.cmdline
+#     'CompositeTransformUtil --assemble my.h5 AffineTransform.mat DisplacementFieldTransform.nii.gz '
+#     >>> tran.run()  # doctest: +SKIP
+#     
+task_name: CompositeTransformUtil
+nipype_name: CompositeTransformUtil
+nipype_module: nipype.interfaces.ants.registration
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: datascience/hdf5
+    # type=file: Compound transformation file
+    # type=file|default=<undefined>: Output file path (only used for disassembly).
+    in_file: '[datascience/text-matrix,datascience/hdf5]+list-of'
+    # type=inputmultiobject|default=[]: Input transform file(s)
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    affine_transform: generic/file
+    # type=file: Affine transform component
+    displacement_field: generic/file
+    # type=file: Displacement field component
+    out_file: datascience/hdf5
+    # type=file: Compound transformation file
+    # type=file|default=<undefined>: Output file path (only used for disassembly).
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    process:
+    # type=enum|default='assemble'|allowed['assemble','disassemble']: What to do with the transform inputs (assemble or disassemble)
+    out_file:
+    # type=file: Compound transformation file
+    # type=file|default=<undefined>: Output file path (only used for disassembly).
+    in_file:
+    # type=inputmultiobject|default=[]: Input transform file(s)
+    output_prefix:
+    # type=str|default='transform': A prefix that is prepended to all output files (only used for assembly).
+    num_threads:
+    # type=int|default=1: Number of ITK threads to use
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    process: '"disassemble"'
+    # type=enum|default='assemble'|allowed['assemble','disassemble']: What to do with the transform inputs (assemble or disassemble)
+    in_file:
+    # type=inputmultiobject|default=[]: Input transform file(s)
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    process: '"assemble"'
+    # type=enum|default='assemble'|allowed['assemble','disassemble']: What to do with the transform inputs (assemble or disassemble)
+    out_file:
+    # type=file: Compound transformation file
+    # type=file|default=<undefined>: Output file path (only used for disassembly).
+    in_file:
+    # type=inputmultiobject|default=[]: Input transform file(s)
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: CompositeTransformUtil --disassemble output_Composite.h5 transform
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    process: '"disassemble"'
+    # type=enum|default='assemble'|allowed['assemble','disassemble']: What to do with the transform inputs (assemble or disassemble)
+    in_file:
+    # type=inputmultiobject|default=[]: Input transform file(s)
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: 'CompositeTransformUtil --assemble my.h5 AffineTransform.mat DisplacementFieldTransform.nii.gz '
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    process: '"assemble"'
+    # type=enum|default='assemble'|allowed['assemble','disassemble']: What to do with the transform inputs (assemble or disassemble)
+    out_file:
+    # type=file: Compound transformation file
+    # type=file|default=<undefined>: Output file path (only used for disassembly).
+    in_file:
+    # type=inputmultiobject|default=[]: Input transform file(s)
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-ants/composite_transform_util_callables.py b/example-specs/task/nipype_internal/pydra-ants/composite_transform_util_callables.py
new file mode 100644
index 00000000..4983be4f
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-ants/composite_transform_util_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in CompositeTransformUtil.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-ants/convert_scalar_image_to_rgb.yaml b/example-specs/task/nipype_internal/pydra-ants/convert_scalar_image_to_rgb.yaml
new file mode 100644
index 00000000..6faac3c1
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-ants/convert_scalar_image_to_rgb.yaml
@@ -0,0 +1,158 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.ants.visualization.ConvertScalarImageToRGB' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Convert scalar images to RGB.
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces.ants.visualization import ConvertScalarImageToRGB
+#     >>> converter = ConvertScalarImageToRGB()
+#     >>> converter.inputs.dimension = 3
+#     >>> converter.inputs.input_image = 'T1.nii.gz'
+#     >>> converter.inputs.colormap = 'jet'
+#     >>> converter.inputs.minimum_input = 0
+#     >>> converter.inputs.maximum_input = 6
+#     >>> converter.cmdline
+#     'ConvertScalarImageToRGB 3 T1.nii.gz rgb.nii.gz none jet none 0 6 0 255'
+# 
+#     
+task_name: ConvertScalarImageToRGB
+nipype_name: ConvertScalarImageToRGB
+nipype_module: nipype.interfaces.ants.visualization
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    input_image: medimage/nifti-gz
+    # type=file|default=<undefined>: Main input is a 3-D grayscale image.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    output_image: generic/file
+    # type=file: converted RGB image
+    # type=str|default='rgb.nii.gz': rgb output image
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    dimension:
+    # type=enum|default=3|allowed[2,3]: image dimension (2 or 3)
+    input_image:
+    # type=file|default=<undefined>: Main input is a 3-D grayscale image.
+    output_image:
+    # type=file: converted RGB image
+    # type=str|default='rgb.nii.gz': rgb output image
+    mask_image:
+    # type=traitcompound|default='none': mask image
+    colormap:
+    # type=enum|default='grey'|allowed['autumn','blue','cool','copper','custom','green','grey','hot','hsv','jet','overunder','red','spring','summer','winter']: Select a colormap
+    custom_color_map_file:
+    # type=str|default='none': custom color map file
+    minimum_input:
+    # type=int|default=0: minimum input
+    maximum_input:
+    # type=int|default=0: maximum input
+    minimum_RGB_output:
+    # type=int|default=0: 
+    maximum_RGB_output:
+    # type=int|default=255: 
+    num_threads:
+    # type=int|default=1: Number of ITK threads to use
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    dimension: '3'
+    # type=enum|default=3|allowed[2,3]: image dimension (2 or 3)
+    input_image:
+    # type=file|default=<undefined>: Main input is a 3-D grayscale image.
+    colormap: '"jet"'
+    # type=enum|default='grey'|allowed['autumn','blue','cool','copper','custom','green','grey','hot','hsv','jet','overunder','red','spring','summer','winter']: Select a colormap
+    minimum_input: '0'
+    # type=int|default=0: minimum input
+    maximum_input: '6'
+    # type=int|default=0: maximum input
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: ConvertScalarImageToRGB 3 T1.nii.gz rgb.nii.gz none jet none 0 6 0 255
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    dimension: '3'
+    # type=enum|default=3|allowed[2,3]: image dimension (2 or 3)
+    input_image:
+    # type=file|default=<undefined>: Main input is a 3-D grayscale image.
+    colormap: '"jet"'
+    # type=enum|default='grey'|allowed['autumn','blue','cool','copper','custom','green','grey','hot','hsv','jet','overunder','red','spring','summer','winter']: Select a colormap
+    minimum_input: '0'
+    # type=int|default=0: minimum input
+    maximum_input: '6'
+    # type=int|default=0: maximum input
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-ants/convert_scalar_image_to_rgb_callables.py b/example-specs/task/nipype_internal/pydra-ants/convert_scalar_image_to_rgb_callables.py
new file mode 100644
index 00000000..f4c78361
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-ants/convert_scalar_image_to_rgb_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in ConvertScalarImageToRGB.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-ants/cortical_thickness.yaml b/example-specs/task/nipype_internal/pydra-ants/cortical_thickness.yaml
new file mode 100644
index 00000000..4718a3ac
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-ants/cortical_thickness.yaml
@@ -0,0 +1,220 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.ants.segmentation.CorticalThickness' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces.ants.segmentation import CorticalThickness
+#     >>> corticalthickness = CorticalThickness()
+#     >>> corticalthickness.inputs.dimension = 3
+#     >>> corticalthickness.inputs.anatomical_image ='T1.nii.gz'
+#     >>> corticalthickness.inputs.brain_template = 'study_template.nii.gz'
+#     >>> corticalthickness.inputs.brain_probability_mask ='ProbabilityMaskOfStudyTemplate.nii.gz'
+#     >>> corticalthickness.inputs.segmentation_priors = ['BrainSegmentationPrior01.nii.gz',
+#     ...                                                 'BrainSegmentationPrior02.nii.gz',
+#     ...                                                 'BrainSegmentationPrior03.nii.gz',
+#     ...                                                 'BrainSegmentationPrior04.nii.gz']
+#     >>> corticalthickness.inputs.t1_registration_template = 'brain_study_template.nii.gz'
+#     >>> corticalthickness.cmdline
+#     'antsCorticalThickness.sh -a T1.nii.gz -m ProbabilityMaskOfStudyTemplate.nii.gz
+#     -e study_template.nii.gz -d 3 -s nii.gz -o antsCT_
+#     -p nipype_priors/BrainSegmentationPrior%02d.nii.gz -t brain_study_template.nii.gz'
+# 
+#     
+task_name: CorticalThickness
+nipype_name: CorticalThickness
+nipype_module: nipype.interfaces.ants.segmentation
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    anatomical_image: medimage/nifti-gz
+    # type=file|default=<undefined>: Structural *intensity* image, typically T1. If more than one anatomical image is specified, subsequently specified images are used during the segmentation process. However, only the first image is used in the registration of priors. Our suggestion would be to specify the T1 as the first image.
+    brain_template: medimage/nifti-gz
+    # type=file|default=<undefined>: Anatomical *intensity* template (possibly created using a population data set with buildtemplateparallel.sh in ANTs). This template is  *not* skull-stripped.
+    brain_probability_mask: medimage/nifti-gz
+    # type=file|default=<undefined>: brain probability mask in template space
+    segmentation_priors: medimage/nifti-gz+list-of
+    # type=inputmultiobject|default=[]: 
+    t1_registration_template: medimage/nifti-gz
+    # type=file|default=<undefined>: Anatomical *intensity* template (assumed to be skull-stripped). A common case would be where this would be the same template as specified in the -e option which is not skull stripped.
+    extraction_registration_mask: generic/file
+    # type=file|default=<undefined>: Mask (defined in the template space) used during registration for brain extraction.
+    cortical_label_image: generic/file
+    # type=file|default=<undefined>: Cortical ROI labels to use as a prior for ATITH.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    BrainExtractionMask: generic/file
+    # type=file: brain extraction mask
+    ExtractedBrainN4: generic/file
+    # type=file: extracted brain from N4 image
+    BrainSegmentation: generic/file
+    # type=file: brain segmentation image
+    BrainSegmentationN4: generic/file
+    # type=file: N4 corrected image
+    CorticalThickness: generic/file
+    # type=file: cortical thickness file
+    TemplateToSubject1GenericAffine: generic/file
+    # type=file: Template to subject affine
+    TemplateToSubject0Warp: generic/file
+    # type=file: Template to subject warp
+    SubjectToTemplate1Warp: generic/file
+    # type=file: Template to subject inverse warp
+    SubjectToTemplate0GenericAffine: generic/file
+    # type=file: Template to subject inverse affine
+    SubjectToTemplateLogJacobian: generic/file
+    # type=file: Template to subject log jacobian
+    CorticalThicknessNormedToTemplate: generic/file
+    # type=file: Normalized cortical thickness
+    BrainVolumes: generic/file
+    # type=file: Brain volumes as text
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    dimension:
+    # type=enum|default=3|allowed[2,3]: image dimension (2 or 3)
+    anatomical_image:
+    # type=file|default=<undefined>: Structural *intensity* image, typically T1. If more than one anatomical image is specified, subsequently specified images are used during the segmentation process. However, only the first image is used in the registration of priors. Our suggestion would be to specify the T1 as the first image.
+    brain_template:
+    # type=file|default=<undefined>: Anatomical *intensity* template (possibly created using a population data set with buildtemplateparallel.sh in ANTs). This template is  *not* skull-stripped.
+    brain_probability_mask:
+    # type=file|default=<undefined>: brain probability mask in template space
+    segmentation_priors:
+    # type=inputmultiobject|default=[]: 
+    out_prefix:
+    # type=str|default='antsCT_': Prefix that is prepended to all output files
+    image_suffix:
+    # type=str|default='nii.gz': any of standard ITK formats, nii.gz is default
+    t1_registration_template:
+    # type=file|default=<undefined>: Anatomical *intensity* template (assumed to be skull-stripped). A common case would be where this would be the same template as specified in the -e option which is not skull stripped.
+    extraction_registration_mask:
+    # type=file|default=<undefined>: Mask (defined in the template space) used during registration for brain extraction.
+    keep_temporary_files:
+    # type=int|default=0: Keep brain extraction/segmentation warps, etc (default = 0).
+    max_iterations:
+    # type=int|default=0: ANTS registration max iterations (default = 100x100x70x20)
+    prior_segmentation_weight:
+    # type=float|default=0.0: Atropos spatial prior *probability* weight for the segmentation
+    segmentation_iterations:
+    # type=int|default=0: N4 -> Atropos -> N4 iterations during segmentation (default = 3)
+    posterior_formulation:
+    # type=str|default='': Atropos posterior formulation and whether or not to use mixture model proportions. e.g 'Socrates[1]' (default) or 'Aristotle[1]'. Choose the latter if you want use the distance priors (see also the -l option for label propagation control).
+    use_floatingpoint_precision:
+    # type=enum|default=0|allowed[0,1]: Use floating point precision in registrations (default = 0)
+    use_random_seeding:
+    # type=enum|default=0|allowed[0,1]: Use random number generated from system clock in Atropos (default = 1)
+    b_spline_smoothing:
+    # type=bool|default=False: Use B-spline SyN for registrations and B-spline exponential mapping in DiReCT.
+    cortical_label_image:
+    # type=file|default=<undefined>: Cortical ROI labels to use as a prior for ATITH.
+    label_propagation:
+    # type=str|default='': Incorporate a distance prior one the posterior formulation.  Should be of the form 'label[lambda,boundaryProbability]' where label is a value of 1,2,3,... denoting label ID.  The label probability for anything outside the current label = boundaryProbability * exp( -lambda * distanceFromBoundary ) Intuitively, smaller lambda values will increase the spatial capture range of the distance prior.  To apply to all label values, simply omit specifying the label, i.e. -l [lambda,boundaryProbability].
+    quick_registration:
+    # type=bool|default=False: If = 1, use antsRegistrationSyNQuick.sh as the basis for registration during brain extraction, brain segmentation, and (optional) normalization to a template. Otherwise use antsRegistrationSyN.sh (default = 0).
+    debug:
+    # type=bool|default=False: If > 0, runs a faster version of the script. Only for testing. Implies -u 0. Requires single thread computation for complete reproducibility.
+    num_threads:
+    # type=int|default=1: Number of ITK threads to use
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    dimension: '3'
+    # type=enum|default=3|allowed[2,3]: image dimension (2 or 3)
+    anatomical_image:
+    # type=file|default=<undefined>: Structural *intensity* image, typically T1. If more than one anatomical image is specified, subsequently specified images are used during the segmentation process. However, only the first image is used in the registration of priors. Our suggestion would be to specify the T1 as the first image.
+    brain_template:
+    # type=file|default=<undefined>: Anatomical *intensity* template (possibly created using a population data set with buildtemplateparallel.sh in ANTs). This template is  *not* skull-stripped.
+    brain_probability_mask:
+    # type=file|default=<undefined>: brain probability mask in template space
+    segmentation_priors:
+    # type=inputmultiobject|default=[]: 
+    t1_registration_template:
+    # type=file|default=<undefined>: Anatomical *intensity* template (assumed to be skull-stripped). A common case would be where this would be the same template as specified in the -e option which is not skull stripped.
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: antsCorticalThickness.sh -a T1.nii.gz -m ProbabilityMaskOfStudyTemplate.nii.gz -e study_template.nii.gz -d 3 -s nii.gz -o antsCT_ -p nipype_priors/BrainSegmentationPrior%02d.nii.gz -t brain_study_template.nii.gz
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    dimension: '3'
+    # type=enum|default=3|allowed[2,3]: image dimension (2 or 3)
+    anatomical_image:
+    # type=file|default=<undefined>: Structural *intensity* image, typically T1. If more than one anatomical image is specified, subsequently specified images are used during the segmentation process. However, only the first image is used in the registration of priors. Our suggestion would be to specify the T1 as the first image.
+    brain_template:
+    # type=file|default=<undefined>: Anatomical *intensity* template (possibly created using a population data set with buildtemplateparallel.sh in ANTs). This template is  *not* skull-stripped.
+    brain_probability_mask:
+    # type=file|default=<undefined>: brain probability mask in template space
+    segmentation_priors:
+    # type=inputmultiobject|default=[]: 
+    t1_registration_template:
+    # type=file|default=<undefined>: Anatomical *intensity* template (assumed to be skull-stripped). A common case would be where this would be the same template as specified in the -e option which is not skull stripped.
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-ants/cortical_thickness_callables.py b/example-specs/task/nipype_internal/pydra-ants/cortical_thickness_callables.py
new file mode 100644
index 00000000..847ddf0c
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-ants/cortical_thickness_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in CorticalThickness.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-ants/create_jacobian_determinant_image.yaml b/example-specs/task/nipype_internal/pydra-ants/create_jacobian_determinant_image.yaml
new file mode 100644
index 00000000..78da54d7
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-ants/create_jacobian_determinant_image.yaml
@@ -0,0 +1,135 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.ants.utils.CreateJacobianDeterminantImage' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces.ants import CreateJacobianDeterminantImage
+#     >>> jacobian = CreateJacobianDeterminantImage()
+#     >>> jacobian.inputs.imageDimension = 3
+#     >>> jacobian.inputs.deformationField = 'ants_Warp.nii.gz'
+#     >>> jacobian.inputs.outputImage = 'out_name.nii.gz'
+#     >>> jacobian.cmdline
+#     'CreateJacobianDeterminantImage 3 ants_Warp.nii.gz out_name.nii.gz'
+#     
+task_name: CreateJacobianDeterminantImage
+nipype_name: CreateJacobianDeterminantImage
+nipype_module: nipype.interfaces.ants.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    deformationField: medimage/nifti-gz
+    # type=file|default=<undefined>: deformation transformation file
+    outputImage: medimage/nifti-gz
+    # type=file|default=<undefined>: output filename
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    jacobian_image: generic/file
+    # type=file: jacobian image
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    imageDimension:
+    # type=enum|default=3|allowed[2,3]: image dimension (2 or 3)
+    deformationField:
+    # type=file|default=<undefined>: deformation transformation file
+    outputImage:
+    # type=file|default=<undefined>: output filename
+    doLogJacobian:
+    # type=enum|default=0|allowed[0,1]: return the log jacobian
+    useGeometric:
+    # type=enum|default=0|allowed[0,1]: return the geometric jacobian
+    num_threads:
+    # type=int|default=1: Number of ITK threads to use
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    imageDimension: '3'
+    # type=enum|default=3|allowed[2,3]: image dimension (2 or 3)
+    deformationField:
+    # type=file|default=<undefined>: deformation transformation file
+    outputImage:
+    # type=file|default=<undefined>: output filename
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: CreateJacobianDeterminantImage 3 ants_Warp.nii.gz out_name.nii.gz
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    imageDimension: '3'
+    # type=enum|default=3|allowed[2,3]: image dimension (2 or 3)
+    deformationField:
+    # type=file|default=<undefined>: deformation transformation file
+    outputImage:
+    # type=file|default=<undefined>: output filename
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-ants/create_jacobian_determinant_image_callables.py b/example-specs/task/nipype_internal/pydra-ants/create_jacobian_determinant_image_callables.py
new file mode 100644
index 00000000..ed5d9270
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-ants/create_jacobian_determinant_image_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in CreateJacobianDeterminantImage.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-ants/create_tiled_mosaic.yaml b/example-specs/task/nipype_internal/pydra-ants/create_tiled_mosaic.yaml
new file mode 100644
index 00000000..dcb374c7
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-ants/create_tiled_mosaic.yaml
@@ -0,0 +1,183 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.ants.visualization.CreateTiledMosaic' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# The program CreateTiledMosaic in conjunction with ConvertScalarImageToRGB
+#     provides useful functionality for common image analysis tasks. The basic
+#     usage of CreateTiledMosaic is to tile a 3-D image volume slice-wise into
+#     a 2-D image.
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces.ants.visualization import CreateTiledMosaic
+#     >>> mosaic_slicer = CreateTiledMosaic()
+#     >>> mosaic_slicer.inputs.input_image = 'T1.nii.gz'
+#     >>> mosaic_slicer.inputs.rgb_image = 'rgb.nii.gz'
+#     >>> mosaic_slicer.inputs.mask_image = 'mask.nii.gz'
+#     >>> mosaic_slicer.inputs.output_image = 'output.png'
+#     >>> mosaic_slicer.inputs.alpha_value = 0.5
+#     >>> mosaic_slicer.inputs.direction = 2
+#     >>> mosaic_slicer.inputs.pad_or_crop = '[ -15x -50 , -15x -30 ,0]'
+#     >>> mosaic_slicer.inputs.slices = '[2 ,100 ,160]'
+#     >>> mosaic_slicer.cmdline
+#     'CreateTiledMosaic -a 0.50 -d 2 -i T1.nii.gz -x mask.nii.gz -o output.png -p [ -15x -50 , -15x -30 ,0] -r rgb.nii.gz -s [2 ,100 ,160]'
+#     
+task_name: CreateTiledMosaic
+nipype_name: CreateTiledMosaic
+nipype_module: nipype.interfaces.ants.visualization
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    input_image: medimage/nifti-gz
+    # type=file|default=<undefined>: Main input is a 3-D grayscale image.
+    rgb_image: medimage/nifti-gz
+    # type=file|default=<undefined>: An optional Rgb image can be added as an overlay.It must have the same imagegeometry as the input grayscale image.
+    mask_image: medimage/nifti-gz
+    # type=file|default=<undefined>: Specifies the ROI of the RGB voxels used.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    output_image: image/png
+    # type=file: image file
+    # type=str|default='output.png': The output consists of the tiled mosaic image.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    input_image:
+    # type=file|default=<undefined>: Main input is a 3-D grayscale image.
+    rgb_image:
+    # type=file|default=<undefined>: An optional Rgb image can be added as an overlay.It must have the same imagegeometry as the input grayscale image.
+    mask_image:
+    # type=file|default=<undefined>: Specifies the ROI of the RGB voxels used.
+    alpha_value:
+    # type=float|default=0.0: If an Rgb image is provided, render the overlay using the specified alpha parameter.
+    output_image:
+    # type=file: image file
+    # type=str|default='output.png': The output consists of the tiled mosaic image.
+    tile_geometry:
+    # type=str|default='': The tile geometry specifies the number of rows and columnsin the output image. For example, if the user specifies "5x10", then 5 rows by 10 columns of slices are rendered. If R < 0 and C > 0 (or vice versa), the negative value is selectedbased on direction.
+    direction:
+    # type=int|default=0: Specifies the direction of the slices. If no direction is specified, the direction with the coarsest spacing is chosen.
+    pad_or_crop:
+    # type=str|default='': argument passed to -p flag:[padVoxelWidth,<constantValue=0>][lowerPadding[0]xlowerPadding[1],upperPadding[0]xupperPadding[1],constantValue]The user can specify whether to pad or crop a specified voxel-width boundary of each individual slice. For this program, cropping is simply padding with negative voxel-widths.If one pads (+), the user can also specify a constant pad value (default = 0). If a mask is specified, the user can use the mask to define the region, by using the keyword "mask" plus an offset, e.g. "-p mask+3".
+    slices:
+    # type=str|default='': Number of slices to increment Slice1xSlice2xSlice3[numberOfSlicesToIncrement,<minSlice=0>,<maxSlice=lastSlice>]
+    flip_slice:
+    # type=str|default='': flipXxflipY
+    permute_axes:
+    # type=bool|default=False: doPermute
+    num_threads:
+    # type=int|default=1: Number of ITK threads to use
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    input_image:
+    # type=file|default=<undefined>: Main input is a 3-D grayscale image.
+    rgb_image:
+    # type=file|default=<undefined>: An optional Rgb image can be added as an overlay.It must have the same imagegeometry as the input grayscale image.
+    mask_image:
+    # type=file|default=<undefined>: Specifies the ROI of the RGB voxels used.
+    output_image: '"output.png"'
+    # type=file: image file
+    # type=str|default='output.png': The output consists of the tiled mosaic image.
+    alpha_value: '0.5'
+    # type=float|default=0.0: If an Rgb image is provided, render the overlay using the specified alpha parameter.
+    direction: '2'
+    # type=int|default=0: Specifies the direction of the slices. If no direction is specified, the direction with the coarsest spacing is chosen.
+    pad_or_crop: '"[ -15x -50 , -15x -30 ,0]"'
+    # type=str|default='': argument passed to -p flag:[padVoxelWidth,<constantValue=0>][lowerPadding[0]xlowerPadding[1],upperPadding[0]xupperPadding[1],constantValue]The user can specify whether to pad or crop a specified voxel-width boundary of each individual slice. For this program, cropping is simply padding with negative voxel-widths.If one pads (+), the user can also specify a constant pad value (default = 0). If a mask is specified, the user can use the mask to define the region, by using the keyword "mask" plus an offset, e.g. "-p mask+3".
+    slices: '"[2 ,100 ,160]"'
+    # type=str|default='': Number of slices to increment Slice1xSlice2xSlice3[numberOfSlicesToIncrement,<minSlice=0>,<maxSlice=lastSlice>]
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: CreateTiledMosaic -a 0.50 -d 2 -i T1.nii.gz -x mask.nii.gz -o output.png -p [ -15x -50 , -15x -30 ,0] -r rgb.nii.gz -s [2 ,100 ,160]
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    input_image:
+    # type=file|default=<undefined>: Main input is a 3-D grayscale image.
+    rgb_image:
+    # type=file|default=<undefined>: An optional Rgb image can be added as an overlay.It must have the same imagegeometry as the input grayscale image.
+    mask_image:
+    # type=file|default=<undefined>: Specifies the ROI of the RGB voxels used.
+    output_image: '"output.png"'
+    # type=file: image file
+    # type=str|default='output.png': The output consists of the tiled mosaic image.
+    alpha_value: '0.5'
+    # type=float|default=0.0: If an Rgb image is provided, render the overlay using the specified alpha parameter.
+    direction: '2'
+    # type=int|default=0: Specifies the direction of the slices. If no direction is specified, the direction with the coarsest spacing is chosen.
+    pad_or_crop: '"[ -15x -50 , -15x -30 ,0]"'
+    # type=str|default='': argument passed to -p flag:[padVoxelWidth,<constantValue=0>][lowerPadding[0]xlowerPadding[1],upperPadding[0]xupperPadding[1],constantValue]The user can specify whether to pad or crop a specified voxel-width boundary of each individual slice. For this program, cropping is simply padding with negative voxel-widths.If one pads (+), the user can also specify a constant pad value (default = 0). If a mask is specified, the user can use the mask to define the region, by using the keyword "mask" plus an offset, e.g. "-p mask+3".
+    slices: '"[2 ,100 ,160]"'
+    # type=str|default='': Number of slices to increment Slice1xSlice2xSlice3[numberOfSlicesToIncrement,<minSlice=0>,<maxSlice=lastSlice>]
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-ants/create_tiled_mosaic_callables.py b/example-specs/task/nipype_internal/pydra-ants/create_tiled_mosaic_callables.py
new file mode 100644
index 00000000..b65faa69
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-ants/create_tiled_mosaic_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in CreateTiledMosaic.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-ants/denoise_image.yaml b/example-specs/task/nipype_internal/pydra-ants/denoise_image.yaml
new file mode 100644
index 00000000..7b88d7f0
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-ants/denoise_image.yaml
@@ -0,0 +1,242 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.ants.segmentation.DenoiseImage' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Examples
+#     --------
+#     >>> import copy
+#     >>> from nipype.interfaces.ants import DenoiseImage
+#     >>> denoise = DenoiseImage()
+#     >>> denoise.inputs.dimension = 3
+#     >>> denoise.inputs.input_image = 'im1.nii'
+#     >>> denoise.cmdline
+#     'DenoiseImage -d 3 -i im1.nii -n Gaussian -o im1_noise_corrected.nii -s 1'
+# 
+#     >>> denoise_2 = copy.deepcopy(denoise)
+#     >>> denoise_2.inputs.output_image = 'output_corrected_image.nii.gz'
+#     >>> denoise_2.inputs.noise_model = 'Rician'
+#     >>> denoise_2.inputs.shrink_factor = 2
+#     >>> denoise_2.cmdline
+#     'DenoiseImage -d 3 -i im1.nii -n Rician -o output_corrected_image.nii.gz -s 2'
+# 
+#     >>> denoise_3 = DenoiseImage()
+#     >>> denoise_3.inputs.input_image = 'im1.nii'
+#     >>> denoise_3.inputs.save_noise = True
+#     >>> denoise_3.cmdline
+#     'DenoiseImage -i im1.nii -n Gaussian -o [ im1_noise_corrected.nii, im1_noise.nii ] -s 1'
+# 
+#     
+task_name: DenoiseImage
+nipype_name: DenoiseImage
+nipype_module: nipype.interfaces.ants.segmentation
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    input_image: medimage/nifti1
+    # type=file|default=<undefined>: A scalar image is expected as input for noise correction.
+    output_image: medimage/nifti-gz
+    # type=file: 
+    # type=file|default=<undefined>: The output consists of the noise corrected version of the input image.
+    noise_image: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: Filename for the estimated noise.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    output_image: medimage/nifti-gz
+    # type=file: 
+    # type=file|default=<undefined>: The output consists of the noise corrected version of the input image.
+    noise_image: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: Filename for the estimated noise.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    dimension:
+    # type=enum|default=2|allowed[2,3,4]: This option forces the image to be treated as a specified-dimensional image. If not specified, the program tries to infer the dimensionality from the input image.
+    input_image:
+    # type=file|default=<undefined>: A scalar image is expected as input for noise correction.
+    noise_model:
+    # type=enum|default='Gaussian'|allowed['Gaussian','Rician']: Employ a Rician or Gaussian noise model.
+    shrink_factor:
+    # type=int|default=1: Running noise correction on large images can be time consuming. To lessen computation time, the input image can be resampled. The shrink factor, specified as a single integer, describes this resampling. Shrink factor = 1 is the default.
+    output_image:
+    # type=file: 
+    # type=file|default=<undefined>: The output consists of the noise corrected version of the input image.
+    save_noise:
+    # type=bool|default=False: True if the estimated noise should be saved to file.
+    noise_image:
+    # type=file: 
+    # type=file|default=<undefined>: Filename for the estimated noise.
+    verbose:
+    # type=bool|default=False: Verbose output.
+    num_threads:
+    # type=int|default=1: Number of ITK threads to use
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    dimension: '3'
+    # type=enum|default=2|allowed[2,3,4]: This option forces the image to be treated as a specified-dimensional image. If not specified, the program tries to infer the dimensionality from the input image.
+    input_image:
+    # type=file|default=<undefined>: A scalar image is expected as input for noise correction.
+  imports: &id001
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  - module: copy
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    output_image:
+    # type=file: 
+    # type=file|default=<undefined>: The output consists of the noise corrected version of the input image.
+    noise_model: '"Rician"'
+    # type=enum|default='Gaussian'|allowed['Gaussian','Rician']: Employ a Rician or Gaussian noise model.
+    shrink_factor: '2'
+    # type=int|default=1: Running noise correction on large images can be time consuming. To lessen computation time, the input image can be resampled. The shrink factor, specified as a single integer, describes this resampling. Shrink factor = 1 is the default.
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    input_image:
+    # type=file|default=<undefined>: A scalar image is expected as input for noise correction.
+    save_noise: 'True'
+    # type=bool|default=False: True if the estimated noise should be saved to file.
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: DenoiseImage -d 3 -i im1.nii -n Gaussian -o im1_noise_corrected.nii -s 1
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    dimension: '3'
+    # type=enum|default=2|allowed[2,3,4]: This option forces the image to be treated as a specified-dimensional image. If not specified, the program tries to infer the dimensionality from the input image.
+    input_image:
+    # type=file|default=<undefined>: A scalar image is expected as input for noise correction.
+  imports: *id001
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: DenoiseImage -d 3 -i im1.nii -n Rician -o output_corrected_image.nii.gz -s 2
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    output_image:
+    # type=file: 
+    # type=file|default=<undefined>: The output consists of the noise corrected version of the input image.
+    noise_model: '"Rician"'
+    # type=enum|default='Gaussian'|allowed['Gaussian','Rician']: Employ a Rician or Gaussian noise model.
+    shrink_factor: '2'
+    # type=int|default=1: Running noise correction on large images can be time consuming. To lessen computation time, the input image can be resampled. The shrink factor, specified as a single integer, describes this resampling. Shrink factor = 1 is the default.
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: DenoiseImage -i im1.nii -n Gaussian -o [ im1_noise_corrected.nii, im1_noise.nii ] -s 1
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    input_image:
+    # type=file|default=<undefined>: A scalar image is expected as input for noise correction.
+    save_noise: 'True'
+    # type=bool|default=False: True if the estimated noise should be saved to file.
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-ants/denoise_image_callables.py b/example-specs/task/nipype_internal/pydra-ants/denoise_image_callables.py
new file mode 100644
index 00000000..1f1bd275
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-ants/denoise_image_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in DenoiseImage.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-ants/gen_warp_fields.yaml b/example-specs/task/nipype_internal/pydra-ants/gen_warp_fields.yaml
new file mode 100644
index 00000000..0d4540ce
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-ants/gen_warp_fields.yaml
@@ -0,0 +1,104 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.ants.legacy.GenWarpFields' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+task_name: GenWarpFields
+nipype_name: GenWarpFields
+nipype_module: nipype.interfaces.ants.legacy
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    reference_image: generic/file
+    # type=file|default=<undefined>: template file to warp to
+    input_image: generic/file
+    # type=file|default=<undefined>: input image to warp to template
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    affine_transformation: generic/file
+    # type=file: affine (prefix_Affine.txt)
+    warp_field: generic/file
+    # type=file: warp field (prefix_Warp.nii)
+    inverse_warp_field: generic/file
+    # type=file: inverse warp field (prefix_InverseWarp.nii)
+    input_file: generic/file
+    # type=file: input image (prefix_repaired.nii)
+    output_file: generic/file
+    # type=file: output image (prefix_deformed.nii)
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    dimension:
+    # type=enum|default=3|allowed[2,3]: image dimension (2 or 3)
+    reference_image:
+    # type=file|default=<undefined>: template file to warp to
+    input_image:
+    # type=file|default=<undefined>: input image to warp to template
+    force_proceed:
+    # type=bool|default=False: force script to proceed even if headers may be incompatible
+    inverse_warp_template_labels:
+    # type=bool|default=False: Applies inverse warp to the template labels to estimate label positions in target space (use for template-based segmentation)
+    max_iterations:
+    # type=list|default=[]: maximum number of iterations (must be list of integers in the form [J,K,L...]: J = coarsest resolution iterations, K = middle resolution iterations, L = fine resolution iterations
+    bias_field_correction:
+    # type=bool|default=False: Applies bias field correction to moving image
+    similarity_metric:
+    # type=enum|default='PR'|allowed['CC','MI','MSQ','PR']: Type of similartiy metric used for registration (CC = cross correlation, MI = mutual information, PR = probability mapping, MSQ = mean square difference)
+    transformation_model:
+    # type=enum|default='GR'|allowed['DD','EL','EX','GR','RA','RI','S2','SY']: Type of transofmration model used for registration (EL = elastic transformation model, SY = SyN with time, arbitrary number of time points, S2 =  SyN with time optimized for 2 time points, GR = greedy SyN, EX = exponential, DD = diffeomorphic demons style exponential mapping, RI = purely rigid, RA = affine rigid
+    out_prefix:
+    # type=str|default='ants_': Prefix that is prepended to all output files (default = ants_)
+    quality_check:
+    # type=bool|default=False: Perform a quality check of the result
+    num_threads:
+    # type=int|default=1: Number of ITK threads to use
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-ants/gen_warp_fields_callables.py b/example-specs/task/nipype_internal/pydra-ants/gen_warp_fields_callables.py
new file mode 100644
index 00000000..f08cf2cf
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-ants/gen_warp_fields_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in GenWarpFields.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-ants/image_math.yaml b/example-specs/task/nipype_internal/pydra-ants/image_math.yaml
new file mode 100644
index 00000000..6a287d9d
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-ants/image_math.yaml
@@ -0,0 +1,307 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.ants.utils.ImageMath' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Operations over images.
+# 
+#     Examples
+#     --------
+#     >>> ImageMath(
+#     ...     op1='structural.nii',
+#     ...     operation='+',
+#     ...     op2='2').cmdline
+#     'ImageMath 3 structural_maths.nii + structural.nii 2'
+# 
+#     >>> ImageMath(
+#     ...     op1='structural.nii',
+#     ...     operation='Project',
+#     ...     op2='1 2').cmdline
+#     'ImageMath 3 structural_maths.nii Project structural.nii 1 2'
+# 
+#     >>> ImageMath(
+#     ...     op1='structural.nii',
+#     ...     operation='G',
+#     ...     op2='4').cmdline
+#     'ImageMath 3 structural_maths.nii G structural.nii 4'
+# 
+#     >>> ImageMath(
+#     ...     op1='structural.nii',
+#     ...     operation='TruncateImageIntensity',
+#     ...     op2='0.005 0.999 256').cmdline
+#     'ImageMath 3 structural_maths.nii TruncateImageIntensity structural.nii 0.005 0.999 256'
+# 
+#     By default, Nipype copies headers from the first input image (``op1``)
+#     to the output image.
+#     For some operations, as the ``PadImage`` operation, the header cannot be copied from inputs to
+#     outputs, and so ``copy_header`` option is automatically set to ``False``.
+# 
+#     >>> pad = ImageMath(
+#     ...     op1='structural.nii',
+#     ...     operation='PadImage')
+#     >>> pad.inputs.copy_header
+#     False
+# 
+#     While the operation is set to ``PadImage``,
+#     setting ``copy_header = True`` will have no effect.
+# 
+#     >>> pad.inputs.copy_header = True
+#     >>> pad.inputs.copy_header
+#     False
+# 
+#     For any other operation, ``copy_header`` can be enabled/disabled normally:
+# 
+#     >>> pad.inputs.operation = "ME"
+#     >>> pad.inputs.copy_header = True
+#     >>> pad.inputs.copy_header
+#     True
+# 
+#     
+task_name: ImageMath
+nipype_name: ImageMath
+nipype_module: nipype.interfaces.ants.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    output_image: generic/file
+    # type=file: output image file
+    # type=file|default=<undefined>: output image file
+    op1: medimage/nifti1
+    # type=file|default=<undefined>: first operator
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    output_image: generic/file
+    # type=file: output image file
+    # type=file|default=<undefined>: output image file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    dimension:
+    # type=int|default=3: dimension of output image
+    output_image:
+    # type=file: output image file
+    # type=file|default=<undefined>: output image file
+    operation:
+    # type=enum|default='m'|allowed['+','-','/','4DTensorTo3DTensor','Byte','Canny','Convolve','CorruptImage','D','Decision','ExtractContours','ExtractSlice','ExtractVectorComponent','FillHoles','Finite','FlattenImage','G','GC','GD','GE','GO','GetLargestComponent','Grad','LabelStats','Laplacian','Lipschitz','MC','MD','ME','MO','MTR','MaurerDistance','Neg','NeighborhoodStats','Normalize','PValueImage','PadImage','Project','ReplaceVoxelValue','ReplicateDisplacement','ReplicateImage','RescaleImage','SetTimeSpacing','SetTimeSpacingWarp','Sharpen','SigmoidImage','TensorAxialDiffusion','TensorColor','TensorEigenvalue','TensorFA','TensorFADenominator','TensorFANumerator','TensorMask','TensorMeanDiffusion','TensorRadialDiffusion','TensorToVector','TensorToVectorComponent','ThresholdAtMean','Translate','TriPlanarView','TruncateImageIntensity','UnsharpMask','WindowImage','^','abs','addtozero','exp','m','max','mean','overadd','stack','total','v+','v-','vm','vtotal']: mathematical operations
+    op1:
+    # type=file|default=<undefined>: first operator
+    op2:
+    # type=traitcompound|default=None: second operator
+    args:
+    # type=str|default='': Additional parameters to the command
+    copy_header:
+    # type=bool|default=True: copy headers of the original image into the output (corrected) file
+    num_threads:
+    # type=int|default=1: Number of ITK threads to use
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    op1:
+    # type=file|default=<undefined>: first operator
+    operation: '"+"'
+    # type=enum|default='m'|allowed['+','-','/','4DTensorTo3DTensor','Byte','Canny','Convolve','CorruptImage','D','Decision','ExtractContours','ExtractSlice','ExtractVectorComponent','FillHoles','Finite','FlattenImage','G','GC','GD','GE','GO','GetLargestComponent','Grad','LabelStats','Laplacian','Lipschitz','MC','MD','ME','MO','MTR','MaurerDistance','Neg','NeighborhoodStats','Normalize','PValueImage','PadImage','Project','ReplaceVoxelValue','ReplicateDisplacement','ReplicateImage','RescaleImage','SetTimeSpacing','SetTimeSpacingWarp','Sharpen','SigmoidImage','TensorAxialDiffusion','TensorColor','TensorEigenvalue','TensorFA','TensorFADenominator','TensorFANumerator','TensorMask','TensorMeanDiffusion','TensorRadialDiffusion','TensorToVector','TensorToVectorComponent','ThresholdAtMean','Translate','TriPlanarView','TruncateImageIntensity','UnsharpMask','WindowImage','^','abs','addtozero','exp','m','max','mean','overadd','stack','total','v+','v-','vm','vtotal']: mathematical operations
+    op2: '"2"'
+    # type=traitcompound|default=None: second operator
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    op1:
+    # type=file|default=<undefined>: first operator
+    operation: '"Project"'
+    # type=enum|default='m'|allowed['+','-','/','4DTensorTo3DTensor','Byte','Canny','Convolve','CorruptImage','D','Decision','ExtractContours','ExtractSlice','ExtractVectorComponent','FillHoles','Finite','FlattenImage','G','GC','GD','GE','GO','GetLargestComponent','Grad','LabelStats','Laplacian','Lipschitz','MC','MD','ME','MO','MTR','MaurerDistance','Neg','NeighborhoodStats','Normalize','PValueImage','PadImage','Project','ReplaceVoxelValue','ReplicateDisplacement','ReplicateImage','RescaleImage','SetTimeSpacing','SetTimeSpacingWarp','Sharpen','SigmoidImage','TensorAxialDiffusion','TensorColor','TensorEigenvalue','TensorFA','TensorFADenominator','TensorFANumerator','TensorMask','TensorMeanDiffusion','TensorRadialDiffusion','TensorToVector','TensorToVectorComponent','ThresholdAtMean','Translate','TriPlanarView','TruncateImageIntensity','UnsharpMask','WindowImage','^','abs','addtozero','exp','m','max','mean','overadd','stack','total','v+','v-','vm','vtotal']: mathematical operations
+    op2: '"1 2"'
+    # type=traitcompound|default=None: second operator
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    op1:
+    # type=file|default=<undefined>: first operator
+    operation: '"G"'
+    # type=enum|default='m'|allowed['+','-','/','4DTensorTo3DTensor','Byte','Canny','Convolve','CorruptImage','D','Decision','ExtractContours','ExtractSlice','ExtractVectorComponent','FillHoles','Finite','FlattenImage','G','GC','GD','GE','GO','GetLargestComponent','Grad','LabelStats','Laplacian','Lipschitz','MC','MD','ME','MO','MTR','MaurerDistance','Neg','NeighborhoodStats','Normalize','PValueImage','PadImage','Project','ReplaceVoxelValue','ReplicateDisplacement','ReplicateImage','RescaleImage','SetTimeSpacing','SetTimeSpacingWarp','Sharpen','SigmoidImage','TensorAxialDiffusion','TensorColor','TensorEigenvalue','TensorFA','TensorFADenominator','TensorFANumerator','TensorMask','TensorMeanDiffusion','TensorRadialDiffusion','TensorToVector','TensorToVectorComponent','ThresholdAtMean','Translate','TriPlanarView','TruncateImageIntensity','UnsharpMask','WindowImage','^','abs','addtozero','exp','m','max','mean','overadd','stack','total','v+','v-','vm','vtotal']: mathematical operations
+    op2: '"4"'
+    # type=traitcompound|default=None: second operator
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    op1:
+    # type=file|default=<undefined>: first operator
+    operation: '"TruncateImageIntensity"'
+    # type=enum|default='m'|allowed['+','-','/','4DTensorTo3DTensor','Byte','Canny','Convolve','CorruptImage','D','Decision','ExtractContours','ExtractSlice','ExtractVectorComponent','FillHoles','Finite','FlattenImage','G','GC','GD','GE','GO','GetLargestComponent','Grad','LabelStats','Laplacian','Lipschitz','MC','MD','ME','MO','MTR','MaurerDistance','Neg','NeighborhoodStats','Normalize','PValueImage','PadImage','Project','ReplaceVoxelValue','ReplicateDisplacement','ReplicateImage','RescaleImage','SetTimeSpacing','SetTimeSpacingWarp','Sharpen','SigmoidImage','TensorAxialDiffusion','TensorColor','TensorEigenvalue','TensorFA','TensorFADenominator','TensorFANumerator','TensorMask','TensorMeanDiffusion','TensorRadialDiffusion','TensorToVector','TensorToVectorComponent','ThresholdAtMean','Translate','TriPlanarView','TruncateImageIntensity','UnsharpMask','WindowImage','^','abs','addtozero','exp','m','max','mean','overadd','stack','total','v+','v-','vm','vtotal']: mathematical operations
+    op2: '"0.005 0.999 256"'
+    # type=traitcompound|default=None: second operator
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: ImageMath 3 structural_maths.nii + structural.nii 2
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    op1:
+    # type=file|default=<undefined>: first operator
+    operation: '"+"'
+    # type=enum|default='m'|allowed['+','-','/','4DTensorTo3DTensor','Byte','Canny','Convolve','CorruptImage','D','Decision','ExtractContours','ExtractSlice','ExtractVectorComponent','FillHoles','Finite','FlattenImage','G','GC','GD','GE','GO','GetLargestComponent','Grad','LabelStats','Laplacian','Lipschitz','MC','MD','ME','MO','MTR','MaurerDistance','Neg','NeighborhoodStats','Normalize','PValueImage','PadImage','Project','ReplaceVoxelValue','ReplicateDisplacement','ReplicateImage','RescaleImage','SetTimeSpacing','SetTimeSpacingWarp','Sharpen','SigmoidImage','TensorAxialDiffusion','TensorColor','TensorEigenvalue','TensorFA','TensorFADenominator','TensorFANumerator','TensorMask','TensorMeanDiffusion','TensorRadialDiffusion','TensorToVector','TensorToVectorComponent','ThresholdAtMean','Translate','TriPlanarView','TruncateImageIntensity','UnsharpMask','WindowImage','^','abs','addtozero','exp','m','max','mean','overadd','stack','total','v+','v-','vm','vtotal']: mathematical operations
+    op2: '"2"'
+    # type=traitcompound|default=None: second operator
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: ImageMath 3 structural_maths.nii Project structural.nii 1 2
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    op1:
+    # type=file|default=<undefined>: first operator
+    operation: '"Project"'
+    # type=enum|default='m'|allowed['+','-','/','4DTensorTo3DTensor','Byte','Canny','Convolve','CorruptImage','D','Decision','ExtractContours','ExtractSlice','ExtractVectorComponent','FillHoles','Finite','FlattenImage','G','GC','GD','GE','GO','GetLargestComponent','Grad','LabelStats','Laplacian','Lipschitz','MC','MD','ME','MO','MTR','MaurerDistance','Neg','NeighborhoodStats','Normalize','PValueImage','PadImage','Project','ReplaceVoxelValue','ReplicateDisplacement','ReplicateImage','RescaleImage','SetTimeSpacing','SetTimeSpacingWarp','Sharpen','SigmoidImage','TensorAxialDiffusion','TensorColor','TensorEigenvalue','TensorFA','TensorFADenominator','TensorFANumerator','TensorMask','TensorMeanDiffusion','TensorRadialDiffusion','TensorToVector','TensorToVectorComponent','ThresholdAtMean','Translate','TriPlanarView','TruncateImageIntensity','UnsharpMask','WindowImage','^','abs','addtozero','exp','m','max','mean','overadd','stack','total','v+','v-','vm','vtotal']: mathematical operations
+    op2: '"1 2"'
+    # type=traitcompound|default=None: second operator
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: ImageMath 3 structural_maths.nii G structural.nii 4
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    op1:
+    # type=file|default=<undefined>: first operator
+    operation: '"G"'
+    # type=enum|default='m'|allowed['+','-','/','4DTensorTo3DTensor','Byte','Canny','Convolve','CorruptImage','D','Decision','ExtractContours','ExtractSlice','ExtractVectorComponent','FillHoles','Finite','FlattenImage','G','GC','GD','GE','GO','GetLargestComponent','Grad','LabelStats','Laplacian','Lipschitz','MC','MD','ME','MO','MTR','MaurerDistance','Neg','NeighborhoodStats','Normalize','PValueImage','PadImage','Project','ReplaceVoxelValue','ReplicateDisplacement','ReplicateImage','RescaleImage','SetTimeSpacing','SetTimeSpacingWarp','Sharpen','SigmoidImage','TensorAxialDiffusion','TensorColor','TensorEigenvalue','TensorFA','TensorFADenominator','TensorFANumerator','TensorMask','TensorMeanDiffusion','TensorRadialDiffusion','TensorToVector','TensorToVectorComponent','ThresholdAtMean','Translate','TriPlanarView','TruncateImageIntensity','UnsharpMask','WindowImage','^','abs','addtozero','exp','m','max','mean','overadd','stack','total','v+','v-','vm','vtotal']: mathematical operations
+    op2: '"4"'
+    # type=traitcompound|default=None: second operator
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: ImageMath 3 structural_maths.nii TruncateImageIntensity structural.nii 0.005 0.999 256
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    op1:
+    # type=file|default=<undefined>: first operator
+    operation: '"TruncateImageIntensity"'
+    # type=enum|default='m'|allowed['+','-','/','4DTensorTo3DTensor','Byte','Canny','Convolve','CorruptImage','D','Decision','ExtractContours','ExtractSlice','ExtractVectorComponent','FillHoles','Finite','FlattenImage','G','GC','GD','GE','GO','GetLargestComponent','Grad','LabelStats','Laplacian','Lipschitz','MC','MD','ME','MO','MTR','MaurerDistance','Neg','NeighborhoodStats','Normalize','PValueImage','PadImage','Project','ReplaceVoxelValue','ReplicateDisplacement','ReplicateImage','RescaleImage','SetTimeSpacing','SetTimeSpacingWarp','Sharpen','SigmoidImage','TensorAxialDiffusion','TensorColor','TensorEigenvalue','TensorFA','TensorFADenominator','TensorFANumerator','TensorMask','TensorMeanDiffusion','TensorRadialDiffusion','TensorToVector','TensorToVectorComponent','ThresholdAtMean','Translate','TriPlanarView','TruncateImageIntensity','UnsharpMask','WindowImage','^','abs','addtozero','exp','m','max','mean','overadd','stack','total','v+','v-','vm','vtotal']: mathematical operations
+    op2: '"0.005 0.999 256"'
+    # type=traitcompound|default=None: second operator
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-ants/image_math_callables.py b/example-specs/task/nipype_internal/pydra-ants/image_math_callables.py
new file mode 100644
index 00000000..49800dde
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-ants/image_math_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in ImageMath.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-ants/joint_fusion.yaml b/example-specs/task/nipype_internal/pydra-ants/joint_fusion.yaml
new file mode 100644
index 00000000..8ef27792
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-ants/joint_fusion.yaml
@@ -0,0 +1,452 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.ants.segmentation.JointFusion' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     An image fusion algorithm.
+# 
+#     Developed by Hongzhi Wang and Paul Yushkevich, and it won segmentation challenges
+#     at MICCAI 2012 and MICCAI 2013.
+#     The original label fusion framework was extended to accommodate intensities by Brian
+#     Avants.
+#     This implementation is based on Paul's original ITK-style implementation
+#     and Brian's ANTsR implementation.
+# 
+#     References include 1) H. Wang, J. W. Suh, S.
+#     Das, J. Pluta, C. Craige, P. Yushkevich, Multi-atlas segmentation with joint
+#     label fusion IEEE Trans. on Pattern Analysis and Machine Intelligence, 35(3),
+#     611-623, 2013. and 2) H. Wang and P. A. Yushkevich, Multi-atlas segmentation
+#     with joint label fusion and corrective learning--an open source implementation,
+#     Front. Neuroinform., 2013.
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces.ants import JointFusion
+#     >>> jf = JointFusion()
+#     >>> jf.inputs.out_label_fusion = 'ants_fusion_label_output.nii'
+#     >>> jf.inputs.atlas_image = [ ['rc1s1.nii','rc1s2.nii'] ]
+#     >>> jf.inputs.atlas_segmentation_image = ['segmentation0.nii.gz']
+#     >>> jf.inputs.target_image = ['im1.nii']
+#     >>> jf.cmdline
+#     "antsJointFusion -a 0.1 -g ['rc1s1.nii', 'rc1s2.nii'] -l segmentation0.nii.gz
+#     -b 2.0 -o ants_fusion_label_output.nii -s 3x3x3 -t ['im1.nii']"
+# 
+#     >>> jf.inputs.target_image = [ ['im1.nii', 'im2.nii'] ]
+#     >>> jf.cmdline
+#     "antsJointFusion -a 0.1 -g ['rc1s1.nii', 'rc1s2.nii'] -l segmentation0.nii.gz
+#     -b 2.0 -o ants_fusion_label_output.nii -s 3x3x3 -t ['im1.nii', 'im2.nii']"
+# 
+#     >>> jf.inputs.atlas_image = [ ['rc1s1.nii','rc1s2.nii'],
+#     ...                                        ['rc2s1.nii','rc2s2.nii'] ]
+#     >>> jf.inputs.atlas_segmentation_image = ['segmentation0.nii.gz',
+#     ...                                                    'segmentation1.nii.gz']
+#     >>> jf.cmdline
+#     "antsJointFusion -a 0.1 -g ['rc1s1.nii', 'rc1s2.nii'] -g ['rc2s1.nii', 'rc2s2.nii']
+#     -l segmentation0.nii.gz -l segmentation1.nii.gz -b 2.0 -o ants_fusion_label_output.nii
+#     -s 3x3x3 -t ['im1.nii', 'im2.nii']"
+# 
+#     >>> jf.inputs.dimension = 3
+#     >>> jf.inputs.alpha = 0.5
+#     >>> jf.inputs.beta = 1.0
+#     >>> jf.inputs.patch_radius = [3,2,1]
+#     >>> jf.inputs.search_radius = [3]
+#     >>> jf.cmdline
+#     "antsJointFusion -a 0.5 -g ['rc1s1.nii', 'rc1s2.nii'] -g ['rc2s1.nii', 'rc2s2.nii']
+#     -l segmentation0.nii.gz -l segmentation1.nii.gz -b 1.0 -d 3 -o ants_fusion_label_output.nii
+#     -p 3x2x1 -s 3 -t ['im1.nii', 'im2.nii']"
+# 
+#     >>> jf.inputs.search_radius = ['mask.nii']
+#     >>> jf.inputs.verbose = True
+#     >>> jf.inputs.exclusion_image = ['roi01.nii', 'roi02.nii']
+#     >>> jf.inputs.exclusion_image_label = ['1','2']
+#     >>> jf.cmdline
+#     "antsJointFusion -a 0.5 -g ['rc1s1.nii', 'rc1s2.nii'] -g ['rc2s1.nii', 'rc2s2.nii']
+#     -l segmentation0.nii.gz -l segmentation1.nii.gz -b 1.0 -d 3 -e 1[roi01.nii] -e 2[roi02.nii]
+#     -o ants_fusion_label_output.nii -p 3x2x1 -s mask.nii -t ['im1.nii', 'im2.nii'] -v"
+# 
+#     >>> jf.inputs.out_label_fusion = 'ants_fusion_label_output.nii'
+#     >>> jf.inputs.out_intensity_fusion_name_format = 'ants_joint_fusion_intensity_%d.nii.gz'
+#     >>> jf.inputs.out_label_post_prob_name_format = 'ants_joint_fusion_posterior_%d.nii.gz'
+#     >>> jf.inputs.out_atlas_voting_weight_name_format = 'ants_joint_fusion_voting_weight_%d.nii.gz'
+#     >>> jf.cmdline
+#     "antsJointFusion -a 0.5 -g ['rc1s1.nii', 'rc1s2.nii'] -g ['rc2s1.nii', 'rc2s2.nii']
+#     -l segmentation0.nii.gz -l segmentation1.nii.gz -b 1.0 -d 3 -e 1[roi01.nii] -e 2[roi02.nii]
+#     -o [ants_fusion_label_output.nii, ants_joint_fusion_intensity_%d.nii.gz,
+#     ants_joint_fusion_posterior_%d.nii.gz, ants_joint_fusion_voting_weight_%d.nii.gz]
+#     -p 3x2x1 -s mask.nii -t ['im1.nii', 'im2.nii'] -v"
+# 
+#     
+task_name: JointFusion
+nipype_name: JointFusion
+nipype_module: nipype.interfaces.ants.segmentation
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    atlas_segmentation_image: medimage/nifti-gz+list-of
+    # type=inputmultiobject|default=[]: The atlas segmentation images. For performing label fusion the number of specified segmentations should be identical to the number of atlas image sets.
+    exclusion_image: medimage/nifti1+list-of
+    # type=list|default=[]: Specify an exclusion region for the given label.
+    mask_image: generic/file
+    # type=file|default=<undefined>: If a mask image is specified, fusion is only performed in the mask region.
+    out_label_fusion: medimage/nifti1
+    # type=file: 
+    # type=file|default=<undefined>: The output label fusion image.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_label_fusion: medimage/nifti1
+    # type=file: 
+    # type=file|default=<undefined>: The output label fusion image.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    dimension:
+    # type=enum|default=3|allowed[2,3,4]: This option forces the image to be treated as a specified-dimensional image. If not specified, the program tries to infer the dimensionality from the input image.
+    target_image:
+    # type=list|default=[]: The target image (or multimodal target images) assumed to be aligned to a common image domain.
+    atlas_image:
+    # type=list|default=[]: The atlas image (or multimodal atlas images) assumed to be aligned to a common image domain.
+    atlas_segmentation_image:
+    # type=inputmultiobject|default=[]: The atlas segmentation images. For performing label fusion the number of specified segmentations should be identical to the number of atlas image sets.
+    alpha:
+    # type=float|default=0.1: Regularization term added to matrix Mx for calculating the inverse. Default = 0.1
+    beta:
+    # type=float|default=2.0: Exponent for mapping intensity difference to the joint error. Default = 2.0
+    retain_label_posterior_images:
+    # type=bool|default=False: Retain label posterior probability images. Requires atlas segmentations to be specified. Default = false
+    retain_atlas_voting_images:
+    # type=bool|default=False: Retain atlas voting images. Default = false
+    constrain_nonnegative:
+    # type=bool|default=False: Constrain solution to non-negative weights.
+    patch_radius:
+    # type=list|default=[]: Patch radius for similarity measures. Default: 2x2x2
+    patch_metric:
+    # type=enum|default='PC'|allowed['MSQ','PC']: Metric to be used in determining the most similar neighborhood patch. Options include Pearson's correlation (PC) and mean squares (MSQ). Default = PC (Pearson correlation).
+    search_radius:
+    # type=list|default=[3, 3, 3]: Search radius for similarity measures. Default = 3x3x3. One can also specify an image where the value at the voxel specifies the isotropic search radius at that voxel.
+    exclusion_image_label:
+    # type=list|default=[]: Specify a label for the exclusion region.
+    exclusion_image:
+    # type=list|default=[]: Specify an exclusion region for the given label.
+    mask_image:
+    # type=file|default=<undefined>: If a mask image is specified, fusion is only performed in the mask region.
+    out_label_fusion:
+    # type=file: 
+    # type=file|default=<undefined>: The output label fusion image.
+    out_intensity_fusion_name_format:
+    # type=str|default='': Optional intensity fusion image file name format. (e.g. "antsJointFusionIntensity_%d.nii.gz")
+    out_label_post_prob_name_format:
+    # type=str|default='antsJointFusionPosterior_%d.nii.gz': Optional label posterior probability image file name format.
+    out_atlas_voting_weight_name_format:
+    # type=str|default='antsJointFusionVotingWeight_%d.nii.gz': Optional atlas voting weight image file name format.
+    verbose:
+    # type=bool|default=False: Verbose output.
+    num_threads:
+    # type=int|default=1: Number of ITK threads to use
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    out_label_fusion:
+    # type=file: 
+    # type=file|default=<undefined>: The output label fusion image.
+    atlas_image: '[ ["rc1s1.nii","rc1s2.nii"] ]'
+    # type=list|default=[]: The atlas image (or multimodal atlas images) assumed to be aligned to a common image domain.
+    atlas_segmentation_image:
+    # type=inputmultiobject|default=[]: The atlas segmentation images. For performing label fusion the number of specified segmentations should be identical to the number of atlas image sets.
+    target_image: '["im1.nii"]'
+    # type=list|default=[]: The target image (or multimodal target images) assumed to be aligned to a common image domain.
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    target_image: '[ ["im1.nii", "im2.nii"] ]'
+    # type=list|default=[]: The target image (or multimodal target images) assumed to be aligned to a common image domain.
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    atlas_image: '[ ["rc1s1.nii","rc1s2.nii"],["rc2s1.nii","rc2s2.nii"] ]'
+    # type=list|default=[]: The atlas image (or multimodal atlas images) assumed to be aligned to a common image domain.
+    atlas_segmentation_image:
+    # type=inputmultiobject|default=[]: The atlas segmentation images. For performing label fusion the number of specified segmentations should be identical to the number of atlas image sets.
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    dimension: '3'
+    # type=enum|default=3|allowed[2,3,4]: This option forces the image to be treated as a specified-dimensional image. If not specified, the program tries to infer the dimensionality from the input image.
+    alpha: '0.5'
+    # type=float|default=0.1: Regularization term added to matrix Mx for calculating the inverse. Default = 0.1
+    beta: '1.0'
+    # type=float|default=2.0: Exponent for mapping intensity difference to the joint error. Default = 2.0
+    patch_radius: '[3,2,1]'
+    # type=list|default=[]: Patch radius for similarity measures. Default: 2x2x2
+    search_radius: '[3]'
+    # type=list|default=[3, 3, 3]: Search radius for similarity measures. Default = 3x3x3. One can also specify an image where the value at the voxel specifies the isotropic search radius at that voxel.
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    search_radius: '["mask.nii"]'
+    # type=list|default=[3, 3, 3]: Search radius for similarity measures. Default = 3x3x3. One can also specify an image where the value at the voxel specifies the isotropic search radius at that voxel.
+    verbose: 'True'
+    # type=bool|default=False: Verbose output.
+    exclusion_image:
+    # type=list|default=[]: Specify an exclusion region for the given label.
+    exclusion_image_label: '["1","2"]'
+    # type=list|default=[]: Specify a label for the exclusion region.
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    out_label_fusion:
+    # type=file: 
+    # type=file|default=<undefined>: The output label fusion image.
+    out_intensity_fusion_name_format: '"ants_joint_fusion_intensity_%d.nii.gz"'
+    # type=str|default='': Optional intensity fusion image file name format. (e.g. "antsJointFusionIntensity_%d.nii.gz")
+    out_label_post_prob_name_format: '"ants_joint_fusion_posterior_%d.nii.gz"'
+    # type=str|default='antsJointFusionPosterior_%d.nii.gz': Optional label posterior probability image file name format.
+    out_atlas_voting_weight_name_format: '"ants_joint_fusion_voting_weight_%d.nii.gz"'
+    # type=str|default='antsJointFusionVotingWeight_%d.nii.gz': Optional atlas voting weight image file name format.
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: antsJointFusion -a 0.1 -g ["rc1s1.nii", "rc1s2.nii"] -l segmentation0.nii.gz -b 2.0 -o ants_fusion_label_output.nii -s 3x3x3 -t ["im1.nii"]
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    out_label_fusion:
+    # type=file: 
+    # type=file|default=<undefined>: The output label fusion image.
+    atlas_image: '[ ["rc1s1.nii","rc1s2.nii"] ]'
+    # type=list|default=[]: The atlas image (or multimodal atlas images) assumed to be aligned to a common image domain.
+    atlas_segmentation_image:
+    # type=inputmultiobject|default=[]: The atlas segmentation images. For performing label fusion the number of specified segmentations should be identical to the number of atlas image sets.
+    target_image: '["im1.nii"]'
+    # type=list|default=[]: The target image (or multimodal target images) assumed to be aligned to a common image domain.
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: antsJointFusion -a 0.1 -g ["rc1s1.nii", "rc1s2.nii"] -l segmentation0.nii.gz -b 2.0 -o ants_fusion_label_output.nii -s 3x3x3 -t ["im1.nii", "im2.nii"]
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    target_image: '[ ["im1.nii", "im2.nii"] ]'
+    # type=list|default=[]: The target image (or multimodal target images) assumed to be aligned to a common image domain.
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: antsJointFusion -a 0.1 -g ["rc1s1.nii", "rc1s2.nii"] -g ["rc2s1.nii", "rc2s2.nii"] -l segmentation0.nii.gz -l segmentation1.nii.gz -b 2.0 -o ants_fusion_label_output.nii -s 3x3x3 -t ["im1.nii", "im2.nii"]
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    atlas_image: '[ ["rc1s1.nii","rc1s2.nii"],["rc2s1.nii","rc2s2.nii"] ]'
+    # type=list|default=[]: The atlas image (or multimodal atlas images) assumed to be aligned to a common image domain.
+    atlas_segmentation_image:
+    # type=inputmultiobject|default=[]: The atlas segmentation images. For performing label fusion the number of specified segmentations should be identical to the number of atlas image sets.
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: antsJointFusion -a 0.5 -g ["rc1s1.nii", "rc1s2.nii"] -g ["rc2s1.nii", "rc2s2.nii"] -l segmentation0.nii.gz -l segmentation1.nii.gz -b 1.0 -d 3 -o ants_fusion_label_output.nii -p 3x2x1 -s 3 -t ["im1.nii", "im2.nii"]
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    dimension: '3'
+    # type=enum|default=3|allowed[2,3,4]: This option forces the image to be treated as a specified-dimensional image. If not specified, the program tries to infer the dimensionality from the input image.
+    alpha: '0.5'
+    # type=float|default=0.1: Regularization term added to matrix Mx for calculating the inverse. Default = 0.1
+    beta: '1.0'
+    # type=float|default=2.0: Exponent for mapping intensity difference to the joint error. Default = 2.0
+    patch_radius: '[3,2,1]'
+    # type=list|default=[]: Patch radius for similarity measures. Default: 2x2x2
+    search_radius: '[3]'
+    # type=list|default=[3, 3, 3]: Search radius for similarity measures. Default = 3x3x3. One can also specify an image where the value at the voxel specifies the isotropic search radius at that voxel.
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: antsJointFusion -a 0.5 -g ["rc1s1.nii", "rc1s2.nii"] -g ["rc2s1.nii", "rc2s2.nii"] -l segmentation0.nii.gz -l segmentation1.nii.gz -b 1.0 -d 3 -e 1[roi01.nii] -e 2[roi02.nii] -o ants_fusion_label_output.nii -p 3x2x1 -s mask.nii -t ["im1.nii", "im2.nii"] -v
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    search_radius: '["mask.nii"]'
+    # type=list|default=[3, 3, 3]: Search radius for similarity measures. Default = 3x3x3. One can also specify an image where the value at the voxel specifies the isotropic search radius at that voxel.
+    verbose: 'True'
+    # type=bool|default=False: Verbose output.
+    exclusion_image:
+    # type=list|default=[]: Specify an exclusion region for the given label.
+    exclusion_image_label: '["1","2"]'
+    # type=list|default=[]: Specify a label for the exclusion region.
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: antsJointFusion -a 0.5 -g ["rc1s1.nii", "rc1s2.nii"] -g ["rc2s1.nii", "rc2s2.nii"] -l segmentation0.nii.gz -l segmentation1.nii.gz -b 1.0 -d 3 -e 1[roi01.nii] -e 2[roi02.nii] -o [ants_fusion_label_output.nii, ants_joint_fusion_intensity_%d.nii.gz, ants_joint_fusion_posterior_%d.nii.gz, ants_joint_fusion_voting_weight_%d.nii.gz] -p 3x2x1 -s mask.nii -t ["im1.nii", "im2.nii"] -v
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    out_label_fusion:
+    # type=file: 
+    # type=file|default=<undefined>: The output label fusion image.
+    out_intensity_fusion_name_format: '"ants_joint_fusion_intensity_%d.nii.gz"'
+    # type=str|default='': Optional intensity fusion image file name format. (e.g. "antsJointFusionIntensity_%d.nii.gz")
+    out_label_post_prob_name_format: '"ants_joint_fusion_posterior_%d.nii.gz"'
+    # type=str|default='antsJointFusionPosterior_%d.nii.gz': Optional label posterior probability image file name format.
+    out_atlas_voting_weight_name_format: '"ants_joint_fusion_voting_weight_%d.nii.gz"'
+    # type=str|default='antsJointFusionVotingWeight_%d.nii.gz': Optional atlas voting weight image file name format.
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-ants/joint_fusion_callables.py b/example-specs/task/nipype_internal/pydra-ants/joint_fusion_callables.py
new file mode 100644
index 00000000..f0bf25d3
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-ants/joint_fusion_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in JointFusion.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-ants/kelly_kapowski.yaml b/example-specs/task/nipype_internal/pydra-ants/kelly_kapowski.yaml
new file mode 100644
index 00000000..6a186384
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-ants/kelly_kapowski.yaml
@@ -0,0 +1,192 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.ants.segmentation.KellyKapowski' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Nipype Interface to ANTs' KellyKapowski, also known as DiReCT.
+# 
+#     DiReCT is a registration based estimate of cortical thickness. It was published
+#     in S. R. Das, B. B. Avants, M. Grossman, and J. C. Gee, Registration based
+#     cortical thickness measurement, Neuroimage 2009, 45:867--879.
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces.ants.segmentation import KellyKapowski
+#     >>> kk = KellyKapowski()
+#     >>> kk.inputs.dimension = 3
+#     >>> kk.inputs.segmentation_image = "segmentation0.nii.gz"
+#     >>> kk.inputs.convergence = "[45,0.0,10]"
+#     >>> kk.inputs.thickness_prior_estimate = 10
+#     >>> kk.cmdline
+#     'KellyKapowski --convergence "[45,0.0,10]"
+#     --output "[segmentation0_cortical_thickness.nii.gz,segmentation0_warped_white_matter.nii.gz]"
+#     --image-dimensionality 3 --gradient-step 0.025000
+#     --maximum-number-of-invert-displacement-field-iterations 20 --number-of-integration-points 10
+#     --segmentation-image "[segmentation0.nii.gz,2,3]" --smoothing-variance 1.000000
+#     --smoothing-velocity-field-parameter 1.500000 --thickness-prior-estimate 10.000000'
+# 
+#     
+task_name: KellyKapowski
+nipype_name: KellyKapowski
+nipype_module: nipype.interfaces.ants.segmentation
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    segmentation_image: medimage/nifti-gz
+    # type=file|default=<undefined>: A segmentation image must be supplied labeling the gray and white matters. Default values = 2 and 3, respectively.
+    gray_matter_prob_image: generic/file
+    # type=file|default=<undefined>: In addition to the segmentation image, a gray matter probability image can be used. If no such image is supplied, one is created using the segmentation image and a variance of 1.0 mm.
+    white_matter_prob_image: generic/file
+    # type=file|default=<undefined>: In addition to the segmentation image, a white matter probability image can be used. If no such image is supplied, one is created using the segmentation image and a variance of 1.0 mm.
+    thickness_prior_image: generic/file
+    # type=file|default=<undefined>: An image containing spatially varying prior thickness values.
+    cortical_thickness: generic/file
+    # type=file: A thickness map defined in the segmented gray matter.
+    # type=file|default=<undefined>: Filename for the cortical thickness.
+    warped_white_matter: generic/file
+    # type=file: A warped white matter image.
+    # type=file|default=<undefined>: Filename for the warped white matter file.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    cortical_thickness: generic/file
+    # type=file: A thickness map defined in the segmented gray matter.
+    # type=file|default=<undefined>: Filename for the cortical thickness.
+    warped_white_matter: generic/file
+    # type=file: A warped white matter image.
+    # type=file|default=<undefined>: Filename for the warped white matter file.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    dimension:
+    # type=enum|default=3|allowed[2,3]: image dimension (2 or 3)
+    segmentation_image:
+    # type=file|default=<undefined>: A segmentation image must be supplied labeling the gray and white matters. Default values = 2 and 3, respectively.
+    gray_matter_label:
+    # type=int|default=2: The label value for the gray matter label in the segmentation_image.
+    white_matter_label:
+    # type=int|default=3: The label value for the white matter label in the segmentation_image.
+    gray_matter_prob_image:
+    # type=file|default=<undefined>: In addition to the segmentation image, a gray matter probability image can be used. If no such image is supplied, one is created using the segmentation image and a variance of 1.0 mm.
+    white_matter_prob_image:
+    # type=file|default=<undefined>: In addition to the segmentation image, a white matter probability image can be used. If no such image is supplied, one is created using the segmentation image and a variance of 1.0 mm.
+    convergence:
+    # type=str|default='[50,0.001,10]': Convergence is determined by fitting a line to the normalized energy profile of the last N iterations (where N is specified by the window size) and determining the slope which is then compared with the convergence threshold.
+    thickness_prior_estimate:
+    # type=float|default=10: Provides a prior constraint on the final thickness measurement in mm.
+    thickness_prior_image:
+    # type=file|default=<undefined>: An image containing spatially varying prior thickness values.
+    gradient_step:
+    # type=float|default=0.025: Gradient step size for the optimization.
+    smoothing_variance:
+    # type=float|default=1.0: Defines the Gaussian smoothing of the hit and total images.
+    smoothing_velocity_field:
+    # type=float|default=1.5: Defines the Gaussian smoothing of the velocity field (default = 1.5). If the b-spline smoothing option is chosen, then this defines the isotropic mesh spacing for the smoothing spline (default = 15).
+    use_bspline_smoothing:
+    # type=bool|default=False: Sets the option for B-spline smoothing of the velocity field.
+    number_integration_points:
+    # type=int|default=10: Number of compositions of the diffeomorphism per iteration.
+    max_invert_displacement_field_iters:
+    # type=int|default=20: Maximum number of iterations for estimating the invertdisplacement field.
+    cortical_thickness:
+    # type=file: A thickness map defined in the segmented gray matter.
+    # type=file|default=<undefined>: Filename for the cortical thickness.
+    warped_white_matter:
+    # type=file: A warped white matter image.
+    # type=file|default=<undefined>: Filename for the warped white matter file.
+    num_threads:
+    # type=int|default=1: Number of ITK threads to use
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    dimension: '3'
+    # type=enum|default=3|allowed[2,3]: image dimension (2 or 3)
+    segmentation_image:
+    # type=file|default=<undefined>: A segmentation image must be supplied labeling the gray and white matters. Default values = 2 and 3, respectively.
+    convergence: '"[45,0.0,10]"'
+    # type=str|default='[50,0.001,10]': Convergence is determined by fitting a line to the normalized energy profile of the last N iterations (where N is specified by the window size) and determining the slope which is then compared with the convergence threshold.
+    thickness_prior_estimate: '10'
+    # type=float|default=10: Provides a prior constraint on the final thickness measurement in mm.
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: KellyKapowski --convergence "[45,0.0,10]" --output "[segmentation0_cortical_thickness.nii.gz,segmentation0_warped_white_matter.nii.gz]" --image-dimensionality 3 --gradient-step 0.025000 --maximum-number-of-invert-displacement-field-iterations 20 --number-of-integration-points 10 --segmentation-image "[segmentation0.nii.gz,2,3]" --smoothing-variance 1.000000 --smoothing-velocity-field-parameter 1.500000 --thickness-prior-estimate 10.000000
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    dimension: '3'
+    # type=enum|default=3|allowed[2,3]: image dimension (2 or 3)
+    segmentation_image:
+    # type=file|default=<undefined>: A segmentation image must be supplied labeling the gray and white matters. Default values = 2 and 3, respectively.
+    convergence: '"[45,0.0,10]"'
+    # type=str|default='[50,0.001,10]': Convergence is determined by fitting a line to the normalized energy profile of the last N iterations (where N is specified by the window size) and determining the slope which is then compared with the convergence threshold.
+    thickness_prior_estimate: '10'
+    # type=float|default=10: Provides a prior constraint on the final thickness measurement in mm.
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-ants/kelly_kapowski_callables.py b/example-specs/task/nipype_internal/pydra-ants/kelly_kapowski_callables.py
new file mode 100644
index 00000000..9073c2b9
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-ants/kelly_kapowski_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in KellyKapowski.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-ants/label_geometry.yaml b/example-specs/task/nipype_internal/pydra-ants/label_geometry.yaml
new file mode 100644
index 00000000..94288523
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-ants/label_geometry.yaml
@@ -0,0 +1,170 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.ants.utils.LabelGeometry' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Extracts geometry measures using a label file and an optional image file
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces.ants import LabelGeometry
+#     >>> label_extract = LabelGeometry()
+#     >>> label_extract.inputs.dimension = 3
+#     >>> label_extract.inputs.label_image = 'atlas.nii.gz'
+#     >>> label_extract.cmdline
+#     'LabelGeometryMeasures 3 atlas.nii.gz [] atlas.csv'
+# 
+#     >>> label_extract.inputs.intensity_image = 'ants_Warp.nii.gz'
+#     >>> label_extract.cmdline
+#     'LabelGeometryMeasures 3 atlas.nii.gz ants_Warp.nii.gz atlas.csv'
+# 
+#     
+task_name: LabelGeometry
+nipype_name: LabelGeometry
+nipype_module: nipype.interfaces.ants.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    label_image: medimage/nifti-gz
+    # type=file|default=<undefined>: label image to use for extracting geometry measures
+    intensity_image: medimage/nifti-gz
+    # type=file|default='[]': Intensity image to extract values from. This is an optional input
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    output_file: generic/file
+    # type=file: CSV file of geometry measures
+    # type=str|default='': name of output file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    dimension:
+    # type=enum|default=3|allowed[2,3]: image dimension (2 or 3)
+    label_image:
+    # type=file|default=<undefined>: label image to use for extracting geometry measures
+    intensity_image:
+    # type=file|default='[]': Intensity image to extract values from. This is an optional input
+    output_file:
+    # type=file: CSV file of geometry measures
+    # type=str|default='': name of output file
+    num_threads:
+    # type=int|default=1: Number of ITK threads to use
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    dimension: '3'
+    # type=enum|default=3|allowed[2,3]: image dimension (2 or 3)
+    label_image:
+    # type=file|default=<undefined>: label image to use for extracting geometry measures
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    intensity_image:
+    # type=file|default='[]': Intensity image to extract values from. This is an optional input
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: LabelGeometryMeasures 3 atlas.nii.gz [] atlas.csv
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    dimension: '3'
+    # type=enum|default=3|allowed[2,3]: image dimension (2 or 3)
+    label_image:
+    # type=file|default=<undefined>: label image to use for extracting geometry measures
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: LabelGeometryMeasures 3 atlas.nii.gz ants_Warp.nii.gz atlas.csv
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    intensity_image:
+    # type=file|default='[]': Intensity image to extract values from. This is an optional input
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-ants/label_geometry_callables.py b/example-specs/task/nipype_internal/pydra-ants/label_geometry_callables.py
new file mode 100644
index 00000000..2ec8a91a
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-ants/label_geometry_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in LabelGeometry.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-ants/laplacian_thickness.yaml b/example-specs/task/nipype_internal/pydra-ants/laplacian_thickness.yaml
new file mode 100644
index 00000000..b5fda038
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-ants/laplacian_thickness.yaml
@@ -0,0 +1,180 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.ants.segmentation.LaplacianThickness' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Calculates the cortical thickness from an anatomical image
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces.ants import LaplacianThickness
+#     >>> cort_thick = LaplacianThickness()
+#     >>> cort_thick.inputs.input_wm = 'white_matter.nii.gz'
+#     >>> cort_thick.inputs.input_gm = 'gray_matter.nii.gz'
+#     >>> cort_thick.cmdline
+#     'LaplacianThickness white_matter.nii.gz gray_matter.nii.gz white_matter_thickness.nii.gz'
+# 
+#     >>> cort_thick.inputs.output_image = 'output_thickness.nii.gz'
+#     >>> cort_thick.cmdline
+#     'LaplacianThickness white_matter.nii.gz gray_matter.nii.gz output_thickness.nii.gz'
+# 
+#     
+task_name: LaplacianThickness
+nipype_name: LaplacianThickness
+nipype_module: nipype.interfaces.ants.segmentation
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    input_wm: medimage/nifti-gz
+    # type=file|default=<undefined>: white matter segmentation image
+    input_gm: medimage/nifti-gz
+    # type=file|default=<undefined>: gray matter segmentation image
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    output_image: medimage/nifti-gz
+    # type=file: Cortical thickness
+    # type=str|default='': name of output file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    input_wm:
+    # type=file|default=<undefined>: white matter segmentation image
+    input_gm:
+    # type=file|default=<undefined>: gray matter segmentation image
+    output_image:
+    # type=file: Cortical thickness
+    # type=str|default='': name of output file
+    smooth_param:
+    # type=float|default=0.0: Sigma of the Laplacian Recursive Image Filter (defaults to 1)
+    prior_thickness:
+    # type=float|default=0.0: Prior thickness (defaults to 500)
+    dT:
+    # type=float|default=0.0: Time delta used during integration (defaults to 0.01)
+    sulcus_prior:
+    # type=float|default=0.0: Positive floating point number for sulcus prior. Authors said that 0.15 might be a reasonable value
+    tolerance:
+    # type=float|default=0.0: Tolerance to reach during optimization (defaults to 0.001)
+    num_threads:
+    # type=int|default=1: Number of ITK threads to use
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    input_wm:
+    # type=file|default=<undefined>: white matter segmentation image
+    input_gm:
+    # type=file|default=<undefined>: gray matter segmentation image
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    output_image: '"output_thickness.nii.gz"'
+    # type=file: Cortical thickness
+    # type=str|default='': name of output file
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: LaplacianThickness white_matter.nii.gz gray_matter.nii.gz white_matter_thickness.nii.gz
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    input_wm:
+    # type=file|default=<undefined>: white matter segmentation image
+    input_gm:
+    # type=file|default=<undefined>: gray matter segmentation image
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: LaplacianThickness white_matter.nii.gz gray_matter.nii.gz output_thickness.nii.gz
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    output_image: '"output_thickness.nii.gz"'
+    # type=file: Cortical thickness
+    # type=str|default='': name of output file
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-ants/laplacian_thickness_callables.py b/example-specs/task/nipype_internal/pydra-ants/laplacian_thickness_callables.py
new file mode 100644
index 00000000..c361c6b2
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-ants/laplacian_thickness_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in LaplacianThickness.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-ants/measure_image_similarity.yaml b/example-specs/task/nipype_internal/pydra-ants/measure_image_similarity.yaml
new file mode 100644
index 00000000..373cae28
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-ants/measure_image_similarity.yaml
@@ -0,0 +1,185 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.ants.registration.MeasureImageSimilarity' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+# 
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces.ants import MeasureImageSimilarity
+#     >>> sim = MeasureImageSimilarity()
+#     >>> sim.inputs.dimension = 3
+#     >>> sim.inputs.metric = 'MI'
+#     >>> sim.inputs.fixed_image = 'T1.nii'
+#     >>> sim.inputs.moving_image = 'resting.nii'
+#     >>> sim.inputs.metric_weight = 1.0
+#     >>> sim.inputs.radius_or_number_of_bins = 5
+#     >>> sim.inputs.sampling_strategy = 'Regular'
+#     >>> sim.inputs.sampling_percentage = 1.0
+#     >>> sim.inputs.fixed_image_mask = 'mask.nii'
+#     >>> sim.inputs.moving_image_mask = 'mask.nii.gz'
+#     >>> sim.cmdline
+#     'MeasureImageSimilarity --dimensionality 3 --masks ["mask.nii","mask.nii.gz"] --metric MI["T1.nii","resting.nii",1.0,5,Regular,1.0]'
+#     
+task_name: MeasureImageSimilarity
+nipype_name: MeasureImageSimilarity
+nipype_module: nipype.interfaces.ants.registration
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    fixed_image: medimage/nifti1
+    # type=file|default=<undefined>: Image to which the moving image is warped
+    moving_image: medimage/nifti1
+    # type=file|default=<undefined>: Image to apply transformation to (generally a coregistered functional)
+    fixed_image_mask: medimage/nifti1
+    # type=file|default=<undefined>: mask used to limit metric sampling region of the fixed image
+    moving_image_mask: medimage/nifti-gz
+    # type=file|default=<undefined>: mask used to limit metric sampling region of the moving image
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    dimension:
+    # type=enum|default=2|allowed[2,3,4]: Dimensionality of the fixed/moving image pair
+    fixed_image:
+    # type=file|default=<undefined>: Image to which the moving image is warped
+    moving_image:
+    # type=file|default=<undefined>: Image to apply transformation to (generally a coregistered functional)
+    metric:
+    # type=enum|default='CC'|allowed['CC','Demons','GC','MI','Mattes','MeanSquares']: 
+    metric_weight:
+    # type=float|default=1.0: The "metricWeight" variable is not used.
+    radius_or_number_of_bins:
+    # type=int|default=0: The number of bins in each stage for the MI and Mattes metric, or the radius for other metrics
+    sampling_strategy:
+    # type=enum|default='None'|allowed['None','Random','Regular']: Manner of choosing point set over which to optimize the metric. Defaults to "None" (i.e. a dense sampling of one sample per voxel).
+    sampling_percentage:
+    # type=range|default=None: Percentage of points accessible to the sampling strategy over which to optimize the metric.
+    fixed_image_mask:
+    # type=file|default=<undefined>: mask used to limit metric sampling region of the fixed image
+    moving_image_mask:
+    # type=file|default=<undefined>: mask used to limit metric sampling region of the moving image
+    num_threads:
+    # type=int|default=1: Number of ITK threads to use
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    dimension: '3'
+    # type=enum|default=2|allowed[2,3,4]: Dimensionality of the fixed/moving image pair
+    metric: '"MI"'
+    # type=enum|default='CC'|allowed['CC','Demons','GC','MI','Mattes','MeanSquares']: 
+    fixed_image:
+    # type=file|default=<undefined>: Image to which the moving image is warped
+    moving_image:
+    # type=file|default=<undefined>: Image to apply transformation to (generally a coregistered functional)
+    metric_weight: '1.0'
+    # type=float|default=1.0: The "metricWeight" variable is not used.
+    radius_or_number_of_bins: '5'
+    # type=int|default=0: The number of bins in each stage for the MI and Mattes metric, or the radius for other metrics
+    sampling_strategy: '"Regular"'
+    # type=enum|default='None'|allowed['None','Random','Regular']: Manner of choosing point set over which to optimize the metric. Defaults to "None" (i.e. a dense sampling of one sample per voxel).
+    sampling_percentage: '1.0'
+    # type=range|default=None: Percentage of points accessible to the sampling strategy over which to optimize the metric.
+    fixed_image_mask:
+    # type=file|default=<undefined>: mask used to limit metric sampling region of the fixed image
+    moving_image_mask:
+    # type=file|default=<undefined>: mask used to limit metric sampling region of the moving image
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: MeasureImageSimilarity --dimensionality 3 --masks ["mask.nii","mask.nii.gz"] --metric MI["T1.nii","resting.nii",1.0,5,Regular,1.0]
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    dimension: '3'
+    # type=enum|default=2|allowed[2,3,4]: Dimensionality of the fixed/moving image pair
+    metric: '"MI"'
+    # type=enum|default='CC'|allowed['CC','Demons','GC','MI','Mattes','MeanSquares']: 
+    fixed_image:
+    # type=file|default=<undefined>: Image to which the moving image is warped
+    moving_image:
+    # type=file|default=<undefined>: Image to apply transformation to (generally a coregistered functional)
+    metric_weight: '1.0'
+    # type=float|default=1.0: The "metricWeight" variable is not used.
+    radius_or_number_of_bins: '5'
+    # type=int|default=0: The number of bins in each stage for the MI and Mattes metric, or the radius for other metrics
+    sampling_strategy: '"Regular"'
+    # type=enum|default='None'|allowed['None','Random','Regular']: Manner of choosing point set over which to optimize the metric. Defaults to "None" (i.e. a dense sampling of one sample per voxel).
+    sampling_percentage: '1.0'
+    # type=range|default=None: Percentage of points accessible to the sampling strategy over which to optimize the metric.
+    fixed_image_mask:
+    # type=file|default=<undefined>: mask used to limit metric sampling region of the fixed image
+    moving_image_mask:
+    # type=file|default=<undefined>: mask used to limit metric sampling region of the moving image
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-ants/measure_image_similarity_callables.py b/example-specs/task/nipype_internal/pydra-ants/measure_image_similarity_callables.py
new file mode 100644
index 00000000..7379ba2f
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-ants/measure_image_similarity_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in MeasureImageSimilarity.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-ants/multiply_images.yaml b/example-specs/task/nipype_internal/pydra-ants/multiply_images.yaml
new file mode 100644
index 00000000..b0598214
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-ants/multiply_images.yaml
@@ -0,0 +1,143 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.ants.utils.MultiplyImages' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces.ants import MultiplyImages
+#     >>> test = MultiplyImages()
+#     >>> test.inputs.dimension = 3
+#     >>> test.inputs.first_input = 'moving2.nii'
+#     >>> test.inputs.second_input = 0.25
+#     >>> test.inputs.output_product_image = "out.nii"
+#     >>> test.cmdline
+#     'MultiplyImages 3 moving2.nii 0.25 out.nii'
+#     
+task_name: MultiplyImages
+nipype_name: MultiplyImages
+nipype_module: nipype.interfaces.ants.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    first_input: medimage/nifti1
+    # type=file|default=<undefined>: image 1
+    output_product_image: medimage/nifti1
+    # type=file: average image file
+    # type=file|default=<undefined>: Outputfname.nii.gz: the name of the resulting image.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    output_product_image: medimage/nifti1
+    # type=file: average image file
+    # type=file|default=<undefined>: Outputfname.nii.gz: the name of the resulting image.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    dimension:
+    # type=enum|default=3|allowed[2,3]: image dimension (2 or 3)
+    first_input:
+    # type=file|default=<undefined>: image 1
+    second_input:
+    # type=traitcompound|default=None: image 2 or multiplication weight
+    output_product_image:
+    # type=file: average image file
+    # type=file|default=<undefined>: Outputfname.nii.gz: the name of the resulting image.
+    num_threads:
+    # type=int|default=1: Number of ITK threads to use
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    dimension: '3'
+    # type=enum|default=3|allowed[2,3]: image dimension (2 or 3)
+    first_input:
+    # type=file|default=<undefined>: image 1
+    second_input: '0.25'
+    # type=traitcompound|default=None: image 2 or multiplication weight
+    output_product_image:
+    # type=file: average image file
+    # type=file|default=<undefined>: Outputfname.nii.gz: the name of the resulting image.
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: MultiplyImages 3 moving2.nii 0.25 out.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    dimension: '3'
+    # type=enum|default=3|allowed[2,3]: image dimension (2 or 3)
+    first_input:
+    # type=file|default=<undefined>: image 1
+    second_input: '0.25'
+    # type=traitcompound|default=None: image 2 or multiplication weight
+    output_product_image:
+    # type=file: average image file
+    # type=file|default=<undefined>: Outputfname.nii.gz: the name of the resulting image.
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-ants/multiply_images_callables.py b/example-specs/task/nipype_internal/pydra-ants/multiply_images_callables.py
new file mode 100644
index 00000000..47cb95b1
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-ants/multiply_images_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in MultiplyImages.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-ants/n4_bias_field_correction.yaml b/example-specs/task/nipype_internal/pydra-ants/n4_bias_field_correction.yaml
new file mode 100644
index 00000000..a85f6de1
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-ants/n4_bias_field_correction.yaml
@@ -0,0 +1,378 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.ants.segmentation.N4BiasFieldCorrection' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Bias field correction.
+# 
+#     N4 is a variant of the popular N3 (nonparameteric nonuniform normalization)
+#     retrospective bias correction algorithm. Based on the assumption that the
+#     corruption of the low frequency bias field can be modeled as a convolution of
+#     the intensity histogram by a Gaussian, the basic algorithmic protocol is to
+#     iterate between deconvolving the intensity histogram by a Gaussian, remapping
+#     the intensities, and then spatially smoothing this result by a B-spline modeling
+#     of the bias field itself. The modifications from and improvements obtained over
+#     the original N3 algorithm are described in [Tustison2010]_.
+# 
+#     .. [Tustison2010] N. Tustison et al.,
+#       N4ITK: Improved N3 Bias Correction, IEEE Transactions on Medical Imaging,
+#       29(6):1310-1320, June 2010.
+# 
+#     Examples
+#     --------
+# 
+#     >>> import copy
+#     >>> from nipype.interfaces.ants import N4BiasFieldCorrection
+#     >>> n4 = N4BiasFieldCorrection()
+#     >>> n4.inputs.dimension = 3
+#     >>> n4.inputs.input_image = 'structural.nii'
+#     >>> n4.inputs.bspline_fitting_distance = 300
+#     >>> n4.inputs.shrink_factor = 3
+#     >>> n4.inputs.n_iterations = [50,50,30,20]
+#     >>> n4.cmdline
+#     'N4BiasFieldCorrection --bspline-fitting [ 300 ]
+#     -d 3 --input-image structural.nii
+#     --convergence [ 50x50x30x20 ] --output structural_corrected.nii
+#     --shrink-factor 3'
+# 
+#     >>> n4_2 = copy.deepcopy(n4)
+#     >>> n4_2.inputs.convergence_threshold = 1e-6
+#     >>> n4_2.cmdline
+#     'N4BiasFieldCorrection --bspline-fitting [ 300 ]
+#     -d 3 --input-image structural.nii
+#     --convergence [ 50x50x30x20, 1e-06 ] --output structural_corrected.nii
+#     --shrink-factor 3'
+# 
+#     >>> n4_3 = copy.deepcopy(n4_2)
+#     >>> n4_3.inputs.bspline_order = 5
+#     >>> n4_3.cmdline
+#     'N4BiasFieldCorrection --bspline-fitting [ 300, 5 ]
+#     -d 3 --input-image structural.nii
+#     --convergence [ 50x50x30x20, 1e-06 ] --output structural_corrected.nii
+#     --shrink-factor 3'
+# 
+#     >>> n4_4 = N4BiasFieldCorrection()
+#     >>> n4_4.inputs.input_image = 'structural.nii'
+#     >>> n4_4.inputs.save_bias = True
+#     >>> n4_4.inputs.dimension = 3
+#     >>> n4_4.cmdline
+#     'N4BiasFieldCorrection -d 3 --input-image structural.nii
+#     --output [ structural_corrected.nii, structural_bias.nii ]'
+# 
+#     >>> n4_5 = N4BiasFieldCorrection()
+#     >>> n4_5.inputs.input_image = 'structural.nii'
+#     >>> n4_5.inputs.dimension = 3
+#     >>> n4_5.inputs.histogram_sharpening = (0.12, 0.02, 200)
+#     >>> n4_5.cmdline
+#     'N4BiasFieldCorrection -d 3  --histogram-sharpening [0.12,0.02,200]
+#     --input-image structural.nii --output structural_corrected.nii'
+# 
+#     
+task_name: N4BiasFieldCorrection
+nipype_name: N4BiasFieldCorrection
+nipype_module: nipype.interfaces.ants.segmentation
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    input_image: medimage/nifti1
+    # type=file|default=<undefined>: input for bias correction. Negative values or values close to zero should be processed prior to correction
+    mask_image: generic/file
+    # type=file|default=<undefined>: image to specify region to perform final bias correction in
+    weight_image: generic/file
+    # type=file|default=<undefined>: image for relative weighting (e.g. probability map of the white matter) of voxels during the B-spline fitting. 
+    bias_image: generic/file
+    # type=file: Estimated bias
+    # type=file|default=<undefined>: Filename for the estimated bias.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    output_image: generic/file
+    # type=file: Warped image
+    # type=str|default='': output file name
+    bias_image: generic/file
+    # type=file: Estimated bias
+    # type=file|default=<undefined>: Filename for the estimated bias.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    dimension:
+    # type=enum|default=3|allowed[2,3,4]: image dimension (2, 3 or 4)
+    input_image:
+    # type=file|default=<undefined>: input for bias correction. Negative values or values close to zero should be processed prior to correction
+    mask_image:
+    # type=file|default=<undefined>: image to specify region to perform final bias correction in
+    weight_image:
+    # type=file|default=<undefined>: image for relative weighting (e.g. probability map of the white matter) of voxels during the B-spline fitting. 
+    output_image:
+    # type=file: Warped image
+    # type=str|default='': output file name
+    bspline_fitting_distance:
+    # type=float|default=0.0: 
+    bspline_order:
+    # type=int|default=0: 
+    shrink_factor:
+    # type=int|default=0: 
+    n_iterations:
+    # type=list|default=[]: 
+    convergence_threshold:
+    # type=float|default=0.0: 
+    save_bias:
+    # type=bool|default=False: True if the estimated bias should be saved to file.
+    bias_image:
+    # type=file: Estimated bias
+    # type=file|default=<undefined>: Filename for the estimated bias.
+    copy_header:
+    # type=bool|default=False: copy headers of the original image into the output (corrected) file
+    rescale_intensities:
+    # type=bool|default=False: [NOTE: Only ANTs>=2.1.0] At each iteration, a new intensity mapping is calculated and applied but there is nothing which constrains the new intensity range to be within certain values. The result is that the range can "drift" from the original at each iteration. This option rescales to the [min,max] range of the original image intensities within the user-specified mask.
+    histogram_sharpening:
+    # type=tuple|default=(0.15, 0.01, 200): Three-values tuple of histogram sharpening parameters (FWHM, wienerNose, numberOfHistogramBins). These options describe the histogram sharpening parameters, i.e. the deconvolution step parameters described in the original N3 algorithm. The default values have been shown to work fairly well.
+    num_threads:
+    # type=int|default=1: Number of ITK threads to use
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    dimension: '3'
+    # type=enum|default=3|allowed[2,3,4]: image dimension (2, 3 or 4)
+    input_image:
+    # type=file|default=<undefined>: input for bias correction. Negative values or values close to zero should be processed prior to correction
+    bspline_fitting_distance: '300'
+    # type=float|default=0.0: 
+    shrink_factor: '3'
+    # type=int|default=0: 
+    n_iterations: '[50,50,30,20]'
+    # type=list|default=[]: 
+  imports: &id001
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  - module: copy
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    convergence_threshold: 1e-6
+    # type=float|default=0.0: 
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    bspline_order: '5'
+    # type=int|default=0: 
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    input_image:
+    # type=file|default=<undefined>: input for bias correction. Negative values or values close to zero should be processed prior to correction
+    save_bias: 'True'
+    # type=bool|default=False: True if the estimated bias should be saved to file.
+    dimension: '3'
+    # type=enum|default=3|allowed[2,3,4]: image dimension (2, 3 or 4)
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    input_image:
+    # type=file|default=<undefined>: input for bias correction. Negative values or values close to zero should be processed prior to correction
+    dimension: '3'
+    # type=enum|default=3|allowed[2,3,4]: image dimension (2, 3 or 4)
+    histogram_sharpening: (0.12, 0.02, 200)
+    # type=tuple|default=(0.15, 0.01, 200): Three-values tuple of histogram sharpening parameters (FWHM, wienerNose, numberOfHistogramBins). These options describe the histogram sharpening parameters, i.e. the deconvolution step parameters described in the original N3 algorithm. The default values have been shown to work fairly well.
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: N4BiasFieldCorrection --bspline-fitting [ 300 ] -d 3 --input-image structural.nii --convergence [ 50x50x30x20 ] --output structural_corrected.nii --shrink-factor 3
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    dimension: '3'
+    # type=enum|default=3|allowed[2,3,4]: image dimension (2, 3 or 4)
+    input_image:
+    # type=file|default=<undefined>: input for bias correction. Negative values or values close to zero should be processed prior to correction
+    bspline_fitting_distance: '300'
+    # type=float|default=0.0: 
+    shrink_factor: '3'
+    # type=int|default=0: 
+    n_iterations: '[50,50,30,20]'
+    # type=list|default=[]: 
+  imports: *id001
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: N4BiasFieldCorrection --bspline-fitting [ 300 ] -d 3 --input-image structural.nii --convergence [ 50x50x30x20, 1e-06 ] --output structural_corrected.nii --shrink-factor 3
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    convergence_threshold: 1e-6
+    # type=float|default=0.0: 
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: N4BiasFieldCorrection --bspline-fitting [ 300, 5 ] -d 3 --input-image structural.nii --convergence [ 50x50x30x20, 1e-06 ] --output structural_corrected.nii --shrink-factor 3
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    bspline_order: '5'
+    # type=int|default=0: 
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: N4BiasFieldCorrection -d 3 --input-image structural.nii --output [ structural_corrected.nii, structural_bias.nii ]
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    input_image:
+    # type=file|default=<undefined>: input for bias correction. Negative values or values close to zero should be processed prior to correction
+    save_bias: 'True'
+    # type=bool|default=False: True if the estimated bias should be saved to file.
+    dimension: '3'
+    # type=enum|default=3|allowed[2,3,4]: image dimension (2, 3 or 4)
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: N4BiasFieldCorrection -d 3 --histogram-sharpening [0.12,0.02,200] --input-image structural.nii --output structural_corrected.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    input_image:
+    # type=file|default=<undefined>: input for bias correction. Negative values or values close to zero should be processed prior to correction
+    dimension: '3'
+    # type=enum|default=3|allowed[2,3,4]: image dimension (2, 3 or 4)
+    histogram_sharpening: (0.12, 0.02, 200)
+    # type=tuple|default=(0.15, 0.01, 200): Three-values tuple of histogram sharpening parameters (FWHM, wienerNose, numberOfHistogramBins). These options describe the histogram sharpening parameters, i.e. the deconvolution step parameters described in the original N3 algorithm. The default values have been shown to work fairly well.
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-ants/n4_bias_field_correction_callables.py b/example-specs/task/nipype_internal/pydra-ants/n4_bias_field_correction_callables.py
new file mode 100644
index 00000000..7c58464f
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-ants/n4_bias_field_correction_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in N4BiasFieldCorrection.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-ants/registration.yaml b/example-specs/task/nipype_internal/pydra-ants/registration.yaml
new file mode 100644
index 00000000..a88a4468
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-ants/registration.yaml
@@ -0,0 +1,1105 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.ants.registration.Registration' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# ANTs Registration command for registration of images
+# 
+#     `antsRegistration <http://stnava.github.io/ANTs/>`_ registers a ``moving_image`` to a ``fixed_image``,
+#     using a predefined (sequence of) cost function(s) and transformation operations.
+#     The cost function is defined using one or more 'metrics', specifically
+#     local cross-correlation (``CC``), Mean Squares (``MeanSquares``), Demons (``Demons``),
+#     global correlation (``GC``), or Mutual Information (``Mattes`` or ``MI``).
+# 
+#     ANTS can use both linear (``Translation``, ``Rigid``, ``Affine``, ``CompositeAffine``,
+#     or ``Translation``) and non-linear transformations (``BSpline``, ``GaussianDisplacementField``,
+#     ``TimeVaryingVelocityField``, ``TimeVaryingBSplineVelocityField``, ``SyN``, ``BSplineSyN``,
+#     ``Exponential``, or ``BSplineExponential``). Usually, registration is done in multiple
+#     *stages*. For example first an Affine, then a Rigid, and ultimately a non-linear
+#     (Syn)-transformation.
+# 
+#     antsRegistration can be initialized using one or more transforms from moving_image
+#     to fixed_image with the ``initial_moving_transform``-input. For example, when you
+#     already have a warpfield that corrects for geometrical distortions in an EPI (functional) image,
+#     that you want to apply before an Affine registration to a structural image.
+#     You could put this transform into 'intial_moving_transform'.
+# 
+#     The Registration-interface can output the resulting transform(s) that map moving_image to
+#     fixed_image in a single file as a ``composite_transform`` (if ``write_composite_transform``
+#     is set to ``True``), or a list of transforms as ``forwards_transforms``. It can also output
+#     inverse transforms (from ``fixed_image`` to ``moving_image``) in a similar fashion using
+#     ``inverse_composite_transform``. Note that the order of ``forward_transforms`` is in 'natural'
+#     order: the first element should be applied first, the last element should be applied last.
+# 
+#     Note, however, that ANTS tools always apply lists of transformations in reverse order (the last
+#     transformation in the list is applied first). Therefore, if the output forward_transforms
+#     is a list, one can not directly feed it into, for example, ``ants.ApplyTransforms``. To
+#     make ``ants.ApplyTransforms`` apply the transformations in the same order as ``ants.Registration``,
+#     you have to provide the list of transformations in reverse order from ``forward_transforms``.
+#     ``reverse_forward_transforms`` outputs ``forward_transforms`` in reverse order and can be used for
+#     this purpose. Note also that, because ``composite_transform`` is always a single file, this
+#     output is preferred for  most use-cases.
+# 
+#     More information can be found in the `ANTS
+#     manual <https://sourceforge.net/projects/advants/files/Documentation/ants.pdf/download>`_.
+# 
+#     See below for some useful examples.
+# 
+#     Examples
+#     --------
+# 
+#     Set up a Registration node with some default settings. This Node registers
+#     'fixed1.nii' to 'moving1.nii' by first fitting a linear 'Affine' transformation, and
+#     then a non-linear 'SyN' transformation, both using the Mutual Information-cost
+#     metric.
+# 
+#     The registration is initialized by first applying the (linear) transform
+#     trans.mat.
+# 
+#     >>> import copy, pprint
+#     >>> from nipype.interfaces.ants import Registration
+#     >>> reg = Registration()
+#     >>> reg.inputs.fixed_image = 'fixed1.nii'
+#     >>> reg.inputs.moving_image = 'moving1.nii'
+#     >>> reg.inputs.output_transform_prefix = "output_"
+#     >>> reg.inputs.initial_moving_transform = 'trans.mat'
+#     >>> reg.inputs.transforms = ['Affine', 'SyN']
+#     >>> reg.inputs.transform_parameters = [(2.0,), (0.25, 3.0, 0.0)]
+#     >>> reg.inputs.number_of_iterations = [[1500, 200], [100, 50, 30]]
+#     >>> reg.inputs.dimension = 3
+#     >>> reg.inputs.write_composite_transform = True
+#     >>> reg.inputs.collapse_output_transforms = False
+#     >>> reg.inputs.initialize_transforms_per_stage = False
+#     >>> reg.inputs.metric = ['Mattes']*2
+#     >>> reg.inputs.metric_weight = [1]*2 # Default (value ignored currently by ANTs)
+#     >>> reg.inputs.radius_or_number_of_bins = [32]*2
+#     >>> reg.inputs.sampling_strategy = ['Random', None]
+#     >>> reg.inputs.sampling_percentage = [0.05, None]
+#     >>> reg.inputs.convergence_threshold = [1.e-8, 1.e-9]
+#     >>> reg.inputs.convergence_window_size = [20]*2
+#     >>> reg.inputs.smoothing_sigmas = [[1,0], [2,1,0]]
+#     >>> reg.inputs.sigma_units = ['vox'] * 2
+#     >>> reg.inputs.shrink_factors = [[2,1], [3,2,1]]
+#     >>> reg.inputs.use_estimate_learning_rate_once = [True, True]
+#     >>> reg.inputs.use_histogram_matching = [True, True] # This is the default
+#     >>> reg.inputs.output_warped_image = 'output_warped_image.nii.gz'
+#     >>> reg.cmdline
+#     'antsRegistration --collapse-output-transforms 0 --dimensionality 3 --initial-moving-transform [ trans.mat, 0 ] --initialize-transforms-per-stage 0 --interpolation Linear --output [ output_, output_warped_image.nii.gz ] --transform Affine[ 2.0 ] --metric Mattes[ fixed1.nii, moving1.nii, 1, 32, Random, 0.05 ] --convergence [ 1500x200, 1e-08, 20 ] --smoothing-sigmas 1.0x0.0vox --shrink-factors 2x1 --use-estimate-learning-rate-once 1 --use-histogram-matching 1 --transform SyN[ 0.25, 3.0, 0.0 ] --metric Mattes[ fixed1.nii, moving1.nii, 1, 32 ] --convergence [ 100x50x30, 1e-09, 20 ] --smoothing-sigmas 2.0x1.0x0.0vox --shrink-factors 3x2x1 --use-estimate-learning-rate-once 1 --use-histogram-matching 1 --winsorize-image-intensities [ 0.0, 1.0 ]  --write-composite-transform 1'
+#     >>> reg.run()  # doctest: +SKIP
+# 
+#     Same as reg1, but first invert the initial transform ('trans.mat') before applying it.
+# 
+#     >>> reg.inputs.invert_initial_moving_transform = True
+#     >>> reg1 = copy.deepcopy(reg)
+#     >>> reg1.inputs.winsorize_lower_quantile = 0.025
+#     >>> reg1.cmdline
+#     'antsRegistration --collapse-output-transforms 0 --dimensionality 3 --initial-moving-transform [ trans.mat, 1 ] --initialize-transforms-per-stage 0 --interpolation Linear --output [ output_, output_warped_image.nii.gz ] --transform Affine[ 2.0 ] --metric Mattes[ fixed1.nii, moving1.nii, 1, 32, Random, 0.05 ] --convergence [ 1500x200, 1e-08, 20 ] --smoothing-sigmas 1.0x0.0vox --shrink-factors 2x1 --use-estimate-learning-rate-once 1 --use-histogram-matching 1 --transform SyN[ 0.25, 3.0, 0.0 ] --metric Mattes[ fixed1.nii, moving1.nii, 1, 32 ] --convergence [ 100x50x30, 1e-09, 20 ] --smoothing-sigmas 2.0x1.0x0.0vox --shrink-factors 3x2x1 --use-estimate-learning-rate-once 1 --use-histogram-matching 1 --winsorize-image-intensities [ 0.025, 1.0 ]  --write-composite-transform 1'
+#     >>> reg1.run()  # doctest: +SKIP
+# 
+#     Clip extremely high intensity data points using winsorize_upper_quantile. All data points
+#     higher than the 0.975 quantile are set to the value of the 0.975 quantile.
+# 
+#     >>> reg2 = copy.deepcopy(reg)
+#     >>> reg2.inputs.winsorize_upper_quantile = 0.975
+#     >>> reg2.cmdline
+#     'antsRegistration --collapse-output-transforms 0 --dimensionality 3 --initial-moving-transform [ trans.mat, 1 ] --initialize-transforms-per-stage 0 --interpolation Linear --output [ output_, output_warped_image.nii.gz ] --transform Affine[ 2.0 ] --metric Mattes[ fixed1.nii, moving1.nii, 1, 32, Random, 0.05 ] --convergence [ 1500x200, 1e-08, 20 ] --smoothing-sigmas 1.0x0.0vox --shrink-factors 2x1 --use-estimate-learning-rate-once 1 --use-histogram-matching 1 --transform SyN[ 0.25, 3.0, 0.0 ] --metric Mattes[ fixed1.nii, moving1.nii, 1, 32 ] --convergence [ 100x50x30, 1e-09, 20 ] --smoothing-sigmas 2.0x1.0x0.0vox --shrink-factors 3x2x1 --use-estimate-learning-rate-once 1 --use-histogram-matching 1 --winsorize-image-intensities [ 0.0, 0.975 ]  --write-composite-transform 1'
+# 
+#     Clip extremely low intensity data points using winsorize_lower_quantile. All data points
+#     lower than the 0.025 quantile are set to the original value at the 0.025 quantile.
+# 
+# 
+#     >>> reg3 = copy.deepcopy(reg)
+#     >>> reg3.inputs.winsorize_lower_quantile = 0.025
+#     >>> reg3.inputs.winsorize_upper_quantile = 0.975
+#     >>> reg3.cmdline
+#     'antsRegistration --collapse-output-transforms 0 --dimensionality 3 --initial-moving-transform [ trans.mat, 1 ] --initialize-transforms-per-stage 0 --interpolation Linear --output [ output_, output_warped_image.nii.gz ] --transform Affine[ 2.0 ] --metric Mattes[ fixed1.nii, moving1.nii, 1, 32, Random, 0.05 ] --convergence [ 1500x200, 1e-08, 20 ] --smoothing-sigmas 1.0x0.0vox --shrink-factors 2x1 --use-estimate-learning-rate-once 1 --use-histogram-matching 1 --transform SyN[ 0.25, 3.0, 0.0 ] --metric Mattes[ fixed1.nii, moving1.nii, 1, 32 ] --convergence [ 100x50x30, 1e-09, 20 ] --smoothing-sigmas 2.0x1.0x0.0vox --shrink-factors 3x2x1 --use-estimate-learning-rate-once 1 --use-histogram-matching 1 --winsorize-image-intensities [ 0.025, 0.975 ]  --write-composite-transform 1'
+# 
+#     Use float instead of double for computations (saves memory usage)
+# 
+#     >>> reg3a = copy.deepcopy(reg)
+#     >>> reg3a.inputs.float = True
+#     >>> reg3a.cmdline
+#     'antsRegistration --collapse-output-transforms 0 --dimensionality 3 --float 1 --initial-moving-transform [ trans.mat, 1 ] --initialize-transforms-per-stage 0 --interpolation Linear --output [ output_, output_warped_image.nii.gz ] --transform Affine[ 2.0 ] --metric Mattes[ fixed1.nii, moving1.nii, 1, 32, Random, 0.05 ] --convergence [ 1500x200, 1e-08, 20 ] --smoothing-sigmas 1.0x0.0vox --shrink-factors 2x1 --use-estimate-learning-rate-once 1 --use-histogram-matching 1 --transform SyN[ 0.25, 3.0, 0.0 ] --metric Mattes[ fixed1.nii, moving1.nii, 1, 32 ] --convergence [ 100x50x30, 1e-09, 20 ] --smoothing-sigmas 2.0x1.0x0.0vox --shrink-factors 3x2x1 --use-estimate-learning-rate-once 1 --use-histogram-matching 1 --winsorize-image-intensities [ 0.0, 1.0 ]  --write-composite-transform 1'
+# 
+#     Force to use double instead of float for computations (more precision and memory usage).
+# 
+#     >>> reg3b = copy.deepcopy(reg)
+#     >>> reg3b.inputs.float = False
+#     >>> reg3b.cmdline
+#     'antsRegistration --collapse-output-transforms 0 --dimensionality 3 --float 0 --initial-moving-transform [ trans.mat, 1 ] --initialize-transforms-per-stage 0 --interpolation Linear --output [ output_, output_warped_image.nii.gz ] --transform Affine[ 2.0 ] --metric Mattes[ fixed1.nii, moving1.nii, 1, 32, Random, 0.05 ] --convergence [ 1500x200, 1e-08, 20 ] --smoothing-sigmas 1.0x0.0vox --shrink-factors 2x1 --use-estimate-learning-rate-once 1 --use-histogram-matching 1 --transform SyN[ 0.25, 3.0, 0.0 ] --metric Mattes[ fixed1.nii, moving1.nii, 1, 32 ] --convergence [ 100x50x30, 1e-09, 20 ] --smoothing-sigmas 2.0x1.0x0.0vox --shrink-factors 3x2x1 --use-estimate-learning-rate-once 1 --use-histogram-matching 1 --winsorize-image-intensities [ 0.0, 1.0 ]  --write-composite-transform 1'
+# 
+#     'collapse_output_transforms' can be used to put all transformation in a single 'composite_transform'-
+#     file. Note that forward_transforms will now be an empty list.
+# 
+#     >>> # Test collapse transforms flag
+#     >>> reg4 = copy.deepcopy(reg)
+#     >>> reg4.inputs.save_state = 'trans.mat'
+#     >>> reg4.inputs.restore_state = 'trans.mat'
+#     >>> reg4.inputs.initialize_transforms_per_stage = True
+#     >>> reg4.inputs.collapse_output_transforms = True
+#     >>> outputs = reg4._list_outputs()
+#     >>> pprint.pprint(outputs)  # doctest: +ELLIPSIS,
+#     {'composite_transform': '...data/output_Composite.h5',
+#      'elapsed_time': <undefined>,
+#      'forward_invert_flags': [],
+#      'forward_transforms': [],
+#      'inverse_composite_transform': '...data/output_InverseComposite.h5',
+#      'inverse_warped_image': <undefined>,
+#      'metric_value': <undefined>,
+#      'reverse_forward_invert_flags': [],
+#      'reverse_forward_transforms': [],
+#      'reverse_invert_flags': [],
+#      'reverse_transforms': [],
+#      'save_state': '...data/trans.mat',
+#      'warped_image': '...data/output_warped_image.nii.gz'}
+#     >>> reg4.cmdline
+#     'antsRegistration --collapse-output-transforms 1 --dimensionality 3 --initial-moving-transform [ trans.mat, 1 ] --initialize-transforms-per-stage 1 --interpolation Linear --output [ output_, output_warped_image.nii.gz ] --restore-state trans.mat --save-state trans.mat --transform Affine[ 2.0 ] --metric Mattes[ fixed1.nii, moving1.nii, 1, 32, Random, 0.05 ] --convergence [ 1500x200, 1e-08, 20 ] --smoothing-sigmas 1.0x0.0vox --shrink-factors 2x1 --use-estimate-learning-rate-once 1 --use-histogram-matching 1 --transform SyN[ 0.25, 3.0, 0.0 ] --metric Mattes[ fixed1.nii, moving1.nii, 1, 32 ] --convergence [ 100x50x30, 1e-09, 20 ] --smoothing-sigmas 2.0x1.0x0.0vox --shrink-factors 3x2x1 --use-estimate-learning-rate-once 1 --use-histogram-matching 1 --winsorize-image-intensities [ 0.0, 1.0 ]  --write-composite-transform 1'
+# 
+# 
+#     >>> # Test collapse transforms flag
+#     >>> reg4b = copy.deepcopy(reg4)
+#     >>> reg4b.inputs.write_composite_transform = False
+#     >>> outputs = reg4b._list_outputs()
+#     >>> pprint.pprint(outputs)  # doctest: +ELLIPSIS,
+#     {'composite_transform': <undefined>,
+#      'elapsed_time': <undefined>,
+#      'forward_invert_flags': [False, False],
+#      'forward_transforms': ['...data/output_0GenericAffine.mat',
+#      '...data/output_1Warp.nii.gz'],
+#      'inverse_composite_transform': <undefined>,
+#      'inverse_warped_image': <undefined>,
+#      'metric_value': <undefined>,
+#      'reverse_forward_invert_flags': [False, False],
+#      'reverse_forward_transforms': ['...data/output_1Warp.nii.gz',
+#      '...data/output_0GenericAffine.mat'],
+#      'reverse_invert_flags': [True, False],
+#      'reverse_transforms': ['...data/output_0GenericAffine.mat',     '...data/output_1InverseWarp.nii.gz'],
+#      'save_state': '...data/trans.mat',
+#      'warped_image': '...data/output_warped_image.nii.gz'}
+#     >>> reg4b.aggregate_outputs()  # doctest: +SKIP
+#     >>> reg4b.cmdline
+#     'antsRegistration --collapse-output-transforms 1 --dimensionality 3 --initial-moving-transform [ trans.mat, 1 ] --initialize-transforms-per-stage 1 --interpolation Linear --output [ output_, output_warped_image.nii.gz ] --restore-state trans.mat --save-state trans.mat --transform Affine[ 2.0 ] --metric Mattes[ fixed1.nii, moving1.nii, 1, 32, Random, 0.05 ] --convergence [ 1500x200, 1e-08, 20 ] --smoothing-sigmas 1.0x0.0vox --shrink-factors 2x1 --use-estimate-learning-rate-once 1 --use-histogram-matching 1 --transform SyN[ 0.25, 3.0, 0.0 ] --metric Mattes[ fixed1.nii, moving1.nii, 1, 32 ] --convergence [ 100x50x30, 1e-09, 20 ] --smoothing-sigmas 2.0x1.0x0.0vox --shrink-factors 3x2x1 --use-estimate-learning-rate-once 1 --use-histogram-matching 1 --winsorize-image-intensities [ 0.0, 1.0 ]  --write-composite-transform 0'
+# 
+#     One can use multiple similarity metrics in a single registration stage.The Node below first
+#     performs a linear registration using only the Mutual Information ('Mattes')-metric.
+#     In a second stage, it performs a non-linear registration ('Syn') using both a
+#     Mutual Information and a local cross-correlation ('CC')-metric. Both metrics are weighted
+#     equally ('metric_weight' is .5 for both). The Mutual Information- metric uses 32 bins.
+#     The local cross-correlations (correlations between every voxel's neighborhoods) is computed
+#     with a radius of 4.
+# 
+#     >>> # Test multiple metrics per stage
+#     >>> reg5 = copy.deepcopy(reg)
+#     >>> reg5.inputs.fixed_image = 'fixed1.nii'
+#     >>> reg5.inputs.moving_image = 'moving1.nii'
+#     >>> reg5.inputs.metric = ['Mattes', ['Mattes', 'CC']]
+#     >>> reg5.inputs.metric_weight = [1, [.5,.5]]
+#     >>> reg5.inputs.radius_or_number_of_bins = [32, [32, 4] ]
+#     >>> reg5.inputs.sampling_strategy = ['Random', None] # use default strategy in second stage
+#     >>> reg5.inputs.sampling_percentage = [0.05, [0.05, 0.10]]
+#     >>> reg5.cmdline
+#     'antsRegistration --collapse-output-transforms 0 --dimensionality 3 --initial-moving-transform [ trans.mat, 1 ] --initialize-transforms-per-stage 0 --interpolation Linear --output [ output_, output_warped_image.nii.gz ] --transform Affine[ 2.0 ] --metric Mattes[ fixed1.nii, moving1.nii, 1, 32, Random, 0.05 ] --convergence [ 1500x200, 1e-08, 20 ] --smoothing-sigmas 1.0x0.0vox --shrink-factors 2x1 --use-estimate-learning-rate-once 1 --use-histogram-matching 1 --transform SyN[ 0.25, 3.0, 0.0 ] --metric Mattes[ fixed1.nii, moving1.nii, 0.5, 32, None, 0.05 ] --metric CC[ fixed1.nii, moving1.nii, 0.5, 4, None, 0.1 ] --convergence [ 100x50x30, 1e-09, 20 ] --smoothing-sigmas 2.0x1.0x0.0vox --shrink-factors 3x2x1 --use-estimate-learning-rate-once 1 --use-histogram-matching 1 --winsorize-image-intensities [ 0.0, 1.0 ]  --write-composite-transform 1'
+# 
+#     ANTS Registration can also use multiple modalities to perform the registration. Here it is assumed
+#     that fixed1.nii and fixed2.nii are in the same space, and so are moving1.nii and
+#     moving2.nii. First, a linear registration is performed matching fixed1.nii to moving1.nii,
+#     then a non-linear registration is performed to match fixed2.nii to moving2.nii, starting from
+#     the transformation of the first step.
+# 
+#     >>> # Test multiple inputS
+#     >>> reg6 = copy.deepcopy(reg5)
+#     >>> reg6.inputs.fixed_image = ['fixed1.nii', 'fixed2.nii']
+#     >>> reg6.inputs.moving_image = ['moving1.nii', 'moving2.nii']
+#     >>> reg6.cmdline
+#     'antsRegistration --collapse-output-transforms 0 --dimensionality 3 --initial-moving-transform [ trans.mat, 1 ] --initialize-transforms-per-stage 0 --interpolation Linear --output [ output_, output_warped_image.nii.gz ] --transform Affine[ 2.0 ] --metric Mattes[ fixed1.nii, moving1.nii, 1, 32, Random, 0.05 ] --convergence [ 1500x200, 1e-08, 20 ] --smoothing-sigmas 1.0x0.0vox --shrink-factors 2x1 --use-estimate-learning-rate-once 1 --use-histogram-matching 1 --transform SyN[ 0.25, 3.0, 0.0 ] --metric Mattes[ fixed1.nii, moving1.nii, 0.5, 32, None, 0.05 ] --metric CC[ fixed2.nii, moving2.nii, 0.5, 4, None, 0.1 ] --convergence [ 100x50x30, 1e-09, 20 ] --smoothing-sigmas 2.0x1.0x0.0vox --shrink-factors 3x2x1 --use-estimate-learning-rate-once 1 --use-histogram-matching 1 --winsorize-image-intensities [ 0.0, 1.0 ]  --write-composite-transform 1'
+# 
+#     Different methods can be used for the interpolation when applying transformations.
+# 
+#     >>> # Test Interpolation Parameters (BSpline)
+#     >>> reg7a = copy.deepcopy(reg)
+#     >>> reg7a.inputs.interpolation = 'BSpline'
+#     >>> reg7a.inputs.interpolation_parameters = (3,)
+#     >>> reg7a.cmdline
+#     'antsRegistration --collapse-output-transforms 0 --dimensionality 3 --initial-moving-transform [ trans.mat, 1 ] --initialize-transforms-per-stage 0 --interpolation BSpline[ 3 ] --output [ output_, output_warped_image.nii.gz ] --transform Affine[ 2.0 ] --metric Mattes[ fixed1.nii, moving1.nii, 1, 32, Random, 0.05 ] --convergence [ 1500x200, 1e-08, 20 ] --smoothing-sigmas 1.0x0.0vox --shrink-factors 2x1 --use-estimate-learning-rate-once 1 --use-histogram-matching 1 --transform SyN[ 0.25, 3.0, 0.0 ] --metric Mattes[ fixed1.nii, moving1.nii, 1, 32 ] --convergence [ 100x50x30, 1e-09, 20 ] --smoothing-sigmas 2.0x1.0x0.0vox --shrink-factors 3x2x1 --use-estimate-learning-rate-once 1 --use-histogram-matching 1 --winsorize-image-intensities [ 0.0, 1.0 ]  --write-composite-transform 1'
+# 
+#     >>> # Test Interpolation Parameters (MultiLabel/Gaussian)
+#     >>> reg7b = copy.deepcopy(reg)
+#     >>> reg7b.inputs.interpolation = 'Gaussian'
+#     >>> reg7b.inputs.interpolation_parameters = (1.0, 1.0)
+#     >>> reg7b.cmdline
+#     'antsRegistration --collapse-output-transforms 0 --dimensionality 3 --initial-moving-transform [ trans.mat, 1 ] --initialize-transforms-per-stage 0 --interpolation Gaussian[ 1.0, 1.0 ] --output [ output_, output_warped_image.nii.gz ] --transform Affine[ 2.0 ] --metric Mattes[ fixed1.nii, moving1.nii, 1, 32, Random, 0.05 ] --convergence [ 1500x200, 1e-08, 20 ] --smoothing-sigmas 1.0x0.0vox --shrink-factors 2x1 --use-estimate-learning-rate-once 1 --use-histogram-matching 1 --transform SyN[ 0.25, 3.0, 0.0 ] --metric Mattes[ fixed1.nii, moving1.nii, 1, 32 ] --convergence [ 100x50x30, 1e-09, 20 ] --smoothing-sigmas 2.0x1.0x0.0vox --shrink-factors 3x2x1 --use-estimate-learning-rate-once 1 --use-histogram-matching 1 --winsorize-image-intensities [ 0.0, 1.0 ]  --write-composite-transform 1'
+# 
+#     BSplineSyN non-linear registration with custom parameters.
+# 
+#     >>> # Test Extended Transform Parameters
+#     >>> reg8 = copy.deepcopy(reg)
+#     >>> reg8.inputs.transforms = ['Affine', 'BSplineSyN']
+#     >>> reg8.inputs.transform_parameters = [(2.0,), (0.25, 26, 0, 3)]
+#     >>> reg8.cmdline
+#     'antsRegistration --collapse-output-transforms 0 --dimensionality 3 --initial-moving-transform [ trans.mat, 1 ] --initialize-transforms-per-stage 0 --interpolation Linear --output [ output_, output_warped_image.nii.gz ] --transform Affine[ 2.0 ] --metric Mattes[ fixed1.nii, moving1.nii, 1, 32, Random, 0.05 ] --convergence [ 1500x200, 1e-08, 20 ] --smoothing-sigmas 1.0x0.0vox --shrink-factors 2x1 --use-estimate-learning-rate-once 1 --use-histogram-matching 1 --transform BSplineSyN[ 0.25, 26, 0, 3 ] --metric Mattes[ fixed1.nii, moving1.nii, 1, 32 ] --convergence [ 100x50x30, 1e-09, 20 ] --smoothing-sigmas 2.0x1.0x0.0vox --shrink-factors 3x2x1 --use-estimate-learning-rate-once 1 --use-histogram-matching 1 --winsorize-image-intensities [ 0.0, 1.0 ]  --write-composite-transform 1'
+# 
+#     Mask the fixed image in the second stage of the registration (but not the first).
+# 
+#     >>> # Test masking
+#     >>> reg9 = copy.deepcopy(reg)
+#     >>> reg9.inputs.fixed_image_masks = ['NULL', 'fixed1.nii']
+#     >>> reg9.cmdline
+#     'antsRegistration --collapse-output-transforms 0 --dimensionality 3 --initial-moving-transform [ trans.mat, 1 ] --initialize-transforms-per-stage 0 --interpolation Linear --output [ output_, output_warped_image.nii.gz ] --transform Affine[ 2.0 ] --metric Mattes[ fixed1.nii, moving1.nii, 1, 32, Random, 0.05 ] --convergence [ 1500x200, 1e-08, 20 ] --smoothing-sigmas 1.0x0.0vox --shrink-factors 2x1 --use-estimate-learning-rate-once 1 --use-histogram-matching 1 --masks [ NULL, NULL ] --transform SyN[ 0.25, 3.0, 0.0 ] --metric Mattes[ fixed1.nii, moving1.nii, 1, 32 ] --convergence [ 100x50x30, 1e-09, 20 ] --smoothing-sigmas 2.0x1.0x0.0vox --shrink-factors 3x2x1 --use-estimate-learning-rate-once 1 --use-histogram-matching 1 --masks [ fixed1.nii, NULL ] --winsorize-image-intensities [ 0.0, 1.0 ]  --write-composite-transform 1'
+# 
+#     Here we use both a warpfield and a linear transformation, before registration commences.  Note that
+#     the first transformation that needs to be applied ('ants_Warp.nii.gz') is last in the list of
+#     'initial_moving_transform'.
+# 
+#     >>> # Test initialization with multiple transforms matrices (e.g., unwarp and affine transform)
+#     >>> reg10 = copy.deepcopy(reg)
+#     >>> reg10.inputs.initial_moving_transform = ['func_to_struct.mat', 'ants_Warp.nii.gz']
+#     >>> reg10.inputs.invert_initial_moving_transform = [False, False]
+#     >>> reg10.cmdline
+#     'antsRegistration --collapse-output-transforms 0 --dimensionality 3 --initial-moving-transform [ func_to_struct.mat, 0 ] [ ants_Warp.nii.gz, 0 ] --initialize-transforms-per-stage 0 --interpolation Linear --output [ output_, output_warped_image.nii.gz ] --transform Affine[ 2.0 ] --metric Mattes[ fixed1.nii, moving1.nii, 1, 32, Random, 0.05 ] --convergence [ 1500x200, 1e-08, 20 ] --smoothing-sigmas 1.0x0.0vox --shrink-factors 2x1 --use-estimate-learning-rate-once 1 --use-histogram-matching 1 --transform SyN[ 0.25, 3.0, 0.0 ] --metric Mattes[ fixed1.nii, moving1.nii, 1, 32 ] --convergence [ 100x50x30, 1e-09, 20 ] --smoothing-sigmas 2.0x1.0x0.0vox --shrink-factors 3x2x1 --use-estimate-learning-rate-once 1 --use-histogram-matching 1 --winsorize-image-intensities [ 0.0, 1.0 ]  --write-composite-transform 1'
+#     
+task_name: Registration
+nipype_name: Registration
+nipype_module: nipype.interfaces.ants.registration
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    fixed_image: medimage/nifti1+list-of
+    # type=inputmultiobject|default=[]: Image to which the moving_image should be transformed(usually a structural image)
+    fixed_image_mask: generic/file
+    # type=file|default=<undefined>: Mask used to limit metric sampling region of the fixed imagein all stages
+    moving_image: medimage/nifti1+list-of
+    # type=inputmultiobject|default=[]: Image that will be registered to the space of fixed_image. This is theimage on which the transformations will be applied to
+    moving_image_mask: generic/file
+    # type=file|default=<undefined>: mask used to limit metric sampling region of the moving imagein all stages
+    save_state: datascience/text-matrix
+    # type=file: The saved registration state to be restored
+    # type=file|default=<undefined>: Filename for saving the internal restorable state of the registration
+    restore_state: datascience/text-matrix
+    # type=file|default=<undefined>: Filename for restoring the internal restorable state of the registration
+    initial_moving_transform: datascience/text-matrix+list-of
+    # type=inputmultiobject|default=[]: A transform or a list of transforms that should be applied before the registration begins. Note that, when a list is given, the transformations are applied in reverse order.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    composite_transform: generic/file
+    # type=file: Composite transform file
+    inverse_composite_transform: generic/file
+    # type=file: Inverse composite transform file
+    warped_image: generic/file
+    # type=file: Outputs warped image
+    inverse_warped_image: generic/file
+    # type=file: Outputs the inverse of the warped image
+    save_state: datascience/text-matrix
+    # type=file: The saved registration state to be restored
+    # type=file|default=<undefined>: Filename for saving the internal restorable state of the registration
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    dimension:
+    # type=enum|default=3|allowed[2,3]: image dimension (2 or 3)
+    fixed_image:
+    # type=inputmultiobject|default=[]: Image to which the moving_image should be transformed(usually a structural image)
+    fixed_image_mask:
+    # type=file|default=<undefined>: Mask used to limit metric sampling region of the fixed imagein all stages
+    fixed_image_masks:
+    # type=inputmultiobject|default=[]: Masks used to limit metric sampling region of the fixed image, defined per registration stage(Use "NULL" to omit a mask at a given stage)
+    moving_image:
+    # type=inputmultiobject|default=[]: Image that will be registered to the space of fixed_image. This is theimage on which the transformations will be applied to
+    moving_image_mask:
+    # type=file|default=<undefined>: mask used to limit metric sampling region of the moving imagein all stages
+    moving_image_masks:
+    # type=inputmultiobject|default=[]: Masks used to limit metric sampling region of the moving image, defined per registration stage(Use "NULL" to omit a mask at a given stage)
+    save_state:
+    # type=file: The saved registration state to be restored
+    # type=file|default=<undefined>: Filename for saving the internal restorable state of the registration
+    restore_state:
+    # type=file|default=<undefined>: Filename for restoring the internal restorable state of the registration
+    initial_moving_transform:
+    # type=inputmultiobject|default=[]: A transform or a list of transforms that should be applied before the registration begins. Note that, when a list is given, the transformations are applied in reverse order.
+    invert_initial_moving_transform:
+    # type=inputmultiobject|default=[]: One boolean or a list of booleans that indicatewhether the inverse(s) of the transform(s) definedin initial_moving_transform should be used.
+    initial_moving_transform_com:
+    # type=enum|default=0|allowed[0,1,2]: Align the moving_image and fixed_image before registration using the geometric center of the images (=0), the image intensities (=1), or the origin of the images (=2).
+    metric_item_trait:
+    # type=enum|default='CC'|allowed['CC','Demons','GC','MI','Mattes','MeanSquares']: 
+    metric_stage_trait:
+    # type=traitcompound|default=None: 
+    metric:
+    # type=list|default=[]: the metric(s) to use for each stage. Note that multiple metrics per stage are not supported in ANTS 1.9.1 and earlier.
+    metric_weight_item_trait:
+    # type=float|default=1.0: 
+    metric_weight_stage_trait:
+    # type=traitcompound|default=None: 
+    metric_weight:
+    # type=list|default=[1.0]: the metric weight(s) for each stage. The weights must sum to 1 per stage.
+    radius_bins_item_trait:
+    # type=int|default=5: 
+    radius_bins_stage_trait:
+    # type=traitcompound|default=None: 
+    radius_or_number_of_bins:
+    # type=list|default=[5]: the number of bins in each stage for the MI and Mattes metric, the radius for other metrics
+    sampling_strategy_item_trait:
+    # type=enum|default='None'|allowed['None','Random','Regular',None]: 
+    sampling_strategy_stage_trait:
+    # type=traitcompound|default=None: 
+    sampling_strategy:
+    # type=list|default=[]: the metric sampling strategy (strategies) for each stage
+    sampling_percentage_item_trait:
+    # type=traitcompound|default=None: 
+    sampling_percentage_stage_trait:
+    # type=traitcompound|default=None: 
+    sampling_percentage:
+    # type=list|default=[]: the metric sampling percentage(s) to use for each stage
+    use_estimate_learning_rate_once:
+    # type=list|default=[]: 
+    use_histogram_matching:
+    # type=traitcompound|default=True: Histogram match the images before registration.
+    interpolation:
+    # type=enum|default='Linear'|allowed['BSpline','CosineWindowedSinc','Gaussian','GenericLabel','HammingWindowedSinc','LanczosWindowedSinc','Linear','MultiLabel','NearestNeighbor','WelchWindowedSinc']: 
+    interpolation_parameters:
+    # type=traitcompound|default=None: 
+    write_composite_transform:
+    # type=bool|default=False: 
+    collapse_output_transforms:
+    # type=bool|default=True: Collapse output transforms. Specifically, enabling this option combines all adjacent linear transforms and composes all adjacent displacement field transforms before writing the results to disk.
+    initialize_transforms_per_stage:
+    # type=bool|default=False: Initialize linear transforms from the previous stage. By enabling this option, the current linear stage transform is directly initialized from the previous stages linear transform; this allows multiple linear stages to be run where each stage directly updates the estimated linear transform from the previous stage. (e.g. Translation -> Rigid -> Affine). 
+    float:
+    # type=bool|default=False: Use float instead of double for computations.
+    transforms:
+    # type=list|default=[]: 
+    transform_parameters:
+    # type=list|default=[]: 
+    restrict_deformation:
+    # type=list|default=[]: This option allows the user to restrict the optimization of the displacement field, translation, rigid or affine transform on a per-component basis. For example, if one wants to limit the deformation or rotation of 3-D volume to the  first two dimensions, this is possible by specifying a weight vector of '1x1x0' for a deformation field or '1x1x0x1x1x0' for a rigid transformation.  Low-dimensional restriction only works if there are no preceding transformations.
+    number_of_iterations:
+    # type=list|default=[]: 
+    smoothing_sigmas:
+    # type=list|default=[]: 
+    sigma_units:
+    # type=list|default=[]: units for smoothing sigmas
+    shrink_factors:
+    # type=list|default=[]: 
+    convergence_threshold:
+    # type=list|default=[1e-06]: 
+    convergence_window_size:
+    # type=list|default=[10]: 
+    output_transform_prefix:
+    # type=str|default='transform': 
+    output_warped_image:
+    # type=traitcompound|default=None: 
+    output_inverse_warped_image:
+    # type=traitcompound|default=None: 
+    winsorize_upper_quantile:
+    # type=range|default=1.0: The Upper quantile to clip image ranges
+    winsorize_lower_quantile:
+    # type=range|default=0.0: The Lower quantile to clip image ranges
+    random_seed:
+    # type=int|default=0: Fixed seed for random number generation
+    verbose:
+    # type=bool|default=False: 
+    num_threads:
+    # type=int|default=1: Number of ITK threads to use
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    fixed_image:
+    # type=inputmultiobject|default=[]: Image to which the moving_image should be transformed(usually a structural image)
+    moving_image:
+    # type=inputmultiobject|default=[]: Image that will be registered to the space of fixed_image. This is theimage on which the transformations will be applied to
+    output_transform_prefix: '"output_"'
+    # type=str|default='transform': 
+    initial_moving_transform:
+    # type=inputmultiobject|default=[]: A transform or a list of transforms that should be applied before the registration begins. Note that, when a list is given, the transformations are applied in reverse order.
+    transforms: '["Affine", "SyN"]'
+    # type=list|default=[]: 
+    transform_parameters: '[(2.0,), (0.25, 3.0, 0.0)]'
+    # type=list|default=[]: 
+    number_of_iterations: '[[1500, 200], [100, 50, 30]]'
+    # type=list|default=[]: 
+    dimension: '3'
+    # type=enum|default=3|allowed[2,3]: image dimension (2 or 3)
+    write_composite_transform: 'True'
+    # type=bool|default=False: 
+    collapse_output_transforms: 'False'
+    # type=bool|default=True: Collapse output transforms. Specifically, enabling this option combines all adjacent linear transforms and composes all adjacent displacement field transforms before writing the results to disk.
+    initialize_transforms_per_stage: 'False'
+    # type=bool|default=False: Initialize linear transforms from the previous stage. By enabling this option, the current linear stage transform is directly initialized from the previous stages linear transform; this allows multiple linear stages to be run where each stage directly updates the estimated linear transform from the previous stage. (e.g. Translation -> Rigid -> Affine). 
+    metric: '["Mattes"]*2'
+    # type=list|default=[]: the metric(s) to use for each stage. Note that multiple metrics per stage are not supported in ANTS 1.9.1 and earlier.
+    metric_weight: '[1]*2 # Default (value ignored currently by ANTs)'
+    # type=list|default=[1.0]: the metric weight(s) for each stage. The weights must sum to 1 per stage.
+    radius_or_number_of_bins: '[32]*2'
+    # type=list|default=[5]: the number of bins in each stage for the MI and Mattes metric, the radius for other metrics
+    sampling_strategy: '["Random", None]'
+    # type=list|default=[]: the metric sampling strategy (strategies) for each stage
+    sampling_percentage: '[0.05, None]'
+    # type=list|default=[]: the metric sampling percentage(s) to use for each stage
+    convergence_threshold: '[1.e-8, 1.e-9]'
+    # type=list|default=[1e-06]: 
+    convergence_window_size: '[20]*2'
+    # type=list|default=[10]: 
+    smoothing_sigmas: '[[1,0], [2,1,0]]'
+    # type=list|default=[]: 
+    sigma_units: '["vox"] * 2'
+    # type=list|default=[]: units for smoothing sigmas
+    shrink_factors: '[[2,1], [3,2,1]]'
+    # type=list|default=[]: 
+    use_estimate_learning_rate_once: '[True, True]'
+    # type=list|default=[]: 
+    use_histogram_matching: '[True, True] # This is the default'
+    # type=traitcompound|default=True: Histogram match the images before registration.
+    output_warped_image: '"output_warped_image.nii.gz"'
+    # type=traitcompound|default=None: 
+  imports: &id001
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  - module: copy
+  - module: pprint
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    invert_initial_moving_transform: 'True'
+    # type=inputmultiobject|default=[]: One boolean or a list of booleans that indicatewhether the inverse(s) of the transform(s) definedin initial_moving_transform should be used.
+    winsorize_lower_quantile: '0.025'
+    # type=range|default=0.0: The Lower quantile to clip image ranges
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    winsorize_upper_quantile: '0.975'
+    # type=range|default=1.0: The Upper quantile to clip image ranges
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    winsorize_lower_quantile: '0.025'
+    # type=range|default=0.0: The Lower quantile to clip image ranges
+    winsorize_upper_quantile: '0.975'
+    # type=range|default=1.0: The Upper quantile to clip image ranges
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    float: 'True'
+    # type=bool|default=False: Use float instead of double for computations.
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    float: 'False'
+    # type=bool|default=False: Use float instead of double for computations.
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    save_state:
+    # type=file: The saved registration state to be restored
+    # type=file|default=<undefined>: Filename for saving the internal restorable state of the registration
+    restore_state:
+    # type=file|default=<undefined>: Filename for restoring the internal restorable state of the registration
+    initialize_transforms_per_stage: 'True'
+    # type=bool|default=False: Initialize linear transforms from the previous stage. By enabling this option, the current linear stage transform is directly initialized from the previous stages linear transform; this allows multiple linear stages to be run where each stage directly updates the estimated linear transform from the previous stage. (e.g. Translation -> Rigid -> Affine). 
+    collapse_output_transforms: 'True'
+    # type=bool|default=True: Collapse output transforms. Specifically, enabling this option combines all adjacent linear transforms and composes all adjacent displacement field transforms before writing the results to disk.
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    write_composite_transform: 'False'
+    # type=bool|default=False: 
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    fixed_image:
+    # type=inputmultiobject|default=[]: Image to which the moving_image should be transformed(usually a structural image)
+    moving_image:
+    # type=inputmultiobject|default=[]: Image that will be registered to the space of fixed_image. This is theimage on which the transformations will be applied to
+    metric: '["Mattes", ["Mattes", "CC"]]'
+    # type=list|default=[]: the metric(s) to use for each stage. Note that multiple metrics per stage are not supported in ANTS 1.9.1 and earlier.
+    metric_weight: '[1, [.5,.5]]'
+    # type=list|default=[1.0]: the metric weight(s) for each stage. The weights must sum to 1 per stage.
+    radius_or_number_of_bins: '[32, [32, 4] ]'
+    # type=list|default=[5]: the number of bins in each stage for the MI and Mattes metric, the radius for other metrics
+    sampling_strategy: '["Random", None] # use default strategy in second stage'
+    # type=list|default=[]: the metric sampling strategy (strategies) for each stage
+    sampling_percentage: '[0.05, [0.05, 0.10]]'
+    # type=list|default=[]: the metric sampling percentage(s) to use for each stage
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    fixed_image:
+    # type=inputmultiobject|default=[]: Image to which the moving_image should be transformed(usually a structural image)
+    moving_image:
+    # type=inputmultiobject|default=[]: Image that will be registered to the space of fixed_image. This is theimage on which the transformations will be applied to
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    interpolation: '"BSpline"'
+    # type=enum|default='Linear'|allowed['BSpline','CosineWindowedSinc','Gaussian','GenericLabel','HammingWindowedSinc','LanczosWindowedSinc','Linear','MultiLabel','NearestNeighbor','WelchWindowedSinc']: 
+    interpolation_parameters: (3,)
+    # type=traitcompound|default=None: 
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    interpolation: '"Gaussian"'
+    # type=enum|default='Linear'|allowed['BSpline','CosineWindowedSinc','Gaussian','GenericLabel','HammingWindowedSinc','LanczosWindowedSinc','Linear','MultiLabel','NearestNeighbor','WelchWindowedSinc']: 
+    interpolation_parameters: (1.0, 1.0)
+    # type=traitcompound|default=None: 
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    transforms: '["Affine", "BSplineSyN"]'
+    # type=list|default=[]: 
+    transform_parameters: '[(2.0,), (0.25, 26, 0, 3)]'
+    # type=list|default=[]: 
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    fixed_image_masks: '["NULL", "fixed1.nii"]'
+    # type=inputmultiobject|default=[]: Masks used to limit metric sampling region of the fixed image, defined per registration stage(Use "NULL" to omit a mask at a given stage)
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    initial_moving_transform:
+    # type=inputmultiobject|default=[]: A transform or a list of transforms that should be applied before the registration begins. Note that, when a list is given, the transformations are applied in reverse order.
+    invert_initial_moving_transform: '[False, False]'
+    # type=inputmultiobject|default=[]: One boolean or a list of booleans that indicatewhether the inverse(s) of the transform(s) definedin initial_moving_transform should be used.
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: antsRegistration --collapse-output-transforms 0 --dimensionality 3 --initial-moving-transform [ trans.mat, 0 ] --initialize-transforms-per-stage 0 --interpolation Linear --output [ output_, output_warped_image.nii.gz ] --transform Affine[ 2.0 ] --metric Mattes[ fixed1.nii, moving1.nii, 1, 32, Random, 0.05 ] --convergence [ 1500x200, 1e-08, 20 ] --smoothing-sigmas 1.0x0.0vox --shrink-factors 2x1 --use-estimate-learning-rate-once 1 --use-histogram-matching 1 --transform SyN[ 0.25, 3.0, 0.0 ] --metric Mattes[ fixed1.nii, moving1.nii, 1, 32 ] --convergence [ 100x50x30, 1e-09, 20 ] --smoothing-sigmas 2.0x1.0x0.0vox --shrink-factors 3x2x1 --use-estimate-learning-rate-once 1 --use-histogram-matching 1 --winsorize-image-intensities [ 0.0, 1.0 ] --write-composite-transform 1
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    fixed_image:
+    # type=inputmultiobject|default=[]: Image to which the moving_image should be transformed(usually a structural image)
+    moving_image:
+    # type=inputmultiobject|default=[]: Image that will be registered to the space of fixed_image. This is theimage on which the transformations will be applied to
+    output_transform_prefix: '"output_"'
+    # type=str|default='transform': 
+    initial_moving_transform:
+    # type=inputmultiobject|default=[]: A transform or a list of transforms that should be applied before the registration begins. Note that, when a list is given, the transformations are applied in reverse order.
+    transforms: '["Affine", "SyN"]'
+    # type=list|default=[]: 
+    transform_parameters: '[(2.0,), (0.25, 3.0, 0.0)]'
+    # type=list|default=[]: 
+    number_of_iterations: '[[1500, 200], [100, 50, 30]]'
+    # type=list|default=[]: 
+    dimension: '3'
+    # type=enum|default=3|allowed[2,3]: image dimension (2 or 3)
+    write_composite_transform: 'True'
+    # type=bool|default=False: 
+    collapse_output_transforms: 'False'
+    # type=bool|default=True: Collapse output transforms. Specifically, enabling this option combines all adjacent linear transforms and composes all adjacent displacement field transforms before writing the results to disk.
+    initialize_transforms_per_stage: 'False'
+    # type=bool|default=False: Initialize linear transforms from the previous stage. By enabling this option, the current linear stage transform is directly initialized from the previous stages linear transform; this allows multiple linear stages to be run where each stage directly updates the estimated linear transform from the previous stage. (e.g. Translation -> Rigid -> Affine). 
+    metric: '["Mattes"]*2'
+    # type=list|default=[]: the metric(s) to use for each stage. Note that multiple metrics per stage are not supported in ANTS 1.9.1 and earlier.
+    metric_weight: '[1]*2 # Default (value ignored currently by ANTs)'
+    # type=list|default=[1.0]: the metric weight(s) for each stage. The weights must sum to 1 per stage.
+    radius_or_number_of_bins: '[32]*2'
+    # type=list|default=[5]: the number of bins in each stage for the MI and Mattes metric, the radius for other metrics
+    sampling_strategy: '["Random", None]'
+    # type=list|default=[]: the metric sampling strategy (strategies) for each stage
+    sampling_percentage: '[0.05, None]'
+    # type=list|default=[]: the metric sampling percentage(s) to use for each stage
+    convergence_threshold: '[1.e-8, 1.e-9]'
+    # type=list|default=[1e-06]: 
+    convergence_window_size: '[20]*2'
+    # type=list|default=[10]: 
+    smoothing_sigmas: '[[1,0], [2,1,0]]'
+    # type=list|default=[]: 
+    sigma_units: '["vox"] * 2'
+    # type=list|default=[]: units for smoothing sigmas
+    shrink_factors: '[[2,1], [3,2,1]]'
+    # type=list|default=[]: 
+    use_estimate_learning_rate_once: '[True, True]'
+    # type=list|default=[]: 
+    use_histogram_matching: '[True, True] # This is the default'
+    # type=traitcompound|default=True: Histogram match the images before registration.
+    output_warped_image: '"output_warped_image.nii.gz"'
+    # type=traitcompound|default=None: 
+  imports: *id001
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: antsRegistration --collapse-output-transforms 0 --dimensionality 3 --initial-moving-transform [ trans.mat, 1 ] --initialize-transforms-per-stage 0 --interpolation Linear --output [ output_, output_warped_image.nii.gz ] --transform Affine[ 2.0 ] --metric Mattes[ fixed1.nii, moving1.nii, 1, 32, Random, 0.05 ] --convergence [ 1500x200, 1e-08, 20 ] --smoothing-sigmas 1.0x0.0vox --shrink-factors 2x1 --use-estimate-learning-rate-once 1 --use-histogram-matching 1 --transform SyN[ 0.25, 3.0, 0.0 ] --metric Mattes[ fixed1.nii, moving1.nii, 1, 32 ] --convergence [ 100x50x30, 1e-09, 20 ] --smoothing-sigmas 2.0x1.0x0.0vox --shrink-factors 3x2x1 --use-estimate-learning-rate-once 1 --use-histogram-matching 1 --winsorize-image-intensities [ 0.025, 1.0 ] --write-composite-transform 1
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    invert_initial_moving_transform: 'True'
+    # type=inputmultiobject|default=[]: One boolean or a list of booleans that indicatewhether the inverse(s) of the transform(s) definedin initial_moving_transform should be used.
+    winsorize_lower_quantile: '0.025'
+    # type=range|default=0.0: The Lower quantile to clip image ranges
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: antsRegistration --collapse-output-transforms 0 --dimensionality 3 --initial-moving-transform [ trans.mat, 1 ] --initialize-transforms-per-stage 0 --interpolation Linear --output [ output_, output_warped_image.nii.gz ] --transform Affine[ 2.0 ] --metric Mattes[ fixed1.nii, moving1.nii, 1, 32, Random, 0.05 ] --convergence [ 1500x200, 1e-08, 20 ] --smoothing-sigmas 1.0x0.0vox --shrink-factors 2x1 --use-estimate-learning-rate-once 1 --use-histogram-matching 1 --transform SyN[ 0.25, 3.0, 0.0 ] --metric Mattes[ fixed1.nii, moving1.nii, 1, 32 ] --convergence [ 100x50x30, 1e-09, 20 ] --smoothing-sigmas 2.0x1.0x0.0vox --shrink-factors 3x2x1 --use-estimate-learning-rate-once 1 --use-histogram-matching 1 --winsorize-image-intensities [ 0.0, 0.975 ] --write-composite-transform 1
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    winsorize_upper_quantile: '0.975'
+    # type=range|default=1.0: The Upper quantile to clip image ranges
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: antsRegistration --collapse-output-transforms 0 --dimensionality 3 --initial-moving-transform [ trans.mat, 1 ] --initialize-transforms-per-stage 0 --interpolation Linear --output [ output_, output_warped_image.nii.gz ] --transform Affine[ 2.0 ] --metric Mattes[ fixed1.nii, moving1.nii, 1, 32, Random, 0.05 ] --convergence [ 1500x200, 1e-08, 20 ] --smoothing-sigmas 1.0x0.0vox --shrink-factors 2x1 --use-estimate-learning-rate-once 1 --use-histogram-matching 1 --transform SyN[ 0.25, 3.0, 0.0 ] --metric Mattes[ fixed1.nii, moving1.nii, 1, 32 ] --convergence [ 100x50x30, 1e-09, 20 ] --smoothing-sigmas 2.0x1.0x0.0vox --shrink-factors 3x2x1 --use-estimate-learning-rate-once 1 --use-histogram-matching 1 --winsorize-image-intensities [ 0.025, 0.975 ] --write-composite-transform 1
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    winsorize_lower_quantile: '0.025'
+    # type=range|default=0.0: The Lower quantile to clip image ranges
+    winsorize_upper_quantile: '0.975'
+    # type=range|default=1.0: The Upper quantile to clip image ranges
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: antsRegistration --collapse-output-transforms 0 --dimensionality 3 --float 1 --initial-moving-transform [ trans.mat, 1 ] --initialize-transforms-per-stage 0 --interpolation Linear --output [ output_, output_warped_image.nii.gz ] --transform Affine[ 2.0 ] --metric Mattes[ fixed1.nii, moving1.nii, 1, 32, Random, 0.05 ] --convergence [ 1500x200, 1e-08, 20 ] --smoothing-sigmas 1.0x0.0vox --shrink-factors 2x1 --use-estimate-learning-rate-once 1 --use-histogram-matching 1 --transform SyN[ 0.25, 3.0, 0.0 ] --metric Mattes[ fixed1.nii, moving1.nii, 1, 32 ] --convergence [ 100x50x30, 1e-09, 20 ] --smoothing-sigmas 2.0x1.0x0.0vox --shrink-factors 3x2x1 --use-estimate-learning-rate-once 1 --use-histogram-matching 1 --winsorize-image-intensities [ 0.0, 1.0 ] --write-composite-transform 1
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    float: 'True'
+    # type=bool|default=False: Use float instead of double for computations.
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: antsRegistration --collapse-output-transforms 0 --dimensionality 3 --float 0 --initial-moving-transform [ trans.mat, 1 ] --initialize-transforms-per-stage 0 --interpolation Linear --output [ output_, output_warped_image.nii.gz ] --transform Affine[ 2.0 ] --metric Mattes[ fixed1.nii, moving1.nii, 1, 32, Random, 0.05 ] --convergence [ 1500x200, 1e-08, 20 ] --smoothing-sigmas 1.0x0.0vox --shrink-factors 2x1 --use-estimate-learning-rate-once 1 --use-histogram-matching 1 --transform SyN[ 0.25, 3.0, 0.0 ] --metric Mattes[ fixed1.nii, moving1.nii, 1, 32 ] --convergence [ 100x50x30, 1e-09, 20 ] --smoothing-sigmas 2.0x1.0x0.0vox --shrink-factors 3x2x1 --use-estimate-learning-rate-once 1 --use-histogram-matching 1 --winsorize-image-intensities [ 0.0, 1.0 ] --write-composite-transform 1
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    float: 'False'
+    # type=bool|default=False: Use float instead of double for computations.
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: antsRegistration --collapse-output-transforms 1 --dimensionality 3 --initial-moving-transform [ trans.mat, 1 ] --initialize-transforms-per-stage 1 --interpolation Linear --output [ output_, output_warped_image.nii.gz ] --restore-state trans.mat --save-state trans.mat --transform Affine[ 2.0 ] --metric Mattes[ fixed1.nii, moving1.nii, 1, 32, Random, 0.05 ] --convergence [ 1500x200, 1e-08, 20 ] --smoothing-sigmas 1.0x0.0vox --shrink-factors 2x1 --use-estimate-learning-rate-once 1 --use-histogram-matching 1 --transform SyN[ 0.25, 3.0, 0.0 ] --metric Mattes[ fixed1.nii, moving1.nii, 1, 32 ] --convergence [ 100x50x30, 1e-09, 20 ] --smoothing-sigmas 2.0x1.0x0.0vox --shrink-factors 3x2x1 --use-estimate-learning-rate-once 1 --use-histogram-matching 1 --winsorize-image-intensities [ 0.0, 1.0 ] --write-composite-transform 1
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    save_state:
+    # type=file: The saved registration state to be restored
+    # type=file|default=<undefined>: Filename for saving the internal restorable state of the registration
+    restore_state:
+    # type=file|default=<undefined>: Filename for restoring the internal restorable state of the registration
+    initialize_transforms_per_stage: 'True'
+    # type=bool|default=False: Initialize linear transforms from the previous stage. By enabling this option, the current linear stage transform is directly initialized from the previous stages linear transform; this allows multiple linear stages to be run where each stage directly updates the estimated linear transform from the previous stage. (e.g. Translation -> Rigid -> Affine). 
+    collapse_output_transforms: 'True'
+    # type=bool|default=True: Collapse output transforms. Specifically, enabling this option combines all adjacent linear transforms and composes all adjacent displacement field transforms before writing the results to disk.
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: antsRegistration --collapse-output-transforms 1 --dimensionality 3 --initial-moving-transform [ trans.mat, 1 ] --initialize-transforms-per-stage 1 --interpolation Linear --output [ output_, output_warped_image.nii.gz ] --restore-state trans.mat --save-state trans.mat --transform Affine[ 2.0 ] --metric Mattes[ fixed1.nii, moving1.nii, 1, 32, Random, 0.05 ] --convergence [ 1500x200, 1e-08, 20 ] --smoothing-sigmas 1.0x0.0vox --shrink-factors 2x1 --use-estimate-learning-rate-once 1 --use-histogram-matching 1 --transform SyN[ 0.25, 3.0, 0.0 ] --metric Mattes[ fixed1.nii, moving1.nii, 1, 32 ] --convergence [ 100x50x30, 1e-09, 20 ] --smoothing-sigmas 2.0x1.0x0.0vox --shrink-factors 3x2x1 --use-estimate-learning-rate-once 1 --use-histogram-matching 1 --winsorize-image-intensities [ 0.0, 1.0 ] --write-composite-transform 0
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    write_composite_transform: 'False'
+    # type=bool|default=False: 
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: antsRegistration --collapse-output-transforms 0 --dimensionality 3 --initial-moving-transform [ trans.mat, 1 ] --initialize-transforms-per-stage 0 --interpolation Linear --output [ output_, output_warped_image.nii.gz ] --transform Affine[ 2.0 ] --metric Mattes[ fixed1.nii, moving1.nii, 1, 32, Random, 0.05 ] --convergence [ 1500x200, 1e-08, 20 ] --smoothing-sigmas 1.0x0.0vox --shrink-factors 2x1 --use-estimate-learning-rate-once 1 --use-histogram-matching 1 --transform SyN[ 0.25, 3.0, 0.0 ] --metric Mattes[ fixed1.nii, moving1.nii, 0.5, 32, None, 0.05 ] --metric CC[ fixed1.nii, moving1.nii, 0.5, 4, None, 0.1 ] --convergence [ 100x50x30, 1e-09, 20 ] --smoothing-sigmas 2.0x1.0x0.0vox --shrink-factors 3x2x1 --use-estimate-learning-rate-once 1 --use-histogram-matching 1 --winsorize-image-intensities [ 0.0, 1.0 ] --write-composite-transform 1
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    fixed_image:
+    # type=inputmultiobject|default=[]: Image to which the moving_image should be transformed(usually a structural image)
+    moving_image:
+    # type=inputmultiobject|default=[]: Image that will be registered to the space of fixed_image. This is theimage on which the transformations will be applied to
+    metric: '["Mattes", ["Mattes", "CC"]]'
+    # type=list|default=[]: the metric(s) to use for each stage. Note that multiple metrics per stage are not supported in ANTS 1.9.1 and earlier.
+    metric_weight: '[1, [.5,.5]]'
+    # type=list|default=[1.0]: the metric weight(s) for each stage. The weights must sum to 1 per stage.
+    radius_or_number_of_bins: '[32, [32, 4] ]'
+    # type=list|default=[5]: the number of bins in each stage for the MI and Mattes metric, the radius for other metrics
+    sampling_strategy: '["Random", None] # use default strategy in second stage'
+    # type=list|default=[]: the metric sampling strategy (strategies) for each stage
+    sampling_percentage: '[0.05, [0.05, 0.10]]'
+    # type=list|default=[]: the metric sampling percentage(s) to use for each stage
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: antsRegistration --collapse-output-transforms 0 --dimensionality 3 --initial-moving-transform [ trans.mat, 1 ] --initialize-transforms-per-stage 0 --interpolation Linear --output [ output_, output_warped_image.nii.gz ] --transform Affine[ 2.0 ] --metric Mattes[ fixed1.nii, moving1.nii, 1, 32, Random, 0.05 ] --convergence [ 1500x200, 1e-08, 20 ] --smoothing-sigmas 1.0x0.0vox --shrink-factors 2x1 --use-estimate-learning-rate-once 1 --use-histogram-matching 1 --transform SyN[ 0.25, 3.0, 0.0 ] --metric Mattes[ fixed1.nii, moving1.nii, 0.5, 32, None, 0.05 ] --metric CC[ fixed2.nii, moving2.nii, 0.5, 4, None, 0.1 ] --convergence [ 100x50x30, 1e-09, 20 ] --smoothing-sigmas 2.0x1.0x0.0vox --shrink-factors 3x2x1 --use-estimate-learning-rate-once 1 --use-histogram-matching 1 --winsorize-image-intensities [ 0.0, 1.0 ] --write-composite-transform 1
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    fixed_image:
+    # type=inputmultiobject|default=[]: Image to which the moving_image should be transformed(usually a structural image)
+    moving_image:
+    # type=inputmultiobject|default=[]: Image that will be registered to the space of fixed_image. This is theimage on which the transformations will be applied to
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: antsRegistration --collapse-output-transforms 0 --dimensionality 3 --initial-moving-transform [ trans.mat, 1 ] --initialize-transforms-per-stage 0 --interpolation BSpline[ 3 ] --output [ output_, output_warped_image.nii.gz ] --transform Affine[ 2.0 ] --metric Mattes[ fixed1.nii, moving1.nii, 1, 32, Random, 0.05 ] --convergence [ 1500x200, 1e-08, 20 ] --smoothing-sigmas 1.0x0.0vox --shrink-factors 2x1 --use-estimate-learning-rate-once 1 --use-histogram-matching 1 --transform SyN[ 0.25, 3.0, 0.0 ] --metric Mattes[ fixed1.nii, moving1.nii, 1, 32 ] --convergence [ 100x50x30, 1e-09, 20 ] --smoothing-sigmas 2.0x1.0x0.0vox --shrink-factors 3x2x1 --use-estimate-learning-rate-once 1 --use-histogram-matching 1 --winsorize-image-intensities [ 0.0, 1.0 ] --write-composite-transform 1
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    interpolation: '"BSpline"'
+    # type=enum|default='Linear'|allowed['BSpline','CosineWindowedSinc','Gaussian','GenericLabel','HammingWindowedSinc','LanczosWindowedSinc','Linear','MultiLabel','NearestNeighbor','WelchWindowedSinc']: 
+    interpolation_parameters: (3,)
+    # type=traitcompound|default=None: 
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: antsRegistration --collapse-output-transforms 0 --dimensionality 3 --initial-moving-transform [ trans.mat, 1 ] --initialize-transforms-per-stage 0 --interpolation Gaussian[ 1.0, 1.0 ] --output [ output_, output_warped_image.nii.gz ] --transform Affine[ 2.0 ] --metric Mattes[ fixed1.nii, moving1.nii, 1, 32, Random, 0.05 ] --convergence [ 1500x200, 1e-08, 20 ] --smoothing-sigmas 1.0x0.0vox --shrink-factors 2x1 --use-estimate-learning-rate-once 1 --use-histogram-matching 1 --transform SyN[ 0.25, 3.0, 0.0 ] --metric Mattes[ fixed1.nii, moving1.nii, 1, 32 ] --convergence [ 100x50x30, 1e-09, 20 ] --smoothing-sigmas 2.0x1.0x0.0vox --shrink-factors 3x2x1 --use-estimate-learning-rate-once 1 --use-histogram-matching 1 --winsorize-image-intensities [ 0.0, 1.0 ] --write-composite-transform 1
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    interpolation: '"Gaussian"'
+    # type=enum|default='Linear'|allowed['BSpline','CosineWindowedSinc','Gaussian','GenericLabel','HammingWindowedSinc','LanczosWindowedSinc','Linear','MultiLabel','NearestNeighbor','WelchWindowedSinc']: 
+    interpolation_parameters: (1.0, 1.0)
+    # type=traitcompound|default=None: 
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: antsRegistration --collapse-output-transforms 0 --dimensionality 3 --initial-moving-transform [ trans.mat, 1 ] --initialize-transforms-per-stage 0 --interpolation Linear --output [ output_, output_warped_image.nii.gz ] --transform Affine[ 2.0 ] --metric Mattes[ fixed1.nii, moving1.nii, 1, 32, Random, 0.05 ] --convergence [ 1500x200, 1e-08, 20 ] --smoothing-sigmas 1.0x0.0vox --shrink-factors 2x1 --use-estimate-learning-rate-once 1 --use-histogram-matching 1 --transform BSplineSyN[ 0.25, 26, 0, 3 ] --metric Mattes[ fixed1.nii, moving1.nii, 1, 32 ] --convergence [ 100x50x30, 1e-09, 20 ] --smoothing-sigmas 2.0x1.0x0.0vox --shrink-factors 3x2x1 --use-estimate-learning-rate-once 1 --use-histogram-matching 1 --winsorize-image-intensities [ 0.0, 1.0 ] --write-composite-transform 1
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    transforms: '["Affine", "BSplineSyN"]'
+    # type=list|default=[]: 
+    transform_parameters: '[(2.0,), (0.25, 26, 0, 3)]'
+    # type=list|default=[]: 
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: antsRegistration --collapse-output-transforms 0 --dimensionality 3 --initial-moving-transform [ trans.mat, 1 ] --initialize-transforms-per-stage 0 --interpolation Linear --output [ output_, output_warped_image.nii.gz ] --transform Affine[ 2.0 ] --metric Mattes[ fixed1.nii, moving1.nii, 1, 32, Random, 0.05 ] --convergence [ 1500x200, 1e-08, 20 ] --smoothing-sigmas 1.0x0.0vox --shrink-factors 2x1 --use-estimate-learning-rate-once 1 --use-histogram-matching 1 --masks [ NULL, NULL ] --transform SyN[ 0.25, 3.0, 0.0 ] --metric Mattes[ fixed1.nii, moving1.nii, 1, 32 ] --convergence [ 100x50x30, 1e-09, 20 ] --smoothing-sigmas 2.0x1.0x0.0vox --shrink-factors 3x2x1 --use-estimate-learning-rate-once 1 --use-histogram-matching 1 --masks [ fixed1.nii, NULL ] --winsorize-image-intensities [ 0.0, 1.0 ] --write-composite-transform 1
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    fixed_image_masks: '["NULL", "fixed1.nii"]'
+    # type=inputmultiobject|default=[]: Masks used to limit metric sampling region of the fixed image, defined per registration stage(Use "NULL" to omit a mask at a given stage)
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: antsRegistration --collapse-output-transforms 0 --dimensionality 3 --initial-moving-transform [ func_to_struct.mat, 0 ] [ ants_Warp.nii.gz, 0 ] --initialize-transforms-per-stage 0 --interpolation Linear --output [ output_, output_warped_image.nii.gz ] --transform Affine[ 2.0 ] --metric Mattes[ fixed1.nii, moving1.nii, 1, 32, Random, 0.05 ] --convergence [ 1500x200, 1e-08, 20 ] --smoothing-sigmas 1.0x0.0vox --shrink-factors 2x1 --use-estimate-learning-rate-once 1 --use-histogram-matching 1 --transform SyN[ 0.25, 3.0, 0.0 ] --metric Mattes[ fixed1.nii, moving1.nii, 1, 32 ] --convergence [ 100x50x30, 1e-09, 20 ] --smoothing-sigmas 2.0x1.0x0.0vox --shrink-factors 3x2x1 --use-estimate-learning-rate-once 1 --use-histogram-matching 1 --winsorize-image-intensities [ 0.0, 1.0 ] --write-composite-transform 1
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    initial_moving_transform:
+    # type=inputmultiobject|default=[]: A transform or a list of transforms that should be applied before the registration begins. Note that, when a list is given, the transformations are applied in reverse order.
+    invert_initial_moving_transform: '[False, False]'
+    # type=inputmultiobject|default=[]: One boolean or a list of booleans that indicatewhether the inverse(s) of the transform(s) definedin initial_moving_transform should be used.
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-ants/registration_callables.py b/example-specs/task/nipype_internal/pydra-ants/registration_callables.py
new file mode 100644
index 00000000..5191c22f
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-ants/registration_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Registration.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-ants/registration_syn_quick.yaml b/example-specs/task/nipype_internal/pydra-ants/registration_syn_quick.yaml
new file mode 100644
index 00000000..d481a172
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-ants/registration_syn_quick.yaml
@@ -0,0 +1,211 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.ants.registration.RegistrationSynQuick' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Registration using a symmetric image normalization method (SyN).
+#     You can read more in Avants et al.; Med Image Anal., 2008
+#     (https://www.ncbi.nlm.nih.gov/pubmed/17659998).
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces.ants import RegistrationSynQuick
+#     >>> reg = RegistrationSynQuick()
+#     >>> reg.inputs.fixed_image = 'fixed1.nii'
+#     >>> reg.inputs.moving_image = 'moving1.nii'
+#     >>> reg.inputs.num_threads = 2
+#     >>> reg.cmdline
+#     'antsRegistrationSyNQuick.sh -d 3 -f fixed1.nii -r 32 -m moving1.nii -n 2 -o transform -p d -s 26 -t s'
+#     >>> reg.run()  # doctest: +SKIP
+# 
+#     example for multiple images
+# 
+#     >>> from nipype.interfaces.ants import RegistrationSynQuick
+#     >>> reg = RegistrationSynQuick()
+#     >>> reg.inputs.fixed_image = ['fixed1.nii', 'fixed2.nii']
+#     >>> reg.inputs.moving_image = ['moving1.nii', 'moving2.nii']
+#     >>> reg.inputs.num_threads = 2
+#     >>> reg.cmdline
+#     'antsRegistrationSyNQuick.sh -d 3 -f fixed1.nii -f fixed2.nii -r 32 -m moving1.nii -m moving2.nii -n 2 -o transform -p d -s 26 -t s'
+#     >>> reg.run()  # doctest: +SKIP
+#     
+task_name: RegistrationSynQuick
+nipype_name: RegistrationSynQuick
+nipype_module: nipype.interfaces.ants.registration
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    fixed_image: medimage/nifti1+list-of
+    # type=inputmultiobject|default=[]: Fixed image or source image or reference image
+    moving_image: medimage/nifti1+list-of
+    # type=inputmultiobject|default=[]: Moving image or target image
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    warped_image: generic/file
+    # type=file: Warped image
+    inverse_warped_image: generic/file
+    # type=file: Inverse warped image
+    out_matrix: generic/file
+    # type=file: Affine matrix
+    forward_warp_field: generic/file
+    # type=file: Forward warp field
+    inverse_warp_field: generic/file
+    # type=file: Inverse warp field
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    dimension:
+    # type=enum|default=3|allowed[2,3]: image dimension (2 or 3)
+    fixed_image:
+    # type=inputmultiobject|default=[]: Fixed image or source image or reference image
+    moving_image:
+    # type=inputmultiobject|default=[]: Moving image or target image
+    output_prefix:
+    # type=str|default='transform': A prefix that is prepended to all output files
+    num_threads:
+    # type=int|default=1: Number of threads (default = 1)
+    transform_type:
+    # type=enum|default='s'|allowed['a','b','br','r','s','sr','t']: Transform type    * t:  translation   * r:  rigid   * a:  rigid + affine   * s:  rigid + affine + deformable syn (default)   * sr: rigid + deformable syn   * b:  rigid + affine + deformable b-spline syn   * br: rigid + deformable b-spline syn  
+    use_histogram_matching:
+    # type=bool|default=False: use histogram matching
+    histogram_bins:
+    # type=int|default=32: histogram bins for mutual information in SyN stage                                  (default = 32)
+    spline_distance:
+    # type=int|default=26: spline distance for deformable B-spline SyN transform                                  (default = 26)
+    precision_type:
+    # type=enum|default='double'|allowed['double','float']: precision type (default = double)
+    random_seed:
+    # type=int|default=0: fixed random seed
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    fixed_image:
+    # type=inputmultiobject|default=[]: Fixed image or source image or reference image
+    moving_image:
+    # type=inputmultiobject|default=[]: Moving image or target image
+    num_threads: '2'
+    # type=int|default=1: Number of threads (default = 1)
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    fixed_image:
+    # type=inputmultiobject|default=[]: Fixed image or source image or reference image
+    moving_image:
+    # type=inputmultiobject|default=[]: Moving image or target image
+    num_threads: '2'
+    # type=int|default=1: Number of threads (default = 1)
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: antsRegistrationSyNQuick.sh -d 3 -f fixed1.nii -r 32 -m moving1.nii -n 2 -o transform -p d -s 26 -t s
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    fixed_image:
+    # type=inputmultiobject|default=[]: Fixed image or source image or reference image
+    moving_image:
+    # type=inputmultiobject|default=[]: Moving image or target image
+    num_threads: '2'
+    # type=int|default=1: Number of threads (default = 1)
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: antsRegistrationSyNQuick.sh -d 3 -f fixed1.nii -f fixed2.nii -r 32 -m moving1.nii -m moving2.nii -n 2 -o transform -p d -s 26 -t s
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    fixed_image:
+    # type=inputmultiobject|default=[]: Fixed image or source image or reference image
+    moving_image:
+    # type=inputmultiobject|default=[]: Moving image or target image
+    num_threads: '2'
+    # type=int|default=1: Number of threads (default = 1)
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-ants/registration_syn_quick_callables.py b/example-specs/task/nipype_internal/pydra-ants/registration_syn_quick_callables.py
new file mode 100644
index 00000000..d009c67f
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-ants/registration_syn_quick_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in RegistrationSynQuick.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-ants/resample_image_by_spacing.yaml b/example-specs/task/nipype_internal/pydra-ants/resample_image_by_spacing.yaml
new file mode 100644
index 00000000..17d6c355
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-ants/resample_image_by_spacing.yaml
@@ -0,0 +1,278 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.ants.utils.ResampleImageBySpacing' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Resample an image with a given spacing.
+# 
+#     Examples
+#     --------
+#     >>> res = ResampleImageBySpacing(dimension=3)
+#     >>> res.inputs.input_image = 'structural.nii'
+#     >>> res.inputs.output_image = 'output.nii.gz'
+#     >>> res.inputs.out_spacing = (4, 4, 4)
+#     >>> res.cmdline  #doctest: +ELLIPSIS
+#     'ResampleImageBySpacing 3 structural.nii output.nii.gz 4 4 4'
+# 
+#     >>> res = ResampleImageBySpacing(dimension=3)
+#     >>> res.inputs.input_image = 'structural.nii'
+#     >>> res.inputs.output_image = 'output.nii.gz'
+#     >>> res.inputs.out_spacing = (4, 4, 4)
+#     >>> res.inputs.apply_smoothing = True
+#     >>> res.cmdline  #doctest: +ELLIPSIS
+#     'ResampleImageBySpacing 3 structural.nii output.nii.gz 4 4 4 1'
+# 
+#     >>> res = ResampleImageBySpacing(dimension=3)
+#     >>> res.inputs.input_image = 'structural.nii'
+#     >>> res.inputs.output_image = 'output.nii.gz'
+#     >>> res.inputs.out_spacing = (0.4, 0.4, 0.4)
+#     >>> res.inputs.apply_smoothing = True
+#     >>> res.inputs.addvox = 2
+#     >>> res.inputs.nn_interp = False
+#     >>> res.cmdline  #doctest: +ELLIPSIS
+#     'ResampleImageBySpacing 3 structural.nii output.nii.gz 0.4 0.4 0.4 1 2 0'
+# 
+#     
+task_name: ResampleImageBySpacing
+nipype_name: ResampleImageBySpacing
+nipype_module: nipype.interfaces.ants.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    input_image: medimage/nifti1
+    # type=file|default=<undefined>: input image file
+    output_image: medimage/nifti-gz
+    # type=file: resampled file
+    # type=file|default=<undefined>: output image file
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    output_image: medimage/nifti-gz
+    # type=file: resampled file
+    # type=file|default=<undefined>: output image file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    dimension:
+    # type=int|default=3: dimension of output image
+    input_image:
+    # type=file|default=<undefined>: input image file
+    output_image:
+    # type=file: resampled file
+    # type=file|default=<undefined>: output image file
+    out_spacing:
+    # type=traitcompound|default=None: output spacing
+    apply_smoothing:
+    # type=bool|default=False: smooth before resampling
+    addvox:
+    # type=int|default=0: addvox pads each dimension by addvox
+    nn_interp:
+    # type=bool|default=False: nn interpolation
+    num_threads:
+    # type=int|default=1: Number of ITK threads to use
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    input_image:
+    # type=file|default=<undefined>: input image file
+    output_image:
+    # type=file: resampled file
+    # type=file|default=<undefined>: output image file
+    out_spacing: (4, 4, 4)
+    # type=traitcompound|default=None: output spacing
+    dimension: '3'
+    # type=int|default=3: dimension of output image
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    input_image:
+    # type=file|default=<undefined>: input image file
+    output_image:
+    # type=file: resampled file
+    # type=file|default=<undefined>: output image file
+    out_spacing: (4, 4, 4)
+    # type=traitcompound|default=None: output spacing
+    apply_smoothing: 'True'
+    # type=bool|default=False: smooth before resampling
+    dimension: '3'
+    # type=int|default=3: dimension of output image
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    input_image:
+    # type=file|default=<undefined>: input image file
+    output_image:
+    # type=file: resampled file
+    # type=file|default=<undefined>: output image file
+    out_spacing: (0.4, 0.4, 0.4)
+    # type=traitcompound|default=None: output spacing
+    apply_smoothing: 'True'
+    # type=bool|default=False: smooth before resampling
+    addvox: '2'
+    # type=int|default=0: addvox pads each dimension by addvox
+    nn_interp: 'False'
+    # type=bool|default=False: nn interpolation
+    dimension: '3'
+    # type=int|default=3: dimension of output image
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline:
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    input_image:
+    # type=file|default=<undefined>: input image file
+    output_image:
+    # type=file: resampled file
+    # type=file|default=<undefined>: output image file
+    out_spacing: (4, 4, 4)
+    # type=traitcompound|default=None: output spacing
+    dimension: '3'
+    # type=int|default=3: dimension of output image
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline:
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    input_image:
+    # type=file|default=<undefined>: input image file
+    output_image:
+    # type=file: resampled file
+    # type=file|default=<undefined>: output image file
+    out_spacing: (4, 4, 4)
+    # type=traitcompound|default=None: output spacing
+    apply_smoothing: 'True'
+    # type=bool|default=False: smooth before resampling
+    dimension: '3'
+    # type=int|default=3: dimension of output image
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline:
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    input_image:
+    # type=file|default=<undefined>: input image file
+    output_image:
+    # type=file: resampled file
+    # type=file|default=<undefined>: output image file
+    out_spacing: (0.4, 0.4, 0.4)
+    # type=traitcompound|default=None: output spacing
+    apply_smoothing: 'True'
+    # type=bool|default=False: smooth before resampling
+    addvox: '2'
+    # type=int|default=0: addvox pads each dimension by addvox
+    nn_interp: 'False'
+    # type=bool|default=False: nn interpolation
+    dimension: '3'
+    # type=int|default=3: dimension of output image
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-ants/resample_image_by_spacing_callables.py b/example-specs/task/nipype_internal/pydra-ants/resample_image_by_spacing_callables.py
new file mode 100644
index 00000000..e84e078e
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-ants/resample_image_by_spacing_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in ResampleImageBySpacing.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-ants/threshold_image.yaml b/example-specs/task/nipype_internal/pydra-ants/threshold_image.yaml
new file mode 100644
index 00000000..c0d7ee1c
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-ants/threshold_image.yaml
@@ -0,0 +1,234 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.ants.utils.ThresholdImage' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Apply thresholds on images.
+# 
+#     Examples
+#     --------
+#     >>> thres = ThresholdImage(dimension=3)
+#     >>> thres.inputs.input_image = 'structural.nii'
+#     >>> thres.inputs.output_image = 'output.nii.gz'
+#     >>> thres.inputs.th_low = 0.5
+#     >>> thres.inputs.th_high = 1.0
+#     >>> thres.inputs.inside_value = 1.0
+#     >>> thres.inputs.outside_value = 0.0
+#     >>> thres.cmdline  #doctest: +ELLIPSIS
+#     'ThresholdImage 3 structural.nii output.nii.gz 0.500000 1.000000 1.000000 0.000000'
+# 
+#     >>> thres = ThresholdImage(dimension=3)
+#     >>> thres.inputs.input_image = 'structural.nii'
+#     >>> thres.inputs.output_image = 'output.nii.gz'
+#     >>> thres.inputs.mode = 'Kmeans'
+#     >>> thres.inputs.num_thresholds = 4
+#     >>> thres.cmdline  #doctest: +ELLIPSIS
+#     'ThresholdImage 3 structural.nii output.nii.gz Kmeans 4'
+# 
+#     
+task_name: ThresholdImage
+nipype_name: ThresholdImage
+nipype_module: nipype.interfaces.ants.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    input_image: medimage/nifti1
+    # type=file|default=<undefined>: input image file
+    output_image: medimage/nifti-gz
+    # type=file: resampled file
+    # type=file|default=<undefined>: output image file
+    input_mask: generic/file
+    # type=file|default=<undefined>: input mask for Otsu, Kmeans
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    output_image: medimage/nifti-gz
+    # type=file: resampled file
+    # type=file|default=<undefined>: output image file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    dimension:
+    # type=int|default=3: dimension of output image
+    input_image:
+    # type=file|default=<undefined>: input image file
+    output_image:
+    # type=file: resampled file
+    # type=file|default=<undefined>: output image file
+    mode:
+    # type=enum|default='Otsu'|allowed['Kmeans','Otsu']: whether to run Otsu / Kmeans thresholding
+    num_thresholds:
+    # type=int|default=0: number of thresholds
+    input_mask:
+    # type=file|default=<undefined>: input mask for Otsu, Kmeans
+    th_low:
+    # type=float|default=0.0: lower threshold
+    th_high:
+    # type=float|default=0.0: upper threshold
+    inside_value:
+    # type=float|default=1: inside value
+    outside_value:
+    # type=float|default=0: outside value
+    copy_header:
+    # type=bool|default=True: copy headers of the original image into the output (corrected) file
+    num_threads:
+    # type=int|default=1: Number of ITK threads to use
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    input_image:
+    # type=file|default=<undefined>: input image file
+    output_image:
+    # type=file: resampled file
+    # type=file|default=<undefined>: output image file
+    th_low: '0.5'
+    # type=float|default=0.0: lower threshold
+    th_high: '1.0'
+    # type=float|default=0.0: upper threshold
+    inside_value: '1.0'
+    # type=float|default=1: inside value
+    outside_value: '0.0'
+    # type=float|default=0: outside value
+    dimension: '3'
+    # type=int|default=3: dimension of output image
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    input_image:
+    # type=file|default=<undefined>: input image file
+    output_image:
+    # type=file: resampled file
+    # type=file|default=<undefined>: output image file
+    mode: '"Kmeans"'
+    # type=enum|default='Otsu'|allowed['Kmeans','Otsu']: whether to run Otsu / Kmeans thresholding
+    num_thresholds: '4'
+    # type=int|default=0: number of thresholds
+    dimension: '3'
+    # type=int|default=3: dimension of output image
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline:
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    input_image:
+    # type=file|default=<undefined>: input image file
+    output_image:
+    # type=file: resampled file
+    # type=file|default=<undefined>: output image file
+    th_low: '0.5'
+    # type=float|default=0.0: lower threshold
+    th_high: '1.0'
+    # type=float|default=0.0: upper threshold
+    inside_value: '1.0'
+    # type=float|default=1: inside value
+    outside_value: '0.0'
+    # type=float|default=0: outside value
+    dimension: '3'
+    # type=int|default=3: dimension of output image
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline:
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    input_image:
+    # type=file|default=<undefined>: input image file
+    output_image:
+    # type=file: resampled file
+    # type=file|default=<undefined>: output image file
+    mode: '"Kmeans"'
+    # type=enum|default='Otsu'|allowed['Kmeans','Otsu']: whether to run Otsu / Kmeans thresholding
+    num_thresholds: '4'
+    # type=int|default=0: number of thresholds
+    dimension: '3'
+    # type=int|default=3: dimension of output image
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-ants/threshold_image_callables.py b/example-specs/task/nipype_internal/pydra-ants/threshold_image_callables.py
new file mode 100644
index 00000000..91e21ef3
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-ants/threshold_image_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in ThresholdImage.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-ants/warp_image_multi_transform.yaml b/example-specs/task/nipype_internal/pydra-ants/warp_image_multi_transform.yaml
new file mode 100644
index 00000000..82206b42
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-ants/warp_image_multi_transform.yaml
@@ -0,0 +1,212 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.ants.resampling.WarpImageMultiTransform' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Warps an image from one space to another
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces.ants import WarpImageMultiTransform
+#     >>> wimt = WarpImageMultiTransform()
+#     >>> wimt.inputs.input_image = 'structural.nii'
+#     >>> wimt.inputs.reference_image = 'ants_deformed.nii.gz'
+#     >>> wimt.inputs.transformation_series = ['ants_Warp.nii.gz','ants_Affine.txt']
+#     >>> wimt.cmdline
+#     'WarpImageMultiTransform 3 structural.nii structural_wimt.nii -R ants_deformed.nii.gz ants_Warp.nii.gz ants_Affine.txt'
+# 
+#     >>> wimt = WarpImageMultiTransform()
+#     >>> wimt.inputs.input_image = 'diffusion_weighted.nii'
+#     >>> wimt.inputs.reference_image = 'functional.nii'
+#     >>> wimt.inputs.transformation_series = ['func2anat_coreg_Affine.txt','func2anat_InverseWarp.nii.gz',     'dwi2anat_Warp.nii.gz','dwi2anat_coreg_Affine.txt']
+#     >>> wimt.inputs.invert_affine = [1]  # this will invert the 1st Affine file: 'func2anat_coreg_Affine.txt'
+#     >>> wimt.cmdline
+#     'WarpImageMultiTransform 3 diffusion_weighted.nii diffusion_weighted_wimt.nii -R functional.nii -i func2anat_coreg_Affine.txt func2anat_InverseWarp.nii.gz dwi2anat_Warp.nii.gz dwi2anat_coreg_Affine.txt'
+# 
+#     
+task_name: WarpImageMultiTransform
+nipype_name: WarpImageMultiTransform
+nipype_module: nipype.interfaces.ants.resampling
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    input_image: medimage/nifti1
+    # type=file|default=<undefined>: image to apply transformation to (generally a coregistered functional)
+    out_postfix: generic/file
+    # type=file|default='_wimt': Postfix that is prepended to all output files (default = _wimt)
+    reference_image: medimage/nifti1,medimage/nifti-gz
+    # type=file|default=<undefined>: reference image space that you wish to warp INTO
+    transformation_series: '[text/text-file,medimage/nifti-gz]+list-of'
+    # type=inputmultiobject|default=[]: transformation file(s) to be applied
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    output_image: generic/file
+    # type=file: Warped image
+    # type=file|default=<undefined>: name of the output warped image
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    output_image: output_image
+    # type=file: Warped image
+    # type=file|default=<undefined>: name of the output warped image
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    dimension:
+    # type=enum|default=3|allowed[2,3]: image dimension (2 or 3)
+    input_image:
+    # type=file|default=<undefined>: image to apply transformation to (generally a coregistered functional)
+    output_image:
+    # type=file: Warped image
+    # type=file|default=<undefined>: name of the output warped image
+    out_postfix:
+    # type=file|default='_wimt': Postfix that is prepended to all output files (default = _wimt)
+    reference_image:
+    # type=file|default=<undefined>: reference image space that you wish to warp INTO
+    tightest_box:
+    # type=bool|default=False: computes tightest bounding box (overridden by reference_image if given)
+    reslice_by_header:
+    # type=bool|default=False: Uses orientation matrix and origin encoded in reference image file header. Not typically used with additional transforms
+    use_nearest:
+    # type=bool|default=False: Use nearest neighbor interpolation
+    use_bspline:
+    # type=bool|default=False: Use 3rd order B-Spline interpolation
+    transformation_series:
+    # type=inputmultiobject|default=[]: transformation file(s) to be applied
+    invert_affine:
+    # type=list|default=[]: List of Affine transformations to invert.E.g.: [1,4,5] inverts the 1st, 4th, and 5th Affines found in transformation_series. Note that indexing starts with 1 and does not include warp fields. Affine transformations are distinguished from warp fields by the word "affine" included in their filenames.
+    num_threads:
+    # type=int|default=1: Number of ITK threads to use
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    input_image:
+    # type=file|default=<undefined>: image to apply transformation to (generally a coregistered functional)
+    reference_image:
+    # type=file|default=<undefined>: reference image space that you wish to warp INTO
+    transformation_series:
+    # type=inputmultiobject|default=[]: transformation file(s) to be applied
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    input_image:
+    # type=file|default=<undefined>: image to apply transformation to (generally a coregistered functional)
+    reference_image:
+    # type=file|default=<undefined>: reference image space that you wish to warp INTO
+    transformation_series:
+    # type=inputmultiobject|default=[]: transformation file(s) to be applied
+    invert_affine: '[1]  # this will invert the 1st Affine file: "func2anat_coreg_Affine.txt"'
+    # type=list|default=[]: List of Affine transformations to invert.E.g.: [1,4,5] inverts the 1st, 4th, and 5th Affines found in transformation_series. Note that indexing starts with 1 and does not include warp fields. Affine transformations are distinguished from warp fields by the word "affine" included in their filenames.
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: WarpImageMultiTransform 3 structural.nii structural_wimt.nii -R ants_deformed.nii.gz ants_Warp.nii.gz ants_Affine.txt
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    input_image:
+    # type=file|default=<undefined>: image to apply transformation to (generally a coregistered functional)
+    reference_image:
+    # type=file|default=<undefined>: reference image space that you wish to warp INTO
+    transformation_series:
+    # type=inputmultiobject|default=[]: transformation file(s) to be applied
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: WarpImageMultiTransform 3 diffusion_weighted.nii diffusion_weighted_wimt.nii -R functional.nii -i func2anat_coreg_Affine.txt func2anat_InverseWarp.nii.gz dwi2anat_Warp.nii.gz dwi2anat_coreg_Affine.txt
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    input_image:
+    # type=file|default=<undefined>: image to apply transformation to (generally a coregistered functional)
+    reference_image:
+    # type=file|default=<undefined>: reference image space that you wish to warp INTO
+    transformation_series:
+    # type=inputmultiobject|default=[]: transformation file(s) to be applied
+    invert_affine: '[1]  # this will invert the 1st Affine file: "func2anat_coreg_Affine.txt"'
+    # type=list|default=[]: List of Affine transformations to invert.E.g.: [1,4,5] inverts the 1st, 4th, and 5th Affines found in transformation_series. Note that indexing starts with 1 and does not include warp fields. Affine transformations are distinguished from warp fields by the word "affine" included in their filenames.
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-ants/warp_image_multi_transform_callables.py b/example-specs/task/nipype_internal/pydra-ants/warp_image_multi_transform_callables.py
new file mode 100644
index 00000000..6982677a
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-ants/warp_image_multi_transform_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in WarpImageMultiTransform.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-ants/warp_time_series_image_multi_transform.yaml b/example-specs/task/nipype_internal/pydra-ants/warp_time_series_image_multi_transform.yaml
new file mode 100644
index 00000000..2ab6266c
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-ants/warp_time_series_image_multi_transform.yaml
@@ -0,0 +1,202 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.ants.resampling.WarpTimeSeriesImageMultiTransform' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Warps a time-series from one space to another
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces.ants import WarpTimeSeriesImageMultiTransform
+#     >>> wtsimt = WarpTimeSeriesImageMultiTransform()
+#     >>> wtsimt.inputs.input_image = 'resting.nii'
+#     >>> wtsimt.inputs.reference_image = 'ants_deformed.nii.gz'
+#     >>> wtsimt.inputs.transformation_series = ['ants_Warp.nii.gz','ants_Affine.txt']
+#     >>> wtsimt.cmdline
+#     'WarpTimeSeriesImageMultiTransform 4 resting.nii resting_wtsimt.nii -R ants_deformed.nii.gz ants_Warp.nii.gz ants_Affine.txt'
+# 
+#     >>> wtsimt = WarpTimeSeriesImageMultiTransform()
+#     >>> wtsimt.inputs.input_image = 'resting.nii'
+#     >>> wtsimt.inputs.reference_image = 'ants_deformed.nii.gz'
+#     >>> wtsimt.inputs.transformation_series = ['ants_Warp.nii.gz','ants_Affine.txt']
+#     >>> wtsimt.inputs.invert_affine = [1] # # this will invert the 1st Affine file: ants_Affine.txt
+#     >>> wtsimt.cmdline
+#     'WarpTimeSeriesImageMultiTransform 4 resting.nii resting_wtsimt.nii -R ants_deformed.nii.gz ants_Warp.nii.gz -i ants_Affine.txt'
+#     
+task_name: WarpTimeSeriesImageMultiTransform
+nipype_name: WarpTimeSeriesImageMultiTransform
+nipype_module: nipype.interfaces.ants.resampling
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    input_image: medimage/nifti1
+    # type=file|default=<undefined>: image to apply transformation to (generally a coregistered functional)
+    reference_image: medimage/nifti-gz
+    # type=file|default=<undefined>: reference image space that you wish to warp INTO
+    transformation_series: medimage/nifti-gz+list-of
+    # type=inputmultiobject|default=[]: transformation file(s) to be applied
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    output_image: generic/file
+    # type=file: Warped image
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    dimension:
+    # type=enum|default=4|allowed[3,4]: image dimension (3 or 4)
+    input_image:
+    # type=file|default=<undefined>: image to apply transformation to (generally a coregistered functional)
+    out_postfix:
+    # type=str|default='_wtsimt': Postfix that is prepended to all output files (default = _wtsimt)
+    reference_image:
+    # type=file|default=<undefined>: reference image space that you wish to warp INTO
+    tightest_box:
+    # type=bool|default=False: computes tightest bounding box (overridden by reference_image if given)
+    reslice_by_header:
+    # type=bool|default=False: Uses orientation matrix and origin encoded in reference image file header. Not typically used with additional transforms
+    use_nearest:
+    # type=bool|default=False: Use nearest neighbor interpolation
+    use_bspline:
+    # type=bool|default=False: Use 3rd order B-Spline interpolation
+    transformation_series:
+    # type=inputmultiobject|default=[]: transformation file(s) to be applied
+    invert_affine:
+    # type=list|default=[]: List of Affine transformations to invert.E.g.: [1,4,5] inverts the 1st, 4th, and 5th Affines found in transformation_series. Note that indexing starts with 1 and does not include warp fields. Affine transformations are distinguished from warp fields by the word "affine" included in their filenames.
+    num_threads:
+    # type=int|default=1: Number of ITK threads to use
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    input_image:
+    # type=file|default=<undefined>: image to apply transformation to (generally a coregistered functional)
+    reference_image:
+    # type=file|default=<undefined>: reference image space that you wish to warp INTO
+    transformation_series:
+    # type=inputmultiobject|default=[]: transformation file(s) to be applied
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    input_image:
+    # type=file|default=<undefined>: image to apply transformation to (generally a coregistered functional)
+    reference_image:
+    # type=file|default=<undefined>: reference image space that you wish to warp INTO
+    transformation_series:
+    # type=inputmultiobject|default=[]: transformation file(s) to be applied
+    invert_affine: '[1] # # this will invert the 1st Affine file: ants_Affine.txt'
+    # type=list|default=[]: List of Affine transformations to invert.E.g.: [1,4,5] inverts the 1st, 4th, and 5th Affines found in transformation_series. Note that indexing starts with 1 and does not include warp fields. Affine transformations are distinguished from warp fields by the word "affine" included in their filenames.
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: WarpTimeSeriesImageMultiTransform 4 resting.nii resting_wtsimt.nii -R ants_deformed.nii.gz ants_Warp.nii.gz ants_Affine.txt
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    input_image:
+    # type=file|default=<undefined>: image to apply transformation to (generally a coregistered functional)
+    reference_image:
+    # type=file|default=<undefined>: reference image space that you wish to warp INTO
+    transformation_series:
+    # type=inputmultiobject|default=[]: transformation file(s) to be applied
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: WarpTimeSeriesImageMultiTransform 4 resting.nii resting_wtsimt.nii -R ants_deformed.nii.gz ants_Warp.nii.gz -i ants_Affine.txt
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    input_image:
+    # type=file|default=<undefined>: image to apply transformation to (generally a coregistered functional)
+    reference_image:
+    # type=file|default=<undefined>: reference image space that you wish to warp INTO
+    transformation_series:
+    # type=inputmultiobject|default=[]: transformation file(s) to be applied
+    invert_affine: '[1] # # this will invert the 1st Affine file: ants_Affine.txt'
+    # type=list|default=[]: List of Affine transformations to invert.E.g.: [1,4,5] inverts the 1st, 4th, and 5th Affines found in transformation_series. Note that indexing starts with 1 and does not include warp fields. Affine transformations are distinguished from warp fields by the word "affine" included in their filenames.
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-ants/warp_time_series_image_multi_transform_callables.py b/example-specs/task/nipype_internal/pydra-ants/warp_time_series_image_multi_transform_callables.py
new file mode 100644
index 00000000..7eef52d6
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-ants/warp_time_series_image_multi_transform_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in WarpTimeSeriesImageMultiTransform.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-brainsuite/bdp.yaml b/example-specs/task/nipype_internal/pydra-brainsuite/bdp.yaml
new file mode 100644
index 00000000..6753fc5b
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-brainsuite/bdp.yaml
@@ -0,0 +1,206 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.brainsuite.brainsuite.BDP' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     BrainSuite Diffusion Pipeline (BDP) enables fusion of diffusion and
+#     structural MRI information for advanced image and connectivity analysis.
+#     It provides various methods for distortion correction, co-registration,
+#     diffusion modeling (DTI and ODF) and basic ROI-wise statistic. BDP is a
+#     flexible and diverse tool which supports wide variety of diffusion
+#     datasets.
+#     For more information, please see:
+# 
+#     http://brainsuite.org/processing/diffusion/
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces import brainsuite
+#     >>> bdp = brainsuite.BDP()
+#     >>> bdp.inputs.bfcFile = '/directory/subdir/prefix.bfc.nii.gz'
+#     >>> bdp.inputs.inputDiffusionData = '/directory/subdir/prefix.dwi.nii.gz'
+#     >>> bdp.inputs.BVecBValPair = ['/directory/subdir/prefix.dwi.bvec', '/directory/subdir/prefix.dwi.bval']
+#     >>> results = bdp.run() #doctest: +SKIP
+# 
+# 
+#     
+task_name: BDP
+nipype_name: BDP
+nipype_module: nipype.interfaces.brainsuite.brainsuite
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    bfcFile: generic/file
+    # type=file|default=<undefined>: Specify absolute path to file produced by bfc. By default, bfc produces the file in the format: prefix.bfc.nii.gz
+    inputDiffusionData: generic/file
+    # type=file|default=<undefined>: Specifies the absolute path and filename of the input diffusion data in 4D NIfTI-1 format. The flag must be followed by the filename. Only NIfTI-1 files with extension .nii or .nii.gz are supported. Furthermore, either  bMatrixFile, or a combination of both bValueFile and diffusionGradientFile must be used to provide the necessary b-matrices/b-values and gradient vectors. 
+    bMatrixFile: generic/file
+    # type=file|default=<undefined>: Specifies the absolute path and filename of the file containing b-matrices for diffusion-weighted scans. The flag must be followed by the filename. This file must be a plain text file containing 3x3 matrices for each diffusion encoding direction. It should contain zero matrices corresponding to b=0 images. This file usually has ".bmat" as its extension, and can be used to provide BDP with the more-accurate b-matrices as saved by some proprietary scanners. The b-matrices specified by the file must be in the voxel coordinates of the input diffusion weighted image (NIfTI file). In case b-matrices are not known/calculated, bvec and .bval files can be used instead (see diffusionGradientFile and bValueFile). 
+    t1Mask: generic/file
+    # type=file|default=<undefined>: Specifies the filename of the brain-mask file for input T1-weighted image. This mask can be same as the brain mask generated during BrainSuite extraction sequence. For best results, the mask should not include any extra-meningial tissues from T1-weighted image. The mask must be in the same coordinates as input T1-weighted image (i.e. should overlay correctly with input <fileprefix>.bfc.nii.gz file in BrainSuite). This mask is used for co-registration and defining brain boundary for statistics computation. The mask can be generated and/or edited in BrainSuite. In case outputDiffusionCoordinates is also used, this mask is first transformed to diffusion coordinate and the transformed mask is used for defining brain boundary in diffusion coordinates. When t1Mask is not set, BDP will try to use fileprefix>.mask.nii.gz as brain-mask. If <fileprefix>.mask.nii.gz is not found, then BDP will use the input <fileprefix>.bfc.nii.gz itself as mask (i.e. all non-zero voxels in <fileprefix>.bfc.nii.gz is assumed to constitute brain mask).  
+    dwiMask: generic/file
+    # type=file|default=<undefined>: Specifies the filename of the brain-mask file for diffusion data. This mask is used only for co-registration purposes and can affect overall quality of co-registration (see t1Mask for definition of brain mask for statistics computation). The mask must be a 3D volume and should be in the same coordinates as input Diffusion file/data (i.e. should overlay correctly with input diffusion data in BrainSuite). For best results, the mask should include only brain voxels (CSF voxels around brain is also acceptable). When this flag is not used, BDP will generate a pseudo mask using first b=0 image volume and would save it as fileprefix>.dwi.RSA.mask.nii.gz. In case co-registration is not accurate with automatically generated pseudo mask, BDP should be re-run with a refined diffusion mask. The mask can be generated and/or edited in BrainSuite. 
+    fieldmapCorrection: generic/file
+    # type=file|default=<undefined>: Use an acquired fieldmap for distortion correction. The fieldmap must have units of radians/second. Specify the filename of the fieldmap file. The field of view (FOV) of the fieldmap scan must cover the FOV of the diffusion scan. BDP will try to check the overlap of the FOV of the two scans and will issue a warning/error if the diffusion scan"s FOV is not fully covered by the fieldmap"s FOV. BDP uses all of the information saved in the NIfTI header to compute the FOV. If you get this error and think that it is incorrect, then it can be suppressed using the flag ignore-fieldmap-FOV. Neither the image matrix size nor the imaging grid resolution of the fieldmap needs to be the same as that of the diffusion scan, but the fieldmap must be pre-registred to the diffusion scan. BDP does NOT align the fieldmap to the diffusion scan, nor does it check the alignment of the fieldmap and diffusion scans. Only NIfTI files with extension of .nii or .nii.gz are supported. Fieldmap-based distortion correction also requires the echoSpacing. Also fieldmapCorrectionMethod allows you to define method for distortion correction. least squares is the default method. 
+    transformDiffusionVolume: generic/file
+    # type=file|default=<undefined>: This flag allows to define custom volumes in diffusion coordinate which would be transformed into T1 coordinate in a rigid fashion. The flag must be followed by the name of either a NIfTI file or of a folder that contains one or more NIfTI files. All of the files must be in diffusion coordinate, i.e. the files should overlay correctly with the diffusion scan in BrainSuite. Only NIfTI files with an extension of .nii or .nii.gz are supported. The transformed files are written to the output directory with suffix ".T1_coord" in the filename and will not be corrected for distortion, if any. The trait transformInterpolation can be used to define the type of interpolation that would be used (default is set to linear). If you are attempting to transform a label file or mask file, use "nearest" interpolation method with transformInterpolation. See also transformT1Volume and transformInterpolation
+    transformT1Volume: generic/file
+    # type=file|default=<undefined>: Same as transformDiffusionVolume except that files specified must be in T1 coordinate, i.e. the files should overlay correctly with the input <fileprefix>.bfc.nii.gz files in BrainSuite. BDP transforms these data/images from T1 coordinate to diffusion coordinate. The transformed files are written to the output directory with suffix ".D_coord" in the filename. See also transformDiffusionVolume  and transformInterpolation. 
+    transformT1Surface: generic/file
+    # type=file|default=<undefined>: Similar to transformT1Volume, except that this flag allows transforming surfaces (instead of volumes) in T1 coordinate into diffusion coordinate in a rigid fashion. The flag must be followed by the name of either a .dfs file or of a folder that contains one or more dfs files. All of the files must be in T1 coordinate, i.e. the files should overlay correctly with the T1-weighted scan in BrainSuite. The transformed files are written to the output directory with suffix D_coord" in the filename. 
+    transformDiffusionSurface: generic/file
+    # type=file|default=<undefined>: Same as transformT1Volume, except that the .dfs files specified must be in diffusion coordinate, i.e. the surface files should overlay correctly with the diffusion scan in BrainSuite. The transformed files are written to the output directory with suffix ".T1_coord" in the filename. See also transformT1Volume. 
+    customDiffusionLabel: generic/file
+    # type=file|default=<undefined>: BDP supports custom ROIs in addition to those generated by BrainSuite SVReg) for ROI-wise statistics calculation. The flag must be followed by the name of either a file (custom ROI file) or of a folder that contains one or more ROI files. All of the files must be in diffusion coordinate, i.e. the label files should overlay correctly with the diffusion scan in BrainSuite. These input label files are also transferred (and saved) to T1 coordinate for statistics in T1 coordinate. BDP uses nearest-neighborhood interpolation for this transformation. Only NIfTI files, with an extension of .nii or .nii.gz are supported. In order to avoid confusion with other ROI IDs in the statistic files, a 5-digit ROI ID is generated for each custom label found and the mapping of ID to label file is saved in the file fileprefix>.BDP_ROI_MAP.xml. Custom label files can also be generated by using the label painter tool in BrainSuite. See also customLabelXML
+    customT1Label: generic/file
+    # type=file|default=<undefined>: Same as customDiffusionLabelexcept that the label files specified must be in T1 coordinate, i.e. the label files should overlay correctly with the T1-weighted scan in BrainSuite. If the trait outputDiffusionCoordinates is also used then these input label files are also transferred (and saved) to diffusion coordinate for statistics in diffusion coordinate. BDP uses nearest-neighborhood interpolation for this transformation. See also customLabelXML. 
+    customLabelXML: generic/file
+    # type=file|default=<undefined>: BrainSuite saves a descriptions of the SVReg labels (ROI name, ID, color, and description) in an .xml file brainsuite_labeldescription.xml). BDP uses the ROI ID"s from this xml file to report statistics. This flag allows for the use of a custom label description xml file. The flag must be followed by an xml filename. This can be useful when you want to limit the ROIs for which you compute statistics. You can also use custom xml files to name your own ROIs (assign ID"s) for custom labels. BrainSuite can save a label description in .xml format after using the label painter tool to create a ROI label. The xml file MUST be in the same format as BrainSuite"s label description file (see brainsuite_labeldescription.xml for an example). When this flag is used, NO 5-digit ROI ID is generated for custom label files and NO Statistics will be calculated for ROIs not identified in the custom xml file. See also customDiffusionLabel and customT1Label.
+    flagConfigFile: generic/file
+    # type=file|default=<undefined>: Uses the defined file to specify BDP flags which can be useful for batch processing. A flag configuration file is a plain text file which can contain any number of BDP"s optional flags (and their parameters) separated by whitespace. Everything coming after # until end-of-line is treated as comment and is ignored. If a flag is defined in configuration file and is also specified in the command used to run BDP, then the later get preference and overrides the definition in configuration file. 
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    bfcFile:
+    # type=file|default=<undefined>: Specify absolute path to file produced by bfc. By default, bfc produces the file in the format: prefix.bfc.nii.gz
+    noStructuralRegistration:
+    # type=bool|default=False: Allows BDP to work without any structural input. This can useful when one is only interested in diffusion modelling part of BDP. With this flag only fieldmap-based distortion correction is supported. outPrefix can be used to specify fileprefix of the output filenames. Change dwiMask to define region of interest for diffusion modelling.
+    inputDiffusionData:
+    # type=file|default=<undefined>: Specifies the absolute path and filename of the input diffusion data in 4D NIfTI-1 format. The flag must be followed by the filename. Only NIfTI-1 files with extension .nii or .nii.gz are supported. Furthermore, either  bMatrixFile, or a combination of both bValueFile and diffusionGradientFile must be used to provide the necessary b-matrices/b-values and gradient vectors. 
+    bMatrixFile:
+    # type=file|default=<undefined>: Specifies the absolute path and filename of the file containing b-matrices for diffusion-weighted scans. The flag must be followed by the filename. This file must be a plain text file containing 3x3 matrices for each diffusion encoding direction. It should contain zero matrices corresponding to b=0 images. This file usually has ".bmat" as its extension, and can be used to provide BDP with the more-accurate b-matrices as saved by some proprietary scanners. The b-matrices specified by the file must be in the voxel coordinates of the input diffusion weighted image (NIfTI file). In case b-matrices are not known/calculated, bvec and .bval files can be used instead (see diffusionGradientFile and bValueFile). 
+    BVecBValPair:
+    # type=list|default=[]: Must input a list containing first the BVector file, then the BValue file (both must be absolute paths) Example: bdp.inputs.BVecBValPair = ['/directory/subdir/prefix.dwi.bvec', '/directory/subdir/prefix.dwi.bval'] The first item in the list specifies the filename of the file containing b-values for the diffusion scan. The b-value file must be a plain-text file and usually has an extension of .bval The second item in the list specifies the filename of the file containing the diffusion gradient directions (specified in the voxel coordinates of the input diffusion-weighted image)The b-vectors file must be a plain text file and usually has an extension of .bvec 
+    dataSinkDelay:
+    # type=list|default=[]: For use in parallel processing workflows including Brainsuite Cortical Surface Extraction sequence. Connect datasink out_file to dataSinkDelay to delay execution of BDP until dataSink has finished sinking outputs. In particular, BDP may be run after BFC has finished. For more information see http://brainsuite.org/processing/diffusion/pipeline/
+    phaseEncodingDirection:
+    # type=enum|default='x'|allowed['x','x-','y','y-','z','z-']: Specifies the phase-encoding direction of the EPI (diffusion) images. It is same as the dominant direction of distortion in the images. This information is used to constrain the distortion correction along the specified direction. Directions are represented by any one of x, x-, y, y-, z or z-. "x" direction increases towards the right side of the subject, while "x-" increases towards the left side of the subject. Similarly, "y" and "y-" are along the anterior-posterior direction of the subject, and "z" & "z-" are along the inferior-superior direction. When this flag is not used, BDP uses "y" as the default phase-encoding direction. 
+    echoSpacing:
+    # type=float|default=0.0: Sets the echo spacing to t seconds, which is used for fieldmap-based distortion correction. This flag is required when using fieldmapCorrection
+    bValRatioThreshold:
+    # type=float|default=0.0: Sets a threshold which is used to determine b=0 images. When there are no diffusion weighted image with b-value of zero, then BDP tries to use diffusion weighted images with a low b-value in place of b=0 image. The diffusion images with minimum b-value is used as b=0 image only if the ratio of the maximum and minimum b-value is more than the specified threshold. A lower value of threshold will allow diffusion images with higher b-value to be used as b=0 image. The default value of this threshold is set to 45, if this trait is not set. 
+    estimateTensors:
+    # type=bool|default=False: Estimates diffusion tensors using a weighted log-linear estimation and saves derived diffusion tensor parameters (FA, MD, axial, radial, L2, L3). This is the default behavior if no diffusion modeling flags are specified. The estimated diffusion tensors can be visualized by loading the saved ``*.eig.nii.gz`` file in BrainSuite. BDP reports diffusivity (MD, axial, radial, L2 and L3) in a unit which is reciprocal inverse of the unit of input b-value. 
+    estimateODF_FRACT:
+    # type=bool|default=False: Estimates ODFs using the Funk-Radon and Cosine Transformation (FRACT). The outputs are saved in a separate directory with name "FRACT" and the ODFs can be visualized by loading the saved ".odf" file in BrainSuite. 
+    estimateODF_FRT:
+    # type=bool|default=False: Estimates ODFs using Funk-Radon Transformation (FRT). The coefficient maps for ODFs are saved in a separate directory with name "FRT" and the ODFs can be visualized by loading the saved ".odf" file in BrainSuite. The derived generalized-FA (GFA) maps are also saved in the output directory. 
+    estimateODF_3DShore:
+    # type=float|default=0.0: Estimates ODFs using 3Dshore. Pass in diffusion time, in ms
+    odfLambta:
+    # type=bool|default=False: Sets the regularization parameter, lambda, of the Laplace-Beltrami operator while estimating ODFs. The default value is set to 0.006 . This can be used to set the appropriate regularization for the input diffusion data. 
+    t1Mask:
+    # type=file|default=<undefined>: Specifies the filename of the brain-mask file for input T1-weighted image. This mask can be same as the brain mask generated during BrainSuite extraction sequence. For best results, the mask should not include any extra-meningial tissues from T1-weighted image. The mask must be in the same coordinates as input T1-weighted image (i.e. should overlay correctly with input <fileprefix>.bfc.nii.gz file in BrainSuite). This mask is used for co-registration and defining brain boundary for statistics computation. The mask can be generated and/or edited in BrainSuite. In case outputDiffusionCoordinates is also used, this mask is first transformed to diffusion coordinate and the transformed mask is used for defining brain boundary in diffusion coordinates. When t1Mask is not set, BDP will try to use fileprefix>.mask.nii.gz as brain-mask. If <fileprefix>.mask.nii.gz is not found, then BDP will use the input <fileprefix>.bfc.nii.gz itself as mask (i.e. all non-zero voxels in <fileprefix>.bfc.nii.gz is assumed to constitute brain mask).  
+    dwiMask:
+    # type=file|default=<undefined>: Specifies the filename of the brain-mask file for diffusion data. This mask is used only for co-registration purposes and can affect overall quality of co-registration (see t1Mask for definition of brain mask for statistics computation). The mask must be a 3D volume and should be in the same coordinates as input Diffusion file/data (i.e. should overlay correctly with input diffusion data in BrainSuite). For best results, the mask should include only brain voxels (CSF voxels around brain is also acceptable). When this flag is not used, BDP will generate a pseudo mask using first b=0 image volume and would save it as fileprefix>.dwi.RSA.mask.nii.gz. In case co-registration is not accurate with automatically generated pseudo mask, BDP should be re-run with a refined diffusion mask. The mask can be generated and/or edited in BrainSuite. 
+    rigidRegMeasure:
+    # type=enum|default='MI'|allowed['BDP','INVERSION','MI']: Defines the similarity measure to be used for rigid registration. Possible measures are "MI", "INVERSION" and "BDP". MI measure uses normalized mutual information based cost function. INVERSION measure uses simpler cost function based on sum of squared difference by exploiting the approximate inverse-contrast relationship in T1- and T2-weighted images. BDP measure combines MI and INVERSION. It starts with INVERSION measure and refines the result with MI measure. BDP is the default measure when this trait is not set.  
+    dcorrRegMeasure:
+    # type=enum|default='MI'|allowed['BDP','INVERSION-BOTH','INVERSION-EPI','INVERSION-T1','MI']: Defines the method for registration-based distortion correction. Possible methods are "MI", "INVERSION-EPI", "INVERSION-T1", INVERSION-BOTH", and "BDP". MI method uses normalized mutual information based cost-function while estimating the distortion field. INVERSION-based method uses simpler cost function based on sum of squared difference by exploiting the known approximate contrast relationship in T1- and T2-weighted images. T2-weighted EPI is inverted when INVERSION-EPI is used; T1-image is inverted when INVERSION-T1 is used; and both are inverted when INVERSION-BOTH is used. BDP method add the MI-based refinement after the correction using INVERSION-BOTH method. BDP is the default method when this trait is not set.  
+    dcorrWeight:
+    # type=float|default=0.0: Sets the (scalar) weighting parameter for regularization penalty in registration-based distortion correction. Set this trait to a single, non-negative number which specifies the weight. A large regularization weight encourages smoother distortion field at the cost of low measure of image similarity after distortion correction. On the other hand, a smaller regularization weight can result into higher measure of image similarity but with unrealistic and unsmooth distortion field. A weight of 0.5 would reduce the penalty to half of the default regularization penalty (By default, this weight is set to 1.0). Similarly, a weight of 2.0 would increase the penalty to twice of the default penalty.  
+    skipDistortionCorr:
+    # type=bool|default=False: Skips distortion correction completely and performs only a rigid registration of diffusion and T1-weighted image. This can be useful when the input diffusion images do not have any distortion or they have been corrected for distortion. 
+    skipNonuniformityCorr:
+    # type=bool|default=False: Skips intensity non-uniformity correction in b=0 image for registration-based distortion correction. The intensity non-uniformity correction does not affect any diffusion modeling. 
+    skipIntensityCorr:
+    # type=bool|default=False: Disables intensity correction when performing distortion correction. Intensity correction can change the noise distribution in the corrected image, but it does not affect estimated diffusion parameters like FA, etc. 
+    fieldmapCorrection:
+    # type=file|default=<undefined>: Use an acquired fieldmap for distortion correction. The fieldmap must have units of radians/second. Specify the filename of the fieldmap file. The field of view (FOV) of the fieldmap scan must cover the FOV of the diffusion scan. BDP will try to check the overlap of the FOV of the two scans and will issue a warning/error if the diffusion scan"s FOV is not fully covered by the fieldmap"s FOV. BDP uses all of the information saved in the NIfTI header to compute the FOV. If you get this error and think that it is incorrect, then it can be suppressed using the flag ignore-fieldmap-FOV. Neither the image matrix size nor the imaging grid resolution of the fieldmap needs to be the same as that of the diffusion scan, but the fieldmap must be pre-registred to the diffusion scan. BDP does NOT align the fieldmap to the diffusion scan, nor does it check the alignment of the fieldmap and diffusion scans. Only NIfTI files with extension of .nii or .nii.gz are supported. Fieldmap-based distortion correction also requires the echoSpacing. Also fieldmapCorrectionMethod allows you to define method for distortion correction. least squares is the default method. 
+    fieldmapCorrectionMethod:
+    # type=enum|default='pixelshift'|allowed['leastsq','pixelshift']: Defines the distortion correction method while using fieldmap. Possible methods are "pixelshift" and "leastsq". leastsq is the default method when this flag is not used. Pixel-shift (pixelshift) method uses image interpolation to un-distort the distorted diffusion images. Least squares (leastsq) method uses a physical model of distortion which is more accurate (and more computationally expensive) than pixel-shift method.
+    ignoreFieldmapFOV:
+    # type=bool|default=False: Suppresses the error generated by an insufficient field of view of the input fieldmap and continues with the processing. It is useful only when used with fieldmap-based distortion correction. See fieldmap-correction for a detailed explanation. 
+    fieldmapSmooth:
+    # type=float|default=0.0: Applies 3D Gaussian smoothing with a standard deviation of S millimeters (mm) to the input fieldmap before applying distortion correction. This trait is only useful with fieldmapCorrection. Skip this trait for no smoothing. 
+    transformDiffusionVolume:
+    # type=file|default=<undefined>: This flag allows to define custom volumes in diffusion coordinate which would be transformed into T1 coordinate in a rigid fashion. The flag must be followed by the name of either a NIfTI file or of a folder that contains one or more NIfTI files. All of the files must be in diffusion coordinate, i.e. the files should overlay correctly with the diffusion scan in BrainSuite. Only NIfTI files with an extension of .nii or .nii.gz are supported. The transformed files are written to the output directory with suffix ".T1_coord" in the filename and will not be corrected for distortion, if any. The trait transformInterpolation can be used to define the type of interpolation that would be used (default is set to linear). If you are attempting to transform a label file or mask file, use "nearest" interpolation method with transformInterpolation. See also transformT1Volume and transformInterpolation
+    transformT1Volume:
+    # type=file|default=<undefined>: Same as transformDiffusionVolume except that files specified must be in T1 coordinate, i.e. the files should overlay correctly with the input <fileprefix>.bfc.nii.gz files in BrainSuite. BDP transforms these data/images from T1 coordinate to diffusion coordinate. The transformed files are written to the output directory with suffix ".D_coord" in the filename. See also transformDiffusionVolume  and transformInterpolation. 
+    transformInterpolation:
+    # type=enum|default='linear'|allowed['cubic','linear','nearest','spline']: Defines the type of interpolation method which would be used while transforming volumes defined by transformT1Volume and transformDiffusionVolume. Possible methods are "linear", "nearest", "cubic" and "spline". By default, "linear" interpolation is used. 
+    transformT1Surface:
+    # type=file|default=<undefined>: Similar to transformT1Volume, except that this flag allows transforming surfaces (instead of volumes) in T1 coordinate into diffusion coordinate in a rigid fashion. The flag must be followed by the name of either a .dfs file or of a folder that contains one or more dfs files. All of the files must be in T1 coordinate, i.e. the files should overlay correctly with the T1-weighted scan in BrainSuite. The transformed files are written to the output directory with suffix D_coord" in the filename. 
+    transformDiffusionSurface:
+    # type=file|default=<undefined>: Same as transformT1Volume, except that the .dfs files specified must be in diffusion coordinate, i.e. the surface files should overlay correctly with the diffusion scan in BrainSuite. The transformed files are written to the output directory with suffix ".T1_coord" in the filename. See also transformT1Volume. 
+    transformDataOnly:
+    # type=bool|default=False: Skip all of the processing (co-registration, distortion correction and tensor/ODF estimation) and directly start transformation of defined custom volumes, mask and labels (using transformT1Volume, transformDiffusionVolume, transformT1Surface, transformDiffusionSurface, customDiffusionLabel, customT1Label). This flag is useful when BDP was previously run on a subject (or <fileprefix>) and some more data (volumes, mask or labels) need to be transformed across the T1-diffusion coordinate spaces. This assumes that all the necessary files were generated earlier and all of the other flags MUST be used in the same way as they were in the initial BDP run that processed the data. 
+    generateStats:
+    # type=bool|default=False: Generate ROI-wise statistics of estimated diffusion tensor parameters. Units of the reported statistics are same as that of the estimated tensor parameters (see estimateTensors). Mean, variance, and voxel counts of white matter(WM), grey matter(GM), and both WM and GM combined are written for each estimated parameter in a separate comma-seperated value csv) file. BDP uses the ROI labels generated by Surface-Volume Registration (SVReg) in the BrainSuite extraction sequence. Specifically, it looks for labels saved in either fileprefix>.svreg.corr.label.nii.gz or <fileprefix>.svreg.label.nii.gz. In case both files are present, only the first file is used. Also see customDiffusionLabel and customT1Label for specifying your own ROIs. It is also possible to forgo computing the SVReg ROI-wise statistics and only compute stats with custom labels if SVReg label is missing. BDP also transfers (and saves) the label/mask files to appropriate coordinates before computing statistics. Also see outputDiffusionCoordinates for outputs in diffusion coordinate and forcePartialROIStats for an important note about field of view of diffusion and T1-weighted scans. 
+    onlyStats:
+    # type=bool|default=False: Skip all of the processing (co-registration, distortion correction and tensor/ODF estimation) and directly start computation of statistics. This flag is useful when BDP was previously run on a subject (or fileprefix>) and statistics need to be (re-)computed later. This assumes that all the necessary files were generated earlier. All of the other flags MUST be used in the same way as they were in the initial BDP run that processed the data. 
+    forcePartialROIStats:
+    # type=bool|default=False: The field of view (FOV) of the diffusion and T1-weighted scans may differ significantly in some situations. This may result in partial acquisitions of some ROIs in the diffusion scan. By default, BDP does not compute statistics for partially acquired ROIs and shows warnings. This flag forces computation of statistics for all ROIs, including those which are partially acquired. When this flag is used, number of missing voxels are also reported for each ROI in statistics files. Number of missing voxels are reported in the same coordinate system as the statistics file.  
+    customDiffusionLabel:
+    # type=file|default=<undefined>: BDP supports custom ROIs in addition to those generated by BrainSuite SVReg) for ROI-wise statistics calculation. The flag must be followed by the name of either a file (custom ROI file) or of a folder that contains one or more ROI files. All of the files must be in diffusion coordinate, i.e. the label files should overlay correctly with the diffusion scan in BrainSuite. These input label files are also transferred (and saved) to T1 coordinate for statistics in T1 coordinate. BDP uses nearest-neighborhood interpolation for this transformation. Only NIfTI files, with an extension of .nii or .nii.gz are supported. In order to avoid confusion with other ROI IDs in the statistic files, a 5-digit ROI ID is generated for each custom label found and the mapping of ID to label file is saved in the file fileprefix>.BDP_ROI_MAP.xml. Custom label files can also be generated by using the label painter tool in BrainSuite. See also customLabelXML
+    customT1Label:
+    # type=file|default=<undefined>: Same as customDiffusionLabelexcept that the label files specified must be in T1 coordinate, i.e. the label files should overlay correctly with the T1-weighted scan in BrainSuite. If the trait outputDiffusionCoordinates is also used then these input label files are also transferred (and saved) to diffusion coordinate for statistics in diffusion coordinate. BDP uses nearest-neighborhood interpolation for this transformation. See also customLabelXML. 
+    customLabelXML:
+    # type=file|default=<undefined>: BrainSuite saves a descriptions of the SVReg labels (ROI name, ID, color, and description) in an .xml file brainsuite_labeldescription.xml). BDP uses the ROI ID"s from this xml file to report statistics. This flag allows for the use of a custom label description xml file. The flag must be followed by an xml filename. This can be useful when you want to limit the ROIs for which you compute statistics. You can also use custom xml files to name your own ROIs (assign ID"s) for custom labels. BrainSuite can save a label description in .xml format after using the label painter tool to create a ROI label. The xml file MUST be in the same format as BrainSuite"s label description file (see brainsuite_labeldescription.xml for an example). When this flag is used, NO 5-digit ROI ID is generated for custom label files and NO Statistics will be calculated for ROIs not identified in the custom xml file. See also customDiffusionLabel and customT1Label.
+    outputSubdir:
+    # type=str|default='': By default, BDP writes out all the output (and intermediate) files in the same directory (or folder) as the BFC file. This flag allows to specify a sub-directory name in which output (and intermediate) files would be written. BDP will create the sub-directory in the same directory as BFC file. <directory_name> should be the name of the sub-directory without any path. This can be useful to organize all outputs generated by BDP in a separate sub-directory. 
+    outputDiffusionCoordinates:
+    # type=bool|default=False: Enables estimation of diffusion tensors and/or ODFs (and statistics if applicable) in the native diffusion coordinate in addition to the default T1-coordinate. All native diffusion coordinate files are saved in a separate folder named "diffusion_coord_outputs". In case statistics computation is required, it will also transform/save all label/mask files required to diffusion coordinate (see generateStats for details). 
+    flagConfigFile:
+    # type=file|default=<undefined>: Uses the defined file to specify BDP flags which can be useful for batch processing. A flag configuration file is a plain text file which can contain any number of BDP"s optional flags (and their parameters) separated by whitespace. Everything coming after # until end-of-line is treated as comment and is ignored. If a flag is defined in configuration file and is also specified in the command used to run BDP, then the later get preference and overrides the definition in configuration file. 
+    outPrefix:
+    # type=str|default='': Specifies output fileprefix when noStructuralRegistration is used. The fileprefix can not start with a dash (-) and should be a simple string reflecting the absolute path to desired location, along with outPrefix. When this flag is not specified (and noStructuralRegistration is used) then the output files have same file-base as the input diffusion file. This trait is ignored when noStructuralRegistration is not used. 
+    threads:
+    # type=int|default=0: Sets the number of parallel process threads which can be used for computations to N, where N must be an integer. Default value of N is  
+    lowMemory:
+    # type=bool|default=False: Activates low-memory mode. This will run the registration-based distortion correction at a lower resolution, which could result in a less-accurate correction. This should only be used when no other alternative is available. 
+    ignoreMemory:
+    # type=bool|default=False: Deactivates the inbuilt memory checks and forces BDP to run registration-based distortion correction at its default resolution even on machines with a low amount of memory. This may result in an out-of-memory error when BDP cannot allocate sufficient memory. 
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-brainsuite/bdp_callables.py b/example-specs/task/nipype_internal/pydra-brainsuite/bdp_callables.py
new file mode 100644
index 00000000..ff745b83
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-brainsuite/bdp_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in BDP.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-brainsuite/bfc.yaml b/example-specs/task/nipype_internal/pydra-brainsuite/bfc.yaml
new file mode 100644
index 00000000..3c05c844
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-brainsuite/bfc.yaml
@@ -0,0 +1,160 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.brainsuite.brainsuite.Bfc' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     bias field corrector (BFC)
+#     This program corrects gain variation in T1-weighted MRI.
+# 
+#     http://brainsuite.org/processing/surfaceextraction/bfc/
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces import brainsuite
+#     >>> from nipype.testing import example_data
+#     >>> bfc = brainsuite.Bfc()
+#     >>> bfc.inputs.inputMRIFile = example_data('structural.nii')
+#     >>> bfc.inputs.inputMaskFile = example_data('mask.nii')
+#     >>> results = bfc.run() #doctest: +SKIP
+# 
+#     
+task_name: Bfc
+nipype_name: Bfc
+nipype_module: nipype.interfaces.brainsuite.brainsuite
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputMRIFile: generic/file
+    # type=file|default=<undefined>: input skull-stripped MRI volume
+    inputMaskFile: generic/file
+    # type=file|default=<undefined>: mask file
+    outputBiasField: generic/file
+    # type=file: path/name of bias field output file
+    # type=file|default=<undefined>: save bias field estimate
+    outputMaskedBiasField: generic/file
+    # type=file: path/name of masked bias field output
+    # type=file|default=<undefined>: save bias field estimate (masked)
+    correctionScheduleFile: generic/file
+    # type=file: path/name of schedule file
+    # type=file|default=<undefined>: list of parameters 
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputMRIVolume: generic/file
+    # type=file: path/name of output file
+    # type=file|default=<undefined>: output bias-corrected MRI volume. If unspecified, output file name will be auto generated.
+    outputBiasField: generic/file
+    # type=file: path/name of bias field output file
+    # type=file|default=<undefined>: save bias field estimate
+    outputMaskedBiasField: generic/file
+    # type=file: path/name of masked bias field output
+    # type=file|default=<undefined>: save bias field estimate (masked)
+    correctionScheduleFile: generic/file
+    # type=file: path/name of schedule file
+    # type=file|default=<undefined>: list of parameters 
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    outputMRIVolume: outputMRIVolume
+    # type=file: path/name of output file
+    # type=file|default=<undefined>: output bias-corrected MRI volume. If unspecified, output file name will be auto generated.
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputMRIFile:
+    # type=file|default=<undefined>: input skull-stripped MRI volume
+    inputMaskFile:
+    # type=file|default=<undefined>: mask file
+    outputMRIVolume:
+    # type=file: path/name of output file
+    # type=file|default=<undefined>: output bias-corrected MRI volume. If unspecified, output file name will be auto generated.
+    outputBiasField:
+    # type=file: path/name of bias field output file
+    # type=file|default=<undefined>: save bias field estimate
+    outputMaskedBiasField:
+    # type=file: path/name of masked bias field output
+    # type=file|default=<undefined>: save bias field estimate (masked)
+    histogramRadius:
+    # type=int|default=0: histogram radius (voxels)
+    biasEstimateSpacing:
+    # type=int|default=0: bias sample spacing (voxels)
+    controlPointSpacing:
+    # type=int|default=0: control point spacing (voxels)
+    splineLambda:
+    # type=float|default=0.0: spline stiffness weighting parameter
+    histogramType:
+    # type=enum|default='ellipse'|allowed['block','ellipse']: Options for type of histogram:    * ``ellipse``: use ellipsoid for ROI histogram   * ``block``:use block for ROI histogram  
+    iterativeMode:
+    # type=bool|default=False: iterative mode (overrides -r, -s, -c, -w settings)
+    correctionScheduleFile:
+    # type=file: path/name of schedule file
+    # type=file|default=<undefined>: list of parameters 
+    biasFieldEstimatesOutputPrefix:
+    # type=str|default='': save iterative bias field estimates as <prefix>.n.field.nii.gz
+    correctedImagesOutputPrefix:
+    # type=str|default='': save iterative corrected images as <prefix>.n.bfc.nii.gz
+    correctWholeVolume:
+    # type=bool|default=False: apply correction field to entire volume
+    minBias:
+    # type=float|default=0.5: minimum allowed bias value
+    maxBias:
+    # type=float|default=1.5: maximum allowed bias value
+    biasRange:
+    # type=enum|default='low'|allowed['high','low','medium']: Preset options for bias_model    * low: small bias model [0.95,1.05]   * medium: medium bias model [0.90,1.10]   * high: high bias model [0.80,1.20]  
+    intermediate_file_type:
+    # type=enum|default='analyze'|allowed['analyze','gzippedAnalyze','gzippedNifti','nifti']: Options for the format in which intermediate files are generated
+    convergenceThreshold:
+    # type=float|default=0.0: convergence threshold
+    biasEstimateConvergenceThreshold:
+    # type=float|default=0.0: bias estimate convergence threshold (values > 0.1 disable)
+    verbosityLevel:
+    # type=int|default=0: verbosity level (0=silent)
+    timer:
+    # type=bool|default=False: display timing information
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-brainsuite/bfc_callables.py b/example-specs/task/nipype_internal/pydra-brainsuite/bfc_callables.py
new file mode 100644
index 00000000..8aefa14d
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-brainsuite/bfc_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Bfc.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-brainsuite/bse.yaml b/example-specs/task/nipype_internal/pydra-brainsuite/bse.yaml
new file mode 100644
index 00000000..d4d01779
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-brainsuite/bse.yaml
@@ -0,0 +1,157 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.brainsuite.brainsuite.Bse' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     brain surface extractor (BSE)
+#     This program performs automated skull and scalp removal on T1-weighted MRI volumes.
+# 
+#     http://brainsuite.org/processing/surfaceextraction/bse/
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces import brainsuite
+#     >>> from nipype.testing import example_data
+#     >>> bse = brainsuite.Bse()
+#     >>> bse.inputs.inputMRIFile = example_data('structural.nii')
+#     >>> results = bse.run() #doctest: +SKIP
+# 
+#     
+task_name: Bse
+nipype_name: Bse
+nipype_module: nipype.interfaces.brainsuite.brainsuite
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputMRIFile: generic/file
+    # type=file|default=<undefined>: input MRI volume
+    outputDiffusionFilter: generic/file
+    # type=file: path/name of diffusion filter output
+    # type=file|default=<undefined>: diffusion filter output
+    outputEdgeMap: generic/file
+    # type=file: path/name of edge map output
+    # type=file|default=<undefined>: edge map output
+    outputDetailedBrainMask: generic/file
+    # type=file: path/name of detailed brain mask
+    # type=file|default=<undefined>: save detailed brain mask
+    outputCortexFile: generic/file
+    # type=file: path/name of cortex file
+    # type=file|default=<undefined>: cortex file
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputMRIVolume: generic/file
+    # type=file: path/name of brain-masked MRI volume
+    # type=file|default=<undefined>: output brain-masked MRI volume. If unspecified, output file name will be auto generated.
+    outputMaskFile: generic/file
+    # type=file: path/name of smooth brain mask
+    # type=file|default=<undefined>: save smooth brain mask. If unspecified, output file name will be auto generated.
+    outputDiffusionFilter: generic/file
+    # type=file: path/name of diffusion filter output
+    # type=file|default=<undefined>: diffusion filter output
+    outputEdgeMap: generic/file
+    # type=file: path/name of edge map output
+    # type=file|default=<undefined>: edge map output
+    outputDetailedBrainMask: generic/file
+    # type=file: path/name of detailed brain mask
+    # type=file|default=<undefined>: save detailed brain mask
+    outputCortexFile: generic/file
+    # type=file: path/name of cortex file
+    # type=file|default=<undefined>: cortex file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    outputMRIVolume: outputMRIVolume
+    # type=file: path/name of brain-masked MRI volume
+    # type=file|default=<undefined>: output brain-masked MRI volume. If unspecified, output file name will be auto generated.
+    outputMaskFile: outputMaskFile
+    # type=file: path/name of smooth brain mask
+    # type=file|default=<undefined>: save smooth brain mask. If unspecified, output file name will be auto generated.
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputMRIFile:
+    # type=file|default=<undefined>: input MRI volume
+    outputMRIVolume:
+    # type=file: path/name of brain-masked MRI volume
+    # type=file|default=<undefined>: output brain-masked MRI volume. If unspecified, output file name will be auto generated.
+    outputMaskFile:
+    # type=file: path/name of smooth brain mask
+    # type=file|default=<undefined>: save smooth brain mask. If unspecified, output file name will be auto generated.
+    diffusionConstant:
+    # type=float|default=25: diffusion constant
+    diffusionIterations:
+    # type=int|default=3: diffusion iterations
+    edgeDetectionConstant:
+    # type=float|default=0.64: edge detection constant
+    radius:
+    # type=float|default=1: radius of erosion/dilation filter
+    dilateFinalMask:
+    # type=bool|default=True: dilate final mask
+    trim:
+    # type=bool|default=True: trim brainstem
+    outputDiffusionFilter:
+    # type=file: path/name of diffusion filter output
+    # type=file|default=<undefined>: diffusion filter output
+    outputEdgeMap:
+    # type=file: path/name of edge map output
+    # type=file|default=<undefined>: edge map output
+    outputDetailedBrainMask:
+    # type=file: path/name of detailed brain mask
+    # type=file|default=<undefined>: save detailed brain mask
+    outputCortexFile:
+    # type=file: path/name of cortex file
+    # type=file|default=<undefined>: cortex file
+    verbosityLevel:
+    # type=float|default=1:  verbosity level (0=silent)
+    noRotate:
+    # type=bool|default=False: retain original orientation(default behavior will auto-rotate input NII files to LPI orientation)
+    timer:
+    # type=bool|default=False: show timing
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-brainsuite/bse_callables.py b/example-specs/task/nipype_internal/pydra-brainsuite/bse_callables.py
new file mode 100644
index 00000000..90e1e12d
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-brainsuite/bse_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Bse.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-brainsuite/cerebro.yaml b/example-specs/task/nipype_internal/pydra-brainsuite/cerebro.yaml
new file mode 100644
index 00000000..2a0cd638
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-brainsuite/cerebro.yaml
@@ -0,0 +1,156 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.brainsuite.brainsuite.Cerebro' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Cerebrum/cerebellum labeling tool
+#     This program performs automated labeling of cerebellum and cerebrum in T1 MRI.
+#     Input MRI should be skull-stripped or a brain-only mask should be provided.
+# 
+# 
+#     http://brainsuite.org/processing/surfaceextraction/cerebrum/
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces import brainsuite
+#     >>> from nipype.testing import example_data
+#     >>> cerebro = brainsuite.Cerebro()
+#     >>> cerebro.inputs.inputMRIFile = example_data('structural.nii')
+#     >>> cerebro.inputs.inputAtlasMRIFile = 'atlasMRIVolume.img'
+#     >>> cerebro.inputs.inputAtlasLabelFile = 'atlasLabels.img'
+#     >>> cerebro.inputs.inputBrainMaskFile = example_data('mask.nii')
+#     >>> results = cerebro.run() #doctest: +SKIP
+# 
+#     
+task_name: Cerebro
+nipype_name: Cerebro
+nipype_module: nipype.interfaces.brainsuite.brainsuite
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputMRIFile: generic/file
+    # type=file|default=<undefined>: input 3D MRI volume
+    inputAtlasMRIFile: generic/file
+    # type=file|default=<undefined>: atlas MRI volume
+    inputAtlasLabelFile: generic/file
+    # type=file|default=<undefined>: atlas labeling
+    inputBrainMaskFile: generic/file
+    # type=file|default=<undefined>: brain mask file
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputCerebrumMaskFile: generic/file
+    # type=file: path/name of cerebrum mask file
+    # type=file|default=<undefined>: output cerebrum mask volume. If unspecified, output file name will be auto generated.
+    outputLabelVolumeFile: generic/file
+    # type=file: path/name of label mask file
+    # type=file|default=<undefined>: output labeled hemisphere/cerebrum volume. If unspecified, output file name will be auto generated.
+    outputAffineTransformFile: generic/file
+    # type=file: path/name of affine transform file
+    # type=file|default=<undefined>: save affine transform to file.
+    outputWarpTransformFile: generic/file
+    # type=file: path/name of warp transform file
+    # type=file|default=<undefined>: save warp transform to file.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    outputCerebrumMaskFile: outputCerebrumMaskFile
+    # type=file: path/name of cerebrum mask file
+    # type=file|default=<undefined>: output cerebrum mask volume. If unspecified, output file name will be auto generated.
+    outputLabelVolumeFile: outputLabelVolumeFile
+    # type=file: path/name of label mask file
+    # type=file|default=<undefined>: output labeled hemisphere/cerebrum volume. If unspecified, output file name will be auto generated.
+    outputAffineTransformFile: outputAffineTransformFile
+    # type=file: path/name of affine transform file
+    # type=file|default=<undefined>: save affine transform to file.
+    outputWarpTransformFile: outputWarpTransformFile
+    # type=file: path/name of warp transform file
+    # type=file|default=<undefined>: save warp transform to file.
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputMRIFile:
+    # type=file|default=<undefined>: input 3D MRI volume
+    inputAtlasMRIFile:
+    # type=file|default=<undefined>: atlas MRI volume
+    inputAtlasLabelFile:
+    # type=file|default=<undefined>: atlas labeling
+    inputBrainMaskFile:
+    # type=file|default=<undefined>: brain mask file
+    outputCerebrumMaskFile:
+    # type=file: path/name of cerebrum mask file
+    # type=file|default=<undefined>: output cerebrum mask volume. If unspecified, output file name will be auto generated.
+    outputLabelVolumeFile:
+    # type=file: path/name of label mask file
+    # type=file|default=<undefined>: output labeled hemisphere/cerebrum volume. If unspecified, output file name will be auto generated.
+    costFunction:
+    # type=int|default=2: 0,1,2
+    useCentroids:
+    # type=bool|default=False: use centroids of data to initialize position
+    outputAffineTransformFile:
+    # type=file: path/name of affine transform file
+    # type=file|default=<undefined>: save affine transform to file.
+    outputWarpTransformFile:
+    # type=file: path/name of warp transform file
+    # type=file|default=<undefined>: save warp transform to file.
+    verbosity:
+    # type=int|default=0: verbosity level (0=silent)
+    linearConvergence:
+    # type=float|default=0.0: linear convergence
+    warpLabel:
+    # type=int|default=0: warp order (2,3,4,5,6,7,8)
+    warpConvergence:
+    # type=float|default=0.0: warp convergence
+    keepTempFiles:
+    # type=bool|default=False: don't remove temporary files
+    tempDirectory:
+    # type=str|default='': specify directory to use for temporary files
+    tempDirectoryBase:
+    # type=str|default='': create a temporary directory within this directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-brainsuite/cerebro_callables.py b/example-specs/task/nipype_internal/pydra-brainsuite/cerebro_callables.py
new file mode 100644
index 00000000..21d206df
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-brainsuite/cerebro_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Cerebro.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-brainsuite/cortex.yaml b/example-specs/task/nipype_internal/pydra-brainsuite/cortex.yaml
new file mode 100644
index 00000000..e4e2a715
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-brainsuite/cortex.yaml
@@ -0,0 +1,112 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.brainsuite.brainsuite.Cortex' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     cortex extractor
+#     This program produces a cortical mask using tissue fraction estimates
+#     and a co-registered cerebellum/hemisphere mask.
+# 
+#     http://brainsuite.org/processing/surfaceextraction/cortex/
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces import brainsuite
+#     >>> from nipype.testing import example_data
+#     >>> cortex = brainsuite.Cortex()
+#     >>> cortex.inputs.inputHemisphereLabelFile = example_data('mask.nii')
+#     >>> cortex.inputs.inputTissueFractionFile = example_data('tissues.nii.gz')
+#     >>> results = cortex.run() #doctest: +SKIP
+# 
+#     
+task_name: Cortex
+nipype_name: Cortex
+nipype_module: nipype.interfaces.brainsuite.brainsuite
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputHemisphereLabelFile: generic/file
+    # type=file|default=<undefined>: hemisphere / lobe label volume
+    inputTissueFractionFile: generic/file
+    # type=file|default=<undefined>: tissue fraction file (32-bit float)
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputCerebrumMask: generic/file
+    # type=file: path/name of cerebrum mask
+    # type=file|default=<undefined>: output structure mask. If unspecified, output file name will be auto generated.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    outputCerebrumMask: outputCerebrumMask
+    # type=file: path/name of cerebrum mask
+    # type=file|default=<undefined>: output structure mask. If unspecified, output file name will be auto generated.
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputHemisphereLabelFile:
+    # type=file|default=<undefined>: hemisphere / lobe label volume
+    outputCerebrumMask:
+    # type=file: path/name of cerebrum mask
+    # type=file|default=<undefined>: output structure mask. If unspecified, output file name will be auto generated.
+    inputTissueFractionFile:
+    # type=file|default=<undefined>: tissue fraction file (32-bit float)
+    tissueFractionThreshold:
+    # type=float|default=50.0: tissue fraction threshold (percentage)
+    computeWGBoundary:
+    # type=bool|default=True: compute WM/GM boundary
+    computeGCBoundary:
+    # type=bool|default=False: compute GM/CSF boundary
+    includeAllSubcorticalAreas:
+    # type=bool|default=True: include all subcortical areas in WM mask
+    verbosity:
+    # type=int|default=0: verbosity level
+    timer:
+    # type=bool|default=False: timing function
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-brainsuite/cortex_callables.py b/example-specs/task/nipype_internal/pydra-brainsuite/cortex_callables.py
new file mode 100644
index 00000000..544a440f
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-brainsuite/cortex_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Cortex.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-brainsuite/dewisp.yaml b/example-specs/task/nipype_internal/pydra-brainsuite/dewisp.yaml
new file mode 100644
index 00000000..dd8707b7
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-brainsuite/dewisp.yaml
@@ -0,0 +1,107 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.brainsuite.brainsuite.Dewisp' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     dewisp
+#     removes wispy tendril structures from cortex model binary masks.
+#     It does so based on graph theoretic analysis of connected components,
+#     similar to TCA. Each branch of the structure graph is analyzed to determine
+#     pinch points that indicate a likely error in segmentation that attaches noise
+#     to the image. The pinch threshold determines how many voxels the cross-section
+#     can be before it is considered part of the image.
+# 
+#     http://brainsuite.org/processing/surfaceextraction/dewisp/
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces import brainsuite
+#     >>> from nipype.testing import example_data
+#     >>> dewisp = brainsuite.Dewisp()
+#     >>> dewisp.inputs.inputMaskFile = example_data('mask.nii')
+#     >>> results = dewisp.run() #doctest: +SKIP
+# 
+#     
+task_name: Dewisp
+nipype_name: Dewisp
+nipype_module: nipype.interfaces.brainsuite.brainsuite
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputMaskFile: generic/file
+    # type=file|default=<undefined>: input file
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputMaskFile: generic/file
+    # type=file: path/name of mask file
+    # type=file|default=<undefined>: output file. If unspecified, output file name will be auto generated.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    outputMaskFile: outputMaskFile
+    # type=file: path/name of mask file
+    # type=file|default=<undefined>: output file. If unspecified, output file name will be auto generated.
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputMaskFile:
+    # type=file|default=<undefined>: input file
+    outputMaskFile:
+    # type=file: path/name of mask file
+    # type=file|default=<undefined>: output file. If unspecified, output file name will be auto generated.
+    verbosity:
+    # type=int|default=0: verbosity
+    sizeThreshold:
+    # type=int|default=0: size threshold
+    maximumIterations:
+    # type=int|default=0: maximum number of iterations
+    timer:
+    # type=bool|default=False: time processing
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-brainsuite/dewisp_callables.py b/example-specs/task/nipype_internal/pydra-brainsuite/dewisp_callables.py
new file mode 100644
index 00000000..516188ff
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-brainsuite/dewisp_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Dewisp.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-brainsuite/dfs.yaml b/example-specs/task/nipype_internal/pydra-brainsuite/dfs.yaml
new file mode 100644
index 00000000..c11ae2b7
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-brainsuite/dfs.yaml
@@ -0,0 +1,122 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.brainsuite.brainsuite.Dfs' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Surface Generator
+#     Generates mesh surfaces using an isosurface algorithm.
+# 
+#     http://brainsuite.org/processing/surfaceextraction/inner-cortical-surface/
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces import brainsuite
+#     >>> from nipype.testing import example_data
+#     >>> dfs = brainsuite.Dfs()
+#     >>> dfs.inputs.inputVolumeFile = example_data('structural.nii')
+#     >>> results = dfs.run() #doctest: +SKIP
+# 
+#     
+task_name: Dfs
+nipype_name: Dfs
+nipype_module: nipype.interfaces.brainsuite.brainsuite
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputVolumeFile: generic/file
+    # type=file|default=<undefined>: input 3D volume
+    inputShadingVolume: generic/file
+    # type=file|default=<undefined>: shade surface model with data from image volume
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputSurfaceFile: generic/file
+    # type=file: path/name of surface file
+    # type=file|default=<undefined>: output surface mesh file. If unspecified, output file name will be auto generated.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    outputSurfaceFile: outputSurfaceFile
+    # type=file: path/name of surface file
+    # type=file|default=<undefined>: output surface mesh file. If unspecified, output file name will be auto generated.
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputVolumeFile:
+    # type=file|default=<undefined>: input 3D volume
+    outputSurfaceFile:
+    # type=file: path/name of surface file
+    # type=file|default=<undefined>: output surface mesh file. If unspecified, output file name will be auto generated.
+    inputShadingVolume:
+    # type=file|default=<undefined>: shade surface model with data from image volume
+    smoothingIterations:
+    # type=int|default=10: number of smoothing iterations
+    smoothingConstant:
+    # type=float|default=0.5: smoothing constant
+    curvatureWeighting:
+    # type=float|default=5.0: curvature weighting
+    scalingPercentile:
+    # type=float|default=0.0: scaling percentile
+    nonZeroTessellation:
+    # type=bool|default=False: tessellate non-zero voxels
+    tessellationThreshold:
+    # type=float|default=0.0: To be used with specialTessellation. Set this value first, then set specialTessellation value. Usage: tessellate voxels greater_than, less_than, or equal_to <tessellationThreshold>
+    specialTessellation:
+    # type=enum|default='greater_than'|allowed['equal_to','greater_than','less_than']: To avoid throwing a UserWarning, set tessellationThreshold first. Then set this attribute. Usage: tessellate voxels greater_than, less_than, or equal_to <tessellationThreshold>
+    zeroPadFlag:
+    # type=bool|default=False: zero-pad volume (avoids clipping at edges)
+    noNormalsFlag:
+    # type=bool|default=False: do not compute vertex normals
+    postSmoothFlag:
+    # type=bool|default=False: smooth vertices after coloring
+    verbosity:
+    # type=int|default=0: verbosity (0 = quiet)
+    timer:
+    # type=bool|default=False: timing function
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-brainsuite/dfs_callables.py b/example-specs/task/nipype_internal/pydra-brainsuite/dfs_callables.py
new file mode 100644
index 00000000..2614c1e9
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-brainsuite/dfs_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Dfs.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-brainsuite/hemisplit.yaml b/example-specs/task/nipype_internal/pydra-brainsuite/hemisplit.yaml
new file mode 100644
index 00000000..2530a0e8
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-brainsuite/hemisplit.yaml
@@ -0,0 +1,135 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.brainsuite.brainsuite.Hemisplit' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Hemisphere splitter
+#     Splits a surface object into two separate surfaces given an input label volume.
+#     Each vertex is labeled left or right based on the labels being odd (left) or even (right).
+#     The largest contour on the split surface is then found and used as the separation between left and right.
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces import brainsuite
+#     >>> from nipype.testing import example_data
+#     >>> hemisplit = brainsuite.Hemisplit()
+#     >>> hemisplit.inputs.inputSurfaceFile = 'input_surf.dfs'
+#     >>> hemisplit.inputs.inputHemisphereLabelFile = 'label.nii'
+#     >>> hemisplit.inputs.pialSurfaceFile = 'pial.dfs'
+#     >>> results = hemisplit.run() #doctest: +SKIP
+# 
+#     
+task_name: Hemisplit
+nipype_name: Hemisplit
+nipype_module: nipype.interfaces.brainsuite.brainsuite
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputSurfaceFile: generic/file
+    # type=file|default=<undefined>: input surface
+    inputHemisphereLabelFile: generic/file
+    # type=file|default=<undefined>: input hemisphere label volume
+    pialSurfaceFile: generic/file
+    # type=file|default=<undefined>: pial surface file -- must have same geometry as input surface
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputLeftHemisphere: generic/file
+    # type=file: path/name of left hemisphere
+    # type=file|default=<undefined>: output surface file, left hemisphere. If unspecified, output file name will be auto generated.
+    outputRightHemisphere: generic/file
+    # type=file: path/name of right hemisphere
+    # type=file|default=<undefined>: output surface file, right hemisphere. If unspecified, output file name will be auto generated.
+    outputLeftPialHemisphere: generic/file
+    # type=file: path/name of left pial hemisphere
+    # type=file|default=<undefined>: output pial surface file, left hemisphere. If unspecified, output file name will be auto generated.
+    outputRightPialHemisphere: generic/file
+    # type=file: path/name of right pial hemisphere
+    # type=file|default=<undefined>: output pial surface file, right hemisphere. If unspecified, output file name will be auto generated.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    outputLeftHemisphere: outputLeftHemisphere
+    # type=file: path/name of left hemisphere
+    # type=file|default=<undefined>: output surface file, left hemisphere. If unspecified, output file name will be auto generated.
+    outputRightHemisphere: outputRightHemisphere
+    # type=file: path/name of right hemisphere
+    # type=file|default=<undefined>: output surface file, right hemisphere. If unspecified, output file name will be auto generated.
+    outputLeftPialHemisphere: outputLeftPialHemisphere
+    # type=file: path/name of left pial hemisphere
+    # type=file|default=<undefined>: output pial surface file, left hemisphere. If unspecified, output file name will be auto generated.
+    outputRightPialHemisphere: outputRightPialHemisphere
+    # type=file: path/name of right pial hemisphere
+    # type=file|default=<undefined>: output pial surface file, right hemisphere. If unspecified, output file name will be auto generated.
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputSurfaceFile:
+    # type=file|default=<undefined>: input surface
+    inputHemisphereLabelFile:
+    # type=file|default=<undefined>: input hemisphere label volume
+    outputLeftHemisphere:
+    # type=file: path/name of left hemisphere
+    # type=file|default=<undefined>: output surface file, left hemisphere. If unspecified, output file name will be auto generated.
+    outputRightHemisphere:
+    # type=file: path/name of right hemisphere
+    # type=file|default=<undefined>: output surface file, right hemisphere. If unspecified, output file name will be auto generated.
+    pialSurfaceFile:
+    # type=file|default=<undefined>: pial surface file -- must have same geometry as input surface
+    outputLeftPialHemisphere:
+    # type=file: path/name of left pial hemisphere
+    # type=file|default=<undefined>: output pial surface file, left hemisphere. If unspecified, output file name will be auto generated.
+    outputRightPialHemisphere:
+    # type=file: path/name of right pial hemisphere
+    # type=file|default=<undefined>: output pial surface file, right hemisphere. If unspecified, output file name will be auto generated.
+    verbosity:
+    # type=int|default=0: verbosity (0 = silent)
+    timer:
+    # type=bool|default=False: timing function
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-brainsuite/hemisplit_callables.py b/example-specs/task/nipype_internal/pydra-brainsuite/hemisplit_callables.py
new file mode 100644
index 00000000..6f782bb3
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-brainsuite/hemisplit_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Hemisplit.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-brainsuite/pialmesh.yaml b/example-specs/task/nipype_internal/pydra-brainsuite/pialmesh.yaml
new file mode 100644
index 00000000..40e34dac
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-brainsuite/pialmesh.yaml
@@ -0,0 +1,130 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.brainsuite.brainsuite.Pialmesh' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     pialmesh
+#     computes a pial surface model using an inner WM/GM mesh and a tissue fraction map.
+# 
+#     http://brainsuite.org/processing/surfaceextraction/pial/
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces import brainsuite
+#     >>> from nipype.testing import example_data
+#     >>> pialmesh = brainsuite.Pialmesh()
+#     >>> pialmesh.inputs.inputSurfaceFile = 'input_mesh.dfs'
+#     >>> pialmesh.inputs.inputTissueFractionFile = 'frac_file.nii.gz'
+#     >>> pialmesh.inputs.inputMaskFile = example_data('mask.nii')
+#     >>> results = pialmesh.run() #doctest: +SKIP
+# 
+#     
+task_name: Pialmesh
+nipype_name: Pialmesh
+nipype_module: nipype.interfaces.brainsuite.brainsuite
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputSurfaceFile: generic/file
+    # type=file|default=<undefined>: input file
+    inputTissueFractionFile: generic/file
+    # type=file|default=<undefined>: floating point (32) tissue fraction image
+    inputMaskFile: generic/file
+    # type=file|default=<undefined>: restrict growth to mask file region
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputSurfaceFile: generic/file
+    # type=file: path/name of surface file
+    # type=file|default=<undefined>: output file. If unspecified, output file name will be auto generated.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    outputSurfaceFile: outputSurfaceFile
+    # type=file: path/name of surface file
+    # type=file|default=<undefined>: output file. If unspecified, output file name will be auto generated.
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputSurfaceFile:
+    # type=file|default=<undefined>: input file
+    outputSurfaceFile:
+    # type=file: path/name of surface file
+    # type=file|default=<undefined>: output file. If unspecified, output file name will be auto generated.
+    verbosity:
+    # type=int|default=0: verbosity
+    inputTissueFractionFile:
+    # type=file|default=<undefined>: floating point (32) tissue fraction image
+    numIterations:
+    # type=int|default=100: number of iterations
+    searchRadius:
+    # type=float|default=1: search radius
+    stepSize:
+    # type=float|default=0.4: step size
+    inputMaskFile:
+    # type=file|default=<undefined>: restrict growth to mask file region
+    maxThickness:
+    # type=float|default=20: maximum allowed tissue thickness
+    tissueThreshold:
+    # type=float|default=1.05: tissue threshold
+    outputInterval:
+    # type=int|default=10: output interval
+    exportPrefix:
+    # type=str|default='': prefix for exporting surfaces if interval is set
+    laplacianSmoothing:
+    # type=float|default=0.025: apply Laplacian smoothing
+    timer:
+    # type=bool|default=False: show timing
+    recomputeNormals:
+    # type=bool|default=False: recompute normals at each iteration
+    normalSmoother:
+    # type=float|default=0.2: strength of normal smoother.
+    tangentSmoother:
+    # type=float|default=0.0: strength of tangential smoother.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-brainsuite/pialmesh_callables.py b/example-specs/task/nipype_internal/pydra-brainsuite/pialmesh_callables.py
new file mode 100644
index 00000000..2f8bd31c
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-brainsuite/pialmesh_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Pialmesh.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-brainsuite/pvc.yaml b/example-specs/task/nipype_internal/pydra-brainsuite/pvc.yaml
new file mode 100644
index 00000000..f8afd1c6
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-brainsuite/pvc.yaml
@@ -0,0 +1,117 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.brainsuite.brainsuite.Pvc' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     partial volume classifier (PVC) tool.
+#     This program performs voxel-wise tissue classification T1-weighted MRI.
+#     Image should be skull-stripped and bias-corrected before tissue classification.
+# 
+#     http://brainsuite.org/processing/surfaceextraction/pvc/
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces import brainsuite
+#     >>> from nipype.testing import example_data
+#     >>> pvc = brainsuite.Pvc()
+#     >>> pvc.inputs.inputMRIFile = example_data('structural.nii')
+#     >>> pvc.inputs.inputMaskFile = example_data('mask.nii')
+#     >>> results = pvc.run() #doctest: +SKIP
+# 
+#     
+task_name: Pvc
+nipype_name: Pvc
+nipype_module: nipype.interfaces.brainsuite.brainsuite
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputMRIFile: generic/file
+    # type=file|default=<undefined>: MRI file
+    inputMaskFile: generic/file
+    # type=file|default=<undefined>: brain mask file
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputLabelFile: generic/file
+    # type=file: path/name of label file
+    # type=file|default=<undefined>: output label file. If unspecified, output file name will be auto generated.
+    outputTissueFractionFile: generic/file
+    # type=file: path/name of tissue fraction file
+    # type=file|default=<undefined>: output tissue fraction file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    outputLabelFile: outputLabelFile
+    # type=file: path/name of label file
+    # type=file|default=<undefined>: output label file. If unspecified, output file name will be auto generated.
+    outputTissueFractionFile: outputTissueFractionFile
+    # type=file: path/name of tissue fraction file
+    # type=file|default=<undefined>: output tissue fraction file
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputMRIFile:
+    # type=file|default=<undefined>: MRI file
+    inputMaskFile:
+    # type=file|default=<undefined>: brain mask file
+    outputLabelFile:
+    # type=file: path/name of label file
+    # type=file|default=<undefined>: output label file. If unspecified, output file name will be auto generated.
+    outputTissueFractionFile:
+    # type=file: path/name of tissue fraction file
+    # type=file|default=<undefined>: output tissue fraction file
+    spatialPrior:
+    # type=float|default=0.0: spatial prior strength
+    verbosity:
+    # type=int|default=0: verbosity level (0 = silent)
+    threeClassFlag:
+    # type=bool|default=False: use a three-class (CSF=0,GM=1,WM=2) labeling
+    timer:
+    # type=bool|default=False: time processing
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-brainsuite/pvc_callables.py b/example-specs/task/nipype_internal/pydra-brainsuite/pvc_callables.py
new file mode 100644
index 00000000..2d3a10a3
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-brainsuite/pvc_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Pvc.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-brainsuite/scrubmask.yaml b/example-specs/task/nipype_internal/pydra-brainsuite/scrubmask.yaml
new file mode 100644
index 00000000..a2129211
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-brainsuite/scrubmask.yaml
@@ -0,0 +1,105 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.brainsuite.brainsuite.Scrubmask' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     ScrubMask tool
+#     scrubmask filters binary masks to trim loosely connected voxels that may
+#     result from segmentation errors and produce bumps on tessellated surfaces.
+# 
+#     http://brainsuite.org/processing/surfaceextraction/scrubmask/
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces import brainsuite
+#     >>> from nipype.testing import example_data
+#     >>> scrubmask = brainsuite.Scrubmask()
+#     >>> scrubmask.inputs.inputMaskFile = example_data('mask.nii')
+#     >>> results = scrubmask.run() #doctest: +SKIP
+# 
+#     
+task_name: Scrubmask
+nipype_name: Scrubmask
+nipype_module: nipype.interfaces.brainsuite.brainsuite
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputMaskFile: generic/file
+    # type=file|default=<undefined>: input structure mask file
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputMaskFile: generic/file
+    # type=file: path/name of mask file
+    # type=file|default=<undefined>: output structure mask file. If unspecified, output file name will be auto generated.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    outputMaskFile: outputMaskFile
+    # type=file: path/name of mask file
+    # type=file|default=<undefined>: output structure mask file. If unspecified, output file name will be auto generated.
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputMaskFile:
+    # type=file|default=<undefined>: input structure mask file
+    outputMaskFile:
+    # type=file: path/name of mask file
+    # type=file|default=<undefined>: output structure mask file. If unspecified, output file name will be auto generated.
+    backgroundFillThreshold:
+    # type=int|default=2: background fill threshold
+    foregroundTrimThreshold:
+    # type=int|default=0: foreground trim threshold
+    numberIterations:
+    # type=int|default=0: number of iterations
+    verbosity:
+    # type=int|default=0: verbosity (0=silent)
+    timer:
+    # type=bool|default=False: timing function
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-brainsuite/scrubmask_callables.py b/example-specs/task/nipype_internal/pydra-brainsuite/scrubmask_callables.py
new file mode 100644
index 00000000..c4b687f9
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-brainsuite/scrubmask_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Scrubmask.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-brainsuite/skullfinder.yaml b/example-specs/task/nipype_internal/pydra-brainsuite/skullfinder.yaml
new file mode 100644
index 00000000..2267352a
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-brainsuite/skullfinder.yaml
@@ -0,0 +1,116 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.brainsuite.brainsuite.Skullfinder' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Skull and scalp segmentation algorithm.
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces import brainsuite
+#     >>> from nipype.testing import example_data
+#     >>> skullfinder = brainsuite.Skullfinder()
+#     >>> skullfinder.inputs.inputMRIFile = example_data('structural.nii')
+#     >>> skullfinder.inputs.inputMaskFile = example_data('mask.nii')
+#     >>> results = skullfinder.run() #doctest: +SKIP
+# 
+#     
+task_name: Skullfinder
+nipype_name: Skullfinder
+nipype_module: nipype.interfaces.brainsuite.brainsuite
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputMRIFile: generic/file
+    # type=file|default=<undefined>: input file
+    inputMaskFile: generic/file
+    # type=file|default=<undefined>: A brain mask file, 8-bit image (0=non-brain, 255=brain)
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputLabelFile: generic/file
+    # type=file: path/name of label file
+    # type=file|default=<undefined>: output multi-colored label volume segmenting brain, scalp, inner skull & outer skull If unspecified, output file name will be auto generated.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    outputLabelFile: outputLabelFile
+    # type=file: path/name of label file
+    # type=file|default=<undefined>: output multi-colored label volume segmenting brain, scalp, inner skull & outer skull If unspecified, output file name will be auto generated.
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputMRIFile:
+    # type=file|default=<undefined>: input file
+    inputMaskFile:
+    # type=file|default=<undefined>: A brain mask file, 8-bit image (0=non-brain, 255=brain)
+    outputLabelFile:
+    # type=file: path/name of label file
+    # type=file|default=<undefined>: output multi-colored label volume segmenting brain, scalp, inner skull & outer skull If unspecified, output file name will be auto generated.
+    verbosity:
+    # type=int|default=0: verbosity
+    lowerThreshold:
+    # type=int|default=0: Lower threshold for segmentation
+    upperThreshold:
+    # type=int|default=0: Upper threshold for segmentation
+    surfaceFilePrefix:
+    # type=str|default='': if specified, generate surface files for brain, skull, and scalp
+    bgLabelValue:
+    # type=int|default=0: background label value (0-255)
+    scalpLabelValue:
+    # type=int|default=0: scalp label value (0-255)
+    skullLabelValue:
+    # type=int|default=0: skull label value (0-255)
+    spaceLabelValue:
+    # type=int|default=0: space label value (0-255)
+    brainLabelValue:
+    # type=int|default=0: brain label value (0-255)
+    performFinalOpening:
+    # type=bool|default=False: perform a final opening operation on the scalp mask
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-brainsuite/skullfinder_callables.py b/example-specs/task/nipype_internal/pydra-brainsuite/skullfinder_callables.py
new file mode 100644
index 00000000..ba356187
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-brainsuite/skullfinder_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Skullfinder.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-brainsuite/sv_reg.yaml b/example-specs/task/nipype_internal/pydra-brainsuite/sv_reg.yaml
new file mode 100644
index 00000000..5bb1056a
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-brainsuite/sv_reg.yaml
@@ -0,0 +1,131 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.brainsuite.brainsuite.SVReg' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     surface and volume registration (svreg)
+#     This program registers a subject's BrainSuite-processed volume and surfaces
+#     to an atlas, allowing for automatic labelling of volume and surface ROIs.
+# 
+#     For more information, please see:
+#     http://brainsuite.org/processing/svreg/usage/
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces import brainsuite
+#     >>> svreg = brainsuite.SVReg()
+#     >>> svreg.inputs.subjectFilePrefix = 'home/user/btestsubject/testsubject'
+#     >>> svreg.inputs.refineOutputs = True
+#     >>> svreg.inputs.skipToVolumeReg = False
+#     >>> svreg.inputs. keepIntermediates = True
+#     >>> svreg.inputs.verbosity2 = True
+#     >>> svreg.inputs.displayTimestamps = True
+#     >>> svreg.inputs.useSingleThreading = True
+#     >>> results = svreg.run() #doctest: +SKIP
+# 
+# 
+#     
+task_name: SVReg
+nipype_name: SVReg
+nipype_module: nipype.interfaces.brainsuite.brainsuite
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    subjectFilePrefix:
+    # type=str|default='': Absolute path and filename prefix of the subjects output from BrainSuite Cortical Surface Extraction Sequence
+    dataSinkDelay:
+    # type=list|default=[]: Connect datasink out_file to dataSinkDelay to delay execution of SVReg until dataSink has finished sinking CSE outputs.For use with parallel processing workflows including Brainsuites Cortical Surface Extraction sequence (SVReg requires certain files from Brainsuite CSE, which must all be in the pathway specified by subjectFilePrefix. see http://brainsuite.org/processing/svreg/usage/ for list of required inputs 
+    atlasFilePrefix:
+    # type=str|default='': Optional: Absolute Path and filename prefix of atlas files and labels to which the subject will be registered. If unspecified, SVRegwill use its own included atlas files
+    iterations:
+    # type=int|default=0: Assigns a number of iterations in the intensity registration step.if unspecified, performs 100 iterations
+    refineOutputs:
+    # type=bool|default=False: Refine outputs at the expense of more processing time.
+    skipToVolumeReg:
+    # type=bool|default=False: If surface registration was already performed at an earlier time and the user would not like to redo this step, then this flag may be used to skip ahead to the volumetric registration. Necessary input files will need to be present in the input directory called by the command.
+    skipToIntensityReg:
+    # type=bool|default=False: If the p-harmonic volumetric registration was already performed at an earlier time and the user would not like to redo this step, then this flag may be used to skip ahead to the intensity registration and label transfer step.
+    useManualMaskFile:
+    # type=bool|default=False: Can call a manually edited cerebrum mask to limit boundaries. Will use file: subbasename.cerebrum.mask.nii.gz Make sure to correctly replace your manually edited mask file in your input folder with the correct subbasename.
+    curveMatchingInstructions:
+    # type=str|default='': Used to take control of the curve matching process between the atlas and subject. One can specify the name of the .dfc file <sulname.dfc> and the sulcal numbers <#sul> to be used as constraints. example: curveMatchingInstructions = "subbasename.right.dfc 1 2 20"
+    useCerebrumMask:
+    # type=bool|default=False: The cerebrum mask <subbasename.cerebrum.mask.nii.gz> will be used for masking the final labels instead of the default pial surface mask. Every voxel will be labeled within the cerebrum mask regardless of the boundaries of the pial surface.
+    pialSurfaceMaskDilation:
+    # type=int|default=0: Cortical volume labels found in file output subbasename.svreg.label.nii.gz find its boundaries by using the pial surface then dilating by 1 voxel. Use this flag in order to control the number of pial surface mask dilation. (ie. -D 0 will assign no voxel dilation)
+    keepIntermediates:
+    # type=bool|default=False: Keep the intermediate files after the svreg sequence is complete.
+    verbosity0:
+    # type=bool|default=False: no messages will be reported
+    verbosity1:
+    # type=bool|default=False: messages will be reported but not the iteration-wise detailed messages
+    verbosity2:
+    # type=bool|default=False: all the messages, including per-iteration, will be displayed
+    shortMessages:
+    # type=bool|default=False: Short messages instead of detailed messages
+    displayModuleName:
+    # type=bool|default=False: Module name will be displayed in the messages
+    displayTimestamps:
+    # type=bool|default=False: Timestamps will be displayed in the messages
+    skipVolumetricProcessing:
+    # type=bool|default=False: Only surface registration and labeling will be performed. Volumetric processing will be skipped.
+    useMultiThreading:
+    # type=bool|default=False: If multiple CPUs are present on the system, the code will try to use multithreading to make the execution fast.
+    useSingleThreading:
+    # type=bool|default=False: Use single threaded mode.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-brainsuite/sv_reg_callables.py b/example-specs/task/nipype_internal/pydra-brainsuite/sv_reg_callables.py
new file mode 100644
index 00000000..ef6e5d5d
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-brainsuite/sv_reg_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in SVReg.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-brainsuite/tca.yaml b/example-specs/task/nipype_internal/pydra-brainsuite/tca.yaml
new file mode 100644
index 00000000..11b54c9e
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-brainsuite/tca.yaml
@@ -0,0 +1,103 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.brainsuite.brainsuite.Tca' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     topological correction algorithm (TCA)
+#     This program removes topological handles from a binary object.
+# 
+#     http://brainsuite.org/processing/surfaceextraction/tca/
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import brainsuite
+#     >>> from nipype.testing import example_data
+#     >>> tca = brainsuite.Tca()
+#     >>> tca.inputs.inputMaskFile = example_data('mask.nii')
+#     >>> results = tca.run() #doctest: +SKIP
+# 
+#     
+task_name: Tca
+nipype_name: Tca
+nipype_module: nipype.interfaces.brainsuite.brainsuite
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputMaskFile: generic/file
+    # type=file|default=<undefined>: input mask volume
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputMaskFile: generic/file
+    # type=file: path/name of mask file
+    # type=file|default=<undefined>: output mask volume. If unspecified, output file name will be auto generated.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    outputMaskFile: outputMaskFile
+    # type=file: path/name of mask file
+    # type=file|default=<undefined>: output mask volume. If unspecified, output file name will be auto generated.
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputMaskFile:
+    # type=file|default=<undefined>: input mask volume
+    outputMaskFile:
+    # type=file: path/name of mask file
+    # type=file|default=<undefined>: output mask volume. If unspecified, output file name will be auto generated.
+    minCorrectionSize:
+    # type=int|default=2500: maximum correction size
+    maxCorrectionSize:
+    # type=int|default=0: minimum correction size
+    foregroundDelta:
+    # type=int|default=20: foreground delta
+    verbosity:
+    # type=int|default=0: verbosity (0 = quiet)
+    timer:
+    # type=bool|default=False: timing function
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-brainsuite/tca_callables.py b/example-specs/task/nipype_internal/pydra-brainsuite/tca_callables.py
new file mode 100644
index 00000000..038e2b06
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-brainsuite/tca_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Tca.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-brainsuite/thickness_pvc.yaml b/example-specs/task/nipype_internal/pydra-brainsuite/thickness_pvc.yaml
new file mode 100644
index 00000000..6ceafa08
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-brainsuite/thickness_pvc.yaml
@@ -0,0 +1,88 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.brainsuite.brainsuite.ThicknessPVC' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     ThicknessPVC computes cortical thickness using partial tissue fractions.
+#     This thickness measure is then transferred to the atlas surface to
+#     facilitate population studies. It also stores the computed thickness into
+#     separate hemisphere files and subject thickness mapped to the atlas
+#     hemisphere surfaces. ThicknessPVC is not run through the main SVReg
+#     sequence, and should be used after executing the BrainSuite and SVReg
+#     sequence.
+#     For more informaction, please see:
+# 
+#     http://brainsuite.org/processing/svreg/svreg_modules/
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces import brainsuite
+#     >>> thicknessPVC = brainsuite.ThicknessPVC()
+#     >>> thicknessPVC.inputs.subjectFilePrefix = 'home/user/btestsubject/testsubject'
+#     >>> results = thicknessPVC.run() #doctest: +SKIP
+# 
+#     
+task_name: ThicknessPVC
+nipype_name: ThicknessPVC
+nipype_module: nipype.interfaces.brainsuite.brainsuite
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    subjectFilePrefix:
+    # type=str|default='': Absolute path and filename prefix of the subject data
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-brainsuite/thickness_pvc_callables.py b/example-specs/task/nipype_internal/pydra-brainsuite/thickness_pvc_callables.py
new file mode 100644
index 00000000..728f0f19
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-brainsuite/thickness_pvc_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in ThicknessPVC.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-bru2nii/bru_2.yaml b/example-specs/task/nipype_internal/pydra-bru2nii/bru_2.yaml
new file mode 100644
index 00000000..14e60c56
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-bru2nii/bru_2.yaml
@@ -0,0 +1,127 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.bru2nii.Bru2' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Uses bru2nii's Bru2 to convert Bruker files
+# 
+#     Examples
+#     ========
+# 
+#     >>> from nipype.interfaces.bru2nii import Bru2
+#     >>> converter = Bru2()
+#     >>> converter.inputs.input_dir = "brukerdir"
+#     >>> converter.cmdline  # doctest: +ELLIPSIS
+#     'Bru2 -o .../data/brukerdir brukerdir'
+#     
+task_name: Bru2
+nipype_name: Bru2
+nipype_module: nipype.interfaces.bru2nii
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    input_dir: generic/directory
+    # type=directory|default=<undefined>: Input Directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    nii_file: generic/file
+    # type=file: 
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    output_filename: output_filename
+    # type=str|default='': Output filename (".nii" will be appended, or ".nii.gz" if the "-z" compress option is selected)
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    input_dir:
+    # type=directory|default=<undefined>: Input Directory
+    actual_size:
+    # type=bool|default=False: Keep actual size - otherwise x10 scale so animals match human.
+    force_conversion:
+    # type=bool|default=False: Force conversion of localizers images (multiple slice orientations).
+    compress:
+    # type=bool|default=False: gz compress images (".nii.gz").
+    append_protocol_name:
+    # type=bool|default=False: Append protocol name to output filename.
+    output_filename:
+    # type=str|default='': Output filename (".nii" will be appended, or ".nii.gz" if the "-z" compress option is selected)
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    input_dir: '"brukerdir"'
+    # type=directory|default=<undefined>: Input Directory
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: Bru2 -o .../data/brukerdir brukerdir
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    input_dir: '"brukerdir"'
+    # type=directory|default=<undefined>: Input Directory
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-bru2nii/bru_2_callables.py b/example-specs/task/nipype_internal/pydra-bru2nii/bru_2_callables.py
new file mode 100644
index 00000000..d452f09c
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-bru2nii/bru_2_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Bru2.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-c3/c_3d.yaml b/example-specs/task/nipype_internal/pydra-c3/c_3d.yaml
new file mode 100644
index 00000000..b07f1226
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-c3/c_3d.yaml
@@ -0,0 +1,165 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.c3.C3d' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Convert3d is a command-line tool for converting 3D (or 4D) images between
+#     common file formats. The tool also includes a growing list of commands for
+#     image manipulation, such as thresholding and resampling. The tool can also
+#     be used to obtain information about image files. More information on
+#     Convert3d can be found at:
+#     https://sourceforge.net/p/c3d/git/ci/master/tree/doc/c3d.md
+# 
+# 
+#     Example
+#     =======
+# 
+#     >>> from nipype.interfaces.c3 import C3d
+#     >>> c3 = C3d()
+#     >>> c3.inputs.in_file = "T1.nii"
+#     >>> c3.inputs.pix_type = "short"
+#     >>> c3.inputs.out_file = "T1.img"
+#     >>> c3.cmdline
+#     'c3d T1.nii -type short -o T1.img'
+#     >>> c3.inputs.is_4d = True
+#     >>> c3.inputs.in_file = "epi.nii"
+#     >>> c3.inputs.out_file = "epi.img"
+#     >>> c3.cmdline
+#     'c4d epi.nii -type short -o epi.img'
+#     
+task_name: C3d
+nipype_name: C3d
+nipype_module: nipype.interfaces.c3
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1+list-of
+    # type=inputmultiobject|default=[]: Input file (wildcard and multiple are supported).
+    out_file: medimage/analyze
+    # type=file|default=<undefined>: Output file of last image on the stack.
+    out_files: generic/file+list-of
+    # type=outputmultiobject: 
+    # type=inputmultiobject|default=[]: Write all images on the convert3d stack as multiple files. Supports both list of output files or a pattern for the output filenames (using %d substitution).
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=inputmultiobject|default=[]: Input file (wildcard and multiple are supported).
+    out_file:
+    # type=file|default=<undefined>: Output file of last image on the stack.
+    out_files:
+    # type=outputmultiobject: 
+    # type=inputmultiobject|default=[]: Write all images on the convert3d stack as multiple files. Supports both list of output files or a pattern for the output filenames (using %d substitution).
+    pix_type:
+    # type=enum|default='float'|allowed['char','double','float','int','short','uchar','uint','ushort']: Specifies the pixel type for the output image. By default, images are written in floating point (float) format
+    scale:
+    # type=traitcompound|default=None: Multiplies the intensity of each voxel in the last image on the stack by the given factor.
+    shift:
+    # type=traitcompound|default=None: Adds the given constant to every voxel.
+    interp:
+    # type=enum|default='Linear'|allowed['Cubic','Gaussian','Linear','NearestNeighbor','Sinc']: Specifies the interpolation used with -resample and other commands. Default is Linear.
+    resample:
+    # type=str|default='': Resamples the image, keeping the bounding box the same, but changing the number of voxels in the image. The dimensions can be specified as a percentage, for example to double the number of voxels in each direction. The -interpolation flag affects how sampling is performed.
+    smooth:
+    # type=str|default='': Applies Gaussian smoothing to the image. The parameter vector specifies the standard deviation of the Gaussian kernel.
+    multicomp_split:
+    # type=bool|default=False: Enable reading of multi-component images.
+    is_4d:
+    # type=bool|default=False: Changes command to support 4D file operations (default is false).
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=inputmultiobject|default=[]: Input file (wildcard and multiple are supported).
+    pix_type: '"short"'
+    # type=enum|default='float'|allowed['char','double','float','int','short','uchar','uint','ushort']: Specifies the pixel type for the output image. By default, images are written in floating point (float) format
+    out_file:
+    # type=file|default=<undefined>: Output file of last image on the stack.
+    is_4d: 'True'
+    # type=bool|default=False: Changes command to support 4D file operations (default is false).
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: c4d epi.nii -type short -o epi.img
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=inputmultiobject|default=[]: Input file (wildcard and multiple are supported).
+    pix_type: '"short"'
+    # type=enum|default='float'|allowed['char','double','float','int','short','uchar','uint','ushort']: Specifies the pixel type for the output image. By default, images are written in floating point (float) format
+    out_file:
+    # type=file|default=<undefined>: Output file of last image on the stack.
+    is_4d: 'True'
+    # type=bool|default=False: Changes command to support 4D file operations (default is false).
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-c3/c_3d_affine_tool.yaml b/example-specs/task/nipype_internal/pydra-c3/c_3d_affine_tool.yaml
new file mode 100644
index 00000000..73a37301
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-c3/c_3d_affine_tool.yaml
@@ -0,0 +1,141 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.c3.C3dAffineTool' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Converts fsl-style Affine registration into ANTS compatible itk format
+# 
+#     Example
+#     =======
+# 
+#     >>> from nipype.interfaces.c3 import C3dAffineTool
+#     >>> c3 = C3dAffineTool()
+#     >>> c3.inputs.source_file = 'cmatrix.mat'
+#     >>> c3.inputs.itk_transform = 'affine.txt'
+#     >>> c3.inputs.fsl2ras = True
+#     >>> c3.cmdline
+#     'c3d_affine_tool -src cmatrix.mat -fsl2ras -oitk affine.txt'
+#     
+task_name: C3dAffineTool
+nipype_name: C3dAffineTool
+nipype_module: nipype.interfaces.c3
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    reference_file: generic/file
+    # type=file|default=<undefined>: 
+    source_file: datascience/text-matrix
+    # type=file|default=<undefined>: 
+    transform_file: generic/file
+    # type=file|default=<undefined>: 
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    itk_transform: text/text-file
+    # type=file: 
+    # type=traitcompound|default=None: Export ITK transform.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    reference_file:
+    # type=file|default=<undefined>: 
+    source_file:
+    # type=file|default=<undefined>: 
+    transform_file:
+    # type=file|default=<undefined>: 
+    itk_transform:
+    # type=file: 
+    # type=traitcompound|default=None: Export ITK transform.
+    fsl2ras:
+    # type=bool|default=False: 
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    source_file:
+    # type=file|default=<undefined>: 
+    itk_transform: '"affine.txt"'
+    # type=file: 
+    # type=traitcompound|default=None: Export ITK transform.
+    fsl2ras: 'True'
+    # type=bool|default=False: 
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: c3d_affine_tool -src cmatrix.mat -fsl2ras -oitk affine.txt
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    source_file:
+    # type=file|default=<undefined>: 
+    itk_transform: '"affine.txt"'
+    # type=file: 
+    # type=traitcompound|default=None: Export ITK transform.
+    fsl2ras: 'True'
+    # type=bool|default=False: 
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-c3/c_3d_affine_tool_callables.py b/example-specs/task/nipype_internal/pydra-c3/c_3d_affine_tool_callables.py
new file mode 100644
index 00000000..a1e0afa3
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-c3/c_3d_affine_tool_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in C3dAffineTool.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-c3/c_3d_callables.py b/example-specs/task/nipype_internal/pydra-c3/c_3d_callables.py
new file mode 100644
index 00000000..a71b7076
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-c3/c_3d_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in C3d.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-camino/analyze_header.yaml b/example-specs/task/nipype_internal/pydra-camino/analyze_header.yaml
new file mode 100644
index 00000000..d5feafcb
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-camino/analyze_header.yaml
@@ -0,0 +1,152 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.camino.convert.AnalyzeHeader' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Create or read an Analyze 7.5 header file.
+# 
+#     Analyze image header, provides support for the most common header fields.
+#     Some fields, such as patient_id, are not currently supported. The program allows
+#     three nonstandard options: the field image_dimension.funused1 is the image scale.
+#     The intensity of each pixel in the associated .img file is (image value from file) * scale.
+#     Also, the origin of the Talairach coordinates (midline of the anterior commisure) are encoded
+#     in the field data_history.originator. These changes are included for compatibility with SPM.
+# 
+#     All headers written with this program are big endian by default.
+# 
+#     Example
+#     -------
+# 
+#     >>> import nipype.interfaces.camino as cmon
+#     >>> hdr = cmon.AnalyzeHeader()
+#     >>> hdr.inputs.in_file = 'tensor_fitted_data.Bdouble'
+#     >>> hdr.inputs.scheme_file = 'A.scheme'
+#     >>> hdr.inputs.data_dims = [256,256,256]
+#     >>> hdr.inputs.voxel_dims = [1,1,1]
+#     >>> hdr.run()          # doctest: +SKIP
+#     
+task_name: AnalyzeHeader
+nipype_name: AnalyzeHeader
+nipype_module: nipype.interfaces.camino.convert
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: Tensor-fitted data filename
+    scheme_file: generic/file
+    # type=file|default=<undefined>: Camino scheme file (b values / vectors, see camino.fsl2scheme)
+    readheader: generic/file
+    # type=file|default=<undefined>: Reads header information from file and prints to stdout. If this option is not specified, then the program writes a header based on the other arguments.
+    printimagedims: generic/file
+    # type=file|default=<undefined>: Prints image data and voxel dimensions as Camino arguments and exits.
+    printprogargs: generic/file
+    # type=file|default=<undefined>: Prints data dimension (and type, if relevant) arguments for a specific Camino program, where prog is one of shredder, scanner2voxel, vcthreshselect, pdview, track.
+    printintelbyteorder: generic/file
+    # type=file|default=<undefined>: Prints 1 if the header is little-endian, 0 otherwise.
+    printbigendian: generic/file
+    # type=file|default=<undefined>: Prints 1 if the header is big-endian, 0 otherwise.
+    initfromheader: generic/file
+    # type=file|default=<undefined>: Reads header information from file and initializes a new header with the values read from the file. You may replace any combination of fields in the new header by specifying subsequent options.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    header: generic/file
+    # type=file: Analyze header
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: out_file
+    # type=file|default=<undefined>: 
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: Tensor-fitted data filename
+    scheme_file:
+    # type=file|default=<undefined>: Camino scheme file (b values / vectors, see camino.fsl2scheme)
+    readheader:
+    # type=file|default=<undefined>: Reads header information from file and prints to stdout. If this option is not specified, then the program writes a header based on the other arguments.
+    printimagedims:
+    # type=file|default=<undefined>: Prints image data and voxel dimensions as Camino arguments and exits.
+    printprogargs:
+    # type=file|default=<undefined>: Prints data dimension (and type, if relevant) arguments for a specific Camino program, where prog is one of shredder, scanner2voxel, vcthreshselect, pdview, track.
+    printintelbyteorder:
+    # type=file|default=<undefined>: Prints 1 if the header is little-endian, 0 otherwise.
+    printbigendian:
+    # type=file|default=<undefined>: Prints 1 if the header is big-endian, 0 otherwise.
+    initfromheader:
+    # type=file|default=<undefined>: Reads header information from file and initializes a new header with the values read from the file. You may replace any combination of fields in the new header by specifying subsequent options.
+    data_dims:
+    # type=list|default=[]: data dimensions in voxels
+    voxel_dims:
+    # type=list|default=[]: voxel dimensions in mm
+    centre:
+    # type=list|default=[]: Voxel specifying origin of Talairach coordinate system for SPM, default [0 0 0].
+    picoseed:
+    # type=list|default=[]: Voxel specifying the seed (for PICo maps), default [0 0 0].
+    nimages:
+    # type=int|default=0: Number of images in the img file. Default 1.
+    datatype:
+    # type=enum|default='byte'|allowed['[u]int','[u]short','byte','char','complex','double','float']: The char datatype is 8 bit (not the 16 bit char of Java), as specified by the Analyze 7.5 standard. The byte, ushort and uint types are not part of the Analyze specification but are supported by SPM.
+    offset:
+    # type=int|default=0: According to the Analyze 7.5 standard, this is the byte offset in the .img file at which voxels start. This value can be negative to specify that the absolute value is applied for every image in the file.
+    greylevels:
+    # type=list|default=[]: Minimum and maximum greylevels. Stored as shorts in the header.
+    scaleslope:
+    # type=float|default=0.0: Intensities in the image are scaled by this factor by SPM and MRICro. Default is 1.0.
+    scaleinter:
+    # type=float|default=0.0: Constant to add to the image intensities. Used by SPM and MRIcro.
+    description:
+    # type=string|default='': Short description - No spaces, max length 79 bytes. Will be null terminated automatically.
+    intelbyteorder:
+    # type=bool|default=False: Write header in intel byte order (little-endian).
+    networkbyteorder:
+    # type=bool|default=False: Write header in network byte order (big-endian). This is the default for new headers.
+    out_file:
+    # type=file|default=<undefined>: 
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-camino/analyze_header_callables.py b/example-specs/task/nipype_internal/pydra-camino/analyze_header_callables.py
new file mode 100644
index 00000000..439f1ddc
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-camino/analyze_header_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in AnalyzeHeader.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-camino/compute_eigensystem.yaml b/example-specs/task/nipype_internal/pydra-camino/compute_eigensystem.yaml
new file mode 100644
index 00000000..f66cf244
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-camino/compute_eigensystem.yaml
@@ -0,0 +1,102 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.camino.dti.ComputeEigensystem' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Computes the eigensystem from tensor fitted data.
+# 
+#     Reads diffusion tensor (single, two-tensor, three-tensor or multitensor) data from the
+#     standard input, computes the eigenvalues and eigenvectors of each tensor and outputs the
+#     results to the standard output. For multiple-tensor data the program outputs the
+#     eigensystem of each tensor. For each tensor the program outputs: {l_1, e_11, e_12, e_13,
+#     l_2, e_21, e_22, e_33, l_3, e_31, e_32, e_33}, where l_1 >= l_2 >= l_3 and e_i = (e_i1,
+#     e_i2, e_i3) is the eigenvector with eigenvalue l_i. For three-tensor data, for example,
+#     the output contains thirty-six values per voxel.
+# 
+#     Example
+#     -------
+# 
+#     >>> import nipype.interfaces.camino as cmon
+#     >>> dteig = cmon.ComputeEigensystem()
+#     >>> dteig.inputs.in_file = 'tensor_fitted_data.Bdouble'
+#     >>> dteig.run()          # doctest: +SKIP
+#     
+task_name: ComputeEigensystem
+nipype_name: ComputeEigensystem
+nipype_module: nipype.interfaces.camino.dti
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: Tensor-fitted data filename
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    eigen: generic/file
+    # type=file: Trace of the diffusion tensor
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: out_file
+    # type=file|default=<undefined>: 
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: Tensor-fitted data filename
+    inputmodel:
+    # type=enum|default='dt'|allowed['dt','multitensor']: Specifies the model that the input data contains parameters for
+    maxcomponents:
+    # type=int|default=0: The maximum number of tensor components in a voxel of the input data.
+    inputdatatype:
+    # type=enum|default='double'|allowed['char','double','float','int','long','short']: Specifies the data type of the input data. The data type can be any of the following strings: "char", "short", "int", "long", "float" or "double".Default is double data type
+    outputdatatype:
+    # type=enum|default='double'|allowed['char','double','float','int','long','short']: Specifies the data type of the output data.
+    out_file:
+    # type=file|default=<undefined>: 
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-camino/compute_eigensystem_callables.py b/example-specs/task/nipype_internal/pydra-camino/compute_eigensystem_callables.py
new file mode 100644
index 00000000..ec83a83e
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-camino/compute_eigensystem_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in ComputeEigensystem.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-camino/compute_fractional_anisotropy.yaml b/example-specs/task/nipype_internal/pydra-camino/compute_fractional_anisotropy.yaml
new file mode 100644
index 00000000..da2baec5
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-camino/compute_fractional_anisotropy.yaml
@@ -0,0 +1,103 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.camino.dti.ComputeFractionalAnisotropy' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Computes the fractional anisotropy of tensors.
+# 
+#     Reads diffusion tensor (single, two-tensor or three-tensor) data from the standard input,
+#     computes the fractional anisotropy (FA) of each tensor and outputs the results to the
+#     standard output. For multiple-tensor data the program outputs the FA of each tensor,
+#     so for three-tensor data, for example, the output contains three fractional anisotropy
+#     values per voxel.
+# 
+#     Example
+#     -------
+#     >>> import nipype.interfaces.camino as cmon
+#     >>> fa = cmon.ComputeFractionalAnisotropy()
+#     >>> fa.inputs.in_file = 'tensor_fitted_data.Bdouble'
+#     >>> fa.inputs.scheme_file = 'A.scheme'
+#     >>> fa.run()          # doctest: +SKIP
+# 
+#     
+task_name: ComputeFractionalAnisotropy
+nipype_name: ComputeFractionalAnisotropy
+nipype_module: nipype.interfaces.camino.dti
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: Tensor-fitted data filename
+    scheme_file: generic/file
+    # type=file|default=<undefined>: Camino scheme file (b values / vectors, see camino.fsl2scheme)
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    fa: generic/file
+    # type=file: Fractional Anisotropy Map
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: out_file
+    # type=file|default=<undefined>: 
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: Tensor-fitted data filename
+    scheme_file:
+    # type=file|default=<undefined>: Camino scheme file (b values / vectors, see camino.fsl2scheme)
+    inputmodel:
+    # type=enum|default='dt'|allowed['dt','multitensor','threetensor','twotensor']: Specifies the model that the input tensor data contains parameters for. By default, the program assumes that the input data contains a single diffusion tensor in each voxel.
+    inputdatatype:
+    # type=enum|default='char'|allowed['char','double','float','int','long','short']: Specifies the data type of the input file.
+    outputdatatype:
+    # type=enum|default='char'|allowed['char','double','float','int','long','short']: Specifies the data type of the output data.
+    out_file:
+    # type=file|default=<undefined>: 
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-camino/compute_fractional_anisotropy_callables.py b/example-specs/task/nipype_internal/pydra-camino/compute_fractional_anisotropy_callables.py
new file mode 100644
index 00000000..b8d6d506
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-camino/compute_fractional_anisotropy_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in ComputeFractionalAnisotropy.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-camino/compute_mean_diffusivity.yaml b/example-specs/task/nipype_internal/pydra-camino/compute_mean_diffusivity.yaml
new file mode 100644
index 00000000..5eb821aa
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-camino/compute_mean_diffusivity.yaml
@@ -0,0 +1,97 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.camino.dti.ComputeMeanDiffusivity' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Computes the mean diffusivity (trace/3) from diffusion tensors.
+# 
+#     Example
+#     -------
+#     >>> import nipype.interfaces.camino as cmon
+#     >>> md = cmon.ComputeMeanDiffusivity()
+#     >>> md.inputs.in_file = 'tensor_fitted_data.Bdouble'
+#     >>> md.inputs.scheme_file = 'A.scheme'
+#     >>> md.run()          # doctest: +SKIP
+# 
+#     
+task_name: ComputeMeanDiffusivity
+nipype_name: ComputeMeanDiffusivity
+nipype_module: nipype.interfaces.camino.dti
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: Tensor-fitted data filename
+    scheme_file: generic/file
+    # type=file|default=<undefined>: Camino scheme file (b values / vectors, see camino.fsl2scheme)
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    md: generic/file
+    # type=file: Mean Diffusivity Map
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: out_file
+    # type=file|default=<undefined>: 
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: Tensor-fitted data filename
+    scheme_file:
+    # type=file|default=<undefined>: Camino scheme file (b values / vectors, see camino.fsl2scheme)
+    out_file:
+    # type=file|default=<undefined>: 
+    inputmodel:
+    # type=enum|default='dt'|allowed['dt','threetensor','twotensor']: Specifies the model that the input tensor data contains parameters for. By default, the program assumes that the input data contains a single diffusion tensor in each voxel.
+    inputdatatype:
+    # type=enum|default='char'|allowed['char','double','float','int','long','short']: Specifies the data type of the input file.
+    outputdatatype:
+    # type=enum|default='char'|allowed['char','double','float','int','long','short']: Specifies the data type of the output data.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-camino/compute_mean_diffusivity_callables.py b/example-specs/task/nipype_internal/pydra-camino/compute_mean_diffusivity_callables.py
new file mode 100644
index 00000000..f665c8b8
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-camino/compute_mean_diffusivity_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in ComputeMeanDiffusivity.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-camino/compute_tensor_trace.yaml b/example-specs/task/nipype_internal/pydra-camino/compute_tensor_trace.yaml
new file mode 100644
index 00000000..ef481bc5
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-camino/compute_tensor_trace.yaml
@@ -0,0 +1,105 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.camino.dti.ComputeTensorTrace' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Computes the trace of tensors.
+# 
+#     Reads diffusion tensor (single, two-tensor or three-tensor) data from the standard input,
+#     computes the trace of each tensor, i.e., three times the mean diffusivity, and outputs
+#     the results to the standard output. For multiple-tensor data the program outputs the
+#     trace of each tensor, so for three-tensor data, for example, the output contains three
+#     values per voxel.
+# 
+#     Divide the output by three to get the mean diffusivity.
+# 
+#     Example
+#     -------
+#     >>> import nipype.interfaces.camino as cmon
+#     >>> trace = cmon.ComputeTensorTrace()
+#     >>> trace.inputs.in_file = 'tensor_fitted_data.Bdouble'
+#     >>> trace.inputs.scheme_file = 'A.scheme'
+#     >>> trace.run()         # doctest: +SKIP
+# 
+#     
+task_name: ComputeTensorTrace
+nipype_name: ComputeTensorTrace
+nipype_module: nipype.interfaces.camino.dti
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: Tensor-fitted data filename
+    scheme_file: generic/file
+    # type=file|default=<undefined>: Camino scheme file (b values / vectors, see camino.fsl2scheme)
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    trace: generic/file
+    # type=file: Trace of the diffusion tensor
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: out_file
+    # type=file|default=<undefined>: 
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: Tensor-fitted data filename
+    scheme_file:
+    # type=file|default=<undefined>: Camino scheme file (b values / vectors, see camino.fsl2scheme)
+    inputmodel:
+    # type=enum|default='dt'|allowed['dt','multitensor','threetensor','twotensor']: Specifies the model that the input tensor data contains parameters for. By default, the program assumes that the input data contains a single diffusion tensor in each voxel.
+    inputdatatype:
+    # type=enum|default='char'|allowed['char','double','float','int','long','short']: Specifies the data type of the input file.
+    outputdatatype:
+    # type=enum|default='char'|allowed['char','double','float','int','long','short']: Specifies the data type of the output data.
+    out_file:
+    # type=file|default=<undefined>: 
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-camino/compute_tensor_trace_callables.py b/example-specs/task/nipype_internal/pydra-camino/compute_tensor_trace_callables.py
new file mode 100644
index 00000000..a78642fe
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-camino/compute_tensor_trace_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in ComputeTensorTrace.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-camino/conmat.yaml b/example-specs/task/nipype_internal/pydra-camino/conmat.yaml
new file mode 100644
index 00000000..a9a0d27e
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-camino/conmat.yaml
@@ -0,0 +1,166 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.camino.connectivity.Conmat' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Creates  a  connectivity  matrix  using a 3D label image (the target image)
+#     and a set of streamlines. The connectivity matrix records how many stream-
+#     lines connect each pair of targets, and optionally the mean tractwise
+#     statistic (eg tract-averaged FA, or length).
+# 
+#     The output is a comma separated variable file or files. The first row of
+#     the output matrix is label names. Label names may be defined by the user,
+#     otherwise  they  are assigned based on label intensity.
+# 
+#     Starting  from the seed point, we move along the streamline until we find
+#     a point in a labeled region. This is done in both directions from the seed
+#     point. Streamlines are counted if they connect two target regions, one on
+#     either side of the seed point. Only the labeled region closest to the seed
+#     is counted, for example if the  input contains two streamlines: ::
+# 
+#          1: A-----B------SEED---C
+#          2: A--------SEED-----------
+# 
+#     then the output would be ::
+# 
+#          A,B,C
+#          0,0,0
+#          0,0,1
+#          0,1,0
+# 
+#     There  are  zero  connections  to A because in streamline 1, the connection
+#     to B is closer to the seed than the connection to A, and in streamline 2
+#     there is no region reached in the other direction.
+# 
+#     The connected target regions can have the same label, as long as the seed
+#     point is outside of the labeled region and both ends connect to the same
+#     label (which may  be in different locations). Therefore this is allowed: ::
+# 
+#          A------SEED-------A
+# 
+#     Such fibers will add to the diagonal elements of the matrix. To remove
+#     these entries, run procstreamlines with -endpointfile before running conmat.
+# 
+#     If the seed point is inside a labeled region, it counts as one end of the
+#     connection.  So ::
+# 
+#          ----[SEED inside A]---------B
+# 
+#     counts as a connection between A and B, while ::
+# 
+#          C----[SEED inside A]---------B
+# 
+#     counts as a connection between A and C, because C is closer to the seed point.
+# 
+#     In all cases, distance to the seed point is defined along the streamline path.
+# 
+#     Examples
+#     --------
+#     To create a standard connectivity matrix based on streamline counts.
+# 
+#     >>> import nipype.interfaces.camino as cam
+#     >>> conmat = cam.Conmat()
+#     >>> conmat.inputs.in_file = 'tracts.Bdouble'
+#     >>> conmat.inputs.target_file = 'atlas.nii.gz'
+#     >>> conmat.run()# doctest: +SKIP
+# 
+#     To create a standard connectivity matrix and mean tractwise FA statistics.
+# 
+#     >>> import nipype.interfaces.camino as cam
+#     >>> conmat = cam.Conmat()
+#     >>> conmat.inputs.in_file = 'tracts.Bdouble'
+#     >>> conmat.inputs.target_file = 'atlas.nii.gz'
+#     >>> conmat.inputs.scalar_file = 'fa.nii.gz'
+#     >>> conmat.tract_stat         = 'mean'
+#     >>> conmat.run()# doctest: +SKIP
+# 
+#     
+task_name: Conmat
+nipype_name: Conmat
+nipype_module: nipype.interfaces.camino.connectivity
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: Streamlines as generated by the Track interface
+    target_file: generic/file
+    # type=file|default=<undefined>: An image containing targets, as used in ProcStreamlines interface.
+    scalar_file: generic/file
+    # type=file|default=<undefined>: Optional scalar file for computing tract-based statistics. Must be in the same space as the target file.
+    targetname_file: generic/file
+    # type=file|default=<undefined>: Optional names of targets. This file should contain one entry per line, with the target intensity followed by the name, separated by white space. For example:   1  some_brain_region   2     some_other_region These names will be used in the output. The names themselves should not contain spaces or commas. The labels may be in any order but the output matrices will be ordered by label intensity.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    conmat_sc: generic/file
+    # type=file: Connectivity matrix in CSV file.
+    conmat_ts: generic/file
+    # type=file: Tract statistics in CSV file.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    output_root: output_root
+    # type=file|default=<undefined>: filename root prepended onto the names of the output files. The extension will be determined from the input.
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: Streamlines as generated by the Track interface
+    target_file:
+    # type=file|default=<undefined>: An image containing targets, as used in ProcStreamlines interface.
+    scalar_file:
+    # type=file|default=<undefined>: Optional scalar file for computing tract-based statistics. Must be in the same space as the target file.
+    targetname_file:
+    # type=file|default=<undefined>: Optional names of targets. This file should contain one entry per line, with the target intensity followed by the name, separated by white space. For example:   1  some_brain_region   2     some_other_region These names will be used in the output. The names themselves should not contain spaces or commas. The labels may be in any order but the output matrices will be ordered by label intensity.
+    tract_stat:
+    # type=enum|default='mean'|allowed['max','mean','median','min','sum','var']: Tract statistic to use. See TractStats for other options.
+    tract_prop:
+    # type=enum|default='length'|allowed['endpointsep','length']: Tract property average to compute in the connectivity matrix. See TractStats for details.
+    output_root:
+    # type=file|default=<undefined>: filename root prepended onto the names of the output files. The extension will be determined from the input.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-camino/conmat_callables.py b/example-specs/task/nipype_internal/pydra-camino/conmat_callables.py
new file mode 100644
index 00000000..377a4ac4
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-camino/conmat_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Conmat.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-camino/dt2n_if_ti.yaml b/example-specs/task/nipype_internal/pydra-camino/dt2n_if_ti.yaml
new file mode 100644
index 00000000..e7865ffa
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-camino/dt2n_if_ti.yaml
@@ -0,0 +1,88 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.camino.convert.DT2NIfTI' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Converts camino tensor data to NIfTI format
+# 
+#     Reads Camino diffusion tensors, and converts them to NIFTI format as three .nii files.
+#     
+task_name: DT2NIfTI
+nipype_name: DT2NIfTI
+nipype_module: nipype.interfaces.camino.convert
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: tract file
+    header_file: generic/file
+    # type=file|default=<undefined>:  A Nifti .nii or .hdr file containing the header information
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    dt: generic/file
+    # type=file: diffusion tensors in NIfTI format
+    exitcode: generic/file
+    # type=file: exit codes from Camino reconstruction in NIfTI format
+    lns0: generic/file
+    # type=file: estimated lns0 from Camino reconstruction in NIfTI format
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    output_root: output_root
+    # type=file|default=<undefined>: filename root prepended onto the names of three output files.
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: tract file
+    output_root:
+    # type=file|default=<undefined>: filename root prepended onto the names of three output files.
+    header_file:
+    # type=file|default=<undefined>:  A Nifti .nii or .hdr file containing the header information
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-camino/dt2n_if_ti_callables.py b/example-specs/task/nipype_internal/pydra-camino/dt2n_if_ti_callables.py
new file mode 100644
index 00000000..6e8b01b8
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-camino/dt2n_if_ti_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in DT2NIfTI.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-camino/dt_metric.yaml b/example-specs/task/nipype_internal/pydra-camino/dt_metric.yaml
new file mode 100644
index 00000000..fb59d552
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-camino/dt_metric.yaml
@@ -0,0 +1,120 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.camino.dti.DTMetric' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Computes tensor metric statistics based on the eigenvalues l1 >= l2 >= l3
+#     typically obtained from ComputeEigensystem.
+# 
+#     The full list of statistics is:
+# 
+#      - <cl> = (l1 - l2) / l1 , a measure of linearity
+#      - <cp> = (l2 - l3) / l1 , a measure of planarity
+#      - <cs> = l3 / l1 , a measure of isotropy
+#        with: cl + cp + cs = 1
+#      - <l1> = first eigenvalue
+#      - <l2> = second eigenvalue
+#      - <l3> = third eigenvalue
+#      - <tr> = l1 + l2 + l3
+#      - <md> = tr / 3
+#      - <rd> = (l2 + l3) / 2
+#      - <fa> = fractional anisotropy. (Basser et al, J Magn Reson B 1996)
+#      - <ra> = relative anisotropy (Basser et al, J Magn Reson B 1996)
+#      - <2dfa> = 2D FA of the two minor eigenvalues l2 and l3
+#        i.e. sqrt( 2 * [(l2 - <l>)^2 + (l3 - <l>)^2] / (l2^2 + l3^2) )
+#        with: <l> = (l2 + l3) / 2
+# 
+# 
+#     Example
+#     -------
+#     Compute the CP planar metric as float data type.
+# 
+#     >>> import nipype.interfaces.camino as cam
+#     >>> dtmetric = cam.DTMetric()
+#     >>> dtmetric.inputs.eigen_data = 'dteig.Bdouble'
+#     >>> dtmetric.inputs.metric = 'cp'
+#     >>> dtmetric.inputs.outputdatatype = 'float'
+#     >>> dtmetric.run()          # doctest: +SKIP
+# 
+#     
+task_name: DTMetric
+nipype_name: DTMetric
+nipype_module: nipype.interfaces.camino.dti
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    eigen_data: generic/file
+    # type=file|default=<undefined>: voxel-order data filename
+    data_header: generic/file
+    # type=file|default=<undefined>: A Nifti .nii or .nii.gz file containing the header information. Usually this will be the header of the raw data file from which the diffusion tensors were reconstructed.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    metric_stats: generic/file
+    # type=file: Diffusion Tensor statistics of the chosen metric
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    outputfile: outputfile
+    # type=file|default=<undefined>: Output name. Output will be a .nii.gz file if data_header is provided andin voxel order with outputdatatype datatype (default: double) otherwise.
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    eigen_data:
+    # type=file|default=<undefined>: voxel-order data filename
+    metric:
+    # type=enum|default='fa'|allowed['2dfa','cl','cp','cs','fa','l1','l2','l3','md','ra','rd','tr']: Specifies the metric to compute.
+    inputdatatype:
+    # type=enum|default='double'|allowed['char','double','float','int','long','short']: Specifies the data type of the input data.
+    outputdatatype:
+    # type=enum|default='double'|allowed['char','double','float','int','long','short']: Specifies the data type of the output data.
+    data_header:
+    # type=file|default=<undefined>: A Nifti .nii or .nii.gz file containing the header information. Usually this will be the header of the raw data file from which the diffusion tensors were reconstructed.
+    outputfile:
+    # type=file|default=<undefined>: Output name. Output will be a .nii.gz file if data_header is provided andin voxel order with outputdatatype datatype (default: double) otherwise.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-camino/dt_metric_callables.py b/example-specs/task/nipype_internal/pydra-camino/dt_metric_callables.py
new file mode 100644
index 00000000..49454cb2
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-camino/dt_metric_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in DTMetric.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-camino/dti_fit.yaml b/example-specs/task/nipype_internal/pydra-camino/dti_fit.yaml
new file mode 100644
index 00000000..40aa6ded
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-camino/dti_fit.yaml
@@ -0,0 +1,112 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.camino.dti.DTIFit' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Reads diffusion MRI data, acquired using the acquisition scheme detailed in the scheme file,
+#     from the data file.
+# 
+#     Use non-linear fitting instead of the default linear regression to the log measurements.
+#     The data file stores the diffusion MRI data in voxel order with the measurements stored
+#     in big-endian format and ordered as in the scheme file.
+#     The default input data type is four-byte float.
+#     The default output data type is eight-byte double.
+#     See modelfit and camino for the format of the data file and scheme file.
+#     The program fits the diffusion tensor to each voxel and outputs the results,
+#     in voxel order and as big-endian eight-byte doubles, to the standard output.
+#     The program outputs eight values in each voxel:
+#     [exit code, ln(S(0)), D_xx, D_xy, D_xz, D_yy, D_yz, D_zz].
+#     An exit code of zero indicates no problems.
+#     For a list of other exit codes, see modelfit(1).
+#     The entry S(0) is an estimate of the signal at q=0.
+# 
+#     Example
+#     -------
+#     >>> import nipype.interfaces.camino as cmon
+#     >>> fit = cmon.DTIFit()
+#     >>> fit.inputs.scheme_file = 'A.scheme'
+#     >>> fit.inputs.in_file = 'tensor_fitted_data.Bdouble'
+#     >>> fit.run()          # doctest: +SKIP
+# 
+#     
+task_name: DTIFit
+nipype_name: DTIFit
+nipype_module: nipype.interfaces.camino.dti
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: voxel-order data filename
+    bgmask: generic/file
+    # type=file|default=<undefined>: Provides the name of a file containing a background mask computed using, for example, FSL bet2 program. The mask file contains zero in background voxels and non-zero in foreground.
+    scheme_file: generic/file
+    # type=file|default=<undefined>: Camino scheme file (b values / vectors, see camino.fsl2scheme)
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    tensor_fitted: generic/file
+    # type=file: path/name of 4D volume in voxel order
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: out_file
+    # type=file|default=<undefined>: 
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: voxel-order data filename
+    bgmask:
+    # type=file|default=<undefined>: Provides the name of a file containing a background mask computed using, for example, FSL bet2 program. The mask file contains zero in background voxels and non-zero in foreground.
+    scheme_file:
+    # type=file|default=<undefined>: Camino scheme file (b values / vectors, see camino.fsl2scheme)
+    non_linear:
+    # type=bool|default=False: Use non-linear fitting instead of the default linear regression to the log measurements. 
+    out_file:
+    # type=file|default=<undefined>: 
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-camino/dti_fit_callables.py b/example-specs/task/nipype_internal/pydra-camino/dti_fit_callables.py
new file mode 100644
index 00000000..5d71e93e
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-camino/dti_fit_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in DTIFit.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-camino/dtlut_gen.yaml b/example-specs/task/nipype_internal/pydra-camino/dtlut_gen.yaml
new file mode 100644
index 00000000..85f8c91b
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-camino/dtlut_gen.yaml
@@ -0,0 +1,118 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.camino.dti.DTLUTGen' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Calibrates the PDFs for PICo probabilistic tractography.
+# 
+#     This program needs to be run once for every acquisition scheme.
+#     It outputs a lookup table that is used by the dtpicoparams program to find PICo PDF
+#     parameters for an image.
+#     The default single tensor LUT contains parameters of the Bingham distribution and is
+#     generated by supplying a scheme file and an estimated signal to noise in white matter
+#     regions of the (q=0) image.
+#     The default inversion is linear (inversion index 1).
+# 
+#     Advanced users can control several options, including the extent and resolution of the LUT,
+#     the inversion index, and the type of PDF. See dtlutgen(1) for details.
+# 
+#     Example
+#     -------
+#     >>> import nipype.interfaces.camino as cmon
+#     >>> dtl = cmon.DTLUTGen()
+#     >>> dtl.inputs.snr = 16
+#     >>> dtl.inputs.scheme_file = 'A.scheme'
+#     >>> dtl.run()          # doctest: +SKIP
+# 
+#     
+task_name: DTLUTGen
+nipype_name: DTLUTGen
+nipype_module: nipype.interfaces.camino.dti
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    scheme_file: generic/file
+    # type=file|default=<undefined>: The scheme file of the images to be processed using this LUT.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    dtLUT: generic/file
+    # type=file: Lookup Table
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: out_file
+    # type=file|default=<undefined>: 
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    lrange:
+    # type=list|default=[]: Index to one-tensor LUTs. This is the ratio L1/L3 and L2 / L3.The LUT is square, with half the values calculated (because L2 / L3 cannot be less than L1 / L3 by definition).The minimum must be >= 1. For comparison, a ratio L1 / L3 = 10 with L2 / L3 = 1 corresponds to an FA of 0.891, and L1 / L3 = 15 with L2 / L3 = 1 corresponds to an FA of 0.929. The default range is 1 to 10.
+    frange:
+    # type=list|default=[]: Index to two-tensor LUTs. This is the fractional anisotropy of the two tensors. The default is 0.3 to 0.94
+    step:
+    # type=float|default=0.0: Distance between points in the LUT.For example, if lrange is 1 to 10 and the step is 0.1, LUT entries will be computed at L1 / L3 = 1, 1.1, 1.2 ... 10.0 and at L2 / L3 = 1.0, 1.1 ... L1 / L3.For single tensor LUTs, the default step is 0.2, for two-tensor LUTs it is 0.02.
+    samples:
+    # type=int|default=0: The number of synthetic measurements to generate at each point in the LUT. The default is 2000.
+    snr:
+    # type=float|default=0.0: The signal to noise ratio of the unweighted (q = 0) measurements.This should match the SNR (in white matter) of the images that the LUTs are used with.
+    bingham:
+    # type=bool|default=False: Compute a LUT for the Bingham PDF. This is the default.
+    acg:
+    # type=bool|default=False: Compute a LUT for the ACG PDF.
+    watson:
+    # type=bool|default=False: Compute a LUT for the Watson PDF.
+    inversion:
+    # type=int|default=0: Index of the inversion to use. The default is 1 (linear single tensor inversion).
+    trace:
+    # type=float|default=0.0: Trace of the diffusion tensor(s) used in the test function in the LUT generation. The default is 2100E-12 m^2 s^-1.
+    scheme_file:
+    # type=file|default=<undefined>: The scheme file of the images to be processed using this LUT.
+    out_file:
+    # type=file|default=<undefined>: 
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-camino/dtlut_gen_callables.py b/example-specs/task/nipype_internal/pydra-camino/dtlut_gen_callables.py
new file mode 100644
index 00000000..287642b4
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-camino/dtlut_gen_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in DTLUTGen.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-camino/fsl2_scheme.yaml b/example-specs/task/nipype_internal/pydra-camino/fsl2_scheme.yaml
new file mode 100644
index 00000000..37111f86
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-camino/fsl2_scheme.yaml
@@ -0,0 +1,108 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.camino.convert.FSL2Scheme' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Converts b-vectors and b-values from FSL format to a Camino scheme file.
+# 
+#     Examples
+#     --------
+# 
+#     >>> import nipype.interfaces.camino as cmon
+#     >>> makescheme = cmon.FSL2Scheme()
+#     >>> makescheme.inputs.bvec_file = 'bvecs'
+#     >>> makescheme.inputs.bvec_file = 'bvals'
+#     >>> makescheme.run()          # doctest: +SKIP
+# 
+#     
+task_name: FSL2Scheme
+nipype_name: FSL2Scheme
+nipype_module: nipype.interfaces.camino.convert
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    bvec_file: generic/file
+    # type=file|default=<undefined>: b vector file
+    bval_file: generic/file
+    # type=file|default=<undefined>: b value file
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    scheme: generic/file
+    # type=file: Scheme file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: out_file
+    # type=file|default=<undefined>: 
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    bvec_file:
+    # type=file|default=<undefined>: b vector file
+    bval_file:
+    # type=file|default=<undefined>: b value file
+    numscans:
+    # type=int|default=0: Output all measurements numerous (n) times, used when combining multiple scans from the same imaging session.
+    interleave:
+    # type=bool|default=False: Interleave repeated scans. Only used with -numscans.
+    bscale:
+    # type=float|default=0.0: Scaling factor to convert the b-values into different units. Default is 10^6.
+    diffusiontime:
+    # type=float|default=0.0: Diffusion time
+    flipx:
+    # type=bool|default=False: Negate the x component of all the vectors.
+    flipy:
+    # type=bool|default=False: Negate the y component of all the vectors.
+    flipz:
+    # type=bool|default=False: Negate the z component of all the vectors.
+    usegradmod:
+    # type=bool|default=False: Use the gradient magnitude to scale b. This option has no effect if your gradient directions have unit magnitude.
+    out_file:
+    # type=file|default=<undefined>: 
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-camino/fsl2_scheme_callables.py b/example-specs/task/nipype_internal/pydra-camino/fsl2_scheme_callables.py
new file mode 100644
index 00000000..d2108215
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-camino/fsl2_scheme_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in FSL2Scheme.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-camino/image_2_voxel.yaml b/example-specs/task/nipype_internal/pydra-camino/image_2_voxel.yaml
new file mode 100644
index 00000000..51972352
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-camino/image_2_voxel.yaml
@@ -0,0 +1,92 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.camino.convert.Image2Voxel' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Converts Analyze / NIFTI / MHA files to voxel order.
+# 
+#     Converts scanner-order data in a supported image format to voxel-order data.
+#     Either takes a 4D file (all measurements in single image)
+#     or a list of 3D images.
+# 
+#     Examples
+#     --------
+# 
+#     >>> import nipype.interfaces.camino as cmon
+#     >>> img2vox = cmon.Image2Voxel()
+#     >>> img2vox.inputs.in_file = '4d_dwi.nii'
+#     >>> img2vox.run()          # doctest: +SKIP
+#     
+task_name: Image2Voxel
+nipype_name: Image2Voxel
+nipype_module: nipype.interfaces.camino.convert
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: 4d image file
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    voxel_order: generic/file
+    # type=file: path/name of 4D volume in voxel order
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: out_file
+    # type=file|default=<undefined>: 
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: 4d image file
+    out_type:
+    # type=enum|default='float'|allowed['char','double','float','int','long','short']: "i.e. Bfloat". Can be "char", "short", "int", "long", "float" or "double"
+    out_file:
+    # type=file|default=<undefined>: 
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-camino/image_2_voxel_callables.py b/example-specs/task/nipype_internal/pydra-camino/image_2_voxel_callables.py
new file mode 100644
index 00000000..9c194f09
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-camino/image_2_voxel_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Image2Voxel.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-camino/image_stats.yaml b/example-specs/task/nipype_internal/pydra-camino/image_stats.yaml
new file mode 100644
index 00000000..ee087531
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-camino/image_stats.yaml
@@ -0,0 +1,93 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.camino.utils.ImageStats' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     This program computes voxelwise statistics on a series of 3D images. The images
+#     must be in the same space; the operation is performed voxelwise and one output
+#     is produced per voxel.
+# 
+#     Examples
+#     --------
+# 
+#     >>> import nipype.interfaces.camino as cam
+#     >>> imstats = cam.ImageStats()
+#     >>> imstats.inputs.in_files = ['im1.nii','im2.nii','im3.nii']
+#     >>> imstats.inputs.stat = 'max'
+#     >>> imstats.run()          # doctest: +SKIP
+#     
+task_name: ImageStats
+nipype_name: ImageStats
+nipype_module: nipype.interfaces.camino.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_files: generic/file+list-of
+    # type=inputmultiobject|default=[]: List of images to process. They must be in the same space and have the same dimensions.
+    output_root: generic/file
+    # type=file|default=<undefined>: Filename root prepended onto the names of the output  files. The extension will be determined from the input.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: Path of the file computed with the statistic chosen
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_files:
+    # type=inputmultiobject|default=[]: List of images to process. They must be in the same space and have the same dimensions.
+    stat:
+    # type=enum|default='min'|allowed['max','mean','median','min','std','sum','var']: The statistic to compute.
+    out_type:
+    # type=enum|default='float'|allowed['char','double','float','int','long','short']: A Camino data type string, default is "float". Type must be signed.
+    output_root:
+    # type=file|default=<undefined>: Filename root prepended onto the names of the output  files. The extension will be determined from the input.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-camino/image_stats_callables.py b/example-specs/task/nipype_internal/pydra-camino/image_stats_callables.py
new file mode 100644
index 00000000..1a145967
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-camino/image_stats_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in ImageStats.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-camino/lin_recon.yaml b/example-specs/task/nipype_internal/pydra-camino/lin_recon.yaml
new file mode 100644
index 00000000..15ce28cc
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-camino/lin_recon.yaml
@@ -0,0 +1,134 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.camino.odf.LinRecon' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Runs a linear transformation in each voxel.
+# 
+#     Reads  a  linear  transformation from the matrix file assuming the
+#     imaging scheme specified in the scheme file. Performs the linear
+#     transformation on the data in every voxel and outputs the result to
+#     the standard output. The output in every voxel is actually: ::
+# 
+#         [exit code, ln(S(0)), p1, ..., pR]
+# 
+#     where p1, ..., pR are the parameters of the reconstruction.
+#     Possible exit codes are:
+# 
+#         - 0. No problems.
+#         - 6. Bad data replaced by substitution of zero.
+# 
+#     The matrix must be R by N+M where N+M is the number of measurements
+#     and R is the number of parameters of the reconstruction. The matrix
+#     file contains binary double-precision floats. The matrix elements
+#     are stored row by row.
+# 
+#     Example
+#     -------
+#     First run QBallMX and create a linear transform matrix using
+#     Spherical Harmonics (sh).
+# 
+#     >>> import nipype.interfaces.camino as cam
+#     >>> qballmx = cam.QBallMX()
+#     >>> qballmx.inputs.scheme_file = 'A.scheme'
+#     >>> qballmx.inputs.basistype = 'sh'
+#     >>> qballmx.inputs.order = 4
+#     >>> qballmx.run()    # doctest: +SKIP
+# 
+#     Then run it over each voxel using LinRecon
+# 
+#     >>> qballcoeffs = cam.LinRecon()
+#     >>> qballcoeffs.inputs.in_file = 'SubjectA.Bfloat'
+#     >>> qballcoeffs.inputs.scheme_file = 'A.scheme'
+#     >>> qballcoeffs.inputs.qball_mat = 'A_qmat.Bdouble'
+#     >>> qballcoeffs.inputs.normalize = True
+#     >>> qballcoeffs.run() # doctest: +SKIP
+# 
+#     
+task_name: LinRecon
+nipype_name: LinRecon
+nipype_module: nipype.interfaces.camino.odf
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: voxel-order data filename
+    scheme_file: generic/file
+    # type=file|default=<undefined>: Specifies the scheme file for the diffusion MRI data
+    qball_mat: generic/file
+    # type=file|default=<undefined>: Linear transformation matrix.
+    bgmask: generic/file
+    # type=file|default=<undefined>: background mask
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    recon_data: generic/file
+    # type=file: Transformed data
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: out_file
+    # type=file|default=<undefined>: 
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: voxel-order data filename
+    scheme_file:
+    # type=file|default=<undefined>: Specifies the scheme file for the diffusion MRI data
+    qball_mat:
+    # type=file|default=<undefined>: Linear transformation matrix.
+    normalize:
+    # type=bool|default=False: Normalize the measurements and discard the zero measurements before the linear transform.
+    log:
+    # type=bool|default=False: Transform the log measurements rather than the measurements themselves
+    bgmask:
+    # type=file|default=<undefined>: background mask
+    out_file:
+    # type=file|default=<undefined>: 
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-camino/lin_recon_callables.py b/example-specs/task/nipype_internal/pydra-camino/lin_recon_callables.py
new file mode 100644
index 00000000..e9bd573c
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-camino/lin_recon_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in LinRecon.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-camino/mesd.yaml b/example-specs/task/nipype_internal/pydra-camino/mesd.yaml
new file mode 100644
index 00000000..f87b74a4
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-camino/mesd.yaml
@@ -0,0 +1,170 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.camino.odf.MESD' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     MESD is a general program for maximum entropy spherical deconvolution.
+#     It also runs PASMRI, which is a special case of spherical deconvolution.
+#     The input data must be in voxel order.
+# 
+#     The format of the output in each voxel is:
+#     { exitcode, ln(A^star(0)), lambda_0, lambda_1, ..., lambda_N }
+# 
+#     The  exitcode  contains  the  results of three tests. The first test thresholds
+#     the maximum relative error between the numerical integrals computed at con-
+#     vergence and those computed using a larger test point set; if the error is
+#     greater than a threshold the exitcode is increased from zero to one as a
+#     warning; if it is greater than a larger threshold the exitcode is increased to
+#     two to suggest failure. The  second  test  thresholds  the predicted  error in
+#     numerical integrals computed using the test point set; if the predicted error
+#     is greater than a threshold the exitcode is increased by 10. The third test
+#     thresholds the RMS error between the measurements and their predictions from
+#     the fitted deconvolution; if the errors are greater than a threshold, the exit
+#     code is increased by 100. An exitcode of 112 means that all three tests were
+#     failed and the result is likely to be unreliable.  If all is well the exitcode
+#     is zero. Results are often still reliable even if one or two of the tests are
+#     failed.
+# 
+#     Other possible exitcodes are:
+# 
+#         - 5 - The optimization failed to converge
+#         - -1 - Background
+#         - -100 - Something wrong in the MRI data, e.g. negative or zero measurements,
+#           so that the optimization could not run.
+# 
+#     The  standard  MESD  implementation  is computationally demanding, particularly
+#     as the number of measurements increases (computation is approximately O(N^2),
+#     where N is the number of measurements). There are two ways to obtain significant
+#     computational speed-up:
+# 
+#     i) Turn off error checks and use a small point set for computing numerical
+#     integrals in the algorithm by adding the flag -fastmesd. Sakaie CDMRI 2008
+#     shows that using the smallest point set  (-basepointset  0)  with  no
+#     error  checks  usually  has only a minor effect on the output of the algorithm,
+#     but provides a major reduction in computation time. You can increase the point
+#     set size using -basepointset with an argument higher than 0, which may produce
+#     better results in some voxels, but will increase computation time, which
+#     approximately doubles every time the point set index increases by 1.
+# 
+#     ii) Reduce the complexity of the maximum entropy encoding using -mepointset <X>.
+#     By default <X> = N, the number of measurements, and is the number of parameters
+#     in the max.  ent. representation of the  output  function, ie  the  number of
+#     lambda parameters, as described in Jansons and Alexander Inverse Problems 2003.
+#     However, we can represent the function using less components and <X> here
+#     specifies the number of lambda parameters. To obtain speed-up, set <X>
+#     < N; complexity become O(<X>^2) rather than O(N^2). Note that <X> must be chosen
+#     so that the camino/PointSets directory contains a point set  with  that  number
+#     of  elements.  When  -mepointset decreases, the  numerical  integration checks
+#     make less and less of a difference and smaller point sets for numerical
+#     integration (see -basepointset) become adequate. So when <X> is low -fastmesd is
+#     worth using to get even more speed-up.
+# 
+#     The choice of <X> is a parameter of the technique. Too low and you lose angular
+#     resoloution; too high and you see no computational benefit and may even suffer
+#     from overfitting. Empirically, we  have  found  that  <X>=16 often  gives  good
+#     results and good speed up, but it is worth trying a few values a comparing
+#     performance. The reduced encoding is described in the following ISMRM abstract:
+#     Sweet and Alexander "Reduced Encoding Persistent Angular Structure" 572 ISMRM 2010.
+# 
+#     Example
+#     -------
+#     Run MESD on every voxel of the data file SubjectA.Bfloat using the PASMRI kernel.
+# 
+#     >>> import nipype.interfaces.camino as cam
+#     >>> mesd = cam.MESD()
+#     >>> mesd.inputs.in_file = 'SubjectA.Bfloat'
+#     >>> mesd.inputs.scheme_file = 'A.scheme'
+#     >>> mesd.inputs.inverter = 'PAS'
+#     >>> mesd.inputs.inverter_param = 1.4
+#     >>> mesd.run()    # doctest: +SKIP
+# 
+#     
+task_name: MESD
+nipype_name: MESD
+nipype_module: nipype.interfaces.camino.odf
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: voxel-order data filename
+    scheme_file: generic/file
+    # type=file|default=<undefined>: Specifies the scheme file for the diffusion MRI data
+    bgmask: generic/file
+    # type=file|default=<undefined>: background mask
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    mesd_data: generic/file
+    # type=file: MESD data
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: out_file
+    # type=file|default=<undefined>: 
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: voxel-order data filename
+    inverter:
+    # type=enum|default='SPIKE'|allowed['PAS','SPIKE']:  The inversion index specifies the type of inversion to perform on the data. The currently available choices are:    +----------------+---------------------------------------------+   | Inverter name  | Inverter parameters                         |   +================+=============================================+   | SPIKE          | bd (b-value x diffusivity along the fibre.) |   +----------------+---------------------------------------------+   | PAS            | r                                           |   +----------------+---------------------------------------------+  
+    inverter_param:
+    # type=float|default=0.0: Parameter associated with the inverter. Cf. inverter description formore information.
+    fastmesd:
+    # type=bool|default=False: Turns off numerical integration checks and fixes the integration point set size at that ofthe index specified by -basepointset..
+    mepointset:
+    # type=int|default=0: Use a set of directions other than those in the scheme file for the deconvolution kernel.The number refers to the number of directions on the unit sphere. For example, "-mepointset 54" uses the directions in "camino/PointSets/Elec054.txt".
+    scheme_file:
+    # type=file|default=<undefined>: Specifies the scheme file for the diffusion MRI data
+    bgmask:
+    # type=file|default=<undefined>: background mask
+    inputdatatype:
+    # type=enum|default='float'|allowed['char','double','float','int','long','short']: Specifies the data type of the input file: "char", "short", "int", "long","float" or "double". The input file must have BIG-ENDIAN ordering.By default, the input type is "float".
+    out_file:
+    # type=file|default=<undefined>: 
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-camino/mesd_callables.py b/example-specs/task/nipype_internal/pydra-camino/mesd_callables.py
new file mode 100644
index 00000000..7576051d
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-camino/mesd_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in MESD.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-camino/model_fit.yaml b/example-specs/task/nipype_internal/pydra-camino/model_fit.yaml
new file mode 100644
index 00000000..8e5de115
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-camino/model_fit.yaml
@@ -0,0 +1,134 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.camino.dti.ModelFit' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Fits models of the spin-displacement density to diffusion MRI measurements.
+# 
+#     This is an interface to various model fitting routines for diffusion MRI data that
+#     fit models of the spin-displacement density function. In particular, it will fit the
+#     diffusion tensor to a set of measurements as well as various other models including
+#     two or three-tensor models. The program can read input data from a file or can
+#     generate synthetic data using various test functions for testing and simulations.
+# 
+#     Example
+#     -------
+#     >>> import nipype.interfaces.camino as cmon
+#     >>> fit = cmon.ModelFit()
+#     >>> fit.model = 'dt'
+#     >>> fit.inputs.scheme_file = 'A.scheme'
+#     >>> fit.inputs.in_file = 'tensor_fitted_data.Bdouble'
+#     >>> fit.run()          # doctest: +SKIP
+# 
+#     
+task_name: ModelFit
+nipype_name: ModelFit
+nipype_module: nipype.interfaces.camino.dti
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: voxel-order data filename
+    scheme_file: generic/file
+    # type=file|default=<undefined>: Camino scheme file (b values / vectors, see camino.fsl2scheme)
+    outputfile: generic/file
+    # type=file|default=<undefined>: Filename of the output file.
+    outlier: generic/file
+    # type=file|default=<undefined>: Specifies the name of the file to contain the outlier map generated by the RESTORE algorithm.
+    noisemap: generic/file
+    # type=file|default=<undefined>: Specifies the name of the file to contain the estimated noise variance on the diffusion-weighted signal, generated by a weighted tensor fit. The data type of this file is big-endian double.
+    residualmap: generic/file
+    # type=file|default=<undefined>: Specifies the name of the file to contain the weighted residual errors after computing a weighted linear tensor fit. One value is produced per measurement, in voxel order. The data type of this file is big-endian double. Images of the residuals for each measurement can be extracted with shredder.
+    bgmask: generic/file
+    # type=file|default=<undefined>: Provides the name of a file containing a background mask computed using, for example, FSL's bet2 program. The mask file contains zero in background voxels and non-zero in foreground.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    fitted_data: generic/file
+    # type=file: output file of 4D volume in voxel order
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: out_file
+    # type=file|default=<undefined>: 
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    model:
+    # type=enum|default='dt'|allowed['adc','algdt','ball_stick','cylcyl adc','cylcyl algdt','cylcyl ball_stick','cylcyl dt','cylcyl ldt_wtd','cylcyl nldt','cylcyl nldt_pos','cylcyl restore','cylcyl_eq adc','cylcyl_eq algdt','cylcyl_eq ball_stick','cylcyl_eq dt','cylcyl_eq ldt_wtd','cylcyl_eq nldt','cylcyl_eq nldt_pos','cylcyl_eq restore','cylcylcyl adc','cylcylcyl algdt','cylcylcyl ball_stick','cylcylcyl dt','cylcylcyl ldt_wtd','cylcylcyl nldt','cylcylcyl nldt_pos','cylcylcyl restore','cylcylcyl_eq adc','cylcylcyl_eq algdt','cylcylcyl_eq ball_stick','cylcylcyl_eq dt','cylcylcyl_eq ldt_wtd','cylcylcyl_eq nldt','cylcylcyl_eq nldt_pos','cylcylcyl_eq restore','dt','ldt_wtd','nldt','nldt_pos','poscyl adc','poscyl algdt','poscyl ball_stick','poscyl dt','poscyl ldt_wtd','poscyl nldt','poscyl nldt_pos','poscyl restore','poscyl_eq adc','poscyl_eq algdt','poscyl_eq ball_stick','poscyl_eq dt','poscyl_eq ldt_wtd','poscyl_eq nldt','poscyl_eq nldt_pos','poscyl_eq restore','poscylcyl adc','poscylcyl algdt','poscylcyl ball_stick','poscylcyl dt','poscylcyl ldt_wtd','poscylcyl nldt','poscylcyl nldt_pos','poscylcyl restore','poscylcyl_eq adc','poscylcyl_eq algdt','poscylcyl_eq ball_stick','poscylcyl_eq dt','poscylcyl_eq ldt_wtd','poscylcyl_eq nldt','poscylcyl_eq nldt_pos','poscylcyl_eq restore','pospos adc','pospos algdt','pospos ball_stick','pospos dt','pospos ldt_wtd','pospos nldt','pospos nldt_pos','pospos restore','pospos_eq adc','pospos_eq algdt','pospos_eq ball_stick','pospos_eq dt','pospos_eq ldt_wtd','pospos_eq nldt','pospos_eq nldt_pos','pospos_eq restore','posposcyl adc','posposcyl algdt','posposcyl ball_stick','posposcyl dt','posposcyl ldt_wtd','posposcyl nldt','posposcyl nldt_pos','posposcyl restore','posposcyl_eq adc','posposcyl_eq algdt','posposcyl_eq ball_stick','posposcyl_eq dt','posposcyl_eq ldt_wtd','posposcyl_eq nldt','posposcyl_eq nldt_pos','posposcyl_eq restore','pospospos adc','pospospos algdt','pospospos ball_stick','pospospos dt','pospospos ldt_wtd','pospospos nldt','pospospos nldt_pos','pospospos restore','pospospos_eq adc','pospospos_eq algdt','pospospos_eq ball_stick','pospospos_eq dt','pospospos_eq ldt_wtd','pospospos_eq nldt','pospospos_eq nldt_pos','pospospos_eq restore','restore']: Specifies the model to be fit to the data.
+    in_file:
+    # type=file|default=<undefined>: voxel-order data filename
+    inputdatatype:
+    # type=enum|default='float'|allowed['char','double','float','int','long','short']: Specifies the data type of the input file. The input file must have BIG-ENDIAN ordering. By default, the input type is ``float``.
+    scheme_file:
+    # type=file|default=<undefined>: Camino scheme file (b values / vectors, see camino.fsl2scheme)
+    outputfile:
+    # type=file|default=<undefined>: Filename of the output file.
+    outlier:
+    # type=file|default=<undefined>: Specifies the name of the file to contain the outlier map generated by the RESTORE algorithm.
+    noisemap:
+    # type=file|default=<undefined>: Specifies the name of the file to contain the estimated noise variance on the diffusion-weighted signal, generated by a weighted tensor fit. The data type of this file is big-endian double.
+    residualmap:
+    # type=file|default=<undefined>: Specifies the name of the file to contain the weighted residual errors after computing a weighted linear tensor fit. One value is produced per measurement, in voxel order. The data type of this file is big-endian double. Images of the residuals for each measurement can be extracted with shredder.
+    sigma:
+    # type=float|default=0.0: Specifies the standard deviation of the noise in the data. Required by the RESTORE algorithm.
+    bgthresh:
+    # type=float|default=0.0: Sets a threshold on the average q=0 measurement to separate foreground and background. The program does not process background voxels, but outputs the same number of values in background voxels and foreground voxels. Each value is zero in background voxels apart from the exit code which is -1.
+    bgmask:
+    # type=file|default=<undefined>: Provides the name of a file containing a background mask computed using, for example, FSL's bet2 program. The mask file contains zero in background voxels and non-zero in foreground.
+    cfthresh:
+    # type=float|default=0.0: Sets a threshold on the average q=0 measurement to determine which voxels are CSF. This program does not treat CSF voxels any different to other voxels.
+    fixedmodq:
+    # type=list|default=[]: Specifies <M> <N> <Q> <tau> a spherical acquisition scheme with M measurements with q=0 and N measurements with :math:`|q|=Q` and diffusion time tau. The N measurements with :math:`|q|=Q` have unique directions. The program reads in the directions from the files in directory PointSets.
+    fixedbvalue:
+    # type=list|default=[]: As above, but specifies <M> <N> <b>. The resulting scheme is the same whether you specify b directly or indirectly using -fixedmodq.
+    tau:
+    # type=float|default=0.0: Sets the diffusion time separately. This overrides the diffusion time specified in a scheme file or by a scheme index for both the acquisition scheme and in the data synthesis.
+    out_file:
+    # type=file|default=<undefined>: 
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-camino/model_fit_callables.py b/example-specs/task/nipype_internal/pydra-camino/model_fit_callables.py
new file mode 100644
index 00000000..947d6446
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-camino/model_fit_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in ModelFit.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-camino/n_if_tidt2_camino.yaml b/example-specs/task/nipype_internal/pydra-camino/n_if_tidt2_camino.yaml
new file mode 100644
index 00000000..6d2cb784
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-camino/n_if_tidt2_camino.yaml
@@ -0,0 +1,116 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.camino.convert.NIfTIDT2Camino' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Converts NIFTI-1 diffusion tensors to Camino format. The program reads the
+#     NIFTI header but does not apply any spatial transformations to the data. The
+#     NIFTI intensity scaling parameters are applied.
+# 
+#     The output is the tensors in Camino voxel ordering: [exit, ln(S0), dxx, dxy,
+#     dxz, dyy, dyz, dzz].
+# 
+#     The exit code is set to 0 unless a background mask is supplied, in which case
+#     the code is 0 in brain voxels and -1 in background voxels.
+# 
+#     The value of ln(S0) in the output is taken from a file if one is supplied,
+#     otherwise it is set to 0.
+# 
+#     NOTE FOR FSL USERS - FSL's dtifit can output NIFTI tensors, but they are not
+#     stored in the usual way (which is using NIFTI_INTENT_SYMMATRIX). FSL's
+#     tensors follow the ITK / VTK "upper-triangular" convention, so you will need
+#     to use the -uppertriangular option to convert these correctly.
+# 
+#     
+task_name: NIfTIDT2Camino
+nipype_name: NIfTIDT2Camino
+nipype_module: nipype.interfaces.camino.convert
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: A NIFTI-1 dataset containing diffusion tensors. The tensors are assumed to be in lower-triangular order as specified by the NIFTI standard for the storage of symmetric matrices. This file should be either a .nii or a .hdr file.
+    s0_file: generic/file
+    # type=file|default=<undefined>: File containing the unweighted signal for each voxel, may be a raw binary file (specify type with -inputdatatype) or a supported image file.
+    lns0_file: generic/file
+    # type=file|default=<undefined>: File containing the log of the unweighted signal for each voxel, may be a raw binary file (specify type with -inputdatatype) or a supported image file.
+    bgmask: generic/file
+    # type=file|default=<undefined>: Binary valued brain / background segmentation, may be a raw binary file (specify type with -maskdatatype) or a supported image file.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: diffusion tensors data in Camino format
+    # type=file|default=<undefined>: 
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: out_file
+    # type=file: diffusion tensors data in Camino format
+    # type=file|default=<undefined>: 
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: A NIFTI-1 dataset containing diffusion tensors. The tensors are assumed to be in lower-triangular order as specified by the NIFTI standard for the storage of symmetric matrices. This file should be either a .nii or a .hdr file.
+    s0_file:
+    # type=file|default=<undefined>: File containing the unweighted signal for each voxel, may be a raw binary file (specify type with -inputdatatype) or a supported image file.
+    lns0_file:
+    # type=file|default=<undefined>: File containing the log of the unweighted signal for each voxel, may be a raw binary file (specify type with -inputdatatype) or a supported image file.
+    bgmask:
+    # type=file|default=<undefined>: Binary valued brain / background segmentation, may be a raw binary file (specify type with -maskdatatype) or a supported image file.
+    scaleslope:
+    # type=float|default=0.0: A value v in the diffusion tensor is scaled to v * s + i. This is applied after any scaling specified by the input image. Default is 1.0.
+    scaleinter:
+    # type=float|default=0.0: A value v in the diffusion tensor is scaled to v * s + i. This is applied after any scaling specified by the input image. Default is 0.0.
+    uppertriangular:
+    # type=bool|default=False: Specifies input in upper-triangular (VTK style) order.
+    out_file:
+    # type=file: diffusion tensors data in Camino format
+    # type=file|default=<undefined>: 
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-camino/n_if_tidt2_camino_callables.py b/example-specs/task/nipype_internal/pydra-camino/n_if_tidt2_camino_callables.py
new file mode 100644
index 00000000..891d1a1f
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-camino/n_if_tidt2_camino_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in NIfTIDT2Camino.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-camino/pico_pd_fs.yaml b/example-specs/task/nipype_internal/pydra-camino/pico_pd_fs.yaml
new file mode 100644
index 00000000..093d2b69
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-camino/pico_pd_fs.yaml
@@ -0,0 +1,102 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.camino.dti.PicoPDFs' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Constructs a spherical PDF in each voxel for probabilistic tractography.
+# 
+#     Example
+#     -------
+#     >>> import nipype.interfaces.camino as cmon
+#     >>> pdf = cmon.PicoPDFs()
+#     >>> pdf.inputs.inputmodel = 'dt'
+#     >>> pdf.inputs.luts = ['lut_file']
+#     >>> pdf.inputs.in_file = 'voxel-order_data.Bfloat'
+#     >>> pdf.run()          # doctest: +SKIP
+# 
+#     
+task_name: PicoPDFs
+nipype_name: PicoPDFs
+nipype_module: nipype.interfaces.camino.dti
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: voxel-order data filename
+    luts: generic/file+list-of
+    # type=inputmultiobject|default=[]: Files containing the lookup tables.For tensor data, one lut must be specified for each type of inversion used in the image (one-tensor, two-tensor, three-tensor).For pds, the number of LUTs must match -numpds (it is acceptable to use the same LUT several times - see example, above).These LUTs may be generated with dtlutgen.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    pdfs: generic/file
+    # type=file: path/name of 4D volume in voxel order
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: out_file
+    # type=file|default=<undefined>: 
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: voxel-order data filename
+    inputmodel:
+    # type=enum|default='dt'|allowed['dt','multitensor','pds']: input model type
+    luts:
+    # type=inputmultiobject|default=[]: Files containing the lookup tables.For tensor data, one lut must be specified for each type of inversion used in the image (one-tensor, two-tensor, three-tensor).For pds, the number of LUTs must match -numpds (it is acceptable to use the same LUT several times - see example, above).These LUTs may be generated with dtlutgen.
+    pdf:
+    # type=enum|default='bingham'|allowed['acg','bingham','watson']: Specifies the PDF to use. There are three choices:    * watson - The Watson distribution. This distribution is rotationally symmetric.   * bingham - The Bingham distributionn, which allows elliptical probability density contours.   * acg - The Angular Central Gaussian distribution, which also allows elliptical probability     density contours.  
+    directmap:
+    # type=bool|default=False: Only applicable when using pds as the inputmodel. Use direct mapping between the eigenvalues and the distribution parameters instead of the log of the eigenvalues.
+    maxcomponents:
+    # type=int|default=0: The maximum number of tensor components in a voxel (default 2) for multitensor data.Currently, only the default is supported, but future releases may allow the input of three-tensor data using this option.
+    numpds:
+    # type=int|default=0: The maximum number of PDs in a voxel (default 3) for PD data.This option determines the size of the input and output voxels.This means that the data file may be large enough to accommodate three or more PDs,but does not mean that any of the voxels are classified as containing three or more PDs.
+    out_file:
+    # type=file|default=<undefined>: 
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-camino/pico_pd_fs_callables.py b/example-specs/task/nipype_internal/pydra-camino/pico_pd_fs_callables.py
new file mode 100644
index 00000000..7301eea5
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-camino/pico_pd_fs_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in PicoPDFs.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-camino/proc_streamlines.yaml b/example-specs/task/nipype_internal/pydra-camino/proc_streamlines.yaml
new file mode 100644
index 00000000..576113b7
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-camino/proc_streamlines.yaml
@@ -0,0 +1,161 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.camino.convert.ProcStreamlines' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Process streamline data
+# 
+#     This program does post-processing of streamline output from track. It can either output streamlines or connection probability maps.
+#      * http://web4.cs.ucl.ac.uk/research/medic/camino/pmwiki/pmwiki.php?n=Man.procstreamlines
+# 
+#     Examples
+#     --------
+# 
+#     >>> import nipype.interfaces.camino as cmon
+#     >>> proc = cmon.ProcStreamlines()
+#     >>> proc.inputs.in_file = 'tract_data.Bfloat'
+#     >>> proc.run()          # doctest: +SKIP
+#     
+task_name: ProcStreamlines
+nipype_name: ProcStreamlines
+nipype_module: nipype.interfaces.camino.convert
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: data file
+    seedfile: generic/file
+    # type=file|default=<undefined>: Image Containing Seed Points
+    targetfile: generic/file
+    # type=file|default=<undefined>: Image containing target volumes.
+    waypointfile: generic/file
+    # type=file|default=<undefined>: Image containing waypoints. Waypoints are defined as regions of the image with the same intensity, where 0 is background and any value > 0 is a waypoint.
+    exclusionfile: generic/file
+    # type=file|default=<undefined>: Image containing exclusion ROIs. This should be an Analyze 7.5 header / image file.hdr and file.img.
+    endpointfile: generic/file
+    # type=file|default=<undefined>: Image containing endpoint ROIs. This should be an Analyze 7.5 header / image file.hdr and file.img.
+    outputroot: generic/file
+    # type=file|default=<undefined>: Prepended onto all output file names.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    proc: generic/file
+    # type=file: Processed Streamlines
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: out_file
+    # type=file|default=<undefined>: 
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputmodel:
+    # type=enum|default='raw'|allowed['raw','voxels']: input model type (raw or voxels)
+    in_file:
+    # type=file|default=<undefined>: data file
+    maxtractpoints:
+    # type=int|default=0: maximum number of tract points
+    mintractpoints:
+    # type=int|default=0: minimum number of tract points
+    maxtractlength:
+    # type=int|default=0: maximum length of tracts
+    mintractlength:
+    # type=int|default=0: minimum length of tracts
+    datadims:
+    # type=list|default=[]: data dimensions in voxels
+    voxeldims:
+    # type=list|default=[]: voxel dimensions in mm
+    seedpointmm:
+    # type=list|default=[]: The coordinates of a single seed point for tractography in mm
+    seedpointvox:
+    # type=list|default=[]: The coordinates of a single seed point for tractography in voxels
+    seedfile:
+    # type=file|default=<undefined>: Image Containing Seed Points
+    regionindex:
+    # type=int|default=0: index of specific region to process
+    iterations:
+    # type=float|default=0.0: Number of streamlines generated for each seed. Not required when outputting streamlines, but needed to create PICo images. The default is 1 if the output is streamlines, and 5000 if the output is connection probability images.
+    targetfile:
+    # type=file|default=<undefined>: Image containing target volumes.
+    allowmultitargets:
+    # type=bool|default=False: Allows streamlines to connect to multiple target volumes.
+    directional:
+    # type=list|default=[]: Splits the streamlines at the seed point and computes separate connection probabilities for each segment. Streamline segments are grouped according to their dot product with the vector (X, Y, Z). The ideal vector will be tangential to the streamline trajectory at the seed, such that the streamline projects from the seed along (X, Y, Z) and -(X, Y, Z). However, it is only necessary for the streamline trajectory to not be orthogonal to (X, Y, Z).
+    waypointfile:
+    # type=file|default=<undefined>: Image containing waypoints. Waypoints are defined as regions of the image with the same intensity, where 0 is background and any value > 0 is a waypoint.
+    truncateloops:
+    # type=bool|default=False: This option allows streamlines to enter a waypoint exactly once. After the streamline leaves the waypoint, it is truncated upon a second entry to the waypoint.
+    discardloops:
+    # type=bool|default=False: This option allows streamlines to enter a waypoint exactly once. After the streamline leaves the waypoint, the entire streamline is discarded upon a second entry to the waypoint.
+    exclusionfile:
+    # type=file|default=<undefined>: Image containing exclusion ROIs. This should be an Analyze 7.5 header / image file.hdr and file.img.
+    truncateinexclusion:
+    # type=bool|default=False: Retain segments of a streamline before entry to an exclusion ROI.
+    endpointfile:
+    # type=file|default=<undefined>: Image containing endpoint ROIs. This should be an Analyze 7.5 header / image file.hdr and file.img.
+    resamplestepsize:
+    # type=float|default=0.0: Each point on a streamline is tested for entry into target, exclusion or waypoint volumes. If the length between points on a tract is not much smaller than the voxel length, then streamlines may pass through part of a voxel without being counted. To avoid this, the program resamples streamlines such that the step size is one tenth of the smallest voxel dimension in the image. This increases the size of raw or oogl streamline output and incurs some performance penalty. The resample resolution can be controlled with this option or disabled altogether by passing a negative step size or by passing the -noresample option.
+    noresample:
+    # type=bool|default=False: Disables resampling of input streamlines. Resampling is automatically disabled if the input model is voxels.
+    outputtracts:
+    # type=bool|default=False: Output streamlines in raw binary format.
+    outputroot:
+    # type=file|default=<undefined>: Prepended onto all output file names.
+    gzip:
+    # type=bool|default=False: save the output image in gzip format
+    outputcp:
+    # type=bool|default=False: output the connection probability map (Analyze image, float)
+    outputsc:
+    # type=bool|default=False: output the connection probability map (raw streamlines, int)
+    outputacm:
+    # type=bool|default=False: output all tracts in a single connection probability map (Analyze image)
+    outputcbs:
+    # type=bool|default=False: outputs connectivity-based segmentation maps; requires target outputfile
+    out_file:
+    # type=file|default=<undefined>: 
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-camino/proc_streamlines_callables.py b/example-specs/task/nipype_internal/pydra-camino/proc_streamlines_callables.py
new file mode 100644
index 00000000..bbef8005
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-camino/proc_streamlines_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in ProcStreamlines.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-camino/q_ball_mx.yaml b/example-specs/task/nipype_internal/pydra-camino/q_ball_mx.yaml
new file mode 100644
index 00000000..d4ecd9c7
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-camino/q_ball_mx.yaml
@@ -0,0 +1,122 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.camino.odf.QBallMX' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Generates a reconstruction matrix for Q-Ball. Used in LinRecon with
+#     the same scheme file to reconstruct data.
+# 
+#     Examples
+#     --------
+#     To create  a linear transform matrix using Spherical Harmonics (sh).
+# 
+#     >>> import nipype.interfaces.camino as cam
+#     >>> qballmx = cam.QBallMX()
+#     >>> qballmx.inputs.scheme_file = 'A.scheme'
+#     >>> qballmx.inputs.basistype = 'sh'
+#     >>> qballmx.inputs.order = 6
+#     >>> qballmx.run()    # doctest: +SKIP
+# 
+#     To create  a linear transform matrix using Radial Basis Functions
+#     (rbf). This command uses the default setting of rbf sigma = 0.2618
+#     (15 degrees), data smoothing sigma = 0.1309 (7.5 degrees), rbf
+#     pointset 246
+# 
+#     >>> import nipype.interfaces.camino as cam
+#     >>> qballmx = cam.QBallMX()
+#     >>> qballmx.inputs.scheme_file = 'A.scheme'
+#     >>> qballmx.run()      # doctest: +SKIP
+# 
+#     The linear transform matrix from any of these two examples can then
+#     be run over each voxel using LinRecon
+# 
+#     >>> qballcoeffs = cam.LinRecon()
+#     >>> qballcoeffs.inputs.in_file = 'SubjectA.Bfloat'
+#     >>> qballcoeffs.inputs.scheme_file = 'A.scheme'
+#     >>> qballcoeffs.inputs.qball_mat = 'A_qmat.Bdouble'
+#     >>> qballcoeffs.inputs.normalize = True
+#     >>> qballcoeffs.inputs.bgmask = 'brain_mask.nii'
+#     >>> qballcoeffs.run()     # doctest: +SKIP
+# 
+#     
+task_name: QBallMX
+nipype_name: QBallMX
+nipype_module: nipype.interfaces.camino.odf
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    scheme_file: generic/file
+    # type=file|default=<undefined>: Specifies the scheme file for the diffusion MRI data
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    qmat: generic/file
+    # type=file: Q-Ball reconstruction matrix
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: out_file
+    # type=file|default=<undefined>: 
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    basistype:
+    # type=enum|default='rbf'|allowed['rbf','sh']: Basis function type. "rbf" to use radial basis functions "sh" to use spherical harmonics
+    scheme_file:
+    # type=file|default=<undefined>: Specifies the scheme file for the diffusion MRI data
+    order:
+    # type=int|default=0: Specific to sh. Maximum order of the spherical harmonic series. Default is 4.
+    rbfpointset:
+    # type=int|default=0: Specific to rbf. Sets the number of radial basis functions to use. The value specified must be present in the Pointsets directory. The default value is 246.
+    rbfsigma:
+    # type=float|default=0.0: Specific to rbf. Sets the width of the interpolating basis functions. The default value is 0.2618 (15 degrees).
+    smoothingsigma:
+    # type=float|default=0.0: Specific to rbf. Sets the width of the smoothing basis functions. The default value is 0.1309 (7.5 degrees).
+    out_file:
+    # type=file|default=<undefined>: 
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-camino/q_ball_mx_callables.py b/example-specs/task/nipype_internal/pydra-camino/q_ball_mx_callables.py
new file mode 100644
index 00000000..4431d606
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-camino/q_ball_mx_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in QBallMX.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-camino/sf_peaks.yaml b/example-specs/task/nipype_internal/pydra-camino/sf_peaks.yaml
new file mode 100644
index 00000000..41b43c74
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-camino/sf_peaks.yaml
@@ -0,0 +1,179 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.camino.odf.SFPeaks' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Finds the peaks of spherical functions.
+# 
+#     This utility reads coefficients of the spherical functions and
+#     outputs a list of peak directions of the function. It computes the
+#     value of the function at each of a set of sample points. Then it
+#     finds local maxima by finding all points at which the function is
+#     larger than for any other point within a fixed search radius (the
+#     default  is 0.4). The utility then uses Powell's algorithm to
+#     optimize the position of each local maximum. Finally the utility
+#     removes duplicates and tiny peaks with function value smaller than
+#     some threshold, which is the mean of the function plus some number
+#     of standard deviations. By default the program checks for con-
+#     sistency with a second set of starting points, but skips the
+#     optimization step. To speed up execution, you can turn off the con-
+#     sistency check by setting the noconsistencycheck flag to True.
+# 
+#     By  default, the utility constructs a set of sample points by
+#     randomly rotating a unit icosahedron repeatedly (the default is 1000
+#     times, which produces a set of 6000 points) and concatenating the
+#     lists of vertices. The 'pointset = <index>' attribute can tell the
+#     utility to use an evenly distributed set of points (index 0 gives
+#     1082 points, 1 gives 1922, 2 gives 4322, 3 gives 8672, 4 gives 15872,
+#     5 gives 32762, 6 gives 72032), which is quicker, because you can get
+#     away with fewer points. We estimate that you can use a factor of 2.5
+#     less evenly distributed points than randomly distributed points and
+#     still expect similar performance levels.
+# 
+#     The output for each voxel is:
+# 
+#     - exitcode (inherited from the input data).
+#     - ln(A(0))
+#     - number of peaks found.
+#     - flag for consistency with a repeated run (number of directions is
+#       the same and the directions are the same to within a threshold.)
+#     - mean(f).
+#     - std(f).
+#     - direction 1 (x, y, z, f, H00, H01, H10, H11).
+#     - direction 2 (x, y, z, f, H00, H01, H10, H11).
+#     - direction 3 (x, y, z, f, H00, H01, H10, H11).
+# 
+#     H is the Hessian of f at the peak. It is the matrix: ::
+# 
+#         [d^2f/ds^2 d^2f/dsdt]
+#         [d^2f/dtds d^2f/dt^2]
+#         = [H00 H01]
+#           [H10 H11]
+# 
+#     where s and t are orthogonal coordinates local to the peak.
+# 
+#     By default the maximum number of peak directions output in each
+#     voxel is three. If less than three directions are found, zeros are
+#     output for later directions. The peaks are ordered by the value of
+#     the function at the peak. If more than the maximum number of
+#     directions are found only the strongest ones are output. The maximum
+#     number can be changed setting the 'numpds' attribute.
+# 
+#     The utility can read various kinds of spherical function, but must
+#     be told what kind of function is input using the 'inputmodel'
+#     attribute. The description of the 'inputmodel' attribute lists
+#     additional information required by SFPeaks for each input model.
+# 
+# 
+#     Example
+#     -------
+#     First run QBallMX and create a linear transform matrix using
+#     Spherical Harmonics (sh).
+# 
+#     >>> import nipype.interfaces.camino as cam
+#     >>> sf_peaks = cam.SFPeaks()
+#     >>> sf_peaks.inputs.in_file = 'A_recon_params.Bdouble'
+#     >>> sf_peaks.inputs.inputmodel = 'sh'
+#     >>> sf_peaks.inputs.order = 4
+#     >>> sf_peaks.inputs.density = 100
+#     >>> sf_peaks.inputs.searchradius = 1.0
+#     >>> sf_peaks.run()  # doctest: +SKIP
+# 
+#     
+task_name: SFPeaks
+nipype_name: SFPeaks
+nipype_module: nipype.interfaces.camino.odf
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: Voxel-order data of spherical functions
+    scheme_file: generic/file
+    # type=file|default=<undefined>: Specific to maxent. Specifies the scheme file.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    peaks: generic/file
+    # type=file: Peaks of the spherical functions.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: out_file
+    # type=file|default=<undefined>: 
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: Voxel-order data of spherical functions
+    inputmodel:
+    # type=enum|default='sh'|allowed['maxent','rbf','sh']: Type of functions input via in_file. Currently supported options are:   sh - Spherical harmonic series. Specify the maximum order of the SH series        with the "order" attribute if different from the default of 4.   maxent - Maximum entropy representations output by MESD. The reconstruction            directions input to MESD must be specified. By default this is the            same set of gradient directions (excluding zero gradients) in the            scheme file, so specify the "schemefile" attribute unless the            "mepointset" attribute was set in MESD.   rbf - Sums of radial basis functions. Specify the pointset with the attribute         "rbfpointset" if different from the default. See QBallMX.
+    order:
+    # type=int|default=0: Specific to sh. Maximum order of the spherical harmonic series.
+    scheme_file:
+    # type=file|default=<undefined>: Specific to maxent. Specifies the scheme file.
+    rbfpointset:
+    # type=int|default=0: Specific to rbf. Sets the number of radial basis functions to use. The value specified must be present in the Pointsets directory. The default value is 246.
+    mepointset:
+    # type=int|default=0: Use a set of directions other than those in the scheme file for the deconvolution kernel. The number refers to the number of directions on the unit sphere. For example, "mepointset = 54" uses the directions in "camino/PointSets/Elec054.txt" Use this option only if you told MESD to use a custom set of directions with the same option. Otherwise, specify the scheme file with the "schemefile" attribute.
+    numpds:
+    # type=int|default=0: The largest number of peak directions to output in each voxel.
+    noconsistencycheck:
+    # type=bool|default=False: Turns off the consistency check. The output shows all consistencies as true.
+    searchradius:
+    # type=float|default=0.0: The search radius in the peak finding algorithm. The default is 0.4 (cf. "density")
+    density:
+    # type=int|default=0: The  number  of  randomly  rotated icosahedra to use in constructing the set of points for random sampling in the peak finding algorithm. Default is 1000, which works well for very spiky maxent functions. For other types of function, it is reasonable to set the density much lower and increase the search radius slightly, which speeds up the computation.
+    pointset:
+    # type=int|default=0: To sample using an evenly distributed set of points instead. The integer can be 0, 1, ..., 7. Index 0 gives 1082 points, 1 gives 1922, 2 gives 3002, 3 gives 4322, 4 gives 5882, 5 gives 8672, 6 gives 12002, 7 gives 15872.
+    pdthresh:
+    # type=float|default=0.0: Base threshold on the actual peak direction strength divided by the mean of the function.  The default is 1.0 (the peak must be equal or greater than the mean).
+    stdsfrommean:
+    # type=float|default=0.0: This is the number of standard deviations of the function to be added to the "pdthresh" attribute in the peak directions pruning.
+    out_file:
+    # type=file|default=<undefined>: 
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-camino/sf_peaks_callables.py b/example-specs/task/nipype_internal/pydra-camino/sf_peaks_callables.py
new file mode 100644
index 00000000..2f5fffd0
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-camino/sf_peaks_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in SFPeaks.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-camino/sflut_gen.yaml b/example-specs/task/nipype_internal/pydra-camino/sflut_gen.yaml
new file mode 100644
index 00000000..b81c7d72
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-camino/sflut_gen.yaml
@@ -0,0 +1,141 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.camino.calib.SFLUTGen' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Generates PICo lookup tables (LUT) for multi-fibre methods such as
+#     PASMRI and Q-Ball.
+# 
+#     SFLUTGen creates the lookup tables for the generalized multi-fibre
+#     implementation of the PICo tractography algorithm.  The outputs of
+#     this utility are either surface or line coefficients up to a given
+#     order. The calibration can be performed for different distributions,
+#     such as the Bingham and Watson distributions.
+# 
+#     This utility uses calibration data generated from SFPICOCalibData
+#     and peak information created by SFPeaks.
+# 
+#     The utility outputs two lut's, ``*_oneFibreSurfaceCoeffs.Bdouble`` and
+#     ``*_twoFibreSurfaceCoeffs.Bdouble``. Each of these files contains big-endian doubles
+#     as standard. The format of the output is::
+# 
+#           dimensions    (1 for Watson, 2 for Bingham)
+#           order         (the order of the polynomial)
+#           coefficient_1
+#           coefficient_2
+#           ...
+#           coefficient_N
+# 
+#     In  the case of the Watson, there is a single set of coefficients,
+#     which are ordered::
+# 
+#           constant, x, x^2, ..., x^order.
+# 
+#     In the case of the Bingham, there are two sets of coefficients (one
+#     for each surface), ordered so that::
+# 
+#           for j = 1 to order
+#             for k = 1 to order
+#               coeff_i = x^j * y^k
+#           where j+k < order
+# 
+#     Example
+#     -------
+#     To create a calibration dataset using the default settings
+# 
+#     >>> import nipype.interfaces.camino as cam
+#     >>> lutgen = cam.SFLUTGen()
+#     >>> lutgen.inputs.in_file = 'QSH_peaks.Bdouble'
+#     >>> lutgen.inputs.info_file = 'PICO_calib.info'
+#     >>> lutgen.run()# doctest: +SKIP
+# 
+#     
+task_name: SFLUTGen
+nipype_name: SFLUTGen
+nipype_module: nipype.interfaces.camino.calib
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: Voxel-order data of the spherical functions peaks.
+    info_file: generic/file
+    # type=file|default=<undefined>: The Info file that corresponds to the calibration datafile used in the reconstruction.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    lut_one_fibre: generic/file
+    # type=file: PICo lut for one-fibre model
+    lut_two_fibres: generic/file
+    # type=file: PICo lut for two-fibre model
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: out_file
+    # type=file|default=<undefined>: 
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: Voxel-order data of the spherical functions peaks.
+    info_file:
+    # type=file|default=<undefined>: The Info file that corresponds to the calibration datafile used in the reconstruction.
+    outputstem:
+    # type=str|default='LUT': Define the name of the generated luts.  The form of the filenames will be [outputstem]_oneFibreSurfaceCoeffs.Bdouble and [outputstem]_twoFibreSurfaceCoeffs.Bdouble
+    pdf:
+    # type=enum|default='bingham'|allowed['bingham','watson']: Sets the distribution to use for the calibration. The default is the Bingham distribution, which allows elliptical probability density contours. Currently supported options are:    * bingham -- The Bingham distribution, which allows elliptical probability     density contours.   * watson -- The Watson distribution. This distribution is rotationally symmetric.  
+    binincsize:
+    # type=int|default=0: Sets the size of the bins.  In the case of 2D histograms such as the Bingham, the bins are always square. Default is 1.
+    minvectsperbin:
+    # type=int|default=0: Specifies the minimum number of fibre-orientation estimates a bin must contain before it is used in the lut line/surface generation. Default is 50. If you get the error "no fibre-orientation estimates in histogram!", the calibration data set is too small to get enough samples in any of the  histogram  bins. You can decrease the minimum number  per  bin to get things running in quick tests, but the sta- tistics will not be reliable and for serious applications, you need  to increase the size of the calibration data set until the error goes.
+    directmap:
+    # type=bool|default=False: Use direct mapping between the eigenvalues and the distribution parameters instead of the log of the eigenvalues.
+    order:
+    # type=int|default=0: The order of the polynomial fitting the surface. Order 1 is linear. Order 2 (default) is quadratic.
+    out_file:
+    # type=file|default=<undefined>: 
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-camino/sflut_gen_callables.py b/example-specs/task/nipype_internal/pydra-camino/sflut_gen_callables.py
new file mode 100644
index 00000000..44c44e70
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-camino/sflut_gen_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in SFLUTGen.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-camino/sfpico_calib_data.yaml b/example-specs/task/nipype_internal/pydra-camino/sfpico_calib_data.yaml
new file mode 100644
index 00000000..68f0a938
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-camino/sfpico_calib_data.yaml
@@ -0,0 +1,153 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.camino.calib.SFPICOCalibData' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Generates Spherical Function PICo Calibration Data.
+# 
+#     SFPICOCalibData creates synthetic data for use with SFLUTGen. The
+#     synthetic data is generated using a mixture of gaussians, in the
+#     same way datasynth generates data.  Each voxel of data models a
+#     slightly different fibre configuration (varying FA and fibre-
+#     crossings) and undergoes a random rotation to help account for any
+#     directional bias in the chosen acquisition scheme.  A second file,
+#     which stores information about the datafile, is generated along with
+#     the datafile.
+# 
+#     Examples
+#     --------
+#     To create a calibration dataset using the default settings
+# 
+#     >>> import nipype.interfaces.camino as cam
+#     >>> calib = cam.SFPICOCalibData()
+#     >>> calib.inputs.scheme_file = 'A.scheme'
+#     >>> calib.inputs.snr = 20
+#     >>> calib.inputs.info_file = 'PICO_calib.info'
+#     >>> calib.run()   # doctest: +SKIP
+# 
+#     The default settings create a large dataset (249,231 voxels), of
+#     which 3401 voxels contain a single fibre population per voxel and
+#     the rest of the voxels contain two fibre-populations. The amount of
+#     data produced can be varied by specifying the ranges and steps of
+#     the parameters for both the one and two fibre datasets used.
+# 
+#     To create a custom calibration dataset
+# 
+#     >>> import nipype.interfaces.camino as cam
+#     >>> calib = cam.SFPICOCalibData()
+#     >>> calib.inputs.scheme_file = 'A.scheme'
+#     >>> calib.inputs.snr = 20
+#     >>> calib.inputs.info_file = 'PICO_calib.info'
+#     >>> calib.inputs.twodtfarange = [0.3, 0.9]
+#     >>> calib.inputs.twodtfastep = 0.02
+#     >>> calib.inputs.twodtanglerange = [0, 0.785]
+#     >>> calib.inputs.twodtanglestep = 0.03925
+#     >>> calib.inputs.twodtmixmax = 0.8
+#     >>> calib.inputs.twodtmixstep = 0.1
+#     >>> calib.run()      # doctest: +SKIP
+# 
+#     This would provide 76,313 voxels of synthetic data, where 3401 voxels
+#     simulate the one fibre cases and 72,912 voxels simulate the various
+#     two fibre cases. However, care should be taken to ensure that enough
+#     data is generated for calculating the LUT.      # doctest: +SKIP
+# 
+#     
+task_name: SFPICOCalibData
+nipype_name: SFPICOCalibData
+nipype_module: nipype.interfaces.camino.calib
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    scheme_file: generic/file
+    # type=file|default=<undefined>: Specifies the scheme file for the diffusion MRI data
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    PICOCalib: generic/file
+    # type=file: Calibration dataset
+    calib_info: generic/file
+    # type=file: Calibration dataset
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    info_file: info_file
+    # type=file|default=<undefined>: The name to be given to the information output filename.
+    out_file: out_file
+    # type=file|default=<undefined>: 
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    snr:
+    # type=float|default=0.0: Specifies  the  signal-to-noise ratio of the non-diffusion-weighted measurements to use in simulations.
+    scheme_file:
+    # type=file|default=<undefined>: Specifies the scheme file for the diffusion MRI data
+    info_file:
+    # type=file|default=<undefined>: The name to be given to the information output filename.
+    trace:
+    # type=float|default=0.0: Trace of the diffusion tensor(s) used in the test function.
+    onedtfarange:
+    # type=list|default=[]: Minimum and maximum FA for the single tensor synthetic data.
+    onedtfastep:
+    # type=float|default=0.0: FA step size controlling how many steps there are between the minimum and maximum FA settings.
+    twodtfarange:
+    # type=list|default=[]: Minimum and maximum FA for the two tensor synthetic data. FA is varied for both tensors to give all the different permutations.
+    twodtfastep:
+    # type=float|default=0.0: FA step size controlling how many steps there are between the minimum and maximum FA settings for the two tensor cases.
+    twodtanglerange:
+    # type=list|default=[]: Minimum and maximum crossing angles between the two fibres.
+    twodtanglestep:
+    # type=float|default=0.0: Angle step size controlling how many steps there are between the minimum and maximum crossing angles for the two tensor cases.
+    twodtmixmax:
+    # type=float|default=0.0: Mixing parameter controlling the proportion of one fibre population to the other. The minimum mixing parameter is (1 - twodtmixmax).
+    twodtmixstep:
+    # type=float|default=0.0: Mixing parameter step size for the two tensor cases. Specify how many mixing parameter increments to use.
+    seed:
+    # type=float|default=0.0: Specifies the random seed to use for noise generation in simulation trials.
+    out_file:
+    # type=file|default=<undefined>: 
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-camino/sfpico_calib_data_callables.py b/example-specs/task/nipype_internal/pydra-camino/sfpico_calib_data_callables.py
new file mode 100644
index 00000000..43f7521c
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-camino/sfpico_calib_data_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in SFPICOCalibData.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-camino/shredder.yaml b/example-specs/task/nipype_internal/pydra-camino/shredder.yaml
new file mode 100644
index 00000000..2a451810
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-camino/shredder.yaml
@@ -0,0 +1,103 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.camino.convert.Shredder' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Extracts periodic chunks from a data stream.
+# 
+#     Shredder makes an initial offset of offset bytes. It then reads and outputs
+#     chunksize bytes, skips space bytes, and repeats until there is no more input.
+# 
+#     If  the  chunksize  is  negative, chunks of size chunksize are read and the
+#     byte ordering of each chunk is reversed. The whole chunk will be reversed, so
+#     the chunk must be the same size as the data type, otherwise the order of the
+#     values in the chunk, as well as their endianness, will be reversed.
+# 
+#     Examples
+#     --------
+# 
+#     >>> import nipype.interfaces.camino as cam
+#     >>> shred = cam.Shredder()
+#     >>> shred.inputs.in_file = 'SubjectA.Bfloat'
+#     >>> shred.inputs.offset = 0
+#     >>> shred.inputs.chunksize = 1
+#     >>> shred.inputs.space = 2
+#     >>> shred.run()          # doctest: +SKIP
+#     
+task_name: Shredder
+nipype_name: Shredder
+nipype_module: nipype.interfaces.camino.convert
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: raw binary data file
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    shredded: generic/file
+    # type=file: Shredded binary data file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: out_file
+    # type=file|default=<undefined>: 
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: raw binary data file
+    offset:
+    # type=int|default=0: initial offset of offset bytes
+    chunksize:
+    # type=int|default=0: reads and outputs a chunk of chunksize bytes
+    space:
+    # type=int|default=0: skips space bytes
+    out_file:
+    # type=file|default=<undefined>: 
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-camino/shredder_callables.py b/example-specs/task/nipype_internal/pydra-camino/shredder_callables.py
new file mode 100644
index 00000000..2d577c7a
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-camino/shredder_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Shredder.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-camino/track.yaml b/example-specs/task/nipype_internal/pydra-camino/track.yaml
new file mode 100644
index 00000000..8c76890f
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-camino/track.yaml
@@ -0,0 +1,131 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.camino.dti.Track' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Performs tractography using one of the following models:
+#     dt', 'multitensor', 'pds', 'pico', 'bootstrap', 'ballstick', 'bayesdirac'
+# 
+#     Example
+#     -------
+#     >>> import nipype.interfaces.camino as cmon
+#     >>> track = cmon.Track()
+#     >>> track.inputs.inputmodel = 'dt'
+#     >>> track.inputs.in_file = 'data.Bfloat'
+#     >>> track.inputs.seed_file = 'seed_mask.nii'
+#     >>> track.run()          # doctest: +SKIP
+# 
+#     
+task_name: Track
+nipype_name: Track
+nipype_module: nipype.interfaces.camino.dti
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: input data file
+    seed_file: generic/file
+    # type=file|default=<undefined>: seed file
+    anisfile: generic/file
+    # type=file|default=<undefined>: File containing the anisotropy map. This is required to apply an anisotropy threshold with non tensor data. If the map issupplied it is always used, even in tensor data.
+    output_root: generic/file
+    # type=file|default=<undefined>: root directory for output
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    tracked: generic/file
+    # type=file: output file containing reconstructed tracts
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: out_file
+    # type=file|default=<undefined>: output data file
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input data file
+    seed_file:
+    # type=file|default=<undefined>: seed file
+    inputmodel:
+    # type=enum|default='dt'|allowed['ballstick','bayesdirac','bayesdirac_dt','bedpostx','bedpostx_dyad','dt','multitensor','pico','repbs_dt','repbs_multitensor','sfpeak','wildbs_dt']: input model type
+    tracker:
+    # type=enum|default='fact'|allowed['euler','fact','rk4']: The tracking algorithm controls streamlines are generated from the data. The choices are: - FACT, which follows the local fibre orientation in each voxel. No interpolation is used.- EULER, which uses a fixed step size along the local fibre orientation. With nearest-neighbour interpolation, this method may be very similar to FACT, except that the step size is fixed, whereas FACT steps extend to the boundary of the next voxel (distance variable depending on the entry and exit points to the voxel).- RK4: Fourth-order Runge-Kutta method. The step size is fixed, however the eventual direction of the step is determined by taking and averaging a series of partial steps.
+    interpolator:
+    # type=enum|default='nn'|allowed['linear','nn','prob_nn']: The interpolation algorithm determines how the fiber orientation(s) are defined at a given continuous point within the input image. Interpolators are only used when the tracking algorithm is not FACT. The choices are: - NN: Nearest-neighbour interpolation, just uses the local voxel data directly.- PROB_NN: Probabilistic nearest-neighbor interpolation,  similar  to the method pro- posed by Behrens et al [Magnetic Resonance in Medicine, 50:1077-1088, 2003]. The data is not interpolated, but at each point we randomly choose one of the 8 voxels sur- rounding a point. The probability of choosing a particular voxel is based on how close the point is to the centre of that voxel.- LINEAR: Linear interpolation of the vector field containing the principal directions at each point.
+    stepsize:
+    # type=float|default=0.0: Step size for EULER and RK4 tracking. The default is 1mm.
+    inputdatatype:
+    # type=enum|default='float'|allowed['double','float']: input file type
+    gzip:
+    # type=bool|default=False: save the output image in gzip format
+    maxcomponents:
+    # type=int|default=0: The maximum number of tensor components in a voxel. This determines the size of the input file and does not say anything about the voxel classification. The default is 2 if the input model is multitensor and 1 if the input model is dt.
+    numpds:
+    # type=int|default=0: The maximum number of PDs in a voxel for input models sfpeak and pico. The default is 3 for input model sfpeak and 1 for input model pico. This option determines the size of the voxels in the input file and does not affect tracking. For tensor data, use the -maxcomponents option.
+    data_dims:
+    # type=list|default=[]: data dimensions in voxels
+    voxel_dims:
+    # type=list|default=[]: voxel dimensions in mm
+    ipthresh:
+    # type=float|default=0.0: Curvature threshold for tracking, expressed as the minimum dot product between two streamline orientations calculated over the length of a voxel. If the dot product between the previous and current directions is less than this threshold, then the streamline terminates. The default setting will terminate fibres that curve by more than 80 degrees. Set this to -1.0 to disable curvature checking completely.
+    curvethresh:
+    # type=float|default=0.0: Curvature threshold for tracking, expressed as the maximum angle (in degrees) between between two streamline orientations calculated over the length of a voxel. If the angle is greater than this, then the streamline terminates.
+    curveinterval:
+    # type=float|default=0.0: Interval over which the curvature threshold should be evaluated, in mm. The default is 5mm. When using the default curvature threshold of 90 degrees, this means that streamlines will terminate if they curve by more than  90  degrees over a path length of 5mm.
+    anisthresh:
+    # type=float|default=0.0: Terminate fibres that enter a voxel with lower anisotropy than the threshold.
+    anisfile:
+    # type=file|default=<undefined>: File containing the anisotropy map. This is required to apply an anisotropy threshold with non tensor data. If the map issupplied it is always used, even in tensor data.
+    outputtracts:
+    # type=enum|default='float'|allowed['double','float','oogl']: output tract file type
+    out_file:
+    # type=file|default=<undefined>: output data file
+    output_root:
+    # type=file|default=<undefined>: root directory for output
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-camino/track_ball_stick.yaml b/example-specs/task/nipype_internal/pydra-camino/track_ball_stick.yaml
new file mode 100644
index 00000000..d81a109e
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-camino/track_ball_stick.yaml
@@ -0,0 +1,129 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.camino.dti.TrackBallStick' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Performs streamline tractography using ball-stick fitted data
+# 
+#     Example
+#     -------
+#     >>> import nipype.interfaces.camino as cmon
+#     >>> track = cmon.TrackBallStick()
+#     >>> track.inputs.in_file = 'ballstickfit_data.Bfloat'
+#     >>> track.inputs.seed_file = 'seed_mask.nii'
+#     >>> track.run()          # doctest: +SKIP
+# 
+#     
+task_name: TrackBallStick
+nipype_name: TrackBallStick
+nipype_module: nipype.interfaces.camino.dti
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: input data file
+    seed_file: generic/file
+    # type=file|default=<undefined>: seed file
+    anisfile: generic/file
+    # type=file|default=<undefined>: File containing the anisotropy map. This is required to apply an anisotropy threshold with non tensor data. If the map issupplied it is always used, even in tensor data.
+    output_root: generic/file
+    # type=file|default=<undefined>: root directory for output
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    tracked: generic/file
+    # type=file: output file containing reconstructed tracts
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: out_file
+    # type=file|default=<undefined>: output data file
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input data file
+    seed_file:
+    # type=file|default=<undefined>: seed file
+    inputmodel:
+    # type=enum|default='dt'|allowed['ballstick','bayesdirac','bayesdirac_dt','bedpostx','bedpostx_dyad','dt','multitensor','pico','repbs_dt','repbs_multitensor','sfpeak','wildbs_dt']: input model type
+    tracker:
+    # type=enum|default='fact'|allowed['euler','fact','rk4']: The tracking algorithm controls streamlines are generated from the data. The choices are: - FACT, which follows the local fibre orientation in each voxel. No interpolation is used.- EULER, which uses a fixed step size along the local fibre orientation. With nearest-neighbour interpolation, this method may be very similar to FACT, except that the step size is fixed, whereas FACT steps extend to the boundary of the next voxel (distance variable depending on the entry and exit points to the voxel).- RK4: Fourth-order Runge-Kutta method. The step size is fixed, however the eventual direction of the step is determined by taking and averaging a series of partial steps.
+    interpolator:
+    # type=enum|default='nn'|allowed['linear','nn','prob_nn']: The interpolation algorithm determines how the fiber orientation(s) are defined at a given continuous point within the input image. Interpolators are only used when the tracking algorithm is not FACT. The choices are: - NN: Nearest-neighbour interpolation, just uses the local voxel data directly.- PROB_NN: Probabilistic nearest-neighbor interpolation,  similar  to the method pro- posed by Behrens et al [Magnetic Resonance in Medicine, 50:1077-1088, 2003]. The data is not interpolated, but at each point we randomly choose one of the 8 voxels sur- rounding a point. The probability of choosing a particular voxel is based on how close the point is to the centre of that voxel.- LINEAR: Linear interpolation of the vector field containing the principal directions at each point.
+    stepsize:
+    # type=float|default=0.0: Step size for EULER and RK4 tracking. The default is 1mm.
+    inputdatatype:
+    # type=enum|default='float'|allowed['double','float']: input file type
+    gzip:
+    # type=bool|default=False: save the output image in gzip format
+    maxcomponents:
+    # type=int|default=0: The maximum number of tensor components in a voxel. This determines the size of the input file and does not say anything about the voxel classification. The default is 2 if the input model is multitensor and 1 if the input model is dt.
+    numpds:
+    # type=int|default=0: The maximum number of PDs in a voxel for input models sfpeak and pico. The default is 3 for input model sfpeak and 1 for input model pico. This option determines the size of the voxels in the input file and does not affect tracking. For tensor data, use the -maxcomponents option.
+    data_dims:
+    # type=list|default=[]: data dimensions in voxels
+    voxel_dims:
+    # type=list|default=[]: voxel dimensions in mm
+    ipthresh:
+    # type=float|default=0.0: Curvature threshold for tracking, expressed as the minimum dot product between two streamline orientations calculated over the length of a voxel. If the dot product between the previous and current directions is less than this threshold, then the streamline terminates. The default setting will terminate fibres that curve by more than 80 degrees. Set this to -1.0 to disable curvature checking completely.
+    curvethresh:
+    # type=float|default=0.0: Curvature threshold for tracking, expressed as the maximum angle (in degrees) between between two streamline orientations calculated over the length of a voxel. If the angle is greater than this, then the streamline terminates.
+    curveinterval:
+    # type=float|default=0.0: Interval over which the curvature threshold should be evaluated, in mm. The default is 5mm. When using the default curvature threshold of 90 degrees, this means that streamlines will terminate if they curve by more than  90  degrees over a path length of 5mm.
+    anisthresh:
+    # type=float|default=0.0: Terminate fibres that enter a voxel with lower anisotropy than the threshold.
+    anisfile:
+    # type=file|default=<undefined>: File containing the anisotropy map. This is required to apply an anisotropy threshold with non tensor data. If the map issupplied it is always used, even in tensor data.
+    outputtracts:
+    # type=enum|default='float'|allowed['double','float','oogl']: output tract file type
+    out_file:
+    # type=file|default=<undefined>: output data file
+    output_root:
+    # type=file|default=<undefined>: root directory for output
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-camino/track_ball_stick_callables.py b/example-specs/task/nipype_internal/pydra-camino/track_ball_stick_callables.py
new file mode 100644
index 00000000..64677eb1
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-camino/track_ball_stick_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in TrackBallStick.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-camino/track_bayes_dirac.yaml b/example-specs/task/nipype_internal/pydra-camino/track_bayes_dirac.yaml
new file mode 100644
index 00000000..21be5bc6
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-camino/track_bayes_dirac.yaml
@@ -0,0 +1,153 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.camino.dti.TrackBayesDirac' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Perform streamline tractography using a Bayesian tracking with Dirac priors.
+# 
+#     Example
+#     -------
+# 
+#     >>> import nipype.interfaces.camino as cmon
+#     >>> track = cmon.TrackBayesDirac()
+#     >>> track.inputs.in_file = 'tensor_fitted_data.Bdouble'
+#     >>> track.inputs.seed_file = 'seed_mask.nii'
+#     >>> track.inputs.scheme_file = 'bvecs.scheme'
+#     >>> track.run()          # doctest: +SKIP
+# 
+#     
+task_name: TrackBayesDirac
+nipype_name: TrackBayesDirac
+nipype_module: nipype.interfaces.camino.dti
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    scheme_file: generic/file
+    # type=file|default=<undefined>: The scheme file corresponding to the data being processed.
+    extpriorfile: generic/file
+    # type=file|default=<undefined>: Path to a PICo image produced by picopdfs. The PDF in each voxel is used as a prior for the fibre orientation in Bayesian tracking. The prior image must be in the same space as the diffusion data.
+    in_file: generic/file
+    # type=file|default=<undefined>: input data file
+    seed_file: generic/file
+    # type=file|default=<undefined>: seed file
+    anisfile: generic/file
+    # type=file|default=<undefined>: File containing the anisotropy map. This is required to apply an anisotropy threshold with non tensor data. If the map issupplied it is always used, even in tensor data.
+    output_root: generic/file
+    # type=file|default=<undefined>: root directory for output
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    tracked: generic/file
+    # type=file: output file containing reconstructed tracts
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: out_file
+    # type=file|default=<undefined>: output data file
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    scheme_file:
+    # type=file|default=<undefined>: The scheme file corresponding to the data being processed.
+    iterations:
+    # type=int|default=0: Number of streamlines to generate at each seed point. The default is 5000.
+    pdf:
+    # type=enum|default='bingham'|allowed['acg','bingham','watson']: Specifies the model for PICo priors (not the curvature priors). The default is 'bingham'.
+    pointset:
+    # type=int|default=0: Index to the point set to use for Bayesian likelihood calculation. The index specifies a set of evenly distributed points on the unit sphere, where each point x defines two possible step directions (x or -x) for the streamline path. A larger number indexes a larger point set, which gives higher angular resolution at the expense of computation time. The default is index 1, which gives 1922 points, index 0 gives 1082 points, index 2 gives 3002 points.
+    datamodel:
+    # type=enum|default='cylsymmdt'|allowed['ballstick','cylsymmdt']: Model of the data for Bayesian tracking. The default model is "cylsymmdt", a diffusion tensor with cylindrical symmetry about e_1, ie L1 >= L_2 = L_3. The other model is "ballstick", the partial volume model (see ballstickfit).
+    curvepriork:
+    # type=float|default=0.0: Concentration parameter for the prior distribution on fibre orientations given the fibre orientation at the previous step. Larger values of k make curvature less likely.
+    curvepriorg:
+    # type=float|default=0.0: Concentration parameter for the prior distribution on fibre orientations given the fibre orientation at the previous step. Larger values of g make curvature less likely.
+    extpriorfile:
+    # type=file|default=<undefined>: Path to a PICo image produced by picopdfs. The PDF in each voxel is used as a prior for the fibre orientation in Bayesian tracking. The prior image must be in the same space as the diffusion data.
+    extpriordatatype:
+    # type=enum|default='float'|allowed['double','float']: Datatype of the prior image. The default is "double".
+    in_file:
+    # type=file|default=<undefined>: input data file
+    seed_file:
+    # type=file|default=<undefined>: seed file
+    inputmodel:
+    # type=enum|default='dt'|allowed['ballstick','bayesdirac','bayesdirac_dt','bedpostx','bedpostx_dyad','dt','multitensor','pico','repbs_dt','repbs_multitensor','sfpeak','wildbs_dt']: input model type
+    tracker:
+    # type=enum|default='fact'|allowed['euler','fact','rk4']: The tracking algorithm controls streamlines are generated from the data. The choices are: - FACT, which follows the local fibre orientation in each voxel. No interpolation is used.- EULER, which uses a fixed step size along the local fibre orientation. With nearest-neighbour interpolation, this method may be very similar to FACT, except that the step size is fixed, whereas FACT steps extend to the boundary of the next voxel (distance variable depending on the entry and exit points to the voxel).- RK4: Fourth-order Runge-Kutta method. The step size is fixed, however the eventual direction of the step is determined by taking and averaging a series of partial steps.
+    interpolator:
+    # type=enum|default='nn'|allowed['linear','nn','prob_nn']: The interpolation algorithm determines how the fiber orientation(s) are defined at a given continuous point within the input image. Interpolators are only used when the tracking algorithm is not FACT. The choices are: - NN: Nearest-neighbour interpolation, just uses the local voxel data directly.- PROB_NN: Probabilistic nearest-neighbor interpolation,  similar  to the method pro- posed by Behrens et al [Magnetic Resonance in Medicine, 50:1077-1088, 2003]. The data is not interpolated, but at each point we randomly choose one of the 8 voxels sur- rounding a point. The probability of choosing a particular voxel is based on how close the point is to the centre of that voxel.- LINEAR: Linear interpolation of the vector field containing the principal directions at each point.
+    stepsize:
+    # type=float|default=0.0: Step size for EULER and RK4 tracking. The default is 1mm.
+    inputdatatype:
+    # type=enum|default='float'|allowed['double','float']: input file type
+    gzip:
+    # type=bool|default=False: save the output image in gzip format
+    maxcomponents:
+    # type=int|default=0: The maximum number of tensor components in a voxel. This determines the size of the input file and does not say anything about the voxel classification. The default is 2 if the input model is multitensor and 1 if the input model is dt.
+    numpds:
+    # type=int|default=0: The maximum number of PDs in a voxel for input models sfpeak and pico. The default is 3 for input model sfpeak and 1 for input model pico. This option determines the size of the voxels in the input file and does not affect tracking. For tensor data, use the -maxcomponents option.
+    data_dims:
+    # type=list|default=[]: data dimensions in voxels
+    voxel_dims:
+    # type=list|default=[]: voxel dimensions in mm
+    ipthresh:
+    # type=float|default=0.0: Curvature threshold for tracking, expressed as the minimum dot product between two streamline orientations calculated over the length of a voxel. If the dot product between the previous and current directions is less than this threshold, then the streamline terminates. The default setting will terminate fibres that curve by more than 80 degrees. Set this to -1.0 to disable curvature checking completely.
+    curvethresh:
+    # type=float|default=0.0: Curvature threshold for tracking, expressed as the maximum angle (in degrees) between between two streamline orientations calculated over the length of a voxel. If the angle is greater than this, then the streamline terminates.
+    curveinterval:
+    # type=float|default=0.0: Interval over which the curvature threshold should be evaluated, in mm. The default is 5mm. When using the default curvature threshold of 90 degrees, this means that streamlines will terminate if they curve by more than  90  degrees over a path length of 5mm.
+    anisthresh:
+    # type=float|default=0.0: Terminate fibres that enter a voxel with lower anisotropy than the threshold.
+    anisfile:
+    # type=file|default=<undefined>: File containing the anisotropy map. This is required to apply an anisotropy threshold with non tensor data. If the map issupplied it is always used, even in tensor data.
+    outputtracts:
+    # type=enum|default='float'|allowed['double','float','oogl']: output tract file type
+    out_file:
+    # type=file|default=<undefined>: output data file
+    output_root:
+    # type=file|default=<undefined>: root directory for output
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-camino/track_bayes_dirac_callables.py b/example-specs/task/nipype_internal/pydra-camino/track_bayes_dirac_callables.py
new file mode 100644
index 00000000..da1da4b9
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-camino/track_bayes_dirac_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in TrackBayesDirac.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-camino/track_bedpostx_deter.yaml b/example-specs/task/nipype_internal/pydra-camino/track_bedpostx_deter.yaml
new file mode 100644
index 00000000..8650d1df
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-camino/track_bedpostx_deter.yaml
@@ -0,0 +1,145 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.camino.dti.TrackBedpostxDeter' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Data from FSL's bedpostx can be imported into Camino for deterministic tracking.
+#     (Use TrackBedpostxProba for bedpostx probabilistic tractography.)
+# 
+#     The tracking is based on the vector images dyads1.nii.gz, ... , dyadsN.nii.gz,
+#     where there are a maximum of N compartments (corresponding to each fiber
+#     population) in each voxel.
+# 
+#     It also uses the N images mean_f1samples.nii.gz, ..., mean_fNsamples.nii.gz,
+#     normalized such that the sum of all compartments is 1. Compartments where the
+#     mean_f is less than a threshold are discarded and not used for tracking.
+#     The default value is 0.01. This can be changed with the min_vol_frac option.
+# 
+#     Example
+#     -------
+#     >>> import nipype.interfaces.camino as cam
+#     >>> track = cam.TrackBedpostxDeter()
+#     >>> track.inputs.bedpostxdir = 'bedpostxout'
+#     >>> track.inputs.seed_file = 'seed_mask.nii'
+#     >>> track.run()          # doctest: +SKIP
+# 
+#     
+task_name: TrackBedpostxDeter
+nipype_name: TrackBedpostxDeter
+nipype_module: nipype.interfaces.camino.dti
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: input data file
+    seed_file: generic/file
+    # type=file|default=<undefined>: seed file
+    anisfile: generic/file
+    # type=file|default=<undefined>: File containing the anisotropy map. This is required to apply an anisotropy threshold with non tensor data. If the map issupplied it is always used, even in tensor data.
+    output_root: generic/file
+    # type=file|default=<undefined>: root directory for output
+    bedpostxdir: generic/directory
+    # type=directory|default=<undefined>: Directory containing bedpostx output
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    tracked: generic/file
+    # type=file: output file containing reconstructed tracts
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: out_file
+    # type=file|default=<undefined>: output data file
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    bedpostxdir:
+    # type=directory|default=<undefined>: Directory containing bedpostx output
+    min_vol_frac:
+    # type=float|default=0.0: Zeros out compartments in bedpostx data with a mean volume fraction f of less than min_vol_frac.  The default is 0.01.
+    in_file:
+    # type=file|default=<undefined>: input data file
+    seed_file:
+    # type=file|default=<undefined>: seed file
+    inputmodel:
+    # type=enum|default='dt'|allowed['ballstick','bayesdirac','bayesdirac_dt','bedpostx','bedpostx_dyad','dt','multitensor','pico','repbs_dt','repbs_multitensor','sfpeak','wildbs_dt']: input model type
+    tracker:
+    # type=enum|default='fact'|allowed['euler','fact','rk4']: The tracking algorithm controls streamlines are generated from the data. The choices are: - FACT, which follows the local fibre orientation in each voxel. No interpolation is used.- EULER, which uses a fixed step size along the local fibre orientation. With nearest-neighbour interpolation, this method may be very similar to FACT, except that the step size is fixed, whereas FACT steps extend to the boundary of the next voxel (distance variable depending on the entry and exit points to the voxel).- RK4: Fourth-order Runge-Kutta method. The step size is fixed, however the eventual direction of the step is determined by taking and averaging a series of partial steps.
+    interpolator:
+    # type=enum|default='nn'|allowed['linear','nn','prob_nn']: The interpolation algorithm determines how the fiber orientation(s) are defined at a given continuous point within the input image. Interpolators are only used when the tracking algorithm is not FACT. The choices are: - NN: Nearest-neighbour interpolation, just uses the local voxel data directly.- PROB_NN: Probabilistic nearest-neighbor interpolation,  similar  to the method pro- posed by Behrens et al [Magnetic Resonance in Medicine, 50:1077-1088, 2003]. The data is not interpolated, but at each point we randomly choose one of the 8 voxels sur- rounding a point. The probability of choosing a particular voxel is based on how close the point is to the centre of that voxel.- LINEAR: Linear interpolation of the vector field containing the principal directions at each point.
+    stepsize:
+    # type=float|default=0.0: Step size for EULER and RK4 tracking. The default is 1mm.
+    inputdatatype:
+    # type=enum|default='float'|allowed['double','float']: input file type
+    gzip:
+    # type=bool|default=False: save the output image in gzip format
+    maxcomponents:
+    # type=int|default=0: The maximum number of tensor components in a voxel. This determines the size of the input file and does not say anything about the voxel classification. The default is 2 if the input model is multitensor and 1 if the input model is dt.
+    numpds:
+    # type=int|default=0: The maximum number of PDs in a voxel for input models sfpeak and pico. The default is 3 for input model sfpeak and 1 for input model pico. This option determines the size of the voxels in the input file and does not affect tracking. For tensor data, use the -maxcomponents option.
+    data_dims:
+    # type=list|default=[]: data dimensions in voxels
+    voxel_dims:
+    # type=list|default=[]: voxel dimensions in mm
+    ipthresh:
+    # type=float|default=0.0: Curvature threshold for tracking, expressed as the minimum dot product between two streamline orientations calculated over the length of a voxel. If the dot product between the previous and current directions is less than this threshold, then the streamline terminates. The default setting will terminate fibres that curve by more than 80 degrees. Set this to -1.0 to disable curvature checking completely.
+    curvethresh:
+    # type=float|default=0.0: Curvature threshold for tracking, expressed as the maximum angle (in degrees) between between two streamline orientations calculated over the length of a voxel. If the angle is greater than this, then the streamline terminates.
+    curveinterval:
+    # type=float|default=0.0: Interval over which the curvature threshold should be evaluated, in mm. The default is 5mm. When using the default curvature threshold of 90 degrees, this means that streamlines will terminate if they curve by more than  90  degrees over a path length of 5mm.
+    anisthresh:
+    # type=float|default=0.0: Terminate fibres that enter a voxel with lower anisotropy than the threshold.
+    anisfile:
+    # type=file|default=<undefined>: File containing the anisotropy map. This is required to apply an anisotropy threshold with non tensor data. If the map issupplied it is always used, even in tensor data.
+    outputtracts:
+    # type=enum|default='float'|allowed['double','float','oogl']: output tract file type
+    out_file:
+    # type=file|default=<undefined>: output data file
+    output_root:
+    # type=file|default=<undefined>: root directory for output
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-camino/track_bedpostx_deter_callables.py b/example-specs/task/nipype_internal/pydra-camino/track_bedpostx_deter_callables.py
new file mode 100644
index 00000000..86f1341c
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-camino/track_bedpostx_deter_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in TrackBedpostxDeter.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-camino/track_bedpostx_proba.yaml b/example-specs/task/nipype_internal/pydra-camino/track_bedpostx_proba.yaml
new file mode 100644
index 00000000..d95edaf0
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-camino/track_bedpostx_proba.yaml
@@ -0,0 +1,152 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.camino.dti.TrackBedpostxProba' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Data from FSL's bedpostx can be imported into Camino for probabilistic tracking.
+#     (Use TrackBedpostxDeter for bedpostx deterministic tractography.)
+# 
+#     The tracking uses the files merged_th1samples.nii.gz, merged_ph1samples.nii.gz,
+#     ... , merged_thNsamples.nii.gz, merged_phNsamples.nii.gz where there are a
+#     maximum of N compartments (corresponding to each fiber population) in each
+#     voxel. These images contain M samples of theta and phi, the polar coordinates
+#     describing the "stick" for each compartment. At each iteration, a random number
+#     X between 1 and M is drawn and the Xth samples of theta and phi become the
+#     principal directions in the voxel.
+# 
+#     It also uses the N images mean_f1samples.nii.gz, ..., mean_fNsamples.nii.gz,
+#     normalized such that the sum of all compartments is 1. Compartments where the
+#     mean_f is less than a threshold are discarded and not used for tracking.
+#     The default value is 0.01. This can be changed with the min_vol_frac option.
+# 
+#     Example
+#     -------
+#     >>> import nipype.interfaces.camino as cam
+#     >>> track = cam.TrackBedpostxProba()
+#     >>> track.inputs.bedpostxdir = 'bedpostxout'
+#     >>> track.inputs.seed_file = 'seed_mask.nii'
+#     >>> track.inputs.iterations = 100
+#     >>> track.run()          # doctest: +SKIP
+# 
+#     
+task_name: TrackBedpostxProba
+nipype_name: TrackBedpostxProba
+nipype_module: nipype.interfaces.camino.dti
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: input data file
+    seed_file: generic/file
+    # type=file|default=<undefined>: seed file
+    anisfile: generic/file
+    # type=file|default=<undefined>: File containing the anisotropy map. This is required to apply an anisotropy threshold with non tensor data. If the map issupplied it is always used, even in tensor data.
+    output_root: generic/file
+    # type=file|default=<undefined>: root directory for output
+    bedpostxdir: generic/directory
+    # type=directory|default=<undefined>: Directory containing bedpostx output
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    tracked: generic/file
+    # type=file: output file containing reconstructed tracts
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: out_file
+    # type=file|default=<undefined>: output data file
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    bedpostxdir:
+    # type=directory|default=<undefined>: Directory containing bedpostx output
+    min_vol_frac:
+    # type=float|default=0.0: Zeros out compartments in bedpostx data with a mean volume fraction f of less than min_vol_frac.  The default is 0.01.
+    iterations:
+    # type=int|default=0: Number of streamlines to generate at each seed point. The default is 1.
+    in_file:
+    # type=file|default=<undefined>: input data file
+    seed_file:
+    # type=file|default=<undefined>: seed file
+    inputmodel:
+    # type=enum|default='dt'|allowed['ballstick','bayesdirac','bayesdirac_dt','bedpostx','bedpostx_dyad','dt','multitensor','pico','repbs_dt','repbs_multitensor','sfpeak','wildbs_dt']: input model type
+    tracker:
+    # type=enum|default='fact'|allowed['euler','fact','rk4']: The tracking algorithm controls streamlines are generated from the data. The choices are: - FACT, which follows the local fibre orientation in each voxel. No interpolation is used.- EULER, which uses a fixed step size along the local fibre orientation. With nearest-neighbour interpolation, this method may be very similar to FACT, except that the step size is fixed, whereas FACT steps extend to the boundary of the next voxel (distance variable depending on the entry and exit points to the voxel).- RK4: Fourth-order Runge-Kutta method. The step size is fixed, however the eventual direction of the step is determined by taking and averaging a series of partial steps.
+    interpolator:
+    # type=enum|default='nn'|allowed['linear','nn','prob_nn']: The interpolation algorithm determines how the fiber orientation(s) are defined at a given continuous point within the input image. Interpolators are only used when the tracking algorithm is not FACT. The choices are: - NN: Nearest-neighbour interpolation, just uses the local voxel data directly.- PROB_NN: Probabilistic nearest-neighbor interpolation,  similar  to the method pro- posed by Behrens et al [Magnetic Resonance in Medicine, 50:1077-1088, 2003]. The data is not interpolated, but at each point we randomly choose one of the 8 voxels sur- rounding a point. The probability of choosing a particular voxel is based on how close the point is to the centre of that voxel.- LINEAR: Linear interpolation of the vector field containing the principal directions at each point.
+    stepsize:
+    # type=float|default=0.0: Step size for EULER and RK4 tracking. The default is 1mm.
+    inputdatatype:
+    # type=enum|default='float'|allowed['double','float']: input file type
+    gzip:
+    # type=bool|default=False: save the output image in gzip format
+    maxcomponents:
+    # type=int|default=0: The maximum number of tensor components in a voxel. This determines the size of the input file and does not say anything about the voxel classification. The default is 2 if the input model is multitensor and 1 if the input model is dt.
+    numpds:
+    # type=int|default=0: The maximum number of PDs in a voxel for input models sfpeak and pico. The default is 3 for input model sfpeak and 1 for input model pico. This option determines the size of the voxels in the input file and does not affect tracking. For tensor data, use the -maxcomponents option.
+    data_dims:
+    # type=list|default=[]: data dimensions in voxels
+    voxel_dims:
+    # type=list|default=[]: voxel dimensions in mm
+    ipthresh:
+    # type=float|default=0.0: Curvature threshold for tracking, expressed as the minimum dot product between two streamline orientations calculated over the length of a voxel. If the dot product between the previous and current directions is less than this threshold, then the streamline terminates. The default setting will terminate fibres that curve by more than 80 degrees. Set this to -1.0 to disable curvature checking completely.
+    curvethresh:
+    # type=float|default=0.0: Curvature threshold for tracking, expressed as the maximum angle (in degrees) between between two streamline orientations calculated over the length of a voxel. If the angle is greater than this, then the streamline terminates.
+    curveinterval:
+    # type=float|default=0.0: Interval over which the curvature threshold should be evaluated, in mm. The default is 5mm. When using the default curvature threshold of 90 degrees, this means that streamlines will terminate if they curve by more than  90  degrees over a path length of 5mm.
+    anisthresh:
+    # type=float|default=0.0: Terminate fibres that enter a voxel with lower anisotropy than the threshold.
+    anisfile:
+    # type=file|default=<undefined>: File containing the anisotropy map. This is required to apply an anisotropy threshold with non tensor data. If the map issupplied it is always used, even in tensor data.
+    outputtracts:
+    # type=enum|default='float'|allowed['double','float','oogl']: output tract file type
+    out_file:
+    # type=file|default=<undefined>: output data file
+    output_root:
+    # type=file|default=<undefined>: root directory for output
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-camino/track_bedpostx_proba_callables.py b/example-specs/task/nipype_internal/pydra-camino/track_bedpostx_proba_callables.py
new file mode 100644
index 00000000..c73548a7
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-camino/track_bedpostx_proba_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in TrackBedpostxProba.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-camino/track_bootstrap.yaml b/example-specs/task/nipype_internal/pydra-camino/track_bootstrap.yaml
new file mode 100644
index 00000000..7f56a7b4
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-camino/track_bootstrap.yaml
@@ -0,0 +1,147 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.camino.dti.TrackBootstrap' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Performs bootstrap streamline tractography using multiple scans of the same subject
+# 
+#     Example
+#     -------
+#     >>> import nipype.interfaces.camino as cmon
+#     >>> track = cmon.TrackBootstrap()
+#     >>> track.inputs.inputmodel='repbs_dt'
+#     >>> track.inputs.scheme_file = 'bvecs.scheme'
+#     >>> track.inputs.bsdatafiles = ['fitted_data1.Bfloat', 'fitted_data2.Bfloat']
+#     >>> track.inputs.seed_file = 'seed_mask.nii'
+#     >>> track.run()          # doctest: +SKIP
+# 
+#     
+task_name: TrackBootstrap
+nipype_name: TrackBootstrap
+nipype_module: nipype.interfaces.camino.dti
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    scheme_file: generic/file
+    # type=file|default=<undefined>: The scheme file corresponding to the data being processed.
+    bsdatafiles: generic/file+list-of
+    # type=list|default=[]: Specifies files containing raw data for repetition bootstrapping. Use -inputfile for wild bootstrap data.
+    bgmask: generic/file
+    # type=file|default=<undefined>: Provides the name of a file containing a background mask computed using, for example, FSL's bet2 program. The mask file contains zero in background voxels and non-zero in foreground.
+    in_file: generic/file
+    # type=file|default=<undefined>: input data file
+    seed_file: generic/file
+    # type=file|default=<undefined>: seed file
+    anisfile: generic/file
+    # type=file|default=<undefined>: File containing the anisotropy map. This is required to apply an anisotropy threshold with non tensor data. If the map issupplied it is always used, even in tensor data.
+    output_root: generic/file
+    # type=file|default=<undefined>: root directory for output
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    tracked: generic/file
+    # type=file: output file containing reconstructed tracts
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: out_file
+    # type=file|default=<undefined>: output data file
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    scheme_file:
+    # type=file|default=<undefined>: The scheme file corresponding to the data being processed.
+    iterations:
+    # type=int|default=0: Number of streamlines to generate at each seed point.
+    inversion:
+    # type=int|default=0: Tensor reconstruction algorithm for repetition bootstrapping. Default is 1 (linear reconstruction, single tensor).
+    bsdatafiles:
+    # type=list|default=[]: Specifies files containing raw data for repetition bootstrapping. Use -inputfile for wild bootstrap data.
+    bgmask:
+    # type=file|default=<undefined>: Provides the name of a file containing a background mask computed using, for example, FSL's bet2 program. The mask file contains zero in background voxels and non-zero in foreground.
+    in_file:
+    # type=file|default=<undefined>: input data file
+    seed_file:
+    # type=file|default=<undefined>: seed file
+    inputmodel:
+    # type=enum|default='dt'|allowed['ballstick','bayesdirac','bayesdirac_dt','bedpostx','bedpostx_dyad','dt','multitensor','pico','repbs_dt','repbs_multitensor','sfpeak','wildbs_dt']: input model type
+    tracker:
+    # type=enum|default='fact'|allowed['euler','fact','rk4']: The tracking algorithm controls streamlines are generated from the data. The choices are: - FACT, which follows the local fibre orientation in each voxel. No interpolation is used.- EULER, which uses a fixed step size along the local fibre orientation. With nearest-neighbour interpolation, this method may be very similar to FACT, except that the step size is fixed, whereas FACT steps extend to the boundary of the next voxel (distance variable depending on the entry and exit points to the voxel).- RK4: Fourth-order Runge-Kutta method. The step size is fixed, however the eventual direction of the step is determined by taking and averaging a series of partial steps.
+    interpolator:
+    # type=enum|default='nn'|allowed['linear','nn','prob_nn']: The interpolation algorithm determines how the fiber orientation(s) are defined at a given continuous point within the input image. Interpolators are only used when the tracking algorithm is not FACT. The choices are: - NN: Nearest-neighbour interpolation, just uses the local voxel data directly.- PROB_NN: Probabilistic nearest-neighbor interpolation,  similar  to the method pro- posed by Behrens et al [Magnetic Resonance in Medicine, 50:1077-1088, 2003]. The data is not interpolated, but at each point we randomly choose one of the 8 voxels sur- rounding a point. The probability of choosing a particular voxel is based on how close the point is to the centre of that voxel.- LINEAR: Linear interpolation of the vector field containing the principal directions at each point.
+    stepsize:
+    # type=float|default=0.0: Step size for EULER and RK4 tracking. The default is 1mm.
+    inputdatatype:
+    # type=enum|default='float'|allowed['double','float']: input file type
+    gzip:
+    # type=bool|default=False: save the output image in gzip format
+    maxcomponents:
+    # type=int|default=0: The maximum number of tensor components in a voxel. This determines the size of the input file and does not say anything about the voxel classification. The default is 2 if the input model is multitensor and 1 if the input model is dt.
+    numpds:
+    # type=int|default=0: The maximum number of PDs in a voxel for input models sfpeak and pico. The default is 3 for input model sfpeak and 1 for input model pico. This option determines the size of the voxels in the input file and does not affect tracking. For tensor data, use the -maxcomponents option.
+    data_dims:
+    # type=list|default=[]: data dimensions in voxels
+    voxel_dims:
+    # type=list|default=[]: voxel dimensions in mm
+    ipthresh:
+    # type=float|default=0.0: Curvature threshold for tracking, expressed as the minimum dot product between two streamline orientations calculated over the length of a voxel. If the dot product between the previous and current directions is less than this threshold, then the streamline terminates. The default setting will terminate fibres that curve by more than 80 degrees. Set this to -1.0 to disable curvature checking completely.
+    curvethresh:
+    # type=float|default=0.0: Curvature threshold for tracking, expressed as the maximum angle (in degrees) between between two streamline orientations calculated over the length of a voxel. If the angle is greater than this, then the streamline terminates.
+    curveinterval:
+    # type=float|default=0.0: Interval over which the curvature threshold should be evaluated, in mm. The default is 5mm. When using the default curvature threshold of 90 degrees, this means that streamlines will terminate if they curve by more than  90  degrees over a path length of 5mm.
+    anisthresh:
+    # type=float|default=0.0: Terminate fibres that enter a voxel with lower anisotropy than the threshold.
+    anisfile:
+    # type=file|default=<undefined>: File containing the anisotropy map. This is required to apply an anisotropy threshold with non tensor data. If the map issupplied it is always used, even in tensor data.
+    outputtracts:
+    # type=enum|default='float'|allowed['double','float','oogl']: output tract file type
+    out_file:
+    # type=file|default=<undefined>: output data file
+    output_root:
+    # type=file|default=<undefined>: root directory for output
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-camino/track_bootstrap_callables.py b/example-specs/task/nipype_internal/pydra-camino/track_bootstrap_callables.py
new file mode 100644
index 00000000..ecc2fe59
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-camino/track_bootstrap_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in TrackBootstrap.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-camino/track_callables.py b/example-specs/task/nipype_internal/pydra-camino/track_callables.py
new file mode 100644
index 00000000..ef486ae5
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-camino/track_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Track.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-camino/track_dt.yaml b/example-specs/task/nipype_internal/pydra-camino/track_dt.yaml
new file mode 100644
index 00000000..94584085
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-camino/track_dt.yaml
@@ -0,0 +1,129 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.camino.dti.TrackDT' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Performs streamline tractography using tensor data
+# 
+#     Example
+#     -------
+#     >>> import nipype.interfaces.camino as cmon
+#     >>> track = cmon.TrackDT()
+#     >>> track.inputs.in_file = 'tensor_fitted_data.Bdouble'
+#     >>> track.inputs.seed_file = 'seed_mask.nii'
+#     >>> track.run()         # doctest: +SKIP
+# 
+#     
+task_name: TrackDT
+nipype_name: TrackDT
+nipype_module: nipype.interfaces.camino.dti
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: input data file
+    seed_file: generic/file
+    # type=file|default=<undefined>: seed file
+    anisfile: generic/file
+    # type=file|default=<undefined>: File containing the anisotropy map. This is required to apply an anisotropy threshold with non tensor data. If the map issupplied it is always used, even in tensor data.
+    output_root: generic/file
+    # type=file|default=<undefined>: root directory for output
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    tracked: generic/file
+    # type=file: output file containing reconstructed tracts
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: out_file
+    # type=file|default=<undefined>: output data file
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input data file
+    seed_file:
+    # type=file|default=<undefined>: seed file
+    inputmodel:
+    # type=enum|default='dt'|allowed['ballstick','bayesdirac','bayesdirac_dt','bedpostx','bedpostx_dyad','dt','multitensor','pico','repbs_dt','repbs_multitensor','sfpeak','wildbs_dt']: input model type
+    tracker:
+    # type=enum|default='fact'|allowed['euler','fact','rk4']: The tracking algorithm controls streamlines are generated from the data. The choices are: - FACT, which follows the local fibre orientation in each voxel. No interpolation is used.- EULER, which uses a fixed step size along the local fibre orientation. With nearest-neighbour interpolation, this method may be very similar to FACT, except that the step size is fixed, whereas FACT steps extend to the boundary of the next voxel (distance variable depending on the entry and exit points to the voxel).- RK4: Fourth-order Runge-Kutta method. The step size is fixed, however the eventual direction of the step is determined by taking and averaging a series of partial steps.
+    interpolator:
+    # type=enum|default='nn'|allowed['linear','nn','prob_nn']: The interpolation algorithm determines how the fiber orientation(s) are defined at a given continuous point within the input image. Interpolators are only used when the tracking algorithm is not FACT. The choices are: - NN: Nearest-neighbour interpolation, just uses the local voxel data directly.- PROB_NN: Probabilistic nearest-neighbor interpolation,  similar  to the method pro- posed by Behrens et al [Magnetic Resonance in Medicine, 50:1077-1088, 2003]. The data is not interpolated, but at each point we randomly choose one of the 8 voxels sur- rounding a point. The probability of choosing a particular voxel is based on how close the point is to the centre of that voxel.- LINEAR: Linear interpolation of the vector field containing the principal directions at each point.
+    stepsize:
+    # type=float|default=0.0: Step size for EULER and RK4 tracking. The default is 1mm.
+    inputdatatype:
+    # type=enum|default='float'|allowed['double','float']: input file type
+    gzip:
+    # type=bool|default=False: save the output image in gzip format
+    maxcomponents:
+    # type=int|default=0: The maximum number of tensor components in a voxel. This determines the size of the input file and does not say anything about the voxel classification. The default is 2 if the input model is multitensor and 1 if the input model is dt.
+    numpds:
+    # type=int|default=0: The maximum number of PDs in a voxel for input models sfpeak and pico. The default is 3 for input model sfpeak and 1 for input model pico. This option determines the size of the voxels in the input file and does not affect tracking. For tensor data, use the -maxcomponents option.
+    data_dims:
+    # type=list|default=[]: data dimensions in voxels
+    voxel_dims:
+    # type=list|default=[]: voxel dimensions in mm
+    ipthresh:
+    # type=float|default=0.0: Curvature threshold for tracking, expressed as the minimum dot product between two streamline orientations calculated over the length of a voxel. If the dot product between the previous and current directions is less than this threshold, then the streamline terminates. The default setting will terminate fibres that curve by more than 80 degrees. Set this to -1.0 to disable curvature checking completely.
+    curvethresh:
+    # type=float|default=0.0: Curvature threshold for tracking, expressed as the maximum angle (in degrees) between between two streamline orientations calculated over the length of a voxel. If the angle is greater than this, then the streamline terminates.
+    curveinterval:
+    # type=float|default=0.0: Interval over which the curvature threshold should be evaluated, in mm. The default is 5mm. When using the default curvature threshold of 90 degrees, this means that streamlines will terminate if they curve by more than  90  degrees over a path length of 5mm.
+    anisthresh:
+    # type=float|default=0.0: Terminate fibres that enter a voxel with lower anisotropy than the threshold.
+    anisfile:
+    # type=file|default=<undefined>: File containing the anisotropy map. This is required to apply an anisotropy threshold with non tensor data. If the map issupplied it is always used, even in tensor data.
+    outputtracts:
+    # type=enum|default='float'|allowed['double','float','oogl']: output tract file type
+    out_file:
+    # type=file|default=<undefined>: output data file
+    output_root:
+    # type=file|default=<undefined>: root directory for output
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-camino/track_dt_callables.py b/example-specs/task/nipype_internal/pydra-camino/track_dt_callables.py
new file mode 100644
index 00000000..85ffc74f
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-camino/track_dt_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in TrackDT.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-camino/track_pi_co.yaml b/example-specs/task/nipype_internal/pydra-camino/track_pi_co.yaml
new file mode 100644
index 00000000..d82bad6e
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-camino/track_pi_co.yaml
@@ -0,0 +1,133 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.camino.dti.TrackPICo' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Performs streamline tractography using Probabilistic Index of Connectivity (PICo).
+# 
+#     Example
+#     -------
+#     >>> import nipype.interfaces.camino as cmon
+#     >>> track = cmon.TrackPICo()
+#     >>> track.inputs.in_file = 'pdfs.Bfloat'
+#     >>> track.inputs.seed_file = 'seed_mask.nii'
+#     >>> track.run()          # doctest: +SKIP
+# 
+#     
+task_name: TrackPICo
+nipype_name: TrackPICo
+nipype_module: nipype.interfaces.camino.dti
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: input data file
+    seed_file: generic/file
+    # type=file|default=<undefined>: seed file
+    anisfile: generic/file
+    # type=file|default=<undefined>: File containing the anisotropy map. This is required to apply an anisotropy threshold with non tensor data. If the map issupplied it is always used, even in tensor data.
+    output_root: generic/file
+    # type=file|default=<undefined>: root directory for output
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    tracked: generic/file
+    # type=file: output file containing reconstructed tracts
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: out_file
+    # type=file|default=<undefined>: output data file
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    pdf:
+    # type=enum|default='bingham'|allowed['acg','bingham','watson']: Specifies the model for PICo parameters. The default is "bingham.
+    iterations:
+    # type=int|default=0: Number of streamlines to generate at each seed point. The default is 5000.
+    in_file:
+    # type=file|default=<undefined>: input data file
+    seed_file:
+    # type=file|default=<undefined>: seed file
+    inputmodel:
+    # type=enum|default='dt'|allowed['ballstick','bayesdirac','bayesdirac_dt','bedpostx','bedpostx_dyad','dt','multitensor','pico','repbs_dt','repbs_multitensor','sfpeak','wildbs_dt']: input model type
+    tracker:
+    # type=enum|default='fact'|allowed['euler','fact','rk4']: The tracking algorithm controls streamlines are generated from the data. The choices are: - FACT, which follows the local fibre orientation in each voxel. No interpolation is used.- EULER, which uses a fixed step size along the local fibre orientation. With nearest-neighbour interpolation, this method may be very similar to FACT, except that the step size is fixed, whereas FACT steps extend to the boundary of the next voxel (distance variable depending on the entry and exit points to the voxel).- RK4: Fourth-order Runge-Kutta method. The step size is fixed, however the eventual direction of the step is determined by taking and averaging a series of partial steps.
+    interpolator:
+    # type=enum|default='nn'|allowed['linear','nn','prob_nn']: The interpolation algorithm determines how the fiber orientation(s) are defined at a given continuous point within the input image. Interpolators are only used when the tracking algorithm is not FACT. The choices are: - NN: Nearest-neighbour interpolation, just uses the local voxel data directly.- PROB_NN: Probabilistic nearest-neighbor interpolation,  similar  to the method pro- posed by Behrens et al [Magnetic Resonance in Medicine, 50:1077-1088, 2003]. The data is not interpolated, but at each point we randomly choose one of the 8 voxels sur- rounding a point. The probability of choosing a particular voxel is based on how close the point is to the centre of that voxel.- LINEAR: Linear interpolation of the vector field containing the principal directions at each point.
+    stepsize:
+    # type=float|default=0.0: Step size for EULER and RK4 tracking. The default is 1mm.
+    inputdatatype:
+    # type=enum|default='float'|allowed['double','float']: input file type
+    gzip:
+    # type=bool|default=False: save the output image in gzip format
+    maxcomponents:
+    # type=int|default=0: The maximum number of tensor components in a voxel. This determines the size of the input file and does not say anything about the voxel classification. The default is 2 if the input model is multitensor and 1 if the input model is dt.
+    numpds:
+    # type=int|default=0: The maximum number of PDs in a voxel for input models sfpeak and pico. The default is 3 for input model sfpeak and 1 for input model pico. This option determines the size of the voxels in the input file and does not affect tracking. For tensor data, use the -maxcomponents option.
+    data_dims:
+    # type=list|default=[]: data dimensions in voxels
+    voxel_dims:
+    # type=list|default=[]: voxel dimensions in mm
+    ipthresh:
+    # type=float|default=0.0: Curvature threshold for tracking, expressed as the minimum dot product between two streamline orientations calculated over the length of a voxel. If the dot product between the previous and current directions is less than this threshold, then the streamline terminates. The default setting will terminate fibres that curve by more than 80 degrees. Set this to -1.0 to disable curvature checking completely.
+    curvethresh:
+    # type=float|default=0.0: Curvature threshold for tracking, expressed as the maximum angle (in degrees) between between two streamline orientations calculated over the length of a voxel. If the angle is greater than this, then the streamline terminates.
+    curveinterval:
+    # type=float|default=0.0: Interval over which the curvature threshold should be evaluated, in mm. The default is 5mm. When using the default curvature threshold of 90 degrees, this means that streamlines will terminate if they curve by more than  90  degrees over a path length of 5mm.
+    anisthresh:
+    # type=float|default=0.0: Terminate fibres that enter a voxel with lower anisotropy than the threshold.
+    anisfile:
+    # type=file|default=<undefined>: File containing the anisotropy map. This is required to apply an anisotropy threshold with non tensor data. If the map issupplied it is always used, even in tensor data.
+    outputtracts:
+    # type=enum|default='float'|allowed['double','float','oogl']: output tract file type
+    out_file:
+    # type=file|default=<undefined>: output data file
+    output_root:
+    # type=file|default=<undefined>: root directory for output
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-camino/track_pi_co_callables.py b/example-specs/task/nipype_internal/pydra-camino/track_pi_co_callables.py
new file mode 100644
index 00000000..15f107a4
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-camino/track_pi_co_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in TrackPICo.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-camino/tract_shredder.yaml b/example-specs/task/nipype_internal/pydra-camino/tract_shredder.yaml
new file mode 100644
index 00000000..763362e5
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-camino/tract_shredder.yaml
@@ -0,0 +1,101 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.camino.convert.TractShredder' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Extracts bunches of streamlines.
+# 
+#     tractshredder works in a similar way to shredder, but processes streamlines instead of scalar data.
+#     The input is raw streamlines, in the format produced by track or procstreamlines.
+# 
+#     The program first makes an initial offset of offset tracts.  It then reads and outputs a group of
+#     bunchsize tracts, skips space tracts, and repeats until there is no more input.
+# 
+#     Examples
+#     --------
+# 
+#     >>> import nipype.interfaces.camino as cmon
+#     >>> shred = cmon.TractShredder()
+#     >>> shred.inputs.in_file = 'tract_data.Bfloat'
+#     >>> shred.inputs.offset = 0
+#     >>> shred.inputs.bunchsize = 1
+#     >>> shred.inputs.space = 2
+#     >>> shred.run()          # doctest: +SKIP
+#     
+task_name: TractShredder
+nipype_name: TractShredder
+nipype_module: nipype.interfaces.camino.convert
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: tract file
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    shredded: generic/file
+    # type=file: Shredded tract file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: out_file
+    # type=file|default=<undefined>: 
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: tract file
+    offset:
+    # type=int|default=0: initial offset of offset tracts
+    bunchsize:
+    # type=int|default=0: reads and outputs a group of bunchsize tracts
+    space:
+    # type=int|default=0: skips space tracts
+    out_file:
+    # type=file|default=<undefined>: 
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-camino/tract_shredder_callables.py b/example-specs/task/nipype_internal/pydra-camino/tract_shredder_callables.py
new file mode 100644
index 00000000..bd0a1ed5
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-camino/tract_shredder_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in TractShredder.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-camino/vtk_streamlines.yaml b/example-specs/task/nipype_internal/pydra-camino/vtk_streamlines.yaml
new file mode 100644
index 00000000..e29ea631
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-camino/vtk_streamlines.yaml
@@ -0,0 +1,109 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.camino.convert.VtkStreamlines' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Use vtkstreamlines to convert raw or voxel format streamlines to VTK polydata
+# 
+#     Examples
+#     --------
+# 
+#     >>> import nipype.interfaces.camino as cmon
+#     >>> vtk = cmon.VtkStreamlines()
+#     >>> vtk.inputs.in_file = 'tract_data.Bfloat'
+#     >>> vtk.inputs.voxeldims = [1,1,1]
+#     >>> vtk.run()          # doctest: +SKIP
+#     
+task_name: VtkStreamlines
+nipype_name: VtkStreamlines
+nipype_module: nipype.interfaces.camino.convert
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: data file
+    seed_file: generic/file
+    # type=file|default=<undefined>: image containing seed points
+    target_file: generic/file
+    # type=file|default=<undefined>: image containing integer-valued target regions
+    scalar_file: generic/file
+    # type=file|default=<undefined>: image that is in the same physical space as the tracts
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    vtk: generic/file
+    # type=file: Streamlines in VTK format
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: out_file
+    # type=file|default=<undefined>: 
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputmodel:
+    # type=enum|default='raw'|allowed['raw','voxels']: input model type (raw or voxels)
+    in_file:
+    # type=file|default=<undefined>: data file
+    voxeldims:
+    # type=list|default=[]: voxel dimensions in mm
+    seed_file:
+    # type=file|default=<undefined>: image containing seed points
+    target_file:
+    # type=file|default=<undefined>: image containing integer-valued target regions
+    scalar_file:
+    # type=file|default=<undefined>: image that is in the same physical space as the tracts
+    colourorient:
+    # type=bool|default=False: Each point on the streamline is coloured by the local orientation.
+    interpolatescalars:
+    # type=bool|default=False: the scalar value at each point on the streamline is calculated by trilinear interpolation
+    interpolate:
+    # type=bool|default=False: the scalar value at each point on the streamline is calculated by trilinear interpolation
+    out_file:
+    # type=file|default=<undefined>: 
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-camino/vtk_streamlines_callables.py b/example-specs/task/nipype_internal/pydra-camino/vtk_streamlines_callables.py
new file mode 100644
index 00000000..de7e4131
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-camino/vtk_streamlines_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in VtkStreamlines.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-camino2trackvis/camino_2_trackvis.yaml b/example-specs/task/nipype_internal/pydra-camino2trackvis/camino_2_trackvis.yaml
new file mode 100644
index 00000000..b9873595
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-camino2trackvis/camino_2_trackvis.yaml
@@ -0,0 +1,106 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.camino2trackvis.convert.Camino2Trackvis' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Wraps camino_to_trackvis from Camino-Trackvis
+# 
+#     Convert files from camino .Bfloat format to trackvis .trk format.
+# 
+#     Example
+#     -------
+# 
+#     >>> import nipype.interfaces.camino2trackvis as cam2trk
+#     >>> c2t = cam2trk.Camino2Trackvis()
+#     >>> c2t.inputs.in_file = 'data.Bfloat'
+#     >>> c2t.inputs.out_file = 'streamlines.trk'
+#     >>> c2t.inputs.min_length = 30
+#     >>> c2t.inputs.data_dims = [128, 104, 64]
+#     >>> c2t.inputs.voxel_dims = [2.0, 2.0, 2.0]
+#     >>> c2t.inputs.voxel_order = 'LAS'
+#     >>> c2t.run()          # doctest: +SKIP
+#     
+task_name: Camino2Trackvis
+nipype_name: Camino2Trackvis
+nipype_module: nipype.interfaces.camino2trackvis.convert
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: The input .Bfloat (camino) file.
+    voxel_order: generic/file
+    # type=file|default=<undefined>: Set the order in which various directions were stored.        Specify with three letters consisting of one each          from the pairs LR, AP, and SI. These stand for Left-Right,         Anterior-Posterior, and Superior-Inferior.          Whichever is specified in each position will          be the direction of increasing order.          Read coordinate system from a NIfTI file.
+    nifti_file: generic/file
+    # type=file|default=<undefined>: Read coordinate system from a NIfTI file.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    trackvis: generic/file
+    # type=file: The filename to which to write the .trk (trackvis) file.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: out_file
+    # type=file|default=<undefined>: The filename to which to write the .trk (trackvis) file.
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: The input .Bfloat (camino) file.
+    out_file:
+    # type=file|default=<undefined>: The filename to which to write the .trk (trackvis) file.
+    min_length:
+    # type=float|default=0.0: The minimum length of tracts to output
+    data_dims:
+    # type=list|default=[]: Three comma-separated integers giving the number of voxels along each dimension of the source scans.
+    voxel_dims:
+    # type=list|default=[]: Three comma-separated numbers giving the size of each voxel in mm.
+    voxel_order:
+    # type=file|default=<undefined>: Set the order in which various directions were stored.        Specify with three letters consisting of one each          from the pairs LR, AP, and SI. These stand for Left-Right,         Anterior-Posterior, and Superior-Inferior.          Whichever is specified in each position will          be the direction of increasing order.          Read coordinate system from a NIfTI file.
+    nifti_file:
+    # type=file|default=<undefined>: Read coordinate system from a NIfTI file.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-camino2trackvis/camino_2_trackvis_callables.py b/example-specs/task/nipype_internal/pydra-camino2trackvis/camino_2_trackvis_callables.py
new file mode 100644
index 00000000..f9f86721
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-camino2trackvis/camino_2_trackvis_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Camino2Trackvis.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-camino2trackvis/trackvis_2_camino.yaml b/example-specs/task/nipype_internal/pydra-camino2trackvis/trackvis_2_camino.yaml
new file mode 100644
index 00000000..2f22b71e
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-camino2trackvis/trackvis_2_camino.yaml
@@ -0,0 +1,80 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.camino2trackvis.convert.Trackvis2Camino' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+task_name: Trackvis2Camino
+nipype_name: Trackvis2Camino
+nipype_module: nipype.interfaces.camino2trackvis.convert
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: The input .trk (trackvis) file.
+    append_file: generic/file
+    # type=file|default=<undefined>: A file to which the append the .Bfloat data. 
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    camino: generic/file
+    # type=file: The filename to which to write the .Bfloat (camino).
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: out_file
+    # type=file|default=<undefined>: The filename to which to write the .Bfloat (camino).
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: The input .trk (trackvis) file.
+    out_file:
+    # type=file|default=<undefined>: The filename to which to write the .Bfloat (camino).
+    append_file:
+    # type=file|default=<undefined>: A file to which the append the .Bfloat data. 
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-camino2trackvis/trackvis_2_camino_callables.py b/example-specs/task/nipype_internal/pydra-camino2trackvis/trackvis_2_camino_callables.py
new file mode 100644
index 00000000..66cf5203
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-camino2trackvis/trackvis_2_camino_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Trackvis2Camino.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-cat12/cat12_segment.yaml b/example-specs/task/nipype_internal/pydra-cat12/cat12_segment.yaml
new file mode 100644
index 00000000..10bad416
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-cat12/cat12_segment.yaml
@@ -0,0 +1,225 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.cat12.preprocess.CAT12Segment' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     CAT12: Segmentation
+# 
+#     This toolbox is an extension to the default segmentation in SPM12, but uses a completely different segmentation
+#     approach.
+#     The segmentation approach is based on an Adaptive Maximum A Posterior (MAP) technique without the need for a priori
+#     information about tissue probabilities. That is, the Tissue Probability Maps (TPM) are not used constantly in the
+#     sense of the classical Unified Segmentation approach (Ashburner et. al. 2005), but just for spatial normalization.
+#     The following AMAP estimation is adaptive in the sense that local variations of the parameters (i.e., means and
+#     variance) are modeled as slowly varying spatial functions (Rajapakse et al. 1997). This not only accounts for
+#     intensity inhomogeneities but also for other local variations of intensity.
+#     Additionally, the segmentation approach uses a Partial Volume Estimation (PVE) with a simplified mixed model of at
+#     most two tissue types (Tohka et al. 2004). We start with an initial segmentation into three pure classes: gray
+#     matter (GM), white matter (WM), and cerebrospinal fluid (CSF) based on the above described AMAP estimation. The
+#     initial segmentation is followed by a PVE of two additional mixed classes: GM-WM and GM-CSF. This results in an
+#     estimation of the amount (or fraction) of each pure tissue type present in every voxel (as single voxels - given by
+#     Another important extension to the SPM12 segmentation is the integration of the Dartel or Geodesic Shooting
+#     registration into the toolbox by an already existing Dartel/Shooting template in MNI space. This template was
+#     derived from 555 healthy control subjects of the IXI-database (http://www.brain-development.org) and provides the
+#     several Dartel or Shooting iterations. Thus, for the majority of studies the creation of sample-specific templates
+#     is not necessary anymore and is mainly recommended for children data.'};
+# 
+#     http://www.neuro.uni-jena.de/cat12/CAT12-Manual.pdf#page=15
+# 
+#     Examples
+#     --------
+#     >>> path_mr = 'structural.nii'
+#     >>> cat = CAT12Segment(in_files=path_mr)
+#     >>> cat.run() # doctest: +SKIP
+#     
+task_name: CAT12Segment
+nipype_name: CAT12Segment
+nipype_module: nipype.interfaces.cat12.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    paths: generic/directory+list-of
+    # type=inputmultiobject|default=[]: Paths to add to matlabpath
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    label_rois: generic/file
+    # type=file: Files with thickness values of ROIs.
+    label_roi: generic/file
+    # type=file: Files with thickness values of ROI.
+    gm_modulated_image: generic/file
+    # type=file: Grey matter modulated image.
+    gm_dartel_image: generic/file
+    # type=file: Grey matter dartel image.
+    gm_native_image: generic/file
+    # type=file: Grey matter native space.
+    wm_modulated_image: generic/file
+    # type=file: White matter modulated image.
+    wm_dartel_image: generic/file
+    # type=file: White matter dartel image.
+    wm_native_image: generic/file
+    # type=file: White matter in native space.
+    csf_modulated_image: generic/file
+    # type=file: CSF modulated image.
+    csf_dartel_image: generic/file
+    # type=file: CSF dartel image.
+    csf_native_image: generic/file
+    # type=file: CSF in native space.
+    bias_corrected_image: generic/file
+    # type=file: Bias corrected image
+    rh_central_surface: generic/file
+    # type=file: Central right hemisphere files
+    rh_sphere_surface: generic/file
+    # type=file: Sphere right hemisphere files
+    lh_central_surface: generic/file
+    # type=file: Central left hemisphere files
+    lh_sphere_surface: generic/file
+    # type=file: Sphere left hemisphere files
+    report: generic/file
+    # type=file: Report file.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_files:
+    # type=inputmultiobject|default=[]: file to segment
+    tpm:
+    # type=inputmultiobject|default=[]: Tissue Probability Map. Select the tissue probability image that includes 6 tissue probability classes for (1) grey matter, (2) white matter, (3) cerebrospinal fluid, (4) bone, (5) non-brain  soft tissue, and (6) the background.  CAT uses the TPM only for the initial SPM segmentation.
+    shooting_tpm:
+    # type=imagefilespm|default=<undefined>: Shooting Template 0.  The Shooting template must be in multi-volume nifti format and should contain GM, WM, and background segmentations and have to be saved with at least 16 bit. 
+    shooting_tpm_template_1:
+    # type=imagefilespm|default=<undefined>: Shooting Template 1.  The Shooting template must be in multi-volume nifti format and should contain GM, WM, and background segmentations and have to be saved with at least 16 bit. 
+    shooting_tpm_template_2:
+    # type=imagefilespm|default=<undefined>: Shooting Template 2.  The Shooting template must be in multi-volume nifti format and should contain GM, WM, and background segmentations and have to be saved with at least 16 bit. 
+    shooting_tpm_template_3:
+    # type=imagefilespm|default=<undefined>: Shooting Template 3.  The Shooting template must be in multi-volume nifti format and should contain GM, WM, and background segmentations and have to be saved with at least 16 bit. 
+    shooting_tpm_template_4:
+    # type=imagefilespm|default=<undefined>: Shooting Template 4.  The Shooting template must be in multi-volume nifti format and should contain GM, WM, and background segmentations and have to be saved with at least 16 bit. 
+    n_jobs:
+    # type=int|default=1: Number of threads
+    affine_regularization:
+    # type=str|default='mni': Affine Regularization. The procedure is a local optimisation, so it needs reasonable initial starting estimates. Images should be placed in approximate alignment using the Display function of SPM before beginning.  A Mutual Information affine registration with the tissue probability maps (DAgostino et al, 2004) is used to achieve approximate alignment.
+    power_spm_inhomogeneity_correction:
+    # type=float|default=0.5: Strength of the SPM inhomogeneity (bias) correction that simultaneously controls the SPM biasreg, biasfwhm, samp (resolution), and tol (iteration) parameter.
+    affine_preprocessing:
+    # type=int|default=1070: Affine registration and SPM preprocessing can fail in some subjects with deviating anatomy (e.g. other species/neonates) or in images with strong signal inhomogeneities, or untypical intensities (e.g. synthetic images). An initial bias correction can help to reduce such problems (see details below). Recommended are the "default" and "full" option.
+    initial_segmentation:
+    # type=int|default=0: In rare cases the Unified Segmentation can fail in highly abnormal brains, where e.g. the cerebrospinal fluid of superlarge ventricles (hydrocephalus) were classified as white matter. However, if the affine registration is correct, the AMAP segmentation with an prior-independent k-means initialization can be used to replace the SPM brain tissue classification. Moreover, if the default Dartel and Shooting registrations will fail then rhe "Optimized Shooting - superlarge ventricles" option for "Spatial registration" is ! required Values:  none: 0; light: 1; full: 2; default: 1070.
+    local_adaptive_seg:
+    # type=float|default=0.5: Additionally to WM-inhomogeneities, GM intensity can vary across different regions such as the motor cortex, the basal ganglia, or the occipital lobe. These changes have an anatomical background (e.g. iron content, myelinization), but are dependent on the MR-protocol and often lead to underestimation of GM at higher intensities and overestimation of CSF at lower intensities. Therefore, a local intensity transformation of all tissue classes is used to reduce these effects in the image. This local adaptive segmentation (LAS) is applied before the final AMAP segmentation.Possible Values:  SPM Unified Segmentation: 0  k-means AMAP: 2
+    skull_strip:
+    # type=float|default=2: Method of initial skull-stripping before AMAP segmentation. The SPM approach works quite stable for the majority of data. However, in some rare cases parts of GM (i.e. in frontal lobe) might be cut. If this happens the GCUT approach is a good alternative. GCUT is a graph-cut/region-growing approach starting from the WM area. APRG (adaptive probability region-growing) is a new method that refines the probability maps of the SPM approach by region-growing techniques of the gcut approach with a final surface-based optimization strategy. This is currently the method with the most accurate and reliable results. If you use already skull-stripped data you can turn off skull-stripping although this is automatically detected in most cases. Please note that the choice of the skull-stripping method will also influence the estimation of TIV, because the methods mainly differ in the handling of the outer CSF around the cortical surface.  Possible Values:  - none (already skull-stripped): -1;  - SPM approach: 0;   - GCUT approach: 0.50;   - APRG approach: 2
+    wm_hyper_intensity_correction:
+    # type=int|default=1: WARNING: Please note that the detection of WM hyperintensies is still under development and does not have the same accuracy as approaches that additionally consider FLAIR images (e.g. Lesion Segmentation Toolbox)! In aging or (neurodegenerative) diseases WM intensity can be reduced locally in T1 or increased in T2/PD images. These so-called WM hyperintensies (WMHs) can lead to preprocessing errors. Large GM areas next to the ventricle can cause normalization problems. Therefore, a temporary correction for normalization is useful if WMHs are expected. CAT allows different ways to handle WMHs:  0) No Correction (handled as GM).  1) Temporary (internal) correction as WM for spatial normalization and estimation of cortical thickness.  2) Permanent correction to WM. 
+    voxel_size:
+    # type=float|default=1.5: The (isotropic) voxel sizes of any spatially normalised written images. A non-finite value will be replaced by the average voxel size of the tissue probability maps used by the segmentation.
+    internal_resampling_process:
+    # type=tuple|default=(1, 0.1): help_resampling
+    ignore_errors:
+    # type=int|default=1: Error handling. Try to catch preprocessing errors and continue with the next data set or ignore all warnings (e.g., bad intensities) and use an experimental pipeline which is still in development. In case of errors, CAT continues with the next subject if this option is enabled. If the experimental option with backup functions is selected and warnings occur, CAT will try to use backup routines and skip some processing steps which require good T1 contrasts (e.g., LAS). If you want to avoid processing of critical data and ensure that only the main pipeline is used then select the option "Ignore errors (continue with the next subject)". It is strongly recommended to check for preprocessing problems, especially with non-T1 contrasts.  Values: none: 0, default: 1, details: 2.
+    surface_and_thickness_estimation:
+    # type=int|default=1: Surface and thickness estimation.  Use projection-based thickness (PBT) (Dahnke et al. 2012) to estimate cortical thickness and to create the central cortical surface for left and right hemisphere. Surface reconstruction includes topology correction (Yotter et al. 2011), spherical inflation (Yotter et al.) and spherical registration. Additionally you can also estimate surface parameters such as gyrification, cortical complexity or sulcal depth that can be subsequently analyzed at each vertex of the surface. Please note, that surface reconstruction and spherical registration additionally requires about 20-60 min of computation time. A fast (1-3 min) surface pipeline is available for visual preview (e.g., to check preprocessing quality) in the cross-sectional, but not in the longitudinal pipeline.  Only the initial surfaces are created with a lower resolution and without topology correction, spherical mapping and surface registration. Please note that the files with the estimated surface thickness can therefore not be used for further analysis!  For distinction, these files contain "preview" in their filename and they are not available as batch dependencies objects. 
+    surface_measures:
+    # type=int|default=1: Extract surface measures
+    neuromorphometrics:
+    # type=bool|default=True: Extract brain measures for Neuromorphometrics template
+    lpba40:
+    # type=bool|default=True: Extract brain measures for LPBA40 template
+    cobra:
+    # type=bool|default=True: Extract brain measures for COBRA template
+    hammers:
+    # type=bool|default=True: Extract brain measures for Hammers template
+    own_atlas:
+    # type=inputmultiobject|default=[]: Extract brain measures for a given template
+    gm_output_native:
+    # type=bool|default=False: Save modulated grey matter images.
+    gm_output_modulated:
+    # type=bool|default=True: Save native grey matter images.
+    gm_output_dartel:
+    # type=bool|default=False: Save dartel grey matter images.
+    wm_output_native:
+    # type=bool|default=False: Save dartel white matter images.
+    wm_output_modulated:
+    # type=bool|default=True: Save dartel white matter images.
+    wm_output_dartel:
+    # type=bool|default=False: Save dartel white matter images.
+    csf_output_native:
+    # type=bool|default=False: Save dartel CSF images.
+    csf_output_modulated:
+    # type=bool|default=True: Save dartel CSF images.
+    csf_output_dartel:
+    # type=bool|default=False: Save dartel CSF images.
+    label_native:
+    # type=bool|default=False: This is the option to save a labeled version of your segmentations in the native space for fast visual comparison. Labels are saved as Partial Volume Estimation (PVE) values with different mix classes for GM-WM (2.5) and GM-CSF (1.5). BG=0, CSF=1, GM=2, WM=3, WMH=4 (if WMHC=3), SL=1.5 (if SLC)
+    label_warped:
+    # type=bool|default=True: This is the option to save a labeled version of your segmentations in the warped space for fast visual comparison. Labels are saved as Partial Volume Estimation (PVE) values with different mix classes for GM-WM (2.5) and GM-CSF (1.5). BG=0, CSF=1, GM=2, WM=3, WMH=4 (if WMHC=3), SL=1.5 (if SLC)
+    label_dartel:
+    # type=bool|default=False: This is the option to save a labeled version of your segmentations in the dartel space for fast visual comparison. Labels are saved as Partial Volume Estimation (PVE) values with different mix classes for GM-WM (2.5) and GM-CSF (1.5). BG=0, CSF=1, GM=2, WM=3, WMH=4 (if WMHC=3), SL=1.5 (if SLC)
+    output_labelnative:
+    # type=bool|default=False: This is the option to save a labeled version of your segmentations in the native space for fast visual comparison. Labels are saved as Partial Volume Estimation (PVE) values with different mix classes for GM-WM (2.5) and GM-CSF (1.5). BG=0, CSF=1, GM=2, WM=3, WMH=4 (if WMHC=3), SL=1.5 (if SLC)
+    save_bias_corrected:
+    # type=bool|default=True: Save bias corrected image
+    las_native:
+    # type=bool|default=False: This is the option to save a bias, noise, and local intensity corrected version of the original T1 image in the native space. MR images are usually corrupted by a smooth, spatially varying artifact that modulates the intensity of the image (bias). These artifacts, although not usually a problem for visual inspection, can impede automated processing of the images. The bias corrected version should have more uniform intensities within the different types of tissues and can be saved in native space and/or normalised. Noise is corrected by an adaptive non-local mean (NLM) filter (Manjon 2008, Medical Image Analysis 12).
+    las_warped:
+    # type=bool|default=True: This is the option to save a bias, noise, and local intensity corrected version of the original T1 image in the warped space. MR images are usually corrupted by a smooth, spatially varying artifact that modulates the intensity of the image (bias). These artifacts, although not usually a problem for visual inspection, can impede automated processing of the images. The bias corrected version should have more uniform intensities within the different types of tissues and can be saved in native space and/or normalised. Noise is corrected by an adaptive non-local mean (NLM) filter (Manjon 2008, Medical Image Analysis 12).
+    las_dartel:
+    # type=bool|default=False: This is the option to save a bias, noise, and local intensity corrected version of the original T1 image in the dartel space. MR images are usually corrupted by a smooth, spatially varying artifact that modulates the intensity of the image (bias). These artifacts, although not usually a problem for visual inspection, can impede automated processing of the images. The bias corrected version should have more uniform intensities within the different types of tissues and can be saved in native space and/or normalised. Noise is corrected by an adaptive non-local mean (NLM) filter (Manjon 2008, Medical Image Analysis 12).
+    jacobianwarped:
+    # type=bool|default=True: This is the option to save the Jacobian determinant, which expresses local volume changes. This image can be used in a pure deformation based morphometry (DBM) design. Please note that the affine part of the deformation field is ignored. Thus, there is no need for any additional correction for different brain sizes using ICV.
+    warps:
+    # type=tuple|default=(1, 0): Deformation fields can be saved to disk, and used by the Deformations Utility and/or applied to coregistered data from other modalities (e.g. fMRI). For spatially normalising images to MNI space, you will need the forward deformation, whereas for spatially normalising (eg) GIFTI surface files, youll need the inverse. It is also possible to transform data in MNI space on to the individual subject, which also requires the inverse transform. Deformations are saved as .nii files, which contain three volumes to encode the x, y and z coordinates. Values: No:[0 0]; Image->Template (forward): [1 0]; Template->Image (inverse): [0 1];  inverse + forward: [1 1]
+    matlab_cmd:
+    # type=str|default='': matlab command to use
+    paths:
+    # type=inputmultiobject|default=[]: Paths to add to matlabpath
+    mfile:
+    # type=bool|default=True: Run m-code using m-file
+    use_mcr:
+    # type=bool|default=False: Run m-code using SPM MCR
+    use_v8struct:
+    # type=bool|default=True: Generate SPM8 and higher compatible jobs
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-cat12/cat12_segment_callables.py b/example-specs/task/nipype_internal/pydra-cat12/cat12_segment_callables.py
new file mode 100644
index 00000000..b548e2e7
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-cat12/cat12_segment_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in CAT12Segment.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-cat12/cat12sanlm_denoising.yaml b/example-specs/task/nipype_internal/pydra-cat12/cat12sanlm_denoising.yaml
new file mode 100644
index 00000000..ca88f4f5
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-cat12/cat12sanlm_denoising.yaml
@@ -0,0 +1,116 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.cat12.preprocess.CAT12SANLMDenoising' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Spatially adaptive non-local means (SANLM) denoising filter
+# 
+#     This  function  applies  an spatial adaptive (sub-resolution) non-local means denoising filter
+#     to  the  data.  This  filter  will  remove  noise  while  preserving  edges. The filter strength is
+#     automatically estimated based on the standard deviation of the noise.
+# 
+#     This   filter   is  internally  used  in  the  segmentation  procedure  anyway.  Thus,  it  is  not
+#     necessary (and not recommended) to apply the filter before segmentation.
+#     ______________________________________________________________________
+#     Christian Gaser, Robert Dahnke
+#     Structural Brain Mapping Group (http://www.neuro.uni-jena.de)
+#     Departments of Neurology and Psychiatry
+#     Jena University Hospital
+#     ______________________________________________________________________
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import cat12
+#     >>> c = cat12.CAT12SANLMDenoising()
+#     >>> c.inputs.in_files = 'anatomical.nii'
+#     >>> c.run() # doctest: +SKIP
+#     
+task_name: CAT12SANLMDenoising
+nipype_name: CAT12SANLMDenoising
+nipype_module: nipype.interfaces.cat12.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    paths: generic/directory+list-of
+    # type=inputmultiobject|default=[]: Paths to add to matlabpath
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: out file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_files:
+    # type=inputmultiobject|default=[]: Images for filtering.
+    spm_type:
+    # type=enum|default='float32'|allowed['float32','same','uint16','uint8']: Data type of the output images. 'same' matches the input image type.
+    intlim:
+    # type=int|default=100: intensity limitation (default = 100)
+    filename_prefix:
+    # type=str|default='sanlm_': Filename prefix. Specify  the  string  to be prepended to the filenames of the filtered image file(s).
+    filename_suffix:
+    # type=str|default='': Filename suffix. Specify  the  string  to  be  appended  to the filenames of the filtered image file(s).
+    addnoise:
+    # type=float|default=0.5: Strength of additional noise in noise-free regions.         Add  minimal  amount  of noise in regions without any noise to avoid image segmentation problems.         This parameter defines the strength of additional noise as percentage of the average signal intensity.
+    rician:
+    # type=bool|default=True: Rician noise         MRIs  can  have  Gaussian  or  Rician  distributed  noise with uniform or nonuniform variance across the image.         If SNR is high enough (>3)  noise  can  be  well  approximated by Gaussian noise in the foreground. However, for         SENSE reconstruction or DTI data a Rician distribution is expected. Please note that the Rician noise estimation         is sensitive for large signals in the neighbourhood and can lead to artefacts, e.g. cortex can be affected by         very high values in the scalp or in blood vessels.
+    replace_nan_and_inf:
+    # type=bool|default=True: Replace NAN by 0, -INF by the minimum and INF by the maximum of the image.
+    noisecorr_strength:
+    # type=enum|default='-Inf'|allowed['-Inf',2,4]: Strength of Noise Corrections         Strength  of  the  (sub-resolution)  spatial  adaptive    non local means (SANLM) noise correction. Please note         that the filter strength is automatically  estimated.  Change this parameter only for specific conditions. The         "light" option applies half of the filter strength of the adaptive  "medium"  cases,  whereas  the  "strong"         option  uses  the  full  filter  strength,  force sub-resolution filtering and applies an additional  iteration.         Sub-resolution  filtering  is  only  used  in  case  of  high image resolution below 0.8 mm or in case of the         "strong" option. light = 2, medium = -Inf, strong = 4
+    matlab_cmd:
+    # type=str|default='': matlab command to use
+    paths:
+    # type=inputmultiobject|default=[]: Paths to add to matlabpath
+    mfile:
+    # type=bool|default=True: Run m-code using m-file
+    use_mcr:
+    # type=bool|default=False: Run m-code using SPM MCR
+    use_v8struct:
+    # type=bool|default=True: Generate SPM8 and higher compatible jobs
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-cat12/cat12sanlm_denoising_callables.py b/example-specs/task/nipype_internal/pydra-cat12/cat12sanlm_denoising_callables.py
new file mode 100644
index 00000000..b4652138
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-cat12/cat12sanlm_denoising_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in CAT12SANLMDenoising.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-cat12/extract_additional_surface_parameters.yaml b/example-specs/task/nipype_internal/pydra-cat12/extract_additional_surface_parameters.yaml
new file mode 100644
index 00000000..0afd2706
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-cat12/extract_additional_surface_parameters.yaml
@@ -0,0 +1,118 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.cat12.surface.ExtractAdditionalSurfaceParameters' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Additional surface parameters can be extracted that can be used for statistical analysis, such as:
+# 
+#     * Central surfaces
+#     * Surface area
+#     * Surface GM volume
+#     * Gyrification Index
+#     * Sulcus depth
+#     * Toro's gyrification index
+#     * Shaer's local gyrification index
+#     * Laplacian gyrification indices
+#     * Addicional surfaces
+#     * Measure normalization
+#     * Lazy processing
+# 
+#     http://www.neuro.uni-jena.de/cat12/CAT12-Manual.pdf#page=53
+# 
+#     Examples
+#     --------
+#     >>> # Set the left surface files, both will be processed
+#     >>> lh_path_central = 'lh.central.structural.gii'
+#     >>> # Put here all surface files generated by CAT12 Segment, this is only required if the this approach is putted in
+#     >>> surf_files = ['lh.sphere.reg.structural.gii', 'rh.sphere.reg.structural.gii', 'lh.sphere.structural.gii', 'rh.sphere.structural.gii', 'rh.central.structural.gii', 'lh.pbt.structural', 'rh.pbt.structural']
+#     >>> extract_additional_measures = ExtractAdditionalSurfaceParameters(left_central_surfaces=lh_path_central, surface_files=surf_files)
+#     >>> extract_additional_measures.run() # doctest: +SKIP
+# 
+#     
+task_name: ExtractAdditionalSurfaceParameters
+nipype_name: ExtractAdditionalSurfaceParameters
+nipype_module: nipype.interfaces.cat12.surface
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    left_central_surfaces: generic/file+list-of
+    # type=inputmultiobject|default=[]: Left and central surfaces files
+    surface_files: generic/file+list-of
+    # type=inputmultiobject|default=[]: All surface files
+    paths: generic/directory+list-of
+    # type=inputmultiobject|default=[]: Paths to add to matlabpath
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    left_central_surfaces:
+    # type=inputmultiobject|default=[]: Left and central surfaces files
+    surface_files:
+    # type=inputmultiobject|default=[]: All surface files
+    gyrification:
+    # type=bool|default=True: Extract gyrification index (GI) based on absolute mean curvature. The method is described in Luders et al. Neuroimage, 29:1224-1230, 2006
+    gmv:
+    # type=bool|default=True: Extract volume
+    area:
+    # type=bool|default=True: Extract area surface
+    depth:
+    # type=bool|default=False: Extract sulcus depth based on euclidean distance between the central surface anf its convex hull.
+    fractal_dimension:
+    # type=bool|default=False: Extract cortical complexity (fractal dimension) which is described in Yotter ar al. Neuroimage, 56(3): 961-973, 2011
+    matlab_cmd:
+    # type=str|default='': matlab command to use
+    paths:
+    # type=inputmultiobject|default=[]: Paths to add to matlabpath
+    mfile:
+    # type=bool|default=True: Run m-code using m-file
+    use_mcr:
+    # type=bool|default=False: Run m-code using SPM MCR
+    use_v8struct:
+    # type=bool|default=True: Generate SPM8 and higher compatible jobs
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-cat12/extract_additional_surface_parameters_callables.py b/example-specs/task/nipype_internal/pydra-cat12/extract_additional_surface_parameters_callables.py
new file mode 100644
index 00000000..5c53cded
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-cat12/extract_additional_surface_parameters_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in ExtractAdditionalSurfaceParameters.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-cat12/extract_roi_based_surface_measures.yaml b/example-specs/task/nipype_internal/pydra-cat12/extract_roi_based_surface_measures.yaml
new file mode 100644
index 00000000..c502dc86
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-cat12/extract_roi_based_surface_measures.yaml
@@ -0,0 +1,117 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.cat12.surface.ExtractROIBasedSurfaceMeasures' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Extract ROI-based surface values
+#     While ROI-based values for VBM (volume) data are automatically saved in the ``label`` folder as XML file it is
+#     necessary to additionally extract these values for surface data (except for thickness which is automatically
+#     extracted during segmentation). This has to be done after preprocessing the data and creating cortical surfaces.
+# 
+#     You can extract ROI-based values for cortical thickness but also for any other surface parameter that was extracted
+#     using the Extract Additional Surface Parameters such as volume, area, depth, gyrification and fractal dimension.
+# 
+# 
+#      http://www.neuro.uni-jena.de/cat12/CAT12-Manual.pdf#page=53
+# 
+#      Examples
+#      --------
+#     >>> # Template surface files
+#     >>> lh_atlas = 'lh.aparc_a2009s.freesurfer.annot'
+#     >>> rh_atlas = 'rh.aparc_a2009s.freesurfer.annot'
+#     >>> surf_files = ['lh.sphere.reg.structural.gii', 'rh.sphere.reg.structural.gii', 'lh.sphere.structural.gii', 'rh.sphere.structural.gii', 'lh.central.structural.gii', 'rh.central.structural.gii', 'lh.pbt.structural', 'rh.pbt.structural']
+#     >>> lh_measure = 'lh.area.structural'
+#     >>> extract_additional_measures = ExtractROIBasedSurfaceMeasures(surface_files=surf_files, lh_surface_measure=lh_measure, lh_roi_atlas=lh_atlas, rh_roi_atlas=rh_atlas)
+#     >>> extract_additional_measures.run() # doctest: +SKIP
+# 
+# 
+#     
+task_name: ExtractROIBasedSurfaceMeasures
+nipype_name: ExtractROIBasedSurfaceMeasures
+nipype_module: nipype.interfaces.cat12.surface
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    surface_files: generic/file+list-of
+    # type=inputmultiobject|default=[]: Surface data files. This variable should be a list with all
+    lh_roi_atlas: generic/file+list-of
+    # type=inputmultiobject|default=[]: (Left) ROI Atlas. These are the ROI's 
+    rh_roi_atlas: generic/file+list-of
+    # type=inputmultiobject|default=[]: (Right) ROI Atlas. These are the ROI's 
+    lh_surface_measure: generic/file+list-of
+    # type=inputmultiobject|default=[]: (Left) Surface data files. 
+    rh_surface_measure: generic/file+list-of
+    # type=inputmultiobject|default=[]: (Right) Surface data files.
+    paths: generic/directory+list-of
+    # type=inputmultiobject|default=[]: Paths to add to matlabpath
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    surface_files:
+    # type=inputmultiobject|default=[]: Surface data files. This variable should be a list with all
+    lh_roi_atlas:
+    # type=inputmultiobject|default=[]: (Left) ROI Atlas. These are the ROI's 
+    rh_roi_atlas:
+    # type=inputmultiobject|default=[]: (Right) ROI Atlas. These are the ROI's 
+    lh_surface_measure:
+    # type=inputmultiobject|default=[]: (Left) Surface data files. 
+    rh_surface_measure:
+    # type=inputmultiobject|default=[]: (Right) Surface data files.
+    matlab_cmd:
+    # type=str|default='': matlab command to use
+    paths:
+    # type=inputmultiobject|default=[]: Paths to add to matlabpath
+    mfile:
+    # type=bool|default=True: Run m-code using m-file
+    use_mcr:
+    # type=bool|default=False: Run m-code using SPM MCR
+    use_v8struct:
+    # type=bool|default=True: Generate SPM8 and higher compatible jobs
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-cat12/extract_roi_based_surface_measures_callables.py b/example-specs/task/nipype_internal/pydra-cat12/extract_roi_based_surface_measures_callables.py
new file mode 100644
index 00000000..554c68d2
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-cat12/extract_roi_based_surface_measures_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in ExtractROIBasedSurfaceMeasures.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-cmtk/average_networks.yaml b/example-specs/task/nipype_internal/pydra-cmtk/average_networks.yaml
new file mode 100644
index 00000000..c4137da3
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-cmtk/average_networks.yaml
@@ -0,0 +1,97 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.cmtk.nx.AverageNetworks' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Calculates and outputs the average network given a set of input NetworkX gpickle files
+# 
+#     This interface will only keep an edge in the averaged network if that edge is present in
+#     at least half of the input networks.
+# 
+#     Example
+#     -------
+#     >>> import nipype.interfaces.cmtk as cmtk
+#     >>> avg = cmtk.AverageNetworks()
+#     >>> avg.inputs.in_files = ['subj1.pck', 'subj2.pck']
+#     >>> avg.run()         # doctest: +SKIP
+# 
+#     
+task_name: AverageNetworks
+nipype_name: AverageNetworks
+nipype_module: nipype.interfaces.cmtk.nx
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_files: generic/file+list-of
+    # type=inputmultiobject|default=[]: Networks for a group of subjects
+    resolution_network_file: generic/file
+    # type=file|default=<undefined>: Parcellation files from Connectome Mapping Toolkit. This is not necessary, but if included, the interface will output the statistical maps as networkx graphs.
+    out_gpickled_groupavg: generic/file
+    # type=file|default=<undefined>: Average network saved as a NetworkX .pck
+    out_gexf_groupavg: generic/file
+    # type=file|default=<undefined>: Average network saved as a .gexf file
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    gpickled_groupavg: generic/file
+    # type=file: Average network saved as a NetworkX .pck
+    gexf_groupavg: generic/file
+    # type=file: Average network saved as a .gexf file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_files:
+    # type=inputmultiobject|default=[]: Networks for a group of subjects
+    resolution_network_file:
+    # type=file|default=<undefined>: Parcellation files from Connectome Mapping Toolkit. This is not necessary, but if included, the interface will output the statistical maps as networkx graphs.
+    group_id:
+    # type=str|default='group1': ID for group
+    out_gpickled_groupavg:
+    # type=file|default=<undefined>: Average network saved as a NetworkX .pck
+    out_gexf_groupavg:
+    # type=file|default=<undefined>: Average network saved as a .gexf file
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-cmtk/average_networks_callables.py b/example-specs/task/nipype_internal/pydra-cmtk/average_networks_callables.py
new file mode 100644
index 00000000..863baeb8
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-cmtk/average_networks_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in AverageNetworks.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-cmtk/cff_converter.yaml b/example-specs/task/nipype_internal/pydra-cmtk/cff_converter.yaml
new file mode 100644
index 00000000..6d726965
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-cmtk/cff_converter.yaml
@@ -0,0 +1,137 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.cmtk.convert.CFFConverter' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Creates a Connectome File Format (CFF) file from input networks, surfaces, volumes, tracts, etcetera....
+# 
+#     Example
+#     -------
+# 
+#     >>> import nipype.interfaces.cmtk as cmtk
+#     >>> cvt = cmtk.CFFConverter()
+#     >>> cvt.inputs.title = 'subject 1'
+#     >>> cvt.inputs.gifti_surfaces = ['lh.pial_converted.gii', 'rh.pial_converted.gii']
+#     >>> cvt.inputs.tract_files = ['streamlines.trk']
+#     >>> cvt.inputs.gpickled_networks = ['network0.gpickle']
+#     >>> cvt.run()         # doctest: +SKIP
+#     
+task_name: CFFConverter
+nipype_name: CFFConverter
+nipype_module: nipype.interfaces.cmtk.convert
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    graphml_networks: generic/file+list-of
+    # type=inputmultiobject|default=[]: list of graphML networks
+    gpickled_networks: generic/file+list-of
+    # type=inputmultiobject|default=[]: list of gpickled Networkx graphs
+    gifti_surfaces: generic/file+list-of
+    # type=inputmultiobject|default=[]: list of GIFTI surfaces
+    gifti_labels: generic/file+list-of
+    # type=inputmultiobject|default=[]: list of GIFTI labels
+    nifti_volumes: generic/file+list-of
+    # type=inputmultiobject|default=[]: list of NIFTI volumes
+    tract_files: generic/file+list-of
+    # type=inputmultiobject|default=[]: list of Trackvis fiber files
+    timeseries_files: generic/file+list-of
+    # type=inputmultiobject|default=[]: list of HDF5 timeseries files
+    script_files: generic/file+list-of
+    # type=inputmultiobject|default=[]: list of script files to include
+    data_files: generic/file+list-of
+    # type=inputmultiobject|default=[]: list of external data files (i.e. Numpy, HD5, XML) 
+    out_file: generic/file
+    # type=file|default='connectome.cff': Output connectome file
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    connectome_file: generic/file
+    # type=file: Output connectome file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    graphml_networks:
+    # type=inputmultiobject|default=[]: list of graphML networks
+    gpickled_networks:
+    # type=inputmultiobject|default=[]: list of gpickled Networkx graphs
+    gifti_surfaces:
+    # type=inputmultiobject|default=[]: list of GIFTI surfaces
+    gifti_labels:
+    # type=inputmultiobject|default=[]: list of GIFTI labels
+    nifti_volumes:
+    # type=inputmultiobject|default=[]: list of NIFTI volumes
+    tract_files:
+    # type=inputmultiobject|default=[]: list of Trackvis fiber files
+    timeseries_files:
+    # type=inputmultiobject|default=[]: list of HDF5 timeseries files
+    script_files:
+    # type=inputmultiobject|default=[]: list of script files to include
+    data_files:
+    # type=inputmultiobject|default=[]: list of external data files (i.e. Numpy, HD5, XML) 
+    title:
+    # type=str|default='': Connectome Title
+    creator:
+    # type=str|default='': Creator
+    email:
+    # type=str|default='': Email address
+    publisher:
+    # type=str|default='': Publisher
+    license:
+    # type=str|default='': License
+    rights:
+    # type=str|default='': Rights
+    references:
+    # type=str|default='': References
+    relation:
+    # type=str|default='': Relation
+    species:
+    # type=str|default='Homo sapiens': Species
+    description:
+    # type=str|default='Created with the Nipype CFF converter': Description
+    out_file:
+    # type=file|default='connectome.cff': Output connectome file
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-cmtk/cff_converter_callables.py b/example-specs/task/nipype_internal/pydra-cmtk/cff_converter_callables.py
new file mode 100644
index 00000000..80595b06
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-cmtk/cff_converter_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in CFFConverter.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-cmtk/create_matrix.yaml b/example-specs/task/nipype_internal/pydra-cmtk/create_matrix.yaml
new file mode 100644
index 00000000..9fb195b2
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-cmtk/create_matrix.yaml
@@ -0,0 +1,145 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.cmtk.cmtk.CreateMatrix' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Performs connectivity mapping and outputs the result as a NetworkX graph and a Matlab matrix
+# 
+#     Example
+#     -------
+# 
+#     >>> import nipype.interfaces.cmtk as cmtk
+#     >>> conmap = cmtk.CreateMatrix()
+#     >>> conmap.inputs.roi_file = 'fsLUT_aparc+aseg.nii'
+#     >>> conmap.inputs.tract_file = 'fibers.trk'
+#     >>> conmap.run()         # doctest: +SKIP
+#     
+task_name: CreateMatrix
+nipype_name: CreateMatrix
+nipype_module: nipype.interfaces.cmtk.cmtk
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    roi_file: generic/file
+    # type=file|default=<undefined>: Freesurfer aparc+aseg file
+    tract_file: generic/file
+    # type=file|default=<undefined>: Trackvis tract file
+    resolution_network_file: generic/file
+    # type=file|default=<undefined>: Parcellation files from Connectome Mapping Toolkit
+    out_matrix_mat_file: generic/file
+    # type=file|default='cmatrix.mat': Matlab matrix describing the connectivity
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    matrix_file: generic/file
+    # type=file: NetworkX graph describing the connectivity
+    intersection_matrix_file: generic/file
+    # type=file: NetworkX graph describing the connectivity
+    matrix_mat_file: generic/file
+    # type=file: Matlab matrix describing the connectivity
+    intersection_matrix_mat_file: generic/file
+    # type=file: Matlab matrix describing the mean fiber lengths between each node.
+    mean_fiber_length_matrix_mat_file: generic/file
+    # type=file: Matlab matrix describing the mean fiber lengths between each node.
+    median_fiber_length_matrix_mat_file: generic/file
+    # type=file: Matlab matrix describing the median fiber lengths between each node.
+    fiber_length_std_matrix_mat_file: generic/file
+    # type=file: Matlab matrix describing the deviation in fiber lengths connecting each node.
+    endpoint_file: generic/file
+    # type=file: Saved Numpy array with the endpoints of each fiber
+    endpoint_file_mm: generic/file
+    # type=file: Saved Numpy array with the endpoints of each fiber (in millimeters)
+    fiber_length_file: generic/file
+    # type=file: Saved Numpy array with the lengths of each fiber
+    fiber_label_file: generic/file
+    # type=file: Saved Numpy array with the labels for each fiber
+    fiber_labels_noorphans: generic/file
+    # type=file: Saved Numpy array with the labels for each non-orphan fiber
+    filtered_tractography: generic/file
+    # type=file: TrackVis file containing only those fibers originate in one and terminate in another region
+    filtered_tractography_by_intersections: generic/file
+    # type=file: TrackVis file containing all fibers which connect two regions
+    stats_file: generic/file
+    # type=file: Saved Matlab .mat file with the number of fibers saved at each stage
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_matrix_file: out_matrix_file
+    # type=file|default=<undefined>: NetworkX graph describing the connectivity
+    out_mean_fiber_length_matrix_mat_file: out_mean_fiber_length_matrix_mat_file
+    # type=file|default=<undefined>: Matlab matrix describing the mean fiber lengths between each node.
+    out_median_fiber_length_matrix_mat_file: out_median_fiber_length_matrix_mat_file
+    # type=file|default=<undefined>: Matlab matrix describing the mean fiber lengths between each node.
+    out_fiber_length_std_matrix_mat_file: out_fiber_length_std_matrix_mat_file
+    # type=file|default=<undefined>: Matlab matrix describing the deviation in fiber lengths connecting each node.
+    out_intersection_matrix_mat_file: out_intersection_matrix_mat_file
+    # type=file|default=<undefined>: Matlab connectivity matrix if all region/fiber intersections are counted.
+    out_endpoint_array_name: out_endpoint_array_name
+    # type=file|default=<undefined>: Name for the generated endpoint arrays
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    roi_file:
+    # type=file|default=<undefined>: Freesurfer aparc+aseg file
+    tract_file:
+    # type=file|default=<undefined>: Trackvis tract file
+    resolution_network_file:
+    # type=file|default=<undefined>: Parcellation files from Connectome Mapping Toolkit
+    count_region_intersections:
+    # type=bool|default=False: Counts all of the fiber-region traversals in the connectivity matrix (requires significantly more computational time)
+    out_matrix_file:
+    # type=file|default=<undefined>: NetworkX graph describing the connectivity
+    out_matrix_mat_file:
+    # type=file|default='cmatrix.mat': Matlab matrix describing the connectivity
+    out_mean_fiber_length_matrix_mat_file:
+    # type=file|default=<undefined>: Matlab matrix describing the mean fiber lengths between each node.
+    out_median_fiber_length_matrix_mat_file:
+    # type=file|default=<undefined>: Matlab matrix describing the mean fiber lengths between each node.
+    out_fiber_length_std_matrix_mat_file:
+    # type=file|default=<undefined>: Matlab matrix describing the deviation in fiber lengths connecting each node.
+    out_intersection_matrix_mat_file:
+    # type=file|default=<undefined>: Matlab connectivity matrix if all region/fiber intersections are counted.
+    out_endpoint_array_name:
+    # type=file|default=<undefined>: Name for the generated endpoint arrays
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-cmtk/create_matrix_callables.py b/example-specs/task/nipype_internal/pydra-cmtk/create_matrix_callables.py
new file mode 100644
index 00000000..e4f4d6a6
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-cmtk/create_matrix_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in CreateMatrix.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-cmtk/create_nodes.yaml b/example-specs/task/nipype_internal/pydra-cmtk/create_nodes.yaml
new file mode 100644
index 00000000..b21a82f1
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-cmtk/create_nodes.yaml
@@ -0,0 +1,87 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.cmtk.cmtk.CreateNodes' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Generates a NetworkX graph containing nodes at the centroid of each region in the input ROI file.
+#     Node data is added from the resolution network file.
+# 
+#     Example
+#     -------
+# 
+#     >>> import nipype.interfaces.cmtk as cmtk
+#     >>> mknode = cmtk.CreateNodes()
+#     >>> mknode.inputs.roi_file = 'ROI_scale500.nii.gz'
+#     >>> mknode.run() # doctest: +SKIP
+#     
+task_name: CreateNodes
+nipype_name: CreateNodes
+nipype_module: nipype.interfaces.cmtk.cmtk
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    roi_file: generic/file
+    # type=file|default=<undefined>: Region of interest file
+    resolution_network_file: generic/file
+    # type=file|default=<undefined>: Parcellation file from Connectome Mapping Toolkit
+    out_filename: generic/file
+    # type=file|default='nodenetwork.pck': Output gpickled network with the nodes defined.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    node_network: generic/file
+    # type=file: Output gpickled network with the nodes defined.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    roi_file:
+    # type=file|default=<undefined>: Region of interest file
+    resolution_network_file:
+    # type=file|default=<undefined>: Parcellation file from Connectome Mapping Toolkit
+    out_filename:
+    # type=file|default='nodenetwork.pck': Output gpickled network with the nodes defined.
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-cmtk/create_nodes_callables.py b/example-specs/task/nipype_internal/pydra-cmtk/create_nodes_callables.py
new file mode 100644
index 00000000..b9c411cb
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-cmtk/create_nodes_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in CreateNodes.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-cmtk/merge_c_networks.yaml b/example-specs/task/nipype_internal/pydra-cmtk/merge_c_networks.yaml
new file mode 100644
index 00000000..0ba17877
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-cmtk/merge_c_networks.yaml
@@ -0,0 +1,82 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.cmtk.convert.MergeCNetworks' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Merges networks from multiple CFF files into one new CFF file.
+# 
+#     Example
+#     -------
+# 
+#     >>> import nipype.interfaces.cmtk as cmtk
+#     >>> mrg = cmtk.MergeCNetworks()
+#     >>> mrg.inputs.in_files = ['subj1.cff','subj2.cff']
+#     >>> mrg.run()          # doctest: +SKIP
+# 
+#     
+task_name: MergeCNetworks
+nipype_name: MergeCNetworks
+nipype_module: nipype.interfaces.cmtk.convert
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_files: generic/file+list-of
+    # type=inputmultiobject|default=[]: List of CFF files to extract networks from
+    out_file: generic/file
+    # type=file|default='merged_network_connectome.cff': Output CFF file with all the networks added
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    connectome_file: generic/file
+    # type=file: Output CFF file with all the networks added
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_files:
+    # type=inputmultiobject|default=[]: List of CFF files to extract networks from
+    out_file:
+    # type=file|default='merged_network_connectome.cff': Output CFF file with all the networks added
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-cmtk/merge_c_networks_callables.py b/example-specs/task/nipype_internal/pydra-cmtk/merge_c_networks_callables.py
new file mode 100644
index 00000000..399f1205
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-cmtk/merge_c_networks_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in MergeCNetworks.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-cmtk/network_based_statistic.yaml b/example-specs/task/nipype_internal/pydra-cmtk/network_based_statistic.yaml
new file mode 100644
index 00000000..f387d96a
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-cmtk/network_based_statistic.yaml
@@ -0,0 +1,110 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.cmtk.nbs.NetworkBasedStatistic' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Calculates and outputs the average network given a set of input NetworkX gpickle files
+# 
+#     See Also
+#     --------
+#     For documentation of Network-based statistic parameters:
+#     https://github.com/LTS5/connectomeviewer/blob/master/cviewer/libs/pyconto/groupstatistics/nbs/_nbs.py
+# 
+#     Example
+#     -------
+#     >>> import nipype.interfaces.cmtk as cmtk
+#     >>> nbs = cmtk.NetworkBasedStatistic()
+#     >>> nbs.inputs.in_group1 = ['subj1.pck', 'subj2.pck'] # doctest: +SKIP
+#     >>> nbs.inputs.in_group2 = ['pat1.pck', 'pat2.pck'] # doctest: +SKIP
+#     >>> nbs.run()         # doctest: +SKIP
+# 
+#     
+task_name: NetworkBasedStatistic
+nipype_name: NetworkBasedStatistic
+nipype_module: nipype.interfaces.cmtk.nbs
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_group1: generic/file+list-of
+    # type=inputmultiobject|default=[]: Networks for the first group of subjects
+    in_group2: generic/file+list-of
+    # type=inputmultiobject|default=[]: Networks for the second group of subjects
+    node_position_network: generic/file
+    # type=file|default=<undefined>: An optional network used to position the nodes for the output networks
+    out_nbs_network: generic/file
+    # type=file|default=<undefined>: Output network with edges identified by the NBS
+    out_nbs_pval_network: generic/file
+    # type=file|default=<undefined>: Output network with p-values to weight the edges identified by the NBS
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    nbs_network: generic/file
+    # type=file: Output network with edges identified by the NBS
+    nbs_pval_network: generic/file
+    # type=file: Output network with p-values to weight the edges identified by the NBS
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_group1:
+    # type=inputmultiobject|default=[]: Networks for the first group of subjects
+    in_group2:
+    # type=inputmultiobject|default=[]: Networks for the second group of subjects
+    node_position_network:
+    # type=file|default=<undefined>: An optional network used to position the nodes for the output networks
+    number_of_permutations:
+    # type=int|default=1000: Number of permutations to perform
+    threshold:
+    # type=float|default=3: T-statistic threshold
+    t_tail:
+    # type=enum|default='left'|allowed['both','left','right']: Can be one of "left", "right", or "both"
+    edge_key:
+    # type=str|default='number_of_fibers': Usually "number_of_fibers, "fiber_length_mean", "fiber_length_std" for matrices made with CMTKSometimes "weight" or "value" for functional networks.
+    out_nbs_network:
+    # type=file|default=<undefined>: Output network with edges identified by the NBS
+    out_nbs_pval_network:
+    # type=file|default=<undefined>: Output network with p-values to weight the edges identified by the NBS
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-cmtk/network_based_statistic_callables.py b/example-specs/task/nipype_internal/pydra-cmtk/network_based_statistic_callables.py
new file mode 100644
index 00000000..913112fe
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-cmtk/network_based_statistic_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in NetworkBasedStatistic.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-cmtk/network_x_metrics.yaml b/example-specs/task/nipype_internal/pydra-cmtk/network_x_metrics.yaml
new file mode 100644
index 00000000..457bacb1
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-cmtk/network_x_metrics.yaml
@@ -0,0 +1,122 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.cmtk.nx.NetworkXMetrics' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Calculates and outputs NetworkX-based measures for an input network
+# 
+#     Example
+#     -------
+#     >>> import nipype.interfaces.cmtk as cmtk
+#     >>> nxmetrics = cmtk.NetworkXMetrics()
+#     >>> nxmetrics.inputs.in_file = 'subj1.pck'
+#     >>> nxmetrics.run()         # doctest: +SKIP
+# 
+#     
+task_name: NetworkXMetrics
+nipype_name: NetworkXMetrics
+nipype_module: nipype.interfaces.cmtk.nx
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: Input network
+    out_k_core: generic/file
+    # type=file|default='k_core': Computed k-core network stored as a NetworkX pickle.
+    out_k_shell: generic/file
+    # type=file|default='k_shell': Computed k-shell network stored as a NetworkX pickle.
+    out_k_crust: generic/file
+    # type=file|default='k_crust': Computed k-crust network stored as a NetworkX pickle.
+    out_pickled_extra_measures: generic/file
+    # type=file|default='extra_measures': Network measures for group 1 that return dictionaries stored as a Pickle.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    global_measures_matlab: generic/file
+    # type=file: Output global metrics in MATLAB .mat format
+    node_measures_matlab: generic/file
+    # type=file: Output node metrics in MATLAB .mat format
+    edge_measures_matlab: generic/file
+    # type=file: Output edge metrics in MATLAB .mat format
+    k_core: generic/file
+    # type=file: Computed k-core network stored as a NetworkX pickle.
+    k_shell: generic/file
+    # type=file: Computed k-shell network stored as a NetworkX pickle.
+    k_crust: generic/file
+    # type=file: Computed k-crust network stored as a NetworkX pickle.
+    pickled_extra_measures: generic/file
+    # type=file: Network measures for the group that return dictionaries, stored as a Pickle.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_global_metrics_matlab: out_global_metrics_matlab
+    # type=file|default=<undefined>: Output node metrics in MATLAB .mat format
+    out_node_metrics_matlab: out_node_metrics_matlab
+    # type=file|default=<undefined>: Output node metrics in MATLAB .mat format
+    out_edge_metrics_matlab: out_edge_metrics_matlab
+    # type=file|default=<undefined>: Output edge metrics in MATLAB .mat format
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: Input network
+    out_k_core:
+    # type=file|default='k_core': Computed k-core network stored as a NetworkX pickle.
+    out_k_shell:
+    # type=file|default='k_shell': Computed k-shell network stored as a NetworkX pickle.
+    out_k_crust:
+    # type=file|default='k_crust': Computed k-crust network stored as a NetworkX pickle.
+    treat_as_weighted_graph:
+    # type=bool|default=True: Some network metrics can be calculated while considering only a binarized version of the graph
+    compute_clique_related_measures:
+    # type=bool|default=False: Computing clique-related measures (e.g. node clique number) can be very time consuming
+    out_global_metrics_matlab:
+    # type=file|default=<undefined>: Output node metrics in MATLAB .mat format
+    out_node_metrics_matlab:
+    # type=file|default=<undefined>: Output node metrics in MATLAB .mat format
+    out_edge_metrics_matlab:
+    # type=file|default=<undefined>: Output edge metrics in MATLAB .mat format
+    out_pickled_extra_measures:
+    # type=file|default='extra_measures': Network measures for group 1 that return dictionaries stored as a Pickle.
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-cmtk/network_x_metrics_callables.py b/example-specs/task/nipype_internal/pydra-cmtk/network_x_metrics_callables.py
new file mode 100644
index 00000000..75555b38
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-cmtk/network_x_metrics_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in NetworkXMetrics.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-cmtk/parcellate.yaml b/example-specs/task/nipype_internal/pydra-cmtk/parcellate.yaml
new file mode 100644
index 00000000..8a91af56
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-cmtk/parcellate.yaml
@@ -0,0 +1,113 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.cmtk.parcellation.Parcellate' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Subdivides segmented ROI file into smaller subregions
+# 
+#     This interface implements the same procedure as in the ConnectomeMapper's
+#     parcellation stage (cmp/stages/parcellation/maskcreation.py) for a single
+#     parcellation scheme (e.g. 'scale500').
+# 
+#     Example
+#     -------
+# 
+#     >>> import nipype.interfaces.cmtk as cmtk
+#     >>> parcellate = cmtk.Parcellate()
+#     >>> parcellate.inputs.freesurfer_dir = '.'
+#     >>> parcellate.inputs.subjects_dir = '.'
+#     >>> parcellate.inputs.subject_id = 'subj1'
+#     >>> parcellate.inputs.dilation = True
+#     >>> parcellate.inputs.parcellation_name = 'scale500'
+#     >>> parcellate.run()         # doctest: +SKIP
+#     
+task_name: Parcellate
+nipype_name: Parcellate
+nipype_module: nipype.interfaces.cmtk.parcellation
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    freesurfer_dir: generic/directory
+    # type=directory|default=<undefined>: Freesurfer main directory
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: Freesurfer subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    roi_file: generic/file
+    # type=file: Region of Interest file for connectivity mapping
+    roiv_file: generic/file
+    # type=file: Region of Interest file for fMRI connectivity mapping
+    white_matter_mask_file: generic/file
+    # type=file: White matter mask file
+    cc_unknown_file: generic/file
+    # type=file: Image file with regions labelled as unknown cortical structures
+    ribbon_file: generic/file
+    # type=file: Image file detailing the cortical ribbon
+    aseg_file: generic/file
+    # type=file: Automated segmentation file converted from Freesurfer "subjects" directory
+    roi_file_in_structural_space: generic/file
+    # type=file: ROI image resliced to the dimensions of the original structural image
+    dilated_roi_file_in_structural_space: generic/file
+    # type=file: dilated ROI image resliced to the dimensions of the original structural image
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_roi_file: out_roi_file
+    # type=file|default=<undefined>: Region of Interest file for connectivity mapping
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    subject_id:
+    # type=string|default='': Subject ID
+    parcellation_name:
+    # type=enum|default='scale500'|allowed['scale125','scale250','scale33','scale500','scale60']: 
+    freesurfer_dir:
+    # type=directory|default=<undefined>: Freesurfer main directory
+    subjects_dir:
+    # type=directory|default=<undefined>: Freesurfer subjects directory
+    out_roi_file:
+    # type=file|default=<undefined>: Region of Interest file for connectivity mapping
+    dilation:
+    # type=bool|default=False: Dilate cortical parcels? Useful for fMRI connectivity
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-cmtk/parcellate_callables.py b/example-specs/task/nipype_internal/pydra-cmtk/parcellate_callables.py
new file mode 100644
index 00000000..f89b306b
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-cmtk/parcellate_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Parcellate.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-cmtk/roi_gen.yaml b/example-specs/task/nipype_internal/pydra-cmtk/roi_gen.yaml
new file mode 100644
index 00000000..8ef0ea6f
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-cmtk/roi_gen.yaml
@@ -0,0 +1,107 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.cmtk.cmtk.ROIGen' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Generates a ROI file for connectivity mapping and a dictionary file containing relevant node information
+# 
+#     Example
+#     -------
+# 
+#     >>> import nipype.interfaces.cmtk as cmtk
+#     >>> rg = cmtk.ROIGen()
+#     >>> rg.inputs.aparc_aseg_file = 'aparc+aseg.nii'
+#     >>> rg.inputs.use_freesurfer_LUT = True
+#     >>> rg.inputs.freesurfer_dir = '/usr/local/freesurfer'
+#     >>> rg.run() # doctest: +SKIP
+# 
+#     The label dictionary is written to disk using Pickle. Resulting data can be loaded using:
+# 
+#     >>> file = open("FreeSurferColorLUT_adapted_aparc+aseg_out.pck", "r")
+#     >>> file = open("fsLUT_aparc+aseg.pck", "r")
+#     >>> labelDict = pickle.load(file) # doctest: +SKIP
+#     >>> labelDict             # doctest: +SKIP
+#     
+task_name: ROIGen
+nipype_name: ROIGen
+nipype_module: nipype.interfaces.cmtk.cmtk
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    aparc_aseg_file: generic/file
+    # type=file|default=<undefined>: Freesurfer aparc+aseg file
+    LUT_file: generic/file
+    # type=file|default=<undefined>: Custom lookup table (cf. FreeSurferColorLUT.txt)
+    freesurfer_dir: generic/directory
+    # type=directory|default=<undefined>: Freesurfer main directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    roi_file: generic/file
+    # type=file: Region of Interest file for connectivity mapping
+    dict_file: generic/file
+    # type=file: Label dictionary saved in Pickle format
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_roi_file: out_roi_file
+    # type=file|default=<undefined>: Region of Interest file for connectivity mapping
+    out_dict_file: out_dict_file
+    # type=file|default=<undefined>: Label dictionary saved in Pickle format
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    aparc_aseg_file:
+    # type=file|default=<undefined>: Freesurfer aparc+aseg file
+    LUT_file:
+    # type=file|default=<undefined>: Custom lookup table (cf. FreeSurferColorLUT.txt)
+    use_freesurfer_LUT:
+    # type=bool|default=False: Boolean value; Set to True to use default Freesurfer LUT, False for custom LUT
+    freesurfer_dir:
+    # type=directory|default=<undefined>: Freesurfer main directory
+    out_roi_file:
+    # type=file|default=<undefined>: Region of Interest file for connectivity mapping
+    out_dict_file:
+    # type=file|default=<undefined>: Label dictionary saved in Pickle format
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-cmtk/roi_gen_callables.py b/example-specs/task/nipype_internal/pydra-cmtk/roi_gen_callables.py
new file mode 100644
index 00000000..02d257c5
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-cmtk/roi_gen_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in ROIGen.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dcmstack/copy_meta.yaml b/example-specs/task/nipype_internal/pydra-dcmstack/copy_meta.yaml
new file mode 100644
index 00000000..80a4aad3
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dcmstack/copy_meta.yaml
@@ -0,0 +1,80 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.dcmstack.CopyMeta' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Copy meta data from one Nifti file to another. Useful for preserving
+#     meta data after some processing steps.
+task_name: CopyMeta
+nipype_name: CopyMeta
+nipype_module: nipype.interfaces.dcmstack
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    src_file: generic/file
+    # type=file|default=<undefined>: 
+    dest_file: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: 
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    dest_file: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: 
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    src_file:
+    # type=file|default=<undefined>: 
+    dest_file:
+    # type=file: 
+    # type=file|default=<undefined>: 
+    include_classes:
+    # type=list|default=[]: List of specific meta data classifications to include. If not specified include everything.
+    exclude_classes:
+    # type=list|default=[]: List of meta data classifications to exclude
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-dcmstack/copy_meta_callables.py b/example-specs/task/nipype_internal/pydra-dcmstack/copy_meta_callables.py
new file mode 100644
index 00000000..b657da5f
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dcmstack/copy_meta_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in CopyMeta.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dcmstack/dcm_stack.yaml b/example-specs/task/nipype_internal/pydra-dcmstack/dcm_stack.yaml
new file mode 100644
index 00000000..9e1b9441
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dcmstack/dcm_stack.yaml
@@ -0,0 +1,94 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.dcmstack.DcmStack' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Create one Nifti file from a set of DICOM files. Can optionally embed
+#     meta data.
+# 
+#     Example
+#     -------
+# 
+#     >>> from nipype.interfaces.dcmstack import DcmStack
+#     >>> stacker = DcmStack()
+#     >>> stacker.inputs.dicom_files = 'path/to/series/'
+#     >>> stacker.run() # doctest: +SKIP
+#     >>> result.outputs.out_file # doctest: +SKIP
+#     '/path/to/cwd/sequence.nii.gz'
+#     
+task_name: DcmStack
+nipype_name: DcmStack
+nipype_module: nipype.interfaces.dcmstack
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_path: generic/directory
+    # type=directory|default=<undefined>: output path, current working directory if not set
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: 
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    dicom_files:
+    # type=traitcompound|default=[None]: 
+    embed_meta:
+    # type=bool|default=False: Embed DICOM meta data into result
+    exclude_regexes:
+    # type=list|default=[]: Meta data to exclude, suplementing any default exclude filters
+    include_regexes:
+    # type=list|default=[]: Meta data to include, overriding any exclude filters
+    force_read:
+    # type=bool|default=True: Force reading files without DICM marker
+    out_format:
+    # type=str|default='': String which can be formatted with meta data to create the output filename(s)
+    out_ext:
+    # type=str|default='.nii.gz': Determines output file type
+    out_path:
+    # type=directory|default=<undefined>: output path, current working directory if not set
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-dcmstack/dcm_stack_callables.py b/example-specs/task/nipype_internal/pydra-dcmstack/dcm_stack_callables.py
new file mode 100644
index 00000000..394aa6a3
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dcmstack/dcm_stack_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in DcmStack.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dcmstack/group_and_stack.yaml b/example-specs/task/nipype_internal/pydra-dcmstack/group_and_stack.yaml
new file mode 100644
index 00000000..87bc591a
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dcmstack/group_and_stack.yaml
@@ -0,0 +1,80 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.dcmstack.GroupAndStack' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Create (potentially) multiple Nifti files for a set of DICOM files.
+task_name: GroupAndStack
+nipype_name: GroupAndStack
+nipype_module: nipype.interfaces.dcmstack
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_path: generic/directory
+    # type=directory|default=<undefined>: output path, current working directory if not set
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    dicom_files:
+    # type=traitcompound|default=[None]: 
+    embed_meta:
+    # type=bool|default=False: Embed DICOM meta data into result
+    exclude_regexes:
+    # type=list|default=[]: Meta data to exclude, suplementing any default exclude filters
+    include_regexes:
+    # type=list|default=[]: Meta data to include, overriding any exclude filters
+    force_read:
+    # type=bool|default=True: Force reading files without DICM marker
+    out_format:
+    # type=str|default='': String which can be formatted with meta data to create the output filename(s)
+    out_ext:
+    # type=str|default='.nii.gz': Determines output file type
+    out_path:
+    # type=directory|default=<undefined>: output path, current working directory if not set
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-dcmstack/group_and_stack_callables.py b/example-specs/task/nipype_internal/pydra-dcmstack/group_and_stack_callables.py
new file mode 100644
index 00000000..a4ab5d7d
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dcmstack/group_and_stack_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in GroupAndStack.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dcmstack/lookup_meta.yaml b/example-specs/task/nipype_internal/pydra-dcmstack/lookup_meta.yaml
new file mode 100644
index 00000000..94817020
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dcmstack/lookup_meta.yaml
@@ -0,0 +1,82 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.dcmstack.LookupMeta' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Lookup meta data values from a Nifti with embedded meta data.
+# 
+#     Example
+#     -------
+# 
+#     >>> from nipype.interfaces import dcmstack
+#     >>> lookup = dcmstack.LookupMeta()
+#     >>> lookup.inputs.in_file = 'functional.nii'
+#     >>> lookup.inputs.meta_keys = {'RepetitionTime' : 'TR',                                    'EchoTime' : 'TE'}
+#     >>> result = lookup.run() # doctest: +SKIP
+#     >>> result.outputs.TR # doctest: +SKIP
+#     9500.0
+#     >>> result.outputs.TE # doctest: +SKIP
+#     95.0
+#     
+task_name: LookupMeta
+nipype_name: LookupMeta
+nipype_module: nipype.interfaces.dcmstack
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: The input Nifti file
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: The input Nifti file
+    meta_keys:
+    # type=traitcompound|default=None: List of meta data keys to lookup, or a dict where keys specify the meta data keys to lookup and the values specify the output names
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-dcmstack/lookup_meta_callables.py b/example-specs/task/nipype_internal/pydra-dcmstack/lookup_meta_callables.py
new file mode 100644
index 00000000..e5cd4092
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dcmstack/lookup_meta_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in LookupMeta.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dcmstack/merge_nifti.yaml b/example-specs/task/nipype_internal/pydra-dcmstack/merge_nifti.yaml
new file mode 100644
index 00000000..1a4668fe
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dcmstack/merge_nifti.yaml
@@ -0,0 +1,79 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.dcmstack.MergeNifti' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Merge multiple Nifti files into one. Merges together meta data
+#     extensions as well.
+task_name: MergeNifti
+nipype_name: MergeNifti
+nipype_module: nipype.interfaces.dcmstack
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_path: generic/directory
+    # type=directory|default=<undefined>: output path, current working directory if not set
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: Merged Nifti file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_files:
+    # type=list|default=[]: List of Nifti files to merge
+    sort_order:
+    # type=traitcompound|default=None: One or more meta data keys to sort files by.
+    merge_dim:
+    # type=int|default=0: Dimension to merge along. If not specified, the last singular or non-existent dimension is used.
+    out_format:
+    # type=str|default='': String which can be formatted with meta data to create the output filename(s)
+    out_ext:
+    # type=str|default='.nii.gz': Determines output file type
+    out_path:
+    # type=directory|default=<undefined>: output path, current working directory if not set
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-dcmstack/merge_nifti_callables.py b/example-specs/task/nipype_internal/pydra-dcmstack/merge_nifti_callables.py
new file mode 100644
index 00000000..18653890
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dcmstack/merge_nifti_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in MergeNifti.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dcmstack/nifti_generator_base.yaml b/example-specs/task/nipype_internal/pydra-dcmstack/nifti_generator_base.yaml
new file mode 100644
index 00000000..b3090206
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dcmstack/nifti_generator_base.yaml
@@ -0,0 +1,63 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.dcmstack.NiftiGeneratorBase' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Base class for interfaces that produce Nifti files, potentially with
+#     embedded meta data.
+task_name: NiftiGeneratorBase
+nipype_name: NiftiGeneratorBase
+nipype_module: nipype.interfaces.dcmstack
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-dcmstack/nifti_generator_base_callables.py b/example-specs/task/nipype_internal/pydra-dcmstack/nifti_generator_base_callables.py
new file mode 100644
index 00000000..7366fad2
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dcmstack/nifti_generator_base_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in NiftiGeneratorBase.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dcmstack/split_nifti.yaml b/example-specs/task/nipype_internal/pydra-dcmstack/split_nifti.yaml
new file mode 100644
index 00000000..e7c1dc2d
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dcmstack/split_nifti.yaml
@@ -0,0 +1,79 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.dcmstack.SplitNifti' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Split one Nifti file into many along the specified dimension. Each
+#     result has an updated meta data extension as well.
+#     
+task_name: SplitNifti
+nipype_name: SplitNifti
+nipype_module: nipype.interfaces.dcmstack
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: Nifti file to split
+    out_path: generic/directory
+    # type=directory|default=<undefined>: output path, current working directory if not set
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: Nifti file to split
+    split_dim:
+    # type=int|default=0: Dimension to split along. If not specified, the last dimension is used.
+    out_format:
+    # type=str|default='': String which can be formatted with meta data to create the output filename(s)
+    out_ext:
+    # type=str|default='.nii.gz': Determines output file type
+    out_path:
+    # type=directory|default=<undefined>: output path, current working directory if not set
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-dcmstack/split_nifti_callables.py b/example-specs/task/nipype_internal/pydra-dcmstack/split_nifti_callables.py
new file mode 100644
index 00000000..7ee89996
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dcmstack/split_nifti_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in SplitNifti.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-diffusion_toolkit/dti_recon.yaml b/example-specs/task/nipype_internal/pydra-diffusion_toolkit/dti_recon.yaml
new file mode 100644
index 00000000..6a586140
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-diffusion_toolkit/dti_recon.yaml
@@ -0,0 +1,114 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.diffusion_toolkit.dti.DTIRecon' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Use dti_recon to generate tensors and other maps
+task_name: DTIRecon
+nipype_name: DTIRecon
+nipype_module: nipype.interfaces.diffusion_toolkit.dti
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    DWI: generic/file
+    # type=file|default=<undefined>: Input diffusion volume
+    bvecs: generic/file
+    # type=file|default=<undefined>: b vectors file
+    bvals: generic/file
+    # type=file|default=<undefined>: b values file
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    ADC: generic/file
+    # type=file: 
+    B0: generic/file
+    # type=file: 
+    L1: generic/file
+    # type=file: 
+    L2: generic/file
+    # type=file: 
+    L3: generic/file
+    # type=file: 
+    exp: generic/file
+    # type=file: 
+    FA: generic/file
+    # type=file: 
+    FA_color: generic/file
+    # type=file: 
+    tensor: generic/file
+    # type=file: 
+    V1: generic/file
+    # type=file: 
+    V2: generic/file
+    # type=file: 
+    V3: generic/file
+    # type=file: 
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    DWI:
+    # type=file|default=<undefined>: Input diffusion volume
+    out_prefix:
+    # type=str|default='dti': Output file prefix
+    output_type:
+    # type=enum|default='nii'|allowed['analyze','ni1','nii','nii.gz']: output file type
+    bvecs:
+    # type=file|default=<undefined>: b vectors file
+    bvals:
+    # type=file|default=<undefined>: b values file
+    n_averages:
+    # type=int|default=0: Number of averages
+    image_orientation_vectors:
+    # type=list|default=[]: Specify image orientation vectors. if just one argument given, will treat it as filename and read the orientation vectors from the file. If 6 arguments are given, will treat them as 6 float numbers and construct the 1st and 2nd vector and calculate the 3rd one automatically. This information will be used to determine image orientation, as well as to adjust gradient vectors with oblique angle when.
+    oblique_correction:
+    # type=bool|default=False: When oblique angle(s) applied, some SIEMENS DTI protocols do not adjust gradient accordingly, thus it requires adjustment for correct diffusion tensor calculation
+    b0_threshold:
+    # type=float|default=0.0: Program will use b0 image with the given threshold to mask out high background of fa/adc maps. by default it will calculate threshold automatically. but if it failed, you need to set it manually.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-diffusion_toolkit/dti_recon_callables.py b/example-specs/task/nipype_internal/pydra-diffusion_toolkit/dti_recon_callables.py
new file mode 100644
index 00000000..a759e3e4
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-diffusion_toolkit/dti_recon_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in DTIRecon.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-diffusion_toolkit/dti_tracker.yaml b/example-specs/task/nipype_internal/pydra-diffusion_toolkit/dti_tracker.yaml
new file mode 100644
index 00000000..fb01efd1
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-diffusion_toolkit/dti_tracker.yaml
@@ -0,0 +1,122 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.diffusion_toolkit.dti.DTITracker' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+task_name: DTITracker
+nipype_name: DTITracker
+nipype_module: nipype.interfaces.diffusion_toolkit.dti
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    tensor_file: generic/file
+    # type=file|default=<undefined>: reconstructed tensor file
+    mask1_file: generic/file
+    # type=file|default=<undefined>: first mask image
+    mask2_file: generic/file
+    # type=file|default=<undefined>: second mask image
+    output_file: generic/file
+    # type=file|default='tracks.trk': 
+    output_mask: generic/file
+    # type=file|default=<undefined>: output a binary mask file in analyze format
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    track_file: generic/file
+    # type=file: 
+    mask_file: generic/file
+    # type=file: 
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    tensor_file:
+    # type=file|default=<undefined>: reconstructed tensor file
+    input_type:
+    # type=enum|default='nii'|allowed['analyze','ni1','nii','nii.gz']: Input and output file type. Accepted values are:  * analyze -> analyze format 7.5 * ni1     -> nifti format saved in separate .hdr and .img file * nii     -> nifti format with one .nii file * nii.gz  -> nifti format with compression  Default type is 'nii' 
+    tracking_method:
+    # type=enum|default='fact'|allowed['fact','rk2','sl','tl']: Tracking algorithm.  * fact -> use FACT method for tracking. This is the default method. * rk2  -> use 2nd order Runge-Kutta method for tracking. * tl   -> use tensorline method for tracking. * sl   -> use interpolated streamline method with fixed step-length  
+    step_length:
+    # type=float|default=0.0: Step length, in the unit of minimum voxel size. default value is 0.5 for interpolated streamline method and 0.1 for other methods
+    angle_threshold:
+    # type=float|default=0.0: set angle threshold. default value is 35 degree
+    angle_threshold_weight:
+    # type=float|default=0.0: set angle threshold weighting factor. weighting will be applied on top of the angle_threshold
+    random_seed:
+    # type=int|default=0: use random location in a voxel instead of the center of the voxel to seed. can also define number of seed per voxel. default is 1
+    invert_x:
+    # type=bool|default=False: invert x component of the vector
+    invert_y:
+    # type=bool|default=False: invert y component of the vector
+    invert_z:
+    # type=bool|default=False: invert z component of the vector
+    swap_xy:
+    # type=bool|default=False: swap x & y vectors while tracking
+    swap_yz:
+    # type=bool|default=False: swap y & z vectors while tracking
+    swap_zx:
+    # type=bool|default=False: swap x & z vectors while tracking
+    mask1_file:
+    # type=file|default=<undefined>: first mask image
+    mask1_threshold:
+    # type=float|default=0.0: threshold value for the first mask image, if not given, the program will try automatically find the threshold
+    mask2_file:
+    # type=file|default=<undefined>: second mask image
+    mask2_threshold:
+    # type=float|default=0.0: threshold value for the second mask image, if not given, the program will try automatically find the threshold
+    input_data_prefix:
+    # type=str|default='dti': for internal naming use only
+    output_file:
+    # type=file|default='tracks.trk': 
+    output_mask:
+    # type=file|default=<undefined>: output a binary mask file in analyze format
+    primary_vector:
+    # type=enum|default='v2'|allowed['v2','v3']: which vector to use for fibre tracking: v2 or v3. If not set use v1
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-diffusion_toolkit/dti_tracker_callables.py b/example-specs/task/nipype_internal/pydra-diffusion_toolkit/dti_tracker_callables.py
new file mode 100644
index 00000000..916e0701
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-diffusion_toolkit/dti_tracker_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in DTITracker.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-diffusion_toolkit/hardi_mat.yaml b/example-specs/task/nipype_internal/pydra-diffusion_toolkit/hardi_mat.yaml
new file mode 100644
index 00000000..d7aeb313
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-diffusion_toolkit/hardi_mat.yaml
@@ -0,0 +1,101 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.diffusion_toolkit.odf.HARDIMat' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Use hardi_mat to calculate a reconstruction matrix from a gradient table
+task_name: HARDIMat
+nipype_name: HARDIMat
+nipype_module: nipype.interfaces.diffusion_toolkit.odf
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    bvecs: generic/file
+    # type=file|default=<undefined>: b vectors file
+    bvals: generic/file
+    # type=file|default=<undefined>: b values file
+    out_file: generic/file
+    # type=file: output matrix file
+    # type=file|default='recon_mat.dat': output matrix file
+    odf_file: generic/file
+    # type=file|default=<undefined>: Filename that contains the reconstruction points on a HEMI-sphere. Use the pre-set 181 points by default
+    reference_file: generic/file
+    # type=file|default=<undefined>: Provide a dicom or nifti image as the reference for the program to figure out the image orientation information. if no such info was found in the given image header, the next 5 options -info, etc., will be used if provided. if image orientation info can be found in the given reference, all other 5 image orientation options will be IGNORED
+    image_info: generic/file
+    # type=file|default=<undefined>: specify image information file. the image info file is generated from original dicom image by diff_unpack program and contains image orientation and other information needed for reconstruction and tracking. by default will look into the image folder for .info file
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: output matrix file
+    # type=file|default='recon_mat.dat': output matrix file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    bvecs:
+    # type=file|default=<undefined>: b vectors file
+    bvals:
+    # type=file|default=<undefined>: b values file
+    out_file:
+    # type=file: output matrix file
+    # type=file|default='recon_mat.dat': output matrix file
+    order:
+    # type=int|default=0: maximum order of spherical harmonics. must be even number. default is 4
+    odf_file:
+    # type=file|default=<undefined>: Filename that contains the reconstruction points on a HEMI-sphere. Use the pre-set 181 points by default
+    reference_file:
+    # type=file|default=<undefined>: Provide a dicom or nifti image as the reference for the program to figure out the image orientation information. if no such info was found in the given image header, the next 5 options -info, etc., will be used if provided. if image orientation info can be found in the given reference, all other 5 image orientation options will be IGNORED
+    image_info:
+    # type=file|default=<undefined>: specify image information file. the image info file is generated from original dicom image by diff_unpack program and contains image orientation and other information needed for reconstruction and tracking. by default will look into the image folder for .info file
+    image_orientation_vectors:
+    # type=list|default=[]: specify image orientation vectors. if just one argument given, will treat it as filename and read the orientation vectors from the file. if 6 arguments are given, will treat them as 6 float numbers and construct the 1st and 2nd vector and calculate the 3rd one automatically. this information will be used to determine image orientation, as well as to adjust gradient vectors with oblique angle when
+    oblique_correction:
+    # type=bool|default=False: when oblique angle(s) applied, some SIEMENS dti protocols do not adjust gradient accordingly, thus it requires adjustment for correct diffusion tensor calculation
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-diffusion_toolkit/hardi_mat_callables.py b/example-specs/task/nipype_internal/pydra-diffusion_toolkit/hardi_mat_callables.py
new file mode 100644
index 00000000..d0dc5d6a
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-diffusion_toolkit/hardi_mat_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in HARDIMat.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-diffusion_toolkit/odf_recon.yaml b/example-specs/task/nipype_internal/pydra-diffusion_toolkit/odf_recon.yaml
new file mode 100644
index 00000000..4b6f1df0
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-diffusion_toolkit/odf_recon.yaml
@@ -0,0 +1,111 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.diffusion_toolkit.odf.ODFRecon' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Use odf_recon to generate tensors and other maps
+task_name: ODFRecon
+nipype_name: ODFRecon
+nipype_module: nipype.interfaces.diffusion_toolkit.odf
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    DWI: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: Input raw data
+    matrix: generic/file
+    # type=file|default=<undefined>: use given file as reconstruction matrix.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    B0: generic/file
+    # type=file: 
+    DWI: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: Input raw data
+    max: generic/file
+    # type=file: 
+    ODF: generic/file
+    # type=file: 
+    entropy: generic/file
+    # type=file: 
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    DWI:
+    # type=file: 
+    # type=file|default=<undefined>: Input raw data
+    n_directions:
+    # type=int|default=0: Number of directions
+    n_output_directions:
+    # type=int|default=0: Number of output directions
+    out_prefix:
+    # type=str|default='odf': Output file prefix
+    matrix:
+    # type=file|default=<undefined>: use given file as reconstruction matrix.
+    n_b0:
+    # type=int|default=0: number of b0 scans. by default the program gets this information from the number of directions and number of volumes in the raw data. useful when dealing with incomplete raw data set or only using part of raw data set to reconstruct
+    output_type:
+    # type=enum|default='nii'|allowed['analyze','ni1','nii','nii.gz']: output file type
+    sharpness:
+    # type=float|default=0.0: smooth or sharpen the raw data. factor > 0 is smoothing. factor < 0 is sharpening. default value is 0 NOTE: this option applies to DSI study only
+    filter:
+    # type=bool|default=False: apply a filter (e.g. high pass) to the raw image
+    subtract_background:
+    # type=bool|default=False: subtract the background value before reconstruction
+    dsi:
+    # type=bool|default=False: indicates that the data is dsi
+    output_entropy:
+    # type=bool|default=False: output entropy map
+    image_orientation_vectors:
+    # type=list|default=[]: specify image orientation vectors. if just one argument given, will treat it as filename and read the orientation vectors from the file. if 6 arguments are given, will treat them as 6 float numbers and construct the 1st and 2nd vector and calculate the 3rd one automatically. this information will be used to determine image orientation, as well as to adjust gradient vectors with oblique angle when
+    oblique_correction:
+    # type=bool|default=False: when oblique angle(s) applied, some SIEMENS dti protocols do not adjust gradient accordingly, thus it requires adjustment for correct diffusion tensor calculation
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-diffusion_toolkit/odf_recon_callables.py b/example-specs/task/nipype_internal/pydra-diffusion_toolkit/odf_recon_callables.py
new file mode 100644
index 00000000..1e5abb7f
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-diffusion_toolkit/odf_recon_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in ODFRecon.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-diffusion_toolkit/odf_tracker.yaml b/example-specs/task/nipype_internal/pydra-diffusion_toolkit/odf_tracker.yaml
new file mode 100644
index 00000000..b465c3bf
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-diffusion_toolkit/odf_tracker.yaml
@@ -0,0 +1,128 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.diffusion_toolkit.odf.ODFTracker' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Use odf_tracker to generate track file
+task_name: ODFTracker
+nipype_name: ODFTracker
+nipype_module: nipype.interfaces.diffusion_toolkit.odf
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    max: generic/file
+    # type=file|default=<undefined>: 
+    ODF: generic/file
+    # type=file|default=<undefined>: 
+    out_file: generic/file
+    # type=file|default='tracks.trk': output track file
+    mask1_file: generic/file
+    # type=file|default=<undefined>: first mask image
+    mask2_file: generic/file
+    # type=file|default=<undefined>: second mask image
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    track_file: generic/file
+    # type=file: output track file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    max:
+    # type=file|default=<undefined>: 
+    ODF:
+    # type=file|default=<undefined>: 
+    input_data_prefix:
+    # type=str|default='odf': recon data prefix
+    out_file:
+    # type=file|default='tracks.trk': output track file
+    input_output_type:
+    # type=enum|default='nii'|allowed['analyze','ni1','nii','nii.gz']: input and output file type
+    runge_kutta2:
+    # type=bool|default=False: use 2nd order Runge-Kutta method for tracking. default tracking method is non-interpolate streamline
+    step_length:
+    # type=float|default=0.0: set step length, in the unit of minimum voxel size. default value is 0.1.
+    angle_threshold:
+    # type=float|default=0.0: set angle threshold. default value is 35 degree for default tracking method and 25 for rk2
+    random_seed:
+    # type=int|default=0: use random location in a voxel instead of the center of the voxel to seed. can also define number of seed per voxel. default is 1
+    invert_x:
+    # type=bool|default=False: invert x component of the vector
+    invert_y:
+    # type=bool|default=False: invert y component of the vector
+    invert_z:
+    # type=bool|default=False: invert z component of the vector
+    swap_xy:
+    # type=bool|default=False: swap x and y vectors while tracking
+    swap_yz:
+    # type=bool|default=False: swap y and z vectors while tracking
+    swap_zx:
+    # type=bool|default=False: swap x and z vectors while tracking
+    disc:
+    # type=bool|default=False: use disc tracking
+    mask1_file:
+    # type=file|default=<undefined>: first mask image
+    mask1_threshold:
+    # type=float|default=0.0: threshold value for the first mask image, if not given, the program will try automatically find the threshold
+    mask2_file:
+    # type=file|default=<undefined>: second mask image
+    mask2_threshold:
+    # type=float|default=0.0: threshold value for the second mask image, if not given, the program will try automatically find the threshold
+    limit:
+    # type=int|default=0: in some special case, such as heart data, some track may go into infinite circle and take long time to stop. this option allows setting a limit for the longest tracking steps (voxels)
+    dsi:
+    # type=bool|default=False: specify the input odf data is dsi. because dsi recon uses fixed pre-calculated matrix, some special orientation patch needs to be applied to keep dti/dsi/q-ball consistent.
+    image_orientation_vectors:
+    # type=list|default=[]: specify image orientation vectors. if just one argument given, will treat it as filename and read the orientation vectors from the file. if 6 arguments are given, will treat them as 6 float numbers and construct the 1st and 2nd vector and calculate the 3rd one automatically. this information will be used to determine image orientation, as well as to adjust gradient vectors with oblique angle when
+    slice_order:
+    # type=int|default=0: set the slice order. 1 means normal, -1 means reversed. default value is 1
+    voxel_order:
+    # type=enum|default='RAS'|allowed['LAI','LAS','LPI','LPS','RAI','RAS','RPI','RPS']: specify the voxel order in RL/AP/IS (human brain) reference. must be 3 letters with no space in between. for example, RAS means the voxel row is from L->R, the column is from P->A and the slice order is from I->S. by default voxel order is determined by the image orientation (but NOT guaranteed to be correct because of various standards). for example, siemens axial image is LPS, coronal image is LIP and sagittal image is PIL. this information also is NOT needed for tracking but will be saved in the track file and is essential for track display to map onto the right coordinates
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-diffusion_toolkit/odf_tracker_callables.py b/example-specs/task/nipype_internal/pydra-diffusion_toolkit/odf_tracker_callables.py
new file mode 100644
index 00000000..b00b8e1d
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-diffusion_toolkit/odf_tracker_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in ODFTracker.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-diffusion_toolkit/spline_filter.yaml b/example-specs/task/nipype_internal/pydra-diffusion_toolkit/spline_filter.yaml
new file mode 100644
index 00000000..241da441
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-diffusion_toolkit/spline_filter.yaml
@@ -0,0 +1,94 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.diffusion_toolkit.postproc.SplineFilter' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Smoothes TrackVis track files with a B-Spline filter.
+# 
+#     Helps remove redundant track points and segments
+#     (thus reducing the size of the track file) and also
+#     make tracks nicely smoothed. It will NOT change the
+#     quality of the tracks or lose any original information.
+# 
+#     Example
+#     -------
+# 
+#     >>> import nipype.interfaces.diffusion_toolkit as dtk
+#     >>> filt = dtk.SplineFilter()
+#     >>> filt.inputs.track_file = 'tracks.trk'
+#     >>> filt.inputs.step_length = 0.5
+#     >>> filt.run()                         # doctest: +SKIP
+#     
+task_name: SplineFilter
+nipype_name: SplineFilter
+nipype_module: nipype.interfaces.diffusion_toolkit.postproc
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    track_file: generic/file
+    # type=file|default=<undefined>: file containing tracks to be filtered
+    output_file: generic/file
+    # type=file|default='spline_tracks.trk': target file for smoothed tracks
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    smoothed_track_file: generic/file
+    # type=file: 
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    track_file:
+    # type=file|default=<undefined>: file containing tracks to be filtered
+    step_length:
+    # type=float|default=0.0: in the unit of minimum voxel size
+    output_file:
+    # type=file|default='spline_tracks.trk': target file for smoothed tracks
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-diffusion_toolkit/spline_filter_callables.py b/example-specs/task/nipype_internal/pydra-diffusion_toolkit/spline_filter_callables.py
new file mode 100644
index 00000000..6948bec6
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-diffusion_toolkit/spline_filter_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in SplineFilter.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-diffusion_toolkit/track_merge.yaml b/example-specs/task/nipype_internal/pydra-diffusion_toolkit/track_merge.yaml
new file mode 100644
index 00000000..3283d43c
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-diffusion_toolkit/track_merge.yaml
@@ -0,0 +1,94 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.diffusion_toolkit.postproc.TrackMerge' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Merges several TrackVis track files into a single track
+#     file.
+# 
+#     An id type property tag is added to each track in the
+#     newly merged file, with each unique id representing where
+#     the track was originally from. When the merged file is
+#     loaded in TrackVis, a property filter will show up in
+#     Track Property panel. Users can adjust that to distinguish
+#     and sub-group tracks by its id (origin).
+# 
+#     Example
+#     -------
+# 
+#     >>> import nipype.interfaces.diffusion_toolkit as dtk
+#     >>> mrg = dtk.TrackMerge()
+#     >>> mrg.inputs.track_files = ['track1.trk','track2.trk']
+#     >>> mrg.run()                         # doctest: +SKIP
+#     
+task_name: TrackMerge
+nipype_name: TrackMerge
+nipype_module: nipype.interfaces.diffusion_toolkit.postproc
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    track_files: generic/file+list-of
+    # type=inputmultiobject|default=[]: file containing tracks to be filtered
+    output_file: generic/file
+    # type=file|default='merged_tracks.trk': target file for merged tracks
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    track_file: generic/file
+    # type=file: 
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    track_files:
+    # type=inputmultiobject|default=[]: file containing tracks to be filtered
+    output_file:
+    # type=file|default='merged_tracks.trk': target file for merged tracks
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-diffusion_toolkit/track_merge_callables.py b/example-specs/task/nipype_internal/pydra-diffusion_toolkit/track_merge_callables.py
new file mode 100644
index 00000000..a0b86625
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-diffusion_toolkit/track_merge_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in TrackMerge.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dipy/apm_qball.yaml b/example-specs/task/nipype_internal/pydra-dipy/apm_qball.yaml
new file mode 100644
index 00000000..5955835a
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dipy/apm_qball.yaml
@@ -0,0 +1,96 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.dipy.anisotropic_power.APMQball' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Calculates the anisotropic power map
+# 
+#     Example
+#     -------
+# 
+#     >>> import nipype.interfaces.dipy as dipy
+#     >>> apm = dipy.APMQball()
+#     >>> apm.inputs.in_file = 'diffusion.nii'
+#     >>> apm.inputs.in_bvec = 'bvecs'
+#     >>> apm.inputs.in_bval = 'bvals'
+#     >>> apm.run()                           # doctest: +SKIP
+#     
+task_name: APMQball
+nipype_name: APMQball
+nipype_module: nipype.interfaces.dipy.anisotropic_power
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    mask_file: generic/file
+    # type=file|default=<undefined>: An optional brain mask
+    in_file: generic/file
+    # type=file|default=<undefined>: input diffusion data
+    in_bval: generic/file
+    # type=file|default=<undefined>: input b-values table
+    in_bvec: generic/file
+    # type=file|default=<undefined>: input b-vectors table
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: 
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    mask_file:
+    # type=file|default=<undefined>: An optional brain mask
+    in_file:
+    # type=file|default=<undefined>: input diffusion data
+    in_bval:
+    # type=file|default=<undefined>: input b-values table
+    in_bvec:
+    # type=file|default=<undefined>: input b-vectors table
+    b0_thres:
+    # type=int|default=700: b0 threshold
+    out_prefix:
+    # type=str|default='': output prefix for file names
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-dipy/apm_qball_callables.py b/example-specs/task/nipype_internal/pydra-dipy/apm_qball_callables.py
new file mode 100644
index 00000000..b71de4a9
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dipy/apm_qball_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in APMQball.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dipy/csd.yaml b/example-specs/task/nipype_internal/pydra-dipy/csd.yaml
new file mode 100644
index 00000000..495920f0
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dipy/csd.yaml
@@ -0,0 +1,120 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.dipy.reconstruction.CSD' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Uses CSD [Tournier2007]_ to generate the fODF of DWIs. The interface uses
+#     :py:mod:`dipy`, as explained in `dipy's CSD example
+#     <http://nipy.org/dipy/examples_built/reconst_csd.html>`_.
+# 
+#     .. [Tournier2007] Tournier, J.D., et al. NeuroImage 2007.
+#       Robust determination of the fibre orientation distribution in diffusion
+#       MRI: Non-negativity constrained super-resolved spherical deconvolution
+# 
+# 
+#     Example
+#     -------
+# 
+#     >>> from nipype.interfaces import dipy as ndp
+#     >>> csd = ndp.CSD()
+#     >>> csd.inputs.in_file = '4d_dwi.nii'
+#     >>> csd.inputs.in_bval = 'bvals'
+#     >>> csd.inputs.in_bvec = 'bvecs'
+#     >>> res = csd.run() # doctest: +SKIP
+#     
+task_name: CSD
+nipype_name: CSD
+nipype_module: nipype.interfaces.dipy.reconstruction
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_mask: generic/file
+    # type=file|default=<undefined>: input mask in which compute tensors
+    response: generic/file
+    # type=file|default=<undefined>: single fiber estimated response
+    out_fods: generic/file
+    # type=file: fODFs output file name
+    # type=file|default=<undefined>: fODFs output file name
+    in_file: generic/file
+    # type=file|default=<undefined>: input diffusion data
+    in_bval: generic/file
+    # type=file|default=<undefined>: input b-values table
+    in_bvec: generic/file
+    # type=file|default=<undefined>: input b-vectors table
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    model: generic/file
+    # type=file: Python pickled object of the CSD model fitted.
+    out_fods: generic/file
+    # type=file: fODFs output file name
+    # type=file|default=<undefined>: fODFs output file name
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_mask:
+    # type=file|default=<undefined>: input mask in which compute tensors
+    response:
+    # type=file|default=<undefined>: single fiber estimated response
+    sh_order:
+    # type=int|default=8: maximal shperical harmonics order
+    save_fods:
+    # type=bool|default=True: save fODFs in file
+    out_fods:
+    # type=file: fODFs output file name
+    # type=file|default=<undefined>: fODFs output file name
+    in_file:
+    # type=file|default=<undefined>: input diffusion data
+    in_bval:
+    # type=file|default=<undefined>: input b-values table
+    in_bvec:
+    # type=file|default=<undefined>: input b-vectors table
+    b0_thres:
+    # type=int|default=700: b0 threshold
+    out_prefix:
+    # type=str|default='': output prefix for file names
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-dipy/csd_callables.py b/example-specs/task/nipype_internal/pydra-dipy/csd_callables.py
new file mode 100644
index 00000000..38c8747e
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dipy/csd_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in CSD.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dipy/denoise.yaml b/example-specs/task/nipype_internal/pydra-dipy/denoise.yaml
new file mode 100644
index 00000000..91a5b67b
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dipy/denoise.yaml
@@ -0,0 +1,106 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.dipy.preprocess.Denoise' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     An interface to denoising diffusion datasets [Coupe2008]_.
+#     See
+#     http://nipy.org/dipy/examples_built/denoise_nlmeans.html#example-denoise-nlmeans.
+# 
+#     .. [Coupe2008] Coupe P et al., `An Optimized Blockwise Non Local Means
+#       Denoising Filter for 3D Magnetic Resonance Images
+#       <https://doi.org/10.1109%2FTMI.2007.906087>`_,
+#       IEEE Transactions on Medical Imaging, 27(4):425-441, 2008.
+# 
+# 
+#     Example
+#     -------
+# 
+#     >>> import nipype.interfaces.dipy as dipy
+#     >>> denoise = dipy.Denoise()
+#     >>> denoise.inputs.in_file = 'diffusion.nii'
+#     >>> denoise.run() # doctest: +SKIP
+#     
+task_name: Denoise
+nipype_name: Denoise
+nipype_module: nipype.interfaces.dipy.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: The input 4D diffusion-weighted image file
+    in_mask: generic/file
+    # type=file|default=<undefined>: brain mask
+    signal_mask: generic/file
+    # type=file|default=<undefined>: mask in which the mean signal will be computed
+    noise_mask: generic/file
+    # type=file|default=<undefined>: mask in which the standard deviation of noise will be computed
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: 
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: The input 4D diffusion-weighted image file
+    in_mask:
+    # type=file|default=<undefined>: brain mask
+    noise_model:
+    # type=enum|default='rician'|allowed['gaussian','rician']: noise distribution model
+    signal_mask:
+    # type=file|default=<undefined>: mask in which the mean signal will be computed
+    noise_mask:
+    # type=file|default=<undefined>: mask in which the standard deviation of noise will be computed
+    patch_radius:
+    # type=int|default=1: patch radius
+    block_radius:
+    # type=int|default=5: block_radius
+    snr:
+    # type=float|default=0.0: manually set an SNR
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-dipy/denoise_callables.py b/example-specs/task/nipype_internal/pydra-dipy/denoise_callables.py
new file mode 100644
index 00000000..3396479d
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dipy/denoise_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Denoise.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dipy/dti.yaml b/example-specs/task/nipype_internal/pydra-dipy/dti.yaml
new file mode 100644
index 00000000..c405b97f
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dipy/dti.yaml
@@ -0,0 +1,106 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.dipy.tensors.DTI' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Calculates the diffusion tensor model parameters
+# 
+#     Example
+#     -------
+# 
+#     >>> import nipype.interfaces.dipy as dipy
+#     >>> dti = dipy.DTI()
+#     >>> dti.inputs.in_file = 'diffusion.nii'
+#     >>> dti.inputs.in_bvec = 'bvecs'
+#     >>> dti.inputs.in_bval = 'bvals'
+#     >>> dti.run()                           # doctest: +SKIP
+#     
+task_name: DTI
+nipype_name: DTI
+nipype_module: nipype.interfaces.dipy.tensors
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    mask_file: generic/file
+    # type=file|default=<undefined>: An optional white matter mask
+    in_file: generic/file
+    # type=file|default=<undefined>: input diffusion data
+    in_bval: generic/file
+    # type=file|default=<undefined>: input b-values table
+    in_bvec: generic/file
+    # type=file|default=<undefined>: input b-vectors table
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: 
+    fa_file: generic/file
+    # type=file: 
+    md_file: generic/file
+    # type=file: 
+    rd_file: generic/file
+    # type=file: 
+    ad_file: generic/file
+    # type=file: 
+    color_fa_file: generic/file
+    # type=file: 
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    mask_file:
+    # type=file|default=<undefined>: An optional white matter mask
+    in_file:
+    # type=file|default=<undefined>: input diffusion data
+    in_bval:
+    # type=file|default=<undefined>: input b-values table
+    in_bvec:
+    # type=file|default=<undefined>: input b-vectors table
+    b0_thres:
+    # type=int|default=700: b0 threshold
+    out_prefix:
+    # type=str|default='': output prefix for file names
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-dipy/dti_callables.py b/example-specs/task/nipype_internal/pydra-dipy/dti_callables.py
new file mode 100644
index 00000000..aea1a740
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dipy/dti_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in DTI.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dipy/estimate_response_sh.yaml b/example-specs/task/nipype_internal/pydra-dipy/estimate_response_sh.yaml
new file mode 100644
index 00000000..b64214a1
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dipy/estimate_response_sh.yaml
@@ -0,0 +1,130 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.dipy.reconstruction.EstimateResponseSH' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Uses dipy to compute the single fiber response to be used in spherical
+#     deconvolution methods, in a similar way to MRTrix's command
+#     ``estimate_response``.
+# 
+# 
+#     Example
+#     -------
+# 
+#     >>> from nipype.interfaces import dipy as ndp
+#     >>> dti = ndp.EstimateResponseSH()
+#     >>> dti.inputs.in_file = '4d_dwi.nii'
+#     >>> dti.inputs.in_bval = 'bvals'
+#     >>> dti.inputs.in_bvec = 'bvecs'
+#     >>> dti.inputs.in_evals = 'dwi_evals.nii'
+#     >>> res = dti.run() # doctest: +SKIP
+# 
+# 
+#     
+task_name: EstimateResponseSH
+nipype_name: EstimateResponseSH
+nipype_module: nipype.interfaces.dipy.reconstruction
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_evals: generic/file
+    # type=file|default=<undefined>: input eigenvalues file
+    in_mask: generic/file
+    # type=file|default=<undefined>: input mask in which we find single fibers
+    response: generic/file
+    # type=file: the response file
+    # type=file|default='response.txt': the output response file
+    out_mask: generic/file
+    # type=file: output wm mask
+    # type=file|default='wm_mask.nii.gz': computed wm mask
+    in_file: generic/file
+    # type=file|default=<undefined>: input diffusion data
+    in_bval: generic/file
+    # type=file|default=<undefined>: input b-values table
+    in_bvec: generic/file
+    # type=file|default=<undefined>: input b-vectors table
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    response: generic/file
+    # type=file: the response file
+    # type=file|default='response.txt': the output response file
+    out_mask: generic/file
+    # type=file: output wm mask
+    # type=file|default='wm_mask.nii.gz': computed wm mask
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_evals:
+    # type=file|default=<undefined>: input eigenvalues file
+    in_mask:
+    # type=file|default=<undefined>: input mask in which we find single fibers
+    fa_thresh:
+    # type=float|default=0.7: FA threshold
+    roi_radius:
+    # type=int|default=10: ROI radius to be used in auto_response
+    auto:
+    # type=bool|default=False: use the auto_response estimator from dipy
+    recursive:
+    # type=bool|default=False: use the recursive response estimator from dipy
+    response:
+    # type=file: the response file
+    # type=file|default='response.txt': the output response file
+    out_mask:
+    # type=file: output wm mask
+    # type=file|default='wm_mask.nii.gz': computed wm mask
+    in_file:
+    # type=file|default=<undefined>: input diffusion data
+    in_bval:
+    # type=file|default=<undefined>: input b-values table
+    in_bvec:
+    # type=file|default=<undefined>: input b-vectors table
+    b0_thres:
+    # type=int|default=700: b0 threshold
+    out_prefix:
+    # type=str|default='': output prefix for file names
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-dipy/estimate_response_sh_callables.py b/example-specs/task/nipype_internal/pydra-dipy/estimate_response_sh_callables.py
new file mode 100644
index 00000000..1a7f226f
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dipy/estimate_response_sh_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in EstimateResponseSH.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dipy/resample.yaml b/example-specs/task/nipype_internal/pydra-dipy/resample.yaml
new file mode 100644
index 00000000..ed3dad79
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dipy/resample.yaml
@@ -0,0 +1,84 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.dipy.preprocess.Resample' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     An interface to reslicing diffusion datasets.
+#     See
+#     http://nipy.org/dipy/examples_built/reslice_datasets.html#example-reslice-datasets.
+# 
+#     Example
+#     -------
+# 
+#     >>> import nipype.interfaces.dipy as dipy
+#     >>> reslice = dipy.Resample()
+#     >>> reslice.inputs.in_file = 'diffusion.nii'
+#     >>> reslice.run() # doctest: +SKIP
+#     
+task_name: Resample
+nipype_name: Resample
+nipype_module: nipype.interfaces.dipy.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: The input 4D diffusion-weighted image file
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: 
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: The input 4D diffusion-weighted image file
+    vox_size:
+    # type=tuple|default=(0.0, 0.0, 0.0): specify the new voxel zooms. If no vox_size is set, then isotropic regridding will be performed, with spacing equal to the smallest current zoom.
+    interp:
+    # type=int|default=1: order of the interpolator (0 = nearest, 1 = linear, etc.
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-dipy/resample_callables.py b/example-specs/task/nipype_internal/pydra-dipy/resample_callables.py
new file mode 100644
index 00000000..1e012806
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dipy/resample_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Resample.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dipy/restore.yaml b/example-specs/task/nipype_internal/pydra-dipy/restore.yaml
new file mode 100644
index 00000000..ecae0700
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dipy/restore.yaml
@@ -0,0 +1,120 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.dipy.reconstruction.RESTORE' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Uses RESTORE [Chang2005]_ to perform DTI fitting with outlier detection.
+#     The interface uses :py:mod:`dipy`, as explained in `dipy's documentation`_.
+# 
+#     .. [Chang2005] Chang, LC, Jones, DK and Pierpaoli, C. RESTORE: robust     estimation of tensors by outlier rejection. MRM, 53:1088-95, (2005).
+# 
+#     .. _dipy's documentation:     http://nipy.org/dipy/examples_built/restore_dti.html
+# 
+# 
+#     Example
+#     -------
+# 
+#     >>> from nipype.interfaces import dipy as ndp
+#     >>> dti = ndp.RESTORE()
+#     >>> dti.inputs.in_file = '4d_dwi.nii'
+#     >>> dti.inputs.in_bval = 'bvals'
+#     >>> dti.inputs.in_bvec = 'bvecs'
+#     >>> res = dti.run() # doctest: +SKIP
+# 
+# 
+#     
+task_name: RESTORE
+nipype_name: RESTORE
+nipype_module: nipype.interfaces.dipy.reconstruction
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_mask: generic/file
+    # type=file|default=<undefined>: input mask in which compute tensors
+    noise_mask: generic/file
+    # type=file|default=<undefined>: input mask in which compute noise variance
+    in_file: generic/file
+    # type=file|default=<undefined>: input diffusion data
+    in_bval: generic/file
+    # type=file|default=<undefined>: input b-values table
+    in_bvec: generic/file
+    # type=file|default=<undefined>: input b-vectors table
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    fa: generic/file
+    # type=file: output fractional anisotropy (FA) map computed from the fitted DTI
+    md: generic/file
+    # type=file: output mean diffusivity (MD) map computed from the fitted DTI
+    rd: generic/file
+    # type=file: output radial diffusivity (RD) map computed from the fitted DTI
+    mode: generic/file
+    # type=file: output mode (MO) map computed from the fitted DTI
+    trace: generic/file
+    # type=file: output the tensor trace map computed from the fitted DTI
+    evals: generic/file
+    # type=file: output the eigenvalues of the fitted DTI
+    evecs: generic/file
+    # type=file: output the eigenvectors of the fitted DTI
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_mask:
+    # type=file|default=<undefined>: input mask in which compute tensors
+    noise_mask:
+    # type=file|default=<undefined>: input mask in which compute noise variance
+    in_file:
+    # type=file|default=<undefined>: input diffusion data
+    in_bval:
+    # type=file|default=<undefined>: input b-values table
+    in_bvec:
+    # type=file|default=<undefined>: input b-vectors table
+    b0_thres:
+    # type=int|default=700: b0 threshold
+    out_prefix:
+    # type=str|default='': output prefix for file names
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-dipy/restore_callables.py b/example-specs/task/nipype_internal/pydra-dipy/restore_callables.py
new file mode 100644
index 00000000..ff72be87
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dipy/restore_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in RESTORE.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dipy/simulate_multi_tensor.yaml b/example-specs/task/nipype_internal/pydra-dipy/simulate_multi_tensor.yaml
new file mode 100644
index 00000000..c96a19c1
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dipy/simulate_multi_tensor.yaml
@@ -0,0 +1,159 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.dipy.simulate.SimulateMultiTensor' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Interface to MultiTensor model simulator in dipy
+#     http://nipy.org/dipy/examples_built/simulate_multi_tensor.html
+# 
+#     Example
+#     -------
+# 
+#     >>> import nipype.interfaces.dipy as dipy
+#     >>> sim = dipy.SimulateMultiTensor()
+#     >>> sim.inputs.in_dirs = ['fdir00.nii', 'fdir01.nii']
+#     >>> sim.inputs.in_frac = ['ffra00.nii', 'ffra01.nii']
+#     >>> sim.inputs.in_vfms = ['tpm_00.nii.gz', 'tpm_01.nii.gz',
+#     ...                       'tpm_02.nii.gz']
+#     >>> sim.inputs.baseline = 'b0.nii'
+#     >>> sim.inputs.in_bvec = 'bvecs'
+#     >>> sim.inputs.in_bval = 'bvals'
+#     >>> sim.run()                           # doctest: +SKIP
+#     
+task_name: SimulateMultiTensor
+nipype_name: SimulateMultiTensor
+nipype_module: nipype.interfaces.dipy.simulate
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_dirs: generic/file+list-of
+    # type=inputmultiobject|default=[]: list of fibers (principal directions)
+    in_frac: generic/file+list-of
+    # type=inputmultiobject|default=[]: volume fraction of each fiber
+    in_vfms: generic/file+list-of
+    # type=inputmultiobject|default=[]: volume fractions of isotropic compartiments
+    in_mask: generic/file
+    # type=file|default=<undefined>: mask to simulate data
+    baseline: generic/file
+    # type=file|default=<undefined>: baseline T2 signal
+    gradients: generic/file
+    # type=file|default=<undefined>: gradients file
+    in_bvec: generic/file
+    # type=file|default=<undefined>: input bvecs file
+    in_bval: generic/file
+    # type=file|default=<undefined>: input bvals file
+    out_file: generic/file
+    # type=file: simulated DWIs
+    # type=file|default='sim_dwi.nii.gz': output file with fractions to be simluated
+    out_mask: generic/file
+    # type=file: mask file
+    # type=file|default='sim_msk.nii.gz': file with the mask simulated
+    out_bvec: generic/file
+    # type=file: simulated b vectors
+    # type=file|default='bvec.sim': simulated b vectors
+    out_bval: generic/file
+    # type=file: simulated b values
+    # type=file|default='bval.sim': simulated b values
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: simulated DWIs
+    # type=file|default='sim_dwi.nii.gz': output file with fractions to be simluated
+    out_mask: generic/file
+    # type=file: mask file
+    # type=file|default='sim_msk.nii.gz': file with the mask simulated
+    out_bvec: generic/file
+    # type=file: simulated b vectors
+    # type=file|default='bvec.sim': simulated b vectors
+    out_bval: generic/file
+    # type=file: simulated b values
+    # type=file|default='bval.sim': simulated b values
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_dirs:
+    # type=inputmultiobject|default=[]: list of fibers (principal directions)
+    in_frac:
+    # type=inputmultiobject|default=[]: volume fraction of each fiber
+    in_vfms:
+    # type=inputmultiobject|default=[]: volume fractions of isotropic compartiments
+    in_mask:
+    # type=file|default=<undefined>: mask to simulate data
+    diff_iso:
+    # type=list|default=[0.003, 0.00096, 0.00068]: Diffusivity of isotropic compartments
+    diff_sf:
+    # type=tuple|default=(0.0017, 0.0002, 0.0002): Single fiber tensor
+    n_proc:
+    # type=int|default=0: number of processes
+    baseline:
+    # type=file|default=<undefined>: baseline T2 signal
+    gradients:
+    # type=file|default=<undefined>: gradients file
+    in_bvec:
+    # type=file|default=<undefined>: input bvecs file
+    in_bval:
+    # type=file|default=<undefined>: input bvals file
+    num_dirs:
+    # type=int|default=32: number of gradient directions (when table is automatically generated)
+    bvalues:
+    # type=list|default=[1000, 3000]: list of b-values (when table is automatically generated)
+    out_file:
+    # type=file: simulated DWIs
+    # type=file|default='sim_dwi.nii.gz': output file with fractions to be simluated
+    out_mask:
+    # type=file: mask file
+    # type=file|default='sim_msk.nii.gz': file with the mask simulated
+    out_bvec:
+    # type=file: simulated b vectors
+    # type=file|default='bvec.sim': simulated b vectors
+    out_bval:
+    # type=file: simulated b values
+    # type=file|default='bval.sim': simulated b values
+    snr:
+    # type=int|default=0: signal-to-noise ratio (dB)
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-dipy/simulate_multi_tensor_callables.py b/example-specs/task/nipype_internal/pydra-dipy/simulate_multi_tensor_callables.py
new file mode 100644
index 00000000..af59eb89
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dipy/simulate_multi_tensor_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in SimulateMultiTensor.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dipy/streamline_tractography.yaml b/example-specs/task/nipype_internal/pydra-dipy/streamline_tractography.yaml
new file mode 100644
index 00000000..cc3af6c7
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dipy/streamline_tractography.yaml
@@ -0,0 +1,123 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.dipy.tracks.StreamlineTractography' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Streamline tractography using EuDX [Garyfallidis12]_.
+# 
+#     .. [Garyfallidis12] Garyfallidis E., “Towards an accurate brain
+#       tractography”, PhD thesis, University of Cambridge, 2012
+# 
+#     Example
+#     -------
+# 
+#     >>> from nipype.interfaces import dipy as ndp
+#     >>> track = ndp.StreamlineTractography()
+#     >>> track.inputs.in_file = '4d_dwi.nii'
+#     >>> track.inputs.in_model = 'model.pklz'
+#     >>> track.inputs.tracking_mask = 'dilated_wm_mask.nii'
+#     >>> res = track.run() # doctest: +SKIP
+#     
+task_name: StreamlineTractography
+nipype_name: StreamlineTractography
+nipype_module: nipype.interfaces.dipy.tracks
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: input diffusion data
+    in_model: generic/file
+    # type=file|default=<undefined>: input f/d-ODF model extracted from.
+    tracking_mask: generic/file
+    # type=file|default=<undefined>: input mask within which perform tracking
+    seed_mask: generic/file
+    # type=file|default=<undefined>: input mask within which perform seeding
+    in_peaks: generic/file
+    # type=file|default=<undefined>: peaks computed from the odf
+    seed_coord: generic/file
+    # type=file|default=<undefined>: file containing the list of seed voxel coordinates (N,3)
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    tracks: generic/file
+    # type=file: TrackVis file containing extracted streamlines
+    gfa: generic/file
+    # type=file: The resulting GFA (generalized FA) computed using the peaks of the ODF
+    odf_peaks: generic/file
+    # type=file: peaks computed from the odf
+    out_seeds: generic/file
+    # type=file: file containing the (N,3) *voxel* coordinates used in seeding.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input diffusion data
+    in_model:
+    # type=file|default=<undefined>: input f/d-ODF model extracted from.
+    tracking_mask:
+    # type=file|default=<undefined>: input mask within which perform tracking
+    seed_mask:
+    # type=file|default=<undefined>: input mask within which perform seeding
+    in_peaks:
+    # type=file|default=<undefined>: peaks computed from the odf
+    seed_coord:
+    # type=file|default=<undefined>: file containing the list of seed voxel coordinates (N,3)
+    gfa_thresh:
+    # type=float|default=0.2: GFA threshold to compute tracking mask
+    peak_threshold:
+    # type=float|default=0.5: threshold to consider peaks from model
+    min_angle:
+    # type=float|default=25.0: minimum separation angle
+    multiprocess:
+    # type=bool|default=True: use multiprocessing
+    save_seeds:
+    # type=bool|default=False: save seeding voxels coordinates
+    num_seeds:
+    # type=int|default=10000: desired number of tracks in tractography
+    out_prefix:
+    # type=str|default='': output prefix for file names
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-dipy/streamline_tractography_callables.py b/example-specs/task/nipype_internal/pydra-dipy/streamline_tractography_callables.py
new file mode 100644
index 00000000..628e7989
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dipy/streamline_tractography_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in StreamlineTractography.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dipy/tensor_mode.yaml b/example-specs/task/nipype_internal/pydra-dipy/tensor_mode.yaml
new file mode 100644
index 00000000..4a0d0649
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dipy/tensor_mode.yaml
@@ -0,0 +1,106 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.dipy.tensors.TensorMode' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Creates a map of the mode of the diffusion tensors given a set of
+#     diffusion-weighted images, as well as their associated b-values and
+#     b-vectors [1]_. Fits the diffusion tensors and calculates tensor mode
+#     with Dipy.
+# 
+#     Example
+#     -------
+#     >>> import nipype.interfaces.dipy as dipy
+#     >>> mode = dipy.TensorMode()
+#     >>> mode.inputs.in_file = 'diffusion.nii'
+#     >>> mode.inputs.in_bvec = 'bvecs'
+#     >>> mode.inputs.in_bval = 'bvals'
+#     >>> mode.run()                           # doctest: +SKIP
+# 
+#     References
+#     ----------
+#     .. [1] Daniel B. Ennis and G. Kindlmann, "Orthogonal Tensor
+#         Invariants and the Analysis of Diffusion Tensor Magnetic Resonance
+#         Images", Magnetic Resonance in Medicine, vol. 55, no. 1, pp. 136-146,
+#         2006.
+# 
+#     
+task_name: TensorMode
+nipype_name: TensorMode
+nipype_module: nipype.interfaces.dipy.tensors
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    mask_file: generic/file
+    # type=file|default=<undefined>: An optional white matter mask
+    in_file: generic/file
+    # type=file|default=<undefined>: input diffusion data
+    in_bval: generic/file
+    # type=file|default=<undefined>: input b-values table
+    in_bvec: generic/file
+    # type=file|default=<undefined>: input b-vectors table
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: 
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    mask_file:
+    # type=file|default=<undefined>: An optional white matter mask
+    in_file:
+    # type=file|default=<undefined>: input diffusion data
+    in_bval:
+    # type=file|default=<undefined>: input b-values table
+    in_bvec:
+    # type=file|default=<undefined>: input b-vectors table
+    b0_thres:
+    # type=int|default=700: b0 threshold
+    out_prefix:
+    # type=str|default='': output prefix for file names
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-dipy/tensor_mode_callables.py b/example-specs/task/nipype_internal/pydra-dipy/tensor_mode_callables.py
new file mode 100644
index 00000000..99b4a6b0
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dipy/tensor_mode_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in TensorMode.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dipy/track_density_map.yaml b/example-specs/task/nipype_internal/pydra-dipy/track_density_map.yaml
new file mode 100644
index 00000000..7a806711
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dipy/track_density_map.yaml
@@ -0,0 +1,94 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.dipy.tracks.TrackDensityMap' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Creates a tract density image from a TrackVis track file using functions
+#     from dipy
+# 
+#     Example
+#     -------
+# 
+#     >>> import nipype.interfaces.dipy as dipy
+#     >>> trk2tdi = dipy.TrackDensityMap()
+#     >>> trk2tdi.inputs.in_file = 'converted.trk'
+#     >>> trk2tdi.run()                           # doctest: +SKIP
+# 
+#     
+task_name: TrackDensityMap
+nipype_name: TrackDensityMap
+nipype_module: nipype.interfaces.dipy.tracks
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: The input TrackVis track file
+    reference: generic/file
+    # type=file|default=<undefined>: A reference file to define RAS coordinates space
+    out_filename: generic/file
+    # type=file|default='tdi.nii': The output filename for the tracks in TrackVis (.trk) format
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: 
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: The input TrackVis track file
+    reference:
+    # type=file|default=<undefined>: A reference file to define RAS coordinates space
+    points_space:
+    # type=enum|default='rasmm'|allowed['rasmm','voxel',None]: coordinates of trk file
+    voxel_dims:
+    # type=list|default=[]: The size of each voxel in mm.
+    data_dims:
+    # type=list|default=[]: The size of the image in voxels.
+    out_filename:
+    # type=file|default='tdi.nii': The output filename for the tracks in TrackVis (.trk) format
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-dipy/track_density_map_callables.py b/example-specs/task/nipype_internal/pydra-dipy/track_density_map_callables.py
new file mode 100644
index 00000000..34dc898d
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dipy/track_density_map_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in TrackDensityMap.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/aff_scalar_vol.yaml b/example-specs/task/nipype_internal/pydra-dtitk/aff_scalar_vol.yaml
new file mode 100644
index 00000000..0cb3af43
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dtitk/aff_scalar_vol.yaml
@@ -0,0 +1,146 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.dtitk.registration.AffScalarVol' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Applies affine transform to a scalar volume
+# 
+#     Example
+#     -------
+# 
+#     >>> from nipype.interfaces import dtitk
+#     >>> node = dtitk.AffScalarVol()
+#     >>> node.inputs.in_file = 'im1.nii'
+#     >>> node.inputs.transform = 'im_affine.aff'
+#     >>> node.cmdline
+#     'affineScalarVolume -in im1.nii -interp 0 -out im1_affxfmd.nii -trans
+#      im_affine.aff'
+#     >>> node.run() # doctest: +SKIP
+#     
+task_name: AffScalarVol
+nipype_name: AffScalarVol
+nipype_module: nipype.interfaces.dtitk.registration
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: moving scalar volume
+    out_file: generic/file
+    # type=file: moved volume
+    # type=file|default=<undefined>: output filename
+    transform: medimage-dtitk/aff
+    # type=file|default=<undefined>: transform to apply: specify an input transformation file; parameters input will be ignored
+    target: generic/file
+    # type=file|default=<undefined>: output volume specification read from the target volume if specified
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: moved volume
+    # type=file|default=<undefined>: output filename
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: moving scalar volume
+    out_file:
+    # type=file: moved volume
+    # type=file|default=<undefined>: output filename
+    transform:
+    # type=file|default=<undefined>: transform to apply: specify an input transformation file; parameters input will be ignored
+    interpolation:
+    # type=enum|default='trilinear'|allowed['NN','trilinear']: trilinear or nearest neighbor interpolation
+    target:
+    # type=file|default=<undefined>: output volume specification read from the target volume if specified
+    translation:
+    # type=tuple|default=(<traits.trait_types.Float object at 0x1416c0c10>, <traits.trait_types.Float object at 0x1416c0bd0>, <traits.trait_types.Float object at 0x1416c0c90>): translation (x,y,z) in mm
+    euler:
+    # type=tuple|default=(<traits.trait_types.Float object at 0x1416c0ed0>, <traits.trait_types.Float object at 0x1416c1090>, <traits.trait_types.Float object at 0x1416c10d0>): (theta, phi, psi) in degrees
+    deformation:
+    # type=tuple|default=(<traits.trait_types.Float object at 0x1416c1250>, <traits.trait_types.Float object at 0x1416c1250>, <traits.trait_types.Float object at 0x1416c1250>, <traits.trait_types.Float object at 0x1416c1250>, <traits.trait_types.Float object at 0x1416c1250>, <traits.trait_types.Float object at 0x1416c1250>): (xx,yy,zz,xy,yz,xz)
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: moving scalar volume
+    transform:
+    # type=file|default=<undefined>: transform to apply: specify an input transformation file; parameters input will be ignored
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: affineScalarVolume -in im1.nii -interp 0 -out im1_affxfmd.nii -trans im_affine.aff
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: moving scalar volume
+    transform:
+    # type=file|default=<undefined>: transform to apply: specify an input transformation file; parameters input will be ignored
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/aff_scalar_vol_callables.py b/example-specs/task/nipype_internal/pydra-dtitk/aff_scalar_vol_callables.py
new file mode 100644
index 00000000..0d20614d
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dtitk/aff_scalar_vol_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in AffScalarVol.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/aff_scalar_vol_task.yaml b/example-specs/task/nipype_internal/pydra-dtitk/aff_scalar_vol_task.yaml
new file mode 100644
index 00000000..d07264d2
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dtitk/aff_scalar_vol_task.yaml
@@ -0,0 +1,95 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.dtitk.registration.affScalarVolTask' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+task_name: affScalarVolTask
+nipype_name: affScalarVolTask
+nipype_module: nipype.interfaces.dtitk.registration
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: moving scalar volume
+    out_file: generic/file
+    # type=file: moved volume
+    # type=file|default=<undefined>: output filename
+    transform: generic/file
+    # type=file|default=<undefined>: transform to apply: specify an input transformation file; parameters input will be ignored
+    target: generic/file
+    # type=file|default=<undefined>: output volume specification read from the target volume if specified
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: moved volume
+    # type=file|default=<undefined>: output filename
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: moving scalar volume
+    out_file:
+    # type=file: moved volume
+    # type=file|default=<undefined>: output filename
+    transform:
+    # type=file|default=<undefined>: transform to apply: specify an input transformation file; parameters input will be ignored
+    interpolation:
+    # type=enum|default='trilinear'|allowed['NN','trilinear']: trilinear or nearest neighbor interpolation
+    target:
+    # type=file|default=<undefined>: output volume specification read from the target volume if specified
+    translation:
+    # type=tuple|default=(<traits.trait_types.Float object at 0x1416c0c10>, <traits.trait_types.Float object at 0x1416c0bd0>, <traits.trait_types.Float object at 0x1416c0c90>): translation (x,y,z) in mm
+    euler:
+    # type=tuple|default=(<traits.trait_types.Float object at 0x1416c0ed0>, <traits.trait_types.Float object at 0x1416c1090>, <traits.trait_types.Float object at 0x1416c10d0>): (theta, phi, psi) in degrees
+    deformation:
+    # type=tuple|default=(<traits.trait_types.Float object at 0x1416c1250>, <traits.trait_types.Float object at 0x1416c1250>, <traits.trait_types.Float object at 0x1416c1250>, <traits.trait_types.Float object at 0x1416c1250>, <traits.trait_types.Float object at 0x1416c1250>, <traits.trait_types.Float object at 0x1416c1250>): (xx,yy,zz,xy,yz,xz)
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/aff_scalar_vol_task_callables.py b/example-specs/task/nipype_internal/pydra-dtitk/aff_scalar_vol_task_callables.py
new file mode 100644
index 00000000..a88c2592
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dtitk/aff_scalar_vol_task_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in affScalarVolTask.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/aff_sym_tensor_3d_vol.yaml b/example-specs/task/nipype_internal/pydra-dtitk/aff_sym_tensor_3d_vol.yaml
new file mode 100644
index 00000000..fb09aff0
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dtitk/aff_sym_tensor_3d_vol.yaml
@@ -0,0 +1,148 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.dtitk.registration.AffSymTensor3DVol' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Applies affine transform to a tensor volume
+# 
+#     Example
+#     -------
+# 
+#     >>> from nipype.interfaces import dtitk
+#     >>> node = dtitk.AffSymTensor3DVol()
+#     >>> node.inputs.in_file = 'im1.nii'
+#     >>> node.inputs.transform = 'im_affine.aff'
+#     >>> node.cmdline
+#     'affineSymTensor3DVolume -in im1.nii -interp LEI -out im1_affxfmd.nii
+#      -reorient PPD -trans im_affine.aff'
+#     >>> node.run() # doctest: +SKIP
+#     
+task_name: AffSymTensor3DVol
+nipype_name: AffSymTensor3DVol
+nipype_module: nipype.interfaces.dtitk.registration
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: moving tensor volume
+    out_file: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: output filename
+    transform: medimage-dtitk/aff
+    # type=file|default=<undefined>: transform to apply: specify an input transformation file; parameters input will be ignored
+    target: generic/file
+    # type=file|default=<undefined>: output volume specification read from the target volume if specified
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: output filename
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: moving tensor volume
+    out_file:
+    # type=file: 
+    # type=file|default=<undefined>: output filename
+    transform:
+    # type=file|default=<undefined>: transform to apply: specify an input transformation file; parameters input will be ignored
+    interpolation:
+    # type=enum|default='LEI'|allowed['EI','LEI']: Log Euclidean/Euclidean Interpolation
+    reorient:
+    # type=enum|default='PPD'|allowed['FS','NO','PPD']: Reorientation strategy: preservation of principal direction, no reorientation, or finite strain
+    target:
+    # type=file|default=<undefined>: output volume specification read from the target volume if specified
+    translation:
+    # type=tuple|default=(<traits.trait_types.Float object at 0x1416bb090>, <traits.trait_types.Float object at 0x1416bb050>, <traits.trait_types.Float object at 0x1416bb150>): translation (x,y,z) in mm
+    euler:
+    # type=tuple|default=(<traits.trait_types.Float object at 0x1416bb310>, <traits.trait_types.Float object at 0x1416bb390>, <traits.trait_types.Float object at 0x1416bb550>): (theta, phi, psi) in degrees
+    deformation:
+    # type=tuple|default=(<traits.trait_types.Float object at 0x1416bb6d0>, <traits.trait_types.Float object at 0x1416bb6d0>, <traits.trait_types.Float object at 0x1416bb6d0>, <traits.trait_types.Float object at 0x1416bb6d0>, <traits.trait_types.Float object at 0x1416bb6d0>, <traits.trait_types.Float object at 0x1416bb6d0>): (xx,yy,zz,xy,yz,xz)
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: moving tensor volume
+    transform:
+    # type=file|default=<undefined>: transform to apply: specify an input transformation file; parameters input will be ignored
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: affineSymTensor3DVolume -in im1.nii -interp LEI -out im1_affxfmd.nii -reorient PPD -trans im_affine.aff
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: moving tensor volume
+    transform:
+    # type=file|default=<undefined>: transform to apply: specify an input transformation file; parameters input will be ignored
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/aff_sym_tensor_3d_vol_callables.py b/example-specs/task/nipype_internal/pydra-dtitk/aff_sym_tensor_3d_vol_callables.py
new file mode 100644
index 00000000..ea407dc6
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dtitk/aff_sym_tensor_3d_vol_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in AffSymTensor3DVol.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/aff_sym_tensor_3d_vol_task.yaml b/example-specs/task/nipype_internal/pydra-dtitk/aff_sym_tensor_3d_vol_task.yaml
new file mode 100644
index 00000000..c3ce3a60
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dtitk/aff_sym_tensor_3d_vol_task.yaml
@@ -0,0 +1,97 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.dtitk.registration.affSymTensor3DVolTask' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+task_name: affSymTensor3DVolTask
+nipype_name: affSymTensor3DVolTask
+nipype_module: nipype.interfaces.dtitk.registration
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: moving tensor volume
+    out_file: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: output filename
+    transform: generic/file
+    # type=file|default=<undefined>: transform to apply: specify an input transformation file; parameters input will be ignored
+    target: generic/file
+    # type=file|default=<undefined>: output volume specification read from the target volume if specified
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: output filename
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: moving tensor volume
+    out_file:
+    # type=file: 
+    # type=file|default=<undefined>: output filename
+    transform:
+    # type=file|default=<undefined>: transform to apply: specify an input transformation file; parameters input will be ignored
+    interpolation:
+    # type=enum|default='LEI'|allowed['EI','LEI']: Log Euclidean/Euclidean Interpolation
+    reorient:
+    # type=enum|default='PPD'|allowed['FS','NO','PPD']: Reorientation strategy: preservation of principal direction, no reorientation, or finite strain
+    target:
+    # type=file|default=<undefined>: output volume specification read from the target volume if specified
+    translation:
+    # type=tuple|default=(<traits.trait_types.Float object at 0x1416bb090>, <traits.trait_types.Float object at 0x1416bb050>, <traits.trait_types.Float object at 0x1416bb150>): translation (x,y,z) in mm
+    euler:
+    # type=tuple|default=(<traits.trait_types.Float object at 0x1416bb310>, <traits.trait_types.Float object at 0x1416bb390>, <traits.trait_types.Float object at 0x1416bb550>): (theta, phi, psi) in degrees
+    deformation:
+    # type=tuple|default=(<traits.trait_types.Float object at 0x1416bb6d0>, <traits.trait_types.Float object at 0x1416bb6d0>, <traits.trait_types.Float object at 0x1416bb6d0>, <traits.trait_types.Float object at 0x1416bb6d0>, <traits.trait_types.Float object at 0x1416bb6d0>, <traits.trait_types.Float object at 0x1416bb6d0>): (xx,yy,zz,xy,yz,xz)
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/aff_sym_tensor_3d_vol_task_callables.py b/example-specs/task/nipype_internal/pydra-dtitk/aff_sym_tensor_3d_vol_task_callables.py
new file mode 100644
index 00000000..26bd31a6
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dtitk/aff_sym_tensor_3d_vol_task_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in affSymTensor3DVolTask.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/affine.yaml b/example-specs/task/nipype_internal/pydra-dtitk/affine.yaml
new file mode 100644
index 00000000..413aa98f
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dtitk/affine.yaml
@@ -0,0 +1,157 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.dtitk.registration.Affine' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Performs affine registration between two tensor volumes
+# 
+#     Example
+#     -------
+# 
+#     >>> from nipype.interfaces import dtitk
+#     >>> node = dtitk.Affine()
+#     >>> node.inputs.fixed_file = 'im1.nii'
+#     >>> node.inputs.moving_file = 'im2.nii'
+#     >>> node.inputs.similarity_metric = 'EDS'
+#     >>> node.inputs.sampling_xyz = (4,4,4)
+#     >>> node.inputs.ftol = 0.01
+#     >>> node.inputs.initialize_xfm = 'im_affine.aff'
+#     >>> node.cmdline
+#     'dti_affine_reg im1.nii im2.nii EDS 4 4 4 0.01 im_affine.aff'
+#     >>> node.run() # doctest: +SKIP
+#     
+task_name: Affine
+nipype_name: Affine
+nipype_module: nipype.interfaces.dtitk.registration
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    fixed_file: medimage/nifti1
+    # type=file|default=<undefined>: fixed tensor volume
+    moving_file: medimage/nifti1
+    # type=file|default=<undefined>: moving tensor volume
+    initialize_xfm: medimage-dtitk/aff
+    # type=file|default=<undefined>: Initialize w/DTITK-FORMAT affine
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: 
+    out_file_xfm: generic/file
+    # type=file: 
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    fixed_file:
+    # type=file|default=<undefined>: fixed tensor volume
+    moving_file:
+    # type=file|default=<undefined>: moving tensor volume
+    similarity_metric:
+    # type=enum|default='EDS'|allowed['DDS','EDS','GDS','NMI']: similarity metric
+    sampling_xyz:
+    # type=tuple|default=(4, 4, 4): dist between samp points (mm) (x,y,z)
+    ftol:
+    # type=float|default=0.01: cost function tolerance
+    initialize_xfm:
+    # type=file|default=<undefined>: Initialize w/DTITK-FORMAT affine
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    fixed_file:
+    # type=file|default=<undefined>: fixed tensor volume
+    moving_file:
+    # type=file|default=<undefined>: moving tensor volume
+    similarity_metric: '"EDS"'
+    # type=enum|default='EDS'|allowed['DDS','EDS','GDS','NMI']: similarity metric
+    sampling_xyz: (4,4,4)
+    # type=tuple|default=(4, 4, 4): dist between samp points (mm) (x,y,z)
+    ftol: '0.01'
+    # type=float|default=0.01: cost function tolerance
+    initialize_xfm:
+    # type=file|default=<undefined>: Initialize w/DTITK-FORMAT affine
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: dti_affine_reg im1.nii im2.nii EDS 4 4 4 0.01 im_affine.aff
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    fixed_file:
+    # type=file|default=<undefined>: fixed tensor volume
+    moving_file:
+    # type=file|default=<undefined>: moving tensor volume
+    similarity_metric: '"EDS"'
+    # type=enum|default='EDS'|allowed['DDS','EDS','GDS','NMI']: similarity metric
+    sampling_xyz: (4,4,4)
+    # type=tuple|default=(4, 4, 4): dist between samp points (mm) (x,y,z)
+    ftol: '0.01'
+    # type=float|default=0.01: cost function tolerance
+    initialize_xfm:
+    # type=file|default=<undefined>: Initialize w/DTITK-FORMAT affine
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/affine_callables.py b/example-specs/task/nipype_internal/pydra-dtitk/affine_callables.py
new file mode 100644
index 00000000..61840691
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dtitk/affine_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Affine.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/affine_task.yaml b/example-specs/task/nipype_internal/pydra-dtitk/affine_task.yaml
new file mode 100644
index 00000000..d5a81cd7
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dtitk/affine_task.yaml
@@ -0,0 +1,88 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.dtitk.registration.AffineTask' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+task_name: AffineTask
+nipype_name: AffineTask
+nipype_module: nipype.interfaces.dtitk.registration
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    fixed_file: generic/file
+    # type=file|default=<undefined>: fixed tensor volume
+    moving_file: generic/file
+    # type=file|default=<undefined>: moving tensor volume
+    initialize_xfm: generic/file
+    # type=file|default=<undefined>: Initialize w/DTITK-FORMAT affine
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: 
+    out_file_xfm: generic/file
+    # type=file: 
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    fixed_file:
+    # type=file|default=<undefined>: fixed tensor volume
+    moving_file:
+    # type=file|default=<undefined>: moving tensor volume
+    similarity_metric:
+    # type=enum|default='EDS'|allowed['DDS','EDS','GDS','NMI']: similarity metric
+    sampling_xyz:
+    # type=tuple|default=(4, 4, 4): dist between samp points (mm) (x,y,z)
+    ftol:
+    # type=float|default=0.01: cost function tolerance
+    initialize_xfm:
+    # type=file|default=<undefined>: Initialize w/DTITK-FORMAT affine
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/affine_task_callables.py b/example-specs/task/nipype_internal/pydra-dtitk/affine_task_callables.py
new file mode 100644
index 00000000..fca167db
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dtitk/affine_task_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in AffineTask.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/bin_thresh.yaml b/example-specs/task/nipype_internal/pydra-dtitk/bin_thresh.yaml
new file mode 100644
index 00000000..815cd3f0
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dtitk/bin_thresh.yaml
@@ -0,0 +1,152 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.dtitk.utils.BinThresh' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Binarizes an image.
+# 
+#     Example
+#     -------
+#     >>> from nipype.interfaces import dtitk
+#     >>> node = dtitk.BinThresh()
+#     >>> node.inputs.in_file = 'im1.nii'
+#     >>> node.inputs.lower_bound = 0
+#     >>> node.inputs.upper_bound = 100
+#     >>> node.inputs.inside_value = 1
+#     >>> node.inputs.outside_value = 0
+#     >>> node.cmdline
+#     'BinaryThresholdImageFilter im1.nii im1_thrbin.nii 0 100 1 0'
+#     >>> node.run() # doctest: +SKIP
+# 
+#     
+task_name: BinThresh
+nipype_name: BinThresh
+nipype_module: nipype.interfaces.dtitk.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: Image to threshold/binarize
+    out_file: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: output path
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: output path
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: Image to threshold/binarize
+    out_file:
+    # type=file: 
+    # type=file|default=<undefined>: output path
+    lower_bound:
+    # type=float|default=0.01: lower bound of binarization range
+    upper_bound:
+    # type=float|default=100: upper bound of binarization range
+    inside_value:
+    # type=float|default=1: value for voxels in binarization range
+    outside_value:
+    # type=float|default=0: value for voxels outside of binarization range
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: Image to threshold/binarize
+    lower_bound: '0'
+    # type=float|default=0.01: lower bound of binarization range
+    upper_bound: '100'
+    # type=float|default=100: upper bound of binarization range
+    inside_value: '1'
+    # type=float|default=1: value for voxels in binarization range
+    outside_value: '0'
+    # type=float|default=0: value for voxels outside of binarization range
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: BinaryThresholdImageFilter im1.nii im1_thrbin.nii 0 100 1 0
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: Image to threshold/binarize
+    lower_bound: '0'
+    # type=float|default=0.01: lower bound of binarization range
+    upper_bound: '100'
+    # type=float|default=100: upper bound of binarization range
+    inside_value: '1'
+    # type=float|default=1: value for voxels in binarization range
+    outside_value: '0'
+    # type=float|default=0: value for voxels outside of binarization range
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/bin_thresh_callables.py b/example-specs/task/nipype_internal/pydra-dtitk/bin_thresh_callables.py
new file mode 100644
index 00000000..c89f3730
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dtitk/bin_thresh_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in BinThresh.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/bin_thresh_task.yaml b/example-specs/task/nipype_internal/pydra-dtitk/bin_thresh_task.yaml
new file mode 100644
index 00000000..e1919270
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dtitk/bin_thresh_task.yaml
@@ -0,0 +1,87 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.dtitk.utils.BinThreshTask' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+task_name: BinThreshTask
+nipype_name: BinThreshTask
+nipype_module: nipype.interfaces.dtitk.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: Image to threshold/binarize
+    out_file: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: output path
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: output path
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: Image to threshold/binarize
+    out_file:
+    # type=file: 
+    # type=file|default=<undefined>: output path
+    lower_bound:
+    # type=float|default=0.01: lower bound of binarization range
+    upper_bound:
+    # type=float|default=100: upper bound of binarization range
+    inside_value:
+    # type=float|default=1: value for voxels in binarization range
+    outside_value:
+    # type=float|default=0: value for voxels outside of binarization range
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/bin_thresh_task_callables.py b/example-specs/task/nipype_internal/pydra-dtitk/bin_thresh_task_callables.py
new file mode 100644
index 00000000..f775d432
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dtitk/bin_thresh_task_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in BinThreshTask.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/compose_xfm.yaml b/example-specs/task/nipype_internal/pydra-dtitk/compose_xfm.yaml
new file mode 100644
index 00000000..8ae1b4a7
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dtitk/compose_xfm.yaml
@@ -0,0 +1,134 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.dtitk.registration.ComposeXfm' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#      Combines diffeomorphic and affine transforms
+# 
+#     Example
+#     -------
+# 
+#     >>> from nipype.interfaces import dtitk
+#     >>> node = dtitk.ComposeXfm()
+#     >>> node.inputs.in_df = 'im_warp.df.nii'
+#     >>> node.inputs.in_aff= 'im_affine.aff'
+#     >>> node.cmdline
+#     'dfRightComposeAffine -aff im_affine.aff -df im_warp.df.nii -out
+#      im_warp_affdf.df.nii'
+#     >>> node.run() # doctest: +SKIP
+#     
+task_name: ComposeXfm
+nipype_name: ComposeXfm
+nipype_module: nipype.interfaces.dtitk.registration
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_df: medimage/nifti1
+    # type=file|default=<undefined>: diffeomorphic warp file
+    in_aff: medimage-dtitk/aff
+    # type=file|default=<undefined>: affine transform file
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: output path
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: out_file
+    # type=file: 
+    # type=file|default=<undefined>: output path
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_df:
+    # type=file|default=<undefined>: diffeomorphic warp file
+    in_aff:
+    # type=file|default=<undefined>: affine transform file
+    out_file:
+    # type=file: 
+    # type=file|default=<undefined>: output path
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_df:
+    # type=file|default=<undefined>: diffeomorphic warp file
+    in_aff:
+    # type=file|default=<undefined>: affine transform file
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: dfRightComposeAffine -aff im_affine.aff -df im_warp.df.nii -out im_warp_affdf.df.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_df:
+    # type=file|default=<undefined>: diffeomorphic warp file
+    in_aff:
+    # type=file|default=<undefined>: affine transform file
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/compose_xfm_callables.py b/example-specs/task/nipype_internal/pydra-dtitk/compose_xfm_callables.py
new file mode 100644
index 00000000..84747e4a
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dtitk/compose_xfm_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in ComposeXfm.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/compose_xfm_task.yaml b/example-specs/task/nipype_internal/pydra-dtitk/compose_xfm_task.yaml
new file mode 100644
index 00000000..5259057f
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dtitk/compose_xfm_task.yaml
@@ -0,0 +1,83 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.dtitk.registration.ComposeXfmTask' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+task_name: ComposeXfmTask
+nipype_name: ComposeXfmTask
+nipype_module: nipype.interfaces.dtitk.registration
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_df: generic/file
+    # type=file|default=<undefined>: diffeomorphic warp file
+    in_aff: generic/file
+    # type=file|default=<undefined>: affine transform file
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: output path
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: out_file
+    # type=file: 
+    # type=file|default=<undefined>: output path
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_df:
+    # type=file|default=<undefined>: diffeomorphic warp file
+    in_aff:
+    # type=file|default=<undefined>: affine transform file
+    out_file:
+    # type=file: 
+    # type=file|default=<undefined>: output path
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/compose_xfm_task_callables.py b/example-specs/task/nipype_internal/pydra-dtitk/compose_xfm_task_callables.py
new file mode 100644
index 00000000..ced1d1dd
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dtitk/compose_xfm_task_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in ComposeXfmTask.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/diffeo.yaml b/example-specs/task/nipype_internal/pydra-dtitk/diffeo.yaml
new file mode 100644
index 00000000..e232fe04
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dtitk/diffeo.yaml
@@ -0,0 +1,157 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.dtitk.registration.Diffeo' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Performs diffeomorphic registration between two tensor volumes
+# 
+#     Example
+#     -------
+# 
+#     >>> from nipype.interfaces import dtitk
+#     >>> node = dtitk.Diffeo()
+#     >>> node.inputs.fixed_file = 'im1.nii'
+#     >>> node.inputs.moving_file = 'im2.nii'
+#     >>> node.inputs.mask_file = 'mask.nii'
+#     >>> node.inputs.legacy = 1
+#     >>> node.inputs.n_iters = 6
+#     >>> node.inputs.ftol = 0.002
+#     >>> node.cmdline
+#     'dti_diffeomorphic_reg im1.nii im2.nii mask.nii 1 6 0.002'
+#     >>> node.run() # doctest: +SKIP
+#     
+task_name: Diffeo
+nipype_name: Diffeo
+nipype_module: nipype.interfaces.dtitk.registration
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    fixed_file: medimage/nifti1
+    # type=file|default=<undefined>: fixed tensor volume
+    moving_file: medimage/nifti1
+    # type=file|default=<undefined>: moving tensor volume
+    mask_file: medimage/nifti1
+    # type=file|default=<undefined>: mask
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: 
+    out_file_xfm: generic/file
+    # type=file: 
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    fixed_file:
+    # type=file|default=<undefined>: fixed tensor volume
+    moving_file:
+    # type=file|default=<undefined>: moving tensor volume
+    mask_file:
+    # type=file|default=<undefined>: mask
+    legacy:
+    # type=enum|default=1|allowed[1]: legacy parameter; always set to 1
+    n_iters:
+    # type=int|default=6: number of iterations
+    ftol:
+    # type=float|default=0.002: iteration for the optimization to stop
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    fixed_file:
+    # type=file|default=<undefined>: fixed tensor volume
+    moving_file:
+    # type=file|default=<undefined>: moving tensor volume
+    mask_file:
+    # type=file|default=<undefined>: mask
+    legacy: '1'
+    # type=enum|default=1|allowed[1]: legacy parameter; always set to 1
+    n_iters: '6'
+    # type=int|default=6: number of iterations
+    ftol: '0.002'
+    # type=float|default=0.002: iteration for the optimization to stop
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: dti_diffeomorphic_reg im1.nii im2.nii mask.nii 1 6 0.002
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    fixed_file:
+    # type=file|default=<undefined>: fixed tensor volume
+    moving_file:
+    # type=file|default=<undefined>: moving tensor volume
+    mask_file:
+    # type=file|default=<undefined>: mask
+    legacy: '1'
+    # type=enum|default=1|allowed[1]: legacy parameter; always set to 1
+    n_iters: '6'
+    # type=int|default=6: number of iterations
+    ftol: '0.002'
+    # type=float|default=0.002: iteration for the optimization to stop
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/diffeo_callables.py b/example-specs/task/nipype_internal/pydra-dtitk/diffeo_callables.py
new file mode 100644
index 00000000..3f705d76
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dtitk/diffeo_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Diffeo.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/diffeo_scalar_vol.yaml b/example-specs/task/nipype_internal/pydra-dtitk/diffeo_scalar_vol.yaml
new file mode 100644
index 00000000..19984e5a
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dtitk/diffeo_scalar_vol.yaml
@@ -0,0 +1,146 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.dtitk.registration.DiffeoScalarVol' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Applies diffeomorphic transform to a scalar volume
+# 
+#     Example
+#     -------
+# 
+#     >>> from nipype.interfaces import dtitk
+#     >>> node = dtitk.DiffeoScalarVol()
+#     >>> node.inputs.in_file = 'im1.nii'
+#     >>> node.inputs.transform = 'im_warp.df.nii'
+#     >>> node.cmdline
+#     'deformationScalarVolume -in im1.nii -interp 0 -out im1_diffeoxfmd.nii
+#      -trans im_warp.df.nii'
+#     >>> node.run() # doctest: +SKIP
+#     
+task_name: DiffeoScalarVol
+nipype_name: DiffeoScalarVol
+nipype_module: nipype.interfaces.dtitk.registration
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: moving scalar volume
+    out_file: generic/file
+    # type=file: moved volume
+    # type=file|default=<undefined>: output filename
+    transform: medimage/nifti1
+    # type=file|default=<undefined>: transform to apply
+    target: generic/file
+    # type=file|default=<undefined>: output volume specification read from the target volume if specified
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: moved volume
+    # type=file|default=<undefined>: output filename
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: moving scalar volume
+    out_file:
+    # type=file: moved volume
+    # type=file|default=<undefined>: output filename
+    transform:
+    # type=file|default=<undefined>: transform to apply
+    target:
+    # type=file|default=<undefined>: output volume specification read from the target volume if specified
+    voxel_size:
+    # type=tuple|default=(<traits.trait_types.Float object at 0x1416c3f10>, <traits.trait_types.Float object at 0x1416c3e50>, <traits.trait_types.Float object at 0x1416c3f90>): xyz voxel size (superseded by target)
+    flip:
+    # type=tuple|default=(<traits.trait_types.Int object at 0x1416cc210>, <traits.trait_types.Int object at 0x1416cc3d0>, <traits.trait_types.Int object at 0x1416cc410>): 
+    resampling_type:
+    # type=enum|default='backward'|allowed['backward','forward']: use backward or forward resampling
+    interpolation:
+    # type=enum|default='trilinear'|allowed['NN','trilinear']: trilinear, or nearest neighbor
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: moving scalar volume
+    transform:
+    # type=file|default=<undefined>: transform to apply
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: deformationScalarVolume -in im1.nii -interp 0 -out im1_diffeoxfmd.nii -trans im_warp.df.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: moving scalar volume
+    transform:
+    # type=file|default=<undefined>: transform to apply
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/diffeo_scalar_vol_callables.py b/example-specs/task/nipype_internal/pydra-dtitk/diffeo_scalar_vol_callables.py
new file mode 100644
index 00000000..87bbb225
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dtitk/diffeo_scalar_vol_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in DiffeoScalarVol.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/diffeo_scalar_vol_task.yaml b/example-specs/task/nipype_internal/pydra-dtitk/diffeo_scalar_vol_task.yaml
new file mode 100644
index 00000000..24776140
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dtitk/diffeo_scalar_vol_task.yaml
@@ -0,0 +1,95 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.dtitk.registration.diffeoScalarVolTask' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+task_name: diffeoScalarVolTask
+nipype_name: diffeoScalarVolTask
+nipype_module: nipype.interfaces.dtitk.registration
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: moving scalar volume
+    out_file: generic/file
+    # type=file: moved volume
+    # type=file|default=<undefined>: output filename
+    transform: generic/file
+    # type=file|default=<undefined>: transform to apply
+    target: generic/file
+    # type=file|default=<undefined>: output volume specification read from the target volume if specified
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: moved volume
+    # type=file|default=<undefined>: output filename
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: moving scalar volume
+    out_file:
+    # type=file: moved volume
+    # type=file|default=<undefined>: output filename
+    transform:
+    # type=file|default=<undefined>: transform to apply
+    target:
+    # type=file|default=<undefined>: output volume specification read from the target volume if specified
+    voxel_size:
+    # type=tuple|default=(<traits.trait_types.Float object at 0x1416c3f10>, <traits.trait_types.Float object at 0x1416c3e50>, <traits.trait_types.Float object at 0x1416c3f90>): xyz voxel size (superseded by target)
+    flip:
+    # type=tuple|default=(<traits.trait_types.Int object at 0x1416cc210>, <traits.trait_types.Int object at 0x1416cc3d0>, <traits.trait_types.Int object at 0x1416cc410>): 
+    resampling_type:
+    # type=enum|default='backward'|allowed['backward','forward']: use backward or forward resampling
+    interpolation:
+    # type=enum|default='trilinear'|allowed['NN','trilinear']: trilinear, or nearest neighbor
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/diffeo_scalar_vol_task_callables.py b/example-specs/task/nipype_internal/pydra-dtitk/diffeo_scalar_vol_task_callables.py
new file mode 100644
index 00000000..65dfccc0
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dtitk/diffeo_scalar_vol_task_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in diffeoScalarVolTask.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/diffeo_sym_tensor_3d_vol.yaml b/example-specs/task/nipype_internal/pydra-dtitk/diffeo_sym_tensor_3d_vol.yaml
new file mode 100644
index 00000000..5642290a
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dtitk/diffeo_sym_tensor_3d_vol.yaml
@@ -0,0 +1,150 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.dtitk.registration.DiffeoSymTensor3DVol' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Applies diffeomorphic transform to a tensor volume
+# 
+#     Example
+#     -------
+# 
+#     >>> from nipype.interfaces import dtitk
+#     >>> node = dtitk.DiffeoSymTensor3DVol()
+#     >>> node.inputs.in_file = 'im1.nii'
+#     >>> node.inputs.transform = 'im_warp.df.nii'
+#     >>> node.cmdline
+#     'deformationSymTensor3DVolume -df FD -in im1.nii -interp LEI -out
+#      im1_diffeoxfmd.nii -reorient PPD -trans im_warp.df.nii'
+#     >>> node.run() # doctest: +SKIP
+#     
+task_name: DiffeoSymTensor3DVol
+nipype_name: DiffeoSymTensor3DVol
+nipype_module: nipype.interfaces.dtitk.registration
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: moving tensor volume
+    out_file: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: output filename
+    transform: medimage/nifti1
+    # type=file|default=<undefined>: transform to apply
+    target: generic/file
+    # type=file|default=<undefined>: output volume specification read from the target volume if specified
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: output filename
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: moving tensor volume
+    out_file:
+    # type=file: 
+    # type=file|default=<undefined>: output filename
+    transform:
+    # type=file|default=<undefined>: transform to apply
+    df:
+    # type=str|default='FD': 
+    interpolation:
+    # type=enum|default='LEI'|allowed['EI','LEI']: Log Euclidean/Euclidean Interpolation
+    reorient:
+    # type=enum|default='PPD'|allowed['FS','PPD']: Reorientation strategy: preservation of principal direction or finite strain
+    target:
+    # type=file|default=<undefined>: output volume specification read from the target volume if specified
+    voxel_size:
+    # type=tuple|default=(<traits.trait_types.Float object at 0x1416c2690>, <traits.trait_types.Float object at 0x1416c2650>, <traits.trait_types.Float object at 0x1416c2750>): xyz voxel size (superseded by target)
+    flip:
+    # type=tuple|default=(<traits.trait_types.Int object at 0x1416c2990>, <traits.trait_types.Int object at 0x1416c2b50>, <traits.trait_types.Int object at 0x1416c2b90>): 
+    resampling_type:
+    # type=enum|default='backward'|allowed['backward','forward']: use backward or forward resampling
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: moving tensor volume
+    transform:
+    # type=file|default=<undefined>: transform to apply
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: deformationSymTensor3DVolume -df FD -in im1.nii -interp LEI -out im1_diffeoxfmd.nii -reorient PPD -trans im_warp.df.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: moving tensor volume
+    transform:
+    # type=file|default=<undefined>: transform to apply
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/diffeo_sym_tensor_3d_vol_callables.py b/example-specs/task/nipype_internal/pydra-dtitk/diffeo_sym_tensor_3d_vol_callables.py
new file mode 100644
index 00000000..870dd500
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dtitk/diffeo_sym_tensor_3d_vol_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in DiffeoSymTensor3DVol.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/diffeo_sym_tensor_3d_vol_task.yaml b/example-specs/task/nipype_internal/pydra-dtitk/diffeo_sym_tensor_3d_vol_task.yaml
new file mode 100644
index 00000000..6a21e37d
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dtitk/diffeo_sym_tensor_3d_vol_task.yaml
@@ -0,0 +1,99 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.dtitk.registration.diffeoSymTensor3DVolTask' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+task_name: diffeoSymTensor3DVolTask
+nipype_name: diffeoSymTensor3DVolTask
+nipype_module: nipype.interfaces.dtitk.registration
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: moving tensor volume
+    out_file: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: output filename
+    transform: generic/file
+    # type=file|default=<undefined>: transform to apply
+    target: generic/file
+    # type=file|default=<undefined>: output volume specification read from the target volume if specified
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: output filename
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: moving tensor volume
+    out_file:
+    # type=file: 
+    # type=file|default=<undefined>: output filename
+    transform:
+    # type=file|default=<undefined>: transform to apply
+    df:
+    # type=str|default='FD': 
+    interpolation:
+    # type=enum|default='LEI'|allowed['EI','LEI']: Log Euclidean/Euclidean Interpolation
+    reorient:
+    # type=enum|default='PPD'|allowed['FS','PPD']: Reorientation strategy: preservation of principal direction or finite strain
+    target:
+    # type=file|default=<undefined>: output volume specification read from the target volume if specified
+    voxel_size:
+    # type=tuple|default=(<traits.trait_types.Float object at 0x1416c2690>, <traits.trait_types.Float object at 0x1416c2650>, <traits.trait_types.Float object at 0x1416c2750>): xyz voxel size (superseded by target)
+    flip:
+    # type=tuple|default=(<traits.trait_types.Int object at 0x1416c2990>, <traits.trait_types.Int object at 0x1416c2b50>, <traits.trait_types.Int object at 0x1416c2b90>): 
+    resampling_type:
+    # type=enum|default='backward'|allowed['backward','forward']: use backward or forward resampling
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/diffeo_sym_tensor_3d_vol_task_callables.py b/example-specs/task/nipype_internal/pydra-dtitk/diffeo_sym_tensor_3d_vol_task_callables.py
new file mode 100644
index 00000000..ffe46e92
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dtitk/diffeo_sym_tensor_3d_vol_task_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in diffeoSymTensor3DVolTask.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/diffeo_task.yaml b/example-specs/task/nipype_internal/pydra-dtitk/diffeo_task.yaml
new file mode 100644
index 00000000..886b0230
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dtitk/diffeo_task.yaml
@@ -0,0 +1,88 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.dtitk.registration.DiffeoTask' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+task_name: DiffeoTask
+nipype_name: DiffeoTask
+nipype_module: nipype.interfaces.dtitk.registration
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    fixed_file: generic/file
+    # type=file|default=<undefined>: fixed tensor volume
+    moving_file: generic/file
+    # type=file|default=<undefined>: moving tensor volume
+    mask_file: generic/file
+    # type=file|default=<undefined>: mask
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: 
+    out_file_xfm: generic/file
+    # type=file: 
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    fixed_file:
+    # type=file|default=<undefined>: fixed tensor volume
+    moving_file:
+    # type=file|default=<undefined>: moving tensor volume
+    mask_file:
+    # type=file|default=<undefined>: mask
+    legacy:
+    # type=enum|default=1|allowed[1]: legacy parameter; always set to 1
+    n_iters:
+    # type=int|default=6: number of iterations
+    ftol:
+    # type=float|default=0.002: iteration for the optimization to stop
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/diffeo_task_callables.py b/example-specs/task/nipype_internal/pydra-dtitk/diffeo_task_callables.py
new file mode 100644
index 00000000..e17bb936
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dtitk/diffeo_task_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in DiffeoTask.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/rigid.yaml b/example-specs/task/nipype_internal/pydra-dtitk/rigid.yaml
new file mode 100644
index 00000000..b138a72d
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dtitk/rigid.yaml
@@ -0,0 +1,152 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.dtitk.registration.Rigid' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Performs rigid registration between two tensor volumes
+# 
+#     Example
+#     -------
+# 
+#     >>> from nipype.interfaces import dtitk
+#     >>> node = dtitk.Rigid()
+#     >>> node.inputs.fixed_file = 'im1.nii'
+#     >>> node.inputs.moving_file = 'im2.nii'
+#     >>> node.inputs.similarity_metric = 'EDS'
+#     >>> node.inputs.sampling_xyz = (4,4,4)
+#     >>> node.inputs.ftol = 0.01
+#     >>> node.cmdline
+#     'dti_rigid_reg im1.nii im2.nii EDS 4 4 4 0.01'
+#     >>> node.run() # doctest: +SKIP
+#     
+task_name: Rigid
+nipype_name: Rigid
+nipype_module: nipype.interfaces.dtitk.registration
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    fixed_file: medimage/nifti1
+    # type=file|default=<undefined>: fixed tensor volume
+    moving_file: medimage/nifti1
+    # type=file|default=<undefined>: moving tensor volume
+    initialize_xfm: generic/file
+    # type=file|default=<undefined>: Initialize w/DTITK-FORMAT affine
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: 
+    out_file_xfm: generic/file
+    # type=file: 
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    fixed_file:
+    # type=file|default=<undefined>: fixed tensor volume
+    moving_file:
+    # type=file|default=<undefined>: moving tensor volume
+    similarity_metric:
+    # type=enum|default='EDS'|allowed['DDS','EDS','GDS','NMI']: similarity metric
+    sampling_xyz:
+    # type=tuple|default=(4, 4, 4): dist between samp points (mm) (x,y,z)
+    ftol:
+    # type=float|default=0.01: cost function tolerance
+    initialize_xfm:
+    # type=file|default=<undefined>: Initialize w/DTITK-FORMAT affine
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    fixed_file:
+    # type=file|default=<undefined>: fixed tensor volume
+    moving_file:
+    # type=file|default=<undefined>: moving tensor volume
+    similarity_metric: '"EDS"'
+    # type=enum|default='EDS'|allowed['DDS','EDS','GDS','NMI']: similarity metric
+    sampling_xyz: (4,4,4)
+    # type=tuple|default=(4, 4, 4): dist between samp points (mm) (x,y,z)
+    ftol: '0.01'
+    # type=float|default=0.01: cost function tolerance
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: dti_rigid_reg im1.nii im2.nii EDS 4 4 4 0.01
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    fixed_file:
+    # type=file|default=<undefined>: fixed tensor volume
+    moving_file:
+    # type=file|default=<undefined>: moving tensor volume
+    similarity_metric: '"EDS"'
+    # type=enum|default='EDS'|allowed['DDS','EDS','GDS','NMI']: similarity metric
+    sampling_xyz: (4,4,4)
+    # type=tuple|default=(4, 4, 4): dist between samp points (mm) (x,y,z)
+    ftol: '0.01'
+    # type=float|default=0.01: cost function tolerance
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/rigid_callables.py b/example-specs/task/nipype_internal/pydra-dtitk/rigid_callables.py
new file mode 100644
index 00000000..76f4fd3c
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dtitk/rigid_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Rigid.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/rigid_task.yaml b/example-specs/task/nipype_internal/pydra-dtitk/rigid_task.yaml
new file mode 100644
index 00000000..69845806
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dtitk/rigid_task.yaml
@@ -0,0 +1,88 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.dtitk.registration.RigidTask' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+task_name: RigidTask
+nipype_name: RigidTask
+nipype_module: nipype.interfaces.dtitk.registration
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    fixed_file: generic/file
+    # type=file|default=<undefined>: fixed tensor volume
+    moving_file: generic/file
+    # type=file|default=<undefined>: moving tensor volume
+    initialize_xfm: generic/file
+    # type=file|default=<undefined>: Initialize w/DTITK-FORMAT affine
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: 
+    out_file_xfm: generic/file
+    # type=file: 
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    fixed_file:
+    # type=file|default=<undefined>: fixed tensor volume
+    moving_file:
+    # type=file|default=<undefined>: moving tensor volume
+    similarity_metric:
+    # type=enum|default='EDS'|allowed['DDS','EDS','GDS','NMI']: similarity metric
+    sampling_xyz:
+    # type=tuple|default=(4, 4, 4): dist between samp points (mm) (x,y,z)
+    ftol:
+    # type=float|default=0.01: cost function tolerance
+    initialize_xfm:
+    # type=file|default=<undefined>: Initialize w/DTITK-FORMAT affine
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/rigid_task_callables.py b/example-specs/task/nipype_internal/pydra-dtitk/rigid_task_callables.py
new file mode 100644
index 00000000..310d098b
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dtitk/rigid_task_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in RigidTask.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/sv_adjust_vox_sp.yaml b/example-specs/task/nipype_internal/pydra-dtitk/sv_adjust_vox_sp.yaml
new file mode 100644
index 00000000..754acdf5
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dtitk/sv_adjust_vox_sp.yaml
@@ -0,0 +1,137 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.dtitk.utils.SVAdjustVoxSp' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Adjusts the voxel space of a scalar volume.
+# 
+#     Example
+#     -------
+#     >>> from nipype.interfaces import dtitk
+#     >>> node = dtitk.SVAdjustVoxSp()
+#     >>> node.inputs.in_file = 'im1.nii'
+#     >>> node.inputs.target_file = 'im2.nii'
+#     >>> node.cmdline
+#     'SVAdjustVoxelspace -in im1.nii -out im1_avs.nii -target im2.nii'
+#     >>> node.run() # doctest: +SKIP
+# 
+#     
+task_name: SVAdjustVoxSp
+nipype_name: SVAdjustVoxSp
+nipype_module: nipype.interfaces.dtitk.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: scalar volume to modify
+    out_file: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: output path
+    target_file: medimage/nifti1
+    # type=file|default=<undefined>: target volume to match
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: output path
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: scalar volume to modify
+    out_file:
+    # type=file: 
+    # type=file|default=<undefined>: output path
+    target_file:
+    # type=file|default=<undefined>: target volume to match
+    voxel_size:
+    # type=tuple|default=(<traits.trait_types.Float object at 0x1416cfed0>, <traits.trait_types.Float object at 0x1416cfe90>, <traits.trait_types.Float object at 0x1416cff50>): xyz voxel size (superseded by target)
+    origin:
+    # type=tuple|default=(<traits.trait_types.Float object at 0x1416d41d0>, <traits.trait_types.Float object at 0x1416d4390>, <traits.trait_types.Float object at 0x1416d43d0>): xyz origin (superseded by target)
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: scalar volume to modify
+    target_file:
+    # type=file|default=<undefined>: target volume to match
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: SVAdjustVoxelspace -in im1.nii -out im1_avs.nii -target im2.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: scalar volume to modify
+    target_file:
+    # type=file|default=<undefined>: target volume to match
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/sv_adjust_vox_sp_callables.py b/example-specs/task/nipype_internal/pydra-dtitk/sv_adjust_vox_sp_callables.py
new file mode 100644
index 00000000..365acffb
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dtitk/sv_adjust_vox_sp_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in SVAdjustVoxSp.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/sv_adjust_vox_sp_task.yaml b/example-specs/task/nipype_internal/pydra-dtitk/sv_adjust_vox_sp_task.yaml
new file mode 100644
index 00000000..5e52cddd
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dtitk/sv_adjust_vox_sp_task.yaml
@@ -0,0 +1,87 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.dtitk.utils.SVAdjustVoxSpTask' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+task_name: SVAdjustVoxSpTask
+nipype_name: SVAdjustVoxSpTask
+nipype_module: nipype.interfaces.dtitk.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: scalar volume to modify
+    out_file: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: output path
+    target_file: generic/file
+    # type=file|default=<undefined>: target volume to match
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: output path
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: scalar volume to modify
+    out_file:
+    # type=file: 
+    # type=file|default=<undefined>: output path
+    target_file:
+    # type=file|default=<undefined>: target volume to match
+    voxel_size:
+    # type=tuple|default=(<traits.trait_types.Float object at 0x1416cfed0>, <traits.trait_types.Float object at 0x1416cfe90>, <traits.trait_types.Float object at 0x1416cff50>): xyz voxel size (superseded by target)
+    origin:
+    # type=tuple|default=(<traits.trait_types.Float object at 0x1416d41d0>, <traits.trait_types.Float object at 0x1416d4390>, <traits.trait_types.Float object at 0x1416d43d0>): xyz origin (superseded by target)
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/sv_adjust_vox_sp_task_callables.py b/example-specs/task/nipype_internal/pydra-dtitk/sv_adjust_vox_sp_task_callables.py
new file mode 100644
index 00000000..f2baecbe
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dtitk/sv_adjust_vox_sp_task_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in SVAdjustVoxSpTask.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/sv_resample.yaml b/example-specs/task/nipype_internal/pydra-dtitk/sv_resample.yaml
new file mode 100644
index 00000000..66be7aa9
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dtitk/sv_resample.yaml
@@ -0,0 +1,141 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.dtitk.utils.SVResample' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Resamples a scalar volume.
+# 
+#     Example
+#     -------
+#     >>> from nipype.interfaces import dtitk
+#     >>> node = dtitk.SVResample()
+#     >>> node.inputs.in_file = 'im1.nii'
+#     >>> node.inputs.target_file = 'im2.nii'
+#     >>> node.cmdline
+#     'SVResample -in im1.nii -out im1_resampled.nii -target im2.nii'
+#     >>> node.run() # doctest: +SKIP
+# 
+#     
+task_name: SVResample
+nipype_name: SVResample
+nipype_module: nipype.interfaces.dtitk.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: image to resample
+    out_file: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: output path
+    target_file: medimage/nifti1
+    # type=file|default=<undefined>: specs read from the target volume
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: output path
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: image to resample
+    out_file:
+    # type=file: 
+    # type=file|default=<undefined>: output path
+    target_file:
+    # type=file|default=<undefined>: specs read from the target volume
+    align:
+    # type=enum|default='center'|allowed['center','origin']: how to align output volume to input volume
+    array_size:
+    # type=tuple|default=(<traits.trait_types.Int object at 0x1416d6f10>, <traits.trait_types.Int object at 0x1416d6ed0>, <traits.trait_types.Int object at 0x1416d6f50>): resampled array size
+    voxel_size:
+    # type=tuple|default=(<traits.trait_types.Float object at 0x1416d71d0>, <traits.trait_types.Float object at 0x1416d7390>, <traits.trait_types.Float object at 0x1416d73d0>): resampled voxel size
+    origin:
+    # type=tuple|default=(<traits.trait_types.Float object at 0x1416d7550>, <traits.trait_types.Float object at 0x1416d7710>, <traits.trait_types.Float object at 0x1416d7750>): xyz origin
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: image to resample
+    target_file:
+    # type=file|default=<undefined>: specs read from the target volume
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: SVResample -in im1.nii -out im1_resampled.nii -target im2.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: image to resample
+    target_file:
+    # type=file|default=<undefined>: specs read from the target volume
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/sv_resample_callables.py b/example-specs/task/nipype_internal/pydra-dtitk/sv_resample_callables.py
new file mode 100644
index 00000000..b7d579fe
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dtitk/sv_resample_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in SVResample.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/sv_resample_task.yaml b/example-specs/task/nipype_internal/pydra-dtitk/sv_resample_task.yaml
new file mode 100644
index 00000000..ba3d4317
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dtitk/sv_resample_task.yaml
@@ -0,0 +1,91 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.dtitk.utils.SVResampleTask' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+task_name: SVResampleTask
+nipype_name: SVResampleTask
+nipype_module: nipype.interfaces.dtitk.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: image to resample
+    out_file: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: output path
+    target_file: generic/file
+    # type=file|default=<undefined>: specs read from the target volume
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: output path
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: image to resample
+    out_file:
+    # type=file: 
+    # type=file|default=<undefined>: output path
+    target_file:
+    # type=file|default=<undefined>: specs read from the target volume
+    align:
+    # type=enum|default='center'|allowed['center','origin']: how to align output volume to input volume
+    array_size:
+    # type=tuple|default=(<traits.trait_types.Int object at 0x1416d6f10>, <traits.trait_types.Int object at 0x1416d6ed0>, <traits.trait_types.Int object at 0x1416d6f50>): resampled array size
+    voxel_size:
+    # type=tuple|default=(<traits.trait_types.Float object at 0x1416d71d0>, <traits.trait_types.Float object at 0x1416d7390>, <traits.trait_types.Float object at 0x1416d73d0>): resampled voxel size
+    origin:
+    # type=tuple|default=(<traits.trait_types.Float object at 0x1416d7550>, <traits.trait_types.Float object at 0x1416d7710>, <traits.trait_types.Float object at 0x1416d7750>): xyz origin
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/sv_resample_task_callables.py b/example-specs/task/nipype_internal/pydra-dtitk/sv_resample_task_callables.py
new file mode 100644
index 00000000..08d5d9df
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dtitk/sv_resample_task_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in SVResampleTask.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/t_vtool.yaml b/example-specs/task/nipype_internal/pydra-dtitk/t_vtool.yaml
new file mode 100644
index 00000000..e5e6b51a
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dtitk/t_vtool.yaml
@@ -0,0 +1,131 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.dtitk.utils.TVtool' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Calculates a tensor metric volume from a tensor volume.
+# 
+#     Example
+#     -------
+#     >>> from nipype.interfaces import dtitk
+#     >>> node = dtitk.TVtool()
+#     >>> node.inputs.in_file = 'im1.nii'
+#     >>> node.inputs.in_flag = 'fa'
+#     >>> node.cmdline
+#     'TVtool -in im1.nii -fa -out im1_fa.nii'
+#     >>> node.run() # doctest: +SKIP
+# 
+#     
+task_name: TVtool
+nipype_name: TVtool
+nipype_module: nipype.interfaces.dtitk.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: scalar volume to resample
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: 
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: out_file
+    # type=file: 
+    # type=file|default=<undefined>: 
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: scalar volume to resample
+    in_flag:
+    # type=enum|default='fa'|allowed['ad','fa','pd','rd','rgb','tr']: 
+    out_file:
+    # type=file: 
+    # type=file|default=<undefined>: 
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: scalar volume to resample
+    in_flag: '"fa"'
+    # type=enum|default='fa'|allowed['ad','fa','pd','rd','rgb','tr']: 
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: TVtool -in im1.nii -fa -out im1_fa.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: scalar volume to resample
+    in_flag: '"fa"'
+    # type=enum|default='fa'|allowed['ad','fa','pd','rd','rgb','tr']: 
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/t_vtool_callables.py b/example-specs/task/nipype_internal/pydra-dtitk/t_vtool_callables.py
new file mode 100644
index 00000000..424484e8
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dtitk/t_vtool_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in TVtool.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/t_vtool_task.yaml b/example-specs/task/nipype_internal/pydra-dtitk/t_vtool_task.yaml
new file mode 100644
index 00000000..4d250e58
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dtitk/t_vtool_task.yaml
@@ -0,0 +1,81 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.dtitk.utils.TVtoolTask' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+task_name: TVtoolTask
+nipype_name: TVtoolTask
+nipype_module: nipype.interfaces.dtitk.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: scalar volume to resample
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: 
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: out_file
+    # type=file: 
+    # type=file|default=<undefined>: 
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: scalar volume to resample
+    in_flag:
+    # type=enum|default='fa'|allowed['ad','fa','pd','rd','rgb','tr']: 
+    out_file:
+    # type=file: 
+    # type=file|default=<undefined>: 
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/t_vtool_task_callables.py b/example-specs/task/nipype_internal/pydra-dtitk/t_vtool_task_callables.py
new file mode 100644
index 00000000..2e8fb4fd
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dtitk/t_vtool_task_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in TVtoolTask.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/tv_adjust_origin_task.yaml b/example-specs/task/nipype_internal/pydra-dtitk/tv_adjust_origin_task.yaml
new file mode 100644
index 00000000..31b4f54c
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dtitk/tv_adjust_origin_task.yaml
@@ -0,0 +1,87 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.dtitk.utils.TVAdjustOriginTask' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+task_name: TVAdjustOriginTask
+nipype_name: TVAdjustOriginTask
+nipype_module: nipype.interfaces.dtitk.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: tensor volume to modify
+    out_file: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: output path
+    target_file: generic/file
+    # type=file|default=<undefined>: target volume to match
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: output path
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: tensor volume to modify
+    out_file:
+    # type=file: 
+    # type=file|default=<undefined>: output path
+    target_file:
+    # type=file|default=<undefined>: target volume to match
+    voxel_size:
+    # type=tuple|default=(<traits.trait_types.Float object at 0x1416ce8d0>, <traits.trait_types.Float object at 0x1416ce890>, <traits.trait_types.Float object at 0x1416ce950>): xyz voxel size (superseded by target)
+    origin:
+    # type=tuple|default=(<traits.trait_types.Float object at 0x1416ceb90>, <traits.trait_types.Float object at 0x1416ced50>, <traits.trait_types.Float object at 0x1416ced90>): xyz origin (superseded by target)
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/tv_adjust_origin_task_callables.py b/example-specs/task/nipype_internal/pydra-dtitk/tv_adjust_origin_task_callables.py
new file mode 100644
index 00000000..862f17c0
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dtitk/tv_adjust_origin_task_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in TVAdjustOriginTask.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/tv_adjust_vox_sp.yaml b/example-specs/task/nipype_internal/pydra-dtitk/tv_adjust_vox_sp.yaml
new file mode 100644
index 00000000..0797b006
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dtitk/tv_adjust_vox_sp.yaml
@@ -0,0 +1,137 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.dtitk.utils.TVAdjustVoxSp' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#      Adjusts the voxel space of a tensor volume.
+# 
+#     Example
+#     -------
+#     >>> from nipype.interfaces import dtitk
+#     >>> node = dtitk.TVAdjustVoxSp()
+#     >>> node.inputs.in_file = 'im1.nii'
+#     >>> node.inputs.target_file = 'im2.nii'
+#     >>> node.cmdline
+#     'TVAdjustVoxelspace -in im1.nii -out im1_avs.nii -target im2.nii'
+#     >>> node.run() # doctest: +SKIP
+# 
+#     
+task_name: TVAdjustVoxSp
+nipype_name: TVAdjustVoxSp
+nipype_module: nipype.interfaces.dtitk.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: tensor volume to modify
+    out_file: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: output path
+    target_file: medimage/nifti1
+    # type=file|default=<undefined>: target volume to match
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: output path
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: tensor volume to modify
+    out_file:
+    # type=file: 
+    # type=file|default=<undefined>: output path
+    target_file:
+    # type=file|default=<undefined>: target volume to match
+    voxel_size:
+    # type=tuple|default=(<traits.trait_types.Float object at 0x1416ce8d0>, <traits.trait_types.Float object at 0x1416ce890>, <traits.trait_types.Float object at 0x1416ce950>): xyz voxel size (superseded by target)
+    origin:
+    # type=tuple|default=(<traits.trait_types.Float object at 0x1416ceb90>, <traits.trait_types.Float object at 0x1416ced50>, <traits.trait_types.Float object at 0x1416ced90>): xyz origin (superseded by target)
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: tensor volume to modify
+    target_file:
+    # type=file|default=<undefined>: target volume to match
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: TVAdjustVoxelspace -in im1.nii -out im1_avs.nii -target im2.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: tensor volume to modify
+    target_file:
+    # type=file|default=<undefined>: target volume to match
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/tv_adjust_vox_sp_callables.py b/example-specs/task/nipype_internal/pydra-dtitk/tv_adjust_vox_sp_callables.py
new file mode 100644
index 00000000..b63636f5
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dtitk/tv_adjust_vox_sp_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in TVAdjustVoxSp.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/tv_adjust_vox_sp_task.yaml b/example-specs/task/nipype_internal/pydra-dtitk/tv_adjust_vox_sp_task.yaml
new file mode 100644
index 00000000..09e53961
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dtitk/tv_adjust_vox_sp_task.yaml
@@ -0,0 +1,87 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.dtitk.utils.TVAdjustVoxSpTask' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+task_name: TVAdjustVoxSpTask
+nipype_name: TVAdjustVoxSpTask
+nipype_module: nipype.interfaces.dtitk.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: tensor volume to modify
+    out_file: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: output path
+    target_file: generic/file
+    # type=file|default=<undefined>: target volume to match
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: output path
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: tensor volume to modify
+    out_file:
+    # type=file: 
+    # type=file|default=<undefined>: output path
+    target_file:
+    # type=file|default=<undefined>: target volume to match
+    voxel_size:
+    # type=tuple|default=(<traits.trait_types.Float object at 0x1416ce8d0>, <traits.trait_types.Float object at 0x1416ce890>, <traits.trait_types.Float object at 0x1416ce950>): xyz voxel size (superseded by target)
+    origin:
+    # type=tuple|default=(<traits.trait_types.Float object at 0x1416ceb90>, <traits.trait_types.Float object at 0x1416ced50>, <traits.trait_types.Float object at 0x1416ced90>): xyz origin (superseded by target)
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/tv_adjust_vox_sp_task_callables.py b/example-specs/task/nipype_internal/pydra-dtitk/tv_adjust_vox_sp_task_callables.py
new file mode 100644
index 00000000..9a84ba5f
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dtitk/tv_adjust_vox_sp_task_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in TVAdjustVoxSpTask.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/tv_resample.yaml b/example-specs/task/nipype_internal/pydra-dtitk/tv_resample.yaml
new file mode 100644
index 00000000..ad0c0809
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dtitk/tv_resample.yaml
@@ -0,0 +1,143 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.dtitk.utils.TVResample' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Resamples a tensor volume.
+# 
+#     Example
+#     -------
+#     >>> from nipype.interfaces import dtitk
+#     >>> node = dtitk.TVResample()
+#     >>> node.inputs.in_file = 'im1.nii'
+#     >>> node.inputs.target_file = 'im2.nii'
+#     >>> node.cmdline
+#     'TVResample -in im1.nii -out im1_resampled.nii -target im2.nii'
+#     >>> node.run() # doctest: +SKIP
+# 
+#     
+task_name: TVResample
+nipype_name: TVResample
+nipype_module: nipype.interfaces.dtitk.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: tensor volume to resample
+    out_file: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: output path
+    target_file: medimage/nifti1
+    # type=file|default=<undefined>: specs read from the target volume
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: output path
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: tensor volume to resample
+    out_file:
+    # type=file: 
+    # type=file|default=<undefined>: output path
+    target_file:
+    # type=file|default=<undefined>: specs read from the target volume
+    align:
+    # type=enum|default='center'|allowed['center','origin']: how to align output volume to input volume
+    interpolation:
+    # type=enum|default='LEI'|allowed['EI','LEI']: Log Euclidean Interpolation
+    array_size:
+    # type=tuple|default=(<traits.trait_types.Int object at 0x1416d5410>, <traits.trait_types.Int object at 0x1416d53d0>, <traits.trait_types.Int object at 0x1416d5450>): resampled array size
+    voxel_size:
+    # type=tuple|default=(<traits.trait_types.Float object at 0x1416d5710>, <traits.trait_types.Float object at 0x1416d58d0>, <traits.trait_types.Float object at 0x1416d5910>): resampled voxel size
+    origin:
+    # type=tuple|default=(<traits.trait_types.Float object at 0x1416d5a90>, <traits.trait_types.Float object at 0x1416d5c50>, <traits.trait_types.Float object at 0x1416d5c90>): xyz origin
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: tensor volume to resample
+    target_file:
+    # type=file|default=<undefined>: specs read from the target volume
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: TVResample -in im1.nii -out im1_resampled.nii -target im2.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: tensor volume to resample
+    target_file:
+    # type=file|default=<undefined>: specs read from the target volume
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/tv_resample_callables.py b/example-specs/task/nipype_internal/pydra-dtitk/tv_resample_callables.py
new file mode 100644
index 00000000..00c4dcd8
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dtitk/tv_resample_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in TVResample.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/tv_resample_task.yaml b/example-specs/task/nipype_internal/pydra-dtitk/tv_resample_task.yaml
new file mode 100644
index 00000000..d829801c
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dtitk/tv_resample_task.yaml
@@ -0,0 +1,93 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.dtitk.utils.TVResampleTask' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+task_name: TVResampleTask
+nipype_name: TVResampleTask
+nipype_module: nipype.interfaces.dtitk.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: tensor volume to resample
+    out_file: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: output path
+    target_file: generic/file
+    # type=file|default=<undefined>: specs read from the target volume
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: output path
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: tensor volume to resample
+    out_file:
+    # type=file: 
+    # type=file|default=<undefined>: output path
+    target_file:
+    # type=file|default=<undefined>: specs read from the target volume
+    align:
+    # type=enum|default='center'|allowed['center','origin']: how to align output volume to input volume
+    interpolation:
+    # type=enum|default='LEI'|allowed['EI','LEI']: Log Euclidean Interpolation
+    array_size:
+    # type=tuple|default=(<traits.trait_types.Int object at 0x1416d5410>, <traits.trait_types.Int object at 0x1416d53d0>, <traits.trait_types.Int object at 0x1416d5450>): resampled array size
+    voxel_size:
+    # type=tuple|default=(<traits.trait_types.Float object at 0x1416d5710>, <traits.trait_types.Float object at 0x1416d58d0>, <traits.trait_types.Float object at 0x1416d5910>): resampled voxel size
+    origin:
+    # type=tuple|default=(<traits.trait_types.Float object at 0x1416d5a90>, <traits.trait_types.Float object at 0x1416d5c50>, <traits.trait_types.Float object at 0x1416d5c90>): xyz origin
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/tv_resample_task_callables.py b/example-specs/task/nipype_internal/pydra-dtitk/tv_resample_task_callables.py
new file mode 100644
index 00000000..33996900
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dtitk/tv_resample_task_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in TVResampleTask.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dynamic_slicer/slicer_command_line.yaml b/example-specs/task/nipype_internal/pydra-dynamic_slicer/slicer_command_line.yaml
new file mode 100644
index 00000000..dfede76c
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dynamic_slicer/slicer_command_line.yaml
@@ -0,0 +1,68 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.dynamic_slicer.SlicerCommandLine' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Experimental Slicer wrapper. Work in progress.
+task_name: SlicerCommandLine
+nipype_name: SlicerCommandLine
+nipype_module: nipype.interfaces.dynamic_slicer
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    module:
+    # type=str|default='': name of the Slicer command line module you want to use
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-dynamic_slicer/slicer_command_line_callables.py b/example-specs/task/nipype_internal/pydra-dynamic_slicer/slicer_command_line_callables.py
new file mode 100644
index 00000000..a21556e6
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-dynamic_slicer/slicer_command_line_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in SlicerCommandLine.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-elastix/analyze_warp.yaml b/example-specs/task/nipype_internal/pydra-elastix/analyze_warp.yaml
new file mode 100644
index 00000000..0bf31d31
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-elastix/analyze_warp.yaml
@@ -0,0 +1,140 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.elastix.registration.AnalyzeWarp' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Use transformix to get details from the input transform (generate
+#     the corresponding deformation field, generate the determinant of the
+#     Jacobian map or the Jacobian map itself)
+# 
+#     Example
+#     -------
+# 
+#     >>> from nipype.interfaces.elastix import AnalyzeWarp
+#     >>> reg = AnalyzeWarp()
+#     >>> reg.inputs.transform_file = 'TransformParameters.0.txt'
+#     >>> reg.cmdline
+#     'transformix -def all -jac all -jacmat all -threads 1 -out ./ -tp TransformParameters.0.txt'
+# 
+# 
+#     
+task_name: AnalyzeWarp
+nipype_name: AnalyzeWarp
+nipype_module: nipype.interfaces.elastix.registration
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    moving_image: generic/file
+    # type=file|default=<undefined>: input image to deform (not used)
+    transform_file: text/text-file
+    # type=file|default=<undefined>: transform-parameter file, only 1
+    output_path: generic/directory
+    # type=directory|default='./': output directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    disp_field: generic/file
+    # type=file: displacements field
+    jacdet_map: generic/file
+    # type=file: det(Jacobian) map
+    jacmat_map: generic/file
+    # type=file: Jacobian matrix map
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    points:
+    # type=enum|default='all'|allowed['all']: transform all points from the input-image, which effectively generates a deformation field.
+    jac:
+    # type=enum|default='all'|allowed['all']: generate an image with the determinant of the spatial Jacobian
+    jacmat:
+    # type=enum|default='all'|allowed['all']: generate an image with the spatial Jacobian matrix at each voxel
+    moving_image:
+    # type=file|default=<undefined>: input image to deform (not used)
+    transform_file:
+    # type=file|default=<undefined>: transform-parameter file, only 1
+    output_path:
+    # type=directory|default='./': output directory
+    num_threads:
+    # type=int|default=1: set the maximum number of threads of elastix
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    transform_file:
+    # type=file|default=<undefined>: transform-parameter file, only 1
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: transformix -def all -jac all -jacmat all -threads 1 -out ./ -tp TransformParameters.0.txt
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    transform_file:
+    # type=file|default=<undefined>: transform-parameter file, only 1
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-elastix/analyze_warp_callables.py b/example-specs/task/nipype_internal/pydra-elastix/analyze_warp_callables.py
new file mode 100644
index 00000000..26c9dc5b
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-elastix/analyze_warp_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in AnalyzeWarp.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-elastix/apply_warp.yaml b/example-specs/task/nipype_internal/pydra-elastix/apply_warp.yaml
new file mode 100644
index 00000000..fc177c0b
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-elastix/apply_warp.yaml
@@ -0,0 +1,134 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.elastix.registration.ApplyWarp' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Use ``transformix`` to apply a transform on an input image.
+#     The transform is specified in the transform-parameter file.
+# 
+#     Example
+#     -------
+# 
+#     >>> from nipype.interfaces.elastix import ApplyWarp
+#     >>> reg = ApplyWarp()
+#     >>> reg.inputs.moving_image = 'moving1.nii'
+#     >>> reg.inputs.transform_file = 'TransformParameters.0.txt'
+#     >>> reg.cmdline
+#     'transformix -in moving1.nii -threads 1 -out ./ -tp TransformParameters.0.txt'
+# 
+# 
+#     
+task_name: ApplyWarp
+nipype_name: ApplyWarp
+nipype_module: nipype.interfaces.elastix.registration
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    transform_file: text/text-file
+    # type=file|default=<undefined>: transform-parameter file, only 1
+    moving_image: medimage/nifti1
+    # type=file|default=<undefined>: input image to deform
+    output_path: generic/directory
+    # type=directory|default='./': output directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    warped_file: generic/file
+    # type=file: input moving image warped to fixed image
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    transform_file:
+    # type=file|default=<undefined>: transform-parameter file, only 1
+    moving_image:
+    # type=file|default=<undefined>: input image to deform
+    output_path:
+    # type=directory|default='./': output directory
+    num_threads:
+    # type=int|default=1: set the maximum number of threads of elastix
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    moving_image:
+    # type=file|default=<undefined>: input image to deform
+    transform_file:
+    # type=file|default=<undefined>: transform-parameter file, only 1
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: transformix -in moving1.nii -threads 1 -out ./ -tp TransformParameters.0.txt
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    moving_image:
+    # type=file|default=<undefined>: input image to deform
+    transform_file:
+    # type=file|default=<undefined>: transform-parameter file, only 1
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-elastix/apply_warp_callables.py b/example-specs/task/nipype_internal/pydra-elastix/apply_warp_callables.py
new file mode 100644
index 00000000..827cf9f6
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-elastix/apply_warp_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in ApplyWarp.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-elastix/edit_transform.yaml b/example-specs/task/nipype_internal/pydra-elastix/edit_transform.yaml
new file mode 100644
index 00000000..a93e2f24
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-elastix/edit_transform.yaml
@@ -0,0 +1,98 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.elastix.utils.EditTransform' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Manipulates an existing transform file generated with elastix
+# 
+#     Example
+#     -------
+# 
+#     >>> from nipype.interfaces.elastix import EditTransform
+#     >>> tfm = EditTransform()
+#     >>> tfm.inputs.transform_file = 'TransformParameters.0.txt'  # doctest: +SKIP
+#     >>> tfm.inputs.reference_image = 'fixed1.nii'  # doctest: +SKIP
+#     >>> tfm.inputs.output_type = 'unsigned char'
+#     >>> tfm.run() # doctest: +SKIP
+# 
+#     
+task_name: EditTransform
+nipype_name: EditTransform
+nipype_module: nipype.interfaces.elastix.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    transform_file: generic/file
+    # type=file|default=<undefined>: transform-parameter file, only 1
+    reference_image: generic/file
+    # type=file|default=<undefined>: set a new reference image to change the target coordinate system.
+    output_file: generic/file
+    # type=file: output transform file
+    # type=file|default=<undefined>: the filename for the resulting transform file
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    output_file: generic/file
+    # type=file: output transform file
+    # type=file|default=<undefined>: the filename for the resulting transform file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    transform_file:
+    # type=file|default=<undefined>: transform-parameter file, only 1
+    reference_image:
+    # type=file|default=<undefined>: set a new reference image to change the target coordinate system.
+    interpolation:
+    # type=enum|default='cubic'|allowed['cubic','linear','nearest']: set a new interpolator for transformation
+    output_type:
+    # type=enum|default='float'|allowed['double','float','long','short','unsigned char','unsigned long','unsigned short']: set a new output pixel type for resampled images
+    output_format:
+    # type=enum|default='nii.gz'|allowed['hdr','mhd','nii','nii.gz','vtk']: set a new image format for resampled images
+    output_file:
+    # type=file: output transform file
+    # type=file|default=<undefined>: the filename for the resulting transform file
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-elastix/edit_transform_callables.py b/example-specs/task/nipype_internal/pydra-elastix/edit_transform_callables.py
new file mode 100644
index 00000000..d27fadf5
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-elastix/edit_transform_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in EditTransform.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-elastix/points_warp.yaml b/example-specs/task/nipype_internal/pydra-elastix/points_warp.yaml
new file mode 100644
index 00000000..f8c7cf4f
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-elastix/points_warp.yaml
@@ -0,0 +1,133 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.elastix.registration.PointsWarp' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Use ``transformix`` to apply a transform on an input point set.
+#     The transform is specified in the transform-parameter file.
+# 
+#     Example
+#     -------
+# 
+#     >>> from nipype.interfaces.elastix import PointsWarp
+#     >>> reg = PointsWarp()
+#     >>> reg.inputs.points_file = 'surf1.vtk'
+#     >>> reg.inputs.transform_file = 'TransformParameters.0.txt'
+#     >>> reg.cmdline
+#     'transformix -threads 1 -out ./ -def surf1.vtk -tp TransformParameters.0.txt'
+# 
+# 
+#     
+task_name: PointsWarp
+nipype_name: PointsWarp
+nipype_module: nipype.interfaces.elastix.registration
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    points_file: medimage-elastix/vtk
+    # type=file|default=<undefined>: input points (accepts .vtk triangular meshes).
+    transform_file: text/text-file
+    # type=file|default=<undefined>: transform-parameter file, only 1
+    output_path: generic/directory
+    # type=directory|default='./': output directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    warped_file: generic/file
+    # type=file: input points displaced in fixed image domain
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    points_file:
+    # type=file|default=<undefined>: input points (accepts .vtk triangular meshes).
+    transform_file:
+    # type=file|default=<undefined>: transform-parameter file, only 1
+    output_path:
+    # type=directory|default='./': output directory
+    num_threads:
+    # type=int|default=1: set the maximum number of threads of elastix
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    points_file:
+    # type=file|default=<undefined>: input points (accepts .vtk triangular meshes).
+    transform_file:
+    # type=file|default=<undefined>: transform-parameter file, only 1
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: transformix -threads 1 -out ./ -def surf1.vtk -tp TransformParameters.0.txt
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    points_file:
+    # type=file|default=<undefined>: input points (accepts .vtk triangular meshes).
+    transform_file:
+    # type=file|default=<undefined>: transform-parameter file, only 1
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-elastix/points_warp_callables.py b/example-specs/task/nipype_internal/pydra-elastix/points_warp_callables.py
new file mode 100644
index 00000000..1369b9e1
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-elastix/points_warp_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in PointsWarp.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-elastix/registration.yaml b/example-specs/task/nipype_internal/pydra-elastix/registration.yaml
new file mode 100644
index 00000000..cdec3684
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-elastix/registration.yaml
@@ -0,0 +1,154 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.elastix.registration.Registration' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Elastix nonlinear registration interface
+# 
+#     Example
+#     -------
+# 
+#     >>> from nipype.interfaces.elastix import Registration
+#     >>> reg = Registration()
+#     >>> reg.inputs.fixed_image = 'fixed1.nii'
+#     >>> reg.inputs.moving_image = 'moving1.nii'
+#     >>> reg.inputs.parameters = ['elastix.txt']
+#     >>> reg.cmdline
+#     'elastix -f fixed1.nii -m moving1.nii -threads 1 -out ./ -p elastix.txt'
+# 
+# 
+#     
+task_name: Registration
+nipype_name: Registration
+nipype_module: nipype.interfaces.elastix.registration
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    fixed_image: medimage/nifti1
+    # type=file|default=<undefined>: fixed image
+    moving_image: medimage/nifti1
+    # type=file|default=<undefined>: moving image
+    parameters: text/text-file+list-of
+    # type=inputmultiobject|default=[]: parameter file, elastix handles 1 or more -p
+    fixed_mask: generic/file
+    # type=file|default=<undefined>: mask for fixed image
+    moving_mask: generic/file
+    # type=file|default=<undefined>: mask for moving image
+    initial_transform: generic/file
+    # type=file|default=<undefined>: parameter file for initial transform
+    output_path: generic/directory
+    # type=directory|default='./': output directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    warped_file: generic/file
+    # type=file: input moving image warped to fixed image
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    fixed_image:
+    # type=file|default=<undefined>: fixed image
+    moving_image:
+    # type=file|default=<undefined>: moving image
+    parameters:
+    # type=inputmultiobject|default=[]: parameter file, elastix handles 1 or more -p
+    fixed_mask:
+    # type=file|default=<undefined>: mask for fixed image
+    moving_mask:
+    # type=file|default=<undefined>: mask for moving image
+    initial_transform:
+    # type=file|default=<undefined>: parameter file for initial transform
+    output_path:
+    # type=directory|default='./': output directory
+    num_threads:
+    # type=int|default=1: set the maximum number of threads of elastix
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    fixed_image:
+    # type=file|default=<undefined>: fixed image
+    moving_image:
+    # type=file|default=<undefined>: moving image
+    parameters:
+    # type=inputmultiobject|default=[]: parameter file, elastix handles 1 or more -p
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: elastix -f fixed1.nii -m moving1.nii -threads 1 -out ./ -p elastix.txt
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    fixed_image:
+    # type=file|default=<undefined>: fixed image
+    moving_image:
+    # type=file|default=<undefined>: moving image
+    parameters:
+    # type=inputmultiobject|default=[]: parameter file, elastix handles 1 or more -p
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-elastix/registration_callables.py b/example-specs/task/nipype_internal/pydra-elastix/registration_callables.py
new file mode 100644
index 00000000..5191c22f
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-elastix/registration_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Registration.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/add_x_form_to_header.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/add_x_form_to_header.yaml
new file mode 100644
index 00000000..57db557d
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/add_x_form_to_header.yaml
@@ -0,0 +1,187 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.utils.AddXFormToHeader' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Just adds specified xform to the volume header.
+# 
+#     .. danger ::
+# 
+#         Input transform **MUST** be an absolute path to a DataSink'ed transform or
+#         the output will reference a transform in the workflow cache directory!
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces.freesurfer import AddXFormToHeader
+#     >>> adder = AddXFormToHeader()
+#     >>> adder.inputs.in_file = 'norm.mgz'
+#     >>> adder.inputs.transform = 'trans.mat'
+#     >>> adder.cmdline
+#     'mri_add_xform_to_header trans.mat norm.mgz output.mgz'
+# 
+#     >>> adder.inputs.copy_name = True
+#     >>> adder.cmdline
+#     'mri_add_xform_to_header -c trans.mat norm.mgz output.mgz'
+#     >>> adder.run()   # doctest: +SKIP
+# 
+#     References
+#     ----------
+#     [https://surfer.nmr.mgh.harvard.edu/fswiki/mri_add_xform_to_header]
+# 
+#     
+task_name: AddXFormToHeader
+nipype_name: AddXFormToHeader
+nipype_module: nipype.interfaces.freesurfer.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/mgh-gz
+    # type=file|default=<undefined>: input volume
+    transform: datascience/text-matrix
+    # type=file|default=<undefined>: xfm file
+    out_file: generic/file
+    # type=file: output volume
+    # type=file|default='output.mgz': output volume
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: output volume
+    # type=file|default='output.mgz': output volume
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input volume
+    transform:
+    # type=file|default=<undefined>: xfm file
+    out_file:
+    # type=file: output volume
+    # type=file|default='output.mgz': output volume
+    copy_name:
+    # type=bool|default=False: do not try to load the xfmfile, just copy name
+    verbose:
+    # type=bool|default=False: be verbose
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input volume
+    transform:
+    # type=file|default=<undefined>: xfm file
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    copy_name: 'True'
+    # type=bool|default=False: do not try to load the xfmfile, just copy name
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: mri_add_xform_to_header trans.mat norm.mgz output.mgz
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: input volume
+    transform:
+    # type=file|default=<undefined>: xfm file
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: mri_add_xform_to_header -c trans.mat norm.mgz output.mgz
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    copy_name: 'True'
+    # type=bool|default=False: do not try to load the xfmfile, just copy name
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/add_x_form_to_header_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/add_x_form_to_header_callables.py
new file mode 100644
index 00000000..360e8b9d
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/add_x_form_to_header_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in AddXFormToHeader.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/aparc_2_aseg.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/aparc_2_aseg.yaml
new file mode 100644
index 00000000..d894bbb3
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/aparc_2_aseg.yaml
@@ -0,0 +1,255 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.utils.Aparc2Aseg' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Maps the cortical labels from the automatic cortical parcellation
+#     (aparc) to the automatic segmentation volume (aseg). The result can be
+#     used as the aseg would. The algorithm is to find each aseg voxel
+#     labeled as cortex (3 and 42) and assign it the label of the closest
+#     cortical vertex. If the voxel is not in the ribbon (as defined by mri/
+#     lh.ribbon and rh.ribbon), then the voxel is marked as unknown (0).
+#     This can be turned off with ``--noribbon``. The cortical parcellation is
+#     obtained from subject/label/hemi.aparc.annot which should be based on
+#     the curvature.buckner40.filled.desikan_killiany.gcs atlas. The aseg is
+#     obtained from subject/mri/aseg.mgz and should be based on the
+#     RB40_talairach_2005-07-20.gca atlas. If these atlases are used, then the
+#     segmentations can be viewed with tkmedit and the
+#     FreeSurferColorLUT.txt color table found in ``$FREESURFER_HOME``. These
+#     are the default atlases used by ``recon-all``.
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces.freesurfer import Aparc2Aseg
+#     >>> aparc2aseg = Aparc2Aseg()
+#     >>> aparc2aseg.inputs.lh_white = 'lh.pial'
+#     >>> aparc2aseg.inputs.rh_white = 'lh.pial'
+#     >>> aparc2aseg.inputs.lh_pial = 'lh.pial'
+#     >>> aparc2aseg.inputs.rh_pial = 'lh.pial'
+#     >>> aparc2aseg.inputs.lh_ribbon = 'label.mgz'
+#     >>> aparc2aseg.inputs.rh_ribbon = 'label.mgz'
+#     >>> aparc2aseg.inputs.ribbon = 'label.mgz'
+#     >>> aparc2aseg.inputs.lh_annotation = 'lh.pial'
+#     >>> aparc2aseg.inputs.rh_annotation = 'lh.pial'
+#     >>> aparc2aseg.inputs.out_file = 'aparc+aseg.mgz'
+#     >>> aparc2aseg.inputs.label_wm = True
+#     >>> aparc2aseg.inputs.rip_unknown = True
+#     >>> aparc2aseg.cmdline # doctest: +SKIP
+#     'mri_aparc2aseg --labelwm  --o aparc+aseg.mgz --rip-unknown --s subject_id'
+# 
+#     
+task_name: Aparc2Aseg
+nipype_name: Aparc2Aseg
+nipype_module: nipype.interfaces.freesurfer.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: medimage/mgh-gz
+    # type=file: Output aseg file
+    # type=file|default=<undefined>: Full path of file to save the output segmentation in
+    lh_white: medimage-freesurfer/pial
+    # type=file|default=<undefined>: Input file must be <subject_id>/surf/lh.white
+    rh_white: medimage-freesurfer/pial
+    # type=file|default=<undefined>: Input file must be <subject_id>/surf/rh.white
+    lh_pial: medimage-freesurfer/pial
+    # type=file|default=<undefined>: Input file must be <subject_id>/surf/lh.pial
+    rh_pial: medimage-freesurfer/pial
+    # type=file|default=<undefined>: Input file must be <subject_id>/surf/rh.pial
+    lh_ribbon: medimage/mgh-gz
+    # type=file|default=<undefined>: Input file must be <subject_id>/mri/lh.ribbon.mgz
+    rh_ribbon: medimage/mgh-gz
+    # type=file|default=<undefined>: Input file must be <subject_id>/mri/rh.ribbon.mgz
+    ribbon: medimage/mgh-gz
+    # type=file|default=<undefined>: Input file must be <subject_id>/mri/ribbon.mgz
+    lh_annotation: medimage-freesurfer/pial
+    # type=file|default=<undefined>: Input file must be <subject_id>/label/lh.aparc.annot
+    rh_annotation: medimage-freesurfer/pial
+    # type=file|default=<undefined>: Input file must be <subject_id>/label/rh.aparc.annot
+    filled: generic/file
+    # type=file|default=<undefined>: Implicit input filled file. Only required with FS v5.3.
+    aseg: generic/file
+    # type=file|default=<undefined>: Input aseg file
+    ctxseg: generic/file
+    # type=file|default=<undefined>: 
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: medimage/mgh-gz
+    # type=file: Output aseg file
+    # type=file|default=<undefined>: Full path of file to save the output segmentation in
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    subject_id:
+    # type=string|default='subject_id': Subject being processed
+    out_file:
+    # type=file: Output aseg file
+    # type=file|default=<undefined>: Full path of file to save the output segmentation in
+    lh_white:
+    # type=file|default=<undefined>: Input file must be <subject_id>/surf/lh.white
+    rh_white:
+    # type=file|default=<undefined>: Input file must be <subject_id>/surf/rh.white
+    lh_pial:
+    # type=file|default=<undefined>: Input file must be <subject_id>/surf/lh.pial
+    rh_pial:
+    # type=file|default=<undefined>: Input file must be <subject_id>/surf/rh.pial
+    lh_ribbon:
+    # type=file|default=<undefined>: Input file must be <subject_id>/mri/lh.ribbon.mgz
+    rh_ribbon:
+    # type=file|default=<undefined>: Input file must be <subject_id>/mri/rh.ribbon.mgz
+    ribbon:
+    # type=file|default=<undefined>: Input file must be <subject_id>/mri/ribbon.mgz
+    lh_annotation:
+    # type=file|default=<undefined>: Input file must be <subject_id>/label/lh.aparc.annot
+    rh_annotation:
+    # type=file|default=<undefined>: Input file must be <subject_id>/label/rh.aparc.annot
+    filled:
+    # type=file|default=<undefined>: Implicit input filled file. Only required with FS v5.3.
+    aseg:
+    # type=file|default=<undefined>: Input aseg file
+    volmask:
+    # type=bool|default=False: Volume mask flag
+    ctxseg:
+    # type=file|default=<undefined>: 
+    label_wm:
+    # type=bool|default=False: For each voxel labeled as white matter in the aseg, re-assign its label to be that of the closest cortical point if its distance is less than dmaxctx.
+    hypo_wm:
+    # type=bool|default=False: Label hypointensities as WM
+    rip_unknown:
+    # type=bool|default=False: Do not label WM based on 'unknown' corical label
+    a2009s:
+    # type=bool|default=False: Using the a2009s atlas
+    copy_inputs:
+    # type=bool|default=False: If running as a node, set this to True.This will copy the input files to the node directory.
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    lh_white:
+    # type=file|default=<undefined>: Input file must be <subject_id>/surf/lh.white
+    rh_white:
+    # type=file|default=<undefined>: Input file must be <subject_id>/surf/rh.white
+    lh_pial:
+    # type=file|default=<undefined>: Input file must be <subject_id>/surf/lh.pial
+    rh_pial:
+    # type=file|default=<undefined>: Input file must be <subject_id>/surf/rh.pial
+    lh_ribbon:
+    # type=file|default=<undefined>: Input file must be <subject_id>/mri/lh.ribbon.mgz
+    rh_ribbon:
+    # type=file|default=<undefined>: Input file must be <subject_id>/mri/rh.ribbon.mgz
+    ribbon:
+    # type=file|default=<undefined>: Input file must be <subject_id>/mri/ribbon.mgz
+    lh_annotation:
+    # type=file|default=<undefined>: Input file must be <subject_id>/label/lh.aparc.annot
+    rh_annotation:
+    # type=file|default=<undefined>: Input file must be <subject_id>/label/rh.aparc.annot
+    out_file:
+    # type=file: Output aseg file
+    # type=file|default=<undefined>: Full path of file to save the output segmentation in
+    label_wm: 'True'
+    # type=bool|default=False: For each voxel labeled as white matter in the aseg, re-assign its label to be that of the closest cortical point if its distance is less than dmaxctx.
+    rip_unknown: 'True'
+    # type=bool|default=False: Do not label WM based on 'unknown' corical label
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: mri_aparc2aseg --labelwm --o aparc+aseg.mgz --rip-unknown --s subject_id
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    lh_white:
+    # type=file|default=<undefined>: Input file must be <subject_id>/surf/lh.white
+    rh_white:
+    # type=file|default=<undefined>: Input file must be <subject_id>/surf/rh.white
+    lh_pial:
+    # type=file|default=<undefined>: Input file must be <subject_id>/surf/lh.pial
+    rh_pial:
+    # type=file|default=<undefined>: Input file must be <subject_id>/surf/rh.pial
+    lh_ribbon:
+    # type=file|default=<undefined>: Input file must be <subject_id>/mri/lh.ribbon.mgz
+    rh_ribbon:
+    # type=file|default=<undefined>: Input file must be <subject_id>/mri/rh.ribbon.mgz
+    ribbon:
+    # type=file|default=<undefined>: Input file must be <subject_id>/mri/ribbon.mgz
+    lh_annotation:
+    # type=file|default=<undefined>: Input file must be <subject_id>/label/lh.aparc.annot
+    rh_annotation:
+    # type=file|default=<undefined>: Input file must be <subject_id>/label/rh.aparc.annot
+    out_file:
+    # type=file: Output aseg file
+    # type=file|default=<undefined>: Full path of file to save the output segmentation in
+    label_wm: 'True'
+    # type=bool|default=False: For each voxel labeled as white matter in the aseg, re-assign its label to be that of the closest cortical point if its distance is less than dmaxctx.
+    rip_unknown: 'True'
+    # type=bool|default=False: Do not label WM based on 'unknown' corical label
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/aparc_2_aseg_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/aparc_2_aseg_callables.py
new file mode 100644
index 00000000..d9a21915
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/aparc_2_aseg_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Aparc2Aseg.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/apas_2_aseg.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/apas_2_aseg.yaml
new file mode 100644
index 00000000..a6a79760
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/apas_2_aseg.yaml
@@ -0,0 +1,137 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.utils.Apas2Aseg' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Converts aparc+aseg.mgz into something like aseg.mgz by replacing the
+#     cortical segmentations 1000-1035 with 3 and 2000-2035 with 42. The
+#     advantage of this output is that the cortical label conforms to the
+#     actual surface (this is not the case with aseg.mgz).
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces.freesurfer import Apas2Aseg
+#     >>> apas2aseg = Apas2Aseg()
+#     >>> apas2aseg.inputs.in_file = 'aseg.mgz'
+#     >>> apas2aseg.inputs.out_file = 'output.mgz'
+#     >>> apas2aseg.cmdline
+#     'apas2aseg --i aseg.mgz --o output.mgz'
+# 
+#     
+task_name: Apas2Aseg
+nipype_name: Apas2Aseg
+nipype_module: nipype.interfaces.freesurfer.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/mgh-gz
+    # type=file|default=<undefined>: Input aparc+aseg.mgz
+    out_file: medimage/mgh-gz
+    # type=file: Output aseg file
+    # type=file|default=<undefined>: Output aseg file
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: medimage/mgh-gz
+    # type=file: Output aseg file
+    # type=file|default=<undefined>: Output aseg file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: Input aparc+aseg.mgz
+    out_file:
+    # type=file: Output aseg file
+    # type=file|default=<undefined>: Output aseg file
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: Input aparc+aseg.mgz
+    out_file:
+    # type=file: Output aseg file
+    # type=file|default=<undefined>: Output aseg file
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: apas2aseg --i aseg.mgz --o output.mgz
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: Input aparc+aseg.mgz
+    out_file:
+    # type=file: Output aseg file
+    # type=file|default=<undefined>: Output aseg file
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/apas_2_aseg_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/apas_2_aseg_callables.py
new file mode 100644
index 00000000..79f67377
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/apas_2_aseg_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Apas2Aseg.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/apply_mask.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/apply_mask.yaml
new file mode 100644
index 00000000..6f6fdfbb
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/apply_mask.yaml
@@ -0,0 +1,115 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.utils.ApplyMask' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Use Freesurfer's mri_mask to apply a mask to an image.
+# 
+#     The mask file need not be binarized; it can be thresholded above a given
+#     value before application. It can also optionally be transformed into input
+#     space with an LTA matrix.
+# 
+#     
+task_name: ApplyMask
+nipype_name: ApplyMask
+nipype_module: nipype.interfaces.freesurfer.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: input image (will be masked)
+    mask_file: generic/file
+    # type=file|default=<undefined>: image defining mask space
+    out_file: generic/file
+    # type=file: masked image
+    # type=file|default=<undefined>: final image to write
+    xfm_file: generic/file
+    # type=file|default=<undefined>: LTA-format transformation matrix to align mask with input
+    xfm_source: generic/file
+    # type=file|default=<undefined>: image defining transform source space
+    xfm_target: generic/file
+    # type=file|default=<undefined>: image defining transform target space
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: masked image
+    # type=file|default=<undefined>: final image to write
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input image (will be masked)
+    mask_file:
+    # type=file|default=<undefined>: image defining mask space
+    out_file:
+    # type=file: masked image
+    # type=file|default=<undefined>: final image to write
+    xfm_file:
+    # type=file|default=<undefined>: LTA-format transformation matrix to align mask with input
+    invert_xfm:
+    # type=bool|default=False: invert transformation
+    xfm_source:
+    # type=file|default=<undefined>: image defining transform source space
+    xfm_target:
+    # type=file|default=<undefined>: image defining transform target space
+    use_abs:
+    # type=bool|default=False: take absolute value of mask before applying
+    mask_thresh:
+    # type=float|default=0.0: threshold mask before applying
+    keep_mask_deletion_edits:
+    # type=bool|default=False: transfer voxel-deletion edits (voxels=1) from mask to out vol
+    transfer:
+    # type=int|default=0: transfer only voxel value # from mask to out
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/apply_mask_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/apply_mask_callables.py
new file mode 100644
index 00000000..ce0e94d9
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/apply_mask_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in ApplyMask.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/apply_vol_transform.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/apply_vol_transform.yaml
new file mode 100644
index 00000000..2e560829
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/apply_vol_transform.yaml
@@ -0,0 +1,194 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.preprocess.ApplyVolTransform' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Use FreeSurfer mri_vol2vol to apply a transform.
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces.freesurfer import ApplyVolTransform
+#     >>> applyreg = ApplyVolTransform()
+#     >>> applyreg.inputs.source_file = 'structural.nii'
+#     >>> applyreg.inputs.reg_file = 'register.dat'
+#     >>> applyreg.inputs.transformed_file = 'struct_warped.nii'
+#     >>> applyreg.inputs.fs_target = True
+#     >>> applyreg.cmdline
+#     'mri_vol2vol --fstarg --reg register.dat --mov structural.nii --o struct_warped.nii'
+# 
+#     
+task_name: ApplyVolTransform
+nipype_name: ApplyVolTransform
+nipype_module: nipype.interfaces.freesurfer.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    source_file: medimage/nifti1
+    # type=file|default=<undefined>: Input volume you wish to transform
+    target_file: generic/file
+    # type=file|default=<undefined>: Output template volume
+    reg_file: datascience/dat-file
+    # type=file|default=<undefined>: tkRAS-to-tkRAS matrix   (tkregister2 format)
+    lta_file: generic/file
+    # type=file|default=<undefined>: Linear Transform Array file
+    lta_inv_file: generic/file
+    # type=file|default=<undefined>: LTA, invert
+    fsl_reg_file: generic/file
+    # type=file|default=<undefined>: fslRAS-to-fslRAS matrix (FSL format)
+    xfm_reg_file: generic/file
+    # type=file|default=<undefined>: ScannerRAS-to-ScannerRAS matrix (MNI format)
+    m3z_file: generic/file
+    # type=file|default=<undefined>: This is the morph to be applied to the volume. Unless the morph is in mri/transforms (eg.: for talairach.m3z computed by reconall), you will need to specify the full path to this morph and use the --noDefM3zPath flag.
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    transformed_file: medimage/nifti1
+    # type=file: Path to output file if used normally
+    # type=file|default=<undefined>: Output volume
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    transformed_file: '"struct_warped.nii"'
+    # type=file: Path to output file if used normally
+    # type=file|default=<undefined>: Output volume
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    source_file:
+    # type=file|default=<undefined>: Input volume you wish to transform
+    transformed_file:
+    # type=file: Path to output file if used normally
+    # type=file|default=<undefined>: Output volume
+    target_file:
+    # type=file|default=<undefined>: Output template volume
+    tal:
+    # type=bool|default=False: map to a sub FOV of MNI305 (with --reg only)
+    tal_resolution:
+    # type=float|default=0.0: Resolution to sample when using tal
+    fs_target:
+    # type=bool|default=False: use orig.mgz from subject in regfile as target
+    reg_file:
+    # type=file|default=<undefined>: tkRAS-to-tkRAS matrix   (tkregister2 format)
+    lta_file:
+    # type=file|default=<undefined>: Linear Transform Array file
+    lta_inv_file:
+    # type=file|default=<undefined>: LTA, invert
+    fsl_reg_file:
+    # type=file|default=<undefined>: fslRAS-to-fslRAS matrix (FSL format)
+    xfm_reg_file:
+    # type=file|default=<undefined>: ScannerRAS-to-ScannerRAS matrix (MNI format)
+    reg_header:
+    # type=bool|default=False: ScannerRAS-to-ScannerRAS matrix = identity
+    mni_152_reg:
+    # type=bool|default=False: target MNI152 space
+    subject:
+    # type=str|default='': set matrix = identity and use subject for any templates
+    inverse:
+    # type=bool|default=False: sample from target to source
+    interp:
+    # type=enum|default='trilin'|allowed['cubic','nearest','trilin']: Interpolation method (<trilin> or nearest)
+    no_resample:
+    # type=bool|default=False: Do not resample; just change vox2ras matrix
+    m3z_file:
+    # type=file|default=<undefined>: This is the morph to be applied to the volume. Unless the morph is in mri/transforms (eg.: for talairach.m3z computed by reconall), you will need to specify the full path to this morph and use the --noDefM3zPath flag.
+    no_ded_m3z_path:
+    # type=bool|default=False: To be used with the m3z flag. Instructs the code not to look for them3z morph in the default location (SUBJECTS_DIR/subj/mri/transforms), but instead just use the path indicated in --m3z.
+    invert_morph:
+    # type=bool|default=False: Compute and use the inverse of the non-linear morph to resample the input volume. To be used by --m3z.
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    source_file:
+    # type=file|default=<undefined>: Input volume you wish to transform
+    reg_file:
+    # type=file|default=<undefined>: tkRAS-to-tkRAS matrix   (tkregister2 format)
+    transformed_file: '"struct_warped.nii"'
+    # type=file: Path to output file if used normally
+    # type=file|default=<undefined>: Output volume
+    fs_target: 'True'
+    # type=bool|default=False: use orig.mgz from subject in regfile as target
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: mri_vol2vol --fstarg --reg register.dat --mov structural.nii --o struct_warped.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    source_file:
+    # type=file|default=<undefined>: Input volume you wish to transform
+    reg_file:
+    # type=file|default=<undefined>: tkRAS-to-tkRAS matrix   (tkregister2 format)
+    transformed_file: '"struct_warped.nii"'
+    # type=file: Path to output file if used normally
+    # type=file|default=<undefined>: Output volume
+    fs_target: 'True'
+    # type=bool|default=False: use orig.mgz from subject in regfile as target
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/apply_vol_transform_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/apply_vol_transform_callables.py
new file mode 100644
index 00000000..34929ae3
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/apply_vol_transform_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in ApplyVolTransform.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/bb_register.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/bb_register.yaml
new file mode 100644
index 00000000..7c1097a9
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/bb_register.yaml
@@ -0,0 +1,194 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.preprocess.BBRegister' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Use FreeSurfer bbregister to register a volume to the Freesurfer anatomical.
+# 
+#     This program performs within-subject, cross-modal registration using a
+#     boundary-based cost function. It is required that you have an anatomical
+#     scan of the subject that has already been recon-all-ed using freesurfer.
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces.freesurfer import BBRegister
+#     >>> bbreg = BBRegister(subject_id='me', source_file='structural.nii', init='header', contrast_type='t2')
+#     >>> bbreg.cmdline
+#     'bbregister --t2 --init-header --reg structural_bbreg_me.dat --mov structural.nii --s me'
+# 
+#     
+task_name: BBRegister
+nipype_name: BBRegister
+nipype_module: nipype.interfaces.freesurfer.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    init_reg_file: generic/file
+    # type=file|default=<undefined>: existing registration file
+    source_file: medimage/nifti1
+    # type=file|default=<undefined>: source file to be registered
+    intermediate_file: generic/file
+    # type=file|default=<undefined>: Intermediate image, e.g. in case of partial FOV
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_reg_file: generic/file
+    # type=file: Output registration file
+    # type=file|default=<undefined>: output registration file
+    out_fsl_file: generic/file
+    # type=file: Output FLIRT-style registration file
+    # type=traitcompound|default=None: write the transformation matrix in FSL FLIRT format
+    out_lta_file: generic/file
+    # type=file: Output LTA-style registration file
+    # type=traitcompound|default=None: write the transformation matrix in LTA format
+    min_cost_file: generic/file
+    # type=file: Output registration minimum cost file
+    init_cost_file: generic/file
+    # type=file: Output initial registration cost file
+    # type=traitcompound|default=None: output initial registration cost file
+    registered_file: generic/file
+    # type=file: Registered and resampled source file
+    # type=traitcompound|default=None: output warped sourcefile either True or filename
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_reg_file: out_reg_file
+    # type=file: Output registration file
+    # type=file|default=<undefined>: output registration file
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    init:
+    # type=enum|default='coreg'|allowed['best','coreg','fsl','header','rr','spm']: initialize registration with mri_coreg, spm, fsl, or header
+    init_reg_file:
+    # type=file|default=<undefined>: existing registration file
+    subject_id:
+    # type=str|default='': freesurfer subject id
+    source_file:
+    # type=file|default=<undefined>: source file to be registered
+    contrast_type:
+    # type=enum|default='t1'|allowed['bold','dti','t1','t2']: contrast type of image
+    intermediate_file:
+    # type=file|default=<undefined>: Intermediate image, e.g. in case of partial FOV
+    reg_frame:
+    # type=int|default=0: 0-based frame index for 4D source file
+    reg_middle_frame:
+    # type=bool|default=False: Register middle frame of 4D source file
+    out_reg_file:
+    # type=file: Output registration file
+    # type=file|default=<undefined>: output registration file
+    spm_nifti:
+    # type=bool|default=False: force use of nifti rather than analyze with SPM
+    epi_mask:
+    # type=bool|default=False: mask out B0 regions in stages 1 and 2
+    dof:
+    # type=enum|default=6|allowed[12,6,9]: number of transform degrees of freedom
+    fsldof:
+    # type=int|default=0: degrees of freedom for initial registration (FSL)
+    out_fsl_file:
+    # type=file: Output FLIRT-style registration file
+    # type=traitcompound|default=None: write the transformation matrix in FSL FLIRT format
+    out_lta_file:
+    # type=file: Output LTA-style registration file
+    # type=traitcompound|default=None: write the transformation matrix in LTA format
+    registered_file:
+    # type=file: Registered and resampled source file
+    # type=traitcompound|default=None: output warped sourcefile either True or filename
+    init_cost_file:
+    # type=file: Output initial registration cost file
+    # type=traitcompound|default=None: output initial registration cost file
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    subject_id: '"me"'
+    # type=str|default='': freesurfer subject id
+    source_file:
+    # type=file|default=<undefined>: source file to be registered
+    init: '"header"'
+    # type=enum|default='coreg'|allowed['best','coreg','fsl','header','rr','spm']: initialize registration with mri_coreg, spm, fsl, or header
+    contrast_type: '"t2"'
+    # type=enum|default='t1'|allowed['bold','dti','t1','t2']: contrast type of image
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: bbregister --t2 --init-header --reg structural_bbreg_me.dat --mov structural.nii --s me
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    subject_id: '"me"'
+    # type=str|default='': freesurfer subject id
+    source_file:
+    # type=file|default=<undefined>: source file to be registered
+    init: '"header"'
+    # type=enum|default='coreg'|allowed['best','coreg','fsl','header','rr','spm']: initialize registration with mri_coreg, spm, fsl, or header
+    contrast_type: '"t2"'
+    # type=enum|default='t1'|allowed['bold','dti','t1','t2']: contrast type of image
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/bb_register_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/bb_register_callables.py
new file mode 100644
index 00000000..fcc6350a
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/bb_register_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in BBRegister.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/binarize.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/binarize.yaml
new file mode 100644
index 00000000..00051fd3
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/binarize.yaml
@@ -0,0 +1,190 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.model.Binarize' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Use FreeSurfer mri_binarize to threshold an input volume
+# 
+#     Examples
+#     --------
+#     >>> binvol = Binarize(in_file='structural.nii', min=10, binary_file='foo_out.nii')
+#     >>> binvol.cmdline
+#     'mri_binarize --o foo_out.nii --i structural.nii --min 10.000000'
+# 
+#     
+task_name: Binarize
+nipype_name: Binarize
+nipype_module: nipype.interfaces.freesurfer.model
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: input volume
+    merge_file: generic/file
+    # type=file|default=<undefined>: merge with mergevol
+    mask_file: generic/file
+    # type=file|default=<undefined>: must be within mask
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    binary_file: medimage/nifti1
+    # type=file: binarized output volume
+    # type=file|default=<undefined>: binary output volume
+    count_file: generic/file
+    # type=file: ascii file containing number of hits
+    # type=traitcompound|default=None: save number of hits in ascii file (hits, ntotvox, pct)
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    binary_file: '"foo_out.nii"'
+    # type=file: binarized output volume
+    # type=file|default=<undefined>: binary output volume
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input volume
+    min:
+    # type=float|default=0.0: min thresh
+    max:
+    # type=float|default=0.0: max thresh
+    rmin:
+    # type=float|default=0.0: compute min based on rmin*globalmean
+    rmax:
+    # type=float|default=0.0: compute max based on rmax*globalmean
+    match:
+    # type=list|default=[]: match instead of threshold
+    wm:
+    # type=bool|default=False: set match vals to 2 and 41 (aseg for cerebral WM)
+    ventricles:
+    # type=bool|default=False: set match vals those for aseg ventricles+choroid (not 4th)
+    wm_ven_csf:
+    # type=bool|default=False: WM and ventricular CSF, including choroid (not 4th)
+    binary_file:
+    # type=file: binarized output volume
+    # type=file|default=<undefined>: binary output volume
+    out_type:
+    # type=enum|default='nii'|allowed['mgz','nii','nii.gz']: output file type
+    count_file:
+    # type=file: ascii file containing number of hits
+    # type=traitcompound|default=None: save number of hits in ascii file (hits, ntotvox, pct)
+    bin_val:
+    # type=int|default=0: set vox within thresh to val (default is 1)
+    bin_val_not:
+    # type=int|default=0: set vox outside range to val (default is 0)
+    invert:
+    # type=bool|default=False: set binval=0, binvalnot=1
+    frame_no:
+    # type=int|default=0: use 0-based frame of input (default is 0)
+    merge_file:
+    # type=file|default=<undefined>: merge with mergevol
+    mask_file:
+    # type=file|default=<undefined>: must be within mask
+    mask_thresh:
+    # type=float|default=0.0: set thresh for mask
+    abs:
+    # type=bool|default=False: take abs of invol first (ie, make unsigned)
+    bin_col_num:
+    # type=bool|default=False: set binarized voxel value to its column number
+    zero_edges:
+    # type=bool|default=False: zero the edge voxels
+    zero_slice_edge:
+    # type=bool|default=False: zero the edge slice voxels
+    dilate:
+    # type=int|default=0: niters: dilate binarization in 3D
+    erode:
+    # type=int|default=0: nerode: erode binarization in 3D (after any dilation)
+    erode2d:
+    # type=int|default=0: nerode2d: erode binarization in 2D (after any 3D erosion)
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input volume
+    min: '10'
+    # type=float|default=0.0: min thresh
+    binary_file: '"foo_out.nii"'
+    # type=file: binarized output volume
+    # type=file|default=<undefined>: binary output volume
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: mri_binarize --o foo_out.nii --i structural.nii --min 10.000000
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: input volume
+    min: '10'
+    # type=float|default=0.0: min thresh
+    binary_file: '"foo_out.nii"'
+    # type=file: binarized output volume
+    # type=file|default=<undefined>: binary output volume
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/binarize_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/binarize_callables.py
new file mode 100644
index 00000000..c4023215
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/binarize_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Binarize.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/ca_label.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/ca_label.yaml
new file mode 100644
index 00000000..025fac4c
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/ca_label.yaml
@@ -0,0 +1,182 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.preprocess.CALabel' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Label subcortical structures based in GCA model.
+# 
+#     See Also
+#     --------
+#     For complete details, see the `FS Documentation
+#     <http://surfer.nmr.mgh.harvard.edu/fswiki/mri_ca_label>`__
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import freesurfer
+#     >>> ca_label = freesurfer.CALabel()
+#     >>> ca_label.inputs.in_file = "norm.mgz"
+#     >>> ca_label.inputs.out_file = "out.mgz"
+#     >>> ca_label.inputs.transform = "trans.mat"
+#     >>> ca_label.inputs.template = "Template_6.nii" # in practice use .gcs extension
+#     >>> ca_label.cmdline
+#     'mri_ca_label norm.mgz trans.mat Template_6.nii out.mgz'
+# 
+#     
+task_name: CALabel
+nipype_name: CALabel
+nipype_module: nipype.interfaces.freesurfer.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/mgh-gz
+    # type=file|default=<undefined>: Input volume for CALabel
+    out_file: medimage/mgh-gz
+    # type=file: Output volume from CALabel
+    # type=file|default=<undefined>: Output file for CALabel
+    transform: datascience/text-matrix
+    # type=file|default=<undefined>: Input transform for CALabel
+    template: medimage/nifti1
+    # type=file|default=<undefined>: Input template for CALabel
+    in_vol: generic/file
+    # type=file|default=<undefined>: set input volume
+    intensities: generic/file
+    # type=file|default=<undefined>: input label intensities file(used in longitudinal processing)
+    label: generic/file
+    # type=file|default=<undefined>: Undocumented flag. Autorecon3 uses ../label/{hemisphere}.cortex.label as input file
+    aseg: generic/file
+    # type=file|default=<undefined>: Undocumented flag. Autorecon3 uses ../mri/aseg.presurf.mgz as input file
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: medimage/mgh-gz
+    # type=file: Output volume from CALabel
+    # type=file|default=<undefined>: Output file for CALabel
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: Input volume for CALabel
+    out_file:
+    # type=file: Output volume from CALabel
+    # type=file|default=<undefined>: Output file for CALabel
+    transform:
+    # type=file|default=<undefined>: Input transform for CALabel
+    template:
+    # type=file|default=<undefined>: Input template for CALabel
+    in_vol:
+    # type=file|default=<undefined>: set input volume
+    intensities:
+    # type=file|default=<undefined>: input label intensities file(used in longitudinal processing)
+    no_big_ventricles:
+    # type=bool|default=False: No big ventricles
+    align:
+    # type=bool|default=False: Align CALabel
+    prior:
+    # type=float|default=0.0: Prior for CALabel
+    relabel_unlikely:
+    # type=tuple|default=(0, 0.0): Reclassify voxels at least some std devs from the mean using some size Gaussian window
+    label:
+    # type=file|default=<undefined>: Undocumented flag. Autorecon3 uses ../label/{hemisphere}.cortex.label as input file
+    aseg:
+    # type=file|default=<undefined>: Undocumented flag. Autorecon3 uses ../mri/aseg.presurf.mgz as input file
+    num_threads:
+    # type=int|default=0: allows for specifying more threads
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: Input volume for CALabel
+    out_file:
+    # type=file: Output volume from CALabel
+    # type=file|default=<undefined>: Output file for CALabel
+    transform:
+    # type=file|default=<undefined>: Input transform for CALabel
+    template:
+    # type=file|default=<undefined>: Input template for CALabel
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: mri_ca_label norm.mgz trans.mat Template_6.nii out.mgz
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: Input volume for CALabel
+    out_file:
+    # type=file: Output volume from CALabel
+    # type=file|default=<undefined>: Output file for CALabel
+    transform:
+    # type=file|default=<undefined>: Input transform for CALabel
+    template:
+    # type=file|default=<undefined>: Input template for CALabel
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/ca_label_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/ca_label_callables.py
new file mode 100644
index 00000000..9461dd05
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/ca_label_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in CALabel.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/ca_normalize.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/ca_normalize.yaml
new file mode 100644
index 00000000..6c64c82c
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/ca_normalize.yaml
@@ -0,0 +1,167 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.preprocess.CANormalize' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# This program creates a normalized volume using the brain volume and an
+#     input gca file.
+# 
+#     See Also
+#     --------
+#     For complete details, see the `FS Documentation
+#     <http://surfer.nmr.mgh.harvard.edu/fswiki/mri_ca_normalize>`__.
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import freesurfer
+#     >>> ca_normalize = freesurfer.CANormalize()
+#     >>> ca_normalize.inputs.in_file = "T1.mgz"
+#     >>> ca_normalize.inputs.atlas = "atlas.nii.gz" # in practice use .gca atlases
+#     >>> ca_normalize.inputs.transform = "trans.mat" # in practice use .lta transforms
+#     >>> ca_normalize.cmdline
+#     'mri_ca_normalize T1.mgz atlas.nii.gz trans.mat T1_norm.mgz'
+# 
+#     
+task_name: CANormalize
+nipype_name: CANormalize
+nipype_module: nipype.interfaces.freesurfer.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/mgh-gz
+    # type=file|default=<undefined>: The input file for CANormalize
+    out_file: generic/file
+    # type=file: The output file for Normalize
+    # type=file|default=<undefined>: The output file for CANormalize
+    atlas: medimage/nifti-gz
+    # type=file|default=<undefined>: The atlas file in gca format
+    transform: datascience/text-matrix
+    # type=file|default=<undefined>: The transform file in lta format
+    mask: generic/file
+    # type=file|default=<undefined>: Specifies volume to use as mask
+    control_points: generic/file
+    # type=file: The output control points for Normalize
+    # type=file|default=<undefined>: File name for the output control points
+    long_file: generic/file
+    # type=file|default=<undefined>: undocumented flag used in longitudinal processing
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: The output file for Normalize
+    # type=file|default=<undefined>: The output file for CANormalize
+    control_points: generic/file
+    # type=file: The output control points for Normalize
+    # type=file|default=<undefined>: File name for the output control points
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: The input file for CANormalize
+    out_file:
+    # type=file: The output file for Normalize
+    # type=file|default=<undefined>: The output file for CANormalize
+    atlas:
+    # type=file|default=<undefined>: The atlas file in gca format
+    transform:
+    # type=file|default=<undefined>: The transform file in lta format
+    mask:
+    # type=file|default=<undefined>: Specifies volume to use as mask
+    control_points:
+    # type=file: The output control points for Normalize
+    # type=file|default=<undefined>: File name for the output control points
+    long_file:
+    # type=file|default=<undefined>: undocumented flag used in longitudinal processing
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: The input file for CANormalize
+    atlas:
+    # type=file|default=<undefined>: The atlas file in gca format
+    transform:
+    # type=file|default=<undefined>: The transform file in lta format
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: mri_ca_normalize T1.mgz atlas.nii.gz trans.mat T1_norm.mgz
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: The input file for CANormalize
+    atlas:
+    # type=file|default=<undefined>: The atlas file in gca format
+    transform:
+    # type=file|default=<undefined>: The transform file in lta format
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/ca_normalize_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/ca_normalize_callables.py
new file mode 100644
index 00000000..74c8f9a0
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/ca_normalize_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in CANormalize.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/ca_register.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/ca_register.yaml
new file mode 100644
index 00000000..7548fa0d
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/ca_register.yaml
@@ -0,0 +1,166 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.preprocess.CARegister' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Generates a multi-dimensional talairach transform from a gca file and talairach.lta file
+# 
+#     See Also
+#     --------
+#     For complete details, see the `FS Documentation
+#     <http://surfer.nmr.mgh.harvard.edu/fswiki/mri_ca_register>`__
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import freesurfer
+#     >>> ca_register = freesurfer.CARegister()
+#     >>> ca_register.inputs.in_file = "norm.mgz"
+#     >>> ca_register.inputs.out_file = "talairach.m3z"
+#     >>> ca_register.cmdline
+#     'mri_ca_register norm.mgz talairach.m3z'
+# 
+#     
+task_name: CARegister
+nipype_name: CARegister
+nipype_module: nipype.interfaces.freesurfer.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/mgh-gz
+    # type=file|default=<undefined>: The input volume for CARegister
+    template: generic/file
+    # type=file|default=<undefined>: The template file in gca format
+    mask: generic/file
+    # type=file|default=<undefined>: Specifies volume to use as mask
+    transform: generic/file
+    # type=file|default=<undefined>: Specifies transform in lta format
+    l_files: generic/file+list-of
+    # type=inputmultiobject|default=[]: undocumented flag used in longitudinal processing
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: medimage-freesurfer/m3z
+    # type=file: The output file for CARegister
+    # type=file|default=<undefined>: The output volume for CARegister
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: '"talairach.m3z"'
+    # type=file: The output file for CARegister
+    # type=file|default=<undefined>: The output volume for CARegister
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: The input volume for CARegister
+    out_file:
+    # type=file: The output file for CARegister
+    # type=file|default=<undefined>: The output volume for CARegister
+    template:
+    # type=file|default=<undefined>: The template file in gca format
+    mask:
+    # type=file|default=<undefined>: Specifies volume to use as mask
+    invert_and_save:
+    # type=bool|default=False: Invert and save the .m3z multi-dimensional talaraich transform to x, y, and z .mgz files
+    no_big_ventricles:
+    # type=bool|default=False: No big ventricles
+    transform:
+    # type=file|default=<undefined>: Specifies transform in lta format
+    align:
+    # type=string|default='': Specifies when to perform alignment
+    levels:
+    # type=int|default=0: defines how many surrounding voxels will be used in interpolations, default is 6
+    A:
+    # type=int|default=0: undocumented flag used in longitudinal processing
+    l_files:
+    # type=inputmultiobject|default=[]: undocumented flag used in longitudinal processing
+    num_threads:
+    # type=int|default=0: allows for specifying more threads
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: The input volume for CARegister
+    out_file: '"talairach.m3z"'
+    # type=file: The output file for CARegister
+    # type=file|default=<undefined>: The output volume for CARegister
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: mri_ca_register norm.mgz talairach.m3z
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: The input volume for CARegister
+    out_file: '"talairach.m3z"'
+    # type=file: The output file for CARegister
+    # type=file|default=<undefined>: The output volume for CARegister
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/ca_register_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/ca_register_callables.py
new file mode 100644
index 00000000..cebb0f07
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/ca_register_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in CARegister.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/check_talairach_alignment.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/check_talairach_alignment.yaml
new file mode 100644
index 00000000..149cf366
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/check_talairach_alignment.yaml
@@ -0,0 +1,132 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.utils.CheckTalairachAlignment' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     This program detects Talairach alignment failures
+# 
+#     Examples
+#     ========
+# 
+#     >>> from nipype.interfaces.freesurfer import CheckTalairachAlignment
+#     >>> checker = CheckTalairachAlignment()
+# 
+#     >>> checker.inputs.in_file = 'trans.mat'
+#     >>> checker.inputs.threshold = 0.005
+#     >>> checker.cmdline
+#     'talairach_afd -T 0.005 -xfm trans.mat'
+# 
+#     >>> checker.run() # doctest: +SKIP
+#     
+task_name: CheckTalairachAlignment
+nipype_name: CheckTalairachAlignment
+nipype_module: nipype.interfaces.freesurfer.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: datascience/text-matrix
+    # type=file|default=<undefined>: specify the talairach.xfm file to check
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: The input file for CheckTalairachAlignment
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: specify the talairach.xfm file to check
+    subject:
+    # type=string|default='': specify subject's name
+    threshold:
+    # type=float|default=0.01: Talairach transforms for subjects with p-values <= T are considered as very unlikely default=0.010
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: specify the talairach.xfm file to check
+    threshold: '0.005'
+    # type=float|default=0.01: Talairach transforms for subjects with p-values <= T are considered as very unlikely default=0.010
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: talairach_afd -T 0.005 -xfm trans.mat
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: specify the talairach.xfm file to check
+    threshold: '0.005'
+    # type=float|default=0.01: Talairach transforms for subjects with p-values <= T are considered as very unlikely default=0.010
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/check_talairach_alignment_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/check_talairach_alignment_callables.py
new file mode 100644
index 00000000..31369920
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/check_talairach_alignment_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in CheckTalairachAlignment.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/concatenate.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/concatenate.yaml
new file mode 100644
index 00000000..bc54d2f4
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/concatenate.yaml
@@ -0,0 +1,170 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.model.Concatenate' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Use Freesurfer mri_concat to combine several input volumes
+#     into one output volume.  Can concatenate by frames, or compute
+#     a variety of statistics on the input volumes.
+# 
+#     Examples
+#     --------
+#     Combine two input volumes into one volume with two frames
+# 
+#     >>> concat = Concatenate()
+#     >>> concat.inputs.in_files = ['cont1.nii', 'cont2.nii']
+#     >>> concat.inputs.concatenated_file = 'bar.nii'
+#     >>> concat.cmdline
+#     'mri_concat --o bar.nii --i cont1.nii --i cont2.nii'
+# 
+#     
+task_name: Concatenate
+nipype_name: Concatenate
+nipype_module: nipype.interfaces.freesurfer.model
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_files: medimage/nifti1+list-of
+    # type=inputmultiobject|default=[]: Individual volumes to be concatenated
+    multiply_matrix_file: generic/file
+    # type=file|default=<undefined>: Multiply input by an ascii matrix in file
+    mask_file: generic/file
+    # type=file|default=<undefined>: Mask input with a volume
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    concatenated_file: medimage/nifti1
+    # type=file: Path/name of the output volume
+    # type=file|default=<undefined>: Output volume
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    concatenated_file: '"bar.nii"'
+    # type=file: Path/name of the output volume
+    # type=file|default=<undefined>: Output volume
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_files:
+    # type=inputmultiobject|default=[]: Individual volumes to be concatenated
+    concatenated_file:
+    # type=file: Path/name of the output volume
+    # type=file|default=<undefined>: Output volume
+    sign:
+    # type=enum|default='abs'|allowed['abs','neg','pos']: Take only pos or neg voxles from input, or take abs
+    stats:
+    # type=enum|default='sum'|allowed['max','mean','min','std','sum','var']: Compute the sum, var, std, max, min or mean of the input volumes
+    paired_stats:
+    # type=enum|default='sum'|allowed['avg','diff','diff-norm','diff-norm1','diff-norm2','sum']: Compute paired sum, avg, or diff
+    gmean:
+    # type=int|default=0: create matrix to average Ng groups, Nper=Ntot/Ng
+    mean_div_n:
+    # type=bool|default=False: compute mean/nframes (good for var)
+    multiply_by:
+    # type=float|default=0.0: Multiply input volume by some amount
+    add_val:
+    # type=float|default=0.0: Add some amount to the input volume
+    multiply_matrix_file:
+    # type=file|default=<undefined>: Multiply input by an ascii matrix in file
+    combine:
+    # type=bool|default=False: Combine non-zero values into single frame volume
+    keep_dtype:
+    # type=bool|default=False: Keep voxelwise precision type (default is float
+    max_bonfcor:
+    # type=bool|default=False: Compute max and bonferroni correct (assumes -log10(ps))
+    max_index:
+    # type=bool|default=False: Compute the index of max voxel in concatenated volumes
+    mask_file:
+    # type=file|default=<undefined>: Mask input with a volume
+    vote:
+    # type=bool|default=False: Most frequent value at each voxel and fraction of occurrences
+    sort:
+    # type=bool|default=False: Sort each voxel by ascending frame value
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_files:
+    # type=inputmultiobject|default=[]: Individual volumes to be concatenated
+    concatenated_file: '"bar.nii"'
+    # type=file: Path/name of the output volume
+    # type=file|default=<undefined>: Output volume
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: mri_concat --o bar.nii --i cont1.nii --i cont2.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_files:
+    # type=inputmultiobject|default=[]: Individual volumes to be concatenated
+    concatenated_file: '"bar.nii"'
+    # type=file: Path/name of the output volume
+    # type=file|default=<undefined>: Output volume
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/concatenate_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/concatenate_callables.py
new file mode 100644
index 00000000..98afd0f7
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/concatenate_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Concatenate.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/concatenate_lta.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/concatenate_lta.yaml
new file mode 100644
index 00000000..e803ec81
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/concatenate_lta.yaml
@@ -0,0 +1,243 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.preprocess.ConcatenateLTA' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Concatenates two consecutive LTA transformations into one overall
+#     transformation
+# 
+#     Out = LTA2*LTA1
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces.freesurfer import ConcatenateLTA
+#     >>> conc_lta = ConcatenateLTA()
+#     >>> conc_lta.inputs.in_lta1 = 'lta1.lta'
+#     >>> conc_lta.inputs.in_lta2 = 'lta2.lta'
+#     >>> conc_lta.cmdline
+#     'mri_concatenate_lta lta1.lta lta2.lta lta1_concat.lta'
+# 
+#     You can use 'identity.nofile' as the filename for in_lta2, e.g.:
+# 
+#     >>> conc_lta.inputs.in_lta2 = 'identity.nofile'
+#     >>> conc_lta.inputs.invert_1 = True
+#     >>> conc_lta.inputs.out_file = 'inv1.lta'
+#     >>> conc_lta.cmdline
+#     'mri_concatenate_lta -invert1 lta1.lta identity.nofile inv1.lta'
+# 
+#     To create a RAS2RAS transform:
+# 
+#     >>> conc_lta.inputs.out_type = 'RAS2RAS'
+#     >>> conc_lta.cmdline
+#     'mri_concatenate_lta -invert1 -out_type 1 lta1.lta identity.nofile inv1.lta'
+#     
+task_name: ConcatenateLTA
+nipype_name: ConcatenateLTA
+nipype_module: nipype.interfaces.freesurfer.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_lta1: medimage-freesurfer/lta
+    # type=file|default=<undefined>: maps some src1 to dst1
+    out_file: medimage-freesurfer/lta
+    # type=file: the combined LTA maps: src1 to dst2 = LTA2*LTA1
+    # type=file|default=<undefined>: the combined LTA maps: src1 to dst2 = LTA2*LTA1
+    tal_source_file: generic/file
+    # type=file|default=<undefined>: if in_lta2 is talairach.xfm, specify source for talairach
+    tal_template_file: generic/file
+    # type=file|default=<undefined>: if in_lta2 is talairach.xfm, specify template for talairach
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: medimage-freesurfer/lta
+    # type=file: the combined LTA maps: src1 to dst2 = LTA2*LTA1
+    # type=file|default=<undefined>: the combined LTA maps: src1 to dst2 = LTA2*LTA1
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_lta1:
+    # type=file|default=<undefined>: maps some src1 to dst1
+    in_lta2:
+    # type=traitcompound|default=None: maps dst1(src2) to dst2
+    out_file:
+    # type=file: the combined LTA maps: src1 to dst2 = LTA2*LTA1
+    # type=file|default=<undefined>: the combined LTA maps: src1 to dst2 = LTA2*LTA1
+    invert_1:
+    # type=bool|default=False: invert in_lta1 before applying it
+    invert_2:
+    # type=bool|default=False: invert in_lta2 before applying it
+    invert_out:
+    # type=bool|default=False: invert output LTA
+    out_type:
+    # type=enum|default='VOX2VOX'|allowed['RAS2RAS','VOX2VOX']: set final LTA type
+    tal_source_file:
+    # type=file|default=<undefined>: if in_lta2 is talairach.xfm, specify source for talairach
+    tal_template_file:
+    # type=file|default=<undefined>: if in_lta2 is talairach.xfm, specify template for talairach
+    subject:
+    # type=str|default='': set subject in output LTA
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_lta1:
+    # type=file|default=<undefined>: maps some src1 to dst1
+    in_lta2: '"lta2.lta"'
+    # type=traitcompound|default=None: maps dst1(src2) to dst2
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_lta2: '"identity.nofile"'
+    # type=traitcompound|default=None: maps dst1(src2) to dst2
+    invert_1: 'True'
+    # type=bool|default=False: invert in_lta1 before applying it
+    out_file:
+    # type=file: the combined LTA maps: src1 to dst2 = LTA2*LTA1
+    # type=file|default=<undefined>: the combined LTA maps: src1 to dst2 = LTA2*LTA1
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    out_type: '"RAS2RAS"'
+    # type=enum|default='VOX2VOX'|allowed['RAS2RAS','VOX2VOX']: set final LTA type
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: mri_concatenate_lta lta1.lta lta2.lta lta1_concat.lta
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_lta1:
+    # type=file|default=<undefined>: maps some src1 to dst1
+    in_lta2: '"lta2.lta"'
+    # type=traitcompound|default=None: maps dst1(src2) to dst2
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: mri_concatenate_lta -invert1 lta1.lta identity.nofile inv1.lta
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_lta2: '"identity.nofile"'
+    # type=traitcompound|default=None: maps dst1(src2) to dst2
+    invert_1: 'True'
+    # type=bool|default=False: invert in_lta1 before applying it
+    out_file:
+    # type=file: the combined LTA maps: src1 to dst2 = LTA2*LTA1
+    # type=file|default=<undefined>: the combined LTA maps: src1 to dst2 = LTA2*LTA1
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: mri_concatenate_lta -invert1 -out_type 1 lta1.lta identity.nofile inv1.lta
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    out_type: '"RAS2RAS"'
+    # type=enum|default='VOX2VOX'|allowed['RAS2RAS','VOX2VOX']: set final LTA type
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/concatenate_lta_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/concatenate_lta_callables.py
new file mode 100644
index 00000000..b772b7d0
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/concatenate_lta_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in ConcatenateLTA.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/contrast.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/contrast.yaml
new file mode 100644
index 00000000..0e8efa7f
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/contrast.yaml
@@ -0,0 +1,184 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.utils.Contrast' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Compute surface-wise gray/white contrast
+# 
+#     Examples
+#     ========
+#     >>> from nipype.interfaces.freesurfer import Contrast
+#     >>> contrast = Contrast()
+#     >>> contrast.inputs.subject_id = '10335'
+#     >>> contrast.inputs.hemisphere = 'lh'
+#     >>> contrast.inputs.white = 'lh.white' # doctest: +SKIP
+#     >>> contrast.inputs.thickness = 'lh.thickness' # doctest: +SKIP
+#     >>> contrast.inputs.annotation = '../label/lh.aparc.annot' # doctest: +SKIP
+#     >>> contrast.inputs.cortex = '../label/lh.cortex.label' # doctest: +SKIP
+#     >>> contrast.inputs.rawavg = '../mri/rawavg.mgz' # doctest: +SKIP
+#     >>> contrast.inputs.orig = '../mri/orig.mgz' # doctest: +SKIP
+#     >>> contrast.cmdline # doctest: +SKIP
+#     'pctsurfcon --lh-only --s 10335'
+#     
+task_name: Contrast
+nipype_name: Contrast
+nipype_module: nipype.interfaces.freesurfer.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    thickness: medimage-freesurfer/thickness
+    # type=file|default=<undefined>: Input file must be <subject_id>/surf/?h.thickness
+    white: medimage-freesurfer/white
+    # type=file|default=<undefined>: Input file must be <subject_id>/surf/<hemisphere>.white
+    annotation: medimage-freesurfer/annot
+    # type=file|default=<undefined>: Input annotation file must be <subject_id>/label/<hemisphere>.aparc.annot
+    cortex: medimage-freesurfer/label
+    # type=file|default=<undefined>: Input cortex label must be <subject_id>/label/<hemisphere>.cortex.label
+    orig: medimage/mgh-gz
+    # type=file|default=<undefined>: Implicit input file mri/orig.mgz
+    rawavg: medimage/mgh-gz
+    # type=file|default=<undefined>: Implicit input file mri/rawavg.mgz
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_contrast: generic/file
+    # type=file: Output contrast file from Contrast
+    out_stats: generic/file
+    # type=file: Output stats file from Contrast
+    out_log: generic/file
+    # type=file: Output log from Contrast
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    subject_id:
+    # type=string|default='subject_id': Subject being processed
+    hemisphere:
+    # type=enum|default='lh'|allowed['lh','rh']: Hemisphere being processed
+    thickness:
+    # type=file|default=<undefined>: Input file must be <subject_id>/surf/?h.thickness
+    white:
+    # type=file|default=<undefined>: Input file must be <subject_id>/surf/<hemisphere>.white
+    annotation:
+    # type=file|default=<undefined>: Input annotation file must be <subject_id>/label/<hemisphere>.aparc.annot
+    cortex:
+    # type=file|default=<undefined>: Input cortex label must be <subject_id>/label/<hemisphere>.cortex.label
+    orig:
+    # type=file|default=<undefined>: Implicit input file mri/orig.mgz
+    rawavg:
+    # type=file|default=<undefined>: Implicit input file mri/rawavg.mgz
+    copy_inputs:
+    # type=bool|default=False: If running as a node, set this to True.This will copy the input files to the node directory.
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    subject_id: '"10335"'
+    # type=string|default='subject_id': Subject being processed
+    hemisphere: '"lh"'
+    # type=enum|default='lh'|allowed['lh','rh']: Hemisphere being processed
+    white:
+    # type=file|default=<undefined>: Input file must be <subject_id>/surf/<hemisphere>.white
+    thickness:
+    # type=file|default=<undefined>: Input file must be <subject_id>/surf/?h.thickness
+    annotation:
+    # type=file|default=<undefined>: Input annotation file must be <subject_id>/label/<hemisphere>.aparc.annot
+    cortex:
+    # type=file|default=<undefined>: Input cortex label must be <subject_id>/label/<hemisphere>.cortex.label
+    rawavg:
+    # type=file|default=<undefined>: Implicit input file mri/rawavg.mgz
+    orig:
+    # type=file|default=<undefined>: Implicit input file mri/orig.mgz
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: pctsurfcon --lh-only --s 10335
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    subject_id: '"10335"'
+    # type=string|default='subject_id': Subject being processed
+    hemisphere: '"lh"'
+    # type=enum|default='lh'|allowed['lh','rh']: Hemisphere being processed
+    white:
+    # type=file|default=<undefined>: Input file must be <subject_id>/surf/<hemisphere>.white
+    thickness:
+    # type=file|default=<undefined>: Input file must be <subject_id>/surf/?h.thickness
+    annotation:
+    # type=file|default=<undefined>: Input annotation file must be <subject_id>/label/<hemisphere>.aparc.annot
+    cortex:
+    # type=file|default=<undefined>: Input cortex label must be <subject_id>/label/<hemisphere>.cortex.label
+    rawavg:
+    # type=file|default=<undefined>: Implicit input file mri/rawavg.mgz
+    orig:
+    # type=file|default=<undefined>: Implicit input file mri/orig.mgz
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/contrast_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/contrast_callables.py
new file mode 100644
index 00000000..926d9117
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/contrast_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Contrast.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/curvature.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/curvature.yaml
new file mode 100644
index 00000000..7f71b624
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/curvature.yaml
@@ -0,0 +1,140 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.utils.Curvature' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     This program will compute the second fundamental form of a cortical
+#     surface. It will create two new files <hemi>.<surface>.H and
+#     <hemi>.<surface>.K with the mean and Gaussian curvature respectively.
+# 
+#     Examples
+#     ========
+#     >>> from nipype.interfaces.freesurfer import Curvature
+#     >>> curv = Curvature()
+#     >>> curv.inputs.in_file = 'lh.pial'
+#     >>> curv.inputs.save = True
+#     >>> curv.cmdline
+#     'mris_curvature -w lh.pial'
+#     
+task_name: Curvature
+nipype_name: Curvature
+nipype_module: nipype.interfaces.freesurfer.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage-freesurfer/pial
+    # type=file|default=<undefined>: Input file for Curvature
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_mean: generic/file
+    # type=file: Mean curvature output file
+    out_gauss: generic/file
+    # type=file: Gaussian curvature output file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: Input file for Curvature
+    threshold:
+    # type=float|default=0.0: Undocumented input threshold
+    n:
+    # type=bool|default=False: Undocumented boolean flag
+    averages:
+    # type=int|default=0: Perform this number iterative averages of curvature measure before saving
+    save:
+    # type=bool|default=False: Save curvature files (will only generate screen output without this option)
+    distances:
+    # type=tuple|default=(0, 0): Undocumented input integer distances
+    copy_input:
+    # type=bool|default=False: Copy input file to current directory
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: Input file for Curvature
+    save: 'True'
+    # type=bool|default=False: Save curvature files (will only generate screen output without this option)
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: mris_curvature -w lh.pial
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: Input file for Curvature
+    save: 'True'
+    # type=bool|default=False: Save curvature files (will only generate screen output without this option)
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/curvature_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/curvature_callables.py
new file mode 100644
index 00000000..a74cd397
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/curvature_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Curvature.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/curvature_stats.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/curvature_stats.yaml
new file mode 100644
index 00000000..066e03ab
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/curvature_stats.yaml
@@ -0,0 +1,202 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.utils.CurvatureStats' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     In its simplest usage, 'mris_curvature_stats' will compute a set
+#     of statistics on its input <curvFile>. These statistics are the
+#     mean and standard deviation of the particular curvature on the
+#     surface, as well as the results from several surface-based
+#     integrals.
+# 
+#     Additionally, 'mris_curvature_stats' can report the max/min
+#     curvature values, and compute a simple histogram based on
+#     all curvature values.
+# 
+#     Curvatures can also be normalised and constrained to a given
+#     range before computation.
+# 
+#     Principal curvature (K, H, k1 and k2) calculations on a surface
+#     structure can also be performed, as well as several functions
+#     derived from k1 and k2.
+# 
+#     Finally, all output to the console, as well as any new
+#     curvatures that result from the above calculations can be
+#     saved to a series of text and binary-curvature files.
+# 
+#     Examples
+#     ========
+#     >>> from nipype.interfaces.freesurfer import CurvatureStats
+#     >>> curvstats = CurvatureStats()
+#     >>> curvstats.inputs.hemisphere = 'lh'
+#     >>> curvstats.inputs.curvfile1 = 'lh.pial'
+#     >>> curvstats.inputs.curvfile2 = 'lh.pial'
+#     >>> curvstats.inputs.surface = 'lh.pial'
+#     >>> curvstats.inputs.out_file = 'lh.curv.stats'
+#     >>> curvstats.inputs.values = True
+#     >>> curvstats.inputs.min_max = True
+#     >>> curvstats.inputs.write = True
+#     >>> curvstats.cmdline
+#     'mris_curvature_stats -m -o lh.curv.stats -F pial -G --writeCurvatureFiles subject_id lh pial pial'
+#     
+task_name: CurvatureStats
+nipype_name: CurvatureStats
+nipype_module: nipype.interfaces.freesurfer.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    surface: medimage-freesurfer/pial
+    # type=file|default=<undefined>: Specify surface file for CurvatureStats
+    curvfile1: medimage-freesurfer/pial
+    # type=file|default=<undefined>: Input file for CurvatureStats
+    curvfile2: medimage-freesurfer/pial
+    # type=file|default=<undefined>: Input file for CurvatureStats
+    out_file: medimage-freesurfer/stats
+    # type=file: Output curvature stats file
+    # type=file|default=<undefined>: Output curvature stats file
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: medimage-freesurfer/stats
+    # type=file: Output curvature stats file
+    # type=file|default=<undefined>: Output curvature stats file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    surface:
+    # type=file|default=<undefined>: Specify surface file for CurvatureStats
+    curvfile1:
+    # type=file|default=<undefined>: Input file for CurvatureStats
+    curvfile2:
+    # type=file|default=<undefined>: Input file for CurvatureStats
+    hemisphere:
+    # type=enum|default='lh'|allowed['lh','rh']: Hemisphere being processed
+    subject_id:
+    # type=string|default='subject_id': Subject being processed
+    out_file:
+    # type=file: Output curvature stats file
+    # type=file|default=<undefined>: Output curvature stats file
+    min_max:
+    # type=bool|default=False: Output min / max information for the processed curvature.
+    values:
+    # type=bool|default=False: Triggers a series of derived curvature values
+    write:
+    # type=bool|default=False: Write curvature files
+    copy_inputs:
+    # type=bool|default=False: If running as a node, set this to True.This will copy the input files to the node directory.
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    hemisphere: '"lh"'
+    # type=enum|default='lh'|allowed['lh','rh']: Hemisphere being processed
+    curvfile1:
+    # type=file|default=<undefined>: Input file for CurvatureStats
+    curvfile2:
+    # type=file|default=<undefined>: Input file for CurvatureStats
+    surface:
+    # type=file|default=<undefined>: Specify surface file for CurvatureStats
+    out_file:
+    # type=file: Output curvature stats file
+    # type=file|default=<undefined>: Output curvature stats file
+    values: 'True'
+    # type=bool|default=False: Triggers a series of derived curvature values
+    min_max: 'True'
+    # type=bool|default=False: Output min / max information for the processed curvature.
+    write: 'True'
+    # type=bool|default=False: Write curvature files
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: mris_curvature_stats -m -o lh.curv.stats -F pial -G --writeCurvatureFiles subject_id lh pial pial
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    hemisphere: '"lh"'
+    # type=enum|default='lh'|allowed['lh','rh']: Hemisphere being processed
+    curvfile1:
+    # type=file|default=<undefined>: Input file for CurvatureStats
+    curvfile2:
+    # type=file|default=<undefined>: Input file for CurvatureStats
+    surface:
+    # type=file|default=<undefined>: Specify surface file for CurvatureStats
+    out_file:
+    # type=file: Output curvature stats file
+    # type=file|default=<undefined>: Output curvature stats file
+    values: 'True'
+    # type=bool|default=False: Triggers a series of derived curvature values
+    min_max: 'True'
+    # type=bool|default=False: Output min / max information for the processed curvature.
+    write: 'True'
+    # type=bool|default=False: Write curvature files
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/curvature_stats_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/curvature_stats_callables.py
new file mode 100644
index 00000000..3f5ae512
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/curvature_stats_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in CurvatureStats.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/dicom_convert.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/dicom_convert.yaml
new file mode 100644
index 00000000..9eef2fab
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/dicom_convert.yaml
@@ -0,0 +1,104 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.preprocess.DICOMConvert' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# use fs mri_convert to convert dicom files
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces.freesurfer import DICOMConvert
+#     >>> cvt = DICOMConvert()
+#     >>> cvt.inputs.dicom_dir = 'dicomdir'
+#     >>> cvt.inputs.file_mapping = [('nifti', '*.nii'), ('info', 'dicom*.txt'), ('dti', '*dti.bv*')]
+# 
+#     
+task_name: DICOMConvert
+nipype_name: DICOMConvert
+nipype_module: nipype.interfaces.freesurfer.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    dicom_info: generic/file
+    # type=file|default=<undefined>: File containing summary information from mri_parse_sdcmdir
+    dicom_dir: generic/directory
+    # type=directory|default=<undefined>: dicom directory from which to convert dicom files
+    base_output_dir: generic/directory
+    # type=directory|default=<undefined>: directory in which subject directories are created
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    dicom_dir:
+    # type=directory|default=<undefined>: dicom directory from which to convert dicom files
+    base_output_dir:
+    # type=directory|default=<undefined>: directory in which subject directories are created
+    subject_dir_template:
+    # type=str|default='S.%04d': template for subject directory name
+    subject_id:
+    # type=any|default=None: subject identifier to insert into template
+    file_mapping:
+    # type=list|default=[]: defines the output fields of interface
+    out_type:
+    # type=enum|default='niigz'|allowed['afni','analyze','analyze4d','bfloat','brik','bshort','cor','gdf','mgh','mgz','minc','nifti1','nii','niigz','otl','outline','sdt','spm']: defines the type of output file produced
+    dicom_info:
+    # type=file|default=<undefined>: File containing summary information from mri_parse_sdcmdir
+    seq_list:
+    # type=list|default=[]: list of pulse sequence names to be converted.
+    ignore_single_slice:
+    # type=bool|default=False: ignore volumes containing a single slice
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/dicom_convert_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/dicom_convert_callables.py
new file mode 100644
index 00000000..3cc0c305
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/dicom_convert_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in DICOMConvert.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/edit_w_mwith_aseg.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/edit_w_mwith_aseg.yaml
new file mode 100644
index 00000000..62f2202b
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/edit_w_mwith_aseg.yaml
@@ -0,0 +1,158 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.preprocess.EditWMwithAseg' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Edits a wm file using a segmentation
+# 
+#     Examples
+#     ========
+#     >>> from nipype.interfaces.freesurfer import EditWMwithAseg
+#     >>> editwm = EditWMwithAseg()
+#     >>> editwm.inputs.in_file = "T1.mgz"
+#     >>> editwm.inputs.brain_file = "norm.mgz"
+#     >>> editwm.inputs.seg_file = "aseg.mgz"
+#     >>> editwm.inputs.out_file = "wm.asegedit.mgz"
+#     >>> editwm.inputs.keep_in = True
+#     >>> editwm.cmdline
+#     'mri_edit_wm_with_aseg -keep-in T1.mgz norm.mgz aseg.mgz wm.asegedit.mgz'
+#     
+task_name: EditWMwithAseg
+nipype_name: EditWMwithAseg
+nipype_module: nipype.interfaces.freesurfer.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/mgh-gz
+    # type=file|default=<undefined>: Input white matter segmentation file
+    brain_file: medimage/mgh-gz
+    # type=file|default=<undefined>: Input brain/T1 file
+    seg_file: medimage/mgh-gz
+    # type=file|default=<undefined>: Input presurf segmentation file
+    out_file: medimage/mgh-gz
+    # type=file: Output edited WM file
+    # type=file|default=<undefined>: File to be written as output
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: medimage/mgh-gz
+    # type=file: Output edited WM file
+    # type=file|default=<undefined>: File to be written as output
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: Input white matter segmentation file
+    brain_file:
+    # type=file|default=<undefined>: Input brain/T1 file
+    seg_file:
+    # type=file|default=<undefined>: Input presurf segmentation file
+    out_file:
+    # type=file: Output edited WM file
+    # type=file|default=<undefined>: File to be written as output
+    keep_in:
+    # type=bool|default=False: Keep edits as found in input volume
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: Input white matter segmentation file
+    brain_file:
+    # type=file|default=<undefined>: Input brain/T1 file
+    seg_file:
+    # type=file|default=<undefined>: Input presurf segmentation file
+    out_file:
+    # type=file: Output edited WM file
+    # type=file|default=<undefined>: File to be written as output
+    keep_in: 'True'
+    # type=bool|default=False: Keep edits as found in input volume
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: mri_edit_wm_with_aseg -keep-in T1.mgz norm.mgz aseg.mgz wm.asegedit.mgz
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: Input white matter segmentation file
+    brain_file:
+    # type=file|default=<undefined>: Input brain/T1 file
+    seg_file:
+    # type=file|default=<undefined>: Input presurf segmentation file
+    out_file:
+    # type=file: Output edited WM file
+    # type=file|default=<undefined>: File to be written as output
+    keep_in: 'True'
+    # type=bool|default=False: Keep edits as found in input volume
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/edit_w_mwith_aseg_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/edit_w_mwith_aseg_callables.py
new file mode 100644
index 00000000..4d2c53dc
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/edit_w_mwith_aseg_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in EditWMwithAseg.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/em_register.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/em_register.yaml
new file mode 100644
index 00000000..63a7b5a1
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/em_register.yaml
@@ -0,0 +1,165 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.registration.EMRegister' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# This program creates a transform in lta format
+# 
+#     Examples
+#     ========
+#     >>> from nipype.interfaces.freesurfer import EMRegister
+#     >>> register = EMRegister()
+#     >>> register.inputs.in_file = 'norm.mgz'
+#     >>> register.inputs.template = 'aseg.mgz'
+#     >>> register.inputs.out_file = 'norm_transform.lta'
+#     >>> register.inputs.skull = True
+#     >>> register.inputs.nbrspacing = 9
+#     >>> register.cmdline
+#     'mri_em_register -uns 9 -skull norm.mgz aseg.mgz norm_transform.lta'
+#     
+task_name: EMRegister
+nipype_name: EMRegister
+nipype_module: nipype.interfaces.freesurfer.registration
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/mgh-gz
+    # type=file|default=<undefined>: in brain volume
+    template: medimage/mgh-gz
+    # type=file|default=<undefined>: template gca
+    out_file: medimage-freesurfer/lta
+    # type=file: output transform
+    # type=file|default=<undefined>: output transform
+    mask: generic/file
+    # type=file|default=<undefined>: use volume as a mask
+    transform: generic/file
+    # type=file|default=<undefined>: Previously computed transform
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: medimage-freesurfer/lta
+    # type=file: output transform
+    # type=file|default=<undefined>: output transform
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: in brain volume
+    template:
+    # type=file|default=<undefined>: template gca
+    out_file:
+    # type=file: output transform
+    # type=file|default=<undefined>: output transform
+    skull:
+    # type=bool|default=False: align to atlas containing skull (uns=5)
+    mask:
+    # type=file|default=<undefined>: use volume as a mask
+    nbrspacing:
+    # type=int|default=0: align to atlas containing skull setting unknown_nbr_spacing = nbrspacing
+    transform:
+    # type=file|default=<undefined>: Previously computed transform
+    num_threads:
+    # type=int|default=0: allows for specifying more threads
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: in brain volume
+    template:
+    # type=file|default=<undefined>: template gca
+    out_file:
+    # type=file: output transform
+    # type=file|default=<undefined>: output transform
+    skull: 'True'
+    # type=bool|default=False: align to atlas containing skull (uns=5)
+    nbrspacing: '9'
+    # type=int|default=0: align to atlas containing skull setting unknown_nbr_spacing = nbrspacing
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: mri_em_register -uns 9 -skull norm.mgz aseg.mgz norm_transform.lta
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: in brain volume
+    template:
+    # type=file|default=<undefined>: template gca
+    out_file:
+    # type=file: output transform
+    # type=file|default=<undefined>: output transform
+    skull: 'True'
+    # type=bool|default=False: align to atlas containing skull (uns=5)
+    nbrspacing: '9'
+    # type=int|default=0: align to atlas containing skull setting unknown_nbr_spacing = nbrspacing
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/em_register_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/em_register_callables.py
new file mode 100644
index 00000000..2e390538
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/em_register_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in EMRegister.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/euler_number.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/euler_number.yaml
new file mode 100644
index 00000000..74628bb3
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/euler_number.yaml
@@ -0,0 +1,117 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.utils.EulerNumber' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     This program computes EulerNumber for a cortical surface
+# 
+#     Examples
+#     ========
+#     >>> from nipype.interfaces.freesurfer import EulerNumber
+#     >>> ft = EulerNumber()
+#     >>> ft.inputs.in_file = 'lh.pial'
+#     >>> ft.cmdline
+#     'mris_euler_number lh.pial'
+#     
+task_name: EulerNumber
+nipype_name: EulerNumber
+nipype_module: nipype.interfaces.freesurfer.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage-freesurfer/pial
+    # type=file|default=<undefined>: Input file for EulerNumber
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: Input file for EulerNumber
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: Input file for EulerNumber
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: mris_euler_number lh.pial
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: Input file for EulerNumber
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/euler_number_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/euler_number_callables.py
new file mode 100644
index 00000000..3759b891
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/euler_number_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in EulerNumber.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/extract_main_component.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/extract_main_component.yaml
new file mode 100644
index 00000000..5e144f10
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/extract_main_component.yaml
@@ -0,0 +1,122 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.utils.ExtractMainComponent' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Extract the main component of a tessellated surface
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces.freesurfer import ExtractMainComponent
+#     >>> mcmp = ExtractMainComponent(in_file='lh.pial')
+#     >>> mcmp.cmdline
+#     'mris_extract_main_component lh.pial lh.maincmp'
+# 
+#     
+task_name: ExtractMainComponent
+nipype_name: ExtractMainComponent
+nipype_module: nipype.interfaces.freesurfer.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage-freesurfer/pial
+    # type=file|default=<undefined>: input surface file
+    out_file: generic/file
+    # type=file: surface containing main component
+    # type=file|default=<undefined>: surface containing main component
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: surface containing main component
+    # type=file|default=<undefined>: surface containing main component
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input surface file
+    out_file:
+    # type=file: surface containing main component
+    # type=file|default=<undefined>: surface containing main component
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input surface file
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: mris_extract_main_component lh.pial lh.maincmp
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: input surface file
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/extract_main_component_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/extract_main_component_callables.py
new file mode 100644
index 00000000..6f7c2d5e
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/extract_main_component_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in ExtractMainComponent.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/fit_ms_params.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/fit_ms_params.yaml
new file mode 100644
index 00000000..d75002bc
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/fit_ms_params.yaml
@@ -0,0 +1,142 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.preprocess.FitMSParams' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Estimate tissue parameters from a set of FLASH images.
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces.freesurfer import FitMSParams
+#     >>> msfit = FitMSParams()
+#     >>> msfit.inputs.in_files = ['flash_05.mgz', 'flash_30.mgz']
+#     >>> msfit.inputs.out_dir = 'flash_parameters'
+#     >>> msfit.cmdline
+#     'mri_ms_fitparms  flash_05.mgz flash_30.mgz flash_parameters'
+# 
+#     
+task_name: FitMSParams
+nipype_name: FitMSParams
+nipype_module: nipype.interfaces.freesurfer.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_files: medimage/mgh-gz+list-of
+    # type=list|default=[]: list of FLASH images (must be in mgh format)
+    xfm_list: generic/file+list-of
+    # type=list|default=[]: list of transform files to apply to each FLASH image
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    t1_image: generic/file
+    # type=file: image of estimated T1 relaxation values
+    pd_image: generic/file
+    # type=file: image of estimated proton density values
+    t2star_image: generic/file
+    # type=file: image of estimated T2* values
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_dir: '"flash_parameters"'
+    # type=directory|default=<undefined>: directory to store output in
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_files:
+    # type=list|default=[]: list of FLASH images (must be in mgh format)
+    tr_list:
+    # type=list|default=[]: list of TRs of the input files (in msec)
+    te_list:
+    # type=list|default=[]: list of TEs of the input files (in msec)
+    flip_list:
+    # type=list|default=[]: list of flip angles of the input files
+    xfm_list:
+    # type=list|default=[]: list of transform files to apply to each FLASH image
+    out_dir:
+    # type=directory|default=<undefined>: directory to store output in
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_files:
+    # type=list|default=[]: list of FLASH images (must be in mgh format)
+    out_dir: '"flash_parameters"'
+    # type=directory|default=<undefined>: directory to store output in
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: mri_ms_fitparms flash_05.mgz flash_30.mgz flash_parameters
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_files:
+    # type=list|default=[]: list of FLASH images (must be in mgh format)
+    out_dir: '"flash_parameters"'
+    # type=directory|default=<undefined>: directory to store output in
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/fit_ms_params_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/fit_ms_params_callables.py
new file mode 100644
index 00000000..c37da7ee
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/fit_ms_params_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in FitMSParams.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/fix_topology.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/fix_topology.yaml
new file mode 100644
index 00000000..63d4a86e
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/fix_topology.yaml
@@ -0,0 +1,179 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.utils.FixTopology' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     This program computes a mapping from the unit sphere onto the surface
+#     of the cortex from a previously generated approximation of the
+#     cortical surface, thus guaranteeing a topologically correct surface.
+# 
+#     Examples
+#     ========
+#     >>> from nipype.interfaces.freesurfer import FixTopology
+#     >>> ft = FixTopology()
+#     >>> ft.inputs.in_orig = 'lh.orig' # doctest: +SKIP
+#     >>> ft.inputs.in_inflated = 'lh.inflated' # doctest: +SKIP
+#     >>> ft.inputs.sphere = 'lh.qsphere.nofix' # doctest: +SKIP
+#     >>> ft.inputs.hemisphere = 'lh'
+#     >>> ft.inputs.subject_id = '10335'
+#     >>> ft.inputs.mgz = True
+#     >>> ft.inputs.ga = True
+#     >>> ft.cmdline # doctest: +SKIP
+#     'mris_fix_topology -ga -mgz -sphere qsphere.nofix 10335 lh'
+#     
+task_name: FixTopology
+nipype_name: FixTopology
+nipype_module: nipype.interfaces.freesurfer.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_orig: medimage-freesurfer/orig
+    # type=file|default=<undefined>: Undocumented input file <hemisphere>.orig
+    in_inflated: medimage-freesurfer/inflated
+    # type=file|default=<undefined>: Undocumented input file <hemisphere>.inflated
+    in_brain: generic/file
+    # type=file|default=<undefined>: Implicit input brain.mgz
+    in_wm: generic/file
+    # type=file|default=<undefined>: Implicit input wm.mgz
+    sphere: medimage-freesurfer/nofix
+    # type=file|default=<undefined>: Sphere input file
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: Output file for FixTopology
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_orig:
+    # type=file|default=<undefined>: Undocumented input file <hemisphere>.orig
+    in_inflated:
+    # type=file|default=<undefined>: Undocumented input file <hemisphere>.inflated
+    in_brain:
+    # type=file|default=<undefined>: Implicit input brain.mgz
+    in_wm:
+    # type=file|default=<undefined>: Implicit input wm.mgz
+    hemisphere:
+    # type=string|default='': Hemisphere being processed
+    subject_id:
+    # type=string|default='subject_id': Subject being processed
+    copy_inputs:
+    # type=bool|default=False: If running as a node, set this to True otherwise, the topology fixing will be done in place.
+    seed:
+    # type=int|default=0: Seed for setting random number generator
+    ga:
+    # type=bool|default=False: No documentation. Direct questions to analysis-bugs@nmr.mgh.harvard.edu
+    mgz:
+    # type=bool|default=False: No documentation. Direct questions to analysis-bugs@nmr.mgh.harvard.edu
+    sphere:
+    # type=file|default=<undefined>: Sphere input file
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_orig:
+    # type=file|default=<undefined>: Undocumented input file <hemisphere>.orig
+    in_inflated:
+    # type=file|default=<undefined>: Undocumented input file <hemisphere>.inflated
+    sphere:
+    # type=file|default=<undefined>: Sphere input file
+    hemisphere: '"lh"'
+    # type=string|default='': Hemisphere being processed
+    subject_id: '"10335"'
+    # type=string|default='subject_id': Subject being processed
+    mgz: 'True'
+    # type=bool|default=False: No documentation. Direct questions to analysis-bugs@nmr.mgh.harvard.edu
+    ga: 'True'
+    # type=bool|default=False: No documentation. Direct questions to analysis-bugs@nmr.mgh.harvard.edu
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: mris_fix_topology -ga -mgz -sphere qsphere.nofix 10335 lh
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_orig:
+    # type=file|default=<undefined>: Undocumented input file <hemisphere>.orig
+    in_inflated:
+    # type=file|default=<undefined>: Undocumented input file <hemisphere>.inflated
+    sphere:
+    # type=file|default=<undefined>: Sphere input file
+    hemisphere: '"lh"'
+    # type=string|default='': Hemisphere being processed
+    subject_id: '"10335"'
+    # type=string|default='subject_id': Subject being processed
+    mgz: 'True'
+    # type=bool|default=False: No documentation. Direct questions to analysis-bugs@nmr.mgh.harvard.edu
+    ga: 'True'
+    # type=bool|default=False: No documentation. Direct questions to analysis-bugs@nmr.mgh.harvard.edu
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/fix_topology_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/fix_topology_callables.py
new file mode 100644
index 00000000..96440301
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/fix_topology_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in FixTopology.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/fuse_segmentations.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/fuse_segmentations.yaml
new file mode 100644
index 00000000..cf0eccf8
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/fuse_segmentations.yaml
@@ -0,0 +1,164 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.longitudinal.FuseSegmentations' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# fuse segmentations together from multiple timepoints
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces.freesurfer import FuseSegmentations
+#     >>> fuse = FuseSegmentations()
+#     >>> fuse.inputs.subject_id = 'tp.long.A.template'
+#     >>> fuse.inputs.timepoints = ['tp1', 'tp2']
+#     >>> fuse.inputs.out_file = 'aseg.fused.mgz'
+#     >>> fuse.inputs.in_segmentations = ['aseg.mgz', 'aseg.mgz']
+#     >>> fuse.inputs.in_segmentations_noCC = ['aseg.mgz', 'aseg.mgz']
+#     >>> fuse.inputs.in_norms = ['norm.mgz', 'norm.mgz', 'norm.mgz']
+#     >>> fuse.cmdline
+#     'mri_fuse_segmentations -n norm.mgz -a aseg.mgz -c aseg.mgz tp.long.A.template tp1 tp2'
+#     
+task_name: FuseSegmentations
+nipype_name: FuseSegmentations
+nipype_module: nipype.interfaces.freesurfer.longitudinal
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: medimage/mgh-gz
+    # type=file: output fused segmentation file
+    # type=file|default=<undefined>: output fused segmentation file
+    in_segmentations: medimage/mgh-gz+list-of
+    # type=inputmultiobject|default=[]: name of aseg file to use (default: aseg.mgz)         must include the aseg files for all the given timepoints
+    in_segmentations_noCC: medimage/mgh-gz+list-of
+    # type=inputmultiobject|default=[]: name of aseg file w/o CC labels (default: aseg.auto_noCCseg.mgz)         must include the corresponding file for all the given timepoints
+    in_norms: medimage/mgh-gz+list-of
+    # type=inputmultiobject|default=[]: -n <filename>  - name of norm file to use (default: norm.mgs)         must include the corresponding norm file for all given timepoints         as well as for the current subject
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: medimage/mgh-gz
+    # type=file: output fused segmentation file
+    # type=file|default=<undefined>: output fused segmentation file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    subject_id:
+    # type=string|default='': subject_id being processed
+    timepoints:
+    # type=inputmultiobject|default=[]: subject_ids or timepoints to be processed
+    out_file:
+    # type=file: output fused segmentation file
+    # type=file|default=<undefined>: output fused segmentation file
+    in_segmentations:
+    # type=inputmultiobject|default=[]: name of aseg file to use (default: aseg.mgz)         must include the aseg files for all the given timepoints
+    in_segmentations_noCC:
+    # type=inputmultiobject|default=[]: name of aseg file w/o CC labels (default: aseg.auto_noCCseg.mgz)         must include the corresponding file for all the given timepoints
+    in_norms:
+    # type=inputmultiobject|default=[]: -n <filename>  - name of norm file to use (default: norm.mgs)         must include the corresponding norm file for all given timepoints         as well as for the current subject
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    subject_id: '"tp.long.A.template"'
+    # type=string|default='': subject_id being processed
+    timepoints: '["tp1", "tp2"]'
+    # type=inputmultiobject|default=[]: subject_ids or timepoints to be processed
+    out_file:
+    # type=file: output fused segmentation file
+    # type=file|default=<undefined>: output fused segmentation file
+    in_segmentations:
+    # type=inputmultiobject|default=[]: name of aseg file to use (default: aseg.mgz)         must include the aseg files for all the given timepoints
+    in_segmentations_noCC:
+    # type=inputmultiobject|default=[]: name of aseg file w/o CC labels (default: aseg.auto_noCCseg.mgz)         must include the corresponding file for all the given timepoints
+    in_norms:
+    # type=inputmultiobject|default=[]: -n <filename>  - name of norm file to use (default: norm.mgs)         must include the corresponding norm file for all given timepoints         as well as for the current subject
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: mri_fuse_segmentations -n norm.mgz -a aseg.mgz -c aseg.mgz tp.long.A.template tp1 tp2
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    subject_id: '"tp.long.A.template"'
+    # type=string|default='': subject_id being processed
+    timepoints: '["tp1", "tp2"]'
+    # type=inputmultiobject|default=[]: subject_ids or timepoints to be processed
+    out_file:
+    # type=file: output fused segmentation file
+    # type=file|default=<undefined>: output fused segmentation file
+    in_segmentations:
+    # type=inputmultiobject|default=[]: name of aseg file to use (default: aseg.mgz)         must include the aseg files for all the given timepoints
+    in_segmentations_noCC:
+    # type=inputmultiobject|default=[]: name of aseg file w/o CC labels (default: aseg.auto_noCCseg.mgz)         must include the corresponding file for all the given timepoints
+    in_norms:
+    # type=inputmultiobject|default=[]: -n <filename>  - name of norm file to use (default: norm.mgs)         must include the corresponding norm file for all given timepoints         as well as for the current subject
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/fuse_segmentations_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/fuse_segmentations_callables.py
new file mode 100644
index 00000000..fda17fb0
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/fuse_segmentations_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in FuseSegmentations.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/glm_fit.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/glm_fit.yaml
new file mode 100644
index 00000000..b6d67c56
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/glm_fit.yaml
@@ -0,0 +1,295 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.model.GLMFit' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Use FreeSurfer's mri_glmfit to specify and estimate a general linear model.
+# 
+#     Examples
+#     --------
+#     >>> glmfit = GLMFit()
+#     >>> glmfit.inputs.in_file = 'functional.nii'
+#     >>> glmfit.inputs.one_sample = True
+#     >>> glmfit.cmdline == 'mri_glmfit --glmdir %s --y functional.nii --osgm'%os.getcwd()
+#     True
+# 
+#     
+task_name: GLMFit
+nipype_name: GLMFit
+nipype_module: nipype.interfaces.freesurfer.model
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: input 4D file
+    design: generic/file
+    # type=file|default=<undefined>: design matrix file
+    contrast: generic/file+list-of
+    # type=inputmultiobject|default=[]: contrast file
+    per_voxel_reg: generic/file+list-of
+    # type=inputmultiobject|default=[]: per-voxel regressors
+    weighted_ls: generic/file
+    # type=file|default=<undefined>: weighted least squares
+    fixed_fx_var: generic/file
+    # type=file|default=<undefined>: for fixed effects analysis
+    fixed_fx_dof_file: generic/file
+    # type=file|default=<undefined>: text file with dof for fixed effects analysis
+    weight_file: generic/file
+    # type=file|default=<undefined>: weight for each input at each voxel
+    mask_file: generic/file
+    # type=file: map of the mask used in the analysis
+    # type=file|default=<undefined>: binary mask
+    label_file: generic/file
+    # type=file|default=<undefined>: use label as mask, surfaces only
+    sim_done_file: generic/file
+    # type=file|default=<undefined>: create file when simulation finished
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    beta_file: generic/file
+    # type=file: map of regression coefficients
+    error_file: generic/file
+    # type=file: map of residual error
+    error_var_file: generic/file
+    # type=file: map of residual error variance
+    error_stddev_file: generic/file
+    # type=file: map of residual error standard deviation
+    estimate_file: generic/file
+    # type=file: map of the estimated Y values
+    mask_file: generic/file
+    # type=file: map of the mask used in the analysis
+    # type=file|default=<undefined>: binary mask
+    fwhm_file: generic/file
+    # type=file: text file with estimated smoothness
+    dof_file: generic/file
+    # type=file: text file with effective degrees-of-freedom for the analysis
+    spatial_eigenvectors: generic/file
+    # type=file: map of spatial eigenvectors from residual PCA
+    frame_eigenvectors: generic/file
+    # type=file: matrix of frame eigenvectors from residual PCA
+    singular_values: generic/file
+    # type=file: matrix singular values from residual PCA
+    svd_stats_file: generic/file
+    # type=file: text file summarizing the residual PCA
+    k2p_file: generic/file
+    # type=file: estimate of k2p parameter
+    bp_file: generic/file
+    # type=file: Binding potential estimates
+    glm_dir: generic/directory
+    # type=directory: output directory
+    # type=str|default='': save outputs to dir
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    glm_dir: glm_dir
+    # type=directory: output directory
+    # type=str|default='': save outputs to dir
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    glm_dir:
+    # type=directory: output directory
+    # type=str|default='': save outputs to dir
+    in_file:
+    # type=file|default=<undefined>: input 4D file
+    fsgd:
+    # type=tuple|default=(<undefined>, 'doss'): freesurfer descriptor file
+    design:
+    # type=file|default=<undefined>: design matrix file
+    contrast:
+    # type=inputmultiobject|default=[]: contrast file
+    one_sample:
+    # type=bool|default=False: construct X and C as a one-sample group mean
+    no_contrast_ok:
+    # type=bool|default=False: do not fail if no contrasts specified
+    per_voxel_reg:
+    # type=inputmultiobject|default=[]: per-voxel regressors
+    self_reg:
+    # type=tuple|default=(0, 0, 0): self-regressor from index col row slice
+    weighted_ls:
+    # type=file|default=<undefined>: weighted least squares
+    fixed_fx_var:
+    # type=file|default=<undefined>: for fixed effects analysis
+    fixed_fx_dof:
+    # type=int|default=0: dof for fixed effects analysis
+    fixed_fx_dof_file:
+    # type=file|default=<undefined>: text file with dof for fixed effects analysis
+    weight_file:
+    # type=file|default=<undefined>: weight for each input at each voxel
+    weight_inv:
+    # type=bool|default=False: invert weights
+    weight_sqrt:
+    # type=bool|default=False: sqrt of weights
+    fwhm:
+    # type=range|default=0.0: smooth input by fwhm
+    var_fwhm:
+    # type=range|default=0.0: smooth variance by fwhm
+    no_mask_smooth:
+    # type=bool|default=False: do not mask when smoothing
+    no_est_fwhm:
+    # type=bool|default=False: turn off FWHM output estimation
+    mask_file:
+    # type=file: map of the mask used in the analysis
+    # type=file|default=<undefined>: binary mask
+    label_file:
+    # type=file|default=<undefined>: use label as mask, surfaces only
+    cortex:
+    # type=bool|default=False: use subjects ?h.cortex.label as label
+    invert_mask:
+    # type=bool|default=False: invert mask
+    prune:
+    # type=bool|default=False: remove voxels that do not have a non-zero value at each frame (def)
+    no_prune:
+    # type=bool|default=False: do not prune
+    prune_thresh:
+    # type=float|default=0.0: prune threshold. Default is FLT_MIN
+    compute_log_y:
+    # type=bool|default=False: compute natural log of y prior to analysis
+    save_estimate:
+    # type=bool|default=False: save signal estimate (yhat)
+    save_residual:
+    # type=bool|default=False: save residual error (eres)
+    save_res_corr_mtx:
+    # type=bool|default=False: save residual error spatial correlation matrix (eres.scm). Big!
+    surf:
+    # type=bool|default=False: analysis is on a surface mesh
+    subject_id:
+    # type=str|default='': subject id for surface geometry
+    hemi:
+    # type=enum|default='lh'|allowed['lh','rh']: surface hemisphere
+    surf_geo:
+    # type=str|default='white': surface geometry name (e.g. white, pial)
+    simulation:
+    # type=tuple|default=('perm', 0, 0.0, ''): nulltype nsim thresh csdbasename
+    sim_sign:
+    # type=enum|default='abs'|allowed['abs','neg','pos']: abs, pos, or neg
+    uniform:
+    # type=tuple|default=(0.0, 0.0): use uniform distribution instead of gaussian
+    pca:
+    # type=bool|default=False: perform pca/svd analysis on residual
+    calc_AR1:
+    # type=bool|default=False: compute and save temporal AR1 of residual
+    save_cond:
+    # type=bool|default=False: flag to save design matrix condition at each voxel
+    vox_dump:
+    # type=tuple|default=(0, 0, 0): dump voxel GLM and exit
+    seed:
+    # type=int|default=0: used for synthesizing noise
+    synth:
+    # type=bool|default=False: replace input with gaussian
+    resynth_test:
+    # type=int|default=0: test GLM by resynthsis
+    profile:
+    # type=int|default=0: niters : test speed
+    mrtm1:
+    # type=tuple|default=(<undefined>, <undefined>): RefTac TimeSec : perform MRTM1 kinetic modeling
+    mrtm2:
+    # type=tuple|default=(<undefined>, <undefined>, 0.0): RefTac TimeSec k2prime : perform MRTM2 kinetic modeling
+    logan:
+    # type=tuple|default=(<undefined>, <undefined>, 0.0): RefTac TimeSec tstar   : perform Logan kinetic modeling
+    force_perm:
+    # type=bool|default=False: force perumtation test, even when design matrix is not orthog
+    diag:
+    # type=int|default=0: Gdiag_no : set diagnostic level
+    diag_cluster:
+    # type=bool|default=False: save sig volume and exit from first sim loop
+    debug:
+    # type=bool|default=False: turn on debugging
+    check_opts:
+    # type=bool|default=False: don't run anything, just check options and exit
+    allow_repeated_subjects:
+    # type=bool|default=False: allow subject names to repeat in the fsgd file (must appear before --fsgd
+    allow_ill_cond:
+    # type=bool|default=False: allow ill-conditioned design matrices
+    sim_done_file:
+    # type=file|default=<undefined>: create file when simulation finished
+    nii:
+    # type=bool|default=False: save outputs as nii
+    nii_gz:
+    # type=bool|default=False: save outputs as nii.gz
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input 4D file
+    one_sample: 'True'
+    # type=bool|default=False: construct X and C as a one-sample group mean
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline:
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: input 4D file
+    one_sample: 'True'
+    # type=bool|default=False: construct X and C as a one-sample group mean
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/glm_fit_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/glm_fit_callables.py
new file mode 100644
index 00000000..a9012e2b
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/glm_fit_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in GLMFit.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/gtm_seg.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/gtm_seg.yaml
new file mode 100644
index 00000000..e0aaf197
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/gtm_seg.yaml
@@ -0,0 +1,154 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.petsurfer.GTMSeg' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# create an anatomical segmentation for the geometric transfer matrix (GTM).
+# 
+#     Examples
+#     --------
+#     >>> gtmseg = GTMSeg()
+#     >>> gtmseg.inputs.subject_id = 'subject_id'
+#     >>> gtmseg.cmdline
+#     'gtmseg --o gtmseg.mgz --s subject_id'
+#     
+task_name: GTMSeg
+nipype_name: GTMSeg
+nipype_module: nipype.interfaces.freesurfer.petsurfer
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: GTM segmentation
+    # type=file|default='gtmseg.mgz': output volume relative to subject/mri
+    colortable: generic/file
+    # type=file|default=<undefined>: colortable
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: GTM segmentation
+    # type=file|default='gtmseg.mgz': output volume relative to subject/mri
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    subject_id:
+    # type=string|default='': subject id
+    xcerseg:
+    # type=bool|default=False: run xcerebralseg on this subject to create apas+head.mgz
+    out_file:
+    # type=file: GTM segmentation
+    # type=file|default='gtmseg.mgz': output volume relative to subject/mri
+    upsampling_factor:
+    # type=int|default=0: upsampling factor (default is 2)
+    subsegwm:
+    # type=bool|default=False: subsegment WM into lobes (default)
+    keep_hypo:
+    # type=bool|default=False: do not relabel hypointensities as WM when subsegmenting WM
+    keep_cc:
+    # type=bool|default=False: do not relabel corpus callosum as WM
+    dmax:
+    # type=float|default=0.0: distance threshold to use when subsegmenting WM (default is 5)
+    ctx_annot:
+    # type=tuple|default=('', 0, 0): annot lhbase rhbase : annotation to use for cortical segmentation (default is aparc 1000 2000)
+    wm_annot:
+    # type=tuple|default=('', 0, 0): annot lhbase rhbase : annotation to use for WM segmentation (with --subsegwm, default is lobes 3200 4200)
+    output_upsampling_factor:
+    # type=int|default=0: set output USF different than USF, mostly for debugging
+    head:
+    # type=string|default='': use headseg instead of apas+head.mgz
+    subseg_cblum_wm:
+    # type=bool|default=False: subsegment cerebellum WM into core and gyri
+    no_pons:
+    # type=bool|default=False: do not add pons segmentation when doing ---xcerseg
+    no_vermis:
+    # type=bool|default=False: do not add vermis segmentation when doing ---xcerseg
+    colortable:
+    # type=file|default=<undefined>: colortable
+    no_seg_stats:
+    # type=bool|default=False: do not compute segmentation stats
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    subject_id: '"subject_id"'
+    # type=string|default='': subject id
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: gtmseg --o gtmseg.mgz --s subject_id
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    subject_id: '"subject_id"'
+    # type=string|default='': subject id
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/gtm_seg_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/gtm_seg_callables.py
new file mode 100644
index 00000000..ec594dae
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/gtm_seg_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in GTMSeg.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/gtmpvc.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/gtmpvc.yaml
new file mode 100644
index 00000000..cb68a4bf
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/gtmpvc.yaml
@@ -0,0 +1,394 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.petsurfer.GTMPVC' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# create an anatomical segmentation for the geometric transfer matrix (GTM).
+# 
+#     Examples
+#     --------
+#     >>> gtmpvc = GTMPVC()
+#     >>> gtmpvc.inputs.in_file = 'sub-01_ses-baseline_pet.nii.gz'
+#     >>> gtmpvc.inputs.segmentation = 'gtmseg.mgz'
+#     >>> gtmpvc.inputs.reg_file = 'sub-01_ses-baseline_pet_mean_reg.lta'
+#     >>> gtmpvc.inputs.pvc_dir = 'pvc'
+#     >>> gtmpvc.inputs.psf = 4
+#     >>> gtmpvc.inputs.default_seg_merge = True
+#     >>> gtmpvc.inputs.auto_mask = (1, 0.1)
+#     >>> gtmpvc.inputs.km_ref = ['8 47']
+#     >>> gtmpvc.inputs.km_hb = ['11 12 50 51']
+#     >>> gtmpvc.inputs.no_rescale = True
+#     >>> gtmpvc.inputs.save_input = True
+#     >>> gtmpvc.cmdline  # doctest: +NORMALIZE_WHITESPACE
+#     'mri_gtmpvc --auto-mask 1.000000 0.100000 --default-seg-merge     --i sub-01_ses-baseline_pet.nii.gz --km-hb 11 12 50 51 --km-ref 8 47 --no-rescale     --psf 4.000000 --o pvc --reg sub-01_ses-baseline_pet_mean_reg.lta --save-input     --seg gtmseg.mgz'
+# 
+#     >>> gtmpvc = GTMPVC()
+#     >>> gtmpvc.inputs.in_file = 'sub-01_ses-baseline_pet.nii.gz'
+#     >>> gtmpvc.inputs.segmentation = 'gtmseg.mgz'
+#     >>> gtmpvc.inputs.regheader = True
+#     >>> gtmpvc.inputs.pvc_dir = 'pvc'
+#     >>> gtmpvc.inputs.mg = (0.5, ["ROI1", "ROI2"])
+#     >>> gtmpvc.cmdline  # doctest: +NORMALIZE_WHITESPACE
+#     'mri_gtmpvc --i sub-01_ses-baseline_pet.nii.gz --mg 0.5 ROI1 ROI2 --o pvc --regheader --seg gtmseg.mgz'
+#     
+task_name: GTMPVC
+nipype_name: GTMPVC
+nipype_module: nipype.interfaces.freesurfer.petsurfer
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti-gz
+    # type=file|default=<undefined>: input volume - source data to pvc
+    segmentation: medimage/mgh-gz
+    # type=file|default=<undefined>: segfile : anatomical segmentation to define regions for GTM
+    reg_file: medimage-freesurfer/lta
+    # type=file|default=<undefined>: LTA registration file that maps PET to anatomical
+    mask_file: generic/file
+    # type=file|default=<undefined>: ignore areas outside of the mask (in input vol space)
+    contrast: generic/file+list-of
+    # type=inputmultiobject|default=[]: contrast file
+    color_table_file: generic/file
+    # type=file|default=<undefined>: color table file with seg id names
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    ref_file: generic/file
+    # type=file: Reference TAC in .dat
+    hb_nifti: generic/file
+    # type=file: High-binding TAC in nifti
+    hb_dat: generic/file
+    # type=file: High-binding TAC in .dat
+    nopvc_file: generic/file
+    # type=file: TACs for all regions with no PVC
+    gtm_file: generic/file
+    # type=file: TACs for all regions with GTM PVC
+    gtm_stats: generic/file
+    # type=file: Statistics for the GTM PVC
+    input_file: generic/file
+    # type=file: 4D PET file in native volume space
+    reg_pet2anat: generic/file
+    # type=file: Registration file to go from PET to anat
+    reg_anat2pet: generic/file
+    # type=file: Registration file to go from anat to PET
+    reg_rbvpet2anat: generic/file
+    # type=file: Registration file to go from RBV corrected PET to anat
+    reg_anat2rbvpet: generic/file
+    # type=file: Registration file to go from anat to RBV corrected PET
+    mgx_ctxgm: generic/file
+    # type=file: Cortical GM voxel-wise values corrected using the extended Muller-Gartner method
+    mgx_subctxgm: generic/file
+    # type=file: Subcortical GM voxel-wise values corrected using the extended Muller-Gartner method
+    mgx_gm: generic/file
+    # type=file: All GM voxel-wise values corrected using the extended Muller-Gartner method
+    rbv: generic/file
+    # type=file: All GM voxel-wise values corrected using the RBV method
+    # type=bool|default=False: perform Region-based Voxelwise (RBV) PVC
+    opt_params: generic/file
+    # type=file: Optimal parameter estimates for the FWHM using adaptive GTM
+    yhat0: generic/file
+    # type=file: 4D PET file of signal estimate (yhat) after PVC (unsmoothed)
+    yhat: generic/file
+    # type=file: 4D PET file of signal estimate (yhat) after PVC (smoothed with PSF)
+    yhat_full_fov: generic/file
+    # type=file: 4D PET file with full FOV of signal estimate (yhat) after PVC (smoothed with PSF)
+    yhat_with_noise: generic/file
+    # type=file: 4D PET file with full FOV of signal estimate (yhat) with noise after PVC (smoothed with PSF)
+    pvc_dir: generic/directory
+    # type=directory: output directory
+    # type=str|default='': save outputs to dir
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    pvc_dir: '"pvc"'
+    # type=directory: output directory
+    # type=str|default='': save outputs to dir
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input volume - source data to pvc
+    frame:
+    # type=int|default=0: only process 0-based frame F from inputvol
+    psf:
+    # type=float|default=0.0: scanner PSF FWHM in mm
+    segmentation:
+    # type=file|default=<undefined>: segfile : anatomical segmentation to define regions for GTM
+    reg_file:
+    # type=file|default=<undefined>: LTA registration file that maps PET to anatomical
+    regheader:
+    # type=bool|default=False: assume input and seg share scanner space
+    reg_identity:
+    # type=bool|default=False: assume that input is in anatomical space
+    pvc_dir:
+    # type=directory: output directory
+    # type=str|default='': save outputs to dir
+    mask_file:
+    # type=file|default=<undefined>: ignore areas outside of the mask (in input vol space)
+    auto_mask:
+    # type=tuple|default=(0.0, 0.0): FWHM thresh : automatically compute mask
+    no_reduce_fov:
+    # type=bool|default=False: do not reduce FoV to encompass mask
+    reduce_fox_eqodd:
+    # type=bool|default=False: reduce FoV to encompass mask but force nc=nr and ns to be odd
+    contrast:
+    # type=inputmultiobject|default=[]: contrast file
+    default_seg_merge:
+    # type=bool|default=False: default schema for merging ROIs
+    merge_hypos:
+    # type=bool|default=False: merge left and right hypointensites into to ROI
+    merge_cblum_wm_gyri:
+    # type=bool|default=False: cerebellum WM gyri back into cerebellum WM
+    tt_reduce:
+    # type=bool|default=False: reduce segmentation to that of a tissue type
+    replace:
+    # type=tuple|default=(0, 0): Id1 Id2 : replace seg Id1 with seg Id2
+    rescale:
+    # type=list|default=[]: Id1 <Id2...>  : specify reference region(s) used to rescale (default is pons)
+    no_rescale:
+    # type=bool|default=False: do not global rescale such that mean of reference region is scaleref
+    scale_refval:
+    # type=float|default=0.0: refval : scale such that mean in reference region is refval
+    color_table_file:
+    # type=file|default=<undefined>: color table file with seg id names
+    default_color_table:
+    # type=bool|default=False: use $FREESURFER_HOME/FreeSurferColorLUT.txt
+    tt_update:
+    # type=bool|default=False: changes tissue type of VentralDC, BrainStem, and Pons to be SubcortGM
+    lat:
+    # type=bool|default=False: lateralize tissue types
+    no_tfe:
+    # type=bool|default=False: do not correct for tissue fraction effect (with --psf 0 turns off PVC entirely)
+    no_pvc:
+    # type=bool|default=False: turns off PVC entirely (both PSF and TFE)
+    tissue_fraction_resolution:
+    # type=float|default=0.0: set the tissue fraction resolution parameter (def is 0.5)
+    rbv:
+    # type=file: All GM voxel-wise values corrected using the RBV method
+    # type=bool|default=False: perform Region-based Voxelwise (RBV) PVC
+    rbv_res:
+    # type=float|default=0.0: voxsize : set RBV voxel resolution (good for when standard res takes too much memory)
+    mg:
+    # type=tuple|default=<undefined>: gmthresh RefId1 RefId2 ...: perform Mueller-Gaertner PVC, gmthresh is min gm pvf bet 0 and 1
+    mg_ref_cerebral_wm:
+    # type=bool|default=False:  set MG RefIds to 2 and 41
+    mg_ref_lobes_wm:
+    # type=bool|default=False: set MG RefIds to those for lobes when using wm subseg
+    mgx:
+    # type=float|default=0.0: gmxthresh : GLM-based Mueller-Gaertner PVC, gmxthresh is min gm pvf bet 0 and 1
+    km_ref:
+    # type=list|default=[]: RefId1 RefId2 ... : compute reference TAC for KM as mean of given RefIds
+    km_hb:
+    # type=list|default=[]: RefId1 RefId2 ... : compute HiBinding TAC for KM as mean of given RefIds
+    steady_state_params:
+    # type=tuple|default=(0.0, 0.0, 0.0): bpc scale dcf : steady-state analysis spec blood plasma concentration, unit scale and decay correction factor. You must also spec --km-ref. Turns off rescaling
+    X:
+    # type=bool|default=False: save X matrix in matlab4 format as X.mat (it will be big)
+    y:
+    # type=bool|default=False: save y matrix in matlab4 format as y.mat
+    beta:
+    # type=bool|default=False: save beta matrix in matlab4 format as beta.mat
+    X0:
+    # type=bool|default=False: save X0 matrix in matlab4 format as X0.mat (it will be big)
+    save_input:
+    # type=bool|default=False: saves rescaled input as input.rescaled.nii.gz
+    save_eres:
+    # type=bool|default=False: saves residual error
+    save_yhat:
+    # type=bool|default=False: save signal estimate (yhat) smoothed with the PSF
+    save_yhat_with_noise:
+    # type=tuple|default=(0, 0): seed nreps : save signal estimate (yhat) with noise
+    save_yhat_full_fov:
+    # type=bool|default=False: save signal estimate (yhat)
+    save_yhat0:
+    # type=bool|default=False: save signal estimate (yhat)
+    optimization_schema:
+    # type=enum|default='3D'|allowed['1D','1D_MB','2D','2D_MB','3D','3D_MB','MB3','MBZ']: opt : optimization schema for applying adaptive GTM
+    opt_tol:
+    # type=tuple|default=(0, 0.0, 0.0): n_iters_max ftol lin_min_tol : optimization parameters for adaptive gtm using fminsearch
+    opt_brain:
+    # type=bool|default=False: apply adaptive GTM
+    opt_seg_merge:
+    # type=bool|default=False: optimal schema for merging ROIs when applying adaptive GTM
+    num_threads:
+    # type=int|default=0: threads : number of threads to use
+    psf_col:
+    # type=float|default=0.0: xFWHM : full-width-half-maximum in the x-direction
+    psf_row:
+    # type=float|default=0.0: yFWHM : full-width-half-maximum in the y-direction
+    psf_slice:
+    # type=float|default=0.0: zFWHM : full-width-half-maximum in the z-direction
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input volume - source data to pvc
+    segmentation:
+    # type=file|default=<undefined>: segfile : anatomical segmentation to define regions for GTM
+    reg_file:
+    # type=file|default=<undefined>: LTA registration file that maps PET to anatomical
+    pvc_dir: '"pvc"'
+    # type=directory: output directory
+    # type=str|default='': save outputs to dir
+    psf: '4'
+    # type=float|default=0.0: scanner PSF FWHM in mm
+    default_seg_merge: 'True'
+    # type=bool|default=False: default schema for merging ROIs
+    auto_mask: (1, 0.1)
+    # type=tuple|default=(0.0, 0.0): FWHM thresh : automatically compute mask
+    km_ref: '["8 47"]'
+    # type=list|default=[]: RefId1 RefId2 ... : compute reference TAC for KM as mean of given RefIds
+    km_hb: '["11 12 50 51"]'
+    # type=list|default=[]: RefId1 RefId2 ... : compute HiBinding TAC for KM as mean of given RefIds
+    no_rescale: 'True'
+    # type=bool|default=False: do not global rescale such that mean of reference region is scaleref
+    save_input: 'True'
+    # type=bool|default=False: saves rescaled input as input.rescaled.nii.gz
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input volume - source data to pvc
+    segmentation:
+    # type=file|default=<undefined>: segfile : anatomical segmentation to define regions for GTM
+    regheader: 'True'
+    # type=bool|default=False: assume input and seg share scanner space
+    pvc_dir: '"pvc"'
+    # type=directory: output directory
+    # type=str|default='': save outputs to dir
+    mg: (0.5, ["ROI1", "ROI2"])
+    # type=tuple|default=<undefined>: gmthresh RefId1 RefId2 ...: perform Mueller-Gaertner PVC, gmthresh is min gm pvf bet 0 and 1
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: mri_gtmpvc --auto-mask 1.000000 0.100000 --default-seg-merge --i sub-01_ses-baseline_pet.nii.gz --km-hb 11 12 50 51 --km-ref 8 47 --no-rescale --psf 4.000000 --o pvc --reg sub-01_ses-baseline_pet_mean_reg.lta --save-input --seg gtmseg.mgz
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: input volume - source data to pvc
+    segmentation:
+    # type=file|default=<undefined>: segfile : anatomical segmentation to define regions for GTM
+    reg_file:
+    # type=file|default=<undefined>: LTA registration file that maps PET to anatomical
+    pvc_dir: '"pvc"'
+    # type=directory: output directory
+    # type=str|default='': save outputs to dir
+    psf: '4'
+    # type=float|default=0.0: scanner PSF FWHM in mm
+    default_seg_merge: 'True'
+    # type=bool|default=False: default schema for merging ROIs
+    auto_mask: (1, 0.1)
+    # type=tuple|default=(0.0, 0.0): FWHM thresh : automatically compute mask
+    km_ref: '["8 47"]'
+    # type=list|default=[]: RefId1 RefId2 ... : compute reference TAC for KM as mean of given RefIds
+    km_hb: '["11 12 50 51"]'
+    # type=list|default=[]: RefId1 RefId2 ... : compute HiBinding TAC for KM as mean of given RefIds
+    no_rescale: 'True'
+    # type=bool|default=False: do not global rescale such that mean of reference region is scaleref
+    save_input: 'True'
+    # type=bool|default=False: saves rescaled input as input.rescaled.nii.gz
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: mri_gtmpvc --i sub-01_ses-baseline_pet.nii.gz --mg 0.5 ROI1 ROI2 --o pvc --regheader --seg gtmseg.mgz
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: input volume - source data to pvc
+    segmentation:
+    # type=file|default=<undefined>: segfile : anatomical segmentation to define regions for GTM
+    regheader: 'True'
+    # type=bool|default=False: assume input and seg share scanner space
+    pvc_dir: '"pvc"'
+    # type=directory: output directory
+    # type=str|default='': save outputs to dir
+    mg: (0.5, ["ROI1", "ROI2"])
+    # type=tuple|default=<undefined>: gmthresh RefId1 RefId2 ...: perform Mueller-Gaertner PVC, gmthresh is min gm pvf bet 0 and 1
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/gtmpvc_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/gtmpvc_callables.py
new file mode 100644
index 00000000..80701ac4
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/gtmpvc_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in GTMPVC.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/image_info.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/image_info.yaml
new file mode 100644
index 00000000..fc2171d5
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/image_info.yaml
@@ -0,0 +1,76 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.utils.ImageInfo' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+task_name: ImageInfo
+nipype_name: ImageInfo
+nipype_module: nipype.interfaces.freesurfer.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: image to query
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: text file with image information
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: image to query
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/image_info_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/image_info_callables.py
new file mode 100644
index 00000000..d6754e7f
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/image_info_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in ImageInfo.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/jacobian.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/jacobian.yaml
new file mode 100644
index 00000000..ce30d3b2
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/jacobian.yaml
@@ -0,0 +1,135 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.utils.Jacobian' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     This program computes the Jacobian of a surface mapping.
+# 
+#     Examples
+#     ========
+#     >>> from nipype.interfaces.freesurfer import Jacobian
+#     >>> jacobian = Jacobian()
+#     >>> jacobian.inputs.in_origsurf = 'lh.pial'
+#     >>> jacobian.inputs.in_mappedsurf = 'lh.pial'
+#     >>> jacobian.cmdline
+#     'mris_jacobian lh.pial lh.pial lh.jacobian'
+#     
+task_name: Jacobian
+nipype_name: Jacobian
+nipype_module: nipype.interfaces.freesurfer.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_origsurf: medimage-freesurfer/pial
+    # type=file|default=<undefined>: Original surface
+    in_mappedsurf: medimage-freesurfer/pial
+    # type=file|default=<undefined>: Mapped surface
+    out_file: generic/file
+    # type=file: Output Jacobian of the surface mapping
+    # type=file|default=<undefined>: Output Jacobian of the surface mapping
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: Output Jacobian of the surface mapping
+    # type=file|default=<undefined>: Output Jacobian of the surface mapping
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_origsurf:
+    # type=file|default=<undefined>: Original surface
+    in_mappedsurf:
+    # type=file|default=<undefined>: Mapped surface
+    out_file:
+    # type=file: Output Jacobian of the surface mapping
+    # type=file|default=<undefined>: Output Jacobian of the surface mapping
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_origsurf:
+    # type=file|default=<undefined>: Original surface
+    in_mappedsurf:
+    # type=file|default=<undefined>: Mapped surface
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: mris_jacobian lh.pial lh.pial lh.jacobian
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_origsurf:
+    # type=file|default=<undefined>: Original surface
+    in_mappedsurf:
+    # type=file|default=<undefined>: Mapped surface
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/jacobian_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/jacobian_callables.py
new file mode 100644
index 00000000..4d7ccd46
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/jacobian_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Jacobian.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/label_2_annot.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/label_2_annot.yaml
new file mode 100644
index 00000000..bf08fff8
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/label_2_annot.yaml
@@ -0,0 +1,157 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.model.Label2Annot' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Converts a set of surface labels to an annotation file
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces.freesurfer import Label2Annot
+#     >>> l2a = Label2Annot()
+#     >>> l2a.inputs.hemisphere = 'lh'
+#     >>> l2a.inputs.subject_id = '10335'
+#     >>> l2a.inputs.in_labels = ['lh.aparc.label']
+#     >>> l2a.inputs.orig = 'lh.pial'
+#     >>> l2a.inputs.out_annot = 'test'
+#     >>> l2a.cmdline
+#     'mris_label2annot --hemi lh --l lh.aparc.label --a test --s 10335'
+#     
+task_name: Label2Annot
+nipype_name: Label2Annot
+nipype_module: nipype.interfaces.freesurfer.model
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    orig: medimage-freesurfer/pial
+    # type=file|default=<undefined>: implicit {hemisphere}.orig
+    color_table: generic/file
+    # type=file|default=<undefined>: File that defines the structure names, their indices, and their color
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: Output annotation file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    hemisphere:
+    # type=enum|default='lh'|allowed['lh','rh']: Input hemisphere
+    subject_id:
+    # type=string|default='subject_id': Subject name/ID
+    in_labels:
+    # type=list|default=[]: List of input label files
+    out_annot:
+    # type=string|default='': Name of the annotation to create
+    orig:
+    # type=file|default=<undefined>: implicit {hemisphere}.orig
+    keep_max:
+    # type=bool|default=False: Keep label with highest 'stat' value
+    verbose_off:
+    # type=bool|default=False: Turn off overlap and stat override messages
+    color_table:
+    # type=file|default=<undefined>: File that defines the structure names, their indices, and their color
+    copy_inputs:
+    # type=bool|default=False: copy implicit inputs and create a temp subjects_dir
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    hemisphere: '"lh"'
+    # type=enum|default='lh'|allowed['lh','rh']: Input hemisphere
+    subject_id: '"10335"'
+    # type=string|default='subject_id': Subject name/ID
+    in_labels: '["lh.aparc.label"]'
+    # type=list|default=[]: List of input label files
+    orig:
+    # type=file|default=<undefined>: implicit {hemisphere}.orig
+    out_annot: '"test"'
+    # type=string|default='': Name of the annotation to create
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: mris_label2annot --hemi lh --l lh.aparc.label --a test --s 10335
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    hemisphere: '"lh"'
+    # type=enum|default='lh'|allowed['lh','rh']: Input hemisphere
+    subject_id: '"10335"'
+    # type=string|default='subject_id': Subject name/ID
+    in_labels: '["lh.aparc.label"]'
+    # type=list|default=[]: List of input label files
+    orig:
+    # type=file|default=<undefined>: implicit {hemisphere}.orig
+    out_annot: '"test"'
+    # type=string|default='': Name of the annotation to create
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/label_2_annot_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/label_2_annot_callables.py
new file mode 100644
index 00000000..ddbd52ea
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/label_2_annot_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Label2Annot.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/label_2_label.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/label_2_label.yaml
new file mode 100644
index 00000000..d10ad0cd
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/label_2_label.yaml
@@ -0,0 +1,195 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.model.Label2Label' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Converts a label in one subject's space to a label
+#     in another subject's space using either talairach or spherical
+#     as an intermediate registration space.
+# 
+#     If a source mask is used, then the input label must have been
+#     created from a surface (ie, the vertex numbers are valid). The
+#     format can be anything supported by mri_convert or curv or paint.
+#     Vertices in the source label that do not meet threshold in the
+#     mask will be removed from the label.
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces.freesurfer import Label2Label
+#     >>> l2l = Label2Label()
+#     >>> l2l.inputs.hemisphere = 'lh'
+#     >>> l2l.inputs.subject_id = '10335'
+#     >>> l2l.inputs.sphere_reg = 'lh.pial'
+#     >>> l2l.inputs.white = 'lh.pial'
+#     >>> l2l.inputs.source_subject = 'fsaverage'
+#     >>> l2l.inputs.source_label = 'lh-pial.stl'
+#     >>> l2l.inputs.source_white = 'lh.pial'
+#     >>> l2l.inputs.source_sphere_reg = 'lh.pial'
+#     >>> l2l.cmdline
+#     'mri_label2label --hemi lh --trglabel lh-pial_converted.stl --regmethod surface --srclabel lh-pial.stl --srcsubject fsaverage --trgsubject 10335'
+#     
+task_name: Label2Label
+nipype_name: Label2Label
+nipype_module: nipype.interfaces.freesurfer.model
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    sphere_reg: medimage-freesurfer/pial
+    # type=file|default=<undefined>: Implicit input <hemisphere>.sphere.reg
+    white: medimage-freesurfer/pial
+    # type=file|default=<undefined>: Implicit input <hemisphere>.white
+    source_sphere_reg: medimage-freesurfer/pial
+    # type=file|default=<undefined>: Implicit input <hemisphere>.sphere.reg
+    source_white: medimage-freesurfer/pial
+    # type=file|default=<undefined>: Implicit input <hemisphere>.white
+    source_label: model/stl
+    # type=file|default=<undefined>: Source label
+    out_file: generic/file
+    # type=file: Output label
+    # type=file|default=<undefined>: Target label
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: Output label
+    # type=file|default=<undefined>: Target label
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    hemisphere:
+    # type=enum|default='lh'|allowed['lh','rh']: Input hemisphere
+    subject_id:
+    # type=string|default='subject_id': Target subject
+    sphere_reg:
+    # type=file|default=<undefined>: Implicit input <hemisphere>.sphere.reg
+    white:
+    # type=file|default=<undefined>: Implicit input <hemisphere>.white
+    source_sphere_reg:
+    # type=file|default=<undefined>: Implicit input <hemisphere>.sphere.reg
+    source_white:
+    # type=file|default=<undefined>: Implicit input <hemisphere>.white
+    source_label:
+    # type=file|default=<undefined>: Source label
+    source_subject:
+    # type=string|default='': Source subject name
+    out_file:
+    # type=file: Output label
+    # type=file|default=<undefined>: Target label
+    registration_method:
+    # type=enum|default='surface'|allowed['surface','volume']: Registration method
+    copy_inputs:
+    # type=bool|default=False: If running as a node, set this to True.This will copy the input files to the node directory.
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    hemisphere: '"lh"'
+    # type=enum|default='lh'|allowed['lh','rh']: Input hemisphere
+    subject_id: '"10335"'
+    # type=string|default='subject_id': Target subject
+    sphere_reg:
+    # type=file|default=<undefined>: Implicit input <hemisphere>.sphere.reg
+    white:
+    # type=file|default=<undefined>: Implicit input <hemisphere>.white
+    source_subject: '"fsaverage"'
+    # type=string|default='': Source subject name
+    source_label:
+    # type=file|default=<undefined>: Source label
+    source_white:
+    # type=file|default=<undefined>: Implicit input <hemisphere>.white
+    source_sphere_reg:
+    # type=file|default=<undefined>: Implicit input <hemisphere>.sphere.reg
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: mri_label2label --hemi lh --trglabel lh-pial_converted.stl --regmethod surface --srclabel lh-pial.stl --srcsubject fsaverage --trgsubject 10335
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    hemisphere: '"lh"'
+    # type=enum|default='lh'|allowed['lh','rh']: Input hemisphere
+    subject_id: '"10335"'
+    # type=string|default='subject_id': Target subject
+    sphere_reg:
+    # type=file|default=<undefined>: Implicit input <hemisphere>.sphere.reg
+    white:
+    # type=file|default=<undefined>: Implicit input <hemisphere>.white
+    source_subject: '"fsaverage"'
+    # type=string|default='': Source subject name
+    source_label:
+    # type=file|default=<undefined>: Source label
+    source_white:
+    # type=file|default=<undefined>: Implicit input <hemisphere>.white
+    source_sphere_reg:
+    # type=file|default=<undefined>: Implicit input <hemisphere>.sphere.reg
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/label_2_label_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/label_2_label_callables.py
new file mode 100644
index 00000000..c00417f0
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/label_2_label_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Label2Label.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/label_2_vol.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/label_2_vol.yaml
new file mode 100644
index 00000000..7a45d61f
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/label_2_vol.yaml
@@ -0,0 +1,190 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.model.Label2Vol' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Make a binary volume from a Freesurfer label
+# 
+#     Examples
+#     --------
+#     >>> binvol = Label2Vol(label_file='cortex.label', template_file='structural.nii', reg_file='register.dat', fill_thresh=0.5, vol_label_file='foo_out.nii')
+#     >>> binvol.cmdline
+#     'mri_label2vol --fillthresh 0.5 --label cortex.label --reg register.dat --temp structural.nii --o foo_out.nii'
+# 
+#     
+task_name: Label2Vol
+nipype_name: Label2Vol
+nipype_module: nipype.interfaces.freesurfer.model
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    label_file: medimage-freesurfer/label+list-of
+    # type=inputmultiobject|default=[]: list of label files
+    annot_file: generic/file
+    # type=file|default=<undefined>: surface annotation file
+    seg_file: generic/file
+    # type=file|default=<undefined>: segmentation file
+    template_file: medimage/nifti1
+    # type=file|default=<undefined>: output template volume
+    reg_file: datascience/dat-file
+    # type=file|default=<undefined>: tkregister style matrix VolXYZ = R*LabelXYZ
+    reg_header: generic/file
+    # type=file|default=<undefined>: label template volume
+    label_hit_file: generic/file
+    # type=file|default=<undefined>: file with each frame is nhits for a label
+    map_label_stat: generic/file
+    # type=file|default=<undefined>: map the label stats field into the vol
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    vol_label_file: medimage/nifti1
+    # type=file: output volume
+    # type=file|default=<undefined>: output volume
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    vol_label_file: '"foo_out.nii"'
+    # type=file: output volume
+    # type=file|default=<undefined>: output volume
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    label_file:
+    # type=inputmultiobject|default=[]: list of label files
+    annot_file:
+    # type=file|default=<undefined>: surface annotation file
+    seg_file:
+    # type=file|default=<undefined>: segmentation file
+    aparc_aseg:
+    # type=bool|default=False: use aparc+aseg.mgz in subjectdir as seg
+    template_file:
+    # type=file|default=<undefined>: output template volume
+    reg_file:
+    # type=file|default=<undefined>: tkregister style matrix VolXYZ = R*LabelXYZ
+    reg_header:
+    # type=file|default=<undefined>: label template volume
+    identity:
+    # type=bool|default=False: set R=I
+    invert_mtx:
+    # type=bool|default=False: Invert the registration matrix
+    fill_thresh:
+    # type=range|default=0.0: thresh : between 0 and 1
+    label_voxel_volume:
+    # type=float|default=0.0: volume of each label point (def 1mm3)
+    proj:
+    # type=tuple|default=('abs', 0.0, 0.0, 0.0): project along surface normal
+    subject_id:
+    # type=str|default='': subject id
+    hemi:
+    # type=enum|default='lh'|allowed['lh','rh']: hemisphere to use lh or rh
+    surface:
+    # type=str|default='': use surface instead of white
+    vol_label_file:
+    # type=file: output volume
+    # type=file|default=<undefined>: output volume
+    label_hit_file:
+    # type=file|default=<undefined>: file with each frame is nhits for a label
+    map_label_stat:
+    # type=file|default=<undefined>: map the label stats field into the vol
+    native_vox2ras:
+    # type=bool|default=False: use native vox2ras xform instead of  tkregister-style
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    label_file:
+    # type=inputmultiobject|default=[]: list of label files
+    template_file:
+    # type=file|default=<undefined>: output template volume
+    reg_file:
+    # type=file|default=<undefined>: tkregister style matrix VolXYZ = R*LabelXYZ
+    fill_thresh: '0.5'
+    # type=range|default=0.0: thresh : between 0 and 1
+    vol_label_file: '"foo_out.nii"'
+    # type=file: output volume
+    # type=file|default=<undefined>: output volume
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: mri_label2vol --fillthresh 0.5 --label cortex.label --reg register.dat --temp structural.nii --o foo_out.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    label_file:
+    # type=inputmultiobject|default=[]: list of label files
+    template_file:
+    # type=file|default=<undefined>: output template volume
+    reg_file:
+    # type=file|default=<undefined>: tkregister style matrix VolXYZ = R*LabelXYZ
+    fill_thresh: '0.5'
+    # type=range|default=0.0: thresh : between 0 and 1
+    vol_label_file: '"foo_out.nii"'
+    # type=file: output volume
+    # type=file|default=<undefined>: output volume
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/label_2_vol_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/label_2_vol_callables.py
new file mode 100644
index 00000000..a6f32381
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/label_2_vol_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Label2Vol.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/logan_ref.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/logan_ref.yaml
new file mode 100644
index 00000000..ad1168ba
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/logan_ref.yaml
@@ -0,0 +1,300 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.petsurfer.LoganRef' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Perform Logan reference kinetic modeling.
+#     Examples
+#     --------
+#     >>> logan = LoganRef()
+#     >>> logan.inputs.in_file = 'tac.nii'
+#     >>> logan.inputs.logan = ('ref_tac.dat', 'timing.dat', 2600)
+#     >>> logan.inputs.glm_dir = 'logan'
+#     >>> logan.cmdline
+#     'mri_glmfit --glmdir logan --y tac.nii --logan ref_tac.dat timing.dat 2600'
+#     
+task_name: LoganRef
+nipype_name: LoganRef
+nipype_module: nipype.interfaces.freesurfer.petsurfer
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: input 4D file
+    design: generic/file
+    # type=file|default=<undefined>: design matrix file
+    contrast: generic/file+list-of
+    # type=inputmultiobject|default=[]: contrast file
+    per_voxel_reg: generic/file+list-of
+    # type=inputmultiobject|default=[]: per-voxel regressors
+    weighted_ls: generic/file
+    # type=file|default=<undefined>: weighted least squares
+    fixed_fx_var: generic/file
+    # type=file|default=<undefined>: for fixed effects analysis
+    fixed_fx_dof_file: generic/file
+    # type=file|default=<undefined>: text file with dof for fixed effects analysis
+    weight_file: generic/file
+    # type=file|default=<undefined>: weight for each input at each voxel
+    mask_file: generic/file
+    # type=file: map of the mask used in the analysis
+    # type=file|default=<undefined>: binary mask
+    label_file: generic/file
+    # type=file|default=<undefined>: use label as mask, surfaces only
+    sim_done_file: generic/file
+    # type=file|default=<undefined>: create file when simulation finished
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    beta_file: generic/file
+    # type=file: map of regression coefficients
+    error_file: generic/file
+    # type=file: map of residual error
+    error_var_file: generic/file
+    # type=file: map of residual error variance
+    error_stddev_file: generic/file
+    # type=file: map of residual error standard deviation
+    estimate_file: generic/file
+    # type=file: map of the estimated Y values
+    mask_file: generic/file
+    # type=file: map of the mask used in the analysis
+    # type=file|default=<undefined>: binary mask
+    fwhm_file: generic/file
+    # type=file: text file with estimated smoothness
+    dof_file: generic/file
+    # type=file: text file with effective degrees-of-freedom for the analysis
+    spatial_eigenvectors: generic/file
+    # type=file: map of spatial eigenvectors from residual PCA
+    frame_eigenvectors: generic/file
+    # type=file: matrix of frame eigenvectors from residual PCA
+    singular_values: generic/file
+    # type=file: matrix singular values from residual PCA
+    svd_stats_file: generic/file
+    # type=file: text file summarizing the residual PCA
+    k2p_file: generic/file
+    # type=file: estimate of k2p parameter
+    bp_file: generic/file
+    # type=file: Binding potential estimates
+    glm_dir: generic/directory
+    # type=directory: output directory
+    # type=str|default='': save outputs to dir
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    glm_dir: '"logan"'
+    # type=directory: output directory
+    # type=str|default='': save outputs to dir
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    logan:
+    # type=tuple|default=(<undefined>, <undefined>, 0.0): RefTac TimeSec tstar   : perform Logan kinetic modeling
+    glm_dir:
+    # type=directory: output directory
+    # type=str|default='': save outputs to dir
+    in_file:
+    # type=file|default=<undefined>: input 4D file
+    fsgd:
+    # type=tuple|default=(<undefined>, 'doss'): freesurfer descriptor file
+    design:
+    # type=file|default=<undefined>: design matrix file
+    contrast:
+    # type=inputmultiobject|default=[]: contrast file
+    one_sample:
+    # type=bool|default=False: construct X and C as a one-sample group mean
+    no_contrast_ok:
+    # type=bool|default=False: do not fail if no contrasts specified
+    per_voxel_reg:
+    # type=inputmultiobject|default=[]: per-voxel regressors
+    self_reg:
+    # type=tuple|default=(0, 0, 0): self-regressor from index col row slice
+    weighted_ls:
+    # type=file|default=<undefined>: weighted least squares
+    fixed_fx_var:
+    # type=file|default=<undefined>: for fixed effects analysis
+    fixed_fx_dof:
+    # type=int|default=0: dof for fixed effects analysis
+    fixed_fx_dof_file:
+    # type=file|default=<undefined>: text file with dof for fixed effects analysis
+    weight_file:
+    # type=file|default=<undefined>: weight for each input at each voxel
+    weight_inv:
+    # type=bool|default=False: invert weights
+    weight_sqrt:
+    # type=bool|default=False: sqrt of weights
+    fwhm:
+    # type=range|default=0.0: smooth input by fwhm
+    var_fwhm:
+    # type=range|default=0.0: smooth variance by fwhm
+    no_mask_smooth:
+    # type=bool|default=False: do not mask when smoothing
+    no_est_fwhm:
+    # type=bool|default=False: turn off FWHM output estimation
+    mask_file:
+    # type=file: map of the mask used in the analysis
+    # type=file|default=<undefined>: binary mask
+    label_file:
+    # type=file|default=<undefined>: use label as mask, surfaces only
+    cortex:
+    # type=bool|default=False: use subjects ?h.cortex.label as label
+    invert_mask:
+    # type=bool|default=False: invert mask
+    prune:
+    # type=bool|default=False: remove voxels that do not have a non-zero value at each frame (def)
+    no_prune:
+    # type=bool|default=False: do not prune
+    prune_thresh:
+    # type=float|default=0.0: prune threshold. Default is FLT_MIN
+    compute_log_y:
+    # type=bool|default=False: compute natural log of y prior to analysis
+    save_estimate:
+    # type=bool|default=False: save signal estimate (yhat)
+    save_residual:
+    # type=bool|default=False: save residual error (eres)
+    save_res_corr_mtx:
+    # type=bool|default=False: save residual error spatial correlation matrix (eres.scm). Big!
+    surf:
+    # type=bool|default=False: analysis is on a surface mesh
+    subject_id:
+    # type=str|default='': subject id for surface geometry
+    hemi:
+    # type=enum|default='lh'|allowed['lh','rh']: surface hemisphere
+    surf_geo:
+    # type=str|default='white': surface geometry name (e.g. white, pial)
+    simulation:
+    # type=tuple|default=('perm', 0, 0.0, ''): nulltype nsim thresh csdbasename
+    sim_sign:
+    # type=enum|default='abs'|allowed['abs','neg','pos']: abs, pos, or neg
+    uniform:
+    # type=tuple|default=(0.0, 0.0): use uniform distribution instead of gaussian
+    pca:
+    # type=bool|default=False: perform pca/svd analysis on residual
+    calc_AR1:
+    # type=bool|default=False: compute and save temporal AR1 of residual
+    save_cond:
+    # type=bool|default=False: flag to save design matrix condition at each voxel
+    vox_dump:
+    # type=tuple|default=(0, 0, 0): dump voxel GLM and exit
+    seed:
+    # type=int|default=0: used for synthesizing noise
+    synth:
+    # type=bool|default=False: replace input with gaussian
+    resynth_test:
+    # type=int|default=0: test GLM by resynthsis
+    profile:
+    # type=int|default=0: niters : test speed
+    mrtm1:
+    # type=tuple|default=(<undefined>, <undefined>): RefTac TimeSec : perform MRTM1 kinetic modeling
+    mrtm2:
+    # type=tuple|default=(<undefined>, <undefined>, 0.0): RefTac TimeSec k2prime : perform MRTM2 kinetic modeling
+    force_perm:
+    # type=bool|default=False: force perumtation test, even when design matrix is not orthog
+    diag:
+    # type=int|default=0: Gdiag_no : set diagnostic level
+    diag_cluster:
+    # type=bool|default=False: save sig volume and exit from first sim loop
+    debug:
+    # type=bool|default=False: turn on debugging
+    check_opts:
+    # type=bool|default=False: don't run anything, just check options and exit
+    allow_repeated_subjects:
+    # type=bool|default=False: allow subject names to repeat in the fsgd file (must appear before --fsgd
+    allow_ill_cond:
+    # type=bool|default=False: allow ill-conditioned design matrices
+    sim_done_file:
+    # type=file|default=<undefined>: create file when simulation finished
+    nii:
+    # type=bool|default=False: save outputs as nii
+    nii_gz:
+    # type=bool|default=False: save outputs as nii.gz
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input 4D file
+    logan: ("ref_tac.dat", "timing.dat", 2600)
+    # type=tuple|default=(<undefined>, <undefined>, 0.0): RefTac TimeSec tstar   : perform Logan kinetic modeling
+    glm_dir: '"logan"'
+    # type=directory: output directory
+    # type=str|default='': save outputs to dir
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: mri_glmfit --glmdir logan --y tac.nii --logan ref_tac.dat timing.dat 2600
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: input 4D file
+    logan: ("ref_tac.dat", "timing.dat", 2600)
+    # type=tuple|default=(<undefined>, <undefined>, 0.0): RefTac TimeSec tstar   : perform Logan kinetic modeling
+    glm_dir: '"logan"'
+    # type=directory: output directory
+    # type=str|default='': save outputs to dir
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/logan_ref_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/logan_ref_callables.py
new file mode 100644
index 00000000..92e5a6b4
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/logan_ref_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in LoganRef.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/lta_convert.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/lta_convert.yaml
new file mode 100644
index 00000000..434de8a7
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/lta_convert.yaml
@@ -0,0 +1,138 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.utils.LTAConvert' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Convert different transformation formats.
+#     Some formats may require you to pass an image if the geometry information
+#     is missing form the transform file format.
+# 
+#     For complete details, see the `lta_convert documentation.
+#     <https://ftp.nmr.mgh.harvard.edu/pub/docs/html/lta_convert.help.xml.html>`_
+#     
+task_name: LTAConvert
+nipype_name: LTAConvert
+nipype_module: nipype.interfaces.freesurfer.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_fsl: generic/file
+    # type=file|default=<undefined>: input transform of FSL type
+    in_mni: generic/file
+    # type=file|default=<undefined>: input transform of MNI/XFM type
+    in_reg: generic/file
+    # type=file|default=<undefined>: input transform of TK REG type (deprecated format)
+    in_niftyreg: generic/file
+    # type=file|default=<undefined>: input transform of Nifty Reg type (inverse RAS2RAS)
+    in_itk: generic/file
+    # type=file|default=<undefined>: input transform of ITK type
+    source_file: generic/file
+    # type=file|default=<undefined>: 
+    target_file: generic/file
+    # type=file|default=<undefined>: 
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_lta: generic/file
+    # type=file: output linear transform (LTA Freesurfer format)
+    # type=traitcompound|default=None: output linear transform (LTA Freesurfer format)
+    out_fsl: generic/file
+    # type=file: output transform in FSL format
+    # type=traitcompound|default=None: output transform in FSL format
+    out_mni: generic/file
+    # type=file: output transform in MNI/XFM format
+    # type=traitcompound|default=None: output transform in MNI/XFM format
+    out_reg: generic/file
+    # type=file: output transform in reg dat format
+    # type=traitcompound|default=None: output transform in reg dat format
+    out_itk: generic/file
+    # type=file: output transform in ITK format
+    # type=traitcompound|default=None: output transform in ITK format
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_lta:
+    # type=traitcompound|default=None: input transform of LTA type
+    in_fsl:
+    # type=file|default=<undefined>: input transform of FSL type
+    in_mni:
+    # type=file|default=<undefined>: input transform of MNI/XFM type
+    in_reg:
+    # type=file|default=<undefined>: input transform of TK REG type (deprecated format)
+    in_niftyreg:
+    # type=file|default=<undefined>: input transform of Nifty Reg type (inverse RAS2RAS)
+    in_itk:
+    # type=file|default=<undefined>: input transform of ITK type
+    out_lta:
+    # type=file: output linear transform (LTA Freesurfer format)
+    # type=traitcompound|default=None: output linear transform (LTA Freesurfer format)
+    out_fsl:
+    # type=file: output transform in FSL format
+    # type=traitcompound|default=None: output transform in FSL format
+    out_mni:
+    # type=file: output transform in MNI/XFM format
+    # type=traitcompound|default=None: output transform in MNI/XFM format
+    out_reg:
+    # type=file: output transform in reg dat format
+    # type=traitcompound|default=None: output transform in reg dat format
+    out_itk:
+    # type=file: output transform in ITK format
+    # type=traitcompound|default=None: output transform in ITK format
+    invert:
+    # type=bool|default=False: 
+    ltavox2vox:
+    # type=bool|default=False: 
+    source_file:
+    # type=file|default=<undefined>: 
+    target_file:
+    # type=file|default=<undefined>: 
+    target_conform:
+    # type=bool|default=False: 
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/lta_convert_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/lta_convert_callables.py
new file mode 100644
index 00000000..efc3a184
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/lta_convert_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in LTAConvert.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/make_average_subject.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/make_average_subject.yaml
new file mode 100644
index 00000000..9a288940
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/make_average_subject.yaml
@@ -0,0 +1,119 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.utils.MakeAverageSubject' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Make an average freesurfer subject
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces.freesurfer import MakeAverageSubject
+#     >>> avg = MakeAverageSubject(subjects_ids=['s1', 's2'])
+#     >>> avg.cmdline
+#     'make_average_subject --out average --subjects s1 s2'
+# 
+#     
+task_name: MakeAverageSubject
+nipype_name: MakeAverageSubject
+nipype_module: nipype.interfaces.freesurfer.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_name: generic/file
+    # type=file|default='average': name for the average subject
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    subjects_ids:
+    # type=list|default=[]: freesurfer subjects ids to average
+    out_name:
+    # type=file|default='average': name for the average subject
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    subjects_ids: '["s1", "s2"]'
+    # type=list|default=[]: freesurfer subjects ids to average
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: make_average_subject --out average --subjects s1 s2
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    subjects_ids: '["s1", "s2"]'
+    # type=list|default=[]: freesurfer subjects ids to average
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/make_average_subject_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/make_average_subject_callables.py
new file mode 100644
index 00000000..4d855d5a
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/make_average_subject_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in MakeAverageSubject.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/make_surfaces.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/make_surfaces.yaml
new file mode 100644
index 00000000..a6ae5f06
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/make_surfaces.yaml
@@ -0,0 +1,222 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.utils.MakeSurfaces' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     This program positions the tessellation of the cortical surface at the
+#     white matter surface, then the gray matter surface and generate
+#     surface files for these surfaces as well as a 'curvature' file for the
+#     cortical thickness, and a surface file which approximates layer IV of
+#     the cortical sheet.
+# 
+#     Examples
+#     ========
+#     >>> from nipype.interfaces.freesurfer import MakeSurfaces
+#     >>> makesurfaces = MakeSurfaces()
+#     >>> makesurfaces.inputs.hemisphere = 'lh'
+#     >>> makesurfaces.inputs.subject_id = '10335'
+#     >>> makesurfaces.inputs.in_orig = 'lh.pial'
+#     >>> makesurfaces.inputs.in_wm = 'wm.mgz'
+#     >>> makesurfaces.inputs.in_filled = 'norm.mgz'
+#     >>> makesurfaces.inputs.in_label = 'aparc+aseg.nii'
+#     >>> makesurfaces.inputs.in_T1 = 'T1.mgz'
+#     >>> makesurfaces.inputs.orig_pial = 'lh.pial'
+#     >>> makesurfaces.cmdline
+#     'mris_make_surfaces -T1 T1.mgz -orig pial -orig_pial pial 10335 lh'
+#     
+task_name: MakeSurfaces
+nipype_name: MakeSurfaces
+nipype_module: nipype.interfaces.freesurfer.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_orig: medimage-freesurfer/pial
+    # type=file|default=<undefined>: Implicit input file <hemisphere>.orig
+    in_wm: medimage/mgh-gz
+    # type=file|default=<undefined>: Implicit input file wm.mgz
+    in_filled: medimage/mgh-gz
+    # type=file|default=<undefined>: Implicit input file filled.mgz
+    in_white: generic/file
+    # type=file|default=<undefined>: Implicit input that is sometimes used
+    in_label: medimage/nifti1
+    # type=file|default=<undefined>: Implicit input label/<hemisphere>.aparc.annot
+    orig_white: generic/file
+    # type=file|default=<undefined>: Specify a white surface to start with
+    orig_pial: medimage-freesurfer/pial
+    # type=file|default=<undefined>: Specify a pial surface to start with
+    in_aseg: generic/file
+    # type=file|default=<undefined>: Input segmentation file
+    in_T1: medimage/mgh-gz
+    # type=file|default=<undefined>: Input brain or T1 file
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_white: generic/file
+    # type=file: Output white matter hemisphere surface
+    out_curv: generic/file
+    # type=file: Output curv file for MakeSurfaces
+    out_area: generic/file
+    # type=file: Output area file for MakeSurfaces
+    out_cortex: generic/file
+    # type=file: Output cortex file for MakeSurfaces
+    out_pial: generic/file
+    # type=file: Output pial surface for MakeSurfaces
+    out_thickness: generic/file
+    # type=file: Output thickness file for MakeSurfaces
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    hemisphere:
+    # type=enum|default='lh'|allowed['lh','rh']: Hemisphere being processed
+    subject_id:
+    # type=string|default='subject_id': Subject being processed
+    in_orig:
+    # type=file|default=<undefined>: Implicit input file <hemisphere>.orig
+    in_wm:
+    # type=file|default=<undefined>: Implicit input file wm.mgz
+    in_filled:
+    # type=file|default=<undefined>: Implicit input file filled.mgz
+    in_white:
+    # type=file|default=<undefined>: Implicit input that is sometimes used
+    in_label:
+    # type=file|default=<undefined>: Implicit input label/<hemisphere>.aparc.annot
+    orig_white:
+    # type=file|default=<undefined>: Specify a white surface to start with
+    orig_pial:
+    # type=file|default=<undefined>: Specify a pial surface to start with
+    fix_mtl:
+    # type=bool|default=False: Undocumented flag
+    no_white:
+    # type=bool|default=False: Undocumented flag
+    white_only:
+    # type=bool|default=False: Undocumented flag
+    in_aseg:
+    # type=file|default=<undefined>: Input segmentation file
+    in_T1:
+    # type=file|default=<undefined>: Input brain or T1 file
+    mgz:
+    # type=bool|default=False: No documentation. Direct questions to analysis-bugs@nmr.mgh.harvard.edu
+    noaparc:
+    # type=bool|default=False: No documentation. Direct questions to analysis-bugs@nmr.mgh.harvard.edu
+    maximum:
+    # type=float|default=0.0: No documentation (used for longitudinal processing)
+    longitudinal:
+    # type=bool|default=False: No documentation (used for longitudinal processing)
+    white:
+    # type=string|default='': White surface name
+    copy_inputs:
+    # type=bool|default=False: If running as a node, set this to True.This will copy the input files to the node directory.
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    hemisphere: '"lh"'
+    # type=enum|default='lh'|allowed['lh','rh']: Hemisphere being processed
+    subject_id: '"10335"'
+    # type=string|default='subject_id': Subject being processed
+    in_orig:
+    # type=file|default=<undefined>: Implicit input file <hemisphere>.orig
+    in_wm:
+    # type=file|default=<undefined>: Implicit input file wm.mgz
+    in_filled:
+    # type=file|default=<undefined>: Implicit input file filled.mgz
+    in_label:
+    # type=file|default=<undefined>: Implicit input label/<hemisphere>.aparc.annot
+    in_T1:
+    # type=file|default=<undefined>: Input brain or T1 file
+    orig_pial:
+    # type=file|default=<undefined>: Specify a pial surface to start with
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: mris_make_surfaces -T1 T1.mgz -orig pial -orig_pial pial 10335 lh
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    hemisphere: '"lh"'
+    # type=enum|default='lh'|allowed['lh','rh']: Hemisphere being processed
+    subject_id: '"10335"'
+    # type=string|default='subject_id': Subject being processed
+    in_orig:
+    # type=file|default=<undefined>: Implicit input file <hemisphere>.orig
+    in_wm:
+    # type=file|default=<undefined>: Implicit input file wm.mgz
+    in_filled:
+    # type=file|default=<undefined>: Implicit input file filled.mgz
+    in_label:
+    # type=file|default=<undefined>: Implicit input label/<hemisphere>.aparc.annot
+    in_T1:
+    # type=file|default=<undefined>: Input brain or T1 file
+    orig_pial:
+    # type=file|default=<undefined>: Specify a pial surface to start with
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/make_surfaces_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/make_surfaces_callables.py
new file mode 100644
index 00000000..93ac50c0
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/make_surfaces_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in MakeSurfaces.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/mni_bias_correction.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/mni_bias_correction.yaml
new file mode 100644
index 00000000..56a77139
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/mni_bias_correction.yaml
@@ -0,0 +1,174 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.preprocess.MNIBiasCorrection' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Wrapper for nu_correct, a program from the Montreal Neurological Insitute (MNI)
+#     used for correcting intensity non-uniformity (ie, bias fields). You must have the
+#     MNI software installed on your system to run this. See [www.bic.mni.mcgill.ca/software/N3]
+#     for more info.
+# 
+#     mri_nu_correct.mni uses float internally instead of uchar. It also rescales the output so
+#     that the global mean is the same as that of the input. These two changes are linked and
+#     can be turned off with --no-float
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces.freesurfer import MNIBiasCorrection
+#     >>> correct = MNIBiasCorrection()
+#     >>> correct.inputs.in_file = "norm.mgz"
+#     >>> correct.inputs.iterations = 6
+#     >>> correct.inputs.protocol_iterations = 1000
+#     >>> correct.inputs.distance = 50
+#     >>> correct.cmdline
+#     'mri_nu_correct.mni --distance 50 --i norm.mgz --n 6 --o norm_output.mgz --proto-iters 1000'
+# 
+#     References
+#     ----------
+#     [http://freesurfer.net/fswiki/mri_nu_correct.mni]
+#     [http://www.bic.mni.mcgill.ca/software/N3]
+#     [https://github.com/BIC-MNI/N3]
+# 
+#     
+task_name: MNIBiasCorrection
+nipype_name: MNIBiasCorrection
+nipype_module: nipype.interfaces.freesurfer.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/mgh-gz
+    # type=file|default=<undefined>: input volume. Input can be any format accepted by mri_convert.
+    out_file: generic/file
+    # type=file: output volume
+    # type=file|default=<undefined>: output volume. Output can be any format accepted by mri_convert. If the output format is COR, then the directory must exist.
+    mask: generic/file
+    # type=file|default=<undefined>: brainmask volume. Input can be any format accepted by mri_convert.
+    transform: generic/file
+    # type=file|default=<undefined>: tal.xfm. Use mri_make_uchar instead of conforming
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: output volume
+    # type=file|default=<undefined>: output volume. Output can be any format accepted by mri_convert. If the output format is COR, then the directory must exist.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input volume. Input can be any format accepted by mri_convert.
+    out_file:
+    # type=file: output volume
+    # type=file|default=<undefined>: output volume. Output can be any format accepted by mri_convert. If the output format is COR, then the directory must exist.
+    iterations:
+    # type=int|default=4: Number of iterations to run nu_correct. Default is 4. This is the number of times that nu_correct is repeated (ie, using the output from the previous run as the input for the next). This is different than the -iterations option to nu_correct.
+    protocol_iterations:
+    # type=int|default=0: Passes Np as argument of the -iterations flag of nu_correct. This is different than the --n flag above. Default is not to pass nu_correct the -iterations flag.
+    distance:
+    # type=int|default=0: N3 -distance option
+    no_rescale:
+    # type=bool|default=False: do not rescale so that global mean of output == input global mean
+    mask:
+    # type=file|default=<undefined>: brainmask volume. Input can be any format accepted by mri_convert.
+    transform:
+    # type=file|default=<undefined>: tal.xfm. Use mri_make_uchar instead of conforming
+    stop:
+    # type=float|default=0.0: Convergence threshold below which iteration stops (suggest 0.01 to 0.0001)
+    shrink:
+    # type=int|default=0: Shrink parameter for finer sampling (default is 4)
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input volume. Input can be any format accepted by mri_convert.
+    iterations: '6'
+    # type=int|default=4: Number of iterations to run nu_correct. Default is 4. This is the number of times that nu_correct is repeated (ie, using the output from the previous run as the input for the next). This is different than the -iterations option to nu_correct.
+    protocol_iterations: '1000'
+    # type=int|default=0: Passes Np as argument of the -iterations flag of nu_correct. This is different than the --n flag above. Default is not to pass nu_correct the -iterations flag.
+    distance: '50'
+    # type=int|default=0: N3 -distance option
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: mri_nu_correct.mni --distance 50 --i norm.mgz --n 6 --o norm_output.mgz --proto-iters 1000
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: input volume. Input can be any format accepted by mri_convert.
+    iterations: '6'
+    # type=int|default=4: Number of iterations to run nu_correct. Default is 4. This is the number of times that nu_correct is repeated (ie, using the output from the previous run as the input for the next). This is different than the -iterations option to nu_correct.
+    protocol_iterations: '1000'
+    # type=int|default=0: Passes Np as argument of the -iterations flag of nu_correct. This is different than the --n flag above. Default is not to pass nu_correct the -iterations flag.
+    distance: '50'
+    # type=int|default=0: N3 -distance option
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/mni_bias_correction_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/mni_bias_correction_callables.py
new file mode 100644
index 00000000..536a2bea
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/mni_bias_correction_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in MNIBiasCorrection.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/mp_rto_mni305.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/mp_rto_mni305.yaml
new file mode 100644
index 00000000..a633c468
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/mp_rto_mni305.yaml
@@ -0,0 +1,145 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.registration.MPRtoMNI305' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     For complete details, see FreeSurfer documentation
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces.freesurfer import MPRtoMNI305, Info
+#     >>> mprtomni305 = MPRtoMNI305()
+#     >>> mprtomni305.inputs.target = 'structural.nii'
+#     >>> mprtomni305.inputs.reference_dir = '.' # doctest: +SKIP
+#     >>> mprtomni305.cmdline # doctest: +SKIP
+#     'mpr2mni305 output'
+#     >>> mprtomni305.inputs.out_file = 'struct_out' # doctest: +SKIP
+#     >>> mprtomni305.cmdline # doctest: +SKIP
+#     'mpr2mni305 struct_out' # doctest: +SKIP
+#     >>> mprtomni305.inputs.environ['REFDIR'] == os.path.join(Info.home(), 'average') # doctest: +SKIP
+#     True
+#     >>> mprtomni305.inputs.environ['MPR2MNI305_TARGET'] # doctest: +SKIP
+#     'structural'
+#     >>> mprtomni305.run() # doctest: +SKIP
+# 
+#     
+task_name: MPRtoMNI305
+nipype_name: MPRtoMNI305
+nipype_module: nipype.interfaces.freesurfer.registration
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: the input file prefix for MPRtoMNI305
+    reference_dir: generic/directory
+    # type=directory|default='': TODO
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: The output file '<in_file>_to_<target>_t4_vox2vox.txt'
+    log_file: generic/file
+    # type=file: The output log
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    reference_dir:
+    # type=directory|default='': TODO
+    target:
+    # type=string|default='': input atlas file
+    in_file:
+    # type=file|default=<undefined>: the input file prefix for MPRtoMNI305
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    target: '"structural.nii"'
+    # type=string|default='': input atlas file
+    reference_dir: '"." # doctest: +SKIP'
+    # type=directory|default='': TODO
+    out_file: '"struct_out" # doctest: +SKIP'
+    # type=file: The output file '<in_file>_to_<target>_t4_vox2vox.txt'
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: structural
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    target: '"structural.nii"'
+    # type=string|default='': input atlas file
+    reference_dir: '"." # doctest: +SKIP'
+    # type=directory|default='': TODO
+    out_file: '"struct_out" # doctest: +SKIP'
+    # type=file: The output file '<in_file>_to_<target>_t4_vox2vox.txt'
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/mp_rto_mni305_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/mp_rto_mni305_callables.py
new file mode 100644
index 00000000..c172ac42
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/mp_rto_mni305_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in MPRtoMNI305.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/mr_is_ca_label.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/mr_is_ca_label.yaml
new file mode 100644
index 00000000..049c71eb
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/mr_is_ca_label.yaml
@@ -0,0 +1,198 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.preprocess.MRIsCALabel' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     For a single subject, produces an annotation file, in which each
+#     cortical surface vertex is assigned a neuroanatomical label.This
+#     automatic procedure employs data from a previously-prepared atlas
+#     file. An atlas file is created from a training set, capturing region
+#     data manually drawn by neuroanatomists combined with statistics on
+#     variability correlated to geometric information derived from the
+#     cortical model (sulcus and curvature). Besides the atlases provided
+#     with FreeSurfer, new ones can be prepared using mris_ca_train).
+# 
+#     Examples
+#     ========
+# 
+#     >>> from nipype.interfaces import freesurfer
+#     >>> ca_label = freesurfer.MRIsCALabel()
+#     >>> ca_label.inputs.subject_id = "test"
+#     >>> ca_label.inputs.hemisphere = "lh"
+#     >>> ca_label.inputs.canonsurf = "lh.pial"
+#     >>> ca_label.inputs.curv = "lh.pial"
+#     >>> ca_label.inputs.sulc = "lh.pial"
+#     >>> ca_label.inputs.classifier = "im1.nii" # in pracice, use .gcs extension
+#     >>> ca_label.inputs.smoothwm = "lh.pial"
+#     >>> ca_label.cmdline
+#     'mris_ca_label test lh lh.pial im1.nii lh.aparc.annot'
+#     
+task_name: MRIsCALabel
+nipype_name: MRIsCALabel
+nipype_module: nipype.interfaces.freesurfer.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    canonsurf: medimage-freesurfer/pial
+    # type=file|default=<undefined>: Input canonical surface file
+    classifier: medimage/nifti1
+    # type=file|default=<undefined>: Classifier array input file
+    smoothwm: medimage-freesurfer/pial
+    # type=file|default=<undefined>: implicit input {hemisphere}.smoothwm
+    curv: medimage-freesurfer/pial
+    # type=file|default=<undefined>: implicit input {hemisphere}.curv
+    sulc: medimage-freesurfer/pial
+    # type=file|default=<undefined>: implicit input {hemisphere}.sulc
+    out_file: generic/file
+    # type=file: Output volume from MRIsCALabel
+    # type=file|default=<undefined>: Annotated surface output file
+    label: generic/file
+    # type=file|default=<undefined>: Undocumented flag. Autorecon3 uses ../label/{hemisphere}.cortex.label as input file
+    aseg: generic/file
+    # type=file|default=<undefined>: Undocumented flag. Autorecon3 uses ../mri/aseg.presurf.mgz as input file
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: Output volume from MRIsCALabel
+    # type=file|default=<undefined>: Annotated surface output file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    subject_id:
+    # type=string|default='subject_id': Subject name or ID
+    hemisphere:
+    # type=enum|default='lh'|allowed['lh','rh']: Hemisphere ('lh' or 'rh')
+    canonsurf:
+    # type=file|default=<undefined>: Input canonical surface file
+    classifier:
+    # type=file|default=<undefined>: Classifier array input file
+    smoothwm:
+    # type=file|default=<undefined>: implicit input {hemisphere}.smoothwm
+    curv:
+    # type=file|default=<undefined>: implicit input {hemisphere}.curv
+    sulc:
+    # type=file|default=<undefined>: implicit input {hemisphere}.sulc
+    out_file:
+    # type=file: Output volume from MRIsCALabel
+    # type=file|default=<undefined>: Annotated surface output file
+    label:
+    # type=file|default=<undefined>: Undocumented flag. Autorecon3 uses ../label/{hemisphere}.cortex.label as input file
+    aseg:
+    # type=file|default=<undefined>: Undocumented flag. Autorecon3 uses ../mri/aseg.presurf.mgz as input file
+    seed:
+    # type=int|default=0: 
+    copy_inputs:
+    # type=bool|default=False: Copies implicit inputs to node directory and creates a temp subjects_directory. Use this when running as a node
+    num_threads:
+    # type=int|default=0: allows for specifying more threads
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    subject_id: '"test"'
+    # type=string|default='subject_id': Subject name or ID
+    hemisphere: '"lh"'
+    # type=enum|default='lh'|allowed['lh','rh']: Hemisphere ('lh' or 'rh')
+    canonsurf:
+    # type=file|default=<undefined>: Input canonical surface file
+    curv:
+    # type=file|default=<undefined>: implicit input {hemisphere}.curv
+    sulc:
+    # type=file|default=<undefined>: implicit input {hemisphere}.sulc
+    classifier:
+    # type=file|default=<undefined>: Classifier array input file
+    smoothwm:
+    # type=file|default=<undefined>: implicit input {hemisphere}.smoothwm
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: mris_ca_label test lh lh.pial im1.nii lh.aparc.annot
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    subject_id: '"test"'
+    # type=string|default='subject_id': Subject name or ID
+    hemisphere: '"lh"'
+    # type=enum|default='lh'|allowed['lh','rh']: Hemisphere ('lh' or 'rh')
+    canonsurf:
+    # type=file|default=<undefined>: Input canonical surface file
+    curv:
+    # type=file|default=<undefined>: implicit input {hemisphere}.curv
+    sulc:
+    # type=file|default=<undefined>: implicit input {hemisphere}.sulc
+    classifier:
+    # type=file|default=<undefined>: Classifier array input file
+    smoothwm:
+    # type=file|default=<undefined>: implicit input {hemisphere}.smoothwm
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/mr_is_ca_label_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/mr_is_ca_label_callables.py
new file mode 100644
index 00000000..9e48dc34
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/mr_is_ca_label_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in MRIsCALabel.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/mr_is_calc.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/mr_is_calc.yaml
new file mode 100644
index 00000000..b8830ad1
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/mr_is_calc.yaml
@@ -0,0 +1,162 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.utils.MRIsCalc' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     'mris_calc' is a simple calculator that operates on FreeSurfer
+#     curvatures and volumes. In most cases, the calculator functions with
+#     three arguments: two inputs and an <ACTION> linking them. Some
+#     actions, however, operate with only one input <file1>. In all cases,
+#     the first input <file1> is the name of a FreeSurfer curvature overlay
+#     (e.g. rh.curv) or volume file (e.g. orig.mgz). For two inputs, the
+#     calculator first assumes that the second input is a file. If, however,
+#     this second input file doesn't exist, the calculator assumes it refers
+#     to a float number, which is then processed according to <ACTION>.Note:
+#     <file1> and <file2> should typically be generated on the same subject.
+# 
+#     Examples
+#     ========
+#     >>> from nipype.interfaces.freesurfer import MRIsCalc
+#     >>> example = MRIsCalc()
+#     >>> example.inputs.in_file1 = 'lh.area' # doctest: +SKIP
+#     >>> example.inputs.in_file2 = 'lh.area.pial' # doctest: +SKIP
+#     >>> example.inputs.action = 'add'
+#     >>> example.inputs.out_file = 'area.mid'
+#     >>> example.cmdline # doctest: +SKIP
+#     'mris_calc -o lh.area.mid lh.area add lh.area.pial'
+#     
+task_name: MRIsCalc
+nipype_name: MRIsCalc
+nipype_module: nipype.interfaces.freesurfer.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file1: medimage-freesurfer/area
+    # type=file|default=<undefined>: Input file 1
+    out_file: audio/sp-midi
+    # type=file: Output file after calculation
+    # type=file|default=<undefined>: Output file after calculation
+    in_file2: medimage-freesurfer/pial
+    # type=file|default=<undefined>: Input file 2
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: audio/sp-midi
+    # type=file: Output file after calculation
+    # type=file|default=<undefined>: Output file after calculation
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file1:
+    # type=file|default=<undefined>: Input file 1
+    action:
+    # type=string|default='': Action to perform on input file(s)
+    out_file:
+    # type=file: Output file after calculation
+    # type=file|default=<undefined>: Output file after calculation
+    in_file2:
+    # type=file|default=<undefined>: Input file 2
+    in_float:
+    # type=float|default=0.0: Input float
+    in_int:
+    # type=int|default=0: Input integer
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file1:
+    # type=file|default=<undefined>: Input file 1
+    in_file2:
+    # type=file|default=<undefined>: Input file 2
+    action: '"add"'
+    # type=string|default='': Action to perform on input file(s)
+    out_file:
+    # type=file: Output file after calculation
+    # type=file|default=<undefined>: Output file after calculation
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: mris_calc -o lh.area.mid lh.area add lh.area.pial
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file1:
+    # type=file|default=<undefined>: Input file 1
+    in_file2:
+    # type=file|default=<undefined>: Input file 2
+    action: '"add"'
+    # type=string|default='': Action to perform on input file(s)
+    out_file:
+    # type=file: Output file after calculation
+    # type=file|default=<undefined>: Output file after calculation
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/mr_is_calc_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/mr_is_calc_callables.py
new file mode 100644
index 00000000..c062d99b
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/mr_is_calc_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in MRIsCalc.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/mr_is_combine.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/mr_is_combine.yaml
new file mode 100644
index 00000000..4cd7516c
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/mr_is_combine.yaml
@@ -0,0 +1,146 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.utils.MRIsCombine' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Uses Freesurfer's ``mris_convert`` to combine two surface files into one.
+# 
+#     For complete details, see the `mris_convert Documentation.
+#     <https://surfer.nmr.mgh.harvard.edu/fswiki/mris_convert>`_
+# 
+#     If given an ``out_file`` that does not begin with ``'lh.'`` or ``'rh.'``,
+#     ``mris_convert`` will prepend ``'lh.'`` to the file name.
+#     To avoid this behavior, consider setting ``out_file = './<filename>'``, or
+#     leaving out_file blank.
+# 
+#     In a Node/Workflow, ``out_file`` is interpreted literally.
+# 
+#     Example
+#     -------
+# 
+#     >>> import nipype.interfaces.freesurfer as fs
+#     >>> mris = fs.MRIsCombine()
+#     >>> mris.inputs.in_files = ['lh.pial', 'rh.pial']
+#     >>> mris.inputs.out_file = 'bh.pial'
+#     >>> mris.cmdline
+#     'mris_convert --combinesurfs lh.pial rh.pial bh.pial'
+#     >>> mris.run()  # doctest: +SKIP
+#     
+task_name: MRIsCombine
+nipype_name: MRIsCombine
+nipype_module: nipype.interfaces.freesurfer.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_files: medimage-freesurfer/pial+list-of
+    # type=list|default=[]: Two surfaces to be combined.
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: medimage-freesurfer/pial
+    # type=file: Output filename. Combined surfaces from in_files.
+    # type=file|default=<undefined>: Output filename. Combined surfaces from in_files.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: '"bh.pial"'
+    # type=file: Output filename. Combined surfaces from in_files.
+    # type=file|default=<undefined>: Output filename. Combined surfaces from in_files.
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_files:
+    # type=list|default=[]: Two surfaces to be combined.
+    out_file:
+    # type=file: Output filename. Combined surfaces from in_files.
+    # type=file|default=<undefined>: Output filename. Combined surfaces from in_files.
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_files:
+    # type=list|default=[]: Two surfaces to be combined.
+    out_file: '"bh.pial"'
+    # type=file: Output filename. Combined surfaces from in_files.
+    # type=file|default=<undefined>: Output filename. Combined surfaces from in_files.
+  imports: &id001
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  - module: nipype.interfaces.freesurfer as fs
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: mris_convert --combinesurfs lh.pial rh.pial bh.pial
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_files:
+    # type=list|default=[]: Two surfaces to be combined.
+    out_file: '"bh.pial"'
+    # type=file: Output filename. Combined surfaces from in_files.
+    # type=file|default=<undefined>: Output filename. Combined surfaces from in_files.
+  imports: *id001
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/mr_is_combine_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/mr_is_combine_callables.py
new file mode 100644
index 00000000..67ed156f
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/mr_is_combine_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in MRIsCombine.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/mr_is_convert.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/mr_is_convert.yaml
new file mode 100644
index 00000000..56fbad14
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/mr_is_convert.yaml
@@ -0,0 +1,139 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.utils.MRIsConvert' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Uses Freesurfer's mris_convert to convert surface files to various formats
+# 
+#     Example
+#     -------
+# 
+#     >>> import nipype.interfaces.freesurfer as fs
+#     >>> mris = fs.MRIsConvert()
+#     >>> mris.inputs.in_file = 'lh.pial'
+#     >>> mris.inputs.out_datatype = 'gii'
+#     >>> mris.run() # doctest: +SKIP
+#     
+task_name: MRIsConvert
+nipype_name: MRIsConvert
+nipype_module: nipype.interfaces.freesurfer.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    annot_file: generic/file
+    # type=file|default=<undefined>: input is annotation or gifti label data
+    parcstats_file: generic/file
+    # type=file|default=<undefined>: infile is name of text file containing label/val pairs
+    label_file: generic/file
+    # type=file|default=<undefined>: infile is .label file, label is name of this label
+    scalarcurv_file: generic/file
+    # type=file|default=<undefined>: input is scalar curv overlay file (must still specify surface)
+    functional_file: generic/file
+    # type=file|default=<undefined>: input is functional time-series or other multi-frame data (must specify surface)
+    labelstats_outfile: generic/file
+    # type=file|default=<undefined>: outfile is name of gifti file to which label stats will be written
+    in_file: generic/file
+    # type=file|default=<undefined>: File to read/convert
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    converted: generic/file
+    # type=file: converted output surface
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: out_file
+    # type=file|default=<undefined>: output filename or True to generate one
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    annot_file:
+    # type=file|default=<undefined>: input is annotation or gifti label data
+    parcstats_file:
+    # type=file|default=<undefined>: infile is name of text file containing label/val pairs
+    label_file:
+    # type=file|default=<undefined>: infile is .label file, label is name of this label
+    scalarcurv_file:
+    # type=file|default=<undefined>: input is scalar curv overlay file (must still specify surface)
+    functional_file:
+    # type=file|default=<undefined>: input is functional time-series or other multi-frame data (must specify surface)
+    labelstats_outfile:
+    # type=file|default=<undefined>: outfile is name of gifti file to which label stats will be written
+    patch:
+    # type=bool|default=False: input is a patch, not a full surface
+    rescale:
+    # type=bool|default=False: rescale vertex xyz so total area is same as group average
+    normal:
+    # type=bool|default=False: output is an ascii file where vertex data
+    xyz_ascii:
+    # type=bool|default=False: Print only surface xyz to ascii file
+    vertex:
+    # type=bool|default=False: Writes out neighbors of a vertex in each row
+    scale:
+    # type=float|default=0.0: scale vertex xyz by scale
+    dataarray_num:
+    # type=int|default=0: if input is gifti, 'num' specifies which data array to use
+    talairachxfm_subjid:
+    # type=string|default='': apply talairach xfm of subject to vertex xyz
+    origname:
+    # type=string|default='': read orig positions
+    in_file:
+    # type=file|default=<undefined>: File to read/convert
+    out_file:
+    # type=file|default=<undefined>: output filename or True to generate one
+    out_datatype:
+    # type=enum|default='asc'|allowed['asc','gii','ico','mgh','mgz','stl','tri','vtk']: These file formats are supported:  ASCII:       .ascICO: .ico, .tri GEO: .geo STL: .stl VTK: .vtk GIFTI: .gii MGH surface-encoded 'volume': .mgh, .mgz
+    to_scanner:
+    # type=bool|default=False: convert coordinates from native FS (tkr) coords to scanner coords
+    to_tkr:
+    # type=bool|default=False: convert coordinates from scanner coords to native FS (tkr) coords
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/mr_is_convert_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/mr_is_convert_callables.py
new file mode 100644
index 00000000..9d8dbbe5
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/mr_is_convert_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in MRIsConvert.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/mr_is_expand.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/mr_is_expand.yaml
new file mode 100644
index 00000000..49d36df2
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/mr_is_expand.yaml
@@ -0,0 +1,157 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.utils.MRIsExpand' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Expands a surface (typically ?h.white) outwards while maintaining
+#     smoothness and self-intersection constraints.
+# 
+#     Examples
+#     ========
+#     >>> from nipype.interfaces.freesurfer import MRIsExpand
+#     >>> mris_expand = MRIsExpand(thickness=True, distance=0.5)
+#     >>> mris_expand.inputs.in_file = 'lh.white'
+#     >>> mris_expand.cmdline
+#     'mris_expand -thickness lh.white 0.5 expanded'
+#     >>> mris_expand.inputs.out_name = 'graymid'
+#     >>> mris_expand.cmdline
+#     'mris_expand -thickness lh.white 0.5 graymid'
+#     
+task_name: MRIsExpand
+nipype_name: MRIsExpand
+nipype_module: nipype.interfaces.freesurfer.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage-freesurfer/white
+    # type=file|default=<undefined>: Surface to expand
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: Output surface file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: Surface to expand
+    distance:
+    # type=float|default=0.0: Distance in mm or fraction of cortical thickness
+    out_name:
+    # type=str|default='expanded': Output surface file. If no path, uses directory of ``in_file``. If no path AND missing "lh." or "rh.", derive from ``in_file``
+    thickness:
+    # type=bool|default=False: Expand by fraction of cortical thickness, not mm
+    thickness_name:
+    # type=str|default='': Name of thickness file (implicit: "thickness") If no path, uses directory of ``in_file`` If no path AND missing "lh." or "rh.", derive from `in_file`
+    pial:
+    # type=str|default='': Name of pial file (implicit: "pial") If no path, uses directory of ``in_file`` If no path AND missing "lh." or "rh.", derive from ``in_file``
+    sphere:
+    # type=str|default='sphere': WARNING: Do not change this trait
+    spring:
+    # type=float|default=0.0: Spring term (implicit: 0.05)
+    dt:
+    # type=float|default=0.0: dt (implicit: 0.25)
+    write_iterations:
+    # type=int|default=0: Write snapshots of expansion every N iterations
+    smooth_averages:
+    # type=int|default=0: Smooth surface with N iterations after expansion
+    nsurfaces:
+    # type=int|default=0: Number of surfacces to write during expansion
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: Surface to expand
+    out_name: '"graymid"'
+    # type=str|default='expanded': Output surface file. If no path, uses directory of ``in_file``. If no path AND missing "lh." or "rh.", derive from ``in_file``
+    thickness: 'True'
+    # type=bool|default=False: Expand by fraction of cortical thickness, not mm
+    distance: '0.5'
+    # type=float|default=0.0: Distance in mm or fraction of cortical thickness
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: mris_expand -thickness lh.white 0.5 graymid
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: Surface to expand
+    out_name: '"graymid"'
+    # type=str|default='expanded': Output surface file. If no path, uses directory of ``in_file``. If no path AND missing "lh." or "rh.", derive from ``in_file``
+    thickness: 'True'
+    # type=bool|default=False: Expand by fraction of cortical thickness, not mm
+    distance: '0.5'
+    # type=float|default=0.0: Distance in mm or fraction of cortical thickness
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/mr_is_expand_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/mr_is_expand_callables.py
new file mode 100644
index 00000000..82577871
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/mr_is_expand_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in MRIsExpand.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/mr_is_inflate.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/mr_is_inflate.yaml
new file mode 100644
index 00000000..6f9e737c
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/mr_is_inflate.yaml
@@ -0,0 +1,142 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.utils.MRIsInflate' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     This program will inflate a cortical surface.
+# 
+#     Examples
+#     ========
+#     >>> from nipype.interfaces.freesurfer import MRIsInflate
+#     >>> inflate = MRIsInflate()
+#     >>> inflate.inputs.in_file = 'lh.pial'
+#     >>> inflate.inputs.no_save_sulc = True
+#     >>> inflate.cmdline # doctest: +SKIP
+#     'mris_inflate -no-save-sulc lh.pial lh.inflated'
+#     
+task_name: MRIsInflate
+nipype_name: MRIsInflate
+nipype_module: nipype.interfaces.freesurfer.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage-freesurfer/pial
+    # type=file|default=<undefined>: Input file for MRIsInflate
+    out_file: generic/file
+    # type=file: Output file for MRIsInflate
+    # type=file|default=<undefined>: Output file for MRIsInflate
+    out_sulc: generic/file
+    # type=file: Output sulc file
+    # type=file|default=<undefined>: Output sulc file
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: Output file for MRIsInflate
+    # type=file|default=<undefined>: Output file for MRIsInflate
+    out_sulc: generic/file
+    # type=file: Output sulc file
+    # type=file|default=<undefined>: Output sulc file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: Input file for MRIsInflate
+    out_file:
+    # type=file: Output file for MRIsInflate
+    # type=file|default=<undefined>: Output file for MRIsInflate
+    out_sulc:
+    # type=file: Output sulc file
+    # type=file|default=<undefined>: Output sulc file
+    no_save_sulc:
+    # type=bool|default=False: Do not save sulc file as output
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: Input file for MRIsInflate
+    no_save_sulc: 'True'
+    # type=bool|default=False: Do not save sulc file as output
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: mris_inflate -no-save-sulc lh.pial lh.inflated
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: Input file for MRIsInflate
+    no_save_sulc: 'True'
+    # type=bool|default=False: Do not save sulc file as output
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/mr_is_inflate_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/mr_is_inflate_callables.py
new file mode 100644
index 00000000..def395d3
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/mr_is_inflate_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in MRIsInflate.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/mri_convert.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/mri_convert.yaml
new file mode 100644
index 00000000..b49e039d
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/mri_convert.yaml
@@ -0,0 +1,316 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.preprocess.MRIConvert' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# use fs mri_convert to manipulate files
+# 
+#     .. note::
+#        Adds niigz as an output type option
+# 
+#     Examples
+#     --------
+# 
+#     >>> mc = MRIConvert()
+#     >>> mc.inputs.in_file = 'structural.nii'
+#     >>> mc.inputs.out_file = 'outfile.mgz'
+#     >>> mc.inputs.out_type = 'mgz'
+#     >>> mc.cmdline
+#     'mri_convert --out_type mgz --input_volume structural.nii --output_volume outfile.mgz'
+# 
+#     
+task_name: MRIConvert
+nipype_name: MRIConvert
+nipype_module: nipype.interfaces.freesurfer.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    autoalign_matrix: generic/file
+    # type=file|default=<undefined>: text file with autoalign matrix
+    apply_transform: generic/file
+    # type=file|default=<undefined>: apply xfm file
+    apply_inv_transform: generic/file
+    # type=file|default=<undefined>: apply inverse transformation xfm file
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: File to read/convert
+    reslice_like: generic/file
+    # type=file|default=<undefined>: reslice output to match file
+    in_like: generic/file
+    # type=file|default=<undefined>: input looks like
+    color_file: generic/file
+    # type=file|default=<undefined>: color file
+    status_file: generic/file
+    # type=file|default=<undefined>: status file for DICOM conversion
+    sdcm_list: generic/file
+    # type=file|default=<undefined>: list of DICOM files for conversion
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: '"outfile.mgz"'
+    # type=outputmultiobject: converted output file
+    # type=file|default=<undefined>: output filename or True to generate one
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    read_only:
+    # type=bool|default=False: read the input volume
+    no_write:
+    # type=bool|default=False: do not write output
+    in_info:
+    # type=bool|default=False: display input info
+    out_info:
+    # type=bool|default=False: display output info
+    in_stats:
+    # type=bool|default=False: display input stats
+    out_stats:
+    # type=bool|default=False: display output stats
+    in_matrix:
+    # type=bool|default=False: display input matrix
+    out_matrix:
+    # type=bool|default=False: display output matrix
+    in_i_size:
+    # type=int|default=0: input i size
+    in_j_size:
+    # type=int|default=0: input j size
+    in_k_size:
+    # type=int|default=0: input k size
+    force_ras:
+    # type=bool|default=False: use default when orientation info absent
+    in_i_dir:
+    # type=tuple|default=(0.0, 0.0, 0.0): <R direction> <A direction> <S direction>
+    in_j_dir:
+    # type=tuple|default=(0.0, 0.0, 0.0): <R direction> <A direction> <S direction>
+    in_k_dir:
+    # type=tuple|default=(0.0, 0.0, 0.0): <R direction> <A direction> <S direction>
+    in_orientation:
+    # type=enum|default='LAI'|allowed['AIL','AIR','ALI','ALS','ARI','ARS','ASL','ASR','IAL','IAR','ILA','ILP','IPL','IPR','IRA','IRP','LAI','LAS','LIA','LIP','LPI','LPS','LSA','LSP','PIL','PIR','PLI','PLS','PRI','PRS','PSL','PSR','RAI','RAS','RIA','RIP','RPI','RPS','RSA','RSP','SAL','SAR','SLA','SLP','SPL','SPR','SRA','SRP']: specify the input orientation
+    in_center:
+    # type=list|default=[]: <R coordinate> <A coordinate> <S coordinate>
+    sphinx:
+    # type=bool|default=False: change orientation info to sphinx
+    out_i_count:
+    # type=int|default=0: some count ?? in i direction
+    out_j_count:
+    # type=int|default=0: some count ?? in j direction
+    out_k_count:
+    # type=int|default=0: some count ?? in k direction
+    vox_size:
+    # type=tuple|default=(0.0, 0.0, 0.0): <size_x> <size_y> <size_z> specify the size (mm) - useful for upsampling or downsampling
+    out_i_size:
+    # type=int|default=0: output i size
+    out_j_size:
+    # type=int|default=0: output j size
+    out_k_size:
+    # type=int|default=0: output k size
+    out_i_dir:
+    # type=tuple|default=(0.0, 0.0, 0.0): <R direction> <A direction> <S direction>
+    out_j_dir:
+    # type=tuple|default=(0.0, 0.0, 0.0): <R direction> <A direction> <S direction>
+    out_k_dir:
+    # type=tuple|default=(0.0, 0.0, 0.0): <R direction> <A direction> <S direction>
+    out_orientation:
+    # type=enum|default='LAI'|allowed['AIL','AIR','ALI','ALS','ARI','ARS','ASL','ASR','IAL','IAR','ILA','ILP','IPL','IPR','IRA','IRP','LAI','LAS','LIA','LIP','LPI','LPS','LSA','LSP','PIL','PIR','PLI','PLS','PRI','PRS','PSL','PSR','RAI','RAS','RIA','RIP','RPI','RPS','RSA','RSP','SAL','SAR','SLA','SLP','SPL','SPR','SRA','SRP']: specify the output orientation
+    out_center:
+    # type=tuple|default=(0.0, 0.0, 0.0): <R coordinate> <A coordinate> <S coordinate>
+    out_datatype:
+    # type=enum|default='uchar'|allowed['float','int','short','uchar']: output data type <uchar|short|int|float>
+    resample_type:
+    # type=enum|default='interpolate'|allowed['cubic','interpolate','nearest','sinc','weighted']: <interpolate|weighted|nearest|sinc|cubic> (default is interpolate)
+    no_scale:
+    # type=bool|default=False: dont rescale values for COR
+    no_change:
+    # type=bool|default=False: don't change type of input to that of template
+    tr:
+    # type=int|default=0: TR in msec
+    te:
+    # type=int|default=0: TE in msec
+    ti:
+    # type=int|default=0: TI in msec (note upper case flag)
+    autoalign_matrix:
+    # type=file|default=<undefined>: text file with autoalign matrix
+    unwarp_gradient:
+    # type=bool|default=False: unwarp gradient nonlinearity
+    apply_transform:
+    # type=file|default=<undefined>: apply xfm file
+    apply_inv_transform:
+    # type=file|default=<undefined>: apply inverse transformation xfm file
+    devolve_transform:
+    # type=str|default='': subject id
+    crop_center:
+    # type=tuple|default=(0, 0, 0): <x> <y> <z> crop to 256 around center (x, y, z)
+    crop_size:
+    # type=tuple|default=(0, 0, 0): <dx> <dy> <dz> crop to size <dx, dy, dz>
+    cut_ends:
+    # type=int|default=0: remove ncut slices from the ends
+    slice_crop:
+    # type=tuple|default=(0, 0): s_start s_end : keep slices s_start to s_end
+    slice_reverse:
+    # type=bool|default=False: reverse order of slices, update vox2ras
+    slice_bias:
+    # type=float|default=0.0: apply half-cosine bias field
+    fwhm:
+    # type=float|default=0.0: smooth input volume by fwhm mm
+    in_type:
+    # type=enum|default='cor'|allowed['afni','analyze','analyze4d','bfloat','brik','bshort','cor','dicom','gdf','ge','gelx','lx','mgh','mgz','minc','nifti1','nii','niigz','otl','outline','sdt','siemens','siemens_dicom','spm','ximg']: input file type
+    out_type:
+    # type=enum|default='cor'|allowed['afni','analyze','analyze4d','bfloat','brik','bshort','cor','gdf','mgh','mgz','minc','nifti1','nii','niigz','otl','outline','sdt','spm']: output file type
+    ascii:
+    # type=bool|default=False: save output as ascii col>row>slice>frame
+    reorder:
+    # type=tuple|default=(0, 0, 0): olddim1 olddim2 olddim3
+    invert_contrast:
+    # type=float|default=0.0: threshold for inversting contrast
+    in_file:
+    # type=file|default=<undefined>: File to read/convert
+    out_file:
+    # type=outputmultiobject: converted output file
+    # type=file|default=<undefined>: output filename or True to generate one
+    conform:
+    # type=bool|default=False: conform to 1mm voxel size in coronal slice direction with 256^3 or more
+    conform_min:
+    # type=bool|default=False: conform to smallest size
+    conform_size:
+    # type=float|default=0.0: conform to size_in_mm
+    cw256:
+    # type=bool|default=False: confrom to dimensions of 256^3
+    parse_only:
+    # type=bool|default=False: parse input only
+    subject_name:
+    # type=str|default='': subject name ???
+    reslice_like:
+    # type=file|default=<undefined>: reslice output to match file
+    template_type:
+    # type=enum|default='cor'|allowed['afni','analyze','analyze4d','bfloat','brik','bshort','cor','dicom','gdf','ge','gelx','lx','mgh','mgz','minc','nifti1','nii','niigz','otl','outline','sdt','siemens','siemens_dicom','spm','ximg']: template file type
+    split:
+    # type=bool|default=False: split output frames into separate output files.
+    frame:
+    # type=int|default=0: keep only 0-based frame number
+    midframe:
+    # type=bool|default=False: keep only the middle frame
+    skip_n:
+    # type=int|default=0: skip the first n frames
+    drop_n:
+    # type=int|default=0: drop the last n frames
+    frame_subsample:
+    # type=tuple|default=(0, 0, 0): start delta end : frame subsampling (end = -1 for end)
+    in_scale:
+    # type=float|default=0.0: input intensity scale factor
+    out_scale:
+    # type=float|default=0.0: output intensity scale factor
+    in_like:
+    # type=file|default=<undefined>: input looks like
+    fill_parcellation:
+    # type=bool|default=False: fill parcellation
+    smooth_parcellation:
+    # type=bool|default=False: smooth parcellation
+    zero_outlines:
+    # type=bool|default=False: zero outlines
+    color_file:
+    # type=file|default=<undefined>: color file
+    no_translate:
+    # type=bool|default=False: ???
+    status_file:
+    # type=file|default=<undefined>: status file for DICOM conversion
+    sdcm_list:
+    # type=file|default=<undefined>: list of DICOM files for conversion
+    template_info:
+    # type=bool|default=False: dump info about template
+    crop_gdf:
+    # type=bool|default=False: apply GDF cropping
+    zero_ge_z_offset:
+    # type=bool|default=False: zero ge z offset ???
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: File to read/convert
+    out_file: '"outfile.mgz"'
+    # type=outputmultiobject: converted output file
+    # type=file|default=<undefined>: output filename or True to generate one
+    out_type: '"mgz"'
+    # type=enum|default='cor'|allowed['afni','analyze','analyze4d','bfloat','brik','bshort','cor','gdf','mgh','mgz','minc','nifti1','nii','niigz','otl','outline','sdt','spm']: output file type
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: mri_convert --out_type mgz --input_volume structural.nii --output_volume outfile.mgz
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: File to read/convert
+    out_file: '"outfile.mgz"'
+    # type=outputmultiobject: converted output file
+    # type=file|default=<undefined>: output filename or True to generate one
+    out_type: '"mgz"'
+    # type=enum|default='cor'|allowed['afni','analyze','analyze4d','bfloat','brik','bshort','cor','gdf','mgh','mgz','minc','nifti1','nii','niigz','otl','outline','sdt','spm']: output file type
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/mri_convert_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/mri_convert_callables.py
new file mode 100644
index 00000000..178c87a0
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/mri_convert_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in MRIConvert.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/mri_coreg.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/mri_coreg.yaml
new file mode 100644
index 00000000..ae1fc16d
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/mri_coreg.yaml
@@ -0,0 +1,329 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.registration.MRICoreg' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# This program registers one volume to another
+# 
+#     mri_coreg is a C reimplementation of spm_coreg in FreeSurfer
+# 
+#     Examples
+#     ========
+#     >>> from nipype.interfaces.freesurfer import MRICoreg
+#     >>> coreg = MRICoreg()
+#     >>> coreg.inputs.source_file = 'moving1.nii'
+#     >>> coreg.inputs.reference_file = 'fixed1.nii'
+#     >>> coreg.inputs.subjects_dir = '.'
+#     >>> coreg.cmdline # doctest: +ELLIPSIS
+#     'mri_coreg --lta .../registration.lta --ref fixed1.nii --mov moving1.nii --sd .'
+# 
+#     If passing a subject ID, the reference mask may be disabled:
+# 
+#     >>> coreg = MRICoreg()
+#     >>> coreg.inputs.source_file = 'moving1.nii'
+#     >>> coreg.inputs.subjects_dir = '.'
+#     >>> coreg.inputs.subject_id = 'fsaverage'
+#     >>> coreg.inputs.reference_mask = False
+#     >>> coreg.cmdline # doctest: +ELLIPSIS
+#     'mri_coreg --s fsaverage --no-ref-mask --lta .../registration.lta --mov moving1.nii --sd .'
+# 
+#     Spatial scales may be specified as a list of one or two separations:
+# 
+#     >>> coreg.inputs.sep = [4]
+#     >>> coreg.cmdline # doctest: +ELLIPSIS
+#     'mri_coreg --s fsaverage --no-ref-mask --lta .../registration.lta --sep 4 --mov moving1.nii --sd .'
+# 
+#     >>> coreg.inputs.sep = [4, 5]
+#     >>> coreg.cmdline # doctest: +ELLIPSIS
+#     'mri_coreg --s fsaverage --no-ref-mask --lta .../registration.lta --sep 4 --sep 5 --mov moving1.nii --sd .'
+#     
+task_name: MRICoreg
+nipype_name: MRICoreg
+nipype_module: nipype.interfaces.freesurfer.registration
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    source_file: medimage/nifti1
+    # type=file|default=<undefined>: source file to be registered
+    reference_file: medimage/nifti1
+    # type=file|default=<undefined>: reference (target) file
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: FreeSurfer SUBJECTS_DIR
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_reg_file: generic/file
+    # type=file: output registration file
+    # type=traitcompound|default=None: output registration file (REG format)
+    out_lta_file: generic/file
+    # type=file: output LTA-style registration file
+    # type=traitcompound|default=True: output registration file (LTA format)
+    out_params_file: generic/file
+    # type=file: output parameters file
+    # type=traitcompound|default=None: output parameters file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    source_file:
+    # type=file|default=<undefined>: source file to be registered
+    reference_file:
+    # type=file|default=<undefined>: reference (target) file
+    out_lta_file:
+    # type=file: output LTA-style registration file
+    # type=traitcompound|default=True: output registration file (LTA format)
+    out_reg_file:
+    # type=file: output registration file
+    # type=traitcompound|default=None: output registration file (REG format)
+    out_params_file:
+    # type=file: output parameters file
+    # type=traitcompound|default=None: output parameters file
+    subjects_dir:
+    # type=directory|default=<undefined>: FreeSurfer SUBJECTS_DIR
+    subject_id:
+    # type=str|default='': freesurfer subject ID (implies ``reference_mask == aparc+aseg.mgz`` unless otherwise specified)
+    dof:
+    # type=enum|default=6|allowed[12,6,9]: number of transform degrees of freedom
+    reference_mask:
+    # type=traitcompound|default=None: mask reference volume with given mask, or None if ``False``
+    source_mask:
+    # type=str|default='': mask source file with given mask
+    num_threads:
+    # type=int|default=0: number of OpenMP threads
+    no_coord_dithering:
+    # type=bool|default=False: turn off coordinate dithering
+    no_intensity_dithering:
+    # type=bool|default=False: turn off intensity dithering
+    sep:
+    # type=list|default=[]: set spatial scales, in voxels (default [2, 4])
+    initial_translation:
+    # type=tuple|default=(0.0, 0.0, 0.0): initial translation in mm (implies no_cras0)
+    initial_rotation:
+    # type=tuple|default=(0.0, 0.0, 0.0): initial rotation in degrees
+    initial_scale:
+    # type=tuple|default=(0.0, 0.0, 0.0): initial scale
+    initial_shear:
+    # type=tuple|default=(0.0, 0.0, 0.0): initial shear (Hxy, Hxz, Hyz)
+    no_cras0:
+    # type=bool|default=False: do not set translation parameters to align centers of source and reference files
+    max_iters:
+    # type=range|default=1: maximum iterations (default: 4)
+    ftol:
+    # type=float|default=0.0: floating-point tolerance (default=1e-7)
+    linmintol:
+    # type=float|default=0.0: 
+    saturation_threshold:
+    # type=range|default=0.0: saturation threshold (default=9.999)
+    conform_reference:
+    # type=bool|default=False: conform reference without rescaling
+    no_brute_force:
+    # type=bool|default=False: do not brute force search
+    brute_force_limit:
+    # type=float|default=0.0: constrain brute force search to +/- lim
+    brute_force_samples:
+    # type=int|default=0: number of samples in brute force search
+    no_smooth:
+    # type=bool|default=False: do not apply smoothing to either reference or source file
+    ref_fwhm:
+    # type=float|default=0.0: apply smoothing to reference file
+    source_oob:
+    # type=bool|default=False: count source voxels that are out-of-bounds as 0
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    source_file:
+    # type=file|default=<undefined>: source file to be registered
+    reference_file:
+    # type=file|default=<undefined>: reference (target) file
+    subjects_dir: '"."'
+    # type=directory|default=<undefined>: FreeSurfer SUBJECTS_DIR
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    source_file:
+    # type=file|default=<undefined>: source file to be registered
+    subjects_dir: '"."'
+    # type=directory|default=<undefined>: FreeSurfer SUBJECTS_DIR
+    subject_id: '"fsaverage"'
+    # type=str|default='': freesurfer subject ID (implies ``reference_mask == aparc+aseg.mgz`` unless otherwise specified)
+    reference_mask: 'False'
+    # type=traitcompound|default=None: mask reference volume with given mask, or None if ``False``
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    sep: '[4]'
+    # type=list|default=[]: set spatial scales, in voxels (default [2, 4])
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    sep: '[4, 5]'
+    # type=list|default=[]: set spatial scales, in voxels (default [2, 4])
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: mri_coreg --lta .../registration.lta --ref fixed1.nii --mov moving1.nii --sd .
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    source_file:
+    # type=file|default=<undefined>: source file to be registered
+    reference_file:
+    # type=file|default=<undefined>: reference (target) file
+    subjects_dir: '"."'
+    # type=directory|default=<undefined>: FreeSurfer SUBJECTS_DIR
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: mri_coreg --s fsaverage --no-ref-mask --lta .../registration.lta --mov moving1.nii --sd .
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    source_file:
+    # type=file|default=<undefined>: source file to be registered
+    subjects_dir: '"."'
+    # type=directory|default=<undefined>: FreeSurfer SUBJECTS_DIR
+    subject_id: '"fsaverage"'
+    # type=str|default='': freesurfer subject ID (implies ``reference_mask == aparc+aseg.mgz`` unless otherwise specified)
+    reference_mask: 'False'
+    # type=traitcompound|default=None: mask reference volume with given mask, or None if ``False``
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: mri_coreg --s fsaverage --no-ref-mask --lta .../registration.lta --sep 4 --mov moving1.nii --sd .
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    sep: '[4]'
+    # type=list|default=[]: set spatial scales, in voxels (default [2, 4])
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: mri_coreg --s fsaverage --no-ref-mask --lta .../registration.lta --sep 4 --sep 5 --mov moving1.nii --sd .
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    sep: '[4, 5]'
+    # type=list|default=[]: set spatial scales, in voxels (default [2, 4])
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/mri_coreg_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/mri_coreg_callables.py
new file mode 100644
index 00000000..c570b237
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/mri_coreg_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in MRICoreg.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/mri_fill.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/mri_fill.yaml
new file mode 100644
index 00000000..01404180
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/mri_fill.yaml
@@ -0,0 +1,151 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.utils.MRIFill' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     This program creates hemispheric cutting planes and fills white matter
+#     with specific values for subsequent surface tessellation.
+# 
+#     Examples
+#     ========
+#     >>> from nipype.interfaces.freesurfer import MRIFill
+#     >>> fill = MRIFill()
+#     >>> fill.inputs.in_file = 'wm.mgz' # doctest: +SKIP
+#     >>> fill.inputs.out_file = 'filled.mgz' # doctest: +SKIP
+#     >>> fill.cmdline # doctest: +SKIP
+#     'mri_fill wm.mgz filled.mgz'
+#     
+task_name: MRIFill
+nipype_name: MRIFill
+nipype_module: nipype.interfaces.freesurfer.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/mgh-gz
+    # type=file|default=<undefined>: Input white matter file
+    out_file: medimage/mgh-gz
+    # type=file: Output file from MRIFill
+    # type=file|default=<undefined>: Output filled volume file name for MRIFill
+    segmentation: generic/file
+    # type=file|default=<undefined>: Input segmentation file for MRIFill
+    transform: generic/file
+    # type=file|default=<undefined>: Input transform file for MRIFill
+    log_file: generic/file
+    # type=file: Output log file from MRIFill
+    # type=file|default=<undefined>: Output log file for MRIFill
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: medimage/mgh-gz
+    # type=file: Output file from MRIFill
+    # type=file|default=<undefined>: Output filled volume file name for MRIFill
+    log_file: generic/file
+    # type=file: Output log file from MRIFill
+    # type=file|default=<undefined>: Output log file for MRIFill
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: Input white matter file
+    out_file:
+    # type=file: Output file from MRIFill
+    # type=file|default=<undefined>: Output filled volume file name for MRIFill
+    segmentation:
+    # type=file|default=<undefined>: Input segmentation file for MRIFill
+    transform:
+    # type=file|default=<undefined>: Input transform file for MRIFill
+    log_file:
+    # type=file: Output log file from MRIFill
+    # type=file|default=<undefined>: Output log file for MRIFill
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: Input white matter file
+    out_file:
+    # type=file: Output file from MRIFill
+    # type=file|default=<undefined>: Output filled volume file name for MRIFill
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: mri_fill wm.mgz filled.mgz
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: Input white matter file
+    out_file:
+    # type=file: Output file from MRIFill
+    # type=file|default=<undefined>: Output filled volume file name for MRIFill
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/mri_fill_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/mri_fill_callables.py
new file mode 100644
index 00000000..82ff297c
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/mri_fill_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in MRIFill.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/mri_marching_cubes.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/mri_marching_cubes.yaml
new file mode 100644
index 00000000..bf3254cd
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/mri_marching_cubes.yaml
@@ -0,0 +1,96 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.utils.MRIMarchingCubes' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Uses Freesurfer's mri_mc to create surfaces by tessellating a given input volume
+# 
+#     Example
+#     -------
+# 
+#     >>> import nipype.interfaces.freesurfer as fs
+#     >>> mc = fs.MRIMarchingCubes()
+#     >>> mc.inputs.in_file = 'aseg.mgz'
+#     >>> mc.inputs.label_value = 17
+#     >>> mc.inputs.out_file = 'lh.hippocampus'
+#     >>> mc.run() # doctest: +SKIP
+#     
+task_name: MRIMarchingCubes
+nipype_name: MRIMarchingCubes
+nipype_module: nipype.interfaces.freesurfer.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: Input volume to tessellate voxels from.
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    surface: generic/file
+    # type=file: binary surface of the tessellation 
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: out_file
+    # type=file|default=<undefined>: output filename or True to generate one
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: Input volume to tessellate voxels from.
+    label_value:
+    # type=int|default=0: Label value which to tessellate from the input volume. (integer, if input is "filled.mgz" volume, 127 is rh, 255 is lh)
+    connectivity_value:
+    # type=int|default=1: Alter the marching cubes connectivity: 1=6+,2=18,3=6,4=26 (default=1)
+    out_file:
+    # type=file|default=<undefined>: output filename or True to generate one
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/mri_marching_cubes_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/mri_marching_cubes_callables.py
new file mode 100644
index 00000000..e598b7c1
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/mri_marching_cubes_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in MRIMarchingCubes.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/mri_pretess.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/mri_pretess.yaml
new file mode 100644
index 00000000..9539aa16
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/mri_pretess.yaml
@@ -0,0 +1,155 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.utils.MRIPretess' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Uses Freesurfer's mri_pretess to prepare volumes to be tessellated.
+# 
+#     Changes white matter (WM) segmentation so that the neighbors of all
+#     voxels labeled as WM have a face in common - no edges or corners
+#     allowed.
+# 
+#     Example
+#     -------
+#     >>> import nipype.interfaces.freesurfer as fs
+#     >>> pretess = fs.MRIPretess()
+#     >>> pretess.inputs.in_filled = 'wm.mgz'
+#     >>> pretess.inputs.in_norm = 'norm.mgz'
+#     >>> pretess.inputs.nocorners = True
+#     >>> pretess.cmdline
+#     'mri_pretess -nocorners wm.mgz wm norm.mgz wm_pretesswm.mgz'
+#     >>> pretess.run() # doctest: +SKIP
+# 
+#     
+task_name: MRIPretess
+nipype_name: MRIPretess
+nipype_module: nipype.interfaces.freesurfer.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_filled: medimage/mgh-gz
+    # type=file|default=<undefined>: filled volume, usually wm.mgz
+    in_norm: medimage/mgh-gz
+    # type=file|default=<undefined>: the normalized, brain-extracted T1w image. Usually norm.mgz
+    out_file: generic/file
+    # type=file: output file after mri_pretess
+    # type=file|default=<undefined>: the output file after mri_pretess.
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: output file after mri_pretess
+    # type=file|default=<undefined>: the output file after mri_pretess.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_filled:
+    # type=file|default=<undefined>: filled volume, usually wm.mgz
+    label:
+    # type=traitcompound|default='wm': label to be picked up, can be a Freesurfer's string like 'wm' or a label value (e.g. 127 for rh or 255 for lh)
+    in_norm:
+    # type=file|default=<undefined>: the normalized, brain-extracted T1w image. Usually norm.mgz
+    out_file:
+    # type=file: output file after mri_pretess
+    # type=file|default=<undefined>: the output file after mri_pretess.
+    nocorners:
+    # type=bool|default=False: do not remove corner configurations in addition to edge ones.
+    keep:
+    # type=bool|default=False: keep WM edits
+    test:
+    # type=bool|default=False: adds a voxel that should be removed by mri_pretess. The value of the voxel is set to that of an ON-edited WM, so it should be kept with -keep. The output will NOT be saved.
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_filled:
+    # type=file|default=<undefined>: filled volume, usually wm.mgz
+    in_norm:
+    # type=file|default=<undefined>: the normalized, brain-extracted T1w image. Usually norm.mgz
+    nocorners: 'True'
+    # type=bool|default=False: do not remove corner configurations in addition to edge ones.
+  imports: &id001
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  - module: nipype.interfaces.freesurfer as fs
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: mri_pretess -nocorners wm.mgz wm norm.mgz wm_pretesswm.mgz
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_filled:
+    # type=file|default=<undefined>: filled volume, usually wm.mgz
+    in_norm:
+    # type=file|default=<undefined>: the normalized, brain-extracted T1w image. Usually norm.mgz
+    nocorners: 'True'
+    # type=bool|default=False: do not remove corner configurations in addition to edge ones.
+  imports: *id001
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/mri_pretess_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/mri_pretess_callables.py
new file mode 100644
index 00000000..9b47ea27
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/mri_pretess_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in MRIPretess.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/mri_tessellate.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/mri_tessellate.yaml
new file mode 100644
index 00000000..a2376d9c
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/mri_tessellate.yaml
@@ -0,0 +1,98 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.utils.MRITessellate' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Uses Freesurfer's mri_tessellate to create surfaces by tessellating a given input volume
+# 
+#     Example
+#     -------
+# 
+#     >>> import nipype.interfaces.freesurfer as fs
+#     >>> tess = fs.MRITessellate()
+#     >>> tess.inputs.in_file = 'aseg.mgz'
+#     >>> tess.inputs.label_value = 17
+#     >>> tess.inputs.out_file = 'lh.hippocampus'
+#     >>> tess.run() # doctest: +SKIP
+#     
+task_name: MRITessellate
+nipype_name: MRITessellate
+nipype_module: nipype.interfaces.freesurfer.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: Input volume to tessellate voxels from.
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    surface: generic/file
+    # type=file: binary surface of the tessellation 
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: out_file
+    # type=file|default=<undefined>: output filename or True to generate one
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: Input volume to tessellate voxels from.
+    label_value:
+    # type=int|default=0: Label value which to tessellate from the input volume. (integer, if input is "filled.mgz" volume, 127 is rh, 255 is lh)
+    out_file:
+    # type=file|default=<undefined>: output filename or True to generate one
+    tesselate_all_voxels:
+    # type=bool|default=False: Tessellate the surface of all voxels with different labels
+    use_real_RAS_coordinates:
+    # type=bool|default=False: Saves surface with real RAS coordinates where c_(r,a,s) != 0
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/mri_tessellate_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/mri_tessellate_callables.py
new file mode 100644
index 00000000..f72b6b64
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/mri_tessellate_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in MRITessellate.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/mris_preproc.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/mris_preproc.yaml
new file mode 100644
index 00000000..29cb0a1b
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/mris_preproc.yaml
@@ -0,0 +1,179 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.model.MRISPreproc' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Use FreeSurfer mris_preproc to prepare a group of contrasts for
+#     a second level analysis
+# 
+#     Examples
+#     --------
+#     >>> preproc = MRISPreproc()
+#     >>> preproc.inputs.target = 'fsaverage'
+#     >>> preproc.inputs.hemi = 'lh'
+#     >>> preproc.inputs.vol_measure_file = [('cont1.nii', 'register.dat'),                                            ('cont1a.nii', 'register.dat')]
+#     >>> preproc.inputs.out_file = 'concatenated_file.mgz'
+#     >>> preproc.cmdline
+#     'mris_preproc --hemi lh --out concatenated_file.mgz --target fsaverage --iv cont1.nii register.dat --iv cont1a.nii register.dat'
+# 
+#     
+task_name: MRISPreproc
+nipype_name: MRISPreproc
+nipype_module: nipype.interfaces.freesurfer.model
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    fsgd_file: generic/file
+    # type=file|default=<undefined>: specify subjects using fsgd file
+    subject_file: generic/file
+    # type=file|default=<undefined>: file specifying subjects separated by white space
+    surf_measure_file: generic/file+list-of
+    # type=inputmultiobject|default=[]: file alternative to surfmeas, still requires list of subjects
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: medimage/mgh-gz
+    # type=file: preprocessed output file
+    # type=file|default=<undefined>: output filename
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: '"concatenated_file.mgz"'
+    # type=file: preprocessed output file
+    # type=file|default=<undefined>: output filename
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    out_file:
+    # type=file: preprocessed output file
+    # type=file|default=<undefined>: output filename
+    target:
+    # type=str|default='': target subject name
+    hemi:
+    # type=enum|default='lh'|allowed['lh','rh']: hemisphere for source and target
+    surf_measure:
+    # type=str|default='': Use subject/surf/hemi.surf_measure as input
+    surf_area:
+    # type=str|default='': Extract vertex area from subject/surf/hemi.surfname to use as input.
+    subjects:
+    # type=list|default=[]: subjects from who measures are calculated
+    fsgd_file:
+    # type=file|default=<undefined>: specify subjects using fsgd file
+    subject_file:
+    # type=file|default=<undefined>: file specifying subjects separated by white space
+    surf_measure_file:
+    # type=inputmultiobject|default=[]: file alternative to surfmeas, still requires list of subjects
+    source_format:
+    # type=str|default='': source format
+    surf_dir:
+    # type=str|default='': alternative directory (instead of surf)
+    vol_measure_file:
+    # type=inputmultiobject|default=[]: list of volume measure and reg file tuples
+    proj_frac:
+    # type=float|default=0.0: projection fraction for vol2surf
+    fwhm:
+    # type=float|default=0.0: smooth by fwhm mm on the target surface
+    num_iters:
+    # type=int|default=0: niters : smooth by niters on the target surface
+    fwhm_source:
+    # type=float|default=0.0: smooth by fwhm mm on the source surface
+    num_iters_source:
+    # type=int|default=0: niters : smooth by niters on the source surface
+    smooth_cortex_only:
+    # type=bool|default=False: only smooth cortex (ie, exclude medial wall)
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    target: '"fsaverage"'
+    # type=str|default='': target subject name
+    hemi: '"lh"'
+    # type=enum|default='lh'|allowed['lh','rh']: hemisphere for source and target
+    vol_measure_file: '[("cont1.nii", "register.dat"),                                            ("cont1a.nii", "register.dat")]'
+    # type=inputmultiobject|default=[]: list of volume measure and reg file tuples
+    out_file: '"concatenated_file.mgz"'
+    # type=file: preprocessed output file
+    # type=file|default=<undefined>: output filename
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: mris_preproc --hemi lh --out concatenated_file.mgz --target fsaverage --iv cont1.nii register.dat --iv cont1a.nii register.dat
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    target: '"fsaverage"'
+    # type=str|default='': target subject name
+    hemi: '"lh"'
+    # type=enum|default='lh'|allowed['lh','rh']: hemisphere for source and target
+    vol_measure_file: '[("cont1.nii", "register.dat"),                                            ("cont1a.nii", "register.dat")]'
+    # type=inputmultiobject|default=[]: list of volume measure and reg file tuples
+    out_file: '"concatenated_file.mgz"'
+    # type=file: preprocessed output file
+    # type=file|default=<undefined>: output filename
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/mris_preproc_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/mris_preproc_callables.py
new file mode 100644
index 00000000..8e72acc6
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/mris_preproc_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in MRISPreproc.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/mris_preproc_recon_all.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/mris_preproc_recon_all.yaml
new file mode 100644
index 00000000..5d64bb62
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/mris_preproc_recon_all.yaml
@@ -0,0 +1,194 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.model.MRISPreprocReconAll' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Extends MRISPreproc to allow it to be used in a recon-all workflow
+# 
+#     Examples
+#     --------
+#     >>> preproc = MRISPreprocReconAll()
+#     >>> preproc.inputs.target = 'fsaverage'
+#     >>> preproc.inputs.hemi = 'lh'
+#     >>> preproc.inputs.vol_measure_file = [('cont1.nii', 'register.dat'),                                            ('cont1a.nii', 'register.dat')]
+#     >>> preproc.inputs.out_file = 'concatenated_file.mgz'
+#     >>> preproc.cmdline
+#     'mris_preproc --hemi lh --out concatenated_file.mgz --s subject_id --target fsaverage --iv cont1.nii register.dat --iv cont1a.nii register.dat'
+# 
+#     
+task_name: MRISPreprocReconAll
+nipype_name: MRISPreprocReconAll
+nipype_module: nipype.interfaces.freesurfer.model
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    surf_measure_file: generic/file
+    # type=file|default=<undefined>: file necessary for surfmeas
+    surfreg_files: generic/file+list-of
+    # type=inputmultiobject|default=[]: lh and rh input surface registration files
+    lh_surfreg_target: generic/file
+    # type=file|default=<undefined>: Implicit target surface registration file
+    rh_surfreg_target: generic/file
+    # type=file|default=<undefined>: Implicit target surface registration file
+    fsgd_file: generic/file
+    # type=file|default=<undefined>: specify subjects using fsgd file
+    subject_file: generic/file
+    # type=file|default=<undefined>: file specifying subjects separated by white space
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: medimage/mgh-gz
+    # type=file: preprocessed output file
+    # type=file|default=<undefined>: output filename
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: '"concatenated_file.mgz"'
+    # type=file: preprocessed output file
+    # type=file|default=<undefined>: output filename
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    surf_measure_file:
+    # type=file|default=<undefined>: file necessary for surfmeas
+    surfreg_files:
+    # type=inputmultiobject|default=[]: lh and rh input surface registration files
+    lh_surfreg_target:
+    # type=file|default=<undefined>: Implicit target surface registration file
+    rh_surfreg_target:
+    # type=file|default=<undefined>: Implicit target surface registration file
+    subject_id:
+    # type=string|default='subject_id': subject from whom measures are calculated
+    copy_inputs:
+    # type=bool|default=False: If running as a node, set this to True this will copy some implicit inputs to the node directory.
+    out_file:
+    # type=file: preprocessed output file
+    # type=file|default=<undefined>: output filename
+    target:
+    # type=str|default='': target subject name
+    hemi:
+    # type=enum|default='lh'|allowed['lh','rh']: hemisphere for source and target
+    surf_measure:
+    # type=str|default='': Use subject/surf/hemi.surf_measure as input
+    surf_area:
+    # type=str|default='': Extract vertex area from subject/surf/hemi.surfname to use as input.
+    subjects:
+    # type=list|default=[]: subjects from who measures are calculated
+    fsgd_file:
+    # type=file|default=<undefined>: specify subjects using fsgd file
+    subject_file:
+    # type=file|default=<undefined>: file specifying subjects separated by white space
+    source_format:
+    # type=str|default='': source format
+    surf_dir:
+    # type=str|default='': alternative directory (instead of surf)
+    vol_measure_file:
+    # type=inputmultiobject|default=[]: list of volume measure and reg file tuples
+    proj_frac:
+    # type=float|default=0.0: projection fraction for vol2surf
+    fwhm:
+    # type=float|default=0.0: smooth by fwhm mm on the target surface
+    num_iters:
+    # type=int|default=0: niters : smooth by niters on the target surface
+    fwhm_source:
+    # type=float|default=0.0: smooth by fwhm mm on the source surface
+    num_iters_source:
+    # type=int|default=0: niters : smooth by niters on the source surface
+    smooth_cortex_only:
+    # type=bool|default=False: only smooth cortex (ie, exclude medial wall)
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    target: '"fsaverage"'
+    # type=str|default='': target subject name
+    hemi: '"lh"'
+    # type=enum|default='lh'|allowed['lh','rh']: hemisphere for source and target
+    vol_measure_file: '[("cont1.nii", "register.dat"),                                            ("cont1a.nii", "register.dat")]'
+    # type=inputmultiobject|default=[]: list of volume measure and reg file tuples
+    out_file: '"concatenated_file.mgz"'
+    # type=file: preprocessed output file
+    # type=file|default=<undefined>: output filename
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: mris_preproc --hemi lh --out concatenated_file.mgz --s subject_id --target fsaverage --iv cont1.nii register.dat --iv cont1a.nii register.dat
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    target: '"fsaverage"'
+    # type=str|default='': target subject name
+    hemi: '"lh"'
+    # type=enum|default='lh'|allowed['lh','rh']: hemisphere for source and target
+    vol_measure_file: '[("cont1.nii", "register.dat"),                                            ("cont1a.nii", "register.dat")]'
+    # type=inputmultiobject|default=[]: list of volume measure and reg file tuples
+    out_file: '"concatenated_file.mgz"'
+    # type=file: preprocessed output file
+    # type=file|default=<undefined>: output filename
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/mris_preproc_recon_all_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/mris_preproc_recon_all_callables.py
new file mode 100644
index 00000000..08da982d
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/mris_preproc_recon_all_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in MRISPreprocReconAll.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/mrtm.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/mrtm.yaml
new file mode 100644
index 00000000..d91bf54b
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/mrtm.yaml
@@ -0,0 +1,301 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.petsurfer.MRTM' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Perform MRTM1 kinetic modeling.
+# 
+#     Examples
+#     --------
+#     >>> mrtm = MRTM()
+#     >>> mrtm.inputs.in_file = 'tac.nii'
+#     >>> mrtm.inputs.mrtm1 = ('ref_tac.dat', 'timing.dat')
+#     >>> mrtm.inputs.glm_dir = 'mrtm'
+#     >>> mrtm.cmdline
+#     'mri_glmfit --glmdir mrtm --y tac.nii --mrtm1 ref_tac.dat timing.dat'
+#     
+task_name: MRTM
+nipype_name: MRTM
+nipype_module: nipype.interfaces.freesurfer.petsurfer
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: input 4D file
+    design: generic/file
+    # type=file|default=<undefined>: design matrix file
+    contrast: generic/file+list-of
+    # type=inputmultiobject|default=[]: contrast file
+    per_voxel_reg: generic/file+list-of
+    # type=inputmultiobject|default=[]: per-voxel regressors
+    weighted_ls: generic/file
+    # type=file|default=<undefined>: weighted least squares
+    fixed_fx_var: generic/file
+    # type=file|default=<undefined>: for fixed effects analysis
+    fixed_fx_dof_file: generic/file
+    # type=file|default=<undefined>: text file with dof for fixed effects analysis
+    weight_file: generic/file
+    # type=file|default=<undefined>: weight for each input at each voxel
+    mask_file: generic/file
+    # type=file: map of the mask used in the analysis
+    # type=file|default=<undefined>: binary mask
+    label_file: generic/file
+    # type=file|default=<undefined>: use label as mask, surfaces only
+    sim_done_file: generic/file
+    # type=file|default=<undefined>: create file when simulation finished
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    beta_file: generic/file
+    # type=file: map of regression coefficients
+    error_file: generic/file
+    # type=file: map of residual error
+    error_var_file: generic/file
+    # type=file: map of residual error variance
+    error_stddev_file: generic/file
+    # type=file: map of residual error standard deviation
+    estimate_file: generic/file
+    # type=file: map of the estimated Y values
+    mask_file: generic/file
+    # type=file: map of the mask used in the analysis
+    # type=file|default=<undefined>: binary mask
+    fwhm_file: generic/file
+    # type=file: text file with estimated smoothness
+    dof_file: generic/file
+    # type=file: text file with effective degrees-of-freedom for the analysis
+    spatial_eigenvectors: generic/file
+    # type=file: map of spatial eigenvectors from residual PCA
+    frame_eigenvectors: generic/file
+    # type=file: matrix of frame eigenvectors from residual PCA
+    singular_values: generic/file
+    # type=file: matrix singular values from residual PCA
+    svd_stats_file: generic/file
+    # type=file: text file summarizing the residual PCA
+    k2p_file: generic/file
+    # type=file: estimate of k2p parameter
+    bp_file: generic/file
+    # type=file: Binding potential estimates
+    glm_dir: generic/directory
+    # type=directory: output directory
+    # type=str|default='': save outputs to dir
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    glm_dir: '"mrtm"'
+    # type=directory: output directory
+    # type=str|default='': save outputs to dir
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    mrtm1:
+    # type=tuple|default=(<undefined>, <undefined>): RefTac TimeSec : perform MRTM1 kinetic modeling
+    glm_dir:
+    # type=directory: output directory
+    # type=str|default='': save outputs to dir
+    in_file:
+    # type=file|default=<undefined>: input 4D file
+    fsgd:
+    # type=tuple|default=(<undefined>, 'doss'): freesurfer descriptor file
+    design:
+    # type=file|default=<undefined>: design matrix file
+    contrast:
+    # type=inputmultiobject|default=[]: contrast file
+    one_sample:
+    # type=bool|default=False: construct X and C as a one-sample group mean
+    no_contrast_ok:
+    # type=bool|default=False: do not fail if no contrasts specified
+    per_voxel_reg:
+    # type=inputmultiobject|default=[]: per-voxel regressors
+    self_reg:
+    # type=tuple|default=(0, 0, 0): self-regressor from index col row slice
+    weighted_ls:
+    # type=file|default=<undefined>: weighted least squares
+    fixed_fx_var:
+    # type=file|default=<undefined>: for fixed effects analysis
+    fixed_fx_dof:
+    # type=int|default=0: dof for fixed effects analysis
+    fixed_fx_dof_file:
+    # type=file|default=<undefined>: text file with dof for fixed effects analysis
+    weight_file:
+    # type=file|default=<undefined>: weight for each input at each voxel
+    weight_inv:
+    # type=bool|default=False: invert weights
+    weight_sqrt:
+    # type=bool|default=False: sqrt of weights
+    fwhm:
+    # type=range|default=0.0: smooth input by fwhm
+    var_fwhm:
+    # type=range|default=0.0: smooth variance by fwhm
+    no_mask_smooth:
+    # type=bool|default=False: do not mask when smoothing
+    no_est_fwhm:
+    # type=bool|default=False: turn off FWHM output estimation
+    mask_file:
+    # type=file: map of the mask used in the analysis
+    # type=file|default=<undefined>: binary mask
+    label_file:
+    # type=file|default=<undefined>: use label as mask, surfaces only
+    cortex:
+    # type=bool|default=False: use subjects ?h.cortex.label as label
+    invert_mask:
+    # type=bool|default=False: invert mask
+    prune:
+    # type=bool|default=False: remove voxels that do not have a non-zero value at each frame (def)
+    no_prune:
+    # type=bool|default=False: do not prune
+    prune_thresh:
+    # type=float|default=0.0: prune threshold. Default is FLT_MIN
+    compute_log_y:
+    # type=bool|default=False: compute natural log of y prior to analysis
+    save_estimate:
+    # type=bool|default=False: save signal estimate (yhat)
+    save_residual:
+    # type=bool|default=False: save residual error (eres)
+    save_res_corr_mtx:
+    # type=bool|default=False: save residual error spatial correlation matrix (eres.scm). Big!
+    surf:
+    # type=bool|default=False: analysis is on a surface mesh
+    subject_id:
+    # type=str|default='': subject id for surface geometry
+    hemi:
+    # type=enum|default='lh'|allowed['lh','rh']: surface hemisphere
+    surf_geo:
+    # type=str|default='white': surface geometry name (e.g. white, pial)
+    simulation:
+    # type=tuple|default=('perm', 0, 0.0, ''): nulltype nsim thresh csdbasename
+    sim_sign:
+    # type=enum|default='abs'|allowed['abs','neg','pos']: abs, pos, or neg
+    uniform:
+    # type=tuple|default=(0.0, 0.0): use uniform distribution instead of gaussian
+    pca:
+    # type=bool|default=False: perform pca/svd analysis on residual
+    calc_AR1:
+    # type=bool|default=False: compute and save temporal AR1 of residual
+    save_cond:
+    # type=bool|default=False: flag to save design matrix condition at each voxel
+    vox_dump:
+    # type=tuple|default=(0, 0, 0): dump voxel GLM and exit
+    seed:
+    # type=int|default=0: used for synthesizing noise
+    synth:
+    # type=bool|default=False: replace input with gaussian
+    resynth_test:
+    # type=int|default=0: test GLM by resynthsis
+    profile:
+    # type=int|default=0: niters : test speed
+    mrtm2:
+    # type=tuple|default=(<undefined>, <undefined>, 0.0): RefTac TimeSec k2prime : perform MRTM2 kinetic modeling
+    logan:
+    # type=tuple|default=(<undefined>, <undefined>, 0.0): RefTac TimeSec tstar   : perform Logan kinetic modeling
+    force_perm:
+    # type=bool|default=False: force perumtation test, even when design matrix is not orthog
+    diag:
+    # type=int|default=0: Gdiag_no : set diagnostic level
+    diag_cluster:
+    # type=bool|default=False: save sig volume and exit from first sim loop
+    debug:
+    # type=bool|default=False: turn on debugging
+    check_opts:
+    # type=bool|default=False: don't run anything, just check options and exit
+    allow_repeated_subjects:
+    # type=bool|default=False: allow subject names to repeat in the fsgd file (must appear before --fsgd
+    allow_ill_cond:
+    # type=bool|default=False: allow ill-conditioned design matrices
+    sim_done_file:
+    # type=file|default=<undefined>: create file when simulation finished
+    nii:
+    # type=bool|default=False: save outputs as nii
+    nii_gz:
+    # type=bool|default=False: save outputs as nii.gz
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input 4D file
+    mrtm1: ("ref_tac.dat", "timing.dat")
+    # type=tuple|default=(<undefined>, <undefined>): RefTac TimeSec : perform MRTM1 kinetic modeling
+    glm_dir: '"mrtm"'
+    # type=directory: output directory
+    # type=str|default='': save outputs to dir
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: mri_glmfit --glmdir mrtm --y tac.nii --mrtm1 ref_tac.dat timing.dat
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: input 4D file
+    mrtm1: ("ref_tac.dat", "timing.dat")
+    # type=tuple|default=(<undefined>, <undefined>): RefTac TimeSec : perform MRTM1 kinetic modeling
+    glm_dir: '"mrtm"'
+    # type=directory: output directory
+    # type=str|default='': save outputs to dir
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/mrtm2.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/mrtm2.yaml
new file mode 100644
index 00000000..ccd6baab
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/mrtm2.yaml
@@ -0,0 +1,300 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.petsurfer.MRTM2' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Perform MRTM2 kinetic modeling.
+#     Examples
+#     --------
+#     >>> mrtm2 = MRTM2()
+#     >>> mrtm2.inputs.in_file = 'tac.nii'
+#     >>> mrtm2.inputs.mrtm2 = ('ref_tac.dat', 'timing.dat', 0.07872)
+#     >>> mrtm2.inputs.glm_dir = 'mrtm2'
+#     >>> mrtm2.cmdline
+#     'mri_glmfit --glmdir mrtm2 --y tac.nii --mrtm2 ref_tac.dat timing.dat 0.078720'
+#     
+task_name: MRTM2
+nipype_name: MRTM2
+nipype_module: nipype.interfaces.freesurfer.petsurfer
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: input 4D file
+    design: generic/file
+    # type=file|default=<undefined>: design matrix file
+    contrast: generic/file+list-of
+    # type=inputmultiobject|default=[]: contrast file
+    per_voxel_reg: generic/file+list-of
+    # type=inputmultiobject|default=[]: per-voxel regressors
+    weighted_ls: generic/file
+    # type=file|default=<undefined>: weighted least squares
+    fixed_fx_var: generic/file
+    # type=file|default=<undefined>: for fixed effects analysis
+    fixed_fx_dof_file: generic/file
+    # type=file|default=<undefined>: text file with dof for fixed effects analysis
+    weight_file: generic/file
+    # type=file|default=<undefined>: weight for each input at each voxel
+    mask_file: generic/file
+    # type=file: map of the mask used in the analysis
+    # type=file|default=<undefined>: binary mask
+    label_file: generic/file
+    # type=file|default=<undefined>: use label as mask, surfaces only
+    sim_done_file: generic/file
+    # type=file|default=<undefined>: create file when simulation finished
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    beta_file: generic/file
+    # type=file: map of regression coefficients
+    error_file: generic/file
+    # type=file: map of residual error
+    error_var_file: generic/file
+    # type=file: map of residual error variance
+    error_stddev_file: generic/file
+    # type=file: map of residual error standard deviation
+    estimate_file: generic/file
+    # type=file: map of the estimated Y values
+    mask_file: generic/file
+    # type=file: map of the mask used in the analysis
+    # type=file|default=<undefined>: binary mask
+    fwhm_file: generic/file
+    # type=file: text file with estimated smoothness
+    dof_file: generic/file
+    # type=file: text file with effective degrees-of-freedom for the analysis
+    spatial_eigenvectors: generic/file
+    # type=file: map of spatial eigenvectors from residual PCA
+    frame_eigenvectors: generic/file
+    # type=file: matrix of frame eigenvectors from residual PCA
+    singular_values: generic/file
+    # type=file: matrix singular values from residual PCA
+    svd_stats_file: generic/file
+    # type=file: text file summarizing the residual PCA
+    k2p_file: generic/file
+    # type=file: estimate of k2p parameter
+    bp_file: generic/file
+    # type=file: Binding potential estimates
+    glm_dir: generic/directory
+    # type=directory: output directory
+    # type=str|default='': save outputs to dir
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    glm_dir: '"mrtm2"'
+    # type=directory: output directory
+    # type=str|default='': save outputs to dir
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    mrtm2:
+    # type=tuple|default=(<undefined>, <undefined>, 0.0): RefTac TimeSec k2prime : perform MRTM2 kinetic modeling
+    glm_dir:
+    # type=directory: output directory
+    # type=str|default='': save outputs to dir
+    in_file:
+    # type=file|default=<undefined>: input 4D file
+    fsgd:
+    # type=tuple|default=(<undefined>, 'doss'): freesurfer descriptor file
+    design:
+    # type=file|default=<undefined>: design matrix file
+    contrast:
+    # type=inputmultiobject|default=[]: contrast file
+    one_sample:
+    # type=bool|default=False: construct X and C as a one-sample group mean
+    no_contrast_ok:
+    # type=bool|default=False: do not fail if no contrasts specified
+    per_voxel_reg:
+    # type=inputmultiobject|default=[]: per-voxel regressors
+    self_reg:
+    # type=tuple|default=(0, 0, 0): self-regressor from index col row slice
+    weighted_ls:
+    # type=file|default=<undefined>: weighted least squares
+    fixed_fx_var:
+    # type=file|default=<undefined>: for fixed effects analysis
+    fixed_fx_dof:
+    # type=int|default=0: dof for fixed effects analysis
+    fixed_fx_dof_file:
+    # type=file|default=<undefined>: text file with dof for fixed effects analysis
+    weight_file:
+    # type=file|default=<undefined>: weight for each input at each voxel
+    weight_inv:
+    # type=bool|default=False: invert weights
+    weight_sqrt:
+    # type=bool|default=False: sqrt of weights
+    fwhm:
+    # type=range|default=0.0: smooth input by fwhm
+    var_fwhm:
+    # type=range|default=0.0: smooth variance by fwhm
+    no_mask_smooth:
+    # type=bool|default=False: do not mask when smoothing
+    no_est_fwhm:
+    # type=bool|default=False: turn off FWHM output estimation
+    mask_file:
+    # type=file: map of the mask used in the analysis
+    # type=file|default=<undefined>: binary mask
+    label_file:
+    # type=file|default=<undefined>: use label as mask, surfaces only
+    cortex:
+    # type=bool|default=False: use subjects ?h.cortex.label as label
+    invert_mask:
+    # type=bool|default=False: invert mask
+    prune:
+    # type=bool|default=False: remove voxels that do not have a non-zero value at each frame (def)
+    no_prune:
+    # type=bool|default=False: do not prune
+    prune_thresh:
+    # type=float|default=0.0: prune threshold. Default is FLT_MIN
+    compute_log_y:
+    # type=bool|default=False: compute natural log of y prior to analysis
+    save_estimate:
+    # type=bool|default=False: save signal estimate (yhat)
+    save_residual:
+    # type=bool|default=False: save residual error (eres)
+    save_res_corr_mtx:
+    # type=bool|default=False: save residual error spatial correlation matrix (eres.scm). Big!
+    surf:
+    # type=bool|default=False: analysis is on a surface mesh
+    subject_id:
+    # type=str|default='': subject id for surface geometry
+    hemi:
+    # type=enum|default='lh'|allowed['lh','rh']: surface hemisphere
+    surf_geo:
+    # type=str|default='white': surface geometry name (e.g. white, pial)
+    simulation:
+    # type=tuple|default=('perm', 0, 0.0, ''): nulltype nsim thresh csdbasename
+    sim_sign:
+    # type=enum|default='abs'|allowed['abs','neg','pos']: abs, pos, or neg
+    uniform:
+    # type=tuple|default=(0.0, 0.0): use uniform distribution instead of gaussian
+    pca:
+    # type=bool|default=False: perform pca/svd analysis on residual
+    calc_AR1:
+    # type=bool|default=False: compute and save temporal AR1 of residual
+    save_cond:
+    # type=bool|default=False: flag to save design matrix condition at each voxel
+    vox_dump:
+    # type=tuple|default=(0, 0, 0): dump voxel GLM and exit
+    seed:
+    # type=int|default=0: used for synthesizing noise
+    synth:
+    # type=bool|default=False: replace input with gaussian
+    resynth_test:
+    # type=int|default=0: test GLM by resynthsis
+    profile:
+    # type=int|default=0: niters : test speed
+    mrtm1:
+    # type=tuple|default=(<undefined>, <undefined>): RefTac TimeSec : perform MRTM1 kinetic modeling
+    logan:
+    # type=tuple|default=(<undefined>, <undefined>, 0.0): RefTac TimeSec tstar   : perform Logan kinetic modeling
+    force_perm:
+    # type=bool|default=False: force perumtation test, even when design matrix is not orthog
+    diag:
+    # type=int|default=0: Gdiag_no : set diagnostic level
+    diag_cluster:
+    # type=bool|default=False: save sig volume and exit from first sim loop
+    debug:
+    # type=bool|default=False: turn on debugging
+    check_opts:
+    # type=bool|default=False: don't run anything, just check options and exit
+    allow_repeated_subjects:
+    # type=bool|default=False: allow subject names to repeat in the fsgd file (must appear before --fsgd
+    allow_ill_cond:
+    # type=bool|default=False: allow ill-conditioned design matrices
+    sim_done_file:
+    # type=file|default=<undefined>: create file when simulation finished
+    nii:
+    # type=bool|default=False: save outputs as nii
+    nii_gz:
+    # type=bool|default=False: save outputs as nii.gz
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input 4D file
+    mrtm2: ("ref_tac.dat", "timing.dat", 0.07872)
+    # type=tuple|default=(<undefined>, <undefined>, 0.0): RefTac TimeSec k2prime : perform MRTM2 kinetic modeling
+    glm_dir: '"mrtm2"'
+    # type=directory: output directory
+    # type=str|default='': save outputs to dir
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: mri_glmfit --glmdir mrtm2 --y tac.nii --mrtm2 ref_tac.dat timing.dat 0.078720
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: input 4D file
+    mrtm2: ("ref_tac.dat", "timing.dat", 0.07872)
+    # type=tuple|default=(<undefined>, <undefined>, 0.0): RefTac TimeSec k2prime : perform MRTM2 kinetic modeling
+    glm_dir: '"mrtm2"'
+    # type=directory: output directory
+    # type=str|default='': save outputs to dir
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/mrtm2_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/mrtm2_callables.py
new file mode 100644
index 00000000..20fb1266
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/mrtm2_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in MRTM2.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/mrtm_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/mrtm_callables.py
new file mode 100644
index 00000000..13bca71e
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/mrtm_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in MRTM.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/ms__lda.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/ms__lda.yaml
new file mode 100644
index 00000000..ef1e17ad
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/ms__lda.yaml
@@ -0,0 +1,184 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.model.MS_LDA' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Perform LDA reduction on the intensity space of an arbitrary # of FLASH images
+# 
+#     Examples
+#     --------
+#     >>> grey_label = 2
+#     >>> white_label = 3
+#     >>> zero_value = 1
+#     >>> optimalWeights = MS_LDA(lda_labels=[grey_label, white_label],                                 label_file='label.mgz', weight_file='weights.txt',                                 shift=zero_value, vol_synth_file='synth_out.mgz',                                 conform=True, use_weights=True,                                 images=['FLASH1.mgz', 'FLASH2.mgz', 'FLASH3.mgz'])
+#     >>> optimalWeights.cmdline
+#     'mri_ms_LDA -conform -label label.mgz -lda 2 3 -shift 1 -W -synth synth_out.mgz -weight weights.txt FLASH1.mgz FLASH2.mgz FLASH3.mgz'
+# 
+#     
+task_name: MS_LDA
+nipype_name: MS_LDA
+nipype_module: nipype.interfaces.freesurfer.model
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    weight_file: text/text-file
+    # type=file: 
+    # type=file|default=<undefined>: filename for the LDA weights (input or output)
+    vol_synth_file: medimage/mgh-gz
+    # type=file: 
+    # type=file|default=<undefined>: filename for the synthesized output volume
+    label_file: medimage/mgh-gz
+    # type=file|default=<undefined>: filename of the label volume
+    mask_file: generic/file
+    # type=file|default=<undefined>: filename of the brain mask volume
+    images: medimage/mgh-gz+list-of
+    # type=inputmultiobject|default=[]: list of input FLASH images
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    weight_file: text/text-file
+    # type=file: 
+    # type=file|default=<undefined>: filename for the LDA weights (input or output)
+    vol_synth_file: medimage/mgh-gz
+    # type=file: 
+    # type=file|default=<undefined>: filename for the synthesized output volume
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    lda_labels:
+    # type=list|default=[]: pair of class labels to optimize
+    weight_file:
+    # type=file: 
+    # type=file|default=<undefined>: filename for the LDA weights (input or output)
+    vol_synth_file:
+    # type=file: 
+    # type=file|default=<undefined>: filename for the synthesized output volume
+    label_file:
+    # type=file|default=<undefined>: filename of the label volume
+    mask_file:
+    # type=file|default=<undefined>: filename of the brain mask volume
+    shift:
+    # type=int|default=0: shift all values equal to the given value to zero
+    conform:
+    # type=bool|default=False: Conform the input volumes (brain mask typically already conformed)
+    use_weights:
+    # type=bool|default=False: Use the weights from a previously generated weight file
+    images:
+    # type=inputmultiobject|default=[]: list of input FLASH images
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    lda_labels: '[grey_label, white_label]'
+    # type=list|default=[]: pair of class labels to optimize
+    label_file:
+    # type=file|default=<undefined>: filename of the label volume
+    weight_file:
+    # type=file: 
+    # type=file|default=<undefined>: filename for the LDA weights (input or output)
+    shift: zero_value
+    # type=int|default=0: shift all values equal to the given value to zero
+    vol_synth_file:
+    # type=file: 
+    # type=file|default=<undefined>: filename for the synthesized output volume
+    conform: 'True'
+    # type=bool|default=False: Conform the input volumes (brain mask typically already conformed)
+    use_weights: 'True'
+    # type=bool|default=False: Use the weights from a previously generated weight file
+    images:
+    # type=inputmultiobject|default=[]: list of input FLASH images
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: mri_ms_LDA -conform -label label.mgz -lda 2 3 -shift 1 -W -synth synth_out.mgz -weight weights.txt FLASH1.mgz FLASH2.mgz FLASH3.mgz
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    lda_labels: '[grey_label, white_label]'
+    # type=list|default=[]: pair of class labels to optimize
+    label_file:
+    # type=file|default=<undefined>: filename of the label volume
+    weight_file:
+    # type=file: 
+    # type=file|default=<undefined>: filename for the LDA weights (input or output)
+    shift: zero_value
+    # type=int|default=0: shift all values equal to the given value to zero
+    vol_synth_file:
+    # type=file: 
+    # type=file|default=<undefined>: filename for the synthesized output volume
+    conform: 'True'
+    # type=bool|default=False: Conform the input volumes (brain mask typically already conformed)
+    use_weights: 'True'
+    # type=bool|default=False: Use the weights from a previously generated weight file
+    images:
+    # type=inputmultiobject|default=[]: list of input FLASH images
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/ms__lda_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/ms__lda_callables.py
new file mode 100644
index 00000000..22230ee1
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/ms__lda_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in MS_LDA.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/normalize.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/normalize.yaml
new file mode 100644
index 00000000..592b9354
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/normalize.yaml
@@ -0,0 +1,147 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.preprocess.Normalize' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Normalize the white-matter, optionally based on control points. The
+#     input volume is converted into a new volume where white matter image
+#     values all range around 110.
+# 
+#     Examples
+#     ========
+#     >>> from nipype.interfaces import freesurfer
+#     >>> normalize = freesurfer.Normalize()
+#     >>> normalize.inputs.in_file = "T1.mgz"
+#     >>> normalize.inputs.gradient = 1
+#     >>> normalize.cmdline
+#     'mri_normalize -g 1 T1.mgz T1_norm.mgz'
+#     
+task_name: Normalize
+nipype_name: Normalize
+nipype_module: nipype.interfaces.freesurfer.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/mgh-gz
+    # type=file|default=<undefined>: The input file for Normalize
+    out_file: generic/file
+    # type=file: The output file for Normalize
+    # type=file|default=<undefined>: The output file for Normalize
+    mask: generic/file
+    # type=file|default=<undefined>: The input mask file for Normalize
+    segmentation: generic/file
+    # type=file|default=<undefined>: The input segmentation for Normalize
+    transform: generic/file
+    # type=file|default=<undefined>: Transform file from the header of the input file
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: The output file for Normalize
+    # type=file|default=<undefined>: The output file for Normalize
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: The input file for Normalize
+    out_file:
+    # type=file: The output file for Normalize
+    # type=file|default=<undefined>: The output file for Normalize
+    gradient:
+    # type=int|default=0: use max intensity/mm gradient g (default=1)
+    mask:
+    # type=file|default=<undefined>: The input mask file for Normalize
+    segmentation:
+    # type=file|default=<undefined>: The input segmentation for Normalize
+    transform:
+    # type=file|default=<undefined>: Transform file from the header of the input file
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: The input file for Normalize
+    gradient: '1'
+    # type=int|default=0: use max intensity/mm gradient g (default=1)
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: mri_normalize -g 1 T1.mgz T1_norm.mgz
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: The input file for Normalize
+    gradient: '1'
+    # type=int|default=0: use max intensity/mm gradient g (default=1)
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/normalize_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/normalize_callables.py
new file mode 100644
index 00000000..795f3328
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/normalize_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Normalize.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/one_sample_t_test.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/one_sample_t_test.yaml
new file mode 100644
index 00000000..18ac4a8a
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/one_sample_t_test.yaml
@@ -0,0 +1,248 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.model.OneSampleTTest' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+task_name: OneSampleTTest
+nipype_name: OneSampleTTest
+nipype_module: nipype.interfaces.freesurfer.model
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: input 4D file
+    design: generic/file
+    # type=file|default=<undefined>: design matrix file
+    contrast: generic/file+list-of
+    # type=inputmultiobject|default=[]: contrast file
+    per_voxel_reg: generic/file+list-of
+    # type=inputmultiobject|default=[]: per-voxel regressors
+    weighted_ls: generic/file
+    # type=file|default=<undefined>: weighted least squares
+    fixed_fx_var: generic/file
+    # type=file|default=<undefined>: for fixed effects analysis
+    fixed_fx_dof_file: generic/file
+    # type=file|default=<undefined>: text file with dof for fixed effects analysis
+    weight_file: generic/file
+    # type=file|default=<undefined>: weight for each input at each voxel
+    mask_file: generic/file
+    # type=file: map of the mask used in the analysis
+    # type=file|default=<undefined>: binary mask
+    label_file: generic/file
+    # type=file|default=<undefined>: use label as mask, surfaces only
+    sim_done_file: generic/file
+    # type=file|default=<undefined>: create file when simulation finished
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    beta_file: generic/file
+    # type=file: map of regression coefficients
+    error_file: generic/file
+    # type=file: map of residual error
+    error_var_file: generic/file
+    # type=file: map of residual error variance
+    error_stddev_file: generic/file
+    # type=file: map of residual error standard deviation
+    estimate_file: generic/file
+    # type=file: map of the estimated Y values
+    mask_file: generic/file
+    # type=file: map of the mask used in the analysis
+    # type=file|default=<undefined>: binary mask
+    fwhm_file: generic/file
+    # type=file: text file with estimated smoothness
+    dof_file: generic/file
+    # type=file: text file with effective degrees-of-freedom for the analysis
+    spatial_eigenvectors: generic/file
+    # type=file: map of spatial eigenvectors from residual PCA
+    frame_eigenvectors: generic/file
+    # type=file: matrix of frame eigenvectors from residual PCA
+    singular_values: generic/file
+    # type=file: matrix singular values from residual PCA
+    svd_stats_file: generic/file
+    # type=file: text file summarizing the residual PCA
+    k2p_file: generic/file
+    # type=file: estimate of k2p parameter
+    bp_file: generic/file
+    # type=file: Binding potential estimates
+    glm_dir: generic/directory
+    # type=directory: output directory
+    # type=str|default='': save outputs to dir
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    glm_dir: glm_dir
+    # type=directory: output directory
+    # type=str|default='': save outputs to dir
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    glm_dir:
+    # type=directory: output directory
+    # type=str|default='': save outputs to dir
+    in_file:
+    # type=file|default=<undefined>: input 4D file
+    fsgd:
+    # type=tuple|default=(<undefined>, 'doss'): freesurfer descriptor file
+    design:
+    # type=file|default=<undefined>: design matrix file
+    contrast:
+    # type=inputmultiobject|default=[]: contrast file
+    one_sample:
+    # type=bool|default=False: construct X and C as a one-sample group mean
+    no_contrast_ok:
+    # type=bool|default=False: do not fail if no contrasts specified
+    per_voxel_reg:
+    # type=inputmultiobject|default=[]: per-voxel regressors
+    self_reg:
+    # type=tuple|default=(0, 0, 0): self-regressor from index col row slice
+    weighted_ls:
+    # type=file|default=<undefined>: weighted least squares
+    fixed_fx_var:
+    # type=file|default=<undefined>: for fixed effects analysis
+    fixed_fx_dof:
+    # type=int|default=0: dof for fixed effects analysis
+    fixed_fx_dof_file:
+    # type=file|default=<undefined>: text file with dof for fixed effects analysis
+    weight_file:
+    # type=file|default=<undefined>: weight for each input at each voxel
+    weight_inv:
+    # type=bool|default=False: invert weights
+    weight_sqrt:
+    # type=bool|default=False: sqrt of weights
+    fwhm:
+    # type=range|default=0.0: smooth input by fwhm
+    var_fwhm:
+    # type=range|default=0.0: smooth variance by fwhm
+    no_mask_smooth:
+    # type=bool|default=False: do not mask when smoothing
+    no_est_fwhm:
+    # type=bool|default=False: turn off FWHM output estimation
+    mask_file:
+    # type=file: map of the mask used in the analysis
+    # type=file|default=<undefined>: binary mask
+    label_file:
+    # type=file|default=<undefined>: use label as mask, surfaces only
+    cortex:
+    # type=bool|default=False: use subjects ?h.cortex.label as label
+    invert_mask:
+    # type=bool|default=False: invert mask
+    prune:
+    # type=bool|default=False: remove voxels that do not have a non-zero value at each frame (def)
+    no_prune:
+    # type=bool|default=False: do not prune
+    prune_thresh:
+    # type=float|default=0.0: prune threshold. Default is FLT_MIN
+    compute_log_y:
+    # type=bool|default=False: compute natural log of y prior to analysis
+    save_estimate:
+    # type=bool|default=False: save signal estimate (yhat)
+    save_residual:
+    # type=bool|default=False: save residual error (eres)
+    save_res_corr_mtx:
+    # type=bool|default=False: save residual error spatial correlation matrix (eres.scm). Big!
+    surf:
+    # type=bool|default=False: analysis is on a surface mesh
+    subject_id:
+    # type=str|default='': subject id for surface geometry
+    hemi:
+    # type=enum|default='lh'|allowed['lh','rh']: surface hemisphere
+    surf_geo:
+    # type=str|default='white': surface geometry name (e.g. white, pial)
+    simulation:
+    # type=tuple|default=('perm', 0, 0.0, ''): nulltype nsim thresh csdbasename
+    sim_sign:
+    # type=enum|default='abs'|allowed['abs','neg','pos']: abs, pos, or neg
+    uniform:
+    # type=tuple|default=(0.0, 0.0): use uniform distribution instead of gaussian
+    pca:
+    # type=bool|default=False: perform pca/svd analysis on residual
+    calc_AR1:
+    # type=bool|default=False: compute and save temporal AR1 of residual
+    save_cond:
+    # type=bool|default=False: flag to save design matrix condition at each voxel
+    vox_dump:
+    # type=tuple|default=(0, 0, 0): dump voxel GLM and exit
+    seed:
+    # type=int|default=0: used for synthesizing noise
+    synth:
+    # type=bool|default=False: replace input with gaussian
+    resynth_test:
+    # type=int|default=0: test GLM by resynthsis
+    profile:
+    # type=int|default=0: niters : test speed
+    mrtm1:
+    # type=tuple|default=(<undefined>, <undefined>): RefTac TimeSec : perform MRTM1 kinetic modeling
+    mrtm2:
+    # type=tuple|default=(<undefined>, <undefined>, 0.0): RefTac TimeSec k2prime : perform MRTM2 kinetic modeling
+    logan:
+    # type=tuple|default=(<undefined>, <undefined>, 0.0): RefTac TimeSec tstar   : perform Logan kinetic modeling
+    force_perm:
+    # type=bool|default=False: force perumtation test, even when design matrix is not orthog
+    diag:
+    # type=int|default=0: Gdiag_no : set diagnostic level
+    diag_cluster:
+    # type=bool|default=False: save sig volume and exit from first sim loop
+    debug:
+    # type=bool|default=False: turn on debugging
+    check_opts:
+    # type=bool|default=False: don't run anything, just check options and exit
+    allow_repeated_subjects:
+    # type=bool|default=False: allow subject names to repeat in the fsgd file (must appear before --fsgd
+    allow_ill_cond:
+    # type=bool|default=False: allow ill-conditioned design matrices
+    sim_done_file:
+    # type=file|default=<undefined>: create file when simulation finished
+    nii:
+    # type=bool|default=False: save outputs as nii
+    nii_gz:
+    # type=bool|default=False: save outputs as nii.gz
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/one_sample_t_test_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/one_sample_t_test_callables.py
new file mode 100644
index 00000000..327ad259
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/one_sample_t_test_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in OneSampleTTest.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/paint.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/paint.yaml
new file mode 100644
index 00000000..1546a476
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/paint.yaml
@@ -0,0 +1,155 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.registration.Paint' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     This program is useful for extracting one of the arrays ("a variable")
+#     from a surface-registration template file. The output is a file
+#     containing a surface-worth of per-vertex values, saved in "curvature"
+#     format. Because the template data is sampled to a particular surface
+#     mesh, this conjures the idea of "painting to a surface".
+# 
+#     Examples
+#     ========
+#     >>> from nipype.interfaces.freesurfer import Paint
+#     >>> paint = Paint()
+#     >>> paint.inputs.in_surf = 'lh.pial'
+#     >>> paint.inputs.template = 'aseg.mgz'
+#     >>> paint.inputs.averages = 5
+#     >>> paint.inputs.out_file = 'lh.avg_curv'
+#     >>> paint.cmdline
+#     'mrisp_paint -a 5 aseg.mgz lh.pial lh.avg_curv'
+#     
+task_name: Paint
+nipype_name: Paint
+nipype_module: nipype.interfaces.freesurfer.registration
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_surf: medimage-freesurfer/pial
+    # type=file|default=<undefined>: Surface file with grid (vertices) onto which the template data is to be sampled or 'painted'
+    template: medimage/mgh-gz
+    # type=file|default=<undefined>: Template file
+    out_file: medimage-freesurfer/avg_curv
+    # type=file: File containing a surface-worth of per-vertex values, saved in 'curvature' format.
+    # type=file|default=<undefined>: File containing a surface-worth of per-vertex values, saved in 'curvature' format.
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: medimage-freesurfer/avg_curv
+    # type=file: File containing a surface-worth of per-vertex values, saved in 'curvature' format.
+    # type=file|default=<undefined>: File containing a surface-worth of per-vertex values, saved in 'curvature' format.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_surf:
+    # type=file|default=<undefined>: Surface file with grid (vertices) onto which the template data is to be sampled or 'painted'
+    template:
+    # type=file|default=<undefined>: Template file
+    template_param:
+    # type=int|default=0: Frame number of the input template
+    averages:
+    # type=int|default=0: Average curvature patterns
+    out_file:
+    # type=file: File containing a surface-worth of per-vertex values, saved in 'curvature' format.
+    # type=file|default=<undefined>: File containing a surface-worth of per-vertex values, saved in 'curvature' format.
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_surf:
+    # type=file|default=<undefined>: Surface file with grid (vertices) onto which the template data is to be sampled or 'painted'
+    template:
+    # type=file|default=<undefined>: Template file
+    averages: '5'
+    # type=int|default=0: Average curvature patterns
+    out_file:
+    # type=file: File containing a surface-worth of per-vertex values, saved in 'curvature' format.
+    # type=file|default=<undefined>: File containing a surface-worth of per-vertex values, saved in 'curvature' format.
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: mrisp_paint -a 5 aseg.mgz lh.pial lh.avg_curv
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_surf:
+    # type=file|default=<undefined>: Surface file with grid (vertices) onto which the template data is to be sampled or 'painted'
+    template:
+    # type=file|default=<undefined>: Template file
+    averages: '5'
+    # type=int|default=0: Average curvature patterns
+    out_file:
+    # type=file: File containing a surface-worth of per-vertex values, saved in 'curvature' format.
+    # type=file|default=<undefined>: File containing a surface-worth of per-vertex values, saved in 'curvature' format.
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/paint_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/paint_callables.py
new file mode 100644
index 00000000..93cce06e
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/paint_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Paint.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/parcellation_stats.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/parcellation_stats.yaml
new file mode 100644
index 00000000..a67d5dc4
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/parcellation_stats.yaml
@@ -0,0 +1,277 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.utils.ParcellationStats' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     This program computes a number of anatomical properties.
+# 
+#     Examples
+#     ========
+#     >>> from nipype.interfaces.freesurfer import ParcellationStats
+#     >>> import os
+#     >>> parcstats = ParcellationStats()
+#     >>> parcstats.inputs.subject_id = '10335'
+#     >>> parcstats.inputs.hemisphere = 'lh'
+#     >>> parcstats.inputs.wm = './../mri/wm.mgz' # doctest: +SKIP
+#     >>> parcstats.inputs.transform = './../mri/transforms/talairach.xfm' # doctest: +SKIP
+#     >>> parcstats.inputs.brainmask = './../mri/brainmask.mgz' # doctest: +SKIP
+#     >>> parcstats.inputs.aseg = './../mri/aseg.presurf.mgz' # doctest: +SKIP
+#     >>> parcstats.inputs.ribbon = './../mri/ribbon.mgz' # doctest: +SKIP
+#     >>> parcstats.inputs.lh_pial = 'lh.pial' # doctest: +SKIP
+#     >>> parcstats.inputs.rh_pial = 'lh.pial' # doctest: +SKIP
+#     >>> parcstats.inputs.lh_white = 'lh.white' # doctest: +SKIP
+#     >>> parcstats.inputs.rh_white = 'rh.white' # doctest: +SKIP
+#     >>> parcstats.inputs.thickness = 'lh.thickness' # doctest: +SKIP
+#     >>> parcstats.inputs.surface = 'white'
+#     >>> parcstats.inputs.out_table = 'lh.test.stats'
+#     >>> parcstats.inputs.out_color = 'test.ctab'
+#     >>> parcstats.cmdline # doctest: +SKIP
+#     'mris_anatomical_stats -c test.ctab -f lh.test.stats 10335 lh white'
+#     
+task_name: ParcellationStats
+nipype_name: ParcellationStats
+nipype_module: nipype.interfaces.freesurfer.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    wm: medimage/mgh-gz
+    # type=file|default=<undefined>: Input file must be <subject_id>/mri/wm.mgz
+    lh_white: medimage-freesurfer/white
+    # type=file|default=<undefined>: Input file must be <subject_id>/surf/lh.white
+    rh_white: medimage-freesurfer/white
+    # type=file|default=<undefined>: Input file must be <subject_id>/surf/rh.white
+    lh_pial: medimage-freesurfer/pial
+    # type=file|default=<undefined>: Input file must be <subject_id>/surf/lh.pial
+    rh_pial: medimage-freesurfer/pial
+    # type=file|default=<undefined>: Input file must be <subject_id>/surf/rh.pial
+    transform: medimage-freesurfer/xfm
+    # type=file|default=<undefined>: Input file must be <subject_id>/mri/transforms/talairach.xfm
+    thickness: medimage-freesurfer/thickness
+    # type=file|default=<undefined>: Input file must be <subject_id>/surf/?h.thickness
+    brainmask: medimage/mgh-gz
+    # type=file|default=<undefined>: Input file must be <subject_id>/mri/brainmask.mgz
+    aseg: medimage/mgh-gz
+    # type=file|default=<undefined>: Input file must be <subject_id>/mri/aseg.presurf.mgz
+    ribbon: medimage/mgh-gz
+    # type=file|default=<undefined>: Input file must be <subject_id>/mri/ribbon.mgz
+    cortex_label: generic/file
+    # type=file|default=<undefined>: implicit input file {hemi}.cortex.label
+    in_cortex: generic/file
+    # type=file|default=<undefined>: Input cortex label
+    in_annotation: generic/file
+    # type=file|default=<undefined>: compute properties for each label in the annotation file separately
+    in_label: generic/file
+    # type=file|default=<undefined>: limit calculations to specified label
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_table: medimage-freesurfer/stats
+    # type=file: Table output to tablefile
+    # type=file|default=<undefined>: Table output to tablefile
+    out_color: medimage-freesurfer/ctab
+    # type=file: Output annotation files's colortable to text file
+    # type=file|default=<undefined>: Output annotation files's colortable to text file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_table: '"lh.test.stats"'
+    # type=file: Table output to tablefile
+    # type=file|default=<undefined>: Table output to tablefile
+    out_color: '"test.ctab"'
+    # type=file: Output annotation files's colortable to text file
+    # type=file|default=<undefined>: Output annotation files's colortable to text file
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    subject_id:
+    # type=string|default='subject_id': Subject being processed
+    hemisphere:
+    # type=enum|default='lh'|allowed['lh','rh']: Hemisphere being processed
+    wm:
+    # type=file|default=<undefined>: Input file must be <subject_id>/mri/wm.mgz
+    lh_white:
+    # type=file|default=<undefined>: Input file must be <subject_id>/surf/lh.white
+    rh_white:
+    # type=file|default=<undefined>: Input file must be <subject_id>/surf/rh.white
+    lh_pial:
+    # type=file|default=<undefined>: Input file must be <subject_id>/surf/lh.pial
+    rh_pial:
+    # type=file|default=<undefined>: Input file must be <subject_id>/surf/rh.pial
+    transform:
+    # type=file|default=<undefined>: Input file must be <subject_id>/mri/transforms/talairach.xfm
+    thickness:
+    # type=file|default=<undefined>: Input file must be <subject_id>/surf/?h.thickness
+    brainmask:
+    # type=file|default=<undefined>: Input file must be <subject_id>/mri/brainmask.mgz
+    aseg:
+    # type=file|default=<undefined>: Input file must be <subject_id>/mri/aseg.presurf.mgz
+    ribbon:
+    # type=file|default=<undefined>: Input file must be <subject_id>/mri/ribbon.mgz
+    cortex_label:
+    # type=file|default=<undefined>: implicit input file {hemi}.cortex.label
+    surface:
+    # type=string|default='': Input surface (e.g. 'white')
+    mgz:
+    # type=bool|default=False: Look for mgz files
+    in_cortex:
+    # type=file|default=<undefined>: Input cortex label
+    in_annotation:
+    # type=file|default=<undefined>: compute properties for each label in the annotation file separately
+    in_label:
+    # type=file|default=<undefined>: limit calculations to specified label
+    tabular_output:
+    # type=bool|default=False: Tabular output
+    out_table:
+    # type=file: Table output to tablefile
+    # type=file|default=<undefined>: Table output to tablefile
+    out_color:
+    # type=file: Output annotation files's colortable to text file
+    # type=file|default=<undefined>: Output annotation files's colortable to text file
+    copy_inputs:
+    # type=bool|default=False: If running as a node, set this to True.This will copy the input files to the node directory.
+    th3:
+    # type=bool|default=False: turns on new vertex-wise volume calc for mris_anat_stats
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    subject_id: '"10335"'
+    # type=string|default='subject_id': Subject being processed
+    hemisphere: '"lh"'
+    # type=enum|default='lh'|allowed['lh','rh']: Hemisphere being processed
+    wm:
+    # type=file|default=<undefined>: Input file must be <subject_id>/mri/wm.mgz
+    transform:
+    # type=file|default=<undefined>: Input file must be <subject_id>/mri/transforms/talairach.xfm
+    brainmask:
+    # type=file|default=<undefined>: Input file must be <subject_id>/mri/brainmask.mgz
+    aseg:
+    # type=file|default=<undefined>: Input file must be <subject_id>/mri/aseg.presurf.mgz
+    ribbon:
+    # type=file|default=<undefined>: Input file must be <subject_id>/mri/ribbon.mgz
+    lh_pial:
+    # type=file|default=<undefined>: Input file must be <subject_id>/surf/lh.pial
+    rh_pial:
+    # type=file|default=<undefined>: Input file must be <subject_id>/surf/rh.pial
+    lh_white:
+    # type=file|default=<undefined>: Input file must be <subject_id>/surf/lh.white
+    rh_white:
+    # type=file|default=<undefined>: Input file must be <subject_id>/surf/rh.white
+    thickness:
+    # type=file|default=<undefined>: Input file must be <subject_id>/surf/?h.thickness
+    surface: '"white"'
+    # type=string|default='': Input surface (e.g. 'white')
+    out_table: '"lh.test.stats"'
+    # type=file: Table output to tablefile
+    # type=file|default=<undefined>: Table output to tablefile
+    out_color: '"test.ctab"'
+    # type=file: Output annotation files's colortable to text file
+    # type=file|default=<undefined>: Output annotation files's colortable to text file
+  imports: &id001
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  - module: os
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: mris_anatomical_stats -c test.ctab -f lh.test.stats 10335 lh white
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    subject_id: '"10335"'
+    # type=string|default='subject_id': Subject being processed
+    hemisphere: '"lh"'
+    # type=enum|default='lh'|allowed['lh','rh']: Hemisphere being processed
+    wm:
+    # type=file|default=<undefined>: Input file must be <subject_id>/mri/wm.mgz
+    transform:
+    # type=file|default=<undefined>: Input file must be <subject_id>/mri/transforms/talairach.xfm
+    brainmask:
+    # type=file|default=<undefined>: Input file must be <subject_id>/mri/brainmask.mgz
+    aseg:
+    # type=file|default=<undefined>: Input file must be <subject_id>/mri/aseg.presurf.mgz
+    ribbon:
+    # type=file|default=<undefined>: Input file must be <subject_id>/mri/ribbon.mgz
+    lh_pial:
+    # type=file|default=<undefined>: Input file must be <subject_id>/surf/lh.pial
+    rh_pial:
+    # type=file|default=<undefined>: Input file must be <subject_id>/surf/rh.pial
+    lh_white:
+    # type=file|default=<undefined>: Input file must be <subject_id>/surf/lh.white
+    rh_white:
+    # type=file|default=<undefined>: Input file must be <subject_id>/surf/rh.white
+    thickness:
+    # type=file|default=<undefined>: Input file must be <subject_id>/surf/?h.thickness
+    surface: '"white"'
+    # type=string|default='': Input surface (e.g. 'white')
+    out_table: '"lh.test.stats"'
+    # type=file: Table output to tablefile
+    # type=file|default=<undefined>: Table output to tablefile
+    out_color: '"test.ctab"'
+    # type=file: Output annotation files's colortable to text file
+    # type=file|default=<undefined>: Output annotation files's colortable to text file
+  imports: *id001
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/parcellation_stats_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/parcellation_stats_callables.py
new file mode 100644
index 00000000..af32d119
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/parcellation_stats_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in ParcellationStats.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/parse_dicom_dir.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/parse_dicom_dir.yaml
new file mode 100644
index 00000000..767f91ed
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/parse_dicom_dir.yaml
@@ -0,0 +1,141 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.preprocess.ParseDICOMDir' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Uses mri_parse_sdcmdir to get information from dicom directories
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces.freesurfer import ParseDICOMDir
+#     >>> dcminfo = ParseDICOMDir()
+#     >>> dcminfo.inputs.dicom_dir = '.'
+#     >>> dcminfo.inputs.sortbyrun = True
+#     >>> dcminfo.inputs.summarize = True
+#     >>> dcminfo.cmdline
+#     'mri_parse_sdcmdir --d . --o dicominfo.txt --sortbyrun --summarize'
+# 
+#     
+task_name: ParseDICOMDir
+nipype_name: ParseDICOMDir
+nipype_module: nipype.interfaces.freesurfer.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    dicom_info_file: generic/file
+    # type=file: text file containing dicom information
+    # type=file|default='dicominfo.txt': file to which results are written
+    dicom_dir: generic/directory
+    # type=directory|default=<undefined>: path to siemens dicom directory
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    dicom_info_file: generic/file
+    # type=file: text file containing dicom information
+    # type=file|default='dicominfo.txt': file to which results are written
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    dicom_dir:
+    # type=directory|default=<undefined>: path to siemens dicom directory
+    dicom_info_file:
+    # type=file: text file containing dicom information
+    # type=file|default='dicominfo.txt': file to which results are written
+    sortbyrun:
+    # type=bool|default=False: assign run numbers
+    summarize:
+    # type=bool|default=False: only print out info for run leaders
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    dicom_dir: '"."'
+    # type=directory|default=<undefined>: path to siemens dicom directory
+    sortbyrun: 'True'
+    # type=bool|default=False: assign run numbers
+    summarize: 'True'
+    # type=bool|default=False: only print out info for run leaders
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: mri_parse_sdcmdir --d . --o dicominfo.txt --sortbyrun --summarize
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    dicom_dir: '"."'
+    # type=directory|default=<undefined>: path to siemens dicom directory
+    sortbyrun: 'True'
+    # type=bool|default=False: assign run numbers
+    summarize: 'True'
+    # type=bool|default=False: only print out info for run leaders
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/parse_dicom_dir_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/parse_dicom_dir_callables.py
new file mode 100644
index 00000000..dfe9a498
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/parse_dicom_dir_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in ParseDICOMDir.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/recon_all.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/recon_all.yaml
new file mode 100644
index 00000000..1afc192b
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/recon_all.yaml
@@ -0,0 +1,548 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.preprocess.ReconAll' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Uses recon-all to generate surfaces and parcellations of structural data
+#     from anatomical images of a subject.
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces.freesurfer import ReconAll
+#     >>> reconall = ReconAll()
+#     >>> reconall.inputs.subject_id = 'foo'
+#     >>> reconall.inputs.directive = 'all'
+#     >>> reconall.inputs.subjects_dir = '.'
+#     >>> reconall.inputs.T1_files = ['structural.nii']
+#     >>> reconall.cmdline
+#     'recon-all -all -i structural.nii -subjid foo -sd .'
+#     >>> reconall.inputs.flags = "-qcache"
+#     >>> reconall.cmdline
+#     'recon-all -all -i structural.nii -qcache -subjid foo -sd .'
+#     >>> reconall.inputs.flags = ["-cw256", "-qcache"]
+#     >>> reconall.cmdline
+#     'recon-all -all -i structural.nii -cw256 -qcache -subjid foo -sd .'
+# 
+#     Hemisphere may be specified regardless of directive:
+# 
+#     >>> reconall.inputs.flags = []
+#     >>> reconall.inputs.hemi = 'lh'
+#     >>> reconall.cmdline
+#     'recon-all -all -i structural.nii -hemi lh -subjid foo -sd .'
+# 
+#     ``-autorecon-hemi`` uses the ``-hemi`` input to specify the hemisphere
+#     to operate upon:
+# 
+#     >>> reconall.inputs.directive = 'autorecon-hemi'
+#     >>> reconall.cmdline
+#     'recon-all -autorecon-hemi lh -i structural.nii -subjid foo -sd .'
+# 
+#     Hippocampal subfields can accept T1 and T2 images:
+# 
+#     >>> reconall_subfields = ReconAll()
+#     >>> reconall_subfields.inputs.subject_id = 'foo'
+#     >>> reconall_subfields.inputs.directive = 'all'
+#     >>> reconall_subfields.inputs.subjects_dir = '.'
+#     >>> reconall_subfields.inputs.T1_files = ['structural.nii']
+#     >>> reconall_subfields.inputs.hippocampal_subfields_T1 = True
+#     >>> reconall_subfields.cmdline
+#     'recon-all -all -i structural.nii -hippocampal-subfields-T1 -subjid foo -sd .'
+#     >>> reconall_subfields.inputs.hippocampal_subfields_T2 = (
+#     ... 'structural.nii', 'test')
+#     >>> reconall_subfields.cmdline
+#     'recon-all -all -i structural.nii -hippocampal-subfields-T1T2 structural.nii test -subjid foo -sd .'
+#     >>> reconall_subfields.inputs.hippocampal_subfields_T1 = False
+#     >>> reconall_subfields.cmdline
+#     'recon-all -all -i structural.nii -hippocampal-subfields-T2 structural.nii test -subjid foo -sd .'
+# 
+#     Base template creation for longitudinal pipeline:
+#     >>> baserecon = ReconAll()
+#     >>> baserecon.inputs.base_template_id = 'sub-template'
+#     >>> baserecon.inputs.base_timepoint_ids = ['ses-1','ses-2']
+#     >>> baserecon.inputs.directive = 'all'
+#     >>> baserecon.inputs.subjects_dir = '.'
+#     >>> baserecon.cmdline
+#     'recon-all -all -base sub-template -base-tp ses-1 -base-tp ses-2 -sd .'
+# 
+#     Longitudinal timepoint run:
+#     >>> longrecon = ReconAll()
+#     >>> longrecon.inputs.longitudinal_timepoint_id = 'ses-1'
+#     >>> longrecon.inputs.longitudinal_template_id = 'sub-template'
+#     >>> longrecon.inputs.directive = 'all'
+#     >>> longrecon.inputs.subjects_dir = '.'
+#     >>> longrecon.cmdline
+#     'recon-all -all -long ses-1 sub-template -sd .'
+#     
+task_name: ReconAll
+nipype_name: ReconAll
+nipype_module: nipype.interfaces.freesurfer.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    T1_files: medimage/nifti1+list-of
+    # type=inputmultiobject|default=[]: name of T1 file to process
+    T2_file: generic/file
+    # type=file|default=<undefined>: Convert T2 image to orig directory
+    FLAIR_file: generic/file
+    # type=file|default=<undefined>: Convert FLAIR image to orig directory
+    expert: generic/file
+    # type=file|default=<undefined>: Set parameters using expert file
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    T1: generic/file
+    # type=file: Intensity normalized whole-head volume
+    aseg: generic/file
+    # type=file: Volumetric map of regions from automatic segmentation
+    brain: generic/file
+    # type=file: Intensity normalized brain-only volume
+    brainmask: generic/file
+    # type=file: Skull-stripped (brain-only) volume
+    filled: generic/file
+    # type=file: Subcortical mass volume
+    norm: generic/file
+    # type=file: Normalized skull-stripped volume
+    nu: generic/file
+    # type=file: Non-uniformity corrected whole-head volume
+    orig: generic/file
+    # type=file: Base image conformed to Freesurfer space
+    rawavg: generic/file
+    # type=file: Volume formed by averaging input images
+    wm: generic/file
+    # type=file: Segmented white-matter volume
+    wmparc: generic/file
+    # type=file: Aparc parcellation projected into subcortical white matter
+    subjects_dir: generic/directory
+    # type=directory: Freesurfer subjects directory.
+    # type=directory|default=<undefined>: path to subjects directory
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    subjects_dir: '"."'
+    # type=directory: Freesurfer subjects directory.
+    # type=directory|default=<undefined>: path to subjects directory
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    subject_id:
+    # type=str: Subject name for whom to retrieve data
+    # type=str|default='recon_all': subject name
+    directive:
+    # type=enum|default='all'|allowed['all','autorecon-hemi','autorecon-pial','autorecon1','autorecon2','autorecon2-cp','autorecon2-inflate1','autorecon2-perhemi','autorecon2-volonly','autorecon2-wm','autorecon3','autorecon3-T2pial','localGI','qcache']: process directive
+    hemi:
+    # type=enum|default='lh'|allowed['lh','rh']: hemisphere to process
+    T1_files:
+    # type=inputmultiobject|default=[]: name of T1 file to process
+    T2_file:
+    # type=file|default=<undefined>: Convert T2 image to orig directory
+    FLAIR_file:
+    # type=file|default=<undefined>: Convert FLAIR image to orig directory
+    use_T2:
+    # type=bool|default=False: Use T2 image to refine the pial surface
+    use_FLAIR:
+    # type=bool|default=False: Use FLAIR image to refine the pial surface
+    openmp:
+    # type=int|default=0: Number of processors to use in parallel
+    parallel:
+    # type=bool|default=False: Enable parallel execution
+    hires:
+    # type=bool|default=False: Conform to minimum voxel size (for voxels < 1mm)
+    mprage:
+    # type=bool|default=False: Assume scan parameters are MGH MP-RAGE protocol, which produces darker gray matter
+    big_ventricles:
+    # type=bool|default=False: For use in subjects with enlarged ventricles
+    brainstem:
+    # type=bool|default=False: Segment brainstem structures
+    hippocampal_subfields_T1:
+    # type=bool|default=False: segment hippocampal subfields using input T1 scan
+    hippocampal_subfields_T2:
+    # type=tuple|default=(<undefined>, ''): segment hippocampal subfields using T2 scan, identified by ID (may be combined with hippocampal_subfields_T1)
+    expert:
+    # type=file|default=<undefined>: Set parameters using expert file
+    xopts:
+    # type=enum|default='use'|allowed['clean','overwrite','use']: Use, delete or overwrite existing expert options file
+    subjects_dir:
+    # type=directory: Freesurfer subjects directory.
+    # type=directory|default=<undefined>: path to subjects directory
+    flags:
+    # type=inputmultiobject|default=[]: additional parameters
+    base_template_id:
+    # type=str|default='': base template id
+    base_timepoint_ids:
+    # type=inputmultiobject|default=[]: processed timepoint to use in template
+    longitudinal_timepoint_id:
+    # type=str|default='': longitudinal session/timepoint id
+    longitudinal_template_id:
+    # type=str|default='': longitudinal base template id
+    talairach:
+    # type=str|default='': Flags to pass to talairach commands
+    mri_normalize:
+    # type=str|default='': Flags to pass to mri_normalize commands
+    mri_watershed:
+    # type=str|default='': Flags to pass to mri_watershed commands
+    mri_em_register:
+    # type=str|default='': Flags to pass to mri_em_register commands
+    mri_ca_normalize:
+    # type=str|default='': Flags to pass to mri_ca_normalize commands
+    mri_ca_register:
+    # type=str|default='': Flags to pass to mri_ca_register commands
+    mri_remove_neck:
+    # type=str|default='': Flags to pass to mri_remove_neck commands
+    mri_ca_label:
+    # type=str|default='': Flags to pass to mri_ca_label commands
+    mri_segstats:
+    # type=str|default='': Flags to pass to mri_segstats commands
+    mri_mask:
+    # type=str|default='': Flags to pass to mri_mask commands
+    mri_segment:
+    # type=str|default='': Flags to pass to mri_segment commands
+    mri_edit_wm_with_aseg:
+    # type=str|default='': Flags to pass to mri_edit_wm_with_aseg commands
+    mri_pretess:
+    # type=str|default='': Flags to pass to mri_pretess commands
+    mri_fill:
+    # type=str|default='': Flags to pass to mri_fill commands
+    mri_tessellate:
+    # type=str|default='': Flags to pass to mri_tessellate commands
+    mris_smooth:
+    # type=str|default='': Flags to pass to mri_smooth commands
+    mris_inflate:
+    # type=str|default='': Flags to pass to mri_inflate commands
+    mris_sphere:
+    # type=str|default='': Flags to pass to mris_sphere commands
+    mris_fix_topology:
+    # type=str|default='': Flags to pass to mris_fix_topology commands
+    mris_make_surfaces:
+    # type=str|default='': Flags to pass to mris_make_surfaces commands
+    mris_surf2vol:
+    # type=str|default='': Flags to pass to mris_surf2vol commands
+    mris_register:
+    # type=str|default='': Flags to pass to mris_register commands
+    mrisp_paint:
+    # type=str|default='': Flags to pass to mrisp_paint commands
+    mris_ca_label:
+    # type=str|default='': Flags to pass to mris_ca_label commands
+    mris_anatomical_stats:
+    # type=str|default='': Flags to pass to mris_anatomical_stats commands
+    mri_aparc2aseg:
+    # type=str|default='': Flags to pass to mri_aparc2aseg commands
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    subject_id: '"foo"'
+    # type=str: Subject name for whom to retrieve data
+    # type=str|default='recon_all': subject name
+    directive: '"all"'
+    # type=enum|default='all'|allowed['all','autorecon-hemi','autorecon-pial','autorecon1','autorecon2','autorecon2-cp','autorecon2-inflate1','autorecon2-perhemi','autorecon2-volonly','autorecon2-wm','autorecon3','autorecon3-T2pial','localGI','qcache']: process directive
+    subjects_dir: '"."'
+    # type=directory: Freesurfer subjects directory.
+    # type=directory|default=<undefined>: path to subjects directory
+    T1_files:
+    # type=inputmultiobject|default=[]: name of T1 file to process
+    flags: '["-cw256", "-qcache"]'
+    # type=inputmultiobject|default=[]: additional parameters
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    flags: '[]'
+    # type=inputmultiobject|default=[]: additional parameters
+    hemi: '"lh"'
+    # type=enum|default='lh'|allowed['lh','rh']: hemisphere to process
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    directive: '"autorecon-hemi"'
+    # type=enum|default='all'|allowed['all','autorecon-hemi','autorecon-pial','autorecon1','autorecon2','autorecon2-cp','autorecon2-inflate1','autorecon2-perhemi','autorecon2-volonly','autorecon2-wm','autorecon3','autorecon3-T2pial','localGI','qcache']: process directive
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    subject_id: '"foo"'
+    # type=str: Subject name for whom to retrieve data
+    # type=str|default='recon_all': subject name
+    directive: '"all"'
+    # type=enum|default='all'|allowed['all','autorecon-hemi','autorecon-pial','autorecon1','autorecon2','autorecon2-cp','autorecon2-inflate1','autorecon2-perhemi','autorecon2-volonly','autorecon2-wm','autorecon3','autorecon3-T2pial','localGI','qcache']: process directive
+    subjects_dir: '"."'
+    # type=directory: Freesurfer subjects directory.
+    # type=directory|default=<undefined>: path to subjects directory
+    T1_files:
+    # type=inputmultiobject|default=[]: name of T1 file to process
+    hippocampal_subfields_T1: 'False'
+    # type=bool|default=False: segment hippocampal subfields using input T1 scan
+    hippocampal_subfields_T2: ("structural.nii", "test")
+    # type=tuple|default=(<undefined>, ''): segment hippocampal subfields using T2 scan, identified by ID (may be combined with hippocampal_subfields_T1)
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    base_template_id: '"sub-template"'
+    # type=str|default='': base template id
+    base_timepoint_ids: '["ses-1","ses-2"]'
+    # type=inputmultiobject|default=[]: processed timepoint to use in template
+    directive: '"all"'
+    # type=enum|default='all'|allowed['all','autorecon-hemi','autorecon-pial','autorecon1','autorecon2','autorecon2-cp','autorecon2-inflate1','autorecon2-perhemi','autorecon2-volonly','autorecon2-wm','autorecon3','autorecon3-T2pial','localGI','qcache']: process directive
+    subjects_dir: '"."'
+    # type=directory: Freesurfer subjects directory.
+    # type=directory|default=<undefined>: path to subjects directory
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    longitudinal_timepoint_id: '"ses-1"'
+    # type=str|default='': longitudinal session/timepoint id
+    longitudinal_template_id: '"sub-template"'
+    # type=str|default='': longitudinal base template id
+    directive: '"all"'
+    # type=enum|default='all'|allowed['all','autorecon-hemi','autorecon-pial','autorecon1','autorecon2','autorecon2-cp','autorecon2-inflate1','autorecon2-perhemi','autorecon2-volonly','autorecon2-wm','autorecon3','autorecon3-T2pial','localGI','qcache']: process directive
+    subjects_dir: '"."'
+    # type=directory: Freesurfer subjects directory.
+    # type=directory|default=<undefined>: path to subjects directory
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: recon-all -all -i structural.nii -cw256 -qcache -subjid foo -sd .
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    subject_id: '"foo"'
+    # type=str: Subject name for whom to retrieve data
+    # type=str|default='recon_all': subject name
+    directive: '"all"'
+    # type=enum|default='all'|allowed['all','autorecon-hemi','autorecon-pial','autorecon1','autorecon2','autorecon2-cp','autorecon2-inflate1','autorecon2-perhemi','autorecon2-volonly','autorecon2-wm','autorecon3','autorecon3-T2pial','localGI','qcache']: process directive
+    subjects_dir: '"."'
+    # type=directory: Freesurfer subjects directory.
+    # type=directory|default=<undefined>: path to subjects directory
+    T1_files:
+    # type=inputmultiobject|default=[]: name of T1 file to process
+    flags: '["-cw256", "-qcache"]'
+    # type=inputmultiobject|default=[]: additional parameters
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: recon-all -all -i structural.nii -hemi lh -subjid foo -sd .
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    flags: '[]'
+    # type=inputmultiobject|default=[]: additional parameters
+    hemi: '"lh"'
+    # type=enum|default='lh'|allowed['lh','rh']: hemisphere to process
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: recon-all -autorecon-hemi lh -i structural.nii -subjid foo -sd .
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    directive: '"autorecon-hemi"'
+    # type=enum|default='all'|allowed['all','autorecon-hemi','autorecon-pial','autorecon1','autorecon2','autorecon2-cp','autorecon2-inflate1','autorecon2-perhemi','autorecon2-volonly','autorecon2-wm','autorecon3','autorecon3-T2pial','localGI','qcache']: process directive
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: recon-all -all -i structural.nii -hippocampal-subfields-T2 structural.nii test -subjid foo -sd .
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    subject_id: '"foo"'
+    # type=str: Subject name for whom to retrieve data
+    # type=str|default='recon_all': subject name
+    directive: '"all"'
+    # type=enum|default='all'|allowed['all','autorecon-hemi','autorecon-pial','autorecon1','autorecon2','autorecon2-cp','autorecon2-inflate1','autorecon2-perhemi','autorecon2-volonly','autorecon2-wm','autorecon3','autorecon3-T2pial','localGI','qcache']: process directive
+    subjects_dir: '"."'
+    # type=directory: Freesurfer subjects directory.
+    # type=directory|default=<undefined>: path to subjects directory
+    T1_files:
+    # type=inputmultiobject|default=[]: name of T1 file to process
+    hippocampal_subfields_T1: 'False'
+    # type=bool|default=False: segment hippocampal subfields using input T1 scan
+    hippocampal_subfields_T2: ("structural.nii", "test")
+    # type=tuple|default=(<undefined>, ''): segment hippocampal subfields using T2 scan, identified by ID (may be combined with hippocampal_subfields_T1)
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: recon-all -all -base sub-template -base-tp ses-1 -base-tp ses-2 -sd .
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    base_template_id: '"sub-template"'
+    # type=str|default='': base template id
+    base_timepoint_ids: '["ses-1","ses-2"]'
+    # type=inputmultiobject|default=[]: processed timepoint to use in template
+    directive: '"all"'
+    # type=enum|default='all'|allowed['all','autorecon-hemi','autorecon-pial','autorecon1','autorecon2','autorecon2-cp','autorecon2-inflate1','autorecon2-perhemi','autorecon2-volonly','autorecon2-wm','autorecon3','autorecon3-T2pial','localGI','qcache']: process directive
+    subjects_dir: '"."'
+    # type=directory: Freesurfer subjects directory.
+    # type=directory|default=<undefined>: path to subjects directory
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: recon-all -all -long ses-1 sub-template -sd .
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    longitudinal_timepoint_id: '"ses-1"'
+    # type=str|default='': longitudinal session/timepoint id
+    longitudinal_template_id: '"sub-template"'
+    # type=str|default='': longitudinal base template id
+    directive: '"all"'
+    # type=enum|default='all'|allowed['all','autorecon-hemi','autorecon-pial','autorecon1','autorecon2','autorecon2-cp','autorecon2-inflate1','autorecon2-perhemi','autorecon2-volonly','autorecon2-wm','autorecon3','autorecon3-T2pial','localGI','qcache']: process directive
+    subjects_dir: '"."'
+    # type=directory: Freesurfer subjects directory.
+    # type=directory|default=<undefined>: path to subjects directory
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/recon_all_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/recon_all_callables.py
new file mode 100644
index 00000000..f2ff9955
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/recon_all_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in ReconAll.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/register.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/register.yaml
new file mode 100644
index 00000000..54e1af54
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/register.yaml
@@ -0,0 +1,166 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.registration.Register' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# This program registers a surface to an average surface template.
+# 
+#     Examples
+#     ========
+#     >>> from nipype.interfaces.freesurfer import Register
+#     >>> register = Register()
+#     >>> register.inputs.in_surf = 'lh.pial'
+#     >>> register.inputs.in_smoothwm = 'lh.pial'
+#     >>> register.inputs.in_sulc = 'lh.pial'
+#     >>> register.inputs.target = 'aseg.mgz'
+#     >>> register.inputs.out_file = 'lh.pial.reg'
+#     >>> register.inputs.curv = True
+#     >>> register.cmdline
+#     'mris_register -curv lh.pial aseg.mgz lh.pial.reg'
+#     
+task_name: Register
+nipype_name: Register
+nipype_module: nipype.interfaces.freesurfer.registration
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_surf: medimage-freesurfer/pial
+    # type=file|default=<undefined>: Surface to register, often {hemi}.sphere
+    target: medimage/mgh-gz
+    # type=file|default=<undefined>: The data to register to. In normal recon-all usage, this is a template file for average surface.
+    in_sulc: medimage-freesurfer/pial
+    # type=file|default=<undefined>: Undocumented mandatory input file ${SUBJECTS_DIR}/surf/{hemisphere}.sulc 
+    in_smoothwm: medimage-freesurfer/pial
+    # type=file|default=<undefined>: Undocumented input file ${SUBJECTS_DIR}/surf/{hemisphere}.smoothwm 
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: medimage-freesurfer/reg
+    # type=file: Output surface file to capture registration
+    # type=file|default=<undefined>: Output surface file to capture registration
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: '"lh.pial.reg"'
+    # type=file: Output surface file to capture registration
+    # type=file|default=<undefined>: Output surface file to capture registration
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_surf:
+    # type=file|default=<undefined>: Surface to register, often {hemi}.sphere
+    target:
+    # type=file|default=<undefined>: The data to register to. In normal recon-all usage, this is a template file for average surface.
+    in_sulc:
+    # type=file|default=<undefined>: Undocumented mandatory input file ${SUBJECTS_DIR}/surf/{hemisphere}.sulc 
+    out_file:
+    # type=file: Output surface file to capture registration
+    # type=file|default=<undefined>: Output surface file to capture registration
+    curv:
+    # type=bool|default=False: Use smoothwm curvature for final alignment
+    in_smoothwm:
+    # type=file|default=<undefined>: Undocumented input file ${SUBJECTS_DIR}/surf/{hemisphere}.smoothwm 
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_surf:
+    # type=file|default=<undefined>: Surface to register, often {hemi}.sphere
+    in_smoothwm:
+    # type=file|default=<undefined>: Undocumented input file ${SUBJECTS_DIR}/surf/{hemisphere}.smoothwm 
+    in_sulc:
+    # type=file|default=<undefined>: Undocumented mandatory input file ${SUBJECTS_DIR}/surf/{hemisphere}.sulc 
+    target:
+    # type=file|default=<undefined>: The data to register to. In normal recon-all usage, this is a template file for average surface.
+    out_file: '"lh.pial.reg"'
+    # type=file: Output surface file to capture registration
+    # type=file|default=<undefined>: Output surface file to capture registration
+    curv: 'True'
+    # type=bool|default=False: Use smoothwm curvature for final alignment
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: mris_register -curv lh.pial aseg.mgz lh.pial.reg
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_surf:
+    # type=file|default=<undefined>: Surface to register, often {hemi}.sphere
+    in_smoothwm:
+    # type=file|default=<undefined>: Undocumented input file ${SUBJECTS_DIR}/surf/{hemisphere}.smoothwm 
+    in_sulc:
+    # type=file|default=<undefined>: Undocumented mandatory input file ${SUBJECTS_DIR}/surf/{hemisphere}.sulc 
+    target:
+    # type=file|default=<undefined>: The data to register to. In normal recon-all usage, this is a template file for average surface.
+    out_file: '"lh.pial.reg"'
+    # type=file: Output surface file to capture registration
+    # type=file|default=<undefined>: Output surface file to capture registration
+    curv: 'True'
+    # type=bool|default=False: Use smoothwm curvature for final alignment
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/register_av_ito_talairach.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/register_av_ito_talairach.yaml
new file mode 100644
index 00000000..007840a1
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/register_av_ito_talairach.yaml
@@ -0,0 +1,158 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.registration.RegisterAVItoTalairach' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     converts the vox2vox from talairach_avi to a talairach.xfm file
+# 
+#     This is a script that converts the vox2vox from talairach_avi to a
+#     talairach.xfm file. It is meant to replace the following cmd line:
+# 
+#     tkregister2_cmdl         --mov $InVol         --targ $FREESURFER_HOME/average/mni305.cor.mgz         --xfmout ${XFM}         --vox2vox talsrcimg_to_${target}_t4_vox2vox.txt         --noedit         --reg talsrcimg.reg.tmp.dat
+#     set targ = $FREESURFER_HOME/average/mni305.cor.mgz
+#     set subject = mgh-02407836-v2
+#     set InVol = $SUBJECTS_DIR/$subject/mri/orig.mgz
+#     set vox2vox = $SUBJECTS_DIR/$subject/mri/transforms/talsrcimg_to_711-2C_as_mni_average_305_t4_vox2vox.txt
+# 
+#     Examples
+#     ========
+# 
+#     >>> from nipype.interfaces.freesurfer import RegisterAVItoTalairach
+#     >>> register = RegisterAVItoTalairach()
+#     >>> register.inputs.in_file = 'structural.mgz'                 # doctest: +SKIP
+#     >>> register.inputs.target = 'mni305.cor.mgz'                  # doctest: +SKIP
+#     >>> register.inputs.vox2vox = 'talsrcimg_to_structural_t4_vox2vox.txt' # doctest: +SKIP
+#     >>> register.cmdline                                           # doctest: +SKIP
+#     'avi2talxfm structural.mgz mni305.cor.mgz talsrcimg_to_structural_t4_vox2vox.txt talairach.auto.xfm'
+# 
+#     >>> register.run() # doctest: +SKIP
+#     
+task_name: RegisterAVItoTalairach
+nipype_name: RegisterAVItoTalairach
+nipype_module: nipype.interfaces.freesurfer.registration
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/mgh-gz
+    # type=file|default=<undefined>: The input file
+    target: medimage/mgh-gz
+    # type=file|default=<undefined>: The target file
+    vox2vox: text/text-file
+    # type=file|default=<undefined>: The vox2vox file
+    out_file: generic/file
+    # type=file: The output file for RegisterAVItoTalairach
+    # type=file|default='talairach.auto.xfm': The transform output
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: The output file for RegisterAVItoTalairach
+    # type=file|default='talairach.auto.xfm': The transform output
+    log_file: generic/file
+    # type=file: The output log
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: The input file
+    target:
+    # type=file|default=<undefined>: The target file
+    vox2vox:
+    # type=file|default=<undefined>: The vox2vox file
+    out_file:
+    # type=file: The output file for RegisterAVItoTalairach
+    # type=file|default='talairach.auto.xfm': The transform output
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: The input file
+    target:
+    # type=file|default=<undefined>: The target file
+    vox2vox:
+    # type=file|default=<undefined>: The vox2vox file
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: avi2talxfm structural.mgz mni305.cor.mgz talsrcimg_to_structural_t4_vox2vox.txt talairach.auto.xfm
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: The input file
+    target:
+    # type=file|default=<undefined>: The target file
+    vox2vox:
+    # type=file|default=<undefined>: The vox2vox file
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/register_av_ito_talairach_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/register_av_ito_talairach_callables.py
new file mode 100644
index 00000000..a968a895
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/register_av_ito_talairach_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in RegisterAVItoTalairach.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/register_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/register_callables.py
new file mode 100644
index 00000000..8dc066af
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/register_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Register.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/relabel_hypointensities.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/relabel_hypointensities.yaml
new file mode 100644
index 00000000..f63bcbb4
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/relabel_hypointensities.yaml
@@ -0,0 +1,153 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.utils.RelabelHypointensities' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Relabel Hypointensities
+# 
+#     Examples
+#     ========
+#     >>> from nipype.interfaces.freesurfer import RelabelHypointensities
+#     >>> relabelhypos = RelabelHypointensities()
+#     >>> relabelhypos.inputs.lh_white = 'lh.pial'
+#     >>> relabelhypos.inputs.rh_white = 'lh.pial'
+#     >>> relabelhypos.inputs.surf_directory = '.'
+#     >>> relabelhypos.inputs.aseg = 'aseg.mgz'
+#     >>> relabelhypos.cmdline
+#     'mri_relabel_hypointensities aseg.mgz . aseg.hypos.mgz'
+#     
+task_name: RelabelHypointensities
+nipype_name: RelabelHypointensities
+nipype_module: nipype.interfaces.freesurfer.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    lh_white: medimage-freesurfer/pial
+    # type=file|default=<undefined>: Implicit input file must be lh.white
+    rh_white: medimage-freesurfer/pial
+    # type=file|default=<undefined>: Implicit input file must be rh.white
+    aseg: medimage/mgh-gz
+    # type=file|default=<undefined>: Input aseg file
+    out_file: generic/file
+    # type=file: Output aseg file
+    # type=file|default=<undefined>: Output aseg file
+    surf_directory: generic/directory
+    # type=directory|default='.': Directory containing lh.white and rh.white
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: Output aseg file
+    # type=file|default=<undefined>: Output aseg file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    lh_white:
+    # type=file|default=<undefined>: Implicit input file must be lh.white
+    rh_white:
+    # type=file|default=<undefined>: Implicit input file must be rh.white
+    aseg:
+    # type=file|default=<undefined>: Input aseg file
+    surf_directory:
+    # type=directory|default='.': Directory containing lh.white and rh.white
+    out_file:
+    # type=file: Output aseg file
+    # type=file|default=<undefined>: Output aseg file
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    lh_white:
+    # type=file|default=<undefined>: Implicit input file must be lh.white
+    rh_white:
+    # type=file|default=<undefined>: Implicit input file must be rh.white
+    surf_directory: '"."'
+    # type=directory|default='.': Directory containing lh.white and rh.white
+    aseg:
+    # type=file|default=<undefined>: Input aseg file
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: mri_relabel_hypointensities aseg.mgz . aseg.hypos.mgz
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    lh_white:
+    # type=file|default=<undefined>: Implicit input file must be lh.white
+    rh_white:
+    # type=file|default=<undefined>: Implicit input file must be rh.white
+    surf_directory: '"."'
+    # type=directory|default='.': Directory containing lh.white and rh.white
+    aseg:
+    # type=file|default=<undefined>: Input aseg file
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/relabel_hypointensities_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/relabel_hypointensities_callables.py
new file mode 100644
index 00000000..5f614cc2
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/relabel_hypointensities_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in RelabelHypointensities.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/remove_intersection.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/remove_intersection.yaml
new file mode 100644
index 00000000..43652f90
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/remove_intersection.yaml
@@ -0,0 +1,126 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.utils.RemoveIntersection' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     This program removes the intersection of the given MRI
+# 
+#     Examples
+#     ========
+#     >>> from nipype.interfaces.freesurfer import RemoveIntersection
+#     >>> ri = RemoveIntersection()
+#     >>> ri.inputs.in_file = 'lh.pial'
+#     >>> ri.cmdline
+#     'mris_remove_intersection lh.pial lh.pial'
+#     
+task_name: RemoveIntersection
+nipype_name: RemoveIntersection
+nipype_module: nipype.interfaces.freesurfer.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage-freesurfer/pial
+    # type=file|default=<undefined>: Input file for RemoveIntersection
+    out_file: generic/file
+    # type=file: Output file for RemoveIntersection
+    # type=file|default=<undefined>: Output file for RemoveIntersection
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: Output file for RemoveIntersection
+    # type=file|default=<undefined>: Output file for RemoveIntersection
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: Input file for RemoveIntersection
+    out_file:
+    # type=file: Output file for RemoveIntersection
+    # type=file|default=<undefined>: Output file for RemoveIntersection
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: Input file for RemoveIntersection
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: mris_remove_intersection lh.pial lh.pial
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: Input file for RemoveIntersection
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/remove_intersection_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/remove_intersection_callables.py
new file mode 100644
index 00000000..63d3b957
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/remove_intersection_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in RemoveIntersection.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/remove_neck.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/remove_neck.yaml
new file mode 100644
index 00000000..96931db4
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/remove_neck.yaml
@@ -0,0 +1,147 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.utils.RemoveNeck' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Crops the neck out of the mri image
+# 
+#     Examples
+#     ========
+# 
+#     >>> from nipype.interfaces.freesurfer import TalairachQC
+#     >>> remove_neck = RemoveNeck()
+#     >>> remove_neck.inputs.in_file = 'norm.mgz'
+#     >>> remove_neck.inputs.transform = 'trans.mat'
+#     >>> remove_neck.inputs.template = 'trans.mat'
+#     >>> remove_neck.cmdline
+#     'mri_remove_neck norm.mgz trans.mat trans.mat norm_noneck.mgz'
+#     
+task_name: RemoveNeck
+nipype_name: RemoveNeck
+nipype_module: nipype.interfaces.freesurfer.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/mgh-gz
+    # type=file|default=<undefined>: Input file for RemoveNeck
+    out_file: generic/file
+    # type=file: Output file with neck removed
+    # type=file|default=<undefined>: Output file for RemoveNeck
+    transform: datascience/text-matrix
+    # type=file|default=<undefined>: Input transform file for RemoveNeck
+    template: datascience/text-matrix
+    # type=file|default=<undefined>: Input template file for RemoveNeck
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: Output file with neck removed
+    # type=file|default=<undefined>: Output file for RemoveNeck
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: Input file for RemoveNeck
+    out_file:
+    # type=file: Output file with neck removed
+    # type=file|default=<undefined>: Output file for RemoveNeck
+    transform:
+    # type=file|default=<undefined>: Input transform file for RemoveNeck
+    template:
+    # type=file|default=<undefined>: Input template file for RemoveNeck
+    radius:
+    # type=int|default=0: Radius
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: Input file for RemoveNeck
+    transform:
+    # type=file|default=<undefined>: Input transform file for RemoveNeck
+    template:
+    # type=file|default=<undefined>: Input template file for RemoveNeck
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: mri_remove_neck norm.mgz trans.mat trans.mat norm_noneck.mgz
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: Input file for RemoveNeck
+    transform:
+    # type=file|default=<undefined>: Input transform file for RemoveNeck
+    template:
+    # type=file|default=<undefined>: Input template file for RemoveNeck
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/remove_neck_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/remove_neck_callables.py
new file mode 100644
index 00000000..899991aa
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/remove_neck_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in RemoveNeck.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/resample.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/resample.yaml
new file mode 100644
index 00000000..52180997
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/resample.yaml
@@ -0,0 +1,141 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.preprocess.Resample' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Use FreeSurfer mri_convert to up or down-sample image files
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces import freesurfer
+#     >>> resampler = freesurfer.Resample()
+#     >>> resampler.inputs.in_file = 'structural.nii'
+#     >>> resampler.inputs.resampled_file = 'resampled.nii'
+#     >>> resampler.inputs.voxel_size = (2.1, 2.1, 2.1)
+#     >>> resampler.cmdline
+#     'mri_convert -vs 2.10 2.10 2.10 -i structural.nii -o resampled.nii'
+# 
+#     
+task_name: Resample
+nipype_name: Resample
+nipype_module: nipype.interfaces.freesurfer.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: file to resample
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    resampled_file: medimage/nifti1
+    # type=file: output filename
+    # type=file|default=<undefined>: output filename
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    resampled_file: '"resampled.nii"'
+    # type=file: output filename
+    # type=file|default=<undefined>: output filename
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: file to resample
+    resampled_file:
+    # type=file: output filename
+    # type=file|default=<undefined>: output filename
+    voxel_size:
+    # type=tuple|default=(0.0, 0.0, 0.0): triplet of output voxel sizes
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: file to resample
+    resampled_file: '"resampled.nii"'
+    # type=file: output filename
+    # type=file|default=<undefined>: output filename
+    voxel_size: (2.1, 2.1, 2.1)
+    # type=tuple|default=(0.0, 0.0, 0.0): triplet of output voxel sizes
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: mri_convert -vs 2.10 2.10 2.10 -i structural.nii -o resampled.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: file to resample
+    resampled_file: '"resampled.nii"'
+    # type=file: output filename
+    # type=file|default=<undefined>: output filename
+    voxel_size: (2.1, 2.1, 2.1)
+    # type=tuple|default=(0.0, 0.0, 0.0): triplet of output voxel sizes
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/resample_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/resample_callables.py
new file mode 100644
index 00000000..1e012806
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/resample_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Resample.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/robust_register.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/robust_register.yaml
new file mode 100644
index 00000000..9b7637dc
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/robust_register.yaml
@@ -0,0 +1,234 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.preprocess.RobustRegister' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Perform intramodal linear registration (translation and rotation) using
+#     robust statistics.
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces.freesurfer import RobustRegister
+#     >>> reg = RobustRegister()
+#     >>> reg.inputs.source_file = 'structural.nii'
+#     >>> reg.inputs.target_file = 'T1.nii'
+#     >>> reg.inputs.auto_sens = True
+#     >>> reg.inputs.init_orient = True
+#     >>> reg.cmdline # doctest: +ELLIPSIS
+#     'mri_robust_register --satit --initorient --lta .../structural_robustreg.lta --mov structural.nii --dst T1.nii'
+# 
+#     References
+#     ----------
+#     Reuter, M, Rosas, HD, and Fischl, B, (2010). Highly Accurate Inverse
+#         Consistent Registration: A Robust Approach.  Neuroimage 53(4) 1181-96.
+# 
+#     
+task_name: RobustRegister
+nipype_name: RobustRegister
+nipype_module: nipype.interfaces.freesurfer.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    source_file: medimage/nifti1
+    # type=file|default=<undefined>: volume to be registered
+    target_file: medimage/nifti1
+    # type=file|default=<undefined>: target volume for the registration
+    in_xfm_file: generic/file
+    # type=file|default=<undefined>: use initial transform on source
+    mask_source: generic/file
+    # type=file|default=<undefined>: image to mask source volume with
+    mask_target: generic/file
+    # type=file|default=<undefined>: image to mask target volume with
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_reg_file: generic/file
+    # type=file: output registration file
+    # type=traitcompound|default=True: registration file; either True or filename
+    registered_file: generic/file
+    # type=file: output image with registration applied
+    # type=traitcompound|default=None: registered image; either True or filename
+    weights_file: generic/file
+    # type=file: image of weights used
+    # type=traitcompound|default=None: weights image to write; either True or filename
+    half_source: generic/file
+    # type=file: source image mapped to halfway space
+    # type=traitcompound|default=None: write source volume mapped to halfway space
+    half_targ: generic/file
+    # type=file: target image mapped to halfway space
+    # type=traitcompound|default=None: write target volume mapped to halfway space
+    half_weights: generic/file
+    # type=file: weights image mapped to halfway space
+    # type=traitcompound|default=None: write weights volume mapped to halfway space
+    half_source_xfm: generic/file
+    # type=file: transform file to map source image to halfway space
+    # type=traitcompound|default=None: write transform from source to halfway space
+    half_targ_xfm: generic/file
+    # type=file: transform file to map target image to halfway space
+    # type=traitcompound|default=None: write transform from target to halfway space
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    source_file:
+    # type=file|default=<undefined>: volume to be registered
+    target_file:
+    # type=file|default=<undefined>: target volume for the registration
+    out_reg_file:
+    # type=file: output registration file
+    # type=traitcompound|default=True: registration file; either True or filename
+    registered_file:
+    # type=file: output image with registration applied
+    # type=traitcompound|default=None: registered image; either True or filename
+    weights_file:
+    # type=file: image of weights used
+    # type=traitcompound|default=None: weights image to write; either True or filename
+    est_int_scale:
+    # type=bool|default=False: estimate intensity scale (recommended for unnormalized images)
+    trans_only:
+    # type=bool|default=False: find 3 parameter translation only
+    in_xfm_file:
+    # type=file|default=<undefined>: use initial transform on source
+    half_source:
+    # type=file: source image mapped to halfway space
+    # type=traitcompound|default=None: write source volume mapped to halfway space
+    half_targ:
+    # type=file: target image mapped to halfway space
+    # type=traitcompound|default=None: write target volume mapped to halfway space
+    half_weights:
+    # type=file: weights image mapped to halfway space
+    # type=traitcompound|default=None: write weights volume mapped to halfway space
+    half_source_xfm:
+    # type=file: transform file to map source image to halfway space
+    # type=traitcompound|default=None: write transform from source to halfway space
+    half_targ_xfm:
+    # type=file: transform file to map target image to halfway space
+    # type=traitcompound|default=None: write transform from target to halfway space
+    auto_sens:
+    # type=bool|default=False: auto-detect good sensitivity
+    outlier_sens:
+    # type=float|default=0.0: set outlier sensitivity explicitly
+    least_squares:
+    # type=bool|default=False: use least squares instead of robust estimator
+    no_init:
+    # type=bool|default=False: skip transform init
+    init_orient:
+    # type=bool|default=False: use moments for initial orient (recommended for stripped brains)
+    max_iterations:
+    # type=int|default=0: maximum # of times on each resolution
+    high_iterations:
+    # type=int|default=0: max # of times on highest resolution
+    iteration_thresh:
+    # type=float|default=0.0: stop iterations when below threshold
+    subsample_thresh:
+    # type=int|default=0: subsample if dimension is above threshold size
+    outlier_limit:
+    # type=float|default=0.0: set maximal outlier limit in satit
+    write_vo2vox:
+    # type=bool|default=False: output vox2vox matrix (default is RAS2RAS)
+    no_multi:
+    # type=bool|default=False: work on highest resolution
+    mask_source:
+    # type=file|default=<undefined>: image to mask source volume with
+    mask_target:
+    # type=file|default=<undefined>: image to mask target volume with
+    force_double:
+    # type=bool|default=False: use double-precision intensities
+    force_float:
+    # type=bool|default=False: use float intensities
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    source_file:
+    # type=file|default=<undefined>: volume to be registered
+    target_file:
+    # type=file|default=<undefined>: target volume for the registration
+    auto_sens: 'True'
+    # type=bool|default=False: auto-detect good sensitivity
+    init_orient: 'True'
+    # type=bool|default=False: use moments for initial orient (recommended for stripped brains)
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: mri_robust_register --satit --initorient --lta .../structural_robustreg.lta --mov structural.nii --dst T1.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    source_file:
+    # type=file|default=<undefined>: volume to be registered
+    target_file:
+    # type=file|default=<undefined>: target volume for the registration
+    auto_sens: 'True'
+    # type=bool|default=False: auto-detect good sensitivity
+    init_orient: 'True'
+    # type=bool|default=False: use moments for initial orient (recommended for stripped brains)
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/robust_register_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/robust_register_callables.py
new file mode 100644
index 00000000..c9447444
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/robust_register_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in RobustRegister.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/robust_template.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/robust_template.yaml
new file mode 100644
index 00000000..a71baf75
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/robust_template.yaml
@@ -0,0 +1,297 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.longitudinal.RobustTemplate' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# construct an unbiased robust template for longitudinal volumes
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces.freesurfer import RobustTemplate
+#     >>> template = RobustTemplate()
+#     >>> template.inputs.in_files = ['structural.nii', 'functional.nii']
+#     >>> template.inputs.auto_detect_sensitivity = True
+#     >>> template.inputs.average_metric = 'mean'
+#     >>> template.inputs.initial_timepoint = 1
+#     >>> template.inputs.fixed_timepoint = True
+#     >>> template.inputs.no_iteration = True
+#     >>> template.inputs.subsample_threshold = 200
+#     >>> template.cmdline  #doctest:
+#     'mri_robust_template --satit --average 0 --fixtp --mov structural.nii functional.nii --inittp 1 --noit --template mri_robust_template_out.mgz --subsample 200'
+#     >>> template.inputs.out_file = 'T1.nii'
+#     >>> template.cmdline  #doctest:
+#     'mri_robust_template --satit --average 0 --fixtp --mov structural.nii functional.nii --inittp 1 --noit --template T1.nii --subsample 200'
+# 
+#     >>> template.inputs.transform_outputs = ['structural.lta',
+#     ...                                      'functional.lta']
+#     >>> template.inputs.scaled_intensity_outputs = ['structural-iscale.txt',
+#     ...                                             'functional-iscale.txt']
+#     >>> template.cmdline    #doctest: +ELLIPSIS
+#     'mri_robust_template --satit --average 0 --fixtp --mov structural.nii functional.nii --inittp 1 --noit --template T1.nii --iscaleout .../structural-iscale.txt .../functional-iscale.txt --subsample 200 --lta .../structural.lta .../functional.lta'
+# 
+#     >>> template.inputs.transform_outputs = True
+#     >>> template.inputs.scaled_intensity_outputs = True
+#     >>> template.cmdline    #doctest: +ELLIPSIS
+#     'mri_robust_template --satit --average 0 --fixtp --mov structural.nii functional.nii --inittp 1 --noit --template T1.nii --iscaleout .../is1.txt .../is2.txt --subsample 200 --lta .../tp1.lta .../tp2.lta'
+# 
+#     >>> template.run()  #doctest: +SKIP
+# 
+#     References
+#     ----------
+#     [https://surfer.nmr.mgh.harvard.edu/fswiki/mri_robust_template]
+# 
+#     
+task_name: RobustTemplate
+nipype_name: RobustTemplate
+nipype_module: nipype.interfaces.freesurfer.longitudinal
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_files: medimage/nifti1+list-of
+    # type=inputmultiobject|default=[]: input movable volumes to be aligned to common mean/median template
+    out_file: medimage/nifti1
+    # type=file: output template volume (final mean/median image)
+    # type=file|default='mri_robust_template_out.mgz': output template volume (final mean/median image)
+    initial_transforms: generic/file+list-of
+    # type=inputmultiobject|default=[]: use initial transforms (lta) on source
+    in_intensity_scales: generic/file+list-of
+    # type=inputmultiobject|default=[]: use initial intensity scales
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: medimage/nifti1
+    # type=file: output template volume (final mean/median image)
+    # type=file|default='mri_robust_template_out.mgz': output template volume (final mean/median image)
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_files:
+    # type=inputmultiobject|default=[]: input movable volumes to be aligned to common mean/median template
+    out_file:
+    # type=file: output template volume (final mean/median image)
+    # type=file|default='mri_robust_template_out.mgz': output template volume (final mean/median image)
+    auto_detect_sensitivity:
+    # type=bool|default=False: auto-detect good sensitivity (recommended for head or full brain scans)
+    outlier_sensitivity:
+    # type=float|default=0.0: set outlier sensitivity manually (e.g. "--sat 4.685" ). Higher values mean less sensitivity.
+    transform_outputs:
+    # type=outputmultiobject: output xform files from moving to template
+    # type=traitcompound|default=[None]: output xforms to template (for each input)
+    intensity_scaling:
+    # type=bool|default=False: allow also intensity scaling (default off)
+    scaled_intensity_outputs:
+    # type=outputmultiobject: output final intensity scales
+    # type=traitcompound|default=[None]: final intensity scales (will activate --iscale)
+    subsample_threshold:
+    # type=int|default=0: subsample if dim > # on all axes (default no subs.)
+    average_metric:
+    # type=enum|default='median'|allowed['mean','median']: construct template from: 0 Mean, 1 Median (default)
+    initial_timepoint:
+    # type=int|default=0: use TP# for special init (default random), 0: no init
+    fixed_timepoint:
+    # type=bool|default=False: map everything to init TP# (init TP is not resampled)
+    no_iteration:
+    # type=bool|default=False: do not iterate, just create first template
+    initial_transforms:
+    # type=inputmultiobject|default=[]: use initial transforms (lta) on source
+    in_intensity_scales:
+    # type=inputmultiobject|default=[]: use initial intensity scales
+    num_threads:
+    # type=int|default=0: allows for specifying more threads
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_files:
+    # type=inputmultiobject|default=[]: input movable volumes to be aligned to common mean/median template
+    auto_detect_sensitivity: 'True'
+    # type=bool|default=False: auto-detect good sensitivity (recommended for head or full brain scans)
+    average_metric: '"mean"'
+    # type=enum|default='median'|allowed['mean','median']: construct template from: 0 Mean, 1 Median (default)
+    initial_timepoint: '1'
+    # type=int|default=0: use TP# for special init (default random), 0: no init
+    fixed_timepoint: 'True'
+    # type=bool|default=False: map everything to init TP# (init TP is not resampled)
+    no_iteration: 'True'
+    # type=bool|default=False: do not iterate, just create first template
+    subsample_threshold: '200'
+    # type=int|default=0: subsample if dim > # on all axes (default no subs.)
+    out_file:
+    # type=file: output template volume (final mean/median image)
+    # type=file|default='mri_robust_template_out.mgz': output template volume (final mean/median image)
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    transform_outputs: '["structural.lta","functional.lta"]'
+    # type=outputmultiobject: output xform files from moving to template
+    # type=traitcompound|default=[None]: output xforms to template (for each input)
+    scaled_intensity_outputs: '["structural-iscale.txt","functional-iscale.txt"]'
+    # type=outputmultiobject: output final intensity scales
+    # type=traitcompound|default=[None]: final intensity scales (will activate --iscale)
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    transform_outputs: 'True'
+    # type=outputmultiobject: output xform files from moving to template
+    # type=traitcompound|default=[None]: output xforms to template (for each input)
+    scaled_intensity_outputs: 'True'
+    # type=outputmultiobject: output final intensity scales
+    # type=traitcompound|default=[None]: final intensity scales (will activate --iscale)
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline:
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_files:
+    # type=inputmultiobject|default=[]: input movable volumes to be aligned to common mean/median template
+    auto_detect_sensitivity: 'True'
+    # type=bool|default=False: auto-detect good sensitivity (recommended for head or full brain scans)
+    average_metric: '"mean"'
+    # type=enum|default='median'|allowed['mean','median']: construct template from: 0 Mean, 1 Median (default)
+    initial_timepoint: '1'
+    # type=int|default=0: use TP# for special init (default random), 0: no init
+    fixed_timepoint: 'True'
+    # type=bool|default=False: map everything to init TP# (init TP is not resampled)
+    no_iteration: 'True'
+    # type=bool|default=False: do not iterate, just create first template
+    subsample_threshold: '200'
+    # type=int|default=0: subsample if dim > # on all axes (default no subs.)
+    out_file:
+    # type=file: output template volume (final mean/median image)
+    # type=file|default='mri_robust_template_out.mgz': output template volume (final mean/median image)
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline:
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    transform_outputs: '["structural.lta","functional.lta"]'
+    # type=outputmultiobject: output xform files from moving to template
+    # type=traitcompound|default=[None]: output xforms to template (for each input)
+    scaled_intensity_outputs: '["structural-iscale.txt","functional-iscale.txt"]'
+    # type=outputmultiobject: output final intensity scales
+    # type=traitcompound|default=[None]: final intensity scales (will activate --iscale)
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline:
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    transform_outputs: 'True'
+    # type=outputmultiobject: output xform files from moving to template
+    # type=traitcompound|default=[None]: output xforms to template (for each input)
+    scaled_intensity_outputs: 'True'
+    # type=outputmultiobject: output final intensity scales
+    # type=traitcompound|default=[None]: final intensity scales (will activate --iscale)
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/robust_template_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/robust_template_callables.py
new file mode 100644
index 00000000..4991aa92
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/robust_template_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in RobustTemplate.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/sample_to_surface.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/sample_to_surface.yaml
new file mode 100644
index 00000000..1a4a1290
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/sample_to_surface.yaml
@@ -0,0 +1,245 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.utils.SampleToSurface' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Sample a volume to the cortical surface using Freesurfer's mri_vol2surf.
+# 
+#     You must supply a sampling method, range, and units.  You can project
+#     either a given distance (in mm) or a given fraction of the cortical
+#     thickness at that vertex along the surface normal from the target surface,
+#     and then set the value of that vertex to be either the value at that point
+#     or the average or maximum value found along the projection vector.
+# 
+#     By default, the surface will be saved as a vector with a length equal to the
+#     number of vertices on the target surface.  This is not a problem for Freesurfer
+#     programs, but if you intend to use the file with interfaces to another package,
+#     you must set the ``reshape`` input to True, which will factor the surface vector
+#     into a matrix with dimensions compatible with proper Nifti files.
+# 
+#     Examples
+#     --------
+# 
+#     >>> import nipype.interfaces.freesurfer as fs
+#     >>> sampler = fs.SampleToSurface(hemi="lh")
+#     >>> sampler.inputs.source_file = "cope1.nii.gz"
+#     >>> sampler.inputs.reg_file = "register.dat"
+#     >>> sampler.inputs.sampling_method = "average"
+#     >>> sampler.inputs.sampling_range = 1
+#     >>> sampler.inputs.sampling_units = "frac"
+#     >>> sampler.cmdline  # doctest: +ELLIPSIS
+#     'mri_vol2surf --hemi lh --o ...lh.cope1.mgz --reg register.dat --projfrac-avg 1.000 --mov cope1.nii.gz'
+#     >>> res = sampler.run() # doctest: +SKIP
+# 
+#     
+task_name: SampleToSurface
+nipype_name: SampleToSurface
+nipype_module: nipype.interfaces.freesurfer.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    source_file: medimage/nifti-gz
+    # type=file|default=<undefined>: volume to sample values from
+    reference_file: generic/file
+    # type=file|default=<undefined>: reference volume (default is orig.mgz)
+    reg_file: datascience/dat-file
+    # type=file|default=<undefined>: source-to-reference registration file
+    mask_label: generic/file
+    # type=file|default=<undefined>: label file to mask output with
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: surface file
+    # type=file|default=<undefined>: surface file to write
+    hits_file: generic/file
+    # type=file: image with number of hits at each voxel
+    # type=traitcompound|default=None: save image with number of hits at each voxel
+    vox_file: generic/file
+    # type=file: text file with the number of voxels intersecting the surface
+    # type=traitcompound|default=None: text file with the number of voxels intersecting the surface
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: out_file
+    # type=file: surface file
+    # type=file|default=<undefined>: surface file to write
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    source_file:
+    # type=file|default=<undefined>: volume to sample values from
+    reference_file:
+    # type=file|default=<undefined>: reference volume (default is orig.mgz)
+    hemi:
+    # type=enum|default='lh'|allowed['lh','rh']: target hemisphere
+    surface:
+    # type=string|default='': target surface (default is white)
+    reg_file:
+    # type=file|default=<undefined>: source-to-reference registration file
+    reg_header:
+    # type=bool|default=False: register based on header geometry
+    mni152reg:
+    # type=bool|default=False: source volume is in MNI152 space
+    apply_rot:
+    # type=tuple|default=(0.0, 0.0, 0.0): rotation angles (in degrees) to apply to reg matrix
+    apply_trans:
+    # type=tuple|default=(0.0, 0.0, 0.0): translation (in mm) to apply to reg matrix
+    override_reg_subj:
+    # type=bool|default=False: override the subject in the reg file header
+    sampling_method:
+    # type=enum|default='point'|allowed['average','max','point']: how to sample -- at a point or at the max or average over a range
+    sampling_range:
+    # type=traitcompound|default=None: sampling range - a point or a tuple of (min, max, step)
+    sampling_units:
+    # type=enum|default='mm'|allowed['frac','mm']: sampling range type -- either 'mm' or 'frac'
+    projection_stem:
+    # type=string|default='': stem for precomputed linear estimates and volume fractions
+    smooth_vol:
+    # type=float|default=0.0: smooth input volume (mm fwhm)
+    smooth_surf:
+    # type=float|default=0.0: smooth output surface (mm fwhm)
+    interp_method:
+    # type=enum|default='nearest'|allowed['nearest','trilinear']: interpolation method
+    cortex_mask:
+    # type=bool|default=False: mask the target surface with hemi.cortex.label
+    mask_label:
+    # type=file|default=<undefined>: label file to mask output with
+    float2int_method:
+    # type=enum|default='round'|allowed['round','tkregister']: method to convert reg matrix values (default is round)
+    fix_tk_reg:
+    # type=bool|default=False: make reg matrix round-compatible
+    subject_id:
+    # type=string|default='': subject id
+    target_subject:
+    # type=string|default='': sample to surface of different subject than source
+    surf_reg:
+    # type=traitcompound|default=None: use surface registration to target subject
+    ico_order:
+    # type=int|default=0: icosahedron order when target_subject is 'ico'
+    reshape:
+    # type=bool|default=False: reshape surface vector to fit in non-mgh format
+    no_reshape:
+    # type=bool|default=False: do not reshape surface vector (default)
+    reshape_slices:
+    # type=int|default=0: number of 'slices' for reshaping
+    scale_input:
+    # type=float|default=0.0: multiple all intensities by scale factor
+    frame:
+    # type=int|default=0: save only one frame (0-based)
+    out_file:
+    # type=file: surface file
+    # type=file|default=<undefined>: surface file to write
+    out_type:
+    # type=enum|default='cor'|allowed['afni','analyze','analyze4d','bfloat','brik','bshort','cor','gdf','gii','mgh','mgz','minc','nifti1','nii','niigz','otl','outline','sdt','spm']: output file type
+    hits_file:
+    # type=file: image with number of hits at each voxel
+    # type=traitcompound|default=None: save image with number of hits at each voxel
+    hits_type:
+    # type=enum|default='cor'|allowed['afni','analyze','analyze4d','bfloat','brik','bshort','cor','gdf','mgh','mgz','minc','nifti1','nii','niigz','otl','outline','sdt','spm']: hits file type
+    vox_file:
+    # type=file: text file with the number of voxels intersecting the surface
+    # type=traitcompound|default=None: text file with the number of voxels intersecting the surface
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    source_file:
+    # type=file|default=<undefined>: volume to sample values from
+    reg_file:
+    # type=file|default=<undefined>: source-to-reference registration file
+    sampling_method: '"average"'
+    # type=enum|default='point'|allowed['average','max','point']: how to sample -- at a point or at the max or average over a range
+    sampling_range: '1'
+    # type=traitcompound|default=None: sampling range - a point or a tuple of (min, max, step)
+    sampling_units: '"frac"'
+    # type=enum|default='mm'|allowed['frac','mm']: sampling range type -- either 'mm' or 'frac'
+    hemi: '"lh"'
+    # type=enum|default='lh'|allowed['lh','rh']: target hemisphere
+  imports: &id001
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  - module: nipype.interfaces.freesurfer as fs
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: mri_vol2surf --hemi lh --o ...lh.cope1.mgz --reg register.dat --projfrac-avg 1.000 --mov cope1.nii.gz
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    source_file:
+    # type=file|default=<undefined>: volume to sample values from
+    reg_file:
+    # type=file|default=<undefined>: source-to-reference registration file
+    sampling_method: '"average"'
+    # type=enum|default='point'|allowed['average','max','point']: how to sample -- at a point or at the max or average over a range
+    sampling_range: '1'
+    # type=traitcompound|default=None: sampling range - a point or a tuple of (min, max, step)
+    sampling_units: '"frac"'
+    # type=enum|default='mm'|allowed['frac','mm']: sampling range type -- either 'mm' or 'frac'
+    hemi: '"lh"'
+    # type=enum|default='lh'|allowed['lh','rh']: target hemisphere
+  imports: *id001
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/sample_to_surface_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/sample_to_surface_callables.py
new file mode 100644
index 00000000..540762f7
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/sample_to_surface_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in SampleToSurface.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/seg_stats.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/seg_stats.yaml
new file mode 100644
index 00000000..5015d0be
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/seg_stats.yaml
@@ -0,0 +1,253 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.model.SegStats' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Use FreeSurfer mri_segstats for ROI analysis
+# 
+#     Examples
+#     --------
+#     >>> import nipype.interfaces.freesurfer as fs
+#     >>> ss = fs.SegStats()
+#     >>> ss.inputs.annot = ('PWS04', 'lh', 'aparc')
+#     >>> ss.inputs.in_file = 'functional.nii'
+#     >>> ss.inputs.subjects_dir = '.'
+#     >>> ss.inputs.avgwf_txt_file = 'avgwf.txt'
+#     >>> ss.inputs.summary_file = 'summary.stats'
+#     >>> ss.cmdline
+#     'mri_segstats --annot PWS04 lh aparc --avgwf ./avgwf.txt --i functional.nii --sum ./summary.stats'
+# 
+#     
+task_name: SegStats
+nipype_name: SegStats
+nipype_module: nipype.interfaces.freesurfer.model
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    segmentation_file: generic/file
+    # type=file|default=<undefined>: segmentation volume path
+    partial_volume_file: generic/file
+    # type=file|default=<undefined>: Compensate for partial voluming
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: Use the segmentation to report stats on this volume
+    color_table_file: generic/file
+    # type=file|default=<undefined>: color table file with seg id names
+    gca_color_table: generic/file
+    # type=file|default=<undefined>: get color table from GCA (CMA)
+    mask_file: generic/file
+    # type=file|default=<undefined>: Mask volume (same size as seg
+    brainmask_file: generic/file
+    # type=file|default=<undefined>: Load brain mask and compute the volume of the brain as the non-zero voxels in this volume
+    in_intensity: generic/file
+    # type=file|default=<undefined>: Undocumented input norm.mgz file
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    summary_file: medimage-freesurfer/stats
+    # type=file: Segmentation summary statistics table
+    # type=file|default=<undefined>: Segmentation stats summary table file
+    avgwf_txt_file: text/text-file
+    # type=file: Text file with functional statistics averaged over segs
+    # type=traitcompound|default=None: Save average waveform into file (bool or filename)
+    avgwf_file: generic/file
+    # type=file: Volume with functional statistics averaged over segs
+    # type=traitcompound|default=None: Save as binary volume (bool or filename)
+    sf_avg_file: generic/file
+    # type=file: Text file with func statistics averaged over segs and framss
+    # type=traitcompound|default=None: Save mean across space and time
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    summary_file: '"summary.stats"'
+    # type=file: Segmentation summary statistics table
+    # type=file|default=<undefined>: Segmentation stats summary table file
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    segmentation_file:
+    # type=file|default=<undefined>: segmentation volume path
+    annot:
+    # type=tuple|default=('', 'lh', ''): subject hemi parc : use surface parcellation
+    surf_label:
+    # type=tuple|default=('', 'lh', ''): subject hemi label : use surface label
+    summary_file:
+    # type=file: Segmentation summary statistics table
+    # type=file|default=<undefined>: Segmentation stats summary table file
+    partial_volume_file:
+    # type=file|default=<undefined>: Compensate for partial voluming
+    in_file:
+    # type=file|default=<undefined>: Use the segmentation to report stats on this volume
+    frame:
+    # type=int|default=0: Report stats on nth frame of input volume
+    multiply:
+    # type=float|default=0.0: multiply input by val
+    calc_snr:
+    # type=bool|default=False: save mean/std as extra column in output table
+    calc_power:
+    # type=enum|default='sqr'|allowed['sqr','sqrt']: Compute either the sqr or the sqrt of the input
+    color_table_file:
+    # type=file|default=<undefined>: color table file with seg id names
+    default_color_table:
+    # type=bool|default=False: use $FREESURFER_HOME/FreeSurferColorLUT.txt
+    gca_color_table:
+    # type=file|default=<undefined>: get color table from GCA (CMA)
+    segment_id:
+    # type=list|default=[]: Manually specify segmentation ids
+    exclude_id:
+    # type=int|default=0: Exclude seg id from report
+    exclude_ctx_gm_wm:
+    # type=bool|default=False: exclude cortical gray and white matter
+    wm_vol_from_surf:
+    # type=bool|default=False: Compute wm volume from surf
+    cortex_vol_from_surf:
+    # type=bool|default=False: Compute cortex volume from surf
+    non_empty_only:
+    # type=bool|default=False: Only report nonempty segmentations
+    empty:
+    # type=bool|default=False: Report on segmentations listed in the color table
+    mask_file:
+    # type=file|default=<undefined>: Mask volume (same size as seg
+    mask_thresh:
+    # type=float|default=0.0: binarize mask with this threshold <0.5>
+    mask_sign:
+    # type=enum|default='abs'|allowed['--masksign %s','abs','neg','pos']: Sign for mask threshold: pos, neg, or abs
+    mask_frame:
+    # type=int|default='--maskframe %d': Mask with this (0 based) frame of the mask volume
+    mask_invert:
+    # type=bool|default=False: Invert binarized mask volume
+    mask_erode:
+    # type=int|default=0: Erode mask by some amount
+    brain_vol:
+    # type=enum|default='brain-vol-from-seg'|allowed['brain-vol-from-seg','brainmask']: Compute brain volume either with ``brainmask`` or ``brain-vol-from-seg``
+    brainmask_file:
+    # type=file|default=<undefined>: Load brain mask and compute the volume of the brain as the non-zero voxels in this volume
+    etiv:
+    # type=bool|default=False: Compute ICV from talairach transform
+    etiv_only:
+    # type=enum|default='etiv'|allowed['--%s-only','etiv','old-etiv']: Compute etiv and exit.  Use ``etiv`` or ``old-etiv``
+    avgwf_txt_file:
+    # type=file: Text file with functional statistics averaged over segs
+    # type=traitcompound|default=None: Save average waveform into file (bool or filename)
+    avgwf_file:
+    # type=file: Volume with functional statistics averaged over segs
+    # type=traitcompound|default=None: Save as binary volume (bool or filename)
+    sf_avg_file:
+    # type=file: Text file with func statistics averaged over segs and framss
+    # type=traitcompound|default=None: Save mean across space and time
+    vox:
+    # type=list|default=[]: Replace seg with all 0s except at C R S (three int inputs)
+    supratent:
+    # type=bool|default=False: Undocumented input flag
+    subcort_gm:
+    # type=bool|default=False: Compute volume of subcortical gray matter
+    total_gray:
+    # type=bool|default=False: Compute volume of total gray matter
+    euler:
+    # type=bool|default=False: Write out number of defect holes in orig.nofix based on the euler number
+    in_intensity:
+    # type=file|default=<undefined>: Undocumented input norm.mgz file
+    intensity_units:
+    # type=enum|default='MR'|allowed['MR']: Intensity units
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    annot: ("PWS04", "lh", "aparc")
+    # type=tuple|default=('', 'lh', ''): subject hemi parc : use surface parcellation
+    in_file:
+    # type=file|default=<undefined>: Use the segmentation to report stats on this volume
+    subjects_dir: '"."'
+    # type=directory|default=<undefined>: subjects directory
+    avgwf_txt_file: '"avgwf.txt"'
+    # type=file: Text file with functional statistics averaged over segs
+    # type=traitcompound|default=None: Save average waveform into file (bool or filename)
+    summary_file: '"summary.stats"'
+    # type=file: Segmentation summary statistics table
+    # type=file|default=<undefined>: Segmentation stats summary table file
+  imports: &id001
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  - module: nipype.interfaces.freesurfer as fs
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: mri_segstats --annot PWS04 lh aparc --avgwf ./avgwf.txt --i functional.nii --sum ./summary.stats
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    annot: ("PWS04", "lh", "aparc")
+    # type=tuple|default=('', 'lh', ''): subject hemi parc : use surface parcellation
+    in_file:
+    # type=file|default=<undefined>: Use the segmentation to report stats on this volume
+    subjects_dir: '"."'
+    # type=directory|default=<undefined>: subjects directory
+    avgwf_txt_file: '"avgwf.txt"'
+    # type=file: Text file with functional statistics averaged over segs
+    # type=traitcompound|default=None: Save average waveform into file (bool or filename)
+    summary_file: '"summary.stats"'
+    # type=file: Segmentation summary statistics table
+    # type=file|default=<undefined>: Segmentation stats summary table file
+  imports: *id001
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/seg_stats_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/seg_stats_callables.py
new file mode 100644
index 00000000..3bb4af02
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/seg_stats_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in SegStats.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/seg_stats_recon_all.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/seg_stats_recon_all.yaml
new file mode 100644
index 00000000..0c69f5d6
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/seg_stats_recon_all.yaml
@@ -0,0 +1,394 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.model.SegStatsReconAll' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     This class inherits SegStats and modifies it for use in a recon-all workflow.
+#     This implementation mandates implicit inputs that SegStats.
+#     To ensure backwards compatibility of SegStats, this class was created.
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces.freesurfer import SegStatsReconAll
+#     >>> segstatsreconall = SegStatsReconAll()
+#     >>> segstatsreconall.inputs.annot = ('PWS04', 'lh', 'aparc')
+#     >>> segstatsreconall.inputs.avgwf_txt_file = 'avgwf.txt'
+#     >>> segstatsreconall.inputs.summary_file = 'summary.stats'
+#     >>> segstatsreconall.inputs.subject_id = '10335'
+#     >>> segstatsreconall.inputs.ribbon = 'wm.mgz'
+#     >>> segstatsreconall.inputs.transform = 'trans.mat'
+#     >>> segstatsreconall.inputs.presurf_seg = 'wm.mgz'
+#     >>> segstatsreconall.inputs.lh_orig_nofix = 'lh.pial'
+#     >>> segstatsreconall.inputs.rh_orig_nofix = 'lh.pial'
+#     >>> segstatsreconall.inputs.lh_pial = 'lh.pial'
+#     >>> segstatsreconall.inputs.rh_pial = 'lh.pial'
+#     >>> segstatsreconall.inputs.lh_white = 'lh.pial'
+#     >>> segstatsreconall.inputs.rh_white = 'lh.pial'
+#     >>> segstatsreconall.inputs.empty = True
+#     >>> segstatsreconall.inputs.brain_vol = 'brain-vol-from-seg'
+#     >>> segstatsreconall.inputs.exclude_ctx_gm_wm = True
+#     >>> segstatsreconall.inputs.supratent = True
+#     >>> segstatsreconall.inputs.subcort_gm = True
+#     >>> segstatsreconall.inputs.etiv = True
+#     >>> segstatsreconall.inputs.wm_vol_from_surf = True
+#     >>> segstatsreconall.inputs.cortex_vol_from_surf = True
+#     >>> segstatsreconall.inputs.total_gray = True
+#     >>> segstatsreconall.inputs.euler = True
+#     >>> segstatsreconall.inputs.exclude_id = 0
+#     >>> segstatsreconall.cmdline
+#     'mri_segstats --annot PWS04 lh aparc --avgwf ./avgwf.txt --brain-vol-from-seg --surf-ctx-vol --empty --etiv --euler --excl-ctxgmwm --excludeid 0 --subcortgray --subject 10335 --supratent --totalgray --surf-wm-vol --sum ./summary.stats'
+# 
+#     
+task_name: SegStatsReconAll
+nipype_name: SegStatsReconAll
+nipype_module: nipype.interfaces.freesurfer.model
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    ribbon: medimage/mgh-gz
+    # type=file|default=<undefined>: Input file mri/ribbon.mgz
+    presurf_seg: medimage/mgh-gz
+    # type=file|default=<undefined>: Input segmentation volume
+    transform: datascience/text-matrix
+    # type=file|default=<undefined>: Input transform file
+    lh_orig_nofix: medimage-freesurfer/pial
+    # type=file|default=<undefined>: Input lh.orig.nofix
+    rh_orig_nofix: medimage-freesurfer/pial
+    # type=file|default=<undefined>: Input rh.orig.nofix
+    lh_white: medimage-freesurfer/pial
+    # type=file|default=<undefined>: Input file must be <subject_id>/surf/lh.white
+    rh_white: medimage-freesurfer/pial
+    # type=file|default=<undefined>: Input file must be <subject_id>/surf/rh.white
+    lh_pial: medimage-freesurfer/pial
+    # type=file|default=<undefined>: Input file must be <subject_id>/surf/lh.pial
+    rh_pial: medimage-freesurfer/pial
+    # type=file|default=<undefined>: Input file must be <subject_id>/surf/rh.pial
+    aseg: generic/file
+    # type=file|default=<undefined>: Mandatory implicit input in 5.3
+    segmentation_file: generic/file
+    # type=file|default=<undefined>: segmentation volume path
+    partial_volume_file: generic/file
+    # type=file|default=<undefined>: Compensate for partial voluming
+    in_file: generic/file
+    # type=file|default=<undefined>: Use the segmentation to report stats on this volume
+    color_table_file: generic/file
+    # type=file|default=<undefined>: color table file with seg id names
+    gca_color_table: generic/file
+    # type=file|default=<undefined>: get color table from GCA (CMA)
+    mask_file: generic/file
+    # type=file|default=<undefined>: Mask volume (same size as seg
+    brainmask_file: generic/file
+    # type=file|default=<undefined>: Load brain mask and compute the volume of the brain as the non-zero voxels in this volume
+    in_intensity: generic/file
+    # type=file|default=<undefined>: Undocumented input norm.mgz file
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    summary_file: medimage-freesurfer/stats
+    # type=file: Segmentation summary statistics table
+    # type=file|default=<undefined>: Segmentation stats summary table file
+    avgwf_txt_file: text/text-file
+    # type=file: Text file with functional statistics averaged over segs
+    # type=traitcompound|default=None: Save average waveform into file (bool or filename)
+    avgwf_file: generic/file
+    # type=file: Volume with functional statistics averaged over segs
+    # type=traitcompound|default=None: Save as binary volume (bool or filename)
+    sf_avg_file: generic/file
+    # type=file: Text file with func statistics averaged over segs and framss
+    # type=traitcompound|default=None: Save mean across space and time
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    summary_file: '"summary.stats"'
+    # type=file: Segmentation summary statistics table
+    # type=file|default=<undefined>: Segmentation stats summary table file
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    subject_id:
+    # type=string|default='subject_id': Subject id being processed
+    ribbon:
+    # type=file|default=<undefined>: Input file mri/ribbon.mgz
+    presurf_seg:
+    # type=file|default=<undefined>: Input segmentation volume
+    transform:
+    # type=file|default=<undefined>: Input transform file
+    lh_orig_nofix:
+    # type=file|default=<undefined>: Input lh.orig.nofix
+    rh_orig_nofix:
+    # type=file|default=<undefined>: Input rh.orig.nofix
+    lh_white:
+    # type=file|default=<undefined>: Input file must be <subject_id>/surf/lh.white
+    rh_white:
+    # type=file|default=<undefined>: Input file must be <subject_id>/surf/rh.white
+    lh_pial:
+    # type=file|default=<undefined>: Input file must be <subject_id>/surf/lh.pial
+    rh_pial:
+    # type=file|default=<undefined>: Input file must be <subject_id>/surf/rh.pial
+    aseg:
+    # type=file|default=<undefined>: Mandatory implicit input in 5.3
+    copy_inputs:
+    # type=bool|default=False: If running as a node, set this to True otherwise, this will copy the implicit inputs to the node directory.
+    segmentation_file:
+    # type=file|default=<undefined>: segmentation volume path
+    annot:
+    # type=tuple|default=('', 'lh', ''): subject hemi parc : use surface parcellation
+    surf_label:
+    # type=tuple|default=('', 'lh', ''): subject hemi label : use surface label
+    summary_file:
+    # type=file: Segmentation summary statistics table
+    # type=file|default=<undefined>: Segmentation stats summary table file
+    partial_volume_file:
+    # type=file|default=<undefined>: Compensate for partial voluming
+    in_file:
+    # type=file|default=<undefined>: Use the segmentation to report stats on this volume
+    frame:
+    # type=int|default=0: Report stats on nth frame of input volume
+    multiply:
+    # type=float|default=0.0: multiply input by val
+    calc_snr:
+    # type=bool|default=False: save mean/std as extra column in output table
+    calc_power:
+    # type=enum|default='sqr'|allowed['sqr','sqrt']: Compute either the sqr or the sqrt of the input
+    color_table_file:
+    # type=file|default=<undefined>: color table file with seg id names
+    default_color_table:
+    # type=bool|default=False: use $FREESURFER_HOME/FreeSurferColorLUT.txt
+    gca_color_table:
+    # type=file|default=<undefined>: get color table from GCA (CMA)
+    segment_id:
+    # type=list|default=[]: Manually specify segmentation ids
+    exclude_id:
+    # type=int|default=0: Exclude seg id from report
+    exclude_ctx_gm_wm:
+    # type=bool|default=False: exclude cortical gray and white matter
+    wm_vol_from_surf:
+    # type=bool|default=False: Compute wm volume from surf
+    cortex_vol_from_surf:
+    # type=bool|default=False: Compute cortex volume from surf
+    non_empty_only:
+    # type=bool|default=False: Only report nonempty segmentations
+    empty:
+    # type=bool|default=False: Report on segmentations listed in the color table
+    mask_file:
+    # type=file|default=<undefined>: Mask volume (same size as seg
+    mask_thresh:
+    # type=float|default=0.0: binarize mask with this threshold <0.5>
+    mask_sign:
+    # type=enum|default='abs'|allowed['--masksign %s','abs','neg','pos']: Sign for mask threshold: pos, neg, or abs
+    mask_frame:
+    # type=int|default='--maskframe %d': Mask with this (0 based) frame of the mask volume
+    mask_invert:
+    # type=bool|default=False: Invert binarized mask volume
+    mask_erode:
+    # type=int|default=0: Erode mask by some amount
+    brain_vol:
+    # type=enum|default='brain-vol-from-seg'|allowed['brain-vol-from-seg','brainmask']: Compute brain volume either with ``brainmask`` or ``brain-vol-from-seg``
+    brainmask_file:
+    # type=file|default=<undefined>: Load brain mask and compute the volume of the brain as the non-zero voxels in this volume
+    etiv:
+    # type=bool|default=False: Compute ICV from talairach transform
+    etiv_only:
+    # type=enum|default='etiv'|allowed['--%s-only','etiv','old-etiv']: Compute etiv and exit.  Use ``etiv`` or ``old-etiv``
+    avgwf_txt_file:
+    # type=file: Text file with functional statistics averaged over segs
+    # type=traitcompound|default=None: Save average waveform into file (bool or filename)
+    avgwf_file:
+    # type=file: Volume with functional statistics averaged over segs
+    # type=traitcompound|default=None: Save as binary volume (bool or filename)
+    sf_avg_file:
+    # type=file: Text file with func statistics averaged over segs and framss
+    # type=traitcompound|default=None: Save mean across space and time
+    vox:
+    # type=list|default=[]: Replace seg with all 0s except at C R S (three int inputs)
+    supratent:
+    # type=bool|default=False: Undocumented input flag
+    subcort_gm:
+    # type=bool|default=False: Compute volume of subcortical gray matter
+    total_gray:
+    # type=bool|default=False: Compute volume of total gray matter
+    euler:
+    # type=bool|default=False: Write out number of defect holes in orig.nofix based on the euler number
+    in_intensity:
+    # type=file|default=<undefined>: Undocumented input norm.mgz file
+    intensity_units:
+    # type=enum|default='MR'|allowed['MR']: Intensity units
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    annot: ("PWS04", "lh", "aparc")
+    # type=tuple|default=('', 'lh', ''): subject hemi parc : use surface parcellation
+    avgwf_txt_file: '"avgwf.txt"'
+    # type=file: Text file with functional statistics averaged over segs
+    # type=traitcompound|default=None: Save average waveform into file (bool or filename)
+    summary_file: '"summary.stats"'
+    # type=file: Segmentation summary statistics table
+    # type=file|default=<undefined>: Segmentation stats summary table file
+    subject_id: '"10335"'
+    # type=string|default='subject_id': Subject id being processed
+    ribbon:
+    # type=file|default=<undefined>: Input file mri/ribbon.mgz
+    transform:
+    # type=file|default=<undefined>: Input transform file
+    presurf_seg:
+    # type=file|default=<undefined>: Input segmentation volume
+    lh_orig_nofix:
+    # type=file|default=<undefined>: Input lh.orig.nofix
+    rh_orig_nofix:
+    # type=file|default=<undefined>: Input rh.orig.nofix
+    lh_pial:
+    # type=file|default=<undefined>: Input file must be <subject_id>/surf/lh.pial
+    rh_pial:
+    # type=file|default=<undefined>: Input file must be <subject_id>/surf/rh.pial
+    lh_white:
+    # type=file|default=<undefined>: Input file must be <subject_id>/surf/lh.white
+    rh_white:
+    # type=file|default=<undefined>: Input file must be <subject_id>/surf/rh.white
+    empty: 'True'
+    # type=bool|default=False: Report on segmentations listed in the color table
+    brain_vol: '"brain-vol-from-seg"'
+    # type=enum|default='brain-vol-from-seg'|allowed['brain-vol-from-seg','brainmask']: Compute brain volume either with ``brainmask`` or ``brain-vol-from-seg``
+    exclude_ctx_gm_wm: 'True'
+    # type=bool|default=False: exclude cortical gray and white matter
+    supratent: 'True'
+    # type=bool|default=False: Undocumented input flag
+    subcort_gm: 'True'
+    # type=bool|default=False: Compute volume of subcortical gray matter
+    etiv: 'True'
+    # type=bool|default=False: Compute ICV from talairach transform
+    wm_vol_from_surf: 'True'
+    # type=bool|default=False: Compute wm volume from surf
+    cortex_vol_from_surf: 'True'
+    # type=bool|default=False: Compute cortex volume from surf
+    total_gray: 'True'
+    # type=bool|default=False: Compute volume of total gray matter
+    euler: 'True'
+    # type=bool|default=False: Write out number of defect holes in orig.nofix based on the euler number
+    exclude_id: '0'
+    # type=int|default=0: Exclude seg id from report
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: mri_segstats --annot PWS04 lh aparc --avgwf ./avgwf.txt --brain-vol-from-seg --surf-ctx-vol --empty --etiv --euler --excl-ctxgmwm --excludeid 0 --subcortgray --subject 10335 --supratent --totalgray --surf-wm-vol --sum ./summary.stats
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    annot: ("PWS04", "lh", "aparc")
+    # type=tuple|default=('', 'lh', ''): subject hemi parc : use surface parcellation
+    avgwf_txt_file: '"avgwf.txt"'
+    # type=file: Text file with functional statistics averaged over segs
+    # type=traitcompound|default=None: Save average waveform into file (bool or filename)
+    summary_file: '"summary.stats"'
+    # type=file: Segmentation summary statistics table
+    # type=file|default=<undefined>: Segmentation stats summary table file
+    subject_id: '"10335"'
+    # type=string|default='subject_id': Subject id being processed
+    ribbon:
+    # type=file|default=<undefined>: Input file mri/ribbon.mgz
+    transform:
+    # type=file|default=<undefined>: Input transform file
+    presurf_seg:
+    # type=file|default=<undefined>: Input segmentation volume
+    lh_orig_nofix:
+    # type=file|default=<undefined>: Input lh.orig.nofix
+    rh_orig_nofix:
+    # type=file|default=<undefined>: Input rh.orig.nofix
+    lh_pial:
+    # type=file|default=<undefined>: Input file must be <subject_id>/surf/lh.pial
+    rh_pial:
+    # type=file|default=<undefined>: Input file must be <subject_id>/surf/rh.pial
+    lh_white:
+    # type=file|default=<undefined>: Input file must be <subject_id>/surf/lh.white
+    rh_white:
+    # type=file|default=<undefined>: Input file must be <subject_id>/surf/rh.white
+    empty: 'True'
+    # type=bool|default=False: Report on segmentations listed in the color table
+    brain_vol: '"brain-vol-from-seg"'
+    # type=enum|default='brain-vol-from-seg'|allowed['brain-vol-from-seg','brainmask']: Compute brain volume either with ``brainmask`` or ``brain-vol-from-seg``
+    exclude_ctx_gm_wm: 'True'
+    # type=bool|default=False: exclude cortical gray and white matter
+    supratent: 'True'
+    # type=bool|default=False: Undocumented input flag
+    subcort_gm: 'True'
+    # type=bool|default=False: Compute volume of subcortical gray matter
+    etiv: 'True'
+    # type=bool|default=False: Compute ICV from talairach transform
+    wm_vol_from_surf: 'True'
+    # type=bool|default=False: Compute wm volume from surf
+    cortex_vol_from_surf: 'True'
+    # type=bool|default=False: Compute cortex volume from surf
+    total_gray: 'True'
+    # type=bool|default=False: Compute volume of total gray matter
+    euler: 'True'
+    # type=bool|default=False: Write out number of defect holes in orig.nofix based on the euler number
+    exclude_id: '0'
+    # type=int|default=0: Exclude seg id from report
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/seg_stats_recon_all_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/seg_stats_recon_all_callables.py
new file mode 100644
index 00000000..7c5925a0
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/seg_stats_recon_all_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in SegStatsReconAll.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/segment_cc.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/segment_cc.yaml
new file mode 100644
index 00000000..58a497df
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/segment_cc.yaml
@@ -0,0 +1,167 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.preprocess.SegmentCC' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     This program segments the corpus callosum into five separate labels in
+#     the subcortical segmentation volume 'aseg.mgz'. The divisions of the
+#     cc are equally spaced in terms of distance along the primary
+#     eigendirection (pretty much the long axis) of the cc. The lateral
+#     extent can be changed with the -T <thickness> parameter, where
+#     <thickness> is the distance off the midline (so -T 1 would result in
+#     the who CC being 3mm thick). The default is 2 so it's 5mm thick. The
+#     aseg.stats values should be volume.
+# 
+#     Examples
+#     ========
+#     >>> from nipype.interfaces import freesurfer
+#     >>> SegmentCC_node = freesurfer.SegmentCC()
+#     >>> SegmentCC_node.inputs.in_file = "aseg.mgz"
+#     >>> SegmentCC_node.inputs.in_norm = "norm.mgz"
+#     >>> SegmentCC_node.inputs.out_rotation = "cc.lta"
+#     >>> SegmentCC_node.inputs.subject_id = "test"
+#     >>> SegmentCC_node.cmdline
+#     'mri_cc -aseg aseg.mgz -o aseg.auto.mgz -lta cc.lta test'
+#     
+task_name: SegmentCC
+nipype_name: SegmentCC
+nipype_module: nipype.interfaces.freesurfer.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/mgh-gz
+    # type=file|default=<undefined>: Input aseg file to read from subjects directory
+    in_norm: medimage/mgh-gz
+    # type=file|default=<undefined>: Required undocumented input {subject}/mri/norm.mgz
+    out_file: generic/file
+    # type=file: Output segmentation uncluding corpus collosum
+    # type=file|default=<undefined>: Filename to write aseg including CC
+    out_rotation: medimage-freesurfer/lta
+    # type=file: Output lta rotation file
+    # type=file|default=<undefined>: Global filepath for writing rotation lta
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: Output segmentation uncluding corpus collosum
+    # type=file|default=<undefined>: Filename to write aseg including CC
+    out_rotation: medimage-freesurfer/lta
+    # type=file: Output lta rotation file
+    # type=file|default=<undefined>: Global filepath for writing rotation lta
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: Input aseg file to read from subjects directory
+    in_norm:
+    # type=file|default=<undefined>: Required undocumented input {subject}/mri/norm.mgz
+    out_file:
+    # type=file: Output segmentation uncluding corpus collosum
+    # type=file|default=<undefined>: Filename to write aseg including CC
+    out_rotation:
+    # type=file: Output lta rotation file
+    # type=file|default=<undefined>: Global filepath for writing rotation lta
+    subject_id:
+    # type=string|default='subject_id': Subject name
+    copy_inputs:
+    # type=bool|default=False: If running as a node, set this to True.This will copy the input files to the node directory.
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: Input aseg file to read from subjects directory
+    in_norm:
+    # type=file|default=<undefined>: Required undocumented input {subject}/mri/norm.mgz
+    out_rotation:
+    # type=file: Output lta rotation file
+    # type=file|default=<undefined>: Global filepath for writing rotation lta
+    subject_id: '"test"'
+    # type=string|default='subject_id': Subject name
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: mri_cc -aseg aseg.mgz -o aseg.auto.mgz -lta cc.lta test
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: Input aseg file to read from subjects directory
+    in_norm:
+    # type=file|default=<undefined>: Required undocumented input {subject}/mri/norm.mgz
+    out_rotation:
+    # type=file: Output lta rotation file
+    # type=file|default=<undefined>: Global filepath for writing rotation lta
+    subject_id: '"test"'
+    # type=string|default='subject_id': Subject name
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/segment_cc_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/segment_cc_callables.py
new file mode 100644
index 00000000..e5ed1b47
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/segment_cc_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in SegmentCC.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/segment_wm.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/segment_wm.yaml
new file mode 100644
index 00000000..987bdbe2
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/segment_wm.yaml
@@ -0,0 +1,136 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.preprocess.SegmentWM' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     This program segments white matter from the input volume.  The input
+#     volume should be normalized such that white matter voxels are
+#     ~110-valued, and the volume is conformed to 256^3.
+# 
+# 
+#     Examples
+#     ========
+#     >>> from nipype.interfaces import freesurfer
+#     >>> SegmentWM_node = freesurfer.SegmentWM()
+#     >>> SegmentWM_node.inputs.in_file = "norm.mgz"
+#     >>> SegmentWM_node.inputs.out_file = "wm.seg.mgz"
+#     >>> SegmentWM_node.cmdline
+#     'mri_segment norm.mgz wm.seg.mgz'
+#     
+task_name: SegmentWM
+nipype_name: SegmentWM
+nipype_module: nipype.interfaces.freesurfer.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/mgh-gz
+    # type=file|default=<undefined>: Input file for SegmentWM
+    out_file: medimage/mgh-gz
+    # type=file: Output white matter segmentation
+    # type=file|default=<undefined>: File to be written as output for SegmentWM
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: medimage/mgh-gz
+    # type=file: Output white matter segmentation
+    # type=file|default=<undefined>: File to be written as output for SegmentWM
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: Input file for SegmentWM
+    out_file:
+    # type=file: Output white matter segmentation
+    # type=file|default=<undefined>: File to be written as output for SegmentWM
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: Input file for SegmentWM
+    out_file:
+    # type=file: Output white matter segmentation
+    # type=file|default=<undefined>: File to be written as output for SegmentWM
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: mri_segment norm.mgz wm.seg.mgz
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: Input file for SegmentWM
+    out_file:
+    # type=file: Output white matter segmentation
+    # type=file|default=<undefined>: File to be written as output for SegmentWM
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/segment_wm_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/segment_wm_callables.py
new file mode 100644
index 00000000..8ab02a19
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/segment_wm_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in SegmentWM.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/smooth.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/smooth.yaml
new file mode 100644
index 00000000..4dd8d6da
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/smooth.yaml
@@ -0,0 +1,167 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.preprocess.Smooth' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Use FreeSurfer mris_volsmooth to smooth a volume
+# 
+#     This function smoothes cortical regions on a surface and non-cortical
+#     regions in volume.
+# 
+#     .. note::
+#        Cortical voxels are mapped to the surface (3D->2D) and then the
+#        smoothed values from the surface are put back into the volume to fill
+#        the cortical ribbon. If data is smoothed with this algorithm, one has to
+#        be careful about how further processing is interpreted.
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces.freesurfer import Smooth
+#     >>> smoothvol = Smooth(in_file='functional.nii', smoothed_file = 'foo_out.nii', reg_file='register.dat', surface_fwhm=10, vol_fwhm=6)
+#     >>> smoothvol.cmdline
+#     'mris_volsmooth --i functional.nii --reg register.dat --o foo_out.nii --fwhm 10.000000 --vol-fwhm 6.000000'
+# 
+#     
+task_name: Smooth
+nipype_name: Smooth
+nipype_module: nipype.interfaces.freesurfer.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: source volume
+    reg_file: datascience/dat-file
+    # type=file|default=<undefined>: registers volume to surface anatomical 
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    smoothed_file: medimage/nifti1
+    # type=file: smoothed input volume
+    # type=file|default=<undefined>: output volume
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    smoothed_file: '"foo_out.nii"'
+    # type=file: smoothed input volume
+    # type=file|default=<undefined>: output volume
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: source volume
+    reg_file:
+    # type=file|default=<undefined>: registers volume to surface anatomical 
+    smoothed_file:
+    # type=file: smoothed input volume
+    # type=file|default=<undefined>: output volume
+    proj_frac_avg:
+    # type=tuple|default=(0.0, 0.0, 0.0): average a long normal min max delta
+    proj_frac:
+    # type=float|default=0.0: project frac of thickness a long surface normal
+    surface_fwhm:
+    # type=range|default=0.0: surface FWHM in mm
+    num_iters:
+    # type=range|default=1: number of iterations instead of fwhm
+    vol_fwhm:
+    # type=range|default=0.0: volume smoothing outside of surface
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: source volume
+    smoothed_file: '"foo_out.nii"'
+    # type=file: smoothed input volume
+    # type=file|default=<undefined>: output volume
+    reg_file:
+    # type=file|default=<undefined>: registers volume to surface anatomical 
+    surface_fwhm: '10'
+    # type=range|default=0.0: surface FWHM in mm
+    vol_fwhm: '6'
+    # type=range|default=0.0: volume smoothing outside of surface
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: mris_volsmooth --i functional.nii --reg register.dat --o foo_out.nii --fwhm 10.000000 --vol-fwhm 6.000000
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: source volume
+    smoothed_file: '"foo_out.nii"'
+    # type=file: smoothed input volume
+    # type=file|default=<undefined>: output volume
+    reg_file:
+    # type=file|default=<undefined>: registers volume to surface anatomical 
+    surface_fwhm: '10'
+    # type=range|default=0.0: surface FWHM in mm
+    vol_fwhm: '6'
+    # type=range|default=0.0: volume smoothing outside of surface
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/smooth_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/smooth_callables.py
new file mode 100644
index 00000000..5dbe8c1a
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/smooth_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Smooth.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/smooth_tessellation.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/smooth_tessellation.yaml
new file mode 100644
index 00000000..ee00618b
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/smooth_tessellation.yaml
@@ -0,0 +1,123 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.utils.SmoothTessellation' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Smooth a tessellated surface.
+# 
+#     See Also
+#     --------
+#     `nipype.interfaces.freesurfer.utils.SurfaceSmooth`_ interface for smoothing a scalar field
+#     along a surface manifold
+# 
+#     Example
+#     -------
+#     >>> import nipype.interfaces.freesurfer as fs
+#     >>> smooth = fs.SmoothTessellation()
+#     >>> smooth.inputs.in_file = 'lh.hippocampus.stl'
+#     >>> smooth.run() # doctest: +SKIP
+# 
+#     
+task_name: SmoothTessellation
+nipype_name: SmoothTessellation
+nipype_module: nipype.interfaces.freesurfer.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: Input volume to tessellate voxels from.
+    out_curvature_file: generic/file
+    # type=file|default=<undefined>: Write curvature to ``?h.curvname`` (default "curv")
+    out_area_file: generic/file
+    # type=file|default=<undefined>: Write area to ``?h.areaname`` (default "area")
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    surface: generic/file
+    # type=file: Smoothed surface file.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: out_file
+    # type=file|default=<undefined>: output filename or True to generate one
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: Input volume to tessellate voxels from.
+    curvature_averaging_iterations:
+    # type=int|default=0: Number of curvature averaging iterations (default=10)
+    smoothing_iterations:
+    # type=int|default=0: Number of smoothing iterations (default=10)
+    snapshot_writing_iterations:
+    # type=int|default=0: Write snapshot every *n* iterations
+    use_gaussian_curvature_smoothing:
+    # type=bool|default=False: Use Gaussian curvature smoothing
+    gaussian_curvature_norm_steps:
+    # type=int|default=0: Use Gaussian curvature smoothing
+    gaussian_curvature_smoothing_steps:
+    # type=int|default=0: Use Gaussian curvature smoothing
+    disable_estimates:
+    # type=bool|default=False: Disables the writing of curvature and area estimates
+    normalize_area:
+    # type=bool|default=False: Normalizes the area after smoothing
+    use_momentum:
+    # type=bool|default=False: Uses momentum
+    out_file:
+    # type=file|default=<undefined>: output filename or True to generate one
+    out_curvature_file:
+    # type=file|default=<undefined>: Write curvature to ``?h.curvname`` (default "curv")
+    out_area_file:
+    # type=file|default=<undefined>: Write area to ``?h.areaname`` (default "area")
+    seed:
+    # type=int|default=0: Seed for setting random number generator
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/smooth_tessellation_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/smooth_tessellation_callables.py
new file mode 100644
index 00000000..fba09942
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/smooth_tessellation_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in SmoothTessellation.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/sphere.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/sphere.yaml
new file mode 100644
index 00000000..f7a15dff
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/sphere.yaml
@@ -0,0 +1,136 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.utils.Sphere' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     This program will add a template into an average surface
+# 
+#     Examples
+#     ========
+#     >>> from nipype.interfaces.freesurfer import Sphere
+#     >>> sphere = Sphere()
+#     >>> sphere.inputs.in_file = 'lh.pial'
+#     >>> sphere.cmdline
+#     'mris_sphere lh.pial lh.sphere'
+#     
+task_name: Sphere
+nipype_name: Sphere
+nipype_module: nipype.interfaces.freesurfer.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage-freesurfer/pial
+    # type=file|default=<undefined>: Input file for Sphere
+    out_file: generic/file
+    # type=file: Output file for Sphere
+    # type=file|default=<undefined>: Output file for Sphere
+    in_smoothwm: generic/file
+    # type=file|default=<undefined>: Input surface required when -q flag is not selected
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: Output file for Sphere
+    # type=file|default=<undefined>: Output file for Sphere
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: Input file for Sphere
+    out_file:
+    # type=file: Output file for Sphere
+    # type=file|default=<undefined>: Output file for Sphere
+    seed:
+    # type=int|default=0: Seed for setting random number generator
+    magic:
+    # type=bool|default=False: No documentation. Direct questions to analysis-bugs@nmr.mgh.harvard.edu
+    in_smoothwm:
+    # type=file|default=<undefined>: Input surface required when -q flag is not selected
+    num_threads:
+    # type=int|default=0: allows for specifying more threads
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: Input file for Sphere
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: mris_sphere lh.pial lh.sphere
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: Input file for Sphere
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/sphere_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/sphere_callables.py
new file mode 100644
index 00000000..ab4fc1b8
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/sphere_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Sphere.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/spherical_average.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/spherical_average.yaml
new file mode 100644
index 00000000..f5b28b69
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/spherical_average.yaml
@@ -0,0 +1,189 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.model.SphericalAverage' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     This program will add a template into an average surface.
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces.freesurfer import SphericalAverage
+#     >>> sphericalavg = SphericalAverage()
+#     >>> sphericalavg.inputs.out_file = 'test.out'
+#     >>> sphericalavg.inputs.in_average = '.'
+#     >>> sphericalavg.inputs.in_surf = 'lh.pial'
+#     >>> sphericalavg.inputs.hemisphere = 'lh'
+#     >>> sphericalavg.inputs.fname = 'lh.entorhinal'
+#     >>> sphericalavg.inputs.which = 'label'
+#     >>> sphericalavg.inputs.subject_id = '10335'
+#     >>> sphericalavg.inputs.erode = 2
+#     >>> sphericalavg.inputs.threshold = 5
+#     >>> sphericalavg.cmdline
+#     'mris_spherical_average -erode 2 -o 10335 -t 5.0 label lh.entorhinal lh pial . test.out'
+# 
+#     
+task_name: SphericalAverage
+nipype_name: SphericalAverage
+nipype_module: nipype.interfaces.freesurfer.model
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_surf: medimage-freesurfer/pial
+    # type=file|default=<undefined>: Input surface file
+    in_orig: generic/file
+    # type=file|default=<undefined>: Original surface filename
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: medimage-freesurfer/out
+    # type=file: Output label
+    # type=file|default=<undefined>: Output filename
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: '"test.out"'
+    # type=file: Output label
+    # type=file|default=<undefined>: Output filename
+    in_average: '"."'
+    # type=directory|default=<undefined>: Average subject
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    out_file:
+    # type=file: Output label
+    # type=file|default=<undefined>: Output filename
+    in_average:
+    # type=directory|default=<undefined>: Average subject
+    in_surf:
+    # type=file|default=<undefined>: Input surface file
+    hemisphere:
+    # type=enum|default='lh'|allowed['lh','rh']: Input hemisphere
+    fname:
+    # type=string|default='': Filename from the average subject directory. Example: to use rh.entorhinal.label as the input label filename, set fname to 'rh.entorhinal' and which to 'label'. The program will then search for ``<in_average>/label/rh.entorhinal.label``
+    which:
+    # type=enum|default='coords'|allowed['area','coords','curv','label','vals']: No documentation
+    subject_id:
+    # type=string|default='': Output subject id
+    erode:
+    # type=int|default=0: Undocumented
+    in_orig:
+    # type=file|default=<undefined>: Original surface filename
+    threshold:
+    # type=float|default=0.0: Undocumented
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    out_file: '"test.out"'
+    # type=file: Output label
+    # type=file|default=<undefined>: Output filename
+    in_average: '"."'
+    # type=directory|default=<undefined>: Average subject
+    in_surf:
+    # type=file|default=<undefined>: Input surface file
+    hemisphere: '"lh"'
+    # type=enum|default='lh'|allowed['lh','rh']: Input hemisphere
+    fname: '"lh.entorhinal"'
+    # type=string|default='': Filename from the average subject directory. Example: to use rh.entorhinal.label as the input label filename, set fname to 'rh.entorhinal' and which to 'label'. The program will then search for ``<in_average>/label/rh.entorhinal.label``
+    which: '"label"'
+    # type=enum|default='coords'|allowed['area','coords','curv','label','vals']: No documentation
+    subject_id: '"10335"'
+    # type=string|default='': Output subject id
+    erode: '2'
+    # type=int|default=0: Undocumented
+    threshold: '5'
+    # type=float|default=0.0: Undocumented
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: mris_spherical_average -erode 2 -o 10335 -t 5.0 label lh.entorhinal lh pial . test.out
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    out_file: '"test.out"'
+    # type=file: Output label
+    # type=file|default=<undefined>: Output filename
+    in_average: '"."'
+    # type=directory|default=<undefined>: Average subject
+    in_surf:
+    # type=file|default=<undefined>: Input surface file
+    hemisphere: '"lh"'
+    # type=enum|default='lh'|allowed['lh','rh']: Input hemisphere
+    fname: '"lh.entorhinal"'
+    # type=string|default='': Filename from the average subject directory. Example: to use rh.entorhinal.label as the input label filename, set fname to 'rh.entorhinal' and which to 'label'. The program will then search for ``<in_average>/label/rh.entorhinal.label``
+    which: '"label"'
+    # type=enum|default='coords'|allowed['area','coords','curv','label','vals']: No documentation
+    subject_id: '"10335"'
+    # type=string|default='': Output subject id
+    erode: '2'
+    # type=int|default=0: Undocumented
+    threshold: '5'
+    # type=float|default=0.0: Undocumented
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/spherical_average_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/spherical_average_callables.py
new file mode 100644
index 00000000..c5d3dc57
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/spherical_average_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in SphericalAverage.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/surface_2_vol_transform.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/surface_2_vol_transform.yaml
new file mode 100644
index 00000000..af2d956a
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/surface_2_vol_transform.yaml
@@ -0,0 +1,173 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.utils.Surface2VolTransform' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Use FreeSurfer mri_surf2vol to apply a transform.
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces.freesurfer import Surface2VolTransform
+#     >>> xfm2vol = Surface2VolTransform()
+#     >>> xfm2vol.inputs.source_file = 'lh.cope1.mgz'
+#     >>> xfm2vol.inputs.reg_file = 'register.mat'
+#     >>> xfm2vol.inputs.hemi = 'lh'
+#     >>> xfm2vol.inputs.template_file = 'cope1.nii.gz'
+#     >>> xfm2vol.inputs.subjects_dir = '.'
+#     >>> xfm2vol.cmdline
+#     'mri_surf2vol --hemi lh --volreg register.mat --surfval lh.cope1.mgz --sd . --template cope1.nii.gz --outvol lh.cope1_asVol.nii --vtxvol lh.cope1_asVol_vertex.nii'
+#     >>> res = xfm2vol.run()# doctest: +SKIP
+# 
+#     
+task_name: Surface2VolTransform
+nipype_name: Surface2VolTransform
+nipype_module: nipype.interfaces.freesurfer.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    source_file: medimage/mgh-gz
+    # type=file|default=<undefined>: This is the source of the surface values
+    transformed_file: generic/file
+    # type=file: Path to output file if used normally
+    # type=file|default=<undefined>: Output volume
+    reg_file: datascience/text-matrix
+    # type=file|default=<undefined>: tkRAS-to-tkRAS matrix   (tkregister2 format)
+    template_file: medimage/nifti-gz
+    # type=file|default=<undefined>: Output template volume
+    vertexvol_file: generic/file
+    # type=file: vertex map volume path id. Optional
+    # type=file|default=<undefined>: Path name of the vertex output volume, which is the same as output volume except that the value of each voxel is the vertex-id that is mapped to that voxel.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    transformed_file: generic/file
+    # type=file: Path to output file if used normally
+    # type=file|default=<undefined>: Output volume
+    vertexvol_file: generic/file
+    # type=file: vertex map volume path id. Optional
+    # type=file|default=<undefined>: Path name of the vertex output volume, which is the same as output volume except that the value of each voxel is the vertex-id that is mapped to that voxel.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    source_file:
+    # type=file|default=<undefined>: This is the source of the surface values
+    hemi:
+    # type=str|default='': hemisphere of data
+    transformed_file:
+    # type=file: Path to output file if used normally
+    # type=file|default=<undefined>: Output volume
+    reg_file:
+    # type=file|default=<undefined>: tkRAS-to-tkRAS matrix   (tkregister2 format)
+    template_file:
+    # type=file|default=<undefined>: Output template volume
+    mkmask:
+    # type=bool|default=False: make a mask instead of loading surface values
+    vertexvol_file:
+    # type=file: vertex map volume path id. Optional
+    # type=file|default=<undefined>: Path name of the vertex output volume, which is the same as output volume except that the value of each voxel is the vertex-id that is mapped to that voxel.
+    surf_name:
+    # type=str|default='': surfname (default is white)
+    projfrac:
+    # type=float|default=0.0: thickness fraction
+    subjects_dir:
+    # type=str|default='': freesurfer subjects directory defaults to $SUBJECTS_DIR
+    subject_id:
+    # type=str|default='': subject id
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    source_file:
+    # type=file|default=<undefined>: This is the source of the surface values
+    reg_file:
+    # type=file|default=<undefined>: tkRAS-to-tkRAS matrix   (tkregister2 format)
+    hemi: '"lh"'
+    # type=str|default='': hemisphere of data
+    template_file:
+    # type=file|default=<undefined>: Output template volume
+    subjects_dir: '"."'
+    # type=str|default='': freesurfer subjects directory defaults to $SUBJECTS_DIR
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: mri_surf2vol --hemi lh --volreg register.mat --surfval lh.cope1.mgz --sd . --template cope1.nii.gz --outvol lh.cope1_asVol.nii --vtxvol lh.cope1_asVol_vertex.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    source_file:
+    # type=file|default=<undefined>: This is the source of the surface values
+    reg_file:
+    # type=file|default=<undefined>: tkRAS-to-tkRAS matrix   (tkregister2 format)
+    hemi: '"lh"'
+    # type=str|default='': hemisphere of data
+    template_file:
+    # type=file|default=<undefined>: Output template volume
+    subjects_dir: '"."'
+    # type=str|default='': freesurfer subjects directory defaults to $SUBJECTS_DIR
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/surface_2_vol_transform_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/surface_2_vol_transform_callables.py
new file mode 100644
index 00000000..41aa3120
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/surface_2_vol_transform_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Surface2VolTransform.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/surface_smooth.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/surface_smooth.yaml
new file mode 100644
index 00000000..105f061a
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/surface_smooth.yaml
@@ -0,0 +1,166 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.utils.SurfaceSmooth' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Smooth a surface image with mri_surf2surf.
+# 
+#     The surface is smoothed by an iterative process of averaging the
+#     value at each vertex with those of its adjacent neighbors. You may supply
+#     either the number of iterations to run or a desired effective FWHM of the
+#     smoothing process.  If the latter, the underlying program will calculate
+#     the correct number of iterations internally.
+# 
+#     See Also
+#     --------
+#     `nipype.interfaces.freesurfer.utils.SmoothTessellation`_ interface for
+#     smoothing a tessellated surface (e.g. in gifti or .stl)
+# 
+#     Examples
+#     --------
+#     >>> import nipype.interfaces.freesurfer as fs
+#     >>> smoother = fs.SurfaceSmooth()
+#     >>> smoother.inputs.in_file = "lh.cope1.mgz"
+#     >>> smoother.inputs.subject_id = "subj_1"
+#     >>> smoother.inputs.hemi = "lh"
+#     >>> smoother.inputs.fwhm = 5
+#     >>> smoother.cmdline # doctest: +ELLIPSIS
+#     'mri_surf2surf --cortex --fwhm 5.0000 --hemi lh --sval lh.cope1.mgz --tval ...lh.cope1_smooth5.mgz --s subj_1'
+#     >>> smoother.run() # doctest: +SKIP
+# 
+#     
+task_name: SurfaceSmooth
+nipype_name: SurfaceSmooth
+nipype_module: nipype.interfaces.freesurfer.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/mgh-gz
+    # type=file|default=<undefined>: source surface file
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: smoothed surface file
+    # type=file|default=<undefined>: surface file to write
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: out_file
+    # type=file: smoothed surface file
+    # type=file|default=<undefined>: surface file to write
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: source surface file
+    subject_id:
+    # type=string|default='': subject id of surface file
+    hemi:
+    # type=enum|default='lh'|allowed['lh','rh']: hemisphere to operate on
+    fwhm:
+    # type=float|default=0.0: effective FWHM of the smoothing process
+    smooth_iters:
+    # type=int|default=0: iterations of the smoothing process
+    cortex:
+    # type=bool|default=True: only smooth within ``$hemi.cortex.label``
+    reshape:
+    # type=bool|default=False: reshape surface vector to fit in non-mgh format
+    out_file:
+    # type=file: smoothed surface file
+    # type=file|default=<undefined>: surface file to write
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: source surface file
+    subject_id: '"subj_1"'
+    # type=string|default='': subject id of surface file
+    hemi: '"lh"'
+    # type=enum|default='lh'|allowed['lh','rh']: hemisphere to operate on
+    fwhm: '5'
+    # type=float|default=0.0: effective FWHM of the smoothing process
+  imports: &id001
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  - module: nipype.interfaces.freesurfer as fs
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: mri_surf2surf --cortex --fwhm 5.0000 --hemi lh --sval lh.cope1.mgz --tval ...lh.cope1_smooth5.mgz --s subj_1
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: source surface file
+    subject_id: '"subj_1"'
+    # type=string|default='': subject id of surface file
+    hemi: '"lh"'
+    # type=enum|default='lh'|allowed['lh','rh']: hemisphere to operate on
+    fwhm: '5'
+    # type=float|default=0.0: effective FWHM of the smoothing process
+  imports: *id001
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/surface_smooth_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/surface_smooth_callables.py
new file mode 100644
index 00000000..ab914fe7
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/surface_smooth_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in SurfaceSmooth.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/surface_snapshots.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/surface_snapshots.yaml
new file mode 100644
index 00000000..1f2e4a0e
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/surface_snapshots.yaml
@@ -0,0 +1,170 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.utils.SurfaceSnapshots' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Use Tksurfer to save pictures of the cortical surface.
+# 
+#     By default, this takes snapshots of the lateral, medial, ventral,
+#     and dorsal surfaces.  See the ``six_images`` option to add the
+#     anterior and posterior surfaces.
+# 
+#     You may also supply your own tcl script (see the Freesurfer wiki for
+#     information on scripting tksurfer). The screenshot stem is set as the
+#     environment variable "_SNAPSHOT_STEM", which you can use in your
+#     own scripts.
+# 
+#     Node that this interface will not run if you do not have graphics
+#     enabled on your system.
+# 
+#     Examples
+#     --------
+# 
+#     >>> import nipype.interfaces.freesurfer as fs
+#     >>> shots = fs.SurfaceSnapshots(subject_id="fsaverage", hemi="lh", surface="pial")
+#     >>> shots.inputs.overlay = "zstat1.nii.gz"
+#     >>> shots.inputs.overlay_range = (2.3, 6)
+#     >>> shots.inputs.overlay_reg = "register.dat"
+#     >>> res = shots.run() # doctest: +SKIP
+# 
+#     
+task_name: SurfaceSnapshots
+nipype_name: SurfaceSnapshots
+nipype_module: nipype.interfaces.freesurfer.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    overlay: generic/file
+    # type=file|default=<undefined>: load an overlay volume/surface
+    overlay_reg: generic/file
+    # type=file|default=<undefined>: registration matrix file to register overlay to surface
+    annot_file: generic/file
+    # type=file|default=<undefined>: path to annotation file to display
+    label_file: generic/file
+    # type=file|default=<undefined>: path to label file to display
+    colortable: generic/file
+    # type=file|default=<undefined>: load colortable file
+    patch_file: generic/file
+    # type=file|default=<undefined>: load a patch
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    tcl_script: tcl_script
+    # type=file|default=<undefined>: override default screenshot script
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    subject_id:
+    # type=string|default='': subject to visualize
+    hemi:
+    # type=enum|default='lh'|allowed['lh','rh']: hemisphere to visualize
+    surface:
+    # type=string|default='': surface to visualize
+    show_curv:
+    # type=bool|default=False: show curvature
+    show_gray_curv:
+    # type=bool|default=False: show curvature in gray
+    overlay:
+    # type=file|default=<undefined>: load an overlay volume/surface
+    overlay_reg:
+    # type=file|default=<undefined>: registration matrix file to register overlay to surface
+    identity_reg:
+    # type=bool|default=False: use the identity matrix to register the overlay to the surface
+    mni152_reg:
+    # type=bool|default=False: use to display a volume in MNI152 space on the average subject
+    overlay_range:
+    # type=traitcompound|default=None: overlay range--either min, (min, max) or (min, mid, max)
+    overlay_range_offset:
+    # type=float|default=0.0: overlay range will be symmetric around offset value
+    truncate_overlay:
+    # type=bool|default=False: truncate the overlay display
+    reverse_overlay:
+    # type=bool|default=False: reverse the overlay display
+    invert_overlay:
+    # type=bool|default=False: invert the overlay display
+    demean_overlay:
+    # type=bool|default=False: remove mean from overlay
+    annot_file:
+    # type=file|default=<undefined>: path to annotation file to display
+    annot_name:
+    # type=string|default='': name of annotation to display (must be in $subject/label directory
+    label_file:
+    # type=file|default=<undefined>: path to label file to display
+    label_name:
+    # type=string|default='': name of label to display (must be in $subject/label directory
+    colortable:
+    # type=file|default=<undefined>: load colortable file
+    label_under:
+    # type=bool|default=False: draw label/annotation under overlay
+    label_outline:
+    # type=bool|default=False: draw label/annotation as outline
+    patch_file:
+    # type=file|default=<undefined>: load a patch
+    orig_suffix:
+    # type=string|default='': set the orig surface suffix string
+    sphere_suffix:
+    # type=string|default='': set the sphere.reg suffix string
+    show_color_scale:
+    # type=bool|default=False: display the color scale bar
+    show_color_text:
+    # type=bool|default=False: display text in the color scale bar
+    six_images:
+    # type=bool|default=False: also take anterior and posterior snapshots
+    screenshot_stem:
+    # type=string|default='': stem to use for screenshot file names
+    stem_template_args:
+    # type=list|default=[]: input names to use as arguments for a string-formated stem template
+    tcl_script:
+    # type=file|default=<undefined>: override default screenshot script
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/surface_snapshots_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/surface_snapshots_callables.py
new file mode 100644
index 00000000..98b507ff
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/surface_snapshots_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in SurfaceSnapshots.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/surface_transform.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/surface_transform.yaml
new file mode 100644
index 00000000..400aabe7
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/surface_transform.yaml
@@ -0,0 +1,120 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.utils.SurfaceTransform' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Transform a surface file from one subject to another via a spherical registration.
+# 
+#     Both the source and target subject must reside in your Subjects Directory,
+#     and they must have been processed with recon-all, unless you are transforming
+#     to one of the icosahedron meshes.
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces.freesurfer import SurfaceTransform
+#     >>> sxfm = SurfaceTransform()
+#     >>> sxfm.inputs.source_file = "lh.cope1.nii.gz"
+#     >>> sxfm.inputs.source_subject = "my_subject"
+#     >>> sxfm.inputs.target_subject = "fsaverage"
+#     >>> sxfm.inputs.hemi = "lh"
+#     >>> sxfm.run() # doctest: +SKIP
+# 
+#     
+task_name: SurfaceTransform
+nipype_name: SurfaceTransform
+nipype_module: nipype.interfaces.freesurfer.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    source_file: generic/file
+    # type=file|default=<undefined>: surface file with source values
+    source_annot_file: generic/file
+    # type=file|default=<undefined>: surface annotation file
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: transformed surface file
+    # type=file|default=<undefined>: surface file to write
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: out_file
+    # type=file: transformed surface file
+    # type=file|default=<undefined>: surface file to write
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    source_file:
+    # type=file|default=<undefined>: surface file with source values
+    source_annot_file:
+    # type=file|default=<undefined>: surface annotation file
+    source_subject:
+    # type=string|default='': subject id for source surface
+    hemi:
+    # type=enum|default='lh'|allowed['lh','rh']: hemisphere to transform
+    target_subject:
+    # type=string|default='': subject id of target surface
+    target_ico_order:
+    # type=enum|default=1|allowed[1,2,3,4,5,6,7]: order of the icosahedron if target_subject is 'ico'
+    source_type:
+    # type=enum|default='cor'|allowed['afni','analyze','analyze4d','bfloat','brik','bshort','cor','gdf','mgh','mgz','minc','nifti1','nii','niigz','otl','outline','sdt','spm']: source file format
+    target_type:
+    # type=enum|default='cor'|allowed['afni','analyze','analyze4d','bfloat','brik','bshort','cor','gdf','gii','mgh','mgz','minc','nifti1','nii','niigz','otl','outline','sdt','spm']: output format
+    reshape:
+    # type=bool|default=False: reshape output surface to conform with Nifti
+    reshape_factor:
+    # type=int|default=0: number of slices in reshaped image
+    out_file:
+    # type=file: transformed surface file
+    # type=file|default=<undefined>: surface file to write
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/surface_transform_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/surface_transform_callables.py
new file mode 100644
index 00000000..4ef7bf87
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/surface_transform_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in SurfaceTransform.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/synthesize_flash.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/synthesize_flash.yaml
new file mode 100644
index 00000000..51481eb5
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/synthesize_flash.yaml
@@ -0,0 +1,162 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.preprocess.SynthesizeFLASH' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Synthesize a FLASH acquisition from T1 and proton density maps.
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces.freesurfer import SynthesizeFLASH
+#     >>> syn = SynthesizeFLASH(tr=20, te=3, flip_angle=30)
+#     >>> syn.inputs.t1_image = 'T1.mgz'
+#     >>> syn.inputs.pd_image = 'PD.mgz'
+#     >>> syn.inputs.out_file = 'flash_30syn.mgz'
+#     >>> syn.cmdline
+#     'mri_synthesize 20.00 30.00 3.000 T1.mgz PD.mgz flash_30syn.mgz'
+# 
+#     
+task_name: SynthesizeFLASH
+nipype_name: SynthesizeFLASH
+nipype_module: nipype.interfaces.freesurfer.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    t1_image: medimage/mgh-gz
+    # type=file|default=<undefined>: image of T1 values
+    pd_image: medimage/mgh-gz
+    # type=file|default=<undefined>: image of proton density values
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: medimage/mgh-gz
+    # type=file: synthesized FLASH acquisition
+    # type=file|default=<undefined>: image to write
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: '"flash_30syn.mgz"'
+    # type=file: synthesized FLASH acquisition
+    # type=file|default=<undefined>: image to write
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    fixed_weighting:
+    # type=bool|default=False: use a fixed weighting to generate optimal gray/white contrast
+    tr:
+    # type=float|default=0.0: repetition time (in msec)
+    flip_angle:
+    # type=float|default=0.0: flip angle (in degrees)
+    te:
+    # type=float|default=0.0: echo time (in msec)
+    t1_image:
+    # type=file|default=<undefined>: image of T1 values
+    pd_image:
+    # type=file|default=<undefined>: image of proton density values
+    out_file:
+    # type=file: synthesized FLASH acquisition
+    # type=file|default=<undefined>: image to write
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    t1_image:
+    # type=file|default=<undefined>: image of T1 values
+    pd_image:
+    # type=file|default=<undefined>: image of proton density values
+    out_file: '"flash_30syn.mgz"'
+    # type=file: synthesized FLASH acquisition
+    # type=file|default=<undefined>: image to write
+    tr: '20'
+    # type=float|default=0.0: repetition time (in msec)
+    te: '3'
+    # type=float|default=0.0: echo time (in msec)
+    flip_angle: '30'
+    # type=float|default=0.0: flip angle (in degrees)
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: mri_synthesize 20.00 30.00 3.000 T1.mgz PD.mgz flash_30syn.mgz
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    t1_image:
+    # type=file|default=<undefined>: image of T1 values
+    pd_image:
+    # type=file|default=<undefined>: image of proton density values
+    out_file: '"flash_30syn.mgz"'
+    # type=file: synthesized FLASH acquisition
+    # type=file|default=<undefined>: image to write
+    tr: '20'
+    # type=float|default=0.0: repetition time (in msec)
+    te: '3'
+    # type=float|default=0.0: echo time (in msec)
+    flip_angle: '30'
+    # type=float|default=0.0: flip angle (in degrees)
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/synthesize_flash_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/synthesize_flash_callables.py
new file mode 100644
index 00000000..57e2ba5e
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/synthesize_flash_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in SynthesizeFLASH.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/talairach_avi.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/talairach_avi.yaml
new file mode 100644
index 00000000..1e264a42
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/talairach_avi.yaml
@@ -0,0 +1,146 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.utils.TalairachAVI' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Front-end for Avi Snyders image registration tool. Computes the
+#     talairach transform that maps the input volume to the MNI average_305.
+#     This does not add the xfm to the header of the input file. When called
+#     by recon-all, the xfm is added to the header after the transform is
+#     computed.
+# 
+#     Examples
+#     ========
+# 
+#     >>> from nipype.interfaces.freesurfer import TalairachAVI
+#     >>> example = TalairachAVI()
+#     >>> example.inputs.in_file = 'norm.mgz'
+#     >>> example.inputs.out_file = 'trans.mat'
+#     >>> example.cmdline
+#     'talairach_avi --i norm.mgz --xfm trans.mat'
+# 
+#     >>> example.run() # doctest: +SKIP
+#     
+task_name: TalairachAVI
+nipype_name: TalairachAVI
+nipype_module: nipype.interfaces.freesurfer.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/mgh-gz
+    # type=file|default=<undefined>: input volume
+    out_file: datascience/text-matrix
+    # type=file: The output transform for TalairachAVI
+    # type=file|default=<undefined>: output xfm file
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: datascience/text-matrix
+    # type=file: The output transform for TalairachAVI
+    # type=file|default=<undefined>: output xfm file
+    out_log: generic/file
+    # type=file: The output log file for TalairachAVI
+    out_txt: generic/file
+    # type=file: The output text file for TaliarachAVI
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input volume
+    out_file:
+    # type=file: The output transform for TalairachAVI
+    # type=file|default=<undefined>: output xfm file
+    atlas:
+    # type=string|default='': alternate target atlas (in freesurfer/average dir)
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input volume
+    out_file:
+    # type=file: The output transform for TalairachAVI
+    # type=file|default=<undefined>: output xfm file
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: talairach_avi --i norm.mgz --xfm trans.mat
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: input volume
+    out_file:
+    # type=file: The output transform for TalairachAVI
+    # type=file|default=<undefined>: output xfm file
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/talairach_avi_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/talairach_avi_callables.py
new file mode 100644
index 00000000..64c41b67
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/talairach_avi_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in TalairachAVI.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/talairach_qc.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/talairach_qc.yaml
new file mode 100644
index 00000000..fa4f395e
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/talairach_qc.yaml
@@ -0,0 +1,123 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.utils.TalairachQC' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Examples
+#     ========
+# 
+#     >>> from nipype.interfaces.freesurfer import TalairachQC
+#     >>> qc = TalairachQC()
+#     >>> qc.inputs.log_file = 'dirs.txt'
+#     >>> qc.cmdline
+#     'tal_QC_AZS dirs.txt'
+#     
+task_name: TalairachQC
+nipype_name: TalairachQC
+nipype_module: nipype.interfaces.freesurfer.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    log_file: text/text-file
+    # type=file: The output log
+    # type=file|default=<undefined>: The log file for TalairachQC
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    log_file: text/text-file
+    # type=file: The output log
+    # type=file|default=<undefined>: The log file for TalairachQC
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    log_file:
+    # type=file: The output log
+    # type=file|default=<undefined>: The log file for TalairachQC
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    log_file:
+    # type=file: The output log
+    # type=file|default=<undefined>: The log file for TalairachQC
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: tal_QC_AZS dirs.txt
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    log_file:
+    # type=file: The output log
+    # type=file|default=<undefined>: The log file for TalairachQC
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/talairach_qc_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/talairach_qc_callables.py
new file mode 100644
index 00000000..0790363f
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/talairach_qc_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in TalairachQC.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/tkregister_2.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/tkregister_2.yaml
new file mode 100644
index 00000000..756cdb5b
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/tkregister_2.yaml
@@ -0,0 +1,236 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.utils.Tkregister2' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+# 
+#     Examples
+#     --------
+#     Get transform matrix between orig (*tkRAS*) and native (*scannerRAS*)
+#     coordinates in Freesurfer. Implements the first step of mapping surfaces
+#     to native space in `this guide
+#     <http://surfer.nmr.mgh.harvard.edu/fswiki/FsAnat-to-NativeAnat>`__.
+# 
+#     >>> from nipype.interfaces.freesurfer import Tkregister2
+#     >>> tk2 = Tkregister2(reg_file='T1_to_native.dat')
+#     >>> tk2.inputs.moving_image = 'T1.mgz'
+#     >>> tk2.inputs.target_image = 'structural.nii'
+#     >>> tk2.inputs.reg_header = True
+#     >>> tk2.cmdline
+#     'tkregister2 --mov T1.mgz --noedit --reg T1_to_native.dat --regheader --targ structural.nii'
+#     >>> tk2.run() # doctest: +SKIP
+# 
+#     The example below uses tkregister2 without the manual editing
+#     stage to convert FSL-style registration matrix (.mat) to
+#     FreeSurfer-style registration matrix (.dat)
+# 
+#     >>> from nipype.interfaces.freesurfer import Tkregister2
+#     >>> tk2 = Tkregister2()
+#     >>> tk2.inputs.moving_image = 'epi.nii'
+#     >>> tk2.inputs.fsl_in_matrix = 'flirt.mat'
+#     >>> tk2.cmdline
+#     'tkregister2 --fsl flirt.mat --mov epi.nii --noedit --reg register.dat'
+#     >>> tk2.run() # doctest: +SKIP
+#     
+task_name: Tkregister2
+nipype_name: Tkregister2
+nipype_module: nipype.interfaces.freesurfer.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    target_image: medimage/nifti1
+    # type=file|default=<undefined>: target volume
+    moving_image: medimage/nifti1,medimage/mgh-gz
+    # type=file|default=<undefined>: moving volume
+    fsl_in_matrix: datascience/text-matrix
+    # type=file|default=<undefined>: fsl-style registration input matrix
+    xfm: generic/file
+    # type=file|default=<undefined>: use a matrix in MNI coordinates as initial registration
+    lta_in: generic/file
+    # type=file|default=<undefined>: use a matrix in MNI coordinates as initial registration
+    reg_file: datascience/dat-file
+    # type=file: freesurfer-style registration file
+    # type=file|default='register.dat': freesurfer-style registration file
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    reg_file: datascience/dat-file
+    # type=file: freesurfer-style registration file
+    # type=file|default='register.dat': freesurfer-style registration file
+    fsl_file: generic/file
+    # type=file: FSL-style registration file
+    lta_file: generic/file
+    # type=file: LTA-style registration file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    target_image:
+    # type=file|default=<undefined>: target volume
+    fstarg:
+    # type=bool|default=False: use subject's T1 as reference
+    moving_image:
+    # type=file|default=<undefined>: moving volume
+    fsl_in_matrix:
+    # type=file|default=<undefined>: fsl-style registration input matrix
+    xfm:
+    # type=file|default=<undefined>: use a matrix in MNI coordinates as initial registration
+    lta_in:
+    # type=file|default=<undefined>: use a matrix in MNI coordinates as initial registration
+    invert_lta_in:
+    # type=bool|default=False: Invert input LTA before applying
+    fsl_out:
+    # type=traitcompound|default=None: compute an FSL-compatible resgitration matrix
+    lta_out:
+    # type=traitcompound|default=None: output registration file (LTA format)
+    invert_lta_out:
+    # type=bool|default=False: Invert input LTA before applying
+    subject_id:
+    # type=string|default='': freesurfer subject ID
+    noedit:
+    # type=bool|default=True: do not open edit window (exit)
+    reg_file:
+    # type=file: freesurfer-style registration file
+    # type=file|default='register.dat': freesurfer-style registration file
+    reg_header:
+    # type=bool|default=False: compute regstration from headers
+    fstal:
+    # type=bool|default=False: set mov to be tal and reg to be tal xfm
+    movscale:
+    # type=float|default=0.0: adjust registration matrix to scale mov
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    moving_image:
+    # type=file|default=<undefined>: moving volume
+    target_image:
+    # type=file|default=<undefined>: target volume
+    reg_header: 'True'
+    # type=bool|default=False: compute regstration from headers
+    reg_file:
+    # type=file: freesurfer-style registration file
+    # type=file|default='register.dat': freesurfer-style registration file
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    moving_image:
+    # type=file|default=<undefined>: moving volume
+    fsl_in_matrix:
+    # type=file|default=<undefined>: fsl-style registration input matrix
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: tkregister2 --mov T1.mgz --noedit --reg T1_to_native.dat --regheader --targ structural.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    moving_image:
+    # type=file|default=<undefined>: moving volume
+    target_image:
+    # type=file|default=<undefined>: target volume
+    reg_header: 'True'
+    # type=bool|default=False: compute regstration from headers
+    reg_file:
+    # type=file: freesurfer-style registration file
+    # type=file|default='register.dat': freesurfer-style registration file
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: tkregister2 --fsl flirt.mat --mov epi.nii --noedit --reg register.dat
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    moving_image:
+    # type=file|default=<undefined>: moving volume
+    fsl_in_matrix:
+    # type=file|default=<undefined>: fsl-style registration input matrix
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/tkregister_2_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/tkregister_2_callables.py
new file mode 100644
index 00000000..01df9072
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/tkregister_2_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Tkregister2.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/unpack_sdicom_dir.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/unpack_sdicom_dir.yaml
new file mode 100644
index 00000000..c207a431
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/unpack_sdicom_dir.yaml
@@ -0,0 +1,165 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.preprocess.UnpackSDICOMDir' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Use unpacksdcmdir to convert dicom files
+# 
+#     Call unpacksdcmdir -help from the command line to see more information on
+#     using this command.
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces.freesurfer import UnpackSDICOMDir
+#     >>> unpack = UnpackSDICOMDir()
+#     >>> unpack.inputs.source_dir = '.'
+#     >>> unpack.inputs.output_dir = '.'
+#     >>> unpack.inputs.run_info = (5, 'mprage', 'nii', 'struct')
+#     >>> unpack.inputs.dir_structure = 'generic'
+#     >>> unpack.cmdline
+#     'unpacksdcmdir -generic -targ . -run 5 mprage nii struct -src .'
+#     
+task_name: UnpackSDICOMDir
+nipype_name: UnpackSDICOMDir
+nipype_module: nipype.interfaces.freesurfer.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    config: generic/file
+    # type=file|default=<undefined>: specify unpacking rules in file
+    seq_config: generic/file
+    # type=file|default=<undefined>: specify unpacking rules based on sequence
+    scan_only: generic/file
+    # type=file|default=<undefined>: only scan the directory and put result in file
+    log_file: generic/file
+    # type=file|default=<undefined>: explicitly set log file
+    source_dir: generic/directory
+    # type=directory|default=<undefined>: directory with the DICOM files
+    output_dir: generic/directory
+    # type=directory|default=<undefined>: top directory into which the files will be unpacked
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    source_dir:
+    # type=directory|default=<undefined>: directory with the DICOM files
+    output_dir:
+    # type=directory|default=<undefined>: top directory into which the files will be unpacked
+    run_info:
+    # type=tuple|default=(0, '', '', ''): runno subdir format name : spec unpacking rules on cmdline
+    config:
+    # type=file|default=<undefined>: specify unpacking rules in file
+    seq_config:
+    # type=file|default=<undefined>: specify unpacking rules based on sequence
+    dir_structure:
+    # type=enum|default='fsfast'|allowed['fsfast','generic']: unpack to specified directory structures
+    no_info_dump:
+    # type=bool|default=False: do not create infodump file
+    scan_only:
+    # type=file|default=<undefined>: only scan the directory and put result in file
+    log_file:
+    # type=file|default=<undefined>: explicitly set log file
+    spm_zeropad:
+    # type=int|default=0: set frame number zero padding width for SPM
+    no_unpack_err:
+    # type=bool|default=False: do not try to unpack runs with errors
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    source_dir: '"."'
+    # type=directory|default=<undefined>: directory with the DICOM files
+    output_dir: '"."'
+    # type=directory|default=<undefined>: top directory into which the files will be unpacked
+    run_info: (5, "mprage", "nii", "struct")
+    # type=tuple|default=(0, '', '', ''): runno subdir format name : spec unpacking rules on cmdline
+    dir_structure: '"generic"'
+    # type=enum|default='fsfast'|allowed['fsfast','generic']: unpack to specified directory structures
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: unpacksdcmdir -generic -targ . -run 5 mprage nii struct -src .
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    source_dir: '"."'
+    # type=directory|default=<undefined>: directory with the DICOM files
+    output_dir: '"."'
+    # type=directory|default=<undefined>: top directory into which the files will be unpacked
+    run_info: (5, "mprage", "nii", "struct")
+    # type=tuple|default=(0, '', '', ''): runno subdir format name : spec unpacking rules on cmdline
+    dir_structure: '"generic"'
+    # type=enum|default='fsfast'|allowed['fsfast','generic']: unpack to specified directory structures
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/unpack_sdicom_dir_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/unpack_sdicom_dir_callables.py
new file mode 100644
index 00000000..05e705bd
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/unpack_sdicom_dir_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in UnpackSDICOMDir.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/volume_mask.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/volume_mask.yaml
new file mode 100644
index 00000000..ef034b89
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/volume_mask.yaml
@@ -0,0 +1,208 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.utils.VolumeMask' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Computes a volume mask, at the same resolution as the
+#     <subject>/mri/brain.mgz.  The volume mask contains 4 values: LH_WM
+#     (default 10), LH_GM (default 100), RH_WM (default 20), RH_GM (default
+#     200).
+#     The algorithm uses the 4 surfaces situated in <subject>/surf/
+#     [lh|rh].[white|pial] and labels voxels based on the
+#     signed-distance function from the surface.
+# 
+#     Examples
+#     ========
+#     >>> from nipype.interfaces.freesurfer import VolumeMask
+#     >>> volmask = VolumeMask()
+#     >>> volmask.inputs.left_whitelabel = 2
+#     >>> volmask.inputs.left_ribbonlabel = 3
+#     >>> volmask.inputs.right_whitelabel = 41
+#     >>> volmask.inputs.right_ribbonlabel = 42
+#     >>> volmask.inputs.lh_pial = 'lh.pial'
+#     >>> volmask.inputs.rh_pial = 'lh.pial'
+#     >>> volmask.inputs.lh_white = 'lh.pial'
+#     >>> volmask.inputs.rh_white = 'lh.pial'
+#     >>> volmask.inputs.subject_id = '10335'
+#     >>> volmask.inputs.save_ribbon = True
+#     >>> volmask.cmdline
+#     'mris_volmask --label_left_ribbon 3 --label_left_white 2 --label_right_ribbon 42 --label_right_white 41 --save_ribbon 10335'
+#     
+task_name: VolumeMask
+nipype_name: VolumeMask
+nipype_module: nipype.interfaces.freesurfer.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    lh_pial: medimage-freesurfer/pial
+    # type=file|default=<undefined>: Implicit input left pial surface
+    rh_pial: medimage-freesurfer/pial
+    # type=file|default=<undefined>: Implicit input right pial surface
+    lh_white: medimage-freesurfer/pial
+    # type=file|default=<undefined>: Implicit input left white matter surface
+    rh_white: medimage-freesurfer/pial
+    # type=file|default=<undefined>: Implicit input right white matter surface
+    aseg: generic/file
+    # type=file|default=<undefined>: Implicit aseg.mgz segmentation. Specify a different aseg by using the 'in_aseg' input.
+    in_aseg: generic/file
+    # type=file|default=<undefined>: Input aseg file for VolumeMask
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_ribbon: generic/file
+    # type=file: Output cortical ribbon mask
+    lh_ribbon: generic/file
+    # type=file: Output left cortical ribbon mask
+    rh_ribbon: generic/file
+    # type=file: Output right cortical ribbon mask
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    left_whitelabel:
+    # type=int|default=0: Left white matter label
+    left_ribbonlabel:
+    # type=int|default=0: Left cortical ribbon label
+    right_whitelabel:
+    # type=int|default=0: Right white matter label
+    right_ribbonlabel:
+    # type=int|default=0: Right cortical ribbon label
+    lh_pial:
+    # type=file|default=<undefined>: Implicit input left pial surface
+    rh_pial:
+    # type=file|default=<undefined>: Implicit input right pial surface
+    lh_white:
+    # type=file|default=<undefined>: Implicit input left white matter surface
+    rh_white:
+    # type=file|default=<undefined>: Implicit input right white matter surface
+    aseg:
+    # type=file|default=<undefined>: Implicit aseg.mgz segmentation. Specify a different aseg by using the 'in_aseg' input.
+    subject_id:
+    # type=string|default='subject_id': Subject being processed
+    in_aseg:
+    # type=file|default=<undefined>: Input aseg file for VolumeMask
+    save_ribbon:
+    # type=bool|default=False: option to save just the ribbon for the hemispheres in the format ?h.ribbon.mgz
+    copy_inputs:
+    # type=bool|default=False: If running as a node, set this to True.This will copy the implicit input files to the node directory.
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    left_whitelabel: '2'
+    # type=int|default=0: Left white matter label
+    left_ribbonlabel: '3'
+    # type=int|default=0: Left cortical ribbon label
+    right_whitelabel: '41'
+    # type=int|default=0: Right white matter label
+    right_ribbonlabel: '42'
+    # type=int|default=0: Right cortical ribbon label
+    lh_pial:
+    # type=file|default=<undefined>: Implicit input left pial surface
+    rh_pial:
+    # type=file|default=<undefined>: Implicit input right pial surface
+    lh_white:
+    # type=file|default=<undefined>: Implicit input left white matter surface
+    rh_white:
+    # type=file|default=<undefined>: Implicit input right white matter surface
+    subject_id: '"10335"'
+    # type=string|default='subject_id': Subject being processed
+    save_ribbon: 'True'
+    # type=bool|default=False: option to save just the ribbon for the hemispheres in the format ?h.ribbon.mgz
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: mris_volmask --label_left_ribbon 3 --label_left_white 2 --label_right_ribbon 42 --label_right_white 41 --save_ribbon 10335
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    left_whitelabel: '2'
+    # type=int|default=0: Left white matter label
+    left_ribbonlabel: '3'
+    # type=int|default=0: Left cortical ribbon label
+    right_whitelabel: '41'
+    # type=int|default=0: Right white matter label
+    right_ribbonlabel: '42'
+    # type=int|default=0: Right cortical ribbon label
+    lh_pial:
+    # type=file|default=<undefined>: Implicit input left pial surface
+    rh_pial:
+    # type=file|default=<undefined>: Implicit input right pial surface
+    lh_white:
+    # type=file|default=<undefined>: Implicit input left white matter surface
+    rh_white:
+    # type=file|default=<undefined>: Implicit input right white matter surface
+    subject_id: '"10335"'
+    # type=string|default='subject_id': Subject being processed
+    save_ribbon: 'True'
+    # type=bool|default=False: option to save just the ribbon for the hemispheres in the format ?h.ribbon.mgz
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/volume_mask_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/volume_mask_callables.py
new file mode 100644
index 00000000..fa5442aa
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/volume_mask_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in VolumeMask.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/watershed_skull_strip.yaml b/example-specs/task/nipype_internal/pydra-freesurfer/watershed_skull_strip.yaml
new file mode 100644
index 00000000..627c9ce0
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/watershed_skull_strip.yaml
@@ -0,0 +1,163 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.freesurfer.preprocess.WatershedSkullStrip' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# This program strips skull and other outer non-brain tissue and
+#     produces the brain volume from T1 volume or the scanned volume.
+# 
+#     The "watershed" segmentation algorithm was used to determine the
+#     intensity values for white matter, grey matter, and CSF.
+#     A force field was then used to fit a spherical surface to the brain.
+#     The shape of the surface fit was then evaluated against a previously
+#     derived template.
+# 
+#     The default parameters are: -w 0.82 -b 0.32 -h 10 -seedpt -ta -wta
+# 
+#     (Segonne 2004)
+# 
+#     Examples
+#     ========
+#     >>> from nipype.interfaces.freesurfer import WatershedSkullStrip
+#     >>> skullstrip = WatershedSkullStrip()
+#     >>> skullstrip.inputs.in_file = "T1.mgz"
+#     >>> skullstrip.inputs.t1 = True
+#     >>> skullstrip.inputs.transform = "transforms/talairach_with_skull.lta"
+#     >>> skullstrip.inputs.out_file = "brainmask.auto.mgz"
+#     >>> skullstrip.cmdline
+#     'mri_watershed -T1 transforms/talairach_with_skull.lta T1.mgz brainmask.auto.mgz'
+#     
+task_name: WatershedSkullStrip
+nipype_name: WatershedSkullStrip
+nipype_module: nipype.interfaces.freesurfer.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/mgh-gz
+    # type=file|default=<undefined>: input volume
+    out_file: medimage/mgh-gz
+    # type=file: skull stripped brain volume
+    # type=file|default='brainmask.auto.mgz': output volume
+    brain_atlas: generic/file
+    # type=file|default=<undefined>: 
+    transform: medimage-freesurfer/lta
+    # type=file|default=<undefined>: undocumented
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: medimage/mgh-gz
+    # type=file: skull stripped brain volume
+    # type=file|default='brainmask.auto.mgz': output volume
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input volume
+    out_file:
+    # type=file: skull stripped brain volume
+    # type=file|default='brainmask.auto.mgz': output volume
+    t1:
+    # type=bool|default=False: specify T1 input volume (T1 grey value = 110)
+    brain_atlas:
+    # type=file|default=<undefined>: 
+    transform:
+    # type=file|default=<undefined>: undocumented
+    subjects_dir:
+    # type=directory|default=<undefined>: subjects directory
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input volume
+    t1: 'True'
+    # type=bool|default=False: specify T1 input volume (T1 grey value = 110)
+    transform:
+    # type=file|default=<undefined>: undocumented
+    out_file:
+    # type=file: skull stripped brain volume
+    # type=file|default='brainmask.auto.mgz': output volume
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: mri_watershed -T1 transforms/talairach_with_skull.lta T1.mgz brainmask.auto.mgz
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: input volume
+    t1: 'True'
+    # type=bool|default=False: specify T1 input volume (T1 grey value = 110)
+    transform:
+    # type=file|default=<undefined>: undocumented
+    out_file:
+    # type=file: skull stripped brain volume
+    # type=file|default='brainmask.auto.mgz': output volume
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/watershed_skull_strip_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/watershed_skull_strip_callables.py
new file mode 100644
index 00000000..e6780434
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-freesurfer/watershed_skull_strip_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in WatershedSkullStrip.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/accuracy_tester.yaml b/example-specs/task/nipype_internal/pydra-fsl/accuracy_tester.yaml
new file mode 100644
index 00000000..e0308e11
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/accuracy_tester.yaml
@@ -0,0 +1,86 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.fix.AccuracyTester' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Test the accuracy of an existing training dataset on a set of hand-labelled subjects.
+#     Note: This may or may not be working. Couldn't presently not confirm because fix fails on this (even outside of nipype) without leaving an error msg.
+#     
+task_name: AccuracyTester
+nipype_name: AccuracyTester
+nipype_module: nipype.interfaces.fsl.fix
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    trained_wts_file: generic/file
+    # type=file|default=<undefined>: trained-weights file
+    mel_icas: generic/directory+list-of
+    # type=inputmultiobject|default=[]: Melodic output directories
+    output_directory: generic/directory
+    # type=directory: Path to folder in which to store the results of the accuracy test.
+    # type=directory|default=<undefined>: Path to folder in which to store the results of the accuracy test.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    output_directory: generic/directory
+    # type=directory: Path to folder in which to store the results of the accuracy test.
+    # type=directory|default=<undefined>: Path to folder in which to store the results of the accuracy test.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    mel_icas:
+    # type=inputmultiobject|default=[]: Melodic output directories
+    trained_wts_file:
+    # type=file|default=<undefined>: trained-weights file
+    output_directory:
+    # type=directory: Path to folder in which to store the results of the accuracy test.
+    # type=directory|default=<undefined>: Path to folder in which to store the results of the accuracy test.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-fsl/accuracy_tester_callables.py b/example-specs/task/nipype_internal/pydra-fsl/accuracy_tester_callables.py
new file mode 100644
index 00000000..5c3eb007
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/accuracy_tester_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in AccuracyTester.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/apply_mask.yaml b/example-specs/task/nipype_internal/pydra-fsl/apply_mask.yaml
new file mode 100644
index 00000000..4f478bea
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/apply_mask.yaml
@@ -0,0 +1,91 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.maths.ApplyMask' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Use fslmaths to apply a binary mask to another image.
+task_name: ApplyMask
+nipype_name: ApplyMask
+nipype_module: nipype.interfaces.fsl.maths
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    mask_file: generic/file
+    # type=file|default=<undefined>: binary image defining mask space
+    in_file: generic/file
+    # type=file|default=<undefined>: image to operate on
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: out_file
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    mask_file:
+    # type=file|default=<undefined>: binary image defining mask space
+    in_file:
+    # type=file|default=<undefined>: image to operate on
+    out_file:
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
+    internal_datatype:
+    # type=enum|default='float'|allowed['char','double','float','input','int','short']: datatype to use for calculations (default is float)
+    output_datatype:
+    # type=enum|default='float'|allowed['char','double','float','input','int','short']: datatype to use for output (default uses input type)
+    nan2zeros:
+    # type=bool|default=False: change NaNs to zeros before doing anything
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-fsl/apply_mask_callables.py b/example-specs/task/nipype_internal/pydra-fsl/apply_mask_callables.py
new file mode 100644
index 00000000..ce0e94d9
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/apply_mask_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in ApplyMask.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/apply_topup.yaml b/example-specs/task/nipype_internal/pydra-fsl/apply_topup.yaml
new file mode 100644
index 00000000..10f58e9b
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/apply_topup.yaml
@@ -0,0 +1,173 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.epi.ApplyTOPUP' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Interface for FSL topup, a tool for estimating and correcting
+#     susceptibility induced distortions.
+#     `General reference
+#     <http://fsl.fmrib.ox.ac.uk/fsl/fslwiki/topup/ApplytopupUsersGuide>`_
+#     and `use example
+#     <http://fsl.fmrib.ox.ac.uk/fsl/fslwiki/topup/ExampleTopupFollowedByApplytopup>`_.
+# 
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces.fsl import ApplyTOPUP
+#     >>> applytopup = ApplyTOPUP()
+#     >>> applytopup.inputs.in_files = ["epi.nii", "epi_rev.nii"]
+#     >>> applytopup.inputs.encoding_file = "topup_encoding.txt"
+#     >>> applytopup.inputs.in_topup_fieldcoef = "topup_fieldcoef.nii.gz"
+#     >>> applytopup.inputs.in_topup_movpar = "topup_movpar.txt"
+#     >>> applytopup.inputs.output_type = "NIFTI_GZ"
+#     >>> applytopup.cmdline # doctest: +ELLIPSIS
+#     'applytopup --datain=topup_encoding.txt --imain=epi.nii,epi_rev.nii --inindex=1,2 --topup=topup --out=epi_corrected.nii.gz'
+#     >>> res = applytopup.run() # doctest: +SKIP
+# 
+#     
+task_name: ApplyTOPUP
+nipype_name: ApplyTOPUP
+nipype_module: nipype.interfaces.fsl.epi
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_files: medimage/nifti1+list-of
+    # type=inputmultiobject|default=[]: name of file with images
+    encoding_file: text/text-file
+    # type=file|default=<undefined>: name of text file with PE directions/times
+    in_topup_fieldcoef: medimage/nifti-gz
+    # type=file|default=<undefined>: topup file containing the field coefficients
+    in_topup_movpar: text/text-file
+    # type=file|default=<undefined>: topup movpar.txt file
+    out_corrected: generic/file
+    # type=file: name of 4D image file with unwarped images
+    # type=file|default=<undefined>: output (warped) image
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_corrected: generic/file
+    # type=file: name of 4D image file with unwarped images
+    # type=file|default=<undefined>: output (warped) image
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_files:
+    # type=inputmultiobject|default=[]: name of file with images
+    encoding_file:
+    # type=file|default=<undefined>: name of text file with PE directions/times
+    in_index:
+    # type=list|default=[]: comma separated list of indices corresponding to --datain
+    in_topup_fieldcoef:
+    # type=file|default=<undefined>: topup file containing the field coefficients
+    in_topup_movpar:
+    # type=file|default=<undefined>: topup movpar.txt file
+    out_corrected:
+    # type=file: name of 4D image file with unwarped images
+    # type=file|default=<undefined>: output (warped) image
+    method:
+    # type=enum|default='jac'|allowed['jac','lsr']: use jacobian modulation (jac) or least-squares resampling (lsr)
+    interp:
+    # type=enum|default='trilinear'|allowed['spline','trilinear']: interpolation method
+    datatype:
+    # type=enum|default='char'|allowed['char','double','float','int','short']: force output data type
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_files:
+    # type=inputmultiobject|default=[]: name of file with images
+    encoding_file:
+    # type=file|default=<undefined>: name of text file with PE directions/times
+    in_topup_fieldcoef:
+    # type=file|default=<undefined>: topup file containing the field coefficients
+    in_topup_movpar:
+    # type=file|default=<undefined>: topup movpar.txt file
+    output_type: '"NIFTI_GZ"'
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: applytopup --datain=topup_encoding.txt --imain=epi.nii,epi_rev.nii --inindex=1,2 --topup=topup --out=epi_corrected.nii.gz
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_files:
+    # type=inputmultiobject|default=[]: name of file with images
+    encoding_file:
+    # type=file|default=<undefined>: name of text file with PE directions/times
+    in_topup_fieldcoef:
+    # type=file|default=<undefined>: topup file containing the field coefficients
+    in_topup_movpar:
+    # type=file|default=<undefined>: topup movpar.txt file
+    output_type: '"NIFTI_GZ"'
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-fsl/apply_topup_callables.py b/example-specs/task/nipype_internal/pydra-fsl/apply_topup_callables.py
new file mode 100644
index 00000000..62f411a9
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/apply_topup_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in ApplyTOPUP.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/apply_warp.yaml b/example-specs/task/nipype_internal/pydra-fsl/apply_warp.yaml
new file mode 100644
index 00000000..70b833ed
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/apply_warp.yaml
@@ -0,0 +1,126 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.preprocess.ApplyWarp' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# FSL's applywarp wrapper to apply the results of a FNIRT registration
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import fsl
+#     >>> from nipype.testing import example_data
+#     >>> aw = fsl.ApplyWarp()
+#     >>> aw.inputs.in_file = example_data('structural.nii')
+#     >>> aw.inputs.ref_file = example_data('mni.nii')
+#     >>> aw.inputs.field_file = 'my_coefficients_filed.nii' #doctest: +SKIP
+#     >>> res = aw.run() #doctest: +SKIP
+# 
+# 
+#     
+task_name: ApplyWarp
+nipype_name: ApplyWarp
+nipype_module: nipype.interfaces.fsl.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: image to be warped
+    ref_file: generic/file
+    # type=file|default=<undefined>: reference image
+    field_file: generic/file
+    # type=file|default=<undefined>: file containing warp field
+    premat: generic/file
+    # type=file|default=<undefined>: filename for pre-transform (affine matrix)
+    postmat: generic/file
+    # type=file|default=<undefined>: filename for post-transform (affine matrix)
+    mask_file: generic/file
+    # type=file|default=<undefined>: filename for mask image (in reference space)
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: Warped output file
+    # type=file|default=<undefined>: output filename
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: out_file
+    # type=file: Warped output file
+    # type=file|default=<undefined>: output filename
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: image to be warped
+    out_file:
+    # type=file: Warped output file
+    # type=file|default=<undefined>: output filename
+    ref_file:
+    # type=file|default=<undefined>: reference image
+    field_file:
+    # type=file|default=<undefined>: file containing warp field
+    abswarp:
+    # type=bool|default=False: treat warp field as absolute: x' = w(x)
+    relwarp:
+    # type=bool|default=False: treat warp field as relative: x' = x + w(x)
+    datatype:
+    # type=enum|default='char'|allowed['char','double','float','int','short']: Force output data type [char short int float double].
+    supersample:
+    # type=bool|default=False: intermediary supersampling of output, default is off
+    superlevel:
+    # type=traitcompound|default=None: level of intermediary supersampling, a for 'automatic' or integer level. Default = 2
+    premat:
+    # type=file|default=<undefined>: filename for pre-transform (affine matrix)
+    postmat:
+    # type=file|default=<undefined>: filename for post-transform (affine matrix)
+    mask_file:
+    # type=file|default=<undefined>: filename for mask image (in reference space)
+    interp:
+    # type=enum|default='nn'|allowed['nn','sinc','spline','trilinear']: interpolation method
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-fsl/apply_warp_callables.py b/example-specs/task/nipype_internal/pydra-fsl/apply_warp_callables.py
new file mode 100644
index 00000000..827cf9f6
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/apply_warp_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in ApplyWarp.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/apply_xfm.yaml b/example-specs/task/nipype_internal/pydra-fsl/apply_xfm.yaml
new file mode 100644
index 00000000..5d4f853c
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/apply_xfm.yaml
@@ -0,0 +1,224 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.preprocess.ApplyXFM' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Currently just a light wrapper around FLIRT,
+#     with no modifications
+# 
+#     ApplyXFM is used to apply an existing transform to an image
+# 
+# 
+#     Examples
+#     --------
+# 
+#     >>> import nipype.interfaces.fsl as fsl
+#     >>> from nipype.testing import example_data
+#     >>> applyxfm = fsl.preprocess.ApplyXFM()
+#     >>> applyxfm.inputs.in_file = example_data('structural.nii')
+#     >>> applyxfm.inputs.in_matrix_file = example_data('trans.mat')
+#     >>> applyxfm.inputs.out_file = 'newfile.nii'
+#     >>> applyxfm.inputs.reference = example_data('mni.nii')
+#     >>> applyxfm.inputs.apply_xfm = True
+#     >>> result = applyxfm.run() # doctest: +SKIP
+# 
+#     
+task_name: ApplyXFM
+nipype_name: ApplyXFM
+nipype_module: nipype.interfaces.fsl.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: input file
+    reference: generic/file
+    # type=file|default=<undefined>: reference file
+    out_file: generic/file
+    # type=file: path/name of registered file (if generated)
+    # type=file|default=<undefined>: registered output file
+    out_matrix_file: generic/file
+    # type=file: path/name of calculated affine transform (if generated)
+    # type=file|default=<undefined>: output affine matrix in 4x4 asciii format
+    out_log: generic/file
+    # type=file: path/name of output log (if generated)
+    # type=file|default=<undefined>: output log
+    in_matrix_file: generic/file
+    # type=file|default=<undefined>: input 4x4 affine matrix
+    schedule: generic/file
+    # type=file|default=<undefined>: replaces default schedule
+    ref_weight: generic/file
+    # type=file|default=<undefined>: File for reference weighting volume
+    in_weight: generic/file
+    # type=file|default=<undefined>: File for input weighting volume
+    wm_seg: generic/file
+    # type=file|default=<undefined>: white matter segmentation volume needed by BBR cost function
+    wmcoords: generic/file
+    # type=file|default=<undefined>: white matter boundary coordinates for BBR cost function
+    wmnorms: generic/file
+    # type=file|default=<undefined>: white matter boundary normals for BBR cost function
+    fieldmap: generic/file
+    # type=file|default=<undefined>: fieldmap image in rads/s - must be already registered to the reference image
+    fieldmapmask: generic/file
+    # type=file|default=<undefined>: mask for fieldmap image
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: path/name of registered file (if generated)
+    # type=file|default=<undefined>: registered output file
+    out_matrix_file: generic/file
+    # type=file: path/name of calculated affine transform (if generated)
+    # type=file|default=<undefined>: output affine matrix in 4x4 asciii format
+    out_log: generic/file
+    # type=file: path/name of output log (if generated)
+    # type=file|default=<undefined>: output log
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    apply_xfm:
+    # type=bool|default=True: apply transformation supplied by in_matrix_file or uses_qform to use the affine matrix stored in the reference header
+    in_file:
+    # type=file|default=<undefined>: input file
+    reference:
+    # type=file|default=<undefined>: reference file
+    out_file:
+    # type=file: path/name of registered file (if generated)
+    # type=file|default=<undefined>: registered output file
+    out_matrix_file:
+    # type=file: path/name of calculated affine transform (if generated)
+    # type=file|default=<undefined>: output affine matrix in 4x4 asciii format
+    out_log:
+    # type=file: path/name of output log (if generated)
+    # type=file|default=<undefined>: output log
+    in_matrix_file:
+    # type=file|default=<undefined>: input 4x4 affine matrix
+    apply_isoxfm:
+    # type=float|default=0.0: as applyxfm but forces isotropic resampling
+    datatype:
+    # type=enum|default='char'|allowed['char','double','float','int','short']: force output data type
+    cost:
+    # type=enum|default='mutualinfo'|allowed['bbr','corratio','labeldiff','leastsq','mutualinfo','normcorr','normmi']: cost function
+    cost_func:
+    # type=enum|default='mutualinfo'|allowed['bbr','corratio','labeldiff','leastsq','mutualinfo','normcorr','normmi']: cost function
+    uses_qform:
+    # type=bool|default=False: initialize using sform or qform
+    display_init:
+    # type=bool|default=False: display initial matrix
+    angle_rep:
+    # type=enum|default='quaternion'|allowed['euler','quaternion']: representation of rotation angles
+    interp:
+    # type=enum|default='trilinear'|allowed['nearestneighbour','sinc','spline','trilinear']: final interpolation method used in reslicing
+    sinc_width:
+    # type=int|default=0: full-width in voxels
+    sinc_window:
+    # type=enum|default='rectangular'|allowed['blackman','hanning','rectangular']: sinc window
+    bins:
+    # type=int|default=0: number of histogram bins
+    dof:
+    # type=int|default=0: number of transform degrees of freedom
+    no_resample:
+    # type=bool|default=False: do not change input sampling
+    force_scaling:
+    # type=bool|default=False: force rescaling even for low-res images
+    min_sampling:
+    # type=float|default=0.0: set minimum voxel dimension for sampling
+    padding_size:
+    # type=int|default=0: for applyxfm: interpolates outside image by size
+    searchr_x:
+    # type=list|default=[]: search angles along x-axis, in degrees
+    searchr_y:
+    # type=list|default=[]: search angles along y-axis, in degrees
+    searchr_z:
+    # type=list|default=[]: search angles along z-axis, in degrees
+    no_search:
+    # type=bool|default=False: set all angular searches to ranges 0 to 0
+    coarse_search:
+    # type=int|default=0: coarse search delta angle
+    fine_search:
+    # type=int|default=0: fine search delta angle
+    schedule:
+    # type=file|default=<undefined>: replaces default schedule
+    ref_weight:
+    # type=file|default=<undefined>: File for reference weighting volume
+    in_weight:
+    # type=file|default=<undefined>: File for input weighting volume
+    no_clamp:
+    # type=bool|default=False: do not use intensity clamping
+    no_resample_blur:
+    # type=bool|default=False: do not use blurring on downsampling
+    rigid2D:
+    # type=bool|default=False: use 2D rigid body mode - ignores dof
+    save_log:
+    # type=bool|default=False: save to log file
+    verbose:
+    # type=int|default=0: verbose mode, 0 is least
+    bgvalue:
+    # type=float|default=0: use specified background value for points outside FOV
+    wm_seg:
+    # type=file|default=<undefined>: white matter segmentation volume needed by BBR cost function
+    wmcoords:
+    # type=file|default=<undefined>: white matter boundary coordinates for BBR cost function
+    wmnorms:
+    # type=file|default=<undefined>: white matter boundary normals for BBR cost function
+    fieldmap:
+    # type=file|default=<undefined>: fieldmap image in rads/s - must be already registered to the reference image
+    fieldmapmask:
+    # type=file|default=<undefined>: mask for fieldmap image
+    pedir:
+    # type=int|default=0: phase encode direction of EPI - 1/2/3=x/y/z & -1/-2/-3=-x/-y/-z
+    echospacing:
+    # type=float|default=0.0: value of EPI echo spacing - units of seconds
+    bbrtype:
+    # type=enum|default='signed'|allowed['global_abs','local_abs','signed']: type of bbr cost function: signed [default], global_abs, local_abs
+    bbrslope:
+    # type=float|default=0.0: value of bbr slope
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-fsl/apply_xfm_callables.py b/example-specs/task/nipype_internal/pydra-fsl/apply_xfm_callables.py
new file mode 100644
index 00000000..3b6054b3
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/apply_xfm_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in ApplyXFM.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/ar1_image.yaml b/example-specs/task/nipype_internal/pydra-fsl/ar1_image.yaml
new file mode 100644
index 00000000..d88777ab
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/ar1_image.yaml
@@ -0,0 +1,92 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.maths.AR1Image' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Use fslmaths to generate an AR1 coefficient image across a
+#     given dimension. (Should use -odt float and probably demean first)
+# 
+#     
+task_name: AR1Image
+nipype_name: AR1Image
+nipype_module: nipype.interfaces.fsl.maths
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: image to operate on
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: out_file
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    dimension:
+    # type=enum|default='T'|allowed['T','X','Y','Z']: dimension to find AR(1) coefficient across
+    in_file:
+    # type=file|default=<undefined>: image to operate on
+    out_file:
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
+    internal_datatype:
+    # type=enum|default='float'|allowed['char','double','float','input','int','short']: datatype to use for calculations (default is float)
+    output_datatype:
+    # type=enum|default='float'|allowed['char','double','float','input','int','short']: datatype to use for output (default uses input type)
+    nan2zeros:
+    # type=bool|default=False: change NaNs to zeros before doing anything
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-fsl/ar1_image_callables.py b/example-specs/task/nipype_internal/pydra-fsl/ar1_image_callables.py
new file mode 100644
index 00000000..7bd81558
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/ar1_image_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in AR1Image.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/av_scale.yaml b/example-specs/task/nipype_internal/pydra-fsl/av_scale.yaml
new file mode 100644
index 00000000..aa961366
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/av_scale.yaml
@@ -0,0 +1,86 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.utils.AvScale' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Use FSL avscale command to extract info from mat file output of FLIRT
+# 
+#     Examples
+#     --------
+# 
+#     >>> avscale = AvScale()
+#     >>> avscale.inputs.mat_file = 'flirt.mat'
+#     >>> res = avscale.run()  # doctest: +SKIP
+# 
+# 
+#     
+task_name: AvScale
+nipype_name: AvScale
+nipype_module: nipype.interfaces.fsl.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    mat_file: generic/file
+    # type=file|default=<undefined>: mat file to read
+    ref_file: generic/file
+    # type=file|default=<undefined>: reference file to get center of rotation
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    all_param:
+    # type=bool|default=False: 
+    mat_file:
+    # type=file|default=<undefined>: mat file to read
+    ref_file:
+    # type=file|default=<undefined>: reference file to get center of rotation
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-fsl/av_scale_callables.py b/example-specs/task/nipype_internal/pydra-fsl/av_scale_callables.py
new file mode 100644
index 00000000..236bd307
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/av_scale_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in AvScale.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/b0_calc.yaml b/example-specs/task/nipype_internal/pydra-fsl/b0_calc.yaml
new file mode 100644
index 00000000..cff8344c
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/b0_calc.yaml
@@ -0,0 +1,163 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.possum.B0Calc' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     B0 inhomogeneities occur at interfaces of materials with different magnetic susceptibilities,
+#     such as tissue-air interfaces. These differences lead to distortion in the local magnetic field,
+#     as Maxwell’s equations need to be satisfied. An example of B0 inhomogneity is the first volume
+#     of the 4D volume ```$FSLDIR/data/possum/b0_ppm.nii.gz```.
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces.fsl import B0Calc
+#     >>> b0calc = B0Calc()
+#     >>> b0calc.inputs.in_file = 'tissue+air_map.nii'
+#     >>> b0calc.inputs.z_b0 = 3.0
+#     >>> b0calc.inputs.output_type = "NIFTI_GZ"
+#     >>> b0calc.cmdline
+#     'b0calc -i tissue+air_map.nii -o tissue+air_map_b0field.nii.gz --chi0=4.000000e-07 -d -9.450000e-06 --extendboundary=1.00 --b0x=0.00 --gx=0.0000 --b0y=0.00 --gy=0.0000 --b0=3.00 --gz=0.0000'
+# 
+#     
+task_name: B0Calc
+nipype_name: B0Calc
+nipype_module: nipype.interfaces.fsl.possum
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: filename of input image (usually a tissue/air segmentation)
+    out_file: generic/file
+    # type=file: filename of B0 output volume
+    # type=file|default=<undefined>: filename of B0 output volume
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: filename of B0 output volume
+    # type=file|default=<undefined>: filename of B0 output volume
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: filename of input image (usually a tissue/air segmentation)
+    out_file:
+    # type=file: filename of B0 output volume
+    # type=file|default=<undefined>: filename of B0 output volume
+    x_grad:
+    # type=float|default=0.0: Value for zeroth-order x-gradient field (per mm)
+    y_grad:
+    # type=float|default=0.0: Value for zeroth-order y-gradient field (per mm)
+    z_grad:
+    # type=float|default=0.0: Value for zeroth-order z-gradient field (per mm)
+    x_b0:
+    # type=float|default=0.0: Value for zeroth-order b0 field (x-component), in Tesla
+    y_b0:
+    # type=float|default=0.0: Value for zeroth-order b0 field (y-component), in Tesla
+    z_b0:
+    # type=float|default=1.0: Value for zeroth-order b0 field (z-component), in Tesla
+    xyz_b0:
+    # type=tuple|default=(0.0, 0.0, 0.0): Zeroth-order B0 field in Tesla
+    delta:
+    # type=float|default=-9.45e-06: Delta value (chi_tissue - chi_air)
+    chi_air:
+    # type=float|default=4e-07: susceptibility of air
+    compute_xyz:
+    # type=bool|default=False: calculate and save all 3 field components (i.e. x,y,z)
+    extendboundary:
+    # type=float|default=1.0: Relative proportion to extend voxels at boundary
+    directconv:
+    # type=bool|default=False: use direct (image space) convolution, not FFT
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: filename of input image (usually a tissue/air segmentation)
+    z_b0: '3.0'
+    # type=float|default=1.0: Value for zeroth-order b0 field (z-component), in Tesla
+    output_type: '"NIFTI_GZ"'
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: b0calc -i tissue+air_map.nii -o tissue+air_map_b0field.nii.gz --chi0=4.000000e-07 -d -9.450000e-06 --extendboundary=1.00 --b0x=0.00 --gx=0.0000 --b0y=0.00 --gy=0.0000 --b0=3.00 --gz=0.0000
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: filename of input image (usually a tissue/air segmentation)
+    z_b0: '3.0'
+    # type=float|default=1.0: Value for zeroth-order b0 field (z-component), in Tesla
+    output_type: '"NIFTI_GZ"'
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-fsl/b0_calc_callables.py b/example-specs/task/nipype_internal/pydra-fsl/b0_calc_callables.py
new file mode 100644
index 00000000..4c30d1fc
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/b0_calc_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in B0Calc.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/bedpostx5.yaml b/example-specs/task/nipype_internal/pydra-fsl/bedpostx5.yaml
new file mode 100644
index 00000000..d9b0585f
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/bedpostx5.yaml
@@ -0,0 +1,212 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.dti.BEDPOSTX5' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     BEDPOSTX stands for Bayesian Estimation of Diffusion Parameters Obtained
+#     using Sampling Techniques. The X stands for modelling Crossing Fibres.
+#     bedpostx runs Markov Chain Monte Carlo sampling to build up distributions
+#     on diffusion parameters at each voxel. It creates all the files necessary
+#     for running probabilistic tractography. For an overview of the modelling
+#     carried out within bedpostx see this `technical report
+#     <http://www.fmrib.ox.ac.uk/analysis/techrep/tr03tb1/tr03tb1/index.html>`_.
+# 
+# 
+#     .. note:: Consider using
+#       :func:`niflow.nipype1.workflows.fsl.dmri.create_bedpostx_pipeline` instead.
+# 
+# 
+#     Example
+#     -------
+# 
+#     >>> from nipype.interfaces import fsl
+#     >>> bedp = fsl.BEDPOSTX5(bvecs='bvecs', bvals='bvals', dwi='diffusion.nii',
+#     ...                     mask='mask.nii', n_fibres=1)
+#     >>> bedp.cmdline
+#     'bedpostx bedpostx -b 0 --burnin_noard=0 --forcedir -n 1 -j 5000 -s 1 --updateproposalevery=40'
+# 
+#     
+task_name: BEDPOSTX5
+nipype_name: BEDPOSTX5
+nipype_module: nipype.interfaces.fsl.dti
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    dwi: medimage/nifti1
+    # type=file|default=<undefined>: diffusion weighted image data file
+    mask: medimage/nifti1
+    # type=file|default=<undefined>: bet binary mask file
+    bvecs: medimage/bvec
+    # type=file|default=<undefined>: b vectors file
+    bvals: medimage/bval
+    # type=file|default=<undefined>: b values file
+    grad_dev: generic/file
+    # type=file|default=<undefined>: grad_dev file, if gradnonlin, -g is True
+    logdir: generic/directory
+    # type=directory|default=<undefined>: 
+    out_dir: generic/directory
+    # type=directory|default='bedpostx': output directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    mean_dsamples: generic/file
+    # type=file: Mean of distribution on diffusivity d
+    mean_S0samples: generic/file
+    # type=file: Mean of distribution on T2w baseline signal intensity S0
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    dwi:
+    # type=file|default=<undefined>: diffusion weighted image data file
+    mask:
+    # type=file|default=<undefined>: bet binary mask file
+    bvecs:
+    # type=file|default=<undefined>: b vectors file
+    bvals:
+    # type=file|default=<undefined>: b values file
+    logdir:
+    # type=directory|default=<undefined>: 
+    n_fibres:
+    # type=range|default=2: Maximum number of fibres to fit in each voxel
+    model:
+    # type=enum|default=1|allowed[1,2,3]: use monoexponential (1, default, required for single-shell) or multiexponential (2, multi-shell) model
+    fudge:
+    # type=int|default=0: ARD fudge factor
+    n_jumps:
+    # type=int|default=5000: Num of jumps to be made by MCMC
+    burn_in:
+    # type=range|default=0: Total num of jumps at start of MCMC to be discarded
+    sample_every:
+    # type=range|default=1: Num of jumps for each sample (MCMC)
+    out_dir:
+    # type=directory|default='bedpostx': output directory
+    gradnonlin:
+    # type=bool|default=False: consider gradient nonlinearities, default off
+    grad_dev:
+    # type=file|default=<undefined>: grad_dev file, if gradnonlin, -g is True
+    use_gpu:
+    # type=bool|default=False: Use the GPU version of bedpostx
+    burn_in_no_ard:
+    # type=range|default=0: num of burnin jumps before the ard is imposed
+    update_proposal_every:
+    # type=range|default=40: Num of jumps for each update to the proposal density std (MCMC)
+    seed:
+    # type=int|default=0: seed for pseudo random number generator
+    no_ard:
+    # type=bool|default=False: Turn ARD off on all fibres
+    all_ard:
+    # type=bool|default=False: Turn ARD on on all fibres
+    no_spat:
+    # type=bool|default=False: Initialise with tensor, not spatially
+    non_linear:
+    # type=bool|default=False: Initialise with nonlinear fitting
+    cnlinear:
+    # type=bool|default=False: Initialise with constrained nonlinear fitting
+    rician:
+    # type=bool|default=False: use Rician noise modeling
+    f0_noard:
+    # type=bool|default=False: Noise floor model: add to the model an unattenuated signal compartment f0
+    f0_ard:
+    # type=bool|default=False: Noise floor model: add to the model an unattenuated signal compartment f0
+    force_dir:
+    # type=bool|default=True: use the actual directory name given (do not add + to make a new directory)
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    bvecs:
+    # type=file|default=<undefined>: b vectors file
+    bvals:
+    # type=file|default=<undefined>: b values file
+    dwi:
+    # type=file|default=<undefined>: diffusion weighted image data file
+    mask:
+    # type=file|default=<undefined>: bet binary mask file
+    n_fibres: '1'
+    # type=range|default=2: Maximum number of fibres to fit in each voxel
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: bedpostx bedpostx -b 0 --burnin_noard=0 --forcedir -n 1 -j 5000 -s 1 --updateproposalevery=40
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    bvecs:
+    # type=file|default=<undefined>: b vectors file
+    bvals:
+    # type=file|default=<undefined>: b values file
+    dwi:
+    # type=file|default=<undefined>: diffusion weighted image data file
+    mask:
+    # type=file|default=<undefined>: bet binary mask file
+    n_fibres: '1'
+    # type=range|default=2: Maximum number of fibres to fit in each voxel
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-fsl/bedpostx5_callables.py b/example-specs/task/nipype_internal/pydra-fsl/bedpostx5_callables.py
new file mode 100644
index 00000000..3f67f67b
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/bedpostx5_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in BEDPOSTX5.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/bet.yaml b/example-specs/task/nipype_internal/pydra-fsl/bet.yaml
new file mode 100644
index 00000000..a0c81937
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/bet.yaml
@@ -0,0 +1,208 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.preprocess.BET' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# FSL BET wrapper for skull stripping
+# 
+#     For complete details, see the `BET Documentation.
+#     <https://fsl.fmrib.ox.ac.uk/fsl/fslwiki/BET/UserGuide>`_
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import fsl
+#     >>> btr = fsl.BET()
+#     >>> btr.inputs.in_file = 'structural.nii'
+#     >>> btr.inputs.frac = 0.7
+#     >>> btr.inputs.out_file = 'brain_anat.nii'
+#     >>> btr.cmdline
+#     'bet structural.nii brain_anat.nii -f 0.70'
+#     >>> res = btr.run() # doctest: +SKIP
+# 
+#     
+task_name: BET
+nipype_name: BET
+nipype_module: nipype.interfaces.fsl.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+    in_file: input_image
+    out_file: output_image
+    outline: save_brain_surface_outline
+    mask: save_brain_mask
+    skull: save_skull_image
+    mesh: save_brain_surface_mesh
+    frac: fractional_intensity_threshold
+    radius: head_radius
+    center: center_of_gravity
+    threshold: apply_thresholding
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: input file to skull strip
+    t2_guided: generic/file
+    # type=file|default=<undefined>: as with creating surfaces, when also feeding in non-brain-extracted T2 (includes registrations)
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: medimage/nifti1
+    # type=file: path/name of skullstripped file (if generated)
+    # type=file|default=<undefined>: name of output skull stripped image
+    mask_file: generic/file
+    # type=file: path/name of binary brain mask (if generated)
+    outline_file: generic/file
+    # type=file: path/name of outline file (if generated)
+    meshfile: generic/file
+    # type=file: path/name of vtk mesh file (if generated)
+    inskull_mask_file: generic/file
+    # type=file: path/name of inskull mask (if generated)
+    inskull_mesh_file: generic/file
+    # type=file: path/name of inskull mesh outline (if generated)
+    outskull_mask_file: generic/file
+    # type=file: path/name of outskull mask (if generated)
+    outskull_mesh_file: generic/file
+    # type=file: path/name of outskull mesh outline (if generated)
+    outskin_mask_file: generic/file
+    # type=file: path/name of outskin mask (if generated)
+    outskin_mesh_file: generic/file
+    # type=file: path/name of outskin mesh outline (if generated)
+    skull_mask_file: generic/file
+    # type=file: path/name of skull mask (if generated)
+    skull_file: generic/file
+    # type=file: path/name of skull file (if generated)
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: '"brain_anat.nii"'
+    # type=file: path/name of skullstripped file (if generated)
+    # type=file|default=<undefined>: name of output skull stripped image
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to skull strip
+    out_file:
+    # type=file: path/name of skullstripped file (if generated)
+    # type=file|default=<undefined>: name of output skull stripped image
+    outline:
+    # type=bool|default=False: create surface outline image
+    mask:
+    # type=bool|default=False: create binary mask image
+    skull:
+    # type=bool|default=False: create skull image
+    no_output:
+    # type=bool|default=False: Don't generate segmented output
+    frac:
+    # type=float|default=0.0: fractional intensity threshold
+    vertical_gradient:
+    # type=float|default=0.0: vertical gradient in fractional intensity threshold (-1, 1)
+    radius:
+    # type=int|default=0: head radius
+    center:
+    # type=list|default=[]: center of gravity in voxels
+    threshold:
+    # type=bool|default=False: apply thresholding to segmented brain image and mask
+    mesh:
+    # type=bool|default=False: generate a vtk mesh brain surface
+    robust:
+    # type=bool|default=False: robust brain centre estimation (iterates BET several times)
+    padding:
+    # type=bool|default=False: improve BET if FOV is very small in Z (by temporarily padding end slices)
+    remove_eyes:
+    # type=bool|default=False: eye & optic nerve cleanup (can be useful in SIENA)
+    surfaces:
+    # type=bool|default=False: run bet2 and then betsurf to get additional skull and scalp surfaces (includes registrations)
+    t2_guided:
+    # type=file|default=<undefined>: as with creating surfaces, when also feeding in non-brain-extracted T2 (includes registrations)
+    functional:
+    # type=bool|default=False: apply to 4D fMRI data
+    reduce_bias:
+    # type=bool|default=False: bias field and neck cleanup
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to skull strip
+    frac: '0.7'
+    # type=float|default=0.0: fractional intensity threshold
+    out_file: '"brain_anat.nii"'
+    # type=file: path/name of skullstripped file (if generated)
+    # type=file|default=<undefined>: name of output skull stripped image
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: bet structural.nii brain_anat.nii -f 0.70
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: input file to skull strip
+    frac: '0.7'
+    # type=float|default=0.0: fractional intensity threshold
+    out_file: '"brain_anat.nii"'
+    # type=file: path/name of skullstripped file (if generated)
+    # type=file|default=<undefined>: name of output skull stripped image
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-fsl/bet_callables.py b/example-specs/task/nipype_internal/pydra-fsl/bet_callables.py
new file mode 100644
index 00000000..8b4d7f59
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/bet_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in BET.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/binary_maths.yaml b/example-specs/task/nipype_internal/pydra-fsl/binary_maths.yaml
new file mode 100644
index 00000000..2cb6b816
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/binary_maths.yaml
@@ -0,0 +1,98 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.maths.BinaryMaths' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Use fslmaths to perform mathematical operations using a second image or
+#     a numeric value.
+# 
+#     
+task_name: BinaryMaths
+nipype_name: BinaryMaths
+nipype_module: nipype.interfaces.fsl.maths
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    operand_file: generic/file
+    # type=file|default=<undefined>: second image to perform operation with
+    in_file: generic/file
+    # type=file|default=<undefined>: image to operate on
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: out_file
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    operation:
+    # type=enum|default='add'|allowed['add','div','max','min','mul','rem','sub']: operation to perform
+    operand_file:
+    # type=file|default=<undefined>: second image to perform operation with
+    operand_value:
+    # type=float|default=0.0: value to perform operation with
+    in_file:
+    # type=file|default=<undefined>: image to operate on
+    out_file:
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
+    internal_datatype:
+    # type=enum|default='float'|allowed['char','double','float','input','int','short']: datatype to use for calculations (default is float)
+    output_datatype:
+    # type=enum|default='float'|allowed['char','double','float','input','int','short']: datatype to use for output (default uses input type)
+    nan2zeros:
+    # type=bool|default=False: change NaNs to zeros before doing anything
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-fsl/binary_maths_callables.py b/example-specs/task/nipype_internal/pydra-fsl/binary_maths_callables.py
new file mode 100644
index 00000000..68e6b721
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/binary_maths_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in BinaryMaths.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/change_data_type.yaml b/example-specs/task/nipype_internal/pydra-fsl/change_data_type.yaml
new file mode 100644
index 00000000..3ba3191c
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/change_data_type.yaml
@@ -0,0 +1,87 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.maths.ChangeDataType' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Use fslmaths to change the datatype of an image.
+task_name: ChangeDataType
+nipype_name: ChangeDataType
+nipype_module: nipype.interfaces.fsl.maths
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: image to operate on
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: out_file
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    output_datatype:
+    # type=enum|default='float'|allowed['char','double','float','input','int','short']: output data type
+    in_file:
+    # type=file|default=<undefined>: image to operate on
+    out_file:
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
+    internal_datatype:
+    # type=enum|default='float'|allowed['char','double','float','input','int','short']: datatype to use for calculations (default is float)
+    nan2zeros:
+    # type=bool|default=False: change NaNs to zeros before doing anything
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-fsl/change_data_type_callables.py b/example-specs/task/nipype_internal/pydra-fsl/change_data_type_callables.py
new file mode 100644
index 00000000..2eb33677
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/change_data_type_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in ChangeDataType.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/classifier.yaml b/example-specs/task/nipype_internal/pydra-fsl/classifier.yaml
new file mode 100644
index 00000000..b9e589b7
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/classifier.yaml
@@ -0,0 +1,87 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.fix.Classifier' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Classify ICA components using a specific training dataset (<thresh> is in the range 0-100, typically 5-20).
+#     
+task_name: Classifier
+nipype_name: Classifier
+nipype_module: nipype.interfaces.fsl.fix
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    trained_wts_file: generic/file
+    # type=file|default=<undefined>: trained-weights file
+    artifacts_list_file: generic/file
+    # type=file: Text file listing which ICs are artifacts; can be the output from classification or can be created manually
+    # type=file|default=<undefined>: Text file listing which ICs are artifacts; can be the output from classification or can be created manually
+    mel_ica: generic/directory
+    # type=directory|default=<undefined>: Melodic output directory or directories
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    artifacts_list_file: generic/file
+    # type=file: Text file listing which ICs are artifacts; can be the output from classification or can be created manually
+    # type=file|default=<undefined>: Text file listing which ICs are artifacts; can be the output from classification or can be created manually
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    mel_ica:
+    # type=directory|default=<undefined>: Melodic output directory or directories
+    trained_wts_file:
+    # type=file|default=<undefined>: trained-weights file
+    thresh:
+    # type=int|default=0: Threshold for cleanup.
+    artifacts_list_file:
+    # type=file: Text file listing which ICs are artifacts; can be the output from classification or can be created manually
+    # type=file|default=<undefined>: Text file listing which ICs are artifacts; can be the output from classification or can be created manually
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-fsl/classifier_callables.py b/example-specs/task/nipype_internal/pydra-fsl/classifier_callables.py
new file mode 100644
index 00000000..4f49e90a
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/classifier_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Classifier.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/cleaner.yaml b/example-specs/task/nipype_internal/pydra-fsl/cleaner.yaml
new file mode 100644
index 00000000..177943ac
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/cleaner.yaml
@@ -0,0 +1,92 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.fix.Cleaner' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Extract features (for later training and/or classifying)
+#     
+task_name: Cleaner
+nipype_name: Cleaner
+nipype_module: nipype.interfaces.fsl.fix
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    artifacts_list_file: generic/file
+    # type=file|default=<undefined>: Text file listing which ICs are artifacts; can be the output from classification or can be created manually
+    confound_file: generic/file
+    # type=file|default=<undefined>: Include additional confound file.
+    confound_file_1: generic/file
+    # type=file|default=<undefined>: Include additional confound file.
+    confound_file_2: generic/file
+    # type=file|default=<undefined>: Include additional confound file.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    cleaned_functional_file: generic/file
+    # type=file: Cleaned session data
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    artifacts_list_file:
+    # type=file|default=<undefined>: Text file listing which ICs are artifacts; can be the output from classification or can be created manually
+    cleanup_motion:
+    # type=bool|default=False: cleanup motion confounds, looks for design.fsf for highpass filter cut-off
+    highpass:
+    # type=float|default=100: cleanup motion confounds
+    aggressive:
+    # type=bool|default=False: Apply aggressive (full variance) cleanup, instead of the default less-aggressive (unique variance) cleanup.
+    confound_file:
+    # type=file|default=<undefined>: Include additional confound file.
+    confound_file_1:
+    # type=file|default=<undefined>: Include additional confound file.
+    confound_file_2:
+    # type=file|default=<undefined>: Include additional confound file.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-fsl/cleaner_callables.py b/example-specs/task/nipype_internal/pydra-fsl/cleaner_callables.py
new file mode 100644
index 00000000..625e2aff
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/cleaner_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Cleaner.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/cluster.yaml b/example-specs/task/nipype_internal/pydra-fsl/cluster.yaml
new file mode 100644
index 00000000..aeb8e2be
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/cluster.yaml
@@ -0,0 +1,202 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.model.Cluster' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Uses FSL cluster to perform clustering on statistical output
+# 
+#     Examples
+#     --------
+# 
+#     >>> cl = Cluster()
+#     >>> cl.inputs.threshold = 2.3
+#     >>> cl.inputs.in_file = 'zstat1.nii.gz'
+#     >>> cl.inputs.out_localmax_txt_file = 'stats.txt'
+#     >>> cl.inputs.use_mm = True
+#     >>> cl.cmdline
+#     'cluster --in=zstat1.nii.gz --olmax=stats.txt --thresh=2.3000000000 --mm'
+# 
+#     
+task_name: Cluster
+nipype_name: Cluster
+nipype_module: nipype.interfaces.fsl.model
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti-gz
+    # type=file|default=<undefined>: input volume
+    cope_file: generic/file
+    # type=file|default=<undefined>: cope volume
+    xfm_file: generic/file
+    # type=file|default=<undefined>: filename for Linear: input->standard-space transform. Non-linear: input->highres transform
+    std_space_file: generic/file
+    # type=file|default=<undefined>: filename for standard-space volume
+    warpfield_file: generic/file
+    # type=file|default=<undefined>: file containing warpfield
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    index_file: generic/file
+    # type=file: output of cluster index (in size order)
+    threshold_file: generic/file
+    # type=file: thresholded image
+    localmax_txt_file: generic/file
+    # type=file: local maxima text file
+    localmax_vol_file: generic/file
+    # type=file: output of local maxima volume
+    size_file: generic/file
+    # type=file: filename for output of size image
+    max_file: generic/file
+    # type=file: filename for output of max image
+    mean_file: generic/file
+    # type=file: filename for output of mean image
+    pval_file: generic/file
+    # type=file: filename for image output of log pvals
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input volume
+    threshold:
+    # type=float|default=0.0: threshold for input volume
+    out_index_file:
+    # type=traitcompound|default=None: output of cluster index (in size order)
+    out_threshold_file:
+    # type=traitcompound|default=None: thresholded image
+    out_localmax_txt_file:
+    # type=traitcompound|default=None: local maxima text file
+    out_localmax_vol_file:
+    # type=traitcompound|default=None: output of local maxima volume
+    out_size_file:
+    # type=traitcompound|default=None: filename for output of size image
+    out_max_file:
+    # type=traitcompound|default=None: filename for output of max image
+    out_mean_file:
+    # type=traitcompound|default=None: filename for output of mean image
+    out_pval_file:
+    # type=traitcompound|default=None: filename for image output of log pvals
+    pthreshold:
+    # type=float|default=0.0: p-threshold for clusters
+    peak_distance:
+    # type=float|default=0.0: minimum distance between local maxima/minima, in mm (default 0)
+    cope_file:
+    # type=file|default=<undefined>: cope volume
+    volume:
+    # type=int|default=0: number of voxels in the mask
+    dlh:
+    # type=float|default=0.0: smoothness estimate = sqrt(det(Lambda))
+    fractional:
+    # type=bool|default=False: interprets the threshold as a fraction of the robust range
+    connectivity:
+    # type=int|default=0: the connectivity of voxels (default 26)
+    use_mm:
+    # type=bool|default=False: use mm, not voxel, coordinates
+    find_min:
+    # type=bool|default=False: find minima instead of maxima
+    no_table:
+    # type=bool|default=False: suppresses printing of the table info
+    minclustersize:
+    # type=bool|default=False: prints out minimum significant cluster size
+    xfm_file:
+    # type=file|default=<undefined>: filename for Linear: input->standard-space transform. Non-linear: input->highres transform
+    std_space_file:
+    # type=file|default=<undefined>: filename for standard-space volume
+    num_maxima:
+    # type=int|default=0: no of local maxima to report
+    warpfield_file:
+    # type=file|default=<undefined>: file containing warpfield
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    threshold: '2.3'
+    # type=float|default=0.0: threshold for input volume
+    in_file:
+    # type=file|default=<undefined>: input volume
+    out_localmax_txt_file: '"stats.txt"'
+    # type=traitcompound|default=None: local maxima text file
+    use_mm: 'True'
+    # type=bool|default=False: use mm, not voxel, coordinates
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: cluster --in=zstat1.nii.gz --olmax=stats.txt --thresh=2.3000000000 --mm
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    threshold: '2.3'
+    # type=float|default=0.0: threshold for input volume
+    in_file:
+    # type=file|default=<undefined>: input volume
+    out_localmax_txt_file: '"stats.txt"'
+    # type=traitcompound|default=None: local maxima text file
+    use_mm: 'True'
+    # type=bool|default=False: use mm, not voxel, coordinates
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-fsl/cluster_callables.py b/example-specs/task/nipype_internal/pydra-fsl/cluster_callables.py
new file mode 100644
index 00000000..bca8cdec
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/cluster_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Cluster.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/complex.yaml b/example-specs/task/nipype_internal/pydra-fsl/complex.yaml
new file mode 100644
index 00000000..36e57c1c
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/complex.yaml
@@ -0,0 +1,164 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.utils.Complex' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# fslcomplex is a tool for converting complex data
+# 
+#     Examples
+#     --------
+# 
+#     >>> cplx = Complex()
+#     >>> cplx.inputs.complex_in_file = "complex.nii"
+#     >>> cplx.real_polar = True
+#     >>> res = cplx.run() # doctest: +SKIP
+# 
+# 
+#     
+task_name: Complex
+nipype_name: Complex
+nipype_module: nipype.interfaces.fsl.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    complex_in_file: generic/file
+    # type=file|default=<undefined>: 
+    complex_in_file2: generic/file
+    # type=file|default=<undefined>: 
+    real_in_file: generic/file
+    # type=file|default=<undefined>: 
+    imaginary_in_file: generic/file
+    # type=file|default=<undefined>: 
+    magnitude_in_file: generic/file
+    # type=file|default=<undefined>: 
+    phase_in_file: generic/file
+    # type=file|default=<undefined>: 
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    magnitude_out_file: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: 
+    phase_out_file: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: 
+    real_out_file: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: 
+    imaginary_out_file: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: 
+    complex_out_file: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: 
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    complex_out_file: complex_out_file
+    # type=file: 
+    # type=file|default=<undefined>: 
+    magnitude_out_file: magnitude_out_file
+    # type=file: 
+    # type=file|default=<undefined>: 
+    phase_out_file: phase_out_file
+    # type=file: 
+    # type=file|default=<undefined>: 
+    real_out_file: real_out_file
+    # type=file: 
+    # type=file|default=<undefined>: 
+    imaginary_out_file: imaginary_out_file
+    # type=file: 
+    # type=file|default=<undefined>: 
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    complex_in_file:
+    # type=file|default=<undefined>: 
+    complex_in_file2:
+    # type=file|default=<undefined>: 
+    real_in_file:
+    # type=file|default=<undefined>: 
+    imaginary_in_file:
+    # type=file|default=<undefined>: 
+    magnitude_in_file:
+    # type=file|default=<undefined>: 
+    phase_in_file:
+    # type=file|default=<undefined>: 
+    complex_out_file:
+    # type=file: 
+    # type=file|default=<undefined>: 
+    magnitude_out_file:
+    # type=file: 
+    # type=file|default=<undefined>: 
+    phase_out_file:
+    # type=file: 
+    # type=file|default=<undefined>: 
+    real_out_file:
+    # type=file: 
+    # type=file|default=<undefined>: 
+    imaginary_out_file:
+    # type=file: 
+    # type=file|default=<undefined>: 
+    start_vol:
+    # type=int|default=0: 
+    end_vol:
+    # type=int|default=0: 
+    real_polar:
+    # type=bool|default=False: 
+    real_cartesian:
+    # type=bool|default=False: 
+    complex_cartesian:
+    # type=bool|default=False: 
+    complex_polar:
+    # type=bool|default=False: 
+    complex_split:
+    # type=bool|default=False: 
+    complex_merge:
+    # type=bool|default=False: 
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-fsl/complex_callables.py b/example-specs/task/nipype_internal/pydra-fsl/complex_callables.py
new file mode 100644
index 00000000..566f01d0
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/complex_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Complex.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/contrast_mgr.yaml b/example-specs/task/nipype_internal/pydra-fsl/contrast_mgr.yaml
new file mode 100644
index 00000000..c344fd2f
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/contrast_mgr.yaml
@@ -0,0 +1,101 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.model.ContrastMgr' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Use FSL contrast_mgr command to evaluate contrasts
+# 
+#     In interface mode this file assumes that all the required inputs are in the
+#     same location. This has deprecated for FSL versions 5.0.7+ as the necessary
+#     corrections file is no longer generated by FILMGLS.
+#     
+task_name: ContrastMgr
+nipype_name: ContrastMgr
+nipype_module: nipype.interfaces.fsl.model
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    tcon_file: generic/file
+    # type=file|default=<undefined>: contrast file containing T-contrasts
+    fcon_file: generic/file
+    # type=file|default=<undefined>: contrast file containing F-contrasts
+    param_estimates: generic/file+list-of
+    # type=inputmultiobject|default=[]: Parameter estimates for each column of the design matrix
+    corrections: generic/file
+    # type=file|default=<undefined>: statistical corrections used within FILM modelling
+    dof_file: generic/file
+    # type=file|default=<undefined>: degrees of freedom
+    sigmasquareds: generic/file
+    # type=file|default=<undefined>: summary of residuals, See Woolrich, et. al., 2001
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    tcon_file:
+    # type=file|default=<undefined>: contrast file containing T-contrasts
+    fcon_file:
+    # type=file|default=<undefined>: contrast file containing F-contrasts
+    param_estimates:
+    # type=inputmultiobject|default=[]: Parameter estimates for each column of the design matrix
+    corrections:
+    # type=file|default=<undefined>: statistical corrections used within FILM modelling
+    dof_file:
+    # type=file|default=<undefined>: degrees of freedom
+    sigmasquareds:
+    # type=file|default=<undefined>: summary of residuals, See Woolrich, et. al., 2001
+    contrast_num:
+    # type=range|default=1: contrast number to start labeling copes from
+    suffix:
+    # type=str|default='': suffix to put on the end of the cope filename before the contrast number, default is nothing
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-fsl/contrast_mgr_callables.py b/example-specs/task/nipype_internal/pydra-fsl/contrast_mgr_callables.py
new file mode 100644
index 00000000..ff62f092
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/contrast_mgr_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in ContrastMgr.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/convert_warp.yaml b/example-specs/task/nipype_internal/pydra-fsl/convert_warp.yaml
new file mode 100644
index 00000000..9d8703a1
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/convert_warp.yaml
@@ -0,0 +1,184 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.utils.ConvertWarp' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Use FSL `convertwarp <http://fsl.fmrib.ox.ac.uk/fsl/fsl-4.1.9/fnirt/warp_utils.html>`_
+#     for combining multiple transforms into one.
+# 
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces.fsl import ConvertWarp
+#     >>> warputils = ConvertWarp()
+#     >>> warputils.inputs.warp1 = "warpfield.nii"
+#     >>> warputils.inputs.reference = "T1.nii"
+#     >>> warputils.inputs.relwarp = True
+#     >>> warputils.inputs.output_type = "NIFTI_GZ"
+#     >>> warputils.cmdline # doctest: +ELLIPSIS
+#     'convertwarp --ref=T1.nii --rel --warp1=warpfield.nii --out=T1_concatwarp.nii.gz'
+#     >>> res = warputils.run() # doctest: +SKIP
+# 
+# 
+#     
+task_name: ConvertWarp
+nipype_name: ConvertWarp
+nipype_module: nipype.interfaces.fsl.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    reference: medimage/nifti1
+    # type=file|default=<undefined>: Name of a file in target space of the full transform.
+    out_file: generic/file
+    # type=file: Name of output file, containing the warp as field or coefficients.
+    # type=file|default=<undefined>: Name of output file, containing warps that are the combination of all those given as arguments. The format of this will be a field-file (rather than spline coefficients) with any affine components included.
+    premat: generic/file
+    # type=file|default=<undefined>: filename for pre-transform (affine matrix)
+    warp1: medimage/nifti1
+    # type=file|default=<undefined>: Name of file containing initial warp-fields/coefficients (follows premat). This could e.g. be a fnirt-transform from a subjects structural scan to an average of a group of subjects.
+    midmat: generic/file
+    # type=file|default=<undefined>: Name of file containing mid-warp-affine transform
+    warp2: generic/file
+    # type=file|default=<undefined>: Name of file containing secondary warp-fields/coefficients (after warp1/midmat but before postmat). This could e.g. be a fnirt-transform from the average of a group of subjects to some standard space (e.g. MNI152).
+    postmat: generic/file
+    # type=file|default=<undefined>: Name of file containing an affine transform (applied last). It could e.g. be an affine transform that maps the MNI152-space into a better approximation to the Talairach-space (if indeed there is one).
+    shift_in_file: generic/file
+    # type=file|default=<undefined>: Name of file containing a "shiftmap", a non-linear transform with displacements only in one direction (applied first, before premat). This would typically be a fieldmap that has been pre-processed using fugue that maps a subjects functional (EPI) data onto an undistorted space (i.e. a space that corresponds to his/her true anatomy).
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: Name of output file, containing the warp as field or coefficients.
+    # type=file|default=<undefined>: Name of output file, containing warps that are the combination of all those given as arguments. The format of this will be a field-file (rather than spline coefficients) with any affine components included.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    reference:
+    # type=file|default=<undefined>: Name of a file in target space of the full transform.
+    out_file:
+    # type=file: Name of output file, containing the warp as field or coefficients.
+    # type=file|default=<undefined>: Name of output file, containing warps that are the combination of all those given as arguments. The format of this will be a field-file (rather than spline coefficients) with any affine components included.
+    premat:
+    # type=file|default=<undefined>: filename for pre-transform (affine matrix)
+    warp1:
+    # type=file|default=<undefined>: Name of file containing initial warp-fields/coefficients (follows premat). This could e.g. be a fnirt-transform from a subjects structural scan to an average of a group of subjects.
+    midmat:
+    # type=file|default=<undefined>: Name of file containing mid-warp-affine transform
+    warp2:
+    # type=file|default=<undefined>: Name of file containing secondary warp-fields/coefficients (after warp1/midmat but before postmat). This could e.g. be a fnirt-transform from the average of a group of subjects to some standard space (e.g. MNI152).
+    postmat:
+    # type=file|default=<undefined>: Name of file containing an affine transform (applied last). It could e.g. be an affine transform that maps the MNI152-space into a better approximation to the Talairach-space (if indeed there is one).
+    shift_in_file:
+    # type=file|default=<undefined>: Name of file containing a "shiftmap", a non-linear transform with displacements only in one direction (applied first, before premat). This would typically be a fieldmap that has been pre-processed using fugue that maps a subjects functional (EPI) data onto an undistorted space (i.e. a space that corresponds to his/her true anatomy).
+    shift_direction:
+    # type=enum|default='y-'|allowed['x','x-','y','y-','z','z-']: Indicates the direction that the distortions from --shiftmap goes. It depends on the direction and polarity of the phase-encoding in the EPI sequence.
+    cons_jacobian:
+    # type=bool|default=False: Constrain the Jacobian of the warpfield to lie within specified min/max limits.
+    jacobian_min:
+    # type=float|default=0.0: Minimum acceptable Jacobian value for constraint (default 0.01)
+    jacobian_max:
+    # type=float|default=0.0: Maximum acceptable Jacobian value for constraint (default 100.0)
+    abswarp:
+    # type=bool|default=False: If set it indicates that the warps in --warp1 and --warp2 should be interpreted as absolute. I.e. the values in --warp1/2 are the coordinates in the next space, rather than displacements. This flag is ignored if --warp1/2 was created by fnirt, which always creates relative displacements.
+    relwarp:
+    # type=bool|default=False: If set it indicates that the warps in --warp1/2 should be interpreted as relative. I.e. the values in --warp1/2 are displacements from the coordinates in the next space.
+    out_abswarp:
+    # type=bool|default=False: If set it indicates that the warps in --out should be absolute, i.e. the values in --out are displacements from the coordinates in --ref.
+    out_relwarp:
+    # type=bool|default=False: If set it indicates that the warps in --out should be relative, i.e. the values in --out are displacements from the coordinates in --ref.
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    warp1:
+    # type=file|default=<undefined>: Name of file containing initial warp-fields/coefficients (follows premat). This could e.g. be a fnirt-transform from a subjects structural scan to an average of a group of subjects.
+    reference:
+    # type=file|default=<undefined>: Name of a file in target space of the full transform.
+    relwarp: 'True'
+    # type=bool|default=False: If set it indicates that the warps in --warp1/2 should be interpreted as relative. I.e. the values in --warp1/2 are displacements from the coordinates in the next space.
+    output_type: '"NIFTI_GZ"'
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: convertwarp --ref=T1.nii --rel --warp1=warpfield.nii --out=T1_concatwarp.nii.gz
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    warp1:
+    # type=file|default=<undefined>: Name of file containing initial warp-fields/coefficients (follows premat). This could e.g. be a fnirt-transform from a subjects structural scan to an average of a group of subjects.
+    reference:
+    # type=file|default=<undefined>: Name of a file in target space of the full transform.
+    relwarp: 'True'
+    # type=bool|default=False: If set it indicates that the warps in --warp1/2 should be interpreted as relative. I.e. the values in --warp1/2 are displacements from the coordinates in the next space.
+    output_type: '"NIFTI_GZ"'
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-fsl/convert_warp_callables.py b/example-specs/task/nipype_internal/pydra-fsl/convert_warp_callables.py
new file mode 100644
index 00000000..b6a046c7
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/convert_warp_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in ConvertWarp.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/convert_xfm.yaml b/example-specs/task/nipype_internal/pydra-fsl/convert_xfm.yaml
new file mode 100644
index 00000000..b6019cf1
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/convert_xfm.yaml
@@ -0,0 +1,149 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.utils.ConvertXFM' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Use the FSL utility convert_xfm to modify FLIRT transformation matrices.
+# 
+#     Examples
+#     --------
+# 
+#     >>> import nipype.interfaces.fsl as fsl
+#     >>> invt = fsl.ConvertXFM()
+#     >>> invt.inputs.in_file = "flirt.mat"
+#     >>> invt.inputs.invert_xfm = True
+#     >>> invt.inputs.out_file = 'flirt_inv.mat'
+#     >>> invt.cmdline
+#     'convert_xfm -omat flirt_inv.mat -inverse flirt.mat'
+# 
+# 
+#     
+task_name: ConvertXFM
+nipype_name: ConvertXFM
+nipype_module: nipype.interfaces.fsl.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: datascience/text-matrix
+    # type=file|default=<undefined>: input transformation matrix
+    in_file2: generic/file
+    # type=file|default=<undefined>: second input matrix (for use with fix_scale_skew or concat_xfm)
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: datascience/text-matrix
+    # type=file: output transformation matrix
+    # type=file|default=<undefined>: final transformation matrix
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: '"flirt_inv.mat"'
+    # type=file: output transformation matrix
+    # type=file|default=<undefined>: final transformation matrix
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input transformation matrix
+    in_file2:
+    # type=file|default=<undefined>: second input matrix (for use with fix_scale_skew or concat_xfm)
+    invert_xfm:
+    # type=bool|default=False: invert input transformation
+    concat_xfm:
+    # type=bool|default=False: write joint transformation of two input matrices
+    fix_scale_skew:
+    # type=bool|default=False: use secondary matrix to fix scale and skew
+    out_file:
+    # type=file: output transformation matrix
+    # type=file|default=<undefined>: final transformation matrix
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input transformation matrix
+    invert_xfm: 'True'
+    # type=bool|default=False: invert input transformation
+    out_file: '"flirt_inv.mat"'
+    # type=file: output transformation matrix
+    # type=file|default=<undefined>: final transformation matrix
+  imports: &id001
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  - module: nipype.interfaces.fsl as fsl
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: convert_xfm -omat flirt_inv.mat -inverse flirt.mat
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: input transformation matrix
+    invert_xfm: 'True'
+    # type=bool|default=False: invert input transformation
+    out_file: '"flirt_inv.mat"'
+    # type=file: output transformation matrix
+    # type=file|default=<undefined>: final transformation matrix
+  imports: *id001
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-fsl/convert_xfm_callables.py b/example-specs/task/nipype_internal/pydra-fsl/convert_xfm_callables.py
new file mode 100644
index 00000000..c81ca182
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/convert_xfm_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in ConvertXFM.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/copy_geom.yaml b/example-specs/task/nipype_internal/pydra-fsl/copy_geom.yaml
new file mode 100644
index 00000000..44d5cf9f
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/copy_geom.yaml
@@ -0,0 +1,87 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.utils.CopyGeom' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Use fslcpgeom to copy the header geometry information to another image.
+#     Copy certain parts of the header information (image dimensions, voxel
+#     dimensions, voxel dimensions units string, image orientation/origin or
+#     qform/sform info) from one image to another. Note that only copies from
+#     Analyze to Analyze or Nifti to Nifti will work properly. Copying from
+#     different files will result in loss of information or potentially incorrect
+#     settings.
+#     
+task_name: CopyGeom
+nipype_name: CopyGeom
+nipype_module: nipype.interfaces.fsl.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: source image
+    dest_file: generic/file
+    # type=file|default=<undefined>: destination image
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: image with new geometry header
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: source image
+    dest_file:
+    # type=file|default=<undefined>: destination image
+    ignore_dims:
+    # type=bool|default=False: Do not copy image dimensions
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-fsl/copy_geom_callables.py b/example-specs/task/nipype_internal/pydra-fsl/copy_geom_callables.py
new file mode 100644
index 00000000..384cdef4
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/copy_geom_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in CopyGeom.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/dilate_image.yaml b/example-specs/task/nipype_internal/pydra-fsl/dilate_image.yaml
new file mode 100644
index 00000000..89d3ecc7
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/dilate_image.yaml
@@ -0,0 +1,97 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.maths.DilateImage' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Use fslmaths to perform a spatial dilation of an image.
+task_name: DilateImage
+nipype_name: DilateImage
+nipype_module: nipype.interfaces.fsl.maths
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    kernel_file: generic/file
+    # type=file|default=<undefined>: use external file for kernel
+    in_file: generic/file
+    # type=file|default=<undefined>: image to operate on
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: out_file
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    operation:
+    # type=enum|default='mean'|allowed['max','mean','modal']: filtering operation to perform in dilation
+    kernel_shape:
+    # type=enum|default='3D'|allowed['2D','3D','box','boxv','file','gauss','sphere']: kernel shape to use
+    kernel_size:
+    # type=float|default=0.0: kernel size - voxels for box/boxv, mm for sphere, mm sigma for gauss
+    kernel_file:
+    # type=file|default=<undefined>: use external file for kernel
+    in_file:
+    # type=file|default=<undefined>: image to operate on
+    out_file:
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
+    internal_datatype:
+    # type=enum|default='float'|allowed['char','double','float','input','int','short']: datatype to use for calculations (default is float)
+    output_datatype:
+    # type=enum|default='float'|allowed['char','double','float','input','int','short']: datatype to use for output (default uses input type)
+    nan2zeros:
+    # type=bool|default=False: change NaNs to zeros before doing anything
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-fsl/dilate_image_callables.py b/example-specs/task/nipype_internal/pydra-fsl/dilate_image_callables.py
new file mode 100644
index 00000000..a27b1b06
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/dilate_image_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in DilateImage.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/distance_map.yaml b/example-specs/task/nipype_internal/pydra-fsl/distance_map.yaml
new file mode 100644
index 00000000..f774eb47
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/distance_map.yaml
@@ -0,0 +1,104 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.dti.DistanceMap' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Use FSL's distancemap to generate a map of the distance to the nearest
+#     nonzero voxel.
+# 
+#     Example
+#     -------
+# 
+#     >>> import nipype.interfaces.fsl as fsl
+#     >>> mapper = fsl.DistanceMap()
+#     >>> mapper.inputs.in_file = "skeleton_mask.nii.gz"
+#     >>> mapper.run() # doctest: +SKIP
+# 
+#     
+task_name: DistanceMap
+nipype_name: DistanceMap
+nipype_module: nipype.interfaces.fsl.dti
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: image to calculate distance values for
+    mask_file: generic/file
+    # type=file|default=<undefined>: binary mask to constrain calculations
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    distance_map: generic/file
+    # type=file: value is distance to nearest nonzero voxels
+    # type=file|default=<undefined>: distance map to write
+    local_max_file: generic/file
+    # type=file: image of local maxima
+    # type=traitcompound|default=None: write an image of the local maxima
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    distance_map: distance_map
+    # type=file: value is distance to nearest nonzero voxels
+    # type=file|default=<undefined>: distance map to write
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: image to calculate distance values for
+    mask_file:
+    # type=file|default=<undefined>: binary mask to constrain calculations
+    invert_input:
+    # type=bool|default=False: invert input image
+    local_max_file:
+    # type=file: image of local maxima
+    # type=traitcompound|default=None: write an image of the local maxima
+    distance_map:
+    # type=file: value is distance to nearest nonzero voxels
+    # type=file|default=<undefined>: distance map to write
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-fsl/distance_map_callables.py b/example-specs/task/nipype_internal/pydra-fsl/distance_map_callables.py
new file mode 100644
index 00000000..e8ef0b5f
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/distance_map_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in DistanceMap.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/dti_fit.yaml b/example-specs/task/nipype_internal/pydra-fsl/dti_fit.yaml
new file mode 100644
index 00000000..93b9163d
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/dti_fit.yaml
@@ -0,0 +1,203 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.dti.DTIFit' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Use FSL  dtifit command for fitting a diffusion tensor model at each
+#     voxel
+# 
+#     Example
+#     -------
+# 
+#     >>> from nipype.interfaces import fsl
+#     >>> dti = fsl.DTIFit()
+#     >>> dti.inputs.dwi = 'diffusion.nii'
+#     >>> dti.inputs.bvecs = 'bvecs'
+#     >>> dti.inputs.bvals = 'bvals'
+#     >>> dti.inputs.base_name = 'TP'
+#     >>> dti.inputs.mask = 'mask.nii'
+#     >>> dti.cmdline
+#     'dtifit -k diffusion.nii -o TP -m mask.nii -r bvecs -b bvals'
+# 
+#     
+task_name: DTIFit
+nipype_name: DTIFit
+nipype_module: nipype.interfaces.fsl.dti
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    dwi: medimage/nifti1
+    # type=file|default=<undefined>: diffusion weighted image data file
+    mask: medimage/nifti1
+    # type=file|default=<undefined>: bet binary mask file
+    bvecs: medimage/bvec
+    # type=file|default=<undefined>: b vectors file
+    bvals: medimage/bval
+    # type=file|default=<undefined>: b values file
+    cni: generic/file
+    # type=file|default=<undefined>: input counfound regressors
+    gradnonlin: generic/file
+    # type=file|default=<undefined>: gradient non linearities
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    V1: generic/file
+    # type=file: path/name of file with the 1st eigenvector
+    V2: generic/file
+    # type=file: path/name of file with the 2nd eigenvector
+    V3: generic/file
+    # type=file: path/name of file with the 3rd eigenvector
+    L1: generic/file
+    # type=file: path/name of file with the 1st eigenvalue
+    L2: generic/file
+    # type=file: path/name of file with the 2nd eigenvalue
+    L3: generic/file
+    # type=file: path/name of file with the 3rd eigenvalue
+    MD: generic/file
+    # type=file: path/name of file with the mean diffusivity
+    FA: generic/file
+    # type=file: path/name of file with the fractional anisotropy
+    MO: generic/file
+    # type=file: path/name of file with the mode of anisotropy
+    S0: generic/file
+    # type=file: path/name of file with the raw T2 signal with no diffusion weighting
+    tensor: generic/file
+    # type=file: path/name of file with the 4D tensor volume
+    sse: generic/file
+    # type=file: path/name of file with the summed squared error
+    # type=bool|default=False: output sum of squared errors
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    dwi:
+    # type=file|default=<undefined>: diffusion weighted image data file
+    base_name:
+    # type=str|default='dtifit_': base_name that all output files will start with
+    mask:
+    # type=file|default=<undefined>: bet binary mask file
+    bvecs:
+    # type=file|default=<undefined>: b vectors file
+    bvals:
+    # type=file|default=<undefined>: b values file
+    min_z:
+    # type=int|default=0: min z
+    max_z:
+    # type=int|default=0: max z
+    min_y:
+    # type=int|default=0: min y
+    max_y:
+    # type=int|default=0: max y
+    min_x:
+    # type=int|default=0: min x
+    max_x:
+    # type=int|default=0: max x
+    save_tensor:
+    # type=bool|default=False: save the elements of the tensor
+    sse:
+    # type=file: path/name of file with the summed squared error
+    # type=bool|default=False: output sum of squared errors
+    cni:
+    # type=file|default=<undefined>: input counfound regressors
+    little_bit:
+    # type=bool|default=False: only process small area of brain
+    gradnonlin:
+    # type=file|default=<undefined>: gradient non linearities
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    dwi:
+    # type=file|default=<undefined>: diffusion weighted image data file
+    bvecs:
+    # type=file|default=<undefined>: b vectors file
+    bvals:
+    # type=file|default=<undefined>: b values file
+    base_name: '"TP"'
+    # type=str|default='dtifit_': base_name that all output files will start with
+    mask:
+    # type=file|default=<undefined>: bet binary mask file
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: dtifit -k diffusion.nii -o TP -m mask.nii -r bvecs -b bvals
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    dwi:
+    # type=file|default=<undefined>: diffusion weighted image data file
+    bvecs:
+    # type=file|default=<undefined>: b vectors file
+    bvals:
+    # type=file|default=<undefined>: b values file
+    base_name: '"TP"'
+    # type=str|default='dtifit_': base_name that all output files will start with
+    mask:
+    # type=file|default=<undefined>: bet binary mask file
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-fsl/dti_fit_callables.py b/example-specs/task/nipype_internal/pydra-fsl/dti_fit_callables.py
new file mode 100644
index 00000000..5d71e93e
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/dti_fit_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in DTIFit.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/dual_regression.yaml b/example-specs/task/nipype_internal/pydra-fsl/dual_regression.yaml
new file mode 100644
index 00000000..d51819f7
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/dual_regression.yaml
@@ -0,0 +1,170 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.model.DualRegression' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Wrapper Script for Dual Regression Workflow
+# 
+#     Examples
+#     --------
+# 
+#     >>> dual_regression = DualRegression()
+#     >>> dual_regression.inputs.in_files = ["functional.nii", "functional2.nii", "functional3.nii"]
+#     >>> dual_regression.inputs.group_IC_maps_4D = "allFA.nii"
+#     >>> dual_regression.inputs.des_norm = False
+#     >>> dual_regression.inputs.one_sample_group_mean = True
+#     >>> dual_regression.inputs.n_perm = 10
+#     >>> dual_regression.inputs.out_dir = "my_output_directory"
+#     >>> dual_regression.cmdline
+#     'dual_regression allFA.nii 0 -1 10 my_output_directory functional.nii functional2.nii functional3.nii'
+#     >>> dual_regression.run() # doctest: +SKIP
+# 
+#     
+task_name: DualRegression
+nipype_name: DualRegression
+nipype_module: nipype.interfaces.fsl.model
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_files: medimage/nifti1+list-of
+    # type=inputmultiobject|default=[]: List all subjects' preprocessed, standard-space 4D datasets
+    group_IC_maps_4D: medimage/nifti1
+    # type=file|default=<undefined>: 4D image containing spatial IC maps (melodic_IC) from the whole-group ICA analysis
+    design_file: generic/file
+    # type=file|default=<undefined>: Design matrix for final cross-subject modelling with randomise
+    con_file: generic/file
+    # type=file|default=<undefined>: Design contrasts for final cross-subject modelling with randomise
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_dir: generic/directory
+    # type=directory: 
+    # type=directory|default='output': This directory will be created to hold all output and logfiles
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_dir: '"my_output_directory"'
+    # type=directory: 
+    # type=directory|default='output': This directory will be created to hold all output and logfiles
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_files:
+    # type=inputmultiobject|default=[]: List all subjects' preprocessed, standard-space 4D datasets
+    group_IC_maps_4D:
+    # type=file|default=<undefined>: 4D image containing spatial IC maps (melodic_IC) from the whole-group ICA analysis
+    des_norm:
+    # type=bool|default=True: Whether to variance-normalise the timecourses used as the stage-2 regressors; True is default and recommended
+    one_sample_group_mean:
+    # type=bool|default=False: perform 1-sample group-mean test instead of generic permutation test
+    design_file:
+    # type=file|default=<undefined>: Design matrix for final cross-subject modelling with randomise
+    con_file:
+    # type=file|default=<undefined>: Design contrasts for final cross-subject modelling with randomise
+    n_perm:
+    # type=int|default=0: Number of permutations for randomise; set to 1 for just raw tstat output, set to 0 to not run randomise at all.
+    out_dir:
+    # type=directory: 
+    # type=directory|default='output': This directory will be created to hold all output and logfiles
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_files:
+    # type=inputmultiobject|default=[]: List all subjects' preprocessed, standard-space 4D datasets
+    group_IC_maps_4D:
+    # type=file|default=<undefined>: 4D image containing spatial IC maps (melodic_IC) from the whole-group ICA analysis
+    des_norm: 'False'
+    # type=bool|default=True: Whether to variance-normalise the timecourses used as the stage-2 regressors; True is default and recommended
+    one_sample_group_mean: 'True'
+    # type=bool|default=False: perform 1-sample group-mean test instead of generic permutation test
+    n_perm: '10'
+    # type=int|default=0: Number of permutations for randomise; set to 1 for just raw tstat output, set to 0 to not run randomise at all.
+    out_dir: '"my_output_directory"'
+    # type=directory: 
+    # type=directory|default='output': This directory will be created to hold all output and logfiles
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: dual_regression allFA.nii 0 -1 10 my_output_directory functional.nii functional2.nii functional3.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_files:
+    # type=inputmultiobject|default=[]: List all subjects' preprocessed, standard-space 4D datasets
+    group_IC_maps_4D:
+    # type=file|default=<undefined>: 4D image containing spatial IC maps (melodic_IC) from the whole-group ICA analysis
+    des_norm: 'False'
+    # type=bool|default=True: Whether to variance-normalise the timecourses used as the stage-2 regressors; True is default and recommended
+    one_sample_group_mean: 'True'
+    # type=bool|default=False: perform 1-sample group-mean test instead of generic permutation test
+    n_perm: '10'
+    # type=int|default=0: Number of permutations for randomise; set to 1 for just raw tstat output, set to 0 to not run randomise at all.
+    out_dir: '"my_output_directory"'
+    # type=directory: 
+    # type=directory|default='output': This directory will be created to hold all output and logfiles
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-fsl/dual_regression_callables.py b/example-specs/task/nipype_internal/pydra-fsl/dual_regression_callables.py
new file mode 100644
index 00000000..1e6cc354
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/dual_regression_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in DualRegression.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/eddy.yaml b/example-specs/task/nipype_internal/pydra-fsl/eddy.yaml
new file mode 100644
index 00000000..ffe16f1e
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/eddy.yaml
@@ -0,0 +1,375 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.epi.Eddy' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Interface for FSL eddy, a tool for estimating and correcting eddy
+#     currents induced distortions. `User guide
+#     <https://fsl.fmrib.ox.ac.uk/fsl/fslwiki/eddy/UsersGuide>`__ and
+#     `more info regarding acqp file
+#     <https://fsl.fmrib.ox.ac.uk/fsl/fslwiki/eddy/Faq#How_do_I_know_what_to_put_into_my_--acqp_file.3F>`_.
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces.fsl import Eddy
+# 
+#     Running eddy on a CPU using OpenMP:
+#     >>> eddy = Eddy()
+#     >>> eddy.inputs.in_file = 'epi.nii'
+#     >>> eddy.inputs.in_mask  = 'epi_mask.nii'
+#     >>> eddy.inputs.in_index = 'epi_index.txt'
+#     >>> eddy.inputs.in_acqp  = 'epi_acqp.txt'
+#     >>> eddy.inputs.in_bvec  = 'bvecs.scheme'
+#     >>> eddy.inputs.in_bval  = 'bvals.scheme'
+#     >>> eddy.cmdline  # doctest: +ELLIPSIS
+#     'eddy_openmp --flm=quadratic --ff=10.0 --acqp=epi_acqp.txt --bvals=bvals.scheme --bvecs=bvecs.scheme --imain=epi.nii --index=epi_index.txt --mask=epi_mask.nii --interp=spline --resamp=jac --niter=5 --nvoxhp=1000 --out=.../eddy_corrected --slm=none'
+# 
+#     Running eddy on an Nvidia GPU using cuda:
+#     >>> eddy.inputs.use_cuda = True
+#     >>> eddy.cmdline # doctest: +ELLIPSIS
+#     'eddy_cuda --flm=quadratic --ff=10.0 --acqp=epi_acqp.txt --bvals=bvals.scheme --bvecs=bvecs.scheme --imain=epi.nii --index=epi_index.txt --mask=epi_mask.nii --interp=spline --resamp=jac --niter=5 --nvoxhp=1000 --out=.../eddy_corrected --slm=none'
+# 
+#     Running eddy with slice-to-volume motion correction:
+#     >>> eddy.inputs.mporder = 6
+#     >>> eddy.inputs.slice2vol_niter = 5
+#     >>> eddy.inputs.slice2vol_lambda = 1
+#     >>> eddy.inputs.slice2vol_interp = 'trilinear'
+#     >>> eddy.inputs.slice_order = 'epi_slspec.txt'
+#     >>> eddy.cmdline  # doctest: +ELLIPSIS
+#     'eddy_cuda --flm=quadratic --ff=10.0 --acqp=epi_acqp.txt --bvals=bvals.scheme --bvecs=bvecs.scheme --imain=epi.nii --index=epi_index.txt --mask=epi_mask.nii --interp=spline --resamp=jac --mporder=6 --niter=5 --nvoxhp=1000 --out=.../eddy_corrected --s2v_interp=trilinear --s2v_lambda=1 --s2v_niter=5 --slspec=epi_slspec.txt --slm=none'
+#     >>> res = eddy.run()     # doctest: +SKIP
+# 
+#     
+task_name: Eddy
+nipype_name: Eddy
+nipype_module: nipype.interfaces.fsl.epi
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: File containing all the images to estimate distortions for
+    in_mask: generic/file
+    # type=file|default=<undefined>: Mask to indicate brain
+    in_index: text/text-file
+    # type=file|default=<undefined>: File containing indices for all volumes in --imain into --acqp and --topup
+    in_acqp: generic/file
+    # type=file|default=<undefined>: File containing acquisition parameters
+    in_bvec: generic/file
+    # type=file|default=<undefined>: File containing the b-vectors for all volumes in --imain
+    in_bval: generic/file
+    # type=file|default=<undefined>: File containing the b-values for all volumes in --imain
+    session: generic/file
+    # type=file|default=<undefined>: File containing session indices for all volumes in --imain
+    in_topup_fieldcoef: generic/file
+    # type=file|default=<undefined>: Topup results file containing the field coefficients
+    in_topup_movpar: generic/file
+    # type=file|default=<undefined>: Topup results file containing the movement parameters (movpar.txt)
+    field: generic/file
+    # type=file|default=<undefined>: Non-topup derived fieldmap scaled in Hz
+    field_mat: generic/file
+    # type=file|default=<undefined>: Matrix specifying the relative positions of the fieldmap, --field, and the first volume of the input file, --imain
+    slice_order: text/text-file
+    # type=file|default='': Name of text file completely specifying slice/group acquisition
+    json: generic/file
+    # type=file|default='': Name of .json text file with information about slice timing
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_corrected: generic/file
+    # type=file: 4D image file containing all the corrected volumes
+    out_parameter: generic/file
+    # type=file: Text file with parameters defining the field and movement for each scan
+    out_rotated_bvecs: generic/file
+    # type=file: File containing rotated b-values for all volumes
+    out_movement_rms: generic/file
+    # type=file: Summary of the 'total movement' in each volume
+    out_restricted_movement_rms: generic/file
+    # type=file: Summary of the 'total movement' in each volume disregarding translation in the PE direction
+    out_shell_alignment_parameters: generic/file
+    # type=file: Text file containing rigid body movement parameters between the different shells as estimated by a post-hoc mutual information based registration
+    out_shell_pe_translation_parameters: generic/file
+    # type=file: Text file containing translation along the PE-direction between the different shells as estimated by a post-hoc mutual information based registration
+    out_outlier_map: generic/file
+    # type=file: Matrix where rows represent volumes and columns represent slices. "0" indicates that scan-slice is not an outlier and "1" indicates that it is
+    out_outlier_n_stdev_map: generic/file
+    # type=file: Matrix where rows represent volumes and columns represent slices. Values indicate number of standard deviations off the mean difference between observation and prediction is
+    out_outlier_n_sqr_stdev_map: generic/file
+    # type=file: Matrix where rows represent volumes and columns represent slices. Values indicate number of standard deivations off the square root of the mean squared difference between observation and prediction is
+    out_outlier_report: generic/file
+    # type=file: Text file with a plain language report on what outlier slices eddy has found
+    out_outlier_free: generic/file
+    # type=file: 4D image file not corrected for susceptibility or eddy-current distortions or subject movement but with outlier slices replaced
+    out_movement_over_time: generic/file
+    # type=file: Text file containing translations (mm) and rotations (radians) for each excitation
+    out_cnr_maps: generic/file
+    # type=file: path/name of file with the cnr_maps
+    out_residuals: generic/file
+    # type=file: path/name of file with the residuals
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: File containing all the images to estimate distortions for
+    in_mask:
+    # type=file|default=<undefined>: Mask to indicate brain
+    in_index:
+    # type=file|default=<undefined>: File containing indices for all volumes in --imain into --acqp and --topup
+    in_acqp:
+    # type=file|default=<undefined>: File containing acquisition parameters
+    in_bvec:
+    # type=file|default=<undefined>: File containing the b-vectors for all volumes in --imain
+    in_bval:
+    # type=file|default=<undefined>: File containing the b-values for all volumes in --imain
+    out_base:
+    # type=str|default='eddy_corrected': Basename for output image
+    session:
+    # type=file|default=<undefined>: File containing session indices for all volumes in --imain
+    in_topup_fieldcoef:
+    # type=file|default=<undefined>: Topup results file containing the field coefficients
+    in_topup_movpar:
+    # type=file|default=<undefined>: Topup results file containing the movement parameters (movpar.txt)
+    field:
+    # type=file|default=<undefined>: Non-topup derived fieldmap scaled in Hz
+    field_mat:
+    # type=file|default=<undefined>: Matrix specifying the relative positions of the fieldmap, --field, and the first volume of the input file, --imain
+    flm:
+    # type=enum|default='quadratic'|allowed['cubic','linear','quadratic']: First level EC model
+    slm:
+    # type=enum|default='none'|allowed['linear','none','quadratic']: Second level EC model
+    fep:
+    # type=bool|default=False: Fill empty planes in x- or y-directions
+    initrand:
+    # type=bool|default=False: Resets rand for when selecting voxels
+    interp:
+    # type=enum|default='spline'|allowed['spline','trilinear']: Interpolation model for estimation step
+    nvoxhp:
+    # type=int|default=1000: # of voxels used to estimate the hyperparameters
+    fudge_factor:
+    # type=float|default=10.0: Fudge factor for hyperparameter error variance
+    dont_sep_offs_move:
+    # type=bool|default=False: Do NOT attempt to separate field offset from subject movement
+    dont_peas:
+    # type=bool|default=False: Do NOT perform a post-eddy alignment of shells
+    fwhm:
+    # type=float|default=0.0: FWHM for conditioning filter when estimating the parameters
+    niter:
+    # type=int|default=5: Number of iterations
+    method:
+    # type=enum|default='jac'|allowed['jac','lsr']: Final resampling method (jacobian/least squares)
+    repol:
+    # type=bool|default=False: Detect and replace outlier slices
+    outlier_nstd:
+    # type=int|default=0: Number of std off to qualify as outlier
+    outlier_nvox:
+    # type=int|default=0: Min # of voxels in a slice for inclusion in outlier detection
+    outlier_type:
+    # type=enum|default='sw'|allowed['both','gw','sw']: Type of outliers, slicewise (sw), groupwise (gw) or both (both)
+    outlier_pos:
+    # type=bool|default=False: Consider both positive and negative outliers if set
+    outlier_sqr:
+    # type=bool|default=False: Consider outliers among sums-of-squared differences if set
+    multiband_factor:
+    # type=int|default=0: Multi-band factor
+    multiband_offset:
+    # type=enum|default=0|allowed[-1,0,1]: Multi-band offset (-1 if bottom slice removed, 1 if top slice removed
+    mporder:
+    # type=int|default=0: Order of slice-to-vol movement model
+    slice2vol_niter:
+    # type=int|default=0: Number of iterations for slice-to-vol
+    slice2vol_lambda:
+    # type=int|default=0: Regularisation weight for slice-to-vol movement (reasonable range 1-10)
+    slice2vol_interp:
+    # type=enum|default='trilinear'|allowed['spline','trilinear']: Slice-to-vol interpolation model for estimation step
+    slice_order:
+    # type=file|default='': Name of text file completely specifying slice/group acquisition
+    json:
+    # type=file|default='': Name of .json text file with information about slice timing
+    estimate_move_by_susceptibility:
+    # type=bool|default=False: Estimate how susceptibility field changes with subject movement
+    mbs_niter:
+    # type=int|default=0: Number of iterations for MBS estimation
+    mbs_lambda:
+    # type=int|default=0: Weighting of regularisation for MBS estimation
+    mbs_ksp:
+    # type=int|default=0: Knot-spacing for MBS field estimation
+    num_threads:
+    # type=int|default=1: Number of openmp threads to use
+    is_shelled:
+    # type=bool|default=False: Override internal check to ensure that date are acquired on a set of b-value shells
+    use_cuda:
+    # type=bool|default=False: Run eddy using cuda gpu
+    cnr_maps:
+    # type=bool|default=False: Output CNR-Maps
+    residuals:
+    # type=bool|default=False: Output Residuals
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: File containing all the images to estimate distortions for
+    in_index:
+    # type=file|default=<undefined>: File containing indices for all volumes in --imain into --acqp and --topup
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    use_cuda: 'True'
+    # type=bool|default=False: Run eddy using cuda gpu
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    mporder: '6'
+    # type=int|default=0: Order of slice-to-vol movement model
+    slice2vol_niter: '5'
+    # type=int|default=0: Number of iterations for slice-to-vol
+    slice2vol_lambda: '1'
+    # type=int|default=0: Regularisation weight for slice-to-vol movement (reasonable range 1-10)
+    slice2vol_interp: '"trilinear"'
+    # type=enum|default='trilinear'|allowed['spline','trilinear']: Slice-to-vol interpolation model for estimation step
+    slice_order:
+    # type=file|default='': Name of text file completely specifying slice/group acquisition
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: eddy_openmp --flm=quadratic --ff=10.0 --acqp=epi_acqp.txt --bvals=bvals.scheme --bvecs=bvecs.scheme --imain=epi.nii --index=epi_index.txt --mask=epi_mask.nii --interp=spline --resamp=jac --niter=5 --nvoxhp=1000 --out=.../eddy_corrected --slm=none
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: File containing all the images to estimate distortions for
+    in_index:
+    # type=file|default=<undefined>: File containing indices for all volumes in --imain into --acqp and --topup
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: eddy_cuda --flm=quadratic --ff=10.0 --acqp=epi_acqp.txt --bvals=bvals.scheme --bvecs=bvecs.scheme --imain=epi.nii --index=epi_index.txt --mask=epi_mask.nii --interp=spline --resamp=jac --niter=5 --nvoxhp=1000 --out=.../eddy_corrected --slm=none
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    use_cuda: 'True'
+    # type=bool|default=False: Run eddy using cuda gpu
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: eddy_cuda --flm=quadratic --ff=10.0 --acqp=epi_acqp.txt --bvals=bvals.scheme --bvecs=bvecs.scheme --imain=epi.nii --index=epi_index.txt --mask=epi_mask.nii --interp=spline --resamp=jac --mporder=6 --niter=5 --nvoxhp=1000 --out=.../eddy_corrected --s2v_interp=trilinear --s2v_lambda=1 --s2v_niter=5 --slspec=epi_slspec.txt --slm=none
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    mporder: '6'
+    # type=int|default=0: Order of slice-to-vol movement model
+    slice2vol_niter: '5'
+    # type=int|default=0: Number of iterations for slice-to-vol
+    slice2vol_lambda: '1'
+    # type=int|default=0: Regularisation weight for slice-to-vol movement (reasonable range 1-10)
+    slice2vol_interp: '"trilinear"'
+    # type=enum|default='trilinear'|allowed['spline','trilinear']: Slice-to-vol interpolation model for estimation step
+    slice_order:
+    # type=file|default='': Name of text file completely specifying slice/group acquisition
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-fsl/eddy_callables.py b/example-specs/task/nipype_internal/pydra-fsl/eddy_callables.py
new file mode 100644
index 00000000..8b90e546
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/eddy_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Eddy.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/eddy_correct.yaml b/example-specs/task/nipype_internal/pydra-fsl/eddy_correct.yaml
new file mode 100644
index 00000000..4b48aa5d
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/eddy_correct.yaml
@@ -0,0 +1,135 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.epi.EddyCorrect' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+# 
+#     .. warning:: Deprecated in FSL. Please use
+#       :class:`nipype.interfaces.fsl.epi.Eddy` instead
+# 
+#     Example
+#     -------
+# 
+#     >>> from nipype.interfaces.fsl import EddyCorrect
+#     >>> eddyc = EddyCorrect(in_file='diffusion.nii',
+#     ...                     out_file="diffusion_edc.nii", ref_num=0)
+#     >>> eddyc.cmdline
+#     'eddy_correct diffusion.nii diffusion_edc.nii 0'
+# 
+#     
+task_name: EddyCorrect
+nipype_name: EddyCorrect
+nipype_module: nipype.interfaces.fsl.epi
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: 4D input file
+    out_file: medimage/nifti1
+    # type=file|default=<undefined>: 4D output file
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    eddy_corrected: generic/file
+    # type=file: path/name of 4D eddy corrected output file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: 4D input file
+    out_file:
+    # type=file|default=<undefined>: 4D output file
+    ref_num:
+    # type=int|default=0: reference number
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: 4D input file
+    out_file:
+    # type=file|default=<undefined>: 4D output file
+    ref_num: '0'
+    # type=int|default=0: reference number
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: eddy_correct diffusion.nii diffusion_edc.nii 0
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: 4D input file
+    out_file:
+    # type=file|default=<undefined>: 4D output file
+    ref_num: '0'
+    # type=int|default=0: reference number
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-fsl/eddy_correct_callables.py b/example-specs/task/nipype_internal/pydra-fsl/eddy_correct_callables.py
new file mode 100644
index 00000000..dfb3b961
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/eddy_correct_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in EddyCorrect.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/eddy_quad.yaml b/example-specs/task/nipype_internal/pydra-fsl/eddy_quad.yaml
new file mode 100644
index 00000000..1da8a64e
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/eddy_quad.yaml
@@ -0,0 +1,172 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.epi.EddyQuad' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Interface for FSL eddy_quad, a tool for generating single subject reports
+#     and storing the quality assessment indices for each subject.
+#     `User guide <https://fsl.fmrib.ox.ac.uk/fsl/fslwiki/eddyqc/UsersGuide>`__
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces.fsl import EddyQuad
+#     >>> quad = EddyQuad()
+#     >>> quad.inputs.base_name  = 'eddy_corrected'
+#     >>> quad.inputs.idx_file   = 'epi_index.txt'
+#     >>> quad.inputs.param_file = 'epi_acqp.txt'
+#     >>> quad.inputs.mask_file  = 'epi_mask.nii'
+#     >>> quad.inputs.bval_file  = 'bvals.scheme'
+#     >>> quad.inputs.bvec_file  = 'bvecs.scheme'
+#     >>> quad.inputs.output_dir = 'eddy_corrected.qc'
+#     >>> quad.inputs.field      = 'fieldmap_phase_fslprepared.nii'
+#     >>> quad.inputs.verbose    = True
+#     >>> quad.cmdline
+#     'eddy_quad eddy_corrected --bvals bvals.scheme --bvecs bvecs.scheme --field fieldmap_phase_fslprepared.nii --eddyIdx epi_index.txt --mask epi_mask.nii --output-dir eddy_corrected.qc --eddyParams epi_acqp.txt --verbose'
+#     >>> res = quad.run() # doctest: +SKIP
+# 
+#     
+task_name: EddyQuad
+nipype_name: EddyQuad
+nipype_module: nipype.interfaces.fsl.epi
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    idx_file: generic/file
+    # type=file|default=<undefined>: File containing indices for all volumes into acquisition parameters
+    param_file: text/text-file
+    # type=file|default=<undefined>: File containing acquisition parameters
+    mask_file: generic/file
+    # type=file|default=<undefined>: Binary mask file
+    bval_file: generic/file
+    # type=file|default=<undefined>: b-values file
+    bvec_file: generic/file
+    # type=file|default=<undefined>: b-vectors file - only used when <base_name>.eddy_residuals file is present
+    field: generic/file
+    # type=file|default=<undefined>: TOPUP estimated field (in Hz)
+    slice_spec: generic/file
+    # type=file|default=<undefined>: Text file specifying slice/group acquisition
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    qc_json: generic/file
+    # type=file: Single subject database containing quality metrics and data info.
+    qc_pdf: generic/file
+    # type=file: Single subject QC report.
+    vdm_png: generic/file
+    # type=file: Image showing mid-sagittal, -coronal and -axial slices of the voxel displacement map. Generated when using the -f option.
+    residuals: generic/file
+    # type=file: Text file containing the volume-wise mask-averaged squared residuals. Generated when residual maps are available.
+    clean_volumes: generic/file
+    # type=file: Text file containing a list of clean volumes, based on the eddy squared residuals. To generate a version of the pre-processed dataset without outlier volumes, use: `fslselectvols -i <eddy_corrected_data> -o eddy_corrected_data_clean --vols=vols_no_outliers.txt`
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    base_name:
+    # type=str|default='eddy_corrected': Basename (including path) for EDDY output files, i.e., corrected images and QC files
+    idx_file:
+    # type=file|default=<undefined>: File containing indices for all volumes into acquisition parameters
+    param_file:
+    # type=file|default=<undefined>: File containing acquisition parameters
+    mask_file:
+    # type=file|default=<undefined>: Binary mask file
+    bval_file:
+    # type=file|default=<undefined>: b-values file
+    bvec_file:
+    # type=file|default=<undefined>: b-vectors file - only used when <base_name>.eddy_residuals file is present
+    output_dir:
+    # type=str|default='': Output directory - default = '<base_name>.qc'
+    field:
+    # type=file|default=<undefined>: TOPUP estimated field (in Hz)
+    slice_spec:
+    # type=file|default=<undefined>: Text file specifying slice/group acquisition
+    verbose:
+    # type=bool|default=False: Display debug messages
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    param_file:
+    # type=file|default=<undefined>: File containing acquisition parameters
+    output_dir: '"eddy_corrected.qc"'
+    # type=str|default='': Output directory - default = '<base_name>.qc'
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: eddy_quad eddy_corrected --bvals bvals.scheme --bvecs bvecs.scheme --field fieldmap_phase_fslprepared.nii --eddyIdx epi_index.txt --mask epi_mask.nii --output-dir eddy_corrected.qc --eddyParams epi_acqp.txt --verbose
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    param_file:
+    # type=file|default=<undefined>: File containing acquisition parameters
+    output_dir: '"eddy_corrected.qc"'
+    # type=str|default='': Output directory - default = '<base_name>.qc'
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-fsl/eddy_quad_callables.py b/example-specs/task/nipype_internal/pydra-fsl/eddy_quad_callables.py
new file mode 100644
index 00000000..1720ae13
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/eddy_quad_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in EddyQuad.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/epi_de_warp.yaml b/example-specs/task/nipype_internal/pydra-fsl/epi_de_warp.yaml
new file mode 100644
index 00000000..22536184
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/epi_de_warp.yaml
@@ -0,0 +1,185 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.epi.EPIDeWarp' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Wraps the unwarping script `epidewarp.fsl
+#     <http://surfer.nmr.mgh.harvard.edu/fswiki/epidewarp.fsl>`_.
+# 
+#     .. warning:: deprecated in FSL, please use
+#       :func:`niflow.nipype1.workflows.dmri.preprocess.epi.sdc_fmb` instead.
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces.fsl import EPIDeWarp
+#     >>> dewarp = EPIDeWarp()
+#     >>> dewarp.inputs.epi_file = "functional.nii"
+#     >>> dewarp.inputs.mag_file = "magnitude.nii"
+#     >>> dewarp.inputs.dph_file = "phase.nii"
+#     >>> dewarp.inputs.output_type = "NIFTI_GZ"
+#     >>> dewarp.cmdline # doctest: +ELLIPSIS
+#     'epidewarp.fsl --mag magnitude.nii --dph phase.nii --epi functional.nii --esp 0.58 --exfdw .../exfdw.nii.gz --nocleanup --sigma 2 --tediff 2.46 --tmpdir .../temp --vsm .../vsm.nii.gz'
+#     >>> res = dewarp.run() # doctest: +SKIP
+# 
+# 
+#     
+task_name: EPIDeWarp
+nipype_name: EPIDeWarp
+nipype_module: nipype.interfaces.fsl.epi
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    mag_file: medimage/nifti1
+    # type=file|default=<undefined>: Magnitude file
+    dph_file: medimage/nifti1
+    # type=file|default=<undefined>: Phase file assumed to be scaled from 0 to 4095
+    exf_file: generic/file
+    # type=file|default=<undefined>: example func volume (or use epi)
+    epi_file: medimage/nifti1
+    # type=file|default=<undefined>: EPI volume to unwarp
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    unwarped_file: generic/file
+    # type=file: unwarped epi file
+    vsm_file: generic/file
+    # type=file: voxel shift map
+    exfdw: generic/file
+    # type=file: dewarped functional volume example
+    # type=string|default='': dewarped example func volume
+    exf_mask: generic/file
+    # type=file: Mask from example functional volume
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    vsm: vsm
+    # type=string|default='': voxel shift map
+    exfdw: exfdw
+    # type=file: dewarped functional volume example
+    # type=string|default='': dewarped example func volume
+    tmpdir: tmpdir
+    # type=string|default='': tmpdir
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    mag_file:
+    # type=file|default=<undefined>: Magnitude file
+    dph_file:
+    # type=file|default=<undefined>: Phase file assumed to be scaled from 0 to 4095
+    exf_file:
+    # type=file|default=<undefined>: example func volume (or use epi)
+    epi_file:
+    # type=file|default=<undefined>: EPI volume to unwarp
+    tediff:
+    # type=float|default=2.46: difference in B0 field map TEs
+    esp:
+    # type=float|default=0.58: EPI echo spacing
+    sigma:
+    # type=int|default=2: 2D spatial gaussing smoothing                        stdev (default = 2mm)
+    vsm:
+    # type=string|default='': voxel shift map
+    exfdw:
+    # type=file: dewarped functional volume example
+    # type=string|default='': dewarped example func volume
+    epidw:
+    # type=string|default='': dewarped epi volume
+    tmpdir:
+    # type=string|default='': tmpdir
+    nocleanup:
+    # type=bool|default=True: no cleanup
+    cleanup:
+    # type=bool|default=False: cleanup
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    epi_file:
+    # type=file|default=<undefined>: EPI volume to unwarp
+    mag_file:
+    # type=file|default=<undefined>: Magnitude file
+    dph_file:
+    # type=file|default=<undefined>: Phase file assumed to be scaled from 0 to 4095
+    output_type: '"NIFTI_GZ"'
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: epidewarp.fsl --mag magnitude.nii --dph phase.nii --epi functional.nii --esp 0.58 --exfdw .../exfdw.nii.gz --nocleanup --sigma 2 --tediff 2.46 --tmpdir .../temp --vsm .../vsm.nii.gz
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    epi_file:
+    # type=file|default=<undefined>: EPI volume to unwarp
+    mag_file:
+    # type=file|default=<undefined>: Magnitude file
+    dph_file:
+    # type=file|default=<undefined>: Phase file assumed to be scaled from 0 to 4095
+    output_type: '"NIFTI_GZ"'
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-fsl/epi_de_warp_callables.py b/example-specs/task/nipype_internal/pydra-fsl/epi_de_warp_callables.py
new file mode 100644
index 00000000..33f2aea8
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/epi_de_warp_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in EPIDeWarp.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/epi_reg.yaml b/example-specs/task/nipype_internal/pydra-fsl/epi_reg.yaml
new file mode 100644
index 00000000..cede9c09
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/epi_reg.yaml
@@ -0,0 +1,229 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.epi.EpiReg' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+# 
+#     Runs FSL epi_reg script for simultaneous coregistration and fieldmap
+#     unwarping.
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces.fsl import EpiReg
+#     >>> epireg = EpiReg()
+#     >>> epireg.inputs.epi='epi.nii'
+#     >>> epireg.inputs.t1_head='T1.nii'
+#     >>> epireg.inputs.t1_brain='T1_brain.nii'
+#     >>> epireg.inputs.out_base='epi2struct'
+#     >>> epireg.inputs.fmap='fieldmap_phase_fslprepared.nii'
+#     >>> epireg.inputs.fmapmag='fieldmap_mag.nii'
+#     >>> epireg.inputs.fmapmagbrain='fieldmap_mag_brain.nii'
+#     >>> epireg.inputs.echospacing=0.00067
+#     >>> epireg.inputs.pedir='y'
+#     >>> epireg.cmdline # doctest: +ELLIPSIS
+#     'epi_reg --echospacing=0.000670 --fmap=fieldmap_phase_fslprepared.nii --fmapmag=fieldmap_mag.nii --fmapmagbrain=fieldmap_mag_brain.nii --noclean --pedir=y --epi=epi.nii --t1=T1.nii --t1brain=T1_brain.nii --out=epi2struct'
+#     >>> epireg.run() # doctest: +SKIP
+# 
+#     
+task_name: EpiReg
+nipype_name: EpiReg
+nipype_module: nipype.interfaces.fsl.epi
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    epi: medimage/nifti1
+    # type=file|default=<undefined>: EPI image
+    t1_head: medimage/nifti1
+    # type=file|default=<undefined>: wholehead T1 image
+    t1_brain: medimage/nifti1
+    # type=file|default=<undefined>: brain extracted T1 image
+    fmap: medimage/nifti1
+    # type=file|default=<undefined>: fieldmap image (in rad/s)
+    fmapmag: medimage/nifti1
+    # type=file|default=<undefined>: fieldmap magnitude image - wholehead
+    fmapmagbrain: medimage/nifti1
+    # type=file|default=<undefined>: fieldmap magnitude image - brain extracted
+    wmseg: generic/file
+    # type=file: white matter segmentation used in flirt bbr
+    # type=file|default=<undefined>: white matter segmentation of T1 image, has to be named                  like the t1brain and end on _wmseg
+    weight_image: generic/file
+    # type=file|default=<undefined>: weighting image (in T1 space)
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: unwarped and coregistered epi input
+    out_1vol: generic/file
+    # type=file: unwarped and coregistered single volume
+    fmap2str_mat: generic/file
+    # type=file: rigid fieldmap-to-structural transform
+    fmap2epi_mat: generic/file
+    # type=file: rigid fieldmap-to-epi transform
+    fmap_epi: generic/file
+    # type=file: fieldmap in epi space
+    fmap_str: generic/file
+    # type=file: fieldmap in structural space
+    fmapmag_str: generic/file
+    # type=file: fieldmap magnitude image in structural space
+    epi2str_inv: generic/file
+    # type=file: rigid structural-to-epi transform
+    epi2str_mat: generic/file
+    # type=file: rigid epi-to-structural transform
+    shiftmap: generic/file
+    # type=file: shiftmap in epi space
+    fullwarp: generic/file
+    # type=file: warpfield to unwarp epi and transform into                     structural space
+    wmseg: generic/file
+    # type=file: white matter segmentation used in flirt bbr
+    # type=file|default=<undefined>: white matter segmentation of T1 image, has to be named                  like the t1brain and end on _wmseg
+    seg: generic/file
+    # type=file: white matter, gray matter, csf segmentation
+    wmedge: generic/file
+    # type=file: white matter edges for visualization
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    epi:
+    # type=file|default=<undefined>: EPI image
+    t1_head:
+    # type=file|default=<undefined>: wholehead T1 image
+    t1_brain:
+    # type=file|default=<undefined>: brain extracted T1 image
+    out_base:
+    # type=string|default='epi2struct': output base name
+    fmap:
+    # type=file|default=<undefined>: fieldmap image (in rad/s)
+    fmapmag:
+    # type=file|default=<undefined>: fieldmap magnitude image - wholehead
+    fmapmagbrain:
+    # type=file|default=<undefined>: fieldmap magnitude image - brain extracted
+    wmseg:
+    # type=file: white matter segmentation used in flirt bbr
+    # type=file|default=<undefined>: white matter segmentation of T1 image, has to be named                  like the t1brain and end on _wmseg
+    echospacing:
+    # type=float|default=0.0: Effective EPI echo spacing                                 (sometimes called dwell time) - in seconds
+    pedir:
+    # type=enum|default='x'|allowed['-x','-y','-z','x','y','z']: phase encoding direction, dir = x/y/z/-x/-y/-z
+    weight_image:
+    # type=file|default=<undefined>: weighting image (in T1 space)
+    no_fmapreg:
+    # type=bool|default=False: do not perform registration of fmap to T1                         (use if fmap already registered)
+    no_clean:
+    # type=bool|default=True: do not clean up intermediate files
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    epi:
+    # type=file|default=<undefined>: EPI image
+    t1_head:
+    # type=file|default=<undefined>: wholehead T1 image
+    t1_brain:
+    # type=file|default=<undefined>: brain extracted T1 image
+    out_base: '"epi2struct"'
+    # type=string|default='epi2struct': output base name
+    fmap:
+    # type=file|default=<undefined>: fieldmap image (in rad/s)
+    fmapmag:
+    # type=file|default=<undefined>: fieldmap magnitude image - wholehead
+    fmapmagbrain:
+    # type=file|default=<undefined>: fieldmap magnitude image - brain extracted
+    echospacing: '0.00067'
+    # type=float|default=0.0: Effective EPI echo spacing                                 (sometimes called dwell time) - in seconds
+    pedir: '"y"'
+    # type=enum|default='x'|allowed['-x','-y','-z','x','y','z']: phase encoding direction, dir = x/y/z/-x/-y/-z
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: epi_reg --echospacing=0.000670 --fmap=fieldmap_phase_fslprepared.nii --fmapmag=fieldmap_mag.nii --fmapmagbrain=fieldmap_mag_brain.nii --noclean --pedir=y --epi=epi.nii --t1=T1.nii --t1brain=T1_brain.nii --out=epi2struct
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    epi:
+    # type=file|default=<undefined>: EPI image
+    t1_head:
+    # type=file|default=<undefined>: wholehead T1 image
+    t1_brain:
+    # type=file|default=<undefined>: brain extracted T1 image
+    out_base: '"epi2struct"'
+    # type=string|default='epi2struct': output base name
+    fmap:
+    # type=file|default=<undefined>: fieldmap image (in rad/s)
+    fmapmag:
+    # type=file|default=<undefined>: fieldmap magnitude image - wholehead
+    fmapmagbrain:
+    # type=file|default=<undefined>: fieldmap magnitude image - brain extracted
+    echospacing: '0.00067'
+    # type=float|default=0.0: Effective EPI echo spacing                                 (sometimes called dwell time) - in seconds
+    pedir: '"y"'
+    # type=enum|default='x'|allowed['-x','-y','-z','x','y','z']: phase encoding direction, dir = x/y/z/-x/-y/-z
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-fsl/epi_reg_callables.py b/example-specs/task/nipype_internal/pydra-fsl/epi_reg_callables.py
new file mode 100644
index 00000000..06d672a6
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/epi_reg_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in EpiReg.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/erode_image.yaml b/example-specs/task/nipype_internal/pydra-fsl/erode_image.yaml
new file mode 100644
index 00000000..821cfac2
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/erode_image.yaml
@@ -0,0 +1,97 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.maths.ErodeImage' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Use fslmaths to perform a spatial erosion of an image.
+task_name: ErodeImage
+nipype_name: ErodeImage
+nipype_module: nipype.interfaces.fsl.maths
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    kernel_file: generic/file
+    # type=file|default=<undefined>: use external file for kernel
+    in_file: generic/file
+    # type=file|default=<undefined>: image to operate on
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: out_file
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    minimum_filter:
+    # type=bool|default=False: if true, minimum filter rather than erosion by zeroing-out
+    kernel_shape:
+    # type=enum|default='3D'|allowed['2D','3D','box','boxv','file','gauss','sphere']: kernel shape to use
+    kernel_size:
+    # type=float|default=0.0: kernel size - voxels for box/boxv, mm for sphere, mm sigma for gauss
+    kernel_file:
+    # type=file|default=<undefined>: use external file for kernel
+    in_file:
+    # type=file|default=<undefined>: image to operate on
+    out_file:
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
+    internal_datatype:
+    # type=enum|default='float'|allowed['char','double','float','input','int','short']: datatype to use for calculations (default is float)
+    output_datatype:
+    # type=enum|default='float'|allowed['char','double','float','input','int','short']: datatype to use for output (default uses input type)
+    nan2zeros:
+    # type=bool|default=False: change NaNs to zeros before doing anything
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-fsl/erode_image_callables.py b/example-specs/task/nipype_internal/pydra-fsl/erode_image_callables.py
new file mode 100644
index 00000000..545fa4d7
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/erode_image_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in ErodeImage.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/extract_roi.yaml b/example-specs/task/nipype_internal/pydra-fsl/extract_roi.yaml
new file mode 100644
index 00000000..1e3c7445
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/extract_roi.yaml
@@ -0,0 +1,172 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.utils.ExtractROI' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Uses FSL Fslroi command to extract region of interest (ROI)
+#     from an image.
+# 
+#     You can a) take a 3D ROI from a 3D data set (or if it is 4D, the
+#     same ROI is taken from each time point and a new 4D data set is
+#     created), b) extract just some time points from a 4D data set, or
+#     c) control time and space limits to the ROI.  Note that the
+#     arguments are minimum index and size (not maximum index).  So to
+#     extract voxels 10 to 12 inclusive you would specify 10 and 3 (not
+#     10 and 12).
+# 
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces.fsl import ExtractROI
+#     >>> from nipype.testing import anatfile
+#     >>> fslroi = ExtractROI(in_file=anatfile, roi_file='bar.nii', t_min=0,
+#     ...                     t_size=1)
+#     >>> fslroi.cmdline == 'fslroi %s bar.nii 0 1' % anatfile
+#     True
+# 
+# 
+#     
+task_name: ExtractROI
+nipype_name: ExtractROI
+nipype_module: nipype.interfaces.fsl.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: input file
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    roi_file: medimage/nifti1
+    # type=file: 
+    # type=file|default=<undefined>: output file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    roi_file: '"bar.nii"'
+    # type=file: 
+    # type=file|default=<undefined>: output file
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file
+    roi_file:
+    # type=file: 
+    # type=file|default=<undefined>: output file
+    x_min:
+    # type=int|default=0: 
+    x_size:
+    # type=int|default=0: 
+    y_min:
+    # type=int|default=0: 
+    y_size:
+    # type=int|default=0: 
+    z_min:
+    # type=int|default=0: 
+    z_size:
+    # type=int|default=0: 
+    t_min:
+    # type=int|default=0: 
+    t_size:
+    # type=int|default=0: 
+    crop_list:
+    # type=list|default=[]: list of two tuples specifying crop options
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file
+    roi_file: '"bar.nii"'
+    # type=file: 
+    # type=file|default=<undefined>: output file
+    t_min: '0'
+    # type=int|default=0: 
+    t_size: '1'
+    # type=int|default=0: 
+  imports: &id001
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  - module: nipype.testing
+    name: anatfile
+    alias:
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline:
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: input file
+    roi_file: '"bar.nii"'
+    # type=file: 
+    # type=file|default=<undefined>: output file
+    t_min: '0'
+    # type=int|default=0: 
+    t_size: '1'
+    # type=int|default=0: 
+  imports: *id001
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-fsl/extract_roi_callables.py b/example-specs/task/nipype_internal/pydra-fsl/extract_roi_callables.py
new file mode 100644
index 00000000..9292403e
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/extract_roi_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in ExtractROI.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/fast.yaml b/example-specs/task/nipype_internal/pydra-fsl/fast.yaml
new file mode 100644
index 00000000..c6179d97
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/fast.yaml
@@ -0,0 +1,181 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.preprocess.FAST' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# FSL FAST wrapper for segmentation and bias correction
+# 
+#     For complete details, see the `FAST Documentation.
+#     <https://fsl.fmrib.ox.ac.uk/fsl/fslwiki/FAST>`_
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import fsl
+#     >>> fast = fsl.FAST()
+#     >>> fast.inputs.in_files = 'structural.nii'
+#     >>> fast.inputs.out_basename = 'fast_'
+#     >>> fast.cmdline
+#     'fast -o fast_ -S 1 structural.nii'
+#     >>> out = fast.run()  # doctest: +SKIP
+# 
+#     
+task_name: FAST
+nipype_name: FAST
+nipype_module: nipype.interfaces.fsl.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_files: medimage/nifti1+list-of
+    # type=inputmultiobject|default=[]: image, or multi-channel set of images, to be segmented
+    out_basename: generic/file
+    # type=file|default=<undefined>: base name of output files
+    init_transform: generic/file
+    # type=file|default=<undefined>: <standard2input.mat> initialise using priors
+    other_priors: generic/file+list-of
+    # type=inputmultiobject|default=[]: alternative prior images
+    manual_seg: generic/file
+    # type=file|default=<undefined>: Filename containing intensities
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    tissue_class_map: generic/file
+    # type=file: path/name of binary segmented volume file one val for each class  _seg
+    mixeltype: generic/file
+    # type=file: path/name of mixeltype volume file _mixeltype
+    partial_volume_map: generic/file
+    # type=file: path/name of partial volume file _pveseg
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_files:
+    # type=inputmultiobject|default=[]: image, or multi-channel set of images, to be segmented
+    out_basename:
+    # type=file|default=<undefined>: base name of output files
+    number_classes:
+    # type=range|default=1: number of tissue-type classes
+    output_biasfield:
+    # type=bool|default=False: output estimated bias field
+    output_biascorrected:
+    # type=bool|default=False: output restored image (bias-corrected image)
+    img_type:
+    # type=enum|default=1|allowed[1,2,3]: int specifying type of image: (1 = T1, 2 = T2, 3 = PD)
+    bias_iters:
+    # type=range|default=1: number of main-loop iterations during bias-field removal
+    bias_lowpass:
+    # type=range|default=4: bias field smoothing extent (FWHM) in mm
+    init_seg_smooth:
+    # type=range|default=0.0001: initial segmentation spatial smoothness (during bias field estimation)
+    segments:
+    # type=bool|default=False: outputs a separate binary image for each tissue type
+    init_transform:
+    # type=file|default=<undefined>: <standard2input.mat> initialise using priors
+    other_priors:
+    # type=inputmultiobject|default=[]: alternative prior images
+    no_pve:
+    # type=bool|default=False: turn off PVE (partial volume estimation)
+    no_bias:
+    # type=bool|default=False: do not remove bias field
+    use_priors:
+    # type=bool|default=False: use priors throughout
+    segment_iters:
+    # type=range|default=1: number of segmentation-initialisation iterations
+    mixel_smooth:
+    # type=range|default=0.0: spatial smoothness for mixeltype
+    iters_afterbias:
+    # type=range|default=1: number of main-loop iterations after bias-field removal
+    hyper:
+    # type=range|default=0.0: segmentation spatial smoothness
+    verbose:
+    # type=bool|default=False: switch on diagnostic messages
+    manual_seg:
+    # type=file|default=<undefined>: Filename containing intensities
+    probability_maps:
+    # type=outputmultiobject: 
+    # type=bool|default=False: outputs individual probability maps
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_files:
+    # type=inputmultiobject|default=[]: image, or multi-channel set of images, to be segmented
+    out_basename:
+    # type=file|default=<undefined>: base name of output files
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: fast -o fast_ -S 1 structural.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_files:
+    # type=inputmultiobject|default=[]: image, or multi-channel set of images, to be segmented
+    out_basename:
+    # type=file|default=<undefined>: base name of output files
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-fsl/fast_callables.py b/example-specs/task/nipype_internal/pydra-fsl/fast_callables.py
new file mode 100644
index 00000000..4e29548b
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/fast_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in FAST.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/feat.yaml b/example-specs/task/nipype_internal/pydra-fsl/feat.yaml
new file mode 100644
index 00000000..78cb408f
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/feat.yaml
@@ -0,0 +1,74 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.model.FEAT' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Uses FSL feat to calculate first level stats
+task_name: FEAT
+nipype_name: FEAT
+nipype_module: nipype.interfaces.fsl.model
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    fsf_file: generic/file
+    # type=file|default=<undefined>: File specifying the feat design spec file
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    feat_dir: generic/directory
+    # type=directory: 
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    fsf_file:
+    # type=file|default=<undefined>: File specifying the feat design spec file
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-fsl/feat_callables.py b/example-specs/task/nipype_internal/pydra-fsl/feat_callables.py
new file mode 100644
index 00000000..ac5b32f2
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/feat_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in FEAT.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/feat_model.yaml b/example-specs/task/nipype_internal/pydra-fsl/feat_model.yaml
new file mode 100644
index 00000000..6b7fe8bc
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/feat_model.yaml
@@ -0,0 +1,86 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.model.FEATModel' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Uses FSL feat_model to generate design.mat files
+task_name: FEATModel
+nipype_name: FEATModel
+nipype_module: nipype.interfaces.fsl.model
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    fsf_file: generic/file
+    # type=file|default=<undefined>: File specifying the feat design spec file
+    ev_files: generic/file+list-of
+    # type=list|default=[]: Event spec files generated by level1design
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    design_file: generic/file
+    # type=file: Mat file containing ascii matrix for design
+    design_image: generic/file
+    # type=file: Graphical representation of design matrix
+    design_cov: generic/file
+    # type=file: Graphical representation of design covariance
+    con_file: generic/file
+    # type=file: Contrast file containing contrast vectors
+    fcon_file: generic/file
+    # type=file: Contrast file containing contrast vectors
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    fsf_file:
+    # type=file|default=<undefined>: File specifying the feat design spec file
+    ev_files:
+    # type=list|default=[]: Event spec files generated by level1design
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-fsl/feat_model_callables.py b/example-specs/task/nipype_internal/pydra-fsl/feat_model_callables.py
new file mode 100644
index 00000000..ddb4019f
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/feat_model_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in FEATModel.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/feature_extractor.yaml b/example-specs/task/nipype_internal/pydra-fsl/feature_extractor.yaml
new file mode 100644
index 00000000..ec458c37
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/feature_extractor.yaml
@@ -0,0 +1,77 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.fix.FeatureExtractor' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Extract features (for later training and/or classifying)
+#     
+task_name: FeatureExtractor
+nipype_name: FeatureExtractor
+nipype_module: nipype.interfaces.fsl.fix
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    mel_ica: generic/directory
+    # type=directory: Melodic output directory or directories
+    # type=directory|default=<undefined>: Melodic output directory or directories
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    mel_ica: generic/directory
+    # type=directory: Melodic output directory or directories
+    # type=directory|default=<undefined>: Melodic output directory or directories
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    mel_ica:
+    # type=directory: Melodic output directory or directories
+    # type=directory|default=<undefined>: Melodic output directory or directories
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-fsl/feature_extractor_callables.py b/example-specs/task/nipype_internal/pydra-fsl/feature_extractor_callables.py
new file mode 100644
index 00000000..1bcc7da7
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/feature_extractor_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in FeatureExtractor.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/filmgls.yaml b/example-specs/task/nipype_internal/pydra-fsl/filmgls.yaml
new file mode 100644
index 00000000..39df0730
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/filmgls.yaml
@@ -0,0 +1,158 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.model.FILMGLS' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Use FSL film_gls command to fit a design matrix to voxel timeseries
+# 
+#     Examples
+#     --------
+# 
+#     Initialize with no options, assigning them when calling run:
+# 
+#     >>> from nipype.interfaces import fsl
+#     >>> fgls = fsl.FILMGLS()
+#     >>> res = fgls.run('in_file', 'design_file', 'thresh', rn='stats') #doctest: +SKIP
+# 
+#     Assign options through the ``inputs`` attribute:
+# 
+#     >>> fgls = fsl.FILMGLS()
+#     >>> fgls.inputs.in_file = 'functional.nii'
+#     >>> fgls.inputs.design_file = 'design.mat'
+#     >>> fgls.inputs.threshold = 10
+#     >>> fgls.inputs.results_dir = 'stats'
+#     >>> res = fgls.run() #doctest: +SKIP
+# 
+#     Specify options when creating an instance:
+# 
+#     >>> fgls = fsl.FILMGLS(in_file='functional.nii', design_file='design.mat', threshold=10, results_dir='stats')
+#     >>> res = fgls.run() #doctest: +SKIP
+# 
+#     
+task_name: FILMGLS
+nipype_name: FILMGLS
+nipype_module: nipype.interfaces.fsl.model
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    tcon_file: generic/file
+    # type=file|default=<undefined>: contrast file containing T-contrasts
+    fcon_file: generic/file
+    # type=file|default=<undefined>: contrast file containing F-contrasts
+    surface: generic/file
+    # type=file|default=<undefined>: input surface for autocorr smoothing in surface-based analyses
+    in_file: generic/file
+    # type=file|default=<undefined>: input data file
+    design_file: generic/file
+    # type=file|default=<undefined>: design matrix file
+    results_dir: generic/directory
+    # type=directory: directory storing model estimation output
+    # type=directory|default='results': directory to store results in
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    residual4d: generic/file
+    # type=file: Model fit residual mean-squared error for each time point
+    dof_file: generic/file
+    # type=file: degrees of freedom
+    sigmasquareds: generic/file
+    # type=file: summary of residuals, See Woolrich, et. al., 2001
+    thresholdac: generic/file
+    # type=file: The FILM autocorrelation parameters
+    logfile: generic/file
+    # type=file: FILM run logfile
+    results_dir: generic/directory
+    # type=directory: directory storing model estimation output
+    # type=directory|default='results': directory to store results in
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    threshold:
+    # type=float|default=-1000.0: threshold
+    tcon_file:
+    # type=file|default=<undefined>: contrast file containing T-contrasts
+    fcon_file:
+    # type=file|default=<undefined>: contrast file containing F-contrasts
+    mode:
+    # type=enum|default='volumetric'|allowed['surface','volumetric']: Type of analysis to be done
+    surface:
+    # type=file|default=<undefined>: input surface for autocorr smoothing in surface-based analyses
+    in_file:
+    # type=file|default=<undefined>: input data file
+    design_file:
+    # type=file|default=<undefined>: design matrix file
+    smooth_autocorr:
+    # type=bool|default=False: Smooth auto corr estimates
+    mask_size:
+    # type=int|default=0: susan mask size
+    brightness_threshold:
+    # type=range|default=0: susan brightness threshold, otherwise it is estimated
+    full_data:
+    # type=bool|default=False: output full data
+    autocorr_estimate_only:
+    # type=bool|default=False: perform autocorrelation estimation only
+    fit_armodel:
+    # type=bool|default=False: fits autoregressive model - default is to use tukey with M=sqrt(numvols)
+    tukey_window:
+    # type=int|default=0: tukey window size to estimate autocorr
+    multitaper_product:
+    # type=int|default=0: multitapering with slepian tapers and num is the time-bandwidth product
+    use_pava:
+    # type=bool|default=False: estimates autocorr using PAVA
+    autocorr_noestimate:
+    # type=bool|default=False: do not estimate autocorrs
+    output_pwdata:
+    # type=bool|default=False: output prewhitened data and average design matrix
+    results_dir:
+    # type=directory: directory storing model estimation output
+    # type=directory|default='results': directory to store results in
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-fsl/filmgls_callables.py b/example-specs/task/nipype_internal/pydra-fsl/filmgls_callables.py
new file mode 100644
index 00000000..2911e6a5
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/filmgls_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in FILMGLS.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/filter_regressor.yaml b/example-specs/task/nipype_internal/pydra-fsl/filter_regressor.yaml
new file mode 100644
index 00000000..9603d623
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/filter_regressor.yaml
@@ -0,0 +1,100 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.utils.FilterRegressor' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Data de-noising by regressing out part of a design matrix
+# 
+#     Uses simple OLS regression on 4D images
+#     
+task_name: FilterRegressor
+nipype_name: FilterRegressor
+nipype_module: nipype.interfaces.fsl.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: input file name (4D image)
+    design_file: generic/file
+    # type=file|default=<undefined>: name of the matrix with time courses (e.g. GLM design or MELODIC mixing matrix)
+    mask: generic/file
+    # type=file|default=<undefined>: mask image file name
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: output file name for the filtered data
+    # type=file|default=<undefined>: output file name for the filtered data
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: out_file
+    # type=file: output file name for the filtered data
+    # type=file|default=<undefined>: output file name for the filtered data
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file name (4D image)
+    out_file:
+    # type=file: output file name for the filtered data
+    # type=file|default=<undefined>: output file name for the filtered data
+    design_file:
+    # type=file|default=<undefined>: name of the matrix with time courses (e.g. GLM design or MELODIC mixing matrix)
+    filter_columns:
+    # type=list|default=[]: (1-based) column indices to filter out of the data
+    filter_all:
+    # type=bool|default=False: use all columns in the design file in denoising
+    mask:
+    # type=file|default=<undefined>: mask image file name
+    var_norm:
+    # type=bool|default=False: perform variance-normalization on data
+    out_vnscales:
+    # type=bool|default=False: output scaling factors for variance normalization
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-fsl/filter_regressor_callables.py b/example-specs/task/nipype_internal/pydra-fsl/filter_regressor_callables.py
new file mode 100644
index 00000000..9e1cd026
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/filter_regressor_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in FilterRegressor.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/find_the_biggest.yaml b/example-specs/task/nipype_internal/pydra-fsl/find_the_biggest.yaml
new file mode 100644
index 00000000..00b6711d
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/find_the_biggest.yaml
@@ -0,0 +1,135 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.dti.FindTheBiggest' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Use FSL find_the_biggest for performing hard segmentation on
+#     the outputs of connectivity-based thresholding in probtrack.
+#     For complete details, see the `FDT
+#     Documentation. <http://www.fmrib.ox.ac.uk/fsl/fdt/fdt_biggest.html>`_
+# 
+#     Example
+#     -------
+# 
+#     >>> from nipype.interfaces import fsl
+#     >>> ldir = ['seeds_to_M1.nii', 'seeds_to_M2.nii']
+#     >>> fBig = fsl.FindTheBiggest(in_files=ldir, out_file='biggestSegmentation')
+#     >>> fBig.cmdline
+#     'find_the_biggest seeds_to_M1.nii seeds_to_M2.nii biggestSegmentation'
+# 
+#     
+task_name: FindTheBiggest
+nipype_name: FindTheBiggest
+nipype_module: nipype.interfaces.fsl.dti
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_files: generic/file+list-of
+    # type=list|default=[]: a list of input volumes or a singleMatrixFile
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: output file indexed in order of input files
+    # type=file|default=<undefined>: file with the resulting segmentation
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: '"biggestSegmentation"'
+    # type=file: output file indexed in order of input files
+    # type=file|default=<undefined>: file with the resulting segmentation
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_files:
+    # type=list|default=[]: a list of input volumes or a singleMatrixFile
+    out_file:
+    # type=file: output file indexed in order of input files
+    # type=file|default=<undefined>: file with the resulting segmentation
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_files:
+    # type=list|default=[]: a list of input volumes or a singleMatrixFile
+    out_file: '"biggestSegmentation"'
+    # type=file: output file indexed in order of input files
+    # type=file|default=<undefined>: file with the resulting segmentation
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: find_the_biggest seeds_to_M1.nii seeds_to_M2.nii biggestSegmentation
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_files:
+    # type=list|default=[]: a list of input volumes or a singleMatrixFile
+    out_file: '"biggestSegmentation"'
+    # type=file: output file indexed in order of input files
+    # type=file|default=<undefined>: file with the resulting segmentation
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-fsl/find_the_biggest_callables.py b/example-specs/task/nipype_internal/pydra-fsl/find_the_biggest_callables.py
new file mode 100644
index 00000000..a666e9d9
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/find_the_biggest_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in FindTheBiggest.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/first.yaml b/example-specs/task/nipype_internal/pydra-fsl/first.yaml
new file mode 100644
index 00000000..1863f910
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/first.yaml
@@ -0,0 +1,109 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.preprocess.FIRST' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# FSL run_first_all wrapper for segmentation of subcortical volumes
+# 
+#     http://www.fmrib.ox.ac.uk/fsl/first/index.html
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces import fsl
+#     >>> first = fsl.FIRST()
+#     >>> first.inputs.in_file = 'structural.nii'
+#     >>> first.inputs.out_file = 'segmented.nii'
+#     >>> res = first.run() #doctest: +SKIP
+# 
+#     
+task_name: FIRST
+nipype_name: FIRST
+nipype_module: nipype.interfaces.fsl.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: input data file
+    out_file: generic/file
+    # type=file|default='segmented': output data file
+    affine_file: generic/file
+    # type=file|default=<undefined>: Affine matrix to use (e.g. img2std.mat) (does not re-run registration)
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    original_segmentations: generic/file
+    # type=file: 3D image file containing the segmented regions as integer values. Uses CMA labelling
+    segmentation_file: generic/file
+    # type=file: 4D image file containing a single volume per segmented region
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input data file
+    out_file:
+    # type=file|default='segmented': output data file
+    verbose:
+    # type=bool|default=False: Use verbose logging.
+    brain_extracted:
+    # type=bool|default=False: Input structural image is already brain-extracted
+    no_cleanup:
+    # type=bool|default=False: Input structural image is already brain-extracted
+    method:
+    # type=enum|default='auto'|allowed['auto','fast','none']: Method must be one of auto, fast, none, or it can be entered using the 'method_as_numerical_threshold' input
+    method_as_numerical_threshold:
+    # type=float|default=0.0: Specify a numerical threshold value or use the 'method' input to choose auto, fast, or none
+    list_of_specific_structures:
+    # type=list|default=[]: Runs only on the specified structures (e.g. L_Hipp, R_HippL_Accu, R_Accu, L_Amyg, R_AmygL_Caud, R_Caud, L_Pall, R_PallL_Puta, R_Puta, L_Thal, R_Thal, BrStem
+    affine_file:
+    # type=file|default=<undefined>: Affine matrix to use (e.g. img2std.mat) (does not re-run registration)
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-fsl/first_callables.py b/example-specs/task/nipype_internal/pydra-fsl/first_callables.py
new file mode 100644
index 00000000..08786d5a
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/first_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in FIRST.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/flameo.yaml b/example-specs/task/nipype_internal/pydra-fsl/flameo.yaml
new file mode 100644
index 00000000..d9edd358
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/flameo.yaml
@@ -0,0 +1,200 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.model.FLAMEO' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Use FSL flameo command to perform higher level model fits
+# 
+#     Examples
+#     --------
+# 
+#     Initialize FLAMEO with no options, assigning them when calling run:
+# 
+#     >>> from nipype.interfaces import fsl
+#     >>> flameo = fsl.FLAMEO()
+#     >>> flameo.inputs.cope_file = 'cope.nii.gz'
+#     >>> flameo.inputs.var_cope_file = 'varcope.nii.gz'
+#     >>> flameo.inputs.cov_split_file = 'cov_split.mat'
+#     >>> flameo.inputs.design_file = 'design.mat'
+#     >>> flameo.inputs.t_con_file = 'design.con'
+#     >>> flameo.inputs.mask_file = 'mask.nii'
+#     >>> flameo.inputs.run_mode = 'fe'
+#     >>> flameo.cmdline
+#     'flameo --copefile=cope.nii.gz --covsplitfile=cov_split.mat --designfile=design.mat --ld=stats --maskfile=mask.nii --runmode=fe --tcontrastsfile=design.con --varcopefile=varcope.nii.gz'
+# 
+#     
+task_name: FLAMEO
+nipype_name: FLAMEO
+nipype_module: nipype.interfaces.fsl.model
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    cope_file: medimage/nifti-gz
+    # type=file|default=<undefined>: cope regressor data file
+    var_cope_file: medimage/nifti-gz
+    # type=file|default=<undefined>: varcope weightings data file
+    dof_var_cope_file: generic/file
+    # type=file|default=<undefined>: dof data file for varcope data
+    mask_file: medimage/nifti1
+    # type=file|default=<undefined>: mask file
+    design_file: datascience/text-matrix
+    # type=file|default=<undefined>: design matrix file
+    t_con_file: medimage-fsl/con
+    # type=file|default=<undefined>: ascii matrix specifying t-contrasts
+    f_con_file: generic/file
+    # type=file|default=<undefined>: ascii matrix specifying f-contrasts
+    cov_split_file: datascience/text-matrix
+    # type=file|default=<undefined>: ascii matrix specifying the groups the covariance is split into
+    log_dir: generic/directory
+    # type=directory|default='stats': 
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    stats_dir: generic/directory
+    # type=directory: directory storing model estimation output
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    cope_file:
+    # type=file|default=<undefined>: cope regressor data file
+    var_cope_file:
+    # type=file|default=<undefined>: varcope weightings data file
+    dof_var_cope_file:
+    # type=file|default=<undefined>: dof data file for varcope data
+    mask_file:
+    # type=file|default=<undefined>: mask file
+    design_file:
+    # type=file|default=<undefined>: design matrix file
+    t_con_file:
+    # type=file|default=<undefined>: ascii matrix specifying t-contrasts
+    f_con_file:
+    # type=file|default=<undefined>: ascii matrix specifying f-contrasts
+    cov_split_file:
+    # type=file|default=<undefined>: ascii matrix specifying the groups the covariance is split into
+    run_mode:
+    # type=enum|default='fe'|allowed['fe','flame1','flame12','ols']: inference to perform
+    n_jumps:
+    # type=int|default=0: number of jumps made by mcmc
+    burnin:
+    # type=int|default=0: number of jumps at start of mcmc to be discarded
+    sample_every:
+    # type=int|default=0: number of jumps for each sample
+    fix_mean:
+    # type=bool|default=False: fix mean for tfit
+    infer_outliers:
+    # type=bool|default=False: infer outliers - not for fe
+    no_pe_outputs:
+    # type=bool|default=False: do not output pe files
+    sigma_dofs:
+    # type=int|default=0: sigma (in mm) to use for Gaussian smoothing the DOFs in FLAME 2. Default is 1mm, -1 indicates no smoothing
+    outlier_iter:
+    # type=int|default=0: Number of max iterations to use when inferring outliers. Default is 12.
+    log_dir:
+    # type=directory|default='stats': 
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    cope_file:
+    # type=file|default=<undefined>: cope regressor data file
+    var_cope_file:
+    # type=file|default=<undefined>: varcope weightings data file
+    cov_split_file:
+    # type=file|default=<undefined>: ascii matrix specifying the groups the covariance is split into
+    design_file:
+    # type=file|default=<undefined>: design matrix file
+    t_con_file:
+    # type=file|default=<undefined>: ascii matrix specifying t-contrasts
+    mask_file:
+    # type=file|default=<undefined>: mask file
+    run_mode: '"fe"'
+    # type=enum|default='fe'|allowed['fe','flame1','flame12','ols']: inference to perform
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: flameo --copefile=cope.nii.gz --covsplitfile=cov_split.mat --designfile=design.mat --ld=stats --maskfile=mask.nii --runmode=fe --tcontrastsfile=design.con --varcopefile=varcope.nii.gz
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    cope_file:
+    # type=file|default=<undefined>: cope regressor data file
+    var_cope_file:
+    # type=file|default=<undefined>: varcope weightings data file
+    cov_split_file:
+    # type=file|default=<undefined>: ascii matrix specifying the groups the covariance is split into
+    design_file:
+    # type=file|default=<undefined>: design matrix file
+    t_con_file:
+    # type=file|default=<undefined>: ascii matrix specifying t-contrasts
+    mask_file:
+    # type=file|default=<undefined>: mask file
+    run_mode: '"fe"'
+    # type=enum|default='fe'|allowed['fe','flame1','flame12','ols']: inference to perform
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-fsl/flameo_callables.py b/example-specs/task/nipype_internal/pydra-fsl/flameo_callables.py
new file mode 100644
index 00000000..d01dd85b
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/flameo_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in FLAMEO.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/flirt.yaml b/example-specs/task/nipype_internal/pydra-fsl/flirt.yaml
new file mode 100644
index 00000000..9a99fb15
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/flirt.yaml
@@ -0,0 +1,277 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.preprocess.FLIRT' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# FSL FLIRT wrapper for coregistration
+# 
+#     For complete details, see the `FLIRT Documentation.
+#     <https://fsl.fmrib.ox.ac.uk/fsl/fslwiki/FLIRT>`_
+# 
+#     To print out the command line help, use:
+#         fsl.FLIRT().inputs_help()
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import fsl
+#     >>> from nipype.testing import example_data
+#     >>> flt = fsl.FLIRT(bins=640, cost_func='mutualinfo')
+#     >>> flt.inputs.in_file = 'structural.nii'
+#     >>> flt.inputs.reference = 'mni.nii'
+#     >>> flt.inputs.output_type = "NIFTI_GZ"
+#     >>> flt.cmdline # doctest: +ELLIPSIS
+#     'flirt -in structural.nii -ref mni.nii -out structural_flirt.nii.gz -omat structural_flirt.mat -bins 640 -searchcost mutualinfo'
+#     >>> res = flt.run() #doctest: +SKIP
+# 
+#     
+task_name: FLIRT
+nipype_name: FLIRT
+nipype_module: nipype.interfaces.fsl.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: input file
+    reference: medimage/nifti1
+    # type=file|default=<undefined>: reference file
+    out_file: generic/file
+    # type=file: path/name of registered file (if generated)
+    # type=file|default=<undefined>: registered output file
+    out_matrix_file: generic/file
+    # type=file: path/name of calculated affine transform (if generated)
+    # type=file|default=<undefined>: output affine matrix in 4x4 asciii format
+    out_log: generic/file
+    # type=file: path/name of output log (if generated)
+    # type=file|default=<undefined>: output log
+    in_matrix_file: generic/file
+    # type=file|default=<undefined>: input 4x4 affine matrix
+    schedule: generic/file
+    # type=file|default=<undefined>: replaces default schedule
+    ref_weight: generic/file
+    # type=file|default=<undefined>: File for reference weighting volume
+    in_weight: generic/file
+    # type=file|default=<undefined>: File for input weighting volume
+    wm_seg: generic/file
+    # type=file|default=<undefined>: white matter segmentation volume needed by BBR cost function
+    wmcoords: generic/file
+    # type=file|default=<undefined>: white matter boundary coordinates for BBR cost function
+    wmnorms: generic/file
+    # type=file|default=<undefined>: white matter boundary normals for BBR cost function
+    fieldmap: generic/file
+    # type=file|default=<undefined>: fieldmap image in rads/s - must be already registered to the reference image
+    fieldmapmask: generic/file
+    # type=file|default=<undefined>: mask for fieldmap image
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: path/name of registered file (if generated)
+    # type=file|default=<undefined>: registered output file
+    out_matrix_file: generic/file
+    # type=file: path/name of calculated affine transform (if generated)
+    # type=file|default=<undefined>: output affine matrix in 4x4 asciii format
+    out_log: generic/file
+    # type=file: path/name of output log (if generated)
+    # type=file|default=<undefined>: output log
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file
+    reference:
+    # type=file|default=<undefined>: reference file
+    out_file:
+    # type=file: path/name of registered file (if generated)
+    # type=file|default=<undefined>: registered output file
+    out_matrix_file:
+    # type=file: path/name of calculated affine transform (if generated)
+    # type=file|default=<undefined>: output affine matrix in 4x4 asciii format
+    out_log:
+    # type=file: path/name of output log (if generated)
+    # type=file|default=<undefined>: output log
+    in_matrix_file:
+    # type=file|default=<undefined>: input 4x4 affine matrix
+    apply_xfm:
+    # type=bool|default=False: apply transformation supplied by in_matrix_file or uses_qform to use the affine matrix stored in the reference header
+    apply_isoxfm:
+    # type=float|default=0.0: as applyxfm but forces isotropic resampling
+    datatype:
+    # type=enum|default='char'|allowed['char','double','float','int','short']: force output data type
+    cost:
+    # type=enum|default='mutualinfo'|allowed['bbr','corratio','labeldiff','leastsq','mutualinfo','normcorr','normmi']: cost function
+    cost_func:
+    # type=enum|default='mutualinfo'|allowed['bbr','corratio','labeldiff','leastsq','mutualinfo','normcorr','normmi']: cost function
+    uses_qform:
+    # type=bool|default=False: initialize using sform or qform
+    display_init:
+    # type=bool|default=False: display initial matrix
+    angle_rep:
+    # type=enum|default='quaternion'|allowed['euler','quaternion']: representation of rotation angles
+    interp:
+    # type=enum|default='trilinear'|allowed['nearestneighbour','sinc','spline','trilinear']: final interpolation method used in reslicing
+    sinc_width:
+    # type=int|default=0: full-width in voxels
+    sinc_window:
+    # type=enum|default='rectangular'|allowed['blackman','hanning','rectangular']: sinc window
+    bins:
+    # type=int|default=0: number of histogram bins
+    dof:
+    # type=int|default=0: number of transform degrees of freedom
+    no_resample:
+    # type=bool|default=False: do not change input sampling
+    force_scaling:
+    # type=bool|default=False: force rescaling even for low-res images
+    min_sampling:
+    # type=float|default=0.0: set minimum voxel dimension for sampling
+    padding_size:
+    # type=int|default=0: for applyxfm: interpolates outside image by size
+    searchr_x:
+    # type=list|default=[]: search angles along x-axis, in degrees
+    searchr_y:
+    # type=list|default=[]: search angles along y-axis, in degrees
+    searchr_z:
+    # type=list|default=[]: search angles along z-axis, in degrees
+    no_search:
+    # type=bool|default=False: set all angular searches to ranges 0 to 0
+    coarse_search:
+    # type=int|default=0: coarse search delta angle
+    fine_search:
+    # type=int|default=0: fine search delta angle
+    schedule:
+    # type=file|default=<undefined>: replaces default schedule
+    ref_weight:
+    # type=file|default=<undefined>: File for reference weighting volume
+    in_weight:
+    # type=file|default=<undefined>: File for input weighting volume
+    no_clamp:
+    # type=bool|default=False: do not use intensity clamping
+    no_resample_blur:
+    # type=bool|default=False: do not use blurring on downsampling
+    rigid2D:
+    # type=bool|default=False: use 2D rigid body mode - ignores dof
+    save_log:
+    # type=bool|default=False: save to log file
+    verbose:
+    # type=int|default=0: verbose mode, 0 is least
+    bgvalue:
+    # type=float|default=0: use specified background value for points outside FOV
+    wm_seg:
+    # type=file|default=<undefined>: white matter segmentation volume needed by BBR cost function
+    wmcoords:
+    # type=file|default=<undefined>: white matter boundary coordinates for BBR cost function
+    wmnorms:
+    # type=file|default=<undefined>: white matter boundary normals for BBR cost function
+    fieldmap:
+    # type=file|default=<undefined>: fieldmap image in rads/s - must be already registered to the reference image
+    fieldmapmask:
+    # type=file|default=<undefined>: mask for fieldmap image
+    pedir:
+    # type=int|default=0: phase encode direction of EPI - 1/2/3=x/y/z & -1/-2/-3=-x/-y/-z
+    echospacing:
+    # type=float|default=0.0: value of EPI echo spacing - units of seconds
+    bbrtype:
+    # type=enum|default='signed'|allowed['global_abs','local_abs','signed']: type of bbr cost function: signed [default], global_abs, local_abs
+    bbrslope:
+    # type=float|default=0.0: value of bbr slope
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file
+    reference:
+    # type=file|default=<undefined>: reference file
+    output_type: '"NIFTI_GZ"'
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    bins: '640'
+    # type=int|default=0: number of histogram bins
+    cost_func: '"mutualinfo"'
+    # type=enum|default='mutualinfo'|allowed['bbr','corratio','labeldiff','leastsq','mutualinfo','normcorr','normmi']: cost function
+  imports: &id001
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  - module: nipype.testing
+    name: example_data
+    alias:
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: flirt -in structural.nii -ref mni.nii -out structural_flirt.nii.gz -omat structural_flirt.mat -bins 640 -searchcost mutualinfo
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: input file
+    reference:
+    # type=file|default=<undefined>: reference file
+    output_type: '"NIFTI_GZ"'
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    bins: '640'
+    # type=int|default=0: number of histogram bins
+    cost_func: '"mutualinfo"'
+    # type=enum|default='mutualinfo'|allowed['bbr','corratio','labeldiff','leastsq','mutualinfo','normcorr','normmi']: cost function
+  imports: *id001
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-fsl/flirt_callables.py b/example-specs/task/nipype_internal/pydra-fsl/flirt_callables.py
new file mode 100644
index 00000000..1b4f6bd0
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/flirt_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in FLIRT.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/fnirt.yaml b/example-specs/task/nipype_internal/pydra-fsl/fnirt.yaml
new file mode 100644
index 00000000..98d44563
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/fnirt.yaml
@@ -0,0 +1,268 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.preprocess.FNIRT' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# FSL FNIRT wrapper for non-linear registration
+# 
+#     For complete details, see the `FNIRT Documentation.
+#     <https://fsl.fmrib.ox.ac.uk/fsl/fslwiki/FNIRT>`_
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import fsl
+#     >>> from nipype.testing import example_data
+#     >>> fnt = fsl.FNIRT(affine_file=example_data('trans.mat'))
+#     >>> res = fnt.run(ref_file=example_data('mni.nii', in_file=example_data('structural.nii')) #doctest: +SKIP
+# 
+#     T1 -> Mni153
+# 
+#     >>> from nipype.interfaces import fsl
+#     >>> fnirt_mprage = fsl.FNIRT()
+#     >>> fnirt_mprage.inputs.in_fwhm = [8, 4, 2, 2]
+#     >>> fnirt_mprage.inputs.subsampling_scheme = [4, 2, 1, 1]
+# 
+#     Specify the resolution of the warps
+# 
+#     >>> fnirt_mprage.inputs.warp_resolution = (6, 6, 6)
+#     >>> res = fnirt_mprage.run(in_file='structural.nii', ref_file='mni.nii', warped_file='warped.nii', fieldcoeff_file='fieldcoeff.nii')#doctest: +SKIP
+# 
+#     We can check the command line and confirm that it's what we expect.
+# 
+#     >>> fnirt_mprage.cmdline  #doctest: +SKIP
+#     'fnirt --cout=fieldcoeff.nii --in=structural.nii --infwhm=8,4,2,2 --ref=mni.nii --subsamp=4,2,1,1 --warpres=6,6,6 --iout=warped.nii'
+# 
+#     
+task_name: FNIRT
+nipype_name: FNIRT
+nipype_module: nipype.interfaces.fsl.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    ref_file: generic/file
+    # type=file|default=<undefined>: name of reference image
+    in_file: generic/file
+    # type=file|default=<undefined>: name of input image
+    affine_file: generic/file
+    # type=file|default=<undefined>: name of file containing affine transform
+    inwarp_file: generic/file
+    # type=file|default=<undefined>: name of file containing initial non-linear warps
+    in_intensitymap_file: generic/file+list-of
+    # type=list|default=[]: name of file/files containing initial intensity mapping usually generated by previous fnirt run
+    refmask_file: generic/file
+    # type=file|default=<undefined>: name of file with mask in reference space
+    inmask_file: generic/file
+    # type=file|default=<undefined>: name of file with mask in input image space
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    fieldcoeff_file: generic/file
+    # type=file: file with field coefficients
+    # type=traitcompound|default=None: name of output file with field coefficients or true
+    warped_file: generic/file
+    # type=file: warped image
+    # type=file|default=<undefined>: name of output image
+    field_file: generic/file
+    # type=file: file with warp field
+    # type=traitcompound|default=None: name of output file with field or true
+    jacobian_file: generic/file
+    # type=file: file containing Jacobian of the field
+    # type=traitcompound|default=None: name of file for writing out the Jacobian of the field (for diagnostic or VBM purposes)
+    modulatedref_file: generic/file
+    # type=file: file containing intensity modulated --ref
+    # type=traitcompound|default=None: name of file for writing out intensity modulated --ref (for diagnostic purposes)
+    log_file: generic/file
+    # type=file: Name of log-file
+    # type=file|default=<undefined>: Name of log-file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    warped_file: warped_file
+    # type=file: warped image
+    # type=file|default=<undefined>: name of output image
+    log_file: log_file
+    # type=file: Name of log-file
+    # type=file|default=<undefined>: Name of log-file
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    ref_file:
+    # type=file|default=<undefined>: name of reference image
+    in_file:
+    # type=file|default=<undefined>: name of input image
+    affine_file:
+    # type=file|default=<undefined>: name of file containing affine transform
+    inwarp_file:
+    # type=file|default=<undefined>: name of file containing initial non-linear warps
+    in_intensitymap_file:
+    # type=list|default=[]: name of file/files containing initial intensity mapping usually generated by previous fnirt run
+    fieldcoeff_file:
+    # type=file: file with field coefficients
+    # type=traitcompound|default=None: name of output file with field coefficients or true
+    warped_file:
+    # type=file: warped image
+    # type=file|default=<undefined>: name of output image
+    field_file:
+    # type=file: file with warp field
+    # type=traitcompound|default=None: name of output file with field or true
+    jacobian_file:
+    # type=file: file containing Jacobian of the field
+    # type=traitcompound|default=None: name of file for writing out the Jacobian of the field (for diagnostic or VBM purposes)
+    modulatedref_file:
+    # type=file: file containing intensity modulated --ref
+    # type=traitcompound|default=None: name of file for writing out intensity modulated --ref (for diagnostic purposes)
+    out_intensitymap_file:
+    # type=list: files containing info pertaining to intensity mapping
+    # type=traitcompound|default=None: name of files for writing information pertaining to intensity mapping
+    log_file:
+    # type=file: Name of log-file
+    # type=file|default=<undefined>: Name of log-file
+    config_file:
+    # type=traitcompound|default=None: Name of config file specifying command line arguments
+    refmask_file:
+    # type=file|default=<undefined>: name of file with mask in reference space
+    inmask_file:
+    # type=file|default=<undefined>: name of file with mask in input image space
+    skip_refmask:
+    # type=bool|default=False: Skip specified refmask if set, default false
+    skip_inmask:
+    # type=bool|default=False: skip specified inmask if set, default false
+    apply_refmask:
+    # type=list|default=[]: list of iterations to use reference mask on (1 to use, 0 to skip)
+    apply_inmask:
+    # type=list|default=[]: list of iterations to use input mask on (1 to use, 0 to skip)
+    skip_implicit_ref_masking:
+    # type=bool|default=False: skip implicit masking  based on value in --ref image. Default = 0
+    skip_implicit_in_masking:
+    # type=bool|default=False: skip implicit masking  based on value in --in image. Default = 0
+    refmask_val:
+    # type=float|default=0.0: Value to mask out in --ref image. Default =0.0
+    inmask_val:
+    # type=float|default=0.0: Value to mask out in --in image. Default =0.0
+    max_nonlin_iter:
+    # type=list|default=[]: Max # of non-linear iterations list, default [5, 5, 5, 5]
+    subsampling_scheme:
+    # type=list|default=[]: sub-sampling scheme, list, default [4, 2, 1, 1]
+    warp_resolution:
+    # type=tuple|default=(0, 0, 0): (approximate) resolution (in mm) of warp basis in x-, y- and z-direction, default 10, 10, 10
+    spline_order:
+    # type=int|default=0: Order of spline, 2->Qadratic spline, 3->Cubic spline. Default=3
+    in_fwhm:
+    # type=list|default=[]: FWHM (in mm) of gaussian smoothing kernel for input volume, default [6, 4, 2, 2]
+    ref_fwhm:
+    # type=list|default=[]: FWHM (in mm) of gaussian smoothing kernel for ref volume, default [4, 2, 0, 0]
+    regularization_model:
+    # type=enum|default='membrane_energy'|allowed['bending_energy','membrane_energy']: Model for regularisation of warp-field [membrane_energy bending_energy], default bending_energy
+    regularization_lambda:
+    # type=list|default=[]: Weight of regularisation, default depending on --ssqlambda and --regmod switches. See user documentation.
+    skip_lambda_ssq:
+    # type=bool|default=False: If true, lambda is not weighted by current ssq, default false
+    jacobian_range:
+    # type=tuple|default=(0.0, 0.0): Allowed range of Jacobian determinants, default 0.01, 100.0
+    derive_from_ref:
+    # type=bool|default=False: If true, ref image is used to calculate derivatives. Default false
+    intensity_mapping_model:
+    # type=enum|default='none'|allowed['global_linear','global_non_linear','global_non_linear_with_bias','local_linear','local_non_linear','none']: Model for intensity-mapping
+    intensity_mapping_order:
+    # type=int|default=0: Order of poynomial for mapping intensities, default 5
+    biasfield_resolution:
+    # type=tuple|default=(0, 0, 0): Resolution (in mm) of bias-field modelling local intensities, default 50, 50, 50
+    bias_regularization_lambda:
+    # type=float|default=0.0: Weight of regularisation for bias-field, default 10000
+    skip_intensity_mapping:
+    # type=bool|default=False: Skip estimate intensity-mapping default false
+    apply_intensity_mapping:
+    # type=list|default=[]: List of subsampling levels to apply intensity mapping for (0 to skip, 1 to apply)
+    hessian_precision:
+    # type=enum|default='double'|allowed['double','float']: Precision for representing Hessian, double or float. Default double
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_fwhm: '[8, 4, 2, 2]'
+    # type=list|default=[]: FWHM (in mm) of gaussian smoothing kernel for input volume, default [6, 4, 2, 2]
+    subsampling_scheme: '[4, 2, 1, 1]'
+    # type=list|default=[]: sub-sampling scheme, list, default [4, 2, 1, 1]
+    warp_resolution: (6, 6, 6)
+    # type=tuple|default=(0, 0, 0): (approximate) resolution (in mm) of warp basis in x-, y- and z-direction, default 10, 10, 10
+  imports: &id001
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  - module: nipype.testing
+    name: example_data
+    alias:
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline:
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_fwhm: '[8, 4, 2, 2]'
+    # type=list|default=[]: FWHM (in mm) of gaussian smoothing kernel for input volume, default [6, 4, 2, 2]
+    subsampling_scheme: '[4, 2, 1, 1]'
+    # type=list|default=[]: sub-sampling scheme, list, default [4, 2, 1, 1]
+    warp_resolution: (6, 6, 6)
+    # type=tuple|default=(0, 0, 0): (approximate) resolution (in mm) of warp basis in x-, y- and z-direction, default 10, 10, 10
+  imports: *id001
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-fsl/fnirt_callables.py b/example-specs/task/nipype_internal/pydra-fsl/fnirt_callables.py
new file mode 100644
index 00000000..6739d9d4
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/fnirt_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in FNIRT.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/fslx_command.yaml b/example-specs/task/nipype_internal/pydra-fsl/fslx_command.yaml
new file mode 100644
index 00000000..eacd2c56
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/fslx_command.yaml
@@ -0,0 +1,132 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.dti.FSLXCommand' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Base support for ``xfibres`` and ``bedpostx``
+#     
+task_name: FSLXCommand
+nipype_name: FSLXCommand
+nipype_module: nipype.interfaces.fsl.dti
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    dwi: generic/file
+    # type=file|default=<undefined>: diffusion weighted image data file
+    mask: generic/file
+    # type=file|default=<undefined>: brain binary mask file (i.e. from BET)
+    bvecs: generic/file
+    # type=file|default=<undefined>: b vectors file
+    bvals: generic/file
+    # type=file|default=<undefined>: b values file
+    logdir: generic/directory
+    # type=directory|default='.': 
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    mean_dsamples: generic/file
+    # type=file: Mean of distribution on diffusivity d
+    mean_S0samples: generic/file
+    # type=file: Mean of distribution on T2w baseline signal intensity S0
+    mean_tausamples: generic/file
+    # type=file: Mean of distribution on tau samples (only with rician noise)
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    dwi:
+    # type=file|default=<undefined>: diffusion weighted image data file
+    mask:
+    # type=file|default=<undefined>: brain binary mask file (i.e. from BET)
+    bvecs:
+    # type=file|default=<undefined>: b vectors file
+    bvals:
+    # type=file|default=<undefined>: b values file
+    logdir:
+    # type=directory|default='.': 
+    n_fibres:
+    # type=range|default=2: Maximum number of fibres to fit in each voxel
+    model:
+    # type=enum|default=1|allowed[1,2,3]: use monoexponential (1, default, required for single-shell) or multiexponential (2, multi-shell) model
+    fudge:
+    # type=int|default=0: ARD fudge factor
+    n_jumps:
+    # type=int|default=5000: Num of jumps to be made by MCMC
+    burn_in:
+    # type=range|default=0: Total num of jumps at start of MCMC to be discarded
+    burn_in_no_ard:
+    # type=range|default=0: num of burnin jumps before the ard is imposed
+    sample_every:
+    # type=range|default=1: Num of jumps for each sample (MCMC)
+    update_proposal_every:
+    # type=range|default=40: Num of jumps for each update to the proposal density std (MCMC)
+    seed:
+    # type=int|default=0: seed for pseudo random number generator
+    no_ard:
+    # type=bool|default=False: Turn ARD off on all fibres
+    all_ard:
+    # type=bool|default=False: Turn ARD on on all fibres
+    no_spat:
+    # type=bool|default=False: Initialise with tensor, not spatially
+    non_linear:
+    # type=bool|default=False: Initialise with nonlinear fitting
+    cnlinear:
+    # type=bool|default=False: Initialise with constrained nonlinear fitting
+    rician:
+    # type=bool|default=False: use Rician noise modeling
+    f0_noard:
+    # type=bool|default=False: Noise floor model: add to the model an unattenuated signal compartment f0
+    f0_ard:
+    # type=bool|default=False: Noise floor model: add to the model an unattenuated signal compartment f0
+    force_dir:
+    # type=bool|default=True: use the actual directory name given (do not add + to make a new directory)
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-fsl/fslx_command_callables.py b/example-specs/task/nipype_internal/pydra-fsl/fslx_command_callables.py
new file mode 100644
index 00000000..048758af
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/fslx_command_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in FSLXCommand.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/fugue.yaml b/example-specs/task/nipype_internal/pydra-fsl/fugue.yaml
new file mode 100644
index 00000000..96e7a0b8
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/fugue.yaml
@@ -0,0 +1,387 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.preprocess.FUGUE' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# FSL FUGUE set of tools for EPI distortion correction
+# 
+#     `FUGUE <http://fsl.fmrib.ox.ac.uk/fsl/fslwiki/FUGUE>`_ is, most generally,
+#     a set of tools for EPI distortion correction.
+# 
+#     Distortions may be corrected for
+#         1. improving registration with non-distorted images (e.g. structurals),
+#            or
+#         2. dealing with motion-dependent changes.
+# 
+#     FUGUE is designed to deal only with the first case -
+#     improving registration.
+# 
+# 
+#     Examples
+#     --------
+# 
+# 
+#     Unwarping an input image (shift map is known):
+# 
+#     >>> from nipype.interfaces.fsl.preprocess import FUGUE
+#     >>> fugue = FUGUE()
+#     >>> fugue.inputs.in_file = 'epi.nii'
+#     >>> fugue.inputs.mask_file = 'epi_mask.nii'
+#     >>> fugue.inputs.shift_in_file = 'vsm.nii'  # Previously computed with fugue as well
+#     >>> fugue.inputs.unwarp_direction = 'y'
+#     >>> fugue.inputs.output_type = "NIFTI_GZ"
+#     >>> fugue.cmdline # doctest: +ELLIPSIS
+#     'fugue --in=epi.nii --mask=epi_mask.nii --loadshift=vsm.nii --unwarpdir=y --unwarp=epi_unwarped.nii.gz'
+#     >>> fugue.run() #doctest: +SKIP
+# 
+# 
+#     Warping an input image (shift map is known):
+# 
+#     >>> from nipype.interfaces.fsl.preprocess import FUGUE
+#     >>> fugue = FUGUE()
+#     >>> fugue.inputs.in_file = 'epi.nii'
+#     >>> fugue.inputs.forward_warping = True
+#     >>> fugue.inputs.mask_file = 'epi_mask.nii'
+#     >>> fugue.inputs.shift_in_file = 'vsm.nii'  # Previously computed with fugue as well
+#     >>> fugue.inputs.unwarp_direction = 'y'
+#     >>> fugue.inputs.output_type = "NIFTI_GZ"
+#     >>> fugue.cmdline # doctest: +ELLIPSIS
+#     'fugue --in=epi.nii --mask=epi_mask.nii --loadshift=vsm.nii --unwarpdir=y --warp=epi_warped.nii.gz'
+#     >>> fugue.run() #doctest: +SKIP
+# 
+# 
+#     Computing the vsm (unwrapped phase map is known):
+# 
+#     >>> from nipype.interfaces.fsl.preprocess import FUGUE
+#     >>> fugue = FUGUE()
+#     >>> fugue.inputs.phasemap_in_file = 'epi_phasediff.nii'
+#     >>> fugue.inputs.mask_file = 'epi_mask.nii'
+#     >>> fugue.inputs.dwell_to_asym_ratio = (0.77e-3 * 3) / 2.46e-3
+#     >>> fugue.inputs.unwarp_direction = 'y'
+#     >>> fugue.inputs.save_shift = True
+#     >>> fugue.inputs.output_type = "NIFTI_GZ"
+#     >>> fugue.cmdline # doctest: +ELLIPSIS
+#     'fugue --dwelltoasym=0.9390243902 --mask=epi_mask.nii --phasemap=epi_phasediff.nii --saveshift=epi_phasediff_vsm.nii.gz --unwarpdir=y'
+#     >>> fugue.run() #doctest: +SKIP
+# 
+# 
+#     
+task_name: FUGUE
+nipype_name: FUGUE
+nipype_module: nipype.interfaces.fsl.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: filename of input volume
+    shift_in_file: medimage/nifti1
+    # type=file|default=<undefined>: filename for reading pixel shift volume
+    phasemap_in_file: medimage/nifti1
+    # type=file|default=<undefined>: filename for input phase image
+    fmap_in_file: generic/file
+    # type=file|default=<undefined>: filename for loading fieldmap (rad/s)
+    unwarped_file: generic/file
+    # type=file: unwarped file
+    # type=file|default=<undefined>: apply unwarping and save as filename
+    warped_file: generic/file
+    # type=file: forward warped file
+    # type=file|default=<undefined>: apply forward warping and save as filename
+    mask_file: medimage/nifti1
+    # type=file|default=<undefined>: filename for loading valid mask
+    shift_out_file: generic/file
+    # type=file: voxel shift map file
+    # type=file|default=<undefined>: filename for saving pixel shift volume
+    fmap_out_file: generic/file
+    # type=file: fieldmap file
+    # type=file|default=<undefined>: filename for saving fieldmap (rad/s)
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    unwarped_file: generic/file
+    # type=file: unwarped file
+    # type=file|default=<undefined>: apply unwarping and save as filename
+    warped_file: generic/file
+    # type=file: forward warped file
+    # type=file|default=<undefined>: apply forward warping and save as filename
+    shift_out_file: generic/file
+    # type=file: voxel shift map file
+    # type=file|default=<undefined>: filename for saving pixel shift volume
+    fmap_out_file: generic/file
+    # type=file: fieldmap file
+    # type=file|default=<undefined>: filename for saving fieldmap (rad/s)
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: filename of input volume
+    shift_in_file:
+    # type=file|default=<undefined>: filename for reading pixel shift volume
+    phasemap_in_file:
+    # type=file|default=<undefined>: filename for input phase image
+    fmap_in_file:
+    # type=file|default=<undefined>: filename for loading fieldmap (rad/s)
+    unwarped_file:
+    # type=file: unwarped file
+    # type=file|default=<undefined>: apply unwarping and save as filename
+    warped_file:
+    # type=file: forward warped file
+    # type=file|default=<undefined>: apply forward warping and save as filename
+    forward_warping:
+    # type=bool|default=False: apply forward warping instead of unwarping
+    dwell_to_asym_ratio:
+    # type=float|default=0.0: set the dwell to asym time ratio
+    dwell_time:
+    # type=float|default=0.0: set the EPI dwell time per phase-encode line - same as echo spacing - (sec)
+    asym_se_time:
+    # type=float|default=0.0: set the fieldmap asymmetric spin echo time (sec)
+    median_2dfilter:
+    # type=bool|default=False: apply 2D median filtering
+    despike_2dfilter:
+    # type=bool|default=False: apply a 2D de-spiking filter
+    no_gap_fill:
+    # type=bool|default=False: do not apply gap-filling measure to the fieldmap
+    no_extend:
+    # type=bool|default=False: do not apply rigid-body extrapolation to the fieldmap
+    smooth2d:
+    # type=float|default=0.0: apply 2D Gaussian smoothing of sigma N (in mm)
+    smooth3d:
+    # type=float|default=0.0: apply 3D Gaussian smoothing of sigma N (in mm)
+    poly_order:
+    # type=int|default=0: apply polynomial fitting of order N
+    fourier_order:
+    # type=int|default=0: apply Fourier (sinusoidal) fitting of order N
+    pava:
+    # type=bool|default=False: apply monotonic enforcement via PAVA
+    despike_threshold:
+    # type=float|default=0.0: specify the threshold for de-spiking (default=3.0)
+    unwarp_direction:
+    # type=enum|default='x'|allowed['x','x-','y','y-','z','z-']: specifies direction of warping (default y)
+    phase_conjugate:
+    # type=bool|default=False: apply phase conjugate method of unwarping
+    icorr:
+    # type=bool|default=False: apply intensity correction to unwarping (pixel shift method only)
+    icorr_only:
+    # type=bool|default=False: apply intensity correction only
+    mask_file:
+    # type=file|default=<undefined>: filename for loading valid mask
+    nokspace:
+    # type=bool|default=False: do not use k-space forward warping
+    save_shift:
+    # type=bool|default=False: write pixel shift volume
+    shift_out_file:
+    # type=file: voxel shift map file
+    # type=file|default=<undefined>: filename for saving pixel shift volume
+    save_unmasked_shift:
+    # type=bool|default=False: saves the unmasked shiftmap when using --saveshift
+    save_fmap:
+    # type=bool|default=False: write field map volume
+    fmap_out_file:
+    # type=file: fieldmap file
+    # type=file|default=<undefined>: filename for saving fieldmap (rad/s)
+    save_unmasked_fmap:
+    # type=bool|default=False: saves the unmasked fieldmap when using --savefmap
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: filename of input volume
+    mask_file:
+    # type=file|default=<undefined>: filename for loading valid mask
+    shift_in_file:
+    # type=file|default=<undefined>: filename for reading pixel shift volume
+    unwarp_direction: '"y"'
+    # type=enum|default='x'|allowed['x','x-','y','y-','z','z-']: specifies direction of warping (default y)
+    output_type: '"NIFTI_GZ"'
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: filename of input volume
+    forward_warping: 'True'
+    # type=bool|default=False: apply forward warping instead of unwarping
+    mask_file:
+    # type=file|default=<undefined>: filename for loading valid mask
+    shift_in_file:
+    # type=file|default=<undefined>: filename for reading pixel shift volume
+    unwarp_direction: '"y"'
+    # type=enum|default='x'|allowed['x','x-','y','y-','z','z-']: specifies direction of warping (default y)
+    output_type: '"NIFTI_GZ"'
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    phasemap_in_file:
+    # type=file|default=<undefined>: filename for input phase image
+    mask_file:
+    # type=file|default=<undefined>: filename for loading valid mask
+    dwell_to_asym_ratio: (0.77e-3 * 3) / 2.46e-3
+    # type=float|default=0.0: set the dwell to asym time ratio
+    unwarp_direction: '"y"'
+    # type=enum|default='x'|allowed['x','x-','y','y-','z','z-']: specifies direction of warping (default y)
+    save_shift: 'True'
+    # type=bool|default=False: write pixel shift volume
+    output_type: '"NIFTI_GZ"'
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: fugue --in=epi.nii --mask=epi_mask.nii --loadshift=vsm.nii --unwarpdir=y --unwarp=epi_unwarped.nii.gz
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: filename of input volume
+    mask_file:
+    # type=file|default=<undefined>: filename for loading valid mask
+    shift_in_file:
+    # type=file|default=<undefined>: filename for reading pixel shift volume
+    unwarp_direction: '"y"'
+    # type=enum|default='x'|allowed['x','x-','y','y-','z','z-']: specifies direction of warping (default y)
+    output_type: '"NIFTI_GZ"'
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: fugue --in=epi.nii --mask=epi_mask.nii --loadshift=vsm.nii --unwarpdir=y --warp=epi_warped.nii.gz
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: filename of input volume
+    forward_warping: 'True'
+    # type=bool|default=False: apply forward warping instead of unwarping
+    mask_file:
+    # type=file|default=<undefined>: filename for loading valid mask
+    shift_in_file:
+    # type=file|default=<undefined>: filename for reading pixel shift volume
+    unwarp_direction: '"y"'
+    # type=enum|default='x'|allowed['x','x-','y','y-','z','z-']: specifies direction of warping (default y)
+    output_type: '"NIFTI_GZ"'
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: fugue --dwelltoasym=0.9390243902 --mask=epi_mask.nii --phasemap=epi_phasediff.nii --saveshift=epi_phasediff_vsm.nii.gz --unwarpdir=y
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    phasemap_in_file:
+    # type=file|default=<undefined>: filename for input phase image
+    mask_file:
+    # type=file|default=<undefined>: filename for loading valid mask
+    dwell_to_asym_ratio: (0.77e-3 * 3) / 2.46e-3
+    # type=float|default=0.0: set the dwell to asym time ratio
+    unwarp_direction: '"y"'
+    # type=enum|default='x'|allowed['x','x-','y','y-','z','z-']: specifies direction of warping (default y)
+    save_shift: 'True'
+    # type=bool|default=False: write pixel shift volume
+    output_type: '"NIFTI_GZ"'
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-fsl/fugue_callables.py b/example-specs/task/nipype_internal/pydra-fsl/fugue_callables.py
new file mode 100644
index 00000000..3d58eb5d
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/fugue_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in FUGUE.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/glm.yaml b/example-specs/task/nipype_internal/pydra-fsl/glm.yaml
new file mode 100644
index 00000000..e14e3c4d
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/glm.yaml
@@ -0,0 +1,201 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.model.GLM' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     FSL GLM:
+# 
+#     Example
+#     -------
+#     >>> import nipype.interfaces.fsl as fsl
+#     >>> glm = fsl.GLM(in_file='functional.nii', design='maps.nii', output_type='NIFTI')
+#     >>> glm.cmdline
+#     'fsl_glm -i functional.nii -d maps.nii -o functional_glm.nii'
+# 
+#     
+task_name: GLM
+nipype_name: GLM
+nipype_module: nipype.interfaces.fsl.model
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: input file name (text matrix or 3D/4D image file)
+    out_file: generic/file
+    # type=file: file name of GLM parameters (if generated)
+    # type=file|default=<undefined>: filename for GLM parameter estimates (GLM betas)
+    design: medimage/nifti1
+    # type=file|default=<undefined>: file name of the GLM design matrix (text time courses for temporal regression or an image file for spatial regression)
+    contrasts: generic/file
+    # type=file|default=<undefined>: matrix of t-statics contrasts
+    mask: generic/file
+    # type=file|default=<undefined>: mask image file name if input is image
+    out_cope: generic/file
+    # type=outputmultiobject: output file name for COPEs (either as text file or image)
+    # type=file|default=<undefined>: output file name for COPE (either as txt or image
+    out_z_name: generic/file
+    # type=file|default=<undefined>: output file name for Z-stats (either as txt or image
+    out_t_name: generic/file
+    # type=file|default=<undefined>: output file name for t-stats (either as txt or image
+    out_p_name: generic/file
+    # type=file|default=<undefined>: output file name for p-values of Z-stats (either as text file or image)
+    out_f_name: generic/file
+    # type=file|default=<undefined>: output file name for F-value of full model fit
+    out_pf_name: generic/file
+    # type=file|default=<undefined>: output file name for p-value for full model fit
+    out_res_name: generic/file
+    # type=file|default=<undefined>: output file name for residuals
+    out_varcb_name: generic/file
+    # type=file|default=<undefined>: output file name for variance of COPEs
+    out_sigsq_name: generic/file
+    # type=file|default=<undefined>: output file name for residual noise variance sigma-square
+    out_data_name: generic/file
+    # type=file|default=<undefined>: output file name for pre-processed data
+    out_vnscales_name: generic/file
+    # type=file|default=<undefined>: output file name for scaling factors for variance normalisation
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: file name of GLM parameters (if generated)
+    # type=file|default=<undefined>: filename for GLM parameter estimates (GLM betas)
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file name (text matrix or 3D/4D image file)
+    out_file:
+    # type=file: file name of GLM parameters (if generated)
+    # type=file|default=<undefined>: filename for GLM parameter estimates (GLM betas)
+    design:
+    # type=file|default=<undefined>: file name of the GLM design matrix (text time courses for temporal regression or an image file for spatial regression)
+    contrasts:
+    # type=file|default=<undefined>: matrix of t-statics contrasts
+    mask:
+    # type=file|default=<undefined>: mask image file name if input is image
+    dof:
+    # type=int|default=0: set degrees of freedom explicitly
+    des_norm:
+    # type=bool|default=False: switch on normalization of the design matrix columns to unit std deviation
+    dat_norm:
+    # type=bool|default=False: switch on normalization of the data time series to unit std deviation
+    var_norm:
+    # type=bool|default=False: perform MELODIC variance-normalisation on data
+    demean:
+    # type=bool|default=False: switch on demeaining of design and data
+    out_cope:
+    # type=outputmultiobject: output file name for COPEs (either as text file or image)
+    # type=file|default=<undefined>: output file name for COPE (either as txt or image
+    out_z_name:
+    # type=file|default=<undefined>: output file name for Z-stats (either as txt or image
+    out_t_name:
+    # type=file|default=<undefined>: output file name for t-stats (either as txt or image
+    out_p_name:
+    # type=file|default=<undefined>: output file name for p-values of Z-stats (either as text file or image)
+    out_f_name:
+    # type=file|default=<undefined>: output file name for F-value of full model fit
+    out_pf_name:
+    # type=file|default=<undefined>: output file name for p-value for full model fit
+    out_res_name:
+    # type=file|default=<undefined>: output file name for residuals
+    out_varcb_name:
+    # type=file|default=<undefined>: output file name for variance of COPEs
+    out_sigsq_name:
+    # type=file|default=<undefined>: output file name for residual noise variance sigma-square
+    out_data_name:
+    # type=file|default=<undefined>: output file name for pre-processed data
+    out_vnscales_name:
+    # type=file|default=<undefined>: output file name for scaling factors for variance normalisation
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file name (text matrix or 3D/4D image file)
+    design:
+    # type=file|default=<undefined>: file name of the GLM design matrix (text time courses for temporal regression or an image file for spatial regression)
+    output_type: '"NIFTI"'
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+  imports: &id001
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  - module: nipype.interfaces.fsl as fsl
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: fsl_glm -i functional.nii -d maps.nii -o functional_glm.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: input file name (text matrix or 3D/4D image file)
+    design:
+    # type=file|default=<undefined>: file name of the GLM design matrix (text time courses for temporal regression or an image file for spatial regression)
+    output_type: '"NIFTI"'
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+  imports: *id001
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-fsl/glm_callables.py b/example-specs/task/nipype_internal/pydra-fsl/glm_callables.py
new file mode 100644
index 00000000..e54bc448
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/glm_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in GLM.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/ica__aroma.yaml b/example-specs/task/nipype_internal/pydra-fsl/ica__aroma.yaml
new file mode 100644
index 00000000..701aad11
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/ica__aroma.yaml
@@ -0,0 +1,201 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.aroma.ICA_AROMA' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Interface for the ICA_AROMA.py script.
+# 
+#     ICA-AROMA (i.e. 'ICA-based Automatic Removal Of Motion Artifacts') concerns
+#     a data-driven method to identify and remove motion-related independent
+#     components from fMRI data. To that end it exploits a small, but robust
+#     set of theoretically motivated features, preventing the need for classifier
+#     re-training and therefore providing direct and easy applicability.
+# 
+#     See link for further documentation: https://github.com/rhr-pruim/ICA-AROMA
+# 
+#     Example
+#     -------
+# 
+#     >>> from nipype.interfaces.fsl import ICA_AROMA
+#     >>> from nipype.testing import example_data
+#     >>> AROMA_obj = ICA_AROMA()
+#     >>> AROMA_obj.inputs.in_file = 'functional.nii'
+#     >>> AROMA_obj.inputs.mat_file = 'func_to_struct.mat'
+#     >>> AROMA_obj.inputs.fnirt_warp_file = 'warpfield.nii'
+#     >>> AROMA_obj.inputs.motion_parameters = 'fsl_mcflirt_movpar.txt'
+#     >>> AROMA_obj.inputs.mask = 'mask.nii.gz'
+#     >>> AROMA_obj.inputs.denoise_type = 'both'
+#     >>> AROMA_obj.inputs.out_dir = 'ICA_testout'
+#     >>> AROMA_obj.cmdline  # doctest: +ELLIPSIS
+#     'ICA_AROMA.py -den both -warp warpfield.nii -i functional.nii -m mask.nii.gz -affmat func_to_struct.mat -mc fsl_mcflirt_movpar.txt -o .../ICA_testout'
+#     
+task_name: ICA_AROMA
+nipype_name: ICA_AROMA
+nipype_module: nipype.interfaces.fsl.aroma
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: volume to be denoised
+    mask: medimage/nifti-gz
+    # type=file|default=<undefined>: path/name volume mask
+    mat_file: datascience/text-matrix
+    # type=file|default=<undefined>: path/name of the mat-file describing the affine registration (e.g. FSL FLIRT) of the functional data to structural space (.mat file)
+    fnirt_warp_file: medimage/nifti1
+    # type=file|default=<undefined>: File name of the warp-file describing the non-linear registration (e.g. FSL FNIRT) of the structural data to MNI152 space (.nii.gz)
+    motion_parameters: text/text-file
+    # type=file|default=<undefined>: motion parameters file
+    feat_dir: generic/directory
+    # type=directory|default=<undefined>: If a feat directory exists and temporal filtering has not been run yet, ICA_AROMA can use the files in this directory.
+    out_dir: generic/directory
+    # type=directory: directory contains (in addition to the denoised files): melodic.ica + classified_motion_components + classification_overview + feature_scores + melodic_ic_mni)
+    # type=directory|default='out': output directory
+    melodic_dir: generic/directory
+    # type=directory|default=<undefined>: path to MELODIC directory if MELODIC has already been run
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    aggr_denoised_file: generic/file
+    # type=file: if generated: aggressively denoised volume
+    nonaggr_denoised_file: generic/file
+    # type=file: if generated: non aggressively denoised volume
+    out_dir: generic/directory
+    # type=directory: directory contains (in addition to the denoised files): melodic.ica + classified_motion_components + classification_overview + feature_scores + melodic_ic_mni)
+    # type=directory|default='out': output directory
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    feat_dir:
+    # type=directory|default=<undefined>: If a feat directory exists and temporal filtering has not been run yet, ICA_AROMA can use the files in this directory.
+    in_file:
+    # type=file|default=<undefined>: volume to be denoised
+    out_dir:
+    # type=directory: directory contains (in addition to the denoised files): melodic.ica + classified_motion_components + classification_overview + feature_scores + melodic_ic_mni)
+    # type=directory|default='out': output directory
+    mask:
+    # type=file|default=<undefined>: path/name volume mask
+    dim:
+    # type=int|default=0: Dimensionality reduction when running MELODIC (default is automatic estimation)
+    TR:
+    # type=float|default=0.0: TR in seconds. If this is not specified the TR will be extracted from the header of the fMRI nifti file.
+    melodic_dir:
+    # type=directory|default=<undefined>: path to MELODIC directory if MELODIC has already been run
+    mat_file:
+    # type=file|default=<undefined>: path/name of the mat-file describing the affine registration (e.g. FSL FLIRT) of the functional data to structural space (.mat file)
+    fnirt_warp_file:
+    # type=file|default=<undefined>: File name of the warp-file describing the non-linear registration (e.g. FSL FNIRT) of the structural data to MNI152 space (.nii.gz)
+    motion_parameters:
+    # type=file|default=<undefined>: motion parameters file
+    denoise_type:
+    # type=enum|default='nonaggr'|allowed['aggr','both','no','nonaggr']: Type of denoising strategy: -no: only classification, no denoising -nonaggr (default): non-aggresssive denoising, i.e. partial component regression -aggr: aggressive denoising, i.e. full component regression -both: both aggressive and non-aggressive denoising (two outputs)
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: volume to be denoised
+    mat_file:
+    # type=file|default=<undefined>: path/name of the mat-file describing the affine registration (e.g. FSL FLIRT) of the functional data to structural space (.mat file)
+    fnirt_warp_file:
+    # type=file|default=<undefined>: File name of the warp-file describing the non-linear registration (e.g. FSL FNIRT) of the structural data to MNI152 space (.nii.gz)
+    motion_parameters:
+    # type=file|default=<undefined>: motion parameters file
+    mask:
+    # type=file|default=<undefined>: path/name volume mask
+    denoise_type: '"both"'
+    # type=enum|default='nonaggr'|allowed['aggr','both','no','nonaggr']: Type of denoising strategy: -no: only classification, no denoising -nonaggr (default): non-aggresssive denoising, i.e. partial component regression -aggr: aggressive denoising, i.e. full component regression -both: both aggressive and non-aggressive denoising (two outputs)
+    out_dir: '"ICA_testout"'
+    # type=directory: directory contains (in addition to the denoised files): melodic.ica + classified_motion_components + classification_overview + feature_scores + melodic_ic_mni)
+    # type=directory|default='out': output directory
+  imports: &id001
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  - module: nipype.testing
+    name: example_data
+    alias:
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: ICA_AROMA.py -den both -warp warpfield.nii -i functional.nii -m mask.nii.gz -affmat func_to_struct.mat -mc fsl_mcflirt_movpar.txt -o .../ICA_testout
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: volume to be denoised
+    mat_file:
+    # type=file|default=<undefined>: path/name of the mat-file describing the affine registration (e.g. FSL FLIRT) of the functional data to structural space (.mat file)
+    fnirt_warp_file:
+    # type=file|default=<undefined>: File name of the warp-file describing the non-linear registration (e.g. FSL FNIRT) of the structural data to MNI152 space (.nii.gz)
+    motion_parameters:
+    # type=file|default=<undefined>: motion parameters file
+    mask:
+    # type=file|default=<undefined>: path/name volume mask
+    denoise_type: '"both"'
+    # type=enum|default='nonaggr'|allowed['aggr','both','no','nonaggr']: Type of denoising strategy: -no: only classification, no denoising -nonaggr (default): non-aggresssive denoising, i.e. partial component regression -aggr: aggressive denoising, i.e. full component regression -both: both aggressive and non-aggressive denoising (two outputs)
+    out_dir: '"ICA_testout"'
+    # type=directory: directory contains (in addition to the denoised files): melodic.ica + classified_motion_components + classification_overview + feature_scores + melodic_ic_mni)
+    # type=directory|default='out': output directory
+  imports: *id001
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-fsl/ica__aroma_callables.py b/example-specs/task/nipype_internal/pydra-fsl/ica__aroma_callables.py
new file mode 100644
index 00000000..ebc5c582
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/ica__aroma_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in ICA_AROMA.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/image_maths.yaml b/example-specs/task/nipype_internal/pydra-fsl/image_maths.yaml
new file mode 100644
index 00000000..82119d18
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/image_maths.yaml
@@ -0,0 +1,156 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.utils.ImageMaths' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Use FSL fslmaths command to allow mathematical manipulation of images
+#     `FSL info <http://www.fmrib.ox.ac.uk/fslcourse/lectures/practicals/intro/index.htm#fslutils>`_
+# 
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces import fsl
+#     >>> from nipype.testing import anatfile
+#     >>> maths = fsl.ImageMaths(in_file=anatfile, op_string= '-add 5',
+#     ...                        out_file='foo_maths.nii')
+#     >>> maths.cmdline == 'fslmaths %s -add 5 foo_maths.nii' % anatfile
+#     True
+# 
+# 
+#     
+task_name: ImageMaths
+nipype_name: ImageMaths
+nipype_module: nipype.interfaces.fsl.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: 
+    in_file2: generic/file
+    # type=file|default=<undefined>: 
+    mask_file: generic/file
+    # type=file|default=<undefined>: use (following image>0) to mask current image
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: medimage/nifti1
+    # type=file: 
+    # type=file|default=<undefined>: 
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: '"foo_maths.nii"'
+    # type=file: 
+    # type=file|default=<undefined>: 
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: 
+    in_file2:
+    # type=file|default=<undefined>: 
+    mask_file:
+    # type=file|default=<undefined>: use (following image>0) to mask current image
+    out_file:
+    # type=file: 
+    # type=file|default=<undefined>: 
+    op_string:
+    # type=str|default='': string defining the operation, i. e. -add
+    suffix:
+    # type=str|default='': out_file suffix
+    out_data_type:
+    # type=enum|default='char'|allowed['char','double','float','input','int','short']: output datatype, one of (char, short, int, float, double, input)
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: 
+    op_string: '"-add 5"'
+    # type=str|default='': string defining the operation, i. e. -add
+    out_file: '"foo_maths.nii"'
+    # type=file: 
+    # type=file|default=<undefined>: 
+  imports: &id001
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  - module: nipype.testing
+    name: anatfile
+    alias:
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline:
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: 
+    op_string: '"-add 5"'
+    # type=str|default='': string defining the operation, i. e. -add
+    out_file: '"foo_maths.nii"'
+    # type=file: 
+    # type=file|default=<undefined>: 
+  imports: *id001
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-fsl/image_maths_callables.py b/example-specs/task/nipype_internal/pydra-fsl/image_maths_callables.py
new file mode 100644
index 00000000..af88ca1a
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/image_maths_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in ImageMaths.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/image_meants.yaml b/example-specs/task/nipype_internal/pydra-fsl/image_meants.yaml
new file mode 100644
index 00000000..d9cfe2fb
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/image_meants.yaml
@@ -0,0 +1,103 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.utils.ImageMeants' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Use fslmeants for printing the average timeseries (intensities) to
+#     the screen (or saves to a file). The average is taken over all voxels
+#     in the mask (or all voxels in the image if no mask is specified)
+# 
+#     
+task_name: ImageMeants
+nipype_name: ImageMeants
+nipype_module: nipype.interfaces.fsl.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: input file for computing the average timeseries
+    mask: generic/file
+    # type=file|default=<undefined>: input 3D mask
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: path/name of output text matrix
+    # type=file|default=<undefined>: name of output text matrix
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: out_file
+    # type=file: path/name of output text matrix
+    # type=file|default=<undefined>: name of output text matrix
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file for computing the average timeseries
+    out_file:
+    # type=file: path/name of output text matrix
+    # type=file|default=<undefined>: name of output text matrix
+    mask:
+    # type=file|default=<undefined>: input 3D mask
+    spatial_coord:
+    # type=list|default=[]: <x y z>  requested spatial coordinate (instead of mask)
+    use_mm:
+    # type=bool|default=False: use mm instead of voxel coordinates (for -c option)
+    show_all:
+    # type=bool|default=False: show all voxel time series (within mask) instead of averaging
+    eig:
+    # type=bool|default=False: calculate Eigenvariate(s) instead of mean (output will have 0 mean)
+    order:
+    # type=int|default=1: select number of Eigenvariates
+    nobin:
+    # type=bool|default=False: do not binarise the mask for calculation of Eigenvariates
+    transpose:
+    # type=bool|default=False: output results in transpose format (one row per voxel/mean)
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-fsl/image_meants_callables.py b/example-specs/task/nipype_internal/pydra-fsl/image_meants_callables.py
new file mode 100644
index 00000000..0e60de8e
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/image_meants_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in ImageMeants.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/image_stats.yaml b/example-specs/task/nipype_internal/pydra-fsl/image_stats.yaml
new file mode 100644
index 00000000..5e6da27c
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/image_stats.yaml
@@ -0,0 +1,139 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.utils.ImageStats' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Use FSL fslstats command to calculate stats from images
+#     `FSL info
+#     <http://www.fmrib.ox.ac.uk/fslcourse/lectures/practicals/intro/index.htm#fslutils>`_
+# 
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces.fsl import ImageStats
+#     >>> from nipype.testing import funcfile
+#     >>> stats = ImageStats(in_file=funcfile, op_string= '-M')
+#     >>> stats.cmdline == 'fslstats %s -M'%funcfile
+#     True
+# 
+# 
+#     
+task_name: ImageStats
+nipype_name: ImageStats
+nipype_module: nipype.interfaces.fsl.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: input file to generate stats of
+    mask_file: generic/file
+    # type=file|default=<undefined>: mask file used for option -k %s
+    index_mask_file: generic/file
+    # type=file|default=<undefined>: generate separate n submasks from indexMask, for indexvalues 1..n where n is the maximum index value in indexMask, and generate statistics for each submask
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    split_4d:
+    # type=bool|default=False: give a separate output line for each 3D volume of a 4D timeseries
+    in_file:
+    # type=file|default=<undefined>: input file to generate stats of
+    op_string:
+    # type=str|default='': string defining the operation, options are applied in order, e.g. -M -l 10 -M will report the non-zero mean, apply a threshold and then report the new nonzero mean
+    mask_file:
+    # type=file|default=<undefined>: mask file used for option -k %s
+    index_mask_file:
+    # type=file|default=<undefined>: generate separate n submasks from indexMask, for indexvalues 1..n where n is the maximum index value in indexMask, and generate statistics for each submask
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input file to generate stats of
+    op_string: '"-M"'
+    # type=str|default='': string defining the operation, options are applied in order, e.g. -M -l 10 -M will report the non-zero mean, apply a threshold and then report the new nonzero mean
+  imports: &id001
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  - module: nipype.testing
+    name: funcfile
+    alias:
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline:
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: input file to generate stats of
+    op_string: '"-M"'
+    # type=str|default='': string defining the operation, options are applied in order, e.g. -M -l 10 -M will report the non-zero mean, apply a threshold and then report the new nonzero mean
+  imports: *id001
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-fsl/image_stats_callables.py b/example-specs/task/nipype_internal/pydra-fsl/image_stats_callables.py
new file mode 100644
index 00000000..1a145967
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/image_stats_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in ImageStats.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/inv_warp.yaml b/example-specs/task/nipype_internal/pydra-fsl/inv_warp.yaml
new file mode 100644
index 00000000..b9237569
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/inv_warp.yaml
@@ -0,0 +1,157 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.utils.InvWarp' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Use FSL Invwarp to invert a FNIRT warp
+# 
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces.fsl import InvWarp
+#     >>> invwarp = InvWarp()
+#     >>> invwarp.inputs.warp = "struct2mni.nii"
+#     >>> invwarp.inputs.reference = "anatomical.nii"
+#     >>> invwarp.inputs.output_type = "NIFTI_GZ"
+#     >>> invwarp.cmdline
+#     'invwarp --out=struct2mni_inverse.nii.gz --ref=anatomical.nii --warp=struct2mni.nii'
+#     >>> res = invwarp.run() # doctest: +SKIP
+# 
+# 
+#     
+task_name: InvWarp
+nipype_name: InvWarp
+nipype_module: nipype.interfaces.fsl.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    warp: medimage/nifti1
+    # type=file|default=<undefined>: Name of file containing warp-coefficients/fields. This would typically be the output from the --cout switch of fnirt (but can also use fields, like the output from --fout).
+    reference: medimage/nifti1
+    # type=file|default=<undefined>: Name of a file in target space. Note that the target space is now different from the target space that was used to create the --warp file. It would typically be the file that was specified with the --in argument when running fnirt.
+    inverse_warp: generic/file
+    # type=file: Name of output file, containing warps that are the "reverse" of those in --warp.
+    # type=file|default=<undefined>: Name of output file, containing warps that are the "reverse" of those in --warp. This will be a field-file (rather than a file of spline coefficients), and it will have any affine component included as part of the displacements.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inverse_warp: generic/file
+    # type=file: Name of output file, containing warps that are the "reverse" of those in --warp.
+    # type=file|default=<undefined>: Name of output file, containing warps that are the "reverse" of those in --warp. This will be a field-file (rather than a file of spline coefficients), and it will have any affine component included as part of the displacements.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    warp:
+    # type=file|default=<undefined>: Name of file containing warp-coefficients/fields. This would typically be the output from the --cout switch of fnirt (but can also use fields, like the output from --fout).
+    reference:
+    # type=file|default=<undefined>: Name of a file in target space. Note that the target space is now different from the target space that was used to create the --warp file. It would typically be the file that was specified with the --in argument when running fnirt.
+    inverse_warp:
+    # type=file: Name of output file, containing warps that are the "reverse" of those in --warp.
+    # type=file|default=<undefined>: Name of output file, containing warps that are the "reverse" of those in --warp. This will be a field-file (rather than a file of spline coefficients), and it will have any affine component included as part of the displacements.
+    absolute:
+    # type=bool|default=False: If set it indicates that the warps in --warp should be interpreted as absolute, provided that it is not created by fnirt (which always uses relative warps). If set it also indicates that the output --out should be absolute.
+    relative:
+    # type=bool|default=False: If set it indicates that the warps in --warp should be interpreted as relative. I.e. the values in --warp are displacements from the coordinates in the --ref space. If set it also indicates that the output --out should be relative.
+    niter:
+    # type=int|default=0: Determines how many iterations of the gradient-descent search that should be run.
+    regularise:
+    # type=float|default=0.0: Regularization strength (default=1.0).
+    noconstraint:
+    # type=bool|default=False: Do not apply Jacobian constraint
+    jacobian_min:
+    # type=float|default=0.0: Minimum acceptable Jacobian value for constraint (default 0.01)
+    jacobian_max:
+    # type=float|default=0.0: Maximum acceptable Jacobian value for constraint (default 100.0)
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    warp:
+    # type=file|default=<undefined>: Name of file containing warp-coefficients/fields. This would typically be the output from the --cout switch of fnirt (but can also use fields, like the output from --fout).
+    reference:
+    # type=file|default=<undefined>: Name of a file in target space. Note that the target space is now different from the target space that was used to create the --warp file. It would typically be the file that was specified with the --in argument when running fnirt.
+    output_type: '"NIFTI_GZ"'
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: invwarp --out=struct2mni_inverse.nii.gz --ref=anatomical.nii --warp=struct2mni.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    warp:
+    # type=file|default=<undefined>: Name of file containing warp-coefficients/fields. This would typically be the output from the --cout switch of fnirt (but can also use fields, like the output from --fout).
+    reference:
+    # type=file|default=<undefined>: Name of a file in target space. Note that the target space is now different from the target space that was used to create the --warp file. It would typically be the file that was specified with the --in argument when running fnirt.
+    output_type: '"NIFTI_GZ"'
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-fsl/inv_warp_callables.py b/example-specs/task/nipype_internal/pydra-fsl/inv_warp_callables.py
new file mode 100644
index 00000000..3df23d87
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/inv_warp_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in InvWarp.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/isotropic_smooth.yaml b/example-specs/task/nipype_internal/pydra-fsl/isotropic_smooth.yaml
new file mode 100644
index 00000000..df735550
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/isotropic_smooth.yaml
@@ -0,0 +1,91 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.maths.IsotropicSmooth' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Use fslmaths to spatially smooth an image with a gaussian kernel.
+task_name: IsotropicSmooth
+nipype_name: IsotropicSmooth
+nipype_module: nipype.interfaces.fsl.maths
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: image to operate on
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: out_file
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    fwhm:
+    # type=float|default=0.0: fwhm of smoothing kernel [mm]
+    sigma:
+    # type=float|default=0.0: sigma of smoothing kernel [mm]
+    in_file:
+    # type=file|default=<undefined>: image to operate on
+    out_file:
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
+    internal_datatype:
+    # type=enum|default='float'|allowed['char','double','float','input','int','short']: datatype to use for calculations (default is float)
+    output_datatype:
+    # type=enum|default='float'|allowed['char','double','float','input','int','short']: datatype to use for output (default uses input type)
+    nan2zeros:
+    # type=bool|default=False: change NaNs to zeros before doing anything
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-fsl/isotropic_smooth_callables.py b/example-specs/task/nipype_internal/pydra-fsl/isotropic_smooth_callables.py
new file mode 100644
index 00000000..cb3b0b01
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/isotropic_smooth_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in IsotropicSmooth.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/l2_model.yaml b/example-specs/task/nipype_internal/pydra-fsl/l2_model.yaml
new file mode 100644
index 00000000..9122537c
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/l2_model.yaml
@@ -0,0 +1,78 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.model.L2Model' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Generate subject specific second level model
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces.fsl import L2Model
+#     >>> model = L2Model(num_copes=3) # 3 sessions
+# 
+#     
+task_name: L2Model
+nipype_name: L2Model
+nipype_module: nipype.interfaces.fsl.model
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    design_mat: generic/file
+    # type=file: design matrix file
+    design_con: generic/file
+    # type=file: design contrast file
+    design_grp: generic/file
+    # type=file: design group file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    num_copes:
+    # type=range|default=1: number of copes to be combined
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-fsl/l2_model_callables.py b/example-specs/task/nipype_internal/pydra-fsl/l2_model_callables.py
new file mode 100644
index 00000000..05b7a8ce
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/l2_model_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in L2Model.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/level_1_design.yaml b/example-specs/task/nipype_internal/pydra-fsl/level_1_design.yaml
new file mode 100644
index 00000000..97fe32d5
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/level_1_design.yaml
@@ -0,0 +1,85 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.model.Level1Design' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Generate FEAT specific files
+# 
+#     Examples
+#     --------
+# 
+#     >>> level1design = Level1Design()
+#     >>> level1design.inputs.interscan_interval = 2.5
+#     >>> level1design.inputs.bases = {'dgamma':{'derivs': False}}
+#     >>> level1design.inputs.session_info = 'session_info.npz'
+#     >>> level1design.run() # doctest: +SKIP
+# 
+#     
+task_name: Level1Design
+nipype_name: Level1Design
+nipype_module: nipype.interfaces.fsl.model
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    interscan_interval:
+    # type=float|default=0.0: Interscan  interval (in secs)
+    session_info:
+    # type=any|default=None: Session specific information generated by ``modelgen.SpecifyModel``
+    bases:
+    # type=traitcompound|default=None: name of basis function and options e.g., {'dgamma': {'derivs': True}}
+    orthogonalization:
+    # type=dict|default={}: which regressors to make orthogonal e.g., {1: {0:0,1:0,2:0}, 2: {0:1,1:1,2:0}} to make the second regressor in a 2-regressor model orthogonal to the first.
+    model_serial_correlations:
+    # type=bool|default=False: Option to model serial correlations using an autoregressive estimator (order 1). Setting this option is only useful in the context of the fsf file. If you set this to False, you need to repeat this option for FILMGLS by setting autocorr_noestimate to True
+    contrasts:
+    # type=list|default=[]: List of contrasts with each contrast being a list of the form - [('name', 'stat', [condition list], [weight list], [session list])]. if session list is None or not provided, all sessions are used. For F contrasts, the condition list should contain previously defined T-contrasts.
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-fsl/level_1_design_callables.py b/example-specs/task/nipype_internal/pydra-fsl/level_1_design_callables.py
new file mode 100644
index 00000000..0558037d
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/level_1_design_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Level1Design.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/make_dyadic_vectors.yaml b/example-specs/task/nipype_internal/pydra-fsl/make_dyadic_vectors.yaml
new file mode 100644
index 00000000..633027e9
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/make_dyadic_vectors.yaml
@@ -0,0 +1,91 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.dti.MakeDyadicVectors' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Create vector volume representing mean principal diffusion direction
+#     and its uncertainty (dispersion)
+task_name: MakeDyadicVectors
+nipype_name: MakeDyadicVectors
+nipype_module: nipype.interfaces.fsl.dti
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    theta_vol: generic/file
+    # type=file|default=<undefined>: 
+    phi_vol: generic/file
+    # type=file|default=<undefined>: 
+    mask: generic/file
+    # type=file|default=<undefined>: 
+    output: generic/file
+    # type=file|default='dyads': 
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    dyads: generic/file
+    # type=file: 
+    dispersion: generic/file
+    # type=file: 
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    theta_vol:
+    # type=file|default=<undefined>: 
+    phi_vol:
+    # type=file|default=<undefined>: 
+    mask:
+    # type=file|default=<undefined>: 
+    output:
+    # type=file|default='dyads': 
+    perc:
+    # type=float|default=0.0: the {perc}% angle of the output cone of uncertainty (output will be in degrees)
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-fsl/make_dyadic_vectors_callables.py b/example-specs/task/nipype_internal/pydra-fsl/make_dyadic_vectors_callables.py
new file mode 100644
index 00000000..3864dbd7
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/make_dyadic_vectors_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in MakeDyadicVectors.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/maths_command.yaml b/example-specs/task/nipype_internal/pydra-fsl/maths_command.yaml
new file mode 100644
index 00000000..c9bbe5bc
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/maths_command.yaml
@@ -0,0 +1,87 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.maths.MathsCommand' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+task_name: MathsCommand
+nipype_name: MathsCommand
+nipype_module: nipype.interfaces.fsl.maths
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: image to operate on
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: out_file
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: image to operate on
+    out_file:
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
+    internal_datatype:
+    # type=enum|default='float'|allowed['char','double','float','input','int','short']: datatype to use for calculations (default is float)
+    output_datatype:
+    # type=enum|default='float'|allowed['char','double','float','input','int','short']: datatype to use for output (default uses input type)
+    nan2zeros:
+    # type=bool|default=False: change NaNs to zeros before doing anything
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-fsl/maths_command_callables.py b/example-specs/task/nipype_internal/pydra-fsl/maths_command_callables.py
new file mode 100644
index 00000000..84e0f131
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/maths_command_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in MathsCommand.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/max_image.yaml b/example-specs/task/nipype_internal/pydra-fsl/max_image.yaml
new file mode 100644
index 00000000..7be290f7
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/max_image.yaml
@@ -0,0 +1,133 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.maths.MaxImage' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Use fslmaths to generate a max image across a given dimension.
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces.fsl.maths import MaxImage
+#     >>> maxer = MaxImage()
+#     >>> maxer.inputs.in_file = "functional.nii"  # doctest: +SKIP
+#     >>> maxer.dimension = "T"
+#     >>> maxer.cmdline  # doctest: +SKIP
+#     'fslmaths functional.nii -Tmax functional_max.nii'
+# 
+#     
+task_name: MaxImage
+nipype_name: MaxImage
+nipype_module: nipype.interfaces.fsl.maths
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: image to operate on
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: out_file
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    dimension:
+    # type=enum|default='T'|allowed['T','X','Y','Z']: dimension to max across
+    in_file:
+    # type=file|default=<undefined>: image to operate on
+    out_file:
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
+    internal_datatype:
+    # type=enum|default='float'|allowed['char','double','float','input','int','short']: datatype to use for calculations (default is float)
+    output_datatype:
+    # type=enum|default='float'|allowed['char','double','float','input','int','short']: datatype to use for output (default uses input type)
+    nan2zeros:
+    # type=bool|default=False: change NaNs to zeros before doing anything
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: image to operate on
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: fslmaths functional.nii -Tmax functional_max.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: image to operate on
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-fsl/max_image_callables.py b/example-specs/task/nipype_internal/pydra-fsl/max_image_callables.py
new file mode 100644
index 00000000..940bd9a0
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/max_image_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in MaxImage.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/maxn_image.yaml b/example-specs/task/nipype_internal/pydra-fsl/maxn_image.yaml
new file mode 100644
index 00000000..2794e7de
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/maxn_image.yaml
@@ -0,0 +1,92 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.maths.MaxnImage' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Use fslmaths to generate an image of index of max across
+#     a given dimension.
+# 
+#     
+task_name: MaxnImage
+nipype_name: MaxnImage
+nipype_module: nipype.interfaces.fsl.maths
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: image to operate on
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: out_file
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    dimension:
+    # type=enum|default='T'|allowed['T','X','Y','Z']: dimension to index max across
+    in_file:
+    # type=file|default=<undefined>: image to operate on
+    out_file:
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
+    internal_datatype:
+    # type=enum|default='float'|allowed['char','double','float','input','int','short']: datatype to use for calculations (default is float)
+    output_datatype:
+    # type=enum|default='float'|allowed['char','double','float','input','int','short']: datatype to use for output (default uses input type)
+    nan2zeros:
+    # type=bool|default=False: change NaNs to zeros before doing anything
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-fsl/maxn_image_callables.py b/example-specs/task/nipype_internal/pydra-fsl/maxn_image_callables.py
new file mode 100644
index 00000000..31eb42f2
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/maxn_image_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in MaxnImage.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/mcflirt.yaml b/example-specs/task/nipype_internal/pydra-fsl/mcflirt.yaml
new file mode 100644
index 00000000..27a2ad64
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/mcflirt.yaml
@@ -0,0 +1,188 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.preprocess.MCFLIRT' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# FSL MCFLIRT wrapper for within-modality motion correction
+# 
+#     For complete details, see the `MCFLIRT Documentation.
+#     <https://fsl.fmrib.ox.ac.uk/fsl/fslwiki/MCFLIRT>`_
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import fsl
+#     >>> mcflt = fsl.MCFLIRT()
+#     >>> mcflt.inputs.in_file = 'functional.nii'
+#     >>> mcflt.inputs.cost = 'mutualinfo'
+#     >>> mcflt.inputs.out_file = 'moco.nii'
+#     >>> mcflt.cmdline
+#     'mcflirt -in functional.nii -cost mutualinfo -out moco.nii'
+#     >>> res = mcflt.run()  # doctest: +SKIP
+# 
+#     
+task_name: MCFLIRT
+nipype_name: MCFLIRT
+nipype_module: nipype.interfaces.fsl.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: timeseries to motion-correct
+    init: generic/file
+    # type=file|default=<undefined>: initial transformation matrix
+    ref_file: generic/file
+    # type=file|default=<undefined>: target image for motion correction
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: medimage/nifti1
+    # type=file: motion-corrected timeseries
+    # type=file|default=<undefined>: file to write
+    variance_img: generic/file
+    # type=file: variance image
+    std_img: generic/file
+    # type=file: standard deviation image
+    mean_img: generic/file
+    # type=file: mean timeseries image (if mean_vol=True)
+    par_file: generic/file
+    # type=file: text-file with motion parameters
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: '"moco.nii"'
+    # type=file: motion-corrected timeseries
+    # type=file|default=<undefined>: file to write
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: timeseries to motion-correct
+    out_file:
+    # type=file: motion-corrected timeseries
+    # type=file|default=<undefined>: file to write
+    cost:
+    # type=enum|default='mutualinfo'|allowed['corratio','leastsquares','mutualinfo','normcorr','normmi','woods']: cost function to optimize
+    bins:
+    # type=int|default=0: number of histogram bins
+    dof:
+    # type=int|default=0: degrees of freedom for the transformation
+    ref_vol:
+    # type=int|default=0: volume to align frames to
+    scaling:
+    # type=float|default=0.0: scaling factor to use
+    smooth:
+    # type=float|default=0.0: smoothing factor for the cost function
+    rotation:
+    # type=int|default=0: scaling factor for rotation tolerances
+    stages:
+    # type=int|default=0: stages (if 4, perform final search with sinc interpolation
+    init:
+    # type=file|default=<undefined>: initial transformation matrix
+    interpolation:
+    # type=enum|default='spline'|allowed['nn','sinc','spline']: interpolation method for transformation
+    use_gradient:
+    # type=bool|default=False: run search on gradient images
+    use_contour:
+    # type=bool|default=False: run search on contour images
+    mean_vol:
+    # type=bool|default=False: register to mean volume
+    stats_imgs:
+    # type=bool|default=False: produce variance and std. dev. images
+    save_mats:
+    # type=bool|default=False: save transformation matrices
+    save_plots:
+    # type=bool|default=False: save transformation parameters
+    save_rms:
+    # type=bool|default=False: save rms displacement parameters
+    ref_file:
+    # type=file|default=<undefined>: target image for motion correction
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: timeseries to motion-correct
+    cost: '"mutualinfo"'
+    # type=enum|default='mutualinfo'|allowed['corratio','leastsquares','mutualinfo','normcorr','normmi','woods']: cost function to optimize
+    out_file: '"moco.nii"'
+    # type=file: motion-corrected timeseries
+    # type=file|default=<undefined>: file to write
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: mcflirt -in functional.nii -cost mutualinfo -out moco.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: timeseries to motion-correct
+    cost: '"mutualinfo"'
+    # type=enum|default='mutualinfo'|allowed['corratio','leastsquares','mutualinfo','normcorr','normmi','woods']: cost function to optimize
+    out_file: '"moco.nii"'
+    # type=file: motion-corrected timeseries
+    # type=file|default=<undefined>: file to write
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-fsl/mcflirt_callables.py b/example-specs/task/nipype_internal/pydra-fsl/mcflirt_callables.py
new file mode 100644
index 00000000..7fb6bc8c
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/mcflirt_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in MCFLIRT.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/mean_image.yaml b/example-specs/task/nipype_internal/pydra-fsl/mean_image.yaml
new file mode 100644
index 00000000..9f080763
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/mean_image.yaml
@@ -0,0 +1,89 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.maths.MeanImage' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Use fslmaths to generate a mean image across a given dimension.
+task_name: MeanImage
+nipype_name: MeanImage
+nipype_module: nipype.interfaces.fsl.maths
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: image to operate on
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: out_file
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    dimension:
+    # type=enum|default='T'|allowed['T','X','Y','Z']: dimension to mean across
+    in_file:
+    # type=file|default=<undefined>: image to operate on
+    out_file:
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
+    internal_datatype:
+    # type=enum|default='float'|allowed['char','double','float','input','int','short']: datatype to use for calculations (default is float)
+    output_datatype:
+    # type=enum|default='float'|allowed['char','double','float','input','int','short']: datatype to use for output (default uses input type)
+    nan2zeros:
+    # type=bool|default=False: change NaNs to zeros before doing anything
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-fsl/mean_image_callables.py b/example-specs/task/nipype_internal/pydra-fsl/mean_image_callables.py
new file mode 100644
index 00000000..1d3333ca
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/mean_image_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in MeanImage.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/median_image.yaml b/example-specs/task/nipype_internal/pydra-fsl/median_image.yaml
new file mode 100644
index 00000000..35181867
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/median_image.yaml
@@ -0,0 +1,89 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.maths.MedianImage' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Use fslmaths to generate a median image across a given dimension.
+task_name: MedianImage
+nipype_name: MedianImage
+nipype_module: nipype.interfaces.fsl.maths
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: image to operate on
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: out_file
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    dimension:
+    # type=enum|default='T'|allowed['T','X','Y','Z']: dimension to median across
+    in_file:
+    # type=file|default=<undefined>: image to operate on
+    out_file:
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
+    internal_datatype:
+    # type=enum|default='float'|allowed['char','double','float','input','int','short']: datatype to use for calculations (default is float)
+    output_datatype:
+    # type=enum|default='float'|allowed['char','double','float','input','int','short']: datatype to use for output (default uses input type)
+    nan2zeros:
+    # type=bool|default=False: change NaNs to zeros before doing anything
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-fsl/median_image_callables.py b/example-specs/task/nipype_internal/pydra-fsl/median_image_callables.py
new file mode 100644
index 00000000..d4df040b
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/median_image_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in MedianImage.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/melodic.yaml b/example-specs/task/nipype_internal/pydra-fsl/melodic.yaml
new file mode 100644
index 00000000..9363b3fc
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/melodic.yaml
@@ -0,0 +1,296 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.model.MELODIC' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Multivariate Exploratory Linear Optimised Decomposition into Independent
+#     Components
+# 
+#     Examples
+#     --------
+# 
+#     >>> melodic_setup = MELODIC()
+#     >>> melodic_setup.inputs.approach = 'tica'
+#     >>> melodic_setup.inputs.in_files = ['functional.nii', 'functional2.nii', 'functional3.nii']
+#     >>> melodic_setup.inputs.no_bet = True
+#     >>> melodic_setup.inputs.bg_threshold = 10
+#     >>> melodic_setup.inputs.tr_sec = 1.5
+#     >>> melodic_setup.inputs.mm_thresh = 0.5
+#     >>> melodic_setup.inputs.out_stats = True
+#     >>> melodic_setup.inputs.t_des = 'timeDesign.mat'
+#     >>> melodic_setup.inputs.t_con = 'timeDesign.con'
+#     >>> melodic_setup.inputs.s_des = 'subjectDesign.mat'
+#     >>> melodic_setup.inputs.s_con = 'subjectDesign.con'
+#     >>> melodic_setup.inputs.out_dir = 'groupICA.out'
+#     >>> melodic_setup.cmdline
+#     'melodic -i functional.nii,functional2.nii,functional3.nii -a tica --bgthreshold=10.000000 --mmthresh=0.500000 --nobet -o groupICA.out --Ostats --Scon=subjectDesign.con --Sdes=subjectDesign.mat --Tcon=timeDesign.con --Tdes=timeDesign.mat --tr=1.500000'
+#     >>> melodic_setup.run() # doctest: +SKIP
+# 
+# 
+#     
+task_name: MELODIC
+nipype_name: MELODIC
+nipype_module: nipype.interfaces.fsl.model
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_files: medimage/nifti1+list-of
+    # type=inputmultiobject|default=[]: input file names (either single file name or a list)
+    mask: generic/file
+    # type=file|default=<undefined>: file name of mask for thresholding
+    ICs: generic/file
+    # type=file|default=<undefined>: filename of the IC components file for mixture modelling
+    mix: generic/file
+    # type=file|default=<undefined>: mixing matrix for mixture modelling / filtering
+    smode: generic/file
+    # type=file|default=<undefined>: matrix of session modes for report generation
+    bg_image: generic/file
+    # type=file|default=<undefined>: specify background image for report (default: mean image)
+    t_des: datascience/text-matrix
+    # type=file|default=<undefined>: design matrix across time-domain
+    t_con: medimage-fsl/con
+    # type=file|default=<undefined>: t-contrast matrix across time-domain
+    s_des: datascience/text-matrix
+    # type=file|default=<undefined>: design matrix across subject-domain
+    s_con: medimage-fsl/con
+    # type=file|default=<undefined>: t-contrast matrix across subject-domain
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_dir: generic/directory
+    # type=directory: 
+    # type=directory|default=<undefined>: output directory name
+    report_dir: generic/directory
+    # type=directory: 
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_dir: '"groupICA.out"'
+    # type=directory: 
+    # type=directory|default=<undefined>: output directory name
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_files:
+    # type=inputmultiobject|default=[]: input file names (either single file name or a list)
+    out_dir:
+    # type=directory: 
+    # type=directory|default=<undefined>: output directory name
+    mask:
+    # type=file|default=<undefined>: file name of mask for thresholding
+    no_mask:
+    # type=bool|default=False: switch off masking
+    update_mask:
+    # type=bool|default=False: switch off mask updating
+    no_bet:
+    # type=bool|default=False: switch off BET
+    bg_threshold:
+    # type=float|default=0.0: brain/non-brain threshold used to mask non-brain voxels, as a percentage (only if --nobet selected)
+    dim:
+    # type=int|default=0: dimensionality reduction into #num dimensions (default: automatic estimation)
+    dim_est:
+    # type=str|default='': use specific dim. estimation technique: lap, bic, mdl, aic, mean (default: lap)
+    sep_whiten:
+    # type=bool|default=False: switch on separate whitening
+    sep_vn:
+    # type=bool|default=False: switch off joined variance normalization
+    migp:
+    # type=bool|default=False: switch on MIGP data reduction
+    migpN:
+    # type=int|default=0: number of internal Eigenmaps
+    migp_shuffle:
+    # type=bool|default=False: randomise MIGP file order (default: TRUE)
+    migp_factor:
+    # type=int|default=0: Internal Factor of mem-threshold relative to number of Eigenmaps (default: 2)
+    num_ICs:
+    # type=int|default=0: number of IC's to extract (for deflation approach)
+    approach:
+    # type=str|default='': approach for decomposition, 2D: defl, symm (default), 3D: tica (default), concat
+    non_linearity:
+    # type=str|default='': nonlinearity: gauss, tanh, pow3, pow4
+    var_norm:
+    # type=bool|default=False: switch off variance normalization
+    pbsc:
+    # type=bool|default=False: switch off conversion to percent BOLD signal change
+    cov_weight:
+    # type=float|default=0.0: voxel-wise weights for the covariance matrix (e.g. segmentation information)
+    epsilon:
+    # type=float|default=0.0: minimum error change
+    epsilonS:
+    # type=float|default=0.0: minimum error change for rank-1 approximation in TICA
+    maxit:
+    # type=int|default=0: maximum number of iterations before restart
+    max_restart:
+    # type=int|default=0: maximum number of restarts
+    mm_thresh:
+    # type=float|default=0.0: threshold for Mixture Model based inference
+    no_mm:
+    # type=bool|default=False: switch off mixture modelling on IC maps
+    ICs:
+    # type=file|default=<undefined>: filename of the IC components file for mixture modelling
+    mix:
+    # type=file|default=<undefined>: mixing matrix for mixture modelling / filtering
+    smode:
+    # type=file|default=<undefined>: matrix of session modes for report generation
+    rem_cmp:
+    # type=list|default=[]: component numbers to remove
+    report:
+    # type=bool|default=False: generate Melodic web report
+    bg_image:
+    # type=file|default=<undefined>: specify background image for report (default: mean image)
+    tr_sec:
+    # type=float|default=0.0: TR in seconds
+    log_power:
+    # type=bool|default=False: calculate log of power for frequency spectrum
+    t_des:
+    # type=file|default=<undefined>: design matrix across time-domain
+    t_con:
+    # type=file|default=<undefined>: t-contrast matrix across time-domain
+    s_des:
+    # type=file|default=<undefined>: design matrix across subject-domain
+    s_con:
+    # type=file|default=<undefined>: t-contrast matrix across subject-domain
+    out_all:
+    # type=bool|default=False: output everything
+    out_unmix:
+    # type=bool|default=False: output unmixing matrix
+    out_stats:
+    # type=bool|default=False: output thresholded maps and probability maps
+    out_pca:
+    # type=bool|default=False: output PCA results
+    out_white:
+    # type=bool|default=False: output whitening/dewhitening matrices
+    out_orig:
+    # type=bool|default=False: output the original ICs
+    out_mean:
+    # type=bool|default=False: output mean volume
+    report_maps:
+    # type=str|default='': control string for spatial map images (see slicer)
+    remove_deriv:
+    # type=bool|default=False: removes every second entry in paradigm file (EV derivatives)
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    approach: '"tica"'
+    # type=str|default='': approach for decomposition, 2D: defl, symm (default), 3D: tica (default), concat
+    in_files:
+    # type=inputmultiobject|default=[]: input file names (either single file name or a list)
+    no_bet: 'True'
+    # type=bool|default=False: switch off BET
+    bg_threshold: '10'
+    # type=float|default=0.0: brain/non-brain threshold used to mask non-brain voxels, as a percentage (only if --nobet selected)
+    tr_sec: '1.5'
+    # type=float|default=0.0: TR in seconds
+    mm_thresh: '0.5'
+    # type=float|default=0.0: threshold for Mixture Model based inference
+    out_stats: 'True'
+    # type=bool|default=False: output thresholded maps and probability maps
+    t_des:
+    # type=file|default=<undefined>: design matrix across time-domain
+    t_con:
+    # type=file|default=<undefined>: t-contrast matrix across time-domain
+    s_des:
+    # type=file|default=<undefined>: design matrix across subject-domain
+    s_con:
+    # type=file|default=<undefined>: t-contrast matrix across subject-domain
+    out_dir: '"groupICA.out"'
+    # type=directory: 
+    # type=directory|default=<undefined>: output directory name
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: melodic -i functional.nii,functional2.nii,functional3.nii -a tica --bgthreshold=10.000000 --mmthresh=0.500000 --nobet -o groupICA.out --Ostats --Scon=subjectDesign.con --Sdes=subjectDesign.mat --Tcon=timeDesign.con --Tdes=timeDesign.mat --tr=1.500000
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    approach: '"tica"'
+    # type=str|default='': approach for decomposition, 2D: defl, symm (default), 3D: tica (default), concat
+    in_files:
+    # type=inputmultiobject|default=[]: input file names (either single file name or a list)
+    no_bet: 'True'
+    # type=bool|default=False: switch off BET
+    bg_threshold: '10'
+    # type=float|default=0.0: brain/non-brain threshold used to mask non-brain voxels, as a percentage (only if --nobet selected)
+    tr_sec: '1.5'
+    # type=float|default=0.0: TR in seconds
+    mm_thresh: '0.5'
+    # type=float|default=0.0: threshold for Mixture Model based inference
+    out_stats: 'True'
+    # type=bool|default=False: output thresholded maps and probability maps
+    t_des:
+    # type=file|default=<undefined>: design matrix across time-domain
+    t_con:
+    # type=file|default=<undefined>: t-contrast matrix across time-domain
+    s_des:
+    # type=file|default=<undefined>: design matrix across subject-domain
+    s_con:
+    # type=file|default=<undefined>: t-contrast matrix across subject-domain
+    out_dir: '"groupICA.out"'
+    # type=directory: 
+    # type=directory|default=<undefined>: output directory name
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-fsl/melodic_callables.py b/example-specs/task/nipype_internal/pydra-fsl/melodic_callables.py
new file mode 100644
index 00000000..b6075b9a
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/melodic_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in MELODIC.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/merge.yaml b/example-specs/task/nipype_internal/pydra-fsl/merge.yaml
new file mode 100644
index 00000000..8fb0c1c5
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/merge.yaml
@@ -0,0 +1,154 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.utils.Merge' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Use fslmerge to concatenate images
+# 
+#     Images can be concatenated across time, x, y, or z dimensions. Across the
+#     time (t) dimension the TR is set by default to 1 sec.
+# 
+#     Note: to set the TR to a different value, specify 't' for dimension and
+#     specify the TR value in seconds for the tr input. The dimension will be
+#     automatically updated to 'tr'.
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces.fsl import Merge
+#     >>> merger = Merge()
+#     >>> merger.inputs.in_files = ['functional2.nii', 'functional3.nii']
+#     >>> merger.inputs.dimension = 't'
+#     >>> merger.inputs.output_type = 'NIFTI_GZ'
+#     >>> merger.cmdline
+#     'fslmerge -t functional2_merged.nii.gz functional2.nii functional3.nii'
+#     >>> merger.inputs.tr = 2.25
+#     >>> merger.cmdline
+#     'fslmerge -tr functional2_merged.nii.gz functional2.nii functional3.nii 2.25'
+# 
+# 
+#     
+task_name: Merge
+nipype_name: Merge
+nipype_module: nipype.interfaces.fsl.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_files: medimage/nifti1+list-of
+    # type=list|default=[]: 
+    merged_file: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: 
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    merged_file: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: 
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_files:
+    # type=list|default=[]: 
+    dimension:
+    # type=enum|default='t'|allowed['a','t','x','y','z']: dimension along which to merge, optionally set tr input when dimension is t
+    tr:
+    # type=float|default=0.0: use to specify TR in seconds (default is 1.00 sec), overrides dimension and sets it to tr
+    merged_file:
+    # type=file: 
+    # type=file|default=<undefined>: 
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_files:
+    # type=list|default=[]: 
+    dimension: '"t"'
+    # type=enum|default='t'|allowed['a','t','x','y','z']: dimension along which to merge, optionally set tr input when dimension is t
+    output_type: '"NIFTI_GZ"'
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    tr: '2.25'
+    # type=float|default=0.0: use to specify TR in seconds (default is 1.00 sec), overrides dimension and sets it to tr
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: fslmerge -tr functional2_merged.nii.gz functional2.nii functional3.nii 2.25
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_files:
+    # type=list|default=[]: 
+    dimension: '"t"'
+    # type=enum|default='t'|allowed['a','t','x','y','z']: dimension along which to merge, optionally set tr input when dimension is t
+    output_type: '"NIFTI_GZ"'
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    tr: '2.25'
+    # type=float|default=0.0: use to specify TR in seconds (default is 1.00 sec), overrides dimension and sets it to tr
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-fsl/merge_callables.py b/example-specs/task/nipype_internal/pydra-fsl/merge_callables.py
new file mode 100644
index 00000000..1950a89d
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/merge_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Merge.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/min_image.yaml b/example-specs/task/nipype_internal/pydra-fsl/min_image.yaml
new file mode 100644
index 00000000..001cd4f9
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/min_image.yaml
@@ -0,0 +1,89 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.maths.MinImage' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Use fslmaths to generate a minimum image across a given dimension.
+task_name: MinImage
+nipype_name: MinImage
+nipype_module: nipype.interfaces.fsl.maths
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: image to operate on
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: out_file
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    dimension:
+    # type=enum|default='T'|allowed['T','X','Y','Z']: dimension to min across
+    in_file:
+    # type=file|default=<undefined>: image to operate on
+    out_file:
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
+    internal_datatype:
+    # type=enum|default='float'|allowed['char','double','float','input','int','short']: datatype to use for calculations (default is float)
+    output_datatype:
+    # type=enum|default='float'|allowed['char','double','float','input','int','short']: datatype to use for output (default uses input type)
+    nan2zeros:
+    # type=bool|default=False: change NaNs to zeros before doing anything
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-fsl/min_image_callables.py b/example-specs/task/nipype_internal/pydra-fsl/min_image_callables.py
new file mode 100644
index 00000000..be3a24b8
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/min_image_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in MinImage.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/motion_outliers.yaml b/example-specs/task/nipype_internal/pydra-fsl/motion_outliers.yaml
new file mode 100644
index 00000000..ccd418bf
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/motion_outliers.yaml
@@ -0,0 +1,154 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.utils.MotionOutliers' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Use FSL fsl_motion_outliers`http://fsl.fmrib.ox.ac.uk/fsl/fslwiki/FSLMotionOutliers`_ to find outliers in timeseries (4d) data.
+#     Examples
+#     --------
+#     >>> from nipype.interfaces.fsl import MotionOutliers
+#     >>> mo = MotionOutliers()
+#     >>> mo.inputs.in_file = "epi.nii"
+#     >>> mo.cmdline # doctest: +ELLIPSIS
+#     'fsl_motion_outliers -i epi.nii -o epi_outliers.txt -p epi_metrics.png -s epi_metrics.txt'
+#     >>> res = mo.run() # doctest: +SKIP
+#     
+task_name: MotionOutliers
+nipype_name: MotionOutliers
+nipype_module: nipype.interfaces.fsl.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: unfiltered 4D image
+    out_file: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: output outlier file name
+    mask: generic/file
+    # type=file|default=<undefined>: mask image for calculating metric
+    out_metric_values: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: output metric values (DVARS etc.) file name
+    out_metric_plot: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: output metric values plot (DVARS etc.) file name
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: output outlier file name
+    out_metric_values: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: output metric values (DVARS etc.) file name
+    out_metric_plot: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: output metric values plot (DVARS etc.) file name
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: unfiltered 4D image
+    out_file:
+    # type=file: 
+    # type=file|default=<undefined>: output outlier file name
+    mask:
+    # type=file|default=<undefined>: mask image for calculating metric
+    metric:
+    # type=enum|default='refrms'|allowed['dvars','fd','fdrms','refmse','refrms']: metrics: refrms - RMS intensity difference to reference volume as metric [default metric], refmse - Mean Square Error version of refrms (used in original version of fsl_motion_outliers), dvars - DVARS, fd - frame displacement, fdrms - FD with RMS matrix calculation
+    threshold:
+    # type=float|default=0.0: specify absolute threshold value (otherwise use box-plot cutoff = P75 + 1.5*IQR)
+    no_motion_correction:
+    # type=bool|default=False: do not run motion correction (assumed already done)
+    dummy:
+    # type=int|default=0: number of dummy scans to delete (before running anything and creating EVs)
+    out_metric_values:
+    # type=file: 
+    # type=file|default=<undefined>: output metric values (DVARS etc.) file name
+    out_metric_plot:
+    # type=file: 
+    # type=file|default=<undefined>: output metric values plot (DVARS etc.) file name
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: unfiltered 4D image
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: fsl_motion_outliers -i epi.nii -o epi_outliers.txt -p epi_metrics.png -s epi_metrics.txt
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: unfiltered 4D image
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-fsl/motion_outliers_callables.py b/example-specs/task/nipype_internal/pydra-fsl/motion_outliers_callables.py
new file mode 100644
index 00000000..811e8192
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/motion_outliers_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in MotionOutliers.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/multi_image_maths.yaml b/example-specs/task/nipype_internal/pydra-fsl/multi_image_maths.yaml
new file mode 100644
index 00000000..35b56119
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/multi_image_maths.yaml
@@ -0,0 +1,153 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.maths.MultiImageMaths' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Use fslmaths to perform a sequence of mathematical operations.
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces.fsl import MultiImageMaths
+#     >>> maths = MultiImageMaths()
+#     >>> maths.inputs.in_file = "functional.nii"
+#     >>> maths.inputs.op_string = "-add %s -mul -1 -div %s"
+#     >>> maths.inputs.operand_files = ["functional2.nii", "functional3.nii"]
+#     >>> maths.inputs.out_file = "functional4.nii"
+#     >>> maths.cmdline
+#     'fslmaths functional.nii -add functional2.nii -mul -1 -div functional3.nii functional4.nii'
+# 
+#     
+task_name: MultiImageMaths
+nipype_name: MultiImageMaths
+nipype_module: nipype.interfaces.fsl.maths
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    operand_files: medimage/nifti1+list-of
+    # type=inputmultiobject|default=[]: list of file names to plug into op string
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: image to operate on
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: medimage/nifti1
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: '"functional4.nii"'
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    op_string:
+    # type=string|default='': python formatted string of operations to perform
+    operand_files:
+    # type=inputmultiobject|default=[]: list of file names to plug into op string
+    in_file:
+    # type=file|default=<undefined>: image to operate on
+    out_file:
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
+    internal_datatype:
+    # type=enum|default='float'|allowed['char','double','float','input','int','short']: datatype to use for calculations (default is float)
+    output_datatype:
+    # type=enum|default='float'|allowed['char','double','float','input','int','short']: datatype to use for output (default uses input type)
+    nan2zeros:
+    # type=bool|default=False: change NaNs to zeros before doing anything
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: image to operate on
+    op_string: '"-add %s -mul -1 -div %s"'
+    # type=string|default='': python formatted string of operations to perform
+    operand_files:
+    # type=inputmultiobject|default=[]: list of file names to plug into op string
+    out_file: '"functional4.nii"'
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: fslmaths functional.nii -add functional2.nii -mul -1 -div functional3.nii functional4.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: image to operate on
+    op_string: '"-add %s -mul -1 -div %s"'
+    # type=string|default='': python formatted string of operations to perform
+    operand_files:
+    # type=inputmultiobject|default=[]: list of file names to plug into op string
+    out_file: '"functional4.nii"'
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-fsl/multi_image_maths_callables.py b/example-specs/task/nipype_internal/pydra-fsl/multi_image_maths_callables.py
new file mode 100644
index 00000000..af619ea5
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/multi_image_maths_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in MultiImageMaths.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/multiple_regress_design.yaml b/example-specs/task/nipype_internal/pydra-fsl/multiple_regress_design.yaml
new file mode 100644
index 00000000..499caa02
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/multiple_regress_design.yaml
@@ -0,0 +1,94 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.model.MultipleRegressDesign' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Generate multiple regression design
+# 
+#     .. note::
+#       FSL does not demean columns for higher level analysis.
+# 
+#     Please see `FSL documentation
+#     <http://www.fmrib.ox.ac.uk/fsl/feat5/detail.html#higher>`_
+#     for more details on model specification for higher level analysis.
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces.fsl import MultipleRegressDesign
+#     >>> model = MultipleRegressDesign()
+#     >>> model.inputs.contrasts = [['group mean', 'T',['reg1'],[1]]]
+#     >>> model.inputs.regressors = dict(reg1=[1, 1, 1], reg2=[2.,-4, 3])
+#     >>> model.run() # doctest: +SKIP
+# 
+#     
+task_name: MultipleRegressDesign
+nipype_name: MultipleRegressDesign
+nipype_module: nipype.interfaces.fsl.model
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    design_mat: generic/file
+    # type=file: design matrix file
+    design_con: generic/file
+    # type=file: design t-contrast file
+    design_fts: generic/file
+    # type=file: design f-contrast file
+    design_grp: generic/file
+    # type=file: design group file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    contrasts:
+    # type=list|default=[]: List of contrasts with each contrast being a list of the form - [('name', 'stat', [condition list], [weight list])]. if session list is None or not provided, all sessions are used. For F contrasts, the condition list should contain previously defined T-contrasts without any weight list.
+    regressors:
+    # type=dict|default={}: dictionary containing named lists of regressors
+    groups:
+    # type=list|default=[]: list of group identifiers (defaults to single group)
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-fsl/multiple_regress_design_callables.py b/example-specs/task/nipype_internal/pydra-fsl/multiple_regress_design_callables.py
new file mode 100644
index 00000000..d429231c
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/multiple_regress_design_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in MultipleRegressDesign.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/overlay.yaml b/example-specs/task/nipype_internal/pydra-fsl/overlay.yaml
new file mode 100644
index 00000000..5b5781a1
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/overlay.yaml
@@ -0,0 +1,124 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.utils.Overlay' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Use FSL's overlay command to combine background and statistical images
+#         into one volume
+# 
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces import fsl
+#     >>> combine = fsl.Overlay()
+#     >>> combine.inputs.background_image = 'mean_func.nii.gz'
+#     >>> combine.inputs.auto_thresh_bg = True
+#     >>> combine.inputs.stat_image = 'zstat1.nii.gz'
+#     >>> combine.inputs.stat_thresh = (3.5, 10)
+#     >>> combine.inputs.show_negative_stats = True
+#     >>> res = combine.run() #doctest: +SKIP
+# 
+# 
+#     
+task_name: Overlay
+nipype_name: Overlay
+nipype_module: nipype.interfaces.fsl.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    background_image: generic/file
+    # type=file|default=<undefined>: image to use as background
+    stat_image: generic/file
+    # type=file|default=<undefined>: statistical image to overlay in color
+    stat_image2: generic/file
+    # type=file|default=<undefined>: second statistical image to overlay in color
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: combined image volume
+    # type=file|default=<undefined>: combined image volume
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: out_file
+    # type=file: combined image volume
+    # type=file|default=<undefined>: combined image volume
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    transparency:
+    # type=bool|default=True: make overlay colors semi-transparent
+    out_type:
+    # type=enum|default='float'|allowed['float','int']: write output with float or int
+    use_checkerboard:
+    # type=bool|default=False: use checkerboard mask for overlay
+    background_image:
+    # type=file|default=<undefined>: image to use as background
+    auto_thresh_bg:
+    # type=bool|default=False: automatically threshold the background image
+    full_bg_range:
+    # type=bool|default=False: use full range of background image
+    bg_thresh:
+    # type=tuple|default=(0.0, 0.0): min and max values for background intensity
+    stat_image:
+    # type=file|default=<undefined>: statistical image to overlay in color
+    stat_thresh:
+    # type=tuple|default=(0.0, 0.0): min and max values for the statistical overlay
+    show_negative_stats:
+    # type=bool|default=False: display negative statistics in overlay
+    stat_image2:
+    # type=file|default=<undefined>: second statistical image to overlay in color
+    stat_thresh2:
+    # type=tuple|default=(0.0, 0.0): min and max values for second statistical overlay
+    out_file:
+    # type=file: combined image volume
+    # type=file|default=<undefined>: combined image volume
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-fsl/overlay_callables.py b/example-specs/task/nipype_internal/pydra-fsl/overlay_callables.py
new file mode 100644
index 00000000..dc826681
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/overlay_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Overlay.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/percentile_image.yaml b/example-specs/task/nipype_internal/pydra-fsl/percentile_image.yaml
new file mode 100644
index 00000000..bcd4ba6a
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/percentile_image.yaml
@@ -0,0 +1,136 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.maths.PercentileImage' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Use fslmaths to generate a percentile image across a given dimension.
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces.fsl.maths import MaxImage
+#     >>> percer = PercentileImage()
+#     >>> percer.inputs.in_file = "functional.nii"  # doctest: +SKIP
+#     >>> percer.dimension = "T"
+#     >>> percer.perc = 90
+#     >>> percer.cmdline  # doctest: +SKIP
+#     'fslmaths functional.nii -Tperc 90 functional_perc.nii'
+# 
+#     
+task_name: PercentileImage
+nipype_name: PercentileImage
+nipype_module: nipype.interfaces.fsl.maths
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: image to operate on
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: out_file
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    dimension:
+    # type=enum|default='T'|allowed['T','X','Y','Z']: dimension to percentile across
+    perc:
+    # type=range|default=0: nth percentile (0-100) of FULL RANGE across dimension
+    in_file:
+    # type=file|default=<undefined>: image to operate on
+    out_file:
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
+    internal_datatype:
+    # type=enum|default='float'|allowed['char','double','float','input','int','short']: datatype to use for calculations (default is float)
+    output_datatype:
+    # type=enum|default='float'|allowed['char','double','float','input','int','short']: datatype to use for output (default uses input type)
+    nan2zeros:
+    # type=bool|default=False: change NaNs to zeros before doing anything
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: image to operate on
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: fslmaths functional.nii -Tperc 90 functional_perc.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: image to operate on
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-fsl/percentile_image_callables.py b/example-specs/task/nipype_internal/pydra-fsl/percentile_image_callables.py
new file mode 100644
index 00000000..3ab3b262
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/percentile_image_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in PercentileImage.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/plot_motion_params.yaml b/example-specs/task/nipype_internal/pydra-fsl/plot_motion_params.yaml
new file mode 100644
index 00000000..ecce3340
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/plot_motion_params.yaml
@@ -0,0 +1,110 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.utils.PlotMotionParams' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Use fsl_tsplot to plot the estimated motion parameters from a
+#     realignment program.
+# 
+# 
+#     Examples
+#     --------
+# 
+#     >>> import nipype.interfaces.fsl as fsl
+#     >>> plotter = fsl.PlotMotionParams()
+#     >>> plotter.inputs.in_file = 'functional.par'
+#     >>> plotter.inputs.in_source = 'fsl'
+#     >>> plotter.inputs.plot_type = 'rotations'
+#     >>> res = plotter.run() #doctest: +SKIP
+# 
+# 
+#     Notes
+#     -----
+# 
+#     The 'in_source' attribute determines the order of columns that are expected
+#     in the source file.  FSL prints motion parameters in the order rotations,
+#     translations, while SPM prints them in the opposite order.  This interface
+#     should be able to plot timecourses of motion parameters generated from
+#     other sources as long as they fall under one of these two patterns.  For
+#     more flexibility, see the :class:`fsl.PlotTimeSeries` interface.
+# 
+#     
+task_name: PlotMotionParams
+nipype_name: PlotMotionParams
+nipype_module: nipype.interfaces.fsl.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: image to write
+    # type=file|default=<undefined>: image to write
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: out_file
+    # type=file: image to write
+    # type=file|default=<undefined>: image to write
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=traitcompound|default=None: file with motion parameters
+    in_source:
+    # type=enum|default='spm'|allowed['fsl','spm']: which program generated the motion parameter file - fsl, spm
+    plot_type:
+    # type=enum|default='rotations'|allowed['displacement','rotations','translations']: which motion type to plot - rotations, translations, displacement
+    plot_size:
+    # type=tuple|default=(0, 0): plot image height and width
+    out_file:
+    # type=file: image to write
+    # type=file|default=<undefined>: image to write
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-fsl/plot_motion_params_callables.py b/example-specs/task/nipype_internal/pydra-fsl/plot_motion_params_callables.py
new file mode 100644
index 00000000..cb9a47a0
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/plot_motion_params_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in PlotMotionParams.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/plot_time_series.yaml b/example-specs/task/nipype_internal/pydra-fsl/plot_time_series.yaml
new file mode 100644
index 00000000..b5898404
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/plot_time_series.yaml
@@ -0,0 +1,120 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.utils.PlotTimeSeries' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Use fsl_tsplot to create images of time course plots.
+# 
+#     Examples
+#     --------
+# 
+#     >>> import nipype.interfaces.fsl as fsl
+#     >>> plotter = fsl.PlotTimeSeries()
+#     >>> plotter.inputs.in_file = 'functional.par'
+#     >>> plotter.inputs.title = 'Functional timeseries'
+#     >>> plotter.inputs.labels = ['run1', 'run2']
+#     >>> plotter.run() #doctest: +SKIP
+# 
+# 
+#     
+task_name: PlotTimeSeries
+nipype_name: PlotTimeSeries
+nipype_module: nipype.interfaces.fsl.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    legend_file: generic/file
+    # type=file|default=<undefined>: legend file
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: image to write
+    # type=file|default=<undefined>: image to write
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: out_file
+    # type=file: image to write
+    # type=file|default=<undefined>: image to write
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=traitcompound|default=None: file or list of files with columns of timecourse information
+    plot_start:
+    # type=int|default=0: first column from in-file to plot
+    plot_finish:
+    # type=int|default=0: final column from in-file to plot
+    plot_range:
+    # type=tuple|default=(0, 0): first and last columns from the in-file to plot
+    title:
+    # type=str|default='': plot title
+    legend_file:
+    # type=file|default=<undefined>: legend file
+    labels:
+    # type=traitcompound|default=None: label or list of labels
+    y_min:
+    # type=float|default=0.0: minimum y value
+    y_max:
+    # type=float|default=0.0: maximum y value
+    y_range:
+    # type=tuple|default=(0.0, 0.0): min and max y axis values
+    x_units:
+    # type=int|default=1: scaling units for x-axis (between 1 and length of in file)
+    plot_size:
+    # type=tuple|default=(0, 0): plot image height and width
+    x_precision:
+    # type=int|default=0: precision of x-axis labels
+    sci_notation:
+    # type=bool|default=False: switch on scientific notation
+    out_file:
+    # type=file: image to write
+    # type=file|default=<undefined>: image to write
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-fsl/plot_time_series_callables.py b/example-specs/task/nipype_internal/pydra-fsl/plot_time_series_callables.py
new file mode 100644
index 00000000..a741da77
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/plot_time_series_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in PlotTimeSeries.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/power_spectrum.yaml b/example-specs/task/nipype_internal/pydra-fsl/power_spectrum.yaml
new file mode 100644
index 00000000..a51287c0
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/power_spectrum.yaml
@@ -0,0 +1,92 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.utils.PowerSpectrum' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Use FSL PowerSpectrum command for power spectrum estimation.
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces import fsl
+#     >>> pspec = fsl.PowerSpectrum()
+#     >>> pspec.inputs.in_file = 'functional.nii'
+#     >>> res = pspec.run() # doctest: +SKIP
+# 
+# 
+#     
+task_name: PowerSpectrum
+nipype_name: PowerSpectrum
+nipype_module: nipype.interfaces.fsl.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: input 4D file to estimate the power spectrum
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: path/name of the output 4D power spectrum file
+    # type=file|default=<undefined>: name of output 4D file for power spectrum
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: out_file
+    # type=file: path/name of the output 4D power spectrum file
+    # type=file|default=<undefined>: name of output 4D file for power spectrum
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input 4D file to estimate the power spectrum
+    out_file:
+    # type=file: path/name of the output 4D power spectrum file
+    # type=file|default=<undefined>: name of output 4D file for power spectrum
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-fsl/power_spectrum_callables.py b/example-specs/task/nipype_internal/pydra-fsl/power_spectrum_callables.py
new file mode 100644
index 00000000..99730853
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/power_spectrum_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in PowerSpectrum.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/prelude.yaml b/example-specs/task/nipype_internal/pydra-fsl/prelude.yaml
new file mode 100644
index 00000000..6e4160ed
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/prelude.yaml
@@ -0,0 +1,128 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.preprocess.PRELUDE' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# FSL prelude wrapper for phase unwrapping
+# 
+#     Examples
+#     --------
+# 
+#     Please insert examples for use of this command
+# 
+#     
+task_name: PRELUDE
+nipype_name: PRELUDE
+nipype_module: nipype.interfaces.fsl.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    complex_phase_file: generic/file
+    # type=file|default=<undefined>: complex phase input volume
+    magnitude_file: generic/file
+    # type=file|default=<undefined>: file containing magnitude image
+    phase_file: generic/file
+    # type=file|default=<undefined>: raw phase file
+    mask_file: generic/file
+    # type=file|default=<undefined>: filename of mask input volume
+    savemask_file: generic/file
+    # type=file|default=<undefined>: saving the mask volume
+    rawphase_file: generic/file
+    # type=file|default=<undefined>: saving the raw phase output
+    label_file: generic/file
+    # type=file|default=<undefined>: saving the area labels output
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    unwrapped_phase_file: generic/file
+    # type=file: unwrapped phase file
+    # type=file|default=<undefined>: file containing unwrapepd phase
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    unwrapped_phase_file: unwrapped_phase_file
+    # type=file: unwrapped phase file
+    # type=file|default=<undefined>: file containing unwrapepd phase
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    complex_phase_file:
+    # type=file|default=<undefined>: complex phase input volume
+    magnitude_file:
+    # type=file|default=<undefined>: file containing magnitude image
+    phase_file:
+    # type=file|default=<undefined>: raw phase file
+    unwrapped_phase_file:
+    # type=file: unwrapped phase file
+    # type=file|default=<undefined>: file containing unwrapepd phase
+    num_partitions:
+    # type=int|default=0: number of phase partitions to use
+    labelprocess2d:
+    # type=bool|default=False: does label processing in 2D (slice at a time)
+    process2d:
+    # type=bool|default=False: does all processing in 2D (slice at a time)
+    process3d:
+    # type=bool|default=False: forces all processing to be full 3D
+    threshold:
+    # type=float|default=0.0: intensity threshold for masking
+    mask_file:
+    # type=file|default=<undefined>: filename of mask input volume
+    start:
+    # type=int|default=0: first image number to process (default 0)
+    end:
+    # type=int|default=0: final image number to process (default Inf)
+    savemask_file:
+    # type=file|default=<undefined>: saving the mask volume
+    rawphase_file:
+    # type=file|default=<undefined>: saving the raw phase output
+    label_file:
+    # type=file|default=<undefined>: saving the area labels output
+    removeramps:
+    # type=bool|default=False: remove phase ramps during unwrapping
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-fsl/prelude_callables.py b/example-specs/task/nipype_internal/pydra-fsl/prelude_callables.py
new file mode 100644
index 00000000..af11ab91
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/prelude_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in PRELUDE.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/prepare_fieldmap.yaml b/example-specs/task/nipype_internal/pydra-fsl/prepare_fieldmap.yaml
new file mode 100644
index 00000000..008e00eb
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/prepare_fieldmap.yaml
@@ -0,0 +1,153 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.epi.PrepareFieldmap' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Interface for the fsl_prepare_fieldmap script (FSL 5.0)
+# 
+#     Prepares a fieldmap suitable for FEAT from SIEMENS data - saves output in
+#     rad/s format (e.g. ```fsl_prepare_fieldmap SIEMENS
+#     images_3_gre_field_mapping images_4_gre_field_mapping fmap_rads 2.65```).
+# 
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces.fsl import PrepareFieldmap
+#     >>> prepare = PrepareFieldmap()
+#     >>> prepare.inputs.in_phase = "phase.nii"
+#     >>> prepare.inputs.in_magnitude = "magnitude.nii"
+#     >>> prepare.inputs.output_type = "NIFTI_GZ"
+#     >>> prepare.cmdline # doctest: +ELLIPSIS
+#     'fsl_prepare_fieldmap SIEMENS phase.nii magnitude.nii .../phase_fslprepared.nii.gz 2.460000'
+#     >>> res = prepare.run() # doctest: +SKIP
+# 
+# 
+#     
+task_name: PrepareFieldmap
+nipype_name: PrepareFieldmap
+nipype_module: nipype.interfaces.fsl.epi
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_phase: medimage/nifti1
+    # type=file|default=<undefined>: Phase difference map, in SIEMENS format range from 0-4096 or 0-8192)
+    in_magnitude: medimage/nifti1
+    # type=file|default=<undefined>: Magnitude difference map, brain extracted
+    out_fieldmap: generic/file
+    # type=file: output name for prepared fieldmap
+    # type=file|default=<undefined>: output name for prepared fieldmap
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_fieldmap: generic/file
+    # type=file: output name for prepared fieldmap
+    # type=file|default=<undefined>: output name for prepared fieldmap
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    scanner:
+    # type=string|default='SIEMENS': must be SIEMENS
+    in_phase:
+    # type=file|default=<undefined>: Phase difference map, in SIEMENS format range from 0-4096 or 0-8192)
+    in_magnitude:
+    # type=file|default=<undefined>: Magnitude difference map, brain extracted
+    delta_TE:
+    # type=float|default=2.46: echo time difference of the fieldmap sequence in ms. (usually 2.46ms in Siemens)
+    nocheck:
+    # type=bool|default=False: do not perform sanity checks for image size/range/dimensions
+    out_fieldmap:
+    # type=file: output name for prepared fieldmap
+    # type=file|default=<undefined>: output name for prepared fieldmap
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_phase:
+    # type=file|default=<undefined>: Phase difference map, in SIEMENS format range from 0-4096 or 0-8192)
+    in_magnitude:
+    # type=file|default=<undefined>: Magnitude difference map, brain extracted
+    output_type: '"NIFTI_GZ"'
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: fsl_prepare_fieldmap SIEMENS phase.nii magnitude.nii .../phase_fslprepared.nii.gz 2.460000
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_phase:
+    # type=file|default=<undefined>: Phase difference map, in SIEMENS format range from 0-4096 or 0-8192)
+    in_magnitude:
+    # type=file|default=<undefined>: Magnitude difference map, brain extracted
+    output_type: '"NIFTI_GZ"'
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-fsl/prepare_fieldmap_callables.py b/example-specs/task/nipype_internal/pydra-fsl/prepare_fieldmap_callables.py
new file mode 100644
index 00000000..55273d74
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/prepare_fieldmap_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in PrepareFieldmap.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/prob_track_x.yaml b/example-specs/task/nipype_internal/pydra-fsl/prob_track_x.yaml
new file mode 100644
index 00000000..c1025493
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/prob_track_x.yaml
@@ -0,0 +1,273 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.dti.ProbTrackX' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+#  Use FSL  probtrackx for tractography on bedpostx results
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces import fsl
+#     >>> pbx = fsl.ProbTrackX(samples_base_name='merged', mask='mask.nii',     seed='MASK_average_thal_right.nii', mode='seedmask',     xfm='trans.mat', n_samples=3, n_steps=10, force_dir=True, opd=True,     os2t=True, target_masks = ['targets_MASK1.nii', 'targets_MASK2.nii'],     thsamples='merged_thsamples.nii', fsamples='merged_fsamples.nii',     phsamples='merged_phsamples.nii', out_dir='.')
+#     >>> pbx.cmdline
+#     'probtrackx --forcedir -m mask.nii --mode=seedmask --nsamples=3 --nsteps=10 --opd --os2t --dir=. --samples=merged --seed=MASK_average_thal_right.nii --targetmasks=targets.txt --xfm=trans.mat'
+# 
+#     
+task_name: ProbTrackX
+nipype_name: ProbTrackX
+nipype_module: nipype.interfaces.fsl.dti
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    mask2: generic/file
+    # type=file|default=<undefined>: second bet binary mask (in diffusion space) in twomask_symm mode
+    mesh: generic/file
+    # type=file|default=<undefined>: Freesurfer-type surface descriptor (in ascii format)
+    thsamples: medimage/nifti1+list-of
+    # type=inputmultiobject|default=[]: 
+    phsamples: medimage/nifti1+list-of
+    # type=inputmultiobject|default=[]: 
+    fsamples: medimage/nifti1+list-of
+    # type=inputmultiobject|default=[]: 
+    mask: medimage/nifti1
+    # type=file|default=<undefined>: bet binary mask file in diffusion space
+    target_masks: medimage/nifti1+list-of
+    # type=inputmultiobject|default=[]: list of target masks - required for seeds_to_targets classification
+    waypoints: generic/file
+    # type=file|default=<undefined>: waypoint mask or ascii list of waypoint masks - only keep paths going through ALL the masks
+    seed_ref: generic/file
+    # type=file|default=<undefined>: reference vol to define seed space in simple mode - diffusion space assumed if absent
+    avoid_mp: generic/file
+    # type=file|default=<undefined>: reject pathways passing through locations given by this mask
+    stop_mask: generic/file
+    # type=file|default=<undefined>: stop tracking at locations given by this mask file
+    xfm: datascience/text-matrix
+    # type=file|default=<undefined>: transformation matrix taking seed space to DTI space (either FLIRT matrix or FNIRT warp_field) - default is identity
+    inv_xfm: generic/file
+    # type=file|default=<undefined>: transformation matrix taking DTI space to seed space (compulsory when using a warp_field for seeds_to_dti)
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    log: generic/file
+    # type=file: path/name of a text record of the command that was run
+    way_total: generic/file
+    # type=file: path/name of a text file containing a single number corresponding to the total number of generated tracts that have not been rejected by inclusion/exclusion mask criteria
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    mode: '"seedmask"'
+    # type=enum|default='simple'|allowed['seedmask','simple','two_mask_symm']: options: simple (single seed voxel), seedmask (mask of seed voxels), twomask_symm (two bet binary masks)
+    out_dir: '"."'
+    # type=directory|default=<undefined>: directory to put the final volumes in
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    mode:
+    # type=enum|default='simple'|allowed['seedmask','simple','two_mask_symm']: options: simple (single seed voxel), seedmask (mask of seed voxels), twomask_symm (two bet binary masks)
+    mask2:
+    # type=file|default=<undefined>: second bet binary mask (in diffusion space) in twomask_symm mode
+    mesh:
+    # type=file|default=<undefined>: Freesurfer-type surface descriptor (in ascii format)
+    thsamples:
+    # type=inputmultiobject|default=[]: 
+    phsamples:
+    # type=inputmultiobject|default=[]: 
+    fsamples:
+    # type=inputmultiobject|default=[]: 
+    samples_base_name:
+    # type=str|default='merged': the rootname/base_name for samples files
+    mask:
+    # type=file|default=<undefined>: bet binary mask file in diffusion space
+    seed:
+    # type=traitcompound|default=None: seed volume(s), or voxel(s) or freesurfer label file
+    target_masks:
+    # type=inputmultiobject|default=[]: list of target masks - required for seeds_to_targets classification
+    waypoints:
+    # type=file|default=<undefined>: waypoint mask or ascii list of waypoint masks - only keep paths going through ALL the masks
+    network:
+    # type=bool|default=False: activate network mode - only keep paths going through at least one seed mask (required if multiple seed masks)
+    seed_ref:
+    # type=file|default=<undefined>: reference vol to define seed space in simple mode - diffusion space assumed if absent
+    out_dir:
+    # type=directory|default=<undefined>: directory to put the final volumes in
+    force_dir:
+    # type=bool|default=True: use the actual directory name given - i.e. do not add + to make a new directory
+    opd:
+    # type=bool|default=True: outputs path distributions
+    correct_path_distribution:
+    # type=bool|default=False: correct path distribution for the length of the pathways
+    os2t:
+    # type=bool|default=False: Outputs seeds to targets
+    avoid_mp:
+    # type=file|default=<undefined>: reject pathways passing through locations given by this mask
+    stop_mask:
+    # type=file|default=<undefined>: stop tracking at locations given by this mask file
+    xfm:
+    # type=file|default=<undefined>: transformation matrix taking seed space to DTI space (either FLIRT matrix or FNIRT warp_field) - default is identity
+    inv_xfm:
+    # type=file|default=<undefined>: transformation matrix taking DTI space to seed space (compulsory when using a warp_field for seeds_to_dti)
+    n_samples:
+    # type=int|default=5000: number of samples - default=5000
+    n_steps:
+    # type=int|default=0: number of steps per sample - default=2000
+    dist_thresh:
+    # type=float|default=0.0: discards samples shorter than this threshold (in mm - default=0)
+    c_thresh:
+    # type=float|default=0.0: curvature threshold - default=0.2
+    sample_random_points:
+    # type=float|default=0.0: sample random points within seed voxels
+    step_length:
+    # type=float|default=0.0: step_length in mm - default=0.5
+    loop_check:
+    # type=bool|default=False: perform loop_checks on paths - slower, but allows lower curvature threshold
+    use_anisotropy:
+    # type=bool|default=False: use anisotropy to constrain tracking
+    rand_fib:
+    # type=enum|default=0|allowed[0,1,2,3]: options: 0 - default, 1 - to randomly sample initial fibres (with f > fibthresh), 2 - to sample in proportion fibres (with f>fibthresh) to f, 3 - to sample ALL populations at random (even if f<fibthresh)
+    fibst:
+    # type=int|default=0: force a starting fibre for tracking - default=1, i.e. first fibre orientation. Only works if randfib==0
+    mod_euler:
+    # type=bool|default=False: use modified euler streamlining
+    random_seed:
+    # type=int|default=0: random seed
+    s2tastext:
+    # type=bool|default=False: output seed-to-target counts as a text file (useful when seeding from a mesh)
+    verbose:
+    # type=enum|default=0|allowed[0,1,2]: Verbose level, [0-2]. Level 2 is required to output particle files.
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    samples_base_name: '"merged"'
+    # type=str|default='merged': the rootname/base_name for samples files
+    mask:
+    # type=file|default=<undefined>: bet binary mask file in diffusion space
+    seed: '"MASK_average_thal_right.nii"'
+    # type=traitcompound|default=None: seed volume(s), or voxel(s) or freesurfer label file
+    mode: '"seedmask"'
+    # type=enum|default='simple'|allowed['seedmask','simple','two_mask_symm']: options: simple (single seed voxel), seedmask (mask of seed voxels), twomask_symm (two bet binary masks)
+    xfm:
+    # type=file|default=<undefined>: transformation matrix taking seed space to DTI space (either FLIRT matrix or FNIRT warp_field) - default is identity
+    n_samples: '3'
+    # type=int|default=5000: number of samples - default=5000
+    n_steps: '10'
+    # type=int|default=0: number of steps per sample - default=2000
+    force_dir: 'True'
+    # type=bool|default=True: use the actual directory name given - i.e. do not add + to make a new directory
+    opd: 'True'
+    # type=bool|default=True: outputs path distributions
+    os2t: 'True'
+    # type=bool|default=False: Outputs seeds to targets
+    target_masks:
+    # type=inputmultiobject|default=[]: list of target masks - required for seeds_to_targets classification
+    thsamples:
+    # type=inputmultiobject|default=[]: 
+    fsamples:
+    # type=inputmultiobject|default=[]: 
+    phsamples:
+    # type=inputmultiobject|default=[]: 
+    out_dir: '"."'
+    # type=directory|default=<undefined>: directory to put the final volumes in
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: probtrackx --forcedir -m mask.nii --mode=seedmask --nsamples=3 --nsteps=10 --opd --os2t --dir=. --samples=merged --seed=MASK_average_thal_right.nii --targetmasks=targets.txt --xfm=trans.mat
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    samples_base_name: '"merged"'
+    # type=str|default='merged': the rootname/base_name for samples files
+    mask:
+    # type=file|default=<undefined>: bet binary mask file in diffusion space
+    seed: '"MASK_average_thal_right.nii"'
+    # type=traitcompound|default=None: seed volume(s), or voxel(s) or freesurfer label file
+    mode: '"seedmask"'
+    # type=enum|default='simple'|allowed['seedmask','simple','two_mask_symm']: options: simple (single seed voxel), seedmask (mask of seed voxels), twomask_symm (two bet binary masks)
+    xfm:
+    # type=file|default=<undefined>: transformation matrix taking seed space to DTI space (either FLIRT matrix or FNIRT warp_field) - default is identity
+    n_samples: '3'
+    # type=int|default=5000: number of samples - default=5000
+    n_steps: '10'
+    # type=int|default=0: number of steps per sample - default=2000
+    force_dir: 'True'
+    # type=bool|default=True: use the actual directory name given - i.e. do not add + to make a new directory
+    opd: 'True'
+    # type=bool|default=True: outputs path distributions
+    os2t: 'True'
+    # type=bool|default=False: Outputs seeds to targets
+    target_masks:
+    # type=inputmultiobject|default=[]: list of target masks - required for seeds_to_targets classification
+    thsamples:
+    # type=inputmultiobject|default=[]: 
+    fsamples:
+    # type=inputmultiobject|default=[]: 
+    phsamples:
+    # type=inputmultiobject|default=[]: 
+    out_dir: '"."'
+    # type=directory|default=<undefined>: directory to put the final volumes in
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-fsl/prob_track_x2.yaml b/example-specs/task/nipype_internal/pydra-fsl/prob_track_x2.yaml
new file mode 100644
index 00000000..c2e66368
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/prob_track_x2.yaml
@@ -0,0 +1,296 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.dti.ProbTrackX2' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Use FSL  probtrackx2 for tractography on bedpostx results
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces import fsl
+#     >>> pbx2 = fsl.ProbTrackX2()
+#     >>> pbx2.inputs.seed = 'seed_source.nii.gz'
+#     >>> pbx2.inputs.thsamples = 'merged_th1samples.nii.gz'
+#     >>> pbx2.inputs.fsamples = 'merged_f1samples.nii.gz'
+#     >>> pbx2.inputs.phsamples = 'merged_ph1samples.nii.gz'
+#     >>> pbx2.inputs.mask = 'nodif_brain_mask.nii.gz'
+#     >>> pbx2.inputs.out_dir = '.'
+#     >>> pbx2.inputs.n_samples = 3
+#     >>> pbx2.inputs.n_steps = 10
+#     >>> pbx2.cmdline
+#     'probtrackx2 --forcedir -m nodif_brain_mask.nii.gz --nsamples=3 --nsteps=10 --opd --dir=. --samples=merged --seed=seed_source.nii.gz'
+#     
+task_name: ProbTrackX2
+nipype_name: ProbTrackX2
+nipype_module: nipype.interfaces.fsl.dti
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    fopd: generic/file
+    # type=file|default=<undefined>: Other mask for binning tract distribution
+    target2: generic/file
+    # type=file|default=<undefined>: Low resolution binary brain mask for storing connectivity distribution in matrix2 mode
+    target3: generic/file
+    # type=file|default=<undefined>: Mask used for NxN connectivity matrix (or Nxn if lrtarget3 is set)
+    lrtarget3: generic/file
+    # type=file|default=<undefined>: Column-space mask used for Nxn connectivity matrix
+    colmask4: generic/file
+    # type=file|default=<undefined>: Mask for columns of matrix4 (default=seed mask)
+    target4: generic/file
+    # type=file|default=<undefined>: Brain mask in DTI space
+    thsamples: medimage/nifti-gz+list-of
+    # type=inputmultiobject|default=[]: 
+    phsamples: medimage/nifti-gz+list-of
+    # type=inputmultiobject|default=[]: 
+    fsamples: medimage/nifti-gz+list-of
+    # type=inputmultiobject|default=[]: 
+    mask: medimage/nifti-gz
+    # type=file|default=<undefined>: bet binary mask file in diffusion space
+    target_masks: generic/file+list-of
+    # type=inputmultiobject|default=[]: list of target masks - required for seeds_to_targets classification
+    waypoints: generic/file
+    # type=file|default=<undefined>: waypoint mask or ascii list of waypoint masks - only keep paths going through ALL the masks
+    seed_ref: generic/file
+    # type=file|default=<undefined>: reference vol to define seed space in simple mode - diffusion space assumed if absent
+    avoid_mp: generic/file
+    # type=file|default=<undefined>: reject pathways passing through locations given by this mask
+    stop_mask: generic/file
+    # type=file|default=<undefined>: stop tracking at locations given by this mask file
+    xfm: generic/file
+    # type=file|default=<undefined>: transformation matrix taking seed space to DTI space (either FLIRT matrix or FNIRT warp_field) - default is identity
+    inv_xfm: generic/file
+    # type=file|default=<undefined>: transformation matrix taking DTI space to seed space (compulsory when using a warp_field for seeds_to_dti)
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    network_matrix: generic/file
+    # type=file: the network matrix generated by --omatrix1 option
+    matrix1_dot: generic/file
+    # type=file: Output matrix1.dot - SeedToSeed Connectivity
+    lookup_tractspace: generic/file
+    # type=file: lookup_tractspace generated by --omatrix2 option
+    matrix2_dot: generic/file
+    # type=file: Output matrix2.dot - SeedToLowResMask
+    matrix3_dot: generic/file
+    # type=file: Output matrix3 - NxN connectivity matrix
+    log: generic/file
+    # type=file: path/name of a text record of the command that was run
+    way_total: generic/file
+    # type=file: path/name of a text file containing a single number corresponding to the total number of generated tracts that have not been rejected by inclusion/exclusion mask criteria
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_dir: '"."'
+    # type=directory|default=<undefined>: directory to put the final volumes in
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    simple:
+    # type=bool|default=False: rack from a list of voxels (seed must be a ASCII list of coordinates)
+    fopd:
+    # type=file|default=<undefined>: Other mask for binning tract distribution
+    waycond:
+    # type=enum|default='OR'|allowed['AND','OR']: Waypoint condition. Either "AND" (default) or "OR"
+    wayorder:
+    # type=bool|default=False: Reject streamlines that do not hit waypoints in given order. Only valid if waycond=AND
+    onewaycondition:
+    # type=bool|default=False: Apply waypoint conditions to each half tract separately
+    omatrix1:
+    # type=bool|default=False: Output matrix1 - SeedToSeed Connectivity
+    distthresh1:
+    # type=float|default=0.0: Discards samples (in matrix1) shorter than this threshold (in mm - default=0)
+    omatrix2:
+    # type=bool|default=False: Output matrix2 - SeedToLowResMask
+    target2:
+    # type=file|default=<undefined>: Low resolution binary brain mask for storing connectivity distribution in matrix2 mode
+    omatrix3:
+    # type=bool|default=False: Output matrix3 (NxN connectivity matrix)
+    target3:
+    # type=file|default=<undefined>: Mask used for NxN connectivity matrix (or Nxn if lrtarget3 is set)
+    lrtarget3:
+    # type=file|default=<undefined>: Column-space mask used for Nxn connectivity matrix
+    distthresh3:
+    # type=float|default=0.0: Discards samples (in matrix3) shorter than this threshold (in mm - default=0)
+    omatrix4:
+    # type=bool|default=False: Output matrix4 - DtiMaskToSeed (special Oxford Sparse Format)
+    colmask4:
+    # type=file|default=<undefined>: Mask for columns of matrix4 (default=seed mask)
+    target4:
+    # type=file|default=<undefined>: Brain mask in DTI space
+    meshspace:
+    # type=enum|default='caret'|allowed['caret','first','freesurfer','vox']: Mesh reference space - either "caret" (default) or "freesurfer" or "first" or "vox"
+    thsamples:
+    # type=inputmultiobject|default=[]: 
+    phsamples:
+    # type=inputmultiobject|default=[]: 
+    fsamples:
+    # type=inputmultiobject|default=[]: 
+    samples_base_name:
+    # type=str|default='merged': the rootname/base_name for samples files
+    mask:
+    # type=file|default=<undefined>: bet binary mask file in diffusion space
+    seed:
+    # type=traitcompound|default=None: seed volume(s), or voxel(s) or freesurfer label file
+    target_masks:
+    # type=inputmultiobject|default=[]: list of target masks - required for seeds_to_targets classification
+    waypoints:
+    # type=file|default=<undefined>: waypoint mask or ascii list of waypoint masks - only keep paths going through ALL the masks
+    network:
+    # type=bool|default=False: activate network mode - only keep paths going through at least one seed mask (required if multiple seed masks)
+    seed_ref:
+    # type=file|default=<undefined>: reference vol to define seed space in simple mode - diffusion space assumed if absent
+    out_dir:
+    # type=directory|default=<undefined>: directory to put the final volumes in
+    force_dir:
+    # type=bool|default=True: use the actual directory name given - i.e. do not add + to make a new directory
+    opd:
+    # type=bool|default=True: outputs path distributions
+    correct_path_distribution:
+    # type=bool|default=False: correct path distribution for the length of the pathways
+    os2t:
+    # type=bool|default=False: Outputs seeds to targets
+    avoid_mp:
+    # type=file|default=<undefined>: reject pathways passing through locations given by this mask
+    stop_mask:
+    # type=file|default=<undefined>: stop tracking at locations given by this mask file
+    xfm:
+    # type=file|default=<undefined>: transformation matrix taking seed space to DTI space (either FLIRT matrix or FNIRT warp_field) - default is identity
+    inv_xfm:
+    # type=file|default=<undefined>: transformation matrix taking DTI space to seed space (compulsory when using a warp_field for seeds_to_dti)
+    n_samples:
+    # type=int|default=5000: number of samples - default=5000
+    n_steps:
+    # type=int|default=0: number of steps per sample - default=2000
+    dist_thresh:
+    # type=float|default=0.0: discards samples shorter than this threshold (in mm - default=0)
+    c_thresh:
+    # type=float|default=0.0: curvature threshold - default=0.2
+    sample_random_points:
+    # type=float|default=0.0: sample random points within seed voxels
+    step_length:
+    # type=float|default=0.0: step_length in mm - default=0.5
+    loop_check:
+    # type=bool|default=False: perform loop_checks on paths - slower, but allows lower curvature threshold
+    use_anisotropy:
+    # type=bool|default=False: use anisotropy to constrain tracking
+    rand_fib:
+    # type=enum|default=0|allowed[0,1,2,3]: options: 0 - default, 1 - to randomly sample initial fibres (with f > fibthresh), 2 - to sample in proportion fibres (with f>fibthresh) to f, 3 - to sample ALL populations at random (even if f<fibthresh)
+    fibst:
+    # type=int|default=0: force a starting fibre for tracking - default=1, i.e. first fibre orientation. Only works if randfib==0
+    mod_euler:
+    # type=bool|default=False: use modified euler streamlining
+    random_seed:
+    # type=int|default=0: random seed
+    s2tastext:
+    # type=bool|default=False: output seed-to-target counts as a text file (useful when seeding from a mesh)
+    verbose:
+    # type=enum|default=0|allowed[0,1,2]: Verbose level, [0-2]. Level 2 is required to output particle files.
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    seed: '"seed_source.nii.gz"'
+    # type=traitcompound|default=None: seed volume(s), or voxel(s) or freesurfer label file
+    thsamples:
+    # type=inputmultiobject|default=[]: 
+    fsamples:
+    # type=inputmultiobject|default=[]: 
+    phsamples:
+    # type=inputmultiobject|default=[]: 
+    mask:
+    # type=file|default=<undefined>: bet binary mask file in diffusion space
+    out_dir: '"."'
+    # type=directory|default=<undefined>: directory to put the final volumes in
+    n_samples: '3'
+    # type=int|default=5000: number of samples - default=5000
+    n_steps: '10'
+    # type=int|default=0: number of steps per sample - default=2000
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: probtrackx2 --forcedir -m nodif_brain_mask.nii.gz --nsamples=3 --nsteps=10 --opd --dir=. --samples=merged --seed=seed_source.nii.gz
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    seed: '"seed_source.nii.gz"'
+    # type=traitcompound|default=None: seed volume(s), or voxel(s) or freesurfer label file
+    thsamples:
+    # type=inputmultiobject|default=[]: 
+    fsamples:
+    # type=inputmultiobject|default=[]: 
+    phsamples:
+    # type=inputmultiobject|default=[]: 
+    mask:
+    # type=file|default=<undefined>: bet binary mask file in diffusion space
+    out_dir: '"."'
+    # type=directory|default=<undefined>: directory to put the final volumes in
+    n_samples: '3'
+    # type=int|default=5000: number of samples - default=5000
+    n_steps: '10'
+    # type=int|default=0: number of steps per sample - default=2000
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-fsl/prob_track_x2_callables.py b/example-specs/task/nipype_internal/pydra-fsl/prob_track_x2_callables.py
new file mode 100644
index 00000000..bf9e220b
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/prob_track_x2_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in ProbTrackX2.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/prob_track_x_callables.py b/example-specs/task/nipype_internal/pydra-fsl/prob_track_x_callables.py
new file mode 100644
index 00000000..9bac8685
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/prob_track_x_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in ProbTrackX.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/proj_thresh.yaml b/example-specs/task/nipype_internal/pydra-fsl/proj_thresh.yaml
new file mode 100644
index 00000000..7f0fea03
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/proj_thresh.yaml
@@ -0,0 +1,124 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.dti.ProjThresh' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Use FSL proj_thresh for thresholding some outputs of probtrack
+#     For complete details, see the FDT Documentation
+#     <http://www.fmrib.ox.ac.uk/fsl/fdt/fdt_thresh.html>
+# 
+#     Example
+#     -------
+# 
+#     >>> from nipype.interfaces import fsl
+#     >>> ldir = ['seeds_to_M1.nii', 'seeds_to_M2.nii']
+#     >>> pThresh = fsl.ProjThresh(in_files=ldir, threshold=3)
+#     >>> pThresh.cmdline
+#     'proj_thresh seeds_to_M1.nii seeds_to_M2.nii 3'
+# 
+#     
+task_name: ProjThresh
+nipype_name: ProjThresh
+nipype_module: nipype.interfaces.fsl.dti
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_files: generic/file+list-of
+    # type=list|default=[]: a list of input volumes
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_files:
+    # type=list|default=[]: a list of input volumes
+    threshold:
+    # type=int|default=0: threshold indicating minimum number of seed voxels entering this mask region
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_files:
+    # type=list|default=[]: a list of input volumes
+    threshold: '3'
+    # type=int|default=0: threshold indicating minimum number of seed voxels entering this mask region
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: proj_thresh seeds_to_M1.nii seeds_to_M2.nii 3
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_files:
+    # type=list|default=[]: a list of input volumes
+    threshold: '3'
+    # type=int|default=0: threshold indicating minimum number of seed voxels entering this mask region
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-fsl/proj_thresh_callables.py b/example-specs/task/nipype_internal/pydra-fsl/proj_thresh_callables.py
new file mode 100644
index 00000000..30899258
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/proj_thresh_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in ProjThresh.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/randomise.yaml b/example-specs/task/nipype_internal/pydra-fsl/randomise.yaml
new file mode 100644
index 00000000..f4bc08b3
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/randomise.yaml
@@ -0,0 +1,191 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.model.Randomise' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# FSL Randomise: feeds the 4D projected FA data into GLM
+#     modelling and thresholding
+#     in order to find voxels which correlate with your model
+# 
+#     Example
+#     -------
+#     >>> import nipype.interfaces.fsl as fsl
+#     >>> rand = fsl.Randomise(in_file='allFA.nii', mask = 'mask.nii', tcon='design.con', design_mat='design.mat')
+#     >>> rand.cmdline
+#     'randomise -i allFA.nii -o "randomise" -d design.mat -t design.con -m mask.nii'
+# 
+#     
+task_name: Randomise
+nipype_name: Randomise
+nipype_module: nipype.interfaces.fsl.model
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: 4D input file
+    design_mat: datascience/text-matrix
+    # type=file|default=<undefined>: design matrix file
+    tcon: medimage-fsl/con
+    # type=file|default=<undefined>: t contrasts file
+    fcon: generic/file
+    # type=file|default=<undefined>: f contrasts file
+    mask: medimage/nifti1
+    # type=file|default=<undefined>: mask image
+    x_block_labels: generic/file
+    # type=file|default=<undefined>: exchangeability block labels file
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: 4D input file
+    base_name:
+    # type=str|default='randomise': the rootname that all generated files will have
+    design_mat:
+    # type=file|default=<undefined>: design matrix file
+    tcon:
+    # type=file|default=<undefined>: t contrasts file
+    fcon:
+    # type=file|default=<undefined>: f contrasts file
+    mask:
+    # type=file|default=<undefined>: mask image
+    x_block_labels:
+    # type=file|default=<undefined>: exchangeability block labels file
+    demean:
+    # type=bool|default=False: demean data temporally before model fitting
+    one_sample_group_mean:
+    # type=bool|default=False: perform 1-sample group-mean test instead of generic permutation test
+    show_total_perms:
+    # type=bool|default=False: print out how many unique permutations would be generated and exit
+    show_info_parallel_mode:
+    # type=bool|default=False: print out information required for parallel mode and exit
+    vox_p_values:
+    # type=bool|default=False: output voxelwise (corrected and uncorrected) p-value images
+    tfce:
+    # type=bool|default=False: carry out Threshold-Free Cluster Enhancement
+    tfce2D:
+    # type=bool|default=False: carry out Threshold-Free Cluster Enhancement with 2D optimisation
+    f_only:
+    # type=bool|default=False: calculate f-statistics only
+    raw_stats_imgs:
+    # type=bool|default=False: output raw ( unpermuted ) statistic images
+    p_vec_n_dist_files:
+    # type=bool|default=False: output permutation vector and null distribution text files
+    num_perm:
+    # type=int|default=0: number of permutations (default 5000, set to 0 for exhaustive)
+    seed:
+    # type=int|default=0: specific integer seed for random number generator
+    var_smooth:
+    # type=int|default=0: use variance smoothing (std is in mm)
+    c_thresh:
+    # type=float|default=0.0: carry out cluster-based thresholding
+    cm_thresh:
+    # type=float|default=0.0: carry out cluster-mass-based thresholding
+    f_c_thresh:
+    # type=float|default=0.0: carry out f cluster thresholding
+    f_cm_thresh:
+    # type=float|default=0.0: carry out f cluster-mass thresholding
+    tfce_H:
+    # type=float|default=0.0: TFCE height parameter (default=2)
+    tfce_E:
+    # type=float|default=0.0: TFCE extent parameter (default=0.5)
+    tfce_C:
+    # type=float|default=0.0: TFCE connectivity (6 or 26; default=6)
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: 4D input file
+    mask:
+    # type=file|default=<undefined>: mask image
+    tcon:
+    # type=file|default=<undefined>: t contrasts file
+    design_mat:
+    # type=file|default=<undefined>: design matrix file
+  imports: &id001
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  - module: nipype.interfaces.fsl as fsl
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: randomise -i allFA.nii -o "randomise" -d design.mat -t design.con -m mask.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: 4D input file
+    mask:
+    # type=file|default=<undefined>: mask image
+    tcon:
+    # type=file|default=<undefined>: t contrasts file
+    design_mat:
+    # type=file|default=<undefined>: design matrix file
+  imports: *id001
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-fsl/randomise_callables.py b/example-specs/task/nipype_internal/pydra-fsl/randomise_callables.py
new file mode 100644
index 00000000..3f63d057
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/randomise_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Randomise.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/reorient_2_std.yaml b/example-specs/task/nipype_internal/pydra-fsl/reorient_2_std.yaml
new file mode 100644
index 00000000..f8f0e820
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/reorient_2_std.yaml
@@ -0,0 +1,93 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.utils.Reorient2Std' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# fslreorient2std is a tool for reorienting the image to match the
+#     approximate orientation of the standard template images (MNI152).
+# 
+# 
+#     Examples
+#     --------
+# 
+#     >>> reorient = Reorient2Std()
+#     >>> reorient.inputs.in_file = "functional.nii"
+#     >>> res = reorient.run() # doctest: +SKIP
+# 
+# 
+#     
+task_name: Reorient2Std
+nipype_name: Reorient2Std
+nipype_module: nipype.interfaces.fsl.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: 
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: 
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: out_file
+    # type=file: 
+    # type=file|default=<undefined>: 
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: 
+    out_file:
+    # type=file: 
+    # type=file|default=<undefined>: 
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-fsl/reorient_2_std_callables.py b/example-specs/task/nipype_internal/pydra-fsl/reorient_2_std_callables.py
new file mode 100644
index 00000000..7e424ba6
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/reorient_2_std_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Reorient2Std.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/robust_fov.yaml b/example-specs/task/nipype_internal/pydra-fsl/robust_fov.yaml
new file mode 100644
index 00000000..72f6ee3e
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/robust_fov.yaml
@@ -0,0 +1,96 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.utils.RobustFOV' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Automatically crops an image removing lower head and neck.
+# 
+#     Interface is stable 5.0.0 to 5.0.9, but default brainsize changed from
+#     150mm to 170mm.
+#     
+task_name: RobustFOV
+nipype_name: RobustFOV
+nipype_module: nipype.interfaces.fsl.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: input filename
+    out_roi: generic/file
+    # type=file: ROI volume output name
+    # type=file|default=<undefined>: ROI volume output name
+    out_transform: generic/file
+    # type=file: Transformation matrix in_file to out_roi output name
+    # type=file|default=<undefined>: Transformation matrix in_file to out_roi output name
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_roi: generic/file
+    # type=file: ROI volume output name
+    # type=file|default=<undefined>: ROI volume output name
+    out_transform: generic/file
+    # type=file: Transformation matrix in_file to out_roi output name
+    # type=file|default=<undefined>: Transformation matrix in_file to out_roi output name
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input filename
+    out_roi:
+    # type=file: ROI volume output name
+    # type=file|default=<undefined>: ROI volume output name
+    brainsize:
+    # type=int|default=0: size of brain in z-dimension (default 170mm/150mm)
+    out_transform:
+    # type=file: Transformation matrix in_file to out_roi output name
+    # type=file|default=<undefined>: Transformation matrix in_file to out_roi output name
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-fsl/robust_fov_callables.py b/example-specs/task/nipype_internal/pydra-fsl/robust_fov_callables.py
new file mode 100644
index 00000000..4b540c7e
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/robust_fov_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in RobustFOV.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/sig_loss.yaml b/example-specs/task/nipype_internal/pydra-fsl/sig_loss.yaml
new file mode 100644
index 00000000..509b6b29
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/sig_loss.yaml
@@ -0,0 +1,100 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.utils.SigLoss' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Estimates signal loss from a field map (in rad/s)
+# 
+#     Examples
+#     --------
+# 
+#     >>> sigloss = SigLoss()
+#     >>> sigloss.inputs.in_file = "phase.nii"
+#     >>> sigloss.inputs.echo_time = 0.03
+#     >>> res = sigloss.run() # doctest: +SKIP
+# 
+# 
+#     
+task_name: SigLoss
+nipype_name: SigLoss
+nipype_module: nipype.interfaces.fsl.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: b0 fieldmap file
+    mask_file: generic/file
+    # type=file|default=<undefined>: brain mask file
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: signal loss estimate file
+    # type=file|default=<undefined>: output signal loss estimate file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: out_file
+    # type=file: signal loss estimate file
+    # type=file|default=<undefined>: output signal loss estimate file
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: b0 fieldmap file
+    out_file:
+    # type=file: signal loss estimate file
+    # type=file|default=<undefined>: output signal loss estimate file
+    mask_file:
+    # type=file|default=<undefined>: brain mask file
+    echo_time:
+    # type=float|default=0.0: echo time in seconds
+    slice_direction:
+    # type=enum|default='x'|allowed['x','y','z']: slicing direction
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-fsl/sig_loss_callables.py b/example-specs/task/nipype_internal/pydra-fsl/sig_loss_callables.py
new file mode 100644
index 00000000..05400d7b
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/sig_loss_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in SigLoss.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/slice.yaml b/example-specs/task/nipype_internal/pydra-fsl/slice.yaml
new file mode 100644
index 00000000..b4dcfc94
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/slice.yaml
@@ -0,0 +1,125 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.utils.Slice' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Use fslslice to split a 3D file into lots of 2D files (along z-axis).
+# 
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces.fsl import Slice
+#     >>> slice = Slice()
+#     >>> slice.inputs.in_file = 'functional.nii'
+#     >>> slice.inputs.out_base_name = 'sl'
+#     >>> slice.cmdline
+#     'fslslice functional.nii sl'
+# 
+# 
+#     
+task_name: Slice
+nipype_name: Slice
+nipype_module: nipype.interfaces.fsl.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: input filename
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input filename
+    out_base_name:
+    # type=str|default='': outputs prefix
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input filename
+    out_base_name: '"sl"'
+    # type=str|default='': outputs prefix
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: fslslice functional.nii sl
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: input filename
+    out_base_name: '"sl"'
+    # type=str|default='': outputs prefix
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-fsl/slice_callables.py b/example-specs/task/nipype_internal/pydra-fsl/slice_callables.py
new file mode 100644
index 00000000..d53846ee
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/slice_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Slice.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/slice_timer.yaml b/example-specs/task/nipype_internal/pydra-fsl/slice_timer.yaml
new file mode 100644
index 00000000..c45cd37b
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/slice_timer.yaml
@@ -0,0 +1,107 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.preprocess.SliceTimer' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# FSL slicetimer wrapper to perform slice timing correction
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import fsl
+#     >>> from nipype.testing import example_data
+#     >>> st = fsl.SliceTimer()
+#     >>> st.inputs.in_file = example_data('functional.nii')
+#     >>> st.inputs.interleaved = True
+#     >>> result = st.run() #doctest: +SKIP
+# 
+#     
+task_name: SliceTimer
+nipype_name: SliceTimer
+nipype_module: nipype.interfaces.fsl.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: filename of input timeseries
+    custom_timings: generic/file
+    # type=file|default=<undefined>: slice timings, in fractions of TR, range 0:1 (default is 0.5 = no shift)
+    custom_order: generic/file
+    # type=file|default=<undefined>: filename of single-column custom interleave order file (first slice is referred to as 1 not 0)
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    slice_time_corrected_file: generic/file
+    # type=file: slice time corrected file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: out_file
+    # type=file|default=<undefined>: filename of output timeseries
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: filename of input timeseries
+    out_file:
+    # type=file|default=<undefined>: filename of output timeseries
+    index_dir:
+    # type=bool|default=False: slice indexing from top to bottom
+    time_repetition:
+    # type=float|default=0.0: Specify TR of data - default is 3s
+    slice_direction:
+    # type=enum|default=1|allowed[1,2,3]: direction of slice acquisition (x=1, y=2, z=3) - default is z
+    interleaved:
+    # type=bool|default=False: use interleaved acquisition
+    custom_timings:
+    # type=file|default=<undefined>: slice timings, in fractions of TR, range 0:1 (default is 0.5 = no shift)
+    global_shift:
+    # type=float|default=0.0: shift in fraction of TR, range 0:1 (default is 0.5 = no shift)
+    custom_order:
+    # type=file|default=<undefined>: filename of single-column custom interleave order file (first slice is referred to as 1 not 0)
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-fsl/slice_timer_callables.py b/example-specs/task/nipype_internal/pydra-fsl/slice_timer_callables.py
new file mode 100644
index 00000000..ecae1562
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/slice_timer_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in SliceTimer.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/slicer.yaml b/example-specs/task/nipype_internal/pydra-fsl/slicer.yaml
new file mode 100644
index 00000000..e60a1317
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/slicer.yaml
@@ -0,0 +1,130 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.utils.Slicer' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Use FSL's slicer command to output a png image from a volume.
+# 
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces import fsl
+#     >>> from nipype.testing import example_data
+#     >>> slice = fsl.Slicer()
+#     >>> slice.inputs.in_file = example_data('functional.nii')
+#     >>> slice.inputs.all_axial = True
+#     >>> slice.inputs.image_width = 750
+#     >>> res = slice.run() #doctest: +SKIP
+# 
+# 
+#     
+task_name: Slicer
+nipype_name: Slicer
+nipype_module: nipype.interfaces.fsl.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: input volume
+    image_edges: generic/file
+    # type=file|default=<undefined>: volume to display edge overlay for (useful for checking registration
+    colour_map: generic/file
+    # type=file|default=<undefined>: use different colour map from that stored in nifti header
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: picture to write
+    # type=file|default=<undefined>: picture to write
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: out_file
+    # type=file: picture to write
+    # type=file|default=<undefined>: picture to write
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input volume
+    image_edges:
+    # type=file|default=<undefined>: volume to display edge overlay for (useful for checking registration
+    label_slices:
+    # type=bool|default=True: display slice number
+    colour_map:
+    # type=file|default=<undefined>: use different colour map from that stored in nifti header
+    intensity_range:
+    # type=tuple|default=(0.0, 0.0): min and max intensities to display
+    threshold_edges:
+    # type=float|default=0.0: use threshold for edges
+    dither_edges:
+    # type=bool|default=False: produce semi-transparent (dithered) edges
+    nearest_neighbour:
+    # type=bool|default=False: use nearest neighbor interpolation for output
+    show_orientation:
+    # type=bool|default=True: label left-right orientation
+    single_slice:
+    # type=enum|default='x'|allowed['x','y','z']: output picture of single slice in the x, y, or z plane
+    slice_number:
+    # type=int|default=0: slice number to save in picture
+    middle_slices:
+    # type=bool|default=False: output picture of mid-sagittal, axial, and coronal slices
+    all_axial:
+    # type=bool|default=False: output all axial slices into one picture
+    sample_axial:
+    # type=int|default=0: output every n axial slices into one picture
+    image_width:
+    # type=int|default=0: max picture width
+    out_file:
+    # type=file: picture to write
+    # type=file|default=<undefined>: picture to write
+    scaling:
+    # type=float|default=0.0: image scale
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-fsl/slicer_callables.py b/example-specs/task/nipype_internal/pydra-fsl/slicer_callables.py
new file mode 100644
index 00000000..88b43163
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/slicer_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Slicer.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/smm.yaml b/example-specs/task/nipype_internal/pydra-fsl/smm.yaml
new file mode 100644
index 00000000..0b723345
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/smm.yaml
@@ -0,0 +1,88 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.model.SMM' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Spatial Mixture Modelling. For more detail on the spatial mixture modelling
+#     see Mixture Models with Adaptive Spatial Regularisation for Segmentation
+#     with an Application to FMRI Data; Woolrich, M., Behrens, T., Beckmann, C.,
+#     and Smith, S.; IEEE Trans. Medical Imaging, 24(1):1-11, 2005.
+#     
+task_name: SMM
+nipype_name: SMM
+nipype_module: nipype.interfaces.fsl.model
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    spatial_data_file: generic/file
+    # type=file|default=<undefined>: statistics spatial map
+    mask: generic/file
+    # type=file|default=<undefined>: mask file
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+   _p_map: generic/file
+    activation_p_map: generic/file
+    # type=file: 
+    deactivation_p_map: generic/file
+    # type=file: 
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    spatial_data_file:
+    # type=file|default=<undefined>: statistics spatial map
+    mask:
+    # type=file|default=<undefined>: mask file
+    no_deactivation_class:
+    # type=bool|default=False: enforces no deactivation class
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-fsl/smm_callables.py b/example-specs/task/nipype_internal/pydra-fsl/smm_callables.py
new file mode 100644
index 00000000..a6c27295
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/smm_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in SMM.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/smooth.yaml b/example-specs/task/nipype_internal/pydra-fsl/smooth.yaml
new file mode 100644
index 00000000..3e389292
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/smooth.yaml
@@ -0,0 +1,239 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.utils.Smooth' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Use fslmaths to smooth the image
+# 
+#     Examples
+#     --------
+# 
+#     Setting the kernel width using sigma:
+# 
+#     >>> sm = Smooth()
+#     >>> sm.inputs.output_type = 'NIFTI_GZ'
+#     >>> sm.inputs.in_file = 'functional2.nii'
+#     >>> sm.inputs.sigma = 8.0
+#     >>> sm.cmdline # doctest: +ELLIPSIS
+#     'fslmaths functional2.nii -kernel gauss 8.000 -fmean functional2_smooth.nii.gz'
+# 
+#     Setting the kernel width using fwhm:
+# 
+#     >>> sm = Smooth()
+#     >>> sm.inputs.output_type = 'NIFTI_GZ'
+#     >>> sm.inputs.in_file = 'functional2.nii'
+#     >>> sm.inputs.fwhm = 8.0
+#     >>> sm.cmdline # doctest: +ELLIPSIS
+#     'fslmaths functional2.nii -kernel gauss 3.397 -fmean functional2_smooth.nii.gz'
+# 
+#     One of sigma or fwhm must be set:
+# 
+#     >>> from nipype.interfaces.fsl import Smooth
+#     >>> sm = Smooth()
+#     >>> sm.inputs.output_type = 'NIFTI_GZ'
+#     >>> sm.inputs.in_file = 'functional2.nii'
+#     >>> sm.cmdline #doctest: +ELLIPSIS
+#     Traceback (most recent call last):
+#      ...
+#     ValueError: Smooth requires a value for one of the inputs ...
+# 
+#     
+task_name: Smooth
+nipype_name: Smooth
+nipype_module: nipype.interfaces.fsl.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: 
+    smoothed_file: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: 
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    smoothed_file: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: 
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: 
+    sigma:
+    # type=float|default=0.0: gaussian kernel sigma in mm (not voxels)
+    fwhm:
+    # type=float|default=0.0: gaussian kernel fwhm, will be converted to sigma in mm (not voxels)
+    smoothed_file:
+    # type=file: 
+    # type=file|default=<undefined>: 
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    output_type: '"NIFTI_GZ"'
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    in_file:
+    # type=file|default=<undefined>: 
+    sigma: '8.0'
+    # type=float|default=0.0: gaussian kernel sigma in mm (not voxels)
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    output_type: '"NIFTI_GZ"'
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    in_file:
+    # type=file|default=<undefined>: 
+    fwhm: '8.0'
+    # type=float|default=0.0: gaussian kernel fwhm, will be converted to sigma in mm (not voxels)
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    output_type: '"NIFTI_GZ"'
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    in_file:
+    # type=file|default=<undefined>: 
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: fslmaths functional2.nii -kernel gauss 8.000 -fmean functional2_smooth.nii.gz
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    output_type: '"NIFTI_GZ"'
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    in_file:
+    # type=file|default=<undefined>: 
+    sigma: '8.0'
+    # type=float|default=0.0: gaussian kernel sigma in mm (not voxels)
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: fslmaths functional2.nii -kernel gauss 3.397 -fmean functional2_smooth.nii.gz
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    output_type: '"NIFTI_GZ"'
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    in_file:
+    # type=file|default=<undefined>: 
+    fwhm: '8.0'
+    # type=float|default=0.0: gaussian kernel fwhm, will be converted to sigma in mm (not voxels)
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline:
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    output_type: '"NIFTI_GZ"'
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    in_file:
+    # type=file|default=<undefined>: 
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-fsl/smooth_callables.py b/example-specs/task/nipype_internal/pydra-fsl/smooth_callables.py
new file mode 100644
index 00000000..5dbe8c1a
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/smooth_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Smooth.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/smooth_estimate.yaml b/example-specs/task/nipype_internal/pydra-fsl/smooth_estimate.yaml
new file mode 100644
index 00000000..ae8d0708
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/smooth_estimate.yaml
@@ -0,0 +1,130 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.model.SmoothEstimate' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Estimates the smoothness of an image
+# 
+#     Examples
+#     --------
+# 
+#     >>> est = SmoothEstimate()
+#     >>> est.inputs.zstat_file = 'zstat1.nii.gz'
+#     >>> est.inputs.mask_file = 'mask.nii'
+#     >>> est.cmdline
+#     'smoothest --mask=mask.nii --zstat=zstat1.nii.gz'
+# 
+#     
+task_name: SmoothEstimate
+nipype_name: SmoothEstimate
+nipype_module: nipype.interfaces.fsl.model
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    mask_file: medimage/nifti1
+    # type=file|default=<undefined>: brain mask volume
+    residual_fit_file: generic/file
+    # type=file|default=<undefined>: residual-fit image file
+    zstat_file: medimage/nifti-gz
+    # type=file|default=<undefined>: zstat image file
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    dof:
+    # type=int|default=0: number of degrees of freedom
+    mask_file:
+    # type=file|default=<undefined>: brain mask volume
+    residual_fit_file:
+    # type=file|default=<undefined>: residual-fit image file
+    zstat_file:
+    # type=file|default=<undefined>: zstat image file
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    zstat_file:
+    # type=file|default=<undefined>: zstat image file
+    mask_file:
+    # type=file|default=<undefined>: brain mask volume
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: smoothest --mask=mask.nii --zstat=zstat1.nii.gz
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    zstat_file:
+    # type=file|default=<undefined>: zstat image file
+    mask_file:
+    # type=file|default=<undefined>: brain mask volume
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-fsl/smooth_estimate_callables.py b/example-specs/task/nipype_internal/pydra-fsl/smooth_estimate_callables.py
new file mode 100644
index 00000000..bac9d457
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/smooth_estimate_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in SmoothEstimate.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/spatial_filter.yaml b/example-specs/task/nipype_internal/pydra-fsl/spatial_filter.yaml
new file mode 100644
index 00000000..d7bccd78
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/spatial_filter.yaml
@@ -0,0 +1,97 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.maths.SpatialFilter' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Use fslmaths to spatially filter an image.
+task_name: SpatialFilter
+nipype_name: SpatialFilter
+nipype_module: nipype.interfaces.fsl.maths
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    kernel_file: generic/file
+    # type=file|default=<undefined>: use external file for kernel
+    in_file: generic/file
+    # type=file|default=<undefined>: image to operate on
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: out_file
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    operation:
+    # type=enum|default='mean'|allowed['mean','meanu','median']: operation to filter with
+    kernel_shape:
+    # type=enum|default='3D'|allowed['2D','3D','box','boxv','file','gauss','sphere']: kernel shape to use
+    kernel_size:
+    # type=float|default=0.0: kernel size - voxels for box/boxv, mm for sphere, mm sigma for gauss
+    kernel_file:
+    # type=file|default=<undefined>: use external file for kernel
+    in_file:
+    # type=file|default=<undefined>: image to operate on
+    out_file:
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
+    internal_datatype:
+    # type=enum|default='float'|allowed['char','double','float','input','int','short']: datatype to use for calculations (default is float)
+    output_datatype:
+    # type=enum|default='float'|allowed['char','double','float','input','int','short']: datatype to use for output (default uses input type)
+    nan2zeros:
+    # type=bool|default=False: change NaNs to zeros before doing anything
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-fsl/spatial_filter_callables.py b/example-specs/task/nipype_internal/pydra-fsl/spatial_filter_callables.py
new file mode 100644
index 00000000..3a39375c
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/spatial_filter_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in SpatialFilter.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/split.yaml b/example-specs/task/nipype_internal/pydra-fsl/split.yaml
new file mode 100644
index 00000000..5d2a4e8c
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/split.yaml
@@ -0,0 +1,78 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.utils.Split' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Uses FSL Fslsplit command to separate a volume into images in
+#     time, x, y or z dimension.
+#     
+task_name: Split
+nipype_name: Split
+nipype_module: nipype.interfaces.fsl.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: input filename
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input filename
+    out_base_name:
+    # type=str|default='': outputs prefix
+    dimension:
+    # type=enum|default='t'|allowed['t','x','y','z']: dimension along which the file will be split
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-fsl/split_callables.py b/example-specs/task/nipype_internal/pydra-fsl/split_callables.py
new file mode 100644
index 00000000..bdbf3d70
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/split_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Split.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/std_image.yaml b/example-specs/task/nipype_internal/pydra-fsl/std_image.yaml
new file mode 100644
index 00000000..d8b88ade
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/std_image.yaml
@@ -0,0 +1,91 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.maths.StdImage' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Use fslmaths to generate a standard deviation in an image across a given
+#     dimension.
+#     
+task_name: StdImage
+nipype_name: StdImage
+nipype_module: nipype.interfaces.fsl.maths
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: image to operate on
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: out_file
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    dimension:
+    # type=enum|default='T'|allowed['T','X','Y','Z']: dimension to standard deviate across
+    in_file:
+    # type=file|default=<undefined>: image to operate on
+    out_file:
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
+    internal_datatype:
+    # type=enum|default='float'|allowed['char','double','float','input','int','short']: datatype to use for calculations (default is float)
+    output_datatype:
+    # type=enum|default='float'|allowed['char','double','float','input','int','short']: datatype to use for output (default uses input type)
+    nan2zeros:
+    # type=bool|default=False: change NaNs to zeros before doing anything
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-fsl/std_image_callables.py b/example-specs/task/nipype_internal/pydra-fsl/std_image_callables.py
new file mode 100644
index 00000000..4670a791
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/std_image_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in StdImage.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/susan.yaml b/example-specs/task/nipype_internal/pydra-fsl/susan.yaml
new file mode 100644
index 00000000..aafe0dae
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/susan.yaml
@@ -0,0 +1,105 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.preprocess.SUSAN' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# FSL SUSAN wrapper to perform smoothing
+# 
+#     For complete details, see the `SUSAN Documentation.
+#     <https://fsl.fmrib.ox.ac.uk/fsl/fslwiki/SUSAN>`_
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces import fsl
+#     >>> from nipype.testing import example_data
+#     >>> anatfile  # doctest: +SKIP
+#     anatomical.nii  # doctest: +SKIP
+#     >>> sus = fsl.SUSAN()
+#     >>> sus.inputs.in_file = example_data('structural.nii')
+#     >>> sus.inputs.brightness_threshold = 2000.0
+#     >>> sus.inputs.fwhm = 8.0
+#     >>> result = sus.run()  # doctest: +SKIP
+#     
+task_name: SUSAN
+nipype_name: SUSAN
+nipype_module: nipype.interfaces.fsl.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: filename of input timeseries
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    smoothed_file: generic/file
+    # type=file: smoothed output file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: out_file
+    # type=file|default=<undefined>: output file name
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: filename of input timeseries
+    brightness_threshold:
+    # type=float|default=0.0: brightness threshold and should be greater than noise level and less than contrast of edges to be preserved.
+    fwhm:
+    # type=float|default=0.0: fwhm of smoothing, in mm, gets converted using sqrt(8*log(2))
+    dimension:
+    # type=enum|default=3|allowed[2,3]: within-plane (2) or fully 3D (3)
+    use_median:
+    # type=enum|default=1|allowed[0,1]: whether to use a local median filter in the cases where single-point noise is detected
+    usans:
+    # type=list|default=[]: determines whether the smoothing area (USAN) is to be found from secondary images (0, 1 or 2). A negative value for any brightness threshold will auto-set the threshold at 10% of the robust range
+    out_file:
+    # type=file|default=<undefined>: output file name
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-fsl/susan_callables.py b/example-specs/task/nipype_internal/pydra-fsl/susan_callables.py
new file mode 100644
index 00000000..505eade0
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/susan_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in SUSAN.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/swap_dimensions.yaml b/example-specs/task/nipype_internal/pydra-fsl/swap_dimensions.yaml
new file mode 100644
index 00000000..c2cc15c7
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/swap_dimensions.yaml
@@ -0,0 +1,90 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.utils.SwapDimensions' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Use fslswapdim to alter the orientation of an image.
+# 
+#     This interface accepts a three-tuple corresponding to the new
+#     orientation.  You may either provide dimension ids in the form of
+#     (-)x, (-)y, or (-z), or nifti-syle dimension codes
+#     (RL, LR, AP, PA, IS, SI).
+# 
+#     
+task_name: SwapDimensions
+nipype_name: SwapDimensions
+nipype_module: nipype.interfaces.fsl.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: input image
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: image with new dimensions
+    # type=file|default=<undefined>: image to write
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: out_file
+    # type=file: image with new dimensions
+    # type=file|default=<undefined>: image to write
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input image
+    new_dims:
+    # type=tuple|default=('x', 'x', 'x'): 3-tuple of new dimension order
+    out_file:
+    # type=file: image with new dimensions
+    # type=file|default=<undefined>: image to write
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-fsl/swap_dimensions_callables.py b/example-specs/task/nipype_internal/pydra-fsl/swap_dimensions_callables.py
new file mode 100644
index 00000000..74ec8eca
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/swap_dimensions_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in SwapDimensions.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/temporal_filter.yaml b/example-specs/task/nipype_internal/pydra-fsl/temporal_filter.yaml
new file mode 100644
index 00000000..b961e7d8
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/temporal_filter.yaml
@@ -0,0 +1,94 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.maths.TemporalFilter' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Use fslmaths to apply a low, high, or bandpass temporal filter to a
+#     timeseries.
+# 
+#     
+task_name: TemporalFilter
+nipype_name: TemporalFilter
+nipype_module: nipype.interfaces.fsl.maths
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: image to operate on
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: out_file
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    lowpass_sigma:
+    # type=float|default=-1: lowpass filter sigma (in volumes)
+    highpass_sigma:
+    # type=float|default=-1: highpass filter sigma (in volumes)
+    in_file:
+    # type=file|default=<undefined>: image to operate on
+    out_file:
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
+    internal_datatype:
+    # type=enum|default='float'|allowed['char','double','float','input','int','short']: datatype to use for calculations (default is float)
+    output_datatype:
+    # type=enum|default='float'|allowed['char','double','float','input','int','short']: datatype to use for output (default uses input type)
+    nan2zeros:
+    # type=bool|default=False: change NaNs to zeros before doing anything
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-fsl/temporal_filter_callables.py b/example-specs/task/nipype_internal/pydra-fsl/temporal_filter_callables.py
new file mode 100644
index 00000000..3ec888f9
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/temporal_filter_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in TemporalFilter.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/text_2_vest.yaml b/example-specs/task/nipype_internal/pydra-fsl/text_2_vest.yaml
new file mode 100644
index 00000000..b78fffba
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/text_2_vest.yaml
@@ -0,0 +1,133 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.utils.Text2Vest' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Use FSL Text2Vest`https://web.mit.edu/fsl_v5.0.10/fsl/doc/wiki/GLM(2f)CreatingDesignMatricesByHand.html`_
+#     to convert your plain text design matrix data into the format used by the FSL tools.
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces.fsl import Text2Vest
+#     >>> t2v = Text2Vest()
+#     >>> t2v.inputs.in_file = "design.txt"
+#     >>> t2v.inputs.out_file = "design.mat"
+#     >>> t2v.cmdline
+#     'Text2Vest design.txt design.mat'
+#     >>> res = t2v.run() # doctest: +SKIP
+#     
+task_name: Text2Vest
+nipype_name: Text2Vest
+nipype_module: nipype.interfaces.fsl.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: text/text-file
+    # type=file|default=<undefined>: plain text file representing your design, contrast, or f-test matrix
+    out_file: datascience/text-matrix
+    # type=file: matrix data in the format used by FSL tools
+    # type=file|default=<undefined>: file name to store matrix data in the format used by FSL tools (e.g., design.mat, design.con design.fts)
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: datascience/text-matrix
+    # type=file: matrix data in the format used by FSL tools
+    # type=file|default=<undefined>: file name to store matrix data in the format used by FSL tools (e.g., design.mat, design.con design.fts)
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: plain text file representing your design, contrast, or f-test matrix
+    out_file:
+    # type=file: matrix data in the format used by FSL tools
+    # type=file|default=<undefined>: file name to store matrix data in the format used by FSL tools (e.g., design.mat, design.con design.fts)
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: plain text file representing your design, contrast, or f-test matrix
+    out_file:
+    # type=file: matrix data in the format used by FSL tools
+    # type=file|default=<undefined>: file name to store matrix data in the format used by FSL tools (e.g., design.mat, design.con design.fts)
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: Text2Vest design.txt design.mat
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: plain text file representing your design, contrast, or f-test matrix
+    out_file:
+    # type=file: matrix data in the format used by FSL tools
+    # type=file|default=<undefined>: file name to store matrix data in the format used by FSL tools (e.g., design.mat, design.con design.fts)
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-fsl/text_2_vest_callables.py b/example-specs/task/nipype_internal/pydra-fsl/text_2_vest_callables.py
new file mode 100644
index 00000000..1fdad810
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/text_2_vest_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Text2Vest.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/threshold.yaml b/example-specs/task/nipype_internal/pydra-fsl/threshold.yaml
new file mode 100644
index 00000000..3efba32c
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/threshold.yaml
@@ -0,0 +1,95 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.maths.Threshold' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Use fslmaths to apply a threshold to an image in a variety of ways.
+task_name: Threshold
+nipype_name: Threshold
+nipype_module: nipype.interfaces.fsl.maths
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: image to operate on
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: out_file
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    thresh:
+    # type=float|default=0.0: threshold value
+    direction:
+    # type=enum|default='below'|allowed['above','below']: zero-out either below or above thresh value
+    use_robust_range:
+    # type=bool|default=False: interpret thresh as percentage (0-100) of robust range
+    use_nonzero_voxels:
+    # type=bool|default=False: use nonzero voxels to calculate robust range
+    in_file:
+    # type=file|default=<undefined>: image to operate on
+    out_file:
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
+    internal_datatype:
+    # type=enum|default='float'|allowed['char','double','float','input','int','short']: datatype to use for calculations (default is float)
+    output_datatype:
+    # type=enum|default='float'|allowed['char','double','float','input','int','short']: datatype to use for output (default uses input type)
+    nan2zeros:
+    # type=bool|default=False: change NaNs to zeros before doing anything
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-fsl/threshold_callables.py b/example-specs/task/nipype_internal/pydra-fsl/threshold_callables.py
new file mode 100644
index 00000000..a542f78f
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/threshold_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Threshold.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/topup.yaml b/example-specs/task/nipype_internal/pydra-fsl/topup.yaml
new file mode 100644
index 00000000..5e597d67
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/topup.yaml
@@ -0,0 +1,215 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.epi.TOPUP' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Interface for FSL topup, a tool for estimating and correcting
+#     susceptibility induced distortions. See FSL documentation for
+#     `reference <http://fsl.fmrib.ox.ac.uk/fsl/fslwiki/TOPUP>`_,
+#     `usage examples
+#     <http://fsl.fmrib.ox.ac.uk/fsl/fslwiki/topup/ExampleTopupFollowedByApplytopup>`_,
+#     and `exemplary config files
+#     <https://github.com/ahheckel/FSL-scripts/blob/master/rsc/fsl/fsl4/topup/b02b0.cnf>`_.
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces.fsl import TOPUP
+#     >>> topup = TOPUP()
+#     >>> topup.inputs.in_file = "b0_b0rev.nii"
+#     >>> topup.inputs.encoding_file = "topup_encoding.txt"
+#     >>> topup.inputs.output_type = "NIFTI_GZ"
+#     >>> topup.cmdline # doctest: +ELLIPSIS
+#     'topup --config=b02b0.cnf --datain=topup_encoding.txt --imain=b0_b0rev.nii --out=b0_b0rev_base --iout=b0_b0rev_corrected.nii.gz --fout=b0_b0rev_field.nii.gz --jacout=jac --logout=b0_b0rev_topup.log --rbmout=xfm --dfout=warpfield'
+#     >>> res = topup.run() # doctest: +SKIP
+# 
+#     
+task_name: TOPUP
+nipype_name: TOPUP
+nipype_module: nipype.interfaces.fsl.epi
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: name of 4D file with images
+    encoding_file: text/text-file
+    # type=file|default=<undefined>: name of text file with PE directions/times
+    out_base: generic/file
+    # type=file|default=<undefined>: base-name of output files (spline coefficients (Hz) and movement parameters)
+    out_field: generic/file
+    # type=file: name of image file with field (Hz)
+    # type=file|default=<undefined>: name of image file with field (Hz)
+    out_corrected: generic/file
+    # type=file: name of 4D image file with unwarped images
+    # type=file|default=<undefined>: name of 4D image file with unwarped images
+    out_logfile: generic/file
+    # type=file: name of log-file
+    # type=file|default=<undefined>: name of log-file
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_fieldcoef: generic/file
+    # type=file: file containing the field coefficients
+    out_movpar: generic/file
+    # type=file: movpar.txt output file
+    out_enc_file: generic/file
+    # type=file: encoding directions file output for applytopup
+    out_field: generic/file
+    # type=file: name of image file with field (Hz)
+    # type=file|default=<undefined>: name of image file with field (Hz)
+    out_corrected: generic/file
+    # type=file: name of 4D image file with unwarped images
+    # type=file|default=<undefined>: name of 4D image file with unwarped images
+    out_logfile: generic/file
+    # type=file: name of log-file
+    # type=file|default=<undefined>: name of log-file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: name of 4D file with images
+    encoding_file:
+    # type=file|default=<undefined>: name of text file with PE directions/times
+    encoding_direction:
+    # type=list|default=[]: encoding direction for automatic generation of encoding_file
+    readout_times:
+    # type=inputmultiobject|default=[]: readout times (dwell times by # phase-encode steps minus 1)
+    out_base:
+    # type=file|default=<undefined>: base-name of output files (spline coefficients (Hz) and movement parameters)
+    out_field:
+    # type=file: name of image file with field (Hz)
+    # type=file|default=<undefined>: name of image file with field (Hz)
+    out_warp_prefix:
+    # type=str|default='warpfield': prefix for the warpfield images (in mm)
+    out_mat_prefix:
+    # type=str|default='xfm': prefix for the realignment matrices
+    out_jac_prefix:
+    # type=str|default='jac': prefix for the warpfield images
+    out_corrected:
+    # type=file: name of 4D image file with unwarped images
+    # type=file|default=<undefined>: name of 4D image file with unwarped images
+    out_logfile:
+    # type=file: name of log-file
+    # type=file|default=<undefined>: name of log-file
+    warp_res:
+    # type=float|default=0.0: (approximate) resolution (in mm) of warp basis for the different sub-sampling levels
+    subsamp:
+    # type=int|default=0: sub-sampling scheme
+    fwhm:
+    # type=float|default=0.0: FWHM (in mm) of gaussian smoothing kernel
+    config:
+    # type=string|default='b02b0.cnf': Name of config file specifying command line arguments
+    max_iter:
+    # type=int|default=0: max # of non-linear iterations
+    reg_lambda:
+    # type=float|default=0.0: Weight of regularisation, default depending on --ssqlambda and --regmod switches.
+    ssqlambda:
+    # type=enum|default=1|allowed[0,1]: Weight lambda by the current value of the ssd. If used (=1), the effective weight of regularisation term becomes higher for the initial iterations, therefore initial steps are a little smoother than they would without weighting. This reduces the risk of finding a local minimum.
+    regmod:
+    # type=enum|default='bending_energy'|allowed['bending_energy','membrane_energy']: Regularisation term implementation. Defaults to bending_energy. Note that the two functions have vastly different scales. The membrane energy is based on the first derivatives and the bending energy on the second derivatives. The second derivatives will typically be much smaller than the first derivatives, so input lambda will have to be larger for bending_energy to yield approximately the same level of regularisation.
+    estmov:
+    # type=enum|default=1|allowed[0,1]: estimate movements if set
+    minmet:
+    # type=enum|default=0|allowed[0,1]: Minimisation method 0=Levenberg-Marquardt, 1=Scaled Conjugate Gradient
+    splineorder:
+    # type=int|default=0: order of spline, 2->Qadratic spline, 3->Cubic spline
+    numprec:
+    # type=enum|default='double'|allowed['double','float']: Precision for representing Hessian, double or float.
+    interp:
+    # type=enum|default='spline'|allowed['linear','spline']: Image interpolation model, linear or spline.
+    scale:
+    # type=enum|default=0|allowed[0,1]: If set (=1), the images are individually scaled to a common mean
+    regrid:
+    # type=enum|default=1|allowed[0,1]: If set (=1), the calculations are done in a different grid
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: name of 4D file with images
+    encoding_file:
+    # type=file|default=<undefined>: name of text file with PE directions/times
+    output_type: '"NIFTI_GZ"'
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: topup --config=b02b0.cnf --datain=topup_encoding.txt --imain=b0_b0rev.nii --out=b0_b0rev_base --iout=b0_b0rev_corrected.nii.gz --fout=b0_b0rev_field.nii.gz --jacout=jac --logout=b0_b0rev_topup.log --rbmout=xfm --dfout=warpfield
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: name of 4D file with images
+    encoding_file:
+    # type=file|default=<undefined>: name of text file with PE directions/times
+    output_type: '"NIFTI_GZ"'
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-fsl/topup_callables.py b/example-specs/task/nipype_internal/pydra-fsl/topup_callables.py
new file mode 100644
index 00000000..3069076b
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/topup_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in TOPUP.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/tract_skeleton.yaml b/example-specs/task/nipype_internal/pydra-fsl/tract_skeleton.yaml
new file mode 100644
index 00000000..599fe46e
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/tract_skeleton.yaml
@@ -0,0 +1,135 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.dti.TractSkeleton' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Use FSL's tbss_skeleton to skeletonise an FA image or project arbitrary
+#     values onto a skeleton.
+# 
+#     There are two ways to use this interface.  To create a skeleton from an FA
+#     image, just supply the ``in_file`` and set ``skeleton_file`` to True (or
+#     specify a skeleton filename. To project values onto a skeleton, you must
+#     set ``project_data`` to True, and then also supply values for
+#     ``threshold``, ``distance_map``, and ``data_file``. The
+#     ``search_mask_file`` and ``use_cingulum_mask`` inputs are also used in data
+#     projection, but ``use_cingulum_mask`` is set to True by default.  This mask
+#     controls where the projection algorithm searches within a circular space
+#     around a tract, rather than in a single perpendicular direction.
+# 
+#     Example
+#     -------
+# 
+#     >>> import nipype.interfaces.fsl as fsl
+#     >>> skeletor = fsl.TractSkeleton()
+#     >>> skeletor.inputs.in_file = "all_FA.nii.gz"
+#     >>> skeletor.inputs.skeleton_file = True
+#     >>> skeletor.run() # doctest: +SKIP
+# 
+#     
+task_name: TractSkeleton
+nipype_name: TractSkeleton
+nipype_module: nipype.interfaces.fsl.dti
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: input image (typically mean FA volume)
+    distance_map: generic/file
+    # type=file|default=<undefined>: distance map image
+    search_mask_file: generic/file
+    # type=file|default=<undefined>: mask in which to use alternate search rule
+    data_file: generic/file
+    # type=file|default=<undefined>: 4D data to project onto skeleton (usually FA)
+    alt_data_file: generic/file
+    # type=file|default=<undefined>: 4D non-FA data to project onto skeleton
+    alt_skeleton: generic/file
+    # type=file|default=<undefined>: alternate skeleton to use
+    projected_data: generic/file
+    # type=file: input data projected onto skeleton
+    # type=file|default=<undefined>: input data projected onto skeleton
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    projected_data: generic/file
+    # type=file: input data projected onto skeleton
+    # type=file|default=<undefined>: input data projected onto skeleton
+    skeleton_file: generic/file
+    # type=file: tract skeleton image
+    # type=traitcompound|default=None: write out skeleton image
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: input image (typically mean FA volume)
+    project_data:
+    # type=bool|default=False: project data onto skeleton
+    threshold:
+    # type=float|default=0.0: skeleton threshold value
+    distance_map:
+    # type=file|default=<undefined>: distance map image
+    search_mask_file:
+    # type=file|default=<undefined>: mask in which to use alternate search rule
+    use_cingulum_mask:
+    # type=bool|default=True: perform alternate search using built-in cingulum mask
+    data_file:
+    # type=file|default=<undefined>: 4D data to project onto skeleton (usually FA)
+    alt_data_file:
+    # type=file|default=<undefined>: 4D non-FA data to project onto skeleton
+    alt_skeleton:
+    # type=file|default=<undefined>: alternate skeleton to use
+    projected_data:
+    # type=file: input data projected onto skeleton
+    # type=file|default=<undefined>: input data projected onto skeleton
+    skeleton_file:
+    # type=file: tract skeleton image
+    # type=traitcompound|default=None: write out skeleton image
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-fsl/tract_skeleton_callables.py b/example-specs/task/nipype_internal/pydra-fsl/tract_skeleton_callables.py
new file mode 100644
index 00000000..92b6fc48
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/tract_skeleton_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in TractSkeleton.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/training.yaml b/example-specs/task/nipype_internal/pydra-fsl/training.yaml
new file mode 100644
index 00000000..5c972428
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/training.yaml
@@ -0,0 +1,78 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.fix.Training' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Train the classifier based on your own FEAT/MELODIC output directory.
+#     
+task_name: Training
+nipype_name: Training
+nipype_module: nipype.interfaces.fsl.fix
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    mel_icas: generic/directory+list-of
+    # type=inputmultiobject|default=[]: Melodic output directories
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    trained_wts_file: generic/file
+    # type=file: Trained-weights file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    mel_icas:
+    # type=inputmultiobject|default=[]: Melodic output directories
+    trained_wts_filestem:
+    # type=str|default='': trained-weights filestem, used for trained_wts_file and output directories
+    loo:
+    # type=bool|default=False: full leave-one-out test with classifier training
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-fsl/training_callables.py b/example-specs/task/nipype_internal/pydra-fsl/training_callables.py
new file mode 100644
index 00000000..7be534ea
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/training_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Training.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/training_set_creator.yaml b/example-specs/task/nipype_internal/pydra-fsl/training_set_creator.yaml
new file mode 100644
index 00000000..f3a0a06c
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/training_set_creator.yaml
@@ -0,0 +1,73 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.fix.TrainingSetCreator' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Goes through set of provided melodic output directories, to find all
+#     the ones that have a hand_labels_noise.txt file in them.
+# 
+#     This is outsourced as a separate class, so that the pipeline is
+#     rerun every time a handlabeled file has been changed, or a new one
+#     created.
+# 
+#     
+task_name: TrainingSetCreator
+nipype_name: TrainingSetCreator
+nipype_module: nipype.interfaces.fsl.fix
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    mel_icas_in: generic/directory+list-of
+    # type=inputmultiobject|default=[]: Melodic output directories
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    mel_icas_in:
+    # type=inputmultiobject|default=[]: Melodic output directories
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-fsl/training_set_creator_callables.py b/example-specs/task/nipype_internal/pydra-fsl/training_set_creator_callables.py
new file mode 100644
index 00000000..b5853094
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/training_set_creator_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in TrainingSetCreator.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/unary_maths.yaml b/example-specs/task/nipype_internal/pydra-fsl/unary_maths.yaml
new file mode 100644
index 00000000..28d9d3ef
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/unary_maths.yaml
@@ -0,0 +1,89 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.maths.UnaryMaths' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Use fslmaths to perorm a variety of mathematical operations on an image.
+task_name: UnaryMaths
+nipype_name: UnaryMaths
+nipype_module: nipype.interfaces.fsl.maths
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: image to operate on
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: out_file
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    operation:
+    # type=enum|default='exp'|allowed['abs','acos','asin','atan','bin','binv','cos','edge','exp','fillh','fillh26','index','log','nan','nanm','rand','randn','range','recip','sin','sqr','sqrt','tan']: operation to perform
+    in_file:
+    # type=file|default=<undefined>: image to operate on
+    out_file:
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
+    internal_datatype:
+    # type=enum|default='float'|allowed['char','double','float','input','int','short']: datatype to use for calculations (default is float)
+    output_datatype:
+    # type=enum|default='float'|allowed['char','double','float','input','int','short']: datatype to use for output (default uses input type)
+    nan2zeros:
+    # type=bool|default=False: change NaNs to zeros before doing anything
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-fsl/unary_maths_callables.py b/example-specs/task/nipype_internal/pydra-fsl/unary_maths_callables.py
new file mode 100644
index 00000000..ae1ae260
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/unary_maths_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in UnaryMaths.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/vec_reg.yaml b/example-specs/task/nipype_internal/pydra-fsl/vec_reg.yaml
new file mode 100644
index 00000000..f5f60af1
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/vec_reg.yaml
@@ -0,0 +1,170 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.dti.VecReg' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Use FSL vecreg for registering vector data
+#     For complete details, see the FDT Documentation
+#     <http://www.fmrib.ox.ac.uk/fsl/fdt/fdt_vecreg.html>
+# 
+#     Example
+#     -------
+# 
+#     >>> from nipype.interfaces import fsl
+#     >>> vreg = fsl.VecReg(in_file='diffusion.nii',                  affine_mat='trans.mat',                  ref_vol='mni.nii',                  out_file='diffusion_vreg.nii')
+#     >>> vreg.cmdline
+#     'vecreg -t trans.mat -i diffusion.nii -o diffusion_vreg.nii -r mni.nii'
+# 
+#     
+task_name: VecReg
+nipype_name: VecReg
+nipype_module: nipype.interfaces.fsl.dti
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: filename for input vector or tensor field
+    ref_vol: medimage/nifti1
+    # type=file|default=<undefined>: filename for reference (target) volume
+    affine_mat: datascience/text-matrix
+    # type=file|default=<undefined>: filename for affine transformation matrix
+    warp_field: generic/file
+    # type=file|default=<undefined>: filename for 4D warp field for nonlinear registration
+    rotation_mat: generic/file
+    # type=file|default=<undefined>: filename for secondary affine matrix if set, this will be used for the rotation of the vector/tensor field
+    rotation_warp: generic/file
+    # type=file|default=<undefined>: filename for secondary warp field if set, this will be used for the rotation of the vector/tensor field
+    mask: generic/file
+    # type=file|default=<undefined>: brain mask in input space
+    ref_mask: generic/file
+    # type=file|default=<undefined>: brain mask in output space (useful for speed up of nonlinear reg)
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: medimage/nifti1
+    # type=file: path/name of filename for the registered vector or tensor field
+    # type=file|default=<undefined>: filename for output registered vector or tensor field
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: '"diffusion_vreg.nii"'
+    # type=file: path/name of filename for the registered vector or tensor field
+    # type=file|default=<undefined>: filename for output registered vector or tensor field
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: filename for input vector or tensor field
+    out_file:
+    # type=file: path/name of filename for the registered vector or tensor field
+    # type=file|default=<undefined>: filename for output registered vector or tensor field
+    ref_vol:
+    # type=file|default=<undefined>: filename for reference (target) volume
+    affine_mat:
+    # type=file|default=<undefined>: filename for affine transformation matrix
+    warp_field:
+    # type=file|default=<undefined>: filename for 4D warp field for nonlinear registration
+    rotation_mat:
+    # type=file|default=<undefined>: filename for secondary affine matrix if set, this will be used for the rotation of the vector/tensor field
+    rotation_warp:
+    # type=file|default=<undefined>: filename for secondary warp field if set, this will be used for the rotation of the vector/tensor field
+    interpolation:
+    # type=enum|default='nearestneighbour'|allowed['nearestneighbour','sinc','spline','trilinear']: interpolation method : nearestneighbour, trilinear (default), sinc or spline
+    mask:
+    # type=file|default=<undefined>: brain mask in input space
+    ref_mask:
+    # type=file|default=<undefined>: brain mask in output space (useful for speed up of nonlinear reg)
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: filename for input vector or tensor field
+    affine_mat:
+    # type=file|default=<undefined>: filename for affine transformation matrix
+    ref_vol:
+    # type=file|default=<undefined>: filename for reference (target) volume
+    out_file: '"diffusion_vreg.nii"'
+    # type=file: path/name of filename for the registered vector or tensor field
+    # type=file|default=<undefined>: filename for output registered vector or tensor field
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: vecreg -t trans.mat -i diffusion.nii -o diffusion_vreg.nii -r mni.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: filename for input vector or tensor field
+    affine_mat:
+    # type=file|default=<undefined>: filename for affine transformation matrix
+    ref_vol:
+    # type=file|default=<undefined>: filename for reference (target) volume
+    out_file: '"diffusion_vreg.nii"'
+    # type=file: path/name of filename for the registered vector or tensor field
+    # type=file|default=<undefined>: filename for output registered vector or tensor field
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-fsl/vec_reg_callables.py b/example-specs/task/nipype_internal/pydra-fsl/vec_reg_callables.py
new file mode 100644
index 00000000..e1d8453d
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/vec_reg_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in VecReg.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/vest_2_text.yaml b/example-specs/task/nipype_internal/pydra-fsl/vest_2_text.yaml
new file mode 100644
index 00000000..f63c0301
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/vest_2_text.yaml
@@ -0,0 +1,126 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.utils.Vest2Text' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Use FSL Vest2Text`https://web.mit.edu/fsl_v5.0.10/fsl/doc/wiki/GLM(2f)CreatingDesignMatricesByHand.html`_
+#     to convert your design.mat design.con and design.fts files into plain text.
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces.fsl import Vest2Text
+#     >>> v2t = Vest2Text()
+#     >>> v2t.inputs.in_file = "design.mat"
+#     >>> v2t.cmdline
+#     'Vest2Text design.mat design.txt'
+#     >>> res = v2t.run() # doctest: +SKIP
+#     
+task_name: Vest2Text
+nipype_name: Vest2Text
+nipype_module: nipype.interfaces.fsl.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: datascience/text-matrix
+    # type=file|default=<undefined>: matrix data stored in the format used by FSL tools
+    out_file: generic/file
+    # type=file: plain text representation of FSL matrix
+    # type=file|default='design.txt': file name to store text output from matrix
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: plain text representation of FSL matrix
+    # type=file|default='design.txt': file name to store text output from matrix
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: matrix data stored in the format used by FSL tools
+    out_file:
+    # type=file: plain text representation of FSL matrix
+    # type=file|default='design.txt': file name to store text output from matrix
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: matrix data stored in the format used by FSL tools
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: Vest2Text design.mat design.txt
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: matrix data stored in the format used by FSL tools
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-fsl/vest_2_text_callables.py b/example-specs/task/nipype_internal/pydra-fsl/vest_2_text_callables.py
new file mode 100644
index 00000000..905b2264
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/vest_2_text_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Vest2Text.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/warp_points.yaml b/example-specs/task/nipype_internal/pydra-fsl/warp_points.yaml
new file mode 100644
index 00000000..e29720e2
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/warp_points.yaml
@@ -0,0 +1,169 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.utils.WarpPoints' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Use FSL `img2imgcoord <http://fsl.fmrib.ox.ac.uk/fsl/fsl-4.1.9/flirt/overview.html>`_
+#     to transform point sets. Accepts plain text files and vtk files.
+# 
+#     .. Note:: transformation of TrackVis trk files is not yet implemented
+# 
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces.fsl import WarpPoints
+#     >>> warppoints = WarpPoints()
+#     >>> warppoints.inputs.in_coords = 'surf.txt'
+#     >>> warppoints.inputs.src_file = 'epi.nii'
+#     >>> warppoints.inputs.dest_file = 'T1.nii'
+#     >>> warppoints.inputs.warp_file = 'warpfield.nii'
+#     >>> warppoints.inputs.coord_mm = True
+#     >>> warppoints.cmdline # doctest: +ELLIPSIS
+#     'img2imgcoord -mm -dest T1.nii -src epi.nii -warp warpfield.nii surf.txt'
+#     >>> res = warppoints.run() # doctest: +SKIP
+# 
+# 
+#     
+task_name: WarpPoints
+nipype_name: WarpPoints
+nipype_module: nipype.interfaces.fsl.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    src_file: medimage/nifti1
+    # type=file|default=<undefined>: filename of source image
+    dest_file: medimage/nifti1
+    # type=file|default=<undefined>: filename of destination image
+    in_coords: text/text-file
+    # type=file|default=<undefined>: filename of file containing coordinates
+    xfm_file: generic/file
+    # type=file|default=<undefined>: filename of affine transform (e.g. source2dest.mat)
+    warp_file: medimage/nifti1
+    # type=file|default=<undefined>: filename of warpfield (e.g. intermediate2dest_warp.nii.gz)
+    out_file: generic/file
+    # type=file: Name of output file, containing the warp as field or coefficients.
+    # type=file|default=<undefined>: output file name
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: Name of output file, containing the warp as field or coefficients.
+    # type=file|default=<undefined>: output file name
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    src_file:
+    # type=file|default=<undefined>: filename of source image
+    dest_file:
+    # type=file|default=<undefined>: filename of destination image
+    in_coords:
+    # type=file|default=<undefined>: filename of file containing coordinates
+    xfm_file:
+    # type=file|default=<undefined>: filename of affine transform (e.g. source2dest.mat)
+    warp_file:
+    # type=file|default=<undefined>: filename of warpfield (e.g. intermediate2dest_warp.nii.gz)
+    coord_vox:
+    # type=bool|default=True: all coordinates in voxels - default
+    coord_mm:
+    # type=bool|default=False: all coordinates in mm
+    out_file:
+    # type=file: Name of output file, containing the warp as field or coefficients.
+    # type=file|default=<undefined>: output file name
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_coords:
+    # type=file|default=<undefined>: filename of file containing coordinates
+    src_file:
+    # type=file|default=<undefined>: filename of source image
+    dest_file:
+    # type=file|default=<undefined>: filename of destination image
+    warp_file:
+    # type=file|default=<undefined>: filename of warpfield (e.g. intermediate2dest_warp.nii.gz)
+    coord_mm: 'True'
+    # type=bool|default=False: all coordinates in mm
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: img2imgcoord -mm -dest T1.nii -src epi.nii -warp warpfield.nii surf.txt
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_coords:
+    # type=file|default=<undefined>: filename of file containing coordinates
+    src_file:
+    # type=file|default=<undefined>: filename of source image
+    dest_file:
+    # type=file|default=<undefined>: filename of destination image
+    warp_file:
+    # type=file|default=<undefined>: filename of warpfield (e.g. intermediate2dest_warp.nii.gz)
+    coord_mm: 'True'
+    # type=bool|default=False: all coordinates in mm
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-fsl/warp_points_callables.py b/example-specs/task/nipype_internal/pydra-fsl/warp_points_callables.py
new file mode 100644
index 00000000..b868a2c6
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/warp_points_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in WarpPoints.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/warp_points_from_std.yaml b/example-specs/task/nipype_internal/pydra-fsl/warp_points_from_std.yaml
new file mode 100644
index 00000000..aaffa6bc
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/warp_points_from_std.yaml
@@ -0,0 +1,162 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.utils.WarpPointsFromStd' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Use FSL `std2imgcoord <http://fsl.fmrib.ox.ac.uk/fsl/fsl-4.1.9/flirt/overview.html>`_
+#     to transform point sets to standard space coordinates. Accepts plain text coordinates
+#     files.
+# 
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces.fsl import WarpPointsFromStd
+#     >>> warppoints = WarpPointsFromStd()
+#     >>> warppoints.inputs.in_coords = 'surf.txt'
+#     >>> warppoints.inputs.img_file = 'T1.nii'
+#     >>> warppoints.inputs.std_file = 'mni.nii'
+#     >>> warppoints.inputs.warp_file = 'warpfield.nii'
+#     >>> warppoints.inputs.coord_mm = True
+#     >>> warppoints.cmdline # doctest: +ELLIPSIS
+#     'std2imgcoord -mm -img T1.nii -std mni.nii -warp warpfield.nii surf.txt'
+#     >>> res = warppoints.run() # doctest: +SKIP
+# 
+# 
+#     
+task_name: WarpPointsFromStd
+nipype_name: WarpPointsFromStd
+nipype_module: nipype.interfaces.fsl.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    img_file: medimage/nifti1
+    # type=file|default=<undefined>: filename of a destination image
+    std_file: medimage/nifti1
+    # type=file|default=<undefined>: filename of the image in standard space
+    in_coords: text/text-file
+    # type=file|default=<undefined>: filename of file containing coordinates
+    xfm_file: generic/file
+    # type=file|default=<undefined>: filename of affine transform (e.g. source2dest.mat)
+    warp_file: medimage/nifti1
+    # type=file|default=<undefined>: filename of warpfield (e.g. intermediate2dest_warp.nii.gz)
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: Name of output file, containing the warp as field or coefficients.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    img_file:
+    # type=file|default=<undefined>: filename of a destination image
+    std_file:
+    # type=file|default=<undefined>: filename of the image in standard space
+    in_coords:
+    # type=file|default=<undefined>: filename of file containing coordinates
+    xfm_file:
+    # type=file|default=<undefined>: filename of affine transform (e.g. source2dest.mat)
+    warp_file:
+    # type=file|default=<undefined>: filename of warpfield (e.g. intermediate2dest_warp.nii.gz)
+    coord_vox:
+    # type=bool|default=True: all coordinates in voxels - default
+    coord_mm:
+    # type=bool|default=False: all coordinates in mm
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_coords:
+    # type=file|default=<undefined>: filename of file containing coordinates
+    img_file:
+    # type=file|default=<undefined>: filename of a destination image
+    std_file:
+    # type=file|default=<undefined>: filename of the image in standard space
+    warp_file:
+    # type=file|default=<undefined>: filename of warpfield (e.g. intermediate2dest_warp.nii.gz)
+    coord_mm: 'True'
+    # type=bool|default=False: all coordinates in mm
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: std2imgcoord -mm -img T1.nii -std mni.nii -warp warpfield.nii surf.txt
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_coords:
+    # type=file|default=<undefined>: filename of file containing coordinates
+    img_file:
+    # type=file|default=<undefined>: filename of a destination image
+    std_file:
+    # type=file|default=<undefined>: filename of the image in standard space
+    warp_file:
+    # type=file|default=<undefined>: filename of warpfield (e.g. intermediate2dest_warp.nii.gz)
+    coord_mm: 'True'
+    # type=bool|default=False: all coordinates in mm
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-fsl/warp_points_from_std_callables.py b/example-specs/task/nipype_internal/pydra-fsl/warp_points_from_std_callables.py
new file mode 100644
index 00000000..e587abf1
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/warp_points_from_std_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in WarpPointsFromStd.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/warp_points_to_std.yaml b/example-specs/task/nipype_internal/pydra-fsl/warp_points_to_std.yaml
new file mode 100644
index 00000000..1ee0c210
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/warp_points_to_std.yaml
@@ -0,0 +1,175 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.utils.WarpPointsToStd' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Use FSL `img2stdcoord <http://fsl.fmrib.ox.ac.uk/fsl/fsl-4.1.9/flirt/overview.html>`_
+#     to transform point sets to standard space coordinates. Accepts plain text
+#     files and vtk files.
+# 
+#     .. Note:: transformation of TrackVis trk files is not yet implemented
+# 
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces.fsl import WarpPointsToStd
+#     >>> warppoints = WarpPointsToStd()
+#     >>> warppoints.inputs.in_coords = 'surf.txt'
+#     >>> warppoints.inputs.img_file = 'T1.nii'
+#     >>> warppoints.inputs.std_file = 'mni.nii'
+#     >>> warppoints.inputs.warp_file = 'warpfield.nii'
+#     >>> warppoints.inputs.coord_mm = True
+#     >>> warppoints.cmdline # doctest: +ELLIPSIS
+#     'img2stdcoord -mm -img T1.nii -std mni.nii -warp warpfield.nii surf.txt'
+#     >>> res = warppoints.run() # doctest: +SKIP
+# 
+# 
+#     
+task_name: WarpPointsToStd
+nipype_name: WarpPointsToStd
+nipype_module: nipype.interfaces.fsl.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    img_file: medimage/nifti1
+    # type=file|default=<undefined>: filename of input image
+    std_file: medimage/nifti1
+    # type=file|default=<undefined>: filename of destination image
+    premat_file: generic/file
+    # type=file|default=<undefined>: filename of pre-warp affine transform (e.g. example_func2highres.mat)
+    in_coords: text/text-file
+    # type=file|default=<undefined>: filename of file containing coordinates
+    xfm_file: generic/file
+    # type=file|default=<undefined>: filename of affine transform (e.g. source2dest.mat)
+    warp_file: medimage/nifti1
+    # type=file|default=<undefined>: filename of warpfield (e.g. intermediate2dest_warp.nii.gz)
+    out_file: generic/file
+    # type=file: Name of output file, containing the warp as field or coefficients.
+    # type=file|default=<undefined>: output file name
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: Name of output file, containing the warp as field or coefficients.
+    # type=file|default=<undefined>: output file name
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    img_file:
+    # type=file|default=<undefined>: filename of input image
+    std_file:
+    # type=file|default=<undefined>: filename of destination image
+    premat_file:
+    # type=file|default=<undefined>: filename of pre-warp affine transform (e.g. example_func2highres.mat)
+    in_coords:
+    # type=file|default=<undefined>: filename of file containing coordinates
+    xfm_file:
+    # type=file|default=<undefined>: filename of affine transform (e.g. source2dest.mat)
+    warp_file:
+    # type=file|default=<undefined>: filename of warpfield (e.g. intermediate2dest_warp.nii.gz)
+    coord_vox:
+    # type=bool|default=True: all coordinates in voxels - default
+    coord_mm:
+    # type=bool|default=False: all coordinates in mm
+    out_file:
+    # type=file: Name of output file, containing the warp as field or coefficients.
+    # type=file|default=<undefined>: output file name
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_coords:
+    # type=file|default=<undefined>: filename of file containing coordinates
+    img_file:
+    # type=file|default=<undefined>: filename of input image
+    std_file:
+    # type=file|default=<undefined>: filename of destination image
+    warp_file:
+    # type=file|default=<undefined>: filename of warpfield (e.g. intermediate2dest_warp.nii.gz)
+    coord_mm: 'True'
+    # type=bool|default=False: all coordinates in mm
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: img2stdcoord -mm -img T1.nii -std mni.nii -warp warpfield.nii surf.txt
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_coords:
+    # type=file|default=<undefined>: filename of file containing coordinates
+    img_file:
+    # type=file|default=<undefined>: filename of input image
+    std_file:
+    # type=file|default=<undefined>: filename of destination image
+    warp_file:
+    # type=file|default=<undefined>: filename of warpfield (e.g. intermediate2dest_warp.nii.gz)
+    coord_mm: 'True'
+    # type=bool|default=False: all coordinates in mm
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-fsl/warp_points_to_std_callables.py b/example-specs/task/nipype_internal/pydra-fsl/warp_points_to_std_callables.py
new file mode 100644
index 00000000..3c706519
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/warp_points_to_std_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in WarpPointsToStd.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/warp_utils.yaml b/example-specs/task/nipype_internal/pydra-fsl/warp_utils.yaml
new file mode 100644
index 00000000..8b08dd4b
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/warp_utils.yaml
@@ -0,0 +1,172 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.utils.WarpUtils' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Use FSL `fnirtfileutils <http://fsl.fmrib.ox.ac.uk/fsl/fsl-4.1.9/fnirt/warp_utils.html>`_
+#     to convert field->coefficients, coefficients->field, coefficients->other_coefficients etc
+# 
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces.fsl import WarpUtils
+#     >>> warputils = WarpUtils()
+#     >>> warputils.inputs.in_file = "warpfield.nii"
+#     >>> warputils.inputs.reference = "T1.nii"
+#     >>> warputils.inputs.out_format = 'spline'
+#     >>> warputils.inputs.warp_resolution = (10,10,10)
+#     >>> warputils.inputs.output_type = "NIFTI_GZ"
+#     >>> warputils.cmdline # doctest: +ELLIPSIS
+#     'fnirtfileutils --in=warpfield.nii --outformat=spline --ref=T1.nii --warpres=10.0000,10.0000,10.0000 --out=warpfield_coeffs.nii.gz'
+#     >>> res = invwarp.run() # doctest: +SKIP
+# 
+# 
+#     
+task_name: WarpUtils
+nipype_name: WarpUtils
+nipype_module: nipype.interfaces.fsl.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: Name of file containing warp-coefficients/fields. This would typically be the output from the --cout switch of fnirt (but can also use fields, like the output from --fout).
+    reference: medimage/nifti1
+    # type=file|default=<undefined>: Name of a file in target space. Note that the target space is now different from the target space that was used to create the --warp file. It would typically be the file that was specified with the --in argument when running fnirt.
+    out_file: generic/file
+    # type=file: Name of output file, containing the warp as field or coefficients.
+    # type=file|default=<undefined>: Name of output file. The format of the output depends on what other parameters are set. The default format is a (4D) field-file. If the --outformat is set to spline the format will be a (4D) file of spline coefficients.
+    out_jacobian: generic/file
+    # type=file: Name of output file, containing the map of the determinant of the Jacobian
+    # type=file|default=<undefined>: Specifies that a (3D) file of Jacobian determinants corresponding to --in should be produced and written to filename.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: Name of output file, containing the warp as field or coefficients.
+    # type=file|default=<undefined>: Name of output file. The format of the output depends on what other parameters are set. The default format is a (4D) field-file. If the --outformat is set to spline the format will be a (4D) file of spline coefficients.
+    out_jacobian: generic/file
+    # type=file: Name of output file, containing the map of the determinant of the Jacobian
+    # type=file|default=<undefined>: Specifies that a (3D) file of Jacobian determinants corresponding to --in should be produced and written to filename.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: Name of file containing warp-coefficients/fields. This would typically be the output from the --cout switch of fnirt (but can also use fields, like the output from --fout).
+    reference:
+    # type=file|default=<undefined>: Name of a file in target space. Note that the target space is now different from the target space that was used to create the --warp file. It would typically be the file that was specified with the --in argument when running fnirt.
+    out_format:
+    # type=enum|default='spline'|allowed['field','spline']: Specifies the output format. If set to field (default) the output will be a (4D) field-file. If set to spline the format will be a (4D) file of spline coefficients.
+    warp_resolution:
+    # type=tuple|default=(0.0, 0.0, 0.0): Specifies the resolution/knot-spacing of the splines pertaining to the coefficients in the --out file. This parameter is only relevant if --outformat is set to spline. It should be noted that if the --in file has a higher resolution, the resulting coefficients will pertain to the closest (in a least-squares sense) file in the space of fields with the --warpres resolution. It should also be noted that the resolution will always be an integer multiple of the voxel size.
+    knot_space:
+    # type=tuple|default=(0, 0, 0): Alternative (to --warpres) specification of the resolution of the output spline-field.
+    out_file:
+    # type=file: Name of output file, containing the warp as field or coefficients.
+    # type=file|default=<undefined>: Name of output file. The format of the output depends on what other parameters are set. The default format is a (4D) field-file. If the --outformat is set to spline the format will be a (4D) file of spline coefficients.
+    write_jacobian:
+    # type=bool|default=False: Switch on --jac flag with automatically generated filename
+    out_jacobian:
+    # type=file: Name of output file, containing the map of the determinant of the Jacobian
+    # type=file|default=<undefined>: Specifies that a (3D) file of Jacobian determinants corresponding to --in should be produced and written to filename.
+    with_affine:
+    # type=bool|default=False: Specifies that the affine transform (i.e. that which was specified for the --aff parameter in fnirt) should be included as displacements in the --out file. That can be useful for interfacing with software that cannot decode FSL/fnirt coefficient-files (where the affine transform is stored separately from the displacements).
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: Name of file containing warp-coefficients/fields. This would typically be the output from the --cout switch of fnirt (but can also use fields, like the output from --fout).
+    reference:
+    # type=file|default=<undefined>: Name of a file in target space. Note that the target space is now different from the target space that was used to create the --warp file. It would typically be the file that was specified with the --in argument when running fnirt.
+    out_format: '"spline"'
+    # type=enum|default='spline'|allowed['field','spline']: Specifies the output format. If set to field (default) the output will be a (4D) field-file. If set to spline the format will be a (4D) file of spline coefficients.
+    warp_resolution: (10,10,10)
+    # type=tuple|default=(0.0, 0.0, 0.0): Specifies the resolution/knot-spacing of the splines pertaining to the coefficients in the --out file. This parameter is only relevant if --outformat is set to spline. It should be noted that if the --in file has a higher resolution, the resulting coefficients will pertain to the closest (in a least-squares sense) file in the space of fields with the --warpres resolution. It should also be noted that the resolution will always be an integer multiple of the voxel size.
+    output_type: '"NIFTI_GZ"'
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: fnirtfileutils --in=warpfield.nii --outformat=spline --ref=T1.nii --warpres=10.0000,10.0000,10.0000 --out=warpfield_coeffs.nii.gz
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: Name of file containing warp-coefficients/fields. This would typically be the output from the --cout switch of fnirt (but can also use fields, like the output from --fout).
+    reference:
+    # type=file|default=<undefined>: Name of a file in target space. Note that the target space is now different from the target space that was used to create the --warp file. It would typically be the file that was specified with the --in argument when running fnirt.
+    out_format: '"spline"'
+    # type=enum|default='spline'|allowed['field','spline']: Specifies the output format. If set to field (default) the output will be a (4D) field-file. If set to spline the format will be a (4D) file of spline coefficients.
+    warp_resolution: (10,10,10)
+    # type=tuple|default=(0.0, 0.0, 0.0): Specifies the resolution/knot-spacing of the splines pertaining to the coefficients in the --out file. This parameter is only relevant if --outformat is set to spline. It should be noted that if the --in file has a higher resolution, the resulting coefficients will pertain to the closest (in a least-squares sense) file in the space of fields with the --warpres resolution. It should also be noted that the resolution will always be an integer multiple of the voxel size.
+    output_type: '"NIFTI_GZ"'
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-fsl/warp_utils_callables.py b/example-specs/task/nipype_internal/pydra-fsl/warp_utils_callables.py
new file mode 100644
index 00000000..f8cee64c
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/warp_utils_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in WarpUtils.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/x_fibres_5.yaml b/example-specs/task/nipype_internal/pydra-fsl/x_fibres_5.yaml
new file mode 100644
index 00000000..73909879
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/x_fibres_5.yaml
@@ -0,0 +1,137 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.fsl.dti.XFibres5' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Perform model parameters estimation for local (voxelwise) diffusion
+#     parameters
+#     
+task_name: XFibres5
+nipype_name: XFibres5
+nipype_module: nipype.interfaces.fsl.dti
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    gradnonlin: generic/file
+    # type=file|default=<undefined>: gradient file corresponding to slice
+    dwi: generic/file
+    # type=file|default=<undefined>: diffusion weighted image data file
+    mask: generic/file
+    # type=file|default=<undefined>: brain binary mask file (i.e. from BET)
+    bvecs: generic/file
+    # type=file|default=<undefined>: b vectors file
+    bvals: generic/file
+    # type=file|default=<undefined>: b values file
+    logdir: generic/directory
+    # type=directory|default='.': 
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    mean_dsamples: generic/file
+    # type=file: Mean of distribution on diffusivity d
+    mean_S0samples: generic/file
+    # type=file: Mean of distribution on T2w baseline signal intensity S0
+    mean_tausamples: generic/file
+    # type=file: Mean of distribution on tau samples (only with rician noise)
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    gradnonlin:
+    # type=file|default=<undefined>: gradient file corresponding to slice
+    dwi:
+    # type=file|default=<undefined>: diffusion weighted image data file
+    mask:
+    # type=file|default=<undefined>: brain binary mask file (i.e. from BET)
+    bvecs:
+    # type=file|default=<undefined>: b vectors file
+    bvals:
+    # type=file|default=<undefined>: b values file
+    logdir:
+    # type=directory|default='.': 
+    n_fibres:
+    # type=range|default=2: Maximum number of fibres to fit in each voxel
+    model:
+    # type=enum|default=1|allowed[1,2,3]: use monoexponential (1, default, required for single-shell) or multiexponential (2, multi-shell) model
+    fudge:
+    # type=int|default=0: ARD fudge factor
+    n_jumps:
+    # type=int|default=5000: Num of jumps to be made by MCMC
+    burn_in:
+    # type=range|default=0: Total num of jumps at start of MCMC to be discarded
+    burn_in_no_ard:
+    # type=range|default=0: num of burnin jumps before the ard is imposed
+    sample_every:
+    # type=range|default=1: Num of jumps for each sample (MCMC)
+    update_proposal_every:
+    # type=range|default=40: Num of jumps for each update to the proposal density std (MCMC)
+    seed:
+    # type=int|default=0: seed for pseudo random number generator
+    no_ard:
+    # type=bool|default=False: Turn ARD off on all fibres
+    all_ard:
+    # type=bool|default=False: Turn ARD on on all fibres
+    no_spat:
+    # type=bool|default=False: Initialise with tensor, not spatially
+    non_linear:
+    # type=bool|default=False: Initialise with nonlinear fitting
+    cnlinear:
+    # type=bool|default=False: Initialise with constrained nonlinear fitting
+    rician:
+    # type=bool|default=False: use Rician noise modeling
+    f0_noard:
+    # type=bool|default=False: Noise floor model: add to the model an unattenuated signal compartment f0
+    f0_ard:
+    # type=bool|default=False: Noise floor model: add to the model an unattenuated signal compartment f0
+    force_dir:
+    # type=bool|default=True: use the actual directory name given (do not add + to make a new directory)
+    output_type:
+    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-fsl/x_fibres_5_callables.py b/example-specs/task/nipype_internal/pydra-fsl/x_fibres_5_callables.py
new file mode 100644
index 00000000..0f22a32c
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-fsl/x_fibres_5_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in XFibres5.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-meshfix/mesh_fix.yaml b/example-specs/task/nipype_internal/pydra-meshfix/mesh_fix.yaml
new file mode 100644
index 00000000..0a7f6038
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-meshfix/mesh_fix.yaml
@@ -0,0 +1,198 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.meshfix.MeshFix' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     MeshFix v1.2-alpha - by Marco Attene, Mirko Windhoff, Axel Thielscher.
+# 
+#     .. seealso::
+# 
+#         http://jmeshlib.sourceforge.net
+#             Sourceforge page
+# 
+#         http://simnibs.de/installation/meshfixandgetfem
+#             Ubuntu installation instructions
+# 
+#     If MeshFix is used for research purposes, please cite the following paper:
+#     M. Attene - A lightweight approach to repairing digitized polygon meshes.
+#     The Visual Computer, 2010. (c) Springer.
+# 
+#     Accepted input formats are OFF, PLY and STL.
+#     Other formats (like .msh for gmsh) are supported only partially.
+# 
+#     Example
+#     -------
+# 
+#     >>> import nipype.interfaces.meshfix as mf
+#     >>> fix = mf.MeshFix()
+#     >>> fix.inputs.in_file1 = 'lh-pial.stl'
+#     >>> fix.inputs.in_file2 = 'rh-pial.stl'
+#     >>> fix.run()                            # doctest: +SKIP
+#     >>> fix.cmdline
+#     'meshfix lh-pial.stl rh-pial.stl -o lh-pial_fixed.off'
+#     
+task_name: MeshFix
+nipype_name: MeshFix
+nipype_module: nipype.interfaces.meshfix
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file1: model/stl
+    # type=file|default=<undefined>: 
+    in_file2: model/stl
+    # type=file|default=<undefined>: 
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    mesh_file: generic/file
+    # type=file: The output mesh file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_filename: out_filename
+    # type=file|default=<undefined>: The output filename for the fixed mesh file
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    number_of_biggest_shells:
+    # type=int|default=0: Only the N biggest shells are kept
+    epsilon_angle:
+    # type=range|default=0.0: Epsilon angle in degrees (must be between 0 and 2)
+    join_overlapping_largest_components:
+    # type=bool|default=False: Join 2 biggest components if they overlap, remove the rest.
+    join_closest_components:
+    # type=bool|default=False: Join the closest pair of components.
+    quiet_mode:
+    # type=bool|default=False: Quiet mode, don't write much to stdout.
+    dont_clean:
+    # type=bool|default=False: Don't Clean
+    save_as_stl:
+    # type=bool|default=False: Result is saved in stereolithographic format (.stl)
+    save_as_vrml:
+    # type=bool|default=False: Result is saved in VRML1.0 format (.wrl)
+    save_as_freesurfer_mesh:
+    # type=bool|default=False: Result is saved in freesurfer mesh format
+    remove_handles:
+    # type=bool|default=False: Remove handles
+    uniform_remeshing_steps:
+    # type=int|default=0: Number of steps for uniform remeshing of the whole mesh
+    uniform_remeshing_vertices:
+    # type=int|default=0: Constrains the number of vertices.Must be used with uniform_remeshing_steps
+    laplacian_smoothing_steps:
+    # type=int|default=0: The number of laplacian smoothing steps to apply
+    x_shift:
+    # type=int|default=0: Shifts the coordinates of the vertices when saving. Output must be in FreeSurfer format
+    cut_outer:
+    # type=int|default=0: Remove triangles of 1st that are outside of the 2nd shell.
+    cut_inner:
+    # type=int|default=0: Remove triangles of 1st that are inside of the 2nd shell. Dilate 2nd by N; Fill holes and keep only 1st afterwards.
+    decouple_inin:
+    # type=int|default=0: Treat 1st file as inner, 2nd file as outer component.Resolve overlaps by moving inners triangles inwards. Constrain the min distance between the components > d.
+    decouple_outin:
+    # type=int|default=0: Treat 1st file as outer, 2nd file as inner component.Resolve overlaps by moving outers triangles inwards. Constrain the min distance between the components > d.
+    decouple_outout:
+    # type=int|default=0: Treat 1st file as outer, 2nd file as inner component.Resolve overlaps by moving outers triangles outwards. Constrain the min distance between the components > d.
+    finetuning_inwards:
+    # type=bool|default=False: Used to fine-tune the minimal distance between surfaces.
+    finetuning_outwards:
+    # type=bool|default=False: Similar to finetuning_inwards, but ensures minimal distance in the other direction
+    finetuning_distance:
+    # type=float|default=0.0: Used to fine-tune the minimal distance between surfaces.A minimal distance d is ensured, and reached in n substeps. When using the surfaces for subsequent volume meshing by gmsh, this step prevent too flat tetrahedra2)
+    finetuning_substeps:
+    # type=int|default=0: Used to fine-tune the minimal distance between surfaces.A minimal distance d is ensured, and reached in n substeps. When using the surfaces for subsequent volume meshing by gmsh, this step prevent too flat tetrahedra2)
+    dilation:
+    # type=int|default=0: Dilate the surface by d. d < 0 means shrinking.
+    set_intersections_to_one:
+    # type=bool|default=False: If the mesh contains intersections, return value = 1.If saved in gmsh format, intersections will be highlighted.
+    in_file1:
+    # type=file|default=<undefined>: 
+    in_file2:
+    # type=file|default=<undefined>: 
+    output_type:
+    # type=enum|default='off'|allowed['fs','msh','off','stl','vrml','wrl']: The output type to save the file as.
+    out_filename:
+    # type=file|default=<undefined>: The output filename for the fixed mesh file
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file1:
+    # type=file|default=<undefined>: 
+    in_file2:
+    # type=file|default=<undefined>: 
+  imports: &id001
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  - module: nipype.interfaces.meshfix as mf
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: meshfix lh-pial.stl rh-pial.stl -o lh-pial_fixed.off
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file1:
+    # type=file|default=<undefined>: 
+    in_file2:
+    # type=file|default=<undefined>: 
+  imports: *id001
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-meshfix/mesh_fix_callables.py b/example-specs/task/nipype_internal/pydra-meshfix/mesh_fix_callables.py
new file mode 100644
index 00000000..f52e2aaf
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-meshfix/mesh_fix_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in MeshFix.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-minc/average.yaml b/example-specs/task/nipype_internal/pydra-minc/average.yaml
new file mode 100644
index 00000000..7efa441f
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-minc/average.yaml
@@ -0,0 +1,155 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.minc.minc.Average' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Average a number of MINC files.
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces.minc import Average
+#     >>> from nipype.interfaces.minc.testdata import nonempty_minc_data
+# 
+#     >>> files = [nonempty_minc_data(i) for i in range(3)]
+#     >>> average = Average(input_files=files, output_file='/tmp/tmp.mnc')
+#     >>> average.run() # doctest: +SKIP
+# 
+#     
+task_name: Average
+nipype_name: Average
+nipype_module: nipype.interfaces.minc.minc
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    input_files: generic/file+list-of
+    # type=inputmultiobject|default=[]: input file(s)
+    filelist: generic/file
+    # type=file|default=<undefined>: Specify the name of a file containing input file names.
+    sdfile: generic/file
+    # type=file|default=<undefined>: Specify an output sd file (default=none).
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    output_file: generic/file
+    # type=file: output file
+    # type=file|default=<undefined>: output file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    output_file: output_file
+    # type=file: output file
+    # type=file|default=<undefined>: output file
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    input_files:
+    # type=inputmultiobject|default=[]: input file(s)
+    filelist:
+    # type=file|default=<undefined>: Specify the name of a file containing input file names.
+    output_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output file
+    two:
+    # type=bool|default=False: Create a MINC 2 output file.
+    clobber:
+    # type=bool|default=True: Overwrite existing file.
+    verbose:
+    # type=bool|default=False: Print out log messages (default).
+    quiet:
+    # type=bool|default=False: Do not print out log messages.
+    debug:
+    # type=bool|default=False: Print out debugging messages.
+    check_dimensions:
+    # type=bool|default=False: Check that dimension info matches across files (default).
+    no_check_dimensions:
+    # type=bool|default=False: Do not check dimension info.
+    format_filetype:
+    # type=bool|default=False: Use data type of first file (default).
+    format_byte:
+    # type=bool|default=False: Write out byte data.
+    format_short:
+    # type=bool|default=False: Write out short integer data.
+    format_int:
+    # type=bool|default=False: Write out 32-bit integer data.
+    format_long:
+    # type=bool|default=False: Superseded by -int.
+    format_float:
+    # type=bool|default=False: Write out single-precision floating-point data.
+    format_double:
+    # type=bool|default=False: Write out double-precision floating-point data.
+    format_signed:
+    # type=bool|default=False: Write signed integer data.
+    format_unsigned:
+    # type=bool|default=False: Write unsigned integer data (default).
+    max_buffer_size_in_kb:
+    # type=range|default=4096: Specify the maximum size of the internal buffers (in kbytes).
+    normalize:
+    # type=bool|default=False: Normalize data sets for mean intensity.
+    nonormalize:
+    # type=bool|default=False: Do not normalize data sets (default).
+    voxel_range:
+    # type=tuple|default=(0, 0): Valid range for output data.
+    sdfile:
+    # type=file|default=<undefined>: Specify an output sd file (default=none).
+    copy_header:
+    # type=bool|default=False: Copy all of the header from the first file (default for one file).
+    no_copy_header:
+    # type=bool|default=False: Do not copy all of the header from the first file (default for many files)).
+    avgdim:
+    # type=str|default='': Specify a dimension along which we wish to average.
+    binarize:
+    # type=bool|default=False: Binarize the volume by looking for values in a given range.
+    binrange:
+    # type=tuple|default=(0.0, 0.0): Specify a range for binarization. Default value: 1.79769e+308 -1.79769e+308.
+    binvalue:
+    # type=float|default=0.0: Specify a target value (+/- 0.5) forbinarization. Default value: -1.79769e+308
+    weights:
+    # type=inputmultiobject|default=[]: Specify weights for averaging ("<w1>,<w2>,...").
+    width_weighted:
+    # type=bool|default=False: Weight by dimension widths when -avgdim is used.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-minc/average_callables.py b/example-specs/task/nipype_internal/pydra-minc/average_callables.py
new file mode 100644
index 00000000..aa77629f
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-minc/average_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Average.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-minc/b_box.yaml b/example-specs/task/nipype_internal/pydra-minc/b_box.yaml
new file mode 100644
index 00000000..58cf5f1f
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-minc/b_box.yaml
@@ -0,0 +1,106 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.minc.minc.BBox' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Determine a bounding box of image.
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces.minc import BBox
+#     >>> from nipype.interfaces.minc.testdata import nonempty_minc_data
+# 
+#     >>> file0 = nonempty_minc_data(0)
+#     >>> bbox = BBox(input_file=file0)
+#     >>> bbox.run() # doctest: +SKIP
+# 
+#     
+task_name: BBox
+nipype_name: BBox
+nipype_module: nipype.interfaces.minc.minc
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    input_file: generic/file
+    # type=file|default=<undefined>: input file
+    output_file: generic/file
+    # type=file: output file containing bounding box corners
+    # type=file|default=<undefined>: output file containing bounding box corners
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    output_file: generic/file
+    # type=file: output file containing bounding box corners
+    # type=file|default=<undefined>: output file containing bounding box corners
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: out_file
+    # type=file|default=<undefined>: 
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    input_file:
+    # type=file|default=<undefined>: input file
+    output_file:
+    # type=file: output file containing bounding box corners
+    # type=file|default=<undefined>: output file containing bounding box corners
+    threshold:
+    # type=int|default=0: VIO_Real value threshold for bounding box. Default value: 0.
+    one_line:
+    # type=bool|default=False: Output on one line (default): start_x y z width_x y z
+    two_lines:
+    # type=bool|default=False: Write output with two rows (start and width).
+    format_mincresample:
+    # type=bool|default=False: Output format for mincresample: (-step x y z -start x y z -nelements x y z
+    format_mincreshape:
+    # type=bool|default=False: Output format for mincreshape: (-start x,y,z -count dx,dy,dz
+    format_minccrop:
+    # type=bool|default=False: Output format for minccrop: (-xlim x1 x2 -ylim y1 y2 -zlim z1 z2
+    out_file:
+    # type=file|default=<undefined>: 
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-minc/b_box_callables.py b/example-specs/task/nipype_internal/pydra-minc/b_box_callables.py
new file mode 100644
index 00000000..dfc1894a
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-minc/b_box_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in BBox.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-minc/beast.yaml b/example-specs/task/nipype_internal/pydra-minc/beast.yaml
new file mode 100644
index 00000000..1ba0ea91
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-minc/beast.yaml
@@ -0,0 +1,131 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.minc.minc.Beast' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Extract brain image using BEaST (Brain Extraction using
+#     non-local Segmentation Technique).
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces.minc import Beast
+#     >>> from nipype.interfaces.minc.testdata import nonempty_minc_data
+# 
+#     >>> file0 = nonempty_minc_data(0)
+#     >>> beast = Beast(input_file=file0)
+#     >>> beast .run() # doctest: +SKIP
+#     
+task_name: Beast
+nipype_name: Beast
+nipype_module: nipype.interfaces.minc.minc
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    configuration_file: generic/file
+    # type=file|default=<undefined>: Specify configuration file.
+    input_file: generic/file
+    # type=file|default=<undefined>: input file
+    output_file: generic/file
+    # type=file: output mask file
+    # type=file|default=<undefined>: output file
+    library_dir: generic/directory
+    # type=directory|default=<undefined>: library directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    output_file: generic/file
+    # type=file: output mask file
+    # type=file|default=<undefined>: output file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    probability_map:
+    # type=bool|default=False: Output the probability map instead of crisp mask.
+    flip_images:
+    # type=bool|default=False: Flip images around the mid-sagittal plane to increase patch count.
+    load_moments:
+    # type=bool|default=False: Do not calculate moments instead use precalculatedlibrary moments. (for optimization purposes)
+    fill_holes:
+    # type=bool|default=False: Fill holes in the binary output.
+    median_filter:
+    # type=bool|default=False: Apply a median filter on the probability map.
+    nlm_filter:
+    # type=bool|default=False: Apply an NLM filter on the probability map (experimental).
+    clobber:
+    # type=bool|default=True: Overwrite existing file.
+    configuration_file:
+    # type=file|default=<undefined>: Specify configuration file.
+    voxel_size:
+    # type=int|default=4: Specify voxel size for calculations (4, 2, or 1).Default value: 4. Assumes no multiscale. Use configurationfile for multiscale.
+    abspath:
+    # type=bool|default=True: File paths in the library are absolute (default is relative to library root).
+    patch_size:
+    # type=int|default=1: Specify patch size for single scale approach. Default value: 1.
+    search_area:
+    # type=int|default=2: Specify size of search area for single scale approach. Default value: 2.
+    confidence_level_alpha:
+    # type=float|default=0.5: Specify confidence level Alpha. Default value: 0.5
+    smoothness_factor_beta:
+    # type=float|default=0.5: Specify smoothness factor Beta. Default value: 0.25
+    threshold_patch_selection:
+    # type=float|default=0.95: Specify threshold for patch selection. Default value: 0.95
+    number_selected_images:
+    # type=int|default=20: Specify number of selected images. Default value: 20
+    same_resolution:
+    # type=bool|default=False: Output final mask with the same resolution as input file.
+    library_dir:
+    # type=directory|default=<undefined>: library directory
+    input_file:
+    # type=file|default=<undefined>: input file
+    output_file:
+    # type=file: output mask file
+    # type=file|default=<undefined>: output file
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-minc/beast_callables.py b/example-specs/task/nipype_internal/pydra-minc/beast_callables.py
new file mode 100644
index 00000000..a264bb30
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-minc/beast_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Beast.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-minc/best_lin_reg.yaml b/example-specs/task/nipype_internal/pydra-minc/best_lin_reg.yaml
new file mode 100644
index 00000000..767dfd24
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-minc/best_lin_reg.yaml
@@ -0,0 +1,112 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.minc.minc.BestLinReg' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Hierachial linear fitting between two files.
+# 
+#     The bestlinreg script is part of the EZminc package:
+# 
+#     https://github.com/BIC-MNI/EZminc/blob/master/scripts/bestlinreg.pl
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces.minc import BestLinReg
+#     >>> from nipype.interfaces.minc.testdata import nonempty_minc_data
+# 
+#     >>> input_file = nonempty_minc_data(0)
+#     >>> target_file = nonempty_minc_data(1)
+#     >>> linreg = BestLinReg(source=input_file, target=target_file)
+#     >>> linreg.run() # doctest: +SKIP
+#     
+task_name: BestLinReg
+nipype_name: BestLinReg
+nipype_module: nipype.interfaces.minc.minc
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    source: generic/file
+    # type=file|default=<undefined>: source Minc file
+    target: generic/file
+    # type=file|default=<undefined>: target Minc file
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    output_xfm: generic/file
+    # type=file: output xfm file
+    # type=file|default=<undefined>: output xfm file
+    output_mnc: generic/file
+    # type=file: output mnc file
+    # type=file|default=<undefined>: output mnc file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    output_xfm: output_xfm
+    # type=file: output xfm file
+    # type=file|default=<undefined>: output xfm file
+    output_mnc: output_mnc
+    # type=file: output mnc file
+    # type=file|default=<undefined>: output mnc file
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    source:
+    # type=file|default=<undefined>: source Minc file
+    target:
+    # type=file|default=<undefined>: target Minc file
+    output_xfm:
+    # type=file: output xfm file
+    # type=file|default=<undefined>: output xfm file
+    output_mnc:
+    # type=file: output mnc file
+    # type=file|default=<undefined>: output mnc file
+    verbose:
+    # type=bool|default=False: Print out log messages. Default: False.
+    clobber:
+    # type=bool|default=True: Overwrite existing file.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-minc/best_lin_reg_callables.py b/example-specs/task/nipype_internal/pydra-minc/best_lin_reg_callables.py
new file mode 100644
index 00000000..bc1341e4
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-minc/best_lin_reg_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in BestLinReg.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-minc/big_average.yaml b/example-specs/task/nipype_internal/pydra-minc/big_average.yaml
new file mode 100644
index 00000000..9ae2cbc4
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-minc/big_average.yaml
@@ -0,0 +1,130 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.minc.minc.BigAverage' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Average 1000's of MINC files in linear time.
+# 
+#     mincbigaverage is designed to discretise the problem of averaging either
+#     a large number of input files or averaging a smaller number of large
+#     files. (>1GB each). There is also some code included to perform "robust"
+#     averaging in which only the most common features are kept via down-weighting
+#     outliers beyond a standard deviation.
+# 
+#     One advantage of mincbigaverage is that it avoids issues around the number
+#     of possible open files in HDF/netCDF. In short if you have more than 100
+#     files open at once while averaging things will slow down significantly.
+# 
+#     mincbigaverage does this via a iterative approach to averaging files and
+#     is a direct drop in replacement for mincaverage. That said not all the
+#     arguments of mincaverage are supported in mincbigaverage but they should
+#     be.
+# 
+#     This tool is part of the minc-widgets package:
+# 
+#     https://github.com/BIC-MNI/minc-widgets/blob/master/mincbigaverage/mincbigaverage
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces.minc import BigAverage
+#     >>> from nipype.interfaces.minc.testdata import nonempty_minc_data
+# 
+#     >>> files = [nonempty_minc_data(i) for i in range(3)]
+#     >>> average = BigAverage(input_files=files, output_float=True, robust=True)
+#     >>> average.run() # doctest: +SKIP
+#     
+task_name: BigAverage
+nipype_name: BigAverage
+nipype_module: nipype.interfaces.minc.minc
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    input_files: generic/file+list-of
+    # type=inputmultiobject|default=[]: input file(s)
+    sd_file: generic/file
+    # type=file: standard deviation image
+    # type=file|default=<undefined>: Place standard deviation image in specified file.
+    tmpdir: generic/directory
+    # type=directory|default=<undefined>: temporary files directory
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    output_file: generic/file
+    # type=file: output file
+    # type=file|default=<undefined>: output file
+    sd_file: generic/file
+    # type=file: standard deviation image
+    # type=file|default=<undefined>: Place standard deviation image in specified file.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    output_file: output_file
+    # type=file: output file
+    # type=file|default=<undefined>: output file
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    input_files:
+    # type=inputmultiobject|default=[]: input file(s)
+    output_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output file
+    verbose:
+    # type=bool|default=False: Print out log messages. Default: False.
+    clobber:
+    # type=bool|default=True: Overwrite existing file.
+    output_float:
+    # type=bool|default=False: Output files with float precision.
+    robust:
+    # type=bool|default=False: Perform robust averaging, features that are outside 1 standarddeviation from the mean are downweighted. Works well for noisydata with artifacts. see the --tmpdir option if you have alarge number of input files.
+    tmpdir:
+    # type=directory|default=<undefined>: temporary files directory
+    sd_file:
+    # type=file: standard deviation image
+    # type=file|default=<undefined>: Place standard deviation image in specified file.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-minc/big_average_callables.py b/example-specs/task/nipype_internal/pydra-minc/big_average_callables.py
new file mode 100644
index 00000000..ba427eaa
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-minc/big_average_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in BigAverage.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-minc/blob.yaml b/example-specs/task/nipype_internal/pydra-minc/blob.yaml
new file mode 100644
index 00000000..9f9ab901
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-minc/blob.yaml
@@ -0,0 +1,97 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.minc.minc.Blob' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Calculate blobs from minc deformation grids.
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces.minc import Blob
+#     >>> from nipype.interfaces.minc.testdata import minc2Dfile
+# 
+#     >>> blob = Blob(input_file=minc2Dfile, output_file='/tmp/tmp.mnc', trace=True)
+#     >>> blob.run() # doctest: +SKIP
+#     
+task_name: Blob
+nipype_name: Blob
+nipype_module: nipype.interfaces.minc.minc
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    input_file: generic/file
+    # type=file|default=<undefined>: input file to blob
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    output_file: generic/file
+    # type=file: output file
+    # type=file|default=<undefined>: output file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    output_file: output_file
+    # type=file: output file
+    # type=file|default=<undefined>: output file
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    input_file:
+    # type=file|default=<undefined>: input file to blob
+    output_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output file
+    trace:
+    # type=bool|default=False: compute the trace (approximate growth and shrinkage) -- FAST
+    determinant:
+    # type=bool|default=False: compute the determinant (exact growth and shrinkage) -- SLOW
+    translation:
+    # type=bool|default=False: compute translation (structure displacement)
+    magnitude:
+    # type=bool|default=False: compute the magnitude of the displacement vector
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-minc/blob_callables.py b/example-specs/task/nipype_internal/pydra-minc/blob_callables.py
new file mode 100644
index 00000000..39913d7f
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-minc/blob_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Blob.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-minc/blur.yaml b/example-specs/task/nipype_internal/pydra-minc/blur.yaml
new file mode 100644
index 00000000..37fe9974
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-minc/blur.yaml
@@ -0,0 +1,140 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.minc.minc.Blur' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Convolve an input volume with a Gaussian blurring kernel of
+#     user-defined width.  Optionally, the first partial derivatives
+#     and the gradient magnitude volume can be calculated.
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces.minc import Blur
+#     >>> from nipype.interfaces.minc.testdata import minc3Dfile
+# 
+#     (1) Blur  an  input  volume with a 6mm fwhm isotropic Gaussian
+#     blurring kernel:
+# 
+#     >>> blur = Blur(input_file=minc3Dfile, fwhm=6, output_file_base='/tmp/out_6')
+#     >>> blur.run() # doctest: +SKIP
+# 
+#     mincblur will create /tmp/out_6_blur.mnc.
+# 
+#     (2) Calculate the blurred and gradient magnitude data:
+# 
+#     >>> blur = Blur(input_file=minc3Dfile, fwhm=6, gradient=True, output_file_base='/tmp/out_6')
+#     >>> blur.run() # doctest: +SKIP
+# 
+#     will create /tmp/out_6_blur.mnc and /tmp/out_6_dxyz.mnc.
+# 
+#     (3) Calculate the blurred data, the partial derivative volumes
+#     and  the gradient magnitude for the same data:
+# 
+#     >>> blur = Blur(input_file=minc3Dfile, fwhm=6, partial=True, output_file_base='/tmp/out_6')
+#     >>> blur.run() # doctest: +SKIP
+# 
+#     will create /tmp/out_6_blur.mnc, /tmp/out_6_dx.mnc,
+#     /tmp/out_6_dy.mnc, /tmp/out_6_dz.mnc and /tmp/out_6_dxyz.mnc.
+#     
+task_name: Blur
+nipype_name: Blur
+nipype_module: nipype.interfaces.minc.minc
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    input_file: generic/file
+    # type=file|default=<undefined>: input file
+    output_file_base: generic/file
+    # type=file|default=<undefined>: output file base
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    output_file: generic/file
+    # type=file: Blurred output file.
+    gradient_dxyz: generic/file
+    # type=file: Gradient dxyz.
+    partial_dx: generic/file
+    # type=file: Partial gradient dx.
+    partial_dy: generic/file
+    # type=file: Partial gradient dy.
+    partial_dz: generic/file
+    # type=file: Partial gradient dz.
+    partial_dxyz: generic/file
+    # type=file: Partial gradient dxyz.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    input_file:
+    # type=file|default=<undefined>: input file
+    output_file_base:
+    # type=file|default=<undefined>: output file base
+    clobber:
+    # type=bool|default=True: Overwrite existing file.
+    gaussian:
+    # type=bool|default=False: Use a gaussian smoothing kernel (default).
+    rect:
+    # type=bool|default=False: Use a rect (box) smoothing kernel.
+    gradient:
+    # type=bool|default=False: Create the gradient magnitude volume as well.
+    partial:
+    # type=bool|default=False: Create the partial derivative and gradient magnitude volumes as well.
+    no_apodize:
+    # type=bool|default=False: Do not apodize the data before blurring.
+    fwhm:
+    # type=float|default=0: Full-width-half-maximum of gaussian kernel. Default value: 0.
+    standard_dev:
+    # type=float|default=0: Standard deviation of gaussian kernel. Default value: 0.
+    fwhm3d:
+    # type=tuple|default=(0.0, 0.0, 0.0): Full-width-half-maximum of gaussian kernel.Default value: -1.79769e+308 -1.79769e+308 -1.79769e+308.
+    dimensions:
+    # type=enum|default=3|allowed[1,2,3]: Number of dimensions to blur (either 1,2 or 3). Default value: 3.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-minc/blur_callables.py b/example-specs/task/nipype_internal/pydra-minc/blur_callables.py
new file mode 100644
index 00000000..3373f83b
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-minc/blur_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Blur.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-minc/calc.yaml b/example-specs/task/nipype_internal/pydra-minc/calc.yaml
new file mode 100644
index 00000000..5b9b49eb
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-minc/calc.yaml
@@ -0,0 +1,155 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.minc.minc.Calc' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Compute an expression using MINC files as input.
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces.minc import Calc
+#     >>> from nipype.interfaces.minc.testdata import nonempty_minc_data
+# 
+#     >>> file0 = nonempty_minc_data(0)
+#     >>> file1 = nonempty_minc_data(1)
+#     >>> calc = Calc(input_files=[file0, file1], output_file='/tmp/calc.mnc', expression='A[0] + A[1]') # add files together
+#     >>> calc.run() # doctest: +SKIP
+#     
+task_name: Calc
+nipype_name: Calc
+nipype_module: nipype.interfaces.minc.minc
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    input_files: generic/file+list-of
+    # type=inputmultiobject|default=[]: input file(s) for calculation
+    filelist: generic/file
+    # type=file|default=<undefined>: Specify the name of a file containing input file names.
+    expfile: generic/file
+    # type=file|default=<undefined>: Name of file containing expression.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    output_file: generic/file
+    # type=file: output file
+    # type=file|default=<undefined>: output file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    output_file: output_file
+    # type=file: output file
+    # type=file|default=<undefined>: output file
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    input_files:
+    # type=inputmultiobject|default=[]: input file(s) for calculation
+    output_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output file
+    two:
+    # type=bool|default=False: Create a MINC 2 output file.
+    clobber:
+    # type=bool|default=True: Overwrite existing file.
+    verbose:
+    # type=bool|default=False: Print out log messages (default).
+    quiet:
+    # type=bool|default=False: Do not print out log messages.
+    debug:
+    # type=bool|default=False: Print out debugging messages.
+    filelist:
+    # type=file|default=<undefined>: Specify the name of a file containing input file names.
+    copy_header:
+    # type=bool|default=False: Copy all of the header from the first file.
+    no_copy_header:
+    # type=bool|default=False: Do not copy all of the header from the first file.
+    format_filetype:
+    # type=bool|default=False: Use data type of first file (default).
+    format_byte:
+    # type=bool|default=False: Write out byte data.
+    format_short:
+    # type=bool|default=False: Write out short integer data.
+    format_int:
+    # type=bool|default=False: Write out 32-bit integer data.
+    format_long:
+    # type=bool|default=False: Superseded by -int.
+    format_float:
+    # type=bool|default=False: Write out single-precision floating-point data.
+    format_double:
+    # type=bool|default=False: Write out double-precision floating-point data.
+    format_signed:
+    # type=bool|default=False: Write signed integer data.
+    format_unsigned:
+    # type=bool|default=False: Write unsigned integer data (default).
+    voxel_range:
+    # type=tuple|default=(0, 0): Valid range for output data.
+    max_buffer_size_in_kb:
+    # type=range|default=0: Specify the maximum size of the internal buffers (in kbytes).
+    check_dimensions:
+    # type=bool|default=False: Check that files have matching dimensions (default).
+    no_check_dimensions:
+    # type=bool|default=False: Do not check that files have matching dimensions.
+    ignore_nan:
+    # type=bool|default=False: Ignore invalid data (NaN) for accumulations.
+    propagate_nan:
+    # type=bool|default=False: Invalid data in any file at a voxel produces a NaN (default).
+    output_nan:
+    # type=bool|default=False: Output NaN when an illegal operation is done (default).
+    output_zero:
+    # type=bool|default=False: Output zero when an illegal operation is done.
+    output_illegal:
+    # type=bool|default=False: Value to write out when an illegal operation is done. Default value: 1.79769e+308
+    expression:
+    # type=str|default='': Expression to use in calculations.
+    expfile:
+    # type=file|default=<undefined>: Name of file containing expression.
+    outfiles:
+    # type=list|default=[]: 
+    eval_width:
+    # type=int|default=0: Number of voxels to evaluate simultaneously.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-minc/calc_callables.py b/example-specs/task/nipype_internal/pydra-minc/calc_callables.py
new file mode 100644
index 00000000..e7ff3fa7
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-minc/calc_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Calc.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-minc/convert.yaml b/example-specs/task/nipype_internal/pydra-minc/convert.yaml
new file mode 100644
index 00000000..4c9cb4f1
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-minc/convert.yaml
@@ -0,0 +1,98 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.minc.minc.Convert' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# convert between MINC 1 to MINC 2 format.
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces.minc import Convert
+#     >>> from nipype.interfaces.minc.testdata import minc2Dfile
+#     >>> c = Convert(input_file=minc2Dfile, output_file='/tmp/out.mnc', two=True) # Convert to MINC2 format.
+#     >>> c.run() # doctest: +SKIP
+#     
+task_name: Convert
+nipype_name: Convert
+nipype_module: nipype.interfaces.minc.minc
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    input_file: generic/file
+    # type=file|default=<undefined>: input file for converting
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    output_file: generic/file
+    # type=file: output file
+    # type=file|default=<undefined>: output file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    output_file: output_file
+    # type=file: output file
+    # type=file|default=<undefined>: output file
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    input_file:
+    # type=file|default=<undefined>: input file for converting
+    output_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output file
+    clobber:
+    # type=bool|default=True: Overwrite existing file.
+    two:
+    # type=bool|default=False: Create a MINC 2 output file.
+    template:
+    # type=bool|default=False: Create a template file. The dimensions, variables, andattributes of the input file are preserved but all data it set to zero.
+    compression:
+    # type=enum|default=0|allowed[0,1,2,3,4,5,6,7,8,9]: Set the compression level, from 0 (disabled) to 9 (maximum).
+    chunk:
+    # type=range|default=0: Set the target block size for chunking (0 default, >1 block size).
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-minc/convert_callables.py b/example-specs/task/nipype_internal/pydra-minc/convert_callables.py
new file mode 100644
index 00000000..4ff69023
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-minc/convert_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Convert.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-minc/copy.yaml b/example-specs/task/nipype_internal/pydra-minc/copy.yaml
new file mode 100644
index 00000000..6b312bb8
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-minc/copy.yaml
@@ -0,0 +1,92 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.minc.minc.Copy' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Copy image values from one MINC file to another. Both the input
+#     and output files must exist, and the images in both files must
+#     have an equal number dimensions and equal dimension lengths.
+# 
+#     NOTE: This program is intended primarily for use with scripts
+#     such as mincedit. It does not follow the typical design rules of
+#     most MINC command-line tools and therefore should be used only
+#     with caution.
+#     
+task_name: Copy
+nipype_name: Copy
+nipype_module: nipype.interfaces.minc.minc
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    input_file: generic/file
+    # type=file|default=<undefined>: input file to copy
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    output_file: generic/file
+    # type=file: output file
+    # type=file|default=<undefined>: output file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    output_file: output_file
+    # type=file: output file
+    # type=file|default=<undefined>: output file
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    input_file:
+    # type=file|default=<undefined>: input file to copy
+    output_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output file
+    pixel_values:
+    # type=bool|default=False: Copy pixel values as is.
+    real_values:
+    # type=bool|default=False: Copy real pixel intensities (default).
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-minc/copy_callables.py b/example-specs/task/nipype_internal/pydra-minc/copy_callables.py
new file mode 100644
index 00000000..df0aabd9
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-minc/copy_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Copy.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-minc/dump.yaml b/example-specs/task/nipype_internal/pydra-minc/dump.yaml
new file mode 100644
index 00000000..ff86a8e4
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-minc/dump.yaml
@@ -0,0 +1,113 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.minc.minc.Dump' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Dump a MINC file. Typically used in conjunction with mincgen (see Gen).
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces.minc import Dump
+#     >>> from nipype.interfaces.minc.testdata import minc2Dfile
+# 
+#     >>> dump = Dump(input_file=minc2Dfile)
+#     >>> dump.run() # doctest: +SKIP
+# 
+#     >>> dump = Dump(input_file=minc2Dfile, output_file='/tmp/out.txt', precision=(3, 4))
+#     >>> dump.run() # doctest: +SKIP
+# 
+#     
+task_name: Dump
+nipype_name: Dump
+nipype_module: nipype.interfaces.minc.minc
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    input_file: generic/file
+    # type=file|default=<undefined>: input file
+    output_file: generic/file
+    # type=file: output file
+    # type=file|default=<undefined>: output file
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    output_file: generic/file
+    # type=file: output file
+    # type=file|default=<undefined>: output file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: out_file
+    # type=file|default=<undefined>: 
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    input_file:
+    # type=file|default=<undefined>: input file
+    output_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output file
+    coordinate_data:
+    # type=bool|default=False: Coordinate variable data and header information.
+    header_data:
+    # type=bool|default=False: Header information only, no data.
+    annotations_brief:
+    # type=enum|default='c'|allowed['c','f']: Brief annotations for C or Fortran indices in data.
+    annotations_full:
+    # type=enum|default='c'|allowed['c','f']: Full annotations for C or Fortran indices in data.
+    variables:
+    # type=inputmultiobject|default=[]: Output data for specified variables only.
+    line_length:
+    # type=range|default=0: Line length maximum in data section (default 80).
+    netcdf_name:
+    # type=str|default='': Name for netCDF (default derived from file name).
+    precision:
+    # type=traitcompound|default=None: Display floating-point values with less precision
+    out_file:
+    # type=file|default=<undefined>: 
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-minc/dump_callables.py b/example-specs/task/nipype_internal/pydra-minc/dump_callables.py
new file mode 100644
index 00000000..26912dad
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-minc/dump_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Dump.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-minc/extract.yaml b/example-specs/task/nipype_internal/pydra-minc/extract.yaml
new file mode 100644
index 00000000..2d80d5de
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-minc/extract.yaml
@@ -0,0 +1,154 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.minc.minc.Extract' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Dump a hyperslab of MINC file data.
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces.minc import Extract
+#     >>> from nipype.interfaces.minc.testdata import minc2Dfile
+# 
+#     >>> extract = Extract(input_file=minc2Dfile)
+#     >>> extract.run() # doctest: +SKIP
+# 
+#     >>> extract = Extract(input_file=minc2Dfile, start=[3, 10, 5], count=[4, 4, 4]) # extract a 4x4x4 slab at offset [3, 10, 5]
+#     >>> extract.run() # doctest: +SKIP
+#     
+task_name: Extract
+nipype_name: Extract
+nipype_module: nipype.interfaces.minc.minc
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    input_file: generic/file
+    # type=file|default=<undefined>: input file
+    output_file: generic/file
+    # type=file: output file in raw/text format
+    # type=file|default=<undefined>: output file
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    output_file: generic/file
+    # type=file: output file in raw/text format
+    # type=file|default=<undefined>: output file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: out_file
+    # type=file|default=<undefined>: 
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    input_file:
+    # type=file|default=<undefined>: input file
+    output_file:
+    # type=file: output file in raw/text format
+    # type=file|default=<undefined>: output file
+    write_ascii:
+    # type=bool|default=False: Write out data as ascii strings (default).
+    write_byte:
+    # type=bool|default=False: Write out data as bytes.
+    write_short:
+    # type=bool|default=False: Write out data as short integers.
+    write_int:
+    # type=bool|default=False: Write out data as 32-bit integers.
+    write_long:
+    # type=bool|default=False: Superseded by write_int.
+    write_float:
+    # type=bool|default=False: Write out data as single precision floating-point values.
+    write_double:
+    # type=bool|default=False: Write out data as double precision floating-point values.
+    write_signed:
+    # type=bool|default=False: Write out signed data.
+    write_unsigned:
+    # type=bool|default=False: Write out unsigned data.
+    write_range:
+    # type=tuple|default=(0.0, 0.0): Specify the range of output values Default value: 1.79769e+308 1.79769e+308.
+    normalize:
+    # type=bool|default=False: Normalize integer pixel values to file max and min.
+    nonormalize:
+    # type=bool|default=False: Turn off pixel normalization.
+    image_range:
+    # type=tuple|default=(0.0, 0.0): Specify the range of real image values for normalization.
+    image_minimum:
+    # type=float|default=0.0: Specify the minimum real image value for normalization.Default value: 1.79769e+308.
+    image_maximum:
+    # type=float|default=0.0: Specify the maximum real image value for normalization.Default value: 1.79769e+308.
+    start:
+    # type=inputmultiobject|default=[]: Specifies corner of hyperslab (C conventions for indices).
+    count:
+    # type=inputmultiobject|default=[]: Specifies edge lengths of hyperslab to read.
+    flip_positive_direction:
+    # type=bool|default=False: Flip images to always have positive direction.
+    flip_negative_direction:
+    # type=bool|default=False: Flip images to always have negative direction.
+    flip_any_direction:
+    # type=bool|default=False: Do not flip images (Default).
+    flip_x_positive:
+    # type=bool|default=False: Flip images to give positive xspace:step value (left-to-right).
+    flip_x_negative:
+    # type=bool|default=False: Flip images to give negative xspace:step value (right-to-left).
+    flip_x_any:
+    # type=bool|default=False: Don't flip images along x-axis (default).
+    flip_y_positive:
+    # type=bool|default=False: Flip images to give positive yspace:step value (post-to-ant).
+    flip_y_negative:
+    # type=bool|default=False: Flip images to give negative yspace:step value (ant-to-post).
+    flip_y_any:
+    # type=bool|default=False: Don't flip images along y-axis (default).
+    flip_z_positive:
+    # type=bool|default=False: Flip images to give positive zspace:step value (inf-to-sup).
+    flip_z_negative:
+    # type=bool|default=False: Flip images to give negative zspace:step value (sup-to-inf).
+    flip_z_any:
+    # type=bool|default=False: Don't flip images along z-axis (default).
+    out_file:
+    # type=file|default=<undefined>: 
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-minc/extract_callables.py b/example-specs/task/nipype_internal/pydra-minc/extract_callables.py
new file mode 100644
index 00000000..40b78e07
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-minc/extract_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Extract.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-minc/gennlxfm.yaml b/example-specs/task/nipype_internal/pydra-minc/gennlxfm.yaml
new file mode 100644
index 00000000..c19b38ce
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-minc/gennlxfm.yaml
@@ -0,0 +1,104 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.minc.minc.Gennlxfm' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Generate nonlinear xfms. Currently only identity xfms
+#     are supported!
+# 
+#     This tool is part of minc-widgets:
+# 
+#     https://github.com/BIC-MNI/minc-widgets/blob/master/gennlxfm/gennlxfm
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces.minc import Gennlxfm
+#     >>> from nipype.interfaces.minc.testdata import minc2Dfile
+#     >>> gennlxfm = Gennlxfm(step=1, like=minc2Dfile)
+#     >>> gennlxfm.run() # doctest: +SKIP
+# 
+#     
+task_name: Gennlxfm
+nipype_name: Gennlxfm
+nipype_module: nipype.interfaces.minc.minc
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    like: generic/file
+    # type=file|default=<undefined>: Generate a nlxfm like this file.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    output_file: generic/file
+    # type=file: output file
+    # type=file|default=<undefined>: output file
+    output_grid: generic/file
+    # type=file: output grid
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    output_file: output_file
+    # type=file: output file
+    # type=file|default=<undefined>: output file
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    output_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output file
+    verbose:
+    # type=bool|default=False: Print out log messages. Default: False.
+    clobber:
+    # type=bool|default=True: Overwrite existing file.
+    ident:
+    # type=bool|default=False: Generate an identity xfm. Default: False.
+    step:
+    # type=int|default=0: Output ident xfm step [default: 1].
+    like:
+    # type=file|default=<undefined>: Generate a nlxfm like this file.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-minc/gennlxfm_callables.py b/example-specs/task/nipype_internal/pydra-minc/gennlxfm_callables.py
new file mode 100644
index 00000000..440b54e0
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-minc/gennlxfm_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Gennlxfm.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-minc/math.yaml b/example-specs/task/nipype_internal/pydra-minc/math.yaml
new file mode 100644
index 00000000..6c75ef19
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-minc/math.yaml
@@ -0,0 +1,205 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.minc.minc.Math' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Various mathematical operations supplied by mincmath.
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces.minc import Math
+#     >>> from nipype.interfaces.minc.testdata import minc2Dfile
+# 
+#     Scale: volume*3.0 + 2:
+# 
+#     >>> scale = Math(input_files=[minc2Dfile], scale=(3.0, 2))
+#     >>> scale.run() # doctest: +SKIP
+# 
+#     Test if >= 1.5:
+# 
+#     >>> gt = Math(input_files=[minc2Dfile], test_gt=1.5)
+#     >>> gt.run() # doctest: +SKIP
+#     
+task_name: Math
+nipype_name: Math
+nipype_module: nipype.interfaces.minc.minc
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    input_files: generic/file+list-of
+    # type=inputmultiobject|default=[]: input file(s) for calculation
+    filelist: generic/file
+    # type=file|default=<undefined>: Specify the name of a file containing input file names.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    output_file: generic/file
+    # type=file: output file
+    # type=file|default=<undefined>: output file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    output_file: output_file
+    # type=file: output file
+    # type=file|default=<undefined>: output file
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    input_files:
+    # type=inputmultiobject|default=[]: input file(s) for calculation
+    output_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output file
+    filelist:
+    # type=file|default=<undefined>: Specify the name of a file containing input file names.
+    clobber:
+    # type=bool|default=True: Overwrite existing file.
+    two:
+    # type=bool|default=False: Create a MINC 2 output file.
+    copy_header:
+    # type=bool|default=False: Copy all of the header from the first file (default for one file).
+    no_copy_header:
+    # type=bool|default=False: Do not copy all of the header from the first file (default for many files)).
+    format_filetype:
+    # type=bool|default=False: Use data type of first file (default).
+    format_byte:
+    # type=bool|default=False: Write out byte data.
+    format_short:
+    # type=bool|default=False: Write out short integer data.
+    format_int:
+    # type=bool|default=False: Write out 32-bit integer data.
+    format_long:
+    # type=bool|default=False: Superseded by -int.
+    format_float:
+    # type=bool|default=False: Write out single-precision floating-point data.
+    format_double:
+    # type=bool|default=False: Write out double-precision floating-point data.
+    format_signed:
+    # type=bool|default=False: Write signed integer data.
+    format_unsigned:
+    # type=bool|default=False: Write unsigned integer data (default).
+    voxel_range:
+    # type=tuple|default=(0, 0): Valid range for output data.
+    max_buffer_size_in_kb:
+    # type=range|default=4096: Specify the maximum size of the internal buffers (in kbytes).
+    check_dimensions:
+    # type=bool|default=False: Check that dimension info matches across files (default).
+    no_check_dimensions:
+    # type=bool|default=False: Do not check dimension info.
+    dimension:
+    # type=str|default='': Specify a dimension along which we wish to perform a calculation.
+    ignore_nan:
+    # type=bool|default=False: Ignore invalid data (NaN) for accumulations.
+    propagate_nan:
+    # type=bool|default=False: Invalid data in any file at a voxel produces a NaN (default).
+    output_nan:
+    # type=bool|default=False: Output NaN when an illegal operation is done (default).
+    output_zero:
+    # type=bool|default=False: Output zero when an illegal operation is done.
+    output_illegal:
+    # type=bool|default=False: Value to write out when an illegal operationis done. Default value: 1.79769e+308
+    test_gt:
+    # type=traitcompound|default=None: Test for vol1 > vol2 or vol1 > constant.
+    test_lt:
+    # type=traitcompound|default=None: Test for vol1 < vol2 or vol1 < constant.
+    test_eq:
+    # type=traitcompound|default=None: Test for integer vol1 == vol2 or vol1 == constant.
+    test_ne:
+    # type=traitcompound|default=None: Test for integer vol1 != vol2 or vol1 != const.
+    test_ge:
+    # type=traitcompound|default=None: Test for vol1 >= vol2 or vol1 >= const.
+    test_le:
+    # type=traitcompound|default=None: Test for vol1 <= vol2 or vol1 <= const.
+    calc_add:
+    # type=traitcompound|default=None: Add N volumes or volume + constant.
+    calc_sub:
+    # type=traitcompound|default=None: Subtract 2 volumes or volume - constant.
+    calc_mul:
+    # type=traitcompound|default=None: Multiply N volumes or volume * constant.
+    calc_div:
+    # type=traitcompound|default=None: Divide 2 volumes or volume / constant.
+    invert:
+    # type=float|default=None: Calculate 1/c.
+    calc_not:
+    # type=bool|default=False: Calculate !vol1.
+    sqrt:
+    # type=bool|default=False: Take square root of a volume.
+    square:
+    # type=bool|default=False: Take square of a volume.
+    abs:
+    # type=bool|default=False: Take absolute value of a volume.
+    exp:
+    # type=tuple|default=(0.0, 0.0): Calculate c2*exp(c1*x). Both constants must be specified.
+    log:
+    # type=tuple|default=(0.0, 0.0): Calculate log(x/c2)/c1. The constants c1 and c2 default to 1.
+    scale:
+    # type=tuple|default=(0.0, 0.0): Scale a volume: volume * c1 + c2.
+    clamp:
+    # type=tuple|default=(0.0, 0.0): Clamp a volume to lie between two values.
+    segment:
+    # type=tuple|default=(0.0, 0.0): Segment a volume using range of -const2: within range = 1, outside range = 0.
+    nsegment:
+    # type=tuple|default=(0.0, 0.0): Opposite of -segment: within range = 0, outside range = 1.
+    isnan:
+    # type=bool|default=False: Test for NaN values in vol1.
+    nisnan:
+    # type=bool|default=False: Negation of -isnan.
+    percentdiff:
+    # type=float|default=0.0: Percent difference between 2 volumes, thresholded (const def=0.0).
+    count_valid:
+    # type=bool|default=False: Count the number of valid values in N volumes.
+    maximum:
+    # type=bool|default=False: Find maximum of N volumes.
+    minimum:
+    # type=bool|default=False: Find minimum of N volumes.
+    calc_and:
+    # type=bool|default=False: Calculate vol1 && vol2 (&& ...).
+    calc_or:
+    # type=bool|default=False: Calculate vol1 || vol2 (|| ...).
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-minc/math_callables.py b/example-specs/task/nipype_internal/pydra-minc/math_callables.py
new file mode 100644
index 00000000..a8b328fe
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-minc/math_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Math.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-minc/nlp_fit.yaml b/example-specs/task/nipype_internal/pydra-minc/nlp_fit.yaml
new file mode 100644
index 00000000..ac294203
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-minc/nlp_fit.yaml
@@ -0,0 +1,125 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.minc.minc.NlpFit' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Hierarchial non-linear fitting with bluring.
+# 
+#     This tool is part of the minc-widgets package:
+# 
+#     https://github.com/BIC-MNI/minc-widgets/blob/master/nlpfit/nlpfit
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces.minc import NlpFit
+#     >>> from nipype.interfaces.minc.testdata import nonempty_minc_data, nlp_config
+#     >>> from nipype.testing import example_data
+# 
+#     >>> source = nonempty_minc_data(0)
+#     >>> target = nonempty_minc_data(1)
+#     >>> source_mask = nonempty_minc_data(2)
+#     >>> config = nlp_config
+#     >>> initial = example_data('minc_initial.xfm')
+#     >>> nlpfit = NlpFit(config_file=config, init_xfm=initial, source_mask=source_mask, source=source, target=target)
+#     >>> nlpfit.run() # doctest: +SKIP
+#     
+task_name: NlpFit
+nipype_name: NlpFit
+nipype_module: nipype.interfaces.minc.minc
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    source: generic/file
+    # type=file|default=<undefined>: source Minc file
+    target: generic/file
+    # type=file|default=<undefined>: target Minc file
+    input_grid_files: generic/file+list-of
+    # type=inputmultiobject|default=[]: input grid file(s)
+    config_file: generic/file
+    # type=file|default=<undefined>: File containing the fitting configuration use.
+    init_xfm: generic/file
+    # type=file|default=<undefined>: Initial transformation (default identity).
+    source_mask: generic/file
+    # type=file|default=<undefined>: Source mask to use during fitting.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    output_xfm: generic/file
+    # type=file: output xfm file
+    # type=file|default=<undefined>: output xfm file
+    output_grid: generic/file
+    # type=file: output grid file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    output_xfm: output_xfm
+    # type=file: output xfm file
+    # type=file|default=<undefined>: output xfm file
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    source:
+    # type=file|default=<undefined>: source Minc file
+    target:
+    # type=file|default=<undefined>: target Minc file
+    output_xfm:
+    # type=file: output xfm file
+    # type=file|default=<undefined>: output xfm file
+    input_grid_files:
+    # type=inputmultiobject|default=[]: input grid file(s)
+    config_file:
+    # type=file|default=<undefined>: File containing the fitting configuration use.
+    init_xfm:
+    # type=file|default=<undefined>: Initial transformation (default identity).
+    source_mask:
+    # type=file|default=<undefined>: Source mask to use during fitting.
+    verbose:
+    # type=bool|default=False: Print out log messages. Default: False.
+    clobber:
+    # type=bool|default=True: Overwrite existing file.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-minc/nlp_fit_callables.py b/example-specs/task/nipype_internal/pydra-minc/nlp_fit_callables.py
new file mode 100644
index 00000000..cb7f93a2
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-minc/nlp_fit_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in NlpFit.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-minc/norm.yaml b/example-specs/task/nipype_internal/pydra-minc/norm.yaml
new file mode 100644
index 00000000..e048d8c7
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-minc/norm.yaml
@@ -0,0 +1,124 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.minc.minc.Norm' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Normalise a file between a max and minimum (possibly)
+#        using two histogram pct's.
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces.minc import Norm
+#     >>> from nipype.interfaces.minc.testdata import minc2Dfile
+#     >>> n = Norm(input_file=minc2Dfile, output_file='/tmp/out.mnc') # Normalise the file.
+#     >>> n.run() # doctest: +SKIP
+#     
+task_name: Norm
+nipype_name: Norm
+nipype_module: nipype.interfaces.minc.minc
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    input_file: generic/file
+    # type=file|default=<undefined>: input file to normalise
+    output_threshold_mask: generic/file
+    # type=file: threshold mask file
+    # type=file|default=<undefined>: File in which to store the threshold mask.
+    mask: generic/file
+    # type=file|default=<undefined>: Calculate the image normalisation within a mask.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    output_file: generic/file
+    # type=file: output file
+    # type=file|default=<undefined>: output file
+    output_threshold_mask: generic/file
+    # type=file: threshold mask file
+    # type=file|default=<undefined>: File in which to store the threshold mask.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    output_file: output_file
+    # type=file: output file
+    # type=file|default=<undefined>: output file
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    input_file:
+    # type=file|default=<undefined>: input file to normalise
+    output_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output file
+    output_threshold_mask:
+    # type=file: threshold mask file
+    # type=file|default=<undefined>: File in which to store the threshold mask.
+    clobber:
+    # type=bool|default=True: Overwrite existing file.
+    mask:
+    # type=file|default=<undefined>: Calculate the image normalisation within a mask.
+    clamp:
+    # type=bool|default=True: Force the output range between limits [default].
+    cutoff:
+    # type=range|default=0.0: Cutoff value to use to calculate thresholds by a histogram PcT in %. [default: 0.01]
+    lower:
+    # type=float|default=0.0: Lower real value to use.
+    upper:
+    # type=float|default=0.0: Upper real value to use.
+    out_floor:
+    # type=float|default=0.0: Output files maximum [default: 0]
+    out_ceil:
+    # type=float|default=0.0: Output files minimum [default: 100]
+    threshold:
+    # type=bool|default=False: Threshold the image (set values below threshold_perc to -out_floor).
+    threshold_perc:
+    # type=range|default=0.0: Threshold percentage (0.1 == lower 10% of intensity range) [default: 0.1].
+    threshold_bmt:
+    # type=bool|default=False: Use the resulting image BiModalT as the threshold.
+    threshold_blur:
+    # type=float|default=0.0: Blur FWHM for intensity edges then thresholding [default: 2].
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-minc/norm_callables.py b/example-specs/task/nipype_internal/pydra-minc/norm_callables.py
new file mode 100644
index 00000000..866c8ed5
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-minc/norm_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Norm.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-minc/pik.yaml b/example-specs/task/nipype_internal/pydra-minc/pik.yaml
new file mode 100644
index 00000000..ccce436b
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-minc/pik.yaml
@@ -0,0 +1,140 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.minc.minc.Pik' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Generate images from minc files.
+# 
+#     Mincpik uses Imagemagick to generate images
+#     from Minc files.
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces.minc import Pik
+#     >>> from nipype.interfaces.minc.testdata import nonempty_minc_data
+# 
+#     >>> file0 = nonempty_minc_data(0)
+#     >>> pik = Pik(input_file=file0, title='foo')
+#     >>> pik .run() # doctest: +SKIP
+# 
+#     
+task_name: Pik
+nipype_name: Pik
+nipype_module: nipype.interfaces.minc.minc
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    input_file: generic/file
+    # type=file|default=<undefined>: input file
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    output_file: generic/file
+    # type=file: output image
+    # type=file|default=<undefined>: output file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    output_file: output_file
+    # type=file: output image
+    # type=file|default=<undefined>: output file
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    input_file:
+    # type=file|default=<undefined>: input file
+    jpg:
+    # type=bool|default=False: Output a jpg file.
+    png:
+    # type=bool|default=False: Output a png file (default).
+    output_file:
+    # type=file: output image
+    # type=file|default=<undefined>: output file
+    clobber:
+    # type=bool|default=True: Overwrite existing file.
+    scale:
+    # type=int|default=2: Scaling factor for resulting image. By default images areoutput at twice their original resolution.
+    width:
+    # type=int|default=0: Autoscale the resulting image to have a fixed image width (in pixels).
+    depth:
+    # type=enum|default=8|allowed[16,8]: Bitdepth for resulting image 8 or 16 (MSB machines only!)
+    title:
+    # type=traitcompound|default=None: 
+    title_size:
+    # type=int|default=0: Font point size for the title.
+    annotated_bar:
+    # type=bool|default=False: create an annotated bar to match the image (use height of the output image)
+    minc_range:
+    # type=tuple|default=(0.0, 0.0): Valid range of values for MINC file.
+    image_range:
+    # type=tuple|default=(0.0, 0.0): Range of image values to use for pixel intensity.
+    auto_range:
+    # type=bool|default=False: Automatically determine image range using a 5 and 95% PcT. (histogram)
+    start:
+    # type=int|default=0: Slice number to get. (note this is in voxel coordinates).
+    slice_z:
+    # type=bool|default=False: Get an axial/transverse (z) slice.
+    slice_y:
+    # type=bool|default=False: Get a coronal (y) slice.
+    slice_x:
+    # type=bool|default=False: Get a sagittal (x) slice.
+    triplanar:
+    # type=bool|default=False: Create a triplanar view of the input file.
+    tile_size:
+    # type=int|default=0: Pixel size for each image in a triplanar.
+    sagittal_offset:
+    # type=int|default=0: Offset the sagittal slice from the centre.
+    sagittal_offset_perc:
+    # type=range|default=0: Offset the sagittal slice by a percentage from the centre.
+    vertical_triplanar_view:
+    # type=bool|default=False: Create a vertical triplanar view (Default).
+    horizontal_triplanar_view:
+    # type=bool|default=False: Create a horizontal triplanar view.
+    lookup:
+    # type=str|default='': Arguments to pass to minclookup
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-minc/pik_callables.py b/example-specs/task/nipype_internal/pydra-minc/pik_callables.py
new file mode 100644
index 00000000..76000097
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-minc/pik_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Pik.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-minc/resample.yaml b/example-specs/task/nipype_internal/pydra-minc/resample.yaml
new file mode 100644
index 00000000..2c9d42dc
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-minc/resample.yaml
@@ -0,0 +1,202 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.minc.minc.Resample' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Resample a minc file.'
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces.minc import Resample
+#     >>> from nipype.interfaces.minc.testdata import minc2Dfile
+#     >>> r = Resample(input_file=minc2Dfile, output_file='/tmp/out.mnc') # Resample the file.
+#     >>> r.run() # doctest: +SKIP
+# 
+#     
+task_name: Resample
+nipype_name: Resample
+nipype_module: nipype.interfaces.minc.minc
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    input_file: generic/file
+    # type=file|default=<undefined>: input file for resampling
+    input_grid_files: generic/file+list-of
+    # type=inputmultiobject|default=[]: input grid file(s)
+    transformation: generic/file
+    # type=file|default=<undefined>: File giving world transformation. (Default = identity).
+    like: generic/file
+    # type=file|default=<undefined>: Specifies a model file for the resampling.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    output_file: generic/file
+    # type=file: output file
+    # type=file|default=<undefined>: output file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    output_file: output_file
+    # type=file: output file
+    # type=file|default=<undefined>: output file
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    input_file:
+    # type=file|default=<undefined>: input file for resampling
+    output_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output file
+    input_grid_files:
+    # type=inputmultiobject|default=[]: input grid file(s)
+    two:
+    # type=bool|default=False: Create a MINC 2 output file.
+    clobber:
+    # type=bool|default=True: Overwrite existing file.
+    trilinear_interpolation:
+    # type=bool|default=False: Do trilinear interpolation.
+    tricubic_interpolation:
+    # type=bool|default=False: Do tricubic interpolation.
+    nearest_neighbour_interpolation:
+    # type=bool|default=False: Do nearest neighbour interpolation.
+    sinc_interpolation:
+    # type=bool|default=False: Do windowed sinc interpolation.
+    half_width_sinc_window:
+    # type=enum|default=5|allowed[1,10,2,3,4,5,6,7,8,9]: Set half-width of sinc window (1-10). Default value: 5.
+    sinc_window_hanning:
+    # type=bool|default=False: Set sinc window type to Hanning.
+    sinc_window_hamming:
+    # type=bool|default=False: Set sinc window type to Hamming.
+    transformation:
+    # type=file|default=<undefined>: File giving world transformation. (Default = identity).
+    invert_transformation:
+    # type=bool|default=False: Invert the transformation before using it.
+    vio_transform:
+    # type=bool|default=False: VIO_Transform the input sampling with the transform (default).
+    no_input_sampling:
+    # type=bool|default=False: Use the input sampling without transforming (old behaviour).
+    like:
+    # type=file|default=<undefined>: Specifies a model file for the resampling.
+    format_byte:
+    # type=bool|default=False: Write out byte data.
+    format_short:
+    # type=bool|default=False: Write out short integer data.
+    format_int:
+    # type=bool|default=False: Write out 32-bit integer data.
+    format_long:
+    # type=bool|default=False: Superseded by -int.
+    format_float:
+    # type=bool|default=False: Write out single-precision floating-point data.
+    format_double:
+    # type=bool|default=False: Write out double-precision floating-point data.
+    format_signed:
+    # type=bool|default=False: Write signed integer data.
+    format_unsigned:
+    # type=bool|default=False: Write unsigned integer data (default).
+    output_range:
+    # type=tuple|default=(0.0, 0.0): Valid range for output data. Default value: -1.79769e+308 -1.79769e+308.
+    transverse_slices:
+    # type=bool|default=False: Write out transverse slices.
+    sagittal_slices:
+    # type=bool|default=False: Write out sagittal slices
+    coronal_slices:
+    # type=bool|default=False: Write out coronal slices
+    no_fill:
+    # type=bool|default=False: Use value zero for points outside of input volume.
+    fill:
+    # type=bool|default=False: Use a fill value for points outside of input volume.
+    fill_value:
+    # type=float|default=0.0: Specify a fill value for points outside of input volume.Default value: 1.79769e+308.
+    keep_real_range:
+    # type=bool|default=False: Keep the real scale of the input volume.
+    nokeep_real_range:
+    # type=bool|default=False: Do not keep the real scale of the data (default).
+    spacetype:
+    # type=str|default='': Set the spacetype attribute to a specified string.
+    talairach:
+    # type=bool|default=False: Output is in Talairach space.
+    origin:
+    # type=tuple|default=(0.0, 0.0, 0.0): Origin of first pixel in 3D space.Default value: 1.79769e+308 1.79769e+308 1.79769e+308.
+    standard_sampling:
+    # type=bool|default=False: Set the sampling to standard values (step, start and dircos).
+    units:
+    # type=str|default='': Specify the units of the output sampling.
+    nelements:
+    # type=tuple|default=(0, 0, 0): Number of elements along each dimension (X, Y, Z).
+    xnelements:
+    # type=int|default=0: Number of elements along the X dimension.
+    ynelements:
+    # type=int|default=0: Number of elements along the Y dimension.
+    znelements:
+    # type=int|default=0: Number of elements along the Z dimension.
+    step:
+    # type=tuple|default=(0, 0, 0): Step size along each dimension (X, Y, Z). Default value: (0, 0, 0).
+    xstep:
+    # type=int|default=0: Step size along the X dimension. Default value: 0.
+    ystep:
+    # type=int|default=0: Step size along the Y dimension. Default value: 0.
+    zstep:
+    # type=int|default=0: Step size along the Z dimension. Default value: 0.
+    start:
+    # type=tuple|default=(0.0, 0.0, 0.0): Start point along each dimension (X, Y, Z).Default value: 1.79769e+308 1.79769e+308 1.79769e+308.
+    xstart:
+    # type=float|default=0.0: Start point along the X dimension. Default value: 1.79769e+308.
+    ystart:
+    # type=float|default=0.0: Start point along the Y dimension. Default value: 1.79769e+308.
+    zstart:
+    # type=float|default=0.0: Start point along the Z dimension. Default value: 1.79769e+308.
+    dircos:
+    # type=tuple|default=(0.0, 0.0, 0.0): Direction cosines along each dimension (X, Y, Z). Default value:1.79769e+308 1.79769e+308 1.79769e+308 1.79769e+308 ...  1.79769e+308 1.79769e+308 1.79769e+308 1.79769e+308 1.79769e+308.
+    xdircos:
+    # type=float|default=0.0: Direction cosines along the X dimension.Default value: 1.79769e+308 1.79769e+308 1.79769e+308.
+    ydircos:
+    # type=float|default=0.0: Direction cosines along the Y dimension.Default value: 1.79769e+308 1.79769e+308 1.79769e+308.
+    zdircos:
+    # type=float|default=0.0: Direction cosines along the Z dimension.Default value: 1.79769e+308 1.79769e+308 1.79769e+308.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-minc/resample_callables.py b/example-specs/task/nipype_internal/pydra-minc/resample_callables.py
new file mode 100644
index 00000000..1e012806
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-minc/resample_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Resample.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-minc/reshape.yaml b/example-specs/task/nipype_internal/pydra-minc/reshape.yaml
new file mode 100644
index 00000000..885eb165
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-minc/reshape.yaml
@@ -0,0 +1,100 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.minc.minc.Reshape' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Cut a hyperslab out of a minc file, with dimension reordering.
+# 
+#     This is also useful for rewriting with a different format, for
+#     example converting to short (see example below).
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces.minc import Reshape
+#     >>> from nipype.interfaces.minc.testdata import nonempty_minc_data
+# 
+#     >>> input_file = nonempty_minc_data(0)
+#     >>> reshape_to_short = Reshape(input_file=input_file, write_short=True)
+#     >>> reshape_to_short.run() # doctest: +SKIP
+# 
+#     
+task_name: Reshape
+nipype_name: Reshape
+nipype_module: nipype.interfaces.minc.minc
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    input_file: generic/file
+    # type=file|default=<undefined>: input file
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    output_file: generic/file
+    # type=file: output file
+    # type=file|default=<undefined>: output file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    output_file: output_file
+    # type=file: output file
+    # type=file|default=<undefined>: output file
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    input_file:
+    # type=file|default=<undefined>: input file
+    output_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output file
+    verbose:
+    # type=bool|default=False: Print out log messages. Default: False.
+    clobber:
+    # type=bool|default=True: Overwrite existing file.
+    write_short:
+    # type=bool|default=False: Convert to short integer data.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-minc/reshape_callables.py b/example-specs/task/nipype_internal/pydra-minc/reshape_callables.py
new file mode 100644
index 00000000..8246e719
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-minc/reshape_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Reshape.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-minc/to_ecat.yaml b/example-specs/task/nipype_internal/pydra-minc/to_ecat.yaml
new file mode 100644
index 00000000..43db9740
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-minc/to_ecat.yaml
@@ -0,0 +1,110 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.minc.minc.ToEcat' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Convert a 2D image, a 3D volumes or a 4D dynamic volumes
+#     written in MINC file format to a 2D, 3D or 4D Ecat7 file.
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces.minc import ToEcat
+#     >>> from nipype.interfaces.minc.testdata import minc2Dfile
+# 
+#     >>> c = ToEcat(input_file=minc2Dfile)
+#     >>> c.run() # doctest: +SKIP
+# 
+#     >>> c = ToEcat(input_file=minc2Dfile, voxels_as_integers=True)
+#     >>> c.run() # doctest: +SKIP
+# 
+#     
+task_name: ToEcat
+nipype_name: ToEcat
+nipype_module: nipype.interfaces.minc.minc
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    input_file: generic/file
+    # type=file|default=<undefined>: input file to convert
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    output_file: generic/file
+    # type=file: output file
+    # type=file|default=<undefined>: output file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    output_file: output_file
+    # type=file: output file
+    # type=file|default=<undefined>: output file
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    input_file:
+    # type=file|default=<undefined>: input file to convert
+    output_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output file
+    ignore_patient_variable:
+    # type=bool|default=False: Ignore information from the minc patient variable.
+    ignore_study_variable:
+    # type=bool|default=False: Ignore information from the minc study variable.
+    ignore_acquisition_variable:
+    # type=bool|default=False: Ignore information from the minc acquisition variable.
+    ignore_ecat_acquisition_variable:
+    # type=bool|default=False: Ignore information from the minc ecat_acquisition variable.
+    ignore_ecat_main:
+    # type=bool|default=False: Ignore information from the minc ecat-main variable.
+    ignore_ecat_subheader_variable:
+    # type=bool|default=False: Ignore information from the minc ecat-subhdr variable.
+    no_decay_corr_fctr:
+    # type=bool|default=False: Do not compute the decay correction factors
+    voxels_as_integers:
+    # type=bool|default=False: Voxel values are treated as integers, scale andcalibration factors are set to unity
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-minc/to_ecat_callables.py b/example-specs/task/nipype_internal/pydra-minc/to_ecat_callables.py
new file mode 100644
index 00000000..b98e1d2e
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-minc/to_ecat_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in ToEcat.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-minc/to_raw.yaml b/example-specs/task/nipype_internal/pydra-minc/to_raw.yaml
new file mode 100644
index 00000000..75f6e01e
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-minc/to_raw.yaml
@@ -0,0 +1,119 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.minc.minc.ToRaw' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Dump a chunk of MINC file data. This program is largely
+#     superseded by mincextract (see Extract).
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces.minc import ToRaw
+#     >>> from nipype.interfaces.minc.testdata import minc2Dfile
+# 
+#     >>> toraw = ToRaw(input_file=minc2Dfile)
+#     >>> toraw.run() # doctest: +SKIP
+# 
+#     >>> toraw = ToRaw(input_file=minc2Dfile, write_range=(0, 100))
+#     >>> toraw.run() # doctest: +SKIP
+#     
+task_name: ToRaw
+nipype_name: ToRaw
+nipype_module: nipype.interfaces.minc.minc
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    input_file: generic/file
+    # type=file|default=<undefined>: input file
+    output_file: generic/file
+    # type=file: output file in raw format
+    # type=file|default=<undefined>: output file
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    output_file: generic/file
+    # type=file: output file in raw format
+    # type=file|default=<undefined>: output file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: out_file
+    # type=file|default=<undefined>: 
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    input_file:
+    # type=file|default=<undefined>: input file
+    output_file:
+    # type=file: output file in raw format
+    # type=file|default=<undefined>: output file
+    write_byte:
+    # type=bool|default=False: Write out data as bytes.
+    write_short:
+    # type=bool|default=False: Write out data as short integers.
+    write_int:
+    # type=bool|default=False: Write out data as 32-bit integers.
+    write_long:
+    # type=bool|default=False: Superseded by write_int.
+    write_float:
+    # type=bool|default=False: Write out data as single precision floating-point values.
+    write_double:
+    # type=bool|default=False: Write out data as double precision floating-point values.
+    write_signed:
+    # type=bool|default=False: Write out signed data.
+    write_unsigned:
+    # type=bool|default=False: Write out unsigned data.
+    write_range:
+    # type=tuple|default=(0.0, 0.0): Specify the range of output values.Default value: 1.79769e+308 1.79769e+308.
+    normalize:
+    # type=bool|default=False: Normalize integer pixel values to file max and min.
+    nonormalize:
+    # type=bool|default=False: Turn off pixel normalization.
+    out_file:
+    # type=file|default=<undefined>: 
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-minc/to_raw_callables.py b/example-specs/task/nipype_internal/pydra-minc/to_raw_callables.py
new file mode 100644
index 00000000..48959526
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-minc/to_raw_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in ToRaw.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-minc/vol_symm.yaml b/example-specs/task/nipype_internal/pydra-minc/vol_symm.yaml
new file mode 100644
index 00000000..3db9c3cf
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-minc/vol_symm.yaml
@@ -0,0 +1,132 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.minc.minc.VolSymm' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Make a volume symmetric about an axis either linearly
+#     and/or nonlinearly. This is done by registering a volume
+#     to a flipped image of itself.
+# 
+#     This tool is part of the minc-widgets package:
+# 
+#     https://github.com/BIC-MNI/minc-widgets/blob/master/volsymm/volsymm
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces.minc import VolSymm
+#     >>> from nipype.interfaces.minc.testdata import nonempty_minc_data
+# 
+#     >>> input_file = nonempty_minc_data(0)
+#     >>> volsymm = VolSymm(input_file=input_file)
+#     >>> volsymm.run() # doctest: +SKIP
+# 
+#     
+task_name: VolSymm
+nipype_name: VolSymm
+nipype_module: nipype.interfaces.minc.minc
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    input_file: generic/file
+    # type=file|default=<undefined>: input file
+    input_grid_files: generic/file+list-of
+    # type=inputmultiobject|default=[]: input grid file(s)
+    config_file: generic/file
+    # type=file|default=<undefined>: File containing the fitting configuration (nlpfit -help for info).
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    output_file: generic/file
+    # type=file: output file
+    # type=file|default=<undefined>: output file
+    trans_file: generic/file
+    # type=file: xfm trans file
+    # type=file|default=<undefined>: output xfm trans file
+    output_grid: generic/file
+    # type=file: output grid file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    trans_file: trans_file
+    # type=file: xfm trans file
+    # type=file|default=<undefined>: output xfm trans file
+    output_file: output_file
+    # type=file: output file
+    # type=file|default=<undefined>: output file
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    input_file:
+    # type=file|default=<undefined>: input file
+    trans_file:
+    # type=file: xfm trans file
+    # type=file|default=<undefined>: output xfm trans file
+    output_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output file
+    input_grid_files:
+    # type=inputmultiobject|default=[]: input grid file(s)
+    verbose:
+    # type=bool|default=False: Print out log messages. Default: False.
+    clobber:
+    # type=bool|default=True: Overwrite existing file.
+    fit_linear:
+    # type=bool|default=False: Fit using a linear xfm.
+    fit_nonlinear:
+    # type=bool|default=False: Fit using a non-linear xfm.
+    nofit:
+    # type=bool|default=False: Use the input transformation instead of generating one.
+    config_file:
+    # type=file|default=<undefined>: File containing the fitting configuration (nlpfit -help for info).
+    x:
+    # type=bool|default=False: Flip volume in x-plane (default).
+    y:
+    # type=bool|default=False: Flip volume in y-plane.
+    z:
+    # type=bool|default=False: Flip volume in z-plane.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-minc/vol_symm_callables.py b/example-specs/task/nipype_internal/pydra-minc/vol_symm_callables.py
new file mode 100644
index 00000000..4c7f40ab
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-minc/vol_symm_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in VolSymm.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-minc/volcentre.yaml b/example-specs/task/nipype_internal/pydra-minc/volcentre.yaml
new file mode 100644
index 00000000..1c457caa
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-minc/volcentre.yaml
@@ -0,0 +1,98 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.minc.minc.Volcentre' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Centre a MINC image's sampling about a point, typically (0,0,0).
+# 
+#     Example
+#     --------
+# 
+#     >>> from nipype.interfaces.minc import Volcentre
+#     >>> from nipype.interfaces.minc.testdata import minc2Dfile
+#     >>> vc = Volcentre(input_file=minc2Dfile)
+#     >>> vc.run() # doctest: +SKIP
+#     
+task_name: Volcentre
+nipype_name: Volcentre
+nipype_module: nipype.interfaces.minc.minc
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    input_file: generic/file
+    # type=file|default=<undefined>: input file to centre
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    output_file: generic/file
+    # type=file: output file
+    # type=file|default=<undefined>: output file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    output_file: output_file
+    # type=file: output file
+    # type=file|default=<undefined>: output file
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    input_file:
+    # type=file|default=<undefined>: input file to centre
+    output_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output file
+    verbose:
+    # type=bool|default=False: Print out log messages. Default: False.
+    clobber:
+    # type=bool|default=True: Overwrite existing file.
+    com:
+    # type=bool|default=False: Use the CoM of the volume for the new centre (via mincstats). Default: False
+    centre:
+    # type=tuple|default=(0.0, 0.0, 0.0): Centre to use (x,y,z) [default: 0 0 0].
+    zero_dircos:
+    # type=bool|default=False: Set the direction cosines to identity [default].
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-minc/volcentre_callables.py b/example-specs/task/nipype_internal/pydra-minc/volcentre_callables.py
new file mode 100644
index 00000000..70c0696b
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-minc/volcentre_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Volcentre.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-minc/voliso.yaml b/example-specs/task/nipype_internal/pydra-minc/voliso.yaml
new file mode 100644
index 00000000..e6b62b83
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-minc/voliso.yaml
@@ -0,0 +1,99 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.minc.minc.Voliso' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Changes the steps and starts in order that the output volume
+#     has isotropic sampling.
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces.minc import Voliso
+#     >>> from nipype.interfaces.minc.testdata import minc2Dfile
+#     >>> viso = Voliso(input_file=minc2Dfile, minstep=0.1, avgstep=True)
+#     >>> viso.run() # doctest: +SKIP
+#     
+task_name: Voliso
+nipype_name: Voliso
+nipype_module: nipype.interfaces.minc.minc
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    input_file: generic/file
+    # type=file|default=<undefined>: input file to convert to isotropic sampling
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    output_file: generic/file
+    # type=file: output file
+    # type=file|default=<undefined>: output file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    output_file: output_file
+    # type=file: output file
+    # type=file|default=<undefined>: output file
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    input_file:
+    # type=file|default=<undefined>: input file to convert to isotropic sampling
+    output_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output file
+    verbose:
+    # type=bool|default=False: Print out log messages. Default: False.
+    clobber:
+    # type=bool|default=True: Overwrite existing file.
+    maxstep:
+    # type=float|default=0.0: The target maximum step desired in the output volume.
+    minstep:
+    # type=float|default=0.0: The target minimum step desired in the output volume.
+    avgstep:
+    # type=bool|default=False: Calculate the maximum step from the average steps of the input volume.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-minc/voliso_callables.py b/example-specs/task/nipype_internal/pydra-minc/voliso_callables.py
new file mode 100644
index 00000000..ea4a107d
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-minc/voliso_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Voliso.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-minc/volpad.yaml b/example-specs/task/nipype_internal/pydra-minc/volpad.yaml
new file mode 100644
index 00000000..8194cfe7
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-minc/volpad.yaml
@@ -0,0 +1,102 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.minc.minc.Volpad' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Centre a MINC image's sampling about a point, typically (0,0,0).
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces.minc import Volpad
+#     >>> from nipype.interfaces.minc.testdata import minc2Dfile
+#     >>> vp = Volpad(input_file=minc2Dfile, smooth=True, smooth_distance=4)
+#     >>> vp.run() # doctest: +SKIP
+#     
+task_name: Volpad
+nipype_name: Volpad
+nipype_module: nipype.interfaces.minc.minc
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    input_file: generic/file
+    # type=file|default=<undefined>: input file to centre
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    output_file: generic/file
+    # type=file: output file
+    # type=file|default=<undefined>: output file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    output_file: output_file
+    # type=file: output file
+    # type=file|default=<undefined>: output file
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    input_file:
+    # type=file|default=<undefined>: input file to centre
+    output_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output file
+    verbose:
+    # type=bool|default=False: Print out log messages. Default: False.
+    clobber:
+    # type=bool|default=True: Overwrite existing file.
+    auto:
+    # type=bool|default=False: Automatically determine padding distances (uses -distance as max). Default: False.
+    auto_freq:
+    # type=float|default=0.0: Frequency of voxels over bimodalt threshold to stop at [default: 500].
+    distance:
+    # type=int|default=0: Padding distance (in voxels) [default: 4].
+    smooth:
+    # type=bool|default=False: Smooth (blur) edges before padding. Default: False.
+    smooth_distance:
+    # type=int|default=0: Smoothing distance (in voxels) [default: 4].
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-minc/volpad_callables.py b/example-specs/task/nipype_internal/pydra-minc/volpad_callables.py
new file mode 100644
index 00000000..2b030cf2
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-minc/volpad_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Volpad.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-minc/xfm_avg.yaml b/example-specs/task/nipype_internal/pydra-minc/xfm_avg.yaml
new file mode 100644
index 00000000..b9888377
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-minc/xfm_avg.yaml
@@ -0,0 +1,115 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.minc.minc.XfmAvg' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Average a number of xfm transforms using matrix logs and exponents.
+#     The program xfmavg calls Octave for numerical work.
+# 
+#     This tool is part of the minc-widgets package:
+# 
+#     https://github.com/BIC-MNI/minc-widgets/tree/master/xfmavg
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces.minc import XfmAvg
+#     >>> from nipype.interfaces.minc.testdata import nonempty_minc_data, nlp_config
+#     >>> from nipype.testing import example_data
+# 
+#     >>> xfm1 = example_data('minc_initial.xfm')
+#     >>> xfm2 = example_data('minc_initial.xfm')  # cheating for doctest
+#     >>> xfmavg = XfmAvg(input_files=[xfm1, xfm2])
+#     >>> xfmavg.run() # doctest: +SKIP
+#     
+task_name: XfmAvg
+nipype_name: XfmAvg
+nipype_module: nipype.interfaces.minc.minc
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    input_files: generic/file+list-of
+    # type=inputmultiobject|default=[]: input file(s)
+    input_grid_files: generic/file+list-of
+    # type=inputmultiobject|default=[]: input grid file(s)
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    output_file: generic/file
+    # type=file: output file
+    # type=file|default=<undefined>: output file
+    output_grid: generic/file
+    # type=file: output grid file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    output_file: output_file
+    # type=file: output file
+    # type=file|default=<undefined>: output file
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    input_files:
+    # type=inputmultiobject|default=[]: input file(s)
+    input_grid_files:
+    # type=inputmultiobject|default=[]: input grid file(s)
+    output_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output file
+    verbose:
+    # type=bool|default=False: Print out log messages. Default: False.
+    clobber:
+    # type=bool|default=True: Overwrite existing file.
+    avg_linear:
+    # type=bool|default=False: average the linear part [default].
+    avg_nonlinear:
+    # type=bool|default=False: average the non-linear part [default].
+    ignore_linear:
+    # type=bool|default=False: opposite of -avg_linear.
+    ignore_nonlinear:
+    # type=bool|default=False: opposite of -avg_nonlinear.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-minc/xfm_avg_callables.py b/example-specs/task/nipype_internal/pydra-minc/xfm_avg_callables.py
new file mode 100644
index 00000000..faeaef89
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-minc/xfm_avg_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in XfmAvg.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-minc/xfm_concat.yaml b/example-specs/task/nipype_internal/pydra-minc/xfm_concat.yaml
new file mode 100644
index 00000000..296082f2
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-minc/xfm_concat.yaml
@@ -0,0 +1,98 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.minc.minc.XfmConcat' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Concatenate transforms together. The output transformation
+#     is equivalent to applying input1.xfm, then input2.xfm, ..., in
+#     that order.
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces.minc import XfmConcat
+#     >>> from nipype.interfaces.minc.testdata import minc2Dfile
+#     >>> conc = XfmConcat(input_files=['input1.xfm', 'input1.xfm'])
+#     >>> conc.run() # doctest: +SKIP
+#     
+task_name: XfmConcat
+nipype_name: XfmConcat
+nipype_module: nipype.interfaces.minc.minc
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    input_files: generic/file+list-of
+    # type=inputmultiobject|default=[]: input file(s)
+    input_grid_files: generic/file+list-of
+    # type=inputmultiobject|default=[]: input grid file(s)
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    output_file: generic/file
+    # type=file: output file
+    # type=file|default=<undefined>: output file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    output_file: output_file
+    # type=file: output file
+    # type=file|default=<undefined>: output file
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    input_files:
+    # type=inputmultiobject|default=[]: input file(s)
+    input_grid_files:
+    # type=inputmultiobject|default=[]: input grid file(s)
+    output_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output file
+    verbose:
+    # type=bool|default=False: Print out log messages. Default: False.
+    clobber:
+    # type=bool|default=True: Overwrite existing file.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-minc/xfm_concat_callables.py b/example-specs/task/nipype_internal/pydra-minc/xfm_concat_callables.py
new file mode 100644
index 00000000..6d82e185
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-minc/xfm_concat_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in XfmConcat.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-minc/xfm_invert.yaml b/example-specs/task/nipype_internal/pydra-minc/xfm_invert.yaml
new file mode 100644
index 00000000..d678e5ae
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-minc/xfm_invert.yaml
@@ -0,0 +1,96 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.minc.minc.XfmInvert' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Invert an xfm transform file.
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces.minc import XfmAvg
+#     >>> from nipype.testing import example_data
+# 
+#     >>> xfm = example_data('minc_initial.xfm')
+#     >>> invert = XfmInvert(input_file=xfm)
+#     >>> invert.run() # doctest: +SKIP
+#     
+task_name: XfmInvert
+nipype_name: XfmInvert
+nipype_module: nipype.interfaces.minc.minc
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    input_file: generic/file
+    # type=file|default=<undefined>: input file
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    output_file: generic/file
+    # type=file: output file
+    # type=file|default=<undefined>: output file
+    output_grid: generic/file
+    # type=file: output grid file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    output_file: output_file
+    # type=file: output file
+    # type=file|default=<undefined>: output file
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    input_file:
+    # type=file|default=<undefined>: input file
+    output_file:
+    # type=file: output file
+    # type=file|default=<undefined>: output file
+    verbose:
+    # type=bool|default=False: Print out log messages. Default: False.
+    clobber:
+    # type=bool|default=True: Overwrite existing file.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-minc/xfm_invert_callables.py b/example-specs/task/nipype_internal/pydra-minc/xfm_invert_callables.py
new file mode 100644
index 00000000..ae791175
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-minc/xfm_invert_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in XfmInvert.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-mipav/jist_brain_mgdm_segmentation.yaml b/example-specs/task/nipype_internal/pydra-mipav/jist_brain_mgdm_segmentation.yaml
new file mode 100644
index 00000000..0cd441b6
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-mipav/jist_brain_mgdm_segmentation.yaml
@@ -0,0 +1,146 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.mipav.developer.JistBrainMgdmSegmentation' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# MGDM Whole Brain Segmentation.
+# 
+#     Estimate brain structures from an atlas for a MRI dataset (multiple input combinations
+#     are possible).
+# 
+#     
+task_name: JistBrainMgdmSegmentation
+nipype_name: JistBrainMgdmSegmentation
+nipype_module: nipype.interfaces.mipav.developer
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inMP2RAGE: generic/file
+    # type=file|default=<undefined>: MP2RAGE T1 Map Image
+    inMP2RAGE2: generic/file
+    # type=file|default=<undefined>: MP2RAGE T1-weighted Image
+    inPV: generic/file
+    # type=file|default=<undefined>: PV / Dura Image
+    inMPRAGE: generic/file
+    # type=file|default=<undefined>: MPRAGE T1-weighted Image
+    inFLAIR: generic/file
+    # type=file|default=<undefined>: FLAIR Image
+    inAtlas: generic/file
+    # type=file|default=<undefined>: Atlas file
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outSegmented: generic/file
+    # type=file: Segmented Brain Image
+    # type=traitcompound|default=None: Segmented Brain Image
+    outLevelset: generic/file
+    # type=file: Levelset Boundary Image
+    # type=traitcompound|default=None: Levelset Boundary Image
+    outPosterior2: generic/file
+    # type=file: Posterior Maximum Memberships (4D)
+    # type=traitcompound|default=None: Posterior Maximum Memberships (4D)
+    outPosterior3: generic/file
+    # type=file: Posterior Maximum Labels (4D)
+    # type=traitcompound|default=None: Posterior Maximum Labels (4D)
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inMP2RAGE:
+    # type=file|default=<undefined>: MP2RAGE T1 Map Image
+    inMP2RAGE2:
+    # type=file|default=<undefined>: MP2RAGE T1-weighted Image
+    inPV:
+    # type=file|default=<undefined>: PV / Dura Image
+    inMPRAGE:
+    # type=file|default=<undefined>: MPRAGE T1-weighted Image
+    inFLAIR:
+    # type=file|default=<undefined>: FLAIR Image
+    inAtlas:
+    # type=file|default=<undefined>: Atlas file
+    inData:
+    # type=float|default=0.0: Data weight
+    inCurvature:
+    # type=float|default=0.0: Curvature weight
+    inPosterior:
+    # type=float|default=0.0: Posterior scale (mm)
+    inMax:
+    # type=int|default=0: Max iterations
+    inMin:
+    # type=float|default=0.0: Min change
+    inSteps:
+    # type=int|default=0: Steps
+    inTopology:
+    # type=enum|default='26/6'|allowed['18/6','26/6','6/18','6/26','6/6','no','wco','wcs']: Topology
+    inCompute:
+    # type=enum|default='true'|allowed['false','true']: Compute posteriors
+    inAdjust:
+    # type=enum|default='true'|allowed['false','true']: Adjust intensity priors
+    inOutput:
+    # type=enum|default='segmentation'|allowed['memberships','segmentation']: Output images
+    xPrefExt:
+    # type=enum|default='nrrd'|allowed['nrrd']: Output File Type
+    outSegmented:
+    # type=file: Segmented Brain Image
+    # type=traitcompound|default=None: Segmented Brain Image
+    outLevelset:
+    # type=file: Levelset Boundary Image
+    # type=traitcompound|default=None: Levelset Boundary Image
+    outPosterior2:
+    # type=file: Posterior Maximum Memberships (4D)
+    # type=traitcompound|default=None: Posterior Maximum Memberships (4D)
+    outPosterior3:
+    # type=file: Posterior Maximum Labels (4D)
+    # type=traitcompound|default=None: Posterior Maximum Labels (4D)
+    'null':
+    xDefaultMem:
+    # type=int|default=0: Set default maximum heap size
+    xMaxProcess:
+    # type=int|default=1: Set default maximum number of processes.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-mipav/jist_brain_mgdm_segmentation_callables.py b/example-specs/task/nipype_internal/pydra-mipav/jist_brain_mgdm_segmentation_callables.py
new file mode 100644
index 00000000..0f2f5f0c
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-mipav/jist_brain_mgdm_segmentation_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in JistBrainMgdmSegmentation.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-mipav/jist_brain_mp_2rage_dura_estimation.yaml b/example-specs/task/nipype_internal/pydra-mipav/jist_brain_mp_2rage_dura_estimation.yaml
new file mode 100644
index 00000000..9e2fa684
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-mipav/jist_brain_mp_2rage_dura_estimation.yaml
@@ -0,0 +1,91 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.mipav.developer.JistBrainMp2rageDuraEstimation' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Filters a MP2RAGE brain image to obtain a probability map of dura matter.
+task_name: JistBrainMp2rageDuraEstimation
+nipype_name: JistBrainMp2rageDuraEstimation
+nipype_module: nipype.interfaces.mipav.developer
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inSecond: generic/file
+    # type=file|default=<undefined>: Second inversion (Inv2) Image
+    inSkull: generic/file
+    # type=file|default=<undefined>: Skull Stripping Mask
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outDura: generic/file
+    # type=file: Dura Image
+    # type=traitcompound|default=None: Dura Image
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inSecond:
+    # type=file|default=<undefined>: Second inversion (Inv2) Image
+    inSkull:
+    # type=file|default=<undefined>: Skull Stripping Mask
+    inDistance:
+    # type=float|default=0.0: Distance to background (mm)
+    inoutput:
+    # type=enum|default='dura_region'|allowed['bg_prior','boundary','dura_prior','dura_region','intens_prior']: Outputs an estimate of the dura / CSF boundary or an estimate of the entire dura region.
+    xPrefExt:
+    # type=enum|default='nrrd'|allowed['nrrd']: Output File Type
+    outDura:
+    # type=file: Dura Image
+    # type=traitcompound|default=None: Dura Image
+    'null':
+    xDefaultMem:
+    # type=int|default=0: Set default maximum heap size
+    xMaxProcess:
+    # type=int|default=1: Set default maximum number of processes.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-mipav/jist_brain_mp_2rage_dura_estimation_callables.py b/example-specs/task/nipype_internal/pydra-mipav/jist_brain_mp_2rage_dura_estimation_callables.py
new file mode 100644
index 00000000..a3beeabd
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-mipav/jist_brain_mp_2rage_dura_estimation_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in JistBrainMp2rageDuraEstimation.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-mipav/jist_brain_mp_2rage_skull_stripping.yaml b/example-specs/task/nipype_internal/pydra-mipav/jist_brain_mp_2rage_skull_stripping.yaml
new file mode 100644
index 00000000..3aa2c5bf
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-mipav/jist_brain_mp_2rage_skull_stripping.yaml
@@ -0,0 +1,119 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.mipav.developer.JistBrainMp2rageSkullStripping' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Estimate a brain mask for a MP2RAGE dataset.
+# 
+#     At least a T1-weighted or a T1 map image is required.
+# 
+#     
+task_name: JistBrainMp2rageSkullStripping
+nipype_name: JistBrainMp2rageSkullStripping
+nipype_module: nipype.interfaces.mipav.developer
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inSecond: generic/file
+    # type=file|default=<undefined>: Second inversion (Inv2) Image
+    inT1: generic/file
+    # type=file|default=<undefined>: T1 Map (T1_Images) Image (opt)
+    inT1weighted: generic/file
+    # type=file|default=<undefined>: T1-weighted (UNI) Image (opt)
+    inFilter: generic/file
+    # type=file|default=<undefined>: Filter Image (opt)
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outBrain: generic/file
+    # type=file: Brain Mask Image
+    # type=traitcompound|default=None: Brain Mask Image
+    outMasked: generic/file
+    # type=file: Masked T1 Map Image
+    # type=traitcompound|default=None: Masked T1 Map Image
+    outMasked2: generic/file
+    # type=file: Masked T1-weighted Image
+    # type=traitcompound|default=None: Masked T1-weighted Image
+    outMasked3: generic/file
+    # type=file: Masked Filter Image
+    # type=traitcompound|default=None: Masked Filter Image
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inSecond:
+    # type=file|default=<undefined>: Second inversion (Inv2) Image
+    inT1:
+    # type=file|default=<undefined>: T1 Map (T1_Images) Image (opt)
+    inT1weighted:
+    # type=file|default=<undefined>: T1-weighted (UNI) Image (opt)
+    inFilter:
+    # type=file|default=<undefined>: Filter Image (opt)
+    inSkip:
+    # type=enum|default='true'|allowed['false','true']: Skip zero values
+    xPrefExt:
+    # type=enum|default='nrrd'|allowed['nrrd']: Output File Type
+    outBrain:
+    # type=file: Brain Mask Image
+    # type=traitcompound|default=None: Brain Mask Image
+    outMasked:
+    # type=file: Masked T1 Map Image
+    # type=traitcompound|default=None: Masked T1 Map Image
+    outMasked2:
+    # type=file: Masked T1-weighted Image
+    # type=traitcompound|default=None: Masked T1-weighted Image
+    outMasked3:
+    # type=file: Masked Filter Image
+    # type=traitcompound|default=None: Masked Filter Image
+    'null':
+    xDefaultMem:
+    # type=int|default=0: Set default maximum heap size
+    xMaxProcess:
+    # type=int|default=1: Set default maximum number of processes.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-mipav/jist_brain_mp_2rage_skull_stripping_callables.py b/example-specs/task/nipype_internal/pydra-mipav/jist_brain_mp_2rage_skull_stripping_callables.py
new file mode 100644
index 00000000..57e2a32c
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-mipav/jist_brain_mp_2rage_skull_stripping_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in JistBrainMp2rageSkullStripping.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-mipav/jist_brain_partial_volume_filter.yaml b/example-specs/task/nipype_internal/pydra-mipav/jist_brain_partial_volume_filter.yaml
new file mode 100644
index 00000000..2ad84577
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-mipav/jist_brain_partial_volume_filter.yaml
@@ -0,0 +1,91 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.mipav.developer.JistBrainPartialVolumeFilter' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Partial Volume Filter.
+# 
+#     Filters an image for regions of partial voluming assuming a ridge-like model of intensity.
+# 
+#     
+task_name: JistBrainPartialVolumeFilter
+nipype_name: JistBrainPartialVolumeFilter
+nipype_module: nipype.interfaces.mipav.developer
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inInput: generic/file
+    # type=file|default=<undefined>: Input Image
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outPartial: generic/file
+    # type=file: Partial Volume Image
+    # type=traitcompound|default=None: Partial Volume Image
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inInput:
+    # type=file|default=<undefined>: Input Image
+    inPV:
+    # type=enum|default='bright'|allowed['both','bright','dark']: Outputs the raw intensity values or a probability score for the partial volume regions.
+    inoutput:
+    # type=enum|default='probability'|allowed['intensity','probability']: output
+    xPrefExt:
+    # type=enum|default='nrrd'|allowed['nrrd']: Output File Type
+    outPartial:
+    # type=file: Partial Volume Image
+    # type=traitcompound|default=None: Partial Volume Image
+    'null':
+    xDefaultMem:
+    # type=int|default=0: Set default maximum heap size
+    xMaxProcess:
+    # type=int|default=1: Set default maximum number of processes.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-mipav/jist_brain_partial_volume_filter_callables.py b/example-specs/task/nipype_internal/pydra-mipav/jist_brain_partial_volume_filter_callables.py
new file mode 100644
index 00000000..c76b15e1
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-mipav/jist_brain_partial_volume_filter_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in JistBrainPartialVolumeFilter.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-mipav/jist_cortex_surface_mesh_inflation.yaml b/example-specs/task/nipype_internal/pydra-mipav/jist_cortex_surface_mesh_inflation.yaml
new file mode 100644
index 00000000..f7bf1588
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-mipav/jist_cortex_surface_mesh_inflation.yaml
@@ -0,0 +1,108 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.mipav.developer.JistCortexSurfaceMeshInflation' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Inflates a cortical surface mesh.
+# 
+#     References
+#     ----------
+#     D. Tosun, M. E. Rettmann, X. Han, X. Tao, C. Xu, S. M. Resnick, D. Pham, and J. L. Prince,
+#     Cortical Surface Segmentation and Mapping, NeuroImage, vol. 23, pp. S108--S118, 2004.
+# 
+#     
+task_name: JistCortexSurfaceMeshInflation
+nipype_name: JistCortexSurfaceMeshInflation
+nipype_module: nipype.interfaces.mipav.developer
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inLevelset: generic/file
+    # type=file|default=<undefined>: Levelset Image
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outOriginal: generic/file
+    # type=file: Original Surface
+    # type=traitcompound|default=None: Original Surface
+    outInflated: generic/file
+    # type=file: Inflated Surface
+    # type=traitcompound|default=None: Inflated Surface
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inLevelset:
+    # type=file|default=<undefined>: Levelset Image
+    inSOR:
+    # type=float|default=0.0: SOR Parameter
+    inMean:
+    # type=float|default=0.0: Mean Curvature Threshold
+    inStep:
+    # type=int|default=0: Step Size
+    inMax:
+    # type=int|default=0: Max Iterations
+    inLorentzian:
+    # type=enum|default='true'|allowed['false','true']: Lorentzian Norm
+    inTopology:
+    # type=enum|default='26/6'|allowed['18/6','26/6','6/18','6/26','6/6','no','wco','wcs']: Topology
+    xPrefExt:
+    # type=enum|default='nrrd'|allowed['nrrd']: Output File Type
+    outOriginal:
+    # type=file: Original Surface
+    # type=traitcompound|default=None: Original Surface
+    outInflated:
+    # type=file: Inflated Surface
+    # type=traitcompound|default=None: Inflated Surface
+    'null':
+    xDefaultMem:
+    # type=int|default=0: Set default maximum heap size
+    xMaxProcess:
+    # type=int|default=1: Set default maximum number of processes.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-mipav/jist_cortex_surface_mesh_inflation_callables.py b/example-specs/task/nipype_internal/pydra-mipav/jist_cortex_surface_mesh_inflation_callables.py
new file mode 100644
index 00000000..21aa8fe4
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-mipav/jist_cortex_surface_mesh_inflation_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in JistCortexSurfaceMeshInflation.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-mipav/jist_intensity_mp_2rage_masking.yaml b/example-specs/task/nipype_internal/pydra-mipav/jist_intensity_mp_2rage_masking.yaml
new file mode 100644
index 00000000..987b914b
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-mipav/jist_intensity_mp_2rage_masking.yaml
@@ -0,0 +1,115 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.mipav.developer.JistIntensityMp2rageMasking' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Estimate a background signal mask for a MP2RAGE dataset.
+task_name: JistIntensityMp2rageMasking
+nipype_name: JistIntensityMp2rageMasking
+nipype_module: nipype.interfaces.mipav.developer
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inSecond: generic/file
+    # type=file|default=<undefined>: Second inversion (Inv2) Image
+    inQuantitative: generic/file
+    # type=file|default=<undefined>: Quantitative T1 Map (T1_Images) Image
+    inT1weighted: generic/file
+    # type=file|default=<undefined>: T1-weighted (UNI) Image
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outSignal: generic/file
+    # type=file: Signal Proba Image
+    # type=traitcompound|default=None: Signal Proba Image
+    outSignal2: generic/file
+    # type=file: Signal Mask Image
+    # type=traitcompound|default=None: Signal Mask Image
+    outMasked: generic/file
+    # type=file: Masked T1 Map Image
+    # type=traitcompound|default=None: Masked T1 Map Image
+    outMasked2: generic/file
+    # type=file: Masked Iso Image
+    # type=traitcompound|default=None: Masked Iso Image
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inSecond:
+    # type=file|default=<undefined>: Second inversion (Inv2) Image
+    inQuantitative:
+    # type=file|default=<undefined>: Quantitative T1 Map (T1_Images) Image
+    inT1weighted:
+    # type=file|default=<undefined>: T1-weighted (UNI) Image
+    inBackground:
+    # type=enum|default='exponential'|allowed['exponential','half-normal']: Model distribution for background noise (default is half-normal, exponential is more stringent).
+    inSkip:
+    # type=enum|default='true'|allowed['false','true']: Skip zero values
+    inMasking:
+    # type=enum|default='binary'|allowed['binary','proba']: Whether to use a binary threshold or a weighted average based on the probability.
+    xPrefExt:
+    # type=enum|default='nrrd'|allowed['nrrd']: Output File Type
+    outSignal:
+    # type=file: Signal Proba Image
+    # type=traitcompound|default=None: Signal Proba Image
+    outSignal2:
+    # type=file: Signal Mask Image
+    # type=traitcompound|default=None: Signal Mask Image
+    outMasked:
+    # type=file: Masked T1 Map Image
+    # type=traitcompound|default=None: Masked T1 Map Image
+    outMasked2:
+    # type=file: Masked Iso Image
+    # type=traitcompound|default=None: Masked Iso Image
+    'null':
+    xDefaultMem:
+    # type=int|default=0: Set default maximum heap size
+    xMaxProcess:
+    # type=int|default=1: Set default maximum number of processes.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-mipav/jist_intensity_mp_2rage_masking_callables.py b/example-specs/task/nipype_internal/pydra-mipav/jist_intensity_mp_2rage_masking_callables.py
new file mode 100644
index 00000000..4d895704
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-mipav/jist_intensity_mp_2rage_masking_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in JistIntensityMp2rageMasking.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-mipav/jist_laminar_profile_calculator.yaml b/example-specs/task/nipype_internal/pydra-mipav/jist_laminar_profile_calculator.yaml
new file mode 100644
index 00000000..bf92bdd8
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-mipav/jist_laminar_profile_calculator.yaml
@@ -0,0 +1,89 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.mipav.developer.JistLaminarProfileCalculator' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Compute various moments for intensities mapped along a cortical profile.
+task_name: JistLaminarProfileCalculator
+nipype_name: JistLaminarProfileCalculator
+nipype_module: nipype.interfaces.mipav.developer
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inIntensity: generic/file
+    # type=file|default=<undefined>: Intensity Profile Image
+    inMask: generic/file
+    # type=file|default=<undefined>: Mask Image (opt, 3D or 4D)
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outResult: generic/file
+    # type=file: Result
+    # type=traitcompound|default=None: Result
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inIntensity:
+    # type=file|default=<undefined>: Intensity Profile Image
+    inMask:
+    # type=file|default=<undefined>: Mask Image (opt, 3D or 4D)
+    incomputed:
+    # type=enum|default='mean'|allowed['kurtosis','mean','skewness','stdev']: computed statistic
+    xPrefExt:
+    # type=enum|default='nrrd'|allowed['nrrd']: Output File Type
+    outResult:
+    # type=file: Result
+    # type=traitcompound|default=None: Result
+    'null':
+    xDefaultMem:
+    # type=int|default=0: Set default maximum heap size
+    xMaxProcess:
+    # type=int|default=1: Set default maximum number of processes.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-mipav/jist_laminar_profile_calculator_callables.py b/example-specs/task/nipype_internal/pydra-mipav/jist_laminar_profile_calculator_callables.py
new file mode 100644
index 00000000..10232179
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-mipav/jist_laminar_profile_calculator_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in JistLaminarProfileCalculator.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-mipav/jist_laminar_profile_geometry.yaml b/example-specs/task/nipype_internal/pydra-mipav/jist_laminar_profile_geometry.yaml
new file mode 100644
index 00000000..43b64dae
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-mipav/jist_laminar_profile_geometry.yaml
@@ -0,0 +1,91 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.mipav.developer.JistLaminarProfileGeometry' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Compute various geometric quantities for a cortical layers.
+task_name: JistLaminarProfileGeometry
+nipype_name: JistLaminarProfileGeometry
+nipype_module: nipype.interfaces.mipav.developer
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inProfile: generic/file
+    # type=file|default=<undefined>: Profile Surface Image
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outResult: generic/file
+    # type=file: Result
+    # type=traitcompound|default=None: Result
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inProfile:
+    # type=file|default=<undefined>: Profile Surface Image
+    incomputed:
+    # type=enum|default='thickness'|allowed['curvedness','gauss_curvature','mean_curvature','profile_curvature','profile_length','profile_torsion','shape_index','thickness']: computed measure
+    inregularization:
+    # type=enum|default='none'|allowed['Gaussian','none']: regularization
+    insmoothing:
+    # type=float|default=0.0: smoothing parameter
+    inoutside:
+    # type=float|default=0.0: outside extension (mm)
+    xPrefExt:
+    # type=enum|default='nrrd'|allowed['nrrd']: Output File Type
+    outResult:
+    # type=file: Result
+    # type=traitcompound|default=None: Result
+    'null':
+    xDefaultMem:
+    # type=int|default=0: Set default maximum heap size
+    xMaxProcess:
+    # type=int|default=1: Set default maximum number of processes.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-mipav/jist_laminar_profile_geometry_callables.py b/example-specs/task/nipype_internal/pydra-mipav/jist_laminar_profile_geometry_callables.py
new file mode 100644
index 00000000..09543349
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-mipav/jist_laminar_profile_geometry_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in JistLaminarProfileGeometry.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-mipav/jist_laminar_profile_sampling.yaml b/example-specs/task/nipype_internal/pydra-mipav/jist_laminar_profile_sampling.yaml
new file mode 100644
index 00000000..f28c442d
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-mipav/jist_laminar_profile_sampling.yaml
@@ -0,0 +1,97 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.mipav.developer.JistLaminarProfileSampling' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Sample some intensity image along a cortical profile across layer surfaces.
+task_name: JistLaminarProfileSampling
+nipype_name: JistLaminarProfileSampling
+nipype_module: nipype.interfaces.mipav.developer
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inProfile: generic/file
+    # type=file|default=<undefined>: Profile Surface Image
+    inIntensity: generic/file
+    # type=file|default=<undefined>: Intensity Image
+    inCortex: generic/file
+    # type=file|default=<undefined>: Cortex Mask (opt)
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outProfilemapped: generic/file
+    # type=file: Profile-mapped Intensity Image
+    # type=traitcompound|default=None: Profile-mapped Intensity Image
+    outProfile2: generic/file
+    # type=file: Profile 4D Mask
+    # type=traitcompound|default=None: Profile 4D Mask
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inProfile:
+    # type=file|default=<undefined>: Profile Surface Image
+    inIntensity:
+    # type=file|default=<undefined>: Intensity Image
+    inCortex:
+    # type=file|default=<undefined>: Cortex Mask (opt)
+    xPrefExt:
+    # type=enum|default='nrrd'|allowed['nrrd']: Output File Type
+    outProfilemapped:
+    # type=file: Profile-mapped Intensity Image
+    # type=traitcompound|default=None: Profile-mapped Intensity Image
+    outProfile2:
+    # type=file: Profile 4D Mask
+    # type=traitcompound|default=None: Profile 4D Mask
+    'null':
+    xDefaultMem:
+    # type=int|default=0: Set default maximum heap size
+    xMaxProcess:
+    # type=int|default=1: Set default maximum number of processes.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-mipav/jist_laminar_profile_sampling_callables.py b/example-specs/task/nipype_internal/pydra-mipav/jist_laminar_profile_sampling_callables.py
new file mode 100644
index 00000000..821bf7c6
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-mipav/jist_laminar_profile_sampling_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in JistLaminarProfileSampling.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-mipav/jist_laminar_roi_averaging.yaml b/example-specs/task/nipype_internal/pydra-mipav/jist_laminar_roi_averaging.yaml
new file mode 100644
index 00000000..6a60aa23
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-mipav/jist_laminar_roi_averaging.yaml
@@ -0,0 +1,93 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.mipav.developer.JistLaminarROIAveraging' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Compute an average profile over a given ROI.
+task_name: JistLaminarROIAveraging
+nipype_name: JistLaminarROIAveraging
+nipype_module: nipype.interfaces.mipav.developer
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inIntensity: generic/file
+    # type=file|default=<undefined>: Intensity Profile Image
+    inROI: generic/file
+    # type=file|default=<undefined>: ROI Mask
+    inMask: generic/file
+    # type=file|default=<undefined>: Mask Image (opt, 3D or 4D)
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outROI3: generic/file
+    # type=file: ROI Average
+    # type=traitcompound|default=None: ROI Average
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inIntensity:
+    # type=file|default=<undefined>: Intensity Profile Image
+    inROI:
+    # type=file|default=<undefined>: ROI Mask
+    inROI2:
+    # type=str|default='': ROI Name
+    inMask:
+    # type=file|default=<undefined>: Mask Image (opt, 3D or 4D)
+    xPrefExt:
+    # type=enum|default='nrrd'|allowed['nrrd']: Output File Type
+    outROI3:
+    # type=file: ROI Average
+    # type=traitcompound|default=None: ROI Average
+    'null':
+    xDefaultMem:
+    # type=int|default=0: Set default maximum heap size
+    xMaxProcess:
+    # type=int|default=1: Set default maximum number of processes.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-mipav/jist_laminar_roi_averaging_callables.py b/example-specs/task/nipype_internal/pydra-mipav/jist_laminar_roi_averaging_callables.py
new file mode 100644
index 00000000..e72f4851
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-mipav/jist_laminar_roi_averaging_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in JistLaminarROIAveraging.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-mipav/jist_laminar_volumetric_layering.yaml b/example-specs/task/nipype_internal/pydra-mipav/jist_laminar_volumetric_layering.yaml
new file mode 100644
index 00000000..d1b5f171
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-mipav/jist_laminar_volumetric_layering.yaml
@@ -0,0 +1,127 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.mipav.developer.JistLaminarVolumetricLayering' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Volumetric Layering.
+# 
+#     Builds a continuous layering of the cortex following distance-preserving or volume-preserving
+#     models of cortical folding.
+# 
+#     References
+#     ----------
+#     Waehnert MD, Dinse J, Weiss M, Streicher MN, Waehnert P, Geyer S, Turner R, Bazin PL,
+#     Anatomically motivated modeling of cortical laminae, Neuroimage, 2013.
+# 
+#     
+task_name: JistLaminarVolumetricLayering
+nipype_name: JistLaminarVolumetricLayering
+nipype_module: nipype.interfaces.mipav.developer
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inInner: generic/file
+    # type=file|default=<undefined>: Inner Distance Image (GM/WM boundary)
+    inOuter: generic/file
+    # type=file|default=<undefined>: Outer Distance Image (CSF/GM boundary)
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outContinuous: generic/file
+    # type=file: Continuous depth measurement
+    # type=traitcompound|default=None: Continuous depth measurement
+    outDiscrete: generic/file
+    # type=file: Discrete sampled layers
+    # type=traitcompound|default=None: Discrete sampled layers
+    outLayer: generic/file
+    # type=file: Layer boundary surfaces
+    # type=traitcompound|default=None: Layer boundary surfaces
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inInner:
+    # type=file|default=<undefined>: Inner Distance Image (GM/WM boundary)
+    inOuter:
+    # type=file|default=<undefined>: Outer Distance Image (CSF/GM boundary)
+    inNumber:
+    # type=int|default=0: Number of layers
+    inMax:
+    # type=int|default=0: Max iterations for narrow band evolution
+    inMin:
+    # type=float|default=0.0: Min change ratio for narrow band evolution
+    inLayering:
+    # type=enum|default='distance-preserving'|allowed['distance-preserving','volume-preserving']: Layering method
+    inLayering2:
+    # type=enum|default='outward'|allowed['inward','outward']: Layering direction
+    incurvature:
+    # type=int|default=0: curvature approximation scale (voxels)
+    inratio:
+    # type=float|default=0.0: ratio smoothing kernel size (voxels)
+    inpresmooth:
+    # type=enum|default='true'|allowed['false','true']: pre-smooth cortical surfaces
+    inTopology:
+    # type=enum|default='26/6'|allowed['18/6','26/6','6/18','6/26','6/6','no','wco','wcs']: Topology
+    xPrefExt:
+    # type=enum|default='nrrd'|allowed['nrrd']: Output File Type
+    outContinuous:
+    # type=file: Continuous depth measurement
+    # type=traitcompound|default=None: Continuous depth measurement
+    outDiscrete:
+    # type=file: Discrete sampled layers
+    # type=traitcompound|default=None: Discrete sampled layers
+    outLayer:
+    # type=file: Layer boundary surfaces
+    # type=traitcompound|default=None: Layer boundary surfaces
+    'null':
+    xDefaultMem:
+    # type=int|default=0: Set default maximum heap size
+    xMaxProcess:
+    # type=int|default=1: Set default maximum number of processes.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-mipav/jist_laminar_volumetric_layering_callables.py b/example-specs/task/nipype_internal/pydra-mipav/jist_laminar_volumetric_layering_callables.py
new file mode 100644
index 00000000..a57c8d48
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-mipav/jist_laminar_volumetric_layering_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in JistLaminarVolumetricLayering.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_image_calculator.yaml b/example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_image_calculator.yaml
new file mode 100644
index 00000000..70fe3cbe
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_image_calculator.yaml
@@ -0,0 +1,93 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.mipav.developer.MedicAlgorithmImageCalculator' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Perform simple image calculator operations on two images.
+# 
+#     The operations include 'Add', 'Subtract', 'Multiply', and 'Divide'
+# 
+#     
+task_name: MedicAlgorithmImageCalculator
+nipype_name: MedicAlgorithmImageCalculator
+nipype_module: nipype.interfaces.mipav.developer
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inVolume: generic/file
+    # type=file|default=<undefined>: Volume 1
+    inVolume2: generic/file
+    # type=file|default=<undefined>: Volume 2
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outResult: generic/file
+    # type=file: Result Volume
+    # type=traitcompound|default=None: Result Volume
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inVolume:
+    # type=file|default=<undefined>: Volume 1
+    inVolume2:
+    # type=file|default=<undefined>: Volume 2
+    inOperation:
+    # type=enum|default='Add'|allowed['Add','Divide','Max','Min','Multiply','Subtract']: Operation
+    xPrefExt:
+    # type=enum|default='nrrd'|allowed['nrrd']: Output File Type
+    outResult:
+    # type=file: Result Volume
+    # type=traitcompound|default=None: Result Volume
+    'null':
+    xDefaultMem:
+    # type=int|default=0: Set default maximum heap size
+    xMaxProcess:
+    # type=int|default=1: Set default maximum number of processes.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_image_calculator_callables.py b/example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_image_calculator_callables.py
new file mode 100644
index 00000000..bb1e2ead
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_image_calculator_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in MedicAlgorithmImageCalculator.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_lesion_toads.yaml b/example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_lesion_toads.yaml
new file mode 100644
index 00000000..88cf1874
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_lesion_toads.yaml
@@ -0,0 +1,192 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.mipav.developer.MedicAlgorithmLesionToads' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Algorithm for simultaneous brain structures and MS lesion segmentation of MS Brains.
+# 
+#     The brain segmentation is topologically consistent and the algorithm can use multiple
+#     MR sequences as input data.
+# 
+#     References
+#     ----------
+#     N. Shiee, P.-L. Bazin, A.Z. Ozturk, P.A. Calabresi, D.S. Reich, D.L. Pham,
+#     "A Topology-Preserving Approach to the Segmentation of Brain Images with Multiple Sclerosis",
+#     NeuroImage, vol. 49, no. 2, pp. 1524-1535, 2010.
+# 
+#     
+task_name: MedicAlgorithmLesionToads
+nipype_name: MedicAlgorithmLesionToads
+nipype_module: nipype.interfaces.mipav.developer
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inT1_MPRAGE: generic/file
+    # type=file|default=<undefined>: T1_MPRAGE Image
+    inT1_SPGR: generic/file
+    # type=file|default=<undefined>: T1_SPGR Image
+    inFLAIR: generic/file
+    # type=file|default=<undefined>: FLAIR Image
+    inAtlas2: generic/file
+    # type=file|default=<undefined>: Atlas File - With Lesions
+    inAtlas3: generic/file
+    # type=file|default=<undefined>: Atlas File - No Lesion - T1 and FLAIR
+    inAtlas4: generic/file
+    # type=file|default=<undefined>: Atlas File - No Lesion - T1 Only
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outHard: generic/file
+    # type=file: Hard segmentation
+    # type=traitcompound|default=None: Hard segmentation
+    outHard2: generic/file
+    # type=file: Hard segmentationfrom memberships
+    # type=traitcompound|default=None: Hard segmentationfrom memberships
+    outInhomogeneity: generic/file
+    # type=file: Inhomogeneity Field
+    # type=traitcompound|default=None: Inhomogeneity Field
+    outMembership: generic/file
+    # type=file: Membership Functions
+    # type=traitcompound|default=None: Membership Functions
+    outLesion: generic/file
+    # type=file: Lesion Segmentation
+    # type=traitcompound|default=None: Lesion Segmentation
+    outSulcal: generic/file
+    # type=file: Sulcal CSF Membership
+    # type=traitcompound|default=None: Sulcal CSF Membership
+    outCortical: generic/file
+    # type=file: Cortical GM Membership
+    # type=traitcompound|default=None: Cortical GM Membership
+    outFilled: generic/file
+    # type=file: Filled WM Membership
+    # type=traitcompound|default=None: Filled WM Membership
+    outWM: generic/file
+    # type=file: WM Mask
+    # type=traitcompound|default=None: WM Mask
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inT1_MPRAGE:
+    # type=file|default=<undefined>: T1_MPRAGE Image
+    inT1_SPGR:
+    # type=file|default=<undefined>: T1_SPGR Image
+    inFLAIR:
+    # type=file|default=<undefined>: FLAIR Image
+    inAtlas:
+    # type=enum|default='With Lesion'|allowed['No Lesion','With Lesion']: Atlas to Use
+    inOutput:
+    # type=enum|default='hard segmentation'|allowed['cruise inputs','dura removal inputs','hard segmentation','hard segmentation+memberships']: Output images
+    inOutput2:
+    # type=enum|default='true'|allowed['false','true']: Output the hard classification using maximum membership (not neceesarily topologically correct)
+    inCorrect:
+    # type=enum|default='true'|allowed['false','true']: Correct MR field inhomogeneity.
+    inOutput3:
+    # type=enum|default='true'|allowed['false','true']: Output the estimated inhomogeneity field
+    inAtlas2:
+    # type=file|default=<undefined>: Atlas File - With Lesions
+    inAtlas3:
+    # type=file|default=<undefined>: Atlas File - No Lesion - T1 and FLAIR
+    inAtlas4:
+    # type=file|default=<undefined>: Atlas File - No Lesion - T1 Only
+    inMaximum:
+    # type=int|default=0: Maximum distance from the interventricular WM boundary to downweight the lesion membership to avoid false positives
+    inMaximum2:
+    # type=int|default=0: Maximum Ventircle Distance
+    inMaximum3:
+    # type=int|default=0: Maximum InterVentricular Distance
+    inInclude:
+    # type=enum|default='true'|allowed['false','true']: Include lesion in WM class in hard classification
+    inAtlas5:
+    # type=float|default=0.0: Controls the effect of the statistical atlas on the segmentation
+    inSmooting:
+    # type=float|default=0.0: Controls the effect of neighborhood voxels on the membership
+    inMaximum4:
+    # type=float|default=0.0: Maximum amount of relative change in the energy function considered as the convergence criteria
+    inMaximum5:
+    # type=int|default=0: Maximum iterations
+    inAtlas6:
+    # type=enum|default='rigid'|allowed['multi_fully_affine','rigid']: Atlas alignment
+    inConnectivity:
+    # type=enum|default='(26,6)'|allowed['(18,6)','(26,6)','(6,18)','(6,26)']: Connectivity (foreground,background)
+    xPrefExt:
+    # type=enum|default='nrrd'|allowed['nrrd']: Output File Type
+    outHard:
+    # type=file: Hard segmentation
+    # type=traitcompound|default=None: Hard segmentation
+    outHard2:
+    # type=file: Hard segmentationfrom memberships
+    # type=traitcompound|default=None: Hard segmentationfrom memberships
+    outInhomogeneity:
+    # type=file: Inhomogeneity Field
+    # type=traitcompound|default=None: Inhomogeneity Field
+    outMembership:
+    # type=file: Membership Functions
+    # type=traitcompound|default=None: Membership Functions
+    outLesion:
+    # type=file: Lesion Segmentation
+    # type=traitcompound|default=None: Lesion Segmentation
+    outSulcal:
+    # type=file: Sulcal CSF Membership
+    # type=traitcompound|default=None: Sulcal CSF Membership
+    outCortical:
+    # type=file: Cortical GM Membership
+    # type=traitcompound|default=None: Cortical GM Membership
+    outFilled:
+    # type=file: Filled WM Membership
+    # type=traitcompound|default=None: Filled WM Membership
+    outWM:
+    # type=file: WM Mask
+    # type=traitcompound|default=None: WM Mask
+    'null':
+    xDefaultMem:
+    # type=int|default=0: Set default maximum heap size
+    xMaxProcess:
+    # type=int|default=1: Set default maximum number of processes.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_lesion_toads_callables.py b/example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_lesion_toads_callables.py
new file mode 100644
index 00000000..aed440ed
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_lesion_toads_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in MedicAlgorithmLesionToads.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_mipav_reorient.yaml b/example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_mipav_reorient.yaml
new file mode 100644
index 00000000..b5b5ed75
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_mipav_reorient.yaml
@@ -0,0 +1,99 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.mipav.developer.MedicAlgorithmMipavReorient' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Reorient a volume to a particular anatomical orientation.
+task_name: MedicAlgorithmMipavReorient
+nipype_name: MedicAlgorithmMipavReorient
+nipype_module: nipype.interfaces.mipav.developer
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inSource: generic/file+list-of
+    # type=inputmultiobject|default=[]: Source
+    inTemplate: generic/file
+    # type=file|default=<undefined>: Template
+    outReoriented: generic/file+list-of
+    # type=inputmultiobject|default=[]: Reoriented Volume
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inSource:
+    # type=inputmultiobject|default=[]: Source
+    inTemplate:
+    # type=file|default=<undefined>: Template
+    inNew:
+    # type=enum|default='Dicom axial'|allowed['Dicom axial','Dicom coronal','Dicom sagittal','User defined']: New image orientation
+    inUser:
+    # type=enum|default='Unknown'|allowed['Patient Anterior to Posterior','Patient Inferior to Superior','Patient Left to Right','Patient Posterior to Anterior','Patient Right to Left','Patient Superior to Inferior','Unknown']: User defined X-axis orientation (image left to right)
+    inUser2:
+    # type=enum|default='Unknown'|allowed['Patient Anterior to Posterior','Patient Inferior to Superior','Patient Left to Right','Patient Posterior to Anterior','Patient Right to Left','Patient Superior to Inferior','Unknown']: User defined Y-axis orientation (image top to bottom)
+    inUser3:
+    # type=enum|default='Unknown'|allowed['Patient Anterior to Posterior','Patient Inferior to Superior','Patient Left to Right','Patient Posterior to Anterior','Patient Right to Left','Patient Superior to Inferior','Unknown']: User defined Z-axis orientation (into the screen)
+    inUser4:
+    # type=enum|default='Axial'|allowed['Axial','Coronal','Sagittal','Unknown']: User defined Image Orientation
+    inInterpolation:
+    # type=enum|default='Nearest Neighbor'|allowed['Bspline 3rd order','Bspline 4th order','Cubic Lagrangian','Heptic Lagrangian','Nearest Neighbor','Quintic Lagrangian','Trilinear','Windowed Sinc']: Interpolation
+    inResolution:
+    # type=enum|default='Unchanged'|allowed['Coarsest cubic','Finest cubic','Same as template','Unchanged']: Resolution
+    xPrefExt:
+    # type=enum|default='nrrd'|allowed['nrrd']: Output File Type
+    outReoriented:
+    # type=inputmultiobject|default=[]: Reoriented Volume
+    'null':
+    xDefaultMem:
+    # type=int|default=0: Set default maximum heap size
+    xMaxProcess:
+    # type=int|default=1: Set default maximum number of processes.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_mipav_reorient_callables.py b/example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_mipav_reorient_callables.py
new file mode 100644
index 00000000..e1ad5c91
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_mipav_reorient_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in MedicAlgorithmMipavReorient.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_n3.yaml b/example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_n3.yaml
new file mode 100644
index 00000000..8bb04dfa
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_n3.yaml
@@ -0,0 +1,105 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.mipav.developer.MedicAlgorithmN3' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Non-parametric Intensity Non-uniformity Correction, N3, originally by J.G. Sled.
+task_name: MedicAlgorithmN3
+nipype_name: MedicAlgorithmN3
+nipype_module: nipype.interfaces.mipav.developer
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inInput: generic/file
+    # type=file|default=<undefined>: Input Volume
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outInhomogeneity: generic/file
+    # type=file: Inhomogeneity Corrected Volume
+    # type=traitcompound|default=None: Inhomogeneity Corrected Volume
+    outInhomogeneity2: generic/file
+    # type=file: Inhomogeneity Field
+    # type=traitcompound|default=None: Inhomogeneity Field
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inInput:
+    # type=file|default=<undefined>: Input Volume
+    inSignal:
+    # type=float|default=0.0: Default = min + 1, Values at less than threshold are treated as part of the background
+    inMaximum:
+    # type=int|default=0: Maximum number of Iterations
+    inEnd:
+    # type=float|default=0.0: Usually 0.01-0.00001, The measure used to terminate the iterations is the coefficient of variation of change in field estimates between successive iterations.
+    inField:
+    # type=float|default=0.0: Characteristic distance over which the field varies. The distance between adjacent knots in bspline fitting with at least 4 knots going in every dimension. The default in the dialog is one third the distance (resolution * extents) of the smallest dimension.
+    inSubsample:
+    # type=float|default=0.0: Usually between 1-32, The factor by which the data is subsampled to a lower resolution in estimating the slowly varying non-uniformity field. Reduce sampling in the finest sampling direction by the shrink factor.
+    inKernel:
+    # type=float|default=0.0: Usually between 0.05-0.50, Width of deconvolution kernel used to sharpen the histogram. Larger values give faster convergence while smaller values give greater accuracy.
+    inWeiner:
+    # type=float|default=0.0: Usually between 0.0-1.0
+    inAutomatic:
+    # type=enum|default='true'|allowed['false','true']: If true determines the threshold by histogram analysis. If true a VOI cannot be used and the input threshold is ignored.
+    xPrefExt:
+    # type=enum|default='nrrd'|allowed['nrrd']: Output File Type
+    outInhomogeneity:
+    # type=file: Inhomogeneity Corrected Volume
+    # type=traitcompound|default=None: Inhomogeneity Corrected Volume
+    outInhomogeneity2:
+    # type=file: Inhomogeneity Field
+    # type=traitcompound|default=None: Inhomogeneity Field
+    'null':
+    xDefaultMem:
+    # type=int|default=0: Set default maximum heap size
+    xMaxProcess:
+    # type=int|default=1: Set default maximum number of processes.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_n3_callables.py b/example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_n3_callables.py
new file mode 100644
index 00000000..d950ae80
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_n3_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in MedicAlgorithmN3.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_spectre2010.yaml b/example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_spectre2010.yaml
new file mode 100644
index 00000000..40c1680c
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_spectre2010.yaml
@@ -0,0 +1,212 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.mipav.developer.MedicAlgorithmSPECTRE2010' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# SPECTRE 2010: Simple Paradigm for Extra-Cranial Tissue REmoval [1]_, [2]_.
+# 
+#     References
+#     ----------
+# 
+#     .. [1] A. Carass, M.B. Wheeler, J. Cuzzocreo, P.-L. Bazin, S.S. Bassett, and J.L. Prince,
+#            'A Joint Registration and Segmentation Approach to Skull Stripping',
+#            Fourth IEEE International Symposium on Biomedical Imaging (ISBI 2007), Arlington, VA,
+#            April 12-15, 2007.
+#     .. [2] A. Carass, J. Cuzzocreo, M.B. Wheeler, P.-L. Bazin, S.M. Resnick, and J.L. Prince,
+#            'Simple paradigm for extra-cerebral tissue removal: Algorithm and analysis',
+#            NeuroImage 56(4):1982-1992, 2011.
+# 
+#     
+task_name: MedicAlgorithmSPECTRE2010
+nipype_name: MedicAlgorithmSPECTRE2010
+nipype_module: nipype.interfaces.mipav.developer
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inInput: generic/file
+    # type=file|default=<undefined>: Input volume to be skullstripped.
+    inAtlas: generic/file
+    # type=file|default=<undefined>: SPECTRE atlas description file. A text file enumerating atlas files and landmarks.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outOriginal: generic/file
+    # type=file: If Output in Original Space Flag is true then outputs the original input volume. Otherwise outputs the axialy reoriented input volume.
+    # type=traitcompound|default=None: If Output in Original Space Flag is true then outputs the original input volume. Otherwise outputs the axialy reoriented input volume.
+    outStripped: generic/file
+    # type=file: Skullstripped result of the input volume with just the brain.
+    # type=traitcompound|default=None: Skullstripped result of the input volume with just the brain.
+    outMask: generic/file
+    # type=file: Binary Mask of the skullstripped result with just the brain
+    # type=traitcompound|default=None: Binary Mask of the skullstripped result with just the brain
+    outPrior: generic/file
+    # type=file: Probability prior from the atlas registrations
+    # type=traitcompound|default=None: Probability prior from the atlas registrations
+    outFANTASM: generic/file
+    # type=file: Tissue classification of the whole input volume.
+    # type=traitcompound|default=None: Tissue classification of the whole input volume.
+    outd0: generic/file
+    # type=file: Initial Brainmask
+    # type=traitcompound|default=None: Initial Brainmask
+    outMidsagittal: generic/file
+    # type=file: Plane dividing the brain hemispheres
+    # type=traitcompound|default=None: Plane dividing the brain hemispheres
+    outSplitHalves: generic/file
+    # type=file: Skullstripped mask of the brain with the hemispheres divided.
+    # type=traitcompound|default=None: Skullstripped mask of the brain with the hemispheres divided.
+    outSegmentation: generic/file
+    # type=file: 2D image showing the tissue classification on the midsagittal plane
+    # type=traitcompound|default=None: 2D image showing the tissue classification on the midsagittal plane
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inInput:
+    # type=file|default=<undefined>: Input volume to be skullstripped.
+    inAtlas:
+    # type=file|default=<undefined>: SPECTRE atlas description file. A text file enumerating atlas files and landmarks.
+    inInitial:
+    # type=int|default=0: Erosion of the initial mask, which is based on the probability mask and the classification., The initial mask is output as the d0 volume at the conclusion of SPECTRE.
+    inImage:
+    # type=enum|default='T1_SPGR'|allowed['FLAIR','T1_ALT','T1_MPRAGE','T1_SPGR','T2']: Set the image modality. MP-RAGE is recommended for most T1 sequence images.
+    inOutput:
+    # type=enum|default='true'|allowed['false','true']: Determines if the output results are transformed back into the space of the original input image.
+    inFind:
+    # type=enum|default='true'|allowed['false','true']: Find Midsaggital Plane
+    inRun:
+    # type=enum|default='true'|allowed['false','true']: Run Smooth Brain Mask
+    inResample:
+    # type=enum|default='true'|allowed['false','true']: Determines if the data is resampled to be isotropic during the processing.
+    inInitial2:
+    # type=float|default=0.0: Initial probability threshold
+    inMinimum:
+    # type=float|default=0.0: Minimum probability threshold
+    inMMC:
+    # type=int|default=0: The size of the dilation step within the Modified Morphological Closing.
+    inMMC2:
+    # type=int|default=0: The size of the erosion step within the Modified Morphological Closing.
+    inInhomogeneity:
+    # type=enum|default='true'|allowed['false','true']: Set to false by default, this parameter will make FANTASM try to do inhomogeneity correction during it's iterative cycle.
+    inSmoothing:
+    # type=float|default=0.0: 
+    inBackground:
+    # type=float|default=0.0: 
+    inOutput2:
+    # type=enum|default='true'|allowed['false','true']: Output Plane?
+    inOutput3:
+    # type=enum|default='true'|allowed['false','true']: Output Split-Halves?
+    inOutput4:
+    # type=enum|default='true'|allowed['false','true']: Output Segmentation on Plane?
+    inDegrees:
+    # type=enum|default='Rigid - 6'|allowed['Affine - 12','Global rescale - 7','Rigid - 6','Specific rescale - 9']: Degrees of freedom
+    inCost:
+    # type=enum|default='Correlation ratio'|allowed['Correlation ratio','Least squares','Normalized cross correlation','Normalized mutual information']: Cost function
+    inRegistration:
+    # type=enum|default='Trilinear'|allowed['Bspline 3rd order','Bspline 4th order','Cubic Lagrangian','Heptic Lagrangian','Quintic Lagrangian','Trilinear','Windowed sinc']: Registration interpolation
+    inOutput5:
+    # type=enum|default='Trilinear'|allowed['Bspline 3rd order','Bspline 4th order','Cubic Lagrangian','Heptic Lagrangian','Nearest Neighbor','Quintic Lagrangian','Trilinear','Windowed sinc']: Output interpolation
+    inApply:
+    # type=enum|default='All'|allowed['All','X','Y','Z']: Apply rotation
+    inMinimum2:
+    # type=float|default=0.0: Minimum angle
+    inMaximum:
+    # type=float|default=0.0: Maximum angle
+    inCoarse:
+    # type=float|default=0.0: Coarse angle increment
+    inFine:
+    # type=float|default=0.0: Fine angle increment
+    inMultiple:
+    # type=int|default=0: Multiple of tolerance to bracket the minimum
+    inNumber:
+    # type=int|default=0: Number of iterations
+    inNumber2:
+    # type=int|default=0: Number of minima from Level 8 to test at Level 4
+    inUse:
+    # type=enum|default='true'|allowed['false','true']: Use the max of the min resolutions of the two datasets when resampling
+    inSubsample:
+    # type=enum|default='true'|allowed['false','true']: Subsample image for speed
+    inSkip:
+    # type=enum|default='true'|allowed['false','true']: Skip multilevel search (Assume images are close to alignment)
+    inMultithreading:
+    # type=enum|default='true'|allowed['false','true']: Set to false by default, this parameter controls the multithreaded behavior of the linear registration.
+    xPrefExt:
+    # type=enum|default='nrrd'|allowed['nrrd']: Output File Type
+    outOriginal:
+    # type=file: If Output in Original Space Flag is true then outputs the original input volume. Otherwise outputs the axialy reoriented input volume.
+    # type=traitcompound|default=None: If Output in Original Space Flag is true then outputs the original input volume. Otherwise outputs the axialy reoriented input volume.
+    outStripped:
+    # type=file: Skullstripped result of the input volume with just the brain.
+    # type=traitcompound|default=None: Skullstripped result of the input volume with just the brain.
+    outMask:
+    # type=file: Binary Mask of the skullstripped result with just the brain
+    # type=traitcompound|default=None: Binary Mask of the skullstripped result with just the brain
+    outPrior:
+    # type=file: Probability prior from the atlas registrations
+    # type=traitcompound|default=None: Probability prior from the atlas registrations
+    outFANTASM:
+    # type=file: Tissue classification of the whole input volume.
+    # type=traitcompound|default=None: Tissue classification of the whole input volume.
+    outd0:
+    # type=file: Initial Brainmask
+    # type=traitcompound|default=None: Initial Brainmask
+    outMidsagittal:
+    # type=file: Plane dividing the brain hemispheres
+    # type=traitcompound|default=None: Plane dividing the brain hemispheres
+    outSplitHalves:
+    # type=file: Skullstripped mask of the brain with the hemispheres divided.
+    # type=traitcompound|default=None: Skullstripped mask of the brain with the hemispheres divided.
+    outSegmentation:
+    # type=file: 2D image showing the tissue classification on the midsagittal plane
+    # type=traitcompound|default=None: 2D image showing the tissue classification on the midsagittal plane
+    'null':
+    xDefaultMem:
+    # type=int|default=0: Set default maximum heap size
+    xMaxProcess:
+    # type=int|default=1: Set default maximum number of processes.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_spectre2010_callables.py b/example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_spectre2010_callables.py
new file mode 100644
index 00000000..814db8ce
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_spectre2010_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in MedicAlgorithmSPECTRE2010.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_threshold_to_binary_mask.yaml b/example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_threshold_to_binary_mask.yaml
new file mode 100644
index 00000000..75471636
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_threshold_to_binary_mask.yaml
@@ -0,0 +1,91 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.mipav.developer.MedicAlgorithmThresholdToBinaryMask' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Threshold to Binary Mask.
+# 
+#     Given a volume and an intensity range create a binary mask for values within that range.
+# 
+#     
+task_name: MedicAlgorithmThresholdToBinaryMask
+nipype_name: MedicAlgorithmThresholdToBinaryMask
+nipype_module: nipype.interfaces.mipav.developer
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inLabel: generic/file+list-of
+    # type=inputmultiobject|default=[]: Input volumes
+    outBinary: generic/file+list-of
+    # type=inputmultiobject|default=[]: Binary Mask
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inLabel:
+    # type=inputmultiobject|default=[]: Input volumes
+    inMinimum:
+    # type=float|default=0.0: Minimum threshold value.
+    inMaximum:
+    # type=float|default=0.0: Maximum threshold value.
+    inUse:
+    # type=enum|default='true'|allowed['false','true']: Use the images max intensity as the max value of the range.
+    xPrefExt:
+    # type=enum|default='nrrd'|allowed['nrrd']: Output File Type
+    outBinary:
+    # type=inputmultiobject|default=[]: Binary Mask
+    'null':
+    xDefaultMem:
+    # type=int|default=0: Set default maximum heap size
+    xMaxProcess:
+    # type=int|default=1: Set default maximum number of processes.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_threshold_to_binary_mask_callables.py b/example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_threshold_to_binary_mask_callables.py
new file mode 100644
index 00000000..0a7cae4b
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_threshold_to_binary_mask_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in MedicAlgorithmThresholdToBinaryMask.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-mipav/random_vol.yaml b/example-specs/task/nipype_internal/pydra-mipav/random_vol.yaml
new file mode 100644
index 00000000..eebf05fd
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-mipav/random_vol.yaml
@@ -0,0 +1,97 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.mipav.developer.RandomVol' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Generate a volume of random scalars.
+task_name: RandomVol
+nipype_name: RandomVol
+nipype_module: nipype.interfaces.mipav.developer
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outRand1: generic/file
+    # type=file: Rand1
+    # type=traitcompound|default=None: Rand1
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inSize:
+    # type=int|default=0: Size of Volume in X direction
+    inSize2:
+    # type=int|default=0: Size of Volume in Y direction
+    inSize3:
+    # type=int|default=0: Size of Volume in Z direction
+    inSize4:
+    # type=int|default=0: Size of Volume in t direction
+    inStandard:
+    # type=int|default=0: Standard Deviation for Normal Distribution
+    inLambda:
+    # type=float|default=0.0: Lambda Value for Exponential Distribution
+    inMaximum:
+    # type=int|default=0: Maximum Value
+    inMinimum:
+    # type=int|default=0: Minimum Value
+    inField:
+    # type=enum|default='Uniform'|allowed['Exponential','Normal','Uniform']: Field
+    xPrefExt:
+    # type=enum|default='nrrd'|allowed['nrrd']: Output File Type
+    outRand1:
+    # type=file: Rand1
+    # type=traitcompound|default=None: Rand1
+    'null':
+    xDefaultMem:
+    # type=int|default=0: Set default maximum heap size
+    xMaxProcess:
+    # type=int|default=1: Set default maximum number of processes.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-mipav/random_vol_callables.py b/example-specs/task/nipype_internal/pydra-mipav/random_vol_callables.py
new file mode 100644
index 00000000..d5a8a91e
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-mipav/random_vol_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in RandomVol.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-niftyfit/dwi_tool.yaml b/example-specs/task/nipype_internal/pydra-niftyfit/dwi_tool.yaml
new file mode 100644
index 00000000..6fed5d44
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-niftyfit/dwi_tool.yaml
@@ -0,0 +1,252 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.niftyfit.dwi.DwiTool' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Interface for executable dwi_tool from Niftyfit platform.
+# 
+#     Use DwiTool.
+# 
+#     Diffusion-Weighted MR Prediction.
+#     Predicts DWI from previously fitted models and calculates model derived
+#     maps.
+# 
+#     `Source code <https://cmiclab.cs.ucl.ac.uk/CMIC/NiftyFit-Release>`_
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces import niftyfit
+#     >>> dwi_tool = niftyfit.DwiTool(dti_flag=True)
+#     >>> dwi_tool.inputs.source_file = 'dwi.nii.gz'
+#     >>> dwi_tool.inputs.bvec_file = 'bvecs'
+#     >>> dwi_tool.inputs.bval_file = 'bvals'
+#     >>> dwi_tool.inputs.mask_file = 'mask.nii.gz'
+#     >>> dwi_tool.inputs.b0_file = 'b0.nii.gz'
+#     >>> dwi_tool.inputs.rgbmap_file = 'rgb_map.nii.gz'
+#     >>> dwi_tool.cmdline
+#     'dwi_tool -source dwi.nii.gz -bval bvals -bvec bvecs -b0 b0.nii.gz -mask mask.nii.gz -dti -famap dwi_famap.nii.gz -logdti2 dwi_logdti2.nii.gz -mcmap dwi_mcmap.nii.gz -mdmap dwi_mdmap.nii.gz -rgbmap rgb_map.nii.gz -syn dwi_syn.nii.gz -v1map dwi_v1map.nii.gz'
+# 
+#     
+task_name: DwiTool
+nipype_name: DwiTool
+nipype_module: nipype.interfaces.niftyfit.dwi
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    source_file: medimage/nifti-gz
+    # type=file|default=<undefined>: The source image containing the fitted model.
+    bval_file: medimage/bval
+    # type=file|default=<undefined>: The file containing the bvalues of the source DWI.
+    bvec_file: medimage/bvec
+    # type=file|default=<undefined>: The file containing the bvectors of the source DWI.
+    b0_file: medimage/nifti-gz
+    # type=file|default=<undefined>: The B0 image corresponding to the source DWI
+    mask_file: medimage/nifti-gz
+    # type=file|default=<undefined>: The image mask
+    mcmap_file: generic/file
+    # type=file: Filename of multi-compartment model parameter map (-ivim,-ball,-nod)
+    # type=file|default=<undefined>: Filename of multi-compartment model parameter map (-ivim,-ball,-nod)
+    syn_file: generic/file
+    # type=file: Filename of synthetic image
+    # type=file|default=<undefined>: Filename of synthetic image. Requires: bvec_file/b0_file.
+    mdmap_file: generic/file
+    # type=file: Filename of MD map/ADC
+    # type=file|default=<undefined>: Filename of MD map/ADC
+    famap_file: generic/file
+    # type=file: Filename of FA map
+    # type=file|default=<undefined>: Filename of FA map
+    v1map_file: generic/file
+    # type=file: Filename of PDD map [x,y,z]
+    # type=file|default=<undefined>: Filename of PDD map [x,y,z]
+    rgbmap_file: medimage/nifti-gz
+    # type=file: Filename of colour FA map
+    # type=file|default=<undefined>: Filename of colour FA map.
+    logdti_file: generic/file
+    # type=file: Filename of output logdti map
+    # type=file|default=<undefined>: Filename of output logdti map.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    mcmap_file: generic/file
+    # type=file: Filename of multi-compartment model parameter map (-ivim,-ball,-nod)
+    # type=file|default=<undefined>: Filename of multi-compartment model parameter map (-ivim,-ball,-nod)
+    syn_file: generic/file
+    # type=file: Filename of synthetic image
+    # type=file|default=<undefined>: Filename of synthetic image. Requires: bvec_file/b0_file.
+    mdmap_file: generic/file
+    # type=file: Filename of MD map/ADC
+    # type=file|default=<undefined>: Filename of MD map/ADC
+    famap_file: generic/file
+    # type=file: Filename of FA map
+    # type=file|default=<undefined>: Filename of FA map
+    v1map_file: generic/file
+    # type=file: Filename of PDD map [x,y,z]
+    # type=file|default=<undefined>: Filename of PDD map [x,y,z]
+    rgbmap_file: medimage/nifti-gz
+    # type=file: Filename of colour FA map
+    # type=file|default=<undefined>: Filename of colour FA map.
+    logdti_file: generic/file
+    # type=file: Filename of output logdti map
+    # type=file|default=<undefined>: Filename of output logdti map.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    source_file:
+    # type=file|default=<undefined>: The source image containing the fitted model.
+    bval_file:
+    # type=file|default=<undefined>: The file containing the bvalues of the source DWI.
+    bvec_file:
+    # type=file|default=<undefined>: The file containing the bvectors of the source DWI.
+    b0_file:
+    # type=file|default=<undefined>: The B0 image corresponding to the source DWI
+    mask_file:
+    # type=file|default=<undefined>: The image mask
+    mcmap_file:
+    # type=file: Filename of multi-compartment model parameter map (-ivim,-ball,-nod)
+    # type=file|default=<undefined>: Filename of multi-compartment model parameter map (-ivim,-ball,-nod)
+    syn_file:
+    # type=file: Filename of synthetic image
+    # type=file|default=<undefined>: Filename of synthetic image. Requires: bvec_file/b0_file.
+    mdmap_file:
+    # type=file: Filename of MD map/ADC
+    # type=file|default=<undefined>: Filename of MD map/ADC
+    famap_file:
+    # type=file: Filename of FA map
+    # type=file|default=<undefined>: Filename of FA map
+    v1map_file:
+    # type=file: Filename of PDD map [x,y,z]
+    # type=file|default=<undefined>: Filename of PDD map [x,y,z]
+    rgbmap_file:
+    # type=file: Filename of colour FA map
+    # type=file|default=<undefined>: Filename of colour FA map.
+    logdti_file:
+    # type=file: Filename of output logdti map
+    # type=file|default=<undefined>: Filename of output logdti map.
+    mono_flag:
+    # type=bool|default=False: Input is a single exponential to non-directional data [default with no b-vectors]
+    ivim_flag:
+    # type=bool|default=False: Inputs is an IVIM model to non-directional data.
+    dti_flag:
+    # type=bool|default=False: Input is a tensor model diag/off-diag.
+    dti_flag2:
+    # type=bool|default=False: Input is a tensor model lower triangular
+    ball_flag:
+    # type=bool|default=False: Input is a ball and stick model.
+    ballv_flag:
+    # type=bool|default=False: Input is a ball and stick model with optimised PDD.
+    nod_flag:
+    # type=bool|default=False: Input is a NODDI model
+    nodv_flag:
+    # type=bool|default=False: Input is a NODDI model with optimised PDD
+    diso_val:
+    # type=float|default=0.0: Isotropic diffusivity for -nod [3e-3]
+    dpr_val:
+    # type=float|default=0.0: Parallel diffusivity for -nod [1.7e-3].
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    source_file:
+    # type=file|default=<undefined>: The source image containing the fitted model.
+    bvec_file:
+    # type=file|default=<undefined>: The file containing the bvectors of the source DWI.
+    bval_file:
+    # type=file|default=<undefined>: The file containing the bvalues of the source DWI.
+    mask_file:
+    # type=file|default=<undefined>: The image mask
+    b0_file:
+    # type=file|default=<undefined>: The B0 image corresponding to the source DWI
+    rgbmap_file:
+    # type=file: Filename of colour FA map
+    # type=file|default=<undefined>: Filename of colour FA map.
+    dti_flag: 'True'
+    # type=bool|default=False: Input is a tensor model diag/off-diag.
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: dwi_tool -source dwi.nii.gz -bval bvals -bvec bvecs -b0 b0.nii.gz -mask mask.nii.gz -dti -famap dwi_famap.nii.gz -logdti2 dwi_logdti2.nii.gz -mcmap dwi_mcmap.nii.gz -mdmap dwi_mdmap.nii.gz -rgbmap rgb_map.nii.gz -syn dwi_syn.nii.gz -v1map dwi_v1map.nii.gz
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    source_file:
+    # type=file|default=<undefined>: The source image containing the fitted model.
+    bvec_file:
+    # type=file|default=<undefined>: The file containing the bvectors of the source DWI.
+    bval_file:
+    # type=file|default=<undefined>: The file containing the bvalues of the source DWI.
+    mask_file:
+    # type=file|default=<undefined>: The image mask
+    b0_file:
+    # type=file|default=<undefined>: The B0 image corresponding to the source DWI
+    rgbmap_file:
+    # type=file: Filename of colour FA map
+    # type=file|default=<undefined>: Filename of colour FA map.
+    dti_flag: 'True'
+    # type=bool|default=False: Input is a tensor model diag/off-diag.
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-niftyfit/dwi_tool_callables.py b/example-specs/task/nipype_internal/pydra-niftyfit/dwi_tool_callables.py
new file mode 100644
index 00000000..d5325340
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-niftyfit/dwi_tool_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in DwiTool.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-niftyfit/fit_asl.yaml b/example-specs/task/nipype_internal/pydra-niftyfit/fit_asl.yaml
new file mode 100644
index 00000000..808006ad
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-niftyfit/fit_asl.yaml
@@ -0,0 +1,227 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.niftyfit.asl.FitAsl' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Interface for executable fit_asl from Niftyfit platform.
+# 
+#     Use NiftyFit to perform ASL fitting.
+# 
+#     ASL fitting routines (following EU Cost Action White Paper recommendations)
+#     Fits Cerebral Blood Flow maps in the first instance.
+# 
+#     `Source code <https://cmiclab.cs.ucl.ac.uk/CMIC/NiftyFit-Release>`_
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import niftyfit
+#     >>> node = niftyfit.FitAsl()
+#     >>> node.inputs.source_file = 'asl.nii.gz'
+#     >>> node.cmdline
+#     'fit_asl -source asl.nii.gz -cbf asl_cbf.nii.gz -error asl_error.nii.gz -syn asl_syn.nii.gz'
+# 
+#     
+task_name: FitAsl
+nipype_name: FitAsl
+nipype_module: nipype.interfaces.niftyfit.asl
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    source_file: medimage/nifti-gz
+    # type=file|default=<undefined>: Filename of the 4D ASL (control/label) source image (mandatory).
+    cbf_file: generic/file
+    # type=file: Filename of the Cerebral Blood Flow map (in ml/100g/min).
+    # type=file|default=<undefined>: Filename of the Cerebral Blood Flow map (in ml/100g/min).
+    error_file: generic/file
+    # type=file: Filename of the CBF error map.
+    # type=file|default=<undefined>: Filename of the CBF error map.
+    syn_file: generic/file
+    # type=file: Filename of the synthetic ASL data.
+    # type=file|default=<undefined>: Filename of the synthetic ASL data.
+    t1map: generic/file
+    # type=file|default=<undefined>: Filename of the estimated input T1 map (in ms).
+    m0map: generic/file
+    # type=file|default=<undefined>: Filename of the estimated input M0 map.
+    m0mape: generic/file
+    # type=file|default=<undefined>: Filename of the estimated input M0 map error.
+    ir_volume: generic/file
+    # type=file|default=<undefined>: Filename of a [1,2,5]s Inversion Recovery volume (T1/M0 fitting carried out internally).
+    ir_output: generic/file
+    # type=file|default=<undefined>: Output of [1,2,5]s Inversion Recovery fitting.
+    mask: generic/file
+    # type=file|default=<undefined>: Filename of image mask.
+    seg: generic/file
+    # type=file|default=<undefined>: Filename of the 4D segmentation (in ASL space) for L/T1 estimation and PV correction {WM,GM,CSF}.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    cbf_file: generic/file
+    # type=file: Filename of the Cerebral Blood Flow map (in ml/100g/min).
+    # type=file|default=<undefined>: Filename of the Cerebral Blood Flow map (in ml/100g/min).
+    error_file: generic/file
+    # type=file: Filename of the CBF error map.
+    # type=file|default=<undefined>: Filename of the CBF error map.
+    syn_file: generic/file
+    # type=file: Filename of the synthetic ASL data.
+    # type=file|default=<undefined>: Filename of the synthetic ASL data.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    source_file:
+    # type=file|default=<undefined>: Filename of the 4D ASL (control/label) source image (mandatory).
+    pasl:
+    # type=bool|default=False: Fit PASL ASL data [default]
+    pcasl:
+    # type=bool|default=False: Fit PCASL ASL data
+    cbf_file:
+    # type=file: Filename of the Cerebral Blood Flow map (in ml/100g/min).
+    # type=file|default=<undefined>: Filename of the Cerebral Blood Flow map (in ml/100g/min).
+    error_file:
+    # type=file: Filename of the CBF error map.
+    # type=file|default=<undefined>: Filename of the CBF error map.
+    syn_file:
+    # type=file: Filename of the synthetic ASL data.
+    # type=file|default=<undefined>: Filename of the synthetic ASL data.
+    t1map:
+    # type=file|default=<undefined>: Filename of the estimated input T1 map (in ms).
+    m0map:
+    # type=file|default=<undefined>: Filename of the estimated input M0 map.
+    m0mape:
+    # type=file|default=<undefined>: Filename of the estimated input M0 map error.
+    ir_volume:
+    # type=file|default=<undefined>: Filename of a [1,2,5]s Inversion Recovery volume (T1/M0 fitting carried out internally).
+    ir_output:
+    # type=file|default=<undefined>: Output of [1,2,5]s Inversion Recovery fitting.
+    mask:
+    # type=file|default=<undefined>: Filename of image mask.
+    t1_art_cmp:
+    # type=float|default=0.0: T1 of arterial component [1650ms].
+    plasma_coeff:
+    # type=float|default=0.0: Single plasma/tissue partition coefficient [0.9ml/g].
+    eff:
+    # type=float|default=0.0: Labelling efficiency [0.99 (pasl), 0.85 (pcasl)], ensure any background suppression pulses are included in -eff
+    out:
+    # type=float|default=0.0: Outlier rejection for multi CL volumes (enter z-score threshold (e.g. 2.5)) [off].
+    pld:
+    # type=float|default=0.0: Post Labelling Delay [2000ms].
+    ldd:
+    # type=float|default=0.0: Labelling Duration [1800ms].
+    dpld:
+    # type=float|default=0.0: Difference in labelling delay per slice [0.0 ms/slice.
+    t_inv1:
+    # type=float|default=0.0: Saturation pulse time [800ms].
+    t_inv2:
+    # type=float|default=0.0: Inversion time [2000ms].
+    dt_inv2:
+    # type=float|default=0.0: Difference in inversion time per slice [0ms/slice].
+    gm_t1:
+    # type=float|default=0.0: T1 of GM [1150ms].
+    gm_plasma:
+    # type=float|default=0.0: Plasma/GM water partition [0.95ml/g].
+    gm_ttt:
+    # type=float|default=0.0: Time to GM [ATT+0ms].
+    wm_t1:
+    # type=float|default=0.0: T1 of WM [800ms].
+    wm_plasma:
+    # type=float|default=0.0: Plasma/WM water partition [0.82ml/g].
+    wm_ttt:
+    # type=float|default=0.0: Time to WM [ATT+0ms].
+    seg:
+    # type=file|default=<undefined>: Filename of the 4D segmentation (in ASL space) for L/T1 estimation and PV correction {WM,GM,CSF}.
+    sig:
+    # type=bool|default=False: Use sigmoid to estimate L from T1: L(T1|gmL,wmL) [Off].
+    pv0:
+    # type=int|default=0: Simple PV correction (CBF=vg*CBFg + vw*CBFw, with CBFw=f*CBFg) [0.25].
+    pv2:
+    # type=int|default=0: In plane PV kernel size [3x3].
+    pv3:
+    # type=tuple|default=(0, 0, 0): 3D kernel size [3x3x1].
+    mul:
+    # type=float|default=0.0: Multiply CBF by this value (e.g. if CL are mislabelled use -1.0).
+    mulgm:
+    # type=bool|default=False: Multiply CBF by segmentation [Off].
+    pv_threshold:
+    # type=bool|default=False: Set PV threshold for switching off LSQR [O.05].
+    segstyle:
+    # type=bool|default=False: Set CBF as [gm,wm] not [wm,gm].
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    source_file:
+    # type=file|default=<undefined>: Filename of the 4D ASL (control/label) source image (mandatory).
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: fit_asl -source asl.nii.gz -cbf asl_cbf.nii.gz -error asl_error.nii.gz -syn asl_syn.nii.gz
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    source_file:
+    # type=file|default=<undefined>: Filename of the 4D ASL (control/label) source image (mandatory).
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-niftyfit/fit_asl_callables.py b/example-specs/task/nipype_internal/pydra-niftyfit/fit_asl_callables.py
new file mode 100644
index 00000000..753aabb6
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-niftyfit/fit_asl_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in FitAsl.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-niftyfit/fit_dwi.yaml b/example-specs/task/nipype_internal/pydra-niftyfit/fit_dwi.yaml
new file mode 100644
index 00000000..94e94772
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-niftyfit/fit_dwi.yaml
@@ -0,0 +1,328 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.niftyfit.dwi.FitDwi' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Interface for executable fit_dwi from Niftyfit platform.
+# 
+#     Use NiftyFit to perform diffusion model fitting.
+# 
+#     Diffusion-weighted MR Fitting.
+#     Fits DWI parameter maps to multi-shell, multi-directional data.
+# 
+#     `Source code <https://cmiclab.cs.ucl.ac.uk/CMIC/NiftyFit-Release>`_
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces import niftyfit
+#     >>> fit_dwi = niftyfit.FitDwi(dti_flag=True)
+#     >>> fit_dwi.inputs.source_file = 'dwi.nii.gz'
+#     >>> fit_dwi.inputs.bvec_file = 'bvecs'
+#     >>> fit_dwi.inputs.bval_file = 'bvals'
+#     >>> fit_dwi.inputs.rgbmap_file = 'rgb.nii.gz'
+#     >>> fit_dwi.cmdline
+#     'fit_dwi -source dwi.nii.gz -bval bvals -bvec bvecs -dti -error dwi_error.nii.gz -famap dwi_famap.nii.gz -mcout dwi_mcout.txt -mdmap dwi_mdmap.nii.gz -nodiff dwi_no_diff.nii.gz -res dwi_resmap.nii.gz -rgbmap rgb.nii.gz -syn dwi_syn.nii.gz -tenmap2 dwi_tenmap2.nii.gz -v1map dwi_v1map.nii.gz'
+# 
+#     
+task_name: FitDwi
+nipype_name: FitDwi
+nipype_module: nipype.interfaces.niftyfit.dwi
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    source_file: medimage/nifti-gz
+    # type=file|default=<undefined>: The source image containing the dwi data.
+    bval_file: medimage/bval
+    # type=file|default=<undefined>: The file containing the bvalues of the source DWI.
+    bvec_file: medimage/bvec
+    # type=file|default=<undefined>: The file containing the bvectors of the source DWI.
+    te_file: generic/file
+    # type=file|default=<undefined>: Filename of TEs (ms).
+    te_value: generic/file
+    # type=file|default=<undefined>: Value of TEs (ms).
+    mask_file: generic/file
+    # type=file|default=<undefined>: The image mask
+    prior_file: generic/file
+    # type=file|default=<undefined>: Filename of parameter priors for -ball and -nod.
+    error_file: generic/file
+    # type=file: Filename of parameter error maps
+    # type=file|default=<undefined>: Filename of parameter error maps.
+    res_file: generic/file
+    # type=file: Filename of model residual map
+    # type=file|default=<undefined>: Filename of model residual map.
+    syn_file: generic/file
+    # type=file: Filename of synthetic image
+    # type=file|default=<undefined>: Filename of synthetic image.
+    nodiff_file: generic/file
+    # type=file: Filename of average no diffusion image.
+    # type=file|default=<undefined>: Filename of average no diffusion image.
+    mcmap_file: generic/file
+    # type=file: Filename of multi-compartment model parameter map (-ivim,-ball,-nod).
+    # type=file|default=<undefined>: Filename of multi-compartment model parameter map (-ivim,-ball,-nod)
+    mdmap_file: generic/file
+    # type=file: Filename of MD map/ADC
+    # type=file|default=<undefined>: Filename of MD map/ADC
+    famap_file: generic/file
+    # type=file: Filename of FA map
+    # type=file|default=<undefined>: Filename of FA map
+    v1map_file: generic/file
+    # type=file: Filename of PDD map [x,y,z]
+    # type=file|default=<undefined>: Filename of PDD map [x,y,z]
+    rgbmap_file: medimage/nifti-gz
+    # type=file: Filename of colour FA map
+    # type=file|default=<undefined>: Filename of colour-coded FA map
+    tenmap_file: generic/file
+    # type=file: Filename of tensor map
+    # type=file|default=<undefined>: Filename of tensor map [diag,offdiag].
+    tenmap2_file: generic/file
+    # type=file: Filename of tensor map [lower tri]
+    # type=file|default=<undefined>: Filename of tensor map [lower tri]
+    cov_file: generic/file
+    # type=file|default=<undefined>: Filename of ithe nc*nc covariance matrix [I]
+    mcout: generic/file
+    # type=file: Filename of mc samples (ascii text file)
+    # type=file|default=<undefined>: Filename of mc samples (ascii text file)
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    error_file: generic/file
+    # type=file: Filename of parameter error maps
+    # type=file|default=<undefined>: Filename of parameter error maps.
+    res_file: generic/file
+    # type=file: Filename of model residual map
+    # type=file|default=<undefined>: Filename of model residual map.
+    syn_file: generic/file
+    # type=file: Filename of synthetic image
+    # type=file|default=<undefined>: Filename of synthetic image.
+    nodiff_file: generic/file
+    # type=file: Filename of average no diffusion image.
+    # type=file|default=<undefined>: Filename of average no diffusion image.
+    mdmap_file: generic/file
+    # type=file: Filename of MD map/ADC
+    # type=file|default=<undefined>: Filename of MD map/ADC
+    famap_file: generic/file
+    # type=file: Filename of FA map
+    # type=file|default=<undefined>: Filename of FA map
+    v1map_file: generic/file
+    # type=file: Filename of PDD map [x,y,z]
+    # type=file|default=<undefined>: Filename of PDD map [x,y,z]
+    rgbmap_file: medimage/nifti-gz
+    # type=file: Filename of colour FA map
+    # type=file|default=<undefined>: Filename of colour-coded FA map
+    tenmap_file: generic/file
+    # type=file: Filename of tensor map
+    # type=file|default=<undefined>: Filename of tensor map [diag,offdiag].
+    tenmap2_file: generic/file
+    # type=file: Filename of tensor map [lower tri]
+    # type=file|default=<undefined>: Filename of tensor map [lower tri]
+    mcmap_file: generic/file
+    # type=file: Filename of multi-compartment model parameter map (-ivim,-ball,-nod).
+    # type=file|default=<undefined>: Filename of multi-compartment model parameter map (-ivim,-ball,-nod)
+    mcout: generic/file
+    # type=file: Filename of mc samples (ascii text file)
+    # type=file|default=<undefined>: Filename of mc samples (ascii text file)
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    source_file:
+    # type=file|default=<undefined>: The source image containing the dwi data.
+    bval_file:
+    # type=file|default=<undefined>: The file containing the bvalues of the source DWI.
+    bvec_file:
+    # type=file|default=<undefined>: The file containing the bvectors of the source DWI.
+    te_file:
+    # type=file|default=<undefined>: Filename of TEs (ms).
+    te_value:
+    # type=file|default=<undefined>: Value of TEs (ms).
+    mask_file:
+    # type=file|default=<undefined>: The image mask
+    prior_file:
+    # type=file|default=<undefined>: Filename of parameter priors for -ball and -nod.
+    rot_sform_flag:
+    # type=int|default=0: Rotate the output tensors according to the q/s form of the image (resulting tensors will be in mm coordinates, default: 0).
+    error_file:
+    # type=file: Filename of parameter error maps
+    # type=file|default=<undefined>: Filename of parameter error maps.
+    res_file:
+    # type=file: Filename of model residual map
+    # type=file|default=<undefined>: Filename of model residual map.
+    syn_file:
+    # type=file: Filename of synthetic image
+    # type=file|default=<undefined>: Filename of synthetic image.
+    nodiff_file:
+    # type=file: Filename of average no diffusion image.
+    # type=file|default=<undefined>: Filename of average no diffusion image.
+    mcmap_file:
+    # type=file: Filename of multi-compartment model parameter map (-ivim,-ball,-nod).
+    # type=file|default=<undefined>: Filename of multi-compartment model parameter map (-ivim,-ball,-nod)
+    mdmap_file:
+    # type=file: Filename of MD map/ADC
+    # type=file|default=<undefined>: Filename of MD map/ADC
+    famap_file:
+    # type=file: Filename of FA map
+    # type=file|default=<undefined>: Filename of FA map
+    v1map_file:
+    # type=file: Filename of PDD map [x,y,z]
+    # type=file|default=<undefined>: Filename of PDD map [x,y,z]
+    rgbmap_file:
+    # type=file: Filename of colour FA map
+    # type=file|default=<undefined>: Filename of colour-coded FA map
+    ten_type:
+    # type=enum|default='lower-tri'|allowed['diag-off-diag','lower-tri']: Use lower triangular (tenmap2) or diagonal, off-diagonal tensor format
+    tenmap_file:
+    # type=file: Filename of tensor map
+    # type=file|default=<undefined>: Filename of tensor map [diag,offdiag].
+    tenmap2_file:
+    # type=file: Filename of tensor map [lower tri]
+    # type=file|default=<undefined>: Filename of tensor map [lower tri]
+    mono_flag:
+    # type=bool|default=False: Fit single exponential to non-directional data [default with no b-vectors]
+    ivim_flag:
+    # type=bool|default=False: Fit IVIM model to non-directional data.
+    dti_flag:
+    # type=bool|default=False: Fit the tensor model [default with b-vectors].
+    ball_flag:
+    # type=bool|default=False: Fit the ball and stick model.
+    ballv_flag:
+    # type=bool|default=False: Fit the ball and stick model with optimised PDD.
+    nod_flag:
+    # type=bool|default=False: Fit the NODDI model
+    nodv_flag:
+    # type=bool|default=False: Fit the NODDI model with optimised PDD
+    maxit_val:
+    # type=int|default=0: Maximum number of non-linear LSQR iterations [100x2 passes])
+    lm_vals:
+    # type=tuple|default=(0.0, 0.0): LM parameters (initial value, decrease rate) [100,1.2].
+    gn_flag:
+    # type=bool|default=False: Use Gauss-Newton algorithm [Levenberg-Marquardt].
+    vb_flag:
+    # type=bool|default=False: Use Variational Bayes fitting with known prior (currently identity covariance...).
+    cov_file:
+    # type=file|default=<undefined>: Filename of ithe nc*nc covariance matrix [I]
+    wls_flag:
+    # type=bool|default=False: Use Variational Bayes fitting with known prior (currently identity covariance...).
+    swls_val:
+    # type=float|default=0.0: Use location-weighted least squares for DTI fitting [3x3 Gaussian]
+    slice_no:
+    # type=int|default=0: Fit to single slice number.
+    voxel:
+    # type=tuple|default=(0, 0, 0): Fit to single voxel only.
+    diso_val:
+    # type=float|default=0.0: Isotropic diffusivity for -nod [3e-3]
+    dpr_val:
+    # type=float|default=0.0: Parallel diffusivity for -nod [1.7e-3].
+    wm_t2_val:
+    # type=float|default=0.0: White matter T2 value [80ms].
+    csf_t2_val:
+    # type=float|default=0.0: CSF T2 value [400ms].
+    perf_thr:
+    # type=float|default=0.0: Threshold for perfusion/diffsuion effects [100].
+    mcout:
+    # type=file: Filename of mc samples (ascii text file)
+    # type=file|default=<undefined>: Filename of mc samples (ascii text file)
+    mcsamples:
+    # type=int|default=0: Number of samples to keep [100].
+    mcmaxit:
+    # type=int|default=0: Number of iterations to run [10,000].
+    acceptance:
+    # type=float|default=0.0: Fraction of iterations to accept [0.23].
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    source_file:
+    # type=file|default=<undefined>: The source image containing the dwi data.
+    bvec_file:
+    # type=file|default=<undefined>: The file containing the bvectors of the source DWI.
+    bval_file:
+    # type=file|default=<undefined>: The file containing the bvalues of the source DWI.
+    rgbmap_file:
+    # type=file: Filename of colour FA map
+    # type=file|default=<undefined>: Filename of colour-coded FA map
+    dti_flag: 'True'
+    # type=bool|default=False: Fit the tensor model [default with b-vectors].
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: fit_dwi -source dwi.nii.gz -bval bvals -bvec bvecs -dti -error dwi_error.nii.gz -famap dwi_famap.nii.gz -mcout dwi_mcout.txt -mdmap dwi_mdmap.nii.gz -nodiff dwi_no_diff.nii.gz -res dwi_resmap.nii.gz -rgbmap rgb.nii.gz -syn dwi_syn.nii.gz -tenmap2 dwi_tenmap2.nii.gz -v1map dwi_v1map.nii.gz
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    source_file:
+    # type=file|default=<undefined>: The source image containing the dwi data.
+    bvec_file:
+    # type=file|default=<undefined>: The file containing the bvectors of the source DWI.
+    bval_file:
+    # type=file|default=<undefined>: The file containing the bvalues of the source DWI.
+    rgbmap_file:
+    # type=file: Filename of colour FA map
+    # type=file|default=<undefined>: Filename of colour-coded FA map
+    dti_flag: 'True'
+    # type=bool|default=False: Fit the tensor model [default with b-vectors].
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-niftyfit/fit_dwi_callables.py b/example-specs/task/nipype_internal/pydra-niftyfit/fit_dwi_callables.py
new file mode 100644
index 00000000..4126c31d
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-niftyfit/fit_dwi_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in FitDwi.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-niftyfit/fit_qt_1.yaml b/example-specs/task/nipype_internal/pydra-niftyfit/fit_qt_1.yaml
new file mode 100644
index 00000000..2f3626b8
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-niftyfit/fit_qt_1.yaml
@@ -0,0 +1,248 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.niftyfit.qt1.FitQt1' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Interface for executable fit_qt1 from Niftyfit platform.
+# 
+#     Use NiftyFit to perform Qt1 fitting.
+# 
+#     T1 Fitting Routine (To inversion recovery or spgr data).
+#     Fits single component T1 maps in the first instance.
+# 
+#     `Source code <https://cmiclab.cs.ucl.ac.uk/CMIC/NiftyFit-Release>`_
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces.niftyfit import FitQt1
+#     >>> fit_qt1 = FitQt1()
+#     >>> fit_qt1.inputs.source_file = 'TI4D.nii.gz'
+#     >>> fit_qt1.cmdline
+#     'fit_qt1 -source TI4D.nii.gz -comp TI4D_comp.nii.gz -error TI4D_error.nii.gz -m0map TI4D_m0map.nii.gz -mcmap TI4D_mcmap.nii.gz -res TI4D_res.nii.gz -syn TI4D_syn.nii.gz -t1map TI4D_t1map.nii.gz'
+# 
+#     
+task_name: FitQt1
+nipype_name: FitQt1
+nipype_module: nipype.interfaces.niftyfit.qt1
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    source_file: medimage/nifti-gz
+    # type=file|default=<undefined>: Filename of the 4D Multi-Echo T1 source image.
+    t1map_file: generic/file
+    # type=file: Filename of the estimated output T1 map (in ms)
+    # type=file|default=<undefined>: Filename of the estimated output T1 map (in ms).
+    m0map_file: generic/file
+    # type=file: Filename of the m0 map
+    # type=file|default=<undefined>: Filename of the estimated input M0 map.
+    mcmap_file: generic/file
+    # type=file: Filename of the estimated output multi-parameter map
+    # type=file|default=<undefined>: Filename of the estimated output multi-parameter map.
+    comp_file: generic/file
+    # type=file: Filename of the estimated multi-component T1 map.
+    # type=file|default=<undefined>: Filename of the estimated multi-component T1 map.
+    error_file: generic/file
+    # type=file: Filename of the error map (symmetric matrix, [Diag,OffDiag])
+    # type=file|default=<undefined>: Filename of the error map (symmetric matrix, [Diag,OffDiag]).
+    syn_file: generic/file
+    # type=file: Filename of the synthetic ASL data
+    # type=file|default=<undefined>: Filename of the synthetic ASL data.
+    res_file: generic/file
+    # type=file: Filename of the model fit residuals
+    # type=file|default=<undefined>: Filename of the model fit residuals
+    mask: generic/file
+    # type=file|default=<undefined>: Filename of image mask.
+    prior: generic/file
+    # type=file|default=<undefined>: Filename of parameter prior.
+    tis_list: generic/file
+    # type=file|default=<undefined>: Filename of list of pre-defined TIs.
+    t1_list: generic/file
+    # type=file|default=<undefined>: Filename of list of pre-defined T1s
+    flips_list: generic/file
+    # type=file|default=<undefined>: Filename of list of pre-defined flip angles (deg).
+    b1map: generic/file
+    # type=file|default=<undefined>: Filename of B1 estimate for fitting (or include in prior).
+    mcout: generic/file
+    # type=file|default=<undefined>: Filename of mc samples (ascii text file)
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    t1map_file: generic/file
+    # type=file: Filename of the estimated output T1 map (in ms)
+    # type=file|default=<undefined>: Filename of the estimated output T1 map (in ms).
+    m0map_file: generic/file
+    # type=file: Filename of the m0 map
+    # type=file|default=<undefined>: Filename of the estimated input M0 map.
+    mcmap_file: generic/file
+    # type=file: Filename of the estimated output multi-parameter map
+    # type=file|default=<undefined>: Filename of the estimated output multi-parameter map.
+    comp_file: generic/file
+    # type=file: Filename of the estimated multi-component T1 map.
+    # type=file|default=<undefined>: Filename of the estimated multi-component T1 map.
+    error_file: generic/file
+    # type=file: Filename of the error map (symmetric matrix, [Diag,OffDiag])
+    # type=file|default=<undefined>: Filename of the error map (symmetric matrix, [Diag,OffDiag]).
+    syn_file: generic/file
+    # type=file: Filename of the synthetic ASL data
+    # type=file|default=<undefined>: Filename of the synthetic ASL data.
+    res_file: generic/file
+    # type=file: Filename of the model fit residuals
+    # type=file|default=<undefined>: Filename of the model fit residuals
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    source_file:
+    # type=file|default=<undefined>: Filename of the 4D Multi-Echo T1 source image.
+    t1map_file:
+    # type=file: Filename of the estimated output T1 map (in ms)
+    # type=file|default=<undefined>: Filename of the estimated output T1 map (in ms).
+    m0map_file:
+    # type=file: Filename of the m0 map
+    # type=file|default=<undefined>: Filename of the estimated input M0 map.
+    mcmap_file:
+    # type=file: Filename of the estimated output multi-parameter map
+    # type=file|default=<undefined>: Filename of the estimated output multi-parameter map.
+    comp_file:
+    # type=file: Filename of the estimated multi-component T1 map.
+    # type=file|default=<undefined>: Filename of the estimated multi-component T1 map.
+    error_file:
+    # type=file: Filename of the error map (symmetric matrix, [Diag,OffDiag])
+    # type=file|default=<undefined>: Filename of the error map (symmetric matrix, [Diag,OffDiag]).
+    syn_file:
+    # type=file: Filename of the synthetic ASL data
+    # type=file|default=<undefined>: Filename of the synthetic ASL data.
+    res_file:
+    # type=file: Filename of the model fit residuals
+    # type=file|default=<undefined>: Filename of the model fit residuals
+    mask:
+    # type=file|default=<undefined>: Filename of image mask.
+    prior:
+    # type=file|default=<undefined>: Filename of parameter prior.
+    te_value:
+    # type=float|default=0.0: TE Echo Time [0ms!].
+    tr_value:
+    # type=float|default=0.0: TR Repetition Time [10s!].
+    nb_comp:
+    # type=int|default=0: Number of components to fit [1] (currently IR/SR only)
+    lm_val:
+    # type=tuple|default=(0.0, 0.0): Set LM parameters (initial value, decrease rate) [100,1.2].
+    gn_flag:
+    # type=bool|default=False: Use Gauss-Newton algorithm [Levenberg-Marquardt].
+    slice_no:
+    # type=int|default=0: Fit to single slice number.
+    voxel:
+    # type=tuple|default=(0, 0, 0): Fit to single voxel only.
+    maxit:
+    # type=int|default=0: NLSQR iterations [100].
+    sr_flag:
+    # type=bool|default=False: Saturation Recovery fitting [default].
+    ir_flag:
+    # type=bool|default=False: Inversion Recovery fitting [default].
+    tis:
+    # type=list|default=[]: Inversion times for T1 data [1s,2s,5s].
+    tis_list:
+    # type=file|default=<undefined>: Filename of list of pre-defined TIs.
+    t1_list:
+    # type=file|default=<undefined>: Filename of list of pre-defined T1s
+    t1min:
+    # type=float|default=0.0: Minimum tissue T1 value [400ms].
+    t1max:
+    # type=float|default=0.0: Maximum tissue T1 value [4000ms].
+    spgr:
+    # type=bool|default=False: Spoiled Gradient Echo fitting
+    flips:
+    # type=list|default=[]: Flip angles
+    flips_list:
+    # type=file|default=<undefined>: Filename of list of pre-defined flip angles (deg).
+    b1map:
+    # type=file|default=<undefined>: Filename of B1 estimate for fitting (or include in prior).
+    mcout:
+    # type=file|default=<undefined>: Filename of mc samples (ascii text file)
+    mcsamples:
+    # type=int|default=0: Number of samples to keep [100].
+    mcmaxit:
+    # type=int|default=0: Number of iterations to run [10,000].
+    acceptance:
+    # type=float|default=0.0: Fraction of iterations to accept [0.23].
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    source_file:
+    # type=file|default=<undefined>: Filename of the 4D Multi-Echo T1 source image.
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: fit_qt1 -source TI4D.nii.gz -comp TI4D_comp.nii.gz -error TI4D_error.nii.gz -m0map TI4D_m0map.nii.gz -mcmap TI4D_mcmap.nii.gz -res TI4D_res.nii.gz -syn TI4D_syn.nii.gz -t1map TI4D_t1map.nii.gz
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    source_file:
+    # type=file|default=<undefined>: Filename of the 4D Multi-Echo T1 source image.
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-niftyfit/fit_qt_1_callables.py b/example-specs/task/nipype_internal/pydra-niftyfit/fit_qt_1_callables.py
new file mode 100644
index 00000000..a2a3a5e7
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-niftyfit/fit_qt_1_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in FitQt1.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-niftyreg/reg_aladin.yaml b/example-specs/task/nipype_internal/pydra-niftyreg/reg_aladin.yaml
new file mode 100644
index 00000000..87fccc3b
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-niftyreg/reg_aladin.yaml
@@ -0,0 +1,209 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.niftyreg.reg.RegAladin' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Interface for executable reg_aladin from NiftyReg platform.
+# 
+#     Block Matching algorithm for symmetric global registration.
+#     Based on Modat et al., "Global image registration using
+#     asymmetric block-matching approach"
+#     J. Med. Img. 1(2) 024003, 2014, doi: 10.1117/1.JMI.1.2.024003
+# 
+#     `Source code <https://cmiclab.cs.ucl.ac.uk/mmodat/niftyreg>`_
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import niftyreg
+#     >>> node = niftyreg.RegAladin()
+#     >>> node.inputs.ref_file = 'im1.nii'
+#     >>> node.inputs.flo_file = 'im2.nii'
+#     >>> node.inputs.rmask_file = 'mask.nii'
+#     >>> node.inputs.omp_core_val = 4
+#     >>> node.cmdline
+#     'reg_aladin -aff im2_aff.txt -flo im2.nii -omp 4 -ref im1.nii -res im2_res.nii.gz -rmask mask.nii'
+# 
+#     
+task_name: RegAladin
+nipype_name: RegAladin
+nipype_module: nipype.interfaces.niftyreg.reg
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    ref_file: medimage/nifti1
+    # type=file|default=<undefined>: The input reference/target image
+    flo_file: medimage/nifti1
+    # type=file|default=<undefined>: The input floating/source image
+    in_aff_file: generic/file
+    # type=file|default=<undefined>: The input affine transformation
+    rmask_file: medimage/nifti1
+    # type=file|default=<undefined>: The input reference mask
+    fmask_file: generic/file
+    # type=file|default=<undefined>: The input floating mask
+    aff_file: generic/file
+    # type=file: The output affine file
+    # type=file|default=<undefined>: The output affine matrix file
+    res_file: generic/file
+    # type=file: The output transformed image
+    # type=file|default=<undefined>: The affine transformed floating image
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    aff_file: generic/file
+    # type=file: The output affine file
+    # type=file|default=<undefined>: The output affine matrix file
+    res_file: generic/file
+    # type=file: The output transformed image
+    # type=file|default=<undefined>: The affine transformed floating image
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    ref_file:
+    # type=file|default=<undefined>: The input reference/target image
+    flo_file:
+    # type=file|default=<undefined>: The input floating/source image
+    nosym_flag:
+    # type=bool|default=False: Turn off symmetric registration
+    rig_only_flag:
+    # type=bool|default=False: Do only a rigid registration
+    aff_direct_flag:
+    # type=bool|default=False: Directly optimise the affine parameters
+    in_aff_file:
+    # type=file|default=<undefined>: The input affine transformation
+    rmask_file:
+    # type=file|default=<undefined>: The input reference mask
+    fmask_file:
+    # type=file|default=<undefined>: The input floating mask
+    maxit_val:
+    # type=range|default=0: Maximum number of iterations
+    ln_val:
+    # type=range|default=0: Number of resolution levels to create
+    lp_val:
+    # type=range|default=0: Number of resolution levels to perform
+    smoo_r_val:
+    # type=float|default=0.0: Amount of smoothing to apply to reference image
+    smoo_f_val:
+    # type=float|default=0.0: Amount of smoothing to apply to floating image
+    nac_flag:
+    # type=bool|default=False: Use nifti header to initialise transformation
+    cog_flag:
+    # type=bool|default=False: Use the masks centre of mass to initialise the transformation
+    v_val:
+    # type=range|default=0: Percent of blocks that are active
+    i_val:
+    # type=range|default=0: Percent of inlier blocks
+    ref_low_val:
+    # type=float|default=0.0: Lower threshold value on reference image
+    ref_up_val:
+    # type=float|default=0.0: Upper threshold value on reference image
+    flo_low_val:
+    # type=float|default=0.0: Lower threshold value on floating image
+    flo_up_val:
+    # type=float|default=0.0: Upper threshold value on floating image
+    platform_val:
+    # type=int|default=0: Platform index
+    gpuid_val:
+    # type=int|default=0: Device to use id
+    verbosity_off_flag:
+    # type=bool|default=False: Turn off verbose output
+    aff_file:
+    # type=file: The output affine file
+    # type=file|default=<undefined>: The output affine matrix file
+    res_file:
+    # type=file: The output transformed image
+    # type=file|default=<undefined>: The affine transformed floating image
+    omp_core_val:
+    # type=int|default=1: Number of openmp thread to use
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    ref_file:
+    # type=file|default=<undefined>: The input reference/target image
+    flo_file:
+    # type=file|default=<undefined>: The input floating/source image
+    rmask_file:
+    # type=file|default=<undefined>: The input reference mask
+    omp_core_val: '4'
+    # type=int|default=1: Number of openmp thread to use
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: reg_aladin -aff im2_aff.txt -flo im2.nii -omp 4 -ref im1.nii -res im2_res.nii.gz -rmask mask.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    ref_file:
+    # type=file|default=<undefined>: The input reference/target image
+    flo_file:
+    # type=file|default=<undefined>: The input floating/source image
+    rmask_file:
+    # type=file|default=<undefined>: The input reference mask
+    omp_core_val: '4'
+    # type=int|default=1: Number of openmp thread to use
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-niftyreg/reg_aladin_callables.py b/example-specs/task/nipype_internal/pydra-niftyreg/reg_aladin_callables.py
new file mode 100644
index 00000000..e482a6d4
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-niftyreg/reg_aladin_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in RegAladin.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-niftyreg/reg_average.yaml b/example-specs/task/nipype_internal/pydra-niftyreg/reg_average.yaml
new file mode 100644
index 00000000..59dca0d3
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-niftyreg/reg_average.yaml
@@ -0,0 +1,161 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.niftyreg.regutils.RegAverage' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Interface for executable reg_average from NiftyReg platform.
+# 
+#     Compute average matrix or image from a list of matrices or image.
+#     The tool can be use to resample images given input transformation
+#     parametrisation as well as to demean transformations in Euclidean or
+#     log-Euclidean space.
+# 
+#     This interface is different than the others in the way that the options
+#     will be written in a command file that is given as a parameter.
+# 
+#     `Source code <https://cmiclab.cs.ucl.ac.uk/mmodat/niftyreg>`_
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces import niftyreg
+#     >>> node = niftyreg.RegAverage()
+#     >>> one_file = 'im1.nii'
+#     >>> two_file = 'im2.nii'
+#     >>> three_file = 'im3.nii'
+#     >>> node.inputs.avg_files = [one_file, two_file, three_file]
+#     >>> node.cmdline  # doctest: +ELLIPSIS
+#     'reg_average --cmd_file .../reg_average_cmd'
+#     
+task_name: RegAverage
+nipype_name: RegAverage
+nipype_module: nipype.interfaces.niftyreg.regutils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    avg_files: generic/file+list-of
+    # type=list|default=[]: Averaging of images/affine transformations
+    avg_lts_files: generic/file+list-of
+    # type=list|default=[]: Robust average of affine transformations
+    avg_ref_file: generic/file
+    # type=file|default=<undefined>: All input images are resampled into the space of <reference image> and averaged. A cubic spline interpolation scheme is used for resampling
+    demean1_ref_file: generic/file
+    # type=file|default=<undefined>: Average images and demean average image that have affine transformations to a common space
+    demean2_ref_file: generic/file
+    # type=file|default=<undefined>: Average images and demean average image that have non-rigid transformations to a common space
+    demean3_ref_file: generic/file
+    # type=file|default=<undefined>: Average images and demean average image that have linear and non-rigid transformations to a common space
+    warp_files: generic/file+list-of
+    # type=list|default=[]: transformation files and floating image pairs/triplets to the reference space
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: Output file name
+    # type=file|default=<undefined>: Output file name
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: out_file
+    # type=file: Output file name
+    # type=file|default=<undefined>: Output file name
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    avg_files:
+    # type=list|default=[]: Averaging of images/affine transformations
+    avg_lts_files:
+    # type=list|default=[]: Robust average of affine transformations
+    avg_ref_file:
+    # type=file|default=<undefined>: All input images are resampled into the space of <reference image> and averaged. A cubic spline interpolation scheme is used for resampling
+    demean1_ref_file:
+    # type=file|default=<undefined>: Average images and demean average image that have affine transformations to a common space
+    demean2_ref_file:
+    # type=file|default=<undefined>: Average images and demean average image that have non-rigid transformations to a common space
+    demean3_ref_file:
+    # type=file|default=<undefined>: Average images and demean average image that have linear and non-rigid transformations to a common space
+    warp_files:
+    # type=list|default=[]: transformation files and floating image pairs/triplets to the reference space
+    out_file:
+    # type=file: Output file name
+    # type=file|default=<undefined>: Output file name
+    omp_core_val:
+    # type=int|default=1: Number of openmp thread to use
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    avg_files:
+    # type=list|default=[]: Averaging of images/affine transformations
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: reg_average --cmd_file .../reg_average_cmd
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    avg_files:
+    # type=list|default=[]: Averaging of images/affine transformations
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-niftyreg/reg_average_callables.py b/example-specs/task/nipype_internal/pydra-niftyreg/reg_average_callables.py
new file mode 100644
index 00000000..c1a8b396
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-niftyreg/reg_average_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in RegAverage.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-niftyreg/reg_f3d.yaml b/example-specs/task/nipype_internal/pydra-niftyreg/reg_f3d.yaml
new file mode 100644
index 00000000..d78f7817
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-niftyreg/reg_f3d.yaml
@@ -0,0 +1,262 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.niftyreg.reg.RegF3D' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Interface for executable reg_f3d from NiftyReg platform.
+# 
+#     Fast Free-Form Deformation (F3D) algorithm for non-rigid registration.
+#     Initially based on Modat et al., "Fast Free-Form Deformation using
+#     graphics processing units", CMPB, 2010
+# 
+#     `Source code <https://cmiclab.cs.ucl.ac.uk/mmodat/niftyreg>`_
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import niftyreg
+#     >>> node = niftyreg.RegF3D()
+#     >>> node.inputs.ref_file = 'im1.nii'
+#     >>> node.inputs.flo_file = 'im2.nii'
+#     >>> node.inputs.rmask_file = 'mask.nii'
+#     >>> node.inputs.omp_core_val = 4
+#     >>> node.cmdline
+#     'reg_f3d -cpp im2_cpp.nii.gz -flo im2.nii -omp 4 -ref im1.nii -res im2_res.nii.gz -rmask mask.nii'
+# 
+#     
+task_name: RegF3D
+nipype_name: RegF3D
+nipype_module: nipype.interfaces.niftyreg.reg
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    ref_file: medimage/nifti1
+    # type=file|default=<undefined>: The input reference/target image
+    flo_file: medimage/nifti1
+    # type=file|default=<undefined>: The input floating/source image
+    aff_file: generic/file
+    # type=file|default=<undefined>: The input affine transformation file
+    incpp_file: generic/file
+    # type=file|default=<undefined>: The input cpp transformation file
+    rmask_file: medimage/nifti1
+    # type=file|default=<undefined>: Reference image mask
+    fmask_file: generic/file
+    # type=file|default=<undefined>: Floating image mask
+    cpp_file: generic/file
+    # type=file: The output CPP file
+    # type=file|default=<undefined>: The output CPP file
+    res_file: generic/file
+    # type=file: The output resampled image
+    # type=file|default=<undefined>: The output resampled image
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    cpp_file: generic/file
+    # type=file: The output CPP file
+    # type=file|default=<undefined>: The output CPP file
+    res_file: generic/file
+    # type=file: The output resampled image
+    # type=file|default=<undefined>: The output resampled image
+    invcpp_file: generic/file
+    # type=file: The output inverse CPP file
+    invres_file: generic/file
+    # type=file: The output inverse res file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    ref_file:
+    # type=file|default=<undefined>: The input reference/target image
+    flo_file:
+    # type=file|default=<undefined>: The input floating/source image
+    aff_file:
+    # type=file|default=<undefined>: The input affine transformation file
+    incpp_file:
+    # type=file|default=<undefined>: The input cpp transformation file
+    rmask_file:
+    # type=file|default=<undefined>: Reference image mask
+    ref_smooth_val:
+    # type=float|default=0.0: Smoothing kernel width for reference image
+    flo_smooth_val:
+    # type=float|default=0.0: Smoothing kernel width for floating image
+    rlwth_thr_val:
+    # type=float|default=0.0: Lower threshold for reference image
+    rupth_thr_val:
+    # type=float|default=0.0: Upper threshold for reference image
+    flwth_thr_val:
+    # type=float|default=0.0: Lower threshold for floating image
+    fupth_thr_val:
+    # type=float|default=0.0: Upper threshold for floating image
+    rlwth2_thr_val:
+    # type=tuple|default=(0, 0.0): Lower threshold for reference image at the specified time point
+    rupth2_thr_val:
+    # type=tuple|default=(0, 0.0): Upper threshold for reference image at the specified time point
+    flwth2_thr_val:
+    # type=tuple|default=(0, 0.0): Lower threshold for floating image at the specified time point
+    fupth2_thr_val:
+    # type=tuple|default=(0, 0.0): Upper threshold for floating image at the specified time point
+    sx_val:
+    # type=float|default=0.0: Final grid spacing along the x axes
+    sy_val:
+    # type=float|default=0.0: Final grid spacing along the y axes
+    sz_val:
+    # type=float|default=0.0: Final grid spacing along the z axes
+    be_val:
+    # type=float|default=0.0: Bending energy value
+    le_val:
+    # type=float|default=0.0: Linear elasticity penalty term
+    jl_val:
+    # type=float|default=0.0: Log of jacobian of deformation penalty value
+    no_app_jl_flag:
+    # type=bool|default=False: Do not approximate the log of jacobian penalty at control points only
+    nmi_flag:
+    # type=bool|default=False: use NMI even when other options are specified
+    rbn_val:
+    # type=range|default=0: Number of bins in the histogram for reference image
+    fbn_val:
+    # type=range|default=0: Number of bins in the histogram for reference image
+    rbn2_val:
+    # type=tuple|default=(0, 0): Number of bins in the histogram for reference image for given time point
+    fbn2_val:
+    # type=tuple|default=(0, 0): Number of bins in the histogram for reference image for given time point
+    lncc_val:
+    # type=float|default=0.0: SD of the Gaussian for computing LNCC
+    lncc2_val:
+    # type=tuple|default=(0, 0.0): SD of the Gaussian for computing LNCC for a given time point
+    ssd_flag:
+    # type=bool|default=False: Use SSD as the similarity measure
+    ssd2_flag:
+    # type=range|default=0: Use SSD as the similarity measure for a given time point
+    kld_flag:
+    # type=bool|default=False: Use KL divergence as the similarity measure
+    kld2_flag:
+    # type=range|default=0: Use KL divergence as the similarity measure for a given time point
+    amc_flag:
+    # type=bool|default=False: Use additive NMI
+    nox_flag:
+    # type=bool|default=False: Don't optimise in x direction
+    noy_flag:
+    # type=bool|default=False: Don't optimise in y direction
+    noz_flag:
+    # type=bool|default=False: Don't optimise in z direction
+    maxit_val:
+    # type=range|default=0: Maximum number of iterations per level
+    ln_val:
+    # type=range|default=0: Number of resolution levels to create
+    lp_val:
+    # type=range|default=0: Number of resolution levels to perform
+    nopy_flag:
+    # type=bool|default=False: Do not use the multiresolution approach
+    noconj_flag:
+    # type=bool|default=False: Use simple GD optimization
+    pert_val:
+    # type=range|default=0: Add perturbation steps after each optimization step
+    vel_flag:
+    # type=bool|default=False: Use velocity field integration
+    fmask_file:
+    # type=file|default=<undefined>: Floating image mask
+    smooth_grad_val:
+    # type=float|default=0.0: Kernel width for smoothing the metric gradient
+    pad_val:
+    # type=float|default=0.0: Padding value
+    verbosity_off_flag:
+    # type=bool|default=False: Turn off verbose output
+    cpp_file:
+    # type=file: The output CPP file
+    # type=file|default=<undefined>: The output CPP file
+    res_file:
+    # type=file: The output resampled image
+    # type=file|default=<undefined>: The output resampled image
+    omp_core_val:
+    # type=int|default=1: Number of openmp thread to use
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    ref_file:
+    # type=file|default=<undefined>: The input reference/target image
+    flo_file:
+    # type=file|default=<undefined>: The input floating/source image
+    rmask_file:
+    # type=file|default=<undefined>: Reference image mask
+    omp_core_val: '4'
+    # type=int|default=1: Number of openmp thread to use
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: reg_f3d -cpp im2_cpp.nii.gz -flo im2.nii -omp 4 -ref im1.nii -res im2_res.nii.gz -rmask mask.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    ref_file:
+    # type=file|default=<undefined>: The input reference/target image
+    flo_file:
+    # type=file|default=<undefined>: The input floating/source image
+    rmask_file:
+    # type=file|default=<undefined>: Reference image mask
+    omp_core_val: '4'
+    # type=int|default=1: Number of openmp thread to use
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-niftyreg/reg_f3d_callables.py b/example-specs/task/nipype_internal/pydra-niftyreg/reg_f3d_callables.py
new file mode 100644
index 00000000..b176f3c6
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-niftyreg/reg_f3d_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in RegF3D.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-niftyreg/reg_jacobian.yaml b/example-specs/task/nipype_internal/pydra-niftyreg/reg_jacobian.yaml
new file mode 100644
index 00000000..68012a34
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-niftyreg/reg_jacobian.yaml
@@ -0,0 +1,145 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.niftyreg.regutils.RegJacobian' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Interface for executable reg_resample from NiftyReg platform.
+# 
+#     Tool to generate Jacobian determinant maps from transformation
+#     parametrisation generated by reg_f3d
+# 
+#     `Source code <https://cmiclab.cs.ucl.ac.uk/mmodat/niftyreg>`_
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import niftyreg
+#     >>> node = niftyreg.RegJacobian()
+#     >>> node.inputs.ref_file = 'im1.nii'
+#     >>> node.inputs.trans_file = 'warpfield.nii'
+#     >>> node.inputs.omp_core_val = 4
+#     >>> node.cmdline
+#     'reg_jacobian -omp 4 -ref im1.nii -trans warpfield.nii -jac warpfield_jac.nii.gz'
+# 
+#     
+task_name: RegJacobian
+nipype_name: RegJacobian
+nipype_module: nipype.interfaces.niftyreg.regutils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    ref_file: medimage/nifti1
+    # type=file|default=<undefined>: Reference/target file (required if specifying CPP transformations.
+    trans_file: medimage/nifti1
+    # type=file|default=<undefined>: The input non-rigid transformation
+    out_file: generic/file
+    # type=file: The output file
+    # type=file|default=<undefined>: The output jacobian determinant file name
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: The output file
+    # type=file|default=<undefined>: The output jacobian determinant file name
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    ref_file:
+    # type=file|default=<undefined>: Reference/target file (required if specifying CPP transformations.
+    trans_file:
+    # type=file|default=<undefined>: The input non-rigid transformation
+    type:
+    # type=enum|default='jac'|allowed['jac','jacL','jacM']: Type of jacobian outcome
+    out_file:
+    # type=file: The output file
+    # type=file|default=<undefined>: The output jacobian determinant file name
+    omp_core_val:
+    # type=int|default=1: Number of openmp thread to use
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    ref_file:
+    # type=file|default=<undefined>: Reference/target file (required if specifying CPP transformations.
+    trans_file:
+    # type=file|default=<undefined>: The input non-rigid transformation
+    omp_core_val: '4'
+    # type=int|default=1: Number of openmp thread to use
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: reg_jacobian -omp 4 -ref im1.nii -trans warpfield.nii -jac warpfield_jac.nii.gz
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    ref_file:
+    # type=file|default=<undefined>: Reference/target file (required if specifying CPP transformations.
+    trans_file:
+    # type=file|default=<undefined>: The input non-rigid transformation
+    omp_core_val: '4'
+    # type=int|default=1: Number of openmp thread to use
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-niftyreg/reg_jacobian_callables.py b/example-specs/task/nipype_internal/pydra-niftyreg/reg_jacobian_callables.py
new file mode 100644
index 00000000..a8426361
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-niftyreg/reg_jacobian_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in RegJacobian.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-niftyreg/reg_measure.yaml b/example-specs/task/nipype_internal/pydra-niftyreg/reg_measure.yaml
new file mode 100644
index 00000000..b2f3bae5
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-niftyreg/reg_measure.yaml
@@ -0,0 +1,149 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.niftyreg.regutils.RegMeasure' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Interface for executable reg_measure from NiftyReg platform.
+# 
+#     Given two input images, compute the specified measure(s) of similarity
+# 
+#     `Source code <https://cmiclab.cs.ucl.ac.uk/mmodat/niftyreg>`_
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import niftyreg
+#     >>> node = niftyreg.RegMeasure()
+#     >>> node.inputs.ref_file = 'im1.nii'
+#     >>> node.inputs.flo_file = 'im2.nii'
+#     >>> node.inputs.measure_type = 'lncc'
+#     >>> node.inputs.omp_core_val = 4
+#     >>> node.cmdline
+#     'reg_measure -flo im2.nii -lncc -omp 4 -out im2_lncc.txt -ref im1.nii'
+# 
+#     
+task_name: RegMeasure
+nipype_name: RegMeasure
+nipype_module: nipype.interfaces.niftyreg.regutils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    ref_file: medimage/nifti1
+    # type=file|default=<undefined>: The input reference/target image
+    flo_file: medimage/nifti1
+    # type=file|default=<undefined>: The input floating/source image
+    out_file: generic/file
+    # type=file: The output text file containing the measure
+    # type=file|default=<undefined>: The output text file containing the measure
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: The output text file containing the measure
+    # type=file|default=<undefined>: The output text file containing the measure
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    ref_file:
+    # type=file|default=<undefined>: The input reference/target image
+    flo_file:
+    # type=file|default=<undefined>: The input floating/source image
+    measure_type:
+    # type=enum|default='ncc'|allowed['lncc','ncc','nmi','ssd']: Measure of similarity to compute
+    out_file:
+    # type=file: The output text file containing the measure
+    # type=file|default=<undefined>: The output text file containing the measure
+    omp_core_val:
+    # type=int|default=1: Number of openmp thread to use
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    ref_file:
+    # type=file|default=<undefined>: The input reference/target image
+    flo_file:
+    # type=file|default=<undefined>: The input floating/source image
+    measure_type: '"lncc"'
+    # type=enum|default='ncc'|allowed['lncc','ncc','nmi','ssd']: Measure of similarity to compute
+    omp_core_val: '4'
+    # type=int|default=1: Number of openmp thread to use
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: reg_measure -flo im2.nii -lncc -omp 4 -out im2_lncc.txt -ref im1.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    ref_file:
+    # type=file|default=<undefined>: The input reference/target image
+    flo_file:
+    # type=file|default=<undefined>: The input floating/source image
+    measure_type: '"lncc"'
+    # type=enum|default='ncc'|allowed['lncc','ncc','nmi','ssd']: Measure of similarity to compute
+    omp_core_val: '4'
+    # type=int|default=1: Number of openmp thread to use
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-niftyreg/reg_measure_callables.py b/example-specs/task/nipype_internal/pydra-niftyreg/reg_measure_callables.py
new file mode 100644
index 00000000..c352e88c
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-niftyreg/reg_measure_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in RegMeasure.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-niftyreg/reg_resample.yaml b/example-specs/task/nipype_internal/pydra-niftyreg/reg_resample.yaml
new file mode 100644
index 00000000..31ade135
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-niftyreg/reg_resample.yaml
@@ -0,0 +1,172 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.niftyreg.regutils.RegResample' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Interface for executable reg_resample from NiftyReg platform.
+# 
+#     Tool to resample floating image in the space of a defined reference image
+#     given a transformation parametrisation generated by reg_aladin, reg_f3d or
+#     reg_transform
+# 
+#     `Source code <https://cmiclab.cs.ucl.ac.uk/mmodat/niftyreg>`_
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import niftyreg
+#     >>> node = niftyreg.RegResample()
+#     >>> node.inputs.ref_file = 'im1.nii'
+#     >>> node.inputs.flo_file = 'im2.nii'
+#     >>> node.inputs.trans_file = 'warpfield.nii'
+#     >>> node.inputs.inter_val = 'LIN'
+#     >>> node.inputs.omp_core_val = 4
+#     >>> node.cmdline
+#     'reg_resample -flo im2.nii -inter 1 -omp 4 -ref im1.nii -trans warpfield.nii -res im2_res.nii.gz'
+# 
+#     
+task_name: RegResample
+nipype_name: RegResample
+nipype_module: nipype.interfaces.niftyreg.regutils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    ref_file: medimage/nifti1
+    # type=file|default=<undefined>: The input reference/target image
+    flo_file: medimage/nifti1
+    # type=file|default=<undefined>: The input floating/source image
+    trans_file: medimage/nifti1
+    # type=file|default=<undefined>: The input transformation file
+    out_file: generic/file
+    # type=file: The output filename of the transformed image
+    # type=file|default=<undefined>: The output filename of the transformed image
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: The output filename of the transformed image
+    # type=file|default=<undefined>: The output filename of the transformed image
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    ref_file:
+    # type=file|default=<undefined>: The input reference/target image
+    flo_file:
+    # type=file|default=<undefined>: The input floating/source image
+    trans_file:
+    # type=file|default=<undefined>: The input transformation file
+    type:
+    # type=enum|default='res'|allowed['blank','res']: Type of output
+    out_file:
+    # type=file: The output filename of the transformed image
+    # type=file|default=<undefined>: The output filename of the transformed image
+    inter_val:
+    # type=enum|default='NN'|allowed['CUB','LIN','NN','SINC']: Interpolation type
+    pad_val:
+    # type=float|default=0.0: Padding value
+    tensor_flag:
+    # type=bool|default=False: Resample Tensor Map
+    verbosity_off_flag:
+    # type=bool|default=False: Turn off verbose output
+    psf_flag:
+    # type=bool|default=False: Perform the resampling in two steps to resample an image to a lower resolution
+    psf_alg:
+    # type=enum|default=0|allowed[0,1]: Minimise the matrix metric (0) or the determinant (1) when estimating the PSF [0]
+    omp_core_val:
+    # type=int|default=1: Number of openmp thread to use
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    ref_file:
+    # type=file|default=<undefined>: The input reference/target image
+    flo_file:
+    # type=file|default=<undefined>: The input floating/source image
+    trans_file:
+    # type=file|default=<undefined>: The input transformation file
+    inter_val: '"LIN"'
+    # type=enum|default='NN'|allowed['CUB','LIN','NN','SINC']: Interpolation type
+    omp_core_val: '4'
+    # type=int|default=1: Number of openmp thread to use
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: reg_resample -flo im2.nii -inter 1 -omp 4 -ref im1.nii -trans warpfield.nii -res im2_res.nii.gz
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    ref_file:
+    # type=file|default=<undefined>: The input reference/target image
+    flo_file:
+    # type=file|default=<undefined>: The input floating/source image
+    trans_file:
+    # type=file|default=<undefined>: The input transformation file
+    inter_val: '"LIN"'
+    # type=enum|default='NN'|allowed['CUB','LIN','NN','SINC']: Interpolation type
+    omp_core_val: '4'
+    # type=int|default=1: Number of openmp thread to use
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-niftyreg/reg_resample_callables.py b/example-specs/task/nipype_internal/pydra-niftyreg/reg_resample_callables.py
new file mode 100644
index 00000000..0ed41722
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-niftyreg/reg_resample_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in RegResample.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-niftyreg/reg_tools.yaml b/example-specs/task/nipype_internal/pydra-niftyreg/reg_tools.yaml
new file mode 100644
index 00000000..6cdafe68
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-niftyreg/reg_tools.yaml
@@ -0,0 +1,174 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.niftyreg.regutils.RegTools' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Interface for executable reg_tools from NiftyReg platform.
+# 
+#     Tool delivering various actions related to registration such as
+#     resampling the input image to a chosen resolution or remove the nan and
+#     inf in the input image by a specified value.
+# 
+#     `Source code <https://cmiclab.cs.ucl.ac.uk/mmodat/niftyreg>`_
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import niftyreg
+#     >>> node = niftyreg.RegTools()
+#     >>> node.inputs.in_file = 'im1.nii'
+#     >>> node.inputs.mul_val = 4
+#     >>> node.inputs.omp_core_val = 4
+#     >>> node.cmdline
+#     'reg_tools -in im1.nii -mul 4.0 -omp 4 -out im1_tools.nii.gz'
+# 
+#     
+task_name: RegTools
+nipype_name: RegTools
+nipype_module: nipype.interfaces.niftyreg.regutils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: The input image file path
+    out_file: generic/file
+    # type=file: The output file
+    # type=file|default=<undefined>: The output file name
+    mask_file: generic/file
+    # type=file|default=<undefined>: Values outside the mask are set to NaN
+    rms_val: generic/file
+    # type=file|default=<undefined>: Compute the mean RMS between the images
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: The output file
+    # type=file|default=<undefined>: The output file name
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: The input image file path
+    out_file:
+    # type=file: The output file
+    # type=file|default=<undefined>: The output file name
+    iso_flag:
+    # type=bool|default=False: Make output image isotropic
+    noscl_flag:
+    # type=bool|default=False: Set scale, slope to 0 and 1
+    mask_file:
+    # type=file|default=<undefined>: Values outside the mask are set to NaN
+    thr_val:
+    # type=float|default=0.0: Binarise the input image with the given threshold
+    bin_flag:
+    # type=bool|default=False: Binarise the input image
+    rms_val:
+    # type=file|default=<undefined>: Compute the mean RMS between the images
+    div_val:
+    # type=traitcompound|default=None: Divide the input by image or value
+    mul_val:
+    # type=traitcompound|default=None: Multiply the input by image or value
+    add_val:
+    # type=traitcompound|default=None: Add to the input image or value
+    sub_val:
+    # type=traitcompound|default=None: Add to the input image or value
+    down_flag:
+    # type=bool|default=False: Downsample the image by a factor of 2
+    smo_s_val:
+    # type=tuple|default=(0.0, 0.0, 0.0): Smooth the input image using a cubic spline kernel
+    chg_res_val:
+    # type=tuple|default=(0.0, 0.0, 0.0): Change the resolution of the input image
+    smo_g_val:
+    # type=tuple|default=(0.0, 0.0, 0.0): Smooth the input image using a Gaussian kernel
+    inter_val:
+    # type=enum|default='NN'|allowed['CUB','LIN','NN','SINC']: Interpolation order to use to warp the floating image
+    omp_core_val:
+    # type=int|default=1: Number of openmp thread to use
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: The input image file path
+    mul_val: '4'
+    # type=traitcompound|default=None: Multiply the input by image or value
+    omp_core_val: '4'
+    # type=int|default=1: Number of openmp thread to use
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: reg_tools -in im1.nii -mul 4.0 -omp 4 -out im1_tools.nii.gz
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: The input image file path
+    mul_val: '4'
+    # type=traitcompound|default=None: Multiply the input by image or value
+    omp_core_val: '4'
+    # type=int|default=1: Number of openmp thread to use
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-niftyreg/reg_tools_callables.py b/example-specs/task/nipype_internal/pydra-niftyreg/reg_tools_callables.py
new file mode 100644
index 00000000..ff12b1cf
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-niftyreg/reg_tools_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in RegTools.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-niftyreg/reg_transform.yaml b/example-specs/task/nipype_internal/pydra-niftyreg/reg_transform.yaml
new file mode 100644
index 00000000..619d24ad
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-niftyreg/reg_transform.yaml
@@ -0,0 +1,184 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.niftyreg.regutils.RegTransform' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Interface for executable reg_transform from NiftyReg platform.
+# 
+#     Tools to convert transformation parametrisation from one type to another
+#     as well as to compose, inverse or half transformations.
+# 
+#     `Source code <https://cmiclab.cs.ucl.ac.uk/mmodat/niftyreg>`_
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import niftyreg
+#     >>> node = niftyreg.RegTransform()
+#     >>> node.inputs.def_input = 'warpfield.nii'
+#     >>> node.inputs.omp_core_val = 4
+#     >>> node.cmdline  # doctest: +ELLIPSIS
+#     'reg_transform -omp 4 -def warpfield.nii .../warpfield_trans.nii.gz'
+# 
+#     
+task_name: RegTransform
+nipype_name: RegTransform
+nipype_module: nipype.interfaces.niftyreg.regutils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    ref1_file: generic/file
+    # type=file|default=<undefined>: The input reference/target image
+    ref2_file: generic/file
+    # type=file|default=<undefined>: The input second reference/target image
+    def_input: medimage/nifti1
+    # type=file|default=<undefined>: Compute deformation field from transformation
+    disp_input: generic/file
+    # type=file|default=<undefined>: Compute displacement field from transformation
+    flow_input: generic/file
+    # type=file|default=<undefined>: Compute flow field from spline SVF
+    comp_input: generic/file
+    # type=file|default=<undefined>: compose two transformations
+    comp_input2: generic/file
+    # type=file|default=<undefined>: compose two transformations
+    upd_s_form_input: generic/file
+    # type=file|default=<undefined>: Update s-form using the affine transformation
+    upd_s_form_input2: generic/file
+    # type=file|default=<undefined>: Update s-form using the affine transformation
+    inv_aff_input: generic/file
+    # type=file|default=<undefined>: Invert an affine transformation
+    half_input: generic/file
+    # type=file|default=<undefined>: Half way to the input transformation
+    aff_2_rig_input: generic/file
+    # type=file|default=<undefined>: Extract the rigid component from affine transformation
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: Output File (transformation in any format)
+    # type=file|default=<undefined>: transformation file to write
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: out_file
+    # type=file: Output File (transformation in any format)
+    # type=file|default=<undefined>: transformation file to write
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    ref1_file:
+    # type=file|default=<undefined>: The input reference/target image
+    ref2_file:
+    # type=file|default=<undefined>: The input second reference/target image
+    def_input:
+    # type=file|default=<undefined>: Compute deformation field from transformation
+    disp_input:
+    # type=file|default=<undefined>: Compute displacement field from transformation
+    flow_input:
+    # type=file|default=<undefined>: Compute flow field from spline SVF
+    comp_input:
+    # type=file|default=<undefined>: compose two transformations
+    comp_input2:
+    # type=file|default=<undefined>: compose two transformations
+    upd_s_form_input:
+    # type=file|default=<undefined>: Update s-form using the affine transformation
+    upd_s_form_input2:
+    # type=file|default=<undefined>: Update s-form using the affine transformation
+    inv_aff_input:
+    # type=file|default=<undefined>: Invert an affine transformation
+    inv_nrr_input:
+    # type=tuple|default=(<undefined>, <undefined>): Invert a non-linear transformation
+    half_input:
+    # type=file|default=<undefined>: Half way to the input transformation
+    make_aff_input:
+    # type=tuple|default=(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0): Make an affine transformation matrix
+    aff_2_rig_input:
+    # type=file|default=<undefined>: Extract the rigid component from affine transformation
+    flirt_2_nr_input:
+    # type=tuple|default=(<undefined>, <undefined>, <undefined>): Convert a FLIRT affine transformation to niftyreg affine transformation
+    out_file:
+    # type=file: Output File (transformation in any format)
+    # type=file|default=<undefined>: transformation file to write
+    omp_core_val:
+    # type=int|default=1: Number of openmp thread to use
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    def_input:
+    # type=file|default=<undefined>: Compute deformation field from transformation
+    omp_core_val: '4'
+    # type=int|default=1: Number of openmp thread to use
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: reg_transform -omp 4 -def warpfield.nii .../warpfield_trans.nii.gz
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    def_input:
+    # type=file|default=<undefined>: Compute deformation field from transformation
+    omp_core_val: '4'
+    # type=int|default=1: Number of openmp thread to use
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-niftyreg/reg_transform_callables.py b/example-specs/task/nipype_internal/pydra-niftyreg/reg_transform_callables.py
new file mode 100644
index 00000000..42c8ed3a
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-niftyreg/reg_transform_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in RegTransform.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-niftyseg/binary_maths.yaml b/example-specs/task/nipype_internal/pydra-niftyseg/binary_maths.yaml
new file mode 100644
index 00000000..a34abc4b
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-niftyseg/binary_maths.yaml
@@ -0,0 +1,295 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.niftyseg.maths.BinaryMaths' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Binary mathematical operations.
+# 
+#     See Also
+#     --------
+#     `Source code <http://cmictig.cs.ucl.ac.uk/wiki/index.php/NiftySeg>`__ --
+#     `Documentation <http://cmictig.cs.ucl.ac.uk/wiki/index.php/NiftySeg_documentation>`__
+# 
+#     Examples
+#     --------
+#     >>> import copy
+#     >>> from nipype.interfaces import niftyseg
+#     >>> binary = niftyseg.BinaryMaths()
+#     >>> binary.inputs.in_file = 'im1.nii'
+#     >>> binary.inputs.output_datatype = 'float'
+# 
+#     >>> # Test sub operation
+#     >>> binary_sub = copy.deepcopy(binary)
+#     >>> binary_sub.inputs.operation = 'sub'
+#     >>> binary_sub.inputs.operand_file = 'im2.nii'
+#     >>> binary_sub.cmdline
+#     'seg_maths im1.nii -sub im2.nii -odt float im1_sub.nii'
+#     >>> binary_sub.run()  # doctest: +SKIP
+# 
+#     >>> # Test mul operation
+#     >>> binary_mul = copy.deepcopy(binary)
+#     >>> binary_mul.inputs.operation = 'mul'
+#     >>> binary_mul.inputs.operand_value = 2.0
+#     >>> binary_mul.cmdline
+#     'seg_maths im1.nii -mul 2.00000000 -odt float im1_mul.nii'
+#     >>> binary_mul.run()  # doctest: +SKIP
+# 
+#     >>> # Test llsnorm operation
+#     >>> binary_llsnorm = copy.deepcopy(binary)
+#     >>> binary_llsnorm.inputs.operation = 'llsnorm'
+#     >>> binary_llsnorm.inputs.operand_file = 'im2.nii'
+#     >>> binary_llsnorm.cmdline
+#     'seg_maths im1.nii -llsnorm im2.nii -odt float im1_llsnorm.nii'
+#     >>> binary_llsnorm.run()  # doctest: +SKIP
+# 
+#     >>> # Test splitinter operation
+#     >>> binary_splitinter = copy.deepcopy(binary)
+#     >>> binary_splitinter.inputs.operation = 'splitinter'
+#     >>> binary_splitinter.inputs.operand_str = 'z'
+#     >>> binary_splitinter.cmdline
+#     'seg_maths im1.nii -splitinter z -odt float im1_splitinter.nii'
+#     >>> binary_splitinter.run()  # doctest: +SKIP
+# 
+#     
+task_name: BinaryMaths
+nipype_name: BinaryMaths
+nipype_module: nipype.interfaces.niftyseg.maths
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    operand_file: medimage/nifti1
+    # type=file|default=<undefined>: second image to perform operation with
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: image to operate on
+    out_file: generic/file
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    operation:
+    # type=enum|default='mul'|allowed['add','div','edge','geo','hdr_copy','llsnorm','masknan','min','mul','pow','smo','smol','sobel3','sobel5','splitinter','sub','thr','uthr']: Operation to perform:      * mul - <float/file> - Multiply image <float> value or by other image.     * div - <float/file> - Divide image by <float> or by other image.     * add - <float/file> - Add image by <float> or by other image.     * sub - <float/file> - Subtract image by <float> or by other image.     * pow - <float> - Image to the power of <float>.     * thr - <float> - Threshold the image below <float>.     * uthr - <float> - Threshold image above <float>.     * smo - <float> - Gaussian smoothing by std <float> (in voxels and up to 4-D).     * edge - <float> - Calculate the edges of the image using a threshold <float>.     * sobel3 - <float> - Calculate the edges of all timepoints using a Sobel filter       with a 3x3x3 kernel and applying <float> gaussian smoothing.     * sobel5 - <float> - Calculate the edges of all timepoints using a Sobel filter       with a 5x5x5 kernel and applying <float> gaussian smoothing.     * min - <file> - Get the min per voxel between <current> and <file>.     * smol - <float> - Gaussian smoothing of a 3D label image.     * geo - <float/file> - Geodesic distance according to the speed function <float/file>     * llsnorm  <file_norm> - Linear LS normalisation between current and <file_norm>     * masknan <file_norm> - Assign everything outside the mask (mask==0) with NaNs     * hdr_copy <file> - Copy header from working image to <file> and save in <output>.     * splitinter <x/y/z> - Split interleaved slices in direction <x/y/z>       into separate time points  
+    operand_file:
+    # type=file|default=<undefined>: second image to perform operation with
+    operand_value:
+    # type=float|default=0.0: float value to perform operation with
+    operand_str:
+    # type=enum|default='x'|allowed['x','y','z']: string value to perform operation splitinter
+    in_file:
+    # type=file|default=<undefined>: image to operate on
+    out_file:
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
+    output_datatype:
+    # type=enum|default='float'|allowed['char','double','float','input','int','short']: datatype to use for output (default uses input type)
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: image to operate on
+    output_datatype: '"float"'
+    # type=enum|default='float'|allowed['char','double','float','input','int','short']: datatype to use for output (default uses input type)
+    operation: '"sub"'
+    # type=enum|default='mul'|allowed['add','div','edge','geo','hdr_copy','llsnorm','masknan','min','mul','pow','smo','smol','sobel3','sobel5','splitinter','sub','thr','uthr']: Operation to perform:      * mul - <float/file> - Multiply image <float> value or by other image.     * div - <float/file> - Divide image by <float> or by other image.     * add - <float/file> - Add image by <float> or by other image.     * sub - <float/file> - Subtract image by <float> or by other image.     * pow - <float> - Image to the power of <float>.     * thr - <float> - Threshold the image below <float>.     * uthr - <float> - Threshold image above <float>.     * smo - <float> - Gaussian smoothing by std <float> (in voxels and up to 4-D).     * edge - <float> - Calculate the edges of the image using a threshold <float>.     * sobel3 - <float> - Calculate the edges of all timepoints using a Sobel filter       with a 3x3x3 kernel and applying <float> gaussian smoothing.     * sobel5 - <float> - Calculate the edges of all timepoints using a Sobel filter       with a 5x5x5 kernel and applying <float> gaussian smoothing.     * min - <file> - Get the min per voxel between <current> and <file>.     * smol - <float> - Gaussian smoothing of a 3D label image.     * geo - <float/file> - Geodesic distance according to the speed function <float/file>     * llsnorm  <file_norm> - Linear LS normalisation between current and <file_norm>     * masknan <file_norm> - Assign everything outside the mask (mask==0) with NaNs     * hdr_copy <file> - Copy header from working image to <file> and save in <output>.     * splitinter <x/y/z> - Split interleaved slices in direction <x/y/z>       into separate time points  
+    operand_file:
+    # type=file|default=<undefined>: second image to perform operation with
+  imports: &id001
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  - module: copy
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    operation: '"mul"'
+    # type=enum|default='mul'|allowed['add','div','edge','geo','hdr_copy','llsnorm','masknan','min','mul','pow','smo','smol','sobel3','sobel5','splitinter','sub','thr','uthr']: Operation to perform:      * mul - <float/file> - Multiply image <float> value or by other image.     * div - <float/file> - Divide image by <float> or by other image.     * add - <float/file> - Add image by <float> or by other image.     * sub - <float/file> - Subtract image by <float> or by other image.     * pow - <float> - Image to the power of <float>.     * thr - <float> - Threshold the image below <float>.     * uthr - <float> - Threshold image above <float>.     * smo - <float> - Gaussian smoothing by std <float> (in voxels and up to 4-D).     * edge - <float> - Calculate the edges of the image using a threshold <float>.     * sobel3 - <float> - Calculate the edges of all timepoints using a Sobel filter       with a 3x3x3 kernel and applying <float> gaussian smoothing.     * sobel5 - <float> - Calculate the edges of all timepoints using a Sobel filter       with a 5x5x5 kernel and applying <float> gaussian smoothing.     * min - <file> - Get the min per voxel between <current> and <file>.     * smol - <float> - Gaussian smoothing of a 3D label image.     * geo - <float/file> - Geodesic distance according to the speed function <float/file>     * llsnorm  <file_norm> - Linear LS normalisation between current and <file_norm>     * masknan <file_norm> - Assign everything outside the mask (mask==0) with NaNs     * hdr_copy <file> - Copy header from working image to <file> and save in <output>.     * splitinter <x/y/z> - Split interleaved slices in direction <x/y/z>       into separate time points  
+    operand_value: '2.0'
+    # type=float|default=0.0: float value to perform operation with
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    operation: '"llsnorm"'
+    # type=enum|default='mul'|allowed['add','div','edge','geo','hdr_copy','llsnorm','masknan','min','mul','pow','smo','smol','sobel3','sobel5','splitinter','sub','thr','uthr']: Operation to perform:      * mul - <float/file> - Multiply image <float> value or by other image.     * div - <float/file> - Divide image by <float> or by other image.     * add - <float/file> - Add image by <float> or by other image.     * sub - <float/file> - Subtract image by <float> or by other image.     * pow - <float> - Image to the power of <float>.     * thr - <float> - Threshold the image below <float>.     * uthr - <float> - Threshold image above <float>.     * smo - <float> - Gaussian smoothing by std <float> (in voxels and up to 4-D).     * edge - <float> - Calculate the edges of the image using a threshold <float>.     * sobel3 - <float> - Calculate the edges of all timepoints using a Sobel filter       with a 3x3x3 kernel and applying <float> gaussian smoothing.     * sobel5 - <float> - Calculate the edges of all timepoints using a Sobel filter       with a 5x5x5 kernel and applying <float> gaussian smoothing.     * min - <file> - Get the min per voxel between <current> and <file>.     * smol - <float> - Gaussian smoothing of a 3D label image.     * geo - <float/file> - Geodesic distance according to the speed function <float/file>     * llsnorm  <file_norm> - Linear LS normalisation between current and <file_norm>     * masknan <file_norm> - Assign everything outside the mask (mask==0) with NaNs     * hdr_copy <file> - Copy header from working image to <file> and save in <output>.     * splitinter <x/y/z> - Split interleaved slices in direction <x/y/z>       into separate time points  
+    operand_file:
+    # type=file|default=<undefined>: second image to perform operation with
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    operation: '"splitinter"'
+    # type=enum|default='mul'|allowed['add','div','edge','geo','hdr_copy','llsnorm','masknan','min','mul','pow','smo','smol','sobel3','sobel5','splitinter','sub','thr','uthr']: Operation to perform:      * mul - <float/file> - Multiply image <float> value or by other image.     * div - <float/file> - Divide image by <float> or by other image.     * add - <float/file> - Add image by <float> or by other image.     * sub - <float/file> - Subtract image by <float> or by other image.     * pow - <float> - Image to the power of <float>.     * thr - <float> - Threshold the image below <float>.     * uthr - <float> - Threshold image above <float>.     * smo - <float> - Gaussian smoothing by std <float> (in voxels and up to 4-D).     * edge - <float> - Calculate the edges of the image using a threshold <float>.     * sobel3 - <float> - Calculate the edges of all timepoints using a Sobel filter       with a 3x3x3 kernel and applying <float> gaussian smoothing.     * sobel5 - <float> - Calculate the edges of all timepoints using a Sobel filter       with a 5x5x5 kernel and applying <float> gaussian smoothing.     * min - <file> - Get the min per voxel between <current> and <file>.     * smol - <float> - Gaussian smoothing of a 3D label image.     * geo - <float/file> - Geodesic distance according to the speed function <float/file>     * llsnorm  <file_norm> - Linear LS normalisation between current and <file_norm>     * masknan <file_norm> - Assign everything outside the mask (mask==0) with NaNs     * hdr_copy <file> - Copy header from working image to <file> and save in <output>.     * splitinter <x/y/z> - Split interleaved slices in direction <x/y/z>       into separate time points  
+    operand_str: '"z"'
+    # type=enum|default='x'|allowed['x','y','z']: string value to perform operation splitinter
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: seg_maths im1.nii -sub im2.nii -odt float im1_sub.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: image to operate on
+    output_datatype: '"float"'
+    # type=enum|default='float'|allowed['char','double','float','input','int','short']: datatype to use for output (default uses input type)
+    operation: '"sub"'
+    # type=enum|default='mul'|allowed['add','div','edge','geo','hdr_copy','llsnorm','masknan','min','mul','pow','smo','smol','sobel3','sobel5','splitinter','sub','thr','uthr']: Operation to perform:      * mul - <float/file> - Multiply image <float> value or by other image.     * div - <float/file> - Divide image by <float> or by other image.     * add - <float/file> - Add image by <float> or by other image.     * sub - <float/file> - Subtract image by <float> or by other image.     * pow - <float> - Image to the power of <float>.     * thr - <float> - Threshold the image below <float>.     * uthr - <float> - Threshold image above <float>.     * smo - <float> - Gaussian smoothing by std <float> (in voxels and up to 4-D).     * edge - <float> - Calculate the edges of the image using a threshold <float>.     * sobel3 - <float> - Calculate the edges of all timepoints using a Sobel filter       with a 3x3x3 kernel and applying <float> gaussian smoothing.     * sobel5 - <float> - Calculate the edges of all timepoints using a Sobel filter       with a 5x5x5 kernel and applying <float> gaussian smoothing.     * min - <file> - Get the min per voxel between <current> and <file>.     * smol - <float> - Gaussian smoothing of a 3D label image.     * geo - <float/file> - Geodesic distance according to the speed function <float/file>     * llsnorm  <file_norm> - Linear LS normalisation between current and <file_norm>     * masknan <file_norm> - Assign everything outside the mask (mask==0) with NaNs     * hdr_copy <file> - Copy header from working image to <file> and save in <output>.     * splitinter <x/y/z> - Split interleaved slices in direction <x/y/z>       into separate time points  
+    operand_file:
+    # type=file|default=<undefined>: second image to perform operation with
+  imports: *id001
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: seg_maths im1.nii -mul 2.00000000 -odt float im1_mul.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    operation: '"mul"'
+    # type=enum|default='mul'|allowed['add','div','edge','geo','hdr_copy','llsnorm','masknan','min','mul','pow','smo','smol','sobel3','sobel5','splitinter','sub','thr','uthr']: Operation to perform:      * mul - <float/file> - Multiply image <float> value or by other image.     * div - <float/file> - Divide image by <float> or by other image.     * add - <float/file> - Add image by <float> or by other image.     * sub - <float/file> - Subtract image by <float> or by other image.     * pow - <float> - Image to the power of <float>.     * thr - <float> - Threshold the image below <float>.     * uthr - <float> - Threshold image above <float>.     * smo - <float> - Gaussian smoothing by std <float> (in voxels and up to 4-D).     * edge - <float> - Calculate the edges of the image using a threshold <float>.     * sobel3 - <float> - Calculate the edges of all timepoints using a Sobel filter       with a 3x3x3 kernel and applying <float> gaussian smoothing.     * sobel5 - <float> - Calculate the edges of all timepoints using a Sobel filter       with a 5x5x5 kernel and applying <float> gaussian smoothing.     * min - <file> - Get the min per voxel between <current> and <file>.     * smol - <float> - Gaussian smoothing of a 3D label image.     * geo - <float/file> - Geodesic distance according to the speed function <float/file>     * llsnorm  <file_norm> - Linear LS normalisation between current and <file_norm>     * masknan <file_norm> - Assign everything outside the mask (mask==0) with NaNs     * hdr_copy <file> - Copy header from working image to <file> and save in <output>.     * splitinter <x/y/z> - Split interleaved slices in direction <x/y/z>       into separate time points  
+    operand_value: '2.0'
+    # type=float|default=0.0: float value to perform operation with
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: seg_maths im1.nii -llsnorm im2.nii -odt float im1_llsnorm.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    operation: '"llsnorm"'
+    # type=enum|default='mul'|allowed['add','div','edge','geo','hdr_copy','llsnorm','masknan','min','mul','pow','smo','smol','sobel3','sobel5','splitinter','sub','thr','uthr']: Operation to perform:      * mul - <float/file> - Multiply image <float> value or by other image.     * div - <float/file> - Divide image by <float> or by other image.     * add - <float/file> - Add image by <float> or by other image.     * sub - <float/file> - Subtract image by <float> or by other image.     * pow - <float> - Image to the power of <float>.     * thr - <float> - Threshold the image below <float>.     * uthr - <float> - Threshold image above <float>.     * smo - <float> - Gaussian smoothing by std <float> (in voxels and up to 4-D).     * edge - <float> - Calculate the edges of the image using a threshold <float>.     * sobel3 - <float> - Calculate the edges of all timepoints using a Sobel filter       with a 3x3x3 kernel and applying <float> gaussian smoothing.     * sobel5 - <float> - Calculate the edges of all timepoints using a Sobel filter       with a 5x5x5 kernel and applying <float> gaussian smoothing.     * min - <file> - Get the min per voxel between <current> and <file>.     * smol - <float> - Gaussian smoothing of a 3D label image.     * geo - <float/file> - Geodesic distance according to the speed function <float/file>     * llsnorm  <file_norm> - Linear LS normalisation between current and <file_norm>     * masknan <file_norm> - Assign everything outside the mask (mask==0) with NaNs     * hdr_copy <file> - Copy header from working image to <file> and save in <output>.     * splitinter <x/y/z> - Split interleaved slices in direction <x/y/z>       into separate time points  
+    operand_file:
+    # type=file|default=<undefined>: second image to perform operation with
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: seg_maths im1.nii -splitinter z -odt float im1_splitinter.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    operation: '"splitinter"'
+    # type=enum|default='mul'|allowed['add','div','edge','geo','hdr_copy','llsnorm','masknan','min','mul','pow','smo','smol','sobel3','sobel5','splitinter','sub','thr','uthr']: Operation to perform:      * mul - <float/file> - Multiply image <float> value or by other image.     * div - <float/file> - Divide image by <float> or by other image.     * add - <float/file> - Add image by <float> or by other image.     * sub - <float/file> - Subtract image by <float> or by other image.     * pow - <float> - Image to the power of <float>.     * thr - <float> - Threshold the image below <float>.     * uthr - <float> - Threshold image above <float>.     * smo - <float> - Gaussian smoothing by std <float> (in voxels and up to 4-D).     * edge - <float> - Calculate the edges of the image using a threshold <float>.     * sobel3 - <float> - Calculate the edges of all timepoints using a Sobel filter       with a 3x3x3 kernel and applying <float> gaussian smoothing.     * sobel5 - <float> - Calculate the edges of all timepoints using a Sobel filter       with a 5x5x5 kernel and applying <float> gaussian smoothing.     * min - <file> - Get the min per voxel between <current> and <file>.     * smol - <float> - Gaussian smoothing of a 3D label image.     * geo - <float/file> - Geodesic distance according to the speed function <float/file>     * llsnorm  <file_norm> - Linear LS normalisation between current and <file_norm>     * masknan <file_norm> - Assign everything outside the mask (mask==0) with NaNs     * hdr_copy <file> - Copy header from working image to <file> and save in <output>.     * splitinter <x/y/z> - Split interleaved slices in direction <x/y/z>       into separate time points  
+    operand_str: '"z"'
+    # type=enum|default='x'|allowed['x','y','z']: string value to perform operation splitinter
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-niftyseg/binary_maths_callables.py b/example-specs/task/nipype_internal/pydra-niftyseg/binary_maths_callables.py
new file mode 100644
index 00000000..68e6b721
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-niftyseg/binary_maths_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in BinaryMaths.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-niftyseg/binary_maths_integer.yaml b/example-specs/task/nipype_internal/pydra-niftyseg/binary_maths_integer.yaml
new file mode 100644
index 00000000..25a9c99c
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-niftyseg/binary_maths_integer.yaml
@@ -0,0 +1,167 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.niftyseg.maths.BinaryMathsInteger' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Integer mathematical operations.
+# 
+#     See Also
+#     --------
+#     `Source code <http://cmictig.cs.ucl.ac.uk/wiki/index.php/NiftySeg>`__ --
+#     `Documentation <http://cmictig.cs.ucl.ac.uk/wiki/index.php/NiftySeg_documentation>`__
+# 
+#     Examples
+#     --------
+#     >>> import copy
+#     >>> from nipype.interfaces.niftyseg import BinaryMathsInteger
+#     >>> binaryi = BinaryMathsInteger()
+#     >>> binaryi.inputs.in_file = 'im1.nii'
+#     >>> binaryi.inputs.output_datatype = 'float'
+#     >>> # Test dil operation
+#     >>> binaryi_dil = copy.deepcopy(binaryi)
+#     >>> binaryi_dil.inputs.operation = 'dil'
+#     >>> binaryi_dil.inputs.operand_value = 2
+#     >>> binaryi_dil.cmdline
+#     'seg_maths im1.nii -dil 2 -odt float im1_dil.nii'
+#     >>> binaryi_dil.run()  # doctest: +SKIP
+#     >>> # Test dil operation
+#     >>> binaryi_ero = copy.deepcopy(binaryi)
+#     >>> binaryi_ero.inputs.operation = 'ero'
+#     >>> binaryi_ero.inputs.operand_value = 1
+#     >>> binaryi_ero.cmdline
+#     'seg_maths im1.nii -ero 1 -odt float im1_ero.nii'
+#     >>> binaryi_ero.run()  # doctest: +SKIP
+#     >>> # Test pad operation
+#     >>> binaryi_pad = copy.deepcopy(binaryi)
+#     >>> binaryi_pad.inputs.operation = 'pad'
+#     >>> binaryi_pad.inputs.operand_value = 4
+#     >>> binaryi_pad.cmdline
+#     'seg_maths im1.nii -pad 4 -odt float im1_pad.nii'
+#     >>> binaryi_pad.run()  # doctest: +SKIP
+# 
+#     
+task_name: BinaryMathsInteger
+nipype_name: BinaryMathsInteger
+nipype_module: nipype.interfaces.niftyseg.maths
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: image to operate on
+    out_file: generic/file
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    operation:
+    # type=enum|default='dil'|allowed['crop','dil','equal','ero','pad','tp']: Operation to perform:      * equal - <int> - Get voxels equal to <int>     * dil - <int>  - Dilate the image <int> times (in voxels).     * ero - <int> - Erode the image <int> times (in voxels).     * tp - <int> - Extract time point <int>     * crop - <int> - Crop <int> voxels around each 3D volume.     * pad - <int> -  Pad <int> voxels with NaN value around each 3D volume.  
+    operand_value:
+    # type=int|default=0: int value to perform operation with
+    in_file:
+    # type=file|default=<undefined>: image to operate on
+    out_file:
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
+    output_datatype:
+    # type=enum|default='float'|allowed['char','double','float','input','int','short']: datatype to use for output (default uses input type)
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: image to operate on
+    output_datatype: '"float"'
+    # type=enum|default='float'|allowed['char','double','float','input','int','short']: datatype to use for output (default uses input type)
+    operation: '"pad"'
+    # type=enum|default='dil'|allowed['crop','dil','equal','ero','pad','tp']: Operation to perform:      * equal - <int> - Get voxels equal to <int>     * dil - <int>  - Dilate the image <int> times (in voxels).     * ero - <int> - Erode the image <int> times (in voxels).     * tp - <int> - Extract time point <int>     * crop - <int> - Crop <int> voxels around each 3D volume.     * pad - <int> -  Pad <int> voxels with NaN value around each 3D volume.  
+    operand_value: '4'
+    # type=int|default=0: int value to perform operation with
+  imports: &id001
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  - module: copy
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: seg_maths im1.nii -pad 4 -odt float im1_pad.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: image to operate on
+    output_datatype: '"float"'
+    # type=enum|default='float'|allowed['char','double','float','input','int','short']: datatype to use for output (default uses input type)
+    operation: '"pad"'
+    # type=enum|default='dil'|allowed['crop','dil','equal','ero','pad','tp']: Operation to perform:      * equal - <int> - Get voxels equal to <int>     * dil - <int>  - Dilate the image <int> times (in voxels).     * ero - <int> - Erode the image <int> times (in voxels).     * tp - <int> - Extract time point <int>     * crop - <int> - Crop <int> voxels around each 3D volume.     * pad - <int> -  Pad <int> voxels with NaN value around each 3D volume.  
+    operand_value: '4'
+    # type=int|default=0: int value to perform operation with
+  imports: *id001
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-niftyseg/binary_maths_integer_callables.py b/example-specs/task/nipype_internal/pydra-niftyseg/binary_maths_integer_callables.py
new file mode 100644
index 00000000..d1edb96e
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-niftyseg/binary_maths_integer_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in BinaryMathsInteger.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-niftyseg/binary_stats.yaml b/example-specs/task/nipype_internal/pydra-niftyseg/binary_stats.yaml
new file mode 100644
index 00000000..a91d3683
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-niftyseg/binary_stats.yaml
@@ -0,0 +1,165 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.niftyseg.stats.BinaryStats' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Binary statistical operations.
+# 
+#     See Also
+#     --------
+#     `Source code <http://cmictig.cs.ucl.ac.uk/wiki/index.php/NiftySeg>`__ --
+#     `Documentation <http://cmictig.cs.ucl.ac.uk/wiki/index.php/NiftySeg_documentation>`__
+# 
+#     Examples
+#     --------
+#     >>> import copy
+#     >>> from nipype.interfaces import niftyseg
+#     >>> binary = niftyseg.BinaryStats()
+#     >>> binary.inputs.in_file = 'im1.nii'
+#     >>> # Test sa operation
+#     >>> binary_sa = copy.deepcopy(binary)
+#     >>> binary_sa.inputs.operation = 'sa'
+#     >>> binary_sa.inputs.operand_value = 2.0
+#     >>> binary_sa.cmdline
+#     'seg_stats im1.nii -sa 2.00000000'
+#     >>> binary_sa.run()  # doctest: +SKIP
+#     >>> # Test ncc operation
+#     >>> binary_ncc = copy.deepcopy(binary)
+#     >>> binary_ncc.inputs.operation = 'ncc'
+#     >>> binary_ncc.inputs.operand_file = 'im2.nii'
+#     >>> binary_ncc.cmdline
+#     'seg_stats im1.nii -ncc im2.nii'
+#     >>> binary_ncc.run()  # doctest: +SKIP
+#     >>> # Test Nl operation
+#     >>> binary_nl = copy.deepcopy(binary)
+#     >>> binary_nl.inputs.operation = 'Nl'
+#     >>> binary_nl.inputs.operand_file = 'output.csv'
+#     >>> binary_nl.cmdline
+#     'seg_stats im1.nii -Nl output.csv'
+#     >>> binary_nl.run()  # doctest: +SKIP
+# 
+#     
+task_name: BinaryStats
+nipype_name: BinaryStats
+nipype_module: nipype.interfaces.niftyseg.stats
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    operand_file: text/csv
+    # type=file|default=<undefined>: second image to perform operation with
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: image to operate on
+    mask_file: generic/file
+    # type=file|default=<undefined>: statistics within the masked area
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    operation:
+    # type=enum|default='p'|allowed['Nl','Vl','al','d','ncc','nmi','p','sa','ss','svp']: Operation to perform:      * p - <float> - The <float>th percentile of all voxels intensity (float=[0,100])     * sa - <ax> - Average of all voxels     * ss - <ax> - Standard deviation of all voxels     * svp - <ax> - Volume of all probabilsitic voxels (sum(<in>) x <volume per voxel>)     * al - <in2> - Average value in <in> for each label in <in2>     * d - <in2> - Calculate the Dice score between all classes in <in> and <in2>     * ncc - <in2> - Normalized cross correlation between <in> and <in2>     * nmi - <in2> - Normalized Mutual Information between <in> and <in2>     * Vl - <csv> - Volume of each integer label <in>. Save to <csv>file.     * Nl - <csv> - Count of each label <in>. Save to <csv> file.  
+    operand_file:
+    # type=file|default=<undefined>: second image to perform operation with
+    operand_value:
+    # type=float|default=0.0: value to perform operation with
+    in_file:
+    # type=file|default=<undefined>: image to operate on
+    mask_file:
+    # type=file|default=<undefined>: statistics within the masked area
+    larger_voxel:
+    # type=float|default=0.0: Only estimate statistics if voxel is larger than <float>
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: image to operate on
+    operation: '"Nl"'
+    # type=enum|default='p'|allowed['Nl','Vl','al','d','ncc','nmi','p','sa','ss','svp']: Operation to perform:      * p - <float> - The <float>th percentile of all voxels intensity (float=[0,100])     * sa - <ax> - Average of all voxels     * ss - <ax> - Standard deviation of all voxels     * svp - <ax> - Volume of all probabilsitic voxels (sum(<in>) x <volume per voxel>)     * al - <in2> - Average value in <in> for each label in <in2>     * d - <in2> - Calculate the Dice score between all classes in <in> and <in2>     * ncc - <in2> - Normalized cross correlation between <in> and <in2>     * nmi - <in2> - Normalized Mutual Information between <in> and <in2>     * Vl - <csv> - Volume of each integer label <in>. Save to <csv>file.     * Nl - <csv> - Count of each label <in>. Save to <csv> file.  
+    operand_value: '2.0'
+    # type=float|default=0.0: value to perform operation with
+    operand_file:
+    # type=file|default=<undefined>: second image to perform operation with
+  imports: &id001
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  - module: copy
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: seg_stats im1.nii -Nl output.csv
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: image to operate on
+    operation: '"Nl"'
+    # type=enum|default='p'|allowed['Nl','Vl','al','d','ncc','nmi','p','sa','ss','svp']: Operation to perform:      * p - <float> - The <float>th percentile of all voxels intensity (float=[0,100])     * sa - <ax> - Average of all voxels     * ss - <ax> - Standard deviation of all voxels     * svp - <ax> - Volume of all probabilsitic voxels (sum(<in>) x <volume per voxel>)     * al - <in2> - Average value in <in> for each label in <in2>     * d - <in2> - Calculate the Dice score between all classes in <in> and <in2>     * ncc - <in2> - Normalized cross correlation between <in> and <in2>     * nmi - <in2> - Normalized Mutual Information between <in> and <in2>     * Vl - <csv> - Volume of each integer label <in>. Save to <csv>file.     * Nl - <csv> - Count of each label <in>. Save to <csv> file.  
+    operand_value: '2.0'
+    # type=float|default=0.0: value to perform operation with
+    operand_file:
+    # type=file|default=<undefined>: second image to perform operation with
+  imports: *id001
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-niftyseg/binary_stats_callables.py b/example-specs/task/nipype_internal/pydra-niftyseg/binary_stats_callables.py
new file mode 100644
index 00000000..bfcafb23
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-niftyseg/binary_stats_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in BinaryStats.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-niftyseg/calc_top_ncc.yaml b/example-specs/task/nipype_internal/pydra-niftyseg/calc_top_ncc.yaml
new file mode 100644
index 00000000..bfe3e37a
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-niftyseg/calc_top_ncc.yaml
@@ -0,0 +1,140 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.niftyseg.label_fusion.CalcTopNCC' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Interface for executable seg_CalcTopNCC from NiftySeg platform.
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import niftyseg
+#     >>> node = niftyseg.CalcTopNCC()
+#     >>> node.inputs.in_file = 'im1.nii'
+#     >>> node.inputs.num_templates = 2
+#     >>> node.inputs.in_templates = ['im2.nii', 'im3.nii']
+#     >>> node.inputs.top_templates = 1
+#     >>> node.cmdline
+#     'seg_CalcTopNCC -target im1.nii -templates 2 im2.nii im3.nii -n 1'
+# 
+#     
+task_name: CalcTopNCC
+nipype_name: CalcTopNCC
+nipype_module: nipype.interfaces.niftyseg.label_fusion
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: Target file
+    in_templates: medimage/nifti1+list-of
+    # type=list|default=[]: 
+    mask_file: generic/file
+    # type=file|default=<undefined>: Filename of the ROI for label fusion
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: Target file
+    num_templates:
+    # type=int|default=0: Number of Templates
+    in_templates:
+    # type=list|default=[]: 
+    top_templates:
+    # type=int|default=0: Number of Top Templates
+    mask_file:
+    # type=file|default=<undefined>: Filename of the ROI for label fusion
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: Target file
+    num_templates: '2'
+    # type=int|default=0: Number of Templates
+    in_templates:
+    # type=list|default=[]: 
+    top_templates: '1'
+    # type=int|default=0: Number of Top Templates
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: seg_CalcTopNCC -target im1.nii -templates 2 im2.nii im3.nii -n 1
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: Target file
+    num_templates: '2'
+    # type=int|default=0: Number of Templates
+    in_templates:
+    # type=list|default=[]: 
+    top_templates: '1'
+    # type=int|default=0: Number of Top Templates
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-niftyseg/calc_top_ncc_callables.py b/example-specs/task/nipype_internal/pydra-niftyseg/calc_top_ncc_callables.py
new file mode 100644
index 00000000..48a54d55
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-niftyseg/calc_top_ncc_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in CalcTopNCC.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-niftyseg/em.yaml b/example-specs/task/nipype_internal/pydra-niftyseg/em.yaml
new file mode 100644
index 00000000..69f09c06
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-niftyseg/em.yaml
@@ -0,0 +1,180 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.niftyseg.em.EM' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Interface for executable seg_EM from NiftySeg platform.
+# 
+#     seg_EM is a general purpose intensity based image segmentation tool. In
+#     it's simplest form, it takes in one 2D or 3D image and segments it in n
+#     classes.
+# 
+#     `Source code <http://cmictig.cs.ucl.ac.uk/wiki/index.php/NiftySeg>`_ |
+#     `Documentation <http://cmictig.cs.ucl.ac.uk/wiki/index.php/NiftySeg_documentation>`_
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import niftyseg
+#     >>> node = niftyseg.EM()
+#     >>> node.inputs.in_file = 'im1.nii'
+#     >>> node.inputs.no_prior = 4
+#     >>> node.cmdline
+#     'seg_EM -in im1.nii -bc_order 3 -bc_thresh 0 -max_iter 100 -min_iter 0 -nopriors 4 -bc_out im1_bc_em.nii.gz -out im1_em.nii.gz -out_outlier im1_outlier_em.nii.gz'
+# 
+#     
+task_name: EM
+nipype_name: EM
+nipype_module: nipype.interfaces.niftyseg.em
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: Input image to segment
+    mask_file: generic/file
+    # type=file|default=<undefined>: Filename of the ROI for label fusion
+    prior_4D: generic/file
+    # type=file|default=<undefined>: 4D file containing the priors
+    out_file: generic/file
+    # type=file: Output segmentation
+    # type=file|default=<undefined>: Output segmentation
+    out_bc_file: generic/file
+    # type=file: Output bias corrected image
+    # type=file|default=<undefined>: Output bias corrected image
+    out_outlier_file: generic/file
+    # type=file: Output outlierness image
+    # type=file|default=<undefined>: Output outlierness image
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: Output segmentation
+    # type=file|default=<undefined>: Output segmentation
+    out_bc_file: generic/file
+    # type=file: Output bias corrected image
+    # type=file|default=<undefined>: Output bias corrected image
+    out_outlier_file: generic/file
+    # type=file: Output outlierness image
+    # type=file|default=<undefined>: Output outlierness image
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: Input image to segment
+    mask_file:
+    # type=file|default=<undefined>: Filename of the ROI for label fusion
+    no_prior:
+    # type=int|default=0: Number of classes to use without prior
+    prior_4D:
+    # type=file|default=<undefined>: 4D file containing the priors
+    priors:
+    # type=inputmultiobject|default=[]: List of priors filepaths.
+    max_iter:
+    # type=int|default=100: Maximum number of iterations
+    min_iter:
+    # type=int|default=0: Minimum number of iterations
+    bc_order_val:
+    # type=int|default=3: Polynomial order for the bias field
+    mrf_beta_val:
+    # type=float|default=0.0: Weight of the Markov Random Field
+    bc_thresh_val:
+    # type=float|default=0: Bias field correction will run only if the ratio of improvement is below bc_thresh. (default=0 [OFF])
+    reg_val:
+    # type=float|default=0.0: Amount of regularization over the diagonal of the covariance matrix [above 1]
+    outlier_val:
+    # type=tuple|default=(0.0, 0.0): Outlier detection as in (Van Leemput TMI 2003). <fl1> is the Mahalanobis threshold [recommended between 3 and 7] <fl2> is a convergence ratio below which the outlier detection is going to be done [recommended 0.01]
+    relax_priors:
+    # type=tuple|default=(0.0, 0.0): Relax Priors [relaxation factor: 0<rf<1 (recommended=0.5), gaussian regularization: gstd>0 (recommended=2.0)] /only 3D/
+    out_file:
+    # type=file: Output segmentation
+    # type=file|default=<undefined>: Output segmentation
+    out_bc_file:
+    # type=file: Output bias corrected image
+    # type=file|default=<undefined>: Output bias corrected image
+    out_outlier_file:
+    # type=file: Output outlierness image
+    # type=file|default=<undefined>: Output outlierness image
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: Input image to segment
+    no_prior: '4'
+    # type=int|default=0: Number of classes to use without prior
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: seg_EM -in im1.nii -bc_order 3 -bc_thresh 0 -max_iter 100 -min_iter 0 -nopriors 4 -bc_out im1_bc_em.nii.gz -out im1_em.nii.gz -out_outlier im1_outlier_em.nii.gz
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: Input image to segment
+    no_prior: '4'
+    # type=int|default=0: Number of classes to use without prior
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-niftyseg/em_callables.py b/example-specs/task/nipype_internal/pydra-niftyseg/em_callables.py
new file mode 100644
index 00000000..5727596b
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-niftyseg/em_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in EM.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-niftyseg/fill_lesions.yaml b/example-specs/task/nipype_internal/pydra-niftyseg/fill_lesions.yaml
new file mode 100644
index 00000000..102b9935
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-niftyseg/fill_lesions.yaml
@@ -0,0 +1,162 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.niftyseg.lesions.FillLesions' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Interface for executable seg_FillLesions from NiftySeg platform.
+# 
+#     Fill all the masked lesions with WM intensity average.
+# 
+#     `Source code <http://cmictig.cs.ucl.ac.uk/wiki/index.php/NiftySeg>`_ |
+#     `Documentation <http://cmictig.cs.ucl.ac.uk/wiki/index.php/NiftySeg_documentation>`_
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import niftyseg
+#     >>> node = niftyseg.FillLesions()
+#     >>> node.inputs.in_file = 'im1.nii'
+#     >>> node.inputs.lesion_mask = 'im2.nii'
+#     >>> node.cmdline
+#     'seg_FillLesions -i im1.nii -l im2.nii -o im1_lesions_filled.nii.gz'
+# 
+#     
+task_name: FillLesions
+nipype_name: FillLesions
+nipype_module: nipype.interfaces.niftyseg.lesions
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: Input image to fill lesions
+    lesion_mask: medimage/nifti1
+    # type=file|default=<undefined>: Lesion mask
+    out_file: generic/file
+    # type=file: Output segmentation
+    # type=file|default=<undefined>: The output filename of the fill lesions results
+    bin_mask: generic/file
+    # type=file|default=<undefined>: Give a binary mask with the valid search areas.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: Output segmentation
+    # type=file|default=<undefined>: The output filename of the fill lesions results
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: Input image to fill lesions
+    lesion_mask:
+    # type=file|default=<undefined>: Lesion mask
+    out_file:
+    # type=file: Output segmentation
+    # type=file|default=<undefined>: The output filename of the fill lesions results
+    in_dilation:
+    # type=int|default=0: Dilate the mask <int> times (in voxels, by default 0)
+    match:
+    # type=float|default=0.0: Percentage of minimum number of voxels between patches <float> (by default 0.5).
+    search:
+    # type=float|default=0.0: Minimum percentage of valid voxels in target patch <float> (by default 0).
+    smooth:
+    # type=float|default=0.0: Smoothing by <float> (in minimal 6-neighbourhood voxels (by default 0.1)).
+    size:
+    # type=int|default=0: Search regions size respect biggest patch size (by default 4).
+    cwf:
+    # type=float|default=0.0: Patch cardinality weighting factor (by default 2).
+    bin_mask:
+    # type=file|default=<undefined>: Give a binary mask with the valid search areas.
+    other:
+    # type=bool|default=False: Guizard et al. (FIN 2015) method, it doesn't include the multiresolution/hierarchical inpainting part, this part needs to be done with some external software such as reg_tools and reg_resample from NiftyReg. By default it uses the method presented in Prados et al. (Neuroimage 2016).
+    use_2d:
+    # type=bool|default=False: Uses 2D patches in the Z axis, by default 3D.
+    debug:
+    # type=bool|default=False: Save all intermidium files (by default OFF).
+    out_datatype:
+    # type=string|default='': Set output <datatype> (char, short, int, uchar, ushort, uint, float, double).
+    verbose:
+    # type=bool|default=False: Verbose (by default OFF).
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: Input image to fill lesions
+    lesion_mask:
+    # type=file|default=<undefined>: Lesion mask
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: seg_FillLesions -i im1.nii -l im2.nii -o im1_lesions_filled.nii.gz
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: Input image to fill lesions
+    lesion_mask:
+    # type=file|default=<undefined>: Lesion mask
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-niftyseg/fill_lesions_callables.py b/example-specs/task/nipype_internal/pydra-niftyseg/fill_lesions_callables.py
new file mode 100644
index 00000000..9de29704
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-niftyseg/fill_lesions_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in FillLesions.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-niftyseg/label_fusion.yaml b/example-specs/task/nipype_internal/pydra-niftyseg/label_fusion.yaml
new file mode 100644
index 00000000..cb32245a
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-niftyseg/label_fusion.yaml
@@ -0,0 +1,208 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.niftyseg.label_fusion.LabelFusion' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Interface for executable seg_LabelFusion from NiftySeg platform using
+#     type STEPS as classifier Fusion.
+# 
+#     This executable implements 4 fusion strategies (-STEPS, -STAPLE, -MV or
+#     - SBA), all of them using either a global (-GNCC), ROI-based (-ROINCC),
+#     local (-LNCC) or no image similarity (-ALL). Combinations of fusion
+#     algorithms and similarity metrics give rise to different variants of known
+#     algorithms. As an example, using LNCC and MV as options will run a locally
+#     weighted voting strategy with LNCC derived weights, while using STAPLE and
+#     LNCC is equivalent to running STEPS as per its original formulation.
+#     A few other options pertaining the use of an MRF (-MRF beta), the initial
+#     sensitivity and specificity estimates and the use of only non-consensus
+#     voxels (-unc) for the STAPLE and STEPS algorithm. All processing can be
+#     masked (-mask), greatly reducing memory consumption.
+# 
+#     As an example, the command to use STEPS should be:
+#     seg_LabFusion -in 4D_Propragated_Labels_to_fuse.nii -out     FusedSegmentation.nii -STEPS 2 15 TargetImage.nii     4D_Propagated_Intensities.nii
+# 
+#     `Source code <http://cmictig.cs.ucl.ac.uk/wiki/index.php/NiftySeg>`_ |
+#     `Documentation <http://cmictig.cs.ucl.ac.uk/wiki/index.php/NiftySeg_documentation>`_
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import niftyseg
+#     >>> node = niftyseg.LabelFusion()
+#     >>> node.inputs.in_file = 'im1.nii'
+#     >>> node.inputs.kernel_size = 2.0
+#     >>> node.inputs.file_to_seg = 'im2.nii'
+#     >>> node.inputs.template_file = 'im3.nii'
+#     >>> node.inputs.template_num = 2
+#     >>> node.inputs.classifier_type = 'STEPS'
+#     >>> node.cmdline
+#     'seg_LabFusion -in im1.nii -STEPS 2.000000 2 im2.nii im3.nii -out im1_steps.nii'
+# 
+#     
+task_name: LabelFusion
+nipype_name: LabelFusion
+nipype_module: nipype.interfaces.niftyseg.label_fusion
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: Filename of the 4D integer label image.
+    template_file: medimage/nifti1
+    # type=file|default=<undefined>: Registered templates (4D Image)
+    file_to_seg: medimage/nifti1
+    # type=file|default=<undefined>: Original image to segment (3D Image)
+    mask_file: generic/file
+    # type=file|default=<undefined>: Filename of the ROI for label fusion
+    out_file: generic/file
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: Output consensus segmentation
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: Output consensus segmentation
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: Filename of the 4D integer label image.
+    template_file:
+    # type=file|default=<undefined>: Registered templates (4D Image)
+    file_to_seg:
+    # type=file|default=<undefined>: Original image to segment (3D Image)
+    mask_file:
+    # type=file|default=<undefined>: Filename of the ROI for label fusion
+    out_file:
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: Output consensus segmentation
+    prob_flag:
+    # type=bool|default=False: Probabilistic/Fuzzy segmented image
+    verbose:
+    # type=enum|default='0'|allowed['0','1','2']: Verbose level [0 = off, 1 = on, 2 = debug] (default = 0)
+    unc:
+    # type=bool|default=False: Only consider non-consensus voxels to calculate statistics
+    classifier_type:
+    # type=enum|default='STEPS'|allowed['MV','SBA','STAPLE','STEPS']: Type of Classifier Fusion.
+    kernel_size:
+    # type=float|default=0.0: Gaussian kernel size in mm to compute the local similarity
+    template_num:
+    # type=int|default=0: Number of labels to use
+    sm_ranking:
+    # type=enum|default='ALL'|allowed['ALL','GNCC','LNCC','ROINCC']: Ranking for STAPLE and MV
+    dilation_roi:
+    # type=int|default=0: Dilation of the ROI ( <int> d>=1 )
+    proportion:
+    # type=float|default=0.0: Proportion of the label (only for single labels).
+    prob_update_flag:
+    # type=bool|default=False: Update label proportions at each iteration
+    set_pq:
+    # type=tuple|default=(0.0, 0.0): Value of P and Q [ 0 < (P,Q) < 1 ] (default = 0.99 0.99)
+    mrf_value:
+    # type=float|default=0.0: MRF prior strength (between 0 and 5)
+    max_iter:
+    # type=int|default=0: Maximum number of iterations (default = 15).
+    unc_thresh:
+    # type=float|default=0.0: If <float> percent of labels agree, then area is not uncertain.
+    conv:
+    # type=float|default=0.0: Ratio for convergence (default epsilon = 10^-5).
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: Filename of the 4D integer label image.
+    kernel_size: '2.0'
+    # type=float|default=0.0: Gaussian kernel size in mm to compute the local similarity
+    file_to_seg:
+    # type=file|default=<undefined>: Original image to segment (3D Image)
+    template_file:
+    # type=file|default=<undefined>: Registered templates (4D Image)
+    template_num: '2'
+    # type=int|default=0: Number of labels to use
+    classifier_type: '"STEPS"'
+    # type=enum|default='STEPS'|allowed['MV','SBA','STAPLE','STEPS']: Type of Classifier Fusion.
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: seg_LabFusion -in im1.nii -STEPS 2.000000 2 im2.nii im3.nii -out im1_steps.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: Filename of the 4D integer label image.
+    kernel_size: '2.0'
+    # type=float|default=0.0: Gaussian kernel size in mm to compute the local similarity
+    file_to_seg:
+    # type=file|default=<undefined>: Original image to segment (3D Image)
+    template_file:
+    # type=file|default=<undefined>: Registered templates (4D Image)
+    template_num: '2'
+    # type=int|default=0: Number of labels to use
+    classifier_type: '"STEPS"'
+    # type=enum|default='STEPS'|allowed['MV','SBA','STAPLE','STEPS']: Type of Classifier Fusion.
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-niftyseg/label_fusion_callables.py b/example-specs/task/nipype_internal/pydra-niftyseg/label_fusion_callables.py
new file mode 100644
index 00000000..77a5401a
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-niftyseg/label_fusion_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in LabelFusion.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-niftyseg/maths_command.yaml b/example-specs/task/nipype_internal/pydra-niftyseg/maths_command.yaml
new file mode 100644
index 00000000..b00d9ae5
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-niftyseg/maths_command.yaml
@@ -0,0 +1,96 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.niftyseg.maths.MathsCommand' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Base Command Interface for seg_maths interfaces.
+# 
+#     The executable seg_maths enables the sequential execution of arithmetic
+#     operations, like multiplication (-mul), division (-div) or addition
+#     (-add), binarisation (-bin) or thresholding (-thr) operations and
+#     convolution by a Gaussian kernel (-smo). It also allows mathematical
+#     morphology based operations like dilation (-dil), erosion (-ero),
+#     connected components (-lconcomp) and hole filling (-fill), Euclidean
+#     (- euc) and geodesic (-geo) distance transforms, local image similarity
+#     metric calculation (-lncc and -lssd). Finally, it allows multiple
+#     operations over the dimensionality of the image, from merging 3D images
+#     together as a 4D image (-merge) or splitting (-split or -tp) 4D images
+#     into several 3D images, to estimating the maximum, minimum and average
+#     over all time-points, etc.
+#     
+task_name: MathsCommand
+nipype_name: MathsCommand
+nipype_module: nipype.interfaces.niftyseg.maths
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: image to operate on
+    out_file: generic/file
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: image to operate on
+    out_file:
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
+    output_datatype:
+    # type=enum|default='float'|allowed['char','double','float','input','int','short']: datatype to use for output (default uses input type)
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-niftyseg/maths_command_callables.py b/example-specs/task/nipype_internal/pydra-niftyseg/maths_command_callables.py
new file mode 100644
index 00000000..84e0f131
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-niftyseg/maths_command_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in MathsCommand.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-niftyseg/merge.yaml b/example-specs/task/nipype_internal/pydra-niftyseg/merge.yaml
new file mode 100644
index 00000000..843f2ac8
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-niftyseg/merge.yaml
@@ -0,0 +1,151 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.niftyseg.maths.Merge' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Merge image files.
+# 
+#     See Also
+#     --------
+#     `Source code <http://cmictig.cs.ucl.ac.uk/wiki/index.php/NiftySeg>`__ --
+#     `Documentation <http://cmictig.cs.ucl.ac.uk/wiki/index.php/NiftySeg_documentation>`__
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import niftyseg
+#     >>> node = niftyseg.Merge()
+#     >>> node.inputs.in_file = 'im1.nii'
+#     >>> files = ['im2.nii', 'im3.nii']
+#     >>> node.inputs.merge_files = files
+#     >>> node.inputs.dimension = 2
+#     >>> node.inputs.output_datatype = 'float'
+#     >>> node.cmdline
+#     'seg_maths im1.nii -merge 2 2 im2.nii im3.nii -odt float im1_merged.nii'
+# 
+#     
+task_name: Merge
+nipype_name: Merge
+nipype_module: nipype.interfaces.niftyseg.maths
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    merge_files: generic/file+list-of
+    # type=list|default=[]: List of images to merge to the working image <input>.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: image to operate on
+    out_file: generic/file
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    dimension:
+    # type=int|default=0: Dimension to merge the images.
+    merge_files:
+    # type=list|default=[]: List of images to merge to the working image <input>.
+    in_file:
+    # type=file|default=<undefined>: image to operate on
+    out_file:
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
+    output_datatype:
+    # type=enum|default='float'|allowed['char','double','float','input','int','short']: datatype to use for output (default uses input type)
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: image to operate on
+    merge_files:
+    # type=list|default=[]: List of images to merge to the working image <input>.
+    dimension: '2'
+    # type=int|default=0: Dimension to merge the images.
+    output_datatype: '"float"'
+    # type=enum|default='float'|allowed['char','double','float','input','int','short']: datatype to use for output (default uses input type)
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: seg_maths im1.nii -merge 2 2 im2.nii im3.nii -odt float im1_merged.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: image to operate on
+    merge_files:
+    # type=list|default=[]: List of images to merge to the working image <input>.
+    dimension: '2'
+    # type=int|default=0: Dimension to merge the images.
+    output_datatype: '"float"'
+    # type=enum|default='float'|allowed['char','double','float','input','int','short']: datatype to use for output (default uses input type)
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-niftyseg/merge_callables.py b/example-specs/task/nipype_internal/pydra-niftyseg/merge_callables.py
new file mode 100644
index 00000000..1950a89d
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-niftyseg/merge_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Merge.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-niftyseg/patch_match.yaml b/example-specs/task/nipype_internal/pydra-niftyseg/patch_match.yaml
new file mode 100644
index 00000000..dff477db
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-niftyseg/patch_match.yaml
@@ -0,0 +1,165 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.niftyseg.patchmatch.PatchMatch' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Interface for executable seg_PatchMatch from NiftySeg platform.
+# 
+#     The database file is a text file and in each line we have a template
+#     file, a mask with the search region to consider and a file with the
+#     label to propagate.
+# 
+#     Input image, input mask, template images from database and masks from
+#     database must have the same 4D resolution (same number of XxYxZ voxels,
+#     modalities and/or time-points).
+#     Label files from database must have the same 3D resolution
+#     (XxYxZ voxels) than input image but can have different number of
+#     volumes than the input image allowing to propagate multiple labels
+#     in the same execution.
+# 
+#     `Source code <http://cmictig.cs.ucl.ac.uk/wiki/index.php/NiftySeg>`_ |
+#     `Documentation <http://cmictig.cs.ucl.ac.uk/wiki/index.php/NiftySeg_documentation>`_
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces import niftyseg
+#     >>> node = niftyseg.PatchMatch()
+#     >>> node.inputs.in_file = 'im1.nii'
+#     >>> node.inputs.mask_file = 'im2.nii'
+#     >>> node.inputs.database_file = 'db.xml'
+#     >>> node.cmdline
+#     'seg_PatchMatch -i im1.nii -m im2.nii -db db.xml -o im1_pm.nii.gz'
+# 
+#     
+task_name: PatchMatch
+nipype_name: PatchMatch
+nipype_module: nipype.interfaces.niftyseg.patchmatch
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: Input image to segment
+    mask_file: medimage/nifti1
+    # type=file|default=<undefined>: Input mask for the area where applies PatchMatch
+    database_file: application/xml
+    # type=file|default=<undefined>: Database with the segmentations
+    out_file: generic/file
+    # type=file: Output segmentation
+    # type=file|default=<undefined>: The output filename of the patchmatch results
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: Output segmentation
+    # type=file|default=<undefined>: The output filename of the patchmatch results
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: Input image to segment
+    mask_file:
+    # type=file|default=<undefined>: Input mask for the area where applies PatchMatch
+    database_file:
+    # type=file|default=<undefined>: Database with the segmentations
+    out_file:
+    # type=file: Output segmentation
+    # type=file|default=<undefined>: The output filename of the patchmatch results
+    patch_size:
+    # type=int|default=0: Patch size, #voxels
+    cs_size:
+    # type=int|default=0: Constrained search area size, number of times bigger than the patchsize
+    match_num:
+    # type=int|default=0: Number of better matching
+    pm_num:
+    # type=int|default=0: Number of patchmatch executions
+    it_num:
+    # type=int|default=0: Number of iterations for the patchmatch algorithm
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: Input image to segment
+    mask_file:
+    # type=file|default=<undefined>: Input mask for the area where applies PatchMatch
+    database_file:
+    # type=file|default=<undefined>: Database with the segmentations
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: seg_PatchMatch -i im1.nii -m im2.nii -db db.xml -o im1_pm.nii.gz
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: Input image to segment
+    mask_file:
+    # type=file|default=<undefined>: Input mask for the area where applies PatchMatch
+    database_file:
+    # type=file|default=<undefined>: Database with the segmentations
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-niftyseg/patch_match_callables.py b/example-specs/task/nipype_internal/pydra-niftyseg/patch_match_callables.py
new file mode 100644
index 00000000..e32afef5
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-niftyseg/patch_match_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in PatchMatch.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-niftyseg/stats_command.yaml b/example-specs/task/nipype_internal/pydra-niftyseg/stats_command.yaml
new file mode 100644
index 00000000..b2679fc4
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-niftyseg/stats_command.yaml
@@ -0,0 +1,88 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.niftyseg.stats.StatsCommand' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Base Command Interface for seg_stats interfaces.
+# 
+#     The executable seg_stats enables the estimation of image statistics on
+#     continuous voxel intensities (average, standard deviation, min/max, robust
+#     range, percentiles, sum, probabilistic volume, entropy, etc) either over
+#     the full image or on a per slice basis (slice axis can be specified),
+#     statistics over voxel coordinates (location of max, min and centre of
+#     mass, bounding box, etc) and statistics over categorical images (e.g. per
+#     region volume, count, average, Dice scores, etc). These statistics are
+#     robust to the presence of NaNs, and can be constrained by a mask and/or
+#     thresholded at a certain level.
+#     
+task_name: StatsCommand
+nipype_name: StatsCommand
+nipype_module: nipype.interfaces.niftyseg.stats
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: image to operate on
+    mask_file: generic/file
+    # type=file|default=<undefined>: statistics within the masked area
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: image to operate on
+    mask_file:
+    # type=file|default=<undefined>: statistics within the masked area
+    larger_voxel:
+    # type=float|default=0.0: Only estimate statistics if voxel is larger than <float>
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-niftyseg/stats_command_callables.py b/example-specs/task/nipype_internal/pydra-niftyseg/stats_command_callables.py
new file mode 100644
index 00000000..59622afe
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-niftyseg/stats_command_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in StatsCommand.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-niftyseg/tuple_maths.yaml b/example-specs/task/nipype_internal/pydra-niftyseg/tuple_maths.yaml
new file mode 100644
index 00000000..f747c691
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-niftyseg/tuple_maths.yaml
@@ -0,0 +1,269 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.niftyseg.maths.TupleMaths' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Mathematical operations on tuples.
+# 
+#     See Also
+#     --------
+#     `Source code <http://cmictig.cs.ucl.ac.uk/wiki/index.php/NiftySeg>`__ --
+#     `Documentation <http://cmictig.cs.ucl.ac.uk/wiki/index.php/NiftySeg_documentation>`__
+# 
+#     Examples
+#     --------
+#     >>> import copy
+#     >>> from nipype.interfaces import niftyseg
+#     >>> tuple = niftyseg.TupleMaths()
+#     >>> tuple.inputs.in_file = 'im1.nii'
+#     >>> tuple.inputs.output_datatype = 'float'
+# 
+#     >>> # Test lncc operation
+#     >>> tuple_lncc = copy.deepcopy(tuple)
+#     >>> tuple_lncc.inputs.operation = 'lncc'
+#     >>> tuple_lncc.inputs.operand_file1 = 'im2.nii'
+#     >>> tuple_lncc.inputs.operand_value2 = 2.0
+#     >>> tuple_lncc.cmdline
+#     'seg_maths im1.nii -lncc im2.nii 2.00000000 -odt float im1_lncc.nii'
+#     >>> tuple_lncc.run()  # doctest: +SKIP
+# 
+#     >>> # Test lssd operation
+#     >>> tuple_lssd = copy.deepcopy(tuple)
+#     >>> tuple_lssd.inputs.operation = 'lssd'
+#     >>> tuple_lssd.inputs.operand_file1 = 'im2.nii'
+#     >>> tuple_lssd.inputs.operand_value2 = 1.0
+#     >>> tuple_lssd.cmdline
+#     'seg_maths im1.nii -lssd im2.nii 1.00000000 -odt float im1_lssd.nii'
+#     >>> tuple_lssd.run()  # doctest: +SKIP
+# 
+#     >>> # Test lltsnorm operation
+#     >>> tuple_lltsnorm = copy.deepcopy(tuple)
+#     >>> tuple_lltsnorm.inputs.operation = 'lltsnorm'
+#     >>> tuple_lltsnorm.inputs.operand_file1 = 'im2.nii'
+#     >>> tuple_lltsnorm.inputs.operand_value2 = 0.01
+#     >>> tuple_lltsnorm.cmdline
+#     'seg_maths im1.nii -lltsnorm im2.nii 0.01000000 -odt float im1_lltsnorm.nii'
+#     >>> tuple_lltsnorm.run()  # doctest: +SKIP
+# 
+#     
+task_name: TupleMaths
+nipype_name: TupleMaths
+nipype_module: nipype.interfaces.niftyseg.maths
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    operand_file1: medimage/nifti1
+    # type=file|default=<undefined>: image to perform operation 1 with
+    operand_file2: generic/file
+    # type=file|default=<undefined>: image to perform operation 2 with
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: image to operate on
+    out_file: generic/file
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    operation:
+    # type=enum|default='lncc'|allowed['lltsnorm','lncc','lssd']: Operation to perform:      * lncc <file> <std> Local CC between current img and <file> on a kernel with <std>     * lssd <file> <std> Local SSD between current img and <file> on a kernel with <std>     * lltsnorm <file_norm> <float>  Linear LTS normalisation assuming <float> percent outliers  
+    operand_file1:
+    # type=file|default=<undefined>: image to perform operation 1 with
+    operand_value1:
+    # type=float|default=0.0: float value to perform operation 1 with
+    operand_file2:
+    # type=file|default=<undefined>: image to perform operation 2 with
+    operand_value2:
+    # type=float|default=0.0: float value to perform operation 2 with
+    in_file:
+    # type=file|default=<undefined>: image to operate on
+    out_file:
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
+    output_datatype:
+    # type=enum|default='float'|allowed['char','double','float','input','int','short']: datatype to use for output (default uses input type)
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: image to operate on
+    output_datatype: '"float"'
+    # type=enum|default='float'|allowed['char','double','float','input','int','short']: datatype to use for output (default uses input type)
+    operation: '"lncc"'
+    # type=enum|default='lncc'|allowed['lltsnorm','lncc','lssd']: Operation to perform:      * lncc <file> <std> Local CC between current img and <file> on a kernel with <std>     * lssd <file> <std> Local SSD between current img and <file> on a kernel with <std>     * lltsnorm <file_norm> <float>  Linear LTS normalisation assuming <float> percent outliers  
+    operand_file1:
+    # type=file|default=<undefined>: image to perform operation 1 with
+    operand_value2: '2.0'
+    # type=float|default=0.0: float value to perform operation 2 with
+  imports: &id001
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  - module: copy
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    operation: '"lssd"'
+    # type=enum|default='lncc'|allowed['lltsnorm','lncc','lssd']: Operation to perform:      * lncc <file> <std> Local CC between current img and <file> on a kernel with <std>     * lssd <file> <std> Local SSD between current img and <file> on a kernel with <std>     * lltsnorm <file_norm> <float>  Linear LTS normalisation assuming <float> percent outliers  
+    operand_file1:
+    # type=file|default=<undefined>: image to perform operation 1 with
+    operand_value2: '1.0'
+    # type=float|default=0.0: float value to perform operation 2 with
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    operation: '"lltsnorm"'
+    # type=enum|default='lncc'|allowed['lltsnorm','lncc','lssd']: Operation to perform:      * lncc <file> <std> Local CC between current img and <file> on a kernel with <std>     * lssd <file> <std> Local SSD between current img and <file> on a kernel with <std>     * lltsnorm <file_norm> <float>  Linear LTS normalisation assuming <float> percent outliers  
+    operand_file1:
+    # type=file|default=<undefined>: image to perform operation 1 with
+    operand_value2: '0.01'
+    # type=float|default=0.0: float value to perform operation 2 with
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: seg_maths im1.nii -lncc im2.nii 2.00000000 -odt float im1_lncc.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: image to operate on
+    output_datatype: '"float"'
+    # type=enum|default='float'|allowed['char','double','float','input','int','short']: datatype to use for output (default uses input type)
+    operation: '"lncc"'
+    # type=enum|default='lncc'|allowed['lltsnorm','lncc','lssd']: Operation to perform:      * lncc <file> <std> Local CC between current img and <file> on a kernel with <std>     * lssd <file> <std> Local SSD between current img and <file> on a kernel with <std>     * lltsnorm <file_norm> <float>  Linear LTS normalisation assuming <float> percent outliers  
+    operand_file1:
+    # type=file|default=<undefined>: image to perform operation 1 with
+    operand_value2: '2.0'
+    # type=float|default=0.0: float value to perform operation 2 with
+  imports: *id001
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: seg_maths im1.nii -lssd im2.nii 1.00000000 -odt float im1_lssd.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    operation: '"lssd"'
+    # type=enum|default='lncc'|allowed['lltsnorm','lncc','lssd']: Operation to perform:      * lncc <file> <std> Local CC between current img and <file> on a kernel with <std>     * lssd <file> <std> Local SSD between current img and <file> on a kernel with <std>     * lltsnorm <file_norm> <float>  Linear LTS normalisation assuming <float> percent outliers  
+    operand_file1:
+    # type=file|default=<undefined>: image to perform operation 1 with
+    operand_value2: '1.0'
+    # type=float|default=0.0: float value to perform operation 2 with
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: seg_maths im1.nii -lltsnorm im2.nii 0.01000000 -odt float im1_lltsnorm.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    operation: '"lltsnorm"'
+    # type=enum|default='lncc'|allowed['lltsnorm','lncc','lssd']: Operation to perform:      * lncc <file> <std> Local CC between current img and <file> on a kernel with <std>     * lssd <file> <std> Local SSD between current img and <file> on a kernel with <std>     * lltsnorm <file_norm> <float>  Linear LTS normalisation assuming <float> percent outliers  
+    operand_file1:
+    # type=file|default=<undefined>: image to perform operation 1 with
+    operand_value2: '0.01'
+    # type=float|default=0.0: float value to perform operation 2 with
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-niftyseg/tuple_maths_callables.py b/example-specs/task/nipype_internal/pydra-niftyseg/tuple_maths_callables.py
new file mode 100644
index 00000000..7a6b9e82
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-niftyseg/tuple_maths_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in TupleMaths.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-niftyseg/unary_maths.yaml b/example-specs/task/nipype_internal/pydra-niftyseg/unary_maths.yaml
new file mode 100644
index 00000000..83ef5b48
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-niftyseg/unary_maths.yaml
@@ -0,0 +1,307 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.niftyseg.maths.UnaryMaths' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Unary mathematical operations.
+# 
+#     See Also
+#     --------
+#     `Source code <http://cmictig.cs.ucl.ac.uk/wiki/index.php/NiftySeg>`__ --
+#     `Documentation <http://cmictig.cs.ucl.ac.uk/wiki/index.php/NiftySeg_documentation>`__
+# 
+#     Examples
+#     --------
+#     >>> import copy
+#     >>> from nipype.interfaces import niftyseg
+#     >>> unary = niftyseg.UnaryMaths()
+#     >>> unary.inputs.output_datatype = 'float'
+#     >>> unary.inputs.in_file = 'im1.nii'
+# 
+#     >>> # Test sqrt operation
+#     >>> unary_sqrt = copy.deepcopy(unary)
+#     >>> unary_sqrt.inputs.operation = 'sqrt'
+#     >>> unary_sqrt.cmdline
+#     'seg_maths im1.nii -sqrt -odt float im1_sqrt.nii'
+#     >>> unary_sqrt.run()  # doctest: +SKIP
+# 
+#     >>> # Test sqrt operation
+#     >>> unary_abs = copy.deepcopy(unary)
+#     >>> unary_abs.inputs.operation = 'abs'
+#     >>> unary_abs.cmdline
+#     'seg_maths im1.nii -abs -odt float im1_abs.nii'
+#     >>> unary_abs.run()  # doctest: +SKIP
+# 
+#     >>> # Test bin operation
+#     >>> unary_bin = copy.deepcopy(unary)
+#     >>> unary_bin.inputs.operation = 'bin'
+#     >>> unary_bin.cmdline
+#     'seg_maths im1.nii -bin -odt float im1_bin.nii'
+#     >>> unary_bin.run()  # doctest: +SKIP
+# 
+#     >>> # Test otsu operation
+#     >>> unary_otsu = copy.deepcopy(unary)
+#     >>> unary_otsu.inputs.operation = 'otsu'
+#     >>> unary_otsu.cmdline
+#     'seg_maths im1.nii -otsu -odt float im1_otsu.nii'
+#     >>> unary_otsu.run()  # doctest: +SKIP
+# 
+#     >>> # Test isnan operation
+#     >>> unary_isnan = copy.deepcopy(unary)
+#     >>> unary_isnan.inputs.operation = 'isnan'
+#     >>> unary_isnan.cmdline
+#     'seg_maths im1.nii -isnan -odt float im1_isnan.nii'
+#     >>> unary_isnan.run()  # doctest: +SKIP
+# 
+#     
+task_name: UnaryMaths
+nipype_name: UnaryMaths
+nipype_module: nipype.interfaces.niftyseg.maths
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: image to operate on
+    out_file: generic/file
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    operation:
+    # type=enum|default='sqrt'|allowed['4to5','abs','bin','concomp26','concomp6','euc','exp','fill','isnan','lconcomp','log','otsu','range','recip','removenan','scl','splitlab','sqrt','subsamp2','tmax','tmean','tmin','tpmax']: Operation to perform:      * sqrt - Square root of the image).     * exp - Exponential root of the image.     * log - Log of the image.     * recip - Reciprocal (1/I) of the image.     * abs - Absolute value of the image.     * bin - Binarise the image.     * otsu - Otsu thresholding of the current image.     * lconcomp - Take the largest connected component     * concomp6 - Label the different connected components with a 6NN kernel     * concomp26 - Label the different connected components with a 26NN kernel     * fill - Fill holes in binary object (e.g. fill ventricle in brain mask).     * euc - Euclidean distance transform     * tpmax - Get the time point with the highest value (binarise 4D probabilities)     * tmean - Mean value of all time points.     * tmax - Max value of all time points.     * tmin - Mean value of all time points.     * splitlab - Split the integer labels into multiple timepoints     * removenan - Remove all NaNs and replace then with 0     * isnan - Binary image equal to 1 if the value is NaN and 0 otherwise     * subsamp2 - Subsample the image by 2 using NN sampling (qform and sform scaled)     * scl  - Reset scale and slope info.     * 4to5 - Flip the 4th and 5th dimension.     * range - Reset the image range to the min max.  
+    in_file:
+    # type=file|default=<undefined>: image to operate on
+    out_file:
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
+    output_datatype:
+    # type=enum|default='float'|allowed['char','double','float','input','int','short']: datatype to use for output (default uses input type)
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    output_datatype: '"float"'
+    # type=enum|default='float'|allowed['char','double','float','input','int','short']: datatype to use for output (default uses input type)
+    in_file:
+    # type=file|default=<undefined>: image to operate on
+    operation: '"sqrt"'
+    # type=enum|default='sqrt'|allowed['4to5','abs','bin','concomp26','concomp6','euc','exp','fill','isnan','lconcomp','log','otsu','range','recip','removenan','scl','splitlab','sqrt','subsamp2','tmax','tmean','tmin','tpmax']: Operation to perform:      * sqrt - Square root of the image).     * exp - Exponential root of the image.     * log - Log of the image.     * recip - Reciprocal (1/I) of the image.     * abs - Absolute value of the image.     * bin - Binarise the image.     * otsu - Otsu thresholding of the current image.     * lconcomp - Take the largest connected component     * concomp6 - Label the different connected components with a 6NN kernel     * concomp26 - Label the different connected components with a 26NN kernel     * fill - Fill holes in binary object (e.g. fill ventricle in brain mask).     * euc - Euclidean distance transform     * tpmax - Get the time point with the highest value (binarise 4D probabilities)     * tmean - Mean value of all time points.     * tmax - Max value of all time points.     * tmin - Mean value of all time points.     * splitlab - Split the integer labels into multiple timepoints     * removenan - Remove all NaNs and replace then with 0     * isnan - Binary image equal to 1 if the value is NaN and 0 otherwise     * subsamp2 - Subsample the image by 2 using NN sampling (qform and sform scaled)     * scl  - Reset scale and slope info.     * 4to5 - Flip the 4th and 5th dimension.     * range - Reset the image range to the min max.  
+  imports: &id001
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  - module: copy
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    operation: '"abs"'
+    # type=enum|default='sqrt'|allowed['4to5','abs','bin','concomp26','concomp6','euc','exp','fill','isnan','lconcomp','log','otsu','range','recip','removenan','scl','splitlab','sqrt','subsamp2','tmax','tmean','tmin','tpmax']: Operation to perform:      * sqrt - Square root of the image).     * exp - Exponential root of the image.     * log - Log of the image.     * recip - Reciprocal (1/I) of the image.     * abs - Absolute value of the image.     * bin - Binarise the image.     * otsu - Otsu thresholding of the current image.     * lconcomp - Take the largest connected component     * concomp6 - Label the different connected components with a 6NN kernel     * concomp26 - Label the different connected components with a 26NN kernel     * fill - Fill holes in binary object (e.g. fill ventricle in brain mask).     * euc - Euclidean distance transform     * tpmax - Get the time point with the highest value (binarise 4D probabilities)     * tmean - Mean value of all time points.     * tmax - Max value of all time points.     * tmin - Mean value of all time points.     * splitlab - Split the integer labels into multiple timepoints     * removenan - Remove all NaNs and replace then with 0     * isnan - Binary image equal to 1 if the value is NaN and 0 otherwise     * subsamp2 - Subsample the image by 2 using NN sampling (qform and sform scaled)     * scl  - Reset scale and slope info.     * 4to5 - Flip the 4th and 5th dimension.     * range - Reset the image range to the min max.  
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    operation: '"bin"'
+    # type=enum|default='sqrt'|allowed['4to5','abs','bin','concomp26','concomp6','euc','exp','fill','isnan','lconcomp','log','otsu','range','recip','removenan','scl','splitlab','sqrt','subsamp2','tmax','tmean','tmin','tpmax']: Operation to perform:      * sqrt - Square root of the image).     * exp - Exponential root of the image.     * log - Log of the image.     * recip - Reciprocal (1/I) of the image.     * abs - Absolute value of the image.     * bin - Binarise the image.     * otsu - Otsu thresholding of the current image.     * lconcomp - Take the largest connected component     * concomp6 - Label the different connected components with a 6NN kernel     * concomp26 - Label the different connected components with a 26NN kernel     * fill - Fill holes in binary object (e.g. fill ventricle in brain mask).     * euc - Euclidean distance transform     * tpmax - Get the time point with the highest value (binarise 4D probabilities)     * tmean - Mean value of all time points.     * tmax - Max value of all time points.     * tmin - Mean value of all time points.     * splitlab - Split the integer labels into multiple timepoints     * removenan - Remove all NaNs and replace then with 0     * isnan - Binary image equal to 1 if the value is NaN and 0 otherwise     * subsamp2 - Subsample the image by 2 using NN sampling (qform and sform scaled)     * scl  - Reset scale and slope info.     * 4to5 - Flip the 4th and 5th dimension.     * range - Reset the image range to the min max.  
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    operation: '"otsu"'
+    # type=enum|default='sqrt'|allowed['4to5','abs','bin','concomp26','concomp6','euc','exp','fill','isnan','lconcomp','log','otsu','range','recip','removenan','scl','splitlab','sqrt','subsamp2','tmax','tmean','tmin','tpmax']: Operation to perform:      * sqrt - Square root of the image).     * exp - Exponential root of the image.     * log - Log of the image.     * recip - Reciprocal (1/I) of the image.     * abs - Absolute value of the image.     * bin - Binarise the image.     * otsu - Otsu thresholding of the current image.     * lconcomp - Take the largest connected component     * concomp6 - Label the different connected components with a 6NN kernel     * concomp26 - Label the different connected components with a 26NN kernel     * fill - Fill holes in binary object (e.g. fill ventricle in brain mask).     * euc - Euclidean distance transform     * tpmax - Get the time point with the highest value (binarise 4D probabilities)     * tmean - Mean value of all time points.     * tmax - Max value of all time points.     * tmin - Mean value of all time points.     * splitlab - Split the integer labels into multiple timepoints     * removenan - Remove all NaNs and replace then with 0     * isnan - Binary image equal to 1 if the value is NaN and 0 otherwise     * subsamp2 - Subsample the image by 2 using NN sampling (qform and sform scaled)     * scl  - Reset scale and slope info.     * 4to5 - Flip the 4th and 5th dimension.     * range - Reset the image range to the min max.  
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    operation: '"isnan"'
+    # type=enum|default='sqrt'|allowed['4to5','abs','bin','concomp26','concomp6','euc','exp','fill','isnan','lconcomp','log','otsu','range','recip','removenan','scl','splitlab','sqrt','subsamp2','tmax','tmean','tmin','tpmax']: Operation to perform:      * sqrt - Square root of the image).     * exp - Exponential root of the image.     * log - Log of the image.     * recip - Reciprocal (1/I) of the image.     * abs - Absolute value of the image.     * bin - Binarise the image.     * otsu - Otsu thresholding of the current image.     * lconcomp - Take the largest connected component     * concomp6 - Label the different connected components with a 6NN kernel     * concomp26 - Label the different connected components with a 26NN kernel     * fill - Fill holes in binary object (e.g. fill ventricle in brain mask).     * euc - Euclidean distance transform     * tpmax - Get the time point with the highest value (binarise 4D probabilities)     * tmean - Mean value of all time points.     * tmax - Max value of all time points.     * tmin - Mean value of all time points.     * splitlab - Split the integer labels into multiple timepoints     * removenan - Remove all NaNs and replace then with 0     * isnan - Binary image equal to 1 if the value is NaN and 0 otherwise     * subsamp2 - Subsample the image by 2 using NN sampling (qform and sform scaled)     * scl  - Reset scale and slope info.     * 4to5 - Flip the 4th and 5th dimension.     * range - Reset the image range to the min max.  
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: seg_maths im1.nii -sqrt -odt float im1_sqrt.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    output_datatype: '"float"'
+    # type=enum|default='float'|allowed['char','double','float','input','int','short']: datatype to use for output (default uses input type)
+    in_file:
+    # type=file|default=<undefined>: image to operate on
+    operation: '"sqrt"'
+    # type=enum|default='sqrt'|allowed['4to5','abs','bin','concomp26','concomp6','euc','exp','fill','isnan','lconcomp','log','otsu','range','recip','removenan','scl','splitlab','sqrt','subsamp2','tmax','tmean','tmin','tpmax']: Operation to perform:      * sqrt - Square root of the image).     * exp - Exponential root of the image.     * log - Log of the image.     * recip - Reciprocal (1/I) of the image.     * abs - Absolute value of the image.     * bin - Binarise the image.     * otsu - Otsu thresholding of the current image.     * lconcomp - Take the largest connected component     * concomp6 - Label the different connected components with a 6NN kernel     * concomp26 - Label the different connected components with a 26NN kernel     * fill - Fill holes in binary object (e.g. fill ventricle in brain mask).     * euc - Euclidean distance transform     * tpmax - Get the time point with the highest value (binarise 4D probabilities)     * tmean - Mean value of all time points.     * tmax - Max value of all time points.     * tmin - Mean value of all time points.     * splitlab - Split the integer labels into multiple timepoints     * removenan - Remove all NaNs and replace then with 0     * isnan - Binary image equal to 1 if the value is NaN and 0 otherwise     * subsamp2 - Subsample the image by 2 using NN sampling (qform and sform scaled)     * scl  - Reset scale and slope info.     * 4to5 - Flip the 4th and 5th dimension.     * range - Reset the image range to the min max.  
+  imports: *id001
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: seg_maths im1.nii -abs -odt float im1_abs.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    operation: '"abs"'
+    # type=enum|default='sqrt'|allowed['4to5','abs','bin','concomp26','concomp6','euc','exp','fill','isnan','lconcomp','log','otsu','range','recip','removenan','scl','splitlab','sqrt','subsamp2','tmax','tmean','tmin','tpmax']: Operation to perform:      * sqrt - Square root of the image).     * exp - Exponential root of the image.     * log - Log of the image.     * recip - Reciprocal (1/I) of the image.     * abs - Absolute value of the image.     * bin - Binarise the image.     * otsu - Otsu thresholding of the current image.     * lconcomp - Take the largest connected component     * concomp6 - Label the different connected components with a 6NN kernel     * concomp26 - Label the different connected components with a 26NN kernel     * fill - Fill holes in binary object (e.g. fill ventricle in brain mask).     * euc - Euclidean distance transform     * tpmax - Get the time point with the highest value (binarise 4D probabilities)     * tmean - Mean value of all time points.     * tmax - Max value of all time points.     * tmin - Mean value of all time points.     * splitlab - Split the integer labels into multiple timepoints     * removenan - Remove all NaNs and replace then with 0     * isnan - Binary image equal to 1 if the value is NaN and 0 otherwise     * subsamp2 - Subsample the image by 2 using NN sampling (qform and sform scaled)     * scl  - Reset scale and slope info.     * 4to5 - Flip the 4th and 5th dimension.     * range - Reset the image range to the min max.  
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: seg_maths im1.nii -bin -odt float im1_bin.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    operation: '"bin"'
+    # type=enum|default='sqrt'|allowed['4to5','abs','bin','concomp26','concomp6','euc','exp','fill','isnan','lconcomp','log','otsu','range','recip','removenan','scl','splitlab','sqrt','subsamp2','tmax','tmean','tmin','tpmax']: Operation to perform:      * sqrt - Square root of the image).     * exp - Exponential root of the image.     * log - Log of the image.     * recip - Reciprocal (1/I) of the image.     * abs - Absolute value of the image.     * bin - Binarise the image.     * otsu - Otsu thresholding of the current image.     * lconcomp - Take the largest connected component     * concomp6 - Label the different connected components with a 6NN kernel     * concomp26 - Label the different connected components with a 26NN kernel     * fill - Fill holes in binary object (e.g. fill ventricle in brain mask).     * euc - Euclidean distance transform     * tpmax - Get the time point with the highest value (binarise 4D probabilities)     * tmean - Mean value of all time points.     * tmax - Max value of all time points.     * tmin - Mean value of all time points.     * splitlab - Split the integer labels into multiple timepoints     * removenan - Remove all NaNs and replace then with 0     * isnan - Binary image equal to 1 if the value is NaN and 0 otherwise     * subsamp2 - Subsample the image by 2 using NN sampling (qform and sform scaled)     * scl  - Reset scale and slope info.     * 4to5 - Flip the 4th and 5th dimension.     * range - Reset the image range to the min max.  
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: seg_maths im1.nii -otsu -odt float im1_otsu.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    operation: '"otsu"'
+    # type=enum|default='sqrt'|allowed['4to5','abs','bin','concomp26','concomp6','euc','exp','fill','isnan','lconcomp','log','otsu','range','recip','removenan','scl','splitlab','sqrt','subsamp2','tmax','tmean','tmin','tpmax']: Operation to perform:      * sqrt - Square root of the image).     * exp - Exponential root of the image.     * log - Log of the image.     * recip - Reciprocal (1/I) of the image.     * abs - Absolute value of the image.     * bin - Binarise the image.     * otsu - Otsu thresholding of the current image.     * lconcomp - Take the largest connected component     * concomp6 - Label the different connected components with a 6NN kernel     * concomp26 - Label the different connected components with a 26NN kernel     * fill - Fill holes in binary object (e.g. fill ventricle in brain mask).     * euc - Euclidean distance transform     * tpmax - Get the time point with the highest value (binarise 4D probabilities)     * tmean - Mean value of all time points.     * tmax - Max value of all time points.     * tmin - Mean value of all time points.     * splitlab - Split the integer labels into multiple timepoints     * removenan - Remove all NaNs and replace then with 0     * isnan - Binary image equal to 1 if the value is NaN and 0 otherwise     * subsamp2 - Subsample the image by 2 using NN sampling (qform and sform scaled)     * scl  - Reset scale and slope info.     * 4to5 - Flip the 4th and 5th dimension.     * range - Reset the image range to the min max.  
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: seg_maths im1.nii -isnan -odt float im1_isnan.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    operation: '"isnan"'
+    # type=enum|default='sqrt'|allowed['4to5','abs','bin','concomp26','concomp6','euc','exp','fill','isnan','lconcomp','log','otsu','range','recip','removenan','scl','splitlab','sqrt','subsamp2','tmax','tmean','tmin','tpmax']: Operation to perform:      * sqrt - Square root of the image).     * exp - Exponential root of the image.     * log - Log of the image.     * recip - Reciprocal (1/I) of the image.     * abs - Absolute value of the image.     * bin - Binarise the image.     * otsu - Otsu thresholding of the current image.     * lconcomp - Take the largest connected component     * concomp6 - Label the different connected components with a 6NN kernel     * concomp26 - Label the different connected components with a 26NN kernel     * fill - Fill holes in binary object (e.g. fill ventricle in brain mask).     * euc - Euclidean distance transform     * tpmax - Get the time point with the highest value (binarise 4D probabilities)     * tmean - Mean value of all time points.     * tmax - Max value of all time points.     * tmin - Mean value of all time points.     * splitlab - Split the integer labels into multiple timepoints     * removenan - Remove all NaNs and replace then with 0     * isnan - Binary image equal to 1 if the value is NaN and 0 otherwise     * subsamp2 - Subsample the image by 2 using NN sampling (qform and sform scaled)     * scl  - Reset scale and slope info.     * 4to5 - Flip the 4th and 5th dimension.     * range - Reset the image range to the min max.  
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-niftyseg/unary_maths_callables.py b/example-specs/task/nipype_internal/pydra-niftyseg/unary_maths_callables.py
new file mode 100644
index 00000000..ae1ae260
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-niftyseg/unary_maths_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in UnaryMaths.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-niftyseg/unary_stats.yaml b/example-specs/task/nipype_internal/pydra-niftyseg/unary_stats.yaml
new file mode 100644
index 00000000..e7f235db
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-niftyseg/unary_stats.yaml
@@ -0,0 +1,217 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.niftyseg.stats.UnaryStats' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Unary statistical operations.
+# 
+#     See Also
+#     --------
+#     `Source code <http://cmictig.cs.ucl.ac.uk/wiki/index.php/NiftySeg>`__ --
+#     `Documentation <http://cmictig.cs.ucl.ac.uk/wiki/index.php/NiftySeg_documentation>`__
+# 
+#     Examples
+#     --------
+#     >>> import copy
+#     >>> from nipype.interfaces import niftyseg
+#     >>> unary = niftyseg.UnaryStats()
+#     >>> unary.inputs.in_file = 'im1.nii'
+# 
+#     >>> # Test v operation
+#     >>> unary_v = copy.deepcopy(unary)
+#     >>> unary_v.inputs.operation = 'v'
+#     >>> unary_v.cmdline
+#     'seg_stats im1.nii -v'
+#     >>> unary_v.run()  # doctest: +SKIP
+# 
+#     >>> # Test vl operation
+#     >>> unary_vl = copy.deepcopy(unary)
+#     >>> unary_vl.inputs.operation = 'vl'
+#     >>> unary_vl.cmdline
+#     'seg_stats im1.nii -vl'
+#     >>> unary_vl.run()  # doctest: +SKIP
+# 
+#     >>> # Test x operation
+#     >>> unary_x = copy.deepcopy(unary)
+#     >>> unary_x.inputs.operation = 'x'
+#     >>> unary_x.cmdline
+#     'seg_stats im1.nii -x'
+#     >>> unary_x.run()  # doctest: +SKIP
+# 
+#     
+task_name: UnaryStats
+nipype_name: UnaryStats
+nipype_module: nipype.interfaces.niftyseg.stats
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: image to operate on
+    mask_file: generic/file
+    # type=file|default=<undefined>: statistics within the masked area
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    operation:
+    # type=enum|default='r'|allowed['B','R','X','a','c','e','n','ne','np','r','s','v','vl','vp','x','xdim','xvox']: Operation to perform:      * r - The range <min max> of all voxels.     * R - The robust range (assuming 2% outliers on both sides) of all voxels     * a - Average of all voxels     * s - Standard deviation of all voxels     * v - Volume of all voxels above 0 (<# voxels> * <volume per voxel>)     * vl - Volume of each integer label (<# voxels per label> x <volume per voxel>)     * vp - Volume of all probabilsitic voxels (sum(<in>) x <volume per voxel>)     * n - Count of all voxels above 0 (<# voxels>)     * np - Sum of all fuzzy voxels (sum(<in>))     * e - Entropy of all voxels     * ne - Normalized entropy of all voxels     * x - Location (i j k x y z) of the smallest value in the image     * X - Location (i j k x y z) of the largest value in the image     * c - Location (i j k x y z) of the centre of mass of the object     * B - Bounding box of all nonzero voxels [ xmin xsize ymin ysize zmin zsize ]     * xvox - Output the number of voxels in the x direction.       Replace x with y/z for other directions.     * xdim - Output the voxel dimension in the x direction.       Replace x with y/z for other directions.  
+    in_file:
+    # type=file|default=<undefined>: image to operate on
+    mask_file:
+    # type=file|default=<undefined>: statistics within the masked area
+    larger_voxel:
+    # type=float|default=0.0: Only estimate statistics if voxel is larger than <float>
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: image to operate on
+    operation: '"v"'
+    # type=enum|default='r'|allowed['B','R','X','a','c','e','n','ne','np','r','s','v','vl','vp','x','xdim','xvox']: Operation to perform:      * r - The range <min max> of all voxels.     * R - The robust range (assuming 2% outliers on both sides) of all voxels     * a - Average of all voxels     * s - Standard deviation of all voxels     * v - Volume of all voxels above 0 (<# voxels> * <volume per voxel>)     * vl - Volume of each integer label (<# voxels per label> x <volume per voxel>)     * vp - Volume of all probabilsitic voxels (sum(<in>) x <volume per voxel>)     * n - Count of all voxels above 0 (<# voxels>)     * np - Sum of all fuzzy voxels (sum(<in>))     * e - Entropy of all voxels     * ne - Normalized entropy of all voxels     * x - Location (i j k x y z) of the smallest value in the image     * X - Location (i j k x y z) of the largest value in the image     * c - Location (i j k x y z) of the centre of mass of the object     * B - Bounding box of all nonzero voxels [ xmin xsize ymin ysize zmin zsize ]     * xvox - Output the number of voxels in the x direction.       Replace x with y/z for other directions.     * xdim - Output the voxel dimension in the x direction.       Replace x with y/z for other directions.  
+  imports: &id001
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  - module: copy
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    operation: '"vl"'
+    # type=enum|default='r'|allowed['B','R','X','a','c','e','n','ne','np','r','s','v','vl','vp','x','xdim','xvox']: Operation to perform:      * r - The range <min max> of all voxels.     * R - The robust range (assuming 2% outliers on both sides) of all voxels     * a - Average of all voxels     * s - Standard deviation of all voxels     * v - Volume of all voxels above 0 (<# voxels> * <volume per voxel>)     * vl - Volume of each integer label (<# voxels per label> x <volume per voxel>)     * vp - Volume of all probabilsitic voxels (sum(<in>) x <volume per voxel>)     * n - Count of all voxels above 0 (<# voxels>)     * np - Sum of all fuzzy voxels (sum(<in>))     * e - Entropy of all voxels     * ne - Normalized entropy of all voxels     * x - Location (i j k x y z) of the smallest value in the image     * X - Location (i j k x y z) of the largest value in the image     * c - Location (i j k x y z) of the centre of mass of the object     * B - Bounding box of all nonzero voxels [ xmin xsize ymin ysize zmin zsize ]     * xvox - Output the number of voxels in the x direction.       Replace x with y/z for other directions.     * xdim - Output the voxel dimension in the x direction.       Replace x with y/z for other directions.  
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    operation: '"x"'
+    # type=enum|default='r'|allowed['B','R','X','a','c','e','n','ne','np','r','s','v','vl','vp','x','xdim','xvox']: Operation to perform:      * r - The range <min max> of all voxels.     * R - The robust range (assuming 2% outliers on both sides) of all voxels     * a - Average of all voxels     * s - Standard deviation of all voxels     * v - Volume of all voxels above 0 (<# voxels> * <volume per voxel>)     * vl - Volume of each integer label (<# voxels per label> x <volume per voxel>)     * vp - Volume of all probabilsitic voxels (sum(<in>) x <volume per voxel>)     * n - Count of all voxels above 0 (<# voxels>)     * np - Sum of all fuzzy voxels (sum(<in>))     * e - Entropy of all voxels     * ne - Normalized entropy of all voxels     * x - Location (i j k x y z) of the smallest value in the image     * X - Location (i j k x y z) of the largest value in the image     * c - Location (i j k x y z) of the centre of mass of the object     * B - Bounding box of all nonzero voxels [ xmin xsize ymin ysize zmin zsize ]     * xvox - Output the number of voxels in the x direction.       Replace x with y/z for other directions.     * xdim - Output the voxel dimension in the x direction.       Replace x with y/z for other directions.  
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: seg_stats im1.nii -v
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: image to operate on
+    operation: '"v"'
+    # type=enum|default='r'|allowed['B','R','X','a','c','e','n','ne','np','r','s','v','vl','vp','x','xdim','xvox']: Operation to perform:      * r - The range <min max> of all voxels.     * R - The robust range (assuming 2% outliers on both sides) of all voxels     * a - Average of all voxels     * s - Standard deviation of all voxels     * v - Volume of all voxels above 0 (<# voxels> * <volume per voxel>)     * vl - Volume of each integer label (<# voxels per label> x <volume per voxel>)     * vp - Volume of all probabilsitic voxels (sum(<in>) x <volume per voxel>)     * n - Count of all voxels above 0 (<# voxels>)     * np - Sum of all fuzzy voxels (sum(<in>))     * e - Entropy of all voxels     * ne - Normalized entropy of all voxels     * x - Location (i j k x y z) of the smallest value in the image     * X - Location (i j k x y z) of the largest value in the image     * c - Location (i j k x y z) of the centre of mass of the object     * B - Bounding box of all nonzero voxels [ xmin xsize ymin ysize zmin zsize ]     * xvox - Output the number of voxels in the x direction.       Replace x with y/z for other directions.     * xdim - Output the voxel dimension in the x direction.       Replace x with y/z for other directions.  
+  imports: *id001
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: seg_stats im1.nii -vl
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    operation: '"vl"'
+    # type=enum|default='r'|allowed['B','R','X','a','c','e','n','ne','np','r','s','v','vl','vp','x','xdim','xvox']: Operation to perform:      * r - The range <min max> of all voxels.     * R - The robust range (assuming 2% outliers on both sides) of all voxels     * a - Average of all voxels     * s - Standard deviation of all voxels     * v - Volume of all voxels above 0 (<# voxels> * <volume per voxel>)     * vl - Volume of each integer label (<# voxels per label> x <volume per voxel>)     * vp - Volume of all probabilsitic voxels (sum(<in>) x <volume per voxel>)     * n - Count of all voxels above 0 (<# voxels>)     * np - Sum of all fuzzy voxels (sum(<in>))     * e - Entropy of all voxels     * ne - Normalized entropy of all voxels     * x - Location (i j k x y z) of the smallest value in the image     * X - Location (i j k x y z) of the largest value in the image     * c - Location (i j k x y z) of the centre of mass of the object     * B - Bounding box of all nonzero voxels [ xmin xsize ymin ysize zmin zsize ]     * xvox - Output the number of voxels in the x direction.       Replace x with y/z for other directions.     * xdim - Output the voxel dimension in the x direction.       Replace x with y/z for other directions.  
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
+- cmdline: seg_stats im1.nii -x
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    operation: '"x"'
+    # type=enum|default='r'|allowed['B','R','X','a','c','e','n','ne','np','r','s','v','vl','vp','x','xdim','xvox']: Operation to perform:      * r - The range <min max> of all voxels.     * R - The robust range (assuming 2% outliers on both sides) of all voxels     * a - Average of all voxels     * s - Standard deviation of all voxels     * v - Volume of all voxels above 0 (<# voxels> * <volume per voxel>)     * vl - Volume of each integer label (<# voxels per label> x <volume per voxel>)     * vp - Volume of all probabilsitic voxels (sum(<in>) x <volume per voxel>)     * n - Count of all voxels above 0 (<# voxels>)     * np - Sum of all fuzzy voxels (sum(<in>))     * e - Entropy of all voxels     * ne - Normalized entropy of all voxels     * x - Location (i j k x y z) of the smallest value in the image     * X - Location (i j k x y z) of the largest value in the image     * c - Location (i j k x y z) of the centre of mass of the object     * B - Bounding box of all nonzero voxels [ xmin xsize ymin ysize zmin zsize ]     * xvox - Output the number of voxels in the x direction.       Replace x with y/z for other directions.     * xdim - Output the voxel dimension in the x direction.       Replace x with y/z for other directions.  
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-niftyseg/unary_stats_callables.py b/example-specs/task/nipype_internal/pydra-niftyseg/unary_stats_callables.py
new file mode 100644
index 00000000..6a045e76
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-niftyseg/unary_stats_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in UnaryStats.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-nilearn/nilearn_base_interface.yaml b/example-specs/task/nipype_internal/pydra-nilearn/nilearn_base_interface.yaml
new file mode 100644
index 00000000..b724a38c
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-nilearn/nilearn_base_interface.yaml
@@ -0,0 +1,62 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.nilearn.NilearnBaseInterface' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+task_name: NilearnBaseInterface
+nipype_name: NilearnBaseInterface
+nipype_module: nipype.interfaces.nilearn
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-nilearn/nilearn_base_interface_callables.py b/example-specs/task/nipype_internal/pydra-nilearn/nilearn_base_interface_callables.py
new file mode 100644
index 00000000..92f926a6
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-nilearn/nilearn_base_interface_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in NilearnBaseInterface.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-nilearn/signal_extraction.yaml b/example-specs/task/nipype_internal/pydra-nilearn/signal_extraction.yaml
new file mode 100644
index 00000000..84a56847
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-nilearn/signal_extraction.yaml
@@ -0,0 +1,98 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.nilearn.SignalExtraction' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Extracts signals over tissue classes or brain regions
+# 
+#     >>> seinterface = SignalExtraction()
+#     >>> seinterface.inputs.in_file = 'functional.nii'
+#     >>> seinterface.inputs.label_files = 'segmentation0.nii.gz'
+#     >>> seinterface.inputs.out_file = 'means.tsv'
+#     >>> segments = ['CSF', 'GrayMatter', 'WhiteMatter']
+#     >>> seinterface.inputs.class_labels = segments
+#     >>> seinterface.inputs.detrend = True
+#     >>> seinterface.inputs.include_global = True
+#     
+task_name: SignalExtraction
+nipype_name: SignalExtraction
+nipype_module: nipype.interfaces.nilearn
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: 4-D fMRI nii file
+    label_files: generic/file+list-of
+    # type=inputmultiobject|default=[]: a 3-D label image, with 0 denoting background, or a list of 3-D probability maps (one per label) or the equivalent 4D file.
+    out_file: generic/file
+    # type=file: tsv file containing the computed signals, with as many columns as there are labels and as many rows as there are timepoints in in_file, plus a header row with values from class_labels
+    # type=file|default='signals.tsv': The name of the file to output to. signals.tsv by default
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: tsv file containing the computed signals, with as many columns as there are labels and as many rows as there are timepoints in in_file, plus a header row with values from class_labels
+    # type=file|default='signals.tsv': The name of the file to output to. signals.tsv by default
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: 4-D fMRI nii file
+    label_files:
+    # type=inputmultiobject|default=[]: a 3-D label image, with 0 denoting background, or a list of 3-D probability maps (one per label) or the equivalent 4D file.
+    class_labels:
+    # type=list|default=[]: Human-readable labels for each segment in the label file, in order. The length of class_labels must be equal to the number of segments (background excluded). This list corresponds to the class labels in label_file in ascending order
+    out_file:
+    # type=file: tsv file containing the computed signals, with as many columns as there are labels and as many rows as there are timepoints in in_file, plus a header row with values from class_labels
+    # type=file|default='signals.tsv': The name of the file to output to. signals.tsv by default
+    incl_shared_variance:
+    # type=bool|default=True: By default (True), returns simple time series calculated from each region independently (e.g., for noise regression). If False, returns unique signals for each region, discarding shared variance (e.g., for connectivity. Only has effect with 4D probability maps.
+    include_global:
+    # type=bool|default=False: If True, include an extra column labeled "GlobalSignal", with values calculated from the entire brain (instead of just regions).
+    detrend:
+    # type=bool|default=False: If True, perform detrending using nilearn.
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-nilearn/signal_extraction_callables.py b/example-specs/task/nipype_internal/pydra-nilearn/signal_extraction_callables.py
new file mode 100644
index 00000000..d1ae6627
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-nilearn/signal_extraction_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in SignalExtraction.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-nitime/coherence_analyzer.yaml b/example-specs/task/nipype_internal/pydra-nitime/coherence_analyzer.yaml
new file mode 100644
index 00000000..83ec4c22
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-nitime/coherence_analyzer.yaml
@@ -0,0 +1,94 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.nitime.analysis.CoherenceAnalyzer' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Wraps nitime.analysis.CoherenceAnalyzer: Coherence/y
+task_name: CoherenceAnalyzer
+nipype_name: CoherenceAnalyzer
+nipype_module: nipype.interfaces.nitime.analysis
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: csv file with ROIs on the columns and time-points on the rows. ROI names at the top row
+    output_csv_file: generic/file
+    # type=file|default=<undefined>: File to write outputs (coherence,time-delay) with file-names: ``file_name_{coherence,timedelay}``
+    output_figure_file: generic/file
+    # type=file|default=<undefined>: File to write output figures (coherence,time-delay) with file-names: ``file_name_{coherence,timedelay}``. Possible formats: .png,.svg,.pdf,.jpg,...
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    coherence_csv: generic/file
+    # type=file: A csv file containing the pairwise  coherence values
+    timedelay_csv: generic/file
+    # type=file: A csv file containing the pairwise time delay values
+    coherence_fig: generic/file
+    # type=file: Figure representing coherence values
+    timedelay_fig: generic/file
+    # type=file: Figure representing coherence values
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: csv file with ROIs on the columns and time-points on the rows. ROI names at the top row
+    TR:
+    # type=float|default=0.0: The TR used to collect the data in your csv file <in_file>
+    in_TS:
+    # type=any|default=None: a nitime TimeSeries object
+    NFFT:
+    # type=range|default=64: This is the size of the window used for the spectral estimation. Use values between 32 and the number of samples in your time-series.(Defaults to 64.)
+    n_overlap:
+    # type=range|default=0: The number of samples which overlapbetween subsequent windows.(Defaults to 0)
+    frequency_range:
+    # type=list|default=[0.02, 0.15]: The range of frequencies overwhich the analysis will average.[low,high] (Default [0.02,0.15]
+    output_csv_file:
+    # type=file|default=<undefined>: File to write outputs (coherence,time-delay) with file-names: ``file_name_{coherence,timedelay}``
+    output_figure_file:
+    # type=file|default=<undefined>: File to write output figures (coherence,time-delay) with file-names: ``file_name_{coherence,timedelay}``. Possible formats: .png,.svg,.pdf,.jpg,...
+    figure_type:
+    # type=enum|default='matrix'|allowed['matrix','network']: The type of plot to generate, where 'matrix' denotes a matrix image and'network' denotes a graph representation. Default: 'matrix'
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-nitime/coherence_analyzer_callables.py b/example-specs/task/nipype_internal/pydra-nitime/coherence_analyzer_callables.py
new file mode 100644
index 00000000..f81d3da2
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-nitime/coherence_analyzer_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in CoherenceAnalyzer.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-petpvc/petpvc.yaml b/example-specs/task/nipype_internal/pydra-petpvc/petpvc.yaml
new file mode 100644
index 00000000..9d536425
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-petpvc/petpvc.yaml
@@ -0,0 +1,128 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.petpvc.PETPVC' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Use PETPVC for partial volume correction of PET images.
+# 
+#     PETPVC ([1]_, [2]_) is a software from the Nuclear Medicine Department
+#     of the UCL University Hospital, London, UK.
+# 
+#     Examples
+#     --------
+#     >>> from ..testing import example_data
+#     >>> #TODO get data for PETPVC
+#     >>> pvc = PETPVC()
+#     >>> pvc.inputs.in_file   = 'pet.nii.gz'
+#     >>> pvc.inputs.mask_file = 'tissues.nii.gz'
+#     >>> pvc.inputs.out_file  = 'pet_pvc_rbv.nii.gz'
+#     >>> pvc.inputs.pvc = 'RBV'
+#     >>> pvc.inputs.fwhm_x = 2.0
+#     >>> pvc.inputs.fwhm_y = 2.0
+#     >>> pvc.inputs.fwhm_z = 2.0
+#     >>> outs = pvc.run() #doctest: +SKIP
+# 
+#     References
+#     ----------
+#     .. [1] K. Erlandsson, I. Buvat, P. H. Pretorius, B. A. Thomas, and B. F. Hutton,
+#            "A review of partial volume correction techniques for emission tomography
+#            and their applications in neurology, cardiology and oncology," Phys. Med.
+#            Biol., vol. 57, no. 21, p. R119, 2012.
+#     .. [2] https://github.com/UCL/PETPVC
+# 
+#     
+task_name: PETPVC
+nipype_name: PETPVC
+nipype_module: nipype.interfaces.petpvc
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: PET image file
+    mask_file: generic/file
+    # type=file|default=<undefined>: Mask image file
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: Output file
+    # type=file|default=<undefined>: Output file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: out_file
+    # type=file: Output file
+    # type=file|default=<undefined>: Output file
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: PET image file
+    out_file:
+    # type=file: Output file
+    # type=file|default=<undefined>: Output file
+    mask_file:
+    # type=file|default=<undefined>: Mask image file
+    pvc:
+    # type=enum|default='GTM'|allowed['GTM','IY','IY+RL','IY+VC','LABBE','LABBE+MTC','LABBE+MTC+RL','LABBE+MTC+VC','LABBE+RBV','LABBE+RBV+RL','LABBE+RBV+VC','MG','MG+RL','MG+VC','MTC','MTC+RL','MTC+VC','RBV','RBV+RL','RBV+VC','RL','VC']: Desired PVC method:      * Geometric transfer matrix -- ``GTM``     * Labbe approach -- ``LABBE``     * Richardson-Lucy -- ``RL``     * Van-Cittert -- ``VC``     * Region-based voxel-wise correction -- ``RBV``     * RBV with Labbe -- ``LABBE+RBV``     * RBV with Van-Cittert -- ``RBV+VC``     * RBV with Richardson-Lucy -- ``RBV+RL``     * RBV with Labbe and Van-Cittert -- ``LABBE+RBV+VC``     * RBV with Labbe and Richardson-Lucy -- ``LABBE+RBV+RL``     * Multi-target correction -- ``MTC``     * MTC with Labbe -- ``LABBE+MTC``     * MTC with Van-Cittert -- ``MTC+VC``     * MTC with Richardson-Lucy -- ``MTC+RL``     * MTC with Labbe and Van-Cittert -- ``LABBE+MTC+VC``     * MTC with Labbe and Richardson-Lucy -- ``LABBE+MTC+RL``     * Iterative Yang -- ``IY``     * Iterative Yang with Van-Cittert -- ``IY+VC``     * Iterative Yang with Richardson-Lucy -- ``IY+RL``     * Muller Gartner -- ``MG``     * Muller Gartner with Van-Cittert -- ``MG+VC``     * Muller Gartner with Richardson-Lucy -- ``MG+RL``  
+    fwhm_x:
+    # type=float|default=0.0: The full-width at half maximum in mm along x-axis
+    fwhm_y:
+    # type=float|default=0.0: The full-width at half maximum in mm along y-axis
+    fwhm_z:
+    # type=float|default=0.0: The full-width at half maximum in mm along z-axis
+    debug:
+    # type=bool|default=False: Prints debug information
+    n_iter:
+    # type=int|default=10: Number of iterations
+    n_deconv:
+    # type=int|default=10: Number of deconvolution iterations
+    alpha:
+    # type=float|default=1.5: Alpha value
+    stop_crit:
+    # type=float|default=0.01: Stopping criterion
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-petpvc/petpvc_callables.py b/example-specs/task/nipype_internal/pydra-petpvc/petpvc_callables.py
new file mode 100644
index 00000000..4316b213
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-petpvc/petpvc_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in PETPVC.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-quickshear/quickshear.yaml b/example-specs/task/nipype_internal/pydra-quickshear/quickshear.yaml
new file mode 100644
index 00000000..fcd5f5ee
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-quickshear/quickshear.yaml
@@ -0,0 +1,155 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.quickshear.Quickshear' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Quickshear is a simple geometric defacing algorithm
+# 
+#     Given an anatomical image and a reasonable brainmask, Quickshear estimates
+#     a shearing plane with the brain mask on one side and the face on the other,
+#     zeroing out the face side.
+# 
+#     >>> from nipype.interfaces.quickshear import Quickshear
+#     >>> qs = Quickshear(in_file='T1.nii', mask_file='brain_mask.nii')
+#     >>> qs.cmdline
+#     'quickshear T1.nii brain_mask.nii T1_defaced.nii'
+# 
+#     In the absence of a precomputed mask, a simple pipeline can be generated
+#     with any tool that generates brain masks:
+# 
+#     >>> from nipype.pipeline import engine as pe
+#     >>> from nipype.interfaces import utility as niu
+#     >>> from nipype.interfaces.fsl import BET
+#     >>> deface_wf = pe.Workflow('deface_wf')
+#     >>> inputnode = pe.Node(niu.IdentityInterface(['in_file']),
+#     ...                     name='inputnode')
+#     >>> outputnode = pe.Node(niu.IdentityInterface(['out_file']),
+#     ...                      name='outputnode')
+#     >>> bet = pe.Node(BET(mask=True), name='bet')
+#     >>> quickshear = pe.Node(Quickshear(), name='quickshear')
+#     >>> deface_wf.connect([
+#     ...     (inputnode, bet, [('in_file', 'in_file')]),
+#     ...     (inputnode, quickshear, [('in_file', 'in_file')]),
+#     ...     (bet, quickshear, [('mask_file', 'mask_file')]),
+#     ...     (quickshear, outputnode, [('out_file', 'out_file')]),
+#     ...     ])
+#     >>> inputnode.inputs.in_file = 'T1.nii'
+#     >>> res = deface_wf.run()  # doctest: +SKIP
+#     
+task_name: Quickshear
+nipype_name: Quickshear
+nipype_module: nipype.interfaces.quickshear
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: neuroimage to deface
+    mask_file: medimage/nifti1
+    # type=file|default=<undefined>: brain mask
+    out_file: generic/file
+    # type=file: defaced output image
+    # type=file|default=<undefined>: defaced output image
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: defaced output image
+    # type=file|default=<undefined>: defaced output image
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: neuroimage to deface
+    mask_file:
+    # type=file|default=<undefined>: brain mask
+    out_file:
+    # type=file: defaced output image
+    # type=file|default=<undefined>: defaced output image
+    buff:
+    # type=int|default=0: buffer size (in voxels) between shearing plane and the brain
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: neuroimage to deface
+    mask_file:
+    # type=file|default=<undefined>: brain mask
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: quickshear T1.nii brain_mask.nii T1_defaced.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: neuroimage to deface
+    mask_file:
+    # type=file|default=<undefined>: brain mask
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-quickshear/quickshear_callables.py b/example-specs/task/nipype_internal/pydra-quickshear/quickshear_callables.py
new file mode 100644
index 00000000..a744f4a7
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-quickshear/quickshear_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Quickshear.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-robex/robex_segment.yaml b/example-specs/task/nipype_internal/pydra-robex/robex_segment.yaml
new file mode 100644
index 00000000..1e7314a5
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-robex/robex_segment.yaml
@@ -0,0 +1,142 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.robex.preprocess.RobexSegment' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+# 
+#     ROBEX is an automatic whole-brain extraction tool for T1-weighted MRI data (commonly known as skull stripping).
+#     ROBEX aims for robust skull-stripping across datasets with no parameter settings. It fits a triangular mesh,
+#     constrained by a shape model, to the probabilistic output of a supervised brain boundary classifier.
+#     Because the shape model cannot perfectly accommodate unseen cases, a small free deformation is subsequently allowed.
+#     The deformation is optimized using graph cuts.
+#     The method ROBEX is based on was published in IEEE Transactions on Medical Imaging;
+#     please visit the website http://www.jeiglesias.com to download the paper.
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces.robex.preprocess import RobexSegment
+#     >>> robex = RobexSegment()
+#     >>> robex.inputs.in_file = 'structural.nii'
+#     >>> robex.cmdline
+#     'runROBEX.sh structural.nii structural_brain.nii structural_brainmask.nii'
+#     >>> robex.run() # doctest: +SKIP
+# 
+#     
+task_name: RobexSegment
+nipype_name: RobexSegment
+nipype_module: nipype.interfaces.robex.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: Input volume
+    out_file: generic/file
+    # type=file: Output volume
+    # type=file|default=<undefined>: Output volume
+    out_mask: generic/file
+    # type=file: Output mask
+    # type=file|default=<undefined>: Output mask
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: Output volume
+    # type=file|default=<undefined>: Output volume
+    out_mask: generic/file
+    # type=file: Output mask
+    # type=file|default=<undefined>: Output mask
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: Input volume
+    out_file:
+    # type=file: Output volume
+    # type=file|default=<undefined>: Output volume
+    out_mask:
+    # type=file: Output mask
+    # type=file|default=<undefined>: Output mask
+    seed:
+    # type=int|default=0: Seed for random number generator
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: Input volume
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: runROBEX.sh structural.nii structural_brain.nii structural_brainmask.nii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: Input volume
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-robex/robex_segment_callables.py b/example-specs/task/nipype_internal/pydra-robex/robex_segment_callables.py
new file mode 100644
index 00000000..392f200a
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-robex/robex_segment_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in RobexSegment.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/binary_mask_editor_based_on_landmarks.yaml b/example-specs/task/nipype_internal/pydra-semtools/binary_mask_editor_based_on_landmarks.yaml
new file mode 100644
index 00000000..ed03737f
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/binary_mask_editor_based_on_landmarks.yaml
@@ -0,0 +1,95 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.segmentation.specialized.BinaryMaskEditorBasedOnLandmarks' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: BRAINS Binary Mask Editor Based On Landmarks(BRAINS)
+# 
+#     category: Segmentation.Specialized
+# 
+#     version: 1.0
+# 
+#     documentation-url: http://www.nitrc.org/projects/brainscdetector/
+#     
+task_name: BinaryMaskEditorBasedOnLandmarks
+nipype_name: BinaryMaskEditorBasedOnLandmarks
+nipype_module: nipype.interfaces.semtools.segmentation.specialized
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputBinaryVolume: generic/file
+    # type=file|default=<undefined>: Input binary image in which to be edited
+    inputLandmarksFilename: generic/file
+    # type=file|default=<undefined>:  The filename for the  landmark definition file in the same format produced by Slicer3 (.fcsv). 
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputBinaryVolume: generic/file
+    # type=file: Output binary image in which to be edited
+    # type=traitcompound|default=None: Output binary image in which to be edited
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputBinaryVolume:
+    # type=file|default=<undefined>: Input binary image in which to be edited
+    outputBinaryVolume:
+    # type=file: Output binary image in which to be edited
+    # type=traitcompound|default=None: Output binary image in which to be edited
+    inputLandmarksFilename:
+    # type=file|default=<undefined>:  The filename for the  landmark definition file in the same format produced by Slicer3 (.fcsv). 
+    inputLandmarkNames:
+    # type=inputmultiobject|default=[]:  A target input landmark name to be edited. This should be listed in the inputLandmakrFilename Given. 
+    setCutDirectionForLandmark:
+    # type=inputmultiobject|default=[]: Setting the cutting out direction of the input binary image to the one of anterior, posterior, left, right, superior or posterior. (ENUMERATION: ANTERIOR, POSTERIOR, LEFT, RIGHT, SUPERIOR, POSTERIOR) 
+    setCutDirectionForObliquePlane:
+    # type=inputmultiobject|default=[]: If this is true, the mask will be thresholded out to the direction of inferior, posterior,  and/or left. Default behavrior is that cutting out to the direction of superior, anterior and/or right. 
+    inputLandmarkNamesForObliquePlane:
+    # type=inputmultiobject|default=[]:  Three subset landmark names of inputLandmarksFilename for a oblique plane computation. The plane computed for binary volume editing. 
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/binary_mask_editor_based_on_landmarks_callables.py b/example-specs/task/nipype_internal/pydra-semtools/binary_mask_editor_based_on_landmarks_callables.py
new file mode 100644
index 00000000..efbeba26
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/binary_mask_editor_based_on_landmarks_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in BinaryMaskEditorBasedOnLandmarks.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_align_msp.yaml b/example-specs/task/nipype_internal/pydra-semtools/brains_align_msp.yaml
new file mode 100644
index 00000000..6606334f
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/brains_align_msp.yaml
@@ -0,0 +1,105 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.utilities.brains.BRAINSAlignMSP' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Align Mid Sagittal Brain (BRAINS)
+# 
+#     category: Utilities.BRAINS
+# 
+#     description: Resample an image into ACPC alignment ACPCDetect
+#     
+task_name: BRAINSAlignMSP
+nipype_name: BRAINSAlignMSP
+nipype_module: nipype.interfaces.semtools.utilities.brains
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputVolume: generic/file
+    # type=file|default=<undefined>: ,         The Image to be resampled,       
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    OutputresampleMSP: generic/file
+    # type=file: ,         The image to be output.,       
+    # type=traitcompound|default=None: ,         The image to be output.,       
+    resultsDir: generic/directory
+    # type=directory: ,         The directory for the results to be written.,       
+    # type=traitcompound|default=None: ,         The directory for the results to be written.,       
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputVolume:
+    # type=file|default=<undefined>: ,         The Image to be resampled,       
+    OutputresampleMSP:
+    # type=file: ,         The image to be output.,       
+    # type=traitcompound|default=None: ,         The image to be output.,       
+    verbose:
+    # type=bool|default=False: ,         Show more verbose output,       
+    resultsDir:
+    # type=directory: ,         The directory for the results to be written.,       
+    # type=traitcompound|default=None: ,         The directory for the results to be written.,       
+    writedebuggingImagesLevel:
+    # type=int|default=0: ,           This flag controls if debugging images are produced.  By default value of 0 is no images.  Anything greater than zero will be increasing level of debugging images.,       
+    mspQualityLevel:
+    # type=int|default=0: ,           Flag controls how aggressive the MSP is estimated.  0=quick estimate (9 seconds), 1=normal estimate (11 seconds), 2=great estimate (22 seconds), 3=best estimate (58 seconds).,       
+    rescaleIntensities:
+    # type=bool|default=False: ,           Flag to turn on rescaling image intensities on input.,       
+    trimRescaledIntensities:
+    # type=float|default=0.0: ,           Turn on clipping the rescaled image one-tailed on input.  Units of standard deviations above the mean.  Very large values are very permissive.  Non-positive value turns clipping off.  Defaults to removing 0.00001 of a normal tail above the mean.,       
+    rescaleIntensitiesOutputRange:
+    # type=inputmultiobject|default=[]: ,           This pair of integers gives the lower and upper bounds on the signal portion of the output image.  Out-of-field voxels are taken from BackgroundFillValue.,       
+    BackgroundFillValue:
+    # type=str|default='': Fill the background of image with specified short int value. Enter number or use BIGNEG for a large negative number.
+    interpolationMode:
+    # type=enum|default='NearestNeighbor'|allowed['BSpline','Blackman','Cosine','Hamming','Lanczos','Linear','NearestNeighbor','ResampleInPlace','Welch','WindowedSinc']: Type of interpolation to be used when applying transform to moving volume.  Options are Linear, ResampleInPlace, NearestNeighbor, BSpline, or WindowedSinc
+    numberOfThreads:
+    # type=int|default=0: Explicitly specify the maximum number of threads to use.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_align_msp_callables.py b/example-specs/task/nipype_internal/pydra-semtools/brains_align_msp_callables.py
new file mode 100644
index 00000000..40de2170
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/brains_align_msp_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in BRAINSAlignMSP.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_clip_inferior.yaml b/example-specs/task/nipype_internal/pydra-semtools/brains_clip_inferior.yaml
new file mode 100644
index 00000000..7e69e03f
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/brains_clip_inferior.yaml
@@ -0,0 +1,89 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.utilities.brains.BRAINSClipInferior' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Clip Inferior of Center of Brain (BRAINS)
+# 
+#     category: Utilities.BRAINS
+# 
+#     description: This program will read the inputVolume as a short int image, write the BackgroundFillValue everywhere inferior to the lower bound, and write the resulting clipped short int image in the outputVolume.
+# 
+#     version: 1.0
+#     
+task_name: BRAINSClipInferior
+nipype_name: BRAINSClipInferior
+nipype_module: nipype.interfaces.semtools.utilities.brains
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputVolume: generic/file
+    # type=file|default=<undefined>: Input image to make a clipped short int copy from.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputVolume: generic/file
+    # type=file: Output image, a short int copy of the upper portion of the input image, filled with BackgroundFillValue.
+    # type=traitcompound|default=None: Output image, a short int copy of the upper portion of the input image, filled with BackgroundFillValue.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputVolume:
+    # type=file|default=<undefined>: Input image to make a clipped short int copy from.
+    outputVolume:
+    # type=file: Output image, a short int copy of the upper portion of the input image, filled with BackgroundFillValue.
+    # type=traitcompound|default=None: Output image, a short int copy of the upper portion of the input image, filled with BackgroundFillValue.
+    acLowerBound:
+    # type=float|default=0.0: ,                 When the input image to the output image, replace the image with the BackgroundFillValue everywhere below the plane This Far in physical units (millimeters) below (inferior to) the AC point (assumed to be the voxel field middle.)  The oversize default was chosen to have no effect.  Based on visualizing a thousand masks in the IPIG study, we recommend a limit no smaller than 80.0 mm.,             
+    BackgroundFillValue:
+    # type=str|default='': Fill the background of image with specified short int value. Enter number or use BIGNEG for a large negative number.
+    numberOfThreads:
+    # type=int|default=0: Explicitly specify the maximum number of threads to use.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_clip_inferior_callables.py b/example-specs/task/nipype_internal/pydra-semtools/brains_clip_inferior_callables.py
new file mode 100644
index 00000000..c06f5275
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/brains_clip_inferior_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in BRAINSClipInferior.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_constellation_detector.yaml b/example-specs/task/nipype_internal/pydra-semtools/brains_constellation_detector.yaml
new file mode 100644
index 00000000..85de538d
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/brains_constellation_detector.yaml
@@ -0,0 +1,209 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.segmentation.specialized.BRAINSConstellationDetector' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Brain Landmark Constellation Detector (BRAINS)
+# 
+#     category: Segmentation.Specialized
+# 
+#     description: This program will find the mid-sagittal plane, a constellation of landmarks in a volume, and create an AC/PC aligned data set with the AC point at the center of the voxel lattice (labeled at the origin of the image physical space.)  Part of this work is an extension of the algorithms originally described by Dr. Babak A. Ardekani, Alvin H. Bachman, Model-based automatic detection of the anterior and posterior commissures on MRI scans, NeuroImage, Volume 46, Issue 3, 1 July 2009, Pages 677-682, ISSN 1053-8119, DOI: 10.1016/j.neuroimage.2009.02.030.  (http://www.sciencedirect.com/science/article/B6WNP-4VRP25C-4/2/8207b962a38aa83c822c6379bc43fe4c)
+# 
+#     version: 1.0
+# 
+#     documentation-url: http://www.nitrc.org/projects/brainscdetector/
+#     
+task_name: BRAINSConstellationDetector
+nipype_name: BRAINSConstellationDetector
+nipype_module: nipype.interfaces.semtools.segmentation.specialized
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputTemplateModel: generic/file
+    # type=file|default=<undefined>: User-specified template model.,             
+    LLSModel: generic/file
+    # type=file|default=<undefined>: Linear least squares model filename in HD5 format
+    inputVolume: generic/file
+    # type=file|default=<undefined>: Input image in which to find ACPC points
+    inputLandmarksEMSP: generic/file
+    # type=file|default=<undefined>: ,               The filename for the new subject-specific landmark definition file in the same format produced by Slicer3 (in .fcsv) with the landmarks in the estimated MSP aligned space to be loaded. The detector will only process landmarks not enlisted on the file.,             
+    atlasVolume: generic/file
+    # type=file|default=<undefined>: Atlas volume image to be used for BRAINSFit registration
+    atlasLandmarks: generic/file
+    # type=file|default=<undefined>: Atlas landmarks to be used for BRAINSFit registration initialization,             
+    atlasLandmarkWeights: generic/file
+    # type=file|default=<undefined>: Weights associated with atlas landmarks to be used for BRAINSFit registration initialization,             
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputVolume: generic/file
+    # type=file: ACPC-aligned output image with the same voxels, but updated origin, and direction cosign so that the AC point would fall at the physical location (0.0,0.0,0.0), and the mid-sagital plane is the plane where physical L/R coordinate is 0.0.
+    # type=traitcompound|default=None: ACPC-aligned output image with the same voxels, but updated origin, and direction cosign so that the AC point would fall at the physical location (0.0,0.0,0.0), and the mid-sagital plane is the plane where physical L/R coordinate is 0.0.
+    outputResampledVolume: generic/file
+    # type=file: ACPC-aligned output image in a resampled unifor space.  Currently this is a 1mm, 256^3, Identity direction image.
+    # type=traitcompound|default=None: ACPC-aligned output image in a resampled unifor space.  Currently this is a 1mm, 256^3, Identity direction image.
+    outputTransform: generic/file
+    # type=file: The filename for the original space to ACPC alignment to be written (in .h5 format).,             
+    # type=traitcompound|default=None: The filename for the original space to ACPC alignment to be written (in .h5 format).,             
+    outputLandmarksInInputSpace: generic/file
+    # type=file: ,               The filename for the new subject-specific landmark definition file in the same format produced by Slicer3 (.fcsv) with the landmarks in the original image space (the detected RP, AC, PC, and VN4) in it to be written.,             
+    # type=traitcompound|default=None: ,               The filename for the new subject-specific landmark definition file in the same format produced by Slicer3 (.fcsv) with the landmarks in the original image space (the detected RP, AC, PC, and VN4) in it to be written.,             
+    outputLandmarksInACPCAlignedSpace: generic/file
+    # type=file: ,               The filename for the new subject-specific landmark definition file in the same format produced by Slicer3 (.fcsv) with the landmarks in the output image space (the detected RP, AC, PC, and VN4) in it to be written.,             
+    # type=traitcompound|default=None: ,               The filename for the new subject-specific landmark definition file in the same format produced by Slicer3 (.fcsv) with the landmarks in the output image space (the detected RP, AC, PC, and VN4) in it to be written.,             
+    outputMRML: generic/file
+    # type=file: ,               The filename for the new subject-specific scene definition file in the same format produced by Slicer3 (in .mrml format). Only the components that were specified by the user on command line would be generated. Compatible components include inputVolume, outputVolume, outputLandmarksInInputSpace, outputLandmarksInACPCAlignedSpace, and outputTransform.,             
+    # type=traitcompound|default=None: ,               The filename for the new subject-specific scene definition file in the same format produced by Slicer3 (in .mrml format). Only the components that were specified by the user on command line would be generated. Compatible components include inputVolume, outputVolume, outputLandmarksInInputSpace, outputLandmarksInACPCAlignedSpace, and outputTransform.,             
+    outputVerificationScript: generic/file
+    # type=file: ,               The filename for the Slicer3 script that verifies the aligned landmarks against the aligned image file.  This will happen only in conjunction with saveOutputLandmarks and an outputVolume.,             
+    # type=traitcompound|default=None: ,               The filename for the Slicer3 script that verifies the aligned landmarks against the aligned image file.  This will happen only in conjunction with saveOutputLandmarks and an outputVolume.,             
+    outputUntransformedClippedVolume: generic/file
+    # type=file: Output image in which to store neck-clipped input image, with the use of --acLowerBound and maybe --cutOutHeadInUntransformedVolume.
+    # type=traitcompound|default=None: Output image in which to store neck-clipped input image, with the use of --acLowerBound and maybe --cutOutHeadInUntransformedVolume.
+    writeBranded2DImage: generic/file
+    # type=file: ,               The filename for the 2D .png branded midline debugging image.  This will happen only in conjunction with requesting an outputVolume.,             
+    # type=traitcompound|default=None: ,               The filename for the 2D .png branded midline debugging image.  This will happen only in conjunction with requesting an outputVolume.,             
+    resultsDir: generic/directory
+    # type=directory: ,               The directory for the debugging images to be written.,             
+    # type=traitcompound|default=None: ,               The directory for the debugging images to be written.,             
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    houghEyeDetectorMode:
+    # type=int|default=0: ,                 This flag controls the mode of Hough eye detector.  By default, value of 1 is for T1W images, while the value of 0 is for T2W and PD images.,             
+    inputTemplateModel:
+    # type=file|default=<undefined>: User-specified template model.,             
+    LLSModel:
+    # type=file|default=<undefined>: Linear least squares model filename in HD5 format
+    inputVolume:
+    # type=file|default=<undefined>: Input image in which to find ACPC points
+    outputVolume:
+    # type=file: ACPC-aligned output image with the same voxels, but updated origin, and direction cosign so that the AC point would fall at the physical location (0.0,0.0,0.0), and the mid-sagital plane is the plane where physical L/R coordinate is 0.0.
+    # type=traitcompound|default=None: ACPC-aligned output image with the same voxels, but updated origin, and direction cosign so that the AC point would fall at the physical location (0.0,0.0,0.0), and the mid-sagital plane is the plane where physical L/R coordinate is 0.0.
+    outputResampledVolume:
+    # type=file: ACPC-aligned output image in a resampled unifor space.  Currently this is a 1mm, 256^3, Identity direction image.
+    # type=traitcompound|default=None: ACPC-aligned output image in a resampled unifor space.  Currently this is a 1mm, 256^3, Identity direction image.
+    outputTransform:
+    # type=file: The filename for the original space to ACPC alignment to be written (in .h5 format).,             
+    # type=traitcompound|default=None: The filename for the original space to ACPC alignment to be written (in .h5 format).,             
+    outputLandmarksInInputSpace:
+    # type=file: ,               The filename for the new subject-specific landmark definition file in the same format produced by Slicer3 (.fcsv) with the landmarks in the original image space (the detected RP, AC, PC, and VN4) in it to be written.,             
+    # type=traitcompound|default=None: ,               The filename for the new subject-specific landmark definition file in the same format produced by Slicer3 (.fcsv) with the landmarks in the original image space (the detected RP, AC, PC, and VN4) in it to be written.,             
+    outputLandmarksInACPCAlignedSpace:
+    # type=file: ,               The filename for the new subject-specific landmark definition file in the same format produced by Slicer3 (.fcsv) with the landmarks in the output image space (the detected RP, AC, PC, and VN4) in it to be written.,             
+    # type=traitcompound|default=None: ,               The filename for the new subject-specific landmark definition file in the same format produced by Slicer3 (.fcsv) with the landmarks in the output image space (the detected RP, AC, PC, and VN4) in it to be written.,             
+    outputMRML:
+    # type=file: ,               The filename for the new subject-specific scene definition file in the same format produced by Slicer3 (in .mrml format). Only the components that were specified by the user on command line would be generated. Compatible components include inputVolume, outputVolume, outputLandmarksInInputSpace, outputLandmarksInACPCAlignedSpace, and outputTransform.,             
+    # type=traitcompound|default=None: ,               The filename for the new subject-specific scene definition file in the same format produced by Slicer3 (in .mrml format). Only the components that were specified by the user on command line would be generated. Compatible components include inputVolume, outputVolume, outputLandmarksInInputSpace, outputLandmarksInACPCAlignedSpace, and outputTransform.,             
+    outputVerificationScript:
+    # type=file: ,               The filename for the Slicer3 script that verifies the aligned landmarks against the aligned image file.  This will happen only in conjunction with saveOutputLandmarks and an outputVolume.,             
+    # type=traitcompound|default=None: ,               The filename for the Slicer3 script that verifies the aligned landmarks against the aligned image file.  This will happen only in conjunction with saveOutputLandmarks and an outputVolume.,             
+    mspQualityLevel:
+    # type=int|default=0: ,                 Flag controls how aggressive the MSP is estimated. 0=quick estimate (9 seconds), 1=normal estimate (11 seconds), 2=great estimate (22 seconds), 3=best estimate (58 seconds), NOTE: -1= Prealigned so no estimate!.,             
+    otsuPercentileThreshold:
+    # type=float|default=0.0: ,                 This is a parameter to FindLargestForegroundFilledMask, which is employed when acLowerBound is set and an outputUntransformedClippedVolume is requested.,             
+    acLowerBound:
+    # type=float|default=0.0: ,                 When generating a resampled output image, replace the image with the BackgroundFillValue everywhere below the plane This Far in physical units (millimeters) below (inferior to) the AC point (as found by the model.)  The oversize default was chosen to have no effect.  Based on visualizing a thousand masks in the IPIG study, we recommend a limit no smaller than 80.0 mm.,             
+    cutOutHeadInOutputVolume:
+    # type=bool|default=False: ,                 Flag to cut out just the head tissue when producing an (un)transformed clipped volume.,             
+    outputUntransformedClippedVolume:
+    # type=file: Output image in which to store neck-clipped input image, with the use of --acLowerBound and maybe --cutOutHeadInUntransformedVolume.
+    # type=traitcompound|default=None: Output image in which to store neck-clipped input image, with the use of --acLowerBound and maybe --cutOutHeadInUntransformedVolume.
+    rescaleIntensities:
+    # type=bool|default=False: ,                 Flag to turn on rescaling image intensities on input.,             
+    trimRescaledIntensities:
+    # type=float|default=0.0: ,                 Turn on clipping the rescaled image one-tailed on input.  Units of standard deviations above the mean.  Very large values are very permissive.  Non-positive value turns clipping off.  Defaults to removing 0.00001 of a normal tail above the mean.,             
+    rescaleIntensitiesOutputRange:
+    # type=inputmultiobject|default=[]: ,                 This pair of integers gives the lower and upper bounds on the signal portion of the output image.  Out-of-field voxels are taken from BackgroundFillValue.,             
+    BackgroundFillValue:
+    # type=str|default='': Fill the background of image with specified short int value. Enter number or use BIGNEG for a large negative number.
+    interpolationMode:
+    # type=enum|default='NearestNeighbor'|allowed['BSpline','Blackman','Cosine','Hamming','Lanczos','Linear','NearestNeighbor','ResampleInPlace','Welch','WindowedSinc']: Type of interpolation to be used when applying transform to moving volume.  Options are Linear, ResampleInPlace, NearestNeighbor, BSpline, or WindowedSinc
+    forceACPoint:
+    # type=inputmultiobject|default=[]: ,                 Use this flag to manually specify the AC point from the original image on the command line.,             
+    forcePCPoint:
+    # type=inputmultiobject|default=[]: ,                 Use this flag to manually specify the PC point from the original image on the command line.,             
+    forceVN4Point:
+    # type=inputmultiobject|default=[]: ,                 Use this flag to manually specify the VN4 point from the original image on the command line.,             
+    forceRPPoint:
+    # type=inputmultiobject|default=[]: ,                 Use this flag to manually specify the RP point from the original image on the command line.,             
+    inputLandmarksEMSP:
+    # type=file|default=<undefined>: ,               The filename for the new subject-specific landmark definition file in the same format produced by Slicer3 (in .fcsv) with the landmarks in the estimated MSP aligned space to be loaded. The detector will only process landmarks not enlisted on the file.,             
+    forceHoughEyeDetectorReportFailure:
+    # type=bool|default=False: ,                 Flag indicates whether the Hough eye detector should report failure,             
+    rmpj:
+    # type=float|default=0.0: ,               Search radius for MPJ in unit of mm,             
+    rac:
+    # type=float|default=0.0: ,               Search radius for AC in unit of mm,             
+    rpc:
+    # type=float|default=0.0: ,               Search radius for PC in unit of mm,             
+    rVN4:
+    # type=float|default=0.0: ,               Search radius for VN4 in unit of mm,             
+    debug:
+    # type=bool|default=False: ,               Show internal debugging information.,             
+    verbose:
+    # type=bool|default=False: ,               Show more verbose output,             
+    writeBranded2DImage:
+    # type=file: ,               The filename for the 2D .png branded midline debugging image.  This will happen only in conjunction with requesting an outputVolume.,             
+    # type=traitcompound|default=None: ,               The filename for the 2D .png branded midline debugging image.  This will happen only in conjunction with requesting an outputVolume.,             
+    resultsDir:
+    # type=directory: ,               The directory for the debugging images to be written.,             
+    # type=traitcompound|default=None: ,               The directory for the debugging images to be written.,             
+    writedebuggingImagesLevel:
+    # type=int|default=0: ,                 This flag controls if debugging images are produced.  By default value of 0 is no images.  Anything greater than zero will be increasing level of debugging images.,             
+    numberOfThreads:
+    # type=int|default=0: Explicitly specify the maximum number of threads to use.
+    atlasVolume:
+    # type=file|default=<undefined>: Atlas volume image to be used for BRAINSFit registration
+    atlasLandmarks:
+    # type=file|default=<undefined>: Atlas landmarks to be used for BRAINSFit registration initialization,             
+    atlasLandmarkWeights:
+    # type=file|default=<undefined>: Weights associated with atlas landmarks to be used for BRAINSFit registration initialization,             
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_constellation_detector_callables.py b/example-specs/task/nipype_internal/pydra-semtools/brains_constellation_detector_callables.py
new file mode 100644
index 00000000..e9384916
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/brains_constellation_detector_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in BRAINSConstellationDetector.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_constellation_modeler.yaml b/example-specs/task/nipype_internal/pydra-semtools/brains_constellation_modeler.yaml
new file mode 100644
index 00000000..cbc3cb7a
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/brains_constellation_modeler.yaml
@@ -0,0 +1,107 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.utilities.brains.BRAINSConstellationModeler' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Generate Landmarks Model (BRAINS)
+# 
+#     category: Utilities.BRAINS
+# 
+#     description: Train up a model for BRAINSConstellationDetector
+#     
+task_name: BRAINSConstellationModeler
+nipype_name: BRAINSConstellationModeler
+nipype_module: nipype.interfaces.semtools.utilities.brains
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputTrainingList: generic/file
+    # type=file|default=<undefined>: ,               Setup file, giving all parameters for training up a template model for each landmark.,             
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputModel: generic/file
+    # type=file: ,               The full filename of the output model file.,             
+    # type=traitcompound|default=None: ,               The full filename of the output model file.,             
+    resultsDir: generic/directory
+    # type=directory: ,               The directory for the results to be written.,             
+    # type=traitcompound|default=None: ,               The directory for the results to be written.,             
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    verbose:
+    # type=bool|default=False: ,               Show more verbose output,             
+    inputTrainingList:
+    # type=file|default=<undefined>: ,               Setup file, giving all parameters for training up a template model for each landmark.,             
+    outputModel:
+    # type=file: ,               The full filename of the output model file.,             
+    # type=traitcompound|default=None: ,               The full filename of the output model file.,             
+    saveOptimizedLandmarks:
+    # type=bool|default=False: ,               Flag to make a new subject-specific landmark definition file in the same format produced by Slicer3 with the optimized landmark (the detected RP, AC, and PC) in it.  Useful to tighten the variances in the ConstellationModeler.,             
+    optimizedLandmarksFilenameExtender:
+    # type=str|default='': ,                If the trainingList is (indexFullPathName) and contains landmark data filenames [path]/[filename].fcsv ,  make the optimized landmarks filenames out of [path]/[filename](thisExtender) and the optimized version of the input trainingList out of (indexFullPathName)(thisExtender) , when you rewrite all the landmarks according to the saveOptimizedLandmarks flag.,             
+    resultsDir:
+    # type=directory: ,               The directory for the results to be written.,             
+    # type=traitcompound|default=None: ,               The directory for the results to be written.,             
+    mspQualityLevel:
+    # type=int|default=0: ,                 Flag controls how aggressive the MSP is estimated.  0=quick estimate (9 seconds), 1=normal estimate (11 seconds), 2=great estimate (22 seconds), 3=best estimate (58 seconds).,             
+    rescaleIntensities:
+    # type=bool|default=False: ,                 Flag to turn on rescaling image intensities on input.,             
+    trimRescaledIntensities:
+    # type=float|default=0.0: ,                 Turn on clipping the rescaled image one-tailed on input.  Units of standard deviations above the mean.  Very large values are very permissive.  Non-positive value turns clipping off.  Defaults to removing 0.00001 of a normal tail above the mean.,             
+    rescaleIntensitiesOutputRange:
+    # type=inputmultiobject|default=[]: ,                 This pair of integers gives the lower and upper bounds on the signal portion of the output image.  Out-of-field voxels are taken from BackgroundFillValue.,             
+    BackgroundFillValue:
+    # type=str|default='': Fill the background of image with specified short int value. Enter number or use BIGNEG for a large negative number.
+    writedebuggingImagesLevel:
+    # type=int|default=0: ,                 This flag controls if debugging images are produced.  By default value of 0 is no images.  Anything greater than zero will be increasing level of debugging images.,             
+    numberOfThreads:
+    # type=int|default=0: Explicitly specify the maximum number of threads to use.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_constellation_modeler_callables.py b/example-specs/task/nipype_internal/pydra-semtools/brains_constellation_modeler_callables.py
new file mode 100644
index 00000000..dc30b88b
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/brains_constellation_modeler_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in BRAINSConstellationModeler.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_create_label_map_from_probability_maps.yaml b/example-specs/task/nipype_internal/pydra-semtools/brains_create_label_map_from_probability_maps.yaml
new file mode 100644
index 00000000..57ecb4a3
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/brains_create_label_map_from_probability_maps.yaml
@@ -0,0 +1,97 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.segmentation.specialized.BRAINSCreateLabelMapFromProbabilityMaps' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Create Label Map From Probability Maps (BRAINS)
+# 
+#     category: Segmentation.Specialized
+# 
+#     description: Given A list of Probability Maps, generate a LabelMap.
+#     
+task_name: BRAINSCreateLabelMapFromProbabilityMaps
+nipype_name: BRAINSCreateLabelMapFromProbabilityMaps
+nipype_module: nipype.interfaces.semtools.segmentation.specialized
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputProbabilityVolume: generic/file+list-of
+    # type=inputmultiobject|default=[]: The list of proobabilityimages.
+    nonAirRegionMask: generic/file
+    # type=file|default=<undefined>: a mask representing the 'NonAirRegion' -- Just force pixels in this region to zero
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    dirtyLabelVolume: generic/file
+    # type=file: the labels prior to cleaning
+    # type=traitcompound|default=None: the labels prior to cleaning
+    cleanLabelVolume: generic/file
+    # type=file: the foreground labels volume
+    # type=traitcompound|default=None: the foreground labels volume
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputProbabilityVolume:
+    # type=inputmultiobject|default=[]: The list of proobabilityimages.
+    priorLabelCodes:
+    # type=inputmultiobject|default=[]: A list of PriorLabelCode values used for coding the output label images
+    foregroundPriors:
+    # type=inputmultiobject|default=[]: A list: For each Prior Label, 1 if foreground, 0 if background
+    nonAirRegionMask:
+    # type=file|default=<undefined>: a mask representing the 'NonAirRegion' -- Just force pixels in this region to zero
+    inclusionThreshold:
+    # type=float|default=0.0: tolerance for inclusion
+    dirtyLabelVolume:
+    # type=file: the labels prior to cleaning
+    # type=traitcompound|default=None: the labels prior to cleaning
+    cleanLabelVolume:
+    # type=file: the foreground labels volume
+    # type=traitcompound|default=None: the foreground labels volume
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_create_label_map_from_probability_maps_callables.py b/example-specs/task/nipype_internal/pydra-semtools/brains_create_label_map_from_probability_maps_callables.py
new file mode 100644
index 00000000..e2f10eae
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/brains_create_label_map_from_probability_maps_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in BRAINSCreateLabelMapFromProbabilityMaps.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_cut.yaml b/example-specs/task/nipype_internal/pydra-semtools/brains_cut.yaml
new file mode 100644
index 00000000..6dbcd6d2
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/brains_cut.yaml
@@ -0,0 +1,115 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.segmentation.specialized.BRAINSCut' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: BRAINSCut (BRAINS)
+# 
+#     category: Segmentation.Specialized
+# 
+#     description: Automatic Segmentation using neural networks
+# 
+#     version: 1.0
+# 
+#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
+# 
+#     contributor: Vince Magnotta, Hans Johnson, Greg Harris, Kent Williams, Eunyoung Regina Kim
+#     
+task_name: BRAINSCut
+nipype_name: BRAINSCut
+nipype_module: nipype.interfaces.semtools.segmentation.specialized
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    netConfiguration: generic/file
+    # type=file|default=<undefined>: XML File defining BRAINSCut parameters. OLD NAME. PLEASE USE modelConfigurationFilename instead.
+    modelConfigurationFilename: generic/file
+    # type=file|default=<undefined>: XML File defining BRAINSCut parameters
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    netConfiguration:
+    # type=file|default=<undefined>: XML File defining BRAINSCut parameters. OLD NAME. PLEASE USE modelConfigurationFilename instead.
+    modelConfigurationFilename:
+    # type=file|default=<undefined>: XML File defining BRAINSCut parameters
+    trainModelStartIndex:
+    # type=int|default=0: Starting iteration for training
+    verbose:
+    # type=int|default=0: print out some debugging information
+    multiStructureThreshold:
+    # type=bool|default=False: multiStructureThreshold module to deal with overlapping area
+    histogramEqualization:
+    # type=bool|default=False: A Histogram Equalization process could be added to the creating/applying process from Subject To Atlas. Default is false, which generate input vectors without Histogram Equalization. 
+    computeSSEOn:
+    # type=bool|default=False: compute Sum of Square Error (SSE) along the trained model until the number of iteration given in the modelConfigurationFilename file
+    generateProbability:
+    # type=bool|default=False: Generate probability map
+    createVectors:
+    # type=bool|default=False: create vectors for training neural net
+    trainModel:
+    # type=bool|default=False: train the neural net
+    NoTrainingVectorShuffling:
+    # type=bool|default=False: If this flag is on, there will be no shuffling.
+    applyModel:
+    # type=bool|default=False: apply the neural net
+    validate:
+    # type=bool|default=False: validate data set.Just need for the first time run ( This is for validation of xml file and not working yet )
+    method:
+    # type=enum|default='RandomForest'|allowed['ANN','RandomForest']: 
+    numberOfTrees:
+    # type=int|default=0:  Random tree: number of trees. This is to be used when only one model with specified depth wish to be created. 
+    randomTreeDepth:
+    # type=int|default=0:  Random tree depth. This is to be used when only one model with specified depth wish to be created. 
+    modelFilename:
+    # type=str|default='':  model file name given from user (not by xml  configuration file) 
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_cut_callables.py b/example-specs/task/nipype_internal/pydra-semtools/brains_cut_callables.py
new file mode 100644
index 00000000..52afda6d
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/brains_cut_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in BRAINSCut.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_demon_warp.yaml b/example-specs/task/nipype_internal/pydra-semtools/brains_demon_warp.yaml
new file mode 100644
index 00000000..2e59146a
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/brains_demon_warp.yaml
@@ -0,0 +1,185 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.registration.specialized.BRAINSDemonWarp' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Demon Registration (BRAINS)
+# 
+#     category: Registration.Specialized
+# 
+#     description: This program finds a deformation field to warp a moving image onto a fixed image.  The images must be of the same signal kind, and contain an image of the same kind of object.  This program uses the Thirion Demons warp software in ITK, the Insight Toolkit.  Additional information is available at: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/BRAINSDemonWarp.
+# 
+#     version: 3.0.0
+# 
+#     documentation-url: http://www.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/BRAINSDemonWarp
+# 
+#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
+# 
+#     contributor: This tool was developed by Hans J. Johnson and Greg Harris.
+# 
+#     acknowledgements: The development of this tool was supported by funding from grants NS050568 and NS40068 from the National Institute of Neurological Disorders and Stroke and grants MH31593, MH40856, from the National Institute of Mental Health.
+#     
+task_name: BRAINSDemonWarp
+nipype_name: BRAINSDemonWarp
+nipype_module: nipype.interfaces.semtools.registration.specialized
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    movingVolume: generic/file
+    # type=file|default=<undefined>: Required: input moving image
+    fixedVolume: generic/file
+    # type=file|default=<undefined>: Required: input fixed (target) image
+    initializeWithDisplacementField: generic/file
+    # type=file|default=<undefined>: Initial deformation field vector image file name
+    initializeWithTransform: generic/file
+    # type=file|default=<undefined>: Initial Transform filename
+    fixedBinaryVolume: generic/file
+    # type=file|default=<undefined>: Mask filename for desired region of interest in the Fixed image.
+    movingBinaryVolume: generic/file
+    # type=file|default=<undefined>: Mask filename for desired region of interest in the Moving image.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputVolume: generic/file
+    # type=file: Required: output resampled moving image (will have the same physical space as the fixedVolume).
+    # type=traitcompound|default=None: Required: output resampled moving image (will have the same physical space as the fixedVolume).
+    outputDisplacementFieldVolume: generic/file
+    # type=file: Output deformation field vector image (will have the same physical space as the fixedVolume).
+    # type=traitcompound|default=None: Output deformation field vector image (will have the same physical space as the fixedVolume).
+    outputCheckerboardVolume: generic/file
+    # type=file: Genete a checkerboard image volume between the fixedVolume and the deformed movingVolume.
+    # type=traitcompound|default=None: Genete a checkerboard image volume between the fixedVolume and the deformed movingVolume.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    movingVolume:
+    # type=file|default=<undefined>: Required: input moving image
+    fixedVolume:
+    # type=file|default=<undefined>: Required: input fixed (target) image
+    inputPixelType:
+    # type=enum|default='float'|allowed['float','int','short','uchar','ushort']: Input volumes will be typecast to this format: float|short|ushort|int|uchar
+    outputVolume:
+    # type=file: Required: output resampled moving image (will have the same physical space as the fixedVolume).
+    # type=traitcompound|default=None: Required: output resampled moving image (will have the same physical space as the fixedVolume).
+    outputDisplacementFieldVolume:
+    # type=file: Output deformation field vector image (will have the same physical space as the fixedVolume).
+    # type=traitcompound|default=None: Output deformation field vector image (will have the same physical space as the fixedVolume).
+    outputPixelType:
+    # type=enum|default='float'|allowed['float','int','short','uchar','ushort']: outputVolume will be typecast to this format: float|short|ushort|int|uchar
+    interpolationMode:
+    # type=enum|default='NearestNeighbor'|allowed['BSpline','Blackman','Cosine','Hamming','Lanczos','Linear','NearestNeighbor','ResampleInPlace','Welch','WindowedSinc']: Type of interpolation to be used when applying transform to moving volume.  Options are Linear, ResampleInPlace, NearestNeighbor, BSpline, or WindowedSinc
+    registrationFilterType:
+    # type=enum|default='Demons'|allowed['Demons','Diffeomorphic','FastSymmetricForces']: Registration Filter Type: Demons|FastSymmetricForces|Diffeomorphic
+    smoothDisplacementFieldSigma:
+    # type=float|default=0.0: A gaussian smoothing value to be applied to the deformation field at each iteration.
+    numberOfPyramidLevels:
+    # type=int|default=0: Number of image pyramid levels to use in the multi-resolution registration.
+    minimumFixedPyramid:
+    # type=inputmultiobject|default=[]: The shrink factor for the first level of the fixed image pyramid. (i.e. start at 1/16 scale, then 1/8, then 1/4, then 1/2, and finally full scale)
+    minimumMovingPyramid:
+    # type=inputmultiobject|default=[]: The shrink factor for the first level of the moving image pyramid. (i.e. start at 1/16 scale, then 1/8, then 1/4, then 1/2, and finally full scale)
+    arrayOfPyramidLevelIterations:
+    # type=inputmultiobject|default=[]: The number of iterations for each pyramid level
+    histogramMatch:
+    # type=bool|default=False: Histogram Match the input images.  This is suitable for images of the same modality that may have different absolute scales, but the same overall intensity profile.
+    numberOfHistogramBins:
+    # type=int|default=0: The number of histogram levels
+    numberOfMatchPoints:
+    # type=int|default=0: The number of match points for histrogramMatch
+    medianFilterSize:
+    # type=inputmultiobject|default=[]: Median filter radius in all 3 directions.  When images have a lot of salt and pepper noise, this step can improve the registration.
+    initializeWithDisplacementField:
+    # type=file|default=<undefined>: Initial deformation field vector image file name
+    initializeWithTransform:
+    # type=file|default=<undefined>: Initial Transform filename
+    maskProcessingMode:
+    # type=enum|default='NOMASK'|allowed['BOBF','NOMASK','ROI','ROIAUTO']: What mode to use for using the masks: NOMASK|ROIAUTO|ROI|BOBF.  If ROIAUTO is chosen, then the mask is implicitly defined using a otsu foreground and hole filling algorithm. Where the Region Of Interest mode uses the masks to define what parts of the image should be used for computing the deformation field.  Brain Only Background Fill uses the masks to pre-process the input images by clipping and filling in the background with a predefined value.
+    fixedBinaryVolume:
+    # type=file|default=<undefined>: Mask filename for desired region of interest in the Fixed image.
+    movingBinaryVolume:
+    # type=file|default=<undefined>: Mask filename for desired region of interest in the Moving image.
+    lowerThresholdForBOBF:
+    # type=int|default=0: Lower threshold for performing BOBF
+    upperThresholdForBOBF:
+    # type=int|default=0: Upper threshold for performing BOBF
+    backgroundFillValue:
+    # type=int|default=0: Replacement value to overwrite background when performing BOBF
+    seedForBOBF:
+    # type=inputmultiobject|default=[]: coordinates in all 3 directions for Seed when performing BOBF
+    neighborhoodForBOBF:
+    # type=inputmultiobject|default=[]: neighborhood in all 3 directions to be included when performing BOBF
+    outputDisplacementFieldPrefix:
+    # type=str|default='': Displacement field filename prefix for writing separate x, y, and z component images
+    outputCheckerboardVolume:
+    # type=file: Genete a checkerboard image volume between the fixedVolume and the deformed movingVolume.
+    # type=traitcompound|default=None: Genete a checkerboard image volume between the fixedVolume and the deformed movingVolume.
+    checkerboardPatternSubdivisions:
+    # type=inputmultiobject|default=[]: Number of Checkerboard subdivisions in all 3 directions
+    outputNormalized:
+    # type=bool|default=False: Flag to warp and write the normalized images to output.  In normalized images the image values are fit-scaled to be between 0 and the maximum storage type value.
+    outputDebug:
+    # type=bool|default=False: Flag to write debugging images after each step.
+    gradient_type:
+    # type=enum|default='0'|allowed['0','1','2']: Type of gradient used for computing the demons force (0 is symmetrized, 1 is fixed image, 2 is moving image)
+    upFieldSmoothing:
+    # type=float|default=0.0: Smoothing sigma for the update field at each iteration
+    max_step_length:
+    # type=float|default=0.0: Maximum length of an update vector (0: no restriction)
+    use_vanilla_dem:
+    # type=bool|default=False: Run vanilla demons algorithm
+    gui:
+    # type=bool|default=False: Display intermediate image volumes for debugging
+    promptUser:
+    # type=bool|default=False: Prompt the user to hit enter each time an image is sent to the DebugImageViewer
+    numberOfBCHApproximationTerms:
+    # type=int|default=0: Number of terms in the BCH expansion
+    numberOfThreads:
+    # type=int|default=0: Explicitly specify the maximum number of threads to use.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_demon_warp_callables.py b/example-specs/task/nipype_internal/pydra-semtools/brains_demon_warp_callables.py
new file mode 100644
index 00000000..bb153f9f
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/brains_demon_warp_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in BRAINSDemonWarp.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_eye_detector.yaml b/example-specs/task/nipype_internal/pydra-semtools/brains_eye_detector.yaml
new file mode 100644
index 00000000..def8f012
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/brains_eye_detector.yaml
@@ -0,0 +1,87 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.utilities.brains.BRAINSEyeDetector' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Eye Detector (BRAINS)
+# 
+#     category: Utilities.BRAINS
+# 
+#     version: 1.0
+# 
+#     documentation-url: http://www.nitrc.org/projects/brainscdetector/
+#     
+task_name: BRAINSEyeDetector
+nipype_name: BRAINSEyeDetector
+nipype_module: nipype.interfaces.semtools.utilities.brains
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputVolume: generic/file
+    # type=file|default=<undefined>: The input volume
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputVolume: generic/file
+    # type=file: The output volume
+    # type=traitcompound|default=None: The output volume
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    numberOfThreads:
+    # type=int|default=0: Explicitly specify the maximum number of threads to use.
+    inputVolume:
+    # type=file|default=<undefined>: The input volume
+    outputVolume:
+    # type=file: The output volume
+    # type=traitcompound|default=None: The output volume
+    debugDir:
+    # type=str|default='': A place for debug information
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_eye_detector_callables.py b/example-specs/task/nipype_internal/pydra-semtools/brains_eye_detector_callables.py
new file mode 100644
index 00000000..fa9130d0
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/brains_eye_detector_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in BRAINSEyeDetector.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_fit.yaml b/example-specs/task/nipype_internal/pydra-semtools/brains_fit.yaml
new file mode 100644
index 00000000..9da201fb
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/brains_fit.yaml
@@ -0,0 +1,257 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.registration.brainsfit.BRAINSFit' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: General Registration (BRAINS)
+# 
+#     category: Registration
+# 
+#     description: Register a three-dimensional volume to a reference volume (Mattes Mutual Information by default). Full documentation available here: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/BRAINSFit. Method described in BRAINSFit: Mutual Information Registrations of Whole-Brain 3D Images, Using the Insight Toolkit, Johnson H.J., Harris G., Williams K., The Insight Journal, 2007. http://hdl.handle.net/1926/1291
+# 
+#     version: 3.0.0
+# 
+#     documentation-url: http://www.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/BRAINSFit
+# 
+#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
+# 
+#     contributor: Hans J. Johnson, hans-johnson -at- uiowa.edu, http://www.psychiatry.uiowa.edu
+# 
+#     acknowledgements: Hans Johnson(1,3,4); Kent Williams(1); Gregory Harris(1), Vincent Magnotta(1,2,3);  Andriy Fedorov(5) 1=University of Iowa Department of Psychiatry, 2=University of Iowa Department of Radiology, 3=University of Iowa Department of Biomedical Engineering, 4=University of Iowa Department of Electrical and Computer Engineering, 5=Surgical Planning Lab, Harvard
+#     
+task_name: BRAINSFit
+nipype_name: BRAINSFit
+nipype_module: nipype.interfaces.semtools.registration.brainsfit
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    fixedVolume: generic/file
+    # type=file|default=<undefined>: Input fixed image (the moving image will be transformed into this image space).
+    movingVolume: generic/file
+    # type=file|default=<undefined>: Input moving image (this image will be transformed into the fixed image space).
+    initialTransform: generic/file
+    # type=file|default=<undefined>: Transform to be applied to the moving image to initialize the registration.  This can only be used if Initialize Transform Mode is Off.
+    fixedBinaryVolume: generic/file
+    # type=file|default=<undefined>: Fixed Image binary mask volume, required if Masking Option is ROI. Image areas where the mask volume has zero value are ignored during the registration.
+    movingBinaryVolume: generic/file
+    # type=file|default=<undefined>: Moving Image binary mask volume, required if Masking Option is ROI. Image areas where the mask volume has zero value are ignored during the registration.
+    fixedVolume2: generic/file
+    # type=file|default=<undefined>: Input fixed image that will be used for multimodal registration. (the moving image will be transformed into this image space).
+    movingVolume2: generic/file
+    # type=file|default=<undefined>: Input moving image that will be used for multimodal registration(this image will be transformed into the fixed image space).
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    linearTransform: generic/file
+    # type=file: (optional) Output estimated transform - in case the computed transform is not BSpline. NOTE: You must set at least one output object (transform and/or output volume).
+    # type=traitcompound|default=None: (optional) Output estimated transform - in case the computed transform is not BSpline. NOTE: You must set at least one output object (transform and/or output volume).
+    bsplineTransform: generic/file
+    # type=file: (optional) Output estimated transform - in case the computed transform is BSpline. NOTE: You must set at least one output object (transform and/or output volume).
+    # type=traitcompound|default=None: (optional) Output estimated transform - in case the computed transform is BSpline. NOTE: You must set at least one output object (transform and/or output volume).
+    outputVolume: generic/file
+    # type=file: (optional) Output image: the moving image warped to the fixed image space. NOTE: You must set at least one output object (transform and/or output volume).
+    # type=traitcompound|default=None: (optional) Output image: the moving image warped to the fixed image space. NOTE: You must set at least one output object (transform and/or output volume).
+    outputFixedVolumeROI: generic/file
+    # type=file: ROI that is automatically computed from the fixed image. Only available if Masking Option is ROIAUTO. Image areas where the mask volume has zero value are ignored during the registration.
+    # type=traitcompound|default=None: ROI that is automatically computed from the fixed image. Only available if Masking Option is ROIAUTO. Image areas where the mask volume has zero value are ignored during the registration.
+    outputMovingVolumeROI: generic/file
+    # type=file: ROI that is automatically computed from the moving image. Only available if Masking Option is ROIAUTO. Image areas where the mask volume has zero value are ignored during the registration.
+    # type=traitcompound|default=None: ROI that is automatically computed from the moving image. Only available if Masking Option is ROIAUTO. Image areas where the mask volume has zero value are ignored during the registration.
+    strippedOutputTransform: generic/file
+    # type=file: Rigid component of the estimated affine transform. Can be used to rigidly register the moving image to the fixed image. NOTE:  This value is overridden if either bsplineTransform or linearTransform is set.
+    # type=traitcompound|default=None: Rigid component of the estimated affine transform. Can be used to rigidly register the moving image to the fixed image. NOTE:  This value is overridden if either bsplineTransform or linearTransform is set.
+    outputTransform: generic/file
+    # type=file: (optional) Filename to which save the (optional) estimated transform. NOTE: You must select either the outputTransform or the outputVolume option.
+    # type=traitcompound|default=None: (optional) Filename to which save the (optional) estimated transform. NOTE: You must select either the outputTransform or the outputVolume option.
+    logFileReport: generic/file
+    # type=file: A file to write out final information report in CSV file: MetricName,MetricValue,FixedImageName,FixedMaskName,MovingImageName,MovingMaskName
+    # type=traitcompound|default=None: A file to write out final information report in CSV file: MetricName,MetricValue,FixedImageName,FixedMaskName,MovingImageName,MovingMaskName
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    fixedVolume:
+    # type=file|default=<undefined>: Input fixed image (the moving image will be transformed into this image space).
+    movingVolume:
+    # type=file|default=<undefined>: Input moving image (this image will be transformed into the fixed image space).
+    samplingPercentage:
+    # type=float|default=0.0: Fraction of voxels of the fixed image that will be used for registration. The number has to be larger than zero and less or equal to one. Higher values increase the computation time but may give more accurate results. You can also limit the sampling focus with ROI masks and ROIAUTO mask generation. The default is 0.002 (use approximately 0.2% of voxels, resulting in 100000 samples in a 512x512x192 volume) to provide a very fast registration in most cases. Typical values range from 0.01 (1%) for low detail images to 0.2 (20%) for high detail images.
+    splineGridSize:
+    # type=inputmultiobject|default=[]: Number of BSpline grid subdivisions along each axis of the fixed image, centered on the image space. Values must be 3 or higher for the BSpline to be correctly computed.
+    linearTransform:
+    # type=file: (optional) Output estimated transform - in case the computed transform is not BSpline. NOTE: You must set at least one output object (transform and/or output volume).
+    # type=traitcompound|default=None: (optional) Output estimated transform - in case the computed transform is not BSpline. NOTE: You must set at least one output object (transform and/or output volume).
+    bsplineTransform:
+    # type=file: (optional) Output estimated transform - in case the computed transform is BSpline. NOTE: You must set at least one output object (transform and/or output volume).
+    # type=traitcompound|default=None: (optional) Output estimated transform - in case the computed transform is BSpline. NOTE: You must set at least one output object (transform and/or output volume).
+    outputVolume:
+    # type=file: (optional) Output image: the moving image warped to the fixed image space. NOTE: You must set at least one output object (transform and/or output volume).
+    # type=traitcompound|default=None: (optional) Output image: the moving image warped to the fixed image space. NOTE: You must set at least one output object (transform and/or output volume).
+    initialTransform:
+    # type=file|default=<undefined>: Transform to be applied to the moving image to initialize the registration.  This can only be used if Initialize Transform Mode is Off.
+    initializeTransformMode:
+    # type=enum|default='Off'|allowed['Off','useCenterOfHeadAlign','useCenterOfROIAlign','useGeometryAlign','useMomentsAlign']: Determine how to initialize the transform center.  useMomentsAlign assumes that the center of mass of the images represent similar structures.  useCenterOfHeadAlign attempts to use the top of head and shape of neck to drive a center of mass estimate. useGeometryAlign on assumes that the center of the voxel lattice of the images represent similar structures.  Off assumes that the physical space of the images are close.  This flag is mutually exclusive with the Initialization transform.
+    useRigid:
+    # type=bool|default=False: Perform a rigid registration as part of the sequential registration steps.  This family of options overrides the use of transformType if any of them are set.
+    useScaleVersor3D:
+    # type=bool|default=False: Perform a ScaleVersor3D registration as part of the sequential registration steps.  This family of options overrides the use of transformType if any of them are set.
+    useScaleSkewVersor3D:
+    # type=bool|default=False: Perform a ScaleSkewVersor3D registration as part of the sequential registration steps.  This family of options overrides the use of transformType if any of them are set.
+    useAffine:
+    # type=bool|default=False: Perform an Affine registration as part of the sequential registration steps.  This family of options overrides the use of transformType if any of them are set.
+    useBSpline:
+    # type=bool|default=False: Perform a BSpline registration as part of the sequential registration steps.  This family of options overrides the use of transformType if any of them are set.
+    useSyN:
+    # type=bool|default=False: Perform a SyN registration as part of the sequential registration steps.  This family of options overrides the use of transformType if any of them are set.
+    useComposite:
+    # type=bool|default=False: Perform a Composite registration as part of the sequential registration steps.  This family of options overrides the use of transformType if any of them are set.
+    maskProcessingMode:
+    # type=enum|default='NOMASK'|allowed['NOMASK','ROI','ROIAUTO']: Specifies a mask to only consider a certain image region for the registration.  If ROIAUTO is chosen, then the mask is computed using Otsu thresholding and hole filling. If ROI is chosen then the mask has to be specified as in input.
+    fixedBinaryVolume:
+    # type=file|default=<undefined>: Fixed Image binary mask volume, required if Masking Option is ROI. Image areas where the mask volume has zero value are ignored during the registration.
+    movingBinaryVolume:
+    # type=file|default=<undefined>: Moving Image binary mask volume, required if Masking Option is ROI. Image areas where the mask volume has zero value are ignored during the registration.
+    outputFixedVolumeROI:
+    # type=file: ROI that is automatically computed from the fixed image. Only available if Masking Option is ROIAUTO. Image areas where the mask volume has zero value are ignored during the registration.
+    # type=traitcompound|default=None: ROI that is automatically computed from the fixed image. Only available if Masking Option is ROIAUTO. Image areas where the mask volume has zero value are ignored during the registration.
+    outputMovingVolumeROI:
+    # type=file: ROI that is automatically computed from the moving image. Only available if Masking Option is ROIAUTO. Image areas where the mask volume has zero value are ignored during the registration.
+    # type=traitcompound|default=None: ROI that is automatically computed from the moving image. Only available if Masking Option is ROIAUTO. Image areas where the mask volume has zero value are ignored during the registration.
+    useROIBSpline:
+    # type=bool|default=False: If enabled then the bounding box of the input ROIs defines the BSpline grid support region. Otherwise the BSpline grid support region is the whole fixed image.
+    histogramMatch:
+    # type=bool|default=False: Apply histogram matching operation for the input images to make them more similar.  This is suitable for images of the same modality that may have different brightness or contrast, but the same overall intensity profile. Do NOT use if registering images from different modalities.
+    medianFilterSize:
+    # type=inputmultiobject|default=[]: Apply median filtering to reduce noise in the input volumes. The 3 values specify the radius for the optional MedianImageFilter preprocessing in all 3 directions (in voxels).
+    removeIntensityOutliers:
+    # type=float|default=0.0: Remove very high and very low intensity voxels from the input volumes. The parameter specifies the half percentage to decide outliers of image intensities. The default value is zero, which means no outlier removal. If the value of 0.005 is given, the 0.005% of both tails will be thrown away, so 0.01% of intensities in total would be ignored in the statistic calculation.
+    fixedVolume2:
+    # type=file|default=<undefined>: Input fixed image that will be used for multimodal registration. (the moving image will be transformed into this image space).
+    movingVolume2:
+    # type=file|default=<undefined>: Input moving image that will be used for multimodal registration(this image will be transformed into the fixed image space).
+    outputVolumePixelType:
+    # type=enum|default='float'|allowed['float','int','short','uchar','uint','ushort']: Data type for representing a voxel of the Output Volume.
+    backgroundFillValue:
+    # type=float|default=0.0: This value will be used for filling those areas of the output image that have no corresponding voxels in the input moving image.
+    scaleOutputValues:
+    # type=bool|default=False: If true, and the voxel values do not fit within the minimum and maximum values of the desired outputVolumePixelType, then linearly scale the min/max output image voxel values to fit within the min/max range of the outputVolumePixelType.
+    interpolationMode:
+    # type=enum|default='NearestNeighbor'|allowed['BSpline','Blackman','Cosine','Hamming','Lanczos','Linear','NearestNeighbor','ResampleInPlace','Welch','WindowedSinc']: Type of interpolation to be used when applying transform to moving volume.  Options are Linear, NearestNeighbor, BSpline, WindowedSinc, Hamming, Cosine, Welch, Lanczos, or ResampleInPlace.  The ResampleInPlace option will create an image with the same discrete voxel values and will adjust the origin and direction of the physical space interpretation.
+    numberOfIterations:
+    # type=inputmultiobject|default=[]: The maximum number of iterations to try before stopping the optimization. When using a lower value (500-1000) then the registration is forced to terminate earlier but there is a higher risk of stopping before an optimal solution is reached.
+    maximumStepLength:
+    # type=float|default=0.0: Starting step length of the optimizer. In general, higher values allow for recovering larger initial misalignments but there is an increased chance that the registration will not converge.
+    minimumStepLength:
+    # type=inputmultiobject|default=[]: Each step in the optimization takes steps at least this big.  When none are possible, registration is complete. Smaller values allows the optimizer to make smaller adjustments, but the registration time may increase.
+    relaxationFactor:
+    # type=float|default=0.0: Specifies how quickly the optimization step length is decreased during registration. The value must be larger than 0 and smaller than 1. Larger values result in slower step size decrease, which allow for recovering larger initial misalignments but it increases the registration time and the chance that the registration will not converge.
+    translationScale:
+    # type=float|default=0.0: How much to scale up changes in position (in mm) compared to unit rotational changes (in radians) -- decrease this to allow for more rotation in the search pattern.
+    reproportionScale:
+    # type=float|default=0.0: ScaleVersor3D 'Scale' compensation factor.  Increase this to allow for more rescaling in a ScaleVersor3D or ScaleSkewVersor3D search pattern.  1.0 works well with a translationScale of 1000.0
+    skewScale:
+    # type=float|default=0.0: ScaleSkewVersor3D Skew compensation factor.  Increase this to allow for more skew in a ScaleSkewVersor3D search pattern.  1.0 works well with a translationScale of 1000.0
+    maxBSplineDisplacement:
+    # type=float|default=0.0: Maximum allowed displacements in image physical coordinates (mm) for BSpline control grid along each axis.  A value of 0.0 indicates that the problem should be unbounded.  NOTE:  This only constrains the BSpline portion, and does not limit the displacement from the associated bulk transform.  This can lead to a substantial reduction in computation time in the BSpline optimizer.,       
+    fixedVolumeTimeIndex:
+    # type=int|default=0: The index in the time series for the 3D fixed image to fit. Only allowed if the fixed input volume is 4-dimensional.
+    movingVolumeTimeIndex:
+    # type=int|default=0: The index in the time series for the 3D moving image to fit. Only allowed if the moving input volume is 4-dimensional
+    numberOfHistogramBins:
+    # type=int|default=0: The number of histogram levels used for mutual information metric estimation.
+    numberOfMatchPoints:
+    # type=int|default=0: Number of histogram match points used for mutual information metric estimation.
+    costMetric:
+    # type=enum|default='MMI'|allowed['MIH','MMI','MSE','NC']: The cost metric to be used during fitting. Defaults to MMI. Options are MMI (Mattes Mutual Information), MSE (Mean Square Error), NC (Normalized Correlation), MC (Match Cardinality for binary images)
+    maskInferiorCutOffFromCenter:
+    # type=float|default=0.0: If Initialize Transform Mode is set to useCenterOfHeadAlign or Masking Option is ROIAUTO then this value defines the how much is cut of from the inferior part of the image. The cut-off distance is specified in millimeters, relative to the image center. If the value is 1000 or larger then no cut-off performed.
+    ROIAutoDilateSize:
+    # type=float|default=0.0: This flag is only relevant when using ROIAUTO mode for initializing masks.  It defines the final dilation size to capture a bit of background outside the tissue region.  A setting of 10mm has been shown to help regularize a BSpline registration type so that there is some background constraints to match the edges of the head better.
+    ROIAutoClosingSize:
+    # type=float|default=0.0: This flag is only relevant when using ROIAUTO mode for initializing masks.  It defines the hole closing size in mm.  It is rounded up to the nearest whole pixel size in each direction. The default is to use a closing size of 9mm.  For mouse data this value may need to be reset to 0.9 or smaller.
+    numberOfSamples:
+    # type=int|default=0: The number of voxels sampled for mutual information computation.  Increase this for higher accuracy, at the cost of longer computation time., NOTE that it is suggested to use samplingPercentage instead of this option. However, if set to non-zero, numberOfSamples overwrites the samplingPercentage option.  
+    strippedOutputTransform:
+    # type=file: Rigid component of the estimated affine transform. Can be used to rigidly register the moving image to the fixed image. NOTE:  This value is overridden if either bsplineTransform or linearTransform is set.
+    # type=traitcompound|default=None: Rigid component of the estimated affine transform. Can be used to rigidly register the moving image to the fixed image. NOTE:  This value is overridden if either bsplineTransform or linearTransform is set.
+    transformType:
+    # type=inputmultiobject|default=[]: Specifies a list of registration types to be used.  The valid types are, Rigid, ScaleVersor3D, ScaleSkewVersor3D, Affine, BSpline and SyN.  Specifying more than one in a comma separated list will initialize the next stage with the previous results. If registrationClass flag is used, it overrides this parameter setting.
+    outputTransform:
+    # type=file: (optional) Filename to which save the (optional) estimated transform. NOTE: You must select either the outputTransform or the outputVolume option.
+    # type=traitcompound|default=None: (optional) Filename to which save the (optional) estimated transform. NOTE: You must select either the outputTransform or the outputVolume option.
+    initializeRegistrationByCurrentGenericTransform:
+    # type=bool|default=False: If this flag is ON, the current generic composite transform, resulted from the linear registration stages, is set to initialize the follow nonlinear registration process. However, by the default behaviour, the moving image is first warped based on the existent transform before it is passed to the BSpline registration filter. It is done to speed up the BSpline registration by reducing the computations of composite transform Jacobian.
+    failureExitCode:
+    # type=int|default=0: If the fit fails, exit with this status code.  (It can be used to force a successfult exit status of (0) if the registration fails due to reaching the maximum number of iterations.
+    writeTransformOnFailure:
+    # type=bool|default=False: Flag to save the final transform even if the numberOfIterations are reached without convergence. (Intended for use when --failureExitCode 0 )
+    numberOfThreads:
+    # type=int|default=0: Explicitly specify the maximum number of threads to use. (default is auto-detected)
+    debugLevel:
+    # type=int|default=0: Display debug messages, and produce debug intermediate results.  0=OFF, 1=Minimal, 10=Maximum debugging.
+    costFunctionConvergenceFactor:
+    # type=float|default=0.0: From itkLBFGSBOptimizer.h: Set/Get the CostFunctionConvergenceFactor. Algorithm terminates when the reduction in cost function is less than (factor * epsmcj) where epsmch is the machine precision. Typical values for factor: 1e+12 for low accuracy; 1e+7 for moderate accuracy and 1e+1 for extremely high accuracy.  1e+9 seems to work well.,       
+    projectedGradientTolerance:
+    # type=float|default=0.0: From itkLBFGSBOptimizer.h: Set/Get the ProjectedGradientTolerance. Algorithm terminates when the project gradient is below the tolerance. Default lbfgsb value is 1e-5, but 1e-4 seems to work well.,       
+    maximumNumberOfEvaluations:
+    # type=int|default=0: Maximum number of evaluations for line search in lbfgsb optimizer.
+    maximumNumberOfCorrections:
+    # type=int|default=0: Maximum number of corrections in lbfgsb optimizer.
+    gui:
+    # type=bool|default=False: Display intermediate image volumes for debugging.  NOTE:  This is not part of the standard build system, and probably does nothing on your installation.
+    promptUser:
+    # type=bool|default=False: Prompt the user to hit enter each time an image is sent to the DebugImageViewer
+    metricSamplingStrategy:
+    # type=enum|default='Random'|allowed['Random']: It defines the method that registration filter uses to sample the input fixed image. Only Random is supported for now.
+    logFileReport:
+    # type=file: A file to write out final information report in CSV file: MetricName,MetricValue,FixedImageName,FixedMaskName,MovingImageName,MovingMaskName
+    # type=traitcompound|default=None: A file to write out final information report in CSV file: MetricName,MetricValue,FixedImageName,FixedMaskName,MovingImageName,MovingMaskName
+    writeOutputTransformInFloat:
+    # type=bool|default=False: By default, the output registration transforms (either the output composite transform or each transform component) are written to the disk in double precision. If this flag is ON, the output transforms will be written in single (float) precision. It is especially important if the output transform is a displacement field transform, or it is a composite transform that includes several displacement fields.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_fit_callables.py b/example-specs/task/nipype_internal/pydra-semtools/brains_fit_callables.py
new file mode 100644
index 00000000..324aacce
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/brains_fit_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in BRAINSFit.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_initialized_control_points.yaml b/example-specs/task/nipype_internal/pydra-semtools/brains_initialized_control_points.yaml
new file mode 100644
index 00000000..527b9da7
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/brains_initialized_control_points.yaml
@@ -0,0 +1,97 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.utilities.brains.BRAINSInitializedControlPoints' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Initialized Control Points (BRAINS)
+# 
+#     category: Utilities.BRAINS
+# 
+#     description: Outputs bspline control points as landmarks
+# 
+#     version: 0.1.0.$Revision: 916 $(alpha)
+# 
+#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
+# 
+#     contributor: Mark Scully
+# 
+#     acknowledgements: This work is part of the National Alliance for Medical Image Computing (NAMIC), funded by the National Institutes of Health through the NIH Roadmap for Medical Research, Grant U54 EB005149.  Additional support for Mark Scully and Hans Johnson at the University of Iowa.
+#     
+task_name: BRAINSInitializedControlPoints
+nipype_name: BRAINSInitializedControlPoints
+nipype_module: nipype.interfaces.semtools.utilities.brains
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputVolume: generic/file
+    # type=file|default=<undefined>: Input Volume
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputVolume: generic/file
+    # type=file: Output Volume
+    # type=traitcompound|default=None: Output Volume
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputVolume:
+    # type=file|default=<undefined>: Input Volume
+    outputVolume:
+    # type=file: Output Volume
+    # type=traitcompound|default=None: Output Volume
+    splineGridSize:
+    # type=inputmultiobject|default=[]: The number of subdivisions of the BSpline Grid to be centered on the image space.  Each dimension must have at least 3 subdivisions for the BSpline to be correctly computed. 
+    permuteOrder:
+    # type=inputmultiobject|default=[]: The permutation order for the images.  The default is 0,1,2 (i.e. no permutation)
+    outputLandmarksFile:
+    # type=str|default='': Output filename
+    numberOfThreads:
+    # type=int|default=0: Explicitly specify the maximum number of threads to use.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_initialized_control_points_callables.py b/example-specs/task/nipype_internal/pydra-semtools/brains_initialized_control_points_callables.py
new file mode 100644
index 00000000..d9351137
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/brains_initialized_control_points_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in BRAINSInitializedControlPoints.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_landmark_initializer.yaml b/example-specs/task/nipype_internal/pydra-semtools/brains_landmark_initializer.yaml
new file mode 100644
index 00000000..25bbdbeb
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/brains_landmark_initializer.yaml
@@ -0,0 +1,95 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.utilities.brains.BRAINSLandmarkInitializer' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: BRAINSLandmarkInitializer
+# 
+#     category: Utilities.BRAINS
+# 
+#     description: Create transformation file (*mat) from a pair of landmarks (*fcsv) files.
+# 
+#     version: 1.0
+# 
+#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
+# 
+#     contributor: Eunyoung Regina Kim
+#     
+task_name: BRAINSLandmarkInitializer
+nipype_name: BRAINSLandmarkInitializer
+nipype_module: nipype.interfaces.semtools.utilities.brains
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputFixedLandmarkFilename: generic/file
+    # type=file|default=<undefined>: input fixed landmark. *.fcsv
+    inputMovingLandmarkFilename: generic/file
+    # type=file|default=<undefined>: input moving landmark. *.fcsv
+    inputWeightFilename: generic/file
+    # type=file|default=<undefined>: Input weight file name for landmarks. Higher weighted landmark will be considered more heavily. Weights are proportional, that is the magnitude of weights will be normalized by its minimum and maximum value. 
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputTransformFilename: generic/file
+    # type=file: output transform file name (ex: ./outputTransform.mat) 
+    # type=traitcompound|default=None: output transform file name (ex: ./outputTransform.mat) 
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputFixedLandmarkFilename:
+    # type=file|default=<undefined>: input fixed landmark. *.fcsv
+    inputMovingLandmarkFilename:
+    # type=file|default=<undefined>: input moving landmark. *.fcsv
+    inputWeightFilename:
+    # type=file|default=<undefined>: Input weight file name for landmarks. Higher weighted landmark will be considered more heavily. Weights are proportional, that is the magnitude of weights will be normalized by its minimum and maximum value. 
+    outputTransformFilename:
+    # type=file: output transform file name (ex: ./outputTransform.mat) 
+    # type=traitcompound|default=None: output transform file name (ex: ./outputTransform.mat) 
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_landmark_initializer_callables.py b/example-specs/task/nipype_internal/pydra-semtools/brains_landmark_initializer_callables.py
new file mode 100644
index 00000000..6283aa56
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/brains_landmark_initializer_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in BRAINSLandmarkInitializer.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_linear_modeler_epca.yaml b/example-specs/task/nipype_internal/pydra-semtools/brains_linear_modeler_epca.yaml
new file mode 100644
index 00000000..86c2e098
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/brains_linear_modeler_epca.yaml
@@ -0,0 +1,81 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.utilities.brains.BRAINSLinearModelerEPCA' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Landmark Linear Modeler (BRAINS)
+# 
+#     category: Utilities.BRAINS
+# 
+#     description: Training linear model using EPCA. Implementation based on my MS thesis, "A METHOD FOR AUTOMATED LANDMARK CONSTELLATION DETECTION USING EVOLUTIONARY PRINCIPAL COMPONENTS AND STATISTICAL SHAPE MODELS"
+# 
+#     version: 1.0
+# 
+#     documentation-url: http://www.nitrc.org/projects/brainscdetector/
+#     
+task_name: BRAINSLinearModelerEPCA
+nipype_name: BRAINSLinearModelerEPCA
+nipype_module: nipype.interfaces.semtools.utilities.brains
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputTrainingList: generic/file
+    # type=file|default=<undefined>: Input Training Landmark List Filename,             
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputTrainingList:
+    # type=file|default=<undefined>: Input Training Landmark List Filename,             
+    numberOfThreads:
+    # type=int|default=0: Explicitly specify the maximum number of threads to use.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_linear_modeler_epca_callables.py b/example-specs/task/nipype_internal/pydra-semtools/brains_linear_modeler_epca_callables.py
new file mode 100644
index 00000000..c7fab313
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/brains_linear_modeler_epca_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in BRAINSLinearModelerEPCA.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_lmk_transform.yaml b/example-specs/task/nipype_internal/pydra-semtools/brains_lmk_transform.yaml
new file mode 100644
index 00000000..8e06928e
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/brains_lmk_transform.yaml
@@ -0,0 +1,105 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.utilities.brains.BRAINSLmkTransform' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Landmark Transform (BRAINS)
+# 
+#     category: Utilities.BRAINS
+# 
+#     description: This utility program estimates the affine transform to align the fixed landmarks to the moving landmarks, and then generate the resampled moving image to the same physical space as that of the reference image.
+# 
+#     version: 1.0
+# 
+#     documentation-url: http://www.nitrc.org/projects/brainscdetector/
+#     
+task_name: BRAINSLmkTransform
+nipype_name: BRAINSLmkTransform
+nipype_module: nipype.interfaces.semtools.utilities.brains
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputMovingLandmarks: generic/file
+    # type=file|default=<undefined>: Input Moving Landmark list file in fcsv,             
+    inputFixedLandmarks: generic/file
+    # type=file|default=<undefined>: Input Fixed Landmark list file in fcsv,             
+    inputMovingVolume: generic/file
+    # type=file|default=<undefined>: The filename of input moving volume
+    inputReferenceVolume: generic/file
+    # type=file|default=<undefined>: The filename of the reference volume
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputAffineTransform: generic/file
+    # type=file: The filename for the estimated affine transform,             
+    # type=traitcompound|default=None: The filename for the estimated affine transform,             
+    outputResampledVolume: generic/file
+    # type=file: The filename of the output resampled volume
+    # type=traitcompound|default=None: The filename of the output resampled volume
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputMovingLandmarks:
+    # type=file|default=<undefined>: Input Moving Landmark list file in fcsv,             
+    inputFixedLandmarks:
+    # type=file|default=<undefined>: Input Fixed Landmark list file in fcsv,             
+    outputAffineTransform:
+    # type=file: The filename for the estimated affine transform,             
+    # type=traitcompound|default=None: The filename for the estimated affine transform,             
+    inputMovingVolume:
+    # type=file|default=<undefined>: The filename of input moving volume
+    inputReferenceVolume:
+    # type=file|default=<undefined>: The filename of the reference volume
+    outputResampledVolume:
+    # type=file: The filename of the output resampled volume
+    # type=traitcompound|default=None: The filename of the output resampled volume
+    numberOfThreads:
+    # type=int|default=0: Explicitly specify the maximum number of threads to use.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_lmk_transform_callables.py b/example-specs/task/nipype_internal/pydra-semtools/brains_lmk_transform_callables.py
new file mode 100644
index 00000000..844caf36
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/brains_lmk_transform_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in BRAINSLmkTransform.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_multi_staple.yaml b/example-specs/task/nipype_internal/pydra-semtools/brains_multi_staple.yaml
new file mode 100644
index 00000000..7d2a6ae1
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/brains_multi_staple.yaml
@@ -0,0 +1,101 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.segmentation.specialized.BRAINSMultiSTAPLE' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Create best representative label map)
+# 
+#     category: Segmentation.Specialized
+# 
+#     description: given a list of label map images, create a representative/average label map.
+#     
+task_name: BRAINSMultiSTAPLE
+nipype_name: BRAINSMultiSTAPLE
+nipype_module: nipype.interfaces.semtools.segmentation.specialized
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputCompositeT1Volume: generic/file
+    # type=file|default=<undefined>: Composite T1, all label maps transformed into the space for this image.
+    inputLabelVolume: generic/file+list-of
+    # type=inputmultiobject|default=[]: The list of proobabilityimages.
+    inputTransform: generic/file+list-of
+    # type=inputmultiobject|default=[]: transforms to apply to label volumes
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputMultiSTAPLE: generic/file
+    # type=file: the MultiSTAPLE average of input label volumes
+    # type=traitcompound|default=None: the MultiSTAPLE average of input label volumes
+    outputConfusionMatrix: generic/file
+    # type=file: Confusion Matrix
+    # type=traitcompound|default=None: Confusion Matrix
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputCompositeT1Volume:
+    # type=file|default=<undefined>: Composite T1, all label maps transformed into the space for this image.
+    inputLabelVolume:
+    # type=inputmultiobject|default=[]: The list of proobabilityimages.
+    inputTransform:
+    # type=inputmultiobject|default=[]: transforms to apply to label volumes
+    labelForUndecidedPixels:
+    # type=int|default=0: Label for undecided pixels
+    resampledVolumePrefix:
+    # type=str|default='': if given, write out resampled volumes with this prefix
+    skipResampling:
+    # type=bool|default=False: Omit resampling images into reference space
+    outputMultiSTAPLE:
+    # type=file: the MultiSTAPLE average of input label volumes
+    # type=traitcompound|default=None: the MultiSTAPLE average of input label volumes
+    outputConfusionMatrix:
+    # type=file: Confusion Matrix
+    # type=traitcompound|default=None: Confusion Matrix
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_multi_staple_callables.py b/example-specs/task/nipype_internal/pydra-semtools/brains_multi_staple_callables.py
new file mode 100644
index 00000000..78548902
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/brains_multi_staple_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in BRAINSMultiSTAPLE.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_mush.yaml b/example-specs/task/nipype_internal/pydra-semtools/brains_mush.yaml
new file mode 100644
index 00000000..73974849
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/brains_mush.yaml
@@ -0,0 +1,131 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.utilities.brains.BRAINSMush' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Brain Extraction from T1/T2 image (BRAINS)
+# 
+#     category: Utilities.BRAINS
+# 
+#     description: This program: 1) generates a weighted mixture image optimizing the mean and variance and 2) produces a mask of the brain volume
+# 
+#     version: 0.1.0.$Revision: 1.4 $(alpha)
+# 
+#     documentation-url: http:://mri.radiology.uiowa.edu
+# 
+#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
+# 
+#     contributor: This tool is a modification by Steven Dunn of a program developed by Greg Harris and Ron Pierson.
+# 
+#     acknowledgements: This work was developed by the University of Iowa Departments of Radiology and Psychiatry. This software was supported in part of NIH/NINDS award NS050568.
+#     
+task_name: BRAINSMush
+nipype_name: BRAINSMush
+nipype_module: nipype.interfaces.semtools.utilities.brains
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputFirstVolume: generic/file
+    # type=file|default=<undefined>: Input image (1) for mixture optimization
+    inputSecondVolume: generic/file
+    # type=file|default=<undefined>: Input image (2) for mixture optimization
+    inputMaskVolume: generic/file
+    # type=file|default=<undefined>: Input label image for mixture optimization
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputWeightsFile: generic/file
+    # type=file: Output Weights File
+    # type=traitcompound|default=None: Output Weights File
+    outputVolume: generic/file
+    # type=file: The MUSH image produced from the T1 and T2 weighted images
+    # type=traitcompound|default=None: The MUSH image produced from the T1 and T2 weighted images
+    outputMask: generic/file
+    # type=file: The brain volume mask generated from the MUSH image
+    # type=traitcompound|default=None: The brain volume mask generated from the MUSH image
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputFirstVolume:
+    # type=file|default=<undefined>: Input image (1) for mixture optimization
+    inputSecondVolume:
+    # type=file|default=<undefined>: Input image (2) for mixture optimization
+    inputMaskVolume:
+    # type=file|default=<undefined>: Input label image for mixture optimization
+    outputWeightsFile:
+    # type=file: Output Weights File
+    # type=traitcompound|default=None: Output Weights File
+    outputVolume:
+    # type=file: The MUSH image produced from the T1 and T2 weighted images
+    # type=traitcompound|default=None: The MUSH image produced from the T1 and T2 weighted images
+    outputMask:
+    # type=file: The brain volume mask generated from the MUSH image
+    # type=traitcompound|default=None: The brain volume mask generated from the MUSH image
+    seed:
+    # type=inputmultiobject|default=[]: Seed Point for Brain Region Filling
+    desiredMean:
+    # type=float|default=0.0: Desired mean within the mask for weighted sum of both images.
+    desiredVariance:
+    # type=float|default=0.0: Desired variance within the mask for weighted sum of both images.
+    lowerThresholdFactorPre:
+    # type=float|default=0.0: Lower threshold factor for finding an initial brain mask
+    upperThresholdFactorPre:
+    # type=float|default=0.0: Upper threshold factor for finding an initial brain mask
+    lowerThresholdFactor:
+    # type=float|default=0.0: Lower threshold factor for defining the brain mask
+    upperThresholdFactor:
+    # type=float|default=0.0: Upper threshold factor for defining the brain mask
+    boundingBoxSize:
+    # type=inputmultiobject|default=[]: Size of the cubic bounding box mask used when no brain mask is present
+    boundingBoxStart:
+    # type=inputmultiobject|default=[]: XYZ point-coordinate for the start of the cubic bounding box mask used when no brain mask is present
+    numberOfThreads:
+    # type=int|default=0: Explicitly specify the maximum number of threads to use.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_mush_callables.py b/example-specs/task/nipype_internal/pydra-semtools/brains_mush_callables.py
new file mode 100644
index 00000000..71bacf88
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/brains_mush_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in BRAINSMush.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_posterior_to_continuous_class.yaml b/example-specs/task/nipype_internal/pydra-semtools/brains_posterior_to_continuous_class.yaml
new file mode 100644
index 00000000..94ab5773
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/brains_posterior_to_continuous_class.yaml
@@ -0,0 +1,115 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.brains.classify.BRAINSPosteriorToContinuousClass' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Tissue Classification
+# 
+#     category: BRAINS.Classify
+# 
+#     description: This program will generate an 8-bit continuous tissue classified image based on BRAINSABC posterior images.
+# 
+#     version: 3.0
+# 
+#     documentation-url: http://www.nitrc.org/plugins/mwiki/index.php/brains:BRAINSClassify
+# 
+#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
+# 
+#     contributor: Vincent A. Magnotta
+# 
+#     acknowledgements: Funding for this work was provided by NIH/NINDS award NS050568
+#     
+task_name: BRAINSPosteriorToContinuousClass
+nipype_name: BRAINSPosteriorToContinuousClass
+nipype_module: nipype.interfaces.semtools.brains.classify
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputWhiteVolume: generic/file
+    # type=file|default=<undefined>: White Matter Posterior Volume
+    inputBasalGmVolume: generic/file
+    # type=file|default=<undefined>: Basal Grey Matter Posterior Volume
+    inputSurfaceGmVolume: generic/file
+    # type=file|default=<undefined>: Surface Grey Matter Posterior Volume
+    inputCsfVolume: generic/file
+    # type=file|default=<undefined>: CSF Posterior Volume
+    inputVbVolume: generic/file
+    # type=file|default=<undefined>: Venous Blood Posterior Volume
+    inputCrblGmVolume: generic/file
+    # type=file|default=<undefined>: Cerebellum Grey Matter Posterior Volume
+    inputCrblWmVolume: generic/file
+    # type=file|default=<undefined>: Cerebellum White Matter Posterior Volume
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputVolume: generic/file
+    # type=file: Output Continuous Tissue Classified Image
+    # type=traitcompound|default=None: Output Continuous Tissue Classified Image
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputWhiteVolume:
+    # type=file|default=<undefined>: White Matter Posterior Volume
+    inputBasalGmVolume:
+    # type=file|default=<undefined>: Basal Grey Matter Posterior Volume
+    inputSurfaceGmVolume:
+    # type=file|default=<undefined>: Surface Grey Matter Posterior Volume
+    inputCsfVolume:
+    # type=file|default=<undefined>: CSF Posterior Volume
+    inputVbVolume:
+    # type=file|default=<undefined>: Venous Blood Posterior Volume
+    inputCrblGmVolume:
+    # type=file|default=<undefined>: Cerebellum Grey Matter Posterior Volume
+    inputCrblWmVolume:
+    # type=file|default=<undefined>: Cerebellum White Matter Posterior Volume
+    outputVolume:
+    # type=file: Output Continuous Tissue Classified Image
+    # type=traitcompound|default=None: Output Continuous Tissue Classified Image
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_posterior_to_continuous_class_callables.py b/example-specs/task/nipype_internal/pydra-semtools/brains_posterior_to_continuous_class_callables.py
new file mode 100644
index 00000000..3e1c01af
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/brains_posterior_to_continuous_class_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in BRAINSPosteriorToContinuousClass.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_resample.yaml b/example-specs/task/nipype_internal/pydra-semtools/brains_resample.yaml
new file mode 100644
index 00000000..4821a423
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/brains_resample.yaml
@@ -0,0 +1,115 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.registration.brainsresample.BRAINSResample' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Resample Image (BRAINS)
+# 
+#     category: Registration
+# 
+#     description: This program collects together three common image processing tasks that all involve resampling an image volume: Resampling to a new resolution and spacing, applying a transformation (using an ITK transform IO mechanisms) and Warping (using a vector image deformation field).  Full documentation available here: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/BRAINSResample.
+# 
+#     version: 3.0.0
+# 
+#     documentation-url: http://www.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/BRAINSResample
+# 
+#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
+# 
+#     contributor: This tool was developed by Vincent Magnotta, Greg Harris, and Hans Johnson.
+# 
+#     acknowledgements: The development of this tool was supported by funding from grants NS050568 and NS40068 from the National Institute of Neurological Disorders and Stroke and grants MH31593, MH40856, from the National Institute of Mental Health.
+#     
+task_name: BRAINSResample
+nipype_name: BRAINSResample
+nipype_module: nipype.interfaces.semtools.registration.brainsresample
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputVolume: generic/file
+    # type=file|default=<undefined>: Image To Warp
+    referenceVolume: generic/file
+    # type=file|default=<undefined>: Reference image used only to define the output space. If not specified, the warping is done in the same space as the image to warp.
+    deformationVolume: generic/file
+    # type=file|default=<undefined>: Displacement Field to be used to warp the image (ITKv3 or earlier)
+    warpTransform: generic/file
+    # type=file|default=<undefined>: Filename for the BRAINSFit transform (ITKv3 or earlier) or composite transform file (ITKv4)
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputVolume: generic/file
+    # type=file: Resulting deformed image
+    # type=traitcompound|default=None: Resulting deformed image
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputVolume:
+    # type=file|default=<undefined>: Image To Warp
+    referenceVolume:
+    # type=file|default=<undefined>: Reference image used only to define the output space. If not specified, the warping is done in the same space as the image to warp.
+    outputVolume:
+    # type=file: Resulting deformed image
+    # type=traitcompound|default=None: Resulting deformed image
+    pixelType:
+    # type=enum|default='float'|allowed['binary','float','int','short','uchar','uint','ushort']: Specifies the pixel type for the input/output images.  The 'binary' pixel type uses a modified algorithm whereby the image is read in as unsigned char, a signed distance map is created, signed distance map is resampled, and then a thresholded image of type unsigned char is written to disk.
+    deformationVolume:
+    # type=file|default=<undefined>: Displacement Field to be used to warp the image (ITKv3 or earlier)
+    warpTransform:
+    # type=file|default=<undefined>: Filename for the BRAINSFit transform (ITKv3 or earlier) or composite transform file (ITKv4)
+    interpolationMode:
+    # type=enum|default='NearestNeighbor'|allowed['BSpline','Blackman','Cosine','Hamming','Lanczos','Linear','NearestNeighbor','ResampleInPlace','Welch','WindowedSinc']: Type of interpolation to be used when applying transform to moving volume.  Options are Linear, ResampleInPlace, NearestNeighbor, BSpline, or WindowedSinc
+    inverseTransform:
+    # type=bool|default=False: True/False is to compute inverse of given transformation. Default is false
+    defaultValue:
+    # type=float|default=0.0: Default voxel value
+    gridSpacing:
+    # type=inputmultiobject|default=[]: Add warped grid to output image to help show the deformation that occurred with specified spacing.   A spacing of 0 in a dimension indicates that grid lines should be rendered to fall exactly (i.e. do not allow displacements off that plane).  This is useful for making a 2D image of grid lines from the 3D space
+    numberOfThreads:
+    # type=int|default=0: Explicitly specify the maximum number of threads to use.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_resample_callables.py b/example-specs/task/nipype_internal/pydra-semtools/brains_resample_callables.py
new file mode 100644
index 00000000..e8e4b158
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/brains_resample_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in BRAINSResample.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_resize.yaml b/example-specs/task/nipype_internal/pydra-semtools/brains_resize.yaml
new file mode 100644
index 00000000..b36c41ff
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/brains_resize.yaml
@@ -0,0 +1,93 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.registration.brainsresize.BRAINSResize' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Resize Image (BRAINS)
+# 
+#     category: Registration
+# 
+#     description: This program is useful for downsampling an image by a constant scale factor.
+# 
+#     version: 3.0.0
+# 
+#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
+# 
+#     contributor: This tool was developed by Hans Johnson.
+# 
+#     acknowledgements: The development of this tool was supported by funding from grants NS050568 and NS40068 from the National Institute of Neurological Disorders and Stroke and grants MH31593, MH40856, from the National Institute of Mental Health.
+#     
+task_name: BRAINSResize
+nipype_name: BRAINSResize
+nipype_module: nipype.interfaces.semtools.registration.brainsresize
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputVolume: generic/file
+    # type=file|default=<undefined>: Image To Scale
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputVolume: generic/file
+    # type=file: Resulting scaled image
+    # type=traitcompound|default=None: Resulting scaled image
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputVolume:
+    # type=file|default=<undefined>: Image To Scale
+    outputVolume:
+    # type=file: Resulting scaled image
+    # type=traitcompound|default=None: Resulting scaled image
+    pixelType:
+    # type=enum|default='float'|allowed['binary','float','int','short','uchar','uint','ushort']: Specifies the pixel type for the input/output images.  The 'binary' pixel type uses a modified algorithm whereby the image is read in as unsigned char, a signed distance map is created, signed distance map is resampled, and then a thresholded image of type unsigned char is written to disk.
+    scaleFactor:
+    # type=float|default=0.0: The scale factor for the image spacing.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_resize_callables.py b/example-specs/task/nipype_internal/pydra-semtools/brains_resize_callables.py
new file mode 100644
index 00000000..c2bd8950
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/brains_resize_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in BRAINSResize.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_snap_shot_writer.yaml b/example-specs/task/nipype_internal/pydra-semtools/brains_snap_shot_writer.yaml
new file mode 100644
index 00000000..5697e012
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/brains_snap_shot_writer.yaml
@@ -0,0 +1,99 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.utilities.brains.BRAINSSnapShotWriter' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: BRAINSSnapShotWriter
+# 
+#     category: Utilities.BRAINS
+# 
+#     description: Create 2D snapshot of input images. Mask images are color-coded
+# 
+#     version: 1.0
+# 
+#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
+# 
+#     contributor: Eunyoung Regina Kim
+#     
+task_name: BRAINSSnapShotWriter
+nipype_name: BRAINSSnapShotWriter
+nipype_module: nipype.interfaces.semtools.utilities.brains
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputVolumes: generic/file+list-of
+    # type=inputmultiobject|default=[]: Input image volume list to be extracted as 2D image. Multiple input is possible. At least one input is required.
+    inputBinaryVolumes: generic/file+list-of
+    # type=inputmultiobject|default=[]: Input mask (binary) volume list to be extracted as 2D image. Multiple input is possible.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputFilename: generic/file
+    # type=file: 2D file name of input images. Required.
+    # type=traitcompound|default=None: 2D file name of input images. Required.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputVolumes:
+    # type=inputmultiobject|default=[]: Input image volume list to be extracted as 2D image. Multiple input is possible. At least one input is required.
+    inputBinaryVolumes:
+    # type=inputmultiobject|default=[]: Input mask (binary) volume list to be extracted as 2D image. Multiple input is possible.
+    inputSliceToExtractInPhysicalPoint:
+    # type=inputmultiobject|default=[]: 2D slice number of input images. For autoWorkUp output, which AC-PC aligned, 0,0,0 will be the center.
+    inputSliceToExtractInIndex:
+    # type=inputmultiobject|default=[]: 2D slice number of input images. For size of 256*256*256 image, 128 is usually used.
+    inputSliceToExtractInPercent:
+    # type=inputmultiobject|default=[]: 2D slice number of input images. Percentage input from 0%-100%. (ex. --inputSliceToExtractInPercent 50,50,50
+    inputPlaneDirection:
+    # type=inputmultiobject|default=[]: Plane to display. In general, 0=sagittal, 1=coronal, and 2=axial plane.
+    outputFilename:
+    # type=file: 2D file name of input images. Required.
+    # type=traitcompound|default=None: 2D file name of input images. Required.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_snap_shot_writer_callables.py b/example-specs/task/nipype_internal/pydra-semtools/brains_snap_shot_writer_callables.py
new file mode 100644
index 00000000..789aac69
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/brains_snap_shot_writer_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in BRAINSSnapShotWriter.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_talairach.yaml b/example-specs/task/nipype_internal/pydra-semtools/brains_talairach.yaml
new file mode 100644
index 00000000..5707024d
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/brains_talairach.yaml
@@ -0,0 +1,113 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.brains.segmentation.BRAINSTalairach' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: BRAINS Talairach
+# 
+#     category: BRAINS.Segmentation
+# 
+#     description: This program creates a VTK structured grid defining the Talairach coordinate system based on four points: AC, PC, IRP, and SLA. The resulting structured grid can be written as either a classic VTK file or the new VTK XML file format. Two representations of the resulting grid can be written. The first is a bounding box representation that also contains the location of the AC and PC points. The second representation is the full Talairach grid representation that includes the additional rows of boxes added to the inferior allowing full coverage of the cerebellum.
+# 
+#     version: 0.1
+# 
+#     documentation-url: http://www.nitrc.org/plugins/mwiki/index.php/brains:BRAINSTalairach
+# 
+#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
+# 
+#     contributor: Steven Dunn and Vincent Magnotta
+# 
+#     acknowledgements: Funding for this work was provided by NIH/NINDS award NS050568
+#     
+task_name: BRAINSTalairach
+nipype_name: BRAINSTalairach
+nipype_module: nipype.interfaces.semtools.brains.segmentation
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputVolume: generic/file
+    # type=file|default=<undefined>: Input image used to define physical space of images
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputBox: generic/file
+    # type=file: Name of the resulting Talairach Bounding Box file
+    # type=traitcompound|default=None: Name of the resulting Talairach Bounding Box file
+    outputGrid: generic/file
+    # type=file: Name of the resulting Talairach Grid file
+    # type=traitcompound|default=None: Name of the resulting Talairach Grid file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    AC:
+    # type=inputmultiobject|default=[]: Location of AC Point 
+    ACisIndex:
+    # type=bool|default=False: AC Point is Index
+    PC:
+    # type=inputmultiobject|default=[]: Location of PC Point 
+    PCisIndex:
+    # type=bool|default=False: PC Point is Index
+    SLA:
+    # type=inputmultiobject|default=[]: Location of SLA Point 
+    SLAisIndex:
+    # type=bool|default=False: SLA Point is Index
+    IRP:
+    # type=inputmultiobject|default=[]: Location of IRP Point 
+    IRPisIndex:
+    # type=bool|default=False: IRP Point is Index
+    inputVolume:
+    # type=file|default=<undefined>: Input image used to define physical space of images
+    outputBox:
+    # type=file: Name of the resulting Talairach Bounding Box file
+    # type=traitcompound|default=None: Name of the resulting Talairach Bounding Box file
+    outputGrid:
+    # type=file: Name of the resulting Talairach Grid file
+    # type=traitcompound|default=None: Name of the resulting Talairach Grid file
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_talairach_callables.py b/example-specs/task/nipype_internal/pydra-semtools/brains_talairach_callables.py
new file mode 100644
index 00000000..c5f88d78
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/brains_talairach_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in BRAINSTalairach.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_talairach_mask.yaml b/example-specs/task/nipype_internal/pydra-semtools/brains_talairach_mask.yaml
new file mode 100644
index 00000000..230b57c5
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/brains_talairach_mask.yaml
@@ -0,0 +1,103 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.brains.segmentation.BRAINSTalairachMask' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Talairach Mask
+# 
+#     category: BRAINS.Segmentation
+# 
+#     description: This program creates a binary image representing the specified Talairach region. The input is an example image to define the physical space for the resulting image, the Talairach grid representation in VTK format, and the file containing the Talairach box definitions to be generated. These can be combined in BRAINS to create a label map using the procedure Brains::WorkupUtils::CreateLabelMapFromBinaryImages.
+# 
+#     version: 0.1
+# 
+#     documentation-url: http://www.nitrc.org/plugins/mwiki/index.php/brains:BRAINSTalairachMask
+# 
+#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
+# 
+#     contributor: Steven Dunn and Vincent Magnotta
+# 
+#     acknowledgements: Funding for this work was provided by NIH/NINDS award NS050568
+#     
+task_name: BRAINSTalairachMask
+nipype_name: BRAINSTalairachMask
+nipype_module: nipype.interfaces.semtools.brains.segmentation
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputVolume: generic/file
+    # type=file|default=<undefined>: Input image used to define physical space of resulting mask
+    talairachParameters: generic/file
+    # type=file|default=<undefined>: Name of the Talairach parameter file.
+    talairachBox: generic/file
+    # type=file|default=<undefined>: Name of the Talairach box file.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputVolume: generic/file
+    # type=file: Output filename for the resulting binary image
+    # type=traitcompound|default=None: Output filename for the resulting binary image
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputVolume:
+    # type=file|default=<undefined>: Input image used to define physical space of resulting mask
+    talairachParameters:
+    # type=file|default=<undefined>: Name of the Talairach parameter file.
+    talairachBox:
+    # type=file|default=<undefined>: Name of the Talairach box file.
+    hemisphereMode:
+    # type=enum|default='left'|allowed['both','left','right']: Mode for box creation: left, right, both
+    expand:
+    # type=bool|default=False: Expand exterior box to include surface CSF
+    outputVolume:
+    # type=file: Output filename for the resulting binary image
+    # type=traitcompound|default=None: Output filename for the resulting binary image
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_talairach_mask_callables.py b/example-specs/task/nipype_internal/pydra-semtools/brains_talairach_mask_callables.py
new file mode 100644
index 00000000..9e5b751f
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/brains_talairach_mask_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in BRAINSTalairachMask.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_transform_convert.yaml b/example-specs/task/nipype_internal/pydra-semtools/brains_transform_convert.yaml
new file mode 100644
index 00000000..dd05c38e
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/brains_transform_convert.yaml
@@ -0,0 +1,103 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.utilities.brains.BRAINSTransformConvert' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: BRAINS Transform Convert
+# 
+#     category: Utilities.BRAINS
+# 
+#     description: Convert ITK transforms to higher order transforms
+# 
+#     version: 1.0
+# 
+#     documentation-url: A utility to convert between transform file formats.
+# 
+#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
+# 
+#     contributor: Hans J. Johnson,Kent Williams, Ali Ghayoor
+#     
+task_name: BRAINSTransformConvert
+nipype_name: BRAINSTransformConvert
+nipype_module: nipype.interfaces.semtools.utilities.brains
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputTransform: generic/file
+    # type=file|default=<undefined>: 
+    referenceVolume: generic/file
+    # type=file|default=<undefined>: 
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    displacementVolume: generic/file
+    # type=file: 
+    # type=traitcompound|default=None: 
+    outputTransform: generic/file
+    # type=file: 
+    # type=traitcompound|default=None: 
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputTransform:
+    # type=file|default=<undefined>: 
+    referenceVolume:
+    # type=file|default=<undefined>: 
+    outputTransformType:
+    # type=enum|default='Affine'|allowed['Affine','DisplacementField','Same','ScaleSkewVersor','ScaleVersor','VersorRigid']: The target transformation type. Must be conversion-compatible with the input transform type
+    outputPrecisionType:
+    # type=enum|default='double'|allowed['double','float']: Precision type of the output transform. It can be either single precision or double precision
+    displacementVolume:
+    # type=file: 
+    # type=traitcompound|default=None: 
+    outputTransform:
+    # type=file: 
+    # type=traitcompound|default=None: 
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_transform_convert_callables.py b/example-specs/task/nipype_internal/pydra-semtools/brains_transform_convert_callables.py
new file mode 100644
index 00000000..bd22c4e3
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/brains_transform_convert_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in BRAINSTransformConvert.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_transform_from_fiducials.yaml b/example-specs/task/nipype_internal/pydra-semtools/brains_transform_from_fiducials.yaml
new file mode 100644
index 00000000..6cab2456
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/brains_transform_from_fiducials.yaml
@@ -0,0 +1,101 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.registration.specialized.BRAINSTransformFromFiducials' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Fiducial Registration (BRAINS)
+# 
+#     category: Registration.Specialized
+# 
+#     description: Computes a rigid, similarity or affine transform from a matched list of fiducials
+# 
+#     version: 0.1.0.$Revision$
+# 
+#     documentation-url: http://www.slicer.org/slicerWiki/index.php/Modules:TransformFromFiducials-Documentation-3.6
+# 
+#     contributor: Casey B Goodlett
+# 
+#     acknowledgements: This work is part of the National Alliance for Medical Image Computing (NAMIC), funded by the National Institutes of Health through the NIH Roadmap for Medical Research, Grant U54 EB005149.
+#     
+task_name: BRAINSTransformFromFiducials
+nipype_name: BRAINSTransformFromFiducials
+nipype_module: nipype.interfaces.semtools.registration.specialized
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    fixedLandmarksFile: generic/file
+    # type=file|default=<undefined>: An fcsv formatted file with a list of landmark points.
+    movingLandmarksFile: generic/file
+    # type=file|default=<undefined>: An fcsv formatted file with a list of landmark points.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    saveTransform: generic/file
+    # type=file: Save the transform that results from registration
+    # type=traitcompound|default=None: Save the transform that results from registration
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    fixedLandmarks:
+    # type=inputmultiobject|default=[]: Ordered list of landmarks in the fixed image
+    movingLandmarks:
+    # type=inputmultiobject|default=[]: Ordered list of landmarks in the moving image
+    saveTransform:
+    # type=file: Save the transform that results from registration
+    # type=traitcompound|default=None: Save the transform that results from registration
+    transformType:
+    # type=enum|default='Translation'|allowed['Rigid','Similarity','Translation']: Type of transform to produce
+    fixedLandmarksFile:
+    # type=file|default=<undefined>: An fcsv formatted file with a list of landmark points.
+    movingLandmarksFile:
+    # type=file|default=<undefined>: An fcsv formatted file with a list of landmark points.
+    numberOfThreads:
+    # type=int|default=0: Explicitly specify the maximum number of threads to use.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_transform_from_fiducials_callables.py b/example-specs/task/nipype_internal/pydra-semtools/brains_transform_from_fiducials_callables.py
new file mode 100644
index 00000000..2f189fd2
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/brains_transform_from_fiducials_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in BRAINSTransformFromFiducials.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_trim_foreground_in_direction.yaml b/example-specs/task/nipype_internal/pydra-semtools/brains_trim_foreground_in_direction.yaml
new file mode 100644
index 00000000..81da64c6
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/brains_trim_foreground_in_direction.yaml
@@ -0,0 +1,97 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.utilities.brains.BRAINSTrimForegroundInDirection' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Trim Foreground In Direction (BRAINS)
+# 
+#     category: Utilities.BRAINS
+# 
+#     description: This program will trim off the neck and also air-filling noise from the inputImage.
+# 
+#     version: 0.1
+# 
+#     documentation-url: http://www.nitrc.org/projects/art/
+#     
+task_name: BRAINSTrimForegroundInDirection
+nipype_name: BRAINSTrimForegroundInDirection
+nipype_module: nipype.interfaces.semtools.utilities.brains
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputVolume: generic/file
+    # type=file|default=<undefined>: Input image to trim off the neck (and also air-filling noise.)
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputVolume: generic/file
+    # type=file: Output image with neck and air-filling noise trimmed isotropic image with AC at center of image.
+    # type=traitcompound|default=None: Output image with neck and air-filling noise trimmed isotropic image with AC at center of image.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputVolume:
+    # type=file|default=<undefined>: Input image to trim off the neck (and also air-filling noise.)
+    outputVolume:
+    # type=file: Output image with neck and air-filling noise trimmed isotropic image with AC at center of image.
+    # type=traitcompound|default=None: Output image with neck and air-filling noise trimmed isotropic image with AC at center of image.
+    directionCode:
+    # type=int|default=0: ,                 This flag chooses which dimension to compare.  The sign lets you flip direction.,             
+    otsuPercentileThreshold:
+    # type=float|default=0.0: ,                 This is a parameter to FindLargestForegroundFilledMask, which is employed to trim off air-filling noise.,             
+    closingSize:
+    # type=int|default=0: ,                 This is a parameter to FindLargestForegroundFilledMask,             
+    headSizeLimit:
+    # type=float|default=0.0: ,                 Use this to vary from the command line our search for how much upper tissue is head for the center-of-mass calculation.  Units are CCs, not cubic millimeters.,             
+    BackgroundFillValue:
+    # type=str|default='': Fill the background of image with specified short int value. Enter number or use BIGNEG for a large negative number.
+    numberOfThreads:
+    # type=int|default=0: Explicitly specify the maximum number of threads to use.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_trim_foreground_in_direction_callables.py b/example-specs/task/nipype_internal/pydra-semtools/brains_trim_foreground_in_direction_callables.py
new file mode 100644
index 00000000..78a1bd14
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/brains_trim_foreground_in_direction_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in BRAINSTrimForegroundInDirection.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brainsabc.yaml b/example-specs/task/nipype_internal/pydra-semtools/brainsabc.yaml
new file mode 100644
index 00000000..2a63237a
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/brainsabc.yaml
@@ -0,0 +1,167 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.segmentation.specialized.BRAINSABC' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Intra-subject registration, bias Correction, and tissue classification (BRAINS)
+# 
+#     category: Segmentation.Specialized
+# 
+#     description: Atlas-based tissue segmentation method.  This is an algorithmic extension of work done by XXXX at UNC and Utah XXXX need more description here.
+#     
+task_name: BRAINSABC
+nipype_name: BRAINSABC
+nipype_module: nipype.interfaces.semtools.segmentation.specialized
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputVolumes: generic/file+list-of
+    # type=inputmultiobject|default=[]: The list of input image files to be segmented.
+    atlasDefinition: generic/file
+    # type=file|default=<undefined>: Contains all parameters for Atlas
+    restoreState: generic/file
+    # type=file|default=<undefined>: The initial state for the registration process
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    saveState: generic/file
+    # type=file: (optional) Filename to which save the final state of the registration
+    # type=traitcompound|default=None: (optional) Filename to which save the final state of the registration
+    atlasToSubjectTransform: generic/file
+    # type=file: The transform from atlas to the subject
+    # type=traitcompound|default=None: The transform from atlas to the subject
+    atlasToSubjectInitialTransform: generic/file
+    # type=file: The initial transform from atlas to the subject
+    # type=traitcompound|default=None: The initial transform from atlas to the subject
+    outputLabels: generic/file
+    # type=file: Output Label Image
+    # type=traitcompound|default=None: Output Label Image
+    outputDirtyLabels: generic/file
+    # type=file: Output Dirty Label Image
+    # type=traitcompound|default=None: Output Dirty Label Image
+    outputDir: generic/directory
+    # type=directory: Output directory
+    # type=traitcompound|default=None: Output directory
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputVolumes:
+    # type=inputmultiobject|default=[]: The list of input image files to be segmented.
+    atlasDefinition:
+    # type=file|default=<undefined>: Contains all parameters for Atlas
+    restoreState:
+    # type=file|default=<undefined>: The initial state for the registration process
+    saveState:
+    # type=file: (optional) Filename to which save the final state of the registration
+    # type=traitcompound|default=None: (optional) Filename to which save the final state of the registration
+    inputVolumeTypes:
+    # type=inputmultiobject|default=[]: The list of input image types corresponding to the inputVolumes.
+    outputDir:
+    # type=directory: Output directory
+    # type=traitcompound|default=None: Output directory
+    atlasToSubjectTransformType:
+    # type=enum|default='Identity'|allowed['Affine','BSpline','Identity','Rigid','SyN']:  What type of linear transform type do you want to use to register the atlas to the reference subject image.
+    atlasToSubjectTransform:
+    # type=file: The transform from atlas to the subject
+    # type=traitcompound|default=None: The transform from atlas to the subject
+    atlasToSubjectInitialTransform:
+    # type=file: The initial transform from atlas to the subject
+    # type=traitcompound|default=None: The initial transform from atlas to the subject
+    subjectIntermodeTransformType:
+    # type=enum|default='Identity'|allowed['Affine','BSpline','Identity','Rigid']:  What type of linear transform type do you want to use to register the atlas to the reference subject image.
+    outputVolumes:
+    # type=outputmultiobject: Corrected Output Images: should specify the same number of images as inputVolume, if only one element is given, then it is used as a file pattern where %s is replaced by the imageVolumeType, and %d by the index list location.
+    # type=traitcompound|default=[None]: Corrected Output Images: should specify the same number of images as inputVolume, if only one element is given, then it is used as a file pattern where %s is replaced by the imageVolumeType, and %d by the index list location.
+    outputLabels:
+    # type=file: Output Label Image
+    # type=traitcompound|default=None: Output Label Image
+    outputDirtyLabels:
+    # type=file: Output Dirty Label Image
+    # type=traitcompound|default=None: Output Dirty Label Image
+    posteriorTemplate:
+    # type=str|default='': filename template for Posterior output files
+    outputFormat:
+    # type=enum|default='NIFTI'|allowed['Meta','NIFTI','Nrrd']: Output format
+    interpolationMode:
+    # type=enum|default='BSpline'|allowed['BSpline','Blackman','Cosine','Hamming','Lanczos','Linear','NearestNeighbor','ResampleInPlace','Welch','WindowedSinc']: Type of interpolation to be used when applying transform to moving volume.  Options are Linear, NearestNeighbor, BSpline, WindowedSinc, or ResampleInPlace.  The ResampleInPlace option will create an image with the same discrete voxel values and will adjust the origin and direction of the physical space interpretation.
+    maxIterations:
+    # type=int|default=0: Filter iterations
+    medianFilterSize:
+    # type=inputmultiobject|default=[]: The radius for the optional MedianImageFilter preprocessing in all 3 directions.
+    filterIteration:
+    # type=int|default=0: Filter iterations
+    filterTimeStep:
+    # type=float|default=0.0: Filter time step should be less than (PixelSpacing/(1^(DIM+1)), value is set to negative, then allow automatic setting of this value. 
+    filterMethod:
+    # type=enum|default='None'|allowed['CurvatureFlow','GradientAnisotropicDiffusion','Median','None']: Filter method for preprocessing of registration
+    maxBiasDegree:
+    # type=int|default=0: Maximum bias degree
+    useKNN:
+    # type=bool|default=False: Use the KNN stage of estimating posteriors.
+    purePlugsThreshold:
+    # type=float|default=0.0: If this threshold value is greater than zero, only pure samples are used to compute the distributions in EM classification, and only pure samples are used for KNN training. The default value is set to 0, that means not using pure plugs. However, a value of 0.2 is suggested if you want to activate using pure plugs option.
+    numberOfSubSamplesInEachPlugArea:
+    # type=inputmultiobject|default=[]: Number of continuous index samples taken at each direction of lattice space for each plug volume.
+    atlasWarpingOff:
+    # type=bool|default=False: Deformable registration of atlas to subject
+    gridSize:
+    # type=inputmultiobject|default=[]: Grid size for atlas warping with BSplines
+    defaultSuffix:
+    # type=str|default='': 
+    implicitOutputs:
+    # type=outputmultiobject: Outputs to be made available to NiPype. Needed because not all BRAINSABC outputs have command line arguments.
+    # type=traitcompound|default=[None]: Outputs to be made available to NiPype. Needed because not all BRAINSABC outputs have command line arguments.
+    debuglevel:
+    # type=int|default=0: Display debug messages, and produce debug intermediate results.  0=OFF, 1=Minimal, 10=Maximum debugging.
+    writeLess:
+    # type=bool|default=False: Does not write posteriors and filtered, bias corrected images
+    numberOfThreads:
+    # type=int|default=0: Explicitly specify the maximum number of threads to use.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brainsabc_callables.py b/example-specs/task/nipype_internal/pydra-semtools/brainsabc_callables.py
new file mode 100644
index 00000000..c7eba2e0
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/brainsabc_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in BRAINSABC.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brainsroi_auto.yaml b/example-specs/task/nipype_internal/pydra-semtools/brainsroi_auto.yaml
new file mode 100644
index 00000000..dc81ec25
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/brainsroi_auto.yaml
@@ -0,0 +1,111 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.segmentation.specialized.BRAINSROIAuto' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Foreground masking (BRAINS)
+# 
+#     category: Segmentation.Specialized
+# 
+#     description: This program is used to create a mask over the most prominent foreground region in an image.  This is accomplished via a combination of otsu thresholding and a closing operation.  More documentation is available here: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/ForegroundMasking.
+# 
+#     version: 2.4.1
+# 
+#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
+# 
+#     contributor: Hans J. Johnson, hans-johnson -at- uiowa.edu, http://www.psychiatry.uiowa.edu
+# 
+#     acknowledgements: Hans Johnson(1,3,4); Kent Williams(1); Gregory Harris(1), Vincent Magnotta(1,2,3);  Andriy Fedorov(5), fedorov -at- bwh.harvard.edu (Slicer integration); (1=University of Iowa Department of Psychiatry, 2=University of Iowa Department of Radiology, 3=University of Iowa Department of Biomedical Engineering, 4=University of Iowa Department of Electrical and Computer Engineering, 5=Surgical Planning Lab, Harvard)
+#     
+task_name: BRAINSROIAuto
+nipype_name: BRAINSROIAuto
+nipype_module: nipype.interfaces.semtools.segmentation.specialized
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputVolume: generic/file
+    # type=file|default=<undefined>: The input image for finding the largest region filled mask.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputROIMaskVolume: generic/file
+    # type=file: The ROI automatically found from the input image.
+    # type=traitcompound|default=None: The ROI automatically found from the input image.
+    outputVolume: generic/file
+    # type=file: The inputVolume with optional [maskOutput|cropOutput] to the region of the brain mask.
+    # type=traitcompound|default=None: The inputVolume with optional [maskOutput|cropOutput] to the region of the brain mask.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputVolume:
+    # type=file|default=<undefined>: The input image for finding the largest region filled mask.
+    outputROIMaskVolume:
+    # type=file: The ROI automatically found from the input image.
+    # type=traitcompound|default=None: The ROI automatically found from the input image.
+    outputVolume:
+    # type=file: The inputVolume with optional [maskOutput|cropOutput] to the region of the brain mask.
+    # type=traitcompound|default=None: The inputVolume with optional [maskOutput|cropOutput] to the region of the brain mask.
+    maskOutput:
+    # type=bool|default=False: The inputVolume multiplied by the ROI mask.
+    cropOutput:
+    # type=bool|default=False: The inputVolume cropped to the region of the ROI mask.
+    otsuPercentileThreshold:
+    # type=float|default=0.0: Parameter to the Otsu threshold algorithm.
+    thresholdCorrectionFactor:
+    # type=float|default=0.0: A factor to scale the Otsu algorithm's result threshold, in case clipping mangles the image.
+    closingSize:
+    # type=float|default=0.0: The Closing Size (in millimeters) for largest connected filled mask.  This value is divided by image spacing and rounded to the next largest voxel number.
+    ROIAutoDilateSize:
+    # type=float|default=0.0: This flag is only relevant when using ROIAUTO mode for initializing masks.  It defines the final dilation size to capture a bit of background outside the tissue region.  At setting of 10mm has been shown to help regularize a BSpline registration type so that there is some background constraints to match the edges of the head better.
+    outputVolumePixelType:
+    # type=enum|default='float'|allowed['float','int','short','uchar','uint','ushort']: The output image Pixel Type is the scalar datatype for representation of the Output Volume.
+    numberOfThreads:
+    # type=int|default=0: Explicitly specify the maximum number of threads to use.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brainsroi_auto_callables.py b/example-specs/task/nipype_internal/pydra-semtools/brainsroi_auto_callables.py
new file mode 100644
index 00000000..421d7dbf
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/brainsroi_auto_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in BRAINSROIAuto.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/canny_edge.yaml b/example-specs/task/nipype_internal/pydra-semtools/canny_edge.yaml
new file mode 100644
index 00000000..c590bb18
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/canny_edge.yaml
@@ -0,0 +1,95 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.filtering.featuredetection.CannyEdge' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Canny Edge Detection
+# 
+#     category: Filtering.FeatureDetection
+# 
+#     description: Get the distance from a voxel to the nearest voxel of a given tissue type.
+# 
+#     version: 0.1.0.(alpha)
+# 
+#     documentation-url: http:://www.na-mic.org/
+# 
+#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
+# 
+#     contributor: This tool was written by Hans J. Johnson.
+#     
+task_name: CannyEdge
+nipype_name: CannyEdge
+nipype_module: nipype.interfaces.semtools.filtering.featuredetection
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputVolume: generic/file
+    # type=file|default=<undefined>: Required: input tissue label image
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputVolume: generic/file
+    # type=file: Required: output image
+    # type=traitcompound|default=None: Required: output image
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputVolume:
+    # type=file|default=<undefined>: Required: input tissue label image
+    variance:
+    # type=float|default=0.0: Variance and Maximum error are used in the Gaussian smoothing of the input image.  See  itkDiscreteGaussianImageFilter for information on these parameters.
+    upperThreshold:
+    # type=float|default=0.0: Threshold is the lowest allowed value in the output image.  Its data type is the same as the data type of the output image. Any values below the Threshold level will be replaced with the OutsideValue parameter value, whose default is zero.  
+    lowerThreshold:
+    # type=float|default=0.0: Threshold is the lowest allowed value in the output image.  Its data type is the same as the data type of the output image. Any values below the Threshold level will be replaced with the OutsideValue parameter value, whose default is zero.  
+    outputVolume:
+    # type=file: Required: output image
+    # type=traitcompound|default=None: Required: output image
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/canny_edge_callables.py b/example-specs/task/nipype_internal/pydra-semtools/canny_edge_callables.py
new file mode 100644
index 00000000..5bd76b55
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/canny_edge_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in CannyEdge.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/canny_segmentation_level_set_image_filter.yaml b/example-specs/task/nipype_internal/pydra-semtools/canny_segmentation_level_set_image_filter.yaml
new file mode 100644
index 00000000..d062b252
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/canny_segmentation_level_set_image_filter.yaml
@@ -0,0 +1,109 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.filtering.featuredetection.CannySegmentationLevelSetImageFilter' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Canny Level Set Image Filter
+# 
+#     category: Filtering.FeatureDetection
+# 
+#     description: The CannySegmentationLevelSet is commonly used to refine a manually generated manual mask.
+# 
+#     version: 0.3.0
+# 
+#     license: CC
+# 
+#     contributor: Regina Kim
+# 
+#     acknowledgements: This command module was derived from Insight/Examples/Segmentation/CannySegmentationLevelSetImageFilter.cxx (copyright) Insight Software Consortium.  See http://wiki.na-mic.org/Wiki/index.php/Slicer3:Execution_Model_Documentation for more detailed descriptions.
+#     
+task_name: CannySegmentationLevelSetImageFilter
+nipype_name: CannySegmentationLevelSetImageFilter
+nipype_module: nipype.interfaces.semtools.filtering.featuredetection
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputVolume: generic/file
+    # type=file|default=<undefined>: 
+    initialModel: generic/file
+    # type=file|default=<undefined>: 
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputVolume: generic/file
+    # type=file: 
+    # type=traitcompound|default=None: 
+    outputSpeedVolume: generic/file
+    # type=file: 
+    # type=traitcompound|default=None: 
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputVolume:
+    # type=file|default=<undefined>: 
+    initialModel:
+    # type=file|default=<undefined>: 
+    outputVolume:
+    # type=file: 
+    # type=traitcompound|default=None: 
+    outputSpeedVolume:
+    # type=file: 
+    # type=traitcompound|default=None: 
+    cannyThreshold:
+    # type=float|default=0.0: Canny Threshold Value
+    cannyVariance:
+    # type=float|default=0.0: Canny variance
+    advectionWeight:
+    # type=float|default=0.0: Controls the smoothness of the resulting mask, small number are more smooth, large numbers allow more sharp corners.  
+    initialModelIsovalue:
+    # type=float|default=0.0: The identification of the input model iso-surface.  (for a binary image with 0s and 1s use 0.5) (for a binary image with 0s and 255's use 127.5).
+    maxIterations:
+    # type=int|default=0: The
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/canny_segmentation_level_set_image_filter_callables.py b/example-specs/task/nipype_internal/pydra-semtools/canny_segmentation_level_set_image_filter_callables.py
new file mode 100644
index 00000000..35463ffb
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/canny_segmentation_level_set_image_filter_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in CannySegmentationLevelSetImageFilter.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/clean_up_overlap_labels.yaml b/example-specs/task/nipype_internal/pydra-semtools/clean_up_overlap_labels.yaml
new file mode 100644
index 00000000..cf31bb7e
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/clean_up_overlap_labels.yaml
@@ -0,0 +1,82 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.utilities.brains.CleanUpOverlapLabels' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Clean Up Overla Labels
+# 
+#     category: Utilities.BRAINS
+# 
+#     description: Take a series of input binary images and clean up for those overlapped area. Binary volumes given first always wins out
+# 
+#     version: 0.1.0
+# 
+#     contributor: Eun Young Kim
+#     
+task_name: CleanUpOverlapLabels
+nipype_name: CleanUpOverlapLabels
+nipype_module: nipype.interfaces.semtools.utilities.brains
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputBinaryVolumes: generic/file+list-of
+    # type=inputmultiobject|default=[]: The list of binary images to be checked and cleaned up. Order is important. Binary volume given first always wins out. 
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputBinaryVolumes:
+    # type=inputmultiobject|default=[]: The list of binary images to be checked and cleaned up. Order is important. Binary volume given first always wins out. 
+    outputBinaryVolumes:
+    # type=outputmultiobject: The output label map images, with integer values in it. Each label value specified in the inputLabels is combined into this output label map volume
+    # type=traitcompound|default=[None]: The output label map images, with integer values in it. Each label value specified in the inputLabels is combined into this output label map volume
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/clean_up_overlap_labels_callables.py b/example-specs/task/nipype_internal/pydra-semtools/clean_up_overlap_labels_callables.py
new file mode 100644
index 00000000..6917490b
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/clean_up_overlap_labels_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in CleanUpOverlapLabels.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/compare_tract_inclusion.yaml b/example-specs/task/nipype_internal/pydra-semtools/compare_tract_inclusion.yaml
new file mode 100644
index 00000000..9899513e
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/compare_tract_inclusion.yaml
@@ -0,0 +1,101 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.diffusion.gtract.compareTractInclusion' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Compare Tracts
+# 
+#     category: Diffusion.GTRACT
+# 
+#     description: This program will halt with a status code indicating whether a test tract is nearly enough included in a standard tract in the sense that every fiber in the test tract has a low enough sum of squares distance to some fiber in the standard tract modulo spline resampling of every fiber to a fixed number of points.
+# 
+#     version: 4.0.0
+# 
+#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Modules:GTRACT
+# 
+#     license: http://mri.radiology.uiowa.edu/copyright/GTRACT-Copyright.txt
+# 
+#     contributor: This tool was developed by Vincent Magnotta and Greg Harris.
+# 
+#     acknowledgements: Funding for this version of the GTRACT program was provided by NIH/NINDS R01NS050568-01A2S1
+#     
+task_name: compareTractInclusion
+nipype_name: compareTractInclusion
+nipype_module: nipype.interfaces.semtools.diffusion.gtract
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    testFiber: generic/file
+    # type=file|default=<undefined>: Required: test fiber tract file name
+    standardFiber: generic/file
+    # type=file|default=<undefined>: Required: standard fiber tract file name
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    testFiber:
+    # type=file|default=<undefined>: Required: test fiber tract file name
+    standardFiber:
+    # type=file|default=<undefined>: Required: standard fiber tract file name
+    closeness:
+    # type=float|default=0.0: Closeness of every test fiber to some fiber in the standard tract, computed as a sum of squares of spatial differences of standard points
+    numberOfPoints:
+    # type=int|default=0: Number of points in comparison fiber pairs
+    testForBijection:
+    # type=bool|default=False: Flag to apply the closeness criterion both ways
+    testForFiberCardinality:
+    # type=bool|default=False: Flag to require the same number of fibers in both tracts
+    writeXMLPolyDataFile:
+    # type=bool|default=False: Flag to make use of XML files when reading and writing vtkPolyData.
+    numberOfThreads:
+    # type=int|default=0: Explicitly specify the maximum number of threads to use.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/compare_tract_inclusion_callables.py b/example-specs/task/nipype_internal/pydra-semtools/compare_tract_inclusion_callables.py
new file mode 100644
index 00000000..caa7221e
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/compare_tract_inclusion_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in compareTractInclusion.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/dilate_image.yaml b/example-specs/task/nipype_internal/pydra-semtools/dilate_image.yaml
new file mode 100644
index 00000000..7d27ffa6
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/dilate_image.yaml
@@ -0,0 +1,95 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.filtering.featuredetection.DilateImage' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Dilate Image
+# 
+#     category: Filtering.FeatureDetection
+# 
+#     description: Uses mathematical morphology to dilate the input images.
+# 
+#     version: 0.1.0.$Revision: 1 $(alpha)
+# 
+#     documentation-url: http:://www.na-mic.org/
+# 
+#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
+# 
+#     contributor: This tool was developed by Mark Scully and Jeremy Bockholt.
+#     
+task_name: DilateImage
+nipype_name: DilateImage
+nipype_module: nipype.interfaces.semtools.filtering.featuredetection
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputVolume: generic/file
+    # type=file|default=<undefined>: Required: input image
+    inputMaskVolume: generic/file
+    # type=file|default=<undefined>: Required: input brain mask image
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputVolume: generic/file
+    # type=file: Required: output image
+    # type=traitcompound|default=None: Required: output image
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputVolume:
+    # type=file|default=<undefined>: Required: input image
+    inputMaskVolume:
+    # type=file|default=<undefined>: Required: input brain mask image
+    inputRadius:
+    # type=int|default=0: Required: input neighborhood radius
+    outputVolume:
+    # type=file: Required: output image
+    # type=traitcompound|default=None: Required: output image
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/dilate_image_callables.py b/example-specs/task/nipype_internal/pydra-semtools/dilate_image_callables.py
new file mode 100644
index 00000000..a27b1b06
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/dilate_image_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in DilateImage.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/dilate_mask.yaml b/example-specs/task/nipype_internal/pydra-semtools/dilate_mask.yaml
new file mode 100644
index 00000000..76072602
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/dilate_mask.yaml
@@ -0,0 +1,97 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.filtering.featuredetection.DilateMask' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Dilate Image
+# 
+#     category: Filtering.FeatureDetection
+# 
+#     description: Uses mathematical morphology to dilate the input images.
+# 
+#     version: 0.1.0.$Revision: 1 $(alpha)
+# 
+#     documentation-url: http:://www.na-mic.org/
+# 
+#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
+# 
+#     contributor: This tool was developed by Mark Scully and Jeremy Bockholt.
+#     
+task_name: DilateMask
+nipype_name: DilateMask
+nipype_module: nipype.interfaces.semtools.filtering.featuredetection
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputVolume: generic/file
+    # type=file|default=<undefined>: Required: input image
+    inputBinaryVolume: generic/file
+    # type=file|default=<undefined>: Required: input brain mask image
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputVolume: generic/file
+    # type=file: Required: output image
+    # type=traitcompound|default=None: Required: output image
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputVolume:
+    # type=file|default=<undefined>: Required: input image
+    inputBinaryVolume:
+    # type=file|default=<undefined>: Required: input brain mask image
+    sizeStructuralElement:
+    # type=int|default=0: size of structural element. sizeStructuralElement=1 means that 3x3x3 structuring element for 3D
+    lowerThreshold:
+    # type=float|default=0.0: Required: lowerThreshold value
+    outputVolume:
+    # type=file: Required: output image
+    # type=traitcompound|default=None: Required: output image
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/dilate_mask_callables.py b/example-specs/task/nipype_internal/pydra-semtools/dilate_mask_callables.py
new file mode 100644
index 00000000..1978f15a
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/dilate_mask_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in DilateMask.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/distance_maps.yaml b/example-specs/task/nipype_internal/pydra-semtools/distance_maps.yaml
new file mode 100644
index 00000000..c36599bd
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/distance_maps.yaml
@@ -0,0 +1,95 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.filtering.featuredetection.DistanceMaps' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Mauerer Distance
+# 
+#     category: Filtering.FeatureDetection
+# 
+#     description: Get the distance from a voxel to the nearest voxel of a given tissue type.
+# 
+#     version: 0.1.0.$Revision: 1 $(alpha)
+# 
+#     documentation-url: http:://www.na-mic.org/
+# 
+#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
+# 
+#     contributor: This tool was developed by Mark Scully and Jeremy Bockholt.
+#     
+task_name: DistanceMaps
+nipype_name: DistanceMaps
+nipype_module: nipype.interfaces.semtools.filtering.featuredetection
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputLabelVolume: generic/file
+    # type=file|default=<undefined>: Required: input tissue label image
+    inputMaskVolume: generic/file
+    # type=file|default=<undefined>: Required: input brain mask image
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputVolume: generic/file
+    # type=file: Required: output image
+    # type=traitcompound|default=None: Required: output image
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputLabelVolume:
+    # type=file|default=<undefined>: Required: input tissue label image
+    inputMaskVolume:
+    # type=file|default=<undefined>: Required: input brain mask image
+    inputTissueLabel:
+    # type=int|default=0: Required: input integer value of tissue type used to calculate distance
+    outputVolume:
+    # type=file: Required: output image
+    # type=traitcompound|default=None: Required: output image
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/distance_maps_callables.py b/example-specs/task/nipype_internal/pydra-semtools/distance_maps_callables.py
new file mode 100644
index 00000000..2090b380
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/distance_maps_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in DistanceMaps.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/dtiaverage.yaml b/example-specs/task/nipype_internal/pydra-semtools/dtiaverage.yaml
new file mode 100644
index 00000000..a8a085f6
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/dtiaverage.yaml
@@ -0,0 +1,98 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.diffusion.diffusion.dtiaverage' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: DTIAverage (DTIProcess)
+# 
+#     category: Diffusion.Diffusion Tensor Images.CommandLineOnly
+# 
+#     description: dtiaverage is a program that allows to compute the average of an arbitrary number of tensor fields (listed after the --inputs option) This program is used in our pipeline as the last step of the atlas building processing. When all the tensor fields have been deformed in the same space, to create the average tensor field (--tensor_output) we use dtiaverage.
+#      Several average method can be used (specified by the --method option): euclidean, log-euclidean and pga. The default being euclidean.
+# 
+#     version: 1.0.0
+# 
+#     documentation-url: http://www.slicer.org/slicerWiki/index.php/Documentation/Nightly/Extensions/DTIProcess
+# 
+#     license: Copyright (c)  Casey Goodlett. All rights reserved.
+#         See http://www.ia.unc.edu/dev/Copyright.htm for details.
+#         This software is distributed WITHOUT ANY WARRANTY; without even
+#         the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+#         PURPOSE.  See the above copyright notices for more information.
+# 
+#     contributor: Casey Goodlett
+#     
+task_name: dtiaverage
+nipype_name: dtiaverage
+nipype_module: nipype.interfaces.semtools.diffusion.diffusion
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputs: generic/file+list-of
+    # type=inputmultiobject|default=[]: List of all the tensor fields to be averaged
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    tensor_output: generic/file
+    # type=file: Averaged tensor volume
+    # type=traitcompound|default=None: Averaged tensor volume
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputs:
+    # type=inputmultiobject|default=[]: List of all the tensor fields to be averaged
+    tensor_output:
+    # type=file: Averaged tensor volume
+    # type=traitcompound|default=None: Averaged tensor volume
+    DTI_double:
+    # type=bool|default=False: Tensor components are saved as doubles (cannot be visualized in Slicer)
+    verbose:
+    # type=bool|default=False: produce verbose output
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/dtiaverage_callables.py b/example-specs/task/nipype_internal/pydra-semtools/dtiaverage_callables.py
new file mode 100644
index 00000000..010db5d5
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/dtiaverage_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in dtiaverage.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/dtiestim.yaml b/example-specs/task/nipype_internal/pydra-semtools/dtiestim.yaml
new file mode 100644
index 00000000..e3cb8dee
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/dtiestim.yaml
@@ -0,0 +1,163 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.diffusion.diffusion.dtiestim' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: DTIEstim (DTIProcess)
+# 
+#     category: Diffusion.Diffusion Weighted Images
+# 
+#     description: dtiestim is a tool that takes in a set of DWIs (with --dwi_image option) in nrrd format and estimates a tensor field out of it. The output tensor file name is specified with the --tensor_output option
+#     There are several methods to estimate the tensors which you can specify with the option --method lls|wls|nls|ml . Here is a short description of the different methods:
+# 
+#     lls
+#           Linear least squares. Standard estimation technique that recovers the tensor parameters by multiplying the log of the normalized signal intensities by the pseudo-inverse of the gradient matrix. Default option.
+# 
+#     wls
+#         Weighted least squares. This method is similar to the linear least squares method except that the gradient matrix is weighted by the original lls estimate. (See Salvador, R., Pena, A., Menon, D. K., Carpenter, T. A., Pickard, J. D., and Bullmore, E. T. Formal characterization and extension of the linearized diffusion tensor model. Human Brain Mapping 24, 2 (Feb. 2005), 144-155. for more information on this method). This method is recommended for most applications. The weight for each iteration can be specified with the --weight_iterations.  It is not currently the default due to occasional matrix singularities.
+#     nls
+#         Non-linear least squares. This method does not take the log of the signal and requires an optimization based on levenberg-marquadt to optimize the parameters of the signal. The lls estimate is used as an initialization. For this method the step size can be specified with the --step option.
+#     ml
+#         Maximum likelihood estimation. This method is experimental and is not currently recommended. For this ml method the sigma can be specified with the option --sigma and the step size can be specified with the --step option.
+# 
+#     You can set a threshold (--threshold) to have the tensor estimated to only a subset of voxels. All the baseline voxel value higher than the threshold define the voxels where the tensors are computed. If not specified the threshold is calculated using an OTSU threshold on the baseline image.The masked generated by the -t option or by the otsu value can be saved with the --B0_mask_output option.
+# 
+#     dtiestim also can extract a few scalar images out of the DWI set of images:
+# 
+#             - the average baseline image (--B0) which is the average of all the B0s.
+#             - the IDWI (--idwi)which is the geometric mean of the diffusion images.
+# 
+#     You can also load a mask if you want to compute the tensors only where the voxels are non-zero (--brain_mask) or a negative mask and the tensors will be estimated where the negative mask has zero values (--bad_region_mask)
+# 
+#     version: 1.2.0
+# 
+#     documentation-url: http://www.slicer.org/slicerWiki/index.php/Documentation/Nightly/Extensions/DTIProcess
+# 
+#     license: Copyright (c)  Casey Goodlett. All rights reserved.
+#       See http://www.ia.unc.edu/dev/Copyright.htm for details.
+#          This software is distributed WITHOUT ANY WARRANTY; without even
+#          the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+#          PURPOSE.  See the above copyright notices for more information.
+# 
+#     contributor: Casey Goodlett, Francois Budin
+# 
+#     acknowledgements: Hans Johnson(1,3,4); Kent Williams(1); (1=University of Iowa Department of Psychiatry, 3=University of Iowa Department of Biomedical Engineering, 4=University of Iowa Department of Electrical and Computer Engineering) provided conversions to make DTIProcess compatible with Slicer execution, and simplified the stand-alone build requirements by removing the dependencies on boost and a fortran compiler.
+#     
+task_name: dtiestim
+nipype_name: dtiestim
+nipype_module: nipype.interfaces.semtools.diffusion.diffusion
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    dwi_image: generic/file
+    # type=file|default=<undefined>: DWI image volume (required)
+    brain_mask: generic/file
+    # type=file|default=<undefined>: Brain mask.  Image where for every voxel == 0 the tensors are not estimated. Be aware that in addition a threshold based masking will be performed by default. If such an additional threshold masking is NOT desired, then use option -t 0.
+    bad_region_mask: generic/file
+    # type=file|default=<undefined>: Bad region mask.  Image where for every voxel > 0 the tensors are not estimated
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    tensor_output: generic/file
+    # type=file: Tensor OutputImage
+    # type=traitcompound|default=None: Tensor OutputImage
+    B0: generic/file
+    # type=file: Baseline image, average of all baseline images
+    # type=traitcompound|default=None: Baseline image, average of all baseline images
+    idwi: generic/file
+    # type=file: idwi output image. Image with isotropic diffusion-weighted information = geometric mean of diffusion images
+    # type=traitcompound|default=None: idwi output image. Image with isotropic diffusion-weighted information = geometric mean of diffusion images
+    B0_mask_output: generic/file
+    # type=file: B0 mask used for the estimation. B0 thresholded either with the -t option value or the automatic OTSU value
+    # type=traitcompound|default=None: B0 mask used for the estimation. B0 thresholded either with the -t option value or the automatic OTSU value
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    dwi_image:
+    # type=file|default=<undefined>: DWI image volume (required)
+    tensor_output:
+    # type=file: Tensor OutputImage
+    # type=traitcompound|default=None: Tensor OutputImage
+    B0:
+    # type=file: Baseline image, average of all baseline images
+    # type=traitcompound|default=None: Baseline image, average of all baseline images
+    idwi:
+    # type=file: idwi output image. Image with isotropic diffusion-weighted information = geometric mean of diffusion images
+    # type=traitcompound|default=None: idwi output image. Image with isotropic diffusion-weighted information = geometric mean of diffusion images
+    B0_mask_output:
+    # type=file: B0 mask used for the estimation. B0 thresholded either with the -t option value or the automatic OTSU value
+    # type=traitcompound|default=None: B0 mask used for the estimation. B0 thresholded either with the -t option value or the automatic OTSU value
+    brain_mask:
+    # type=file|default=<undefined>: Brain mask.  Image where for every voxel == 0 the tensors are not estimated. Be aware that in addition a threshold based masking will be performed by default. If such an additional threshold masking is NOT desired, then use option -t 0.
+    bad_region_mask:
+    # type=file|default=<undefined>: Bad region mask.  Image where for every voxel > 0 the tensors are not estimated
+    method:
+    # type=enum|default='lls'|allowed['lls','ml','nls','wls']: Estimation method (lls:linear least squares, wls:weighted least squares, nls:non-linear least squares, ml:maximum likelihood)
+    correction:
+    # type=enum|default='none'|allowed['abs','nearest','none','zero']: Correct the tensors if computed tensor is not semi-definite positive
+    threshold:
+    # type=int|default=0: Baseline threshold for estimation. If not specified calculated using an OTSU threshold on the baseline image.
+    weight_iterations:
+    # type=int|default=0: Number of iterations to recaluate weightings from tensor estimate
+    step:
+    # type=float|default=0.0: Gradient descent step size (for nls and ml methods)
+    sigma:
+    # type=float|default=0.0: 
+    DTI_double:
+    # type=bool|default=False: Tensor components are saved as doubles (cannot be visualized in Slicer)
+    verbose:
+    # type=bool|default=False: produce verbose output
+    defaultTensor:
+    # type=inputmultiobject|default=[]: Default tensor used if estimated tensor is below a given threshold
+    shiftNeg:
+    # type=bool|default=False: Shift eigenvalues so all are positive (accounts for bad tensors related to noise or acquisition error). This is the same option as the one available in DWIToDTIEstimation in Slicer (but instead of just adding the minimum eigenvalue to all the eigenvalues if it is smaller than 0, we use a coefficient to have stictly positive eigenvalues
+    shiftNegCoeff:
+    # type=float|default=0.0: Shift eigenvalues so all are positive (accounts for bad tensors related to noise or acquisition error). Instead of just adding the minimum eigenvalue to all the eigenvalues if it is smaller than 0, we use a coefficient to have stictly positive eigenvalues. Coefficient must be between 1.0 and 1.001 (included).
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/dtiestim_callables.py b/example-specs/task/nipype_internal/pydra-semtools/dtiestim_callables.py
new file mode 100644
index 00000000..a4d8741b
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/dtiestim_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in dtiestim.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/dtiprocess.yaml b/example-specs/task/nipype_internal/pydra-semtools/dtiprocess.yaml
new file mode 100644
index 00000000..f573cecd
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/dtiprocess.yaml
@@ -0,0 +1,225 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.diffusion.diffusion.dtiprocess' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: DTIProcess (DTIProcess)
+# 
+#     category: Diffusion.Diffusion Tensor Images
+# 
+#     description: dtiprocess is a tool that handles tensor fields. It takes as an input a tensor field in nrrd format.
+#     It can generate diffusion scalar properties out of the tensor field such as : FA (--fa_output), Gradient FA image (--fa_gradient_output), color FA (--color_fa_output), MD (--md_output), Frobenius norm (--frobenius_norm_output), lbd1, lbd2, lbd3 (--lambda{1,2,3}_output), binary map of voxel where if any of the eigenvalue is negative, the voxel is set to 1 (--negative_eigenvector_output)
+# 
+#     It also creates 4D images out of the tensor field such as: Highest eigenvector map (highest eigenvector at each voxel) (--principal_eigenvector_output)
+# 
+#     Masking capabilities: For any of the processing done with dtiprocess, it's possible to apply it on a masked region of the tensor field. You need to use the --mask option for any of the option to be applied on that tensor field sub-region only. If you want to save the masked tensor field use the option --outmask and specify the new masked tensor field file name.
+#     dtiprocess also allows a range of transformations on the tensor fields. The transformed tensor field file name is specified with the option --deformation_output. There are 3 resampling interpolation methods specified with the tag --interpolation followed by the type to use (nearestneighbor, linear, cubic) Then you have several transformations possible to apply:
+# 
+#             - Affine transformations using as an input
+#             - itk affine transformation file (based on the itkAffineTransform class)
+#             - Affine transformations using rview (details and download at http://www.doc.ic.ac.uk/~dr/software/). There are 2 versions of rview both creating transformation files called dof files. The old version of rview outputs text files containing the transformation parameters. It can be read in with the --dof_file option. The new version outputs binary dof files. These dof files can be transformed into human readable file with the dof2mat tool which is part of the rview package. So you need to save the output of dof2mat into a text file which can then be used with the -- newdof_file option. Usage example: dof2mat mynewdoffile.dof >> mynewdoffile.txt       dtiprocess --dti_image mytensorfield.nhdr --newdof_file mynewdoffile.txt --rot_output myaffinetensorfield.nhdr
+# 
+#     Non linear transformations as an input: The default transformation file type is d-field (displacement field) in nrrd format. The option to use is --forward with the name of the file. If the transformation file is a h-field you have to add the option --hField.
+# 
+#     version: 1.0.1
+# 
+#     documentation-url: http://www.slicer.org/slicerWiki/index.php/Documentation/Nightly/Extensions/DTIProcess
+# 
+#     license: Copyright (c)  Casey Goodlett. All rights reserved.
+#       See http://www.ia.unc.edu/dev/Copyright.htm for details.
+#          This software is distributed WITHOUT ANY WARRANTY; without even
+#          the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+#          PURPOSE.  See the above copyright notices for more information.
+# 
+#     contributor: Casey Goodlett
+#     
+task_name: dtiprocess
+nipype_name: dtiprocess
+nipype_module: nipype.interfaces.semtools.diffusion.diffusion
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    dti_image: generic/file
+    # type=file|default=<undefined>: DTI tensor volume
+    affineitk_file: generic/file
+    # type=file|default=<undefined>: Transformation file for affine transformation.  ITK format.
+    dof_file: generic/file
+    # type=file|default=<undefined>: Transformation file for affine transformation.  This can be ITK format (or the outdated RView).
+    newdof_file: generic/file
+    # type=file|default=<undefined>: Transformation file for affine transformation.  RView NEW format. (txt file output of dof2mat)
+    mask: generic/file
+    # type=file|default=<undefined>: Mask tensors. Specify --outmask if you want to save the masked tensor field, otherwise the mask is applied just for the current processing 
+    forward: generic/file
+    # type=file|default=<undefined>: Forward transformation.  Assumed to be a deformation field in world coordinates, unless the --h-field option is specified.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    fa_output: generic/file
+    # type=file: Fractional Anisotropy output file
+    # type=traitcompound|default=None: Fractional Anisotropy output file
+    md_output: generic/file
+    # type=file: Mean Diffusivity output file
+    # type=traitcompound|default=None: Mean Diffusivity output file
+    fa_gradient_output: generic/file
+    # type=file: Fractional Anisotropy Gradient output file
+    # type=traitcompound|default=None: Fractional Anisotropy Gradient output file
+    fa_gradmag_output: generic/file
+    # type=file: Fractional Anisotropy Gradient Magnitude output file
+    # type=traitcompound|default=None: Fractional Anisotropy Gradient Magnitude output file
+    color_fa_output: generic/file
+    # type=file: Color Fractional Anisotropy output file
+    # type=traitcompound|default=None: Color Fractional Anisotropy output file
+    principal_eigenvector_output: generic/file
+    # type=file: Principal Eigenvectors Output
+    # type=traitcompound|default=None: Principal Eigenvectors Output
+    negative_eigenvector_output: generic/file
+    # type=file: Negative Eigenvectors Output: create a binary image where if any of the eigen value is below zero, the voxel is set to 1, otherwise 0.
+    # type=traitcompound|default=None: Negative Eigenvectors Output: create a binary image where if any of the eigen value is below zero, the voxel is set to 1, otherwise 0.
+    frobenius_norm_output: generic/file
+    # type=file: Frobenius Norm Output
+    # type=traitcompound|default=None: Frobenius Norm Output
+    lambda1_output: generic/file
+    # type=file: Axial Diffusivity - Lambda 1 (largest eigenvalue) output
+    # type=traitcompound|default=None: Axial Diffusivity - Lambda 1 (largest eigenvalue) output
+    lambda2_output: generic/file
+    # type=file: Lambda 2 (middle eigenvalue) output
+    # type=traitcompound|default=None: Lambda 2 (middle eigenvalue) output
+    lambda3_output: generic/file
+    # type=file: Lambda 3 (smallest eigenvalue) output
+    # type=traitcompound|default=None: Lambda 3 (smallest eigenvalue) output
+    RD_output: generic/file
+    # type=file: RD (Radial Diffusivity 1/2*(lambda2+lambda3)) output
+    # type=traitcompound|default=None: RD (Radial Diffusivity 1/2*(lambda2+lambda3)) output
+    rot_output: generic/file
+    # type=file: Rotated tensor output file.  Must also specify the dof file.
+    # type=traitcompound|default=None: Rotated tensor output file.  Must also specify the dof file.
+    outmask: generic/file
+    # type=file: Name of the masked tensor field.
+    # type=traitcompound|default=None: Name of the masked tensor field.
+    deformation_output: generic/file
+    # type=file: Warped tensor field based on a deformation field.  This option requires the --forward,-F transformation to be specified.
+    # type=traitcompound|default=None: Warped tensor field based on a deformation field.  This option requires the --forward,-F transformation to be specified.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    dti_image:
+    # type=file|default=<undefined>: DTI tensor volume
+    fa_output:
+    # type=file: Fractional Anisotropy output file
+    # type=traitcompound|default=None: Fractional Anisotropy output file
+    md_output:
+    # type=file: Mean Diffusivity output file
+    # type=traitcompound|default=None: Mean Diffusivity output file
+    sigma:
+    # type=float|default=0.0: Scale of gradients
+    fa_gradient_output:
+    # type=file: Fractional Anisotropy Gradient output file
+    # type=traitcompound|default=None: Fractional Anisotropy Gradient output file
+    fa_gradmag_output:
+    # type=file: Fractional Anisotropy Gradient Magnitude output file
+    # type=traitcompound|default=None: Fractional Anisotropy Gradient Magnitude output file
+    color_fa_output:
+    # type=file: Color Fractional Anisotropy output file
+    # type=traitcompound|default=None: Color Fractional Anisotropy output file
+    principal_eigenvector_output:
+    # type=file: Principal Eigenvectors Output
+    # type=traitcompound|default=None: Principal Eigenvectors Output
+    negative_eigenvector_output:
+    # type=file: Negative Eigenvectors Output: create a binary image where if any of the eigen value is below zero, the voxel is set to 1, otherwise 0.
+    # type=traitcompound|default=None: Negative Eigenvectors Output: create a binary image where if any of the eigen value is below zero, the voxel is set to 1, otherwise 0.
+    frobenius_norm_output:
+    # type=file: Frobenius Norm Output
+    # type=traitcompound|default=None: Frobenius Norm Output
+    lambda1_output:
+    # type=file: Axial Diffusivity - Lambda 1 (largest eigenvalue) output
+    # type=traitcompound|default=None: Axial Diffusivity - Lambda 1 (largest eigenvalue) output
+    lambda2_output:
+    # type=file: Lambda 2 (middle eigenvalue) output
+    # type=traitcompound|default=None: Lambda 2 (middle eigenvalue) output
+    lambda3_output:
+    # type=file: Lambda 3 (smallest eigenvalue) output
+    # type=traitcompound|default=None: Lambda 3 (smallest eigenvalue) output
+    RD_output:
+    # type=file: RD (Radial Diffusivity 1/2*(lambda2+lambda3)) output
+    # type=traitcompound|default=None: RD (Radial Diffusivity 1/2*(lambda2+lambda3)) output
+    rot_output:
+    # type=file: Rotated tensor output file.  Must also specify the dof file.
+    # type=traitcompound|default=None: Rotated tensor output file.  Must also specify the dof file.
+    affineitk_file:
+    # type=file|default=<undefined>: Transformation file for affine transformation.  ITK format.
+    dof_file:
+    # type=file|default=<undefined>: Transformation file for affine transformation.  This can be ITK format (or the outdated RView).
+    newdof_file:
+    # type=file|default=<undefined>: Transformation file for affine transformation.  RView NEW format. (txt file output of dof2mat)
+    mask:
+    # type=file|default=<undefined>: Mask tensors. Specify --outmask if you want to save the masked tensor field, otherwise the mask is applied just for the current processing 
+    outmask:
+    # type=file: Name of the masked tensor field.
+    # type=traitcompound|default=None: Name of the masked tensor field.
+    hField:
+    # type=bool|default=False: forward and inverse transformations are h-fields instead of displacement fields
+    forward:
+    # type=file|default=<undefined>: Forward transformation.  Assumed to be a deformation field in world coordinates, unless the --h-field option is specified.
+    deformation_output:
+    # type=file: Warped tensor field based on a deformation field.  This option requires the --forward,-F transformation to be specified.
+    # type=traitcompound|default=None: Warped tensor field based on a deformation field.  This option requires the --forward,-F transformation to be specified.
+    interpolation:
+    # type=enum|default='nearestneighbor'|allowed['cubic','linear','nearestneighbor']: Interpolation type (nearestneighbor, linear, cubic)
+    reorientation:
+    # type=enum|default='fs'|allowed['fs','ppd']: Reorientation type (fs, ppd)
+    correction:
+    # type=enum|default='none'|allowed['abs','nearest','none','zero']: Correct the tensors if computed tensor is not semi-definite positive
+    scalar_float:
+    # type=bool|default=False: Write scalar [FA,MD] as unscaled float (with their actual values, otherwise scaled by 10 000).  Also causes FA to be unscaled [0..1].
+    DTI_double:
+    # type=bool|default=False: Tensor components are saved as doubles (cannot be visualized in Slicer)
+    verbose:
+    # type=bool|default=False: produce verbose output
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/dtiprocess_callables.py b/example-specs/task/nipype_internal/pydra-semtools/dtiprocess_callables.py
new file mode 100644
index 00000000..a818ae5b
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/dtiprocess_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in dtiprocess.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/dump_binary_training_vectors.yaml b/example-specs/task/nipype_internal/pydra-semtools/dump_binary_training_vectors.yaml
new file mode 100644
index 00000000..abcac5dc
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/dump_binary_training_vectors.yaml
@@ -0,0 +1,87 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.filtering.featuredetection.DumpBinaryTrainingVectors' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Erode Image
+# 
+#     category: Filtering.FeatureDetection
+# 
+#     description: Uses mathematical morphology to erode the input images.
+# 
+#     version: 0.1.0.$Revision: 1 $(alpha)
+# 
+#     documentation-url: http:://www.na-mic.org/
+# 
+#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
+# 
+#     contributor: This tool was developed by Mark Scully and Jeremy Bockholt.
+#     
+task_name: DumpBinaryTrainingVectors
+nipype_name: DumpBinaryTrainingVectors
+nipype_module: nipype.interfaces.semtools.filtering.featuredetection
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputHeaderFilename: generic/file
+    # type=file|default=<undefined>: Required: input header file name
+    inputVectorFilename: generic/file
+    # type=file|default=<undefined>: Required: input vector filename
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputHeaderFilename:
+    # type=file|default=<undefined>: Required: input header file name
+    inputVectorFilename:
+    # type=file|default=<undefined>: Required: input vector filename
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/dump_binary_training_vectors_callables.py b/example-specs/task/nipype_internal/pydra-semtools/dump_binary_training_vectors_callables.py
new file mode 100644
index 00000000..40c89865
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/dump_binary_training_vectors_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in DumpBinaryTrainingVectors.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/dwi_compare.yaml b/example-specs/task/nipype_internal/pydra-semtools/dwi_compare.yaml
new file mode 100644
index 00000000..89f0c354
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/dwi_compare.yaml
@@ -0,0 +1,89 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.converters.DWICompare' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Nrrd DWI comparison
+# 
+#     category: Converters
+# 
+#     description: Compares two nrrd format DWI images and verifies that gradient magnitudes, gradient directions, measurement frame, and max B0 value are identicle.  Used for testing DWIConvert.
+# 
+#     version: 0.1.0.$Revision: 916 $(alpha)
+# 
+#     documentation-url: http://www.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/DWIConvert
+# 
+#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
+# 
+#     contributor: Mark Scully (UIowa)
+# 
+#     acknowledgements: This work is part of the National Alliance for Medical Image Computing (NAMIC), funded by the National Institutes of Health through the NIH Roadmap for Medical Research, Grant U54 EB005149.  Additional support for DTI data produced on Philips scanners was contributed by Vincent Magnotta and Hans Johnson at the University of Iowa.
+#     
+task_name: DWICompare
+nipype_name: DWICompare
+nipype_module: nipype.interfaces.semtools.converters
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputVolume1: generic/file
+    # type=file|default=<undefined>: First input volume (.nhdr or .nrrd)
+    inputVolume2: generic/file
+    # type=file|default=<undefined>: Second input volume (.nhdr or .nrrd)
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputVolume1:
+    # type=file|default=<undefined>: First input volume (.nhdr or .nrrd)
+    inputVolume2:
+    # type=file|default=<undefined>: Second input volume (.nhdr or .nrrd)
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/dwi_compare_callables.py b/example-specs/task/nipype_internal/pydra-semtools/dwi_compare_callables.py
new file mode 100644
index 00000000..d457104c
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/dwi_compare_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in DWICompare.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/dwi_convert.yaml b/example-specs/task/nipype_internal/pydra-semtools/dwi_convert.yaml
new file mode 100644
index 00000000..bc162fdb
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/dwi_convert.yaml
@@ -0,0 +1,147 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.diffusion.diffusion.DWIConvert' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: DWIConverter
+# 
+#     category: Diffusion.Diffusion Data Conversion
+# 
+#     description: Converts diffusion weighted MR images in dicom series into Nrrd format for analysis in Slicer. This program has been tested on only a limited subset of DTI dicom formats available from Siemens, GE, and Phillips scanners. Work in progress to support dicom multi-frame data. The program parses dicom header to extract necessary information about measurement frame, diffusion weighting directions, b-values, etc, and write out a nrrd image. For non-diffusion weighted dicom images, it loads in an entire dicom series and writes out a single dicom volume in a .nhdr/.raw pair.
+# 
+#     version: Version 1.0
+# 
+#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/DWIConverter
+# 
+#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
+# 
+#     contributor: Vince Magnotta (UIowa), Hans Johnson (UIowa), Joy Matsui (UIowa), Kent Williams (UIowa), Mark Scully (Uiowa), Xiaodong Tao (GE)
+# 
+#     acknowledgements: This work is part of the National Alliance for Medical Image Computing (NAMIC), funded by the National Institutes of Health through the NIH Roadmap for Medical Research, Grant U54 EB005149.  Additional support for DTI data produced on Philips scanners was contributed by Vincent Magnotta and Hans Johnson at the University of Iowa.
+#     
+task_name: DWIConvert
+nipype_name: DWIConvert
+nipype_module: nipype.interfaces.semtools.diffusion.diffusion
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputVolume: generic/file
+    # type=file|default=<undefined>: Input DWI volume -- not used for DicomToNrrd mode.
+    fslNIFTIFile: generic/file
+    # type=file|default=<undefined>: 4D NIfTI file containing gradient volumes
+    inputBValues: generic/file
+    # type=file|default=<undefined>: The B Values are stored in FSL .bval text file format
+    inputBVectors: generic/file
+    # type=file|default=<undefined>: The Gradient Vectors are stored in FSL .bvec text file format
+    inputDicomDirectory: generic/directory
+    # type=directory|default=<undefined>: Directory holding Dicom series
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputVolume: generic/file
+    # type=file: Output filename (.nhdr or .nrrd)
+    # type=traitcompound|default=None: Output filename (.nhdr or .nrrd)
+    outputBValues: generic/file
+    # type=file: The B Values are stored in FSL .bval text file format (defaults to <outputVolume>.bval)
+    # type=traitcompound|default=None: The B Values are stored in FSL .bval text file format (defaults to <outputVolume>.bval)
+    outputBVectors: generic/file
+    # type=file: The Gradient Vectors are stored in FSL .bvec text file format (defaults to <outputVolume>.bvec)
+    # type=traitcompound|default=None: The Gradient Vectors are stored in FSL .bvec text file format (defaults to <outputVolume>.bvec)
+    gradientVectorFile: generic/file
+    # type=file: Text file giving gradient vectors
+    # type=traitcompound|default=None: Text file giving gradient vectors
+    outputDirectory: generic/directory
+    # type=directory: Directory holding the output NRRD file
+    # type=traitcompound|default=None: Directory holding the output NRRD file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    conversionMode:
+    # type=enum|default='DicomToNrrd'|allowed['DicomToFSL','DicomToNrrd','FSLToNrrd','NrrdToFSL']: Determine which conversion to perform. DicomToNrrd (default): Convert DICOM series to NRRD DicomToFSL: Convert DICOM series to NIfTI File + gradient/bvalue text files NrrdToFSL: Convert DWI NRRD file to NIfTI File + gradient/bvalue text files FSLToNrrd: Convert NIfTI File + gradient/bvalue text files to NRRD file.
+    inputVolume:
+    # type=file|default=<undefined>: Input DWI volume -- not used for DicomToNrrd mode.
+    outputVolume:
+    # type=file: Output filename (.nhdr or .nrrd)
+    # type=traitcompound|default=None: Output filename (.nhdr or .nrrd)
+    inputDicomDirectory:
+    # type=directory|default=<undefined>: Directory holding Dicom series
+    fslNIFTIFile:
+    # type=file|default=<undefined>: 4D NIfTI file containing gradient volumes
+    inputBValues:
+    # type=file|default=<undefined>: The B Values are stored in FSL .bval text file format
+    inputBVectors:
+    # type=file|default=<undefined>: The Gradient Vectors are stored in FSL .bvec text file format
+    outputBValues:
+    # type=file: The B Values are stored in FSL .bval text file format (defaults to <outputVolume>.bval)
+    # type=traitcompound|default=None: The B Values are stored in FSL .bval text file format (defaults to <outputVolume>.bval)
+    outputBVectors:
+    # type=file: The Gradient Vectors are stored in FSL .bvec text file format (defaults to <outputVolume>.bvec)
+    # type=traitcompound|default=None: The Gradient Vectors are stored in FSL .bvec text file format (defaults to <outputVolume>.bvec)
+    fMRI:
+    # type=bool|default=False: Output a NRRD file, but without gradients
+    writeProtocolGradientsFile:
+    # type=bool|default=False: Write the protocol gradients to a file suffixed by '.txt' as they were specified in the procol by multiplying each diffusion gradient direction by the measurement frame.  This file is for debugging purposes only, the format is not fixed, and will likely change as debugging of new dicom formats is necessary.
+    useIdentityMeaseurementFrame:
+    # type=bool|default=False: Adjust all the gradients so that the measurement frame is an identity matrix.
+    useBMatrixGradientDirections:
+    # type=bool|default=False: Fill the nhdr header with the gradient directions and bvalues computed out of the BMatrix. Only changes behavior for Siemens data.  In some cases the standard public gradients are not properly computed.  The gradients can empirically computed from the private BMatrix fields.  In some cases the private BMatrix is consistent with the public grandients, but not in all cases, when it exists BMatrix is usually most robust.
+    outputDirectory:
+    # type=directory: Directory holding the output NRRD file
+    # type=traitcompound|default=None: Directory holding the output NRRD file
+    gradientVectorFile:
+    # type=file: Text file giving gradient vectors
+    # type=traitcompound|default=None: Text file giving gradient vectors
+    smallGradientThreshold:
+    # type=float|default=0.0: If a gradient magnitude is greater than 0 and less than smallGradientThreshold, then DWIConvert will display an error message and quit, unless the useBMatrixGradientDirections option is set.
+    allowLossyConversion:
+    # type=bool|default=False: The only supported output type is 'short'. Conversion from images of a different type may cause data loss due to rounding or truncation. Use with caution!
+    transposeInputBVectors:
+    # type=bool|default=False: FSL input BVectors are expected to be encoded in the input file as one vector per line. If it is not the case, use this option to transpose the file as it is read.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/dwi_convert_callables.py b/example-specs/task/nipype_internal/pydra-semtools/dwi_convert_callables.py
new file mode 100644
index 00000000..1778100f
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/dwi_convert_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in DWIConvert.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/dwi_simple_compare.yaml b/example-specs/task/nipype_internal/pydra-semtools/dwi_simple_compare.yaml
new file mode 100644
index 00000000..386507f5
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/dwi_simple_compare.yaml
@@ -0,0 +1,91 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.converters.DWISimpleCompare' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Nrrd DWI comparison
+# 
+#     category: Converters
+# 
+#     description: Compares two nrrd format DWI images and verifies that gradient magnitudes, gradient directions, measurement frame, and max B0 value are identicle.  Used for testing DWIConvert.
+# 
+#     version: 0.1.0.$Revision: 916 $(alpha)
+# 
+#     documentation-url: http://www.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/DWIConvert
+# 
+#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
+# 
+#     contributor: Mark Scully (UIowa)
+# 
+#     acknowledgements: This work is part of the National Alliance for Medical Image Computing (NAMIC), funded by the National Institutes of Health through the NIH Roadmap for Medical Research, Grant U54 EB005149.  Additional support for DTI data produced on Philips scanners was contributed by Vincent Magnotta and Hans Johnson at the University of Iowa.
+#     
+task_name: DWISimpleCompare
+nipype_name: DWISimpleCompare
+nipype_module: nipype.interfaces.semtools.converters
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputVolume1: generic/file
+    # type=file|default=<undefined>: First input volume (.nhdr or .nrrd)
+    inputVolume2: generic/file
+    # type=file|default=<undefined>: Second input volume (.nhdr or .nrrd)
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputVolume1:
+    # type=file|default=<undefined>: First input volume (.nhdr or .nrrd)
+    inputVolume2:
+    # type=file|default=<undefined>: Second input volume (.nhdr or .nrrd)
+    checkDWIData:
+    # type=bool|default=False: check for existence of DWI data, and if present, compare it
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/dwi_simple_compare_callables.py b/example-specs/task/nipype_internal/pydra-semtools/dwi_simple_compare_callables.py
new file mode 100644
index 00000000..c3afa157
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/dwi_simple_compare_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in DWISimpleCompare.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/erode_image.yaml b/example-specs/task/nipype_internal/pydra-semtools/erode_image.yaml
new file mode 100644
index 00000000..7cd842a2
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/erode_image.yaml
@@ -0,0 +1,95 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.filtering.featuredetection.ErodeImage' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Erode Image
+# 
+#     category: Filtering.FeatureDetection
+# 
+#     description: Uses mathematical morphology to erode the input images.
+# 
+#     version: 0.1.0.$Revision: 1 $(alpha)
+# 
+#     documentation-url: http:://www.na-mic.org/
+# 
+#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
+# 
+#     contributor: This tool was developed by Mark Scully and Jeremy Bockholt.
+#     
+task_name: ErodeImage
+nipype_name: ErodeImage
+nipype_module: nipype.interfaces.semtools.filtering.featuredetection
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputVolume: generic/file
+    # type=file|default=<undefined>: Required: input image
+    inputMaskVolume: generic/file
+    # type=file|default=<undefined>: Required: input brain mask image
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputVolume: generic/file
+    # type=file: Required: output image
+    # type=traitcompound|default=None: Required: output image
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputVolume:
+    # type=file|default=<undefined>: Required: input image
+    inputMaskVolume:
+    # type=file|default=<undefined>: Required: input brain mask image
+    inputRadius:
+    # type=int|default=0: Required: input neighborhood radius
+    outputVolume:
+    # type=file: Required: output image
+    # type=traitcompound|default=None: Required: output image
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/erode_image_callables.py b/example-specs/task/nipype_internal/pydra-semtools/erode_image_callables.py
new file mode 100644
index 00000000..545fa4d7
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/erode_image_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in ErodeImage.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/eslr.yaml b/example-specs/task/nipype_internal/pydra-semtools/eslr.yaml
new file mode 100644
index 00000000..92b2f8fc
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/eslr.yaml
@@ -0,0 +1,95 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.segmentation.specialized.ESLR' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Clean Contiguous Label Map (BRAINS)
+# 
+#     category: Segmentation.Specialized
+# 
+#     description: From a range of label map values, extract the largest contiguous region of those labels
+#     
+task_name: ESLR
+nipype_name: ESLR
+nipype_module: nipype.interfaces.semtools.segmentation.specialized
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputVolume: generic/file
+    # type=file|default=<undefined>: Input Label Volume
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputVolume: generic/file
+    # type=file: Output Label Volume
+    # type=traitcompound|default=None: Output Label Volume
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputVolume:
+    # type=file|default=<undefined>: Input Label Volume
+    outputVolume:
+    # type=file: Output Label Volume
+    # type=traitcompound|default=None: Output Label Volume
+    low:
+    # type=int|default=0: The lower bound of the labels to be used.
+    high:
+    # type=int|default=0: The higher bound of the labels to be used.
+    closingSize:
+    # type=int|default=0: The closing size for hole filling.
+    openingSize:
+    # type=int|default=0: The opening size for hole filling.
+    safetySize:
+    # type=int|default=0: The safetySize size for the clipping region.
+    preserveOutside:
+    # type=bool|default=False: For values outside the specified range, preserve those values.
+    numberOfThreads:
+    # type=int|default=0: Explicitly specify the maximum number of threads to use.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/eslr_callables.py b/example-specs/task/nipype_internal/pydra-semtools/eslr_callables.py
new file mode 100644
index 00000000..8d2a0716
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/eslr_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in ESLR.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/extract_nrrd_vector_index.yaml b/example-specs/task/nipype_internal/pydra-semtools/extract_nrrd_vector_index.yaml
new file mode 100644
index 00000000..1d35a26f
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/extract_nrrd_vector_index.yaml
@@ -0,0 +1,97 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.diffusion.gtract.extractNrrdVectorIndex' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Extract Nrrd Index
+# 
+#     category: Diffusion.GTRACT
+# 
+#     description: This program will extract a 3D image (single vector) from a vector 3D image at a given vector index.
+# 
+#     version: 4.0.0
+# 
+#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Modules:GTRACT
+# 
+#     license: http://mri.radiology.uiowa.edu/copyright/GTRACT-Copyright.txt
+# 
+#     contributor: This tool was developed by Vincent Magnotta and Greg Harris.
+# 
+#     acknowledgements: Funding for this version of the GTRACT program was provided by NIH/NINDS R01NS050568-01A2S1
+#     
+task_name: extractNrrdVectorIndex
+nipype_name: extractNrrdVectorIndex
+nipype_module: nipype.interfaces.semtools.diffusion.gtract
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputVolume: generic/file
+    # type=file|default=<undefined>: Required: input file containing the vector that will be extracted
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputVolume: generic/file
+    # type=file: Required: name of output NRRD file containing the vector image at the given index
+    # type=traitcompound|default=None: Required: name of output NRRD file containing the vector image at the given index
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputVolume:
+    # type=file|default=<undefined>: Required: input file containing the vector that will be extracted
+    vectorIndex:
+    # type=int|default=0: Index in the vector image to extract
+    setImageOrientation:
+    # type=enum|default='AsAcquired'|allowed['AsAcquired','Axial','Coronal','Sagittal']: Sets the image orientation of the extracted vector (Axial, Coronal, Sagittal)
+    outputVolume:
+    # type=file: Required: name of output NRRD file containing the vector image at the given index
+    # type=traitcompound|default=None: Required: name of output NRRD file containing the vector image at the given index
+    numberOfThreads:
+    # type=int|default=0: Explicitly specify the maximum number of threads to use.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/extract_nrrd_vector_index_callables.py b/example-specs/task/nipype_internal/pydra-semtools/extract_nrrd_vector_index_callables.py
new file mode 100644
index 00000000..25af6cf3
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/extract_nrrd_vector_index_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in extractNrrdVectorIndex.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/fcsv_to_hdf_5.yaml b/example-specs/task/nipype_internal/pydra-semtools/fcsv_to_hdf_5.yaml
new file mode 100644
index 00000000..c1eca51b
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/fcsv_to_hdf_5.yaml
@@ -0,0 +1,93 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.utilities.brains.fcsv_to_hdf5' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: fcsv_to_hdf5 (BRAINS)
+# 
+#     category: Utilities.BRAINS
+# 
+#     description: Convert a collection of fcsv files to a HDF5 format file
+#     
+task_name: fcsv_to_hdf5
+nipype_name: fcsv_to_hdf5
+nipype_module: nipype.interfaces.semtools.utilities.brains
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    landmarkTypesList: generic/file
+    # type=file|default=<undefined>: ,         file containing list of landmark types,       
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    landmarksInformationFile: generic/file
+    # type=file: ,         name of HDF5 file to write matrices into,       
+    # type=traitcompound|default=None: ,         name of HDF5 file to write matrices into,       
+    modelFile: generic/file
+    # type=file: ,         name of HDF5 file containing BRAINSConstellationDetector Model file (LLSMatrices, LLSMeans and LLSSearchRadii),       
+    # type=traitcompound|default=None: ,         name of HDF5 file containing BRAINSConstellationDetector Model file (LLSMatrices, LLSMeans and LLSSearchRadii),       
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    versionID:
+    # type=str|default='': ,         Current version ID. It should be match with the version of BCD that will be using the output model file,       
+    landmarksInformationFile:
+    # type=file: ,         name of HDF5 file to write matrices into,       
+    # type=traitcompound|default=None: ,         name of HDF5 file to write matrices into,       
+    landmarkTypesList:
+    # type=file|default=<undefined>: ,         file containing list of landmark types,       
+    modelFile:
+    # type=file: ,         name of HDF5 file containing BRAINSConstellationDetector Model file (LLSMatrices, LLSMeans and LLSSearchRadii),       
+    # type=traitcompound|default=None: ,         name of HDF5 file containing BRAINSConstellationDetector Model file (LLSMatrices, LLSMeans and LLSSearchRadii),       
+    landmarkGlobPattern:
+    # type=str|default='': Glob pattern to select fcsv files
+    numberOfThreads:
+    # type=int|default=0: Explicitly specify the maximum number of threads to use.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/fcsv_to_hdf_5_callables.py b/example-specs/task/nipype_internal/pydra-semtools/fcsv_to_hdf_5_callables.py
new file mode 100644
index 00000000..f2b47baa
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/fcsv_to_hdf_5_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in fcsv_to_hdf5.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/fiberprocess.yaml b/example-specs/task/nipype_internal/pydra-semtools/fiberprocess.yaml
new file mode 100644
index 00000000..151b312d
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/fiberprocess.yaml
@@ -0,0 +1,129 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.diffusion.tractography.fiberprocess.fiberprocess' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: FiberProcess (DTIProcess)
+# 
+#     category: Diffusion.Tractography
+# 
+#     description: fiberprocess is a tool that manage fiber files extracted from the fibertrack tool or any fiber tracking algorithm. It takes as an input .fib and .vtk files (--fiber_file) and saves the changed fibers (--fiber_output) into the 2 same formats. The main purpose of this tool is to deform the fiber file with a transformation field as an input (--displacement_field or --h_field depending if you deal with dfield or hfield). To use that option you need to specify the tensor field from which the fiber file was extracted with the option --tensor_volume. The transformation applied on the fiber file is the inverse of the one input. If the transformation is from one case to an atlas, fiberprocess assumes that the fiber file is in the atlas space and you want it in the original case space, so it's the inverse of the transformation which has been computed.
+#     You have 2 options for fiber modification. You can either deform the fibers (their geometry) into the space OR you can keep the same geometry but map the diffusion properties (fa, md, lbd's...) of the original tensor field along the fibers at the corresponding locations. This is triggered by the --no_warp option. To use the previous example: when you have a tensor field in the original space and the deformed tensor field in the atlas space, you want to track the fibers in the atlas space, keeping this geometry but with the original case diffusion properties. Then you can specify the transformations field (from original case -> atlas) and the original tensor field with the --tensor_volume option.
+#     With fiberprocess you can also binarize a fiber file. Using the --voxelize option will create an image where each voxel through which a fiber is passing is set to 1. The output is going to be a binary image with the values 0 or 1 by default but the 1 value voxel can be set to any number with the --voxel_label option. Finally you can create an image where the value at the voxel is the number of fiber passing through. (--voxelize_count_fibers)
+# 
+#     version: 1.0.0
+# 
+#     documentation-url: http://www.slicer.org/slicerWiki/index.php/Documentation/Nightly/Extensions/DTIProcess
+# 
+#     license: Copyright (c)  Casey Goodlett. All rights reserved.
+#         See http://www.ia.unc.edu/dev/Copyright.htm for details.
+#         This software is distributed WITHOUT ANY WARRANTY; without even
+#         the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+#         PURPOSE.  See the above copyright notices for more information.
+# 
+#     contributor: Casey Goodlett
+#     
+task_name: fiberprocess
+nipype_name: fiberprocess
+nipype_module: nipype.interfaces.semtools.diffusion.tractography.fiberprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    fiber_file: generic/file
+    # type=file|default=<undefined>: DTI fiber file
+    tensor_volume: generic/file
+    # type=file|default=<undefined>: Interpolate tensor values from the given field
+    h_field: generic/file
+    # type=file|default=<undefined>: HField for warp and statistics lookup. If this option is used tensor-volume must also be specified.
+    displacement_field: generic/file
+    # type=file|default=<undefined>: Displacement Field for warp and statistics lookup.  If this option is used tensor-volume must also be specified.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    fiber_output: generic/file
+    # type=file: Output fiber file. May be warped or updated with new data depending on other options used.
+    # type=traitcompound|default=None: Output fiber file. May be warped or updated with new data depending on other options used.
+    voxelize: generic/file
+    # type=file: Voxelize fiber into a label map (the labelmap filename is the argument of -V). The tensor file must be specified using -T for information about the size, origin, spacing of the image. The deformation is applied before the voxelization 
+    # type=traitcompound|default=None: Voxelize fiber into a label map (the labelmap filename is the argument of -V). The tensor file must be specified using -T for information about the size, origin, spacing of the image. The deformation is applied before the voxelization 
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    fiber_file:
+    # type=file|default=<undefined>: DTI fiber file
+    fiber_output:
+    # type=file: Output fiber file. May be warped or updated with new data depending on other options used.
+    # type=traitcompound|default=None: Output fiber file. May be warped or updated with new data depending on other options used.
+    tensor_volume:
+    # type=file|default=<undefined>: Interpolate tensor values from the given field
+    h_field:
+    # type=file|default=<undefined>: HField for warp and statistics lookup. If this option is used tensor-volume must also be specified.
+    displacement_field:
+    # type=file|default=<undefined>: Displacement Field for warp and statistics lookup.  If this option is used tensor-volume must also be specified.
+    saveProperties:
+    # type=bool|default=False: save the tensor property as scalar data into the vtk (only works for vtk fiber files). 
+    no_warp:
+    # type=bool|default=False: Do not warp the geometry of the tensors only obtain the new statistics.
+    fiber_radius:
+    # type=float|default=0.0: set radius of all fibers to this value
+    index_space:
+    # type=bool|default=False: Use index-space for fiber output coordinates, otherwise us world space for fiber output coordinates (from tensor file).
+    voxelize:
+    # type=file: Voxelize fiber into a label map (the labelmap filename is the argument of -V). The tensor file must be specified using -T for information about the size, origin, spacing of the image. The deformation is applied before the voxelization 
+    # type=traitcompound|default=None: Voxelize fiber into a label map (the labelmap filename is the argument of -V). The tensor file must be specified using -T for information about the size, origin, spacing of the image. The deformation is applied before the voxelization 
+    voxelize_count_fibers:
+    # type=bool|default=False: Count number of fibers per-voxel instead of just setting to 1
+    voxel_label:
+    # type=int|default=0: Label for voxelized fiber
+    verbose:
+    # type=bool|default=False: produce verbose output
+    noDataChange:
+    # type=bool|default=False: Do not change data ??? 
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/fiberprocess_callables.py b/example-specs/task/nipype_internal/pydra-semtools/fiberprocess_callables.py
new file mode 100644
index 00000000..c89a079e
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/fiberprocess_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in fiberprocess.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/fiberstats.yaml b/example-specs/task/nipype_internal/pydra-semtools/fiberstats.yaml
new file mode 100644
index 00000000..5717fb32
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/fiberstats.yaml
@@ -0,0 +1,91 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.diffusion.tractography.commandlineonly.fiberstats' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: FiberStats (DTIProcess)
+# 
+#     category: Diffusion.Tractography.CommandLineOnly
+# 
+#     description: Obsolete tool - Not used anymore
+# 
+#     version: 1.1.0
+# 
+#     documentation-url: http://www.slicer.org/slicerWiki/index.php/Documentation/Nightly/Extensions/DTIProcess
+# 
+#     license: Copyright (c)  Casey Goodlett. All rights reserved.
+#       See http://www.ia.unc.edu/dev/Copyright.htm for details.
+#          This software is distributed WITHOUT ANY WARRANTY; without even
+#          the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+#          PURPOSE.  See the above copyright notices for more information.
+# 
+#     contributor: Casey Goodlett
+# 
+#     acknowledgements: Hans Johnson(1,3,4); Kent Williams(1); (1=University of Iowa Department of Psychiatry, 3=University of Iowa Department of Biomedical Engineering, 4=University of Iowa Department of Electrical and Computer Engineering) provided conversions to make DTIProcess compatible with Slicer execution, and simplified the stand-alone build requirements by removing the dependencies on boost and a fortran compiler.
+#     
+task_name: fiberstats
+nipype_name: fiberstats
+nipype_module: nipype.interfaces.semtools.diffusion.tractography.commandlineonly
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    fiber_file: generic/file
+    # type=file|default=<undefined>: DTI Fiber File
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    fiber_file:
+    # type=file|default=<undefined>: DTI Fiber File
+    verbose:
+    # type=bool|default=False: produce verbose output
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/fiberstats_callables.py b/example-specs/task/nipype_internal/pydra-semtools/fiberstats_callables.py
new file mode 100644
index 00000000..91bf34be
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/fiberstats_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in fiberstats.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/fibertrack.yaml b/example-specs/task/nipype_internal/pydra-semtools/fibertrack.yaml
new file mode 100644
index 00000000..e0af6c7d
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/fibertrack.yaml
@@ -0,0 +1,122 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.diffusion.tractography.fibertrack.fibertrack' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: FiberTrack (DTIProcess)
+# 
+#     category: Diffusion.Tractography
+# 
+#     description: This program implements a simple streamline tractography method based on the principal eigenvector of the tensor field. A fourth order Runge-Kutta integration rule used to advance the streamlines.
+#     As a first parameter you have to input the tensor field (with the --input_tensor_file option). Then the region of interest image file is set with the --input_roi_file. Next you want to set the output fiber file name after the --output_fiber_file option.
+#     You can specify the label value in the input_roi_file with the --target_label, --source_label and  --fobidden_label options. By default target label is 1, source label is 2 and forbidden label is 0. The source label is where the streamlines are seeded, the target label defines the voxels through which the fibers must pass by to be kept in the final fiber file and the forbidden label defines the voxels where the streamlines are stopped if they pass through it. There is also a --whole_brain option which, if enabled, consider both target and source labels of the roi image as target labels and all the voxels of the image are considered as sources.
+#     During the tractography, the --fa_min parameter is used as the minimum value needed at different voxel for the tracking to keep going along a streamline. The --step_size parameter is used for each iteration of the tracking algorithm and defines the length of each step. The --max_angle option defines the maximum angle allowed between two successive segments along the tracked fiber.
+# 
+#     version: 1.1.0
+# 
+#     documentation-url: http://www.slicer.org/slicerWiki/index.php/Documentation/Nightly/Extensions/DTIProcess
+# 
+#     license: Copyright (c)  Casey Goodlett. All rights reserved.
+#       See http://www.ia.unc.edu/dev/Copyright.htm for details.
+#          This software is distributed WITHOUT ANY WARRANTY; without even
+#          the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+#          PURPOSE.  See the above copyright notices for more information.
+# 
+#     contributor: Casey Goodlett
+# 
+#     acknowledgements: Hans Johnson(1,3,4); Kent Williams(1); (1=University of Iowa Department of Psychiatry, 3=University of Iowa Department of Biomedical Engineering, 4=University of Iowa Department of Electrical and Computer Engineering) provided conversions to make DTIProcess compatible with Slicer execution, and simplified the stand-alone build requirements by removing the dependencies on boost and a fortran compiler.
+#     
+task_name: fibertrack
+nipype_name: fibertrack
+nipype_module: nipype.interfaces.semtools.diffusion.tractography.fibertrack
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    input_tensor_file: generic/file
+    # type=file|default=<undefined>: Tensor Image
+    input_roi_file: generic/file
+    # type=file|default=<undefined>: The filename of the image which contains the labels used for seeding and constraining the algorithm.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    output_fiber_file: generic/file
+    # type=file: The filename for the fiber file produced by the algorithm. This file must end in a .fib or .vtk extension for ITK spatial object and vtkPolyData formats respectively.
+    # type=traitcompound|default=None: The filename for the fiber file produced by the algorithm. This file must end in a .fib or .vtk extension for ITK spatial object and vtkPolyData formats respectively.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    input_tensor_file:
+    # type=file|default=<undefined>: Tensor Image
+    input_roi_file:
+    # type=file|default=<undefined>: The filename of the image which contains the labels used for seeding and constraining the algorithm.
+    output_fiber_file:
+    # type=file: The filename for the fiber file produced by the algorithm. This file must end in a .fib or .vtk extension for ITK spatial object and vtkPolyData formats respectively.
+    # type=traitcompound|default=None: The filename for the fiber file produced by the algorithm. This file must end in a .fib or .vtk extension for ITK spatial object and vtkPolyData formats respectively.
+    source_label:
+    # type=int|default=0: The label of voxels in the labelfile to use for seeding tractography. One tract is seeded from the center of each voxel with this label
+    target_label:
+    # type=int|default=0: The label of voxels in the labelfile used to constrain tractography. Tracts that do not pass through a voxel with this label are rejected. Set this keep all tracts.
+    forbidden_label:
+    # type=int|default=0: Forbidden label
+    whole_brain:
+    # type=bool|default=False: If this option is enabled all voxels in the image are used to seed tractography. When this option is enabled both source and target labels function as target labels
+    max_angle:
+    # type=float|default=0.0: Maximum angle of change in radians
+    step_size:
+    # type=float|default=0.0: Step size in mm for the tracking algorithm
+    min_fa:
+    # type=float|default=0.0: The minimum FA threshold to continue tractography
+    force:
+    # type=bool|default=False: Ignore sanity checks.
+    verbose:
+    # type=bool|default=False: produce verbose output
+    really_verbose:
+    # type=bool|default=False: Follow detail of fiber tracking algorithm
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/fibertrack_callables.py b/example-specs/task/nipype_internal/pydra-semtools/fibertrack_callables.py
new file mode 100644
index 00000000..9e13a9cc
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/fibertrack_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in fibertrack.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/find_center_of_brain.yaml b/example-specs/task/nipype_internal/pydra-semtools/find_center_of_brain.yaml
new file mode 100644
index 00000000..715328c1
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/find_center_of_brain.yaml
@@ -0,0 +1,139 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.utilities.brains.FindCenterOfBrain' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Center Of Brain (BRAINS)
+# 
+#     category: Utilities.BRAINS
+# 
+#     description: Finds the center point of a brain
+# 
+#     version: 3.0.0
+# 
+#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
+# 
+#     contributor: Hans J. Johnson, hans-johnson -at- uiowa.edu, http://wwww.psychiatry.uiowa.edu
+# 
+#     acknowledgements: Hans Johnson(1,3,4); Kent Williams(1);  (1=University of Iowa Department of Psychiatry, 3=University of Iowa Department of Biomedical Engineering, 4=University of Iowa Department of Electrical and Computer Engineering
+#     
+task_name: FindCenterOfBrain
+nipype_name: FindCenterOfBrain
+nipype_module: nipype.interfaces.semtools.utilities.brains
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputVolume: generic/file
+    # type=file|default=<undefined>: The image in which to find the center.
+    imageMask: generic/file
+    # type=file|default=<undefined>: 
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    clippedImageMask: generic/file
+    # type=file: 
+    # type=traitcompound|default=None: 
+    debugDistanceImage: generic/file
+    # type=file: 
+    # type=traitcompound|default=None: 
+    debugGridImage: generic/file
+    # type=file: 
+    # type=traitcompound|default=None: 
+    debugAfterGridComputationsForegroundImage: generic/file
+    # type=file: 
+    # type=traitcompound|default=None: 
+    debugClippedImageMask: generic/file
+    # type=file: 
+    # type=traitcompound|default=None: 
+    debugTrimmedImage: generic/file
+    # type=file: 
+    # type=traitcompound|default=None: 
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputVolume:
+    # type=file|default=<undefined>: The image in which to find the center.
+    imageMask:
+    # type=file|default=<undefined>: 
+    clippedImageMask:
+    # type=file: 
+    # type=traitcompound|default=None: 
+    maximize:
+    # type=bool|default=False: 
+    axis:
+    # type=int|default=0: 
+    otsuPercentileThreshold:
+    # type=float|default=0.0: 
+    closingSize:
+    # type=int|default=0: 
+    headSizeLimit:
+    # type=float|default=0.0: 
+    headSizeEstimate:
+    # type=float|default=0.0: 
+    backgroundValue:
+    # type=int|default=0: 
+    generateDebugImages:
+    # type=bool|default=False: 
+    debugDistanceImage:
+    # type=file: 
+    # type=traitcompound|default=None: 
+    debugGridImage:
+    # type=file: 
+    # type=traitcompound|default=None: 
+    debugAfterGridComputationsForegroundImage:
+    # type=file: 
+    # type=traitcompound|default=None: 
+    debugClippedImageMask:
+    # type=file: 
+    # type=traitcompound|default=None: 
+    debugTrimmedImage:
+    # type=file: 
+    # type=traitcompound|default=None: 
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/find_center_of_brain_callables.py b/example-specs/task/nipype_internal/pydra-semtools/find_center_of_brain_callables.py
new file mode 100644
index 00000000..2b90ca0f
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/find_center_of_brain_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in FindCenterOfBrain.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/flipped_difference.yaml b/example-specs/task/nipype_internal/pydra-semtools/flipped_difference.yaml
new file mode 100644
index 00000000..7c9e69b6
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/flipped_difference.yaml
@@ -0,0 +1,93 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.filtering.featuredetection.FlippedDifference' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Flip Image
+# 
+#     category: Filtering.FeatureDetection
+# 
+#     description: Difference between an image and the axially flipped version of that image.
+# 
+#     version: 0.1.0.$Revision: 1 $(alpha)
+# 
+#     documentation-url: http:://www.na-mic.org/
+# 
+#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
+# 
+#     contributor: This tool was developed by Mark Scully and Jeremy Bockholt.
+#     
+task_name: FlippedDifference
+nipype_name: FlippedDifference
+nipype_module: nipype.interfaces.semtools.filtering.featuredetection
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputVolume: generic/file
+    # type=file|default=<undefined>: Required: input image
+    inputMaskVolume: generic/file
+    # type=file|default=<undefined>: Required: input brain mask image
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputVolume: generic/file
+    # type=file: Required: output image
+    # type=traitcompound|default=None: Required: output image
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputVolume:
+    # type=file|default=<undefined>: Required: input image
+    inputMaskVolume:
+    # type=file|default=<undefined>: Required: input brain mask image
+    outputVolume:
+    # type=file: Required: output image
+    # type=traitcompound|default=None: Required: output image
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/flipped_difference_callables.py b/example-specs/task/nipype_internal/pydra-semtools/flipped_difference_callables.py
new file mode 100644
index 00000000..e3d7824a
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/flipped_difference_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in FlippedDifference.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/generate_average_lmk_file.yaml b/example-specs/task/nipype_internal/pydra-semtools/generate_average_lmk_file.yaml
new file mode 100644
index 00000000..74d05ce2
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/generate_average_lmk_file.yaml
@@ -0,0 +1,81 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.testing.generateaveragelmkfile.GenerateAverageLmkFile' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Average Fiducials
+# 
+#     category: Testing
+# 
+#     description: This program gets several fcsv file each one contains several landmarks with the same name but slightly different coordinates. For EACH landmark we compute the average coordination.
+# 
+#     contributor: Ali Ghayoor
+#     
+task_name: GenerateAverageLmkFile
+nipype_name: GenerateAverageLmkFile
+nipype_module: nipype.interfaces.semtools.testing.generateaveragelmkfile
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputLandmarkFile: generic/file
+    # type=file: Output landmark file name that includes average values for landmarks (.fcsv or .wts)
+    # type=traitcompound|default=None: Output landmark file name that includes average values for landmarks (.fcsv or .wts)
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputLandmarkFiles:
+    # type=inputmultiobject|default=[]: Input landmark files names (.fcsv or .wts)
+    outputLandmarkFile:
+    # type=file: Output landmark file name that includes average values for landmarks (.fcsv or .wts)
+    # type=traitcompound|default=None: Output landmark file name that includes average values for landmarks (.fcsv or .wts)
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/generate_average_lmk_file_callables.py b/example-specs/task/nipype_internal/pydra-semtools/generate_average_lmk_file_callables.py
new file mode 100644
index 00000000..755121f1
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/generate_average_lmk_file_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in GenerateAverageLmkFile.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/generate_brain_clipped_image.yaml b/example-specs/task/nipype_internal/pydra-semtools/generate_brain_clipped_image.yaml
new file mode 100644
index 00000000..8f6ab521
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/generate_brain_clipped_image.yaml
@@ -0,0 +1,93 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.filtering.featuredetection.GenerateBrainClippedImage' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: GenerateBrainClippedImage
+# 
+#     category: Filtering.FeatureDetection
+# 
+#     description: Automatic FeatureImages using neural networks
+# 
+#     version: 1.0
+# 
+#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
+# 
+#     contributor: Eun Young Kim
+#     
+task_name: GenerateBrainClippedImage
+nipype_name: GenerateBrainClippedImage
+nipype_module: nipype.interfaces.semtools.filtering.featuredetection
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputImg: generic/file
+    # type=file|default=<undefined>: input volume 1, usually t1 image
+    inputMsk: generic/file
+    # type=file|default=<undefined>: input volume 2, usually t2 image
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputFileName: generic/file
+    # type=file: (required) output file name
+    # type=traitcompound|default=None: (required) output file name
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputImg:
+    # type=file|default=<undefined>: input volume 1, usually t1 image
+    inputMsk:
+    # type=file|default=<undefined>: input volume 2, usually t2 image
+    outputFileName:
+    # type=file: (required) output file name
+    # type=traitcompound|default=None: (required) output file name
+    numberOfThreads:
+    # type=int|default=0: Explicitly specify the maximum number of threads to use.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/generate_brain_clipped_image_callables.py b/example-specs/task/nipype_internal/pydra-semtools/generate_brain_clipped_image_callables.py
new file mode 100644
index 00000000..48b86121
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/generate_brain_clipped_image_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in GenerateBrainClippedImage.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/generate_csf_clipped_from_classified_image.yaml b/example-specs/task/nipype_internal/pydra-semtools/generate_csf_clipped_from_classified_image.yaml
new file mode 100644
index 00000000..e1d44dc8
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/generate_csf_clipped_from_classified_image.yaml
@@ -0,0 +1,89 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.featurecreator.GenerateCsfClippedFromClassifiedImage' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: GenerateCsfClippedFromClassifiedImage
+# 
+#     category: FeatureCreator
+# 
+#     description: Get the distance from a voxel to the nearest voxel of a given tissue type.
+# 
+#     version: 0.1.0.$Revision: 1 $(alpha)
+# 
+#     documentation-url: http:://www.na-mic.org/
+# 
+#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
+# 
+#     contributor: This tool was written by Hans J. Johnson.
+#     
+task_name: GenerateCsfClippedFromClassifiedImage
+nipype_name: GenerateCsfClippedFromClassifiedImage
+nipype_module: nipype.interfaces.semtools.featurecreator
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputCassifiedVolume: generic/file
+    # type=file|default=<undefined>: Required: input tissue label image
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputVolume: generic/file
+    # type=file: Required: output image
+    # type=traitcompound|default=None: Required: output image
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputCassifiedVolume:
+    # type=file|default=<undefined>: Required: input tissue label image
+    outputVolume:
+    # type=file: Required: output image
+    # type=traitcompound|default=None: Required: output image
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/generate_csf_clipped_from_classified_image_callables.py b/example-specs/task/nipype_internal/pydra-semtools/generate_csf_clipped_from_classified_image_callables.py
new file mode 100644
index 00000000..9c2dfa09
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/generate_csf_clipped_from_classified_image_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in GenerateCsfClippedFromClassifiedImage.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/generate_edge_map_image.yaml b/example-specs/task/nipype_internal/pydra-semtools/generate_edge_map_image.yaml
new file mode 100644
index 00000000..ebf9e787
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/generate_edge_map_image.yaml
@@ -0,0 +1,105 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.brains.utilities.GenerateEdgeMapImage' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: GenerateEdgeMapImage
+# 
+#     category: BRAINS.Utilities
+# 
+#     description: Automatic edgemap generation for edge-guided super-resolution reconstruction
+# 
+#     version: 1.0
+# 
+#     contributor: Ali Ghayoor
+#     
+task_name: GenerateEdgeMapImage
+nipype_name: GenerateEdgeMapImage
+nipype_module: nipype.interfaces.semtools.brains.utilities
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputMRVolumes: generic/file+list-of
+    # type=inputmultiobject|default=[]: List of input structural MR volumes to create the maximum edgemap
+    inputMask: generic/file
+    # type=file|default=<undefined>: Input mask file name. If set, image histogram percentiles will be calculated within the mask
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputEdgeMap: generic/file
+    # type=file: (required) output file name
+    # type=traitcompound|default=None: output edgemap file name
+    outputMaximumGradientImage: generic/file
+    # type=file: output gradient image file name
+    # type=traitcompound|default=None: output gradient image file name
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputMRVolumes:
+    # type=inputmultiobject|default=[]: List of input structural MR volumes to create the maximum edgemap
+    inputMask:
+    # type=file|default=<undefined>: Input mask file name. If set, image histogram percentiles will be calculated within the mask
+    minimumOutputRange:
+    # type=int|default=0: Map lower quantile and below to minimum output range. It should be a small number greater than zero. Default is 1
+    maximumOutputRange:
+    # type=int|default=0: Map upper quantile and above to maximum output range. Default is 255 that is the maximum range of unsigned char
+    lowerPercentileMatching:
+    # type=float|default=0.0: Map lower quantile and below to minOutputRange. It should be a value between zero and one
+    upperPercentileMatching:
+    # type=float|default=0.0: Map upper quantile and above to maxOutputRange. It should be a value between zero and one
+    outputEdgeMap:
+    # type=file: (required) output file name
+    # type=traitcompound|default=None: output edgemap file name
+    outputMaximumGradientImage:
+    # type=file: output gradient image file name
+    # type=traitcompound|default=None: output gradient image file name
+    numberOfThreads:
+    # type=int|default=0: Explicitly specify the maximum number of threads to use.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/generate_edge_map_image_callables.py b/example-specs/task/nipype_internal/pydra-semtools/generate_edge_map_image_callables.py
new file mode 100644
index 00000000..ae2090d6
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/generate_edge_map_image_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in GenerateEdgeMapImage.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/generate_label_map_from_probability_map.yaml b/example-specs/task/nipype_internal/pydra-semtools/generate_label_map_from_probability_map.yaml
new file mode 100644
index 00000000..ba2d6d53
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/generate_label_map_from_probability_map.yaml
@@ -0,0 +1,87 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.utilities.brains.GenerateLabelMapFromProbabilityMap' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Label Map from Probability Images
+# 
+#     category: Utilities.BRAINS
+# 
+#     description: Given a list of probability maps for labels, create a discrete label map where only the highest probability region is used for the labeling.
+# 
+#     version: 0.1
+# 
+#     contributor: University of Iowa Department of Psychiatry, http:://www.psychiatry.uiowa.edu
+#     
+task_name: GenerateLabelMapFromProbabilityMap
+nipype_name: GenerateLabelMapFromProbabilityMap
+nipype_module: nipype.interfaces.semtools.utilities.brains
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputVolumes: generic/file+list-of
+    # type=inputmultiobject|default=[]: The Input probaiblity images to be computed for label maps
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputLabelVolume: generic/file
+    # type=file: The Input binary image for region of interest
+    # type=traitcompound|default=None: The Input binary image for region of interest
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputVolumes:
+    # type=inputmultiobject|default=[]: The Input probaiblity images to be computed for label maps
+    outputLabelVolume:
+    # type=file: The Input binary image for region of interest
+    # type=traitcompound|default=None: The Input binary image for region of interest
+    numberOfThreads:
+    # type=int|default=0: Explicitly specify the maximum number of threads to use.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/generate_label_map_from_probability_map_callables.py b/example-specs/task/nipype_internal/pydra-semtools/generate_label_map_from_probability_map_callables.py
new file mode 100644
index 00000000..1a08ec5e
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/generate_label_map_from_probability_map_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in GenerateLabelMapFromProbabilityMap.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/generate_pure_plug_mask.yaml b/example-specs/task/nipype_internal/pydra-semtools/generate_pure_plug_mask.yaml
new file mode 100644
index 00000000..661149c2
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/generate_pure_plug_mask.yaml
@@ -0,0 +1,89 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.brains.utilities.GeneratePurePlugMask' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: GeneratePurePlugMask
+# 
+#     category: BRAINS.Utilities
+# 
+#     description: This program gets several modality image files and returns a binary mask that defines the pure plugs
+# 
+#     version: 1.0
+# 
+#     contributor: Ali Ghayoor
+#     
+task_name: GeneratePurePlugMask
+nipype_name: GeneratePurePlugMask
+nipype_module: nipype.interfaces.semtools.brains.utilities
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputImageModalities: generic/file+list-of
+    # type=inputmultiobject|default=[]: List of input image file names to create pure plugs mask
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputMaskFile: generic/file
+    # type=file: (required) Output binary mask file name
+    # type=traitcompound|default=None: Output binary mask file name
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputImageModalities:
+    # type=inputmultiobject|default=[]: List of input image file names to create pure plugs mask
+    threshold:
+    # type=float|default=0.0: threshold value to define class membership
+    numberOfSubSamples:
+    # type=inputmultiobject|default=[]: Number of continuous index samples taken at each direction of lattice space for each plug volume
+    outputMaskFile:
+    # type=file: (required) Output binary mask file name
+    # type=traitcompound|default=None: Output binary mask file name
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/generate_pure_plug_mask_callables.py b/example-specs/task/nipype_internal/pydra-semtools/generate_pure_plug_mask_callables.py
new file mode 100644
index 00000000..0d7df73d
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/generate_pure_plug_mask_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in GeneratePurePlugMask.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/generate_summed_gradient_image.yaml b/example-specs/task/nipype_internal/pydra-semtools/generate_summed_gradient_image.yaml
new file mode 100644
index 00000000..fb227b86
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/generate_summed_gradient_image.yaml
@@ -0,0 +1,95 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.filtering.featuredetection.GenerateSummedGradientImage' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: GenerateSummedGradient
+# 
+#     category: Filtering.FeatureDetection
+# 
+#     description: Automatic FeatureImages using neural networks
+# 
+#     version: 1.0
+# 
+#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
+# 
+#     contributor: Greg Harris, Eun Young Kim
+#     
+task_name: GenerateSummedGradientImage
+nipype_name: GenerateSummedGradientImage
+nipype_module: nipype.interfaces.semtools.filtering.featuredetection
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputVolume1: generic/file
+    # type=file|default=<undefined>: input volume 1, usually t1 image
+    inputVolume2: generic/file
+    # type=file|default=<undefined>: input volume 2, usually t2 image
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputFileName: generic/file
+    # type=file: (required) output file name
+    # type=traitcompound|default=None: (required) output file name
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputVolume1:
+    # type=file|default=<undefined>: input volume 1, usually t1 image
+    inputVolume2:
+    # type=file|default=<undefined>: input volume 2, usually t2 image
+    outputFileName:
+    # type=file: (required) output file name
+    # type=traitcompound|default=None: (required) output file name
+    MaximumGradient:
+    # type=bool|default=False: If set this flag, it will compute maximum gradient between two input volumes instead of sum of it.
+    numberOfThreads:
+    # type=int|default=0: Explicitly specify the maximum number of threads to use.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/generate_summed_gradient_image_callables.py b/example-specs/task/nipype_internal/pydra-semtools/generate_summed_gradient_image_callables.py
new file mode 100644
index 00000000..16fe577e
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/generate_summed_gradient_image_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in GenerateSummedGradientImage.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/generate_test_image.yaml b/example-specs/task/nipype_internal/pydra-semtools/generate_test_image.yaml
new file mode 100644
index 00000000..0fde3121
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/generate_test_image.yaml
@@ -0,0 +1,93 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.filtering.featuredetection.GenerateTestImage' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: DownSampleImage
+# 
+#     category: Filtering.FeatureDetection
+# 
+#     description: Down sample image for testing
+# 
+#     version: 1.0
+# 
+#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
+# 
+#     contributor: Eun Young Kim
+#     
+task_name: GenerateTestImage
+nipype_name: GenerateTestImage
+nipype_module: nipype.interfaces.semtools.filtering.featuredetection
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputVolume: generic/file
+    # type=file|default=<undefined>: input volume 1, usually t1 image
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputVolume: generic/file
+    # type=file: (required) output file name
+    # type=traitcompound|default=None: (required) output file name
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputVolume:
+    # type=file|default=<undefined>: input volume 1, usually t1 image
+    outputVolume:
+    # type=file: (required) output file name
+    # type=traitcompound|default=None: (required) output file name
+    lowerBoundOfOutputVolume:
+    # type=float|default=0.0: 
+    upperBoundOfOutputVolume:
+    # type=float|default=0.0: 
+    outputVolumeSize:
+    # type=float|default=0.0: output Volume Size
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/generate_test_image_callables.py b/example-specs/task/nipype_internal/pydra-semtools/generate_test_image_callables.py
new file mode 100644
index 00000000..37295d92
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/generate_test_image_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in GenerateTestImage.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gradient_anisotropic_diffusion_image_filter.yaml b/example-specs/task/nipype_internal/pydra-semtools/gradient_anisotropic_diffusion_image_filter.yaml
new file mode 100644
index 00000000..063e0897
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/gradient_anisotropic_diffusion_image_filter.yaml
@@ -0,0 +1,89 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.filtering.featuredetection.GradientAnisotropicDiffusionImageFilter' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: GradientAnisopropicDiffusionFilter
+# 
+#     category: Filtering.FeatureDetection
+# 
+#     description: Image Smoothing using Gradient Anisotropic Diffuesion Filer
+# 
+#     contributor: This tool was developed by Eun Young Kim by modifying ITK Example
+#     
+task_name: GradientAnisotropicDiffusionImageFilter
+nipype_name: GradientAnisotropicDiffusionImageFilter
+nipype_module: nipype.interfaces.semtools.filtering.featuredetection
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputVolume: generic/file
+    # type=file|default=<undefined>: Required: input image
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputVolume: generic/file
+    # type=file: Required: output image
+    # type=traitcompound|default=None: Required: output image
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputVolume:
+    # type=file|default=<undefined>: Required: input image
+    numberOfIterations:
+    # type=int|default=0: Optional value for number of Iterations
+    timeStep:
+    # type=float|default=0.0: Time step for diffusion process
+    conductance:
+    # type=float|default=0.0: Conductance for diffusion process
+    outputVolume:
+    # type=file: Required: output image
+    # type=traitcompound|default=None: Required: output image
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gradient_anisotropic_diffusion_image_filter_callables.py b/example-specs/task/nipype_internal/pydra-semtools/gradient_anisotropic_diffusion_image_filter_callables.py
new file mode 100644
index 00000000..3de25b59
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/gradient_anisotropic_diffusion_image_filter_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in GradientAnisotropicDiffusionImageFilter.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_anisotropy_map.yaml b/example-specs/task/nipype_internal/pydra-semtools/gtract_anisotropy_map.yaml
new file mode 100644
index 00000000..342eea9b
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/gtract_anisotropy_map.yaml
@@ -0,0 +1,95 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.diffusion.gtract.gtractAnisotropyMap' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Anisotropy Map
+# 
+#     category: Diffusion.GTRACT
+# 
+#     description: This program will generate a scalar map of anisotropy, given a tensor representation. Anisotropy images are used for fiber tracking, but the anisotropy scalars are not defined along the path. Instead, the tensor representation is included as point data allowing all of these metrics to be computed using only the fiber tract point data. The images can be saved in any ITK supported format, but it is suggested that you use an image format that supports the definition of the image origin. This includes NRRD, NifTI, and Meta formats. These images can also be used for scalar analysis including regional anisotropy measures or VBM style analysis.
+# 
+#     version: 4.0.0
+# 
+#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Modules:GTRACT
+# 
+#     license: http://mri.radiology.uiowa.edu/copyright/GTRACT-Copyright.txt
+# 
+#     contributor: This tool was developed by Vincent Magnotta and Greg Harris.
+# 
+#     acknowledgements: Funding for this version of the GTRACT program was provided by NIH/NINDS R01NS050568-01A2S1
+#     
+task_name: gtractAnisotropyMap
+nipype_name: gtractAnisotropyMap
+nipype_module: nipype.interfaces.semtools.diffusion.gtract
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputTensorVolume: generic/file
+    # type=file|default=<undefined>: Required: input file containing the diffusion tensor image
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputVolume: generic/file
+    # type=file: Required: name of output NRRD file containing the selected kind of anisotropy scalar.
+    # type=traitcompound|default=None: Required: name of output NRRD file containing the selected kind of anisotropy scalar.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputTensorVolume:
+    # type=file|default=<undefined>: Required: input file containing the diffusion tensor image
+    anisotropyType:
+    # type=enum|default='ADC'|allowed['AD','ADC','FA','LI','RA','RD','VR']: Anisotropy Mapping Type: ADC, FA, RA, VR, AD, RD, LI
+    outputVolume:
+    # type=file: Required: name of output NRRD file containing the selected kind of anisotropy scalar.
+    # type=traitcompound|default=None: Required: name of output NRRD file containing the selected kind of anisotropy scalar.
+    numberOfThreads:
+    # type=int|default=0: Explicitly specify the maximum number of threads to use.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_anisotropy_map_callables.py b/example-specs/task/nipype_internal/pydra-semtools/gtract_anisotropy_map_callables.py
new file mode 100644
index 00000000..326b5aa3
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/gtract_anisotropy_map_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in gtractAnisotropyMap.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_average_bvalues.yaml b/example-specs/task/nipype_internal/pydra-semtools/gtract_average_bvalues.yaml
new file mode 100644
index 00000000..3d601962
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/gtract_average_bvalues.yaml
@@ -0,0 +1,97 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.diffusion.gtract.gtractAverageBvalues' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Average B-Values
+# 
+#     category: Diffusion.GTRACT
+# 
+#     description: This program will directly average together the baseline gradients (b value equals 0) within a DWI scan. This is usually used after gtractCoregBvalues.
+# 
+#     version: 4.0.0
+# 
+#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Modules:GTRACT
+# 
+#     license: http://mri.radiology.uiowa.edu/copyright/GTRACT-Copyright.txt
+# 
+#     contributor: This tool was developed by Vincent Magnotta and Greg Harris.
+# 
+#     acknowledgements: Funding for this version of the GTRACT program was provided by NIH/NINDS R01NS050568-01A2S1
+#     
+task_name: gtractAverageBvalues
+nipype_name: gtractAverageBvalues
+nipype_module: nipype.interfaces.semtools.diffusion.gtract
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputVolume: generic/file
+    # type=file|default=<undefined>: Required: input image file name containing multiple baseline gradients to average
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputVolume: generic/file
+    # type=file: Required: name of output NRRD file containing directly averaged baseline images
+    # type=traitcompound|default=None: Required: name of output NRRD file containing directly averaged baseline images
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputVolume:
+    # type=file|default=<undefined>: Required: input image file name containing multiple baseline gradients to average
+    outputVolume:
+    # type=file: Required: name of output NRRD file containing directly averaged baseline images
+    # type=traitcompound|default=None: Required: name of output NRRD file containing directly averaged baseline images
+    directionsTolerance:
+    # type=float|default=0.0: Tolerance for matching identical gradient direction pairs
+    averageB0only:
+    # type=bool|default=False: Average only baseline gradients. All other gradient directions are not averaged, but retained in the outputVolume
+    numberOfThreads:
+    # type=int|default=0: Explicitly specify the maximum number of threads to use.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_average_bvalues_callables.py b/example-specs/task/nipype_internal/pydra-semtools/gtract_average_bvalues_callables.py
new file mode 100644
index 00000000..776c1057
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/gtract_average_bvalues_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in gtractAverageBvalues.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_clip_anisotropy.yaml b/example-specs/task/nipype_internal/pydra-semtools/gtract_clip_anisotropy.yaml
new file mode 100644
index 00000000..39cb7ac0
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/gtract_clip_anisotropy.yaml
@@ -0,0 +1,97 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.diffusion.gtract.gtractClipAnisotropy' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Clip Anisotropy
+# 
+#     category: Diffusion.GTRACT
+# 
+#     description: This program will zero the first and/or last slice of an anisotropy image, creating a clipped anisotropy image.
+# 
+#     version: 4.0.0
+# 
+#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Modules:GTRACT
+# 
+#     license: http://mri.radiology.uiowa.edu/copyright/GTRACT-Copyright.txt
+# 
+#     contributor: This tool was developed by Vincent Magnotta and Greg Harris.
+# 
+#     acknowledgements: Funding for this version of the GTRACT program was provided by NIH/NINDS R01NS050568-01A2S1
+#     
+task_name: gtractClipAnisotropy
+nipype_name: gtractClipAnisotropy
+nipype_module: nipype.interfaces.semtools.diffusion.gtract
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputVolume: generic/file
+    # type=file|default=<undefined>: Required: input image file name
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputVolume: generic/file
+    # type=file: Required: name of output NRRD file containing the clipped anisotropy image
+    # type=traitcompound|default=None: Required: name of output NRRD file containing the clipped anisotropy image
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputVolume:
+    # type=file|default=<undefined>: Required: input image file name
+    outputVolume:
+    # type=file: Required: name of output NRRD file containing the clipped anisotropy image
+    # type=traitcompound|default=None: Required: name of output NRRD file containing the clipped anisotropy image
+    clipFirstSlice:
+    # type=bool|default=False: Clip the first slice of the anisotropy image
+    clipLastSlice:
+    # type=bool|default=False: Clip the last slice of the anisotropy image
+    numberOfThreads:
+    # type=int|default=0: Explicitly specify the maximum number of threads to use.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_clip_anisotropy_callables.py b/example-specs/task/nipype_internal/pydra-semtools/gtract_clip_anisotropy_callables.py
new file mode 100644
index 00000000..3fddaef0
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/gtract_clip_anisotropy_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in gtractClipAnisotropy.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_co_reg_anatomy.yaml b/example-specs/task/nipype_internal/pydra-semtools/gtract_co_reg_anatomy.yaml
new file mode 100644
index 00000000..920d3ccf
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/gtract_co_reg_anatomy.yaml
@@ -0,0 +1,139 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.diffusion.gtract.gtractCoRegAnatomy' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Coregister B0 to Anatomy B-Spline
+# 
+#     category: Diffusion.GTRACT
+# 
+#     description: This program will register a Nrrd diffusion weighted 4D vector image to a fixed anatomical image. Two registration methods are supported for alignment with anatomical images: Rigid and B-Spline. The rigid registration performs a rigid body registration with the anatomical images and should be done as well to initialize the B-Spline transform. The B-SPline transform is the deformable transform, where the user can control the amount of deformation based on the number of control points as well as the maximum distance that these points can move. The B-Spline registration places a low dimensional grid in the image, which is deformed. This allows for some susceptibility related distortions to be removed from the diffusion weighted images. In general the amount of motion in the slice selection and read-out directions direction should be kept low. The distortion is in the phase encoding direction in the images. It is recommended that skull stripped (i.e. image containing only brain with skull removed) images should be used for image co-registration with the B-Spline transform.
+# 
+#     version: 4.0.0
+# 
+#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Modules:GTRACT
+# 
+#     license: http://mri.radiology.uiowa.edu/copyright/GTRACT-Copyright.txt
+# 
+#     contributor: This tool was developed by Vincent Magnotta and Greg Harris.
+# 
+#     acknowledgements: Funding for this version of the GTRACT program was provided by NIH/NINDS R01NS050568-01A2S1
+#     
+task_name: gtractCoRegAnatomy
+nipype_name: gtractCoRegAnatomy
+nipype_module: nipype.interfaces.semtools.diffusion.gtract
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputVolume: generic/file
+    # type=file|default=<undefined>: Required: input vector image file name. It is recommended that the input volume is the skull stripped baseline image of the DWI scan.
+    inputAnatomicalVolume: generic/file
+    # type=file|default=<undefined>: Required: input anatomical image file name. It is recommended that the input anatomical image has been skull stripped and has the same orientation as the DWI scan.
+    inputRigidTransform: generic/file
+    # type=file|default=<undefined>: Required (for B-Spline type co-registration): input rigid transform file name. Used as a starting point for the anatomical B-Spline registration.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputTransformName: generic/file
+    # type=file: Required: filename for the  fit transform.
+    # type=traitcompound|default=None: Required: filename for the  fit transform.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputVolume:
+    # type=file|default=<undefined>: Required: input vector image file name. It is recommended that the input volume is the skull stripped baseline image of the DWI scan.
+    inputAnatomicalVolume:
+    # type=file|default=<undefined>: Required: input anatomical image file name. It is recommended that the input anatomical image has been skull stripped and has the same orientation as the DWI scan.
+    vectorIndex:
+    # type=int|default=0: Vector image index in the moving image (within the DWI) to be used for registration.
+    inputRigidTransform:
+    # type=file|default=<undefined>: Required (for B-Spline type co-registration): input rigid transform file name. Used as a starting point for the anatomical B-Spline registration.
+    outputTransformName:
+    # type=file: Required: filename for the  fit transform.
+    # type=traitcompound|default=None: Required: filename for the  fit transform.
+    transformType:
+    # type=enum|default='Rigid'|allowed['Bspline','Rigid']: Transform Type: Rigid|Bspline
+    numberOfIterations:
+    # type=int|default=0: Number of iterations in the selected 3D fit
+    gridSize:
+    # type=inputmultiobject|default=[]: Number of grid subdivisions in all 3 directions
+    borderSize:
+    # type=int|default=0: Size of border
+    numberOfHistogramBins:
+    # type=int|default=0: Number of histogram bins
+    spatialScale:
+    # type=int|default=0: Scales the number of voxels in the image by this value to specify the number of voxels used in the registration
+    convergence:
+    # type=float|default=0.0: Convergence Factor
+    gradientTolerance:
+    # type=float|default=0.0: Gradient Tolerance
+    maxBSplineDisplacement:
+    # type=float|default=0.0:  Sets the maximum allowed displacements in image physical coordinates for BSpline control grid along each axis.  A value of 0.0 indicates that the problem should be unbounded.  NOTE:  This only constrains the BSpline portion, and does not limit the displacement from the associated bulk transform.  This can lead to a substantial reduction in computation time in the BSpline optimizer.,       
+    maximumStepSize:
+    # type=float|default=0.0: Maximum permitted step size to move in the selected 3D fit
+    minimumStepSize:
+    # type=float|default=0.0: Minimum required step size to move in the selected 3D fit without converging -- decrease this to make the fit more exacting
+    translationScale:
+    # type=float|default=0.0: How much to scale up changes in position compared to unit rotational changes in radians -- decrease this to put more translation in the fit
+    relaxationFactor:
+    # type=float|default=0.0: Fraction of gradient from Jacobian to attempt to move in the selected 3D fit
+    numberOfSamples:
+    # type=int|default=0: The number of voxels sampled for mutual information computation.  Increase this for a slower, more careful fit. NOTE that it is suggested to use samplingPercentage instead of this option. However, if set, it overwrites the samplingPercentage option.  
+    samplingPercentage:
+    # type=float|default=0.0: This is a number in (0.0,1.0] interval that shows the percentage of the input fixed image voxels that are sampled for mutual information computation.  Increase this for a slower, more careful fit. You can also limit the sampling focus with ROI masks and ROIAUTO mask generation. The default is to use approximately 5% of voxels (for backwards compatibility 5% ~= 500000/(256*256*256)). Typical values range from 1% for low detail images to 20% for high detail images.
+    useMomentsAlign:
+    # type=bool|default=False: MomentsAlign assumes that the center of mass of the images represent similar structures.  Perform a MomentsAlign registration as part of the sequential registration steps.   This option MUST come first, and CAN NOT be used with either CenterOfHeadLAlign, GeometryAlign, or initialTransform file.  This family of options superceeds the use of transformType if any of them are set.
+    useGeometryAlign:
+    # type=bool|default=False: GeometryAlign on assumes that the center of the voxel lattice of the images represent similar structures. Perform a GeometryCenterAlign registration as part of the sequential registration steps.   This option MUST come first, and CAN NOT be used with either MomentsAlign, CenterOfHeadAlign, or initialTransform file.  This family of options superceeds the use of transformType if any of them are set.
+    useCenterOfHeadAlign:
+    # type=bool|default=False: CenterOfHeadAlign attempts to find a hemisphere full of foreground voxels from the superior direction as an estimate of where the center of a head shape would be to drive a center of mass estimate.  Perform a CenterOfHeadAlign registration as part of the sequential registration steps.   This option MUST come first, and CAN NOT be used with either MomentsAlign, GeometryAlign, or initialTransform file.  This family of options superceeds the use of transformType if any of them are set.
+    numberOfThreads:
+    # type=int|default=0: Explicitly specify the maximum number of threads to use.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_co_reg_anatomy_callables.py b/example-specs/task/nipype_internal/pydra-semtools/gtract_co_reg_anatomy_callables.py
new file mode 100644
index 00000000..41723e80
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/gtract_co_reg_anatomy_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in gtractCoRegAnatomy.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_concat_dwi.yaml b/example-specs/task/nipype_internal/pydra-semtools/gtract_concat_dwi.yaml
new file mode 100644
index 00000000..8d8032b0
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/gtract_concat_dwi.yaml
@@ -0,0 +1,95 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.diffusion.gtract.gtractConcatDwi' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Concat DWI Images
+# 
+#     category: Diffusion.GTRACT
+# 
+#     description: This program will concatenate two DTI runs together.
+# 
+#     version: 4.0.0
+# 
+#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Modules:GTRACT
+# 
+#     license: http://mri.radiology.uiowa.edu/copyright/GTRACT-Copyright.txt
+# 
+#     contributor: This tool was developed by Vincent Magnotta and Greg Harris.
+# 
+#     acknowledgements: Funding for this version of the GTRACT program was provided by NIH/NINDS R01NS050568-01A2S1
+#     
+task_name: gtractConcatDwi
+nipype_name: gtractConcatDwi
+nipype_module: nipype.interfaces.semtools.diffusion.gtract
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputVolume: generic/file+list-of
+    # type=inputmultiobject|default=[]: Required: input file containing the first diffusion weighted image
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputVolume: generic/file
+    # type=file: Required: name of output NRRD file containing the combined diffusion weighted images.
+    # type=traitcompound|default=None: Required: name of output NRRD file containing the combined diffusion weighted images.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputVolume:
+    # type=inputmultiobject|default=[]: Required: input file containing the first diffusion weighted image
+    ignoreOrigins:
+    # type=bool|default=False: If image origins are different force all images to origin of first image
+    outputVolume:
+    # type=file: Required: name of output NRRD file containing the combined diffusion weighted images.
+    # type=traitcompound|default=None: Required: name of output NRRD file containing the combined diffusion weighted images.
+    numberOfThreads:
+    # type=int|default=0: Explicitly specify the maximum number of threads to use.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_concat_dwi_callables.py b/example-specs/task/nipype_internal/pydra-semtools/gtract_concat_dwi_callables.py
new file mode 100644
index 00000000..88e971f4
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/gtract_concat_dwi_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in gtractConcatDwi.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_copy_image_orientation.yaml b/example-specs/task/nipype_internal/pydra-semtools/gtract_copy_image_orientation.yaml
new file mode 100644
index 00000000..2ea89e23
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/gtract_copy_image_orientation.yaml
@@ -0,0 +1,97 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.diffusion.gtract.gtractCopyImageOrientation' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Copy Image Orientation
+# 
+#     category: Diffusion.GTRACT
+# 
+#     description: This program will copy the orientation from the reference image into the moving image. Currently, the registration process requires that the diffusion weighted images and the anatomical images have the same image orientation (i.e. Axial, Coronal, Sagittal). It is suggested that you copy the image orientation from the diffusion weighted images and apply this to the anatomical image. This image can be subsequently removed after the registration step is complete. We anticipate that this limitation will be removed in future versions of the registration programs.
+# 
+#     version: 4.0.0
+# 
+#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Modules:GTRACT
+# 
+#     license: http://mri.radiology.uiowa.edu/copyright/GTRACT-Copyright.txt
+# 
+#     contributor: This tool was developed by Vincent Magnotta and Greg Harris.
+# 
+#     acknowledgements: Funding for this version of the GTRACT program was provided by NIH/NINDS R01NS050568-01A2S1
+#     
+task_name: gtractCopyImageOrientation
+nipype_name: gtractCopyImageOrientation
+nipype_module: nipype.interfaces.semtools.diffusion.gtract
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputVolume: generic/file
+    # type=file|default=<undefined>: Required: input file containing the signed short image to reorient without resampling.
+    inputReferenceVolume: generic/file
+    # type=file|default=<undefined>: Required: input file containing orientation that will be cloned.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputVolume: generic/file
+    # type=file: Required: name of output NRRD or Nifti file containing the reoriented image in reference image space.
+    # type=traitcompound|default=None: Required: name of output NRRD or Nifti file containing the reoriented image in reference image space.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputVolume:
+    # type=file|default=<undefined>: Required: input file containing the signed short image to reorient without resampling.
+    inputReferenceVolume:
+    # type=file|default=<undefined>: Required: input file containing orientation that will be cloned.
+    outputVolume:
+    # type=file: Required: name of output NRRD or Nifti file containing the reoriented image in reference image space.
+    # type=traitcompound|default=None: Required: name of output NRRD or Nifti file containing the reoriented image in reference image space.
+    numberOfThreads:
+    # type=int|default=0: Explicitly specify the maximum number of threads to use.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_copy_image_orientation_callables.py b/example-specs/task/nipype_internal/pydra-semtools/gtract_copy_image_orientation_callables.py
new file mode 100644
index 00000000..bf2f62c7
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/gtract_copy_image_orientation_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in gtractCopyImageOrientation.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_coreg_bvalues.yaml b/example-specs/task/nipype_internal/pydra-semtools/gtract_coreg_bvalues.yaml
new file mode 100644
index 00000000..061881e1
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/gtract_coreg_bvalues.yaml
@@ -0,0 +1,125 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.diffusion.gtract.gtractCoregBvalues' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Coregister B-Values
+# 
+#     category: Diffusion.GTRACT
+# 
+#     description: This step should be performed after converting DWI scans from DICOM to NRRD format. This program will register all gradients in a NRRD diffusion weighted 4D vector image (moving image) to a specified index in a fixed image. It also supports co-registration with a T2 weighted image or field map in the same plane as the DWI data. The fixed image for the registration should be a b0 image. A mutual information metric cost function is used for the registration because of the differences in signal intensity as a result of the diffusion gradients. The full affine allows the registration procedure to correct for eddy current distortions that may exist in the data. If the eddyCurrentCorrection is enabled, relaxationFactor (0.25) and maximumStepSize (0.1) should be adjusted.
+# 
+#     version: 4.0.0
+# 
+#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Modules:GTRACT
+# 
+#     license: http://mri.radiology.uiowa.edu/copyright/GTRACT-Copyright.txt
+# 
+#     contributor: This tool was developed by Vincent Magnotta and Greg Harris.
+# 
+#     acknowledgements: Funding for this version of the GTRACT program was provided by NIH/NINDS R01NS050568-01A2S1
+#     
+task_name: gtractCoregBvalues
+nipype_name: gtractCoregBvalues
+nipype_module: nipype.interfaces.semtools.diffusion.gtract
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    movingVolume: generic/file
+    # type=file|default=<undefined>: Required: input moving image file name. In order to register gradients within a scan to its first gradient, set the movingVolume and fixedVolume as the same image.
+    fixedVolume: generic/file
+    # type=file|default=<undefined>: Required: input fixed image file name. It is recommended that this image should either contain or be a b0 image.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputVolume: generic/file
+    # type=file: Required: name of output NRRD file containing moving images individually resampled and fit to the specified fixed image index.
+    # type=traitcompound|default=None: Required: name of output NRRD file containing moving images individually resampled and fit to the specified fixed image index.
+    outputTransform: generic/file
+    # type=file: Registration 3D transforms concatenated in a single output file.  There are no tools that can use this, but can be used for debugging purposes.
+    # type=traitcompound|default=None: Registration 3D transforms concatenated in a single output file.  There are no tools that can use this, but can be used for debugging purposes.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    movingVolume:
+    # type=file|default=<undefined>: Required: input moving image file name. In order to register gradients within a scan to its first gradient, set the movingVolume and fixedVolume as the same image.
+    fixedVolume:
+    # type=file|default=<undefined>: Required: input fixed image file name. It is recommended that this image should either contain or be a b0 image.
+    fixedVolumeIndex:
+    # type=int|default=0: Index in the fixed image for registration. It is recommended that this image should be a b0 image.
+    outputVolume:
+    # type=file: Required: name of output NRRD file containing moving images individually resampled and fit to the specified fixed image index.
+    # type=traitcompound|default=None: Required: name of output NRRD file containing moving images individually resampled and fit to the specified fixed image index.
+    outputTransform:
+    # type=file: Registration 3D transforms concatenated in a single output file.  There are no tools that can use this, but can be used for debugging purposes.
+    # type=traitcompound|default=None: Registration 3D transforms concatenated in a single output file.  There are no tools that can use this, but can be used for debugging purposes.
+    eddyCurrentCorrection:
+    # type=bool|default=False: Flag to perform eddy current correction in addition to motion correction (recommended)
+    numberOfIterations:
+    # type=int|default=0: Number of iterations in each 3D fit
+    numberOfSpatialSamples:
+    # type=int|default=0: The number of voxels sampled for mutual information computation.  Increase this for a slower, more careful fit. NOTE that it is suggested to use samplingPercentage instead of this option. However, if set, it overwrites the samplingPercentage option.  
+    samplingPercentage:
+    # type=float|default=0.0: This is a number in (0.0,1.0] interval that shows the percentage of the input fixed image voxels that are sampled for mutual information computation.  Increase this for a slower, more careful fit. You can also limit the sampling focus with ROI masks and ROIAUTO mask generation. The default is to use approximately 5% of voxels (for backwards compatibility 5% ~= 500000/(256*256*256)). Typical values range from 1% for low detail images to 20% for high detail images.
+    relaxationFactor:
+    # type=float|default=0.0: Fraction of gradient from Jacobian to attempt to move in each 3D fit step (adjust when eddyCurrentCorrection is enabled; suggested value = 0.25)
+    maximumStepSize:
+    # type=float|default=0.0: Maximum permitted step size to move in each 3D fit step (adjust when eddyCurrentCorrection is enabled; suggested value = 0.1)
+    minimumStepSize:
+    # type=float|default=0.0: Minimum required step size to move in each 3D fit step without converging -- decrease this to make the fit more exacting
+    spatialScale:
+    # type=float|default=0.0: How much to scale up changes in position compared to unit rotational changes in radians -- decrease this to put more rotation in the fit
+    registerB0Only:
+    # type=bool|default=False: Register the B0 images only
+    debugLevel:
+    # type=int|default=0: Display debug messages, and produce debug intermediate results.  0=OFF, 1=Minimal, 10=Maximum debugging.
+    numberOfThreads:
+    # type=int|default=0: Explicitly specify the maximum number of threads to use.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_coreg_bvalues_callables.py b/example-specs/task/nipype_internal/pydra-semtools/gtract_coreg_bvalues_callables.py
new file mode 100644
index 00000000..44f534c9
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/gtract_coreg_bvalues_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in gtractCoregBvalues.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_cost_fast_marching.yaml b/example-specs/task/nipype_internal/pydra-semtools/gtract_cost_fast_marching.yaml
new file mode 100644
index 00000000..c266a400
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/gtract_cost_fast_marching.yaml
@@ -0,0 +1,115 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.diffusion.gtract.gtractCostFastMarching' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Cost Fast Marching
+# 
+#     category: Diffusion.GTRACT
+# 
+#     description: This program will use a fast marching fiber tracking algorithm to identify fiber tracts from a tensor image. This program is the first portion of the algorithm. The user must first run gtractFastMarchingTracking to generate the actual fiber tracts.  This algorithm is roughly based on the work by G. Parker et al. from IEEE Transactions On Medical Imaging, 21(5): 505-512, 2002. An additional feature of including anisotropy into the vcl_cost function calculation is included.
+# 
+#     version: 4.0.0
+# 
+#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Modules:GTRACT
+# 
+#     license: http://mri.radiology.uiowa.edu/copyright/GTRACT-Copyright.txt
+# 
+#     contributor: This tool was developed by Vincent Magnotta and Greg Harris. The original code here was developed by Daisy Espino.
+# 
+#     acknowledgements: Funding for this version of the GTRACT program was provided by NIH/NINDS R01NS050568-01A2S1
+#     
+task_name: gtractCostFastMarching
+nipype_name: gtractCostFastMarching
+nipype_module: nipype.interfaces.semtools.diffusion.gtract
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputTensorVolume: generic/file
+    # type=file|default=<undefined>: Required: input tensor image file name
+    inputAnisotropyVolume: generic/file
+    # type=file|default=<undefined>: Required: input anisotropy image file name
+    inputStartingSeedsLabelMapVolume: generic/file
+    # type=file|default=<undefined>: Required: input starting seeds LabelMap image file name
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputCostVolume: generic/file
+    # type=file: Output vcl_cost image
+    # type=traitcompound|default=None: Output vcl_cost image
+    outputSpeedVolume: generic/file
+    # type=file: Output speed image
+    # type=traitcompound|default=None: Output speed image
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputTensorVolume:
+    # type=file|default=<undefined>: Required: input tensor image file name
+    inputAnisotropyVolume:
+    # type=file|default=<undefined>: Required: input anisotropy image file name
+    inputStartingSeedsLabelMapVolume:
+    # type=file|default=<undefined>: Required: input starting seeds LabelMap image file name
+    startingSeedsLabel:
+    # type=int|default=0: Label value for Starting Seeds
+    outputCostVolume:
+    # type=file: Output vcl_cost image
+    # type=traitcompound|default=None: Output vcl_cost image
+    outputSpeedVolume:
+    # type=file: Output speed image
+    # type=traitcompound|default=None: Output speed image
+    anisotropyWeight:
+    # type=float|default=0.0: Anisotropy weight used for vcl_cost function calculations
+    stoppingValue:
+    # type=float|default=0.0: Terminiating value for vcl_cost function estimation
+    seedThreshold:
+    # type=float|default=0.0: Anisotropy threshold used for seed selection
+    numberOfThreads:
+    # type=int|default=0: Explicitly specify the maximum number of threads to use.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_cost_fast_marching_callables.py b/example-specs/task/nipype_internal/pydra-semtools/gtract_cost_fast_marching_callables.py
new file mode 100644
index 00000000..86210563
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/gtract_cost_fast_marching_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in gtractCostFastMarching.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_create_guide_fiber.yaml b/example-specs/task/nipype_internal/pydra-semtools/gtract_create_guide_fiber.yaml
new file mode 100644
index 00000000..125a8cc6
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/gtract_create_guide_fiber.yaml
@@ -0,0 +1,97 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.diffusion.gtract.gtractCreateGuideFiber' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Create Guide Fiber
+# 
+#     category: Diffusion.GTRACT
+# 
+#     description: This program will create a guide fiber by averaging fibers from a previously generated tract.
+# 
+#     version: 4.0.0
+# 
+#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Modules:GTRACT
+# 
+#     license: http://mri.radiology.uiowa.edu/copyright/GTRACT-Copyright.txt
+# 
+#     contributor: This tool was developed by Vincent Magnotta and Greg Harris.
+# 
+#     acknowledgements: Funding for this version of the GTRACT program was provided by NIH/NINDS R01NS050568-01A2S1
+#     
+task_name: gtractCreateGuideFiber
+nipype_name: gtractCreateGuideFiber
+nipype_module: nipype.interfaces.semtools.diffusion.gtract
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputFiber: generic/file
+    # type=file|default=<undefined>: Required: input fiber tract file name
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputFiber: generic/file
+    # type=file: Required: output guide fiber file name
+    # type=traitcompound|default=None: Required: output guide fiber file name
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputFiber:
+    # type=file|default=<undefined>: Required: input fiber tract file name
+    numberOfPoints:
+    # type=int|default=0: Number of points in output guide fiber
+    outputFiber:
+    # type=file: Required: output guide fiber file name
+    # type=traitcompound|default=None: Required: output guide fiber file name
+    writeXMLPolyDataFile:
+    # type=bool|default=False: Flag to make use of XML files when reading and writing vtkPolyData.
+    numberOfThreads:
+    # type=int|default=0: Explicitly specify the maximum number of threads to use.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_create_guide_fiber_callables.py b/example-specs/task/nipype_internal/pydra-semtools/gtract_create_guide_fiber_callables.py
new file mode 100644
index 00000000..52b4e240
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/gtract_create_guide_fiber_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in gtractCreateGuideFiber.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_fast_marching_tracking.yaml b/example-specs/task/nipype_internal/pydra-semtools/gtract_fast_marching_tracking.yaml
new file mode 100644
index 00000000..16a88617
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/gtract_fast_marching_tracking.yaml
@@ -0,0 +1,121 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.diffusion.gtract.gtractFastMarchingTracking' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Fast Marching Tracking
+# 
+#     category: Diffusion.GTRACT
+# 
+#     description: This program will use a fast marching fiber tracking algorithm to identify fiber tracts from a tensor image. This program is the second portion of the algorithm. The user must first run gtractCostFastMarching to generate the vcl_cost image. The second step of the algorithm implemented here is a gradient descent soplution from the defined ending region back to the seed points specified in gtractCostFastMarching. This algorithm is roughly based on the work by G. Parker et al. from IEEE Transactions On Medical Imaging, 21(5): 505-512, 2002. An additional feature of including anisotropy into the vcl_cost function calculation is included.
+# 
+#     version: 4.0.0
+# 
+#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Modules:GTRACT
+# 
+#     license: http://mri.radiology.uiowa.edu/copyright/GTRACT-Copyright.txt
+# 
+#     contributor: This tool was developed by Vincent Magnotta and Greg Harris. The original code here was developed by Daisy Espino.
+# 
+#     acknowledgements: Funding for this version of the GTRACT program was provided by NIH/NINDS R01NS050568-01A2S1
+#     
+task_name: gtractFastMarchingTracking
+nipype_name: gtractFastMarchingTracking
+nipype_module: nipype.interfaces.semtools.diffusion.gtract
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputTensorVolume: generic/file
+    # type=file|default=<undefined>: Required: input tensor image file name
+    inputAnisotropyVolume: generic/file
+    # type=file|default=<undefined>: Required: input anisotropy image file name
+    inputCostVolume: generic/file
+    # type=file|default=<undefined>: Required: input vcl_cost image file name
+    inputStartingSeedsLabelMapVolume: generic/file
+    # type=file|default=<undefined>: Required: input starting seeds LabelMap image file name
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputTract: generic/file
+    # type=file: Required: name of output vtkPolydata file containing tract lines and the point data collected along them.
+    # type=traitcompound|default=None: Required: name of output vtkPolydata file containing tract lines and the point data collected along them.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputTensorVolume:
+    # type=file|default=<undefined>: Required: input tensor image file name
+    inputAnisotropyVolume:
+    # type=file|default=<undefined>: Required: input anisotropy image file name
+    inputCostVolume:
+    # type=file|default=<undefined>: Required: input vcl_cost image file name
+    inputStartingSeedsLabelMapVolume:
+    # type=file|default=<undefined>: Required: input starting seeds LabelMap image file name
+    startingSeedsLabel:
+    # type=int|default=0: Label value for Starting Seeds
+    outputTract:
+    # type=file: Required: name of output vtkPolydata file containing tract lines and the point data collected along them.
+    # type=traitcompound|default=None: Required: name of output vtkPolydata file containing tract lines and the point data collected along them.
+    writeXMLPolyDataFile:
+    # type=bool|default=False: Flag to make use of the XML format for vtkPolyData fiber tracts.
+    numberOfIterations:
+    # type=int|default=0: Number of iterations used for the optimization
+    seedThreshold:
+    # type=float|default=0.0: Anisotropy threshold used for seed selection
+    trackingThreshold:
+    # type=float|default=0.0: Anisotropy threshold used for fiber tracking
+    costStepSize:
+    # type=float|default=0.0: Cost image sub-voxel sampling
+    maximumStepSize:
+    # type=float|default=0.0: Maximum step size to move when tracking
+    minimumStepSize:
+    # type=float|default=0.0: Minimum step size to move when tracking
+    numberOfThreads:
+    # type=int|default=0: Explicitly specify the maximum number of threads to use.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_fast_marching_tracking_callables.py b/example-specs/task/nipype_internal/pydra-semtools/gtract_fast_marching_tracking_callables.py
new file mode 100644
index 00000000..09ef0831
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/gtract_fast_marching_tracking_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in gtractFastMarchingTracking.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_fiber_tracking.yaml b/example-specs/task/nipype_internal/pydra-semtools/gtract_fiber_tracking.yaml
new file mode 100644
index 00000000..eba31ce0
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/gtract_fiber_tracking.yaml
@@ -0,0 +1,151 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.diffusion.gtract.gtractFiberTracking' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Fiber Tracking
+# 
+#     category: Diffusion.GTRACT
+# 
+#     description: This program implements four fiber tracking methods (Free, Streamline, GraphSearch, Guided). The output of the fiber tracking is vtkPolyData (i.e. Polylines) that can be loaded into Slicer3 for visualization. The poly data can be saved in either old VTK format files (.vtk) or in the new VTK XML format (.xml). The polylines contain point data that defines the Tensor at each point along the fiber tract. This can then be used to rendered as glyphs in Slicer3 and can be used to define several scalar measures without referencing back to the anisotropy images. (1) Free tracking is a basic streamlines algorithm. This is a direct implementation of the method original proposed by Basser et al. The tracking follows the primarty eigenvector. The tracking begins with seed points in the starting region. Only those voxels above the specified anisotropy threshold in the starting region are used as seed points. Tracking terminates either as a result of maximum fiber length, low ansiotropy, or large curvature. This is a great way to explore your data. (2) The streamlines algorithm is a direct implementation of the method originally proposed by Basser et al. The tracking follows the primary eigenvector. The tracking begins with seed points in the starting region. Only those voxels above the specified anisotropy threshold in the starting region are used as seed points. Tracking terminates either by reaching the ending region or reaching some stopping criteria. Stopping criteria are specified using the following parameters: tracking threshold, curvature threshold, and max length. Only paths terminating in the ending region are kept in this method. The TEND algorithm proposed by Lazar et al. (Human Brain Mapping 18:306-321, 2003) has been instrumented. This can be enabled using the --useTend option while performing Streamlines tracking. This utilizes the entire diffusion tensor to deflect the incoming vector instead of simply following the primary eigenvector. The TEND parameters are set using the --tendF and --tendG options. (3) Graph Search tracking is the first step in the full GTRACT algorithm developed by Cheng et al. (NeuroImage 31(3): 1075-1085, 2006) for finding the tracks in a tensor image. This method was developed to generate fibers in a Tensor representation where crossing fibers occur. The graph search algorithm follows the primary eigenvector in non-ambiguous regions and utilizes branching and a graph search algorithm in ambiguous regions. Ambiguous tracking regions are defined based on two criteria: Branching Al Threshold (anisotropy values below this value and above the traching threshold) and Curvature Major Eigen (angles of the primary eigenvector direction and the current tracking direction). In regions that meet this criteria, two or three tracking paths are considered. The first is the standard primary eigenvector direction. The second is the seconadary eigenvector direction. This is based on the assumption that these regions may be prolate regions. If the Random Walk option is selected then a third direction is also considered. This direction is defined by a cone pointing from the current position to the centroid of the ending region. The interior angle of the cone is specified by the user with the Branch/Guide Angle parameter. A vector contained inside of the cone is selected at random and used as the third direction. This method can also utilize the TEND option where the primary tracking direction is that specified by the TEND method instead of the primary eigenvector. The parameter '--maximumBranchPoints' allows the tracking to have this number of branches being considered at a time. If this number of branch points is exceeded at any time, then the algorithm will revert back to a streamline algorithm until the number of branches is reduced. This allows the user to constrain the computational complexity of the algorithm. (4) The second phase of the GTRACT algorithm is Guided Tracking. This method incorporates anatomical information about the track orientation using an initial guess of the fiber track. In the originally proposed GTRACT method, this would be created from the fibers resulting from the Graph Search tracking. However, in practice this can be created using any method and could be defined manually. To create the guide fiber the program gtractCreateGuideFiber can be used. This program will load a fiber tract that has been generated and create a centerline representation of the fiber tract (i.e. a single fiber). In this method, the fiber tracking follows the primary eigenvector direction unless it deviates from the guide fiber track by a angle greater than that specified by the '--guidedCurvatureThreshold' parameter. The user must specify the guide fiber when running this program.
+# 
+#     version: 4.0.0
+# 
+#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Modules:GTRACT
+# 
+#     license: http://mri.radiology.uiowa.edu/copyright/GTRACT-Copyright.txt
+# 
+#     contributor: This tool was developed by Vincent Magnotta, Greg Harris and Yongqiang Zhao.
+# 
+#     acknowledgements: Funding for this version of the GTRACT program was provided by NIH/NINDS R01NS050568-01A2S1
+#     
+task_name: gtractFiberTracking
+nipype_name: gtractFiberTracking
+nipype_module: nipype.interfaces.semtools.diffusion.gtract
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputTensorVolume: generic/file
+    # type=file|default=<undefined>: Required (for Free, Streamline, GraphSearch, and Guided fiber tracking methods): input tensor image file name
+    inputAnisotropyVolume: generic/file
+    # type=file|default=<undefined>: Required (for Free, Streamline, GraphSearch, and Guided fiber tracking methods): input anisotropy image file name
+    inputStartingSeedsLabelMapVolume: generic/file
+    # type=file|default=<undefined>: Required (for Free, Streamline, GraphSearch, and Guided fiber tracking methods): input starting seeds LabelMap image file name
+    inputEndingSeedsLabelMapVolume: generic/file
+    # type=file|default=<undefined>: Required (for Streamline, GraphSearch, and Guided fiber tracking methods): input ending seeds LabelMap image file name
+    inputTract: generic/file
+    # type=file|default=<undefined>: Required (for Guided fiber tracking method): guide fiber in vtkPolydata file containing one tract line.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputTract: generic/file
+    # type=file: Required (for Free, Streamline, GraphSearch, and Guided fiber tracking methods): name of output vtkPolydata file containing tract lines and the point data collected along them.
+    # type=traitcompound|default=None: Required (for Free, Streamline, GraphSearch, and Guided fiber tracking methods): name of output vtkPolydata file containing tract lines and the point data collected along them.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputTensorVolume:
+    # type=file|default=<undefined>: Required (for Free, Streamline, GraphSearch, and Guided fiber tracking methods): input tensor image file name
+    inputAnisotropyVolume:
+    # type=file|default=<undefined>: Required (for Free, Streamline, GraphSearch, and Guided fiber tracking methods): input anisotropy image file name
+    inputStartingSeedsLabelMapVolume:
+    # type=file|default=<undefined>: Required (for Free, Streamline, GraphSearch, and Guided fiber tracking methods): input starting seeds LabelMap image file name
+    startingSeedsLabel:
+    # type=int|default=0: Label value for Starting Seeds (required if Label number used to create seed point in Slicer was not 1)
+    inputEndingSeedsLabelMapVolume:
+    # type=file|default=<undefined>: Required (for Streamline, GraphSearch, and Guided fiber tracking methods): input ending seeds LabelMap image file name
+    endingSeedsLabel:
+    # type=int|default=0: Label value for Ending Seeds (required if Label number used to create seed point in Slicer was not 1)
+    inputTract:
+    # type=file|default=<undefined>: Required (for Guided fiber tracking method): guide fiber in vtkPolydata file containing one tract line.
+    outputTract:
+    # type=file: Required (for Free, Streamline, GraphSearch, and Guided fiber tracking methods): name of output vtkPolydata file containing tract lines and the point data collected along them.
+    # type=traitcompound|default=None: Required (for Free, Streamline, GraphSearch, and Guided fiber tracking methods): name of output vtkPolydata file containing tract lines and the point data collected along them.
+    writeXMLPolyDataFile:
+    # type=bool|default=False: Flag to make use of the XML format for vtkPolyData fiber tracts.
+    trackingMethod:
+    # type=enum|default='Guided'|allowed['Free','GraphSearch','Guided','Streamline']: Fiber tracking Filter Type: Guided|Free|Streamline|GraphSearch
+    guidedCurvatureThreshold:
+    # type=float|default=0.0: Guided Curvature Threshold (Degrees)
+    maximumGuideDistance:
+    # type=float|default=0.0: Maximum distance for using the guide fiber direction
+    seedThreshold:
+    # type=float|default=0.0: Anisotropy threshold for seed selection (recommended for Free fiber tracking)
+    trackingThreshold:
+    # type=float|default=0.0: Anisotropy threshold for fiber tracking (anisotropy values of the next point along the path)
+    curvatureThreshold:
+    # type=float|default=0.0: Curvature threshold in degrees (recommended for Free  fiber tracking)
+    branchingThreshold:
+    # type=float|default=0.0: Anisotropy Branching threshold (recommended for GraphSearch fiber tracking method)
+    maximumBranchPoints:
+    # type=int|default=0: Maximum branch points (recommended for GraphSearch fiber tracking method)
+    useRandomWalk:
+    # type=bool|default=False: Flag to use random walk.
+    randomSeed:
+    # type=int|default=0: Random number generator seed
+    branchingAngle:
+    # type=float|default=0.0: Branching angle in degrees (recommended for GraphSearch fiber tracking method)
+    minimumLength:
+    # type=float|default=0.0: Minimum fiber length. Helpful for filtering invalid tracts.
+    maximumLength:
+    # type=float|default=0.0: Maximum fiber length (voxels)
+    stepSize:
+    # type=float|default=0.0: Fiber tracking step size
+    useLoopDetection:
+    # type=bool|default=False: Flag to make use of loop detection.
+    useTend:
+    # type=bool|default=False: Flag to make use of Tend F and Tend G parameters.
+    tendF:
+    # type=float|default=0.0: Tend F parameter
+    tendG:
+    # type=float|default=0.0: Tend G parameter
+    numberOfThreads:
+    # type=int|default=0: Explicitly specify the maximum number of threads to use.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_fiber_tracking_callables.py b/example-specs/task/nipype_internal/pydra-semtools/gtract_fiber_tracking_callables.py
new file mode 100644
index 00000000..8daf2aa5
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/gtract_fiber_tracking_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in gtractFiberTracking.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_image_conformity.yaml b/example-specs/task/nipype_internal/pydra-semtools/gtract_image_conformity.yaml
new file mode 100644
index 00000000..c9f9cfd3
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/gtract_image_conformity.yaml
@@ -0,0 +1,97 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.diffusion.gtract.gtractImageConformity' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Image Conformity
+# 
+#     category: Diffusion.GTRACT
+# 
+#     description: This program will straighten out the Direction and Origin to match the Reference Image.
+# 
+#     version: 4.0.0
+# 
+#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Modules:GTRACT
+# 
+#     license: http://mri.radiology.uiowa.edu/copyright/GTRACT-Copyright.txt
+# 
+#     contributor: This tool was developed by Vincent Magnotta and Greg Harris.
+# 
+#     acknowledgements: Funding for this version of the GTRACT program was provided by NIH/NINDS R01NS050568-01A2S1
+#     
+task_name: gtractImageConformity
+nipype_name: gtractImageConformity
+nipype_module: nipype.interfaces.semtools.diffusion.gtract
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputVolume: generic/file
+    # type=file|default=<undefined>: Required: input file containing the signed short image to reorient without resampling.
+    inputReferenceVolume: generic/file
+    # type=file|default=<undefined>: Required: input file containing the standard image to clone the characteristics of.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputVolume: generic/file
+    # type=file: Required: name of output Nrrd or Nifti file containing the reoriented image in reference image space.
+    # type=traitcompound|default=None: Required: name of output Nrrd or Nifti file containing the reoriented image in reference image space.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputVolume:
+    # type=file|default=<undefined>: Required: input file containing the signed short image to reorient without resampling.
+    inputReferenceVolume:
+    # type=file|default=<undefined>: Required: input file containing the standard image to clone the characteristics of.
+    outputVolume:
+    # type=file: Required: name of output Nrrd or Nifti file containing the reoriented image in reference image space.
+    # type=traitcompound|default=None: Required: name of output Nrrd or Nifti file containing the reoriented image in reference image space.
+    numberOfThreads:
+    # type=int|default=0: Explicitly specify the maximum number of threads to use.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_image_conformity_callables.py b/example-specs/task/nipype_internal/pydra-semtools/gtract_image_conformity_callables.py
new file mode 100644
index 00000000..29f5d396
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/gtract_image_conformity_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in gtractImageConformity.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_invert_b_spline_transform.yaml b/example-specs/task/nipype_internal/pydra-semtools/gtract_invert_b_spline_transform.yaml
new file mode 100644
index 00000000..dfad47d0
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/gtract_invert_b_spline_transform.yaml
@@ -0,0 +1,99 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.diffusion.gtract.gtractInvertBSplineTransform' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: B-Spline Transform Inversion
+# 
+#     category: Diffusion.GTRACT
+# 
+#     description: This program will invert a B-Spline transform using a thin-plate spline approximation.
+# 
+#     version: 4.0.0
+# 
+#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Modules:GTRACT
+# 
+#     license: http://mri.radiology.uiowa.edu/copyright/GTRACT-Copyright.txt
+# 
+#     contributor: This tool was developed by Vincent Magnotta and Greg Harris.
+# 
+#     acknowledgements: Funding for this version of the GTRACT program was provided by NIH/NINDS R01NS050568-01A2S1
+#     
+task_name: gtractInvertBSplineTransform
+nipype_name: gtractInvertBSplineTransform
+nipype_module: nipype.interfaces.semtools.diffusion.gtract
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputReferenceVolume: generic/file
+    # type=file|default=<undefined>: Required: input image file name to exemplify the anatomical space to interpolate over.
+    inputTransform: generic/file
+    # type=file|default=<undefined>: Required: input B-Spline transform file name
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputTransform: generic/file
+    # type=file: Required: output transform file name
+    # type=traitcompound|default=None: Required: output transform file name
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputReferenceVolume:
+    # type=file|default=<undefined>: Required: input image file name to exemplify the anatomical space to interpolate over.
+    inputTransform:
+    # type=file|default=<undefined>: Required: input B-Spline transform file name
+    outputTransform:
+    # type=file: Required: output transform file name
+    # type=traitcompound|default=None: Required: output transform file name
+    landmarkDensity:
+    # type=inputmultiobject|default=[]: Number of landmark subdivisions in all 3 directions
+    numberOfThreads:
+    # type=int|default=0: Explicitly specify the maximum number of threads to use.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_invert_b_spline_transform_callables.py b/example-specs/task/nipype_internal/pydra-semtools/gtract_invert_b_spline_transform_callables.py
new file mode 100644
index 00000000..466c9d5e
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/gtract_invert_b_spline_transform_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in gtractInvertBSplineTransform.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_invert_displacement_field.yaml b/example-specs/task/nipype_internal/pydra-semtools/gtract_invert_displacement_field.yaml
new file mode 100644
index 00000000..e782acfa
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/gtract_invert_displacement_field.yaml
@@ -0,0 +1,99 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.diffusion.gtract.gtractInvertDisplacementField' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Invert Displacement Field
+# 
+#     category: Diffusion.GTRACT
+# 
+#     description: This program will invert a deformatrion field. The size of the deformation field is defined by an example image provided by the user
+# 
+#     version: 4.0.0
+# 
+#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Modules:GTRACT
+# 
+#     license: http://mri.radiology.uiowa.edu/copyright/GTRACT-Copyright.txt
+# 
+#     contributor: This tool was developed by Vincent Magnotta.
+# 
+#     acknowledgements: Funding for this version of the GTRACT program was provided by NIH/NINDS R01NS050568-01A2S1
+#     
+task_name: gtractInvertDisplacementField
+nipype_name: gtractInvertDisplacementField
+nipype_module: nipype.interfaces.semtools.diffusion.gtract
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    baseImage: generic/file
+    # type=file|default=<undefined>: Required: base image used to define the size of the inverse field
+    deformationImage: generic/file
+    # type=file|default=<undefined>: Required: Displacement field image
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputVolume: generic/file
+    # type=file: Required: Output deformation field
+    # type=traitcompound|default=None: Required: Output deformation field
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    baseImage:
+    # type=file|default=<undefined>: Required: base image used to define the size of the inverse field
+    deformationImage:
+    # type=file|default=<undefined>: Required: Displacement field image
+    outputVolume:
+    # type=file: Required: Output deformation field
+    # type=traitcompound|default=None: Required: Output deformation field
+    subsamplingFactor:
+    # type=int|default=0: Subsampling factor for the deformation field
+    numberOfThreads:
+    # type=int|default=0: Explicitly specify the maximum number of threads to use.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_invert_displacement_field_callables.py b/example-specs/task/nipype_internal/pydra-semtools/gtract_invert_displacement_field_callables.py
new file mode 100644
index 00000000..c4dcf2e6
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/gtract_invert_displacement_field_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in gtractInvertDisplacementField.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_invert_rigid_transform.yaml b/example-specs/task/nipype_internal/pydra-semtools/gtract_invert_rigid_transform.yaml
new file mode 100644
index 00000000..317008ca
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/gtract_invert_rigid_transform.yaml
@@ -0,0 +1,93 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.diffusion.gtract.gtractInvertRigidTransform' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Rigid Transform Inversion
+# 
+#     category: Diffusion.GTRACT
+# 
+#     description: This program will invert a Rigid transform.
+# 
+#     version: 4.0.0
+# 
+#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Modules:GTRACT
+# 
+#     license: http://mri.radiology.uiowa.edu/copyright/GTRACT-Copyright.txt
+# 
+#     contributor: This tool was developed by Vincent Magnotta and Greg Harris.
+# 
+#     acknowledgements: Funding for this version of the GTRACT program was provided by NIH/NINDS R01NS050568-01A2S1
+#     
+task_name: gtractInvertRigidTransform
+nipype_name: gtractInvertRigidTransform
+nipype_module: nipype.interfaces.semtools.diffusion.gtract
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputTransform: generic/file
+    # type=file|default=<undefined>: Required: input rigid transform file name
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputTransform: generic/file
+    # type=file: Required: output transform file name
+    # type=traitcompound|default=None: Required: output transform file name
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputTransform:
+    # type=file|default=<undefined>: Required: input rigid transform file name
+    outputTransform:
+    # type=file: Required: output transform file name
+    # type=traitcompound|default=None: Required: output transform file name
+    numberOfThreads:
+    # type=int|default=0: Explicitly specify the maximum number of threads to use.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_invert_rigid_transform_callables.py b/example-specs/task/nipype_internal/pydra-semtools/gtract_invert_rigid_transform_callables.py
new file mode 100644
index 00000000..e1fd18c4
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/gtract_invert_rigid_transform_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in gtractInvertRigidTransform.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_resample_anisotropy.yaml b/example-specs/task/nipype_internal/pydra-semtools/gtract_resample_anisotropy.yaml
new file mode 100644
index 00000000..62cd873f
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/gtract_resample_anisotropy.yaml
@@ -0,0 +1,103 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.diffusion.gtract.gtractResampleAnisotropy' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Resample Anisotropy
+# 
+#     category: Diffusion.GTRACT
+# 
+#     description: This program will resample a floating point image using either the Rigid or B-Spline transform. You may want to save the aligned B0 image after each of the anisotropy map co-registration steps with the anatomical image to check the registration quality with another tool.
+# 
+#     version: 4.0.0
+# 
+#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Modules:GTRACT
+# 
+#     license: http://mri.radiology.uiowa.edu/copyright/GTRACT-Copyright.txt
+# 
+#     contributor: This tool was developed by Vincent Magnotta and Greg Harris.
+# 
+#     acknowledgements: Funding for this version of the GTRACT program was provided by NIH/NINDS R01NS050568-01A2S1
+#     
+task_name: gtractResampleAnisotropy
+nipype_name: gtractResampleAnisotropy
+nipype_module: nipype.interfaces.semtools.diffusion.gtract
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputAnisotropyVolume: generic/file
+    # type=file|default=<undefined>: Required: input file containing the anisotropy image
+    inputAnatomicalVolume: generic/file
+    # type=file|default=<undefined>: Required: input file containing the anatomical image whose characteristics will be cloned.
+    inputTransform: generic/file
+    # type=file|default=<undefined>: Required: input Rigid OR Bspline transform file name
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputVolume: generic/file
+    # type=file: Required: name of output NRRD file containing the resampled transformed anisotropy image.
+    # type=traitcompound|default=None: Required: name of output NRRD file containing the resampled transformed anisotropy image.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputAnisotropyVolume:
+    # type=file|default=<undefined>: Required: input file containing the anisotropy image
+    inputAnatomicalVolume:
+    # type=file|default=<undefined>: Required: input file containing the anatomical image whose characteristics will be cloned.
+    inputTransform:
+    # type=file|default=<undefined>: Required: input Rigid OR Bspline transform file name
+    transformType:
+    # type=enum|default='Rigid'|allowed['B-Spline','Rigid']: Transform type: Rigid, B-Spline
+    outputVolume:
+    # type=file: Required: name of output NRRD file containing the resampled transformed anisotropy image.
+    # type=traitcompound|default=None: Required: name of output NRRD file containing the resampled transformed anisotropy image.
+    numberOfThreads:
+    # type=int|default=0: Explicitly specify the maximum number of threads to use.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_resample_anisotropy_callables.py b/example-specs/task/nipype_internal/pydra-semtools/gtract_resample_anisotropy_callables.py
new file mode 100644
index 00000000..f19f8b2e
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/gtract_resample_anisotropy_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in gtractResampleAnisotropy.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_resample_b0.yaml b/example-specs/task/nipype_internal/pydra-semtools/gtract_resample_b0.yaml
new file mode 100644
index 00000000..350d74b5
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/gtract_resample_b0.yaml
@@ -0,0 +1,105 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.diffusion.gtract.gtractResampleB0' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Resample B0
+# 
+#     category: Diffusion.GTRACT
+# 
+#     description: This program will resample a signed short image using either a Rigid or B-Spline transform. The user must specify a template image that will be used to define the origin, orientation, spacing, and size of the resampled image.
+# 
+#     version: 4.0.0
+# 
+#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Modules:GTRACT
+# 
+#     license: http://mri.radiology.uiowa.edu/copyright/GTRACT-Copyright.txt
+# 
+#     contributor: This tool was developed by Vincent Magnotta and Greg Harris.
+# 
+#     acknowledgements: Funding for this version of the GTRACT program was provided by NIH/NINDS R01NS050568-01A2S1
+#     
+task_name: gtractResampleB0
+nipype_name: gtractResampleB0
+nipype_module: nipype.interfaces.semtools.diffusion.gtract
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputVolume: generic/file
+    # type=file|default=<undefined>: Required: input file containing the 4D image
+    inputAnatomicalVolume: generic/file
+    # type=file|default=<undefined>: Required: input file containing the anatomical image defining the origin, spacing and size of the resampled image (template)
+    inputTransform: generic/file
+    # type=file|default=<undefined>: Required: input Rigid OR Bspline transform file name
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputVolume: generic/file
+    # type=file: Required: name of output NRRD file containing the resampled input image.
+    # type=traitcompound|default=None: Required: name of output NRRD file containing the resampled input image.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputVolume:
+    # type=file|default=<undefined>: Required: input file containing the 4D image
+    inputAnatomicalVolume:
+    # type=file|default=<undefined>: Required: input file containing the anatomical image defining the origin, spacing and size of the resampled image (template)
+    inputTransform:
+    # type=file|default=<undefined>: Required: input Rigid OR Bspline transform file name
+    vectorIndex:
+    # type=int|default=0: Index in the diffusion weighted image set for the B0 image
+    transformType:
+    # type=enum|default='Rigid'|allowed['B-Spline','Rigid']: Transform type: Rigid, B-Spline
+    outputVolume:
+    # type=file: Required: name of output NRRD file containing the resampled input image.
+    # type=traitcompound|default=None: Required: name of output NRRD file containing the resampled input image.
+    numberOfThreads:
+    # type=int|default=0: Explicitly specify the maximum number of threads to use.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_resample_b0_callables.py b/example-specs/task/nipype_internal/pydra-semtools/gtract_resample_b0_callables.py
new file mode 100644
index 00000000..7789dfcd
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/gtract_resample_b0_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in gtractResampleB0.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_resample_code_image.yaml b/example-specs/task/nipype_internal/pydra-semtools/gtract_resample_code_image.yaml
new file mode 100644
index 00000000..5cab6097
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/gtract_resample_code_image.yaml
@@ -0,0 +1,103 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.diffusion.gtract.gtractResampleCodeImage' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Resample Code Image
+# 
+#     category: Diffusion.GTRACT
+# 
+#     description: This program will resample a short integer code image using either the Rigid or Inverse-B-Spline transform.  The reference image is the DTI tensor anisotropy image space, and the input code image is in anatomical space.
+# 
+#     version: 4.0.0
+# 
+#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Modules:GTRACT
+# 
+#     license: http://mri.radiology.uiowa.edu/copyright/GTRACT-Copyright.txt
+# 
+#     contributor: This tool was developed by Vincent Magnotta and Greg Harris.
+# 
+#     acknowledgements: Funding for this version of the GTRACT program was provided by NIH/NINDS R01NS050568-01A2S1
+#     
+task_name: gtractResampleCodeImage
+nipype_name: gtractResampleCodeImage
+nipype_module: nipype.interfaces.semtools.diffusion.gtract
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputCodeVolume: generic/file
+    # type=file|default=<undefined>: Required: input file containing the code image
+    inputReferenceVolume: generic/file
+    # type=file|default=<undefined>: Required: input file containing the standard image to clone the characteristics of.
+    inputTransform: generic/file
+    # type=file|default=<undefined>: Required: input Rigid or Inverse-B-Spline transform file name
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputVolume: generic/file
+    # type=file: Required: name of output NRRD file containing the resampled code image in acquisition space.
+    # type=traitcompound|default=None: Required: name of output NRRD file containing the resampled code image in acquisition space.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputCodeVolume:
+    # type=file|default=<undefined>: Required: input file containing the code image
+    inputReferenceVolume:
+    # type=file|default=<undefined>: Required: input file containing the standard image to clone the characteristics of.
+    inputTransform:
+    # type=file|default=<undefined>: Required: input Rigid or Inverse-B-Spline transform file name
+    transformType:
+    # type=enum|default='Rigid'|allowed['Affine','B-Spline','Inverse-B-Spline','None','Rigid']: Transform type: Rigid or Inverse-B-Spline
+    outputVolume:
+    # type=file: Required: name of output NRRD file containing the resampled code image in acquisition space.
+    # type=traitcompound|default=None: Required: name of output NRRD file containing the resampled code image in acquisition space.
+    numberOfThreads:
+    # type=int|default=0: Explicitly specify the maximum number of threads to use.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_resample_code_image_callables.py b/example-specs/task/nipype_internal/pydra-semtools/gtract_resample_code_image_callables.py
new file mode 100644
index 00000000..01270d55
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/gtract_resample_code_image_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in gtractResampleCodeImage.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_resample_dwi_in_place.yaml b/example-specs/task/nipype_internal/pydra-semtools/gtract_resample_dwi_in_place.yaml
new file mode 100644
index 00000000..82f19105
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/gtract_resample_dwi_in_place.yaml
@@ -0,0 +1,115 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.diffusion.gtract.gtractResampleDWIInPlace' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Resample DWI In Place
+# 
+#     category: Diffusion.GTRACT
+# 
+#     description: Resamples DWI image to structural image.
+# 
+#     version: 4.0.0
+# 
+#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Modules:GTRACT
+# 
+#     license: http://mri.radiology.uiowa.edu/copyright/GTRACT-Copyright.txt
+# 
+#     contributor: This tool was developed by Vincent Magnotta, Greg Harris, Hans Johnson, and Joy Matsui.
+# 
+#     acknowledgements: Funding for this version of the GTRACT program was provided by NIH/NINDS R01NS050568-01A2S1
+#     
+task_name: gtractResampleDWIInPlace
+nipype_name: gtractResampleDWIInPlace
+nipype_module: nipype.interfaces.semtools.diffusion.gtract
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputVolume: generic/file
+    # type=file|default=<undefined>: Required: input image is a 4D NRRD image.
+    referenceVolume: generic/file
+    # type=file|default=<undefined>: If provided, resample to the final space of the referenceVolume 3D data set.
+    inputTransform: generic/file
+    # type=file|default=<undefined>: Required: transform file derived from rigid registration of b0 image to reference structural image.
+    warpDWITransform: generic/file
+    # type=file|default=<undefined>: Optional: transform file to warp gradient volumes.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputResampledB0: generic/file
+    # type=file: Convenience function for extracting the first index location (assumed to be the B0)
+    # type=traitcompound|default=None: Convenience function for extracting the first index location (assumed to be the B0)
+    outputVolume: generic/file
+    # type=file: Required: output image (NRRD file) that has been rigidly transformed into the space of the structural image and padded if image padding was changed from 0,0,0 default.
+    # type=traitcompound|default=None: Required: output image (NRRD file) that has been rigidly transformed into the space of the structural image and padded if image padding was changed from 0,0,0 default.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputVolume:
+    # type=file|default=<undefined>: Required: input image is a 4D NRRD image.
+    referenceVolume:
+    # type=file|default=<undefined>: If provided, resample to the final space of the referenceVolume 3D data set.
+    outputResampledB0:
+    # type=file: Convenience function for extracting the first index location (assumed to be the B0)
+    # type=traitcompound|default=None: Convenience function for extracting the first index location (assumed to be the B0)
+    inputTransform:
+    # type=file|default=<undefined>: Required: transform file derived from rigid registration of b0 image to reference structural image.
+    warpDWITransform:
+    # type=file|default=<undefined>: Optional: transform file to warp gradient volumes.
+    debugLevel:
+    # type=int|default=0: Display debug messages, and produce debug intermediate results.  0=OFF, 1=Minimal, 10=Maximum debugging.
+    imageOutputSize:
+    # type=inputmultiobject|default=[]: The voxel lattice for the output image, padding is added if necessary. NOTE: if 0,0,0, then the inputVolume size is used.
+    outputVolume:
+    # type=file: Required: output image (NRRD file) that has been rigidly transformed into the space of the structural image and padded if image padding was changed from 0,0,0 default.
+    # type=traitcompound|default=None: Required: output image (NRRD file) that has been rigidly transformed into the space of the structural image and padded if image padding was changed from 0,0,0 default.
+    numberOfThreads:
+    # type=int|default=0: Explicitly specify the maximum number of threads to use.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_resample_dwi_in_place_callables.py b/example-specs/task/nipype_internal/pydra-semtools/gtract_resample_dwi_in_place_callables.py
new file mode 100644
index 00000000..55b70f68
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/gtract_resample_dwi_in_place_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in gtractResampleDWIInPlace.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_resample_fibers.yaml b/example-specs/task/nipype_internal/pydra-semtools/gtract_resample_fibers.yaml
new file mode 100644
index 00000000..9ed38dbc
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/gtract_resample_fibers.yaml
@@ -0,0 +1,103 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.diffusion.gtract.gtractResampleFibers' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Resample Fibers
+# 
+#     category: Diffusion.GTRACT
+# 
+#     description: This program will resample a fiber tract with respect to a pair of deformation fields that represent the forward and reverse deformation fields.
+# 
+#     version: 4.0.0
+# 
+#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Modules:GTRACT
+# 
+#     license: http://mri.radiology.uiowa.edu/copyright/GTRACT-Copyright.txt
+# 
+#     contributor: This tool was developed by Vincent Magnotta and Greg Harris.
+# 
+#     acknowledgements: Funding for this version of the GTRACT program was provided by NIH/NINDS R01NS050568-01A2S1
+#     
+task_name: gtractResampleFibers
+nipype_name: gtractResampleFibers
+nipype_module: nipype.interfaces.semtools.diffusion.gtract
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputForwardDeformationFieldVolume: generic/file
+    # type=file|default=<undefined>: Required: input forward deformation field image file name
+    inputReverseDeformationFieldVolume: generic/file
+    # type=file|default=<undefined>: Required: input reverse deformation field image file name
+    inputTract: generic/file
+    # type=file|default=<undefined>: Required: name of input vtkPolydata file containing tract lines.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputTract: generic/file
+    # type=file: Required: name of output vtkPolydata file containing tract lines and the point data collected along them.
+    # type=traitcompound|default=None: Required: name of output vtkPolydata file containing tract lines and the point data collected along them.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputForwardDeformationFieldVolume:
+    # type=file|default=<undefined>: Required: input forward deformation field image file name
+    inputReverseDeformationFieldVolume:
+    # type=file|default=<undefined>: Required: input reverse deformation field image file name
+    inputTract:
+    # type=file|default=<undefined>: Required: name of input vtkPolydata file containing tract lines.
+    outputTract:
+    # type=file: Required: name of output vtkPolydata file containing tract lines and the point data collected along them.
+    # type=traitcompound|default=None: Required: name of output vtkPolydata file containing tract lines and the point data collected along them.
+    writeXMLPolyDataFile:
+    # type=bool|default=False: Flag to make use of the XML format for vtkPolyData fiber tracts.
+    numberOfThreads:
+    # type=int|default=0: Explicitly specify the maximum number of threads to use.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_resample_fibers_callables.py b/example-specs/task/nipype_internal/pydra-semtools/gtract_resample_fibers_callables.py
new file mode 100644
index 00000000..5dd88203
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/gtract_resample_fibers_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in gtractResampleFibers.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_tensor.yaml b/example-specs/task/nipype_internal/pydra-semtools/gtract_tensor.yaml
new file mode 100644
index 00000000..b49086ed
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/gtract_tensor.yaml
@@ -0,0 +1,113 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.diffusion.gtract.gtractTensor' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Tensor Estimation
+# 
+#     category: Diffusion.GTRACT
+# 
+#     description: This step will convert a b-value averaged diffusion tensor image to a 3x3 tensor voxel image. This step takes the diffusion tensor image data and generates a tensor representation of the data based on the signal intensity decay, b values applied, and the diffusion difrections. The apparent diffusion coefficient for a given orientation is computed on a pixel-by-pixel basis by fitting the image data (voxel intensities) to the Stejskal-Tanner equation. If at least 6 diffusion directions are used, then the diffusion tensor can be computed. This program uses itk::DiffusionTensor3DReconstructionImageFilter. The user can adjust background threshold, median filter, and isotropic resampling.
+# 
+#     version: 4.0.0
+# 
+#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Modules:GTRACT
+# 
+#     license: http://mri.radiology.uiowa.edu/copyright/GTRACT-Copyright.txt
+# 
+#     contributor: This tool was developed by Vincent Magnotta and Greg Harris.
+# 
+#     acknowledgements: Funding for this version of the GTRACT program was provided by NIH/NINDS R01NS050568-01A2S1
+#     
+task_name: gtractTensor
+nipype_name: gtractTensor
+nipype_module: nipype.interfaces.semtools.diffusion.gtract
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputVolume: generic/file
+    # type=file|default=<undefined>: Required: input image 4D NRRD image. Must contain data based on at least 6 distinct diffusion directions. The inputVolume is allowed to have multiple b0 and gradient direction images. Averaging of the b0 image is done internally in this step. Prior averaging of the DWIs is not required.
+    maskVolume: generic/file
+    # type=file|default=<undefined>: Mask Image, if maskProcessingMode is ROI
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputVolume: generic/file
+    # type=file: Required: name of output NRRD file containing the Tensor vector image
+    # type=traitcompound|default=None: Required: name of output NRRD file containing the Tensor vector image
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputVolume:
+    # type=file|default=<undefined>: Required: input image 4D NRRD image. Must contain data based on at least 6 distinct diffusion directions. The inputVolume is allowed to have multiple b0 and gradient direction images. Averaging of the b0 image is done internally in this step. Prior averaging of the DWIs is not required.
+    outputVolume:
+    # type=file: Required: name of output NRRD file containing the Tensor vector image
+    # type=traitcompound|default=None: Required: name of output NRRD file containing the Tensor vector image
+    medianFilterSize:
+    # type=inputmultiobject|default=[]: Median filter radius in all 3 directions
+    maskProcessingMode:
+    # type=enum|default='NOMASK'|allowed['NOMASK','ROI','ROIAUTO']: ROIAUTO:  mask is implicitly defined using a otsu foreground and hole filling algorithm. ROI: Uses the masks to define what parts of the image should be used for computing the transform. NOMASK: no mask used
+    maskVolume:
+    # type=file|default=<undefined>: Mask Image, if maskProcessingMode is ROI
+    backgroundSuppressingThreshold:
+    # type=int|default=0: Image threshold to suppress background. This sets a threshold used on the b0 image to remove background voxels from processing. Typically, values of 100 and 500 work well for Siemens and GE DTI data, respectively. Check your data particularly in the globus pallidus to make sure the brain tissue is not being eliminated with this threshold.
+    resampleIsotropic:
+    # type=bool|default=False: Flag to resample to isotropic voxels. Enabling this feature is recommended if fiber tracking will be performed.
+    size:
+    # type=float|default=0.0: Isotropic voxel size to resample to
+    b0Index:
+    # type=int|default=0: Index in input vector index to extract
+    applyMeasurementFrame:
+    # type=bool|default=False: Flag to apply the measurement frame to the gradient directions
+    ignoreIndex:
+    # type=inputmultiobject|default=[]: Ignore diffusion gradient index. Used to remove specific gradient directions with artifacts.
+    numberOfThreads:
+    # type=int|default=0: Explicitly specify the maximum number of threads to use.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_tensor_callables.py b/example-specs/task/nipype_internal/pydra-semtools/gtract_tensor_callables.py
new file mode 100644
index 00000000..ea314f47
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/gtract_tensor_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in gtractTensor.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_transform_to_displacement_field.yaml b/example-specs/task/nipype_internal/pydra-semtools/gtract_transform_to_displacement_field.yaml
new file mode 100644
index 00000000..804b3aa4
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/gtract_transform_to_displacement_field.yaml
@@ -0,0 +1,97 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.diffusion.gtract.gtractTransformToDisplacementField' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Create Displacement Field
+# 
+#     category: Diffusion.GTRACT
+# 
+#     description: This program will compute forward deformation from the given Transform. The size of the DF is equal to MNI space
+# 
+#     version: 4.0.0
+# 
+#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Modules:GTRACT
+# 
+#     license: http://mri.radiology.uiowa.edu/copyright/GTRACT-Copyright.txt
+# 
+#     contributor: This tool was developed by Vincent Magnotta, Madhura Ingalhalikar, and Greg Harris
+# 
+#     acknowledgements: Funding for this version of the GTRACT program was provided by NIH/NINDS R01NS050568-01A2S1
+#     
+task_name: gtractTransformToDisplacementField
+nipype_name: gtractTransformToDisplacementField
+nipype_module: nipype.interfaces.semtools.diffusion.gtract
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputTransform: generic/file
+    # type=file|default=<undefined>: Input Transform File Name
+    inputReferenceVolume: generic/file
+    # type=file|default=<undefined>: Required: input image file name to exemplify the anatomical space over which to vcl_express the transform as a displacement field.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputDeformationFieldVolume: generic/file
+    # type=file: Output deformation field
+    # type=traitcompound|default=None: Output deformation field
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputTransform:
+    # type=file|default=<undefined>: Input Transform File Name
+    inputReferenceVolume:
+    # type=file|default=<undefined>: Required: input image file name to exemplify the anatomical space over which to vcl_express the transform as a displacement field.
+    outputDeformationFieldVolume:
+    # type=file: Output deformation field
+    # type=traitcompound|default=None: Output deformation field
+    numberOfThreads:
+    # type=int|default=0: Explicitly specify the maximum number of threads to use.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_transform_to_displacement_field_callables.py b/example-specs/task/nipype_internal/pydra-semtools/gtract_transform_to_displacement_field_callables.py
new file mode 100644
index 00000000..5012c73d
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/gtract_transform_to_displacement_field_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in gtractTransformToDisplacementField.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/hammer_attribute_creator.yaml b/example-specs/task/nipype_internal/pydra-semtools/hammer_attribute_creator.yaml
new file mode 100644
index 00000000..cea52a34
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/hammer_attribute_creator.yaml
@@ -0,0 +1,97 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.filtering.featuredetection.HammerAttributeCreator' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: HAMMER Feature Vectors
+# 
+#     category: Filtering.FeatureDetection
+# 
+#     description: Create the feature vectors used by HAMMER.
+# 
+#     version: 0.1.0.$Revision: 1 $(alpha)
+# 
+#     documentation-url: http:://www.na-mic.org/
+# 
+#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
+# 
+#     contributor: This was extracted from the Hammer Registration source code, and wrapped up by Hans J. Johnson.
+#     
+task_name: HammerAttributeCreator
+nipype_name: HammerAttributeCreator
+nipype_module: nipype.interfaces.semtools.filtering.featuredetection
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputGMVolume: generic/file
+    # type=file|default=<undefined>: Required: input grey matter posterior image
+    inputWMVolume: generic/file
+    # type=file|default=<undefined>: Required: input white matter posterior image
+    inputCSFVolume: generic/file
+    # type=file|default=<undefined>: Required: input CSF posterior image
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    Scale:
+    # type=int|default=0: Determine Scale of Ball
+    Strength:
+    # type=float|default=0.0: Determine Strength of Edges
+    inputGMVolume:
+    # type=file|default=<undefined>: Required: input grey matter posterior image
+    inputWMVolume:
+    # type=file|default=<undefined>: Required: input white matter posterior image
+    inputCSFVolume:
+    # type=file|default=<undefined>: Required: input CSF posterior image
+    outputVolumeBase:
+    # type=str|default='': Required: output image base name to be appended for each feature vector.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/hammer_attribute_creator_callables.py b/example-specs/task/nipype_internal/pydra-semtools/hammer_attribute_creator_callables.py
new file mode 100644
index 00000000..c80b5d93
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/hammer_attribute_creator_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in HammerAttributeCreator.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/histogram_matching_filter.yaml b/example-specs/task/nipype_internal/pydra-semtools/histogram_matching_filter.yaml
new file mode 100644
index 00000000..1c8aad6b
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/histogram_matching_filter.yaml
@@ -0,0 +1,107 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.brains.utilities.HistogramMatchingFilter' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Write Out Image Intensities
+# 
+#     category: BRAINS.Utilities
+# 
+#     description: For Analysis
+# 
+#     version: 0.1
+# 
+#     contributor: University of Iowa Department of Psychiatry, http:://www.psychiatry.uiowa.edu
+#     
+task_name: HistogramMatchingFilter
+nipype_name: HistogramMatchingFilter
+nipype_module: nipype.interfaces.semtools.brains.utilities
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputVolume: generic/file
+    # type=file|default=<undefined>: The Input image to be computed for statistics
+    referenceVolume: generic/file
+    # type=file|default=<undefined>: The Input image to be computed for statistics
+    referenceBinaryVolume: generic/file
+    # type=file|default=<undefined>: referenceBinaryVolume
+    inputBinaryVolume: generic/file
+    # type=file|default=<undefined>: inputBinaryVolume
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputVolume: generic/file
+    # type=file: Output Image File Name
+    # type=traitcompound|default=None: Output Image File Name
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputVolume:
+    # type=file|default=<undefined>: The Input image to be computed for statistics
+    referenceVolume:
+    # type=file|default=<undefined>: The Input image to be computed for statistics
+    outputVolume:
+    # type=file: Output Image File Name
+    # type=traitcompound|default=None: Output Image File Name
+    referenceBinaryVolume:
+    # type=file|default=<undefined>: referenceBinaryVolume
+    inputBinaryVolume:
+    # type=file|default=<undefined>: inputBinaryVolume
+    numberOfMatchPoints:
+    # type=int|default=0:  number of histogram matching points
+    numberOfHistogramBins:
+    # type=int|default=0:  number of histogram bin
+    writeHistogram:
+    # type=str|default='':  decide if histogram data would be written with prefixe of the file name
+    histogramAlgorithm:
+    # type=enum|default='OtsuHistogramMatching'|allowed['OtsuHistogramMatching']:  histogram algrithm selection
+    verbose:
+    # type=bool|default=False:  verbose mode running for debbuging
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/histogram_matching_filter_callables.py b/example-specs/task/nipype_internal/pydra-semtools/histogram_matching_filter_callables.py
new file mode 100644
index 00000000..ec20f360
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/histogram_matching_filter_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in HistogramMatchingFilter.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/image_region_plotter.yaml b/example-specs/task/nipype_internal/pydra-semtools/image_region_plotter.yaml
new file mode 100644
index 00000000..b9e0a4fa
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/image_region_plotter.yaml
@@ -0,0 +1,101 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.utilities.brains.ImageRegionPlotter' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Write Out Image Intensities
+# 
+#     category: Utilities.BRAINS
+# 
+#     description: For Analysis
+# 
+#     version: 0.1
+# 
+#     contributor: University of Iowa Department of Psychiatry, http:://www.psychiatry.uiowa.edu
+#     
+task_name: ImageRegionPlotter
+nipype_name: ImageRegionPlotter
+nipype_module: nipype.interfaces.semtools.utilities.brains
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputVolume1: generic/file
+    # type=file|default=<undefined>: The Input image to be computed for statistics
+    inputVolume2: generic/file
+    # type=file|default=<undefined>: The Input image to be computed for statistics
+    inputBinaryROIVolume: generic/file
+    # type=file|default=<undefined>: The Input binary image for region of interest
+    inputLabelVolume: generic/file
+    # type=file|default=<undefined>: The Label Image
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputVolume1:
+    # type=file|default=<undefined>: The Input image to be computed for statistics
+    inputVolume2:
+    # type=file|default=<undefined>: The Input image to be computed for statistics
+    inputBinaryROIVolume:
+    # type=file|default=<undefined>: The Input binary image for region of interest
+    inputLabelVolume:
+    # type=file|default=<undefined>: The Label Image
+    numberOfHistogramBins:
+    # type=int|default=0:  the number of histogram levels
+    outputJointHistogramData:
+    # type=str|default='':  output data file name
+    useROIAUTO:
+    # type=bool|default=False:  Use ROIAUTO to compute region of interest. This cannot be used with inputLabelVolume
+    useIntensityForHistogram:
+    # type=bool|default=False:  Create Intensity Joint Histogram instead of Quantile Joint Histogram
+    verbose:
+    # type=bool|default=False:  print debugging information,       
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/image_region_plotter_callables.py b/example-specs/task/nipype_internal/pydra-semtools/image_region_plotter_callables.py
new file mode 100644
index 00000000..bf43a254
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/image_region_plotter_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in ImageRegionPlotter.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/insert_mid_acp_cpoint.yaml b/example-specs/task/nipype_internal/pydra-semtools/insert_mid_acp_cpoint.yaml
new file mode 100644
index 00000000..3f2a4b96
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/insert_mid_acp_cpoint.yaml
@@ -0,0 +1,83 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.utilities.brains.insertMidACPCpoint' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: MidACPC Landmark Insertion
+# 
+#     category: Utilities.BRAINS
+# 
+#     description: This program gets a landmark fcsv file and adds a new landmark as the midpoint between AC and PC points to the output landmark fcsv file
+# 
+#     contributor: Ali Ghayoor
+#     
+task_name: insertMidACPCpoint
+nipype_name: insertMidACPCpoint
+nipype_module: nipype.interfaces.semtools.utilities.brains
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputLandmarkFile: generic/file
+    # type=file|default=<undefined>: Input landmark file (.fcsv)
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputLandmarkFile: generic/file
+    # type=file: Output landmark file (.fcsv)
+    # type=traitcompound|default=None: Output landmark file (.fcsv)
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputLandmarkFile:
+    # type=file|default=<undefined>: Input landmark file (.fcsv)
+    outputLandmarkFile:
+    # type=file: Output landmark file (.fcsv)
+    # type=traitcompound|default=None: Output landmark file (.fcsv)
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/insert_mid_acp_cpoint_callables.py b/example-specs/task/nipype_internal/pydra-semtools/insert_mid_acp_cpoint_callables.py
new file mode 100644
index 00000000..ff32a7b5
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/insert_mid_acp_cpoint_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in insertMidACPCpoint.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/joint_histogram.yaml b/example-specs/task/nipype_internal/pydra-semtools/joint_histogram.yaml
new file mode 100644
index 00000000..2d1dc92f
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/joint_histogram.yaml
@@ -0,0 +1,95 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.utilities.brains.JointHistogram' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Write Out Image Intensities
+# 
+#     category: Utilities.BRAINS
+# 
+#     description: For Analysis
+# 
+#     version: 0.1
+# 
+#     contributor: University of Iowa Department of Psychiatry, http:://www.psychiatry.uiowa.edu
+#     
+task_name: JointHistogram
+nipype_name: JointHistogram
+nipype_module: nipype.interfaces.semtools.utilities.brains
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputVolumeInXAxis: generic/file
+    # type=file|default=<undefined>: The Input image to be computed for statistics
+    inputVolumeInYAxis: generic/file
+    # type=file|default=<undefined>: The Input image to be computed for statistics
+    inputMaskVolumeInXAxis: generic/file
+    # type=file|default=<undefined>: Input mask volume for inputVolumeInXAxis. Histogram will be computed just for the masked region
+    inputMaskVolumeInYAxis: generic/file
+    # type=file|default=<undefined>: Input mask volume for inputVolumeInYAxis. Histogram will be computed just for the masked region
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputVolumeInXAxis:
+    # type=file|default=<undefined>: The Input image to be computed for statistics
+    inputVolumeInYAxis:
+    # type=file|default=<undefined>: The Input image to be computed for statistics
+    inputMaskVolumeInXAxis:
+    # type=file|default=<undefined>: Input mask volume for inputVolumeInXAxis. Histogram will be computed just for the masked region
+    inputMaskVolumeInYAxis:
+    # type=file|default=<undefined>: Input mask volume for inputVolumeInYAxis. Histogram will be computed just for the masked region
+    outputJointHistogramImage:
+    # type=str|default='':  output joint histogram image file name. Histogram is usually 2D image. 
+    verbose:
+    # type=bool|default=False:  print debugging information,       
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/joint_histogram_callables.py b/example-specs/task/nipype_internal/pydra-semtools/joint_histogram_callables.py
new file mode 100644
index 00000000..6b7f172c
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/joint_histogram_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in JointHistogram.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/landmarks_compare.yaml b/example-specs/task/nipype_internal/pydra-semtools/landmarks_compare.yaml
new file mode 100644
index 00000000..3e794c08
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/landmarks_compare.yaml
@@ -0,0 +1,83 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.testing.landmarkscompare.LandmarksCompare' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Compare Fiducials
+# 
+#     category: Testing
+# 
+#     description: Compares two .fcsv or .wts text files and verifies that they are identicle.  Used for testing landmarks files.
+# 
+#     contributor: Ali Ghayoor
+#     
+task_name: LandmarksCompare
+nipype_name: LandmarksCompare
+nipype_module: nipype.interfaces.semtools.testing.landmarkscompare
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputLandmarkFile1: generic/file
+    # type=file|default=<undefined>: First input landmark file (.fcsv or .wts)
+    inputLandmarkFile2: generic/file
+    # type=file|default=<undefined>: Second input landmark file (.fcsv or .wts)
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputLandmarkFile1:
+    # type=file|default=<undefined>: First input landmark file (.fcsv or .wts)
+    inputLandmarkFile2:
+    # type=file|default=<undefined>: Second input landmark file (.fcsv or .wts)
+    tolerance:
+    # type=float|default=0.0: The maximum error (in mm) allowed in each direction of a landmark
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/landmarks_compare_callables.py b/example-specs/task/nipype_internal/pydra-semtools/landmarks_compare_callables.py
new file mode 100644
index 00000000..e251e711
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/landmarks_compare_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in LandmarksCompare.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/landmarks_constellation_aligner.yaml b/example-specs/task/nipype_internal/pydra-semtools/landmarks_constellation_aligner.yaml
new file mode 100644
index 00000000..e7c56858
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/landmarks_constellation_aligner.yaml
@@ -0,0 +1,83 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.utilities.brains.landmarksConstellationAligner' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: MidACPC Landmark Insertion
+# 
+#     category: Utilities.BRAINS
+# 
+#     description: This program converts the original landmark files to the acpc-aligned landmark files
+# 
+#     contributor: Ali Ghayoor
+#     
+task_name: landmarksConstellationAligner
+nipype_name: landmarksConstellationAligner
+nipype_module: nipype.interfaces.semtools.utilities.brains
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputLandmarksPaired: generic/file
+    # type=file|default=<undefined>: Input landmark file (.fcsv)
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputLandmarksPaired: generic/file
+    # type=file: Output landmark file (.fcsv)
+    # type=traitcompound|default=None: Output landmark file (.fcsv)
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputLandmarksPaired:
+    # type=file|default=<undefined>: Input landmark file (.fcsv)
+    outputLandmarksPaired:
+    # type=file: Output landmark file (.fcsv)
+    # type=traitcompound|default=None: Output landmark file (.fcsv)
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/landmarks_constellation_aligner_callables.py b/example-specs/task/nipype_internal/pydra-semtools/landmarks_constellation_aligner_callables.py
new file mode 100644
index 00000000..521e24ab
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/landmarks_constellation_aligner_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in landmarksConstellationAligner.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/landmarks_constellation_weights.yaml b/example-specs/task/nipype_internal/pydra-semtools/landmarks_constellation_weights.yaml
new file mode 100644
index 00000000..ded73a63
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/landmarks_constellation_weights.yaml
@@ -0,0 +1,89 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.utilities.brains.landmarksConstellationWeights' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Generate Landmarks Weights (BRAINS)
+# 
+#     category: Utilities.BRAINS
+# 
+#     description: Train up a list of Weights for the Landmarks in BRAINSConstellationDetector
+#     
+task_name: landmarksConstellationWeights
+nipype_name: landmarksConstellationWeights
+nipype_module: nipype.interfaces.semtools.utilities.brains
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputTrainingList: generic/file
+    # type=file|default=<undefined>: ,                 Setup file, giving all parameters for training up a Weight list for landmark.,             
+    inputTemplateModel: generic/file
+    # type=file|default=<undefined>: User-specified template model.,             
+    LLSModel: generic/file
+    # type=file|default=<undefined>: Linear least squares model filename in HD5 format
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputWeightsList: generic/file
+    # type=file: ,                 The filename of a csv file which is a list of landmarks and their corresponding weights.,             
+    # type=traitcompound|default=None: ,                 The filename of a csv file which is a list of landmarks and their corresponding weights.,             
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputTrainingList:
+    # type=file|default=<undefined>: ,                 Setup file, giving all parameters for training up a Weight list for landmark.,             
+    inputTemplateModel:
+    # type=file|default=<undefined>: User-specified template model.,             
+    LLSModel:
+    # type=file|default=<undefined>: Linear least squares model filename in HD5 format
+    outputWeightsList:
+    # type=file: ,                 The filename of a csv file which is a list of landmarks and their corresponding weights.,             
+    # type=traitcompound|default=None: ,                 The filename of a csv file which is a list of landmarks and their corresponding weights.,             
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/landmarks_constellation_weights_callables.py b/example-specs/task/nipype_internal/pydra-semtools/landmarks_constellation_weights_callables.py
new file mode 100644
index 00000000..4fcab2e3
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/landmarks_constellation_weights_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in landmarksConstellationWeights.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/maxcurvature.yaml b/example-specs/task/nipype_internal/pydra-semtools/maxcurvature.yaml
new file mode 100644
index 00000000..84e0a292
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/maxcurvature.yaml
@@ -0,0 +1,99 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.diffusion.maxcurvature.maxcurvature' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: MaxCurvature-Hessian (DTIProcess)
+# 
+#     category: Diffusion
+# 
+#     description: This program computes the Hessian of the FA image (--image). We use this scalar image as a registration input when doing DTI atlas building. For most adult FA we use a sigma of 2 whereas for neonate or primate images and sigma of 1 or 1.5 is more appropriate. For really noisy images, 2.5 - 4 can be considered. The final image (--output) shows the main feature of the input image.
+# 
+#     version: 1.1.0
+# 
+#     documentation-url: http://www.slicer.org/slicerWiki/index.php/Documentation/Nightly/Extensions/DTIProcess
+# 
+#     license: Copyright (c)  Casey Goodlett. All rights reserved.
+#       See http://www.ia.unc.edu/dev/Copyright.htm for details.
+#          This software is distributed WITHOUT ANY WARRANTY; without even
+#          the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+#          PURPOSE.  See the above copyright notices for more information.
+# 
+#     contributor: Casey Goodlett
+# 
+#     acknowledgements: Hans Johnson(1,3,4); Kent Williams(1); (1=University of Iowa Department of Psychiatry, 3=University of Iowa Department of Biomedical Engineering, 4=University of Iowa Department of Electrical and Computer Engineering) provided conversions to make DTIProcess compatible with Slicer execution, and simplified the stand-alone build requirements by removing the dependencies on boost and a fortran compiler.
+#     
+task_name: maxcurvature
+nipype_name: maxcurvature
+nipype_module: nipype.interfaces.semtools.diffusion.maxcurvature
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    image: generic/file
+    # type=file|default=<undefined>: FA Image
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    output: generic/file
+    # type=file: Output File
+    # type=traitcompound|default=None: Output File
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    image:
+    # type=file|default=<undefined>: FA Image
+    output:
+    # type=file: Output File
+    # type=traitcompound|default=None: Output File
+    sigma:
+    # type=float|default=0.0: Scale of Gradients
+    verbose:
+    # type=bool|default=False: produce verbose output
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/maxcurvature_callables.py b/example-specs/task/nipype_internal/pydra-semtools/maxcurvature_callables.py
new file mode 100644
index 00000000..be69d4a5
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/maxcurvature_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in maxcurvature.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/neighborhood_mean.yaml b/example-specs/task/nipype_internal/pydra-semtools/neighborhood_mean.yaml
new file mode 100644
index 00000000..ad1de709
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/neighborhood_mean.yaml
@@ -0,0 +1,95 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.filtering.featuredetection.NeighborhoodMean' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Neighborhood Mean
+# 
+#     category: Filtering.FeatureDetection
+# 
+#     description: Calculates the mean, for the given neighborhood size, at each voxel of the T1, T2, and FLAIR.
+# 
+#     version: 0.1.0.$Revision: 1 $(alpha)
+# 
+#     documentation-url: http:://www.na-mic.org/
+# 
+#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
+# 
+#     contributor: This tool was developed by Mark Scully and Jeremy Bockholt.
+#     
+task_name: NeighborhoodMean
+nipype_name: NeighborhoodMean
+nipype_module: nipype.interfaces.semtools.filtering.featuredetection
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputVolume: generic/file
+    # type=file|default=<undefined>: Required: input image
+    inputMaskVolume: generic/file
+    # type=file|default=<undefined>: Required: input brain mask image
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputVolume: generic/file
+    # type=file: Required: output image
+    # type=traitcompound|default=None: Required: output image
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputVolume:
+    # type=file|default=<undefined>: Required: input image
+    inputMaskVolume:
+    # type=file|default=<undefined>: Required: input brain mask image
+    inputRadius:
+    # type=int|default=0: Required: input neighborhood radius
+    outputVolume:
+    # type=file: Required: output image
+    # type=traitcompound|default=None: Required: output image
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/neighborhood_mean_callables.py b/example-specs/task/nipype_internal/pydra-semtools/neighborhood_mean_callables.py
new file mode 100644
index 00000000..b0bef2a5
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/neighborhood_mean_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in NeighborhoodMean.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/neighborhood_median.yaml b/example-specs/task/nipype_internal/pydra-semtools/neighborhood_median.yaml
new file mode 100644
index 00000000..ce68050d
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/neighborhood_median.yaml
@@ -0,0 +1,95 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.filtering.featuredetection.NeighborhoodMedian' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Neighborhood Median
+# 
+#     category: Filtering.FeatureDetection
+# 
+#     description: Calculates the median, for the given neighborhood size, at each voxel of the input image.
+# 
+#     version: 0.1.0.$Revision: 1 $(alpha)
+# 
+#     documentation-url: http:://www.na-mic.org/
+# 
+#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
+# 
+#     contributor: This tool was developed by Mark Scully and Jeremy Bockholt.
+#     
+task_name: NeighborhoodMedian
+nipype_name: NeighborhoodMedian
+nipype_module: nipype.interfaces.semtools.filtering.featuredetection
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputVolume: generic/file
+    # type=file|default=<undefined>: Required: input image
+    inputMaskVolume: generic/file
+    # type=file|default=<undefined>: Required: input brain mask image
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputVolume: generic/file
+    # type=file: Required: output image
+    # type=traitcompound|default=None: Required: output image
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputVolume:
+    # type=file|default=<undefined>: Required: input image
+    inputMaskVolume:
+    # type=file|default=<undefined>: Required: input brain mask image
+    inputRadius:
+    # type=int|default=0: Required: input neighborhood radius
+    outputVolume:
+    # type=file: Required: output image
+    # type=traitcompound|default=None: Required: output image
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/neighborhood_median_callables.py b/example-specs/task/nipype_internal/pydra-semtools/neighborhood_median_callables.py
new file mode 100644
index 00000000..75c771e8
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/neighborhood_median_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in NeighborhoodMedian.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/scalartransform.yaml b/example-specs/task/nipype_internal/pydra-semtools/scalartransform.yaml
new file mode 100644
index 00000000..791f7cc2
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/scalartransform.yaml
@@ -0,0 +1,107 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.legacy.registration.scalartransform' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: ScalarTransform (DTIProcess)
+# 
+#     category: Legacy.Registration
+# 
+#     version: 1.0.0
+# 
+#     documentation-url: http://www.slicer.org/slicerWiki/index.php/Documentation/Nightly/Extensions/DTIProcess
+# 
+#     license: Copyright (c)  Casey Goodlett. All rights reserved.
+#       See http://www.ia.unc.edu/dev/Copyright.htm for details.
+#          This software is distributed WITHOUT ANY WARRANTY; without even
+#          the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+#          PURPOSE.  See the above copyright notices for more information.
+# 
+#     contributor: Casey Goodlett
+#     
+task_name: scalartransform
+nipype_name: scalartransform
+nipype_module: nipype.interfaces.semtools.legacy.registration
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    input_image: generic/file
+    # type=file|default=<undefined>: Image to transform
+    deformation: generic/file
+    # type=file|default=<undefined>: Deformation field.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    output_image: generic/file
+    # type=file: The transformed image
+    # type=traitcompound|default=None: The transformed image
+    transformation: generic/file
+    # type=file: Output file for transformation parameters
+    # type=traitcompound|default=None: Output file for transformation parameters
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    input_image:
+    # type=file|default=<undefined>: Image to transform
+    output_image:
+    # type=file: The transformed image
+    # type=traitcompound|default=None: The transformed image
+    transformation:
+    # type=file: Output file for transformation parameters
+    # type=traitcompound|default=None: Output file for transformation parameters
+    invert:
+    # type=bool|default=False: Invert transform before applying.
+    deformation:
+    # type=file|default=<undefined>: Deformation field.
+    h_field:
+    # type=bool|default=False: The deformation is an h-field.
+    interpolation:
+    # type=enum|default='nearestneighbor'|allowed['cubic','linear','nearestneighbor']: Interpolation type (nearestneighbor, linear, cubic)
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/scalartransform_callables.py b/example-specs/task/nipype_internal/pydra-semtools/scalartransform_callables.py
new file mode 100644
index 00000000..4c4197fa
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/scalartransform_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in scalartransform.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/shuffle_vectors_module.yaml b/example-specs/task/nipype_internal/pydra-semtools/shuffle_vectors_module.yaml
new file mode 100644
index 00000000..d7fffa57
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/shuffle_vectors_module.yaml
@@ -0,0 +1,89 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.utilities.brains.ShuffleVectorsModule' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: ShuffleVectors
+# 
+#     category: Utilities.BRAINS
+# 
+#     description: Automatic Segmentation using neural networks
+# 
+#     version: 1.0
+# 
+#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
+# 
+#     contributor: Hans Johnson
+#     
+task_name: ShuffleVectorsModule
+nipype_name: ShuffleVectorsModule
+nipype_module: nipype.interfaces.semtools.utilities.brains
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputVectorFileBaseName: generic/file
+    # type=file|default=<undefined>: input vector file name prefix. Usually end with .txt and header file has prost fix of .txt.hdr
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputVectorFileBaseName: generic/file
+    # type=file: output vector file name prefix. Usually end with .txt and header file has prost fix of .txt.hdr
+    # type=traitcompound|default=None: output vector file name prefix. Usually end with .txt and header file has prost fix of .txt.hdr
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputVectorFileBaseName:
+    # type=file|default=<undefined>: input vector file name prefix. Usually end with .txt and header file has prost fix of .txt.hdr
+    outputVectorFileBaseName:
+    # type=file: output vector file name prefix. Usually end with .txt and header file has prost fix of .txt.hdr
+    # type=traitcompound|default=None: output vector file name prefix. Usually end with .txt and header file has prost fix of .txt.hdr
+    resampleProportion:
+    # type=float|default=0.0: downsample size of 1 will be the same size as the input images, downsample size of 3 will throw 2/3 the vectors away.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/shuffle_vectors_module_callables.py b/example-specs/task/nipype_internal/pydra-semtools/shuffle_vectors_module_callables.py
new file mode 100644
index 00000000..1c56caeb
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/shuffle_vectors_module_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in ShuffleVectorsModule.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/similarity_index.yaml b/example-specs/task/nipype_internal/pydra-semtools/similarity_index.yaml
new file mode 100644
index 00000000..db8872b5
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/similarity_index.yaml
@@ -0,0 +1,91 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.brains.segmentation.SimilarityIndex' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: BRAINSCut:SimilarityIndexComputation
+# 
+#     category: BRAINS.Segmentation
+# 
+#     description: Automatic analysis of BRAINSCut Output
+# 
+#     version: 1.0
+# 
+#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
+# 
+#     contributor: Eunyoung Regin Kim
+#     
+task_name: SimilarityIndex
+nipype_name: SimilarityIndex
+nipype_module: nipype.interfaces.semtools.brains.segmentation
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputCSVFilename: generic/file
+    # type=file|default=<undefined>: output CSV Filename
+    ANNContinuousVolume: generic/file
+    # type=file|default=<undefined>: ANN Continuous volume to be compared to the manual volume
+    inputManualVolume: generic/file
+    # type=file|default=<undefined>: input manual(reference) volume
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    outputCSVFilename:
+    # type=file|default=<undefined>: output CSV Filename
+    ANNContinuousVolume:
+    # type=file|default=<undefined>: ANN Continuous volume to be compared to the manual volume
+    inputManualVolume:
+    # type=file|default=<undefined>: input manual(reference) volume
+    thresholdInterval:
+    # type=float|default=0.0: Threshold interval to compute similarity index between zero and one
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/similarity_index_callables.py b/example-specs/task/nipype_internal/pydra-semtools/similarity_index_callables.py
new file mode 100644
index 00000000..64a0e7e5
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/similarity_index_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in SimilarityIndex.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/spherical_coordinate_generation.yaml b/example-specs/task/nipype_internal/pydra-semtools/spherical_coordinate_generation.yaml
new file mode 100644
index 00000000..46fecd20
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/spherical_coordinate_generation.yaml
@@ -0,0 +1,81 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.testing.featuredetection.SphericalCoordinateGeneration' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Spherical Coordinate Generation
+# 
+#     category: Testing.FeatureDetection
+# 
+#     description: get the atlas image as input and generates the rho, phi and theta images.
+# 
+#     version: 0.1.0.$Revision: 1 $(alpha)
+# 
+#     contributor: Ali Ghayoor
+#     
+task_name: SphericalCoordinateGeneration
+nipype_name: SphericalCoordinateGeneration
+nipype_module: nipype.interfaces.semtools.testing.featuredetection
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputAtlasImage: generic/file
+    # type=file|default=<undefined>: Input atlas image
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputAtlasImage:
+    # type=file|default=<undefined>: Input atlas image
+    outputPath:
+    # type=str|default='': Output path for rho, phi and theta images
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/spherical_coordinate_generation_callables.py b/example-specs/task/nipype_internal/pydra-semtools/spherical_coordinate_generation_callables.py
new file mode 100644
index 00000000..f5a3e1b4
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/spherical_coordinate_generation_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in SphericalCoordinateGeneration.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/staple_analysis.yaml b/example-specs/task/nipype_internal/pydra-semtools/staple_analysis.yaml
new file mode 100644
index 00000000..9f13769f
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/staple_analysis.yaml
@@ -0,0 +1,91 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.filtering.featuredetection.STAPLEAnalysis' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Dilate Image
+# 
+#     category: Filtering.FeatureDetection
+# 
+#     description: Uses mathematical morphology to dilate the input images.
+# 
+#     version: 0.1.0.$Revision: 1 $(alpha)
+# 
+#     documentation-url: http:://www.na-mic.org/
+# 
+#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
+# 
+#     contributor: This tool was developed by Mark Scully and Jeremy Bockholt.
+#     
+task_name: STAPLEAnalysis
+nipype_name: STAPLEAnalysis
+nipype_module: nipype.interfaces.semtools.filtering.featuredetection
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputLabelVolume: generic/file+list-of
+    # type=inputmultiobject|default=[]: Required: input label volume
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputVolume: generic/file
+    # type=file: Required: output image
+    # type=traitcompound|default=None: Required: output image
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputDimension:
+    # type=int|default=0: Required: input image Dimension 2 or 3
+    inputLabelVolume:
+    # type=inputmultiobject|default=[]: Required: input label volume
+    outputVolume:
+    # type=file: Required: output image
+    # type=traitcompound|default=None: Required: output image
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/staple_analysis_callables.py b/example-specs/task/nipype_internal/pydra-semtools/staple_analysis_callables.py
new file mode 100644
index 00000000..202d8fdb
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/staple_analysis_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in STAPLEAnalysis.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/texture_from_noise_image_filter.yaml b/example-specs/task/nipype_internal/pydra-semtools/texture_from_noise_image_filter.yaml
new file mode 100644
index 00000000..de6e4846
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/texture_from_noise_image_filter.yaml
@@ -0,0 +1,91 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.filtering.featuredetection.TextureFromNoiseImageFilter' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: TextureFromNoiseImageFilter
+# 
+#     category: Filtering.FeatureDetection
+# 
+#     description: Calculate the local noise in an image.
+# 
+#     version: 0.1.0.$Revision: 1 $(alpha)
+# 
+#     documentation-url: http:://www.na-mic.org/
+# 
+#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
+# 
+#     contributor: This tool was developed by Eunyoung Regina Kim
+#     
+task_name: TextureFromNoiseImageFilter
+nipype_name: TextureFromNoiseImageFilter
+nipype_module: nipype.interfaces.semtools.filtering.featuredetection
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputVolume: generic/file
+    # type=file|default=<undefined>: Required: input image
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputVolume: generic/file
+    # type=file: Required: output image
+    # type=traitcompound|default=None: Required: output image
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputVolume:
+    # type=file|default=<undefined>: Required: input image
+    inputRadius:
+    # type=int|default=0: Required: input neighborhood radius
+    outputVolume:
+    # type=file: Required: output image
+    # type=traitcompound|default=None: Required: output image
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/texture_from_noise_image_filter_callables.py b/example-specs/task/nipype_internal/pydra-semtools/texture_from_noise_image_filter_callables.py
new file mode 100644
index 00000000..00c718c6
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/texture_from_noise_image_filter_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in TextureFromNoiseImageFilter.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/texture_measure_filter.yaml b/example-specs/task/nipype_internal/pydra-semtools/texture_measure_filter.yaml
new file mode 100644
index 00000000..3c9bf900
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/texture_measure_filter.yaml
@@ -0,0 +1,97 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.filtering.featuredetection.TextureMeasureFilter' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Canny Level Set Image Filter
+# 
+#     category: Filtering.FeatureDetection
+# 
+#     description: The CannySegmentationLevelSet is commonly used to refine a manually generated manual mask.
+# 
+#     version: 0.3.0
+# 
+#     license: CC
+# 
+#     contributor: Regina Kim
+# 
+#     acknowledgements: This command module was derived from Insight/Examples/Segmentation/CannySegmentationLevelSetImageFilter.cxx (copyright) Insight Software Consortium.  See http://wiki.na-mic.org/Wiki/index.php/Slicer3:Execution_Model_Documentation for more detailed descriptions.
+#     
+task_name: TextureMeasureFilter
+nipype_name: TextureMeasureFilter
+nipype_module: nipype.interfaces.semtools.filtering.featuredetection
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputVolume: generic/file
+    # type=file|default=<undefined>: 
+    inputMaskVolume: generic/file
+    # type=file|default=<undefined>: 
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputFilename: generic/file
+    # type=file: 
+    # type=traitcompound|default=None: 
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputVolume:
+    # type=file|default=<undefined>: 
+    inputMaskVolume:
+    # type=file|default=<undefined>: 
+    distance:
+    # type=int|default=0: 
+    insideROIValue:
+    # type=float|default=0.0: 
+    outputFilename:
+    # type=file: 
+    # type=traitcompound|default=None: 
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/texture_measure_filter_callables.py b/example-specs/task/nipype_internal/pydra-semtools/texture_measure_filter_callables.py
new file mode 100644
index 00000000..b2d48fa2
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/texture_measure_filter_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in TextureMeasureFilter.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/ukf_tractography.yaml b/example-specs/task/nipype_internal/pydra-semtools/ukf_tractography.yaml
new file mode 100644
index 00000000..3789694a
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/ukf_tractography.yaml
@@ -0,0 +1,159 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.diffusion.tractography.ukftractography.UKFTractography' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: UKF Tractography
+# 
+#     category: Diffusion.Tractography
+# 
+#     description: This module traces fibers in a DWI Volume using the multiple tensor unscented Kalman Filter methology. For more information check the documentation.
+# 
+#     version: 1.0
+# 
+#     documentation-url: http://www.nitrc.org/plugins/mwiki/index.php/ukftractography:MainPage
+# 
+#     contributor: Yogesh Rathi, Stefan Lienhard, Yinpeng Li, Martin Styner, Ipek Oguz, Yundi Shi, Christian Baumgartner, Kent Williams, Hans Johnson, Peter Savadjiev, Carl-Fredrik Westin.
+# 
+#     acknowledgements: The development of this module was supported by NIH grants R01 MH097979 (PI Rathi), R01 MH092862 (PIs Westin and Verma), U01 NS083223 (PI Westin), R01 MH074794 (PI Westin) and P41 EB015902 (PI Kikinis).
+#     
+task_name: UKFTractography
+nipype_name: UKFTractography
+nipype_module: nipype.interfaces.semtools.diffusion.tractography.ukftractography
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    dwiFile: generic/file
+    # type=file|default=<undefined>: Input DWI volume
+    seedsFile: generic/file
+    # type=file|default=<undefined>: Seeds for diffusion. If not specified, full brain tractography will be performed, and the algorithm will start from every voxel in the brain mask where the Generalized Anisotropy is bigger than 0.18
+    maskFile: generic/file
+    # type=file|default=<undefined>: Mask for diffusion tractography
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    tracts: generic/file
+    # type=file: Tracts generated, with first tensor output
+    # type=traitcompound|default=None: Tracts generated, with first tensor output
+    tractsWithSecondTensor: generic/file
+    # type=file: Tracts generated, with second tensor output (if there is one)
+    # type=traitcompound|default=None: Tracts generated, with second tensor output (if there is one)
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    dwiFile:
+    # type=file|default=<undefined>: Input DWI volume
+    seedsFile:
+    # type=file|default=<undefined>: Seeds for diffusion. If not specified, full brain tractography will be performed, and the algorithm will start from every voxel in the brain mask where the Generalized Anisotropy is bigger than 0.18
+    labels:
+    # type=inputmultiobject|default=[]: A vector of the ROI labels to be used
+    maskFile:
+    # type=file|default=<undefined>: Mask for diffusion tractography
+    tracts:
+    # type=file: Tracts generated, with first tensor output
+    # type=traitcompound|default=None: Tracts generated, with first tensor output
+    writeAsciiTracts:
+    # type=bool|default=False: Write tract file as a VTK binary data file
+    writeUncompressedTracts:
+    # type=bool|default=False: Write tract file as a VTK uncompressed data file
+    seedsPerVoxel:
+    # type=int|default=0:  Each seed generates a fiber, thus using more seeds generates more fibers. In general use 1 or 2 seeds, and for a more thorough result use 5 or 10 (depending on your machine this may take up to 2 days to run).,       
+    numTensor:
+    # type=enum|default='1'|allowed['1','2']: Number of tensors used
+    freeWater:
+    # type=bool|default=False: Adds a term for free water difusion to the model. (Note for experts: if checked, the 1T simple model is forced) 
+    recordFA:
+    # type=bool|default=False: Whether to store FA. Attaches field 'FA', and 'FA2' for 2-tensor case to fiber. 
+    recordFreeWater:
+    # type=bool|default=False: Whether to store the fraction of free water. Attaches field 'FreeWater' to fiber.
+    recordTrace:
+    # type=bool|default=False: Whether to store Trace. Attaches field 'Trace', and 'Trace2' for 2-tensor case to fiber.
+    recordTensors:
+    # type=bool|default=False: Recording the tensors enables Slicer to color the fiber bundles by FA, orientation, and so on. The fields will be called 'TensorN', where N is the tensor number. 
+    recordNMSE:
+    # type=bool|default=False: Whether to store NMSE. Attaches field 'NMSE' to fiber. 
+    recordState:
+    # type=bool|default=False: Whether to attach the states to the fiber. Will generate field 'state'.
+    recordCovariance:
+    # type=bool|default=False: Whether to store the covariance. Will generate field 'covariance' in fiber.
+    recordLength:
+    # type=float|default=0.0: Record length of tractography, in millimeters
+    minFA:
+    # type=float|default=0.0: Abort the tractography when the Fractional Anisotropy is less than this value
+    minGA:
+    # type=float|default=0.0: Abort the tractography when the Generalized Anisotropy is less than this value
+    fullTensorModel:
+    # type=bool|default=False: Whether to use the full tensor model. If unchecked, use the default simple tensor model
+    numThreads:
+    # type=int|default=0: Number of threads used during computation. Set to the number of cores on your workstation for optimal speed. If left undefined the number of cores detected will be used. 
+    stepLength:
+    # type=float|default=0.0: Step length of tractography, in millimeters
+    maxHalfFiberLength:
+    # type=float|default=0.0: The max length limit of the half fibers generated during tractography. Here the fiber is 'half' because the tractography goes in only one direction from one seed point at a time
+    seedFALimit:
+    # type=float|default=0.0: Seed points whose FA are below this value are excluded
+    Qm:
+    # type=float|default=0.0: Process noise for angles/direction
+    Ql:
+    # type=float|default=0.0: Process noise for eigenvalues
+    Qw:
+    # type=float|default=0.0: Process noise for free water weights, ignored if no free water estimation
+    Rs:
+    # type=float|default=0.0: Measurement noise
+    maxBranchingAngle:
+    # type=float|default=0.0: Maximum branching angle, in degrees. When using multiple tensors, a new branch will be created when the tensors' major directions form an angle between (minBranchingAngle, maxBranchingAngle). Branching is suppressed when this maxBranchingAngle is set to 0.0
+    minBranchingAngle:
+    # type=float|default=0.0: Minimum branching angle, in degrees. When using multiple tensors, a new branch will be created when the tensors' major directions form an angle between (minBranchingAngle, maxBranchingAngle)
+    tractsWithSecondTensor:
+    # type=file: Tracts generated, with second tensor output (if there is one)
+    # type=traitcompound|default=None: Tracts generated, with second tensor output (if there is one)
+    storeGlyphs:
+    # type=bool|default=False: Store tensors' main directions as two-point lines in a separate file named glyphs_{tracts}. When using multiple tensors, only the major tensors' main directions are stored
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/ukf_tractography_callables.py b/example-specs/task/nipype_internal/pydra-semtools/ukf_tractography_callables.py
new file mode 100644
index 00000000..d0fe23da
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/ukf_tractography_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in UKFTractography.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/unbiased_non_local_means.yaml b/example-specs/task/nipype_internal/pydra-semtools/unbiased_non_local_means.yaml
new file mode 100644
index 00000000..257f42d0
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/unbiased_non_local_means.yaml
@@ -0,0 +1,107 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.filtering.denoising.UnbiasedNonLocalMeans' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Unbiased NLM for MRI
+# 
+#     category: Filtering.Denoising
+# 
+#     description: This module implements a fast version of the popular Non-Local Means filter for image denoising. This algorithm filters each pixel as a weighted average of its neighbors in a large vicinity. The weights are computed based on the similarity of each neighbor with the voxel to be denoised.
+#      In the original formulation a patch with a certain radius is centered in each of the voxels, and the Mean Squared Error between each pair of corresponding voxels is computed. In this implementation, only the mean value and gradient components are compared. This, together with an efficient memory management, can attain a speed-up of nearly 20x. Besides, the filtering is more accurate than the original with poor SNR.
+#      This code is intended for its use with MRI (or any other Rician-distributed modality): the second order moment is estimated, then we subtract twice the squared power of noise, and finally we take the square root of the result to remove the Rician bias.
+#      The original implementation of the NLM filter may be found in:
+#      A. Buades, B. Coll, J. Morel, "A review of image denoising algorithms, with a new one", Multiscale Modelling and Simulation 4(2): 490-530. 2005.
+#      The correction of the Rician bias is described in the following reference (among others):
+#      S. Aja-Fernandez, K. Krissian, "An unbiased Non-Local Means scheme for DWI filtering", in: Proceedings of the MICCAI Workshop on Computational Diffusion MRI, 2008, pp. 277-284.
+#      The whole description of this version may be found in the following paper (please, cite it if you are willing to use this software):
+#      A. Tristan-Vega, V. Garcia Perez, S. Aja-Fenandez, and C.-F. Westin, "Efficient and Robust Nonlocal Means Denoising of MR Data Based on Salient Features Matching", Computer Methods and Programs in Biomedicine. (Accepted for publication) 2011.
+# 
+#     version: 0.0.1.$Revision: 1 $(beta)
+# 
+#     documentation-url: http://www.slicer.org/slicerWiki/index.php/Modules:UnbiasedNonLocalMeans-Documentation-3.6
+# 
+#     contributor: Antonio Tristan Vega, Veronica Garcia-Perez, Santiago Aja-Fernandez, Carl-Fredrik Westin
+# 
+#     acknowledgements: Supported by grant number FMECD-2010/71131616E from the Spanish Ministry of Education/Fulbright Committee
+#     
+task_name: UnbiasedNonLocalMeans
+nipype_name: UnbiasedNonLocalMeans
+nipype_module: nipype.interfaces.semtools.filtering.denoising
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputVolume: generic/file
+    # type=file|default=<undefined>: Input MRI volume.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputVolume: generic/file
+    # type=file: Output (filtered) MRI volume.
+    # type=traitcompound|default=None: Output (filtered) MRI volume.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    sigma:
+    # type=float|default=0.0: The root power of noise (sigma) in the complex Gaussian process the Rician comes from. If it is underestimated, the algorithm fails to remove the noise. If it is overestimated, over-blurring is likely to occur.
+    rs:
+    # type=inputmultiobject|default=[]: The algorithm search for similar voxels in a neighborhood of this radius (radii larger than 5,5,5 are very slow, and the results can be only marginally better. Small radii may fail to effectively remove the noise).
+    rc:
+    # type=inputmultiobject|default=[]: Similarity between blocks is computed as the difference between mean values and gradients. These parameters are computed fitting a hyperplane with LS inside a neighborhood of this size
+    hp:
+    # type=float|default=0.0: This parameter is related to noise; the larger the parameter, the more aggressive the filtering. Should be near 1, and only values between 0.8 and 1.2 are allowed
+    ps:
+    # type=float|default=0.0: To accelerate computations, preselection is used: if the normalized difference is above this threshold, the voxel will be discarded (non used for average)
+    inputVolume:
+    # type=file|default=<undefined>: Input MRI volume.
+    outputVolume:
+    # type=file: Output (filtered) MRI volume.
+    # type=traitcompound|default=None: Output (filtered) MRI volume.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/unbiased_non_local_means_callables.py b/example-specs/task/nipype_internal/pydra-semtools/unbiased_non_local_means_callables.py
new file mode 100644
index 00000000..e597ef31
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/unbiased_non_local_means_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in UnbiasedNonLocalMeans.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/vbrains_demon_warp.yaml b/example-specs/task/nipype_internal/pydra-semtools/vbrains_demon_warp.yaml
new file mode 100644
index 00000000..ef83febc
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/vbrains_demon_warp.yaml
@@ -0,0 +1,187 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.semtools.registration.specialized.VBRAINSDemonWarp' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Vector Demon Registration (BRAINS)
+# 
+#     category: Registration.Specialized
+# 
+#     description: This program finds a deformation field to warp a moving image onto a fixed image.  The images must be of the same signal kind, and contain an image of the same kind of object.  This program uses the Thirion Demons warp software in ITK, the Insight Toolkit.  Additional information is available at: http://www.nitrc.org/projects/brainsdemonwarp.
+# 
+#     version: 3.0.0
+# 
+#     documentation-url: http://www.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/BRAINSDemonWarp
+# 
+#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
+# 
+#     contributor: This tool was developed by Hans J. Johnson and Greg Harris.
+# 
+#     acknowledgements: The development of this tool was supported by funding from grants NS050568 and NS40068 from the National Institute of Neurological Disorders and Stroke and grants MH31593, MH40856, from the National Institute of Mental Health.
+#     
+task_name: VBRAINSDemonWarp
+nipype_name: VBRAINSDemonWarp
+nipype_module: nipype.interfaces.semtools.registration.specialized
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    movingVolume: generic/file+list-of
+    # type=inputmultiobject|default=[]: Required: input moving image
+    fixedVolume: generic/file+list-of
+    # type=inputmultiobject|default=[]: Required: input fixed (target) image
+    initializeWithDisplacementField: generic/file
+    # type=file|default=<undefined>: Initial deformation field vector image file name
+    initializeWithTransform: generic/file
+    # type=file|default=<undefined>: Initial Transform filename
+    fixedBinaryVolume: generic/file
+    # type=file|default=<undefined>: Mask filename for desired region of interest in the Fixed image.
+    movingBinaryVolume: generic/file
+    # type=file|default=<undefined>: Mask filename for desired region of interest in the Moving image.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputVolume: generic/file
+    # type=file: Required: output resampled moving image (will have the same physical space as the fixedVolume).
+    # type=traitcompound|default=None: Required: output resampled moving image (will have the same physical space as the fixedVolume).
+    outputDisplacementFieldVolume: generic/file
+    # type=file: Output deformation field vector image (will have the same physical space as the fixedVolume).
+    # type=traitcompound|default=None: Output deformation field vector image (will have the same physical space as the fixedVolume).
+    outputCheckerboardVolume: generic/file
+    # type=file: Genete a checkerboard image volume between the fixedVolume and the deformed movingVolume.
+    # type=traitcompound|default=None: Genete a checkerboard image volume between the fixedVolume and the deformed movingVolume.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    movingVolume:
+    # type=inputmultiobject|default=[]: Required: input moving image
+    fixedVolume:
+    # type=inputmultiobject|default=[]: Required: input fixed (target) image
+    inputPixelType:
+    # type=enum|default='float'|allowed['float','int','short','uchar','ushort']: Input volumes will be typecast to this format: float|short|ushort|int|uchar
+    outputVolume:
+    # type=file: Required: output resampled moving image (will have the same physical space as the fixedVolume).
+    # type=traitcompound|default=None: Required: output resampled moving image (will have the same physical space as the fixedVolume).
+    outputDisplacementFieldVolume:
+    # type=file: Output deformation field vector image (will have the same physical space as the fixedVolume).
+    # type=traitcompound|default=None: Output deformation field vector image (will have the same physical space as the fixedVolume).
+    outputPixelType:
+    # type=enum|default='float'|allowed['float','int','short','uchar','ushort']: outputVolume will be typecast to this format: float|short|ushort|int|uchar
+    interpolationMode:
+    # type=enum|default='NearestNeighbor'|allowed['BSpline','Blackman','Cosine','Hamming','Lanczos','Linear','NearestNeighbor','ResampleInPlace','Welch','WindowedSinc']: Type of interpolation to be used when applying transform to moving volume.  Options are Linear, ResampleInPlace, NearestNeighbor, BSpline, or WindowedSinc
+    registrationFilterType:
+    # type=enum|default='Demons'|allowed['Demons','Diffeomorphic','FastSymmetricForces','LogDemons','SymmetricLogDemons']: Registration Filter Type: Demons|FastSymmetricForces|Diffeomorphic|LogDemons|SymmetricLogDemons
+    smoothDisplacementFieldSigma:
+    # type=float|default=0.0: A gaussian smoothing value to be applied to the deformation field at each iteration.
+    numberOfPyramidLevels:
+    # type=int|default=0: Number of image pyramid levels to use in the multi-resolution registration.
+    minimumFixedPyramid:
+    # type=inputmultiobject|default=[]: The shrink factor for the first level of the fixed image pyramid. (i.e. start at 1/16 scale, then 1/8, then 1/4, then 1/2, and finally full scale)
+    minimumMovingPyramid:
+    # type=inputmultiobject|default=[]: The shrink factor for the first level of the moving image pyramid. (i.e. start at 1/16 scale, then 1/8, then 1/4, then 1/2, and finally full scale)
+    arrayOfPyramidLevelIterations:
+    # type=inputmultiobject|default=[]: The number of iterations for each pyramid level
+    histogramMatch:
+    # type=bool|default=False: Histogram Match the input images.  This is suitable for images of the same modality that may have different absolute scales, but the same overall intensity profile.
+    numberOfHistogramBins:
+    # type=int|default=0: The number of histogram levels
+    numberOfMatchPoints:
+    # type=int|default=0: The number of match points for histrogramMatch
+    medianFilterSize:
+    # type=inputmultiobject|default=[]: Median filter radius in all 3 directions.  When images have a lot of salt and pepper noise, this step can improve the registration.
+    initializeWithDisplacementField:
+    # type=file|default=<undefined>: Initial deformation field vector image file name
+    initializeWithTransform:
+    # type=file|default=<undefined>: Initial Transform filename
+    makeBOBF:
+    # type=bool|default=False: Flag to make Brain-Only Background-Filled versions of the input and target volumes.
+    fixedBinaryVolume:
+    # type=file|default=<undefined>: Mask filename for desired region of interest in the Fixed image.
+    movingBinaryVolume:
+    # type=file|default=<undefined>: Mask filename for desired region of interest in the Moving image.
+    lowerThresholdForBOBF:
+    # type=int|default=0: Lower threshold for performing BOBF
+    upperThresholdForBOBF:
+    # type=int|default=0: Upper threshold for performing BOBF
+    backgroundFillValue:
+    # type=int|default=0: Replacement value to overwrite background when performing BOBF
+    seedForBOBF:
+    # type=inputmultiobject|default=[]: coordinates in all 3 directions for Seed when performing BOBF
+    neighborhoodForBOBF:
+    # type=inputmultiobject|default=[]: neighborhood in all 3 directions to be included when performing BOBF
+    outputDisplacementFieldPrefix:
+    # type=str|default='': Displacement field filename prefix for writing separate x, y, and z component images
+    outputCheckerboardVolume:
+    # type=file: Genete a checkerboard image volume between the fixedVolume and the deformed movingVolume.
+    # type=traitcompound|default=None: Genete a checkerboard image volume between the fixedVolume and the deformed movingVolume.
+    checkerboardPatternSubdivisions:
+    # type=inputmultiobject|default=[]: Number of Checkerboard subdivisions in all 3 directions
+    outputNormalized:
+    # type=bool|default=False: Flag to warp and write the normalized images to output.  In normalized images the image values are fit-scaled to be between 0 and the maximum storage type value.
+    outputDebug:
+    # type=bool|default=False: Flag to write debugging images after each step.
+    weightFactors:
+    # type=inputmultiobject|default=[]: Weight fatctors for each input images
+    gradient_type:
+    # type=enum|default='0'|allowed['0','1','2']: Type of gradient used for computing the demons force (0 is symmetrized, 1 is fixed image, 2 is moving image)
+    upFieldSmoothing:
+    # type=float|default=0.0: Smoothing sigma for the update field at each iteration
+    max_step_length:
+    # type=float|default=0.0: Maximum length of an update vector (0: no restriction)
+    use_vanilla_dem:
+    # type=bool|default=False: Run vanilla demons algorithm
+    gui:
+    # type=bool|default=False: Display intermediate image volumes for debugging
+    promptUser:
+    # type=bool|default=False: Prompt the user to hit enter each time an image is sent to the DebugImageViewer
+    numberOfBCHApproximationTerms:
+    # type=int|default=0: Number of terms in the BCH expansion
+    numberOfThreads:
+    # type=int|default=0: Explicitly specify the maximum number of threads to use.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/vbrains_demon_warp_callables.py b/example-specs/task/nipype_internal/pydra-semtools/vbrains_demon_warp_callables.py
new file mode 100644
index 00000000..c1ed6ee7
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-semtools/vbrains_demon_warp_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in VBRAINSDemonWarp.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/acpc_transform.yaml b/example-specs/task/nipype_internal/pydra-slicer/acpc_transform.yaml
new file mode 100644
index 00000000..4b7b0aa0
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/acpc_transform.yaml
@@ -0,0 +1,93 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.slicer.registration.specialized.ACPCTransform' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: ACPC Transform
+# 
+#     category: Registration.Specialized
+# 
+#     description: <p>Calculate a transformation from two lists of fiducial points.</p><p>ACPC line is two fiducial points, one at the anterior commissure and one at the posterior commissure. The resulting transform will bring the line connecting them to horizontal to the AP axis.</p><p>The midline is a series of points defining the division between the hemispheres of the brain (the mid sagittal plane). The resulting transform will put the output volume with the mid sagittal plane lined up with the AS plane.</p><p>Use the Filtering module<b>Resample Scalar/Vector/DWI Volume</b>to apply the transformation to a volume.</p>
+# 
+#     version: 1.0
+# 
+#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/ACPCTransform
+# 
+#     license: slicer3
+# 
+#     contributor: Nicole Aucoin (SPL, BWH), Ron Kikinis (SPL, BWH)
+# 
+#     acknowledgements: This work is part of the National Alliance for Medical Image Computing (NAMIC), funded by the National Institutes of Health through the NIH Roadmap for Medical Research, Grant U54 EB005149.
+#     
+task_name: ACPCTransform
+nipype_name: ACPCTransform
+nipype_module: nipype.interfaces.slicer.registration.specialized
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputTransform: generic/file
+    # type=file: A transform filled in from the ACPC and Midline registration calculation
+    # type=traitcompound|default=None: A transform filled in from the ACPC and Midline registration calculation
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    acpc:
+    # type=inputmultiobject|default=[]: ACPC line, two fiducial points, one at the anterior commissure and one at the posterior commissure.
+    midline:
+    # type=inputmultiobject|default=[]: The midline is a series of points defining the division between the hemispheres of the brain (the mid sagittal plane).
+    outputTransform:
+    # type=file: A transform filled in from the ACPC and Midline registration calculation
+    # type=traitcompound|default=None: A transform filled in from the ACPC and Midline registration calculation
+    debugSwitch:
+    # type=bool|default=False: Click if wish to see debugging output
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/acpc_transform_callables.py b/example-specs/task/nipype_internal/pydra-slicer/acpc_transform_callables.py
new file mode 100644
index 00000000..2f786068
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/acpc_transform_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in ACPCTransform.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/add_scalar_volumes.yaml b/example-specs/task/nipype_internal/pydra-slicer/add_scalar_volumes.yaml
new file mode 100644
index 00000000..ec1b6e7a
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/add_scalar_volumes.yaml
@@ -0,0 +1,95 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.slicer.filtering.arithmetic.AddScalarVolumes' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Add Scalar Volumes
+# 
+#     category: Filtering.Arithmetic
+# 
+#     description: Adds two images. Although all image types are supported on input, only signed types are produced. The two images do not have to have the same dimensions.
+# 
+#     version: 0.1.0.$Revision: 19608 $(alpha)
+# 
+#     documentation-url: http://slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/Add
+# 
+#     contributor: Bill Lorensen (GE)
+# 
+#     acknowledgements: This work is part of the National Alliance for Medical Image Computing (NAMIC), funded by the National Institutes of Health through the NIH Roadmap for Medical Research, Grant U54 EB005149.
+#     
+task_name: AddScalarVolumes
+nipype_name: AddScalarVolumes
+nipype_module: nipype.interfaces.slicer.filtering.arithmetic
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputVolume1: generic/file
+    # type=file|default=<undefined>: Input volume 1
+    inputVolume2: generic/file
+    # type=file|default=<undefined>: Input volume 2
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputVolume: generic/file
+    # type=file: Volume1 + Volume2
+    # type=traitcompound|default=None: Volume1 + Volume2
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputVolume1:
+    # type=file|default=<undefined>: Input volume 1
+    inputVolume2:
+    # type=file|default=<undefined>: Input volume 2
+    outputVolume:
+    # type=file: Volume1 + Volume2
+    # type=traitcompound|default=None: Volume1 + Volume2
+    order:
+    # type=enum|default='0'|allowed['0','1','2','3']: Interpolation order if two images are in different coordinate frames or have different sampling.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/add_scalar_volumes_callables.py b/example-specs/task/nipype_internal/pydra-slicer/add_scalar_volumes_callables.py
new file mode 100644
index 00000000..557644f7
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/add_scalar_volumes_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in AddScalarVolumes.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/affine_registration.yaml b/example-specs/task/nipype_internal/pydra-slicer/affine_registration.yaml
new file mode 100644
index 00000000..421540d9
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/affine_registration.yaml
@@ -0,0 +1,121 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.slicer.legacy.registration.AffineRegistration' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Affine Registration
+# 
+#     category: Legacy.Registration
+# 
+#     description: Registers two images together using an affine transform and mutual information. This module is often used to align images of different subjects or images of the same subject from different modalities.
+# 
+#     This module can smooth images prior to registration to mitigate noise and improve convergence. Many of the registration parameters require a working knowledge of the algorithm although the default parameters are sufficient for many registration tasks.
+# 
+# 
+# 
+#     version: 0.1.0.$Revision: 19608 $(alpha)
+# 
+#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/AffineRegistration
+# 
+#     contributor: Daniel Blezek (GE)
+# 
+#     acknowledgements: This module was developed by Daniel Blezek while at GE Research with contributions from Jim Miller.
+# 
+#     This work is part of the National Alliance for Medical Image Computing (NAMIC), funded by the National Institutes of Health through the NIH Roadmap for Medical Research, Grant U54 EB005149.
+#     
+task_name: AffineRegistration
+nipype_name: AffineRegistration
+nipype_module: nipype.interfaces.slicer.legacy.registration
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    initialtransform: generic/file
+    # type=file|default=<undefined>: Initial transform for aligning the fixed and moving image.  Maps positions in the fixed coordinate frame to positions in the moving coordinate frame. Optional.
+    FixedImageFileName: generic/file
+    # type=file|default=<undefined>: Fixed image to which to register
+    MovingImageFileName: generic/file
+    # type=file|default=<undefined>: Moving image
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputtransform: generic/file
+    # type=file: Transform calculated that aligns the fixed and moving image. Maps positions in the fixed coordinate frame to the moving coordinate frame. Optional (specify an output transform or an output volume or both).
+    # type=traitcompound|default=None: Transform calculated that aligns the fixed and moving image. Maps positions in the fixed coordinate frame to the moving coordinate frame. Optional (specify an output transform or an output volume or both).
+    resampledmovingfilename: generic/file
+    # type=file: Resampled moving image to the fixed image coordinate frame. Optional (specify an output transform or an output volume or both).
+    # type=traitcompound|default=None: Resampled moving image to the fixed image coordinate frame. Optional (specify an output transform or an output volume or both).
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    fixedsmoothingfactor:
+    # type=int|default=0: Amount of smoothing applied to fixed image prior to registration. Default is 0 (none). Range is 0-5 (unitless). Consider smoothing the input data if there is considerable amounts of noise or the noise pattern in the fixed and moving images is very different.
+    movingsmoothingfactor:
+    # type=int|default=0: Amount of smoothing applied to moving image prior to registration. Default is 0 (none). Range is 0-5 (unitless). Consider smoothing the input data if there is considerable amounts of noise or the noise pattern in the fixed and moving images is very different.
+    histogrambins:
+    # type=int|default=0: Number of histogram bins to use for Mattes Mutual Information. Reduce the number of bins if a registration fails. If the number of bins is too large, the estimated PDFs will be a field of impulses and will inhibit reliable registration estimation.
+    spatialsamples:
+    # type=int|default=0: Number of spatial samples to use in estimating Mattes Mutual Information. Larger values yield more accurate PDFs and improved registration quality.
+    iterations:
+    # type=int|default=0: Number of iterations
+    translationscale:
+    # type=float|default=0.0: Relative scale of translations to rotations, i.e. a value of 100 means 10mm = 1 degree. (Actual scale used is 1/(TranslationScale^2)). This parameter is used to 'weight' or 'standardized' the transform parameters and their effect on the registration objective function.
+    initialtransform:
+    # type=file|default=<undefined>: Initial transform for aligning the fixed and moving image.  Maps positions in the fixed coordinate frame to positions in the moving coordinate frame. Optional.
+    FixedImageFileName:
+    # type=file|default=<undefined>: Fixed image to which to register
+    MovingImageFileName:
+    # type=file|default=<undefined>: Moving image
+    outputtransform:
+    # type=file: Transform calculated that aligns the fixed and moving image. Maps positions in the fixed coordinate frame to the moving coordinate frame. Optional (specify an output transform or an output volume or both).
+    # type=traitcompound|default=None: Transform calculated that aligns the fixed and moving image. Maps positions in the fixed coordinate frame to the moving coordinate frame. Optional (specify an output transform or an output volume or both).
+    resampledmovingfilename:
+    # type=file: Resampled moving image to the fixed image coordinate frame. Optional (specify an output transform or an output volume or both).
+    # type=traitcompound|default=None: Resampled moving image to the fixed image coordinate frame. Optional (specify an output transform or an output volume or both).
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/affine_registration_callables.py b/example-specs/task/nipype_internal/pydra-slicer/affine_registration_callables.py
new file mode 100644
index 00000000..0a078adc
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/affine_registration_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in AffineRegistration.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/b_spline_deformable_registration.yaml b/example-specs/task/nipype_internal/pydra-slicer/b_spline_deformable_registration.yaml
new file mode 100644
index 00000000..6fd1a9d9
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/b_spline_deformable_registration.yaml
@@ -0,0 +1,123 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.slicer.legacy.registration.BSplineDeformableRegistration' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: BSpline Deformable Registration
+# 
+#     category: Legacy.Registration
+# 
+#     description: Registers two images together using BSpline transform and mutual information.
+# 
+#     version: 0.1.0.$Revision: 19608 $(alpha)
+# 
+#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/BSplineDeformableRegistration
+# 
+#     contributor: Bill Lorensen (GE)
+# 
+#     acknowledgements: This work is part of the National Alliance for Medical Image Computing (NAMIC), funded by the National Institutes of Health through the NIH Roadmap for Medical Research, Grant U54 EB005149.
+#     
+task_name: BSplineDeformableRegistration
+nipype_name: BSplineDeformableRegistration
+nipype_module: nipype.interfaces.slicer.legacy.registration
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    initialtransform: generic/file
+    # type=file|default=<undefined>: Initial transform for aligning the fixed and moving image. Maps positions in the fixed coordinate frame to positions in the moving coordinate frame. This transform should be an affine or rigid transform.  It is used an a bulk transform for the BSpline. Optional.
+    FixedImageFileName: generic/file
+    # type=file|default=<undefined>: Fixed image to which to register
+    MovingImageFileName: generic/file
+    # type=file|default=<undefined>: Moving image
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputtransform: generic/file
+    # type=file: Transform calculated that aligns the fixed and moving image. Maps positions from the fixed coordinate frame to the moving coordinate frame. Optional (specify an output transform or an output volume or both).
+    # type=traitcompound|default=None: Transform calculated that aligns the fixed and moving image. Maps positions from the fixed coordinate frame to the moving coordinate frame. Optional (specify an output transform or an output volume or both).
+    outputwarp: generic/file
+    # type=file: Vector field that applies an equivalent warp as the BSpline. Maps positions from the fixed coordinate frame to the moving coordinate frame. Optional.
+    # type=traitcompound|default=None: Vector field that applies an equivalent warp as the BSpline. Maps positions from the fixed coordinate frame to the moving coordinate frame. Optional.
+    resampledmovingfilename: generic/file
+    # type=file: Resampled moving image to fixed image coordinate frame. Optional (specify an output transform or an output volume or both).
+    # type=traitcompound|default=None: Resampled moving image to fixed image coordinate frame. Optional (specify an output transform or an output volume or both).
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    iterations:
+    # type=int|default=0: Number of iterations
+    gridSize:
+    # type=int|default=0: Number of grid points on interior of the fixed image. Larger grid sizes allow for finer registrations.
+    histogrambins:
+    # type=int|default=0: Number of histogram bins to use for Mattes Mutual Information. Reduce the number of bins if a deformable registration fails. If the number of bins is too large, the estimated PDFs will be a field of impulses and will inhibit reliable registration estimation.
+    spatialsamples:
+    # type=int|default=0: Number of spatial samples to use in estimating Mattes Mutual Information. Larger values yield more accurate PDFs and improved registration quality.
+    constrain:
+    # type=bool|default=False: Constrain the deformation to the amount specified in Maximum Deformation
+    maximumDeformation:
+    # type=float|default=0.0: If Constrain Deformation is checked, limit the deformation to this amount.
+    default:
+    # type=int|default=0: Default pixel value used if resampling a pixel outside of the volume.
+    initialtransform:
+    # type=file|default=<undefined>: Initial transform for aligning the fixed and moving image. Maps positions in the fixed coordinate frame to positions in the moving coordinate frame. This transform should be an affine or rigid transform.  It is used an a bulk transform for the BSpline. Optional.
+    FixedImageFileName:
+    # type=file|default=<undefined>: Fixed image to which to register
+    MovingImageFileName:
+    # type=file|default=<undefined>: Moving image
+    outputtransform:
+    # type=file: Transform calculated that aligns the fixed and moving image. Maps positions from the fixed coordinate frame to the moving coordinate frame. Optional (specify an output transform or an output volume or both).
+    # type=traitcompound|default=None: Transform calculated that aligns the fixed and moving image. Maps positions from the fixed coordinate frame to the moving coordinate frame. Optional (specify an output transform or an output volume or both).
+    outputwarp:
+    # type=file: Vector field that applies an equivalent warp as the BSpline. Maps positions from the fixed coordinate frame to the moving coordinate frame. Optional.
+    # type=traitcompound|default=None: Vector field that applies an equivalent warp as the BSpline. Maps positions from the fixed coordinate frame to the moving coordinate frame. Optional.
+    resampledmovingfilename:
+    # type=file: Resampled moving image to fixed image coordinate frame. Optional (specify an output transform or an output volume or both).
+    # type=traitcompound|default=None: Resampled moving image to fixed image coordinate frame. Optional (specify an output transform or an output volume or both).
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/b_spline_deformable_registration_callables.py b/example-specs/task/nipype_internal/pydra-slicer/b_spline_deformable_registration_callables.py
new file mode 100644
index 00000000..dfb0e885
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/b_spline_deformable_registration_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in BSplineDeformableRegistration.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/b_spline_to_deformation_field.yaml b/example-specs/task/nipype_internal/pydra-slicer/b_spline_to_deformation_field.yaml
new file mode 100644
index 00000000..dae97fe0
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/b_spline_to_deformation_field.yaml
@@ -0,0 +1,93 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.slicer.legacy.converters.BSplineToDeformationField' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: BSpline to deformation field
+# 
+#     category: Legacy.Converters
+# 
+#     description: Create a dense deformation field from a bspline+bulk transform.
+# 
+#     version: 0.1.0.$Revision: 2104 $(alpha)
+# 
+#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/BSplineToDeformationField
+# 
+#     contributor: Andrey Fedorov (SPL, BWH)
+# 
+#     acknowledgements: This work is funded by NIH grants R01 CA111288 and U01 CA151261.
+#     
+task_name: BSplineToDeformationField
+nipype_name: BSplineToDeformationField
+nipype_module: nipype.interfaces.slicer.legacy.converters
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    tfm: generic/file
+    # type=file|default=<undefined>: 
+    refImage: generic/file
+    # type=file|default=<undefined>: 
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    defImage: generic/file
+    # type=file: 
+    # type=traitcompound|default=None: 
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    tfm:
+    # type=file|default=<undefined>: 
+    refImage:
+    # type=file|default=<undefined>: 
+    defImage:
+    # type=file: 
+    # type=traitcompound|default=None: 
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/b_spline_to_deformation_field_callables.py b/example-specs/task/nipype_internal/pydra-slicer/b_spline_to_deformation_field_callables.py
new file mode 100644
index 00000000..6d8d7269
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/b_spline_to_deformation_field_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in BSplineToDeformationField.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/brains_demon_warp.yaml b/example-specs/task/nipype_internal/pydra-slicer/brains_demon_warp.yaml
new file mode 100644
index 00000000..2eadc746
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/brains_demon_warp.yaml
@@ -0,0 +1,188 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.slicer.registration.specialized.BRAINSDemonWarp' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Demon Registration (BRAINS)
+# 
+#     category: Registration.Specialized
+# 
+#     description:
+#         This program finds a deformation field to warp a moving image onto a fixed image.  The images must be of the same signal kind, and contain an image of the same kind of object.  This program uses the Thirion Demons warp software in ITK, the Insight Toolkit.  Additional information is available at: http://www.nitrc.org/projects/brainsdemonwarp.
+# 
+# 
+# 
+#     version: 3.0.0
+# 
+#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Modules:BRAINSDemonWarp
+# 
+#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
+# 
+#     contributor: This tool was developed by Hans J. Johnson and Greg Harris.
+# 
+#     acknowledgements: The development of this tool was supported by funding from grants NS050568 and NS40068 from the National Institute of Neurological Disorders and Stroke and grants MH31593, MH40856, from the National Institute of Mental Health.
+#     
+task_name: BRAINSDemonWarp
+nipype_name: BRAINSDemonWarp
+nipype_module: nipype.interfaces.slicer.registration.specialized
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    movingVolume: generic/file
+    # type=file|default=<undefined>: Required: input moving image
+    fixedVolume: generic/file
+    # type=file|default=<undefined>: Required: input fixed (target) image
+    initializeWithDisplacementField: generic/file
+    # type=file|default=<undefined>: Initial deformation field vector image file name
+    initializeWithTransform: generic/file
+    # type=file|default=<undefined>: Initial Transform filename
+    fixedBinaryVolume: generic/file
+    # type=file|default=<undefined>: Mask filename for desired region of interest in the Fixed image.
+    movingBinaryVolume: generic/file
+    # type=file|default=<undefined>: Mask filename for desired region of interest in the Moving image.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputVolume: generic/file
+    # type=file: Required: output resampled moving image (will have the same physical space as the fixedVolume).
+    # type=traitcompound|default=None: Required: output resampled moving image (will have the same physical space as the fixedVolume).
+    outputDisplacementFieldVolume: generic/file
+    # type=file: Output deformation field vector image (will have the same physical space as the fixedVolume).
+    # type=traitcompound|default=None: Output deformation field vector image (will have the same physical space as the fixedVolume).
+    outputCheckerboardVolume: generic/file
+    # type=file: Genete a checkerboard image volume between the fixedVolume and the deformed movingVolume.
+    # type=traitcompound|default=None: Genete a checkerboard image volume between the fixedVolume and the deformed movingVolume.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    movingVolume:
+    # type=file|default=<undefined>: Required: input moving image
+    fixedVolume:
+    # type=file|default=<undefined>: Required: input fixed (target) image
+    inputPixelType:
+    # type=enum|default='float'|allowed['float','int','short','uchar','ushort']: Input volumes will be typecast to this format: float|short|ushort|int|uchar
+    outputVolume:
+    # type=file: Required: output resampled moving image (will have the same physical space as the fixedVolume).
+    # type=traitcompound|default=None: Required: output resampled moving image (will have the same physical space as the fixedVolume).
+    outputDisplacementFieldVolume:
+    # type=file: Output deformation field vector image (will have the same physical space as the fixedVolume).
+    # type=traitcompound|default=None: Output deformation field vector image (will have the same physical space as the fixedVolume).
+    outputPixelType:
+    # type=enum|default='float'|allowed['float','int','short','uchar','ushort']: outputVolume will be typecast to this format: float|short|ushort|int|uchar
+    interpolationMode:
+    # type=enum|default='NearestNeighbor'|allowed['BSpline','Blackman','Cosine','Hamming','Lanczos','Linear','NearestNeighbor','ResampleInPlace','Welch','WindowedSinc']: Type of interpolation to be used when applying transform to moving volume.  Options are Linear, ResampleInPlace, NearestNeighbor, BSpline, or WindowedSinc
+    registrationFilterType:
+    # type=enum|default='Demons'|allowed['Demons','Diffeomorphic','FastSymmetricForces']: Registration Filter Type: Demons|FastSymmetricForces|Diffeomorphic
+    smoothDisplacementFieldSigma:
+    # type=float|default=0.0: A gaussian smoothing value to be applied to the deformation field at each iteration.
+    numberOfPyramidLevels:
+    # type=int|default=0: Number of image pyramid levels to use in the multi-resolution registration.
+    minimumFixedPyramid:
+    # type=inputmultiobject|default=[]: The shrink factor for the first level of the fixed image pyramid. (i.e. start at 1/16 scale, then 1/8, then 1/4, then 1/2, and finally full scale)
+    minimumMovingPyramid:
+    # type=inputmultiobject|default=[]: The shrink factor for the first level of the moving image pyramid. (i.e. start at 1/16 scale, then 1/8, then 1/4, then 1/2, and finally full scale)
+    arrayOfPyramidLevelIterations:
+    # type=inputmultiobject|default=[]: The number of iterations for each pyramid level
+    histogramMatch:
+    # type=bool|default=False: Histogram Match the input images.  This is suitable for images of the same modality that may have different absolute scales, but the same overall intensity profile.
+    numberOfHistogramBins:
+    # type=int|default=0: The number of histogram levels
+    numberOfMatchPoints:
+    # type=int|default=0: The number of match points for histrogramMatch
+    medianFilterSize:
+    # type=inputmultiobject|default=[]: Median filter radius in all 3 directions.  When images have a lot of salt and pepper noise, this step can improve the registration.
+    initializeWithDisplacementField:
+    # type=file|default=<undefined>: Initial deformation field vector image file name
+    initializeWithTransform:
+    # type=file|default=<undefined>: Initial Transform filename
+    maskProcessingMode:
+    # type=enum|default='NOMASK'|allowed['BOBF','NOMASK','ROI','ROIAUTO']: What mode to use for using the masks: NOMASK|ROIAUTO|ROI|BOBF.  If ROIAUTO is chosen, then the mask is implicitly defined using a otsu foreground and hole filling algorithm. Where the Region Of Interest mode uses the masks to define what parts of the image should be used for computing the deformation field.  Brain Only Background Fill uses the masks to pre-process the input images by clipping and filling in the background with a predefined value.
+    fixedBinaryVolume:
+    # type=file|default=<undefined>: Mask filename for desired region of interest in the Fixed image.
+    movingBinaryVolume:
+    # type=file|default=<undefined>: Mask filename for desired region of interest in the Moving image.
+    lowerThresholdForBOBF:
+    # type=int|default=0: Lower threshold for performing BOBF
+    upperThresholdForBOBF:
+    # type=int|default=0: Upper threshold for performing BOBF
+    backgroundFillValue:
+    # type=int|default=0: Replacement value to overwrite background when performing BOBF
+    seedForBOBF:
+    # type=inputmultiobject|default=[]: coordinates in all 3 directions for Seed when performing BOBF
+    neighborhoodForBOBF:
+    # type=inputmultiobject|default=[]: neighborhood in all 3 directions to be included when performing BOBF
+    outputDisplacementFieldPrefix:
+    # type=str|default='': Displacement field filename prefix for writing separate x, y, and z component images
+    outputCheckerboardVolume:
+    # type=file: Genete a checkerboard image volume between the fixedVolume and the deformed movingVolume.
+    # type=traitcompound|default=None: Genete a checkerboard image volume between the fixedVolume and the deformed movingVolume.
+    checkerboardPatternSubdivisions:
+    # type=inputmultiobject|default=[]: Number of Checkerboard subdivisions in all 3 directions
+    outputNormalized:
+    # type=bool|default=False: Flag to warp and write the normalized images to output.  In normalized images the image values are fit-scaled to be between 0 and the maximum storage type value.
+    outputDebug:
+    # type=bool|default=False: Flag to write debugging images after each step.
+    gradient_type:
+    # type=enum|default='0'|allowed['0','1','2']: Type of gradient used for computing the demons force (0 is symmetrized, 1 is fixed image, 2 is moving image)
+    upFieldSmoothing:
+    # type=float|default=0.0: Smoothing sigma for the update field at each iteration
+    max_step_length:
+    # type=float|default=0.0: Maximum length of an update vector (0: no restriction)
+    use_vanilla_dem:
+    # type=bool|default=False: Run vanilla demons algorithm
+    gui:
+    # type=bool|default=False: Display intermediate image volumes for debugging
+    promptUser:
+    # type=bool|default=False: Prompt the user to hit enter each time an image is sent to the DebugImageViewer
+    numberOfBCHApproximationTerms:
+    # type=int|default=0: Number of terms in the BCH expansion
+    numberOfThreads:
+    # type=int|default=0: Explicitly specify the maximum number of threads to use.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/brains_demon_warp_callables.py b/example-specs/task/nipype_internal/pydra-slicer/brains_demon_warp_callables.py
new file mode 100644
index 00000000..bb153f9f
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/brains_demon_warp_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in BRAINSDemonWarp.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/brains_fit.yaml b/example-specs/task/nipype_internal/pydra-slicer/brains_fit.yaml
new file mode 100644
index 00000000..34dd9c06
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/brains_fit.yaml
@@ -0,0 +1,241 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.slicer.registration.brainsfit.BRAINSFit' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: General Registration (BRAINS)
+# 
+#     category: Registration
+# 
+#     description: Register a three-dimensional volume to a reference volume (Mattes Mutual Information by default). Described in BRAINSFit: Mutual Information Registrations of Whole-Brain 3D Images, Using the Insight Toolkit, Johnson H.J., Harris G., Williams K., The Insight Journal, 2007. http://hdl.handle.net/1926/1291
+# 
+#     version: 3.0.0
+# 
+#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Modules:BRAINSFit
+# 
+#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
+# 
+#     contributor: Hans J. Johnson, hans-johnson -at- uiowa.edu, http://wwww.psychiatry.uiowa.edu
+# 
+#     acknowledgements: Hans Johnson(1,3,4); Kent Williams(1); Gregory Harris(1), Vincent Magnotta(1,2,3);  Andriy Fedorov(5) 1=University of Iowa Department of Psychiatry, 2=University of Iowa Department of Radiology, 3=University of Iowa Department of Biomedical Engineering, 4=University of Iowa Department of Electrical and Computer Engineering, 5=Surgical Planning Lab, Harvard
+#     
+task_name: BRAINSFit
+nipype_name: BRAINSFit
+nipype_module: nipype.interfaces.slicer.registration.brainsfit
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    fixedVolume: generic/file
+    # type=file|default=<undefined>: The fixed image for registration by mutual information optimization.
+    movingVolume: generic/file
+    # type=file|default=<undefined>: The moving image for registration by mutual information optimization.
+    initialTransform: generic/file
+    # type=file|default=<undefined>: Filename of transform used to initialize the registration.  This CAN NOT be used with either CenterOfHeadLAlign, MomentsAlign, GeometryAlign, or initialTransform file.
+    fixedBinaryVolume: generic/file
+    # type=file|default=<undefined>: Fixed Image binary mask volume, ONLY FOR MANUAL ROI mode.
+    movingBinaryVolume: generic/file
+    # type=file|default=<undefined>: Moving Image binary mask volume, ONLY FOR MANUAL ROI mode.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    bsplineTransform: generic/file
+    # type=file: (optional) Filename to which save the estimated transform. NOTE: You must set at least one output object (either a deformed image or a transform.  NOTE: USE THIS ONLY IF THE FINAL TRANSFORM IS BSpline
+    # type=traitcompound|default=None: (optional) Filename to which save the estimated transform. NOTE: You must set at least one output object (either a deformed image or a transform.  NOTE: USE THIS ONLY IF THE FINAL TRANSFORM IS BSpline
+    linearTransform: generic/file
+    # type=file: (optional) Filename to which save the estimated transform. NOTE: You must set at least one output object (either a deformed image or a transform.  NOTE: USE THIS ONLY IF THE FINAL TRANSFORM IS ---NOT--- BSpline
+    # type=traitcompound|default=None: (optional) Filename to which save the estimated transform. NOTE: You must set at least one output object (either a deformed image or a transform.  NOTE: USE THIS ONLY IF THE FINAL TRANSFORM IS ---NOT--- BSpline
+    outputVolume: generic/file
+    # type=file: (optional) Output image for registration. NOTE: You must select either the outputTransform or the outputVolume option.
+    # type=traitcompound|default=None: (optional) Output image for registration. NOTE: You must select either the outputTransform or the outputVolume option.
+    outputFixedVolumeROI: generic/file
+    # type=file: The ROI automatically found in fixed image, ONLY FOR ROIAUTO mode.
+    # type=traitcompound|default=None: The ROI automatically found in fixed image, ONLY FOR ROIAUTO mode.
+    outputMovingVolumeROI: generic/file
+    # type=file: The ROI automatically found in moving image, ONLY FOR ROIAUTO mode.
+    # type=traitcompound|default=None: The ROI automatically found in moving image, ONLY FOR ROIAUTO mode.
+    strippedOutputTransform: generic/file
+    # type=file: File name for the rigid component of the estimated affine transform. Can be used to rigidly register the moving image to the fixed image. NOTE:  This value is overwritten if either bsplineTransform or linearTransform is set.
+    # type=traitcompound|default=None: File name for the rigid component of the estimated affine transform. Can be used to rigidly register the moving image to the fixed image. NOTE:  This value is overwritten if either bsplineTransform or linearTransform is set.
+    outputTransform: generic/file
+    # type=file: (optional) Filename to which save the (optional) estimated transform. NOTE: You must select either the outputTransform or the outputVolume option.
+    # type=traitcompound|default=None: (optional) Filename to which save the (optional) estimated transform. NOTE: You must select either the outputTransform or the outputVolume option.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    fixedVolume:
+    # type=file|default=<undefined>: The fixed image for registration by mutual information optimization.
+    movingVolume:
+    # type=file|default=<undefined>: The moving image for registration by mutual information optimization.
+    bsplineTransform:
+    # type=file: (optional) Filename to which save the estimated transform. NOTE: You must set at least one output object (either a deformed image or a transform.  NOTE: USE THIS ONLY IF THE FINAL TRANSFORM IS BSpline
+    # type=traitcompound|default=None: (optional) Filename to which save the estimated transform. NOTE: You must set at least one output object (either a deformed image or a transform.  NOTE: USE THIS ONLY IF THE FINAL TRANSFORM IS BSpline
+    linearTransform:
+    # type=file: (optional) Filename to which save the estimated transform. NOTE: You must set at least one output object (either a deformed image or a transform.  NOTE: USE THIS ONLY IF THE FINAL TRANSFORM IS ---NOT--- BSpline
+    # type=traitcompound|default=None: (optional) Filename to which save the estimated transform. NOTE: You must set at least one output object (either a deformed image or a transform.  NOTE: USE THIS ONLY IF THE FINAL TRANSFORM IS ---NOT--- BSpline
+    outputVolume:
+    # type=file: (optional) Output image for registration. NOTE: You must select either the outputTransform or the outputVolume option.
+    # type=traitcompound|default=None: (optional) Output image for registration. NOTE: You must select either the outputTransform or the outputVolume option.
+    initialTransform:
+    # type=file|default=<undefined>: Filename of transform used to initialize the registration.  This CAN NOT be used with either CenterOfHeadLAlign, MomentsAlign, GeometryAlign, or initialTransform file.
+    initializeTransformMode:
+    # type=enum|default='Off'|allowed['Off','useCenterOfHeadAlign','useCenterOfROIAlign','useGeometryAlign','useMomentsAlign']: Determine how to initialize the transform center.  GeometryAlign on assumes that the center of the voxel lattice of the images represent similar structures.  MomentsAlign assumes that the center of mass of the images represent similar structures.  useCenterOfHeadAlign attempts to use the top of head and shape of neck to drive a center of mass estimate.  Off assumes that the physical space of the images are close, and that centering in terms of the image Origins is a good starting point.  This flag is mutually exclusive with the initialTransform flag.
+    useRigid:
+    # type=bool|default=False: Perform a rigid registration as part of the sequential registration steps.  This family of options superceeds the use of transformType if any of them are set.
+    useScaleVersor3D:
+    # type=bool|default=False: Perform a ScaleVersor3D registration as part of the sequential registration steps.  This family of options superceeds the use of transformType if any of them are set.
+    useScaleSkewVersor3D:
+    # type=bool|default=False: Perform a ScaleSkewVersor3D registration as part of the sequential registration steps.  This family of options superceeds the use of transformType if any of them are set.
+    useAffine:
+    # type=bool|default=False: Perform an Affine registration as part of the sequential registration steps.  This family of options superceeds the use of transformType if any of them are set.
+    useBSpline:
+    # type=bool|default=False: Perform a BSpline registration as part of the sequential registration steps.  This family of options superceeds the use of transformType if any of them are set.
+    numberOfSamples:
+    # type=int|default=0: The number of voxels sampled for mutual information computation.  Increase this for a slower, more careful fit.  You can also limit the sampling focus with ROI masks and ROIAUTO mask generation.
+    splineGridSize:
+    # type=inputmultiobject|default=[]: The number of subdivisions of the BSpline Grid to be centered on the image space.  Each dimension must have at least 3 subdivisions for the BSpline to be correctly computed. 
+    numberOfIterations:
+    # type=inputmultiobject|default=[]: The maximum number of iterations to try before failing to converge.  Use an explicit limit like 500 or 1000 to manage risk of divergence
+    maskProcessingMode:
+    # type=enum|default='NOMASK'|allowed['NOMASK','ROI','ROIAUTO']: What mode to use for using the masks.  If ROIAUTO is chosen, then the mask is implicitly defined using a otsu foreground and hole filling algorithm. The Region Of Interest mode (choose ROI) uses the masks to define what parts of the image should be used for computing the transform.
+    fixedBinaryVolume:
+    # type=file|default=<undefined>: Fixed Image binary mask volume, ONLY FOR MANUAL ROI mode.
+    movingBinaryVolume:
+    # type=file|default=<undefined>: Moving Image binary mask volume, ONLY FOR MANUAL ROI mode.
+    outputFixedVolumeROI:
+    # type=file: The ROI automatically found in fixed image, ONLY FOR ROIAUTO mode.
+    # type=traitcompound|default=None: The ROI automatically found in fixed image, ONLY FOR ROIAUTO mode.
+    outputMovingVolumeROI:
+    # type=file: The ROI automatically found in moving image, ONLY FOR ROIAUTO mode.
+    # type=traitcompound|default=None: The ROI automatically found in moving image, ONLY FOR ROIAUTO mode.
+    outputVolumePixelType:
+    # type=enum|default='float'|allowed['float','int','short','uchar','uint','ushort']: The output image Pixel Type is the scalar datatype for representation of the Output Volume.
+    backgroundFillValue:
+    # type=float|default=0.0: Background fill value for output image.
+    maskInferiorCutOffFromCenter:
+    # type=float|default=0.0: For use with --useCenterOfHeadAlign (and --maskProcessingMode ROIAUTO): the cut-off below the image centers, in millimeters, 
+    scaleOutputValues:
+    # type=bool|default=False: If true, and the voxel values do not fit within the minimum and maximum values of the desired outputVolumePixelType, then linearly scale the min/max output image voxel values to fit within the min/max range of the outputVolumePixelType.
+    interpolationMode:
+    # type=enum|default='NearestNeighbor'|allowed['BSpline','Blackman','Cosine','Hamming','Lanczos','Linear','NearestNeighbor','ResampleInPlace','Welch','WindowedSinc']: Type of interpolation to be used when applying transform to moving volume.  Options are Linear, NearestNeighbor, BSpline, WindowedSinc, or ResampleInPlace.  The ResampleInPlace option will create an image with the same discrete voxel values and will adjust the origin and direction of the physical space interpretation.
+    minimumStepLength:
+    # type=inputmultiobject|default=[]: Each step in the optimization takes steps at least this big.  When none are possible, registration is complete.
+    translationScale:
+    # type=float|default=0.0: How much to scale up changes in position compared to unit rotational changes in radians -- decrease this to put more rotation in the search pattern.
+    reproportionScale:
+    # type=float|default=0.0: ScaleVersor3D 'Scale' compensation factor.  Increase this to put more rescaling in a ScaleVersor3D or ScaleSkewVersor3D search pattern.  1.0 works well with a translationScale of 1000.0
+    skewScale:
+    # type=float|default=0.0: ScaleSkewVersor3D Skew compensation factor.  Increase this to put more skew in a ScaleSkewVersor3D search pattern.  1.0 works well with a translationScale of 1000.0
+    maxBSplineDisplacement:
+    # type=float|default=0.0:  Sets the maximum allowed displacements in image physical coordinates for BSpline control grid along each axis.  A value of 0.0 indicates that the problem should be unbounded.  NOTE:  This only constrains the BSpline portion, and does not limit the displacement from the associated bulk transform.  This can lead to a substantial reduction in computation time in the BSpline optimizer.,       
+    histogramMatch:
+    # type=bool|default=False: Histogram Match the input images.  This is suitable for images of the same modality that may have different absolute scales, but the same overall intensity profile. Do NOT use if registering images from different modailties.
+    numberOfHistogramBins:
+    # type=int|default=0: The number of histogram levels
+    numberOfMatchPoints:
+    # type=int|default=0: the number of match points
+    strippedOutputTransform:
+    # type=file: File name for the rigid component of the estimated affine transform. Can be used to rigidly register the moving image to the fixed image. NOTE:  This value is overwritten if either bsplineTransform or linearTransform is set.
+    # type=traitcompound|default=None: File name for the rigid component of the estimated affine transform. Can be used to rigidly register the moving image to the fixed image. NOTE:  This value is overwritten if either bsplineTransform or linearTransform is set.
+    transformType:
+    # type=inputmultiobject|default=[]: Specifies a list of registration types to be used.  The valid types are, Rigid, ScaleVersor3D, ScaleSkewVersor3D, Affine, and BSpline.  Specifying more than one in a comma separated list will initialize the next stage with the previous results. If registrationClass flag is used, it overrides this parameter setting.
+    outputTransform:
+    # type=file: (optional) Filename to which save the (optional) estimated transform. NOTE: You must select either the outputTransform or the outputVolume option.
+    # type=traitcompound|default=None: (optional) Filename to which save the (optional) estimated transform. NOTE: You must select either the outputTransform or the outputVolume option.
+    fixedVolumeTimeIndex:
+    # type=int|default=0: The index in the time series for the 3D fixed image to fit, if 4-dimensional.
+    movingVolumeTimeIndex:
+    # type=int|default=0: The index in the time series for the 3D moving image to fit, if 4-dimensional.
+    medianFilterSize:
+    # type=inputmultiobject|default=[]: The radius for the optional MedianImageFilter preprocessing in all 3 directions.
+    removeIntensityOutliers:
+    # type=float|default=0.0: The half percentage to decide outliers of image intensities. The default value is zero, which means no outlier removal. If the value of 0.005 is given, the module will throw away 0.005 % of both tails, so 0.01% of intensities in total would be ignored in its statistic calculation. 
+    useCachingOfBSplineWeightsMode:
+    # type=enum|default='ON'|allowed['OFF','ON']: This is a 5x speed advantage at the expense of requiring much more memory.  Only relevant when transformType is BSpline.
+    useExplicitPDFDerivativesMode:
+    # type=enum|default='AUTO'|allowed['AUTO','OFF','ON']: Using mode AUTO means OFF for BSplineDeformableTransforms and ON for the linear transforms.  The ON alternative uses more memory to sometimes do a better job.
+    ROIAutoDilateSize:
+    # type=float|default=0.0: This flag is only relevant when using ROIAUTO mode for initializing masks.  It defines the final dilation size to capture a bit of background outside the tissue region.  At setting of 10mm has been shown to help regularize a BSpline registration type so that there is some background constraints to match the edges of the head better.
+    ROIAutoClosingSize:
+    # type=float|default=0.0: This flag is only relevant when using ROIAUTO mode for initializing masks.  It defines the hole closing size in mm.  It is rounded up to the nearest whole pixel size in each direction. The default is to use a closing size of 9mm.  For mouse data this value may need to be reset to 0.9 or smaller.
+    relaxationFactor:
+    # type=float|default=0.0: Internal debugging parameter, and should probably never be used from the command line.  This will be removed in the future.
+    maximumStepLength:
+    # type=float|default=0.0: Internal debugging parameter, and should probably never be used from the command line.  This will be removed in the future.
+    failureExitCode:
+    # type=int|default=0: If the fit fails, exit with this status code.  (It can be used to force a successfult exit status of (0) if the registration fails due to reaching the maximum number of iterations.
+    writeTransformOnFailure:
+    # type=bool|default=False: Flag to save the final transform even if the numberOfIterations are reached without convergence. (Intended for use when --failureExitCode 0 )
+    numberOfThreads:
+    # type=int|default=0: Explicitly specify the maximum number of threads to use. (default is auto-detected)
+    forceMINumberOfThreads:
+    # type=int|default=0: Force the maximum number of threads to use for non thread safe MI metric.  CAUTION: Inconsistent results my arise!
+    debugLevel:
+    # type=int|default=0: Display debug messages, and produce debug intermediate results.  0=OFF, 1=Minimal, 10=Maximum debugging.
+    costFunctionConvergenceFactor:
+    # type=float|default=0.0:  From itkLBFGSBOptimizer.h: Set/Get the CostFunctionConvergenceFactor. Algorithm terminates when the reduction in cost function is less than (factor * epsmcj) where epsmch is the machine precision. Typical values for factor: 1e+12 for low accuracy; 1e+7 for moderate accuracy and 1e+1 for extremely high accuracy.  1e+9 seems to work well.,       
+    projectedGradientTolerance:
+    # type=float|default=0.0:  From itkLBFGSBOptimizer.h: Set/Get the ProjectedGradientTolerance. Algorithm terminates when the project gradient is below the tolerance. Default lbfgsb value is 1e-5, but 1e-4 seems to work well.,       
+    gui:
+    # type=bool|default=False: Display intermediate image volumes for debugging.  NOTE:  This is not part of the standard build system, and probably does nothing on your installation.
+    promptUser:
+    # type=bool|default=False: Prompt the user to hit enter each time an image is sent to the DebugImageViewer
+    NEVER_USE_THIS_FLAG_IT_IS_OUTDATED_00:
+    # type=bool|default=False: DO NOT USE THIS FLAG
+    NEVER_USE_THIS_FLAG_IT_IS_OUTDATED_01:
+    # type=bool|default=False: DO NOT USE THIS FLAG
+    NEVER_USE_THIS_FLAG_IT_IS_OUTDATED_02:
+    # type=bool|default=False: DO NOT USE THIS FLAG
+    permitParameterVariation:
+    # type=inputmultiobject|default=[]: A bit vector to permit linear transform parameters to vary under optimization.  The vector order corresponds with transform parameters, and beyond the end ones fill in as a default.  For instance, you can choose to rotate only in x (pitch) with 1,0,0;  this is mostly for expert use in turning on and off individual degrees of freedom in rotation, translation or scaling without multiplying the number of transform representations; this trick is probably meaningless when tried with the general affine transform.
+    costMetric:
+    # type=enum|default='MMI'|allowed['MC','MMI','MSE','NC']: The cost metric to be used during fitting. Defaults to MMI. Options are MMI (Mattes Mutual Information), MSE (Mean Square Error), NC (Normalized Correlation), MC (Match Cardinality for binary images)
+    writeOutputTransformInFloat:
+    # type=bool|default=False: By default, the output registration transforms (either the output composite transform or each transform component) are written to the disk in double precision. If this flag is ON, the output transforms will be written in single (float) precision. It is especially important if the output transform is a displacement field transform, or it is a composite transform that includes several displacement fields.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/brains_fit_callables.py b/example-specs/task/nipype_internal/pydra-slicer/brains_fit_callables.py
new file mode 100644
index 00000000..324aacce
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/brains_fit_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in BRAINSFit.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/brains_resample.yaml b/example-specs/task/nipype_internal/pydra-slicer/brains_resample.yaml
new file mode 100644
index 00000000..8a2e30d6
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/brains_resample.yaml
@@ -0,0 +1,117 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.slicer.registration.brainsresample.BRAINSResample' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Resample Image (BRAINS)
+# 
+#     category: Registration
+# 
+#     description:
+#        This program resamples an image using a deformation field or a transform (BSpline, Affine, Rigid, etc.).
+# 
+# 
+#     version: 3.0.0
+# 
+#     documentation-url: http://www.slicer.org/slicerWiki/index.php/Modules:BRAINSResample
+# 
+#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
+# 
+#     contributor: This tool was developed by Vincent Magnotta, Greg Harris, and Hans Johnson.
+# 
+#     acknowledgements: The development of this tool was supported by funding from grants NS050568 and NS40068 from the National Institute of Neurological Disorders and Stroke and grants MH31593, MH40856, from the National Institute of Mental Health.
+#     
+task_name: BRAINSResample
+nipype_name: BRAINSResample
+nipype_module: nipype.interfaces.slicer.registration.brainsresample
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputVolume: generic/file
+    # type=file|default=<undefined>: Image To Warp
+    referenceVolume: generic/file
+    # type=file|default=<undefined>: Reference image used only to define the output space. If not specified, the warping is done in the same space as the image to warp.
+    deformationVolume: generic/file
+    # type=file|default=<undefined>: Displacement Field to be used to warp the image
+    warpTransform: generic/file
+    # type=file|default=<undefined>: Filename for the BRAINSFit transform used in place of the deformation field
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputVolume: generic/file
+    # type=file: Resulting deformed image
+    # type=traitcompound|default=None: Resulting deformed image
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputVolume:
+    # type=file|default=<undefined>: Image To Warp
+    referenceVolume:
+    # type=file|default=<undefined>: Reference image used only to define the output space. If not specified, the warping is done in the same space as the image to warp.
+    outputVolume:
+    # type=file: Resulting deformed image
+    # type=traitcompound|default=None: Resulting deformed image
+    pixelType:
+    # type=enum|default='float'|allowed['binary','float','int','short','uchar','uint','ushort']: Specifies the pixel type for the input/output images.  The 'binary' pixel type uses a modified algorithm whereby the image is read in as unsigned char, a signed distance map is created, signed distance map is resampled, and then a thresholded image of type unsigned char is written to disk.
+    deformationVolume:
+    # type=file|default=<undefined>: Displacement Field to be used to warp the image
+    warpTransform:
+    # type=file|default=<undefined>: Filename for the BRAINSFit transform used in place of the deformation field
+    interpolationMode:
+    # type=enum|default='NearestNeighbor'|allowed['BSpline','Blackman','Cosine','Hamming','Lanczos','Linear','NearestNeighbor','ResampleInPlace','Welch','WindowedSinc']: Type of interpolation to be used when applying transform to moving volume.  Options are Linear, ResampleInPlace, NearestNeighbor, BSpline, or WindowedSinc
+    inverseTransform:
+    # type=bool|default=False: True/False is to compute inverse of given transformation. Default is false
+    defaultValue:
+    # type=float|default=0.0: Default voxel value
+    gridSpacing:
+    # type=inputmultiobject|default=[]: Add warped grid to output image to help show the deformation that occurred with specified spacing.   A spacing of 0 in a dimension indicates that grid lines should be rendered to fall exactly (i.e. do not allow displacements off that plane).  This is useful for making a 2D image of grid lines from the 3D space 
+    numberOfThreads:
+    # type=int|default=0: Explicitly specify the maximum number of threads to use.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/brains_resample_callables.py b/example-specs/task/nipype_internal/pydra-slicer/brains_resample_callables.py
new file mode 100644
index 00000000..e8e4b158
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/brains_resample_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in BRAINSResample.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/brainsroi_auto.yaml b/example-specs/task/nipype_internal/pydra-slicer/brainsroi_auto.yaml
new file mode 100644
index 00000000..51a42f79
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/brainsroi_auto.yaml
@@ -0,0 +1,108 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.slicer.segmentation.specialized.BRAINSROIAuto' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Foreground masking (BRAINS)
+# 
+#     category: Segmentation.Specialized
+# 
+#     description: This tool uses a combination of otsu thresholding and a closing operations to identify the most prominent foreground region in an image.
+# 
+# 
+#     version: 2.4.1
+# 
+#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
+# 
+#     contributor: Hans J. Johnson, hans-johnson -at- uiowa.edu, http://wwww.psychiatry.uiowa.edu
+# 
+#     acknowledgements: Hans Johnson(1,3,4); Kent Williams(1); Gregory Harris(1), Vincent Magnotta(1,2,3);  Andriy Fedorov(5), fedorov -at- bwh.harvard.edu (Slicer integration); (1=University of Iowa Department of Psychiatry, 2=University of Iowa Department of Radiology, 3=University of Iowa Department of Biomedical Engineering, 4=University of Iowa Department of Electrical and Computer Engineering, 5=Surgical Planning Lab, Harvard)
+#     
+task_name: BRAINSROIAuto
+nipype_name: BRAINSROIAuto
+nipype_module: nipype.interfaces.slicer.segmentation.specialized
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputVolume: generic/file
+    # type=file|default=<undefined>: The input image for finding the largest region filled mask.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputROIMaskVolume: generic/file
+    # type=file: The ROI automatically found from the input image.
+    # type=traitcompound|default=None: The ROI automatically found from the input image.
+    outputClippedVolumeROI: generic/file
+    # type=file: The inputVolume clipped to the region of the brain mask.
+    # type=traitcompound|default=None: The inputVolume clipped to the region of the brain mask.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputVolume:
+    # type=file|default=<undefined>: The input image for finding the largest region filled mask.
+    outputROIMaskVolume:
+    # type=file: The ROI automatically found from the input image.
+    # type=traitcompound|default=None: The ROI automatically found from the input image.
+    outputClippedVolumeROI:
+    # type=file: The inputVolume clipped to the region of the brain mask.
+    # type=traitcompound|default=None: The inputVolume clipped to the region of the brain mask.
+    otsuPercentileThreshold:
+    # type=float|default=0.0: Parameter to the Otsu threshold algorithm.
+    thresholdCorrectionFactor:
+    # type=float|default=0.0: A factor to scale the Otsu algorithm's result threshold, in case clipping mangles the image.
+    closingSize:
+    # type=float|default=0.0: The Closing Size (in millimeters) for largest connected filled mask.  This value is divided by image spacing and rounded to the next largest voxel number.
+    ROIAutoDilateSize:
+    # type=float|default=0.0: This flag is only relevant when using ROIAUTO mode for initializing masks.  It defines the final dilation size to capture a bit of background outside the tissue region.  At setting of 10mm has been shown to help regularize a BSpline registration type so that there is some background constraints to match the edges of the head better.
+    outputVolumePixelType:
+    # type=enum|default='float'|allowed['float','int','short','uchar','uint','ushort']: The output image Pixel Type is the scalar datatype for representation of the Output Volume.
+    numberOfThreads:
+    # type=int|default=0: Explicitly specify the maximum number of threads to use.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/brainsroi_auto_callables.py b/example-specs/task/nipype_internal/pydra-slicer/brainsroi_auto_callables.py
new file mode 100644
index 00000000..421d7dbf
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/brainsroi_auto_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in BRAINSROIAuto.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/cast_scalar_volume.yaml b/example-specs/task/nipype_internal/pydra-slicer/cast_scalar_volume.yaml
new file mode 100644
index 00000000..9bab0561
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/cast_scalar_volume.yaml
@@ -0,0 +1,93 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.slicer.filtering.arithmetic.CastScalarVolume' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Cast Scalar Volume
+# 
+#     category: Filtering.Arithmetic
+# 
+#     description: Cast a volume to a given data type.
+#     Use at your own risk when casting an input volume into a lower precision type!
+#     Allows casting to the same type as the input volume.
+# 
+#     version: 0.1.0.$Revision: 2104 $(alpha)
+# 
+#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/Cast
+# 
+#     contributor: Nicole Aucoin (SPL, BWH), Ron Kikinis (SPL, BWH)
+# 
+#     acknowledgements: This work is part of the National Alliance for Medical Image Computing (NAMIC), funded by the National Institutes of Health through the NIH Roadmap for Medical Research, Grant U54 EB005149.
+#     
+task_name: CastScalarVolume
+nipype_name: CastScalarVolume
+nipype_module: nipype.interfaces.slicer.filtering.arithmetic
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    InputVolume: generic/file
+    # type=file|default=<undefined>: Input volume, the volume to cast.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    OutputVolume: generic/file
+    # type=file: Output volume, cast to the new type.
+    # type=traitcompound|default=None: Output volume, cast to the new type.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    InputVolume:
+    # type=file|default=<undefined>: Input volume, the volume to cast.
+    OutputVolume:
+    # type=file: Output volume, cast to the new type.
+    # type=traitcompound|default=None: Output volume, cast to the new type.
+    type:
+    # type=enum|default='Char'|allowed['Char','Double','Float','Int','Short','UnsignedChar','UnsignedInt','UnsignedShort']: Type for the new output volume.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/cast_scalar_volume_callables.py b/example-specs/task/nipype_internal/pydra-slicer/cast_scalar_volume_callables.py
new file mode 100644
index 00000000..1c82ce5b
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/cast_scalar_volume_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in CastScalarVolume.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/checker_board_filter.yaml b/example-specs/task/nipype_internal/pydra-slicer/checker_board_filter.yaml
new file mode 100644
index 00000000..8792cf30
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/checker_board_filter.yaml
@@ -0,0 +1,95 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.slicer.filtering.checkerboardfilter.CheckerBoardFilter' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: CheckerBoard Filter
+# 
+#     category: Filtering
+# 
+#     description: Create a checkerboard volume of two volumes. The output volume will show the two inputs alternating according to the user supplied checkerPattern. This filter is often used to compare the results of image registration. Note that the second input is resampled to the same origin, spacing and direction before it is composed with the first input. The scalar type of the output volume will be the same as the input image scalar type.
+# 
+#     version: 0.1.0.$Revision: 19608 $(alpha)
+# 
+#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/CheckerBoard
+# 
+#     contributor: Bill Lorensen (GE)
+# 
+#     acknowledgements: This work is part of the National Alliance for Medical Image Computing (NAMIC), funded by the National Institutes of Health through the NIH Roadmap for Medical Research, Grant U54 EB005149.
+#     
+task_name: CheckerBoardFilter
+nipype_name: CheckerBoardFilter
+nipype_module: nipype.interfaces.slicer.filtering.checkerboardfilter
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputVolume1: generic/file
+    # type=file|default=<undefined>: First Input volume
+    inputVolume2: generic/file
+    # type=file|default=<undefined>: Second Input volume
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputVolume: generic/file
+    # type=file: Output filtered
+    # type=traitcompound|default=None: Output filtered
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    checkerPattern:
+    # type=inputmultiobject|default=[]: The pattern of input 1 and input 2 in the output image. The user can specify the number of checkers in each dimension. A checkerPattern of 2,2,1 means that images will alternate in every other checker in the first two dimensions. The same pattern will be used in the 3rd dimension.
+    inputVolume1:
+    # type=file|default=<undefined>: First Input volume
+    inputVolume2:
+    # type=file|default=<undefined>: Second Input volume
+    outputVolume:
+    # type=file: Output filtered
+    # type=traitcompound|default=None: Output filtered
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/checker_board_filter_callables.py b/example-specs/task/nipype_internal/pydra-slicer/checker_board_filter_callables.py
new file mode 100644
index 00000000..d278515f
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/checker_board_filter_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in CheckerBoardFilter.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/curvature_anisotropic_diffusion.yaml b/example-specs/task/nipype_internal/pydra-slicer/curvature_anisotropic_diffusion.yaml
new file mode 100644
index 00000000..46e9a8f4
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/curvature_anisotropic_diffusion.yaml
@@ -0,0 +1,99 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.slicer.filtering.denoising.CurvatureAnisotropicDiffusion' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Curvature Anisotropic Diffusion
+# 
+#     category: Filtering.Denoising
+# 
+#     description: Performs anisotropic diffusion on an image using a modified curvature diffusion equation (MCDE).
+# 
+#     MCDE does not exhibit the edge enhancing properties of classic anisotropic diffusion, which can under certain conditions undergo a 'negative' diffusion, which enhances the contrast of edges.  Equations of the form of MCDE always undergo positive diffusion, with the conductance term only varying the strength of that diffusion.
+# 
+#      Qualitatively, MCDE compares well with other non-linear diffusion techniques.  It is less sensitive to contrast than classic Perona-Malik style diffusion, and preserves finer detailed structures in images.  There is a potential speed trade-off for using this function in place of Gradient Anisotropic Diffusion.  Each iteration of the solution takes roughly twice as long.  Fewer iterations, however, may be required to reach an acceptable solution.
+# 
+#     version: 0.1.0.$Revision: 19608 $(alpha)
+# 
+#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/CurvatureAnisotropicDiffusion
+# 
+#     contributor: Bill Lorensen (GE)
+# 
+#     acknowledgements: This command module was derived from Insight/Examples (copyright) Insight Software Consortium
+#     
+task_name: CurvatureAnisotropicDiffusion
+nipype_name: CurvatureAnisotropicDiffusion
+nipype_module: nipype.interfaces.slicer.filtering.denoising
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputVolume: generic/file
+    # type=file|default=<undefined>: Input volume to be filtered
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputVolume: generic/file
+    # type=file: Output filtered
+    # type=traitcompound|default=None: Output filtered
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    conductance:
+    # type=float|default=0.0: Conductance controls the sensitivity of the conductance term. As a general rule, the lower the value, the more strongly the filter preserves edges. A high value will cause diffusion (smoothing) across edges. Note that the number of iterations controls how much smoothing is done within regions bounded by edges.
+    iterations:
+    # type=int|default=0: The more iterations, the more smoothing. Each iteration takes the same amount of time. If it takes 10 seconds for one iteration, then it will take 100 seconds for 10 iterations. Note that the conductance controls how much each iteration smooths across edges.
+    timeStep:
+    # type=float|default=0.0: The time step depends on the dimensionality of the image. In Slicer the images are 3D and the default (.0625) time step will provide a stable solution.
+    inputVolume:
+    # type=file|default=<undefined>: Input volume to be filtered
+    outputVolume:
+    # type=file: Output filtered
+    # type=traitcompound|default=None: Output filtered
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/curvature_anisotropic_diffusion_callables.py b/example-specs/task/nipype_internal/pydra-slicer/curvature_anisotropic_diffusion_callables.py
new file mode 100644
index 00000000..20e56194
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/curvature_anisotropic_diffusion_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in CurvatureAnisotropicDiffusion.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/dicom_to_nrrd_converter.yaml b/example-specs/task/nipype_internal/pydra-slicer/dicom_to_nrrd_converter.yaml
new file mode 100644
index 00000000..c52c6072
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/dicom_to_nrrd_converter.yaml
@@ -0,0 +1,101 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.slicer.converters.DicomToNrrdConverter' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: DICOM to NRRD Converter
+# 
+#     category: Converters
+# 
+#     description: Converts diffusion weighted MR images in dicom series into Nrrd format for analysis in Slicer. This program has been tested on only a limited subset of DTI dicom formats available from Siemens, GE, and Phillips scanners. Work in progress to support dicom multi-frame data. The program parses dicom header to extract necessary information about measurement frame, diffusion weighting directions, b-values, etc, and write out a nrrd image. For non-diffusion weighted dicom images, it loads in an entire dicom series and writes out a single dicom volume in a .nhdr/.raw pair.
+# 
+#     version: 0.2.0.$Revision: 916 $(alpha)
+# 
+#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/DicomToNrrdConverter
+# 
+#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
+# 
+#     contributor: Xiaodong Tao (GE), Vince Magnotta (UIowa), Hans Johnson (UIowa)
+# 
+#     acknowledgements: This work is part of the National Alliance for Medical Image Computing (NAMIC), funded by the National Institutes of Health through the NIH Roadmap for Medical Research, Grant U54 EB005149.  Additional support for DTI data produced on Philips scanners was contributed by Vincent Magnotta and Hans Johnson at the University of Iowa.
+#     
+task_name: DicomToNrrdConverter
+nipype_name: DicomToNrrdConverter
+nipype_module: nipype.interfaces.slicer.converters
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputDicomDirectory: generic/directory
+    # type=directory|default=<undefined>: Directory holding Dicom series
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputDirectory: generic/directory
+    # type=directory: Directory holding the output NRRD format
+    # type=traitcompound|default=None: Directory holding the output NRRD format
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputDicomDirectory:
+    # type=directory|default=<undefined>: Directory holding Dicom series
+    outputDirectory:
+    # type=directory: Directory holding the output NRRD format
+    # type=traitcompound|default=None: Directory holding the output NRRD format
+    outputVolume:
+    # type=str|default='': Output filename (.nhdr or .nrrd)
+    smallGradientThreshold:
+    # type=float|default=0.0: If a gradient magnitude is greater than 0 and less than smallGradientThreshold, then DicomToNrrdConverter will display an error message and quit, unless the useBMatrixGradientDirections option is set.
+    writeProtocolGradientsFile:
+    # type=bool|default=False: Write the protocol gradients to a file suffixed by '.txt' as they were specified in the procol by multiplying each diffusion gradient direction by the measurement frame.  This file is for debugging purposes only, the format is not fixed, and will likely change as debugging of new dicom formats is necessary.
+    useIdentityMeaseurementFrame:
+    # type=bool|default=False: Adjust all the gradients so that the measurement frame is an identity matrix.
+    useBMatrixGradientDirections:
+    # type=bool|default=False: Fill the nhdr header with the gradient directions and bvalues computed out of the BMatrix. Only changes behavior for Siemens data.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/dicom_to_nrrd_converter_callables.py b/example-specs/task/nipype_internal/pydra-slicer/dicom_to_nrrd_converter_callables.py
new file mode 100644
index 00000000..e8c37aa6
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/dicom_to_nrrd_converter_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in DicomToNrrdConverter.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/diffusion_tensor_scalar_measurements.yaml b/example-specs/task/nipype_internal/pydra-slicer/diffusion_tensor_scalar_measurements.yaml
new file mode 100644
index 00000000..8572a0c9
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/diffusion_tensor_scalar_measurements.yaml
@@ -0,0 +1,91 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.slicer.diffusion.diffusion.DiffusionTensorScalarMeasurements' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Diffusion Tensor Scalar Measurements
+# 
+#     category: Diffusion.Diffusion Tensor Images
+# 
+#     description: Compute a set of different scalar measurements from a tensor field, specially oriented for Diffusion Tensors where some rotationally invariant measurements, like Fractional Anisotropy, are highly used to describe the anistropic behaviour of the tensor.
+# 
+#     version: 0.1.0.$Revision: 1892 $(alpha)
+# 
+#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/DiffusionTensorMathematics
+# 
+#     contributor: Raul San Jose (SPL, BWH)
+# 
+#     acknowledgements: LMI
+#     
+task_name: DiffusionTensorScalarMeasurements
+nipype_name: DiffusionTensorScalarMeasurements
+nipype_module: nipype.interfaces.slicer.diffusion.diffusion
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputVolume: generic/file
+    # type=file|default=<undefined>: Input DTI volume
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputScalar: generic/file
+    # type=file: Scalar volume derived from tensor
+    # type=traitcompound|default=None: Scalar volume derived from tensor
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputVolume:
+    # type=file|default=<undefined>: Input DTI volume
+    outputScalar:
+    # type=file: Scalar volume derived from tensor
+    # type=traitcompound|default=None: Scalar volume derived from tensor
+    enumeration:
+    # type=enum|default='Trace'|allowed['D11','D22','D33','Determinant','FractionalAnisotropy','LinearMeasure','MaxEigenvalue','MaxEigenvalueProjectionX','MaxEigenvalueProjectionY','MaxEigenvalueProjectionZ','MaxEigenvecX','MaxEigenvecY','MaxEigenvecZ','MidEigenvalue','MinEigenvalue','Mode','ParallelDiffusivity','PerpendicularDffusivity','PlanarMeasure','RAIMaxEigenvecX','RAIMaxEigenvecY','RAIMaxEigenvecZ','RelativeAnisotropy','SphericalMeasure','Trace']: An enumeration of strings
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/diffusion_tensor_scalar_measurements_callables.py b/example-specs/task/nipype_internal/pydra-slicer/diffusion_tensor_scalar_measurements_callables.py
new file mode 100644
index 00000000..4b63eb64
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/diffusion_tensor_scalar_measurements_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in DiffusionTensorScalarMeasurements.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/diffusion_weighted_volume_masking.yaml b/example-specs/task/nipype_internal/pydra-slicer/diffusion_weighted_volume_masking.yaml
new file mode 100644
index 00000000..63ccc379
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/diffusion_weighted_volume_masking.yaml
@@ -0,0 +1,99 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.slicer.diffusion.diffusion.DiffusionWeightedVolumeMasking' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Diffusion Weighted Volume Masking
+# 
+#     category: Diffusion.Diffusion Weighted Images
+# 
+#     description: <p>Performs a mask calculation from a diffusion weighted (DW) image.</p><p>Starting from a dw image, this module computes the baseline image averaging all the images without diffusion weighting and then applies the otsu segmentation algorithm in order to produce a mask. this mask can then be used when estimating the diffusion tensor (dt) image, not to estimate tensors all over the volume.</p>
+# 
+#     version: 0.1.0.$Revision: 1892 $(alpha)
+# 
+#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/DiffusionWeightedMasking
+# 
+#     license: slicer3
+# 
+#     contributor: Demian Wassermann (SPL, BWH)
+#     
+task_name: DiffusionWeightedVolumeMasking
+nipype_name: DiffusionWeightedVolumeMasking
+nipype_module: nipype.interfaces.slicer.diffusion.diffusion
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputVolume: generic/file
+    # type=file|default=<undefined>: Input DWI volume
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputBaseline: generic/file
+    # type=file: Estimated baseline volume
+    # type=traitcompound|default=None: Estimated baseline volume
+    thresholdMask: generic/file
+    # type=file: Otsu Threshold Mask
+    # type=traitcompound|default=None: Otsu Threshold Mask
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputVolume:
+    # type=file|default=<undefined>: Input DWI volume
+    outputBaseline:
+    # type=file: Estimated baseline volume
+    # type=traitcompound|default=None: Estimated baseline volume
+    thresholdMask:
+    # type=file: Otsu Threshold Mask
+    # type=traitcompound|default=None: Otsu Threshold Mask
+    otsuomegathreshold:
+    # type=float|default=0.0: Control the sharpness of the threshold in the Otsu computation. 0: lower threshold, 1: higher threshold
+    removeislands:
+    # type=bool|default=False: Remove Islands in Threshold Mask?
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/diffusion_weighted_volume_masking_callables.py b/example-specs/task/nipype_internal/pydra-slicer/diffusion_weighted_volume_masking_callables.py
new file mode 100644
index 00000000..91ba9b9a
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/diffusion_weighted_volume_masking_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in DiffusionWeightedVolumeMasking.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/dt_iexport.yaml b/example-specs/task/nipype_internal/pydra-slicer/dt_iexport.yaml
new file mode 100644
index 00000000..dbcdd98d
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/dt_iexport.yaml
@@ -0,0 +1,89 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.slicer.diffusion.diffusion.DTIexport' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: DTIexport
+# 
+#     category: Diffusion.Diffusion Data Conversion
+# 
+#     description: Export DTI data to various file formats
+# 
+#     version: 1.0
+# 
+#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/DTIExport
+# 
+#     contributor: Sonia Pujol (SPL, BWH)
+# 
+#     acknowledgements: This work is part of the National Alliance for Medical Image Computing (NA-MIC), funded by the National Institutes of Health through the NIH Roadmap for Medical Research, Grant U54 EB005149.
+#     
+task_name: DTIexport
+nipype_name: DTIexport
+nipype_module: nipype.interfaces.slicer.diffusion.diffusion
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputTensor: generic/file
+    # type=file|default=<undefined>: Input DTI volume
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputFile: generic/file
+    # type=file: Output DTI file
+    # type=traitcompound|default=None: Output DTI file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputTensor:
+    # type=file|default=<undefined>: Input DTI volume
+    outputFile:
+    # type=file: Output DTI file
+    # type=traitcompound|default=None: Output DTI file
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/dt_iexport_callables.py b/example-specs/task/nipype_internal/pydra-slicer/dt_iexport_callables.py
new file mode 100644
index 00000000..c631491c
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/dt_iexport_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in DTIexport.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/dt_iimport.yaml b/example-specs/task/nipype_internal/pydra-slicer/dt_iimport.yaml
new file mode 100644
index 00000000..423a1ed1
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/dt_iimport.yaml
@@ -0,0 +1,91 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.slicer.diffusion.diffusion.DTIimport' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: DTIimport
+# 
+#     category: Diffusion.Diffusion Data Conversion
+# 
+#     description: Import tensor datasets from various formats, including the NifTi file format
+# 
+#     version: 1.0
+# 
+#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/DTIImport
+# 
+#     contributor: Sonia Pujol (SPL, BWH)
+# 
+#     acknowledgements: This work is part of the National Alliance for Medical Image Computing (NA-MIC), funded by the National Institutes of Health through the NIH Roadmap for Medical Research, Grant U54 EB005149.
+#     
+task_name: DTIimport
+nipype_name: DTIimport
+nipype_module: nipype.interfaces.slicer.diffusion.diffusion
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputFile: generic/file
+    # type=file|default=<undefined>: Input DTI file
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputTensor: generic/file
+    # type=file: Output DTI volume
+    # type=traitcompound|default=None: Output DTI volume
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputFile:
+    # type=file|default=<undefined>: Input DTI file
+    outputTensor:
+    # type=file: Output DTI volume
+    # type=traitcompound|default=None: Output DTI volume
+    testingmode:
+    # type=bool|default=False: Enable testing mode. Sample helix file (helix-DTI.nhdr) will be loaded into Slicer and converted in Nifti.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/dt_iimport_callables.py b/example-specs/task/nipype_internal/pydra-slicer/dt_iimport_callables.py
new file mode 100644
index 00000000..a808a812
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/dt_iimport_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in DTIimport.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/dwi_joint_rician_lmmse_filter.yaml b/example-specs/task/nipype_internal/pydra-slicer/dwi_joint_rician_lmmse_filter.yaml
new file mode 100644
index 00000000..4bedb33e
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/dwi_joint_rician_lmmse_filter.yaml
@@ -0,0 +1,100 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.slicer.diffusion.diffusion.DWIJointRicianLMMSEFilter' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: DWI Joint Rician LMMSE Filter
+# 
+#     category: Diffusion.Diffusion Weighted Images
+# 
+#     description: This module reduces Rician noise (or unwanted detail) on a set of diffusion weighted images. For this, it filters the image in the mean squared error sense using a Rician noise model. The N closest gradient directions to the direction being processed are filtered together to improve the results: the noise-free signal is seen as an n-diemensional vector which has to be estimated with the LMMSE method from a set of corrupted measurements. To that end, the covariance matrix of the noise-free vector and the cross covariance between this signal and the noise have to be estimated, which is done taking into account the image formation process.
+#     The noise parameter is automatically estimated from a rough segmentation of the background of the image. In this area the signal is simply 0, so that Rician statistics reduce to Rayleigh and the noise power can be easily estimated from the mode of the histogram.
+#     A complete description of the algorithm may be found in:
+#     Antonio Tristan-Vega and Santiago Aja-Fernandez, DWI filtering using joint information for DTI and HARDI, Medical Image Analysis, Volume 14, Issue 2, Pages 205-218. 2010.
+# 
+#     version: 0.1.1.$Revision: 1 $(alpha)
+# 
+#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/JointRicianLMMSEImageFilter
+# 
+#     contributor: Antonio Tristan Vega (UVa), Santiago Aja Fernandez (UVa)
+# 
+#     acknowledgements: Partially founded by grant number TEC2007-67073/TCM from the Comision Interministerial de Ciencia y Tecnologia (Spain).
+#     
+task_name: DWIJointRicianLMMSEFilter
+nipype_name: DWIJointRicianLMMSEFilter
+nipype_module: nipype.interfaces.slicer.diffusion.diffusion
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputVolume: generic/file
+    # type=file|default=<undefined>: Input DWI volume.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputVolume: generic/file
+    # type=file: Output DWI volume.
+    # type=traitcompound|default=None: Output DWI volume.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    re:
+    # type=inputmultiobject|default=[]: Estimation radius.
+    rf:
+    # type=inputmultiobject|default=[]: Filtering radius.
+    ng:
+    # type=int|default=0: The number of the closest gradients that are used to jointly filter a given gradient direction (0 to use all).
+    inputVolume:
+    # type=file|default=<undefined>: Input DWI volume.
+    outputVolume:
+    # type=file: Output DWI volume.
+    # type=traitcompound|default=None: Output DWI volume.
+    compressOutput:
+    # type=bool|default=False: Compress the data of the compressed file using gzip
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/dwi_joint_rician_lmmse_filter_callables.py b/example-specs/task/nipype_internal/pydra-slicer/dwi_joint_rician_lmmse_filter_callables.py
new file mode 100644
index 00000000..4917d0c4
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/dwi_joint_rician_lmmse_filter_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in DWIJointRicianLMMSEFilter.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/dwi_rician_lmmse_filter.yaml b/example-specs/task/nipype_internal/pydra-slicer/dwi_rician_lmmse_filter.yaml
new file mode 100644
index 00000000..4464e08a
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/dwi_rician_lmmse_filter.yaml
@@ -0,0 +1,112 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.slicer.diffusion.diffusion.DWIRicianLMMSEFilter' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: DWI Rician LMMSE Filter
+# 
+#     category: Diffusion.Diffusion Weighted Images
+# 
+#     description: This module reduces noise (or unwanted detail) on a set of diffusion weighted images. For this, it filters the image in the mean squared error sense using a Rician noise model. Images corresponding to each gradient direction, including baseline, are processed individually. The noise parameter is automatically estimated (noise estimation improved but slower).
+#     Note that this is a general purpose filter for MRi images. The module jointLMMSE has been specifically designed for DWI volumes and shows a better performance, so its use is recommended instead.
+#     A complete description of the algorithm in this module can be found in:
+#     S. Aja-Fernandez, M. Niethammer, M. Kubicki, M. Shenton, and C.-F. Westin. Restoration of DWI data using a Rician LMMSE estimator. IEEE Transactions on Medical Imaging, 27(10): pp. 1389-1403, Oct. 2008.
+# 
+#     version: 0.1.1.$Revision: 1 $(alpha)
+# 
+#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/RicianLMMSEImageFilter
+# 
+#     contributor: Antonio Tristan Vega (UVa), Santiago Aja Fernandez (UVa), Marc Niethammer (UNC)
+# 
+#     acknowledgements: Partially founded by grant number TEC2007-67073/TCM from the Comision Interministerial de Ciencia y Tecnologia (Spain).
+#     
+task_name: DWIRicianLMMSEFilter
+nipype_name: DWIRicianLMMSEFilter
+nipype_module: nipype.interfaces.slicer.diffusion.diffusion
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputVolume: generic/file
+    # type=file|default=<undefined>: Input DWI volume.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputVolume: generic/file
+    # type=file: Output DWI volume.
+    # type=traitcompound|default=None: Output DWI volume.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    iter:
+    # type=int|default=0: Number of iterations for the noise removal filter.
+    re:
+    # type=inputmultiobject|default=[]: Estimation radius.
+    rf:
+    # type=inputmultiobject|default=[]: Filtering radius.
+    mnvf:
+    # type=int|default=0: Minimum number of voxels in kernel used for filtering.
+    mnve:
+    # type=int|default=0: Minimum number of voxels in kernel used for estimation.
+    minnstd:
+    # type=int|default=0: Minimum allowed noise standard deviation.
+    maxnstd:
+    # type=int|default=0: Maximum allowed noise standard deviation.
+    hrf:
+    # type=float|default=0.0: How many histogram bins per unit interval.
+    uav:
+    # type=bool|default=False: Use absolute value in case of negative square.
+    inputVolume:
+    # type=file|default=<undefined>: Input DWI volume.
+    outputVolume:
+    # type=file: Output DWI volume.
+    # type=traitcompound|default=None: Output DWI volume.
+    compressOutput:
+    # type=bool|default=False: Compress the data of the compressed file using gzip
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/dwi_rician_lmmse_filter_callables.py b/example-specs/task/nipype_internal/pydra-slicer/dwi_rician_lmmse_filter_callables.py
new file mode 100644
index 00000000..71aa8698
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/dwi_rician_lmmse_filter_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in DWIRicianLMMSEFilter.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/dwi_to_dti_estimation.yaml b/example-specs/task/nipype_internal/pydra-slicer/dwi_to_dti_estimation.yaml
new file mode 100644
index 00000000..a214c9c3
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/dwi_to_dti_estimation.yaml
@@ -0,0 +1,107 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.slicer.diffusion.diffusion.DWIToDTIEstimation' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: DWI to DTI Estimation
+# 
+#     category: Diffusion.Diffusion Weighted Images
+# 
+#     description: Performs a tensor model estimation from diffusion weighted images.
+# 
+#     There are three estimation methods available: least squares, weighted least squares and non-linear estimation. The first method is the traditional method for tensor estimation and the fastest one. Weighted least squares takes into account the noise characteristics of the MRI images to weight the DWI samples used in the estimation based on its intensity magnitude. The last method is the more complex.
+# 
+#     version: 0.1.0.$Revision: 1892 $(alpha)
+# 
+#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/DiffusionTensorEstimation
+# 
+#     license: slicer3
+# 
+#     contributor: Raul San Jose (SPL, BWH)
+# 
+#     acknowledgements: This command module is based on the estimation functionality provided by the Teem library. This work is part of the National Alliance for Medical Image Computing (NAMIC), funded by the National Institutes of Health through the NIH Roadmap for Medical Research, Grant U54 EB005149.
+#     
+task_name: DWIToDTIEstimation
+nipype_name: DWIToDTIEstimation
+nipype_module: nipype.interfaces.slicer.diffusion.diffusion
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputVolume: generic/file
+    # type=file|default=<undefined>: Input DWI volume
+    mask: generic/file
+    # type=file|default=<undefined>: Mask where the tensors will be computed
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputTensor: generic/file
+    # type=file: Estimated DTI volume
+    # type=traitcompound|default=None: Estimated DTI volume
+    outputBaseline: generic/file
+    # type=file: Estimated baseline volume
+    # type=traitcompound|default=None: Estimated baseline volume
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputVolume:
+    # type=file|default=<undefined>: Input DWI volume
+    mask:
+    # type=file|default=<undefined>: Mask where the tensors will be computed
+    outputTensor:
+    # type=file: Estimated DTI volume
+    # type=traitcompound|default=None: Estimated DTI volume
+    outputBaseline:
+    # type=file: Estimated baseline volume
+    # type=traitcompound|default=None: Estimated baseline volume
+    enumeration:
+    # type=enum|default='LS'|allowed['LS','WLS']: LS: Least Squares, WLS: Weighted Least Squares
+    shiftNeg:
+    # type=bool|default=False: Shift eigenvalues so all are positive (accounts for bad tensors related to noise or acquisition error)
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/dwi_to_dti_estimation_callables.py b/example-specs/task/nipype_internal/pydra-slicer/dwi_to_dti_estimation_callables.py
new file mode 100644
index 00000000..cfd9dc1b
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/dwi_to_dti_estimation_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in DWIToDTIEstimation.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/dwi_unbiased_non_local_means_filter.yaml b/example-specs/task/nipype_internal/pydra-slicer/dwi_unbiased_non_local_means_filter.yaml
new file mode 100644
index 00000000..795d0a48
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/dwi_unbiased_non_local_means_filter.yaml
@@ -0,0 +1,103 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.slicer.legacy.diffusion.denoising.DWIUnbiasedNonLocalMeansFilter' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: DWI Unbiased Non Local Means Filter
+# 
+#     category: Legacy.Diffusion.Denoising
+# 
+#     description: This module reduces noise (or unwanted detail) on a set of diffusion weighted images. For this, it filters the images using a Unbiased Non Local Means for Rician noise algorithm. It exploits not only the spatial redundancy, but the redundancy in similar gradient directions as well; it takes into account the N closest gradient directions to the direction being processed (a maximum of 5 gradient directions is allowed to keep a reasonable computational load, since we do not use neither similarity maps nor block-wise implementation).
+#     The noise parameter is automatically estimated in the same way as in the jointLMMSE module.
+#     A complete description of the algorithm may be found in:
+#     Antonio Tristan-Vega and Santiago Aja-Fernandez, DWI filtering using joint information for DTI and HARDI, Medical Image Analysis, Volume 14, Issue 2, Pages 205-218. 2010.
+#     Please, note that the execution of this filter is extremely slow, son only very conservative parameters (block size and search size as small as possible) should be used. Even so, its execution may take several hours. The advantage of this filter over joint LMMSE is its better preservation of edges and fine structures.
+# 
+#     version: 0.0.1.$Revision: 1 $(alpha)
+# 
+#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/UnbiasedNonLocalMeansFilterForDWI
+# 
+#     contributor: Antonio Tristan Vega (UVa), Santiago Aja Fernandez (UVa)
+# 
+#     acknowledgements: Partially founded by grant number TEC2007-67073/TCM from the Comision Interministerial de Ciencia y Tecnologia (Spain).
+#     
+task_name: DWIUnbiasedNonLocalMeansFilter
+nipype_name: DWIUnbiasedNonLocalMeansFilter
+nipype_module: nipype.interfaces.slicer.legacy.diffusion.denoising
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputVolume: generic/file
+    # type=file|default=<undefined>: Input DWI volume.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputVolume: generic/file
+    # type=file: Output DWI volume.
+    # type=traitcompound|default=None: Output DWI volume.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    rs:
+    # type=inputmultiobject|default=[]: The algorithm search for similar voxels in a neighborhood of this size (larger sizes than the default one are extremely slow).
+    rc:
+    # type=inputmultiobject|default=[]: Similarity between blocks is measured using windows of this size.
+    hp:
+    # type=float|default=0.0: This parameter is related to noise; the larger the parameter, the more aggressive the filtering. Should be near 1, and only values between 0.8 and 1.2 are allowed
+    ng:
+    # type=int|default=0: The number of the closest gradients that are used to jointly filter a given gradient direction (a maximum of 5 is allowed).
+    re:
+    # type=inputmultiobject|default=[]: A neighborhood of this size is used to compute the statistics for noise estimation.
+    inputVolume:
+    # type=file|default=<undefined>: Input DWI volume.
+    outputVolume:
+    # type=file: Output DWI volume.
+    # type=traitcompound|default=None: Output DWI volume.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/dwi_unbiased_non_local_means_filter_callables.py b/example-specs/task/nipype_internal/pydra-slicer/dwi_unbiased_non_local_means_filter_callables.py
new file mode 100644
index 00000000..941eb97c
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/dwi_unbiased_non_local_means_filter_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in DWIUnbiasedNonLocalMeansFilter.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/em_segment_command_line.yaml b/example-specs/task/nipype_internal/pydra-slicer/em_segment_command_line.yaml
new file mode 100644
index 00000000..7c3f0d48
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/em_segment_command_line.yaml
@@ -0,0 +1,148 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.slicer.segmentation.specialized.EMSegmentCommandLine' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title:
+#       EMSegment Command-line
+# 
+# 
+#     category:
+#       Segmentation.Specialized
+# 
+# 
+#     description:
+#       This module is used to simplify the process of segmenting large collections of images by providing a command line interface to the EMSegment algorithm for script and batch processing.
+# 
+# 
+#     documentation-url: http://www.slicer.org/slicerWiki/index.php/Documentation/4.0/EMSegment_Command-line
+# 
+#     contributor: Sebastien Barre, Brad Davis, Kilian Pohl, Polina Golland, Yumin Yuan, Daniel Haehn
+# 
+#     acknowledgements: Many people and organizations have contributed to the funding, design, and development of the EMSegment algorithm and its various implementations.
+# 
+#     
+task_name: EMSegmentCommandLine
+nipype_name: EMSegmentCommandLine
+nipype_module: nipype.interfaces.slicer.segmentation.specialized
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    mrmlSceneFileName: generic/file
+    # type=file|default=<undefined>: Active MRML scene that contains EMSegment algorithm parameters.
+    targetVolumeFileNames: generic/file+list-of
+    # type=inputmultiobject|default=[]: File names of target volumes (to be segmented).  The number of target images must be equal to the number of target images specified in the parameter set, and these images must be spatially aligned.
+    resultStandardVolumeFileName: generic/file
+    # type=file|default=<undefined>: Used for testing.  Compare segmentation results to this image and return EXIT_FAILURE if they do not match.
+    atlasVolumeFileNames: generic/file+list-of
+    # type=inputmultiobject|default=[]: Use an alternative atlas to the one that is specified by the mrml file - note the order matters ! 
+    intermediateResultsDirectory: generic/directory
+    # type=directory|default=<undefined>: Directory where EMSegmenter will write intermediate data (e.g., aligned atlas data).
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    resultVolumeFileName: generic/file
+    # type=file: The file name that the segmentation result volume will be written to.
+    # type=traitcompound|default=None: The file name that the segmentation result volume will be written to.
+    generateEmptyMRMLSceneAndQuit: generic/file
+    # type=file: Used for testing.  Only write a scene with default mrml parameters.
+    # type=traitcompound|default=None: Used for testing.  Only write a scene with default mrml parameters.
+    resultMRMLSceneFileName: generic/file
+    # type=file: Write out the MRML scene after command line substitutions have been made.
+    # type=traitcompound|default=None: Write out the MRML scene after command line substitutions have been made.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    mrmlSceneFileName:
+    # type=file|default=<undefined>: Active MRML scene that contains EMSegment algorithm parameters.
+    resultVolumeFileName:
+    # type=file: The file name that the segmentation result volume will be written to.
+    # type=traitcompound|default=None: The file name that the segmentation result volume will be written to.
+    targetVolumeFileNames:
+    # type=inputmultiobject|default=[]: File names of target volumes (to be segmented).  The number of target images must be equal to the number of target images specified in the parameter set, and these images must be spatially aligned.
+    intermediateResultsDirectory:
+    # type=directory|default=<undefined>: Directory where EMSegmenter will write intermediate data (e.g., aligned atlas data).
+    parametersMRMLNodeName:
+    # type=str|default='': The name of the EMSegment parameters node within the active MRML scene.  Leave blank for default.
+    disableMultithreading:
+    # type=int|default=0: Disable multithreading for the EMSegmenter algorithm only! Preprocessing might still run in multi-threaded mode. -1: Do not overwrite default value. 0: Disable. 1: Enable.
+    dontUpdateIntermediateData:
+    # type=int|default=0: Disable update of intermediate results.  -1: Do not overwrite default value. 0: Disable. 1: Enable.
+    verbose:
+    # type=bool|default=False: Enable verbose output.
+    loadTargetCentered:
+    # type=bool|default=False: Read target files centered.
+    loadAtlasNonCentered:
+    # type=bool|default=False: Read atlas files non-centered.
+    taskPreProcessingSetting:
+    # type=str|default='': Specifies the different task parameter. Leave blank for default.
+    keepTempFiles:
+    # type=bool|default=False: If flag is set then at the end of command the temporary files are not removed
+    resultStandardVolumeFileName:
+    # type=file|default=<undefined>: Used for testing.  Compare segmentation results to this image and return EXIT_FAILURE if they do not match.
+    dontWriteResults:
+    # type=bool|default=False: Used for testing.  Don't actually write the resulting labelmap to disk.
+    generateEmptyMRMLSceneAndQuit:
+    # type=file: Used for testing.  Only write a scene with default mrml parameters.
+    # type=traitcompound|default=None: Used for testing.  Only write a scene with default mrml parameters.
+    resultMRMLSceneFileName:
+    # type=file: Write out the MRML scene after command line substitutions have been made.
+    # type=traitcompound|default=None: Write out the MRML scene after command line substitutions have been made.
+    disableCompression:
+    # type=bool|default=False: Don't use compression when writing result image to disk.
+    atlasVolumeFileNames:
+    # type=inputmultiobject|default=[]: Use an alternative atlas to the one that is specified by the mrml file - note the order matters ! 
+    registrationPackage:
+    # type=str|default='': specify the registration package for preprocessing (CMTK or BRAINS or PLASTIMATCH or DEMONS)
+    registrationAffineType:
+    # type=int|default=0: specify the accuracy of the affine registration. -2: Do not overwrite default, -1: Test, 0: Disable, 1: Fast, 2: Accurate
+    registrationDeformableType:
+    # type=int|default=0: specify the accuracy of the deformable registration. -2: Do not overwrite default, -1: Test, 0: Disable, 1: Fast, 2: Accurate
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/em_segment_command_line_callables.py b/example-specs/task/nipype_internal/pydra-slicer/em_segment_command_line_callables.py
new file mode 100644
index 00000000..f1e2f079
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/em_segment_command_line_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in EMSegmentCommandLine.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/em_segment_transform_to_new_format.yaml b/example-specs/task/nipype_internal/pydra-slicer/em_segment_transform_to_new_format.yaml
new file mode 100644
index 00000000..ab28ba10
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/em_segment_transform_to_new_format.yaml
@@ -0,0 +1,89 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.slicer.utilities.EMSegmentTransformToNewFormat' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title:
+#       Transform MRML Files to New EMSegmenter Standard
+# 
+# 
+#     category:
+#       Utilities
+# 
+# 
+#     description:
+#       Transform MRML Files to New EMSegmenter Standard
+# 
+#     
+task_name: EMSegmentTransformToNewFormat
+nipype_name: EMSegmentTransformToNewFormat
+nipype_module: nipype.interfaces.slicer.utilities
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputMRMLFileName: generic/file
+    # type=file|default=<undefined>: Active MRML scene that contains EMSegment algorithm parameters in the format before 3.6.3 - please include absolute  file name in path.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputMRMLFileName: generic/file
+    # type=file: Write out the MRML scene after transformation to format 3.6.3 has been made. - has to be in the same directory as the input MRML file due to Slicer Core bug  - please include absolute  file name in path 
+    # type=traitcompound|default=None: Write out the MRML scene after transformation to format 3.6.3 has been made. - has to be in the same directory as the input MRML file due to Slicer Core bug  - please include absolute  file name in path 
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputMRMLFileName:
+    # type=file|default=<undefined>: Active MRML scene that contains EMSegment algorithm parameters in the format before 3.6.3 - please include absolute  file name in path.
+    outputMRMLFileName:
+    # type=file: Write out the MRML scene after transformation to format 3.6.3 has been made. - has to be in the same directory as the input MRML file due to Slicer Core bug  - please include absolute  file name in path 
+    # type=traitcompound|default=None: Write out the MRML scene after transformation to format 3.6.3 has been made. - has to be in the same directory as the input MRML file due to Slicer Core bug  - please include absolute  file name in path 
+    templateFlag:
+    # type=bool|default=False: Set to true if the transformed mrml file should be used as template file 
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/em_segment_transform_to_new_format_callables.py b/example-specs/task/nipype_internal/pydra-slicer/em_segment_transform_to_new_format_callables.py
new file mode 100644
index 00000000..c3492774
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/em_segment_transform_to_new_format_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in EMSegmentTransformToNewFormat.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/expert_automated_registration.yaml b/example-specs/task/nipype_internal/pydra-slicer/expert_automated_registration.yaml
new file mode 100644
index 00000000..aa857857
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/expert_automated_registration.yaml
@@ -0,0 +1,151 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.slicer.legacy.registration.ExpertAutomatedRegistration' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Expert Automated Registration
+# 
+#     category: Legacy.Registration
+# 
+#     description: Provides rigid, affine, and BSpline registration methods via a simple GUI
+# 
+#     version: 0.1.0.$Revision: 2104 $(alpha)
+# 
+#     documentation-url: http://www.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/ExpertAutomatedRegistration
+# 
+#     contributor: Stephen R Aylward (Kitware), Casey B Goodlett (Kitware)
+# 
+#     acknowledgements: This work is part of the National Alliance for Medical Image Computing (NAMIC), funded by the National Institutes of Health through the NIH Roadmap for Medical Research, Grant U54 EB005149.
+#     
+task_name: ExpertAutomatedRegistration
+nipype_name: ExpertAutomatedRegistration
+nipype_module: nipype.interfaces.slicer.legacy.registration
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    fixedImage: generic/file
+    # type=file|default=<undefined>: Image which defines the space into which the moving image is registered
+    movingImage: generic/file
+    # type=file|default=<undefined>: The transform goes from the fixed image's space into the moving image's space
+    loadTransform: generic/file
+    # type=file|default=<undefined>: Load a transform that is immediately applied to the moving image
+    fixedImageMask: generic/file
+    # type=file|default=<undefined>: Image which defines a mask for the fixed image
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    resampledImage: generic/file
+    # type=file: Registration results
+    # type=traitcompound|default=None: Registration results
+    saveTransform: generic/file
+    # type=file: Save the transform that results from registration
+    # type=traitcompound|default=None: Save the transform that results from registration
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    fixedImage:
+    # type=file|default=<undefined>: Image which defines the space into which the moving image is registered
+    movingImage:
+    # type=file|default=<undefined>: The transform goes from the fixed image's space into the moving image's space
+    resampledImage:
+    # type=file: Registration results
+    # type=traitcompound|default=None: Registration results
+    loadTransform:
+    # type=file|default=<undefined>: Load a transform that is immediately applied to the moving image
+    saveTransform:
+    # type=file: Save the transform that results from registration
+    # type=traitcompound|default=None: Save the transform that results from registration
+    initialization:
+    # type=enum|default='None'|allowed['CentersOfMass','ImageCenters','Landmarks','None','SecondMoments']: Method to prime the registration process
+    registration:
+    # type=enum|default='None'|allowed['Affine','BSpline','Initial','None','PipelineAffine','PipelineBSpline','PipelineRigid','Rigid']: Method for the registration process
+    metric:
+    # type=enum|default='MattesMI'|allowed['MattesMI','MeanSqrd','NormCorr']: Method to quantify image match
+    expectedOffset:
+    # type=float|default=0.0: Expected misalignment after initialization
+    expectedRotation:
+    # type=float|default=0.0: Expected misalignment after initialization
+    expectedScale:
+    # type=float|default=0.0: Expected misalignment after initialization
+    expectedSkew:
+    # type=float|default=0.0: Expected misalignment after initialization
+    verbosityLevel:
+    # type=enum|default='Silent'|allowed['Silent','Standard','Verbose']: Level of detail of reporting progress
+    sampleFromOverlap:
+    # type=bool|default=False: Limit metric evaluation to the fixed image region overlapped by the moving image
+    fixedImageMask:
+    # type=file|default=<undefined>: Image which defines a mask for the fixed image
+    randomNumberSeed:
+    # type=int|default=0: Seed to generate a consistent random number sequence
+    numberOfThreads:
+    # type=int|default=0: Number of CPU threads to use
+    minimizeMemory:
+    # type=bool|default=False: Reduce the amount of memory required at the cost of increased computation time
+    interpolation:
+    # type=enum|default='NearestNeighbor'|allowed['BSpline','Linear','NearestNeighbor']: Method for interpolation within the optimization process
+    fixedLandmarks:
+    # type=inputmultiobject|default=[]: Ordered list of landmarks in the fixed image
+    movingLandmarks:
+    # type=inputmultiobject|default=[]: Ordered list of landmarks in the moving image
+    rigidMaxIterations:
+    # type=int|default=0: Maximum number of rigid optimization iterations
+    rigidSamplingRatio:
+    # type=float|default=0.0: Portion of the image to use in computing the metric during rigid registration
+    affineMaxIterations:
+    # type=int|default=0: Maximum number of affine optimization iterations
+    affineSamplingRatio:
+    # type=float|default=0.0: Portion of the image to use in computing the metric during affine registration
+    bsplineMaxIterations:
+    # type=int|default=0: Maximum number of bspline optimization iterations
+    bsplineSamplingRatio:
+    # type=float|default=0.0: Portion of the image to use in computing the metric during BSpline registration
+    controlPointSpacing:
+    # type=int|default=0: Number of pixels between control points
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/expert_automated_registration_callables.py b/example-specs/task/nipype_internal/pydra-slicer/expert_automated_registration_callables.py
new file mode 100644
index 00000000..3c94919d
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/expert_automated_registration_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in ExpertAutomatedRegistration.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/extract_skeleton.yaml b/example-specs/task/nipype_internal/pydra-slicer/extract_skeleton.yaml
new file mode 100644
index 00000000..3aa15179
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/extract_skeleton.yaml
@@ -0,0 +1,97 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.slicer.filtering.extractskeleton.ExtractSkeleton' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Extract Skeleton
+# 
+#     category: Filtering
+# 
+#     description: Extract the skeleton of a binary object.  The skeleton can be limited to being a 1D curve or allowed to be a full 2D manifold.  The branches of the skeleton can be pruned so that only the maximal center skeleton is returned.
+# 
+#     version: 0.1.0.$Revision: 2104 $(alpha)
+# 
+#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/ExtractSkeleton
+# 
+#     contributor: Pierre Seroul (UNC), Martin Styner (UNC), Guido Gerig (UNC), Stephen Aylward (Kitware)
+# 
+#     acknowledgements: The original implementation of this method was provided by ETH Zurich, Image Analysis Laboratory of Profs Olaf Kuebler, Gabor Szekely and Guido Gerig.  Martin Styner at UNC, Chapel Hill made enhancements.  Wrapping for Slicer was provided by Pierre Seroul and Stephen Aylward at Kitware, Inc.
+#     
+task_name: ExtractSkeleton
+nipype_name: ExtractSkeleton
+nipype_module: nipype.interfaces.slicer.filtering.extractskeleton
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    InputImageFileName: generic/file
+    # type=file|default=<undefined>: Input image
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    OutputImageFileName: generic/file
+    # type=file: Skeleton of the input image
+    # type=traitcompound|default=None: Skeleton of the input image
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    InputImageFileName:
+    # type=file|default=<undefined>: Input image
+    OutputImageFileName:
+    # type=file: Skeleton of the input image
+    # type=traitcompound|default=None: Skeleton of the input image
+    type:
+    # type=enum|default='1D'|allowed['1D','2D']: Type of skeleton to create
+    dontPrune:
+    # type=bool|default=False: Return the full skeleton, not just the maximal skeleton
+    numPoints:
+    # type=int|default=0: Number of points used to represent the skeleton
+    pointsFile:
+    # type=str|default='': Name of the file to store the coordinates of the central (1D) skeleton points
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/extract_skeleton_callables.py b/example-specs/task/nipype_internal/pydra-slicer/extract_skeleton_callables.py
new file mode 100644
index 00000000..4cc88444
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/extract_skeleton_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in ExtractSkeleton.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/fiducial_registration.yaml b/example-specs/task/nipype_internal/pydra-slicer/fiducial_registration.yaml
new file mode 100644
index 00000000..3c2fd72f
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/fiducial_registration.yaml
@@ -0,0 +1,95 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.slicer.registration.specialized.FiducialRegistration' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Fiducial Registration
+# 
+#     category: Registration.Specialized
+# 
+#     description: Computes a rigid, similarity or affine transform from a matched list of fiducials
+# 
+#     version: 0.1.0.$Revision$
+# 
+#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/TransformFromFiducials
+# 
+#     contributor: Casey B Goodlett (Kitware), Dominik Meier (SPL, BWH)
+# 
+#     acknowledgements: This work is part of the National Alliance for Medical Image Computing (NAMIC), funded by the National Institutes of Health through the NIH Roadmap for Medical Research, Grant U54 EB005149.
+#     
+task_name: FiducialRegistration
+nipype_name: FiducialRegistration
+nipype_module: nipype.interfaces.slicer.registration.specialized
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    saveTransform: generic/file
+    # type=file: Save the transform that results from registration
+    # type=traitcompound|default=None: Save the transform that results from registration
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    fixedLandmarks:
+    # type=inputmultiobject|default=[]: Ordered list of landmarks in the fixed image
+    movingLandmarks:
+    # type=inputmultiobject|default=[]: Ordered list of landmarks in the moving image
+    saveTransform:
+    # type=file: Save the transform that results from registration
+    # type=traitcompound|default=None: Save the transform that results from registration
+    transformType:
+    # type=enum|default='Translation'|allowed['Rigid','Similarity','Translation']: Type of transform to produce
+    rms:
+    # type=float|default=0.0: Display RMS Error.
+    outputMessage:
+    # type=str|default='': Provides more information on the output
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/fiducial_registration_callables.py b/example-specs/task/nipype_internal/pydra-slicer/fiducial_registration_callables.py
new file mode 100644
index 00000000..403cb5cf
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/fiducial_registration_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in FiducialRegistration.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/gaussian_blur_image_filter.yaml b/example-specs/task/nipype_internal/pydra-slicer/gaussian_blur_image_filter.yaml
new file mode 100644
index 00000000..0c350f9a
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/gaussian_blur_image_filter.yaml
@@ -0,0 +1,91 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.slicer.filtering.denoising.GaussianBlurImageFilter' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Gaussian Blur Image Filter
+# 
+#     category: Filtering.Denoising
+# 
+#     description: Apply a gaussian blur to an image
+# 
+#     version: 0.1.0.$Revision: 1.1 $(alpha)
+# 
+#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/GaussianBlurImageFilter
+# 
+#     contributor: Julien Jomier (Kitware), Stephen Aylward (Kitware)
+# 
+#     acknowledgements: This work is part of the National Alliance for Medical Image Computing (NAMIC), funded by the National Institutes of Health through the NIH Roadmap for Medical Research, Grant U54 EB005149.
+#     
+task_name: GaussianBlurImageFilter
+nipype_name: GaussianBlurImageFilter
+nipype_module: nipype.interfaces.slicer.filtering.denoising
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputVolume: generic/file
+    # type=file|default=<undefined>: Input volume
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputVolume: generic/file
+    # type=file: Blurred Volume
+    # type=traitcompound|default=None: Blurred Volume
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    sigma:
+    # type=float|default=0.0: Sigma value in physical units (e.g., mm) of the Gaussian kernel
+    inputVolume:
+    # type=file|default=<undefined>: Input volume
+    outputVolume:
+    # type=file: Blurred Volume
+    # type=traitcompound|default=None: Blurred Volume
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/gaussian_blur_image_filter_callables.py b/example-specs/task/nipype_internal/pydra-slicer/gaussian_blur_image_filter_callables.py
new file mode 100644
index 00000000..ef7c5d6a
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/gaussian_blur_image_filter_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in GaussianBlurImageFilter.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/gradient_anisotropic_diffusion.yaml b/example-specs/task/nipype_internal/pydra-slicer/gradient_anisotropic_diffusion.yaml
new file mode 100644
index 00000000..160f9573
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/gradient_anisotropic_diffusion.yaml
@@ -0,0 +1,97 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.slicer.filtering.denoising.GradientAnisotropicDiffusion' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Gradient Anisotropic Diffusion
+# 
+#     category: Filtering.Denoising
+# 
+#     description: Runs gradient anisotropic diffusion on a volume.
+# 
+#     Anisotropic diffusion methods reduce noise (or unwanted detail) in images while preserving specific image features, like edges.  For many applications, there is an assumption that light-dark transitions (edges) are interesting.  Standard isotropic diffusion methods move and blur light-dark boundaries.  Anisotropic diffusion methods are formulated to specifically preserve edges. The conductance term for this implementation is a function of the gradient magnitude of the image at each point, reducing the strength of diffusion at edges. The numerical implementation of this equation is similar to that described in the Perona-Malik paper, but uses a more robust technique for gradient magnitude estimation and has been generalized to N-dimensions.
+# 
+#     version: 0.1.0.$Revision: 19608 $(alpha)
+# 
+#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/GradientAnisotropicDiffusion
+# 
+#     contributor: Bill Lorensen (GE)
+# 
+#     acknowledgements: This command module was derived from Insight/Examples (copyright) Insight Software Consortium
+#     
+task_name: GradientAnisotropicDiffusion
+nipype_name: GradientAnisotropicDiffusion
+nipype_module: nipype.interfaces.slicer.filtering.denoising
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputVolume: generic/file
+    # type=file|default=<undefined>: Input volume to be filtered
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputVolume: generic/file
+    # type=file: Output filtered
+    # type=traitcompound|default=None: Output filtered
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    conductance:
+    # type=float|default=0.0: Conductance controls the sensitivity of the conductance term. As a general rule, the lower the value, the more strongly the filter preserves edges. A high value will cause diffusion (smoothing) across edges. Note that the number of iterations controls how much smoothing is done within regions bounded by edges.
+    iterations:
+    # type=int|default=0: The more iterations, the more smoothing. Each iteration takes the same amount of time. If it takes 10 seconds for one iteration, then it will take 100 seconds for 10 iterations. Note that the conductance controls how much each iteration smooths across edges.
+    timeStep:
+    # type=float|default=0.0: The time step depends on the dimensionality of the image. In Slicer the images are 3D and the default (.0625) time step will provide a stable solution.
+    inputVolume:
+    # type=file|default=<undefined>: Input volume to be filtered
+    outputVolume:
+    # type=file: Output filtered
+    # type=traitcompound|default=None: Output filtered
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/gradient_anisotropic_diffusion_callables.py b/example-specs/task/nipype_internal/pydra-slicer/gradient_anisotropic_diffusion_callables.py
new file mode 100644
index 00000000..91ce97e0
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/gradient_anisotropic_diffusion_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in GradientAnisotropicDiffusion.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/grayscale_fill_hole_image_filter.yaml b/example-specs/task/nipype_internal/pydra-slicer/grayscale_fill_hole_image_filter.yaml
new file mode 100644
index 00000000..af1aee29
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/grayscale_fill_hole_image_filter.yaml
@@ -0,0 +1,97 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.slicer.filtering.morphology.GrayscaleFillHoleImageFilter' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Grayscale Fill Hole Image Filter
+# 
+#     category: Filtering.Morphology
+# 
+#     description: GrayscaleFillholeImageFilter fills holes in a grayscale image.  Holes are local minima in the grayscale topography that are not connected to boundaries of the image. Gray level values adjacent to a hole are extrapolated across the hole.
+# 
+#     This filter is used to smooth over local minima without affecting the values of local maxima.  If you take the difference between the output of this filter and the original image (and perhaps threshold the difference above a small value), you'll obtain a map of the local minima.
+# 
+#     This filter uses the itkGrayscaleGeodesicErodeImageFilter.  It provides its own input as the "mask" input to the geodesic erosion.  The "marker" image for the geodesic erosion is constructed such that boundary pixels match the boundary pixels of the input image and the interior pixels are set to the maximum pixel value in the input image.
+# 
+#      Geodesic morphology and the Fillhole algorithm is described in Chapter 6 of Pierre Soille's book "Morphological Image Analysis: Principles and Applications", Second Edition, Springer, 2003.
+# 
+#      A companion filter, Grayscale Grind Peak, removes peaks in grayscale images.
+# 
+#     version: 0.1.0.$Revision: 19608 $(alpha)
+# 
+#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/GrayscaleFillHoleImageFilter
+# 
+#     contributor: Bill Lorensen (GE)
+# 
+#     acknowledgements: This work is part of the National Alliance for Medical Image Computing (NAMIC), funded by the National Institutes of Health through the NIH Roadmap for Medical Research, Grant U54 EB005149.
+#     
+task_name: GrayscaleFillHoleImageFilter
+nipype_name: GrayscaleFillHoleImageFilter
+nipype_module: nipype.interfaces.slicer.filtering.morphology
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputVolume: generic/file
+    # type=file|default=<undefined>: Input volume to be filtered
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputVolume: generic/file
+    # type=file: Output filtered
+    # type=traitcompound|default=None: Output filtered
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputVolume:
+    # type=file|default=<undefined>: Input volume to be filtered
+    outputVolume:
+    # type=file: Output filtered
+    # type=traitcompound|default=None: Output filtered
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/grayscale_fill_hole_image_filter_callables.py b/example-specs/task/nipype_internal/pydra-slicer/grayscale_fill_hole_image_filter_callables.py
new file mode 100644
index 00000000..cb4ffc92
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/grayscale_fill_hole_image_filter_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in GrayscaleFillHoleImageFilter.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/grayscale_grind_peak_image_filter.yaml b/example-specs/task/nipype_internal/pydra-slicer/grayscale_grind_peak_image_filter.yaml
new file mode 100644
index 00000000..cf29e3cc
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/grayscale_grind_peak_image_filter.yaml
@@ -0,0 +1,99 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.slicer.filtering.morphology.GrayscaleGrindPeakImageFilter' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Grayscale Grind Peak Image Filter
+# 
+#     category: Filtering.Morphology
+# 
+#     description: GrayscaleGrindPeakImageFilter removes peaks in a grayscale image. Peaks are local maxima in the grayscale topography that are not connected to boundaries of the image. Gray level values adjacent to a peak are extrapolated through the peak.
+# 
+#     This filter is used to smooth over local maxima without affecting the values of local minima.  If you take the difference between the output of this filter and the original image (and perhaps threshold the difference above a small value), you'll obtain a map of the local maxima.
+# 
+#     This filter uses the GrayscaleGeodesicDilateImageFilter.  It provides its own input as the "mask" input to the geodesic erosion.  The "marker" image for the geodesic erosion is constructed such that boundary pixels match the boundary pixels of the input image and the interior pixels are set to the minimum pixel value in the input image.
+# 
+#     This filter is the dual to the GrayscaleFillholeImageFilter which implements the Fillhole algorithm.  Since it is a dual, it is somewhat superfluous but is provided as a convenience.
+# 
+#     Geodesic morphology and the Fillhole algorithm is described in Chapter 6 of Pierre Soille's book "Morphological Image Analysis: Principles and Applications", Second Edition, Springer, 2003.
+# 
+#     A companion filter, Grayscale Fill Hole, fills holes in grayscale images.
+# 
+#     version: 0.1.0.$Revision: 19608 $(alpha)
+# 
+#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/GrayscaleGrindPeakImageFilter
+# 
+#     contributor: Bill Lorensen (GE)
+# 
+#     acknowledgements: This work is part of the National Alliance for Medical Image Computing (NAMIC), funded by the National Institutes of Health through the NIH Roadmap for Medical Research, Grant U54 EB005149.
+#     
+task_name: GrayscaleGrindPeakImageFilter
+nipype_name: GrayscaleGrindPeakImageFilter
+nipype_module: nipype.interfaces.slicer.filtering.morphology
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputVolume: generic/file
+    # type=file|default=<undefined>: Input volume to be filtered
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputVolume: generic/file
+    # type=file: Output filtered
+    # type=traitcompound|default=None: Output filtered
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputVolume:
+    # type=file|default=<undefined>: Input volume to be filtered
+    outputVolume:
+    # type=file: Output filtered
+    # type=traitcompound|default=None: Output filtered
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/grayscale_grind_peak_image_filter_callables.py b/example-specs/task/nipype_internal/pydra-slicer/grayscale_grind_peak_image_filter_callables.py
new file mode 100644
index 00000000..04a704df
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/grayscale_grind_peak_image_filter_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in GrayscaleGrindPeakImageFilter.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/grayscale_model_maker.yaml b/example-specs/task/nipype_internal/pydra-slicer/grayscale_model_maker.yaml
new file mode 100644
index 00000000..5865c1e2
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/grayscale_model_maker.yaml
@@ -0,0 +1,103 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.slicer.surface.GrayscaleModelMaker' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Grayscale Model Maker
+# 
+#     category: Surface Models
+# 
+#     description: Create 3D surface models from grayscale data. This module uses Marching Cubes to create an isosurface at a given threshold. The resulting surface consists of triangles that separate a volume into regions below and above the threshold. The resulting surface can be smoothed and decimated. This model works on continuous data while the module Model Maker works on labeled (or discrete) data.
+# 
+#     version: 3.0
+# 
+#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/GrayscaleModelMaker
+# 
+#     license: slicer3
+# 
+#     contributor: Nicole Aucoin (SPL, BWH), Bill Lorensen (GE)
+# 
+#     acknowledgements: This work is part of the National Alliance for Medical Image Computing (NAMIC), funded by the National Institutes of Health through the NIH Roadmap for Medical Research, Grant U54 EB005149.
+#     
+task_name: GrayscaleModelMaker
+nipype_name: GrayscaleModelMaker
+nipype_module: nipype.interfaces.slicer.surface
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    InputVolume: generic/file
+    # type=file|default=<undefined>: Volume containing the input grayscale data.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    OutputGeometry: generic/file
+    # type=file: Output that contains geometry model.
+    # type=traitcompound|default=None: Output that contains geometry model.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    InputVolume:
+    # type=file|default=<undefined>: Volume containing the input grayscale data.
+    OutputGeometry:
+    # type=file: Output that contains geometry model.
+    # type=traitcompound|default=None: Output that contains geometry model.
+    threshold:
+    # type=float|default=0.0: Grayscale threshold of isosurface. The resulting surface of triangles separates the volume into voxels that lie above (inside) and below (outside) the threshold.
+    name:
+    # type=str|default='': Name to use for this model.
+    smooth:
+    # type=int|default=0: Number of smoothing iterations. If 0, no smoothing will be done.
+    decimate:
+    # type=float|default=0.0: Target reduction during decimation, as a decimal percentage reduction in the number of polygons. If 0, no decimation will be done.
+    splitnormals:
+    # type=bool|default=False: Splitting normals is useful for visualizing sharp features. However it creates holes in surfaces which affect measurements
+    pointnormals:
+    # type=bool|default=False: Calculate the point normals? Calculated point normals make the surface appear smooth. Without point normals, the surface will appear faceted.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/grayscale_model_maker_callables.py b/example-specs/task/nipype_internal/pydra-slicer/grayscale_model_maker_callables.py
new file mode 100644
index 00000000..9aa1d44b
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/grayscale_model_maker_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in GrayscaleModelMaker.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/histogram_matching.yaml b/example-specs/task/nipype_internal/pydra-slicer/histogram_matching.yaml
new file mode 100644
index 00000000..cec44df1
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/histogram_matching.yaml
@@ -0,0 +1,105 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.slicer.filtering.histogrammatching.HistogramMatching' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Histogram Matching
+# 
+#     category: Filtering
+# 
+#     description: Normalizes the grayscale values of a source image based on the grayscale values of a reference image.  This filter uses a histogram matching technique where the histograms of the two images are matched only at a specified number of quantile values.
+# 
+#     The filter was originally designed to normalize MR images of the sameMR protocol and same body part. The algorithm works best if background pixels are excluded from both the source and reference histograms.  A simple background exclusion method is to exclude all pixels whose grayscale values are smaller than the mean grayscale value. ThresholdAtMeanIntensity switches on this simple background exclusion method.
+# 
+#     Number of match points governs the number of quantile values to be matched.
+# 
+#     The filter assumes that both the source and reference are of the same type and that the input and output image type have the same number of dimension and have scalar pixel types.
+# 
+#     version: 0.1.0.$Revision: 19608 $(alpha)
+# 
+#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/HistogramMatching
+# 
+#     contributor: Bill Lorensen (GE)
+# 
+#     acknowledgements: This work is part of the National Alliance for Medical Image Computing (NAMIC), funded by the National Institutes of Health through the NIH Roadmap for Medical Research, Grant U54 EB005149.
+#     
+task_name: HistogramMatching
+nipype_name: HistogramMatching
+nipype_module: nipype.interfaces.slicer.filtering.histogrammatching
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputVolume: generic/file
+    # type=file|default=<undefined>: Input volume to be filtered
+    referenceVolume: generic/file
+    # type=file|default=<undefined>: Input volume whose histogram will be matched
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputVolume: generic/file
+    # type=file: Output volume. This is the input volume with intensities matched to the reference volume.
+    # type=traitcompound|default=None: Output volume. This is the input volume with intensities matched to the reference volume.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    numberOfHistogramLevels:
+    # type=int|default=0: The number of hisogram levels to use
+    numberOfMatchPoints:
+    # type=int|default=0: The number of match points to use
+    threshold:
+    # type=bool|default=False: If on, only pixels above the mean in each volume are thresholded.
+    inputVolume:
+    # type=file|default=<undefined>: Input volume to be filtered
+    referenceVolume:
+    # type=file|default=<undefined>: Input volume whose histogram will be matched
+    outputVolume:
+    # type=file: Output volume. This is the input volume with intensities matched to the reference volume.
+    # type=traitcompound|default=None: Output volume. This is the input volume with intensities matched to the reference volume.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/histogram_matching_callables.py b/example-specs/task/nipype_internal/pydra-slicer/histogram_matching_callables.py
new file mode 100644
index 00000000..253ff081
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/histogram_matching_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in HistogramMatching.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/image_label_combine.yaml b/example-specs/task/nipype_internal/pydra-slicer/image_label_combine.yaml
new file mode 100644
index 00000000..98bfed1f
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/image_label_combine.yaml
@@ -0,0 +1,93 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.slicer.filtering.imagelabelcombine.ImageLabelCombine' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Image Label Combine
+# 
+#     category: Filtering
+# 
+#     description: Combine two label maps into one
+# 
+#     version: 0.1.0
+# 
+#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/ImageLabelCombine
+# 
+#     contributor: Alex Yarmarkovich (SPL, BWH)
+#     
+task_name: ImageLabelCombine
+nipype_name: ImageLabelCombine
+nipype_module: nipype.interfaces.slicer.filtering.imagelabelcombine
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    InputLabelMap_A: generic/file
+    # type=file|default=<undefined>: Label map image
+    InputLabelMap_B: generic/file
+    # type=file|default=<undefined>: Label map image
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    OutputLabelMap: generic/file
+    # type=file: Resulting Label map image
+    # type=traitcompound|default=None: Resulting Label map image
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    InputLabelMap_A:
+    # type=file|default=<undefined>: Label map image
+    InputLabelMap_B:
+    # type=file|default=<undefined>: Label map image
+    OutputLabelMap:
+    # type=file: Resulting Label map image
+    # type=traitcompound|default=None: Resulting Label map image
+    first_overwrites:
+    # type=bool|default=False: Use first or second label when both are present
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/image_label_combine_callables.py b/example-specs/task/nipype_internal/pydra-slicer/image_label_combine_callables.py
new file mode 100644
index 00000000..ea00bb0c
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/image_label_combine_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in ImageLabelCombine.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/intensity_difference_metric.yaml b/example-specs/task/nipype_internal/pydra-slicer/intensity_difference_metric.yaml
new file mode 100644
index 00000000..da668c35
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/intensity_difference_metric.yaml
@@ -0,0 +1,112 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.slicer.quantification.changequantification.IntensityDifferenceMetric' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title:
+#       Intensity Difference Change Detection (FAST)
+# 
+# 
+#     category:
+#       Quantification.ChangeQuantification
+# 
+# 
+#     description:
+#       Quantifies the changes between two spatially aligned images based on the pixel-wise difference of image intensities.
+# 
+# 
+#     version: 0.1
+# 
+#     contributor: Andrey Fedorov
+# 
+#     acknowledgements:
+# 
+#     
+task_name: IntensityDifferenceMetric
+nipype_name: IntensityDifferenceMetric
+nipype_module: nipype.interfaces.slicer.quantification.changequantification
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    baselineVolume: generic/file
+    # type=file|default=<undefined>: Baseline volume to be compared to
+    baselineSegmentationVolume: generic/file
+    # type=file|default=<undefined>: Label volume that contains segmentation of the structure of interest in the baseline volume.
+    followupVolume: generic/file
+    # type=file|default=<undefined>: Followup volume to be compare to the baseline
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputVolume: generic/file
+    # type=file: Output volume to keep the results of change quantification.
+    # type=traitcompound|default=None: Output volume to keep the results of change quantification.
+    reportFileName: generic/file
+    # type=file: Report file name
+    # type=traitcompound|default=None: Report file name
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    sensitivityThreshold:
+    # type=float|default=0.0: This parameter should be between 0 and 1, and defines how sensitive the metric should be to the intensity changes.
+    changingBandSize:
+    # type=int|default=0: How far (in mm) from the boundary of the segmentation should the intensity changes be considered.
+    baselineVolume:
+    # type=file|default=<undefined>: Baseline volume to be compared to
+    baselineSegmentationVolume:
+    # type=file|default=<undefined>: Label volume that contains segmentation of the structure of interest in the baseline volume.
+    followupVolume:
+    # type=file|default=<undefined>: Followup volume to be compare to the baseline
+    outputVolume:
+    # type=file: Output volume to keep the results of change quantification.
+    # type=traitcompound|default=None: Output volume to keep the results of change quantification.
+    reportFileName:
+    # type=file: Report file name
+    # type=traitcompound|default=None: Report file name
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/intensity_difference_metric_callables.py b/example-specs/task/nipype_internal/pydra-slicer/intensity_difference_metric_callables.py
new file mode 100644
index 00000000..e544585c
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/intensity_difference_metric_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in IntensityDifferenceMetric.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/label_map_smoothing.yaml b/example-specs/task/nipype_internal/pydra-slicer/label_map_smoothing.yaml
new file mode 100644
index 00000000..d6d1b180
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/label_map_smoothing.yaml
@@ -0,0 +1,97 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.slicer.surface.LabelMapSmoothing' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Label Map Smoothing
+# 
+#     category: Surface Models
+# 
+#     description: This filter smoothes a binary label map.  With a label map as input, this filter runs an anti-alising algorithm followed by a Gaussian smoothing algorithm.  The output is a smoothed label map.
+# 
+#     version: 1.0
+# 
+#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/LabelMapSmoothing
+# 
+#     contributor: Dirk Padfield (GE), Josh Cates (Utah), Ross Whitaker (Utah)
+# 
+#     acknowledgements: This work is part of the National Alliance for Medical Image Computing (NAMIC), funded by the National Institutes of Health through the NIH Roadmap for Medical Research, Grant U54 EB005149.  This filter is based on work developed at the University of Utah, and implemented at GE Research.
+#     
+task_name: LabelMapSmoothing
+nipype_name: LabelMapSmoothing
+nipype_module: nipype.interfaces.slicer.surface
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputVolume: generic/file
+    # type=file|default=<undefined>: Input label map to smooth
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputVolume: generic/file
+    # type=file: Smoothed label map
+    # type=traitcompound|default=None: Smoothed label map
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    labelToSmooth:
+    # type=int|default=0: The label to smooth.  All others will be ignored.  If no label is selected by the user, the maximum label in the image is chosen by default.
+    numberOfIterations:
+    # type=int|default=0: The number of iterations of the level set AntiAliasing algorithm
+    maxRMSError:
+    # type=float|default=0.0: The maximum RMS error.
+    gaussianSigma:
+    # type=float|default=0.0: The standard deviation of the Gaussian kernel
+    inputVolume:
+    # type=file|default=<undefined>: Input label map to smooth
+    outputVolume:
+    # type=file: Smoothed label map
+    # type=traitcompound|default=None: Smoothed label map
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/label_map_smoothing_callables.py b/example-specs/task/nipype_internal/pydra-slicer/label_map_smoothing_callables.py
new file mode 100644
index 00000000..e8f865e7
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/label_map_smoothing_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in LabelMapSmoothing.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/linear_registration.yaml b/example-specs/task/nipype_internal/pydra-slicer/linear_registration.yaml
new file mode 100644
index 00000000..b3806443
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/linear_registration.yaml
@@ -0,0 +1,117 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.slicer.legacy.registration.LinearRegistration' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Linear Registration
+# 
+#     category: Legacy.Registration
+# 
+#     description: Registers two images together using a rigid transform and mutual information.
+# 
+#     version: 0.1.0.$Revision: 19608 $(alpha)
+# 
+#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/LinearRegistration
+# 
+#     contributor: Daniel Blezek (GE)
+# 
+#     acknowledgements: This work is part of the National Alliance for Medical Image Computing (NAMIC), funded by the National Institutes of Health through the NIH Roadmap for Medical Research, Grant U54 EB005149.
+#     
+task_name: LinearRegistration
+nipype_name: LinearRegistration
+nipype_module: nipype.interfaces.slicer.legacy.registration
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    initialtransform: generic/file
+    # type=file|default=<undefined>: Initial transform for aligning the fixed and moving image. Maps positions in the fixed coordinate frame to positions in the moving coordinate frame. Optional.
+    FixedImageFileName: generic/file
+    # type=file|default=<undefined>: Fixed image to which to register
+    MovingImageFileName: generic/file
+    # type=file|default=<undefined>: Moving image
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputtransform: generic/file
+    # type=file: Transform calculated that aligns the fixed and moving image. Maps positions in the fixed coordinate frame to the moving coordinate frame. Optional (specify an output transform or an output volume or both).
+    # type=traitcompound|default=None: Transform calculated that aligns the fixed and moving image. Maps positions in the fixed coordinate frame to the moving coordinate frame. Optional (specify an output transform or an output volume or both).
+    resampledmovingfilename: generic/file
+    # type=file: Resampled moving image to the fixed image coordinate frame. Optional (specify an output transform or an output volume or both).
+    # type=traitcompound|default=None: Resampled moving image to the fixed image coordinate frame. Optional (specify an output transform or an output volume or both).
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    fixedsmoothingfactor:
+    # type=int|default=0: Amount of smoothing applied to fixed image prior to registration. Default is 0 (none). Range is 0-5 (unitless). Consider smoothing the input data if there is considerable amounts of noise or the noise pattern in the fixed and moving images is very different.
+    movingsmoothingfactor:
+    # type=int|default=0: Amount of smoothing applied to moving image prior to registration. Default is 0 (none). Range is 0-5 (unitless). Consider smoothing the input data if there is considerable amounts of noise or the noise pattern in the fixed and moving images is very different.
+    histogrambins:
+    # type=int|default=0: Number of histogram bins to use for Mattes Mutual Information. Reduce the number of bins if a registration fails. If the number of bins is too large, the estimated PDFs will be a field of impulses and will inhibit reliable registration estimation.
+    spatialsamples:
+    # type=int|default=0: Number of spatial samples to use in estimating Mattes Mutual Information. Larger values yield more accurate PDFs and improved registration quality.
+    iterations:
+    # type=inputmultiobject|default=[]: Comma separated list of iterations. Must have the same number of elements as the learning rate.
+    learningrate:
+    # type=inputmultiobject|default=[]: Comma separated list of learning rates. Learning rate is a scale factor on the gradient of the registration objective function (gradient with respect to the parameters of the transformation) used to update the parameters of the transformation during optimization. Smaller values cause the optimizer to take smaller steps through the parameter space. Larger values are typically used early in the registration process to take large jumps in parameter space followed by smaller values to home in on the optimum value of the registration objective function. Default is: 0.01, 0.005, 0.0005, 0.0002. Must have the same number of elements as iterations.
+    translationscale:
+    # type=float|default=0.0: Relative scale of translations to rotations, i.e. a value of 100 means 10mm = 1 degree. (Actual scale used 1/(TranslationScale^2)). This parameter is used to 'weight' or 'standardized' the transform parameters and their effect on the registration objective function.
+    initialtransform:
+    # type=file|default=<undefined>: Initial transform for aligning the fixed and moving image. Maps positions in the fixed coordinate frame to positions in the moving coordinate frame. Optional.
+    FixedImageFileName:
+    # type=file|default=<undefined>: Fixed image to which to register
+    MovingImageFileName:
+    # type=file|default=<undefined>: Moving image
+    outputtransform:
+    # type=file: Transform calculated that aligns the fixed and moving image. Maps positions in the fixed coordinate frame to the moving coordinate frame. Optional (specify an output transform or an output volume or both).
+    # type=traitcompound|default=None: Transform calculated that aligns the fixed and moving image. Maps positions in the fixed coordinate frame to the moving coordinate frame. Optional (specify an output transform or an output volume or both).
+    resampledmovingfilename:
+    # type=file: Resampled moving image to the fixed image coordinate frame. Optional (specify an output transform or an output volume or both).
+    # type=traitcompound|default=None: Resampled moving image to the fixed image coordinate frame. Optional (specify an output transform or an output volume or both).
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/linear_registration_callables.py b/example-specs/task/nipype_internal/pydra-slicer/linear_registration_callables.py
new file mode 100644
index 00000000..14da31af
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/linear_registration_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in LinearRegistration.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/mask_scalar_volume.yaml b/example-specs/task/nipype_internal/pydra-slicer/mask_scalar_volume.yaml
new file mode 100644
index 00000000..0c41d3a3
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/mask_scalar_volume.yaml
@@ -0,0 +1,97 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.slicer.filtering.arithmetic.MaskScalarVolume' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Mask Scalar Volume
+# 
+#     category: Filtering.Arithmetic
+# 
+#     description: Masks two images. The output image is set to 0 everywhere except where the chosen label from the mask volume is present, at which point it will retain it's original values. Although all image types are supported on input, only signed types are produced. The two images do not have to have the same dimensions.
+# 
+#     version: 0.1.0.$Revision: 8595 $(alpha)
+# 
+#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/Mask
+# 
+#     contributor: Nicole Aucoin (SPL, BWH), Ron Kikinis (SPL, BWH)
+# 
+#     acknowledgements: This work is part of the National Alliance for Medical Image Computing (NAMIC), funded by the National Institutes of Health through the NIH Roadmap for Medical Research, Grant U54 EB005149.
+#     
+task_name: MaskScalarVolume
+nipype_name: MaskScalarVolume
+nipype_module: nipype.interfaces.slicer.filtering.arithmetic
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    InputVolume: generic/file
+    # type=file|default=<undefined>: Input volume to be masked
+    MaskVolume: generic/file
+    # type=file|default=<undefined>: Label volume containing the mask
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    OutputVolume: generic/file
+    # type=file: Output volume: Input Volume masked by label value from Mask Volume
+    # type=traitcompound|default=None: Output volume: Input Volume masked by label value from Mask Volume
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    InputVolume:
+    # type=file|default=<undefined>: Input volume to be masked
+    MaskVolume:
+    # type=file|default=<undefined>: Label volume containing the mask
+    OutputVolume:
+    # type=file: Output volume: Input Volume masked by label value from Mask Volume
+    # type=traitcompound|default=None: Output volume: Input Volume masked by label value from Mask Volume
+    label:
+    # type=int|default=0: Label value in the Mask Volume to use as the mask
+    replace:
+    # type=int|default=0: Value to use for the output volume outside of the mask
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/mask_scalar_volume_callables.py b/example-specs/task/nipype_internal/pydra-slicer/mask_scalar_volume_callables.py
new file mode 100644
index 00000000..b8564e47
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/mask_scalar_volume_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in MaskScalarVolume.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/median_image_filter.yaml b/example-specs/task/nipype_internal/pydra-slicer/median_image_filter.yaml
new file mode 100644
index 00000000..a20c20b5
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/median_image_filter.yaml
@@ -0,0 +1,91 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.slicer.filtering.denoising.MedianImageFilter' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Median Image Filter
+# 
+#     category: Filtering.Denoising
+# 
+#     description: The MedianImageFilter is commonly used as a robust approach for noise reduction. This filter is particularly efficient against "salt-and-pepper" noise. In other words, it is robust to the presence of gray-level outliers. MedianImageFilter computes the value of each output pixel as the statistical median of the neighborhood of values around the corresponding input pixel.
+# 
+#     version: 0.1.0.$Revision: 19608 $(alpha)
+# 
+#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/MedianImageFilter
+# 
+#     contributor: Bill Lorensen (GE)
+# 
+#     acknowledgements: This command module was derived from Insight/Examples/Filtering/MedianImageFilter (copyright) Insight Software Consortium
+#     
+task_name: MedianImageFilter
+nipype_name: MedianImageFilter
+nipype_module: nipype.interfaces.slicer.filtering.denoising
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputVolume: generic/file
+    # type=file|default=<undefined>: Input volume to be filtered
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputVolume: generic/file
+    # type=file: Output filtered
+    # type=traitcompound|default=None: Output filtered
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    neighborhood:
+    # type=inputmultiobject|default=[]: The size of the neighborhood in each dimension
+    inputVolume:
+    # type=file|default=<undefined>: Input volume to be filtered
+    outputVolume:
+    # type=file: Output filtered
+    # type=traitcompound|default=None: Output filtered
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/median_image_filter_callables.py b/example-specs/task/nipype_internal/pydra-slicer/median_image_filter_callables.py
new file mode 100644
index 00000000..bcf97cf2
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/median_image_filter_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in MedianImageFilter.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/merge_models.yaml b/example-specs/task/nipype_internal/pydra-slicer/merge_models.yaml
new file mode 100644
index 00000000..7fe417ec
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/merge_models.yaml
@@ -0,0 +1,93 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.slicer.surface.MergeModels' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Merge Models
+# 
+#     category: Surface Models
+# 
+#     description: Merge the polydata from two input models and output a new model with the added polydata. Uses the vtkAppendPolyData filter. Works on .vtp and .vtk surface files.
+# 
+#     version: $Revision$
+# 
+#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/MergeModels
+# 
+#     contributor: Nicole Aucoin (SPL, BWH), Ron Kikinis (SPL, BWH), Daniel Haehn (SPL, BWH)
+# 
+#     acknowledgements: This work is part of the National Alliance for Medical Image Computing (NAMIC), funded by the National Institutes of Health through the NIH Roadmap for Medical Research, Grant U54 EB005149.
+#     
+task_name: MergeModels
+nipype_name: MergeModels
+nipype_module: nipype.interfaces.slicer.surface
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    Model1: generic/file
+    # type=file|default=<undefined>: Model
+    Model2: generic/file
+    # type=file|default=<undefined>: Model
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    ModelOutput: generic/file
+    # type=file: Model
+    # type=traitcompound|default=None: Model
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    Model1:
+    # type=file|default=<undefined>: Model
+    Model2:
+    # type=file|default=<undefined>: Model
+    ModelOutput:
+    # type=file: Model
+    # type=traitcompound|default=None: Model
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/merge_models_callables.py b/example-specs/task/nipype_internal/pydra-slicer/merge_models_callables.py
new file mode 100644
index 00000000..677ca5da
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/merge_models_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in MergeModels.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/model_maker.yaml b/example-specs/task/nipype_internal/pydra-slicer/model_maker.yaml
new file mode 100644
index 00000000..7732cace
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/model_maker.yaml
@@ -0,0 +1,122 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.slicer.surface.ModelMaker' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Model Maker
+# 
+#     category: Surface Models
+# 
+#     description: Create 3D surface models from segmented data.<p>Models are imported into Slicer under a model hierarchy node in a MRML scene. The model colors are set by the color table associated with the input volume (these colours will only be visible if you load the model scene file).</p><p><b>Create Multiple:</b></p><p>If you specify a list of Labels, it will over ride any start/end label settings.</p><p>If you click<i>Generate All</i>it will over ride the list of labels and any start/end label settings.</p><p><b>Model Maker Settings:</b></p><p>You can set the number of smoothing iterations, target reduction in number of polygons (decimal percentage). Use 0 and 1 if you wish no smoothing nor decimation.<br>You can set the flags to split normals or generate point normals in this pane as well.<br>You can save a copy of the models after intermediate steps (marching cubes, smoothing, and decimation if not joint smoothing, otherwise just after decimation); these models are not saved in the mrml file, turn off deleting temporary files first in the python window:<br><i>slicer.modules.modelmaker.cliModuleLogic().DeleteTemporaryFilesOff()</i></p>
+# 
+#     version: 4.1
+# 
+#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/ModelMaker
+# 
+#     license: slicer4
+# 
+#     contributor: Nicole Aucoin (SPL, BWH), Ron Kikinis (SPL, BWH), Bill Lorensen (GE)
+# 
+#     acknowledgements: This work is part of the National Alliance for Medical Image Computing (NAMIC), funded by the National Institutes of Health through the NIH Roadmap for Medical Research, Grant U54 EB005149.
+#     
+task_name: ModelMaker
+nipype_name: ModelMaker
+nipype_module: nipype.interfaces.slicer.surface
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    InputVolume: generic/file
+    # type=file|default=<undefined>: Input label map. The Input Volume drop down menu is populated with the label map volumes that are present in the scene, select one from which to generate models.
+    color: generic/file
+    # type=file|default=<undefined>: Color table to make labels to colors and objects
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    InputVolume:
+    # type=file|default=<undefined>: Input label map. The Input Volume drop down menu is populated with the label map volumes that are present in the scene, select one from which to generate models.
+    color:
+    # type=file|default=<undefined>: Color table to make labels to colors and objects
+    modelSceneFile:
+    # type=outputmultiobject: Generated models, under a model hierarchy node. Models are imported into Slicer under a model hierarchy node, and their colors are set by the color table associated with the input label map volume. The model hierarchy node must be created before running the model maker, by selecting Create New ModelHierarchy from the Models drop down menu. If you're running from the command line, a model hierarchy node in a new mrml scene will be created for you.
+    # type=traitcompound|default=[None]: Generated models, under a model hierarchy node. Models are imported into Slicer under a model hierarchy node, and their colors are set by the color table associated with the input label map volume. The model hierarchy node must be created before running the model maker, by selecting Create New ModelHierarchy from the Models drop down menu. If you're running from the command line, a model hierarchy node in a new mrml scene will be created for you.
+    name:
+    # type=str|default='': Name to use for this model. Any text entered in the entry box will be the starting string for the created model file names. The label number and the color name will also be part of the file name. If making multiple models, use this as a prefix to the label and color name.
+    generateAll:
+    # type=bool|default=False: Generate models for all labels in the input volume. select this option if you want to create all models that correspond to all values in a labelmap volume (using the Joint Smoothing option below is useful with this option). Ignores Labels, Start Label, End Label settings. Skips label 0.
+    labels:
+    # type=inputmultiobject|default=[]: A comma separated list of label values from which to make models. f you specify a list of Labels, it will override any start/end label settings. If you click Generate All Models it will override the list of labels and any start/end label settings.
+    start:
+    # type=int|default=0: If you want to specify a continuous range of labels from which to generate models, enter the lower label here. Voxel value from which to start making models. Used instead of the label list to specify a range (make sure the label list is empty or it will over ride this).
+    end:
+    # type=int|default=0: If you want to specify a continuous range of labels from which to generate models, enter the higher label here. Voxel value up to which to continue making models. Skip any values with zero voxels.
+    skipUnNamed:
+    # type=bool|default=False: Select this to not generate models from labels that do not have names defined in the color look up table associated with the input label map. If true, only models which have an entry in the color table will be generated.  If false, generate all models that exist within the label range.
+    jointsmooth:
+    # type=bool|default=False: This will ensure that all resulting models fit together smoothly, like jigsaw puzzle pieces. Otherwise the models will be smoothed independently and may overlap.
+    smooth:
+    # type=int|default=0: Here you can set the number of smoothing iterations for Laplacian smoothing, or the degree of the polynomial approximating the windowed Sinc function. Use 0 if you wish no smoothing. 
+    filtertype:
+    # type=enum|default='Sinc'|allowed['Laplacian','Sinc']: You can control the type of smoothing done on the models by selecting a filter type of either Sinc or Laplacian.
+    decimate:
+    # type=float|default=0.0: Chose the target reduction in number of polygons as a decimal percentage (between 0 and 1) of the number of polygons. Specifies the percentage of triangles to be removed. For example, 0.1 means 10% reduction and 0.9 means 90% reduction.
+    splitnormals:
+    # type=bool|default=False: Splitting normals is useful for visualizing sharp features. However it creates holes in surfaces which affects measurements.
+    pointnormals:
+    # type=bool|default=False: Turn this flag on if you wish to calculate the normal vectors for the points.
+    pad:
+    # type=bool|default=False: Pad the input volume with zero value voxels on all 6 faces in order to ensure the production of closed surfaces. Sets the origin translation and extent translation so that the models still line up with the unpadded input volume.
+    saveIntermediateModels:
+    # type=bool|default=False: You can save a copy of the models after each of the intermediate steps (marching cubes, smoothing, and decimation if not joint smoothing, otherwise just after decimation). These intermediate models are not saved in the mrml file, you have to load them manually after turning off deleting temporary files in they python console (View ->Python Interactor) using the following command slicer.modules.modelmaker.cliModuleLogic().DeleteTemporaryFilesOff().
+    debug:
+    # type=bool|default=False: turn this flag on in order to see debugging output (look in the Error Log window that is accessed via the View menu)
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/model_maker_callables.py b/example-specs/task/nipype_internal/pydra-slicer/model_maker_callables.py
new file mode 100644
index 00000000..b5a30605
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/model_maker_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in ModelMaker.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/model_to_label_map.yaml b/example-specs/task/nipype_internal/pydra-slicer/model_to_label_map.yaml
new file mode 100644
index 00000000..fd900a17
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/model_to_label_map.yaml
@@ -0,0 +1,95 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.slicer.surface.ModelToLabelMap' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Model To Label Map
+# 
+#     category: Surface Models
+# 
+#     description: Intersects an input model with an reference volume and produces an output label map.
+# 
+#     version: 0.1.0.$Revision: 8643 $(alpha)
+# 
+#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/PolyDataToLabelMap
+# 
+#     contributor: Nicole Aucoin (SPL, BWH), Xiaodong Tao (GE)
+# 
+#     acknowledgements: This work is part of the National Alliance for Medical Image Computing (NAMIC), funded by the National Institutes of Health through the NIH Roadmap for Medical Research, Grant U54 EB005149.
+#     
+task_name: ModelToLabelMap
+nipype_name: ModelToLabelMap
+nipype_module: nipype.interfaces.slicer.surface
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    InputVolume: generic/file
+    # type=file|default=<undefined>: Input volume
+    surface: generic/file
+    # type=file|default=<undefined>: Model
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    OutputVolume: generic/file
+    # type=file: The label volume
+    # type=traitcompound|default=None: The label volume
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    distance:
+    # type=float|default=0.0: Sample distance
+    InputVolume:
+    # type=file|default=<undefined>: Input volume
+    surface:
+    # type=file|default=<undefined>: Model
+    OutputVolume:
+    # type=file: The label volume
+    # type=traitcompound|default=None: The label volume
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/model_to_label_map_callables.py b/example-specs/task/nipype_internal/pydra-slicer/model_to_label_map_callables.py
new file mode 100644
index 00000000..46ed9e69
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/model_to_label_map_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in ModelToLabelMap.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/multi_resolution_affine_registration.yaml b/example-specs/task/nipype_internal/pydra-slicer/multi_resolution_affine_registration.yaml
new file mode 100644
index 00000000..d82527b3
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/multi_resolution_affine_registration.yaml
@@ -0,0 +1,115 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.slicer.legacy.registration.MultiResolutionAffineRegistration' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Robust Multiresolution Affine Registration
+# 
+#     category: Legacy.Registration
+# 
+#     description: Provides affine registration using multiple resolution levels and decomposed affine transforms.
+# 
+#     version: 0.1.0.$Revision: 2104 $(alpha)
+# 
+#     documentation-url: http://www.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/MultiResolutionAffineRegistration
+# 
+#     contributor: Casey B Goodlett (Utah)
+# 
+#     acknowledgements: This work is part of the National Alliance for Medical Image Computing (NAMIC), funded by the National Institutes of Health through the NIH Roadmap for Medical Research, Grant U54 EB005149.
+#     
+task_name: MultiResolutionAffineRegistration
+nipype_name: MultiResolutionAffineRegistration
+nipype_module: nipype.interfaces.slicer.legacy.registration
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    fixedImage: generic/file
+    # type=file|default=<undefined>: Image which defines the space into which the moving image is registered
+    movingImage: generic/file
+    # type=file|default=<undefined>: The transform goes from the fixed image's space into the moving image's space
+    fixedImageMask: generic/file
+    # type=file|default=<undefined>: Label image which defines a mask of interest for the fixed image
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    resampledImage: generic/file
+    # type=file: Registration results
+    # type=traitcompound|default=None: Registration results
+    saveTransform: generic/file
+    # type=file: Save the output transform from the registration
+    # type=traitcompound|default=None: Save the output transform from the registration
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    fixedImage:
+    # type=file|default=<undefined>: Image which defines the space into which the moving image is registered
+    movingImage:
+    # type=file|default=<undefined>: The transform goes from the fixed image's space into the moving image's space
+    resampledImage:
+    # type=file: Registration results
+    # type=traitcompound|default=None: Registration results
+    saveTransform:
+    # type=file: Save the output transform from the registration
+    # type=traitcompound|default=None: Save the output transform from the registration
+    fixedImageMask:
+    # type=file|default=<undefined>: Label image which defines a mask of interest for the fixed image
+    fixedImageROI:
+    # type=list|default=[]: Label image which defines a ROI of interest for the fixed image
+    numIterations:
+    # type=int|default=0: Number of iterations to run at each resolution level.
+    numLineIterations:
+    # type=int|default=0: Number of iterations to run at each resolution level.
+    stepSize:
+    # type=float|default=0.0: The maximum step size of the optimizer in voxels
+    stepTolerance:
+    # type=float|default=0.0: The maximum step size of the optimizer in voxels
+    metricTolerance:
+    # type=float|default=0.0: 
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/multi_resolution_affine_registration_callables.py b/example-specs/task/nipype_internal/pydra-slicer/multi_resolution_affine_registration_callables.py
new file mode 100644
index 00000000..2603847f
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/multi_resolution_affine_registration_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in MultiResolutionAffineRegistration.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/multiply_scalar_volumes.yaml b/example-specs/task/nipype_internal/pydra-slicer/multiply_scalar_volumes.yaml
new file mode 100644
index 00000000..426b2ff0
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/multiply_scalar_volumes.yaml
@@ -0,0 +1,95 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.slicer.filtering.arithmetic.MultiplyScalarVolumes' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Multiply Scalar Volumes
+# 
+#     category: Filtering.Arithmetic
+# 
+#     description: Multiplies two images. Although all image types are supported on input, only signed types are produced. The two images do not have to have the same dimensions.
+# 
+#     version: 0.1.0.$Revision: 8595 $(alpha)
+# 
+#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/Multiply
+# 
+#     contributor: Bill Lorensen (GE)
+# 
+#     acknowledgements: This work is part of the National Alliance for Medical Image Computing (NAMIC), funded by the National Institutes of Health through the NIH Roadmap for Medical Research, Grant U54 EB005149.
+#     
+task_name: MultiplyScalarVolumes
+nipype_name: MultiplyScalarVolumes
+nipype_module: nipype.interfaces.slicer.filtering.arithmetic
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputVolume1: generic/file
+    # type=file|default=<undefined>: Input volume 1
+    inputVolume2: generic/file
+    # type=file|default=<undefined>: Input volume 2
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputVolume: generic/file
+    # type=file: Volume1 * Volume2
+    # type=traitcompound|default=None: Volume1 * Volume2
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputVolume1:
+    # type=file|default=<undefined>: Input volume 1
+    inputVolume2:
+    # type=file|default=<undefined>: Input volume 2
+    outputVolume:
+    # type=file: Volume1 * Volume2
+    # type=traitcompound|default=None: Volume1 * Volume2
+    order:
+    # type=enum|default='0'|allowed['0','1','2','3']: Interpolation order if two images are in different coordinate frames or have different sampling.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/multiply_scalar_volumes_callables.py b/example-specs/task/nipype_internal/pydra-slicer/multiply_scalar_volumes_callables.py
new file mode 100644
index 00000000..e010f113
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/multiply_scalar_volumes_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in MultiplyScalarVolumes.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/n4itk_bias_field_correction.yaml b/example-specs/task/nipype_internal/pydra-slicer/n4itk_bias_field_correction.yaml
new file mode 100644
index 00000000..835806f4
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/n4itk_bias_field_correction.yaml
@@ -0,0 +1,117 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.slicer.filtering.n4itkbiasfieldcorrection.N4ITKBiasFieldCorrection' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: N4ITK MRI Bias correction
+# 
+#     category: Filtering
+# 
+#     description: Performs image bias correction using N4 algorithm. This module is based on the ITK filters contributed in the following publication:  Tustison N, Gee J "N4ITK: Nick's N3 ITK Implementation For MRI Bias Field Correction", The Insight Journal 2009 January-June, http://hdl.handle.net/10380/3053
+# 
+#     version: 9
+# 
+#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/N4ITKBiasFieldCorrection
+# 
+#     contributor: Nick Tustison (UPenn), Andrey Fedorov (SPL, BWH), Ron Kikinis (SPL, BWH)
+# 
+#     acknowledgements: The development of this module was partially supported by NIH grants R01 AA016748-01, R01 CA111288 and U01 CA151261 as well as by NA-MIC, NAC, NCIGT and the Slicer community.
+#     
+task_name: N4ITKBiasFieldCorrection
+nipype_name: N4ITKBiasFieldCorrection
+nipype_module: nipype.interfaces.slicer.filtering.n4itkbiasfieldcorrection
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputimage: generic/file
+    # type=file|default=<undefined>: Input image where you observe signal inhomegeneity
+    maskimage: generic/file
+    # type=file|default=<undefined>: Binary mask that defines the structure of your interest. NOTE: This parameter is OPTIONAL. If the mask is not specified, the module will use internally Otsu thresholding to define this mask. Better processing results can often be obtained when a meaningful mask is defined.
+    weightimage: generic/file
+    # type=file|default=<undefined>: Weight Image
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputimage: generic/file
+    # type=file: Result of processing
+    # type=traitcompound|default=None: Result of processing
+    outputbiasfield: generic/file
+    # type=file: Recovered bias field (OPTIONAL)
+    # type=traitcompound|default=None: Recovered bias field (OPTIONAL)
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputimage:
+    # type=file|default=<undefined>: Input image where you observe signal inhomegeneity
+    maskimage:
+    # type=file|default=<undefined>: Binary mask that defines the structure of your interest. NOTE: This parameter is OPTIONAL. If the mask is not specified, the module will use internally Otsu thresholding to define this mask. Better processing results can often be obtained when a meaningful mask is defined.
+    outputimage:
+    # type=file: Result of processing
+    # type=traitcompound|default=None: Result of processing
+    outputbiasfield:
+    # type=file: Recovered bias field (OPTIONAL)
+    # type=traitcompound|default=None: Recovered bias field (OPTIONAL)
+    iterations:
+    # type=inputmultiobject|default=[]: Maximum number of iterations at each level of resolution. Larger values will increase execution time, but may lead to better results.
+    convergencethreshold:
+    # type=float|default=0.0: Stopping criterion for the iterative bias estimation. Larger values will lead to smaller execution time.
+    meshresolution:
+    # type=inputmultiobject|default=[]: Resolution of the initial bspline grid defined as a sequence of three numbers. The actual resolution will be defined by adding the bspline order (default is 3) to the resolution in each dimension specified here. For example, 1,1,1 will result in a 4x4x4 grid of control points. This parameter may need to be adjusted based on your input image. In the multi-resolution N4 framework, the resolution of the bspline grid at subsequent iterations will be doubled. The number of resolutions is implicitly defined by Number of iterations parameter (the size of this list is the number of resolutions)
+    splinedistance:
+    # type=float|default=0.0: An alternative means to define the spline grid, by setting the distance between the control points. This parameter is used only if the grid resolution is not specified.
+    shrinkfactor:
+    # type=int|default=0: Defines how much the image should be upsampled before estimating the inhomogeneity field. Increase if you want to reduce the execution time. 1 corresponds to the original resolution. Larger values will significantly reduce the computation time.
+    bsplineorder:
+    # type=int|default=0: Order of B-spline used in the approximation. Larger values will lead to longer execution times, may result in overfitting and poor result.
+    weightimage:
+    # type=file|default=<undefined>: Weight Image
+    histogramsharpening:
+    # type=inputmultiobject|default=[]: A vector of up to three values. Non-zero values correspond to Bias Field Full Width at Half Maximum, Wiener filter noise, and Number of histogram bins.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/n4itk_bias_field_correction_callables.py b/example-specs/task/nipype_internal/pydra-slicer/n4itk_bias_field_correction_callables.py
new file mode 100644
index 00000000..d1772955
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/n4itk_bias_field_correction_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in N4ITKBiasFieldCorrection.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/orient_scalar_volume.yaml b/example-specs/task/nipype_internal/pydra-slicer/orient_scalar_volume.yaml
new file mode 100644
index 00000000..345274c0
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/orient_scalar_volume.yaml
@@ -0,0 +1,91 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.slicer.converters.OrientScalarVolume' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Orient Scalar Volume
+# 
+#     category: Converters
+# 
+#     description: Orients an output volume. Rearranges the slices in a volume according to the selected orientation. The slices are not interpolated. They are just reordered and/or permuted. The resulting volume will cover the original volume. NOTE: since Slicer takes into account the orientation of a volume, the re-oriented volume will not show any difference from the original volume, To see the difference, save the volume and display it with a system that either ignores the orientation of the image (e.g. Paraview) or displays individual images.
+# 
+#     version: 0.1.0.$Revision: 19608 $(alpha)
+# 
+#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/OrientImage
+# 
+#     contributor: Bill Lorensen (GE)
+# 
+#     acknowledgements: This work is part of the National Alliance for Medical Image Computing (NAMIC), funded by the National Institutes of Health through the NIH Roadmap for Medical Research, Grant U54 EB005149.
+#     
+task_name: OrientScalarVolume
+nipype_name: OrientScalarVolume
+nipype_module: nipype.interfaces.slicer.converters
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputVolume1: generic/file
+    # type=file|default=<undefined>: Input volume 1
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputVolume: generic/file
+    # type=file: The oriented volume
+    # type=traitcompound|default=None: The oriented volume
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputVolume1:
+    # type=file|default=<undefined>: Input volume 1
+    outputVolume:
+    # type=file: The oriented volume
+    # type=traitcompound|default=None: The oriented volume
+    orientation:
+    # type=enum|default='Axial'|allowed['AIL','AIR','ALI','ALS','ARI','ARS','ASL','ASR','Axial','Coronal','IAL','IAR','ILA','ILP','IPL','IPR','IRA','IRP','LAI','LAS','LIA','LIP','LPI','LPS','LSA','LSP','PIL','PIR','PLI','PLS','PRI','PRS','PSL','PSR','RAI','RAS','RIA','RIP','RPI','RPS','RSA','RSP','SAL','SAR','SLA','SLP','SPL','SPR','SRA','SRP','Sagittal']: Orientation choices
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/orient_scalar_volume_callables.py b/example-specs/task/nipype_internal/pydra-slicer/orient_scalar_volume_callables.py
new file mode 100644
index 00000000..6fcfadb2
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/orient_scalar_volume_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in OrientScalarVolume.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/otsu_threshold_image_filter.yaml b/example-specs/task/nipype_internal/pydra-slicer/otsu_threshold_image_filter.yaml
new file mode 100644
index 00000000..09afdd80
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/otsu_threshold_image_filter.yaml
@@ -0,0 +1,99 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.slicer.legacy.filtering.OtsuThresholdImageFilter' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Otsu Threshold Image Filter
+# 
+#     category: Legacy.Filtering
+# 
+#     description: This filter creates a binary thresholded image that separates an image into foreground and background components. The filter calculates the optimum threshold separating those two classes so that their combined spread (intra-class variance) is minimal (see http://en.wikipedia.org/wiki/Otsu%27s_method).  Then the filter applies that threshold to the input image using the itkBinaryThresholdImageFilter. The numberOfHistogram bins can be set for the Otsu Calculator. The insideValue and outsideValue can be set for the BinaryThresholdImageFilter.  The filter produces a labeled volume.
+# 
+#     The original reference is:
+# 
+#     N.Otsu, A threshold selection method from gray level histograms, IEEE Trans.Syst.ManCybern.SMC-9,62–66 1979.
+# 
+#     version: 0.1.0.$Revision: 19608 $(alpha)
+# 
+#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/OtsuThresholdImageFilter
+# 
+#     contributor: Bill Lorensen (GE)
+# 
+#     acknowledgements: This command module was derived from Insight/Examples (copyright) Insight Software Consortium
+#     
+task_name: OtsuThresholdImageFilter
+nipype_name: OtsuThresholdImageFilter
+nipype_module: nipype.interfaces.slicer.legacy.filtering
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputVolume: generic/file
+    # type=file|default=<undefined>: Input volume to be filtered
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputVolume: generic/file
+    # type=file: Output filtered
+    # type=traitcompound|default=None: Output filtered
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    insideValue:
+    # type=int|default=0: The value assigned to pixels that are inside the computed threshold
+    outsideValue:
+    # type=int|default=0: The value assigned to pixels that are outside the computed threshold
+    numberOfBins:
+    # type=int|default=0: This is an advanced parameter. The number of bins in the histogram used to model the probability mass function of the two intensity distributions. Small numbers of bins may result in a more conservative threshold. The default should suffice for most applications. Experimentation is the only way to see the effect of varying this parameter.
+    inputVolume:
+    # type=file|default=<undefined>: Input volume to be filtered
+    outputVolume:
+    # type=file: Output filtered
+    # type=traitcompound|default=None: Output filtered
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/otsu_threshold_image_filter_callables.py b/example-specs/task/nipype_internal/pydra-slicer/otsu_threshold_image_filter_callables.py
new file mode 100644
index 00000000..c4725667
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/otsu_threshold_image_filter_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in OtsuThresholdImageFilter.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/otsu_threshold_segmentation.yaml b/example-specs/task/nipype_internal/pydra-slicer/otsu_threshold_segmentation.yaml
new file mode 100644
index 00000000..87580705
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/otsu_threshold_segmentation.yaml
@@ -0,0 +1,97 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.slicer.legacy.segmentation.OtsuThresholdSegmentation' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Otsu Threshold Segmentation
+# 
+#     category: Legacy.Segmentation
+# 
+#     description: This filter creates a labeled image from a grayscale image. First, it calculates an optimal threshold that separates the image into foreground and background. This threshold separates those two classes so that their intra-class variance is minimal (see http://en.wikipedia.org/wiki/Otsu%27s_method). Then the filter runs a connected component algorithm to generate unique labels for each connected region of the foreground. Finally, the resulting image is relabeled to provide consecutive numbering.
+# 
+#     version: 1.0
+# 
+#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/OtsuThresholdSegmentation
+# 
+#     contributor: Bill Lorensen (GE)
+# 
+#     acknowledgements: This work is part of the National Alliance for Medical Image Computing (NAMIC), funded by the National Institutes of Health through the NIH Roadmap for Medical Research, Grant U54 EB005149.
+#     
+task_name: OtsuThresholdSegmentation
+nipype_name: OtsuThresholdSegmentation
+nipype_module: nipype.interfaces.slicer.legacy.segmentation
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputVolume: generic/file
+    # type=file|default=<undefined>: Input volume to be segmented
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputVolume: generic/file
+    # type=file: Output filtered
+    # type=traitcompound|default=None: Output filtered
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    brightObjects:
+    # type=bool|default=False: Segmenting bright objects on a dark background or dark objects on a bright background.
+    numberOfBins:
+    # type=int|default=0: This is an advanced parameter. The number of bins in the histogram used to model the probability mass function of the two intensity distributions. Small numbers of bins may result in a more conservative threshold. The default should suffice for most applications. Experimentation is the only way to see the effect of varying this parameter.
+    faceConnected:
+    # type=bool|default=False: This is an advanced parameter. Adjacent voxels are face connected. This affects the connected component algorithm. If this parameter is false, more regions are likely to be identified.
+    minimumObjectSize:
+    # type=int|default=0: Minimum size of object to retain. This parameter can be used to get rid of small regions in noisy images.
+    inputVolume:
+    # type=file|default=<undefined>: Input volume to be segmented
+    outputVolume:
+    # type=file: Output filtered
+    # type=traitcompound|default=None: Output filtered
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/otsu_threshold_segmentation_callables.py b/example-specs/task/nipype_internal/pydra-slicer/otsu_threshold_segmentation_callables.py
new file mode 100644
index 00000000..6cf5b5c5
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/otsu_threshold_segmentation_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in OtsuThresholdSegmentation.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/pet_standard_uptake_value_computation.yaml b/example-specs/task/nipype_internal/pydra-slicer/pet_standard_uptake_value_computation.yaml
new file mode 100644
index 00000000..2d23d0ec
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/pet_standard_uptake_value_computation.yaml
@@ -0,0 +1,111 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.slicer.quantification.petstandarduptakevaluecomputation.PETStandardUptakeValueComputation' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: PET Standard Uptake Value Computation
+# 
+#     category: Quantification
+# 
+#     description: Computes the standardized uptake value based on body weight. Takes an input PET image in DICOM and NRRD format (DICOM header must contain Radiopharmaceutical parameters). Produces a CSV file that contains patientID, studyDate, dose, labelID, suvmin, suvmax, suvmean, labelName for each volume of interest. It also displays some of the information as output strings in the GUI, the CSV file is optional in that case. The CSV file is appended to on each execution of the CLI.
+# 
+#     version: 0.1.0.$Revision: 8595 $(alpha)
+# 
+#     documentation-url: http://www.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/ComputeSUVBodyWeight
+# 
+#     contributor: Wendy Plesniak (SPL, BWH), Nicole Aucoin (SPL, BWH), Ron Kikinis (SPL, BWH)
+# 
+#     acknowledgements: This work is funded by the Harvard Catalyst, and the National Alliance for Medical Image Computing (NAMIC), funded by the National Institutes of Health through the NIH Roadmap for Medical Research, Grant U54 EB005149.
+#     
+task_name: PETStandardUptakeValueComputation
+nipype_name: PETStandardUptakeValueComputation
+nipype_module: nipype.interfaces.slicer.quantification.petstandarduptakevaluecomputation
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    petVolume: generic/file
+    # type=file|default=<undefined>: Input PET volume for SUVbw computation (must be the same volume as pointed to by the DICOM path!).
+    labelMap: generic/file
+    # type=file|default=<undefined>: Input label volume containing the volumes of interest
+    color: generic/file
+    # type=file|default=<undefined>: Color table to to map labels to colors and names
+    petDICOMPath: generic/directory
+    # type=directory|default=<undefined>: Input path to a directory containing a PET volume containing DICOM header information for SUV computation
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    csvFile: generic/file
+    # type=file: A file holding the output SUV values in comma separated lines, one per label. Optional.
+    # type=traitcompound|default=None: A file holding the output SUV values in comma separated lines, one per label. Optional.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    petDICOMPath:
+    # type=directory|default=<undefined>: Input path to a directory containing a PET volume containing DICOM header information for SUV computation
+    petVolume:
+    # type=file|default=<undefined>: Input PET volume for SUVbw computation (must be the same volume as pointed to by the DICOM path!).
+    labelMap:
+    # type=file|default=<undefined>: Input label volume containing the volumes of interest
+    color:
+    # type=file|default=<undefined>: Color table to to map labels to colors and names
+    csvFile:
+    # type=file: A file holding the output SUV values in comma separated lines, one per label. Optional.
+    # type=traitcompound|default=None: A file holding the output SUV values in comma separated lines, one per label. Optional.
+    OutputLabel:
+    # type=str|default='': List of labels for which SUV values were computed
+    OutputLabelValue:
+    # type=str|default='': List of label values for which SUV values were computed
+    SUVMax:
+    # type=str|default='': SUV max for each label
+    SUVMean:
+    # type=str|default='': SUV mean for each label
+    SUVMin:
+    # type=str|default='': SUV minimum for each label
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/pet_standard_uptake_value_computation_callables.py b/example-specs/task/nipype_internal/pydra-slicer/pet_standard_uptake_value_computation_callables.py
new file mode 100644
index 00000000..6246dbaf
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/pet_standard_uptake_value_computation_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in PETStandardUptakeValueComputation.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/probe_volume_with_model.yaml b/example-specs/task/nipype_internal/pydra-slicer/probe_volume_with_model.yaml
new file mode 100644
index 00000000..a77b44c1
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/probe_volume_with_model.yaml
@@ -0,0 +1,93 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.slicer.surface.ProbeVolumeWithModel' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Probe Volume With Model
+# 
+#     category: Surface Models
+# 
+#     description: Paint a model by a volume (using vtkProbeFilter).
+# 
+#     version: 0.1.0.$Revision: 1892 $(alpha)
+# 
+#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/ProbeVolumeWithModel
+# 
+#     contributor: Lauren O'Donnell (SPL, BWH)
+# 
+#     acknowledgements: BWH, NCIGT/LMI
+#     
+task_name: ProbeVolumeWithModel
+nipype_name: ProbeVolumeWithModel
+nipype_module: nipype.interfaces.slicer.surface
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    InputVolume: generic/file
+    # type=file|default=<undefined>: Volume to use to 'paint' the model
+    InputModel: generic/file
+    # type=file|default=<undefined>: Input model
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    OutputModel: generic/file
+    # type=file: Output 'painted' model
+    # type=traitcompound|default=None: Output 'painted' model
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    InputVolume:
+    # type=file|default=<undefined>: Volume to use to 'paint' the model
+    InputModel:
+    # type=file|default=<undefined>: Input model
+    OutputModel:
+    # type=file: Output 'painted' model
+    # type=traitcompound|default=None: Output 'painted' model
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/probe_volume_with_model_callables.py b/example-specs/task/nipype_internal/pydra-slicer/probe_volume_with_model_callables.py
new file mode 100644
index 00000000..25e812cc
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/probe_volume_with_model_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in ProbeVolumeWithModel.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/resample_dti_volume.yaml b/example-specs/task/nipype_internal/pydra-slicer/resample_dti_volume.yaml
new file mode 100644
index 00000000..4e96f03a
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/resample_dti_volume.yaml
@@ -0,0 +1,143 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.slicer.diffusion.diffusion.ResampleDTIVolume' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Resample DTI Volume
+# 
+#     category: Diffusion.Diffusion Tensor Images
+# 
+#     description: Resampling an image is a very important task in image analysis. It is especially important in the frame of image registration. This module implements DT image resampling through the use of itk Transforms. The resampling is controlled by the Output Spacing. "Resampling" is performed in space coordinates, not pixel/grid coordinates. It is quite important to ensure that image spacing is properly set on the images involved. The interpolator is required since the mapping from one space to the other will often require evaluation of the intensity of the image at non-grid positions.
+# 
+#     version: 0.1
+# 
+#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/ResampleDTI
+# 
+#     contributor: Francois Budin (UNC)
+# 
+#     acknowledgements: This work is part of the National Alliance for Medical Image Computing (NAMIC), funded by the National Institutes of Health through the NIH Roadmap for Medical Research, Grant U54 EB005149. Information on the National Centers for Biomedical Computing can be obtained from http://nihroadmap.nih.gov/bioinformatics
+#     
+task_name: ResampleDTIVolume
+nipype_name: ResampleDTIVolume
+nipype_module: nipype.interfaces.slicer.diffusion.diffusion
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputVolume: generic/file
+    # type=file|default=<undefined>: Input volume to be resampled
+    Reference: generic/file
+    # type=file|default=<undefined>: Reference Volume (spacing,size,orientation,origin)
+    transformationFile: generic/file
+    # type=file|default=<undefined>: 
+    defField: generic/file
+    # type=file|default=<undefined>: File containing the deformation field (3D vector image containing vectors with 3 components)
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputVolume: generic/file
+    # type=file: Resampled Volume
+    # type=traitcompound|default=None: Resampled Volume
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputVolume:
+    # type=file|default=<undefined>: Input volume to be resampled
+    outputVolume:
+    # type=file: Resampled Volume
+    # type=traitcompound|default=None: Resampled Volume
+    Reference:
+    # type=file|default=<undefined>: Reference Volume (spacing,size,orientation,origin)
+    transformationFile:
+    # type=file|default=<undefined>: 
+    defField:
+    # type=file|default=<undefined>: File containing the deformation field (3D vector image containing vectors with 3 components)
+    hfieldtype:
+    # type=enum|default='displacement'|allowed['displacement','h-Field']: Set if the deformation field is an -Field
+    interpolation:
+    # type=enum|default='linear'|allowed['bs','linear','nn','ws']: Sampling algorithm (linear , nn (nearest neighbor), ws (WindowedSinc), bs (BSpline) )
+    correction:
+    # type=enum|default='zero'|allowed['abs','nearest','none','zero']: Correct the tensors if computed tensor is not semi-definite positive
+    transform_tensor_method:
+    # type=enum|default='PPD'|allowed['FS','PPD']: Chooses between 2 methods to transform the tensors: Finite Strain (FS), faster but less accurate, or Preservation of the Principal Direction (PPD)
+    transform_order:
+    # type=enum|default='input-to-output'|allowed['input-to-output','output-to-input']: Select in what order the transforms are read
+    notbulk:
+    # type=bool|default=False: The transform following the BSpline transform is not set as a bulk transform for the BSpline transform
+    spaceChange:
+    # type=bool|default=False: Space Orientation between transform and image is different (RAS/LPS) (warning: if the transform is a Transform Node in Slicer3, do not select)
+    rotation_point:
+    # type=list|default=[]: Center of rotation (only for rigid and affine transforms)
+    centered_transform:
+    # type=bool|default=False: Set the center of the transformation to the center of the input image (only for rigid and affine transforms)
+    image_center:
+    # type=enum|default='input'|allowed['input','output']: Image to use to center the transform (used only if 'Centered Transform' is selected)
+    Inverse_ITK_Transformation:
+    # type=bool|default=False: Inverse the transformation before applying it from output image to input image (only for rigid and affine transforms)
+    spacing:
+    # type=inputmultiobject|default=[]: Spacing along each dimension (0 means use input spacing)
+    size:
+    # type=inputmultiobject|default=[]: Size along each dimension (0 means use input size)
+    origin:
+    # type=list|default=[]: Origin of the output Image
+    direction_matrix:
+    # type=inputmultiobject|default=[]: 9 parameters of the direction matrix by rows (ijk to LPS if LPS transform, ijk to RAS if RAS transform)
+    number_of_thread:
+    # type=int|default=0: Number of thread used to compute the output image
+    default_pixel_value:
+    # type=float|default=0.0: Default pixel value for samples falling outside of the input region
+    window_function:
+    # type=enum|default='h'|allowed['b','c','h','l','w']: Window Function , h = Hamming , c = Cosine , w = Welch , l = Lanczos , b = Blackman
+    spline_order:
+    # type=int|default=0: Spline Order (Spline order may be from 0 to 5)
+    transform_matrix:
+    # type=inputmultiobject|default=[]: 12 parameters of the transform matrix by rows ( --last 3 being translation-- )
+    transform:
+    # type=enum|default='rt'|allowed['a','rt']: Transform algorithm, rt = Rigid Transform, a = Affine Transform
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/resample_dti_volume_callables.py b/example-specs/task/nipype_internal/pydra-slicer/resample_dti_volume_callables.py
new file mode 100644
index 00000000..6821cf16
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/resample_dti_volume_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in ResampleDTIVolume.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/resample_scalar_vector_dwi_volume.yaml b/example-specs/task/nipype_internal/pydra-slicer/resample_scalar_vector_dwi_volume.yaml
new file mode 100644
index 00000000..f13840a1
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/resample_scalar_vector_dwi_volume.yaml
@@ -0,0 +1,143 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.slicer.filtering.resamplescalarvectordwivolume.ResampleScalarVectorDWIVolume' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Resample Scalar/Vector/DWI Volume
+# 
+#     category: Filtering
+# 
+#     description: This module implements image and vector-image resampling through  the use of itk Transforms.It can also handle diffusion weighted MRI image resampling. "Resampling" is performed in space coordinates, not pixel/grid coordinates. It is quite important to ensure that image spacing is properly set on the images involved. The interpolator is required since the mapping from one space to the other will often require evaluation of the intensity of the image at non-grid positions.
+# 
+#     Warning: To resample DWMR Images, use nrrd input and output files.
+# 
+#     Warning: Do not use to resample Diffusion Tensor Images, tensors would  not be reoriented
+# 
+#     version: 0.1
+# 
+#     documentation-url: http://www.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/ResampleScalarVectorDWIVolume
+# 
+#     contributor: Francois Budin (UNC)
+# 
+#     acknowledgements: This work is part of the National Alliance for Medical Image Computing (NAMIC), funded by the National Institutes of Health through the NIH Roadmap for Medical Research, Grant U54 EB005149. Information on the National Centers for Biomedical Computing can be obtained from http://nihroadmap.nih.gov/bioinformatics
+#     
+task_name: ResampleScalarVectorDWIVolume
+nipype_name: ResampleScalarVectorDWIVolume
+nipype_module: nipype.interfaces.slicer.filtering.resamplescalarvectordwivolume
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputVolume: generic/file
+    # type=file|default=<undefined>: Input Volume to be resampled
+    Reference: generic/file
+    # type=file|default=<undefined>: Reference Volume (spacing,size,orientation,origin)
+    transformationFile: generic/file
+    # type=file|default=<undefined>: 
+    defField: generic/file
+    # type=file|default=<undefined>: File containing the deformation field (3D vector image containing vectors with 3 components)
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputVolume: generic/file
+    # type=file: Resampled Volume
+    # type=traitcompound|default=None: Resampled Volume
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputVolume:
+    # type=file|default=<undefined>: Input Volume to be resampled
+    outputVolume:
+    # type=file: Resampled Volume
+    # type=traitcompound|default=None: Resampled Volume
+    Reference:
+    # type=file|default=<undefined>: Reference Volume (spacing,size,orientation,origin)
+    transformationFile:
+    # type=file|default=<undefined>: 
+    defField:
+    # type=file|default=<undefined>: File containing the deformation field (3D vector image containing vectors with 3 components)
+    hfieldtype:
+    # type=enum|default='displacement'|allowed['displacement','h-Field']: Set if the deformation field is an h-Field
+    interpolation:
+    # type=enum|default='linear'|allowed['bs','linear','nn','ws']: Sampling algorithm (linear or nn (nearest neighbor), ws (WindowedSinc), bs (BSpline) )
+    transform_order:
+    # type=enum|default='input-to-output'|allowed['input-to-output','output-to-input']: Select in what order the transforms are read
+    notbulk:
+    # type=bool|default=False: The transform following the BSpline transform is not set as a bulk transform for the BSpline transform
+    spaceChange:
+    # type=bool|default=False: Space Orientation between transform and image is different (RAS/LPS) (warning: if the transform is a Transform Node in Slicer3, do not select)
+    rotation_point:
+    # type=list|default=[]: Rotation Point in case of rotation around a point (otherwise useless)
+    centered_transform:
+    # type=bool|default=False: Set the center of the transformation to the center of the input image
+    image_center:
+    # type=enum|default='input'|allowed['input','output']: Image to use to center the transform (used only if 'Centered Transform' is selected)
+    Inverse_ITK_Transformation:
+    # type=bool|default=False: Inverse the transformation before applying it from output image to input image
+    spacing:
+    # type=inputmultiobject|default=[]: Spacing along each dimension (0 means use input spacing)
+    size:
+    # type=inputmultiobject|default=[]: Size along each dimension (0 means use input size)
+    origin:
+    # type=list|default=[]: Origin of the output Image
+    direction_matrix:
+    # type=inputmultiobject|default=[]: 9 parameters of the direction matrix by rows (ijk to LPS if LPS transform, ijk to RAS if RAS transform)
+    number_of_thread:
+    # type=int|default=0: Number of thread used to compute the output image
+    default_pixel_value:
+    # type=float|default=0.0: Default pixel value for samples falling outside of the input region
+    window_function:
+    # type=enum|default='h'|allowed['b','c','h','l','w']: Window Function , h = Hamming , c = Cosine , w = Welch , l = Lanczos , b = Blackman
+    spline_order:
+    # type=int|default=0: Spline Order
+    transform_matrix:
+    # type=inputmultiobject|default=[]: 12 parameters of the transform matrix by rows ( --last 3 being translation-- )
+    transform:
+    # type=enum|default='rt'|allowed['a','rt']: Transform algorithm, rt = Rigid Transform, a = Affine Transform
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/resample_scalar_vector_dwi_volume_callables.py b/example-specs/task/nipype_internal/pydra-slicer/resample_scalar_vector_dwi_volume_callables.py
new file mode 100644
index 00000000..3c6b487b
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/resample_scalar_vector_dwi_volume_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in ResampleScalarVectorDWIVolume.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/resample_scalar_volume.yaml b/example-specs/task/nipype_internal/pydra-slicer/resample_scalar_volume.yaml
new file mode 100644
index 00000000..a6590101
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/resample_scalar_volume.yaml
@@ -0,0 +1,93 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.slicer.legacy.filtering.ResampleScalarVolume' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Resample Scalar Volume
+# 
+#     category: Legacy.Filtering
+# 
+#     description: Resampling an image is an important task in image analysis. It is especially important in the frame of image registration. This module implements image resampling through the use of itk Transforms. This module uses an Identity Transform. The resampling is controlled by the Output Spacing. "Resampling" is performed in space coordinates, not pixel/grid coordinates. It is quite important to ensure that image spacing is properly set on the images involved. The interpolator is required since the mapping from one space to the other will often require evaluation of the intensity of the image at non-grid positions. Several interpolators are available: linear, nearest neighbor, bspline and five flavors of sinc. The sinc interpolators, although more precise, are much slower than the linear and nearest neighbor interpolator. To resample label volumnes, nearest neighbor interpolation should be used exclusively.
+# 
+#     version: 0.1.0.$Revision: 20594 $(alpha)
+# 
+#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/ResampleVolume
+# 
+#     contributor: Bill Lorensen (GE)
+# 
+#     acknowledgements: This work is part of the National Alliance for Medical Image Computing (NAMIC), funded by the National Institutes of Health through the NIH Roadmap for Medical Research, Grant U54 EB005149.
+#     
+task_name: ResampleScalarVolume
+nipype_name: ResampleScalarVolume
+nipype_module: nipype.interfaces.slicer.legacy.filtering
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    InputVolume: generic/file
+    # type=file|default=<undefined>: Input volume to be resampled
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    OutputVolume: generic/file
+    # type=file: Resampled Volume
+    # type=traitcompound|default=None: Resampled Volume
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    spacing:
+    # type=inputmultiobject|default=[]: Spacing along each dimension (0 means use input spacing)
+    interpolation:
+    # type=enum|default='linear'|allowed['blackman','bspline','cosine','hamming','lanczos','linear','nearestNeighbor','welch']: Sampling algorithm (linear, nearest neighbor, bspline(cubic)  or windowed sinc). There are several sinc algorithms available as described in the following publication: Erik H. W. Meijering, Wiro J. Niessen, Josien P. W. Pluim, Max A. Viergever: Quantitative Comparison of Sinc-Approximating Kernels for Medical Image Interpolation. MICCAI 1999, pp. 210-217. Each window has a radius of 3;
+    InputVolume:
+    # type=file|default=<undefined>: Input volume to be resampled
+    OutputVolume:
+    # type=file: Resampled Volume
+    # type=traitcompound|default=None: Resampled Volume
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/resample_scalar_volume_callables.py b/example-specs/task/nipype_internal/pydra-slicer/resample_scalar_volume_callables.py
new file mode 100644
index 00000000..7615cd03
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/resample_scalar_volume_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in ResampleScalarVolume.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/rigid_registration.yaml b/example-specs/task/nipype_internal/pydra-slicer/rigid_registration.yaml
new file mode 100644
index 00000000..d2db437c
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/rigid_registration.yaml
@@ -0,0 +1,129 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.slicer.legacy.registration.RigidRegistration' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Rigid Registration
+# 
+#     category: Legacy.Registration
+# 
+#     description: Registers two images together using a rigid transform and mutual information.
+# 
+#     This module was originally distributed as "Linear registration" but has been renamed to eliminate confusion with the "Affine registration" module.
+# 
+#     This module is often used to align images of different subjects or images of the same subject from different modalities.
+# 
+#     This module can smooth images prior to registration to mitigate noise and improve convergence. Many of the registration parameters require a working knowledge of the algorithm although the default parameters are sufficient for many registration tasks.
+# 
+# 
+# 
+#     version: 0.1.0.$Revision: 19608 $(alpha)
+# 
+#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/RigidRegistration
+# 
+#     contributor: Daniel Blezek (GE)
+# 
+#     acknowledgements: This module was developed by Daniel Blezek while at GE Research with contributions from Jim Miller.
+# 
+#     This work is part of the National Alliance for Medical Image Computing (NAMIC), funded by the National Institutes of Health through the NIH Roadmap for Medical Research, Grant U54 EB005149.
+#     
+task_name: RigidRegistration
+nipype_name: RigidRegistration
+nipype_module: nipype.interfaces.slicer.legacy.registration
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    initialtransform: generic/file
+    # type=file|default=<undefined>: Initial transform for aligning the fixed and moving image. Maps positions in the fixed coordinate frame to positions in the moving coordinate frame. Optional.
+    FixedImageFileName: generic/file
+    # type=file|default=<undefined>: Fixed image to which to register
+    MovingImageFileName: generic/file
+    # type=file|default=<undefined>: Moving image
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputtransform: generic/file
+    # type=file: Transform calculated that aligns the fixed and moving image. Maps positions in the fixed coordinate frame to the moving coordinate frame. Optional (specify an output transform or an output volume or both).
+    # type=traitcompound|default=None: Transform calculated that aligns the fixed and moving image. Maps positions in the fixed coordinate frame to the moving coordinate frame. Optional (specify an output transform or an output volume or both).
+    resampledmovingfilename: generic/file
+    # type=file: Resampled moving image to the fixed image coordinate frame. Optional (specify an output transform or an output volume or both).
+    # type=traitcompound|default=None: Resampled moving image to the fixed image coordinate frame. Optional (specify an output transform or an output volume or both).
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    fixedsmoothingfactor:
+    # type=int|default=0: Amount of smoothing applied to fixed image prior to registration. Default is 0 (none). Range is 0-5 (unitless). Consider smoothing the input data if there is considerable amounts of noise or the noise pattern in the fixed and moving images is very different.
+    movingsmoothingfactor:
+    # type=int|default=0: Amount of smoothing applied to moving image prior to registration. Default is 0 (none). Range is 0-5 (unitless). Consider smoothing the input data if there is considerable amounts of noise or the noise pattern in the fixed and moving images is very different.
+    testingmode:
+    # type=bool|default=False: Enable testing mode. Input transform will be used to construct floating image. The floating image will be ignored if passed.
+    histogrambins:
+    # type=int|default=0: Number of histogram bins to use for Mattes Mutual Information. Reduce the number of bins if a registration fails. If the number of bins is too large, the estimated PDFs will be a field of impulses and will inhibit reliable registration estimation.
+    spatialsamples:
+    # type=int|default=0: Number of spatial samples to use in estimating Mattes Mutual Information. Larger values yield more accurate PDFs and improved registration quality.
+    iterations:
+    # type=inputmultiobject|default=[]: Comma separated list of iterations. Must have the same number of elements as the learning rate.
+    learningrate:
+    # type=inputmultiobject|default=[]: Comma separated list of learning rates. Learning rate is a scale factor on the gradient of the registration objective function (gradient with respect to the parameters of the transformation) used to update the parameters of the transformation during optimization. Smaller values cause the optimizer to take smaller steps through the parameter space. Larger values are typically used early in the registration process to take large jumps in parameter space followed by smaller values to home in on the optimum value of the registration objective function. Default is: 0.01, 0.005, 0.0005, 0.0002. Must have the same number of elements as iterations.
+    translationscale:
+    # type=float|default=0.0: Relative scale of translations to rotations, i.e. a value of 100 means 10mm = 1 degree. (Actual scale used 1/(TranslationScale^2)). This parameter is used to 'weight' or 'standardized' the transform parameters and their effect on the registration objective function.
+    initialtransform:
+    # type=file|default=<undefined>: Initial transform for aligning the fixed and moving image. Maps positions in the fixed coordinate frame to positions in the moving coordinate frame. Optional.
+    FixedImageFileName:
+    # type=file|default=<undefined>: Fixed image to which to register
+    MovingImageFileName:
+    # type=file|default=<undefined>: Moving image
+    outputtransform:
+    # type=file: Transform calculated that aligns the fixed and moving image. Maps positions in the fixed coordinate frame to the moving coordinate frame. Optional (specify an output transform or an output volume or both).
+    # type=traitcompound|default=None: Transform calculated that aligns the fixed and moving image. Maps positions in the fixed coordinate frame to the moving coordinate frame. Optional (specify an output transform or an output volume or both).
+    resampledmovingfilename:
+    # type=file: Resampled moving image to the fixed image coordinate frame. Optional (specify an output transform or an output volume or both).
+    # type=traitcompound|default=None: Resampled moving image to the fixed image coordinate frame. Optional (specify an output transform or an output volume or both).
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/rigid_registration_callables.py b/example-specs/task/nipype_internal/pydra-slicer/rigid_registration_callables.py
new file mode 100644
index 00000000..6f0d82d1
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/rigid_registration_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in RigidRegistration.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/robust_statistics_segmenter.yaml b/example-specs/task/nipype_internal/pydra-slicer/robust_statistics_segmenter.yaml
new file mode 100644
index 00000000..4d6701b5
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/robust_statistics_segmenter.yaml
@@ -0,0 +1,103 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.slicer.segmentation.specialized.RobustStatisticsSegmenter' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Robust Statistics Segmenter
+# 
+#     category: Segmentation.Specialized
+# 
+#     description: Active contour segmentation using robust statistic.
+# 
+#     version: 1.0
+# 
+#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/RobustStatisticsSegmenter
+# 
+#     contributor: Yi Gao (gatech), Allen Tannenbaum (gatech), Ron Kikinis (SPL, BWH)
+# 
+#     acknowledgements: This work is part of the National Alliance for Medical Image Computing (NAMIC), funded by the National Institutes of Health
+#     
+task_name: RobustStatisticsSegmenter
+nipype_name: RobustStatisticsSegmenter
+nipype_module: nipype.interfaces.slicer.segmentation.specialized
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    originalImageFileName: generic/file
+    # type=file|default=<undefined>: Original image to be segmented
+    labelImageFileName: generic/file
+    # type=file|default=<undefined>: Label image for initialization
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    segmentedImageFileName: generic/file
+    # type=file: Segmented image
+    # type=traitcompound|default=None: Segmented image
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    expectedVolume:
+    # type=float|default=0.0: The approximate volume of the object, in mL.
+    intensityHomogeneity:
+    # type=float|default=0.0: What is the homogeneity of intensity within the object? Given constant intensity at 1.0 score and extreme fluctuating intensity at 0.
+    curvatureWeight:
+    # type=float|default=0.0: Given sphere 1.0 score and extreme rough boundary/surface 0 score, what is the expected smoothness of the object?
+    labelValue:
+    # type=int|default=0: Label value of the output image
+    maxRunningTime:
+    # type=float|default=0.0: The program will stop if this time is reached.
+    originalImageFileName:
+    # type=file|default=<undefined>: Original image to be segmented
+    labelImageFileName:
+    # type=file|default=<undefined>: Label image for initialization
+    segmentedImageFileName:
+    # type=file: Segmented image
+    # type=traitcompound|default=None: Segmented image
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/robust_statistics_segmenter_callables.py b/example-specs/task/nipype_internal/pydra-slicer/robust_statistics_segmenter_callables.py
new file mode 100644
index 00000000..b76d8d39
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/robust_statistics_segmenter_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in RobustStatisticsSegmenter.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/simple_region_growing_segmentation.yaml b/example-specs/task/nipype_internal/pydra-slicer/simple_region_growing_segmentation.yaml
new file mode 100644
index 00000000..d5c7aab2
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/simple_region_growing_segmentation.yaml
@@ -0,0 +1,103 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.slicer.segmentation.simpleregiongrowingsegmentation.SimpleRegionGrowingSegmentation' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Simple Region Growing Segmentation
+# 
+#     category: Segmentation
+# 
+#     description: A simple region growing segmentation algorithm based on intensity statistics. To create a list of fiducials (Seeds) for this algorithm, click on the tool bar icon of an arrow pointing to a starburst fiducial to enter the 'place a new object mode' and then use the fiducials module. This module uses the Slicer Command Line Interface (CLI) and the ITK filters CurvatureFlowImageFilter and ConfidenceConnectedImageFilter.
+# 
+#     version: 0.1.0.$Revision: 19904 $(alpha)
+# 
+#     documentation-url: http://www.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/SimpleRegionGrowingSegmentation
+# 
+#     contributor: Jim Miller (GE)
+# 
+#     acknowledgements: This command module was derived from Insight/Examples (copyright) Insight Software Consortium
+#     
+task_name: SimpleRegionGrowingSegmentation
+nipype_name: SimpleRegionGrowingSegmentation
+nipype_module: nipype.interfaces.slicer.segmentation.simpleregiongrowingsegmentation
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputVolume: generic/file
+    # type=file|default=<undefined>: Input volume to be filtered
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputVolume: generic/file
+    # type=file: Output filtered
+    # type=traitcompound|default=None: Output filtered
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    smoothingIterations:
+    # type=int|default=0: Number of smoothing iterations
+    timestep:
+    # type=float|default=0.0: Timestep for curvature flow
+    iterations:
+    # type=int|default=0: Number of iterations of region growing
+    multiplier:
+    # type=float|default=0.0: Number of standard deviations to include in intensity model
+    neighborhood:
+    # type=int|default=0: The radius of the neighborhood over which to calculate intensity model
+    labelvalue:
+    # type=int|default=0: The integer value (0-255) to use for the segmentation results. This will determine the color of the segmentation that will be generated by the Region growing algorithm
+    seed:
+    # type=inputmultiobject|default=[]: Seed point(s) for region growing
+    inputVolume:
+    # type=file|default=<undefined>: Input volume to be filtered
+    outputVolume:
+    # type=file: Output filtered
+    # type=traitcompound|default=None: Output filtered
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/simple_region_growing_segmentation_callables.py b/example-specs/task/nipype_internal/pydra-slicer/simple_region_growing_segmentation_callables.py
new file mode 100644
index 00000000..e90f6103
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/simple_region_growing_segmentation_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in SimpleRegionGrowingSegmentation.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/subtract_scalar_volumes.yaml b/example-specs/task/nipype_internal/pydra-slicer/subtract_scalar_volumes.yaml
new file mode 100644
index 00000000..62b60dda
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/subtract_scalar_volumes.yaml
@@ -0,0 +1,95 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.slicer.filtering.arithmetic.SubtractScalarVolumes' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Subtract Scalar Volumes
+# 
+#     category: Filtering.Arithmetic
+# 
+#     description: Subtracts two images. Although all image types are supported on input, only signed types are produced. The two images do not have to have the same dimensions.
+# 
+#     version: 0.1.0.$Revision: 19608 $(alpha)
+# 
+#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/Subtract
+# 
+#     contributor: Bill Lorensen (GE)
+# 
+#     acknowledgements: This work is part of the National Alliance for Medical Image Computing (NAMIC), funded by the National Institutes of Health through the NIH Roadmap for Medical Research, Grant U54 EB005149.
+#     
+task_name: SubtractScalarVolumes
+nipype_name: SubtractScalarVolumes
+nipype_module: nipype.interfaces.slicer.filtering.arithmetic
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputVolume1: generic/file
+    # type=file|default=<undefined>: Input volume 1
+    inputVolume2: generic/file
+    # type=file|default=<undefined>: Input volume 2
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputVolume: generic/file
+    # type=file: Volume1 - Volume2
+    # type=traitcompound|default=None: Volume1 - Volume2
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    inputVolume1:
+    # type=file|default=<undefined>: Input volume 1
+    inputVolume2:
+    # type=file|default=<undefined>: Input volume 2
+    outputVolume:
+    # type=file: Volume1 - Volume2
+    # type=traitcompound|default=None: Volume1 - Volume2
+    order:
+    # type=enum|default='0'|allowed['0','1','2','3']: Interpolation order if two images are in different coordinate frames or have different sampling.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/subtract_scalar_volumes_callables.py b/example-specs/task/nipype_internal/pydra-slicer/subtract_scalar_volumes_callables.py
new file mode 100644
index 00000000..718dd062
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/subtract_scalar_volumes_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in SubtractScalarVolumes.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/threshold_scalar_volume.yaml b/example-specs/task/nipype_internal/pydra-slicer/threshold_scalar_volume.yaml
new file mode 100644
index 00000000..07ebd4a3
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/threshold_scalar_volume.yaml
@@ -0,0 +1,99 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.slicer.filtering.thresholdscalarvolume.ThresholdScalarVolume' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Threshold Scalar Volume
+# 
+#     category: Filtering
+# 
+#     description: <p>Threshold an image.</p><p>Set image values to a user-specified outside value if they are below, above, or between simple threshold values.</p><p>ThresholdAbove: The values greater than or equal to the threshold value are set to OutsideValue.</p><p>ThresholdBelow: The values less than or equal to the threshold value are set to OutsideValue.</p><p>ThresholdOutside: The values outside the range Lower-Upper are set to OutsideValue.</p><p>Although all image types are supported on input, only signed types are produced.</p><p>
+# 
+#     version: 0.1.0.$Revision: 2104 $(alpha)
+# 
+#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/Threshold
+# 
+#     contributor: Nicole Aucoin (SPL, BWH), Ron Kikinis (SPL, BWH)
+# 
+#     acknowledgements: This work is part of the National Alliance for Medical Image Computing (NAMIC), funded by the National Institutes of Health through the NIH Roadmap for Medical Research, Grant U54 EB005149.
+#     
+task_name: ThresholdScalarVolume
+nipype_name: ThresholdScalarVolume
+nipype_module: nipype.interfaces.slicer.filtering.thresholdscalarvolume
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    InputVolume: generic/file
+    # type=file|default=<undefined>: Input volume
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    OutputVolume: generic/file
+    # type=file: Thresholded input volume
+    # type=traitcompound|default=None: Thresholded input volume
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    InputVolume:
+    # type=file|default=<undefined>: Input volume
+    OutputVolume:
+    # type=file: Thresholded input volume
+    # type=traitcompound|default=None: Thresholded input volume
+    threshold:
+    # type=int|default=0: Threshold value
+    lower:
+    # type=int|default=0: Lower threshold value
+    upper:
+    # type=int|default=0: Upper threshold value
+    outsidevalue:
+    # type=int|default=0: Set the voxels to this value if they fall outside the threshold range
+    thresholdtype:
+    # type=enum|default='Below'|allowed['Above','Below','Outside']: What kind of threshold to perform. If Outside is selected, uses Upper and Lower values. If Below is selected, uses the ThresholdValue, if Above is selected, uses the ThresholdValue.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/threshold_scalar_volume_callables.py b/example-specs/task/nipype_internal/pydra-slicer/threshold_scalar_volume_callables.py
new file mode 100644
index 00000000..883d5b5e
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/threshold_scalar_volume_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in ThresholdScalarVolume.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/tractography_label_map_seeding.yaml b/example-specs/task/nipype_internal/pydra-slicer/tractography_label_map_seeding.yaml
new file mode 100644
index 00000000..fcc9a4ed
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/tractography_label_map_seeding.yaml
@@ -0,0 +1,127 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.slicer.diffusion.diffusion.TractographyLabelMapSeeding' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Tractography Label Map Seeding
+# 
+#     category: Diffusion.Diffusion Tensor Images
+# 
+#     description: Seed tracts on a Diffusion Tensor Image (DT) from a label map
+# 
+#     version: 0.1.0.$Revision: 1892 $(alpha)
+# 
+#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/Seeding
+# 
+#     license: slicer3
+# 
+#     contributor: Raul San Jose (SPL, BWH), Demian Wassermann (SPL, BWH)
+# 
+#     acknowledgements: Laboratory of Mathematics in Imaging. This work is part of the National Alliance for Medical Image Computing (NAMIC), funded by the National Institutes of Health through the NIH Roadmap for Medical Research, Grant U54 EB005149.
+#     
+task_name: TractographyLabelMapSeeding
+nipype_name: TractographyLabelMapSeeding
+nipype_module: nipype.interfaces.slicer.diffusion.diffusion
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    InputVolume: generic/file
+    # type=file|default=<undefined>: Input DTI volume
+    inputroi: generic/file
+    # type=file|default=<undefined>: Label map with seeding ROIs
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    OutputFibers: generic/file
+    # type=file: Tractography result
+    # type=traitcompound|default=None: Tractography result
+    outputdirectory: generic/directory
+    # type=directory: Directory in which to save fiber(s)
+    # type=traitcompound|default=None: Directory in which to save fiber(s)
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    InputVolume:
+    # type=file|default=<undefined>: Input DTI volume
+    inputroi:
+    # type=file|default=<undefined>: Label map with seeding ROIs
+    OutputFibers:
+    # type=file: Tractography result
+    # type=traitcompound|default=None: Tractography result
+    useindexspace:
+    # type=bool|default=False: Seed at IJK voxel grid
+    seedspacing:
+    # type=float|default=0.0: Spacing (in mm) between seed points, only matters if use Use Index Space is off
+    randomgrid:
+    # type=bool|default=False: Enable random placing of seeds
+    clthreshold:
+    # type=float|default=0.0: Minimum Linear Measure for the seeding to start.
+    minimumlength:
+    # type=float|default=0.0: Minimum length of the fibers (in mm)
+    maximumlength:
+    # type=float|default=0.0: Maximum length of fibers (in mm)
+    stoppingmode:
+    # type=enum|default='LinearMeasure'|allowed['FractionalAnisotropy','LinearMeasure']: Tensor measurement used to stop the tractography
+    stoppingvalue:
+    # type=float|default=0.0: Tractography will stop when the stopping measurement drops below this value
+    stoppingcurvature:
+    # type=float|default=0.0: Tractography will stop if radius of curvature becomes smaller than this number units are degrees per mm
+    integrationsteplength:
+    # type=float|default=0.0: Distance between points on the same fiber in mm
+    label:
+    # type=int|default=0: Label value that defines seeding region.
+    writetofile:
+    # type=bool|default=False: Write fibers to disk or create in the scene?
+    outputdirectory:
+    # type=directory: Directory in which to save fiber(s)
+    # type=traitcompound|default=None: Directory in which to save fiber(s)
+    name:
+    # type=str|default='': Name to use for fiber files
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/tractography_label_map_seeding_callables.py b/example-specs/task/nipype_internal/pydra-slicer/tractography_label_map_seeding_callables.py
new file mode 100644
index 00000000..31cacc7a
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/tractography_label_map_seeding_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in TractographyLabelMapSeeding.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/vbrains_demon_warp.yaml b/example-specs/task/nipype_internal/pydra-slicer/vbrains_demon_warp.yaml
new file mode 100644
index 00000000..28ad182e
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/vbrains_demon_warp.yaml
@@ -0,0 +1,190 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.slicer.registration.specialized.VBRAINSDemonWarp' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Vector Demon Registration (BRAINS)
+# 
+#     category: Registration.Specialized
+# 
+#     description:
+#         This program finds a deformation field to warp a moving image onto a fixed image.  The images must be of the same signal kind, and contain an image of the same kind of object.  This program uses the Thirion Demons warp software in ITK, the Insight Toolkit.  Additional information is available at: http://www.nitrc.org/projects/brainsdemonwarp.
+# 
+# 
+# 
+#     version: 3.0.0
+# 
+#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Modules:BRAINSDemonWarp
+# 
+#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
+# 
+#     contributor: This tool was developed by Hans J. Johnson and Greg Harris.
+# 
+#     acknowledgements: The development of this tool was supported by funding from grants NS050568 and NS40068 from the National Institute of Neurological Disorders and Stroke and grants MH31593, MH40856, from the National Institute of Mental Health.
+#     
+task_name: VBRAINSDemonWarp
+nipype_name: VBRAINSDemonWarp
+nipype_module: nipype.interfaces.slicer.registration.specialized
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    movingVolume: generic/file+list-of
+    # type=inputmultiobject|default=[]: Required: input moving image
+    fixedVolume: generic/file+list-of
+    # type=inputmultiobject|default=[]: Required: input fixed (target) image
+    initializeWithDisplacementField: generic/file
+    # type=file|default=<undefined>: Initial deformation field vector image file name
+    initializeWithTransform: generic/file
+    # type=file|default=<undefined>: Initial Transform filename
+    fixedBinaryVolume: generic/file
+    # type=file|default=<undefined>: Mask filename for desired region of interest in the Fixed image.
+    movingBinaryVolume: generic/file
+    # type=file|default=<undefined>: Mask filename for desired region of interest in the Moving image.
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputVolume: generic/file
+    # type=file: Required: output resampled moving image (will have the same physical space as the fixedVolume).
+    # type=traitcompound|default=None: Required: output resampled moving image (will have the same physical space as the fixedVolume).
+    outputDisplacementFieldVolume: generic/file
+    # type=file: Output deformation field vector image (will have the same physical space as the fixedVolume).
+    # type=traitcompound|default=None: Output deformation field vector image (will have the same physical space as the fixedVolume).
+    outputCheckerboardVolume: generic/file
+    # type=file: Genete a checkerboard image volume between the fixedVolume and the deformed movingVolume.
+    # type=traitcompound|default=None: Genete a checkerboard image volume between the fixedVolume and the deformed movingVolume.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    movingVolume:
+    # type=inputmultiobject|default=[]: Required: input moving image
+    fixedVolume:
+    # type=inputmultiobject|default=[]: Required: input fixed (target) image
+    inputPixelType:
+    # type=enum|default='float'|allowed['float','int','short','uchar','ushort']: Input volumes will be typecast to this format: float|short|ushort|int|uchar
+    outputVolume:
+    # type=file: Required: output resampled moving image (will have the same physical space as the fixedVolume).
+    # type=traitcompound|default=None: Required: output resampled moving image (will have the same physical space as the fixedVolume).
+    outputDisplacementFieldVolume:
+    # type=file: Output deformation field vector image (will have the same physical space as the fixedVolume).
+    # type=traitcompound|default=None: Output deformation field vector image (will have the same physical space as the fixedVolume).
+    outputPixelType:
+    # type=enum|default='float'|allowed['float','int','short','uchar','ushort']: outputVolume will be typecast to this format: float|short|ushort|int|uchar
+    interpolationMode:
+    # type=enum|default='NearestNeighbor'|allowed['BSpline','Blackman','Cosine','Hamming','Lanczos','Linear','NearestNeighbor','ResampleInPlace','Welch','WindowedSinc']: Type of interpolation to be used when applying transform to moving volume.  Options are Linear, ResampleInPlace, NearestNeighbor, BSpline, or WindowedSinc
+    registrationFilterType:
+    # type=enum|default='Demons'|allowed['Demons','Diffeomorphic','FastSymmetricForces','LogDemons','SymmetricLogDemons']: Registration Filter Type: Demons|FastSymmetricForces|Diffeomorphic|LogDemons|SymmetricLogDemons
+    smoothDisplacementFieldSigma:
+    # type=float|default=0.0: A gaussian smoothing value to be applied to the deformation field at each iteration.
+    numberOfPyramidLevels:
+    # type=int|default=0: Number of image pyramid levels to use in the multi-resolution registration.
+    minimumFixedPyramid:
+    # type=inputmultiobject|default=[]: The shrink factor for the first level of the fixed image pyramid. (i.e. start at 1/16 scale, then 1/8, then 1/4, then 1/2, and finally full scale)
+    minimumMovingPyramid:
+    # type=inputmultiobject|default=[]: The shrink factor for the first level of the moving image pyramid. (i.e. start at 1/16 scale, then 1/8, then 1/4, then 1/2, and finally full scale)
+    arrayOfPyramidLevelIterations:
+    # type=inputmultiobject|default=[]: The number of iterations for each pyramid level
+    histogramMatch:
+    # type=bool|default=False: Histogram Match the input images.  This is suitable for images of the same modality that may have different absolute scales, but the same overall intensity profile.
+    numberOfHistogramBins:
+    # type=int|default=0: The number of histogram levels
+    numberOfMatchPoints:
+    # type=int|default=0: The number of match points for histrogramMatch
+    medianFilterSize:
+    # type=inputmultiobject|default=[]: Median filter radius in all 3 directions.  When images have a lot of salt and pepper noise, this step can improve the registration.
+    initializeWithDisplacementField:
+    # type=file|default=<undefined>: Initial deformation field vector image file name
+    initializeWithTransform:
+    # type=file|default=<undefined>: Initial Transform filename
+    makeBOBF:
+    # type=bool|default=False: Flag to make Brain-Only Background-Filled versions of the input and target volumes.
+    fixedBinaryVolume:
+    # type=file|default=<undefined>: Mask filename for desired region of interest in the Fixed image.
+    movingBinaryVolume:
+    # type=file|default=<undefined>: Mask filename for desired region of interest in the Moving image.
+    lowerThresholdForBOBF:
+    # type=int|default=0: Lower threshold for performing BOBF
+    upperThresholdForBOBF:
+    # type=int|default=0: Upper threshold for performing BOBF
+    backgroundFillValue:
+    # type=int|default=0: Replacement value to overwrite background when performing BOBF
+    seedForBOBF:
+    # type=inputmultiobject|default=[]: coordinates in all 3 directions for Seed when performing BOBF
+    neighborhoodForBOBF:
+    # type=inputmultiobject|default=[]: neighborhood in all 3 directions to be included when performing BOBF
+    outputDisplacementFieldPrefix:
+    # type=str|default='': Displacement field filename prefix for writing separate x, y, and z component images
+    outputCheckerboardVolume:
+    # type=file: Genete a checkerboard image volume between the fixedVolume and the deformed movingVolume.
+    # type=traitcompound|default=None: Genete a checkerboard image volume between the fixedVolume and the deformed movingVolume.
+    checkerboardPatternSubdivisions:
+    # type=inputmultiobject|default=[]: Number of Checkerboard subdivisions in all 3 directions
+    outputNormalized:
+    # type=bool|default=False: Flag to warp and write the normalized images to output.  In normalized images the image values are fit-scaled to be between 0 and the maximum storage type value.
+    outputDebug:
+    # type=bool|default=False: Flag to write debugging images after each step.
+    weightFactors:
+    # type=inputmultiobject|default=[]: Weight fatctors for each input images
+    gradient_type:
+    # type=enum|default='0'|allowed['0','1','2']: Type of gradient used for computing the demons force (0 is symmetrized, 1 is fixed image, 2 is moving image)
+    upFieldSmoothing:
+    # type=float|default=0.0: Smoothing sigma for the update field at each iteration
+    max_step_length:
+    # type=float|default=0.0: Maximum length of an update vector (0: no restriction)
+    use_vanilla_dem:
+    # type=bool|default=False: Run vanilla demons algorithm
+    gui:
+    # type=bool|default=False: Display intermediate image volumes for debugging
+    promptUser:
+    # type=bool|default=False: Prompt the user to hit enter each time an image is sent to the DebugImageViewer
+    numberOfBCHApproximationTerms:
+    # type=int|default=0: Number of terms in the BCH expansion
+    numberOfThreads:
+    # type=int|default=0: Explicitly specify the maximum number of threads to use.
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/vbrains_demon_warp_callables.py b/example-specs/task/nipype_internal/pydra-slicer/vbrains_demon_warp_callables.py
new file mode 100644
index 00000000..c1ed6ee7
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/vbrains_demon_warp_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in VBRAINSDemonWarp.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/voting_binary_hole_filling_image_filter.yaml b/example-specs/task/nipype_internal/pydra-slicer/voting_binary_hole_filling_image_filter.yaml
new file mode 100644
index 00000000..e052d5e6
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/voting_binary_hole_filling_image_filter.yaml
@@ -0,0 +1,97 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.slicer.filtering.votingbinaryholefillingimagefilter.VotingBinaryHoleFillingImageFilter' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# title: Voting Binary Hole Filling Image Filter
+# 
+#     category: Filtering
+# 
+#     description: Applies a voting operation in order to fill-in cavities. This can be used for smoothing contours and for filling holes in binary images. This technique is used frequently when segmenting complete organs that may have ducts or vasculature that may not have been included in the initial segmentation, e.g. lungs, kidneys, liver.
+# 
+#     version: 0.1.0.$Revision: 19608 $(alpha)
+# 
+#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/VotingBinaryHoleFillingImageFilter
+# 
+#     contributor: Bill Lorensen (GE)
+# 
+#     acknowledgements: This command module was derived from Insight/Examples/Filtering/VotingBinaryHoleFillingImageFilter (copyright) Insight Software Consortium
+#     
+task_name: VotingBinaryHoleFillingImageFilter
+nipype_name: VotingBinaryHoleFillingImageFilter
+nipype_module: nipype.interfaces.slicer.filtering.votingbinaryholefillingimagefilter
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    inputVolume: generic/file
+    # type=file|default=<undefined>: Input volume to be filtered
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    outputVolume: generic/file
+    # type=file: Output filtered
+    # type=traitcompound|default=None: Output filtered
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    radius:
+    # type=inputmultiobject|default=[]: The radius of a hole to be filled
+    majorityThreshold:
+    # type=int|default=0: The number of pixels over 50% that will decide whether an OFF pixel will become ON or not. For example, if the neighborhood of a pixel has 124 pixels (excluding itself), the 50% will be 62, and if you set a Majority threshold of 5, that means that the filter will require 67 or more neighbor pixels to be ON in order to switch the current OFF pixel to ON.
+    background:
+    # type=int|default=0: The value associated with the background (not object)
+    foreground:
+    # type=int|default=0: The value associated with the foreground (object)
+    inputVolume:
+    # type=file|default=<undefined>: Input volume to be filtered
+    outputVolume:
+    # type=file: Output filtered
+    # type=traitcompound|default=None: Output filtered
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/voting_binary_hole_filling_image_filter_callables.py b/example-specs/task/nipype_internal/pydra-slicer/voting_binary_hole_filling_image_filter_callables.py
new file mode 100644
index 00000000..decc36e1
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-slicer/voting_binary_hole_filling_image_filter_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in VotingBinaryHoleFillingImageFilter.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-spm/analyze_2nii.yaml b/example-specs/task/nipype_internal/pydra-spm/analyze_2nii.yaml
new file mode 100644
index 00000000..1a4817be
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-spm/analyze_2nii.yaml
@@ -0,0 +1,86 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.spm.utils.Analyze2nii' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+task_name: Analyze2nii
+nipype_name: Analyze2nii
+nipype_module: nipype.interfaces.spm.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    analyze_file: generic/file
+    # type=file|default=<undefined>: 
+    paths: generic/directory+list-of
+    # type=inputmultiobject: Paths to add to matlabpath
+    # type=inputmultiobject|default=[]: Paths to add to matlabpath
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    nifti_file: generic/file
+    # type=file: 
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    analyze_file:
+    # type=file|default=<undefined>: 
+    matlab_cmd:
+    # type=str: matlab command to use
+    # type=str|default='': matlab command to use
+    paths:
+    # type=inputmultiobject: Paths to add to matlabpath
+    # type=inputmultiobject|default=[]: Paths to add to matlabpath
+    mfile:
+    # type=bool: Run m-code using m-file
+    # type=bool|default=True: Run m-code using m-file
+    use_mcr:
+    # type=bool: Run m-code using SPM MCR
+    # type=bool|default=False: Run m-code using SPM MCR
+    use_v8struct:
+    # type=bool: Generate SPM8 and higher compatible jobs
+    # type=bool|default=True: Generate SPM8 and higher compatible jobs
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-spm/analyze_2nii_callables.py b/example-specs/task/nipype_internal/pydra-spm/analyze_2nii_callables.py
new file mode 100644
index 00000000..533b5f29
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-spm/analyze_2nii_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Analyze2nii.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-spm/apply_deformations.yaml b/example-specs/task/nipype_internal/pydra-spm/apply_deformations.yaml
new file mode 100644
index 00000000..09201361
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-spm/apply_deformations.yaml
@@ -0,0 +1,84 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.spm.preprocess.ApplyDeformations' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+task_name: ApplyDeformations
+nipype_name: ApplyDeformations
+nipype_module: nipype.interfaces.spm.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    deformation_field: generic/file
+    # type=file|default=<undefined>: 
+    paths: generic/directory+list-of
+    # type=inputmultiobject|default=[]: Paths to add to matlabpath
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_files:
+    # type=inputmultiobject|default=[]: 
+    deformation_field:
+    # type=file|default=<undefined>: 
+    reference_volume:
+    # type=imagefilespm|default=<undefined>: 
+    interp:
+    # type=range|default=0: degree of b-spline used for interpolation
+    matlab_cmd:
+    # type=str|default='': matlab command to use
+    paths:
+    # type=inputmultiobject|default=[]: Paths to add to matlabpath
+    mfile:
+    # type=bool|default=True: Run m-code using m-file
+    use_mcr:
+    # type=bool|default=False: Run m-code using SPM MCR
+    use_v8struct:
+    # type=bool|default=True: Generate SPM8 and higher compatible jobs
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-spm/apply_deformations_callables.py b/example-specs/task/nipype_internal/pydra-spm/apply_deformations_callables.py
new file mode 100644
index 00000000..5b50cdc2
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-spm/apply_deformations_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in ApplyDeformations.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-spm/apply_inverse_deformation.yaml b/example-specs/task/nipype_internal/pydra-spm/apply_inverse_deformation.yaml
new file mode 100644
index 00000000..19054119
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-spm/apply_inverse_deformation.yaml
@@ -0,0 +1,108 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.spm.utils.ApplyInverseDeformation' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Uses spm to apply inverse deformation stored in a .mat file or a
+#     deformation field to a given file
+# 
+#     Examples
+#     --------
+# 
+#     >>> import nipype.interfaces.spm.utils as spmu
+#     >>> inv = spmu.ApplyInverseDeformation()
+#     >>> inv.inputs.in_files = 'functional.nii'
+#     >>> inv.inputs.deformation = 'struct_to_func.mat'
+#     >>> inv.inputs.target = 'structural.nii'
+#     >>> inv.run() # doctest: +SKIP
+#     
+task_name: ApplyInverseDeformation
+nipype_name: ApplyInverseDeformation
+nipype_module: nipype.interfaces.spm.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_files: generic/file+list-of
+    # type=inputmultiobject|default=[]: Files on which deformation is applied
+    target: generic/file
+    # type=file|default=<undefined>: File defining target space
+    deformation: generic/file
+    # type=file|default=<undefined>: SN SPM deformation file
+    deformation_field: generic/file
+    # type=file|default=<undefined>: SN SPM deformation file
+    paths: generic/directory+list-of
+    # type=inputmultiobject|default=[]: Paths to add to matlabpath
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_files:
+    # type=inputmultiobject|default=[]: Files on which deformation is applied
+    target:
+    # type=file|default=<undefined>: File defining target space
+    deformation:
+    # type=file|default=<undefined>: SN SPM deformation file
+    deformation_field:
+    # type=file|default=<undefined>: SN SPM deformation file
+    interpolation:
+    # type=range|default=0: degree of b-spline used for interpolation
+    bounding_box:
+    # type=list|default=[]: 6-element list (opt)
+    voxel_sizes:
+    # type=list|default=[]: 3-element list (opt)
+    matlab_cmd:
+    # type=str|default='': matlab command to use
+    paths:
+    # type=inputmultiobject|default=[]: Paths to add to matlabpath
+    mfile:
+    # type=bool|default=True: Run m-code using m-file
+    use_mcr:
+    # type=bool|default=False: Run m-code using SPM MCR
+    use_v8struct:
+    # type=bool|default=True: Generate SPM8 and higher compatible jobs
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-spm/apply_inverse_deformation_callables.py b/example-specs/task/nipype_internal/pydra-spm/apply_inverse_deformation_callables.py
new file mode 100644
index 00000000..d10710f5
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-spm/apply_inverse_deformation_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in ApplyInverseDeformation.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-spm/apply_transform.yaml b/example-specs/task/nipype_internal/pydra-spm/apply_transform.yaml
new file mode 100644
index 00000000..f6f770d9
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-spm/apply_transform.yaml
@@ -0,0 +1,102 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.spm.utils.ApplyTransform' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Uses SPM to apply transform stored in a .mat file to given file
+# 
+#     Examples
+#     --------
+# 
+#     >>> import nipype.interfaces.spm.utils as spmu
+#     >>> applymat = spmu.ApplyTransform()
+#     >>> applymat.inputs.in_file = 'functional.nii'
+#     >>> applymat.inputs.mat = 'func_to_struct.mat'
+#     >>> applymat.run() # doctest: +SKIP
+# 
+#     
+task_name: ApplyTransform
+nipype_name: ApplyTransform
+nipype_module: nipype.interfaces.spm.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: file to apply transform to, (only updates header)
+    mat: generic/file
+    # type=file|default=<undefined>: file holding transform to apply
+    paths: generic/directory+list-of
+    # type=inputmultiobject|default=[]: Paths to add to matlabpath
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: Transformed image file
+    # type=file|default=<undefined>: output file name for transformed data
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: out_file
+    # type=file: Transformed image file
+    # type=file|default=<undefined>: output file name for transformed data
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: file to apply transform to, (only updates header)
+    mat:
+    # type=file|default=<undefined>: file holding transform to apply
+    out_file:
+    # type=file: Transformed image file
+    # type=file|default=<undefined>: output file name for transformed data
+    matlab_cmd:
+    # type=str|default='': matlab command to use
+    paths:
+    # type=inputmultiobject|default=[]: Paths to add to matlabpath
+    mfile:
+    # type=bool|default=True: Run m-code using m-file
+    use_mcr:
+    # type=bool|default=False: Run m-code using SPM MCR
+    use_v8struct:
+    # type=bool|default=True: Generate SPM8 and higher compatible jobs
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-spm/apply_transform_callables.py b/example-specs/task/nipype_internal/pydra-spm/apply_transform_callables.py
new file mode 100644
index 00000000..61ab1d08
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-spm/apply_transform_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in ApplyTransform.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-spm/apply_vdm.yaml b/example-specs/task/nipype_internal/pydra-spm/apply_vdm.yaml
new file mode 100644
index 00000000..e6f9dfce
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-spm/apply_vdm.yaml
@@ -0,0 +1,103 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.spm.preprocess.ApplyVDM' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Use the fieldmap toolbox from spm to apply the voxel displacement map (VDM) to some epi files.
+# 
+#     http://www.fil.ion.ucl.ac.uk/spm/doc/manual.pdf#page=173
+# 
+#     .. important::
+# 
+#         This interface does not deal with real/imag magnitude images nor
+#         with the two phase files case.
+# 
+#     
+task_name: ApplyVDM
+nipype_name: ApplyVDM
+nipype_module: nipype.interfaces.spm.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    vdmfile: generic/file
+    # type=file|default=<undefined>: Voxel displacement map to use
+    paths: generic/directory+list-of
+    # type=inputmultiobject|default=[]: Paths to add to matlabpath
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    mean_image: generic/file
+    # type=file: Mean image
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_files:
+    # type=inputmultiobject|default=[]: list of filenames to apply the vdm to
+    vdmfile:
+    # type=file|default=<undefined>: Voxel displacement map to use
+    distortion_direction:
+    # type=int|default=2: phase encode direction input data have been acquired with
+    write_which:
+    # type=list|default=[2, 1]: If the first value is non-zero, reslice all images. If the second value is non-zero, reslice a mean image.
+    interpolation:
+    # type=range|default=4: degree of b-spline used for interpolation
+    write_wrap:
+    # type=list|default=[]: Check if interpolation should wrap in [x,y,z]
+    write_mask:
+    # type=bool|default=False: True/False mask time series images
+    out_prefix:
+    # type=string|default='u': fieldmap corrected output prefix
+    matlab_cmd:
+    # type=str|default='': matlab command to use
+    paths:
+    # type=inputmultiobject|default=[]: Paths to add to matlabpath
+    mfile:
+    # type=bool|default=True: Run m-code using m-file
+    use_mcr:
+    # type=bool|default=False: Run m-code using SPM MCR
+    use_v8struct:
+    # type=bool|default=True: Generate SPM8 and higher compatible jobs
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-spm/apply_vdm_callables.py b/example-specs/task/nipype_internal/pydra-spm/apply_vdm_callables.py
new file mode 100644
index 00000000..8ae8805c
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-spm/apply_vdm_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in ApplyVDM.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-spm/calc_coreg_affine.yaml b/example-specs/task/nipype_internal/pydra-spm/calc_coreg_affine.yaml
new file mode 100644
index 00000000..a53be158
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-spm/calc_coreg_affine.yaml
@@ -0,0 +1,120 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.spm.utils.CalcCoregAffine' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Uses SPM (spm_coreg) to calculate the transform mapping
+#     moving to target. Saves Transform in mat (matlab binary file)
+#     Also saves inverse transform
+# 
+#     Examples
+#     --------
+# 
+#     >>> import nipype.interfaces.spm.utils as spmu
+#     >>> coreg = spmu.CalcCoregAffine(matlab_cmd='matlab-spm8')
+#     >>> coreg.inputs.target = 'structural.nii'
+#     >>> coreg.inputs.moving = 'functional.nii'
+#     >>> coreg.inputs.mat = 'func_to_struct.mat'
+#     >>> coreg.run() # doctest: +SKIP
+# 
+#     .. note::
+# 
+#      * the output file mat is saves as a matlab binary file
+#      * calculating the transforms does NOT change either input image
+#        it does not **move** the moving image, only calculates the transform
+#        that can be used to move it
+#     
+task_name: CalcCoregAffine
+nipype_name: CalcCoregAffine
+nipype_module: nipype.interfaces.spm.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    target: generic/file
+    # type=file|default=<undefined>: target for generating affine transform
+    moving: generic/file
+    # type=file|default=<undefined>: volume transform can be applied to register with target
+    mat: generic/file
+    # type=file: Matlab file holding transform
+    # type=file|default=<undefined>: Filename used to store affine matrix
+    invmat: generic/file
+    # type=file: Matlab file holding inverse transform
+    # type=file|default=<undefined>: Filename used to store inverse affine matrix
+    paths: generic/directory+list-of
+    # type=inputmultiobject|default=[]: Paths to add to matlabpath
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    mat: generic/file
+    # type=file: Matlab file holding transform
+    # type=file|default=<undefined>: Filename used to store affine matrix
+    invmat: generic/file
+    # type=file: Matlab file holding inverse transform
+    # type=file|default=<undefined>: Filename used to store inverse affine matrix
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    target:
+    # type=file|default=<undefined>: target for generating affine transform
+    moving:
+    # type=file|default=<undefined>: volume transform can be applied to register with target
+    mat:
+    # type=file: Matlab file holding transform
+    # type=file|default=<undefined>: Filename used to store affine matrix
+    invmat:
+    # type=file: Matlab file holding inverse transform
+    # type=file|default=<undefined>: Filename used to store inverse affine matrix
+    matlab_cmd:
+    # type=str|default='': matlab command to use
+    paths:
+    # type=inputmultiobject|default=[]: Paths to add to matlabpath
+    mfile:
+    # type=bool|default=True: Run m-code using m-file
+    use_mcr:
+    # type=bool|default=False: Run m-code using SPM MCR
+    use_v8struct:
+    # type=bool|default=True: Generate SPM8 and higher compatible jobs
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-spm/calc_coreg_affine_callables.py b/example-specs/task/nipype_internal/pydra-spm/calc_coreg_affine_callables.py
new file mode 100644
index 00000000..5a37d161
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-spm/calc_coreg_affine_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in CalcCoregAffine.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-spm/coregister.yaml b/example-specs/task/nipype_internal/pydra-spm/coregister.yaml
new file mode 100644
index 00000000..67c35d0c
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-spm/coregister.yaml
@@ -0,0 +1,113 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.spm.preprocess.Coregister' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Use spm_coreg for estimating cross-modality rigid body alignment
+# 
+#     http://www.fil.ion.ucl.ac.uk/spm/doc/manual.pdf#page=39
+# 
+#     Examples
+#     --------
+# 
+#     >>> import nipype.interfaces.spm as spm
+#     >>> coreg = spm.Coregister()
+#     >>> coreg.inputs.target = 'functional.nii'
+#     >>> coreg.inputs.source = 'structural.nii'
+#     >>> coreg.run() # doctest: +SKIP
+# 
+#     
+task_name: Coregister
+nipype_name: Coregister
+nipype_module: nipype.interfaces.spm.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    apply_to_files: generic/file+list-of
+    # type=inputmultiobject|default=[]: files to apply transformation to
+    paths: generic/directory+list-of
+    # type=inputmultiobject|default=[]: Paths to add to matlabpath
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    target:
+    # type=imagefilespm|default=<undefined>: reference file to register to
+    source:
+    # type=inputmultiobject|default=[]: file to register to target
+    jobtype:
+    # type=enum|default='estwrite'|allowed['estimate','estwrite','write']: one of: estimate, write, estwrite
+    apply_to_files:
+    # type=inputmultiobject|default=[]: files to apply transformation to
+    cost_function:
+    # type=enum|default='mi'|allowed['ecc','mi','ncc','nmi']: cost function, one of:                     'mi' - Mutual Information,                     'nmi' - Normalised Mutual Information,                     'ecc' - Entropy Correlation Coefficient,                     'ncc' - Normalised Cross Correlation
+    fwhm:
+    # type=list|default=[]: gaussian smoothing kernel width (mm)
+    separation:
+    # type=list|default=[]: sampling separation in mm
+    tolerance:
+    # type=list|default=[]: acceptable tolerance for each of 12 params
+    write_interp:
+    # type=range|default=0: degree of b-spline used for interpolation
+    write_wrap:
+    # type=list|default=[]: Check if interpolation should wrap in [x,y,z]
+    write_mask:
+    # type=bool|default=False: True/False mask output image
+    out_prefix:
+    # type=string|default='r': coregistered output prefix
+    matlab_cmd:
+    # type=str|default='': matlab command to use
+    paths:
+    # type=inputmultiobject|default=[]: Paths to add to matlabpath
+    mfile:
+    # type=bool|default=True: Run m-code using m-file
+    use_mcr:
+    # type=bool|default=False: Run m-code using SPM MCR
+    use_v8struct:
+    # type=bool|default=True: Generate SPM8 and higher compatible jobs
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-spm/coregister_callables.py b/example-specs/task/nipype_internal/pydra-spm/coregister_callables.py
new file mode 100644
index 00000000..7de5928a
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-spm/coregister_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Coregister.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-spm/create_warped.yaml b/example-specs/task/nipype_internal/pydra-spm/create_warped.yaml
new file mode 100644
index 00000000..9dcd9906
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-spm/create_warped.yaml
@@ -0,0 +1,96 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.spm.preprocess.CreateWarped' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Apply a flow field estimated by DARTEL to create warped images
+# 
+#     http://www.fil.ion.ucl.ac.uk/spm/doc/manual.pdf#page=190
+# 
+#     Examples
+#     --------
+#     >>> import nipype.interfaces.spm as spm
+#     >>> create_warped = spm.CreateWarped()
+#     >>> create_warped.inputs.image_files = ['rc1s1.nii', 'rc1s2.nii']
+#     >>> create_warped.inputs.flowfield_files = ['u_rc1s1_Template.nii', 'u_rc1s2_Template.nii']
+#     >>> create_warped.run() # doctest: +SKIP
+# 
+#     
+task_name: CreateWarped
+nipype_name: CreateWarped
+nipype_module: nipype.interfaces.spm.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    paths: generic/directory+list-of
+    # type=inputmultiobject|default=[]: Paths to add to matlabpath
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    image_files:
+    # type=inputmultiobject|default=[]: A list of files to be warped
+    flowfield_files:
+    # type=inputmultiobject|default=[]: DARTEL flow fields u_rc1*
+    iterations:
+    # type=range|default=0: The number of iterations: log2(number of time steps)
+    interp:
+    # type=range|default=0: degree of b-spline used for interpolation
+    modulate:
+    # type=bool|default=False: Modulate images
+    matlab_cmd:
+    # type=str|default='': matlab command to use
+    paths:
+    # type=inputmultiobject|default=[]: Paths to add to matlabpath
+    mfile:
+    # type=bool|default=True: Run m-code using m-file
+    use_mcr:
+    # type=bool|default=False: Run m-code using SPM MCR
+    use_v8struct:
+    # type=bool|default=True: Generate SPM8 and higher compatible jobs
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-spm/create_warped_callables.py b/example-specs/task/nipype_internal/pydra-spm/create_warped_callables.py
new file mode 100644
index 00000000..60c29781
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-spm/create_warped_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in CreateWarped.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-spm/dartel.yaml b/example-specs/task/nipype_internal/pydra-spm/dartel.yaml
new file mode 100644
index 00000000..65ef3d73
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-spm/dartel.yaml
@@ -0,0 +1,97 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.spm.preprocess.DARTEL' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Use spm DARTEL to create a template and flow fields
+# 
+#     http://www.fil.ion.ucl.ac.uk/spm/doc/manual.pdf#page=185
+# 
+#     Examples
+#     --------
+#     >>> import nipype.interfaces.spm as spm
+#     >>> dartel = spm.DARTEL()
+#     >>> dartel.inputs.image_files = [['rc1s1.nii','rc1s2.nii'],['rc2s1.nii', 'rc2s2.nii']]
+#     >>> dartel.run() # doctest: +SKIP
+# 
+#     
+task_name: DARTEL
+nipype_name: DARTEL
+nipype_module: nipype.interfaces.spm.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    paths: generic/directory+list-of
+    # type=inputmultiobject|default=[]: Paths to add to matlabpath
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    final_template_file: generic/file
+    # type=file: final DARTEL template
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    image_files:
+    # type=list|default=[]: A list of files to be segmented
+    template_prefix:
+    # type=str|default='Template': Prefix for template
+    regularization_form:
+    # type=enum|default='Linear'|allowed['Bending','Linear','Membrane']: Form of regularization energy term
+    iteration_parameters:
+    # type=list|default=[]: List of tuples for each iteration    * Inner iterations   * Regularization parameters   * Time points for deformation model   * smoothing parameter  
+    optimization_parameters:
+    # type=tuple|default=(0.0, 1, 1): Optimization settings a tuple:    * LM regularization   * cycles of multigrid solver   * relaxation iterations  
+    matlab_cmd:
+    # type=str|default='': matlab command to use
+    paths:
+    # type=inputmultiobject|default=[]: Paths to add to matlabpath
+    mfile:
+    # type=bool|default=True: Run m-code using m-file
+    use_mcr:
+    # type=bool|default=False: Run m-code using SPM MCR
+    use_v8struct:
+    # type=bool|default=True: Generate SPM8 and higher compatible jobs
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-spm/dartel_callables.py b/example-specs/task/nipype_internal/pydra-spm/dartel_callables.py
new file mode 100644
index 00000000..e6fe7031
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-spm/dartel_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in DARTEL.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-spm/dartel_norm_2mni.yaml b/example-specs/task/nipype_internal/pydra-spm/dartel_norm_2mni.yaml
new file mode 100644
index 00000000..4d0a7a36
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-spm/dartel_norm_2mni.yaml
@@ -0,0 +1,104 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.spm.preprocess.DARTELNorm2MNI' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Use spm DARTEL to normalize data to MNI space
+# 
+#     http://www.fil.ion.ucl.ac.uk/spm/doc/manual.pdf#page=188
+# 
+#     Examples
+#     --------
+#     >>> import nipype.interfaces.spm as spm
+#     >>> nm = spm.DARTELNorm2MNI()
+#     >>> nm.inputs.template_file = 'Template_6.nii'
+#     >>> nm.inputs.flowfield_files = ['u_rc1s1_Template.nii', 'u_rc1s3_Template.nii']
+#     >>> nm.inputs.apply_to_files = ['c1s1.nii', 'c1s3.nii']
+#     >>> nm.inputs.modulate = True
+#     >>> nm.run() # doctest: +SKIP
+# 
+#     
+task_name: DARTELNorm2MNI
+nipype_name: DARTELNorm2MNI
+nipype_module: nipype.interfaces.spm.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    paths: generic/directory+list-of
+    # type=inputmultiobject|default=[]: Paths to add to matlabpath
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    normalization_parameter_file: generic/file
+    # type=file: Transform parameters to MNI space
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    template_file:
+    # type=imagefilespm|default=<undefined>: DARTEL template
+    flowfield_files:
+    # type=inputmultiobject|default=[]: DARTEL flow fields u_rc1*
+    apply_to_files:
+    # type=inputmultiobject|default=[]: Files to apply the transform to
+    voxel_size:
+    # type=tuple|default=(0.0, 0.0, 0.0): Voxel sizes for output file
+    bounding_box:
+    # type=tuple|default=(0.0, 0.0, 0.0, 0.0, 0.0, 0.0): Voxel sizes for output file
+    modulate:
+    # type=bool|default=False: Modulate out images - no modulation preserves concentrations
+    fwhm:
+    # type=traitcompound|default=None: 3-list of fwhm for each dimension
+    matlab_cmd:
+    # type=str|default='': matlab command to use
+    paths:
+    # type=inputmultiobject|default=[]: Paths to add to matlabpath
+    mfile:
+    # type=bool|default=True: Run m-code using m-file
+    use_mcr:
+    # type=bool|default=False: Run m-code using SPM MCR
+    use_v8struct:
+    # type=bool|default=True: Generate SPM8 and higher compatible jobs
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-spm/dartel_norm_2mni_callables.py b/example-specs/task/nipype_internal/pydra-spm/dartel_norm_2mni_callables.py
new file mode 100644
index 00000000..27ebbc54
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-spm/dartel_norm_2mni_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in DARTELNorm2MNI.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-spm/dicom_import.yaml b/example-specs/task/nipype_internal/pydra-spm/dicom_import.yaml
new file mode 100644
index 00000000..d5f8b76c
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-spm/dicom_import.yaml
@@ -0,0 +1,95 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.spm.utils.DicomImport' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Uses spm to convert DICOM files to nii or img+hdr.
+# 
+#     Examples
+#     --------
+# 
+#     >>> import nipype.interfaces.spm.utils as spmu
+#     >>> di = spmu.DicomImport()
+#     >>> di.inputs.in_files = ['functional_1.dcm', 'functional_2.dcm']
+#     >>> di.run() # doctest: +SKIP
+#     
+task_name: DicomImport
+nipype_name: DicomImport
+nipype_module: nipype.interfaces.spm.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_files: generic/file+list-of
+    # type=inputmultiobject|default=[]: dicom files to be converted
+    paths: generic/directory+list-of
+    # type=inputmultiobject|default=[]: Paths to add to matlabpath
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_files:
+    # type=inputmultiobject|default=[]: dicom files to be converted
+    output_dir_struct:
+    # type=enum|default='flat'|allowed['date_time','flat','patid','patid_date','patname','series']: directory structure for the output.
+    output_dir:
+    # type=str|default='./converted_dicom': output directory.
+    format:
+    # type=enum|default='nii'|allowed['img','nii']: output format.
+    icedims:
+    # type=bool|default=False: If image sorting fails, one can try using the additional SIEMENS ICEDims information to create unique filenames. Use this only if there would be multiple volumes with exactly the same file names.
+    matlab_cmd:
+    # type=str|default='': matlab command to use
+    paths:
+    # type=inputmultiobject|default=[]: Paths to add to matlabpath
+    mfile:
+    # type=bool|default=True: Run m-code using m-file
+    use_mcr:
+    # type=bool|default=False: Run m-code using SPM MCR
+    use_v8struct:
+    # type=bool|default=True: Generate SPM8 and higher compatible jobs
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-spm/dicom_import_callables.py b/example-specs/task/nipype_internal/pydra-spm/dicom_import_callables.py
new file mode 100644
index 00000000..51866005
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-spm/dicom_import_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in DicomImport.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-spm/estimate_contrast.yaml b/example-specs/task/nipype_internal/pydra-spm/estimate_contrast.yaml
new file mode 100644
index 00000000..7934b0f2
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-spm/estimate_contrast.yaml
@@ -0,0 +1,110 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.spm.model.EstimateContrast' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Use spm_contrasts to estimate contrasts of interest
+# 
+#     Examples
+#     --------
+#     >>> import nipype.interfaces.spm as spm
+#     >>> est = spm.EstimateContrast()
+#     >>> est.inputs.spm_mat_file = 'SPM.mat'
+#     >>> cont1 = ('Task>Baseline','T', ['Task-Odd','Task-Even'],[0.5,0.5])
+#     >>> cont2 = ('Task-Odd>Task-Even','T', ['Task-Odd','Task-Even'],[1,-1])
+#     >>> contrasts = [cont1,cont2]
+#     >>> est.inputs.contrasts = contrasts
+#     >>> est.run() # doctest: +SKIP
+# 
+#     
+task_name: EstimateContrast
+nipype_name: EstimateContrast
+nipype_module: nipype.interfaces.spm.model
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    spm_mat_file: generic/file
+    # type=file: Updated SPM mat file
+    # type=file|default=<undefined>: Absolute path to SPM.mat
+    beta_images: generic/file+list-of
+    # type=inputmultiobject|default=[]: Parameter estimates of the design matrix
+    residual_image: generic/file
+    # type=file|default=<undefined>: Mean-squared image of the residuals
+    paths: generic/directory+list-of
+    # type=inputmultiobject|default=[]: Paths to add to matlabpath
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    spm_mat_file: generic/file
+    # type=file: Updated SPM mat file
+    # type=file|default=<undefined>: Absolute path to SPM.mat
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    spm_mat_file:
+    # type=file: Updated SPM mat file
+    # type=file|default=<undefined>: Absolute path to SPM.mat
+    contrasts:
+    # type=list|default=[]: List of contrasts with each contrast being a list of the form:             [('name', 'stat', [condition list], [weight list], [session list])]             If session list is None or not provided, all sessions are used. For             F contrasts, the condition list should contain previously defined             T-contrasts.
+    beta_images:
+    # type=inputmultiobject|default=[]: Parameter estimates of the design matrix
+    residual_image:
+    # type=file|default=<undefined>: Mean-squared image of the residuals
+    use_derivs:
+    # type=bool|default=False: use derivatives for estimation
+    group_contrast:
+    # type=bool|default=False: higher level contrast
+    matlab_cmd:
+    # type=str|default='': matlab command to use
+    paths:
+    # type=inputmultiobject|default=[]: Paths to add to matlabpath
+    mfile:
+    # type=bool|default=True: Run m-code using m-file
+    use_mcr:
+    # type=bool|default=False: Run m-code using SPM MCR
+    use_v8struct:
+    # type=bool|default=True: Generate SPM8 and higher compatible jobs
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-spm/estimate_contrast_callables.py b/example-specs/task/nipype_internal/pydra-spm/estimate_contrast_callables.py
new file mode 100644
index 00000000..6841e094
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-spm/estimate_contrast_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in EstimateContrast.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-spm/estimate_model.yaml b/example-specs/task/nipype_internal/pydra-spm/estimate_model.yaml
new file mode 100644
index 00000000..fdd7ad78
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-spm/estimate_model.yaml
@@ -0,0 +1,99 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.spm.model.EstimateModel' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Use spm_spm to estimate the parameters of a model
+# 
+#     http://www.fil.ion.ucl.ac.uk/spm/doc/manual.pdf#page=69
+# 
+#     Examples
+#     --------
+#     >>> est = EstimateModel()
+#     >>> est.inputs.spm_mat_file = 'SPM.mat'
+#     >>> est.inputs.estimation_method = {'Classical': 1}
+#     >>> est.run() # doctest: +SKIP
+#     
+task_name: EstimateModel
+nipype_name: EstimateModel
+nipype_module: nipype.interfaces.spm.model
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    spm_mat_file: generic/file
+    # type=file: Updated SPM mat file
+    # type=file|default=<undefined>: Absolute path to SPM.mat
+    paths: generic/directory+list-of
+    # type=inputmultiobject|default=[]: Paths to add to matlabpath
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    spm_mat_file: generic/file
+    # type=file: Updated SPM mat file
+    # type=file|default=<undefined>: Absolute path to SPM.mat
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    spm_mat_file:
+    # type=file: Updated SPM mat file
+    # type=file|default=<undefined>: Absolute path to SPM.mat
+    estimation_method:
+    # type=dict|default={}: Dictionary of either Classical: 1, Bayesian: 1, or Bayesian2: 1 (dict)
+    write_residuals:
+    # type=bool|default=False: Write individual residual images
+    flags:
+    # type=dict|default={}: Additional arguments
+    matlab_cmd:
+    # type=str|default='': matlab command to use
+    paths:
+    # type=inputmultiobject|default=[]: Paths to add to matlabpath
+    mfile:
+    # type=bool|default=True: Run m-code using m-file
+    use_mcr:
+    # type=bool|default=False: Run m-code using SPM MCR
+    use_v8struct:
+    # type=bool|default=True: Generate SPM8 and higher compatible jobs
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-spm/estimate_model_callables.py b/example-specs/task/nipype_internal/pydra-spm/estimate_model_callables.py
new file mode 100644
index 00000000..34d17705
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-spm/estimate_model_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in EstimateModel.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-spm/factorial_design.yaml b/example-specs/task/nipype_internal/pydra-spm/factorial_design.yaml
new file mode 100644
index 00000000..f524698e
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-spm/factorial_design.yaml
@@ -0,0 +1,108 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.spm.model.FactorialDesign' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Base class for factorial designs
+# 
+#     http://www.fil.ion.ucl.ac.uk/spm/doc/manual.pdf#page=77
+# 
+#     
+task_name: FactorialDesign
+nipype_name: FactorialDesign
+nipype_module: nipype.interfaces.spm.model
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    explicit_mask_file: generic/file
+    # type=file|default=<undefined>: use an implicit mask file to threshold
+    spm_mat_dir: generic/directory
+    # type=directory|default=<undefined>: directory to store SPM.mat file (opt)
+    paths: generic/directory+list-of
+    # type=inputmultiobject|default=[]: Paths to add to matlabpath
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    spm_mat_file: generic/file
+    # type=file: SPM mat file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    spm_mat_dir:
+    # type=directory|default=<undefined>: directory to store SPM.mat file (opt)
+    covariates:
+    # type=inputmultiobject|default=[]: covariate dictionary {vector, name, interaction, centering}
+    threshold_mask_none:
+    # type=bool|default=False: do not use threshold masking
+    threshold_mask_absolute:
+    # type=float|default=0.0: use an absolute threshold
+    threshold_mask_relative:
+    # type=float|default=0.0: threshold using a proportion of the global value
+    use_implicit_threshold:
+    # type=bool|default=False: use implicit mask NaNs or zeros to threshold
+    explicit_mask_file:
+    # type=file|default=<undefined>: use an implicit mask file to threshold
+    global_calc_omit:
+    # type=bool|default=False: omit global calculation
+    global_calc_mean:
+    # type=bool|default=False: use mean for global calculation
+    global_calc_values:
+    # type=list|default=[]: omit global calculation
+    no_grand_mean_scaling:
+    # type=bool|default=False: do not perform grand mean scaling
+    global_normalization:
+    # type=enum|default=1|allowed[1,2,3]: global normalization None-1, Proportional-2, ANCOVA-3
+    matlab_cmd:
+    # type=str|default='': matlab command to use
+    paths:
+    # type=inputmultiobject|default=[]: Paths to add to matlabpath
+    mfile:
+    # type=bool|default=True: Run m-code using m-file
+    use_mcr:
+    # type=bool|default=False: Run m-code using SPM MCR
+    use_v8struct:
+    # type=bool|default=True: Generate SPM8 and higher compatible jobs
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-spm/factorial_design_callables.py b/example-specs/task/nipype_internal/pydra-spm/factorial_design_callables.py
new file mode 100644
index 00000000..36a32703
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-spm/factorial_design_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in FactorialDesign.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-spm/field_map.yaml b/example-specs/task/nipype_internal/pydra-spm/field_map.yaml
new file mode 100644
index 00000000..ee89ebef
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-spm/field_map.yaml
@@ -0,0 +1,157 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.spm.preprocess.FieldMap' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Use the fieldmap toolbox from spm to calculate the voxel displacement map (VDM).
+# 
+#     http://www.fil.ion.ucl.ac.uk/spm/doc/manual.pdf#page=173
+# 
+#     .. important::
+# 
+#         This interface does not deal with real/imag magnitude images nor
+#         with the two phase files case.
+# 
+#     Examples
+#     --------
+#     >>> from nipype.interfaces.spm import FieldMap
+#     >>> fm = FieldMap()
+#     >>> fm.inputs.phase_file = 'phase.nii'
+#     >>> fm.inputs.magnitude_file = 'magnitude.nii'
+#     >>> fm.inputs.echo_times = (5.19, 7.65)
+#     >>> fm.inputs.blip_direction = 1
+#     >>> fm.inputs.total_readout_time = 15.6
+#     >>> fm.inputs.epi_file = 'epi.nii'
+#     >>> fm.run() # doctest: +SKIP
+# 
+#     
+task_name: FieldMap
+nipype_name: FieldMap
+nipype_module: nipype.interfaces.spm.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    phase_file: generic/file
+    # type=file|default=<undefined>: presubstracted phase file
+    magnitude_file: generic/file
+    # type=file|default=<undefined>: presubstracted magnitude file
+    template: generic/file
+    # type=file|default=<undefined>: template image for brain masking
+    epi_file: generic/file
+    # type=file|default=<undefined>: EPI to unwarp
+    anat_file: generic/file
+    # type=file|default=<undefined>: anatomical image for comparison
+    paths: generic/directory+list-of
+    # type=inputmultiobject|default=[]: Paths to add to matlabpath
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    vdm: generic/file
+    # type=file: voxel difference map
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    jobtype:
+    # type=enum|default='calculatevdm'|allowed['calculatevdm']: Must be 'calculatevdm'; to apply VDM, use the ApplyVDM interface.
+    phase_file:
+    # type=file|default=<undefined>: presubstracted phase file
+    magnitude_file:
+    # type=file|default=<undefined>: presubstracted magnitude file
+    echo_times:
+    # type=tuple|default=(0.0, 0.0): short and long echo times
+    maskbrain:
+    # type=bool|default=True: masking or no masking of the brain
+    blip_direction:
+    # type=enum|default=1|allowed[-1,1]: polarity of the phase-encode blips
+    total_readout_time:
+    # type=float|default=0.0: total EPI readout time
+    epifm:
+    # type=bool|default=False: epi-based field map
+    jacobian_modulation:
+    # type=bool|default=False: jacobian modulation
+    method:
+    # type=enum|default='Mark3D'|allowed['Huttonish','Mark2D','Mark3D']: One of: Mark3D, Mark2D, Huttonish
+    unwarp_fwhm:
+    # type=range|default=10: gaussian smoothing kernel width
+    pad:
+    # type=range|default=0: padding kernel width
+    ws:
+    # type=bool|default=True: weighted smoothing
+    template:
+    # type=file|default=<undefined>: template image for brain masking
+    mask_fwhm:
+    # type=range|default=5: gaussian smoothing kernel width
+    nerode:
+    # type=range|default=2: number of erosions
+    ndilate:
+    # type=range|default=4: number of erosions
+    thresh:
+    # type=float|default=0.5: threshold used to create brain mask from segmented data
+    reg:
+    # type=float|default=0.02: regularization value used in the segmentation
+    epi_file:
+    # type=file|default=<undefined>: EPI to unwarp
+    matchvdm:
+    # type=bool|default=True: match VDM to EPI
+    sessname:
+    # type=str|default='_run-': VDM filename extension
+    writeunwarped:
+    # type=bool|default=False: write unwarped EPI
+    anat_file:
+    # type=file|default=<undefined>: anatomical image for comparison
+    matchanat:
+    # type=bool|default=True: match anatomical image to EPI
+    matlab_cmd:
+    # type=str|default='': matlab command to use
+    paths:
+    # type=inputmultiobject|default=[]: Paths to add to matlabpath
+    mfile:
+    # type=bool|default=True: Run m-code using m-file
+    use_mcr:
+    # type=bool|default=False: Run m-code using SPM MCR
+    use_v8struct:
+    # type=bool|default=True: Generate SPM8 and higher compatible jobs
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-spm/field_map_callables.py b/example-specs/task/nipype_internal/pydra-spm/field_map_callables.py
new file mode 100644
index 00000000..501c6d08
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-spm/field_map_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in FieldMap.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-spm/level_1_design.yaml b/example-specs/task/nipype_internal/pydra-spm/level_1_design.yaml
new file mode 100644
index 00000000..a7dd3b79
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-spm/level_1_design.yaml
@@ -0,0 +1,123 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.spm.model.Level1Design' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Generate an SPM design matrix
+# 
+#     http://www.fil.ion.ucl.ac.uk/spm/doc/manual.pdf#page=59
+# 
+#     Examples
+#     --------
+# 
+#     >>> level1design = Level1Design()
+#     >>> level1design.inputs.timing_units = 'secs'
+#     >>> level1design.inputs.interscan_interval = 2.5
+#     >>> level1design.inputs.bases = {'hrf':{'derivs': [0,0]}}
+#     >>> level1design.inputs.session_info = 'session_info.npz'
+#     >>> level1design.inputs.flags = {'mthresh': 0.4}
+#     >>> level1design.run() # doctest: +SKIP
+# 
+#     
+task_name: Level1Design
+nipype_name: Level1Design
+nipype_module: nipype.interfaces.spm.model
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    mask_image: generic/file
+    # type=file|default=<undefined>: Image  for  explicitly  masking the analysis
+    spm_mat_dir: generic/directory
+    # type=directory|default=<undefined>: directory to store SPM.mat file (opt)
+    paths: generic/directory+list-of
+    # type=inputmultiobject|default=[]: Paths to add to matlabpath
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    spm_mat_file: generic/file
+    # type=file: SPM mat file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    spm_mat_dir:
+    # type=directory|default=<undefined>: directory to store SPM.mat file (opt)
+    timing_units:
+    # type=enum|default='secs'|allowed['scans','secs']: units for specification of onsets
+    interscan_interval:
+    # type=float|default=0.0: Interscan interval in secs
+    microtime_resolution:
+    # type=int|default=0: Number of time-bins per scan in secs (opt)
+    microtime_onset:
+    # type=float|default=0.0: The onset/time-bin in seconds for alignment (opt)
+    session_info:
+    # type=any|default=None: Session specific information generated by ``modelgen.SpecifyModel``
+    factor_info:
+    # type=list|default=[]: Factor specific information file (opt)
+    bases:
+    # type=dict|default={}: Dictionary names of the basis function to parameters:      * hrf          * derivs -- (2-element list) Model  HRF  Derivatives. No derivatives: [0,0],           Time derivatives : [1,0], Time and Dispersion derivatives: [1,1]      * fourier, fourier_han, gamma, or fir:          * length -- (int) Post-stimulus window length (in seconds)         * order -- (int) Number of basis functions  
+    volterra_expansion_order:
+    # type=enum|default=1|allowed[1,2]: Model interactions - no:1, yes:2
+    global_intensity_normalization:
+    # type=enum|default='none'|allowed['none','scaling']: Global intensity normalization - scaling or none
+    mask_image:
+    # type=file|default=<undefined>: Image  for  explicitly  masking the analysis
+    mask_threshold:
+    # type=traitcompound|default='-Inf': Thresholding for the mask
+    model_serial_correlations:
+    # type=enum|default='AR(1)'|allowed['AR(1)','FAST','none']: Model serial correlations AR(1), FAST or none. FAST is available in SPM12
+    flags:
+    # type=dict|default={}: Additional arguments to the job, e.g., a common SPM operation is to modify the default masking threshold (mthresh)
+    matlab_cmd:
+    # type=str|default='': matlab command to use
+    paths:
+    # type=inputmultiobject|default=[]: Paths to add to matlabpath
+    mfile:
+    # type=bool|default=True: Run m-code using m-file
+    use_mcr:
+    # type=bool|default=False: Run m-code using SPM MCR
+    use_v8struct:
+    # type=bool|default=True: Generate SPM8 and higher compatible jobs
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-spm/level_1_design_callables.py b/example-specs/task/nipype_internal/pydra-spm/level_1_design_callables.py
new file mode 100644
index 00000000..0558037d
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-spm/level_1_design_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Level1Design.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-spm/multi_channel_new_segment.yaml b/example-specs/task/nipype_internal/pydra-spm/multi_channel_new_segment.yaml
new file mode 100644
index 00000000..73249c25
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-spm/multi_channel_new_segment.yaml
@@ -0,0 +1,113 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.spm.preprocess.MultiChannelNewSegment' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Use spm_preproc8 (New Segment) to separate structural images into
+#     different tissue classes. Supports multiple modalities and multichannel inputs.
+# 
+#     http://www.fil.ion.ucl.ac.uk/spm/doc/manual.pdf#page=45
+# 
+#     Examples
+#     --------
+#     >>> import nipype.interfaces.spm as spm
+#     >>> seg = spm.MultiChannelNewSegment()
+#     >>> seg.inputs.channels = [('structural.nii',(0.0001, 60, (True, True)))]
+#     >>> seg.run() # doctest: +SKIP
+# 
+#     For VBM pre-processing [http://www.fil.ion.ucl.ac.uk/~john/misc/VBMclass10.pdf],
+#     TPM.nii should be replaced by /path/to/spm8/toolbox/Seg/TPM.nii
+# 
+#     >>> seg = MultiChannelNewSegment()
+#     >>> channel1= ('T1.nii',(0.0001, 60, (True, True)))
+#     >>> channel2= ('T2.nii',(0.0001, 60, (True, True)))
+#     >>> seg.inputs.channels = [channel1, channel2]
+#     >>> tissue1 = (('TPM.nii', 1), 2, (True,True), (False, False))
+#     >>> tissue2 = (('TPM.nii', 2), 2, (True,True), (False, False))
+#     >>> tissue3 = (('TPM.nii', 3), 2, (True,False), (False, False))
+#     >>> tissue4 = (('TPM.nii', 4), 2, (False,False), (False, False))
+#     >>> tissue5 = (('TPM.nii', 5), 2, (False,False), (False, False))
+#     >>> seg.inputs.tissues = [tissue1, tissue2, tissue3, tissue4, tissue5]
+#     >>> seg.run() # doctest: +SKIP
+# 
+#     
+task_name: MultiChannelNewSegment
+nipype_name: MultiChannelNewSegment
+nipype_module: nipype.interfaces.spm.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    paths: generic/directory+list-of
+    # type=inputmultiobject|default=[]: Paths to add to matlabpath
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    channels:
+    # type=list|default=[]: A list of tuples (one per each channel) with the following fields:             - a list of channel files (only 1rst channel files will be segmented)             - a tuple with the following channel-specific info fields:               - bias reguralisation (0-10)               - FWHM of Gaussian smoothness of bias               - which maps to save (Field, Corrected) - a tuple of two boolean values
+    tissues:
+    # type=list|default=[]: A list of tuples (one per tissue) with the following fields:             - tissue probability map (4D), 1-based index to frame             - number of gaussians             - which maps to save [Native, DARTEL] - a tuple of two boolean values             - which maps to save [Unmodulated, Modulated] - a tuple of two boolean values
+    affine_regularization:
+    # type=enum|default='mni'|allowed['eastern','mni','none','subj']: mni, eastern, subj, none 
+    warping_regularization:
+    # type=traitcompound|default=None: Warping regularization parameter(s). Accepts float or list of floats (the latter is required by SPM12)
+    sampling_distance:
+    # type=float|default=0.0: Sampling distance on data for parameter estimation
+    write_deformation_fields:
+    # type=list|default=[]: Which deformation fields to write:[Inverse, Forward]
+    matlab_cmd:
+    # type=str|default='': matlab command to use
+    paths:
+    # type=inputmultiobject|default=[]: Paths to add to matlabpath
+    mfile:
+    # type=bool|default=True: Run m-code using m-file
+    use_mcr:
+    # type=bool|default=False: Run m-code using SPM MCR
+    use_v8struct:
+    # type=bool|default=True: Generate SPM8 and higher compatible jobs
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-spm/multi_channel_new_segment_callables.py b/example-specs/task/nipype_internal/pydra-spm/multi_channel_new_segment_callables.py
new file mode 100644
index 00000000..83317d0f
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-spm/multi_channel_new_segment_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in MultiChannelNewSegment.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-spm/multiple_regression_design.yaml b/example-specs/task/nipype_internal/pydra-spm/multiple_regression_design.yaml
new file mode 100644
index 00000000..9a190646
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-spm/multiple_regression_design.yaml
@@ -0,0 +1,120 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.spm.model.MultipleRegressionDesign' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Create SPM design for multiple regression
+# 
+#     Examples
+#     --------
+# 
+#     >>> mreg = MultipleRegressionDesign()
+#     >>> mreg.inputs.in_files = ['cont1.nii','cont2.nii']
+#     >>> mreg.run() # doctest: +SKIP
+#     
+task_name: MultipleRegressionDesign
+nipype_name: MultipleRegressionDesign
+nipype_module: nipype.interfaces.spm.model
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_files: generic/file+list-of
+    # type=list|default=[]: List of files
+    explicit_mask_file: generic/file
+    # type=file|default=<undefined>: use an implicit mask file to threshold
+    spm_mat_dir: generic/directory
+    # type=directory|default=<undefined>: directory to store SPM.mat file (opt)
+    paths: generic/directory+list-of
+    # type=inputmultiobject|default=[]: Paths to add to matlabpath
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    spm_mat_file: generic/file
+    # type=file: SPM mat file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_files:
+    # type=list|default=[]: List of files
+    include_intercept:
+    # type=bool|default=True: Include intercept in design
+    user_covariates:
+    # type=inputmultiobject|default=[]: covariate dictionary {vector, name, centering}
+    spm_mat_dir:
+    # type=directory|default=<undefined>: directory to store SPM.mat file (opt)
+    covariates:
+    # type=inputmultiobject|default=[]: covariate dictionary {vector, name, interaction, centering}
+    threshold_mask_none:
+    # type=bool|default=False: do not use threshold masking
+    threshold_mask_absolute:
+    # type=float|default=0.0: use an absolute threshold
+    threshold_mask_relative:
+    # type=float|default=0.0: threshold using a proportion of the global value
+    use_implicit_threshold:
+    # type=bool|default=False: use implicit mask NaNs or zeros to threshold
+    explicit_mask_file:
+    # type=file|default=<undefined>: use an implicit mask file to threshold
+    global_calc_omit:
+    # type=bool|default=False: omit global calculation
+    global_calc_mean:
+    # type=bool|default=False: use mean for global calculation
+    global_calc_values:
+    # type=list|default=[]: omit global calculation
+    no_grand_mean_scaling:
+    # type=bool|default=False: do not perform grand mean scaling
+    global_normalization:
+    # type=enum|default=1|allowed[1,2,3]: global normalization None-1, Proportional-2, ANCOVA-3
+    matlab_cmd:
+    # type=str|default='': matlab command to use
+    paths:
+    # type=inputmultiobject|default=[]: Paths to add to matlabpath
+    mfile:
+    # type=bool|default=True: Run m-code using m-file
+    use_mcr:
+    # type=bool|default=False: Run m-code using SPM MCR
+    use_v8struct:
+    # type=bool|default=True: Generate SPM8 and higher compatible jobs
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-spm/multiple_regression_design_callables.py b/example-specs/task/nipype_internal/pydra-spm/multiple_regression_design_callables.py
new file mode 100644
index 00000000..2b1e9091
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-spm/multiple_regression_design_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in MultipleRegressionDesign.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-spm/new_segment.yaml b/example-specs/task/nipype_internal/pydra-spm/new_segment.yaml
new file mode 100644
index 00000000..b530ad62
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-spm/new_segment.yaml
@@ -0,0 +1,116 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.spm.preprocess.NewSegment' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Use spm_preproc8 (New Segment) to separate structural images into
+#     different tissue classes. Supports multiple modalities.
+# 
+#     NOTE: This interface currently supports single channel input only
+# 
+#     http://www.fil.ion.ucl.ac.uk/spm/doc/manual.pdf#page=43
+# 
+#     Examples
+#     --------
+#     >>> import nipype.interfaces.spm as spm
+#     >>> seg = spm.NewSegment()
+#     >>> seg.inputs.channel_files = 'structural.nii'
+#     >>> seg.inputs.channel_info = (0.0001, 60, (True, True))
+#     >>> seg.run() # doctest: +SKIP
+# 
+#     For VBM pre-processing [http://www.fil.ion.ucl.ac.uk/~john/misc/VBMclass10.pdf],
+#     TPM.nii should be replaced by /path/to/spm8/toolbox/Seg/TPM.nii
+# 
+#     >>> seg = NewSegment()
+#     >>> seg.inputs.channel_files = 'structural.nii'
+#     >>> tissue1 = (('TPM.nii', 1), 2, (True,True), (False, False))
+#     >>> tissue2 = (('TPM.nii', 2), 2, (True,True), (False, False))
+#     >>> tissue3 = (('TPM.nii', 3), 2, (True,False), (False, False))
+#     >>> tissue4 = (('TPM.nii', 4), 2, (False,False), (False, False))
+#     >>> tissue5 = (('TPM.nii', 5), 2, (False,False), (False, False))
+#     >>> seg.inputs.tissues = [tissue1, tissue2, tissue3, tissue4, tissue5]
+#     >>> seg.run() # doctest: +SKIP
+# 
+#     
+task_name: NewSegment
+nipype_name: NewSegment
+nipype_module: nipype.interfaces.spm.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    paths: generic/directory+list-of
+    # type=inputmultiobject|default=[]: Paths to add to matlabpath
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    channel_files:
+    # type=inputmultiobject|default=[]: A list of files to be segmented
+    channel_info:
+    # type=tuple|default=(0.0, 0.0, (False, False)): A tuple with the following fields:             - bias reguralisation (0-10)             - FWHM of Gaussian smoothness of bias             - which maps to save (Field, Corrected) - a tuple of two boolean values
+    tissues:
+    # type=list|default=[]: A list of tuples (one per tissue) with the following fields:             - tissue probability map (4D), 1-based index to frame             - number of gaussians             - which maps to save [Native, DARTEL] - a tuple of two boolean values             - which maps to save [Unmodulated, Modulated] - a tuple of two boolean values
+    affine_regularization:
+    # type=enum|default='mni'|allowed['eastern','mni','none','subj']: mni, eastern, subj, none 
+    warping_regularization:
+    # type=traitcompound|default=None: Warping regularization parameter(s). Accepts float or list of floats (the latter is required by SPM12)
+    sampling_distance:
+    # type=float|default=0.0: Sampling distance on data for parameter estimation
+    write_deformation_fields:
+    # type=list|default=[]: Which deformation fields to write:[Inverse, Forward]
+    matlab_cmd:
+    # type=str|default='': matlab command to use
+    paths:
+    # type=inputmultiobject|default=[]: Paths to add to matlabpath
+    mfile:
+    # type=bool|default=True: Run m-code using m-file
+    use_mcr:
+    # type=bool|default=False: Run m-code using SPM MCR
+    use_v8struct:
+    # type=bool|default=True: Generate SPM8 and higher compatible jobs
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-spm/new_segment_callables.py b/example-specs/task/nipype_internal/pydra-spm/new_segment_callables.py
new file mode 100644
index 00000000..65a698fa
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-spm/new_segment_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in NewSegment.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-spm/normalize.yaml b/example-specs/task/nipype_internal/pydra-spm/normalize.yaml
new file mode 100644
index 00000000..73aa658c
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-spm/normalize.yaml
@@ -0,0 +1,131 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.spm.preprocess.Normalize' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# use spm_normalise for warping an image to a template
+# 
+#     http://www.fil.ion.ucl.ac.uk/spm/doc/manual.pdf#page=203
+# 
+#     Examples
+#     --------
+#     >>> import nipype.interfaces.spm as spm
+#     >>> norm = spm.Normalize()
+#     >>> norm.inputs.source = 'functional.nii'
+#     >>> norm.run() # doctest: +SKIP
+# 
+#     
+task_name: Normalize
+nipype_name: Normalize
+nipype_module: nipype.interfaces.spm.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    template: generic/file
+    # type=file|default=<undefined>: template file to normalize to
+    parameter_file: generic/file
+    # type=file|default=<undefined>: normalization parameter file*_sn.mat
+    source_weight: generic/file
+    # type=file|default=<undefined>: name of weighting image for source
+    template_weight: generic/file
+    # type=file|default=<undefined>: name of weighting image for template
+    paths: generic/directory+list-of
+    # type=inputmultiobject|default=[]: Paths to add to matlabpath
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    template:
+    # type=file|default=<undefined>: template file to normalize to
+    source:
+    # type=inputmultiobject|default=[]: file to normalize to template
+    jobtype:
+    # type=enum|default='estwrite'|allowed['est','estwrite','write']: Estimate, Write or do both
+    apply_to_files:
+    # type=inputmultiobject|default=[]: files to apply transformation to
+    parameter_file:
+    # type=file|default=<undefined>: normalization parameter file*_sn.mat
+    source_weight:
+    # type=file|default=<undefined>: name of weighting image for source
+    template_weight:
+    # type=file|default=<undefined>: name of weighting image for template
+    source_image_smoothing:
+    # type=float|default=0.0: source smoothing
+    template_image_smoothing:
+    # type=float|default=0.0: template smoothing
+    affine_regularization_type:
+    # type=enum|default='mni'|allowed['mni','none','size']: mni, size, none
+    DCT_period_cutoff:
+    # type=float|default=0.0: Cutoff of for DCT bases
+    nonlinear_iterations:
+    # type=int|default=0: Number of iterations of nonlinear warping
+    nonlinear_regularization:
+    # type=float|default=0.0: the amount of the regularization for the nonlinear part of the normalization
+    write_preserve:
+    # type=bool|default=False: True/False warped images are modulated
+    write_bounding_box:
+    # type=list|default=[]: 3x2-element list of lists
+    write_voxel_sizes:
+    # type=list|default=[]: 3-element list
+    write_interp:
+    # type=range|default=0: degree of b-spline used for interpolation
+    write_wrap:
+    # type=list|default=[]: Check if interpolation should wrap in [x,y,z] - list of bools
+    out_prefix:
+    # type=string|default='w': normalized output prefix
+    matlab_cmd:
+    # type=str|default='': matlab command to use
+    paths:
+    # type=inputmultiobject|default=[]: Paths to add to matlabpath
+    mfile:
+    # type=bool|default=True: Run m-code using m-file
+    use_mcr:
+    # type=bool|default=False: Run m-code using SPM MCR
+    use_v8struct:
+    # type=bool|default=True: Generate SPM8 and higher compatible jobs
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-spm/normalize_12.yaml b/example-specs/task/nipype_internal/pydra-spm/normalize_12.yaml
new file mode 100644
index 00000000..eb5566a3
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-spm/normalize_12.yaml
@@ -0,0 +1,122 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.spm.preprocess.Normalize12' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# uses SPM12's new Normalise routine for warping an image to a template.
+#     Spatial normalisation is now done via the segmentation routine (which was
+#     known as ``New Segment`` in SPM8). Note that the normalisation in SPM12
+#     is done towards a file containing multiple tissue probability maps, which
+#     was not the case in SPM8.
+# 
+#     http://www.fil.ion.ucl.ac.uk/spm/doc/manual.pdf#page=49
+# 
+#     Examples
+#     --------
+#     >>> import nipype.interfaces.spm as spm
+#     >>> norm12 = spm.Normalize12()
+#     >>> norm12.inputs.image_to_align = 'structural.nii'
+#     >>> norm12.inputs.apply_to_files = 'functional.nii'
+#     >>> norm12.run() # doctest: +SKIP
+# 
+#     
+task_name: Normalize12
+nipype_name: Normalize12
+nipype_module: nipype.interfaces.spm.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    tpm: generic/file
+    # type=file|default=<undefined>: template in form of tissue probablitiy maps to normalize to
+    paths: generic/directory+list-of
+    # type=inputmultiobject|default=[]: Paths to add to matlabpath
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    image_to_align:
+    # type=imagefilespm|default=<undefined>: file to estimate normalization parameters with
+    apply_to_files:
+    # type=inputmultiobject|default=[]: files to apply transformation to
+    deformation_file:
+    # type=imagefilespm|default=<undefined>: file y_*.nii containing 3 deformation fields for the deformation in x, y and z dimension
+    jobtype:
+    # type=enum|default='estwrite'|allowed['est','estwrite','write']: Estimate, Write or do Both
+    bias_regularization:
+    # type=enum|default=0|allowed[0,0.0001,0.001,0.01,0.1,1,10,1e-05]: no(0) - extremely heavy (10)
+    bias_fwhm:
+    # type=enum|default=30|allowed['Inf',100,110,120,130,140,150,30,40,50,60,70,80,90]: FWHM of Gaussian smoothness of bias
+    tpm:
+    # type=file|default=<undefined>: template in form of tissue probablitiy maps to normalize to
+    affine_regularization_type:
+    # type=enum|default='mni'|allowed['mni','none','size']: mni, size, none
+    warping_regularization:
+    # type=list|default=[]: controls balance between parameters and data
+    smoothness:
+    # type=float|default=0.0: value (in mm) to smooth the data before normalization
+    sampling_distance:
+    # type=float|default=0.0: Sampling distance on data for parameter estimation
+    write_bounding_box:
+    # type=list|default=[]: 3x2-element list of lists representing the bounding box (in mm) to be written
+    write_voxel_sizes:
+    # type=list|default=[]: 3-element list representing the voxel sizes (in mm) of the written normalised images
+    write_interp:
+    # type=range|default=0: degree of b-spline used for interpolation
+    out_prefix:
+    # type=string|default='w': Normalized output prefix
+    matlab_cmd:
+    # type=str|default='': matlab command to use
+    paths:
+    # type=inputmultiobject|default=[]: Paths to add to matlabpath
+    mfile:
+    # type=bool|default=True: Run m-code using m-file
+    use_mcr:
+    # type=bool|default=False: Run m-code using SPM MCR
+    use_v8struct:
+    # type=bool|default=True: Generate SPM8 and higher compatible jobs
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-spm/normalize_12_callables.py b/example-specs/task/nipype_internal/pydra-spm/normalize_12_callables.py
new file mode 100644
index 00000000..61c69cb7
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-spm/normalize_12_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Normalize12.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-spm/normalize_callables.py b/example-specs/task/nipype_internal/pydra-spm/normalize_callables.py
new file mode 100644
index 00000000..795f3328
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-spm/normalize_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Normalize.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-spm/one_sample_t_test_design.yaml b/example-specs/task/nipype_internal/pydra-spm/one_sample_t_test_design.yaml
new file mode 100644
index 00000000..4045fc85
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-spm/one_sample_t_test_design.yaml
@@ -0,0 +1,116 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.spm.model.OneSampleTTestDesign' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Create SPM design for one sample t-test
+# 
+#     Examples
+#     --------
+# 
+#     >>> ttest = OneSampleTTestDesign()
+#     >>> ttest.inputs.in_files = ['cont1.nii', 'cont2.nii']
+#     >>> ttest.run() # doctest: +SKIP
+#     
+task_name: OneSampleTTestDesign
+nipype_name: OneSampleTTestDesign
+nipype_module: nipype.interfaces.spm.model
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_files: generic/file+list-of
+    # type=list|default=[]: input files
+    explicit_mask_file: generic/file
+    # type=file|default=<undefined>: use an implicit mask file to threshold
+    spm_mat_dir: generic/directory
+    # type=directory|default=<undefined>: directory to store SPM.mat file (opt)
+    paths: generic/directory+list-of
+    # type=inputmultiobject|default=[]: Paths to add to matlabpath
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    spm_mat_file: generic/file
+    # type=file: SPM mat file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_files:
+    # type=list|default=[]: input files
+    spm_mat_dir:
+    # type=directory|default=<undefined>: directory to store SPM.mat file (opt)
+    covariates:
+    # type=inputmultiobject|default=[]: covariate dictionary {vector, name, interaction, centering}
+    threshold_mask_none:
+    # type=bool|default=False: do not use threshold masking
+    threshold_mask_absolute:
+    # type=float|default=0.0: use an absolute threshold
+    threshold_mask_relative:
+    # type=float|default=0.0: threshold using a proportion of the global value
+    use_implicit_threshold:
+    # type=bool|default=False: use implicit mask NaNs or zeros to threshold
+    explicit_mask_file:
+    # type=file|default=<undefined>: use an implicit mask file to threshold
+    global_calc_omit:
+    # type=bool|default=False: omit global calculation
+    global_calc_mean:
+    # type=bool|default=False: use mean for global calculation
+    global_calc_values:
+    # type=list|default=[]: omit global calculation
+    no_grand_mean_scaling:
+    # type=bool|default=False: do not perform grand mean scaling
+    global_normalization:
+    # type=enum|default=1|allowed[1,2,3]: global normalization None-1, Proportional-2, ANCOVA-3
+    matlab_cmd:
+    # type=str|default='': matlab command to use
+    paths:
+    # type=inputmultiobject|default=[]: Paths to add to matlabpath
+    mfile:
+    # type=bool|default=True: Run m-code using m-file
+    use_mcr:
+    # type=bool|default=False: Run m-code using SPM MCR
+    use_v8struct:
+    # type=bool|default=True: Generate SPM8 and higher compatible jobs
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-spm/one_sample_t_test_design_callables.py b/example-specs/task/nipype_internal/pydra-spm/one_sample_t_test_design_callables.py
new file mode 100644
index 00000000..df46a0f9
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-spm/one_sample_t_test_design_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in OneSampleTTestDesign.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-spm/paired_t_test_design.yaml b/example-specs/task/nipype_internal/pydra-spm/paired_t_test_design.yaml
new file mode 100644
index 00000000..a15f248d
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-spm/paired_t_test_design.yaml
@@ -0,0 +1,118 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.spm.model.PairedTTestDesign' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Create SPM design for paired t-test
+# 
+#     Examples
+#     --------
+# 
+#     >>> pttest = PairedTTestDesign()
+#     >>> pttest.inputs.paired_files = [['cont1.nii','cont1a.nii'],['cont2.nii','cont2a.nii']]
+#     >>> pttest.run() # doctest: +SKIP
+#     
+task_name: PairedTTestDesign
+nipype_name: PairedTTestDesign
+nipype_module: nipype.interfaces.spm.model
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    explicit_mask_file: generic/file
+    # type=file|default=<undefined>: use an implicit mask file to threshold
+    spm_mat_dir: generic/directory
+    # type=directory|default=<undefined>: directory to store SPM.mat file (opt)
+    paths: generic/directory+list-of
+    # type=inputmultiobject|default=[]: Paths to add to matlabpath
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    spm_mat_file: generic/file
+    # type=file: SPM mat file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    paired_files:
+    # type=list|default=[]: List of paired files
+    grand_mean_scaling:
+    # type=bool|default=False: Perform grand mean scaling
+    ancova:
+    # type=bool|default=False: Specify ancova-by-factor regressors
+    spm_mat_dir:
+    # type=directory|default=<undefined>: directory to store SPM.mat file (opt)
+    covariates:
+    # type=inputmultiobject|default=[]: covariate dictionary {vector, name, interaction, centering}
+    threshold_mask_none:
+    # type=bool|default=False: do not use threshold masking
+    threshold_mask_absolute:
+    # type=float|default=0.0: use an absolute threshold
+    threshold_mask_relative:
+    # type=float|default=0.0: threshold using a proportion of the global value
+    use_implicit_threshold:
+    # type=bool|default=False: use implicit mask NaNs or zeros to threshold
+    explicit_mask_file:
+    # type=file|default=<undefined>: use an implicit mask file to threshold
+    global_calc_omit:
+    # type=bool|default=False: omit global calculation
+    global_calc_mean:
+    # type=bool|default=False: use mean for global calculation
+    global_calc_values:
+    # type=list|default=[]: omit global calculation
+    no_grand_mean_scaling:
+    # type=bool|default=False: do not perform grand mean scaling
+    global_normalization:
+    # type=enum|default=1|allowed[1,2,3]: global normalization None-1, Proportional-2, ANCOVA-3
+    matlab_cmd:
+    # type=str|default='': matlab command to use
+    paths:
+    # type=inputmultiobject|default=[]: Paths to add to matlabpath
+    mfile:
+    # type=bool|default=True: Run m-code using m-file
+    use_mcr:
+    # type=bool|default=False: Run m-code using SPM MCR
+    use_v8struct:
+    # type=bool|default=True: Generate SPM8 and higher compatible jobs
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-spm/paired_t_test_design_callables.py b/example-specs/task/nipype_internal/pydra-spm/paired_t_test_design_callables.py
new file mode 100644
index 00000000..28e8ee93
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-spm/paired_t_test_design_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in PairedTTestDesign.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-spm/realign.yaml b/example-specs/task/nipype_internal/pydra-spm/realign.yaml
new file mode 100644
index 00000000..9f585fa4
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-spm/realign.yaml
@@ -0,0 +1,119 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.spm.preprocess.Realign' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Use spm_realign for estimating within modality rigid body alignment
+# 
+#     http://www.fil.ion.ucl.ac.uk/spm/doc/manual.pdf#page=25
+# 
+#     Examples
+#     --------
+# 
+#     >>> import nipype.interfaces.spm as spm
+#     >>> realign = spm.Realign()
+#     >>> realign.inputs.in_files = 'functional.nii'
+#     >>> realign.inputs.register_to_mean = True
+#     >>> realign.run() # doctest: +SKIP
+# 
+#     
+task_name: Realign
+nipype_name: Realign
+nipype_module: nipype.interfaces.spm.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    weight_img: generic/file
+    # type=file|default=<undefined>: filename of weighting image
+    paths: generic/directory+list-of
+    # type=inputmultiobject|default=[]: Paths to add to matlabpath
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    mean_image: generic/file
+    # type=file: Mean image file from the realignment
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_files:
+    # type=inputmultiobject|default=[]: list of filenames to realign
+    jobtype:
+    # type=enum|default='estwrite'|allowed['estimate','estwrite','write']: one of: estimate, write, estwrite
+    quality:
+    # type=range|default=0.0: 0.1 = fast, 1.0 = precise
+    fwhm:
+    # type=range|default=0.0: gaussian smoothing kernel width
+    separation:
+    # type=range|default=0.0: sampling separation in mm
+    register_to_mean:
+    # type=bool|default=False: Indicate whether realignment is done to the mean image
+    weight_img:
+    # type=file|default=<undefined>: filename of weighting image
+    interp:
+    # type=range|default=0: degree of b-spline used for interpolation
+    wrap:
+    # type=list|default=[]: Check if interpolation should wrap in [x,y,z]
+    write_which:
+    # type=list|default=[2, 1]: determines which images to reslice
+    write_interp:
+    # type=range|default=0: degree of b-spline used for interpolation
+    write_wrap:
+    # type=list|default=[]: Check if interpolation should wrap in [x,y,z]
+    write_mask:
+    # type=bool|default=False: True/False mask output image
+    out_prefix:
+    # type=string|default='r': realigned output prefix
+    matlab_cmd:
+    # type=str|default='': matlab command to use
+    paths:
+    # type=inputmultiobject|default=[]: Paths to add to matlabpath
+    mfile:
+    # type=bool|default=True: Run m-code using m-file
+    use_mcr:
+    # type=bool|default=False: Run m-code using SPM MCR
+    use_v8struct:
+    # type=bool|default=True: Generate SPM8 and higher compatible jobs
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-spm/realign_callables.py b/example-specs/task/nipype_internal/pydra-spm/realign_callables.py
new file mode 100644
index 00000000..8460250c
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-spm/realign_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Realign.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-spm/realign_unwarp.yaml b/example-specs/task/nipype_internal/pydra-spm/realign_unwarp.yaml
new file mode 100644
index 00000000..b45b80d2
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-spm/realign_unwarp.yaml
@@ -0,0 +1,145 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.spm.preprocess.RealignUnwarp' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Use spm_uw_estimate for estimating within subject registration and unwarping
+#     of time series. Function accepts only one single field map. If in_files is a
+#     list of files they will be treated as separate sessions but associated to the
+#     same fieldmap.
+# 
+#     http://www.fil.ion.ucl.ac.uk/spm/doc/manual.pdf#page=31
+# 
+#     Examples
+#     --------
+# 
+#     >>> import nipype.interfaces.spm as spm
+#     >>> realignUnwarp = spm.RealignUnwarp()
+#     >>> realignUnwarp.inputs.in_files = ['functional.nii', 'functional2.nii']
+#     >>> realignUnwarp.inputs.phase_map = 'voxeldisplacemap.vdm'
+#     >>> realignUnwarp.inputs.register_to_mean = True
+#     >>> realignUnwarp.run() # doctest: +SKIP
+# 
+#     
+task_name: RealignUnwarp
+nipype_name: RealignUnwarp
+nipype_module: nipype.interfaces.spm.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    phase_map: generic/file
+    # type=file|default=<undefined>: Voxel displacement map to use in unwarping. Unlike SPM standard behaviour, the same map will be used for all sessions
+    weight_img: generic/file
+    # type=file|default=<undefined>: filename of weighting image
+    paths: generic/directory+list-of
+    # type=inputmultiobject|default=[]: Paths to add to matlabpath
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    mean_image: generic/file
+    # type=file: Mean image file from the realignment & unwarping
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_files:
+    # type=inputmultiobject|default=[]: list of filenames to realign and unwarp
+    phase_map:
+    # type=file|default=<undefined>: Voxel displacement map to use in unwarping. Unlike SPM standard behaviour, the same map will be used for all sessions
+    quality:
+    # type=range|default=0.0: 0.1 = fast, 1.0 = precise
+    fwhm:
+    # type=range|default=0.0: gaussian smoothing kernel width
+    separation:
+    # type=range|default=0.0: sampling separation in mm
+    register_to_mean:
+    # type=bool|default=False: Indicate whether realignment is done to the mean image
+    weight_img:
+    # type=file|default=<undefined>: filename of weighting image
+    interp:
+    # type=range|default=0: degree of b-spline used for interpolation
+    wrap:
+    # type=list|default=[]: Check if interpolation should wrap in [x,y,z]
+    est_basis_func:
+    # type=list|default=[]: Number of basis functions to use for each dimension
+    est_reg_order:
+    # type=range|default=0: This parameter determines how to balance the compromise between likelihood maximization and smoothness maximization of the estimated field.
+    est_reg_factor:
+    # type=list|default=[100000]: Regularisation factor. Default: 100000 (medium).
+    est_jacobian_deformations:
+    # type=bool|default=False: Jacobian deformations. In theory a good idea to include them,  in practice a bad idea. Default: No.
+    est_first_order_effects:
+    # type=list|default=[]: First order effects should only depend on pitch and roll, i.e. [4 5]
+    est_second_order_effects:
+    # type=list|default=[]: List of second order terms to model second derivatives of.
+    est_unwarp_fwhm:
+    # type=range|default=0.0: gaussian smoothing kernel width for unwarp
+    est_re_est_mov_par:
+    # type=bool|default=False: Re-estimate movement parameters at each unwarping iteration.
+    est_num_of_iterations:
+    # type=list|default=[5]: Number of iterations.
+    est_taylor_expansion_point:
+    # type=string|default='Average': Point in position space to perform Taylor-expansion around.
+    reslice_which:
+    # type=list|default=[2, 1]: determines which images to reslice
+    reslice_interp:
+    # type=range|default=0: degree of b-spline used for interpolation
+    reslice_wrap:
+    # type=list|default=[]: Check if interpolation should wrap in [x,y,z]
+    reslice_mask:
+    # type=bool|default=False: True/False mask output image
+    out_prefix:
+    # type=string|default='u': realigned and unwarped output prefix
+    matlab_cmd:
+    # type=str|default='': matlab command to use
+    paths:
+    # type=inputmultiobject|default=[]: Paths to add to matlabpath
+    mfile:
+    # type=bool|default=True: Run m-code using m-file
+    use_mcr:
+    # type=bool|default=False: Run m-code using SPM MCR
+    use_v8struct:
+    # type=bool|default=True: Generate SPM8 and higher compatible jobs
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-spm/realign_unwarp_callables.py b/example-specs/task/nipype_internal/pydra-spm/realign_unwarp_callables.py
new file mode 100644
index 00000000..98e49c21
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-spm/realign_unwarp_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in RealignUnwarp.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-spm/reslice.yaml b/example-specs/task/nipype_internal/pydra-spm/reslice.yaml
new file mode 100644
index 00000000..20b6a72f
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-spm/reslice.yaml
@@ -0,0 +1,93 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.spm.utils.Reslice' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# uses  spm_reslice to resample in_file into space of space_defining
+task_name: Reslice
+nipype_name: Reslice
+nipype_module: nipype.interfaces.spm.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: generic/file
+    # type=file|default=<undefined>: file to apply transform to, (only updates header)
+    space_defining: generic/file
+    # type=file|default=<undefined>: Volume defining space to slice in_file into
+    out_file: generic/file
+    # type=file: resliced volume
+    # type=file|default=<undefined>: Optional file to save resliced volume
+    paths: generic/directory+list-of
+    # type=inputmultiobject|default=[]: Paths to add to matlabpath
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: resliced volume
+    # type=file|default=<undefined>: Optional file to save resliced volume
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: file to apply transform to, (only updates header)
+    space_defining:
+    # type=file|default=<undefined>: Volume defining space to slice in_file into
+    interp:
+    # type=range|default=0: degree of b-spline used for interpolation0 is nearest neighbor (default)
+    out_file:
+    # type=file: resliced volume
+    # type=file|default=<undefined>: Optional file to save resliced volume
+    matlab_cmd:
+    # type=str|default='': matlab command to use
+    paths:
+    # type=inputmultiobject|default=[]: Paths to add to matlabpath
+    mfile:
+    # type=bool|default=True: Run m-code using m-file
+    use_mcr:
+    # type=bool|default=False: Run m-code using SPM MCR
+    use_v8struct:
+    # type=bool|default=True: Generate SPM8 and higher compatible jobs
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-spm/reslice_callables.py b/example-specs/task/nipype_internal/pydra-spm/reslice_callables.py
new file mode 100644
index 00000000..7d5ac3b8
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-spm/reslice_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Reslice.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-spm/reslice_to_reference.yaml b/example-specs/task/nipype_internal/pydra-spm/reslice_to_reference.yaml
new file mode 100644
index 00000000..4eaeeea5
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-spm/reslice_to_reference.yaml
@@ -0,0 +1,99 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.spm.utils.ResliceToReference' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Uses spm to reslice a volume to a target image space or to a provided
+#     voxel size and bounding box
+# 
+#     Examples
+#     --------
+# 
+#     >>> import nipype.interfaces.spm.utils as spmu
+#     >>> r2ref = spmu.ResliceToReference()
+#     >>> r2ref.inputs.in_files = 'functional.nii'
+#     >>> r2ref.inputs.target = 'structural.nii'
+#     >>> r2ref.run() # doctest: +SKIP
+#     
+task_name: ResliceToReference
+nipype_name: ResliceToReference
+nipype_module: nipype.interfaces.spm.utils
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_files: generic/file+list-of
+    # type=inputmultiobject|default=[]: Files on which deformation is applied
+    target: generic/file
+    # type=file|default=<undefined>: File defining target space
+    paths: generic/directory+list-of
+    # type=inputmultiobject|default=[]: Paths to add to matlabpath
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_files:
+    # type=inputmultiobject|default=[]: Files on which deformation is applied
+    target:
+    # type=file|default=<undefined>: File defining target space
+    interpolation:
+    # type=range|default=0: degree of b-spline used for interpolation
+    bounding_box:
+    # type=list|default=[]: 6-element list (opt)
+    voxel_sizes:
+    # type=list|default=[]: 3-element list (opt)
+    matlab_cmd:
+    # type=str|default='': matlab command to use
+    paths:
+    # type=inputmultiobject|default=[]: Paths to add to matlabpath
+    mfile:
+    # type=bool|default=True: Run m-code using m-file
+    use_mcr:
+    # type=bool|default=False: Run m-code using SPM MCR
+    use_v8struct:
+    # type=bool|default=True: Generate SPM8 and higher compatible jobs
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-spm/reslice_to_reference_callables.py b/example-specs/task/nipype_internal/pydra-spm/reslice_to_reference_callables.py
new file mode 100644
index 00000000..73561569
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-spm/reslice_to_reference_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in ResliceToReference.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-spm/segment.yaml b/example-specs/task/nipype_internal/pydra-spm/segment.yaml
new file mode 100644
index 00000000..8efbe84b
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-spm/segment.yaml
@@ -0,0 +1,146 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.spm.preprocess.Segment' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# use spm_segment to separate structural images into different
+#     tissue classes.
+# 
+#     http://www.fil.ion.ucl.ac.uk/spm/doc/manual.pdf#page=209
+# 
+#     Examples
+#     --------
+#     >>> import nipype.interfaces.spm as spm
+#     >>> seg = spm.Segment()
+#     >>> seg.inputs.data = 'structural.nii'
+#     >>> seg.run() # doctest: +SKIP
+# 
+#     
+task_name: Segment
+nipype_name: Segment
+nipype_module: nipype.interfaces.spm.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    tissue_prob_maps: generic/file+list-of
+    # type=list|default=[]: list of gray, white & csf prob. (opt,)
+    mask_image: generic/file
+    # type=file|default=<undefined>: Binary image to restrict parameter estimation 
+    paths: generic/directory+list-of
+    # type=inputmultiobject|default=[]: Paths to add to matlabpath
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    native_gm_image: generic/file
+    # type=file: native space grey probability map
+    normalized_gm_image: generic/file
+    # type=file: normalized grey probability map
+    modulated_gm_image: generic/file
+    # type=file: modulated, normalized grey probability map
+    native_wm_image: generic/file
+    # type=file: native space white probability map
+    normalized_wm_image: generic/file
+    # type=file: normalized white probability map
+    modulated_wm_image: generic/file
+    # type=file: modulated, normalized white probability map
+    native_csf_image: generic/file
+    # type=file: native space csf probability map
+    normalized_csf_image: generic/file
+    # type=file: normalized csf probability map
+    modulated_csf_image: generic/file
+    # type=file: modulated, normalized csf probability map
+    modulated_input_image: generic/file
+    # type=file: bias-corrected version of input image
+    bias_corrected_image: generic/file
+    # type=file: bias-corrected version of input image
+    transformation_mat: generic/file
+    # type=file: Normalization transformation
+    inverse_transformation_mat: generic/file
+    # type=file: Inverse normalization info
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    data:
+    # type=inputmultiobject|default=[]: one scan per subject
+    gm_output_type:
+    # type=list|default=[]: Options to produce grey matter images: c1*.img, wc1*.img and mwc1*.img.             None: [False,False,False],             Native Space: [False,False,True],             Unmodulated Normalised: [False,True,False],             Modulated Normalised: [True,False,False],             Native + Unmodulated Normalised: [False,True,True],             Native + Modulated Normalised: [True,False,True],             Native + Modulated + Unmodulated: [True,True,True],             Modulated + Unmodulated Normalised: [True,True,False]
+    wm_output_type:
+    # type=list|default=[]:              Options to produce white matter images: c2*.img, wc2*.img and mwc2*.img.             None: [False,False,False],             Native Space: [False,False,True],             Unmodulated Normalised: [False,True,False],             Modulated Normalised: [True,False,False],             Native + Unmodulated Normalised: [False,True,True],             Native + Modulated Normalised: [True,False,True],             Native + Modulated + Unmodulated: [True,True,True],             Modulated + Unmodulated Normalised: [True,True,False]
+    csf_output_type:
+    # type=list|default=[]:              Options to produce CSF images: c3*.img, wc3*.img and mwc3*.img.             None: [False,False,False],             Native Space: [False,False,True],             Unmodulated Normalised: [False,True,False],             Modulated Normalised: [True,False,False],             Native + Unmodulated Normalised: [False,True,True],             Native + Modulated Normalised: [True,False,True],             Native + Modulated + Unmodulated: [True,True,True],             Modulated + Unmodulated Normalised: [True,True,False]
+    save_bias_corrected:
+    # type=bool|default=False: True/False produce a bias corrected image
+    clean_masks:
+    # type=enum|default='no'|allowed['light','no','thorough']: clean using estimated brain mask ('no','light','thorough')
+    tissue_prob_maps:
+    # type=list|default=[]: list of gray, white & csf prob. (opt,)
+    gaussians_per_class:
+    # type=list|default=[]: num Gaussians capture intensity distribution
+    affine_regularization:
+    # type=enum|default='mni'|allowed['','eastern','mni','none','subj']: Possible options: "mni", "eastern", "subj", "none" (no reguralisation), "" (no affine registration)
+    warping_regularization:
+    # type=float|default=0.0: Controls balance between parameters and data
+    warp_frequency_cutoff:
+    # type=float|default=0.0: Cutoff of DCT bases
+    bias_regularization:
+    # type=enum|default=0|allowed[0,0.0001,0.001,0.01,0.1,1,10,1e-05]: no(0) - extremely heavy (10)
+    bias_fwhm:
+    # type=enum|default=30|allowed['Inf',100,110,120,130,30,40,50,60,70,80,90]: FWHM of Gaussian smoothness of bias
+    sampling_distance:
+    # type=float|default=0.0: Sampling distance on data for parameter estimation
+    mask_image:
+    # type=file|default=<undefined>: Binary image to restrict parameter estimation 
+    matlab_cmd:
+    # type=str|default='': matlab command to use
+    paths:
+    # type=inputmultiobject|default=[]: Paths to add to matlabpath
+    mfile:
+    # type=bool|default=True: Run m-code using m-file
+    use_mcr:
+    # type=bool|default=False: Run m-code using SPM MCR
+    use_v8struct:
+    # type=bool|default=True: Generate SPM8 and higher compatible jobs
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-spm/segment_callables.py b/example-specs/task/nipype_internal/pydra-spm/segment_callables.py
new file mode 100644
index 00000000..9cb3d9e6
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-spm/segment_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Segment.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-spm/slice_timing.yaml b/example-specs/task/nipype_internal/pydra-spm/slice_timing.yaml
new file mode 100644
index 00000000..625bc155
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-spm/slice_timing.yaml
@@ -0,0 +1,105 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.spm.preprocess.SliceTiming' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Use spm to perform slice timing correction.
+# 
+#     http://www.fil.ion.ucl.ac.uk/spm/doc/manual.pdf#page=19
+# 
+#     Examples
+#     --------
+# 
+#     >>> from nipype.interfaces.spm import SliceTiming
+#     >>> st = SliceTiming()
+#     >>> st.inputs.in_files = 'functional.nii'
+#     >>> st.inputs.num_slices = 32
+#     >>> st.inputs.time_repetition = 6.0
+#     >>> st.inputs.time_acquisition = 6. - 6./32.
+#     >>> st.inputs.slice_order = list(range(32,0,-1))
+#     >>> st.inputs.ref_slice = 1
+#     >>> st.run() # doctest: +SKIP
+# 
+#     
+task_name: SliceTiming
+nipype_name: SliceTiming
+nipype_module: nipype.interfaces.spm.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    paths: generic/directory+list-of
+    # type=inputmultiobject|default=[]: Paths to add to matlabpath
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_files:
+    # type=inputmultiobject|default=[]: list of filenames to apply slice timing
+    num_slices:
+    # type=int|default=0: number of slices in a volume
+    time_repetition:
+    # type=float|default=0.0: time between volume acquisitions (start to start time)
+    time_acquisition:
+    # type=float|default=0.0: time of volume acquisition. usually calculated as TR-(TR/num_slices)
+    slice_order:
+    # type=list|default=[]: 1-based order or onset (in ms) in which slices are acquired
+    ref_slice:
+    # type=traitcompound|default=None: 1-based Number of the reference slice or reference time point if slice_order is in onsets (ms)
+    out_prefix:
+    # type=string|default='a': slicetimed output prefix
+    matlab_cmd:
+    # type=str|default='': matlab command to use
+    paths:
+    # type=inputmultiobject|default=[]: Paths to add to matlabpath
+    mfile:
+    # type=bool|default=True: Run m-code using m-file
+    use_mcr:
+    # type=bool|default=False: Run m-code using SPM MCR
+    use_v8struct:
+    # type=bool|default=True: Generate SPM8 and higher compatible jobs
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-spm/slice_timing_callables.py b/example-specs/task/nipype_internal/pydra-spm/slice_timing_callables.py
new file mode 100644
index 00000000..230aaf91
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-spm/slice_timing_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in SliceTiming.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-spm/smooth.yaml b/example-specs/task/nipype_internal/pydra-spm/smooth.yaml
new file mode 100644
index 00000000..0d7d7c28
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-spm/smooth.yaml
@@ -0,0 +1,95 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.spm.preprocess.Smooth' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Use spm_smooth for 3D Gaussian smoothing of image volumes.
+# 
+#     http://www.fil.ion.ucl.ac.uk/spm/doc/manual.pdf#page=55
+# 
+#     Examples
+#     --------
+#     >>> import nipype.interfaces.spm as spm
+#     >>> smooth = spm.Smooth()
+#     >>> smooth.inputs.in_files = 'functional.nii'
+#     >>> smooth.inputs.fwhm = [4, 4, 4]
+#     >>> smooth.run() # doctest: +SKIP
+#     
+task_name: Smooth
+nipype_name: Smooth
+nipype_module: nipype.interfaces.spm.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    paths: generic/directory+list-of
+    # type=inputmultiobject|default=[]: Paths to add to matlabpath
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_files:
+    # type=inputmultiobject|default=[]: list of files to smooth
+    fwhm:
+    # type=traitcompound|default=None: 3-list of fwhm for each dimension
+    data_type:
+    # type=int|default=0: Data type of the output images
+    implicit_masking:
+    # type=bool|default=False: A mask implied by a particular voxel value
+    out_prefix:
+    # type=string|default='s': smoothed output prefix
+    matlab_cmd:
+    # type=str|default='': matlab command to use
+    paths:
+    # type=inputmultiobject|default=[]: Paths to add to matlabpath
+    mfile:
+    # type=bool|default=True: Run m-code using m-file
+    use_mcr:
+    # type=bool|default=False: Run m-code using SPM MCR
+    use_v8struct:
+    # type=bool|default=True: Generate SPM8 and higher compatible jobs
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-spm/smooth_callables.py b/example-specs/task/nipype_internal/pydra-spm/smooth_callables.py
new file mode 100644
index 00000000..5dbe8c1a
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-spm/smooth_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Smooth.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-spm/threshold.yaml b/example-specs/task/nipype_internal/pydra-spm/threshold.yaml
new file mode 100644
index 00000000..ec2a7c1b
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-spm/threshold.yaml
@@ -0,0 +1,117 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.spm.model.Threshold' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Topological FDR thresholding based on cluster extent/size. Smoothness is
+#     estimated from GLM residuals but is assumed to be the same for all of the
+#     voxels.
+# 
+#     Examples
+#     --------
+# 
+#     >>> thresh = Threshold()
+#     >>> thresh.inputs.spm_mat_file = 'SPM.mat'
+#     >>> thresh.inputs.stat_image = 'spmT_0001.img'
+#     >>> thresh.inputs.contrast_index = 1
+#     >>> thresh.inputs.extent_fdr_p_threshold = 0.05
+#     >>> thresh.run() # doctest: +SKIP
+#     
+task_name: Threshold
+nipype_name: Threshold
+nipype_module: nipype.interfaces.spm.model
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    spm_mat_file: generic/file
+    # type=file|default=<undefined>: absolute path to SPM.mat
+    stat_image: generic/file
+    # type=file|default=<undefined>: stat image
+    paths: generic/directory+list-of
+    # type=inputmultiobject|default=[]: Paths to add to matlabpath
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    thresholded_map: generic/file
+    # type=file: 
+    pre_topo_fdr_map: generic/file
+    # type=file: 
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    spm_mat_file:
+    # type=file|default=<undefined>: absolute path to SPM.mat
+    stat_image:
+    # type=file|default=<undefined>: stat image
+    contrast_index:
+    # type=int|default=0: which contrast in the SPM.mat to use
+    use_fwe_correction:
+    # type=bool|default=True: whether to use FWE (Bonferroni) correction for initial threshold (height_threshold_type has to be set to p-value)
+    use_vox_fdr_correction:
+    # type=bool|default=False: whether to use voxel-based FDR correction for initial threshold (height_threshold_type has to be set to q-value)
+    use_topo_fdr:
+    # type=bool|default=True: whether to use FDR over cluster extent probabilities
+    height_threshold:
+    # type=float|default=0.05: value for initial thresholding (defining clusters)
+    height_threshold_type:
+    # type=enum|default='p-value'|allowed['p-value','stat']: Is the cluster forming threshold a stat value or p-value?
+    extent_fdr_p_threshold:
+    # type=float|default=0.05: p threshold on FDR corrected cluster size probabilities
+    extent_threshold:
+    # type=int|default=0: Minimum cluster size in voxels
+    force_activation:
+    # type=bool|default=False: In case no clusters survive the topological inference step this will pick a culster with the highest sum of t-values. Use with care.
+    matlab_cmd:
+    # type=str|default='': matlab command to use
+    paths:
+    # type=inputmultiobject|default=[]: Paths to add to matlabpath
+    mfile:
+    # type=bool|default=True: Run m-code using m-file
+    use_mcr:
+    # type=bool|default=False: Run m-code using SPM MCR
+    use_v8struct:
+    # type=bool|default=True: Generate SPM8 and higher compatible jobs
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-spm/threshold_callables.py b/example-specs/task/nipype_internal/pydra-spm/threshold_callables.py
new file mode 100644
index 00000000..a542f78f
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-spm/threshold_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Threshold.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-spm/threshold_statistics.yaml b/example-specs/task/nipype_internal/pydra-spm/threshold_statistics.yaml
new file mode 100644
index 00000000..31df06bb
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-spm/threshold_statistics.yaml
@@ -0,0 +1,100 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.spm.model.ThresholdStatistics' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Given height and cluster size threshold calculate theoretical
+#     probabilities concerning false positives
+# 
+#     Examples
+#     --------
+# 
+#     >>> thresh = ThresholdStatistics()
+#     >>> thresh.inputs.spm_mat_file = 'SPM.mat'
+#     >>> thresh.inputs.stat_image = 'spmT_0001.img'
+#     >>> thresh.inputs.contrast_index = 1
+#     >>> thresh.inputs.height_threshold = 4.56
+#     >>> thresh.run() # doctest: +SKIP
+#     
+task_name: ThresholdStatistics
+nipype_name: ThresholdStatistics
+nipype_module: nipype.interfaces.spm.model
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    spm_mat_file: generic/file
+    # type=file|default=<undefined>: absolute path to SPM.mat
+    stat_image: generic/file
+    # type=file|default=<undefined>: stat image
+    paths: generic/directory+list-of
+    # type=inputmultiobject|default=[]: Paths to add to matlabpath
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    spm_mat_file:
+    # type=file|default=<undefined>: absolute path to SPM.mat
+    stat_image:
+    # type=file|default=<undefined>: stat image
+    contrast_index:
+    # type=int|default=0: which contrast in the SPM.mat to use
+    height_threshold:
+    # type=float|default=0.0: stat value for initial thresholding (defining clusters)
+    extent_threshold:
+    # type=int|default=0: Minimum cluster size in voxels
+    matlab_cmd:
+    # type=str|default='': matlab command to use
+    paths:
+    # type=inputmultiobject|default=[]: Paths to add to matlabpath
+    mfile:
+    # type=bool|default=True: Run m-code using m-file
+    use_mcr:
+    # type=bool|default=False: Run m-code using SPM MCR
+    use_v8struct:
+    # type=bool|default=True: Generate SPM8 and higher compatible jobs
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-spm/threshold_statistics_callables.py b/example-specs/task/nipype_internal/pydra-spm/threshold_statistics_callables.py
new file mode 100644
index 00000000..7ef3621e
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-spm/threshold_statistics_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in ThresholdStatistics.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-spm/two_sample_t_test_design.yaml b/example-specs/task/nipype_internal/pydra-spm/two_sample_t_test_design.yaml
new file mode 100644
index 00000000..968fa1e7
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-spm/two_sample_t_test_design.yaml
@@ -0,0 +1,125 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.spm.model.TwoSampleTTestDesign' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Create SPM design for two sample t-test
+# 
+#     Examples
+#     --------
+# 
+#     >>> ttest = TwoSampleTTestDesign()
+#     >>> ttest.inputs.group1_files = ['cont1.nii', 'cont2.nii']
+#     >>> ttest.inputs.group2_files = ['cont1a.nii', 'cont2a.nii']
+#     >>> ttest.run() # doctest: +SKIP
+#     
+task_name: TwoSampleTTestDesign
+nipype_name: TwoSampleTTestDesign
+nipype_module: nipype.interfaces.spm.model
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    group1_files: generic/file+list-of
+    # type=list|default=[]: Group 1 input files
+    group2_files: generic/file+list-of
+    # type=list|default=[]: Group 2 input files
+    explicit_mask_file: generic/file
+    # type=file|default=<undefined>: use an implicit mask file to threshold
+    spm_mat_dir: generic/directory
+    # type=directory|default=<undefined>: directory to store SPM.mat file (opt)
+    paths: generic/directory+list-of
+    # type=inputmultiobject|default=[]: Paths to add to matlabpath
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    spm_mat_file: generic/file
+    # type=file: SPM mat file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    group1_files:
+    # type=list|default=[]: Group 1 input files
+    group2_files:
+    # type=list|default=[]: Group 2 input files
+    dependent:
+    # type=bool|default=False: Are the measurements dependent between levels
+    unequal_variance:
+    # type=bool|default=False: Are the variances equal or unequal between groups
+    spm_mat_dir:
+    # type=directory|default=<undefined>: directory to store SPM.mat file (opt)
+    covariates:
+    # type=inputmultiobject|default=[]: covariate dictionary {vector, name, interaction, centering}
+    threshold_mask_none:
+    # type=bool|default=False: do not use threshold masking
+    threshold_mask_absolute:
+    # type=float|default=0.0: use an absolute threshold
+    threshold_mask_relative:
+    # type=float|default=0.0: threshold using a proportion of the global value
+    use_implicit_threshold:
+    # type=bool|default=False: use implicit mask NaNs or zeros to threshold
+    explicit_mask_file:
+    # type=file|default=<undefined>: use an implicit mask file to threshold
+    global_calc_omit:
+    # type=bool|default=False: omit global calculation
+    global_calc_mean:
+    # type=bool|default=False: use mean for global calculation
+    global_calc_values:
+    # type=list|default=[]: omit global calculation
+    no_grand_mean_scaling:
+    # type=bool|default=False: do not perform grand mean scaling
+    global_normalization:
+    # type=enum|default=1|allowed[1,2,3]: global normalization None-1, Proportional-2, ANCOVA-3
+    matlab_cmd:
+    # type=str|default='': matlab command to use
+    paths:
+    # type=inputmultiobject|default=[]: Paths to add to matlabpath
+    mfile:
+    # type=bool|default=True: Run m-code using m-file
+    use_mcr:
+    # type=bool|default=False: Run m-code using SPM MCR
+    use_v8struct:
+    # type=bool|default=True: Generate SPM8 and higher compatible jobs
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-spm/two_sample_t_test_design_callables.py b/example-specs/task/nipype_internal/pydra-spm/two_sample_t_test_design_callables.py
new file mode 100644
index 00000000..844a84cb
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-spm/two_sample_t_test_design_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in TwoSampleTTestDesign.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-spm/vbm_segment.yaml b/example-specs/task/nipype_internal/pydra-spm/vbm_segment.yaml
new file mode 100644
index 00000000..523b4eca
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-spm/vbm_segment.yaml
@@ -0,0 +1,156 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.spm.preprocess.VBMSegment' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# Use VBM8 toolbox to separate structural images into different
+#     tissue classes.
+# 
+#     Example
+#     -------
+#     >>> import nipype.interfaces.spm as spm
+#     >>> seg = spm.VBMSegment()
+#     >>> seg.inputs.tissues = 'TPM.nii'
+#     >>> seg.inputs.dartel_template = 'Template_1_IXI550_MNI152.nii'
+#     >>> seg.inputs.bias_corrected_native = True
+#     >>> seg.inputs.gm_native = True
+#     >>> seg.inputs.wm_native = True
+#     >>> seg.inputs.csf_native = True
+#     >>> seg.inputs.pve_label_native = True
+#     >>> seg.inputs.deformation_field = (True, False)
+#     >>> seg.run() # doctest: +SKIP
+#     
+task_name: VBMSegment
+nipype_name: VBMSegment
+nipype_module: nipype.interfaces.spm.preprocess
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    paths: generic/directory+list-of
+    # type=inputmultiobject|default=[]: Paths to add to matlabpath
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_files:
+    # type=inputmultiobject|default=[]: A list of files to be segmented
+    tissues:
+    # type=imagefilespm|default=<undefined>: tissue probability map
+    gaussians_per_class:
+    # type=tuple|default=(2, 2, 2, 3, 4, 2): number of gaussians for each tissue class
+    bias_regularization:
+    # type=enum|default=0.0001|allowed[0,0.0001,0.001,0.01,0.1,1,10,1e-05]: no(0) - extremely heavy (10)
+    bias_fwhm:
+    # type=enum|default=60|allowed['Inf',100,110,120,130,30,40,50,60,70,80,90]: FWHM of Gaussian smoothness of bias
+    sampling_distance:
+    # type=float|default=3: Sampling distance on data for parameter estimation
+    warping_regularization:
+    # type=float|default=4: Controls balance between parameters and data
+    spatial_normalization:
+    # type=enum|default='high'|allowed['high','low']: 
+    dartel_template:
+    # type=imagefilespm|default=<undefined>: 
+    use_sanlm_denoising_filter:
+    # type=range|default=2: 0=No denoising, 1=denoising,2=denoising multi-threaded
+    mrf_weighting:
+    # type=float|default=0.15: 
+    cleanup_partitions:
+    # type=int|default=1: 0=None,1=light,2=thorough
+    display_results:
+    # type=bool|default=True: 
+    gm_native:
+    # type=bool|default=False: 
+    gm_normalized:
+    # type=bool|default=False: 
+    gm_modulated_normalized:
+    # type=range|default=2: 0=none,1=affine+non-linear(SPM8 default),2=non-linear only
+    gm_dartel:
+    # type=range|default=0: 0=None,1=rigid(SPM8 default),2=affine
+    wm_native:
+    # type=bool|default=False: 
+    wm_normalized:
+    # type=bool|default=False: 
+    wm_modulated_normalized:
+    # type=range|default=2: 0=none,1=affine+non-linear(SPM8 default),2=non-linear only
+    wm_dartel:
+    # type=range|default=0: 0=None,1=rigid(SPM8 default),2=affine
+    csf_native:
+    # type=bool|default=False: 
+    csf_normalized:
+    # type=bool|default=False: 
+    csf_modulated_normalized:
+    # type=range|default=2: 0=none,1=affine+non-linear(SPM8 default),2=non-linear only
+    csf_dartel:
+    # type=range|default=0: 0=None,1=rigid(SPM8 default),2=affine
+    bias_corrected_native:
+    # type=bool|default=False: 
+    bias_corrected_normalized:
+    # type=bool|default=True: 
+    bias_corrected_affine:
+    # type=bool|default=False: 
+    pve_label_native:
+    # type=bool|default=False: 
+    pve_label_normalized:
+    # type=bool|default=False: 
+    pve_label_dartel:
+    # type=range|default=0: 0=None,1=rigid(SPM8 default),2=affine
+    jacobian_determinant:
+    # type=bool|default=False: 
+    deformation_field:
+    # type=tuple|default=(0, 0): forward and inverse field
+    matlab_cmd:
+    # type=str|default='': matlab command to use
+    paths:
+    # type=inputmultiobject|default=[]: Paths to add to matlabpath
+    mfile:
+    # type=bool|default=True: Run m-code using m-file
+    use_mcr:
+    # type=bool|default=False: Run m-code using SPM MCR
+    use_v8struct:
+    # type=bool|default=True: Generate SPM8 and higher compatible jobs
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-spm/vbm_segment_callables.py b/example-specs/task/nipype_internal/pydra-spm/vbm_segment_callables.py
new file mode 100644
index 00000000..31b90684
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-spm/vbm_segment_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in VBMSegment.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-vista/vnifti_2_image.yaml b/example-specs/task/nipype_internal/pydra-vista/vnifti_2_image.yaml
new file mode 100644
index 00000000..668753b1
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-vista/vnifti_2_image.yaml
@@ -0,0 +1,127 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.vista.vista.Vnifti2Image' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Convert a nifti file into a vista file.
+# 
+#     Example
+#     -------
+#     >>> vimage = Vnifti2Image()
+#     >>> vimage.inputs.in_file = 'image.nii'
+#     >>> vimage.cmdline
+#     'vnifti2image -in image.nii -out image.v'
+#     >>> vimage.run()  # doctest: +SKIP
+# 
+#     
+task_name: Vnifti2Image
+nipype_name: Vnifti2Image
+nipype_module: nipype.interfaces.vista.vista
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: in file
+    attributes: generic/file
+    # type=file|default=<undefined>: attribute file
+    out_file: generic/file
+    # type=file: Output vista file
+    # type=file|default=<undefined>: output data file
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: Output vista file
+    # type=file|default=<undefined>: output data file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: in file
+    attributes:
+    # type=file|default=<undefined>: attribute file
+    out_file:
+    # type=file: Output vista file
+    # type=file|default=<undefined>: output data file
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: in file
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: vnifti2image -in image.nii -out image.v
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: in file
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-vista/vnifti_2_image_callables.py b/example-specs/task/nipype_internal/pydra-vista/vnifti_2_image_callables.py
new file mode 100644
index 00000000..ad1abcaa
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-vista/vnifti_2_image_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in Vnifti2Image.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-vista/vto_mat.yaml b/example-specs/task/nipype_internal/pydra-vista/vto_mat.yaml
new file mode 100644
index 00000000..2f6286e8
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-vista/vto_mat.yaml
@@ -0,0 +1,123 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.vista.vista.VtoMat' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Convert a nifti file into a vista file.
+# 
+#     Example
+#     -------
+#     >>> vimage = VtoMat()
+#     >>> vimage.inputs.in_file = 'image.v'
+#     >>> vimage.cmdline
+#     'vtomat -in image.v -out image.mat'
+#     >>> vimage.run()  # doctest: +SKIP
+# 
+#     
+task_name: VtoMat
+nipype_name: VtoMat
+nipype_module: nipype.interfaces.vista.vista
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage-vista/v
+    # type=file|default=<undefined>: in file
+    out_file: generic/file
+    # type=file: Output mat file
+    # type=file|default=<undefined>: output mat file
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: Output mat file
+    # type=file|default=<undefined>: output mat file
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: in file
+    out_file:
+    # type=file: Output mat file
+    # type=file|default=<undefined>: output mat file
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: in file
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: vtomat -in image.v -out image.mat
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: in file
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-vista/vto_mat_callables.py b/example-specs/task/nipype_internal/pydra-vista/vto_mat_callables.py
new file mode 100644
index 00000000..3c28eba0
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-vista/vto_mat_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in VtoMat.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-workbench/cifti_smooth.yaml b/example-specs/task/nipype_internal/pydra-workbench/cifti_smooth.yaml
new file mode 100644
index 00000000..390ee0c8
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-workbench/cifti_smooth.yaml
@@ -0,0 +1,203 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.workbench.cifti.CiftiSmooth' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Smooth a CIFTI file
+# 
+#     The input cifti file must have a brain models mapping on the chosen
+#     dimension, columns for .dtseries, and either for .dconn.  By default,
+#     data in different structures is smoothed independently (i.e., "parcel
+#     constrained" smoothing), so volume structures that touch do not smooth
+#     across this boundary.  Specify ``merged_volume`` to ignore these
+#     boundaries. Surface smoothing uses the ``GEO_GAUSS_AREA`` smoothing method.
+# 
+#     The ``*_corrected_areas`` options are intended for when it is unavoidable
+#     to smooth on group average surfaces, it is only an approximate correction
+#     for the reduction of structure in a group average surface.  It is better
+#     to smooth the data on individuals before averaging, when feasible.
+# 
+#     The ``fix_zeros_*`` options will treat values of zero as lack of data, and
+#     not use that value when generating the smoothed values, but will fill
+#     zeros with extrapolated values.  The ROI should have a brain models
+#     mapping along columns, exactly matching the mapping of the chosen
+#     direction in the input file.  Data outside the ROI is ignored.
+# 
+#     >>> from nipype.interfaces.workbench import CiftiSmooth
+#     >>> smooth = CiftiSmooth()
+#     >>> smooth.inputs.in_file = 'sub-01_task-rest.dtseries.nii'
+#     >>> smooth.inputs.sigma_surf = 4
+#     >>> smooth.inputs.sigma_vol = 4
+#     >>> smooth.inputs.direction = 'COLUMN'
+#     >>> smooth.inputs.right_surf = 'sub-01.R.midthickness.32k_fs_LR.surf.gii'
+#     >>> smooth.inputs.left_surf = 'sub-01.L.midthickness.32k_fs_LR.surf.gii'
+#     >>> smooth.cmdline
+#     'wb_command -cifti-smoothing sub-01_task-rest.dtseries.nii 4.0 4.0 COLUMN     smoothed_sub-01_task-rest.dtseries.nii     -left-surface sub-01.L.midthickness.32k_fs_LR.surf.gii     -right-surface sub-01.R.midthickness.32k_fs_LR.surf.gii'
+#     
+task_name: CiftiSmooth
+nipype_name: CiftiSmooth
+nipype_module: nipype.interfaces.workbench.cifti
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: The input CIFTI file
+    out_file: generic/file
+    # type=file: output CIFTI file
+    # type=file|default=<undefined>: The output CIFTI
+    left_surf: medimage/gifti
+    # type=file|default=<undefined>: Specify the left surface to use
+    left_corrected_areas: generic/file
+    # type=file|default=<undefined>: vertex areas (as a metric) to use instead of computing them from the left surface.
+    right_surf: medimage/gifti
+    # type=file|default=<undefined>: Specify the right surface to use
+    right_corrected_areas: generic/file
+    # type=file|default=<undefined>: vertex areas (as a metric) to use instead of computing them from the right surface
+    cerebellum_surf: generic/file
+    # type=file|default=<undefined>: specify the cerebellum surface to use
+    cerebellum_corrected_areas: generic/file
+    # type=file|default=<undefined>: vertex areas (as a metric) to use instead of computing them from the cerebellum surface
+    cifti_roi: generic/file
+    # type=file|default=<undefined>: CIFTI file for ROI smoothing
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: output CIFTI file
+    # type=file|default=<undefined>: The output CIFTI
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: The input CIFTI file
+    sigma_surf:
+    # type=float|default=0.0: the sigma for the gaussian surface smoothing kernel, in mm
+    sigma_vol:
+    # type=float|default=0.0: the sigma for the gaussian volume smoothing kernel, in mm
+    direction:
+    # type=enum|default='ROW'|allowed['COLUMN','ROW']: which dimension to smooth along, ROW or COLUMN
+    out_file:
+    # type=file: output CIFTI file
+    # type=file|default=<undefined>: The output CIFTI
+    left_surf:
+    # type=file|default=<undefined>: Specify the left surface to use
+    left_corrected_areas:
+    # type=file|default=<undefined>: vertex areas (as a metric) to use instead of computing them from the left surface.
+    right_surf:
+    # type=file|default=<undefined>: Specify the right surface to use
+    right_corrected_areas:
+    # type=file|default=<undefined>: vertex areas (as a metric) to use instead of computing them from the right surface
+    cerebellum_surf:
+    # type=file|default=<undefined>: specify the cerebellum surface to use
+    cerebellum_corrected_areas:
+    # type=file|default=<undefined>: vertex areas (as a metric) to use instead of computing them from the cerebellum surface
+    cifti_roi:
+    # type=file|default=<undefined>: CIFTI file for ROI smoothing
+    fix_zeros_vol:
+    # type=bool|default=False: treat values of zero in the volume as missing data
+    fix_zeros_surf:
+    # type=bool|default=False: treat values of zero on the surface as missing data
+    merged_volume:
+    # type=bool|default=False: smooth across subcortical structure boundaries
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: The input CIFTI file
+    sigma_surf: '4'
+    # type=float|default=0.0: the sigma for the gaussian surface smoothing kernel, in mm
+    sigma_vol: '4'
+    # type=float|default=0.0: the sigma for the gaussian volume smoothing kernel, in mm
+    direction: '"COLUMN"'
+    # type=enum|default='ROW'|allowed['COLUMN','ROW']: which dimension to smooth along, ROW or COLUMN
+    right_surf:
+    # type=file|default=<undefined>: Specify the right surface to use
+    left_surf:
+    # type=file|default=<undefined>: Specify the left surface to use
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: wb_command -cifti-smoothing sub-01_task-rest.dtseries.nii 4.0 4.0 COLUMN smoothed_sub-01_task-rest.dtseries.nii -left-surface sub-01.L.midthickness.32k_fs_LR.surf.gii -right-surface sub-01.R.midthickness.32k_fs_LR.surf.gii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: The input CIFTI file
+    sigma_surf: '4'
+    # type=float|default=0.0: the sigma for the gaussian surface smoothing kernel, in mm
+    sigma_vol: '4'
+    # type=float|default=0.0: the sigma for the gaussian volume smoothing kernel, in mm
+    direction: '"COLUMN"'
+    # type=enum|default='ROW'|allowed['COLUMN','ROW']: which dimension to smooth along, ROW or COLUMN
+    right_surf:
+    # type=file|default=<undefined>: Specify the right surface to use
+    left_surf:
+    # type=file|default=<undefined>: Specify the left surface to use
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-workbench/cifti_smooth_callables.py b/example-specs/task/nipype_internal/pydra-workbench/cifti_smooth_callables.py
new file mode 100644
index 00000000..24080d97
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-workbench/cifti_smooth_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in CiftiSmooth.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-workbench/metric_resample.yaml b/example-specs/task/nipype_internal/pydra-workbench/metric_resample.yaml
new file mode 100644
index 00000000..670dc849
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-workbench/metric_resample.yaml
@@ -0,0 +1,200 @@
+# This file is used to manually specify the semi-automatic conversion of
+# 'nipype.interfaces.workbench.metric.MetricResample' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# 
+#     Resample a metric file to a different mesh
+# 
+#     Resamples a metric file, given two spherical surfaces that are in
+#     register.  If ``ADAP_BARY_AREA`` is used, exactly one of -area-surfs or
+#     ``-area-metrics`` must be specified.
+# 
+#     The ``ADAP_BARY_AREA`` method is recommended for ordinary metric data,
+#     because it should use all data while downsampling, unlike ``BARYCENTRIC``.
+#     The recommended areas option for most data is individual midthicknesses
+#     for individual data, and averaged vertex area metrics from individual
+#     midthicknesses for group average data.
+# 
+#     The ``-current-roi`` option only masks the input, the output may be slightly
+#     dilated in comparison, consider using ``-metric-mask`` on the output when
+#     using ``-current-roi``.
+# 
+#     The ``-largest option`` results in nearest vertex behavior when used with
+#     ``BARYCENTRIC``.  When resampling a binary metric, consider thresholding at
+#     0.5 after resampling rather than using ``-largest``.
+# 
+#     >>> from nipype.interfaces.workbench import MetricResample
+#     >>> metres = MetricResample()
+#     >>> metres.inputs.in_file = 'sub-01_task-rest_bold_space-fsaverage5.L.func.gii'
+#     >>> metres.inputs.method = 'ADAP_BARY_AREA'
+#     >>> metres.inputs.current_sphere = 'fsaverage5_std_sphere.L.10k_fsavg_L.surf.gii'
+#     >>> metres.inputs.new_sphere = 'fs_LR-deformed_to-fsaverage.L.sphere.32k_fs_LR.surf.gii'
+#     >>> metres.inputs.area_metrics = True
+#     >>> metres.inputs.current_area = 'fsaverage5.L.midthickness_va_avg.10k_fsavg_L.shape.gii'
+#     >>> metres.inputs.new_area = 'fs_LR.L.midthickness_va_avg.32k_fs_LR.shape.gii'
+#     >>> metres.cmdline
+#     'wb_command -metric-resample sub-01_task-rest_bold_space-fsaverage5.L.func.gii     fsaverage5_std_sphere.L.10k_fsavg_L.surf.gii     fs_LR-deformed_to-fsaverage.L.sphere.32k_fs_LR.surf.gii     ADAP_BARY_AREA fs_LR-deformed_to-fsaverage.L.sphere.32k_fs_LR.surf.out     -area-metrics fsaverage5.L.midthickness_va_avg.10k_fsavg_L.shape.gii     fs_LR.L.midthickness_va_avg.32k_fs_LR.shape.gii'
+#     
+task_name: MetricResample
+nipype_name: MetricResample
+nipype_module: nipype.interfaces.workbench.metric
+inputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    in_file: medimage/gifti
+    # type=file|default=<undefined>: The metric file to resample
+    current_sphere: medimage/gifti
+    # type=file|default=<undefined>: A sphere surface with the mesh that the metric is currently on
+    new_sphere: medimage/gifti
+    # type=file|default=<undefined>: A sphere surface that is in register with <current-sphere> and has the desired output mesh
+    out_file: generic/file
+    # type=file: the output metric
+    # type=file|default=<undefined>: The output metric
+    current_area: medimage/gifti
+    # type=file|default=<undefined>: A relevant anatomical surface with <current-sphere> mesh OR a metric file with vertex areas for <current-sphere> mesh
+    new_area: medimage/gifti
+    # type=file|default=<undefined>: A relevant anatomical surface with <current-sphere> mesh OR a metric file with vertex areas for <current-sphere> mesh
+    roi_metric: generic/file
+    # type=file|default=<undefined>: Input roi on the current mesh used to exclude non-data vertices
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: the output metric
+    # type=file|default=<undefined>: The output metric
+    roi_file: generic/file
+    # type=file: ROI of vertices that got data from valid source vertices
+  callables:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set to the `callable` attribute of output fields
+  templates:
+  # dict[str, str] - `output_file_template` values to be provided to output fields
+  requirements:
+  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
+tests:
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: The metric file to resample
+    current_sphere:
+    # type=file|default=<undefined>: A sphere surface with the mesh that the metric is currently on
+    new_sphere:
+    # type=file|default=<undefined>: A sphere surface that is in register with <current-sphere> and has the desired output mesh
+    method:
+    # type=enum|default='ADAP_BARY_AREA'|allowed['ADAP_BARY_AREA','BARYCENTRIC']: The method name - ADAP_BARY_AREA method is recommended for ordinary metric data, because it should use all data while downsampling, unlike BARYCENTRIC. If ADAP_BARY_AREA is used, exactly one of area_surfs or area_metrics must be specified
+    out_file:
+    # type=file: the output metric
+    # type=file|default=<undefined>: The output metric
+    area_surfs:
+    # type=bool|default=False: Specify surfaces to do vertex area correction based on
+    area_metrics:
+    # type=bool|default=False: Specify vertex area metrics to do area correction based on
+    current_area:
+    # type=file|default=<undefined>: A relevant anatomical surface with <current-sphere> mesh OR a metric file with vertex areas for <current-sphere> mesh
+    new_area:
+    # type=file|default=<undefined>: A relevant anatomical surface with <current-sphere> mesh OR a metric file with vertex areas for <current-sphere> mesh
+    roi_metric:
+    # type=file|default=<undefined>: Input roi on the current mesh used to exclude non-data vertices
+    valid_roi_out:
+    # type=bool|default=False: Output the ROI of vertices that got data from valid source vertices
+    largest:
+    # type=bool|default=False: Use only the value of the vertex with the largest weight
+    args:
+    # type=str|default='': Additional parameters to the command
+    environ:
+    # type=dict|default={}: Environment variables
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+- inputs:
+  # dict[str, str] - values to provide to inputs fields in the task initialisation
+  # (if not specified, will try to choose a sensible value)
+    in_file:
+    # type=file|default=<undefined>: The metric file to resample
+    method: '"ADAP_BARY_AREA"'
+    # type=enum|default='ADAP_BARY_AREA'|allowed['ADAP_BARY_AREA','BARYCENTRIC']: The method name - ADAP_BARY_AREA method is recommended for ordinary metric data, because it should use all data while downsampling, unlike BARYCENTRIC. If ADAP_BARY_AREA is used, exactly one of area_surfs or area_metrics must be specified
+    current_sphere:
+    # type=file|default=<undefined>: A sphere surface with the mesh that the metric is currently on
+    new_sphere:
+    # type=file|default=<undefined>: A sphere surface that is in register with <current-sphere> and has the desired output mesh
+    area_metrics: 'True'
+    # type=bool|default=False: Specify vertex area metrics to do area correction based on
+    current_area:
+    # type=file|default=<undefined>: A relevant anatomical surface with <current-sphere> mesh OR a metric file with vertex areas for <current-sphere> mesh
+    new_area:
+    # type=file|default=<undefined>: A relevant anatomical surface with <current-sphere> mesh OR a metric file with vertex areas for <current-sphere> mesh
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  expected_outputs:
+  # dict[str, str] - expected values for selected outputs, noting that tests will typically
+  # be terminated before they complete for time-saving reasons, and therefore
+  # these values will be ignored, when running in CI
+  timeout: 10
+  # int - the value to set for the timeout in the generated test, 
+  # after which the test will be considered to have been initialised 
+  # successfully. Set to 0 to disable the timeout (warning, this could
+  # lead to the unittests taking a very long time to complete)
+  xfail: true
+  # bool - whether the unittest is expected to fail or not. Set to false
+  # when you are satisfied with the edits you have made to this file
+doctests:
+- cmdline: wb_command -metric-resample sub-01_task-rest_bold_space-fsaverage5.L.func.gii fsaverage5_std_sphere.L.10k_fsavg_L.surf.gii fs_LR-deformed_to-fsaverage.L.sphere.32k_fs_LR.surf.gii ADAP_BARY_AREA fs_LR-deformed_to-fsaverage.L.sphere.32k_fs_LR.surf.out -area-metrics fsaverage5.L.midthickness_va_avg.10k_fsavg_L.shape.gii fs_LR.L.midthickness_va_avg.32k_fs_LR.shape.gii
+  # str - the expected cmdline output
+  inputs:
+  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
+  # If the field is of file-format type and the value is None, then the
+  # '.mock()' method of the corresponding class is used instead.
+    in_file:
+    # type=file|default=<undefined>: The metric file to resample
+    method: '"ADAP_BARY_AREA"'
+    # type=enum|default='ADAP_BARY_AREA'|allowed['ADAP_BARY_AREA','BARYCENTRIC']: The method name - ADAP_BARY_AREA method is recommended for ordinary metric data, because it should use all data while downsampling, unlike BARYCENTRIC. If ADAP_BARY_AREA is used, exactly one of area_surfs or area_metrics must be specified
+    current_sphere:
+    # type=file|default=<undefined>: A sphere surface with the mesh that the metric is currently on
+    new_sphere:
+    # type=file|default=<undefined>: A sphere surface that is in register with <current-sphere> and has the desired output mesh
+    area_metrics: 'True'
+    # type=bool|default=False: Specify vertex area metrics to do area correction based on
+    current_area:
+    # type=file|default=<undefined>: A relevant anatomical surface with <current-sphere> mesh OR a metric file with vertex areas for <current-sphere> mesh
+    new_area:
+    # type=file|default=<undefined>: A relevant anatomical surface with <current-sphere> mesh OR a metric file with vertex areas for <current-sphere> mesh
+  imports:
+  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
+  # consisting of 'module', 'name', and optionally 'alias' keys
+  directive:
+  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-workbench/metric_resample_callables.py b/example-specs/task/nipype_internal/pydra-workbench/metric_resample_callables.py
new file mode 100644
index 00000000..10b1a9fb
--- /dev/null
+++ b/example-specs/task/nipype_internal/pydra-workbench/metric_resample_callables.py
@@ -0,0 +1 @@
+"""Module to put any functions that are referred to in MetricResample.yaml"""
diff --git a/nipype2pydra/task/__init__.py b/nipype2pydra/task/__init__.py
index c486f6d3..dc72a2cb 100644
--- a/nipype2pydra/task/__init__.py
+++ b/nipype2pydra/task/__init__.py
@@ -1,6 +1,12 @@
 from .function import FunctionTaskConverter
 from .shell_command import ShellCommandTaskConverter
 from importlib import import_module
+from .base import (
+    InputsConverter,
+    OutputsConverter,
+    TestGenerator,
+    DocTestGenerator,
+)
 
 
 def get_converter(nipype_module: str, nipype_name: str, **kwargs):
@@ -12,8 +18,15 @@ def get_converter(nipype_module: str, nipype_name: str, **kwargs):
     else:
         from .function import FunctionTaskConverter as Converter
 
-    return Converter(
-        nipype_module=nipype_module, nipype_name=nipype_name, **kwargs
-    )
+    return Converter(nipype_module=nipype_module, nipype_name=nipype_name, **kwargs)
 
-__all__ = ["FunctionTaskConverter", "ShellCommandTaskConverter", "get_converter"]
+
+__all__ = [
+    "FunctionTaskConverter",
+    "ShellCommandTaskConverter",
+    "InputsConverter",
+    "OutputsConverter",
+    "TestGenerator",
+    "DocTestGenerator",
+    "get_converter",
+]

From bde7ddcd6522e41bc80664d387bf763e4e88340e Mon Sep 17 00:00:00 2001
From: Tom Close <tom.g.close@gmail.com>
Date: Mon, 26 Feb 2024 15:12:31 +1100
Subject: [PATCH 43/78] copied in required fileformat packages until they are
 available on PyPI

---
 conftest.py                                   |  2 +-
 nipype2pydra/utils.py                         | 22 +++++
 pyproject.toml                                | 33 +++++++
 required-fileformats/afni/LICENSE             | 13 +++
 required-fileformats/afni/README.rst          | 39 +++++++++
 .../fileformats/medimage_afni/__init__.py     | 50 +++++++++++
 .../fileformats/medimage_afni/_version.py     | 16 ++++
 required-fileformats/afni/pyproject.toml      | 84 ++++++++++++++++++
 required-fileformats/ants/LICENSE             | 13 +++
 required-fileformats/ants/README.rst          | 39 +++++++++
 .../fileformats/medimage_ants/__init__.py     |  1 +
 .../fileformats/medimage_ants/_version.py     | 16 ++++
 required-fileformats/ants/pyproject.toml      | 84 ++++++++++++++++++
 required-fileformats/brainsuite/LICENSE       | 13 +++
 required-fileformats/brainsuite/README.rst    | 39 +++++++++
 .../medimage_brainsuite/__init__.py           |  1 +
 .../medimage_brainsuite/_version.py           | 16 ++++
 .../brainsuite/pyproject.toml                 | 84 ++++++++++++++++++
 required-fileformats/bru2nii/LICENSE          | 13 +++
 required-fileformats/bru2nii/README.rst       | 39 +++++++++
 .../fileformats/medimage_bru2nii/__init__.py  |  1 +
 .../fileformats/medimage_bru2nii/_version.py  | 16 ++++
 required-fileformats/bru2nii/pyproject.toml   | 84 ++++++++++++++++++
 required-fileformats/c3/LICENSE               | 13 +++
 required-fileformats/c3/README.rst            | 39 +++++++++
 .../c3/fileformats/medimage_c3/__init__.py    |  1 +
 .../c3/fileformats/medimage_c3/_version.py    | 16 ++++
 required-fileformats/c3/pyproject.toml        | 84 ++++++++++++++++++
 required-fileformats/camino/LICENSE           | 13 +++
 required-fileformats/camino/README.rst        | 39 +++++++++
 .../fileformats/medimage_camino/__init__.py   |  1 +
 .../fileformats/medimage_camino/_version.py   | 16 ++++
 required-fileformats/camino/pyproject.toml    | 84 ++++++++++++++++++
 required-fileformats/camino2trackvis/LICENSE  | 13 +++
 .../camino2trackvis/README.rst                | 39 +++++++++
 .../medimage_camino2trackvis/__init__.py      |  1 +
 .../medimage_camino2trackvis/_version.py      | 16 ++++
 .../camino2trackvis/pyproject.toml            | 84 ++++++++++++++++++
 required-fileformats/cat12/LICENSE            | 13 +++
 required-fileformats/cat12/README.rst         | 39 +++++++++
 .../fileformats/medimage_cat12/__init__.py    |  1 +
 .../fileformats/medimage_cat12/_version.py    | 16 ++++
 required-fileformats/cat12/pyproject.toml     | 84 ++++++++++++++++++
 required-fileformats/cmtk/LICENSE             | 13 +++
 required-fileformats/cmtk/README.rst          | 39 +++++++++
 .../fileformats/medimage_cmtk/__init__.py     |  1 +
 .../fileformats/medimage_cmtk/_version.py     | 16 ++++
 required-fileformats/cmtk/pyproject.toml      | 84 ++++++++++++++++++
 required-fileformats/dcmstack/LICENSE         | 13 +++
 required-fileformats/dcmstack/README.rst      | 39 +++++++++
 .../fileformats/medimage_dcmstack/__init__.py |  1 +
 .../fileformats/medimage_dcmstack/_version.py | 16 ++++
 required-fileformats/dcmstack/pyproject.toml  | 84 ++++++++++++++++++
 .../diffusion_toolkit/LICENSE                 | 13 +++
 .../diffusion_toolkit/README.rst              | 39 +++++++++
 .../medimage_diffusion_toolkit/__init__.py    |  1 +
 .../medimage_diffusion_toolkit/_version.py    | 16 ++++
 .../diffusion_toolkit/pyproject.toml          | 84 ++++++++++++++++++
 required-fileformats/dipy/LICENSE             | 13 +++
 required-fileformats/dipy/README.rst          | 39 +++++++++
 .../fileformats/medimage_dipy/__init__.py     |  1 +
 .../fileformats/medimage_dipy/_version.py     | 16 ++++
 required-fileformats/dipy/pyproject.toml      | 84 ++++++++++++++++++
 required-fileformats/dtitk/LICENSE            | 13 +++
 required-fileformats/dtitk/README.rst         | 39 +++++++++
 .../fileformats/medimage_dtitk/__init__.py    |  5 ++
 .../fileformats/medimage_dtitk/_version.py    | 16 ++++
 required-fileformats/dtitk/pyproject.toml     | 84 ++++++++++++++++++
 required-fileformats/dynamic_slicer/LICENSE   | 13 +++
 .../dynamic_slicer/README.rst                 | 39 +++++++++
 .../medimage_dynamic_slicer/__init__.py       |  1 +
 .../medimage_dynamic_slicer/_version.py       | 16 ++++
 .../dynamic_slicer/pyproject.toml             | 84 ++++++++++++++++++
 required-fileformats/elastix/LICENSE          | 13 +++
 required-fileformats/elastix/README.rst       | 39 +++++++++
 .../fileformats/medimage_elastix/__init__.py  |  5 ++
 .../fileformats/medimage_elastix/_version.py  | 16 ++++
 required-fileformats/elastix/pyproject.toml   | 84 ++++++++++++++++++
 required-fileformats/freesurfer/LICENSE       | 13 +++
 required-fileformats/freesurfer/README.rst    | 39 +++++++++
 .../medimage_freesurfer/__init__.py           | 85 +++++++++++++++++++
 .../medimage_freesurfer/_version.py           | 16 ++++
 .../freesurfer/pyproject.toml                 | 84 ++++++++++++++++++
 required-fileformats/fsl/LICENSE              | 13 +++
 required-fileformats/fsl/README.rst           | 39 +++++++++
 .../fsl/fileformats/medimage_fsl/__init__.py  |  5 ++
 .../fsl/fileformats/medimage_fsl/_version.py  | 16 ++++
 required-fileformats/fsl/pyproject.toml       | 84 ++++++++++++++++++
 required-fileformats/meshfix/LICENSE          | 13 +++
 required-fileformats/meshfix/README.rst       | 39 +++++++++
 .../fileformats/medimage_meshfix/__init__.py  |  1 +
 .../fileformats/medimage_meshfix/_version.py  | 16 ++++
 required-fileformats/meshfix/pyproject.toml   | 84 ++++++++++++++++++
 required-fileformats/minc/LICENSE             | 13 +++
 required-fileformats/minc/README.rst          | 39 +++++++++
 .../fileformats/medimage_minc/__init__.py     |  1 +
 .../fileformats/medimage_minc/_version.py     | 16 ++++
 required-fileformats/minc/pyproject.toml      | 84 ++++++++++++++++++
 required-fileformats/mipav/LICENSE            | 13 +++
 required-fileformats/mipav/README.rst         | 39 +++++++++
 .../fileformats/medimage_mipav/__init__.py    |  1 +
 .../fileformats/medimage_mipav/_version.py    | 16 ++++
 required-fileformats/mipav/pyproject.toml     | 84 ++++++++++++++++++
 required-fileformats/niftyfit/LICENSE         | 13 +++
 required-fileformats/niftyfit/README.rst      | 39 +++++++++
 .../fileformats/medimage_niftyfit/__init__.py |  1 +
 .../fileformats/medimage_niftyfit/_version.py | 16 ++++
 required-fileformats/niftyfit/pyproject.toml  | 84 ++++++++++++++++++
 required-fileformats/niftyreg/LICENSE         | 13 +++
 required-fileformats/niftyreg/README.rst      | 39 +++++++++
 .../fileformats/medimage_niftyreg/__init__.py |  1 +
 .../fileformats/medimage_niftyreg/_version.py | 16 ++++
 required-fileformats/niftyreg/pyproject.toml  | 84 ++++++++++++++++++
 required-fileformats/niftyseg/LICENSE         | 13 +++
 required-fileformats/niftyseg/README.rst      | 39 +++++++++
 .../fileformats/medimage_niftyseg/__init__.py |  1 +
 .../fileformats/medimage_niftyseg/_version.py | 16 ++++
 required-fileformats/niftyseg/pyproject.toml  | 84 ++++++++++++++++++
 required-fileformats/nilearn/LICENSE          | 13 +++
 required-fileformats/nilearn/README.rst       | 39 +++++++++
 .../fileformats/medimage_nilearn/__init__.py  |  1 +
 .../fileformats/medimage_nilearn/_version.py  | 16 ++++
 required-fileformats/nilearn/pyproject.toml   | 84 ++++++++++++++++++
 required-fileformats/nitime/LICENSE           | 13 +++
 required-fileformats/nitime/README.rst        | 39 +++++++++
 .../fileformats/medimage_nitime/__init__.py   |  1 +
 .../fileformats/medimage_nitime/_version.py   | 16 ++++
 required-fileformats/nitime/pyproject.toml    | 84 ++++++++++++++++++
 required-fileformats/petpvc/LICENSE           | 13 +++
 required-fileformats/petpvc/README.rst        | 39 +++++++++
 .../fileformats/medimage_petpvc/__init__.py   |  1 +
 .../fileformats/medimage_petpvc/_version.py   | 16 ++++
 required-fileformats/petpvc/pyproject.toml    | 84 ++++++++++++++++++
 required-fileformats/quickshear/LICENSE       | 13 +++
 required-fileformats/quickshear/README.rst    | 39 +++++++++
 .../medimage_quickshear/__init__.py           |  1 +
 .../medimage_quickshear/_version.py           | 16 ++++
 .../quickshear/pyproject.toml                 | 84 ++++++++++++++++++
 required-fileformats/requirements.txt         | 33 +++++++
 required-fileformats/robex/LICENSE            | 13 +++
 required-fileformats/robex/README.rst         | 39 +++++++++
 .../fileformats/medimage_robex/__init__.py    |  1 +
 .../fileformats/medimage_robex/_version.py    | 16 ++++
 required-fileformats/robex/pyproject.toml     | 84 ++++++++++++++++++
 required-fileformats/semtools/LICENSE         | 13 +++
 required-fileformats/semtools/README.rst      | 39 +++++++++
 .../fileformats/medimage_semtools/__init__.py |  1 +
 .../fileformats/medimage_semtools/_version.py | 16 ++++
 required-fileformats/semtools/pyproject.toml  | 84 ++++++++++++++++++
 required-fileformats/slicer/LICENSE           | 13 +++
 required-fileformats/slicer/README.rst        | 39 +++++++++
 .../fileformats/medimage_slicer/__init__.py   |  1 +
 .../fileformats/medimage_slicer/_version.py   | 16 ++++
 required-fileformats/slicer/pyproject.toml    | 84 ++++++++++++++++++
 required-fileformats/spm/LICENSE              | 13 +++
 required-fileformats/spm/README.rst           | 39 +++++++++
 .../spm/fileformats/medimage_spm/__init__.py  |  1 +
 .../spm/fileformats/medimage_spm/_version.py  | 16 ++++
 required-fileformats/spm/pyproject.toml       | 84 ++++++++++++++++++
 required-fileformats/vista/LICENSE            | 13 +++
 required-fileformats/vista/README.rst         | 39 +++++++++
 .../fileformats/medimage_vista/__init__.py    |  5 ++
 .../fileformats/medimage_vista/_version.py    | 16 ++++
 required-fileformats/vista/pyproject.toml     | 84 ++++++++++++++++++
 required-fileformats/workbench/LICENSE        | 13 +++
 required-fileformats/workbench/README.rst     | 39 +++++++++
 .../medimage_workbench/__init__.py            |  1 +
 .../medimage_workbench/_version.py            | 16 ++++
 required-fileformats/workbench/pyproject.toml | 84 ++++++++++++++++++
 tests/test_task.py                            | 19 +++--
 170 files changed, 5298 insertions(+), 9 deletions(-)
 create mode 100644 required-fileformats/afni/LICENSE
 create mode 100644 required-fileformats/afni/README.rst
 create mode 100644 required-fileformats/afni/fileformats/medimage_afni/__init__.py
 create mode 100644 required-fileformats/afni/fileformats/medimage_afni/_version.py
 create mode 100644 required-fileformats/afni/pyproject.toml
 create mode 100644 required-fileformats/ants/LICENSE
 create mode 100644 required-fileformats/ants/README.rst
 create mode 100644 required-fileformats/ants/fileformats/medimage_ants/__init__.py
 create mode 100644 required-fileformats/ants/fileformats/medimage_ants/_version.py
 create mode 100644 required-fileformats/ants/pyproject.toml
 create mode 100644 required-fileformats/brainsuite/LICENSE
 create mode 100644 required-fileformats/brainsuite/README.rst
 create mode 100644 required-fileformats/brainsuite/fileformats/medimage_brainsuite/__init__.py
 create mode 100644 required-fileformats/brainsuite/fileformats/medimage_brainsuite/_version.py
 create mode 100644 required-fileformats/brainsuite/pyproject.toml
 create mode 100644 required-fileformats/bru2nii/LICENSE
 create mode 100644 required-fileformats/bru2nii/README.rst
 create mode 100644 required-fileformats/bru2nii/fileformats/medimage_bru2nii/__init__.py
 create mode 100644 required-fileformats/bru2nii/fileformats/medimage_bru2nii/_version.py
 create mode 100644 required-fileformats/bru2nii/pyproject.toml
 create mode 100644 required-fileformats/c3/LICENSE
 create mode 100644 required-fileformats/c3/README.rst
 create mode 100644 required-fileformats/c3/fileformats/medimage_c3/__init__.py
 create mode 100644 required-fileformats/c3/fileformats/medimage_c3/_version.py
 create mode 100644 required-fileformats/c3/pyproject.toml
 create mode 100644 required-fileformats/camino/LICENSE
 create mode 100644 required-fileformats/camino/README.rst
 create mode 100644 required-fileformats/camino/fileformats/medimage_camino/__init__.py
 create mode 100644 required-fileformats/camino/fileformats/medimage_camino/_version.py
 create mode 100644 required-fileformats/camino/pyproject.toml
 create mode 100644 required-fileformats/camino2trackvis/LICENSE
 create mode 100644 required-fileformats/camino2trackvis/README.rst
 create mode 100644 required-fileformats/camino2trackvis/fileformats/medimage_camino2trackvis/__init__.py
 create mode 100644 required-fileformats/camino2trackvis/fileformats/medimage_camino2trackvis/_version.py
 create mode 100644 required-fileformats/camino2trackvis/pyproject.toml
 create mode 100644 required-fileformats/cat12/LICENSE
 create mode 100644 required-fileformats/cat12/README.rst
 create mode 100644 required-fileformats/cat12/fileformats/medimage_cat12/__init__.py
 create mode 100644 required-fileformats/cat12/fileformats/medimage_cat12/_version.py
 create mode 100644 required-fileformats/cat12/pyproject.toml
 create mode 100644 required-fileformats/cmtk/LICENSE
 create mode 100644 required-fileformats/cmtk/README.rst
 create mode 100644 required-fileformats/cmtk/fileformats/medimage_cmtk/__init__.py
 create mode 100644 required-fileformats/cmtk/fileformats/medimage_cmtk/_version.py
 create mode 100644 required-fileformats/cmtk/pyproject.toml
 create mode 100644 required-fileformats/dcmstack/LICENSE
 create mode 100644 required-fileformats/dcmstack/README.rst
 create mode 100644 required-fileformats/dcmstack/fileformats/medimage_dcmstack/__init__.py
 create mode 100644 required-fileformats/dcmstack/fileformats/medimage_dcmstack/_version.py
 create mode 100644 required-fileformats/dcmstack/pyproject.toml
 create mode 100644 required-fileformats/diffusion_toolkit/LICENSE
 create mode 100644 required-fileformats/diffusion_toolkit/README.rst
 create mode 100644 required-fileformats/diffusion_toolkit/fileformats/medimage_diffusion_toolkit/__init__.py
 create mode 100644 required-fileformats/diffusion_toolkit/fileformats/medimage_diffusion_toolkit/_version.py
 create mode 100644 required-fileformats/diffusion_toolkit/pyproject.toml
 create mode 100644 required-fileformats/dipy/LICENSE
 create mode 100644 required-fileformats/dipy/README.rst
 create mode 100644 required-fileformats/dipy/fileformats/medimage_dipy/__init__.py
 create mode 100644 required-fileformats/dipy/fileformats/medimage_dipy/_version.py
 create mode 100644 required-fileformats/dipy/pyproject.toml
 create mode 100644 required-fileformats/dtitk/LICENSE
 create mode 100644 required-fileformats/dtitk/README.rst
 create mode 100644 required-fileformats/dtitk/fileformats/medimage_dtitk/__init__.py
 create mode 100644 required-fileformats/dtitk/fileformats/medimage_dtitk/_version.py
 create mode 100644 required-fileformats/dtitk/pyproject.toml
 create mode 100644 required-fileformats/dynamic_slicer/LICENSE
 create mode 100644 required-fileformats/dynamic_slicer/README.rst
 create mode 100644 required-fileformats/dynamic_slicer/fileformats/medimage_dynamic_slicer/__init__.py
 create mode 100644 required-fileformats/dynamic_slicer/fileformats/medimage_dynamic_slicer/_version.py
 create mode 100644 required-fileformats/dynamic_slicer/pyproject.toml
 create mode 100644 required-fileformats/elastix/LICENSE
 create mode 100644 required-fileformats/elastix/README.rst
 create mode 100644 required-fileformats/elastix/fileformats/medimage_elastix/__init__.py
 create mode 100644 required-fileformats/elastix/fileformats/medimage_elastix/_version.py
 create mode 100644 required-fileformats/elastix/pyproject.toml
 create mode 100644 required-fileformats/freesurfer/LICENSE
 create mode 100644 required-fileformats/freesurfer/README.rst
 create mode 100644 required-fileformats/freesurfer/fileformats/medimage_freesurfer/__init__.py
 create mode 100644 required-fileformats/freesurfer/fileformats/medimage_freesurfer/_version.py
 create mode 100644 required-fileformats/freesurfer/pyproject.toml
 create mode 100644 required-fileformats/fsl/LICENSE
 create mode 100644 required-fileformats/fsl/README.rst
 create mode 100644 required-fileformats/fsl/fileformats/medimage_fsl/__init__.py
 create mode 100644 required-fileformats/fsl/fileformats/medimage_fsl/_version.py
 create mode 100644 required-fileformats/fsl/pyproject.toml
 create mode 100644 required-fileformats/meshfix/LICENSE
 create mode 100644 required-fileformats/meshfix/README.rst
 create mode 100644 required-fileformats/meshfix/fileformats/medimage_meshfix/__init__.py
 create mode 100644 required-fileformats/meshfix/fileformats/medimage_meshfix/_version.py
 create mode 100644 required-fileformats/meshfix/pyproject.toml
 create mode 100644 required-fileformats/minc/LICENSE
 create mode 100644 required-fileformats/minc/README.rst
 create mode 100644 required-fileformats/minc/fileformats/medimage_minc/__init__.py
 create mode 100644 required-fileformats/minc/fileformats/medimage_minc/_version.py
 create mode 100644 required-fileformats/minc/pyproject.toml
 create mode 100644 required-fileformats/mipav/LICENSE
 create mode 100644 required-fileformats/mipav/README.rst
 create mode 100644 required-fileformats/mipav/fileformats/medimage_mipav/__init__.py
 create mode 100644 required-fileformats/mipav/fileformats/medimage_mipav/_version.py
 create mode 100644 required-fileformats/mipav/pyproject.toml
 create mode 100644 required-fileformats/niftyfit/LICENSE
 create mode 100644 required-fileformats/niftyfit/README.rst
 create mode 100644 required-fileformats/niftyfit/fileformats/medimage_niftyfit/__init__.py
 create mode 100644 required-fileformats/niftyfit/fileformats/medimage_niftyfit/_version.py
 create mode 100644 required-fileformats/niftyfit/pyproject.toml
 create mode 100644 required-fileformats/niftyreg/LICENSE
 create mode 100644 required-fileformats/niftyreg/README.rst
 create mode 100644 required-fileformats/niftyreg/fileformats/medimage_niftyreg/__init__.py
 create mode 100644 required-fileformats/niftyreg/fileformats/medimage_niftyreg/_version.py
 create mode 100644 required-fileformats/niftyreg/pyproject.toml
 create mode 100644 required-fileformats/niftyseg/LICENSE
 create mode 100644 required-fileformats/niftyseg/README.rst
 create mode 100644 required-fileformats/niftyseg/fileformats/medimage_niftyseg/__init__.py
 create mode 100644 required-fileformats/niftyseg/fileformats/medimage_niftyseg/_version.py
 create mode 100644 required-fileformats/niftyseg/pyproject.toml
 create mode 100644 required-fileformats/nilearn/LICENSE
 create mode 100644 required-fileformats/nilearn/README.rst
 create mode 100644 required-fileformats/nilearn/fileformats/medimage_nilearn/__init__.py
 create mode 100644 required-fileformats/nilearn/fileformats/medimage_nilearn/_version.py
 create mode 100644 required-fileformats/nilearn/pyproject.toml
 create mode 100644 required-fileformats/nitime/LICENSE
 create mode 100644 required-fileformats/nitime/README.rst
 create mode 100644 required-fileformats/nitime/fileformats/medimage_nitime/__init__.py
 create mode 100644 required-fileformats/nitime/fileformats/medimage_nitime/_version.py
 create mode 100644 required-fileformats/nitime/pyproject.toml
 create mode 100644 required-fileformats/petpvc/LICENSE
 create mode 100644 required-fileformats/petpvc/README.rst
 create mode 100644 required-fileformats/petpvc/fileformats/medimage_petpvc/__init__.py
 create mode 100644 required-fileformats/petpvc/fileformats/medimage_petpvc/_version.py
 create mode 100644 required-fileformats/petpvc/pyproject.toml
 create mode 100644 required-fileformats/quickshear/LICENSE
 create mode 100644 required-fileformats/quickshear/README.rst
 create mode 100644 required-fileformats/quickshear/fileformats/medimage_quickshear/__init__.py
 create mode 100644 required-fileformats/quickshear/fileformats/medimage_quickshear/_version.py
 create mode 100644 required-fileformats/quickshear/pyproject.toml
 create mode 100644 required-fileformats/requirements.txt
 create mode 100644 required-fileformats/robex/LICENSE
 create mode 100644 required-fileformats/robex/README.rst
 create mode 100644 required-fileformats/robex/fileformats/medimage_robex/__init__.py
 create mode 100644 required-fileformats/robex/fileformats/medimage_robex/_version.py
 create mode 100644 required-fileformats/robex/pyproject.toml
 create mode 100644 required-fileformats/semtools/LICENSE
 create mode 100644 required-fileformats/semtools/README.rst
 create mode 100644 required-fileformats/semtools/fileformats/medimage_semtools/__init__.py
 create mode 100644 required-fileformats/semtools/fileformats/medimage_semtools/_version.py
 create mode 100644 required-fileformats/semtools/pyproject.toml
 create mode 100644 required-fileformats/slicer/LICENSE
 create mode 100644 required-fileformats/slicer/README.rst
 create mode 100644 required-fileformats/slicer/fileformats/medimage_slicer/__init__.py
 create mode 100644 required-fileformats/slicer/fileformats/medimage_slicer/_version.py
 create mode 100644 required-fileformats/slicer/pyproject.toml
 create mode 100644 required-fileformats/spm/LICENSE
 create mode 100644 required-fileformats/spm/README.rst
 create mode 100644 required-fileformats/spm/fileformats/medimage_spm/__init__.py
 create mode 100644 required-fileformats/spm/fileformats/medimage_spm/_version.py
 create mode 100644 required-fileformats/spm/pyproject.toml
 create mode 100644 required-fileformats/vista/LICENSE
 create mode 100644 required-fileformats/vista/README.rst
 create mode 100644 required-fileformats/vista/fileformats/medimage_vista/__init__.py
 create mode 100644 required-fileformats/vista/fileformats/medimage_vista/_version.py
 create mode 100644 required-fileformats/vista/pyproject.toml
 create mode 100644 required-fileformats/workbench/LICENSE
 create mode 100644 required-fileformats/workbench/README.rst
 create mode 100644 required-fileformats/workbench/fileformats/medimage_workbench/__init__.py
 create mode 100644 required-fileformats/workbench/fileformats/medimage_workbench/_version.py
 create mode 100644 required-fileformats/workbench/pyproject.toml

diff --git a/conftest.py b/conftest.py
index 0e1fb2e5..bf742568 100644
--- a/conftest.py
+++ b/conftest.py
@@ -20,7 +20,7 @@ def gen_test_conftest():
 @pytest.fixture(
     params=[
         str(p.relative_to(EXAMPLE_TASKS_DIR)).replace("/", "__")[:-5]
-        for p in (EXAMPLE_TASKS_DIR).glob("**/*.yaml")
+        for p in (EXAMPLE_TASKS_DIR).glob("nipype_internal/pydra-afni/**/*.yaml")
     ]
 )
 def task_spec_file(request):
diff --git a/nipype2pydra/utils.py b/nipype2pydra/utils.py
index afc46d49..4f957a8e 100644
--- a/nipype2pydra/utils.py
+++ b/nipype2pydra/utils.py
@@ -106,3 +106,25 @@ def to_snake_case(name: str) -> str:
             snake_str += char.lower()
 
     return snake_str
+
+
+def add_exc_note(e, note):
+    """Adds a note to an exception in a Python <3.11 compatible way
+
+    Parameters
+    ----------
+    e : Exception
+        the exception to add the note to
+    note : str
+        the note to add
+
+    Returns
+    -------
+    Exception
+        returns the exception again
+    """
+    if hasattr(e, "add_note"):
+        e.add_note(note)
+    else:
+        e.args = (e.args[0] + "\n" + note,)
+    return e
\ No newline at end of file
diff --git a/pyproject.toml b/pyproject.toml
index 0c08157e..e7aa1fe6 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -60,6 +60,39 @@ test = [
     "pytest-env>=0.6.2",
     "pytest-cov>=2.12.1",
     "fileformats-medimage-extras",
+    "fileformats-medimage-afni",
+    "fileformats-medimage-ants",
+    "fileformats-medimage-brainsuite",
+    "fileformats-medimage-bru2nii",
+    "fileformats-medimage-c3",
+    "fileformats-medimage-camino",
+    "fileformats-medimage-camino2trackvis",
+    "fileformats-medimage-cat12",
+    "fileformats-medimage-cmtk",
+    "fileformats-medimage-dcmstack",
+    "fileformats-medimage-diffusion_toolkit",
+    "fileformats-medimage-dipy",
+    "fileformats-medimage-dtitk",
+    "fileformats-medimage-dynamic_slicer",
+    "fileformats-medimage-elastix",
+    "fileformats-medimage-freesurfer",
+    "fileformats-medimage-fsl",
+    "fileformats-medimage-meshfix",
+    "fileformats-medimage-minc",
+    "fileformats-medimage-mipav",
+    "fileformats-medimage-niftyfit",
+    "fileformats-medimage-niftyreg",
+    "fileformats-medimage-niftyseg",
+    "fileformats-medimage-nilearn",
+    "fileformats-medimage-nitime",
+    "fileformats-medimage-petpvc",
+    "fileformats-medimage-quickshear",
+    "fileformats-medimage-robex",
+    "fileformats-medimage-semtools",
+    "fileformats-medimage-slicer",
+    "fileformats-medimage-spm",
+    "fileformats-medimage-vista",
+    "fileformats-medimage-workbench",
     "qsiprep",
 ]
 docs = [
diff --git a/required-fileformats/afni/LICENSE b/required-fileformats/afni/LICENSE
new file mode 100644
index 00000000..e00bcb30
--- /dev/null
+++ b/required-fileformats/afni/LICENSE
@@ -0,0 +1,13 @@
+   Copyright 2021 Nipype developers
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/required-fileformats/afni/README.rst b/required-fileformats/afni/README.rst
new file mode 100644
index 00000000..f8bf8e13
--- /dev/null
+++ b/required-fileformats/afni/README.rst
@@ -0,0 +1,39 @@
+How to customise this template
+==============================
+
+#. Rename the `related-packages/fileformats/afni` directory to the name of the fileformats subpackage (e.g. `medimage_fsl`)
+#. Search and replace "afni" with the name of the fileformats subpackage the extras are to be added
+#. Replace name + email placeholders in `pyproject.toml` for developers and maintainers
+#. Add the extension file-format classes
+#. Ensure that all the extension file-format classes are imported into the extras package root, i.e. `fileformats/afni`
+#. Delete these instructions
+
+...
+
+FileFormats Extension - afni
+====================================
+.. image:: https://github.com/nipype/pydra-afni/actions/workflows/ci-cd.yml/badge.svg
+    :target: https://github.com/nipype/pydra-afni/actions/workflows/ci-cd.yml
+
+This is the "afni" extension module for the
+`fileformats <https://github.com/ArcanaFramework/fileformats-core>`__ package
+
+
+Quick Installation
+------------------
+
+This extension can be installed for Python 3 using *pip*::
+
+    $ pip3 install fileformats-afni
+
+This will install the core package and any other dependencies
+
+License
+-------
+
+This work is licensed under a
+`Creative Commons Attribution 4.0 International License <http://creativecommons.org/licenses/by/4.0/>`_
+
+.. image:: https://i.creativecommons.org/l/by/4.0/88x31.png
+  :target: http://creativecommons.org/licenses/by/4.0/
+  :alt: Creative Commons Attribution 4.0 International License
diff --git a/required-fileformats/afni/fileformats/medimage_afni/__init__.py b/required-fileformats/afni/fileformats/medimage_afni/__init__.py
new file mode 100644
index 00000000..92a2733f
--- /dev/null
+++ b/required-fileformats/afni/fileformats/medimage_afni/__init__.py
@@ -0,0 +1,50 @@
+from fileformats.generic import File
+
+class Oned(File):
+    ext = ".1D"
+    binary = True
+
+
+class Oned(File):
+    ext = ".1d"
+    binary = True
+
+
+class Threed(File):
+    ext = ".3D"
+    binary = True
+
+
+class Ncorr(File):
+    ext = ".ncorr"
+    binary = True
+
+
+class R1(File):
+    ext = ".r1"
+    binary = True
+
+
+class All1(File):
+    ext = ".all1"
+    binary = True
+
+
+class Dset(File):
+    ext = ".dset"
+    binary = True
+
+
+class Head(File):
+    ext = ".HEAD"
+    binary = True
+
+
+class Nii[0](File):
+    ext = ".nii[0]"
+    binary = True
+
+
+class Unit errts+tlrc(File):
+    ext = ".unit errts+tlrc"
+    binary = True
diff --git a/required-fileformats/afni/fileformats/medimage_afni/_version.py b/required-fileformats/afni/fileformats/medimage_afni/_version.py
new file mode 100644
index 00000000..ecda9af7
--- /dev/null
+++ b/required-fileformats/afni/fileformats/medimage_afni/_version.py
@@ -0,0 +1,16 @@
+# file generated by setuptools_scm
+# don't change, don't track in version control
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple, Union
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '0.2.3.dev42+gb9e3ee9.d20240226'
+__version_tuple__ = version_tuple = (0, 2, 3, 'dev42', 'gb9e3ee9.d20240226')
diff --git a/required-fileformats/afni/pyproject.toml b/required-fileformats/afni/pyproject.toml
new file mode 100644
index 00000000..7030aee2
--- /dev/null
+++ b/required-fileformats/afni/pyproject.toml
@@ -0,0 +1,84 @@
+[build-system]
+requires = ["hatchling", "hatch-vcs"]
+build-backend = "hatchling.build"
+
+[project]
+name = "fileformats-medimage-afni"
+description = "Classes for representing different file formats in Python classes for use in type hinting in data workflows"
+readme = "README.rst"
+requires-python = ">=3.8"
+dependencies = [
+    "fileformats",
+    "fileformats-medimage"
+]
+license = {file = "LICENSE"}
+authors = [
+    {name = "Thomas G. Close", email = "tom.g.close@gmail.com"},
+]
+maintainers = [
+    {name = "Thomas G. Close", email = "tom.g.close@gmail.com"},
+]
+keywords = [
+    "file formats",
+    "data",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: Apache Software License",
+    "Operating System :: MacOS :: MacOS X",
+    "Operating System :: Microsoft :: Windows",
+    "Operating System :: POSIX :: Linux",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Topic :: Scientific/Engineering",
+]
+dynamic = ["version"]
+
+[project.optional-dependencies]
+dev = [
+    "black",
+    "pre-commit",
+    "codespell",
+    "flake8",
+    "flake8-pyproject",
+]
+test = [
+    "pytest >=6.2.5",
+    "pytest-env>=0.6.2",
+    "pytest-cov>=2.12.1",
+    "codecov",
+    "fileformats-medimage-CHANGME-extras",
+]
+
+[project.urls]
+repository = "https://github.com/nipype/pydra-afni"
+
+[tool.hatch.version]
+source = "vcs"
+raw-options = { root = "../.." }
+
+[tool.hatch.build.hooks.vcs]
+version-file = "fileformats/medimage_afni/_version.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["fileformats"]
+
+[tool.black]
+target-version = ['py38']
+exclude = "fileformats/medimage_afni/_version.py"
+
+[tool.codespell]
+ignore-words = ".codespell-ignorewords"
+
+[tool.flake8]
+doctests = true
+per-file-ignores = [
+    "__init__.py:F401"
+]
+max-line-length = 88
+select = "C,E,F,W,B,B950"
+extend-ignore = ['E203', 'E501', 'E129']
diff --git a/required-fileformats/ants/LICENSE b/required-fileformats/ants/LICENSE
new file mode 100644
index 00000000..e00bcb30
--- /dev/null
+++ b/required-fileformats/ants/LICENSE
@@ -0,0 +1,13 @@
+   Copyright 2021 Nipype developers
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/required-fileformats/ants/README.rst b/required-fileformats/ants/README.rst
new file mode 100644
index 00000000..4d945319
--- /dev/null
+++ b/required-fileformats/ants/README.rst
@@ -0,0 +1,39 @@
+How to customise this template
+==============================
+
+#. Rename the `related-packages/fileformats/ants` directory to the name of the fileformats subpackage (e.g. `medimage_fsl`)
+#. Search and replace "ants" with the name of the fileformats subpackage the extras are to be added
+#. Replace name + email placeholders in `pyproject.toml` for developers and maintainers
+#. Add the extension file-format classes
+#. Ensure that all the extension file-format classes are imported into the extras package root, i.e. `fileformats/ants`
+#. Delete these instructions
+
+...
+
+FileFormats Extension - ants
+====================================
+.. image:: https://github.com/nipype/pydra-ants/actions/workflows/ci-cd.yml/badge.svg
+    :target: https://github.com/nipype/pydra-ants/actions/workflows/ci-cd.yml
+
+This is the "ants" extension module for the
+`fileformats <https://github.com/ArcanaFramework/fileformats-core>`__ package
+
+
+Quick Installation
+------------------
+
+This extension can be installed for Python 3 using *pip*::
+
+    $ pip3 install fileformats-ants
+
+This will install the core package and any other dependencies
+
+License
+-------
+
+This work is licensed under a
+`Creative Commons Attribution 4.0 International License <http://creativecommons.org/licenses/by/4.0/>`_
+
+.. image:: https://i.creativecommons.org/l/by/4.0/88x31.png
+  :target: http://creativecommons.org/licenses/by/4.0/
+  :alt: Creative Commons Attribution 4.0 International License
diff --git a/required-fileformats/ants/fileformats/medimage_ants/__init__.py b/required-fileformats/ants/fileformats/medimage_ants/__init__.py
new file mode 100644
index 00000000..10bd9c0d
--- /dev/null
+++ b/required-fileformats/ants/fileformats/medimage_ants/__init__.py
@@ -0,0 +1 @@
+from fileformats.generic import File
\ No newline at end of file
diff --git a/required-fileformats/ants/fileformats/medimage_ants/_version.py b/required-fileformats/ants/fileformats/medimage_ants/_version.py
new file mode 100644
index 00000000..ecda9af7
--- /dev/null
+++ b/required-fileformats/ants/fileformats/medimage_ants/_version.py
@@ -0,0 +1,16 @@
+# file generated by setuptools_scm
+# don't change, don't track in version control
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple, Union
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '0.2.3.dev42+gb9e3ee9.d20240226'
+__version_tuple__ = version_tuple = (0, 2, 3, 'dev42', 'gb9e3ee9.d20240226')
diff --git a/required-fileformats/ants/pyproject.toml b/required-fileformats/ants/pyproject.toml
new file mode 100644
index 00000000..e75b3e6a
--- /dev/null
+++ b/required-fileformats/ants/pyproject.toml
@@ -0,0 +1,84 @@
+[build-system]
+requires = ["hatchling", "hatch-vcs"]
+build-backend = "hatchling.build"
+
+[project]
+name = "fileformats-medimage-ants"
+description = "Classes for representing different file formats in Python classes for use in type hinting in data workflows"
+readme = "README.rst"
+requires-python = ">=3.8"
+dependencies = [
+    "fileformats",
+    "fileformats-medimage"
+]
+license = {file = "LICENSE"}
+authors = [
+    {name = "Thomas G. Close", email = "tom.g.close@gmail.com"},
+]
+maintainers = [
+    {name = "Thomas G. Close", email = "tom.g.close@gmail.com"},
+]
+keywords = [
+    "file formats",
+    "data",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: Apache Software License",
+    "Operating System :: MacOS :: MacOS X",
+    "Operating System :: Microsoft :: Windows",
+    "Operating System :: POSIX :: Linux",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Topic :: Scientific/Engineering",
+]
+dynamic = ["version"]
+
+[project.optional-dependencies]
+dev = [
+    "black",
+    "pre-commit",
+    "codespell",
+    "flake8",
+    "flake8-pyproject",
+]
+test = [
+    "pytest >=6.2.5",
+    "pytest-env>=0.6.2",
+    "pytest-cov>=2.12.1",
+    "codecov",
+    "fileformats-medimage-CHANGME-extras",
+]
+
+[project.urls]
+repository = "https://github.com/nipype/pydra-ants"
+
+[tool.hatch.version]
+source = "vcs"
+raw-options = { root = "../.." }
+
+[tool.hatch.build.hooks.vcs]
+version-file = "fileformats/medimage_ants/_version.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["fileformats"]
+
+[tool.black]
+target-version = ['py38']
+exclude = "fileformats/medimage_ants/_version.py"
+
+[tool.codespell]
+ignore-words = ".codespell-ignorewords"
+
+[tool.flake8]
+doctests = true
+per-file-ignores = [
+    "__init__.py:F401"
+]
+max-line-length = 88
+select = "C,E,F,W,B,B950"
+extend-ignore = ['E203', 'E501', 'E129']
diff --git a/required-fileformats/brainsuite/LICENSE b/required-fileformats/brainsuite/LICENSE
new file mode 100644
index 00000000..e00bcb30
--- /dev/null
+++ b/required-fileformats/brainsuite/LICENSE
@@ -0,0 +1,13 @@
+   Copyright 2021 Nipype developers
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/required-fileformats/brainsuite/README.rst b/required-fileformats/brainsuite/README.rst
new file mode 100644
index 00000000..2fd1dd9f
--- /dev/null
+++ b/required-fileformats/brainsuite/README.rst
@@ -0,0 +1,39 @@
+How to customise this template
+==============================
+
+#. Rename the `related-packages/fileformats/brainsuite` directory to the name of the fileformats subpackage (e.g. `medimage_fsl`)
+#. Search and replace "brainsuite" with the name of the fileformats subpackage the extras are to be added
+#. Replace name + email placeholders in `pyproject.toml` for developers and maintainers
+#. Add the extension file-format classes
+#. Ensure that all the extension file-format classes are imported into the extras package root, i.e. `fileformats/brainsuite`
+#. Delete these instructions
+
+...
+
+FileFormats Extension - brainsuite
+====================================
+.. image:: https://github.com/nipype/pydra-brainsuite/actions/workflows/ci-cd.yml/badge.svg
+    :target: https://github.com/nipype/pydra-brainsuite/actions/workflows/ci-cd.yml
+
+This is the "brainsuite" extension module for the
+`fileformats <https://github.com/ArcanaFramework/fileformats-core>`__ package
+
+
+Quick Installation
+------------------
+
+This extension can be installed for Python 3 using *pip*::
+
+    $ pip3 install fileformats-brainsuite
+
+This will install the core package and any other dependencies
+
+License
+-------
+
+This work is licensed under a
+`Creative Commons Attribution 4.0 International License <http://creativecommons.org/licenses/by/4.0/>`_
+
+.. image:: https://i.creativecommons.org/l/by/4.0/88x31.png
+  :target: http://creativecommons.org/licenses/by/4.0/
+  :alt: Creative Commons Attribution 4.0 International License
diff --git a/required-fileformats/brainsuite/fileformats/medimage_brainsuite/__init__.py b/required-fileformats/brainsuite/fileformats/medimage_brainsuite/__init__.py
new file mode 100644
index 00000000..10bd9c0d
--- /dev/null
+++ b/required-fileformats/brainsuite/fileformats/medimage_brainsuite/__init__.py
@@ -0,0 +1 @@
+from fileformats.generic import File
\ No newline at end of file
diff --git a/required-fileformats/brainsuite/fileformats/medimage_brainsuite/_version.py b/required-fileformats/brainsuite/fileformats/medimage_brainsuite/_version.py
new file mode 100644
index 00000000..ecda9af7
--- /dev/null
+++ b/required-fileformats/brainsuite/fileformats/medimage_brainsuite/_version.py
@@ -0,0 +1,16 @@
+# file generated by setuptools_scm
+# don't change, don't track in version control
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple, Union
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '0.2.3.dev42+gb9e3ee9.d20240226'
+__version_tuple__ = version_tuple = (0, 2, 3, 'dev42', 'gb9e3ee9.d20240226')
diff --git a/required-fileformats/brainsuite/pyproject.toml b/required-fileformats/brainsuite/pyproject.toml
new file mode 100644
index 00000000..85d5c2a2
--- /dev/null
+++ b/required-fileformats/brainsuite/pyproject.toml
@@ -0,0 +1,84 @@
+[build-system]
+requires = ["hatchling", "hatch-vcs"]
+build-backend = "hatchling.build"
+
+[project]
+name = "fileformats-medimage-brainsuite"
+description = "Classes for representing different file formats in Python classes for use in type hinting in data workflows"
+readme = "README.rst"
+requires-python = ">=3.8"
+dependencies = [
+    "fileformats",
+    "fileformats-medimage"
+]
+license = {file = "LICENSE"}
+authors = [
+    {name = "Thomas G. Close", email = "tom.g.close@gmail.com"},
+]
+maintainers = [
+    {name = "Thomas G. Close", email = "tom.g.close@gmail.com"},
+]
+keywords = [
+    "file formats",
+    "data",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: Apache Software License",
+    "Operating System :: MacOS :: MacOS X",
+    "Operating System :: Microsoft :: Windows",
+    "Operating System :: POSIX :: Linux",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Topic :: Scientific/Engineering",
+]
+dynamic = ["version"]
+
+[project.optional-dependencies]
+dev = [
+    "black",
+    "pre-commit",
+    "codespell",
+    "flake8",
+    "flake8-pyproject",
+]
+test = [
+    "pytest >=6.2.5",
+    "pytest-env>=0.6.2",
+    "pytest-cov>=2.12.1",
+    "codecov",
+    "fileformats-medimage-CHANGME-extras",
+]
+
+[project.urls]
+repository = "https://github.com/nipype/pydra-brainsuite"
+
+[tool.hatch.version]
+source = "vcs"
+raw-options = { root = "../.." }
+
+[tool.hatch.build.hooks.vcs]
+version-file = "fileformats/medimage_brainsuite/_version.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["fileformats"]
+
+[tool.black]
+target-version = ['py38']
+exclude = "fileformats/medimage_brainsuite/_version.py"
+
+[tool.codespell]
+ignore-words = ".codespell-ignorewords"
+
+[tool.flake8]
+doctests = true
+per-file-ignores = [
+    "__init__.py:F401"
+]
+max-line-length = 88
+select = "C,E,F,W,B,B950"
+extend-ignore = ['E203', 'E501', 'E129']
diff --git a/required-fileformats/bru2nii/LICENSE b/required-fileformats/bru2nii/LICENSE
new file mode 100644
index 00000000..e00bcb30
--- /dev/null
+++ b/required-fileformats/bru2nii/LICENSE
@@ -0,0 +1,13 @@
+   Copyright 2021 Nipype developers
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/required-fileformats/bru2nii/README.rst b/required-fileformats/bru2nii/README.rst
new file mode 100644
index 00000000..a693249c
--- /dev/null
+++ b/required-fileformats/bru2nii/README.rst
@@ -0,0 +1,39 @@
+How to customise this template
+==============================
+
+#. Rename the `related-packages/fileformats/bru2nii` directory to the name of the fileformats subpackage (e.g. `medimage_fsl`)
+#. Search and replace "bru2nii" with the name of the fileformats subpackage the extras are to be added
+#. Replace name + email placeholders in `pyproject.toml` for developers and maintainers
+#. Add the extension file-format classes
+#. Ensure that all the extension file-format classes are imported into the extras package root, i.e. `fileformats/bru2nii`
+#. Delete these instructions
+
+...
+
+FileFormats Extension - bru2nii
+====================================
+.. image:: https://github.com/nipype/pydra-bru2nii/actions/workflows/ci-cd.yml/badge.svg
+    :target: https://github.com/nipype/pydra-bru2nii/actions/workflows/ci-cd.yml
+
+This is the "bru2nii" extension module for the
+`fileformats <https://github.com/ArcanaFramework/fileformats-core>`__ package
+
+
+Quick Installation
+------------------
+
+This extension can be installed for Python 3 using *pip*::
+
+    $ pip3 install fileformats-bru2nii
+
+This will install the core package and any other dependencies
+
+License
+-------
+
+This work is licensed under a
+`Creative Commons Attribution 4.0 International License <http://creativecommons.org/licenses/by/4.0/>`_
+
+.. image:: https://i.creativecommons.org/l/by/4.0/88x31.png
+  :target: http://creativecommons.org/licenses/by/4.0/
+  :alt: Creative Commons Attribution 4.0 International License
diff --git a/required-fileformats/bru2nii/fileformats/medimage_bru2nii/__init__.py b/required-fileformats/bru2nii/fileformats/medimage_bru2nii/__init__.py
new file mode 100644
index 00000000..10bd9c0d
--- /dev/null
+++ b/required-fileformats/bru2nii/fileformats/medimage_bru2nii/__init__.py
@@ -0,0 +1 @@
+from fileformats.generic import File
\ No newline at end of file
diff --git a/required-fileformats/bru2nii/fileformats/medimage_bru2nii/_version.py b/required-fileformats/bru2nii/fileformats/medimage_bru2nii/_version.py
new file mode 100644
index 00000000..ecda9af7
--- /dev/null
+++ b/required-fileformats/bru2nii/fileformats/medimage_bru2nii/_version.py
@@ -0,0 +1,16 @@
+# file generated by setuptools_scm
+# don't change, don't track in version control
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple, Union
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '0.2.3.dev42+gb9e3ee9.d20240226'
+__version_tuple__ = version_tuple = (0, 2, 3, 'dev42', 'gb9e3ee9.d20240226')
diff --git a/required-fileformats/bru2nii/pyproject.toml b/required-fileformats/bru2nii/pyproject.toml
new file mode 100644
index 00000000..1cfa63d8
--- /dev/null
+++ b/required-fileformats/bru2nii/pyproject.toml
@@ -0,0 +1,84 @@
+[build-system]
+requires = ["hatchling", "hatch-vcs"]
+build-backend = "hatchling.build"
+
+[project]
+name = "fileformats-medimage-bru2nii"
+description = "Classes for representing different file formats in Python classes for use in type hinting in data workflows"
+readme = "README.rst"
+requires-python = ">=3.8"
+dependencies = [
+    "fileformats",
+    "fileformats-medimage"
+]
+license = {file = "LICENSE"}
+authors = [
+    {name = "Thomas G. Close", email = "tom.g.close@gmail.com"},
+]
+maintainers = [
+    {name = "Thomas G. Close", email = "tom.g.close@gmail.com"},
+]
+keywords = [
+    "file formats",
+    "data",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: Apache Software License",
+    "Operating System :: MacOS :: MacOS X",
+    "Operating System :: Microsoft :: Windows",
+    "Operating System :: POSIX :: Linux",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Topic :: Scientific/Engineering",
+]
+dynamic = ["version"]
+
+[project.optional-dependencies]
+dev = [
+    "black",
+    "pre-commit",
+    "codespell",
+    "flake8",
+    "flake8-pyproject",
+]
+test = [
+    "pytest >=6.2.5",
+    "pytest-env>=0.6.2",
+    "pytest-cov>=2.12.1",
+    "codecov",
+    "fileformats-medimage-CHANGME-extras",
+]
+
+[project.urls]
+repository = "https://github.com/nipype/pydra-bru2nii"
+
+[tool.hatch.version]
+source = "vcs"
+raw-options = { root = "../.." }
+
+[tool.hatch.build.hooks.vcs]
+version-file = "fileformats/medimage_bru2nii/_version.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["fileformats"]
+
+[tool.black]
+target-version = ['py38']
+exclude = "fileformats/medimage_bru2nii/_version.py"
+
+[tool.codespell]
+ignore-words = ".codespell-ignorewords"
+
+[tool.flake8]
+doctests = true
+per-file-ignores = [
+    "__init__.py:F401"
+]
+max-line-length = 88
+select = "C,E,F,W,B,B950"
+extend-ignore = ['E203', 'E501', 'E129']
diff --git a/required-fileformats/c3/LICENSE b/required-fileformats/c3/LICENSE
new file mode 100644
index 00000000..e00bcb30
--- /dev/null
+++ b/required-fileformats/c3/LICENSE
@@ -0,0 +1,13 @@
+   Copyright 2021 Nipype developers
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/required-fileformats/c3/README.rst b/required-fileformats/c3/README.rst
new file mode 100644
index 00000000..6ab10027
--- /dev/null
+++ b/required-fileformats/c3/README.rst
@@ -0,0 +1,39 @@
+How to customise this template
+==============================
+
+#. Rename the `related-packages/fileformats/c3` directory to the name of the fileformats subpackage (e.g. `medimage_fsl`)
+#. Search and replace "c3" with the name of the fileformats subpackage the extras are to be added
+#. Replace name + email placeholders in `pyproject.toml` for developers and maintainers
+#. Add the extension file-format classes
+#. Ensure that all the extension file-format classes are imported into the extras package root, i.e. `fileformats/c3`
+#. Delete these instructions
+
+...
+
+FileFormats Extension - c3
+====================================
+.. image:: https://github.com/nipype/pydra-c3/actions/workflows/ci-cd.yml/badge.svg
+    :target: https://github.com/nipype/pydra-c3/actions/workflows/ci-cd.yml
+
+This is the "c3" extension module for the
+`fileformats <https://github.com/ArcanaFramework/fileformats-core>`__ package
+
+
+Quick Installation
+------------------
+
+This extension can be installed for Python 3 using *pip*::
+
+    $ pip3 install fileformats-c3
+
+This will install the core package and any other dependencies
+
+License
+-------
+
+This work is licensed under a
+`Creative Commons Attribution 4.0 International License <http://creativecommons.org/licenses/by/4.0/>`_
+
+.. image:: https://i.creativecommons.org/l/by/4.0/88x31.png
+  :target: http://creativecommons.org/licenses/by/4.0/
+  :alt: Creative Commons Attribution 4.0 International License
diff --git a/required-fileformats/c3/fileformats/medimage_c3/__init__.py b/required-fileformats/c3/fileformats/medimage_c3/__init__.py
new file mode 100644
index 00000000..10bd9c0d
--- /dev/null
+++ b/required-fileformats/c3/fileformats/medimage_c3/__init__.py
@@ -0,0 +1 @@
+from fileformats.generic import File
\ No newline at end of file
diff --git a/required-fileformats/c3/fileformats/medimage_c3/_version.py b/required-fileformats/c3/fileformats/medimage_c3/_version.py
new file mode 100644
index 00000000..ecda9af7
--- /dev/null
+++ b/required-fileformats/c3/fileformats/medimage_c3/_version.py
@@ -0,0 +1,16 @@
+# file generated by setuptools_scm
+# don't change, don't track in version control
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple, Union
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '0.2.3.dev42+gb9e3ee9.d20240226'
+__version_tuple__ = version_tuple = (0, 2, 3, 'dev42', 'gb9e3ee9.d20240226')
diff --git a/required-fileformats/c3/pyproject.toml b/required-fileformats/c3/pyproject.toml
new file mode 100644
index 00000000..f1dd6bca
--- /dev/null
+++ b/required-fileformats/c3/pyproject.toml
@@ -0,0 +1,84 @@
+[build-system]
+requires = ["hatchling", "hatch-vcs"]
+build-backend = "hatchling.build"
+
+[project]
+name = "fileformats-medimage-c3"
+description = "Classes for representing different file formats in Python classes for use in type hinting in data workflows"
+readme = "README.rst"
+requires-python = ">=3.8"
+dependencies = [
+    "fileformats",
+    "fileformats-medimage"
+]
+license = {file = "LICENSE"}
+authors = [
+    {name = "Thomas G. Close", email = "tom.g.close@gmail.com"},
+]
+maintainers = [
+    {name = "Thomas G. Close", email = "tom.g.close@gmail.com"},
+]
+keywords = [
+    "file formats",
+    "data",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: Apache Software License",
+    "Operating System :: MacOS :: MacOS X",
+    "Operating System :: Microsoft :: Windows",
+    "Operating System :: POSIX :: Linux",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Topic :: Scientific/Engineering",
+]
+dynamic = ["version"]
+
+[project.optional-dependencies]
+dev = [
+    "black",
+    "pre-commit",
+    "codespell",
+    "flake8",
+    "flake8-pyproject",
+]
+test = [
+    "pytest >=6.2.5",
+    "pytest-env>=0.6.2",
+    "pytest-cov>=2.12.1",
+    "codecov",
+    "fileformats-medimage-CHANGME-extras",
+]
+
+[project.urls]
+repository = "https://github.com/nipype/pydra-c3"
+
+[tool.hatch.version]
+source = "vcs"
+raw-options = { root = "../.." }
+
+[tool.hatch.build.hooks.vcs]
+version-file = "fileformats/medimage_c3/_version.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["fileformats"]
+
+[tool.black]
+target-version = ['py38']
+exclude = "fileformats/medimage_c3/_version.py"
+
+[tool.codespell]
+ignore-words = ".codespell-ignorewords"
+
+[tool.flake8]
+doctests = true
+per-file-ignores = [
+    "__init__.py:F401"
+]
+max-line-length = 88
+select = "C,E,F,W,B,B950"
+extend-ignore = ['E203', 'E501', 'E129']
diff --git a/required-fileformats/camino/LICENSE b/required-fileformats/camino/LICENSE
new file mode 100644
index 00000000..e00bcb30
--- /dev/null
+++ b/required-fileformats/camino/LICENSE
@@ -0,0 +1,13 @@
+   Copyright 2021 Nipype developers
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/required-fileformats/camino/README.rst b/required-fileformats/camino/README.rst
new file mode 100644
index 00000000..328795f3
--- /dev/null
+++ b/required-fileformats/camino/README.rst
@@ -0,0 +1,39 @@
+How to customise this template
+==============================
+
+#. Rename the `related-packages/fileformats/camino` directory to the name of the fileformats subpackage (e.g. `medimage_fsl`)
+#. Search and replace "camino" with the name of the fileformats subpackage the extras are to be added
+#. Replace name + email placeholders in `pyproject.toml` for developers and maintainers
+#. Add the extension file-format classes
+#. Ensure that all the extension file-format classes are imported into the extras package root, i.e. `fileformats/camino`
+#. Delete these instructions
+
+...
+
+FileFormats Extension - camino
+====================================
+.. image:: https://github.com/nipype/pydra-camino/actions/workflows/ci-cd.yml/badge.svg
+    :target: https://github.com/nipype/pydra-camino/actions/workflows/ci-cd.yml
+
+This is the "camino" extension module for the
+`fileformats <https://github.com/ArcanaFramework/fileformats-core>`__ package
+
+
+Quick Installation
+------------------
+
+This extension can be installed for Python 3 using *pip*::
+
+    $ pip3 install fileformats-camino
+
+This will install the core package and any other dependencies
+
+License
+-------
+
+This work is licensed under a
+`Creative Commons Attribution 4.0 International License <http://creativecommons.org/licenses/by/4.0/>`_
+
+.. image:: https://i.creativecommons.org/l/by/4.0/88x31.png
+  :target: http://creativecommons.org/licenses/by/4.0/
+  :alt: Creative Commons Attribution 4.0 International License
diff --git a/required-fileformats/camino/fileformats/medimage_camino/__init__.py b/required-fileformats/camino/fileformats/medimage_camino/__init__.py
new file mode 100644
index 00000000..10bd9c0d
--- /dev/null
+++ b/required-fileformats/camino/fileformats/medimage_camino/__init__.py
@@ -0,0 +1 @@
+from fileformats.generic import File
\ No newline at end of file
diff --git a/required-fileformats/camino/fileformats/medimage_camino/_version.py b/required-fileformats/camino/fileformats/medimage_camino/_version.py
new file mode 100644
index 00000000..ecda9af7
--- /dev/null
+++ b/required-fileformats/camino/fileformats/medimage_camino/_version.py
@@ -0,0 +1,16 @@
+# file generated by setuptools_scm
+# don't change, don't track in version control
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple, Union
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '0.2.3.dev42+gb9e3ee9.d20240226'
+__version_tuple__ = version_tuple = (0, 2, 3, 'dev42', 'gb9e3ee9.d20240226')
diff --git a/required-fileformats/camino/pyproject.toml b/required-fileformats/camino/pyproject.toml
new file mode 100644
index 00000000..970e6b9a
--- /dev/null
+++ b/required-fileformats/camino/pyproject.toml
@@ -0,0 +1,84 @@
+[build-system]
+requires = ["hatchling", "hatch-vcs"]
+build-backend = "hatchling.build"
+
+[project]
+name = "fileformats-medimage-camino"
+description = "Classes for representing different file formats in Python classes for use in type hinting in data workflows"
+readme = "README.rst"
+requires-python = ">=3.8"
+dependencies = [
+    "fileformats",
+    "fileformats-medimage"
+]
+license = {file = "LICENSE"}
+authors = [
+    {name = "Thomas G. Close", email = "tom.g.close@gmail.com"},
+]
+maintainers = [
+    {name = "Thomas G. Close", email = "tom.g.close@gmail.com"},
+]
+keywords = [
+    "file formats",
+    "data",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: Apache Software License",
+    "Operating System :: MacOS :: MacOS X",
+    "Operating System :: Microsoft :: Windows",
+    "Operating System :: POSIX :: Linux",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Topic :: Scientific/Engineering",
+]
+dynamic = ["version"]
+
+[project.optional-dependencies]
+dev = [
+    "black",
+    "pre-commit",
+    "codespell",
+    "flake8",
+    "flake8-pyproject",
+]
+test = [
+    "pytest >=6.2.5",
+    "pytest-env>=0.6.2",
+    "pytest-cov>=2.12.1",
+    "codecov",
+    "fileformats-medimage-CHANGME-extras",
+]
+
+[project.urls]
+repository = "https://github.com/nipype/pydra-camino"
+
+[tool.hatch.version]
+source = "vcs"
+raw-options = { root = "../.." }
+
+[tool.hatch.build.hooks.vcs]
+version-file = "fileformats/medimage_camino/_version.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["fileformats"]
+
+[tool.black]
+target-version = ['py38']
+exclude = "fileformats/medimage_camino/_version.py"
+
+[tool.codespell]
+ignore-words = ".codespell-ignorewords"
+
+[tool.flake8]
+doctests = true
+per-file-ignores = [
+    "__init__.py:F401"
+]
+max-line-length = 88
+select = "C,E,F,W,B,B950"
+extend-ignore = ['E203', 'E501', 'E129']
diff --git a/required-fileformats/camino2trackvis/LICENSE b/required-fileformats/camino2trackvis/LICENSE
new file mode 100644
index 00000000..e00bcb30
--- /dev/null
+++ b/required-fileformats/camino2trackvis/LICENSE
@@ -0,0 +1,13 @@
+   Copyright 2021 Nipype developers
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/required-fileformats/camino2trackvis/README.rst b/required-fileformats/camino2trackvis/README.rst
new file mode 100644
index 00000000..31a860ea
--- /dev/null
+++ b/required-fileformats/camino2trackvis/README.rst
@@ -0,0 +1,39 @@
+How to customise this template
+==============================
+
+#. Rename the `related-packages/fileformats/camino2trackvis` directory to the name of the fileformats subpackage (e.g. `medimage_fsl`)
+#. Search and replace "camino2trackvis" with the name of the fileformats subpackage the extras are to be added
+#. Replace name + email placeholders in `pyproject.toml` for developers and maintainers
+#. Add the extension file-format classes
+#. Ensure that all the extension file-format classes are imported into the extras package root, i.e. `fileformats/camino2trackvis`
+#. Delete these instructions
+
+...
+
+FileFormats Extension - camino2trackvis
+====================================
+.. image:: https://github.com/nipype/pydra-camino2trackvis/actions/workflows/ci-cd.yml/badge.svg
+    :target: https://github.com/nipype/pydra-camino2trackvis/actions/workflows/ci-cd.yml
+
+This is the "camino2trackvis" extension module for the
+`fileformats <https://github.com/ArcanaFramework/fileformats-core>`__ package
+
+
+Quick Installation
+------------------
+
+This extension can be installed for Python 3 using *pip*::
+
+    $ pip3 install fileformats-camino2trackvis
+
+This will install the core package and any other dependencies
+
+License
+-------
+
+This work is licensed under a
+`Creative Commons Attribution 4.0 International License <http://creativecommons.org/licenses/by/4.0/>`_
+
+.. image:: https://i.creativecommons.org/l/by/4.0/88x31.png
+  :target: http://creativecommons.org/licenses/by/4.0/
+  :alt: Creative Commons Attribution 4.0 International License
diff --git a/required-fileformats/camino2trackvis/fileformats/medimage_camino2trackvis/__init__.py b/required-fileformats/camino2trackvis/fileformats/medimage_camino2trackvis/__init__.py
new file mode 100644
index 00000000..10bd9c0d
--- /dev/null
+++ b/required-fileformats/camino2trackvis/fileformats/medimage_camino2trackvis/__init__.py
@@ -0,0 +1 @@
+from fileformats.generic import File
\ No newline at end of file
diff --git a/required-fileformats/camino2trackvis/fileformats/medimage_camino2trackvis/_version.py b/required-fileformats/camino2trackvis/fileformats/medimage_camino2trackvis/_version.py
new file mode 100644
index 00000000..ecda9af7
--- /dev/null
+++ b/required-fileformats/camino2trackvis/fileformats/medimage_camino2trackvis/_version.py
@@ -0,0 +1,16 @@
+# file generated by setuptools_scm
+# don't change, don't track in version control
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple, Union
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '0.2.3.dev42+gb9e3ee9.d20240226'
+__version_tuple__ = version_tuple = (0, 2, 3, 'dev42', 'gb9e3ee9.d20240226')
diff --git a/required-fileformats/camino2trackvis/pyproject.toml b/required-fileformats/camino2trackvis/pyproject.toml
new file mode 100644
index 00000000..76fbac2d
--- /dev/null
+++ b/required-fileformats/camino2trackvis/pyproject.toml
@@ -0,0 +1,84 @@
+[build-system]
+requires = ["hatchling", "hatch-vcs"]
+build-backend = "hatchling.build"
+
+[project]
+name = "fileformats-medimage-camino2trackvis"
+description = "Classes for representing different file formats in Python classes for use in type hinting in data workflows"
+readme = "README.rst"
+requires-python = ">=3.8"
+dependencies = [
+    "fileformats",
+    "fileformats-medimage"
+]
+license = {file = "LICENSE"}
+authors = [
+    {name = "Thomas G. Close", email = "tom.g.close@gmail.com"},
+]
+maintainers = [
+    {name = "Thomas G. Close", email = "tom.g.close@gmail.com"},
+]
+keywords = [
+    "file formats",
+    "data",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: Apache Software License",
+    "Operating System :: MacOS :: MacOS X",
+    "Operating System :: Microsoft :: Windows",
+    "Operating System :: POSIX :: Linux",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Topic :: Scientific/Engineering",
+]
+dynamic = ["version"]
+
+[project.optional-dependencies]
+dev = [
+    "black",
+    "pre-commit",
+    "codespell",
+    "flake8",
+    "flake8-pyproject",
+]
+test = [
+    "pytest >=6.2.5",
+    "pytest-env>=0.6.2",
+    "pytest-cov>=2.12.1",
+    "codecov",
+    "fileformats-medimage-CHANGME-extras",
+]
+
+[project.urls]
+repository = "https://github.com/nipype/pydra-camino2trackvis"
+
+[tool.hatch.version]
+source = "vcs"
+raw-options = { root = "../.." }
+
+[tool.hatch.build.hooks.vcs]
+version-file = "fileformats/medimage_camino2trackvis/_version.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["fileformats"]
+
+[tool.black]
+target-version = ['py38']
+exclude = "fileformats/medimage_camino2trackvis/_version.py"
+
+[tool.codespell]
+ignore-words = ".codespell-ignorewords"
+
+[tool.flake8]
+doctests = true
+per-file-ignores = [
+    "__init__.py:F401"
+]
+max-line-length = 88
+select = "C,E,F,W,B,B950"
+extend-ignore = ['E203', 'E501', 'E129']
diff --git a/required-fileformats/cat12/LICENSE b/required-fileformats/cat12/LICENSE
new file mode 100644
index 00000000..e00bcb30
--- /dev/null
+++ b/required-fileformats/cat12/LICENSE
@@ -0,0 +1,13 @@
+   Copyright 2021 Nipype developers
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/required-fileformats/cat12/README.rst b/required-fileformats/cat12/README.rst
new file mode 100644
index 00000000..cdb46590
--- /dev/null
+++ b/required-fileformats/cat12/README.rst
@@ -0,0 +1,39 @@
+How to customise this template
+==============================
+
+#. Rename the `related-packages/fileformats/cat12` directory to the name of the fileformats subpackage (e.g. `medimage_fsl`)
+#. Search and replace "cat12" with the name of the fileformats subpackage the extras are to be added
+#. Replace name + email placeholders in `pyproject.toml` for developers and maintainers
+#. Add the extension file-format classes
+#. Ensure that all the extension file-format classes are imported into the extras package root, i.e. `fileformats/cat12`
+#. Delete these instructions
+
+...
+
+FileFormats Extension - cat12
+====================================
+.. image:: https://github.com/nipype/pydra-cat12/actions/workflows/ci-cd.yml/badge.svg
+    :target: https://github.com/nipype/pydra-cat12/actions/workflows/ci-cd.yml
+
+This is the "cat12" extension module for the
+`fileformats <https://github.com/ArcanaFramework/fileformats-core>`__ package
+
+
+Quick Installation
+------------------
+
+This extension can be installed for Python 3 using *pip*::
+
+    $ pip3 install fileformats-cat12
+
+This will install the core package and any other dependencies
+
+License
+-------
+
+This work is licensed under a
+`Creative Commons Attribution 4.0 International License <http://creativecommons.org/licenses/by/4.0/>`_
+
+.. image:: https://i.creativecommons.org/l/by/4.0/88x31.png
+  :target: http://creativecommons.org/licenses/by/4.0/
+  :alt: Creative Commons Attribution 4.0 International License
diff --git a/required-fileformats/cat12/fileformats/medimage_cat12/__init__.py b/required-fileformats/cat12/fileformats/medimage_cat12/__init__.py
new file mode 100644
index 00000000..10bd9c0d
--- /dev/null
+++ b/required-fileformats/cat12/fileformats/medimage_cat12/__init__.py
@@ -0,0 +1 @@
+from fileformats.generic import File
\ No newline at end of file
diff --git a/required-fileformats/cat12/fileformats/medimage_cat12/_version.py b/required-fileformats/cat12/fileformats/medimage_cat12/_version.py
new file mode 100644
index 00000000..ecda9af7
--- /dev/null
+++ b/required-fileformats/cat12/fileformats/medimage_cat12/_version.py
@@ -0,0 +1,16 @@
+# file generated by setuptools_scm
+# don't change, don't track in version control
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple, Union
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '0.2.3.dev42+gb9e3ee9.d20240226'
+__version_tuple__ = version_tuple = (0, 2, 3, 'dev42', 'gb9e3ee9.d20240226')
diff --git a/required-fileformats/cat12/pyproject.toml b/required-fileformats/cat12/pyproject.toml
new file mode 100644
index 00000000..93cc7e66
--- /dev/null
+++ b/required-fileformats/cat12/pyproject.toml
@@ -0,0 +1,84 @@
+[build-system]
+requires = ["hatchling", "hatch-vcs"]
+build-backend = "hatchling.build"
+
+[project]
+name = "fileformats-medimage-cat12"
+description = "Classes for representing different file formats in Python classes for use in type hinting in data workflows"
+readme = "README.rst"
+requires-python = ">=3.8"
+dependencies = [
+    "fileformats",
+    "fileformats-medimage"
+]
+license = {file = "LICENSE"}
+authors = [
+    {name = "Thomas G. Close", email = "tom.g.close@gmail.com"},
+]
+maintainers = [
+    {name = "Thomas G. Close", email = "tom.g.close@gmail.com"},
+]
+keywords = [
+    "file formats",
+    "data",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: Apache Software License",
+    "Operating System :: MacOS :: MacOS X",
+    "Operating System :: Microsoft :: Windows",
+    "Operating System :: POSIX :: Linux",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Topic :: Scientific/Engineering",
+]
+dynamic = ["version"]
+
+[project.optional-dependencies]
+dev = [
+    "black",
+    "pre-commit",
+    "codespell",
+    "flake8",
+    "flake8-pyproject",
+]
+test = [
+    "pytest >=6.2.5",
+    "pytest-env>=0.6.2",
+    "pytest-cov>=2.12.1",
+    "codecov",
+    "fileformats-medimage-CHANGME-extras",
+]
+
+[project.urls]
+repository = "https://github.com/nipype/pydra-cat12"
+
+[tool.hatch.version]
+source = "vcs"
+raw-options = { root = "../.." }
+
+[tool.hatch.build.hooks.vcs]
+version-file = "fileformats/medimage_cat12/_version.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["fileformats"]
+
+[tool.black]
+target-version = ['py38']
+exclude = "fileformats/medimage_cat12/_version.py"
+
+[tool.codespell]
+ignore-words = ".codespell-ignorewords"
+
+[tool.flake8]
+doctests = true
+per-file-ignores = [
+    "__init__.py:F401"
+]
+max-line-length = 88
+select = "C,E,F,W,B,B950"
+extend-ignore = ['E203', 'E501', 'E129']
diff --git a/required-fileformats/cmtk/LICENSE b/required-fileformats/cmtk/LICENSE
new file mode 100644
index 00000000..e00bcb30
--- /dev/null
+++ b/required-fileformats/cmtk/LICENSE
@@ -0,0 +1,13 @@
+   Copyright 2021 Nipype developers
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/required-fileformats/cmtk/README.rst b/required-fileformats/cmtk/README.rst
new file mode 100644
index 00000000..5faa3be3
--- /dev/null
+++ b/required-fileformats/cmtk/README.rst
@@ -0,0 +1,39 @@
+How to customise this template
+==============================
+
+#. Rename the `related-packages/fileformats/cmtk` directory to the name of the fileformats subpackage (e.g. `medimage_fsl`)
+#. Search and replace "cmtk" with the name of the fileformats subpackage the extras are to be added
+#. Replace name + email placeholders in `pyproject.toml` for developers and maintainers
+#. Add the extension file-format classes
+#. Ensure that all the extension file-format classes are imported into the extras package root, i.e. `fileformats/cmtk`
+#. Delete these instructions
+
+...
+
+FileFormats Extension - cmtk
+====================================
+.. image:: https://github.com/nipype/pydra-cmtk/actions/workflows/ci-cd.yml/badge.svg
+    :target: https://github.com/nipype/pydra-cmtk/actions/workflows/ci-cd.yml
+
+This is the "cmtk" extension module for the
+`fileformats <https://github.com/ArcanaFramework/fileformats-core>`__ package
+
+
+Quick Installation
+------------------
+
+This extension can be installed for Python 3 using *pip*::
+
+    $ pip3 install fileformats-cmtk
+
+This will install the core package and any other dependencies
+
+License
+-------
+
+This work is licensed under a
+`Creative Commons Attribution 4.0 International License <http://creativecommons.org/licenses/by/4.0/>`_
+
+.. image:: https://i.creativecommons.org/l/by/4.0/88x31.png
+  :target: http://creativecommons.org/licenses/by/4.0/
+  :alt: Creative Commons Attribution 4.0 International License
diff --git a/required-fileformats/cmtk/fileformats/medimage_cmtk/__init__.py b/required-fileformats/cmtk/fileformats/medimage_cmtk/__init__.py
new file mode 100644
index 00000000..10bd9c0d
--- /dev/null
+++ b/required-fileformats/cmtk/fileformats/medimage_cmtk/__init__.py
@@ -0,0 +1 @@
+from fileformats.generic import File
\ No newline at end of file
diff --git a/required-fileformats/cmtk/fileformats/medimage_cmtk/_version.py b/required-fileformats/cmtk/fileformats/medimage_cmtk/_version.py
new file mode 100644
index 00000000..ecda9af7
--- /dev/null
+++ b/required-fileformats/cmtk/fileformats/medimage_cmtk/_version.py
@@ -0,0 +1,16 @@
+# file generated by setuptools_scm
+# don't change, don't track in version control
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple, Union
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '0.2.3.dev42+gb9e3ee9.d20240226'
+__version_tuple__ = version_tuple = (0, 2, 3, 'dev42', 'gb9e3ee9.d20240226')
diff --git a/required-fileformats/cmtk/pyproject.toml b/required-fileformats/cmtk/pyproject.toml
new file mode 100644
index 00000000..c9509df2
--- /dev/null
+++ b/required-fileformats/cmtk/pyproject.toml
@@ -0,0 +1,84 @@
+[build-system]
+requires = ["hatchling", "hatch-vcs"]
+build-backend = "hatchling.build"
+
+[project]
+name = "fileformats-medimage-cmtk"
+description = "Classes for representing different file formats in Python classes for use in type hinting in data workflows"
+readme = "README.rst"
+requires-python = ">=3.8"
+dependencies = [
+    "fileformats",
+    "fileformats-medimage"
+]
+license = {file = "LICENSE"}
+authors = [
+    {name = "Thomas G. Close", email = "tom.g.close@gmail.com"},
+]
+maintainers = [
+    {name = "Thomas G. Close", email = "tom.g.close@gmail.com"},
+]
+keywords = [
+    "file formats",
+    "data",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: Apache Software License",
+    "Operating System :: MacOS :: MacOS X",
+    "Operating System :: Microsoft :: Windows",
+    "Operating System :: POSIX :: Linux",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Topic :: Scientific/Engineering",
+]
+dynamic = ["version"]
+
+[project.optional-dependencies]
+dev = [
+    "black",
+    "pre-commit",
+    "codespell",
+    "flake8",
+    "flake8-pyproject",
+]
+test = [
+    "pytest >=6.2.5",
+    "pytest-env>=0.6.2",
+    "pytest-cov>=2.12.1",
+    "codecov",
+    "fileformats-medimage-CHANGME-extras",
+]
+
+[project.urls]
+repository = "https://github.com/nipype/pydra-cmtk"
+
+[tool.hatch.version]
+source = "vcs"
+raw-options = { root = "../.." }
+
+[tool.hatch.build.hooks.vcs]
+version-file = "fileformats/medimage_cmtk/_version.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["fileformats"]
+
+[tool.black]
+target-version = ['py38']
+exclude = "fileformats/medimage_cmtk/_version.py"
+
+[tool.codespell]
+ignore-words = ".codespell-ignorewords"
+
+[tool.flake8]
+doctests = true
+per-file-ignores = [
+    "__init__.py:F401"
+]
+max-line-length = 88
+select = "C,E,F,W,B,B950"
+extend-ignore = ['E203', 'E501', 'E129']
diff --git a/required-fileformats/dcmstack/LICENSE b/required-fileformats/dcmstack/LICENSE
new file mode 100644
index 00000000..e00bcb30
--- /dev/null
+++ b/required-fileformats/dcmstack/LICENSE
@@ -0,0 +1,13 @@
+   Copyright 2021 Nipype developers
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/required-fileformats/dcmstack/README.rst b/required-fileformats/dcmstack/README.rst
new file mode 100644
index 00000000..0eaae300
--- /dev/null
+++ b/required-fileformats/dcmstack/README.rst
@@ -0,0 +1,39 @@
+How to customise this template
+==============================
+
+#. Rename the `related-packages/fileformats/dcmstack` directory to the name of the fileformats subpackage (e.g. `medimage_fsl`)
+#. Search and replace "dcmstack" with the name of the fileformats subpackage the extras are to be added
+#. Replace name + email placeholders in `pyproject.toml` for developers and maintainers
+#. Add the extension file-format classes
+#. Ensure that all the extension file-format classes are imported into the extras package root, i.e. `fileformats/dcmstack`
+#. Delete these instructions
+
+...
+
+FileFormats Extension - dcmstack
+====================================
+.. image:: https://github.com/nipype/pydra-dcmstack/actions/workflows/ci-cd.yml/badge.svg
+    :target: https://github.com/nipype/pydra-dcmstack/actions/workflows/ci-cd.yml
+
+This is the "dcmstack" extension module for the
+`fileformats <https://github.com/ArcanaFramework/fileformats-core>`__ package
+
+
+Quick Installation
+------------------
+
+This extension can be installed for Python 3 using *pip*::
+
+    $ pip3 install fileformats-dcmstack
+
+This will install the core package and any other dependencies
+
+License
+-------
+
+This work is licensed under a
+`Creative Commons Attribution 4.0 International License <http://creativecommons.org/licenses/by/4.0/>`_
+
+.. image:: https://i.creativecommons.org/l/by/4.0/88x31.png
+  :target: http://creativecommons.org/licenses/by/4.0/
+  :alt: Creative Commons Attribution 4.0 International License
diff --git a/required-fileformats/dcmstack/fileformats/medimage_dcmstack/__init__.py b/required-fileformats/dcmstack/fileformats/medimage_dcmstack/__init__.py
new file mode 100644
index 00000000..10bd9c0d
--- /dev/null
+++ b/required-fileformats/dcmstack/fileformats/medimage_dcmstack/__init__.py
@@ -0,0 +1 @@
+from fileformats.generic import File
\ No newline at end of file
diff --git a/required-fileformats/dcmstack/fileformats/medimage_dcmstack/_version.py b/required-fileformats/dcmstack/fileformats/medimage_dcmstack/_version.py
new file mode 100644
index 00000000..ecda9af7
--- /dev/null
+++ b/required-fileformats/dcmstack/fileformats/medimage_dcmstack/_version.py
@@ -0,0 +1,16 @@
+# file generated by setuptools_scm
+# don't change, don't track in version control
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple, Union
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '0.2.3.dev42+gb9e3ee9.d20240226'
+__version_tuple__ = version_tuple = (0, 2, 3, 'dev42', 'gb9e3ee9.d20240226')
diff --git a/required-fileformats/dcmstack/pyproject.toml b/required-fileformats/dcmstack/pyproject.toml
new file mode 100644
index 00000000..7ace73b7
--- /dev/null
+++ b/required-fileformats/dcmstack/pyproject.toml
@@ -0,0 +1,84 @@
+[build-system]
+requires = ["hatchling", "hatch-vcs"]
+build-backend = "hatchling.build"
+
+[project]
+name = "fileformats-medimage-dcmstack"
+description = "Classes for representing different file formats in Python classes for use in type hinting in data workflows"
+readme = "README.rst"
+requires-python = ">=3.8"
+dependencies = [
+    "fileformats",
+    "fileformats-medimage"
+]
+license = {file = "LICENSE"}
+authors = [
+    {name = "Thomas G. Close", email = "tom.g.close@gmail.com"},
+]
+maintainers = [
+    {name = "Thomas G. Close", email = "tom.g.close@gmail.com"},
+]
+keywords = [
+    "file formats",
+    "data",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: Apache Software License",
+    "Operating System :: MacOS :: MacOS X",
+    "Operating System :: Microsoft :: Windows",
+    "Operating System :: POSIX :: Linux",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Topic :: Scientific/Engineering",
+]
+dynamic = ["version"]
+
+[project.optional-dependencies]
+dev = [
+    "black",
+    "pre-commit",
+    "codespell",
+    "flake8",
+    "flake8-pyproject",
+]
+test = [
+    "pytest >=6.2.5",
+    "pytest-env>=0.6.2",
+    "pytest-cov>=2.12.1",
+    "codecov",
+    "fileformats-medimage-CHANGME-extras",
+]
+
+[project.urls]
+repository = "https://github.com/nipype/pydra-dcmstack"
+
+[tool.hatch.version]
+source = "vcs"
+raw-options = { root = "../.." }
+
+[tool.hatch.build.hooks.vcs]
+version-file = "fileformats/medimage_dcmstack/_version.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["fileformats"]
+
+[tool.black]
+target-version = ['py38']
+exclude = "fileformats/medimage_dcmstack/_version.py"
+
+[tool.codespell]
+ignore-words = ".codespell-ignorewords"
+
+[tool.flake8]
+doctests = true
+per-file-ignores = [
+    "__init__.py:F401"
+]
+max-line-length = 88
+select = "C,E,F,W,B,B950"
+extend-ignore = ['E203', 'E501', 'E129']
diff --git a/required-fileformats/diffusion_toolkit/LICENSE b/required-fileformats/diffusion_toolkit/LICENSE
new file mode 100644
index 00000000..e00bcb30
--- /dev/null
+++ b/required-fileformats/diffusion_toolkit/LICENSE
@@ -0,0 +1,13 @@
+   Copyright 2021 Nipype developers
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/required-fileformats/diffusion_toolkit/README.rst b/required-fileformats/diffusion_toolkit/README.rst
new file mode 100644
index 00000000..c0e5a0b0
--- /dev/null
+++ b/required-fileformats/diffusion_toolkit/README.rst
@@ -0,0 +1,39 @@
+How to customise this template
+==============================
+
+#. Rename the `related-packages/fileformats/diffusion_toolkit` directory to the name of the fileformats subpackage (e.g. `medimage_fsl`)
+#. Search and replace "diffusion_toolkit" with the name of the fileformats subpackage the extras are to be added
+#. Replace name + email placeholders in `pyproject.toml` for developers and maintainers
+#. Add the extension file-format classes
+#. Ensure that all the extension file-format classes are imported into the extras package root, i.e. `fileformats/diffusion_toolkit`
+#. Delete these instructions
+
+...
+
+FileFormats Extension - diffusion_toolkit
+====================================
+.. image:: https://github.com/nipype/pydra-diffusion_toolkit/actions/workflows/ci-cd.yml/badge.svg
+    :target: https://github.com/nipype/pydra-diffusion_toolkit/actions/workflows/ci-cd.yml
+
+This is the "diffusion_toolkit" extension module for the
+`fileformats <https://github.com/ArcanaFramework/fileformats-core>`__ package
+
+
+Quick Installation
+------------------
+
+This extension can be installed for Python 3 using *pip*::
+
+    $ pip3 install fileformats-diffusion_toolkit
+
+This will install the core package and any other dependencies
+
+License
+-------
+
+This work is licensed under a
+`Creative Commons Attribution 4.0 International License <http://creativecommons.org/licenses/by/4.0/>`_
+
+.. image:: https://i.creativecommons.org/l/by/4.0/88x31.png
+  :target: http://creativecommons.org/licenses/by/4.0/
+  :alt: Creative Commons Attribution 4.0 International License
diff --git a/required-fileformats/diffusion_toolkit/fileformats/medimage_diffusion_toolkit/__init__.py b/required-fileformats/diffusion_toolkit/fileformats/medimage_diffusion_toolkit/__init__.py
new file mode 100644
index 00000000..10bd9c0d
--- /dev/null
+++ b/required-fileformats/diffusion_toolkit/fileformats/medimage_diffusion_toolkit/__init__.py
@@ -0,0 +1 @@
+from fileformats.generic import File
\ No newline at end of file
diff --git a/required-fileformats/diffusion_toolkit/fileformats/medimage_diffusion_toolkit/_version.py b/required-fileformats/diffusion_toolkit/fileformats/medimage_diffusion_toolkit/_version.py
new file mode 100644
index 00000000..ecda9af7
--- /dev/null
+++ b/required-fileformats/diffusion_toolkit/fileformats/medimage_diffusion_toolkit/_version.py
@@ -0,0 +1,16 @@
+# file generated by setuptools_scm
+# don't change, don't track in version control
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple, Union
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '0.2.3.dev42+gb9e3ee9.d20240226'
+__version_tuple__ = version_tuple = (0, 2, 3, 'dev42', 'gb9e3ee9.d20240226')
diff --git a/required-fileformats/diffusion_toolkit/pyproject.toml b/required-fileformats/diffusion_toolkit/pyproject.toml
new file mode 100644
index 00000000..1422da4c
--- /dev/null
+++ b/required-fileformats/diffusion_toolkit/pyproject.toml
@@ -0,0 +1,84 @@
+[build-system]
+requires = ["hatchling", "hatch-vcs"]
+build-backend = "hatchling.build"
+
+[project]
+name = "fileformats-medimage-diffusion_toolkit"
+description = "Classes for representing different file formats in Python classes for use in type hinting in data workflows"
+readme = "README.rst"
+requires-python = ">=3.8"
+dependencies = [
+    "fileformats",
+    "fileformats-medimage"
+]
+license = {file = "LICENSE"}
+authors = [
+    {name = "Thomas G. Close", email = "tom.g.close@gmail.com"},
+]
+maintainers = [
+    {name = "Thomas G. Close", email = "tom.g.close@gmail.com"},
+]
+keywords = [
+    "file formats",
+    "data",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: Apache Software License",
+    "Operating System :: MacOS :: MacOS X",
+    "Operating System :: Microsoft :: Windows",
+    "Operating System :: POSIX :: Linux",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Topic :: Scientific/Engineering",
+]
+dynamic = ["version"]
+
+[project.optional-dependencies]
+dev = [
+    "black",
+    "pre-commit",
+    "codespell",
+    "flake8",
+    "flake8-pyproject",
+]
+test = [
+    "pytest >=6.2.5",
+    "pytest-env>=0.6.2",
+    "pytest-cov>=2.12.1",
+    "codecov",
+    "fileformats-medimage-CHANGME-extras",
+]
+
+[project.urls]
+repository = "https://github.com/nipype/pydra-diffusion_toolkit"
+
+[tool.hatch.version]
+source = "vcs"
+raw-options = { root = "../.." }
+
+[tool.hatch.build.hooks.vcs]
+version-file = "fileformats/medimage_diffusion_toolkit/_version.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["fileformats"]
+
+[tool.black]
+target-version = ['py38']
+exclude = "fileformats/medimage_diffusion_toolkit/_version.py"
+
+[tool.codespell]
+ignore-words = ".codespell-ignorewords"
+
+[tool.flake8]
+doctests = true
+per-file-ignores = [
+    "__init__.py:F401"
+]
+max-line-length = 88
+select = "C,E,F,W,B,B950"
+extend-ignore = ['E203', 'E501', 'E129']
diff --git a/required-fileformats/dipy/LICENSE b/required-fileformats/dipy/LICENSE
new file mode 100644
index 00000000..e00bcb30
--- /dev/null
+++ b/required-fileformats/dipy/LICENSE
@@ -0,0 +1,13 @@
+   Copyright 2021 Nipype developers
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/required-fileformats/dipy/README.rst b/required-fileformats/dipy/README.rst
new file mode 100644
index 00000000..d591f43b
--- /dev/null
+++ b/required-fileformats/dipy/README.rst
@@ -0,0 +1,39 @@
+How to customise this template
+==============================
+
+#. Rename the `related-packages/fileformats/dipy` directory to the name of the fileformats subpackage (e.g. `medimage_fsl`)
+#. Search and replace "dipy" with the name of the fileformats subpackage the extras are to be added
+#. Replace name + email placeholders in `pyproject.toml` for developers and maintainers
+#. Add the extension file-format classes
+#. Ensure that all the extension file-format classes are imported into the extras package root, i.e. `fileformats/dipy`
+#. Delete these instructions
+
+...
+
+FileFormats Extension - dipy
+====================================
+.. image:: https://github.com/nipype/pydra-dipy/actions/workflows/ci-cd.yml/badge.svg
+    :target: https://github.com/nipype/pydra-dipy/actions/workflows/ci-cd.yml
+
+This is the "dipy" extension module for the
+`fileformats <https://github.com/ArcanaFramework/fileformats-core>`__ package
+
+
+Quick Installation
+------------------
+
+This extension can be installed for Python 3 using *pip*::
+
+    $ pip3 install fileformats-dipy
+
+This will install the core package and any other dependencies
+
+License
+-------
+
+This work is licensed under a
+`Creative Commons Attribution 4.0 International License <http://creativecommons.org/licenses/by/4.0/>`_
+
+.. image:: https://i.creativecommons.org/l/by/4.0/88x31.png
+  :target: http://creativecommons.org/licenses/by/4.0/
+  :alt: Creative Commons Attribution 4.0 International License
diff --git a/required-fileformats/dipy/fileformats/medimage_dipy/__init__.py b/required-fileformats/dipy/fileformats/medimage_dipy/__init__.py
new file mode 100644
index 00000000..10bd9c0d
--- /dev/null
+++ b/required-fileformats/dipy/fileformats/medimage_dipy/__init__.py
@@ -0,0 +1 @@
+from fileformats.generic import File
\ No newline at end of file
diff --git a/required-fileformats/dipy/fileformats/medimage_dipy/_version.py b/required-fileformats/dipy/fileformats/medimage_dipy/_version.py
new file mode 100644
index 00000000..ecda9af7
--- /dev/null
+++ b/required-fileformats/dipy/fileformats/medimage_dipy/_version.py
@@ -0,0 +1,16 @@
+# file generated by setuptools_scm
+# don't change, don't track in version control
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple, Union
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '0.2.3.dev42+gb9e3ee9.d20240226'
+__version_tuple__ = version_tuple = (0, 2, 3, 'dev42', 'gb9e3ee9.d20240226')
diff --git a/required-fileformats/dipy/pyproject.toml b/required-fileformats/dipy/pyproject.toml
new file mode 100644
index 00000000..f4415d7c
--- /dev/null
+++ b/required-fileformats/dipy/pyproject.toml
@@ -0,0 +1,84 @@
+[build-system]
+requires = ["hatchling", "hatch-vcs"]
+build-backend = "hatchling.build"
+
+[project]
+name = "fileformats-medimage-dipy"
+description = "Classes for representing different file formats in Python classes for use in type hinting in data workflows"
+readme = "README.rst"
+requires-python = ">=3.8"
+dependencies = [
+    "fileformats",
+    "fileformats-medimage"
+]
+license = {file = "LICENSE"}
+authors = [
+    {name = "Thomas G. Close", email = "tom.g.close@gmail.com"},
+]
+maintainers = [
+    {name = "Thomas G. Close", email = "tom.g.close@gmail.com"},
+]
+keywords = [
+    "file formats",
+    "data",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: Apache Software License",
+    "Operating System :: MacOS :: MacOS X",
+    "Operating System :: Microsoft :: Windows",
+    "Operating System :: POSIX :: Linux",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Topic :: Scientific/Engineering",
+]
+dynamic = ["version"]
+
+[project.optional-dependencies]
+dev = [
+    "black",
+    "pre-commit",
+    "codespell",
+    "flake8",
+    "flake8-pyproject",
+]
+test = [
+    "pytest >=6.2.5",
+    "pytest-env>=0.6.2",
+    "pytest-cov>=2.12.1",
+    "codecov",
+    "fileformats-medimage-CHANGME-extras",
+]
+
+[project.urls]
+repository = "https://github.com/nipype/pydra-dipy"
+
+[tool.hatch.version]
+source = "vcs"
+raw-options = { root = "../.." }
+
+[tool.hatch.build.hooks.vcs]
+version-file = "fileformats/medimage_dipy/_version.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["fileformats"]
+
+[tool.black]
+target-version = ['py38']
+exclude = "fileformats/medimage_dipy/_version.py"
+
+[tool.codespell]
+ignore-words = ".codespell-ignorewords"
+
+[tool.flake8]
+doctests = true
+per-file-ignores = [
+    "__init__.py:F401"
+]
+max-line-length = 88
+select = "C,E,F,W,B,B950"
+extend-ignore = ['E203', 'E501', 'E129']
diff --git a/required-fileformats/dtitk/LICENSE b/required-fileformats/dtitk/LICENSE
new file mode 100644
index 00000000..e00bcb30
--- /dev/null
+++ b/required-fileformats/dtitk/LICENSE
@@ -0,0 +1,13 @@
+   Copyright 2021 Nipype developers
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/required-fileformats/dtitk/README.rst b/required-fileformats/dtitk/README.rst
new file mode 100644
index 00000000..775cb865
--- /dev/null
+++ b/required-fileformats/dtitk/README.rst
@@ -0,0 +1,39 @@
+How to customise this template
+==============================
+
+#. Rename the `related-packages/fileformats/dtitk` directory to the name of the fileformats subpackage (e.g. `medimage_fsl`)
+#. Search and replace "dtitk" with the name of the fileformats subpackage the extras are to be added
+#. Replace name + email placeholders in `pyproject.toml` for developers and maintainers
+#. Add the extension file-format classes
+#. Ensure that all the extension file-format classes are imported into the extras package root, i.e. `fileformats/dtitk`
+#. Delete these instructions
+
+...
+
+FileFormats Extension - dtitk
+====================================
+.. image:: https://github.com/nipype/pydra-dtitk/actions/workflows/ci-cd.yml/badge.svg
+    :target: https://github.com/nipype/pydra-dtitk/actions/workflows/ci-cd.yml
+
+This is the "dtitk" extension module for the
+`fileformats <https://github.com/ArcanaFramework/fileformats-core>`__ package
+
+
+Quick Installation
+------------------
+
+This extension can be installed for Python 3 using *pip*::
+
+    $ pip3 install fileformats-dtitk
+
+This will install the core package and any other dependencies
+
+License
+-------
+
+This work is licensed under a
+`Creative Commons Attribution 4.0 International License <http://creativecommons.org/licenses/by/4.0/>`_
+
+.. image:: https://i.creativecommons.org/l/by/4.0/88x31.png
+  :target: http://creativecommons.org/licenses/by/4.0/
+  :alt: Creative Commons Attribution 4.0 International License
diff --git a/required-fileformats/dtitk/fileformats/medimage_dtitk/__init__.py b/required-fileformats/dtitk/fileformats/medimage_dtitk/__init__.py
new file mode 100644
index 00000000..2af5b96b
--- /dev/null
+++ b/required-fileformats/dtitk/fileformats/medimage_dtitk/__init__.py
@@ -0,0 +1,5 @@
+from fileformats.generic import File
+
+class Aff(File):
+    ext = ".aff"
+    binary = True
diff --git a/required-fileformats/dtitk/fileformats/medimage_dtitk/_version.py b/required-fileformats/dtitk/fileformats/medimage_dtitk/_version.py
new file mode 100644
index 00000000..ecda9af7
--- /dev/null
+++ b/required-fileformats/dtitk/fileformats/medimage_dtitk/_version.py
@@ -0,0 +1,16 @@
+# file generated by setuptools_scm
+# don't change, don't track in version control
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple, Union
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '0.2.3.dev42+gb9e3ee9.d20240226'
+__version_tuple__ = version_tuple = (0, 2, 3, 'dev42', 'gb9e3ee9.d20240226')
diff --git a/required-fileformats/dtitk/pyproject.toml b/required-fileformats/dtitk/pyproject.toml
new file mode 100644
index 00000000..3748ff18
--- /dev/null
+++ b/required-fileformats/dtitk/pyproject.toml
@@ -0,0 +1,84 @@
+[build-system]
+requires = ["hatchling", "hatch-vcs"]
+build-backend = "hatchling.build"
+
+[project]
+name = "fileformats-medimage-dtitk"
+description = "Classes for representing different file formats in Python classes for use in type hinting in data workflows"
+readme = "README.rst"
+requires-python = ">=3.8"
+dependencies = [
+    "fileformats",
+    "fileformats-medimage"
+]
+license = {file = "LICENSE"}
+authors = [
+    {name = "Thomas G. Close", email = "tom.g.close@gmail.com"},
+]
+maintainers = [
+    {name = "Thomas G. Close", email = "tom.g.close@gmail.com"},
+]
+keywords = [
+    "file formats",
+    "data",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: Apache Software License",
+    "Operating System :: MacOS :: MacOS X",
+    "Operating System :: Microsoft :: Windows",
+    "Operating System :: POSIX :: Linux",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Topic :: Scientific/Engineering",
+]
+dynamic = ["version"]
+
+[project.optional-dependencies]
+dev = [
+    "black",
+    "pre-commit",
+    "codespell",
+    "flake8",
+    "flake8-pyproject",
+]
+test = [
+    "pytest >=6.2.5",
+    "pytest-env>=0.6.2",
+    "pytest-cov>=2.12.1",
+    "codecov",
+    "fileformats-medimage-CHANGME-extras",
+]
+
+[project.urls]
+repository = "https://github.com/nipype/pydra-dtitk"
+
+[tool.hatch.version]
+source = "vcs"
+raw-options = { root = "../.." }
+
+[tool.hatch.build.hooks.vcs]
+version-file = "fileformats/medimage_dtitk/_version.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["fileformats"]
+
+[tool.black]
+target-version = ['py38']
+exclude = "fileformats/medimage_dtitk/_version.py"
+
+[tool.codespell]
+ignore-words = ".codespell-ignorewords"
+
+[tool.flake8]
+doctests = true
+per-file-ignores = [
+    "__init__.py:F401"
+]
+max-line-length = 88
+select = "C,E,F,W,B,B950"
+extend-ignore = ['E203', 'E501', 'E129']
diff --git a/required-fileformats/dynamic_slicer/LICENSE b/required-fileformats/dynamic_slicer/LICENSE
new file mode 100644
index 00000000..e00bcb30
--- /dev/null
+++ b/required-fileformats/dynamic_slicer/LICENSE
@@ -0,0 +1,13 @@
+   Copyright 2021 Nipype developers
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/required-fileformats/dynamic_slicer/README.rst b/required-fileformats/dynamic_slicer/README.rst
new file mode 100644
index 00000000..24d793ac
--- /dev/null
+++ b/required-fileformats/dynamic_slicer/README.rst
@@ -0,0 +1,39 @@
+How to customise this template
+==============================
+
+#. Rename the `related-packages/fileformats/dynamic_slicer` directory to the name of the fileformats subpackage (e.g. `medimage_fsl`)
+#. Search and replace "dynamic_slicer" with the name of the fileformats subpackage the extras are to be added
+#. Replace name + email placeholders in `pyproject.toml` for developers and maintainers
+#. Add the extension file-format classes
+#. Ensure that all the extension file-format classes are imported into the extras package root, i.e. `fileformats/dynamic_slicer`
+#. Delete these instructions
+
+...
+
+FileFormats Extension - dynamic_slicer
+====================================
+.. image:: https://github.com/nipype/pydra-dynamic_slicer/actions/workflows/ci-cd.yml/badge.svg
+    :target: https://github.com/nipype/pydra-dynamic_slicer/actions/workflows/ci-cd.yml
+
+This is the "dynamic_slicer" extension module for the
+`fileformats <https://github.com/ArcanaFramework/fileformats-core>`__ package
+
+
+Quick Installation
+------------------
+
+This extension can be installed for Python 3 using *pip*::
+
+    $ pip3 install fileformats-dynamic_slicer
+
+This will install the core package and any other dependencies
+
+License
+-------
+
+This work is licensed under a
+`Creative Commons Attribution 4.0 International License <http://creativecommons.org/licenses/by/4.0/>`_
+
+.. image:: https://i.creativecommons.org/l/by/4.0/88x31.png
+  :target: http://creativecommons.org/licenses/by/4.0/
+  :alt: Creative Commons Attribution 4.0 International License
diff --git a/required-fileformats/dynamic_slicer/fileformats/medimage_dynamic_slicer/__init__.py b/required-fileformats/dynamic_slicer/fileformats/medimage_dynamic_slicer/__init__.py
new file mode 100644
index 00000000..10bd9c0d
--- /dev/null
+++ b/required-fileformats/dynamic_slicer/fileformats/medimage_dynamic_slicer/__init__.py
@@ -0,0 +1 @@
+from fileformats.generic import File
\ No newline at end of file
diff --git a/required-fileformats/dynamic_slicer/fileformats/medimage_dynamic_slicer/_version.py b/required-fileformats/dynamic_slicer/fileformats/medimage_dynamic_slicer/_version.py
new file mode 100644
index 00000000..ecda9af7
--- /dev/null
+++ b/required-fileformats/dynamic_slicer/fileformats/medimage_dynamic_slicer/_version.py
@@ -0,0 +1,16 @@
+# file generated by setuptools_scm
+# don't change, don't track in version control
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple, Union
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '0.2.3.dev42+gb9e3ee9.d20240226'
+__version_tuple__ = version_tuple = (0, 2, 3, 'dev42', 'gb9e3ee9.d20240226')
diff --git a/required-fileformats/dynamic_slicer/pyproject.toml b/required-fileformats/dynamic_slicer/pyproject.toml
new file mode 100644
index 00000000..f070ca42
--- /dev/null
+++ b/required-fileformats/dynamic_slicer/pyproject.toml
@@ -0,0 +1,84 @@
+[build-system]
+requires = ["hatchling", "hatch-vcs"]
+build-backend = "hatchling.build"
+
+[project]
+name = "fileformats-medimage-dynamic_slicer"
+description = "Classes for representing different file formats in Python classes for use in type hinting in data workflows"
+readme = "README.rst"
+requires-python = ">=3.8"
+dependencies = [
+    "fileformats",
+    "fileformats-medimage"
+]
+license = {file = "LICENSE"}
+authors = [
+    {name = "Thomas G. Close", email = "tom.g.close@gmail.com"},
+]
+maintainers = [
+    {name = "Thomas G. Close", email = "tom.g.close@gmail.com"},
+]
+keywords = [
+    "file formats",
+    "data",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: Apache Software License",
+    "Operating System :: MacOS :: MacOS X",
+    "Operating System :: Microsoft :: Windows",
+    "Operating System :: POSIX :: Linux",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Topic :: Scientific/Engineering",
+]
+dynamic = ["version"]
+
+[project.optional-dependencies]
+dev = [
+    "black",
+    "pre-commit",
+    "codespell",
+    "flake8",
+    "flake8-pyproject",
+]
+test = [
+    "pytest >=6.2.5",
+    "pytest-env>=0.6.2",
+    "pytest-cov>=2.12.1",
+    "codecov",
+    "fileformats-medimage-CHANGME-extras",
+]
+
+[project.urls]
+repository = "https://github.com/nipype/pydra-dynamic_slicer"
+
+[tool.hatch.version]
+source = "vcs"
+raw-options = { root = "../.." }
+
+[tool.hatch.build.hooks.vcs]
+version-file = "fileformats/medimage_dynamic_slicer/_version.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["fileformats"]
+
+[tool.black]
+target-version = ['py38']
+exclude = "fileformats/medimage_dynamic_slicer/_version.py"
+
+[tool.codespell]
+ignore-words = ".codespell-ignorewords"
+
+[tool.flake8]
+doctests = true
+per-file-ignores = [
+    "__init__.py:F401"
+]
+max-line-length = 88
+select = "C,E,F,W,B,B950"
+extend-ignore = ['E203', 'E501', 'E129']
diff --git a/required-fileformats/elastix/LICENSE b/required-fileformats/elastix/LICENSE
new file mode 100644
index 00000000..e00bcb30
--- /dev/null
+++ b/required-fileformats/elastix/LICENSE
@@ -0,0 +1,13 @@
+   Copyright 2021 Nipype developers
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/required-fileformats/elastix/README.rst b/required-fileformats/elastix/README.rst
new file mode 100644
index 00000000..e7c0d5e9
--- /dev/null
+++ b/required-fileformats/elastix/README.rst
@@ -0,0 +1,39 @@
+How to customise this template
+==============================
+
+#. Rename the `related-packages/fileformats/elastix` directory to the name of the fileformats subpackage (e.g. `medimage_fsl`)
+#. Search and replace "elastix" with the name of the fileformats subpackage the extras are to be added
+#. Replace name + email placeholders in `pyproject.toml` for developers and maintainers
+#. Add the extension file-format classes
+#. Ensure that all the extension file-format classes are imported into the extras package root, i.e. `fileformats/elastix`
+#. Delete these instructions
+
+...
+
+FileFormats Extension - elastix
+====================================
+.. image:: https://github.com/nipype/pydra-elastix/actions/workflows/ci-cd.yml/badge.svg
+    :target: https://github.com/nipype/pydra-elastix/actions/workflows/ci-cd.yml
+
+This is the "elastix" extension module for the
+`fileformats <https://github.com/ArcanaFramework/fileformats-core>`__ package
+
+
+Quick Installation
+------------------
+
+This extension can be installed for Python 3 using *pip*::
+
+    $ pip3 install fileformats-elastix
+
+This will install the core package and any other dependencies
+
+License
+-------
+
+This work is licensed under a
+`Creative Commons Attribution 4.0 International License <http://creativecommons.org/licenses/by/4.0/>`_
+
+.. image:: https://i.creativecommons.org/l/by/4.0/88x31.png
+  :target: http://creativecommons.org/licenses/by/4.0/
+  :alt: Creative Commons Attribution 4.0 International License
diff --git a/required-fileformats/elastix/fileformats/medimage_elastix/__init__.py b/required-fileformats/elastix/fileformats/medimage_elastix/__init__.py
new file mode 100644
index 00000000..0aac92ed
--- /dev/null
+++ b/required-fileformats/elastix/fileformats/medimage_elastix/__init__.py
@@ -0,0 +1,5 @@
+from fileformats.generic import File
+
+class Vtk(File):
+    ext = ".vtk"
+    binary = True
diff --git a/required-fileformats/elastix/fileformats/medimage_elastix/_version.py b/required-fileformats/elastix/fileformats/medimage_elastix/_version.py
new file mode 100644
index 00000000..ecda9af7
--- /dev/null
+++ b/required-fileformats/elastix/fileformats/medimage_elastix/_version.py
@@ -0,0 +1,16 @@
+# file generated by setuptools_scm
+# don't change, don't track in version control
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple, Union
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '0.2.3.dev42+gb9e3ee9.d20240226'
+__version_tuple__ = version_tuple = (0, 2, 3, 'dev42', 'gb9e3ee9.d20240226')
diff --git a/required-fileformats/elastix/pyproject.toml b/required-fileformats/elastix/pyproject.toml
new file mode 100644
index 00000000..bcd3bf2d
--- /dev/null
+++ b/required-fileformats/elastix/pyproject.toml
@@ -0,0 +1,84 @@
+[build-system]
+requires = ["hatchling", "hatch-vcs"]
+build-backend = "hatchling.build"
+
+[project]
+name = "fileformats-medimage-elastix"
+description = "Classes for representing different file formats in Python classes for use in type hinting in data workflows"
+readme = "README.rst"
+requires-python = ">=3.8"
+dependencies = [
+    "fileformats",
+    "fileformats-medimage"
+]
+license = {file = "LICENSE"}
+authors = [
+    {name = "Thomas G. Close", email = "tom.g.close@gmail.com"},
+]
+maintainers = [
+    {name = "Thomas G. Close", email = "tom.g.close@gmail.com"},
+]
+keywords = [
+    "file formats",
+    "data",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: Apache Software License",
+    "Operating System :: MacOS :: MacOS X",
+    "Operating System :: Microsoft :: Windows",
+    "Operating System :: POSIX :: Linux",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Topic :: Scientific/Engineering",
+]
+dynamic = ["version"]
+
+[project.optional-dependencies]
+dev = [
+    "black",
+    "pre-commit",
+    "codespell",
+    "flake8",
+    "flake8-pyproject",
+]
+test = [
+    "pytest >=6.2.5",
+    "pytest-env>=0.6.2",
+    "pytest-cov>=2.12.1",
+    "codecov",
+    "fileformats-medimage-CHANGME-extras",
+]
+
+[project.urls]
+repository = "https://github.com/nipype/pydra-elastix"
+
+[tool.hatch.version]
+source = "vcs"
+raw-options = { root = "../.." }
+
+[tool.hatch.build.hooks.vcs]
+version-file = "fileformats/medimage_elastix/_version.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["fileformats"]
+
+[tool.black]
+target-version = ['py38']
+exclude = "fileformats/medimage_elastix/_version.py"
+
+[tool.codespell]
+ignore-words = ".codespell-ignorewords"
+
+[tool.flake8]
+doctests = true
+per-file-ignores = [
+    "__init__.py:F401"
+]
+max-line-length = 88
+select = "C,E,F,W,B,B950"
+extend-ignore = ['E203', 'E501', 'E129']
diff --git a/required-fileformats/freesurfer/LICENSE b/required-fileformats/freesurfer/LICENSE
new file mode 100644
index 00000000..e00bcb30
--- /dev/null
+++ b/required-fileformats/freesurfer/LICENSE
@@ -0,0 +1,13 @@
+   Copyright 2021 Nipype developers
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/required-fileformats/freesurfer/README.rst b/required-fileformats/freesurfer/README.rst
new file mode 100644
index 00000000..357c8b1e
--- /dev/null
+++ b/required-fileformats/freesurfer/README.rst
@@ -0,0 +1,39 @@
+How to customise this template
+==============================
+
+#. Rename the `related-packages/fileformats/freesurfer` directory to the name of the fileformats subpackage (e.g. `medimage_fsl`)
+#. Search and replace "freesurfer" with the name of the fileformats subpackage the extras are to be added
+#. Replace name + email placeholders in `pyproject.toml` for developers and maintainers
+#. Add the extension file-format classes
+#. Ensure that all the extension file-format classes are imported into the extras package root, i.e. `fileformats/freesurfer`
+#. Delete these instructions
+
+...
+
+FileFormats Extension - freesurfer
+====================================
+.. image:: https://github.com/nipype/pydra-freesurfer/actions/workflows/ci-cd.yml/badge.svg
+    :target: https://github.com/nipype/pydra-freesurfer/actions/workflows/ci-cd.yml
+
+This is the "freesurfer" extension module for the
+`fileformats <https://github.com/ArcanaFramework/fileformats-core>`__ package
+
+
+Quick Installation
+------------------
+
+This extension can be installed for Python 3 using *pip*::
+
+    $ pip3 install fileformats-freesurfer
+
+This will install the core package and any other dependencies
+
+License
+-------
+
+This work is licensed under a
+`Creative Commons Attribution 4.0 International License <http://creativecommons.org/licenses/by/4.0/>`_
+
+.. image:: https://i.creativecommons.org/l/by/4.0/88x31.png
+  :target: http://creativecommons.org/licenses/by/4.0/
+  :alt: Creative Commons Attribution 4.0 International License
diff --git a/required-fileformats/freesurfer/fileformats/medimage_freesurfer/__init__.py b/required-fileformats/freesurfer/fileformats/medimage_freesurfer/__init__.py
new file mode 100644
index 00000000..6919add5
--- /dev/null
+++ b/required-fileformats/freesurfer/fileformats/medimage_freesurfer/__init__.py
@@ -0,0 +1,85 @@
+from fileformats.generic import File
+
+class M3z(File):
+    ext = ".m3z"
+    binary = True
+
+
+class Ctab(File):
+    ext = ".ctab"
+    binary = True
+
+
+class Nofix(File):
+    ext = ".nofix"
+    binary = True
+
+
+class Stats(File):
+    ext = ".stats"
+    binary = True
+
+
+class Thickness(File):
+    ext = ".thickness"
+    binary = True
+
+
+class Out(File):
+    ext = ".out"
+    binary = True
+
+
+class Label(File):
+    ext = ".label"
+    binary = True
+
+
+class Area(File):
+    ext = ".area"
+    binary = True
+
+
+class White(File):
+    ext = ".white"
+    binary = True
+
+
+class Orig(File):
+    ext = ".orig"
+    binary = True
+
+
+class Inflated(File):
+    ext = ".inflated"
+    binary = True
+
+
+class Lta(File):
+    ext = ".lta"
+    binary = True
+
+
+class Annot(File):
+    ext = ".annot"
+    binary = True
+
+
+class Pial(File):
+    ext = ".pial"
+    binary = True
+
+
+class Xfm(File):
+    ext = ".xfm"
+    binary = True
+
+
+class Reg(File):
+    ext = ".reg"
+    binary = True
+
+
+class Avg_curv(File):
+    ext = ".avg_curv"
+    binary = True
diff --git a/required-fileformats/freesurfer/fileformats/medimage_freesurfer/_version.py b/required-fileformats/freesurfer/fileformats/medimage_freesurfer/_version.py
new file mode 100644
index 00000000..ecda9af7
--- /dev/null
+++ b/required-fileformats/freesurfer/fileformats/medimage_freesurfer/_version.py
@@ -0,0 +1,16 @@
+# file generated by setuptools_scm
+# don't change, don't track in version control
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple, Union
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '0.2.3.dev42+gb9e3ee9.d20240226'
+__version_tuple__ = version_tuple = (0, 2, 3, 'dev42', 'gb9e3ee9.d20240226')
diff --git a/required-fileformats/freesurfer/pyproject.toml b/required-fileformats/freesurfer/pyproject.toml
new file mode 100644
index 00000000..6e30941e
--- /dev/null
+++ b/required-fileformats/freesurfer/pyproject.toml
@@ -0,0 +1,84 @@
+[build-system]
+requires = ["hatchling", "hatch-vcs"]
+build-backend = "hatchling.build"
+
+[project]
+name = "fileformats-medimage-freesurfer"
+description = "Classes for representing different file formats in Python classes for use in type hinting in data workflows"
+readme = "README.rst"
+requires-python = ">=3.8"
+dependencies = [
+    "fileformats",
+    "fileformats-medimage"
+]
+license = {file = "LICENSE"}
+authors = [
+    {name = "Thomas G. Close", email = "tom.g.close@gmail.com"},
+]
+maintainers = [
+    {name = "Thomas G. Close", email = "tom.g.close@gmail.com"},
+]
+keywords = [
+    "file formats",
+    "data",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: Apache Software License",
+    "Operating System :: MacOS :: MacOS X",
+    "Operating System :: Microsoft :: Windows",
+    "Operating System :: POSIX :: Linux",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Topic :: Scientific/Engineering",
+]
+dynamic = ["version"]
+
+[project.optional-dependencies]
+dev = [
+    "black",
+    "pre-commit",
+    "codespell",
+    "flake8",
+    "flake8-pyproject",
+]
+test = [
+    "pytest >=6.2.5",
+    "pytest-env>=0.6.2",
+    "pytest-cov>=2.12.1",
+    "codecov",
+    "fileformats-medimage-CHANGME-extras",
+]
+
+[project.urls]
+repository = "https://github.com/nipype/pydra-freesurfer"
+
+[tool.hatch.version]
+source = "vcs"
+raw-options = { root = "../.." }
+
+[tool.hatch.build.hooks.vcs]
+version-file = "fileformats/medimage_freesurfer/_version.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["fileformats"]
+
+[tool.black]
+target-version = ['py38']
+exclude = "fileformats/medimage_freesurfer/_version.py"
+
+[tool.codespell]
+ignore-words = ".codespell-ignorewords"
+
+[tool.flake8]
+doctests = true
+per-file-ignores = [
+    "__init__.py:F401"
+]
+max-line-length = 88
+select = "C,E,F,W,B,B950"
+extend-ignore = ['E203', 'E501', 'E129']
diff --git a/required-fileformats/fsl/LICENSE b/required-fileformats/fsl/LICENSE
new file mode 100644
index 00000000..e00bcb30
--- /dev/null
+++ b/required-fileformats/fsl/LICENSE
@@ -0,0 +1,13 @@
+   Copyright 2021 Nipype developers
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/required-fileformats/fsl/README.rst b/required-fileformats/fsl/README.rst
new file mode 100644
index 00000000..99ef16e0
--- /dev/null
+++ b/required-fileformats/fsl/README.rst
@@ -0,0 +1,39 @@
+How to customise this template
+==============================
+
+#. Rename the `related-packages/fileformats/fsl` directory to the name of the fileformats subpackage (e.g. `medimage_fsl`)
+#. Search and replace "fsl" with the name of the fileformats subpackage the extras are to be added
+#. Replace name + email placeholders in `pyproject.toml` for developers and maintainers
+#. Add the extension file-format classes
+#. Ensure that all the extension file-format classes are imported into the extras package root, i.e. `fileformats/fsl`
+#. Delete these instructions
+
+...
+
+FileFormats Extension - fsl
+====================================
+.. image:: https://github.com/nipype/pydra-fsl/actions/workflows/ci-cd.yml/badge.svg
+    :target: https://github.com/nipype/pydra-fsl/actions/workflows/ci-cd.yml
+
+This is the "fsl" extension module for the
+`fileformats <https://github.com/ArcanaFramework/fileformats-core>`__ package
+
+
+Quick Installation
+------------------
+
+This extension can be installed for Python 3 using *pip*::
+
+    $ pip3 install fileformats-fsl
+
+This will install the core package and any other dependencies
+
+License
+-------
+
+This work is licensed under a
+`Creative Commons Attribution 4.0 International License <http://creativecommons.org/licenses/by/4.0/>`_
+
+.. image:: https://i.creativecommons.org/l/by/4.0/88x31.png
+  :target: http://creativecommons.org/licenses/by/4.0/
+  :alt: Creative Commons Attribution 4.0 International License
diff --git a/required-fileformats/fsl/fileformats/medimage_fsl/__init__.py b/required-fileformats/fsl/fileformats/medimage_fsl/__init__.py
new file mode 100644
index 00000000..d6ea01b2
--- /dev/null
+++ b/required-fileformats/fsl/fileformats/medimage_fsl/__init__.py
@@ -0,0 +1,5 @@
+from fileformats.generic import File
+
+class Con(File):
+    ext = ".con"
+    binary = True
diff --git a/required-fileformats/fsl/fileformats/medimage_fsl/_version.py b/required-fileformats/fsl/fileformats/medimage_fsl/_version.py
new file mode 100644
index 00000000..ecda9af7
--- /dev/null
+++ b/required-fileformats/fsl/fileformats/medimage_fsl/_version.py
@@ -0,0 +1,16 @@
+# file generated by setuptools_scm
+# don't change, don't track in version control
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple, Union
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '0.2.3.dev42+gb9e3ee9.d20240226'
+__version_tuple__ = version_tuple = (0, 2, 3, 'dev42', 'gb9e3ee9.d20240226')
diff --git a/required-fileformats/fsl/pyproject.toml b/required-fileformats/fsl/pyproject.toml
new file mode 100644
index 00000000..f0b3af08
--- /dev/null
+++ b/required-fileformats/fsl/pyproject.toml
@@ -0,0 +1,84 @@
+[build-system]
+requires = ["hatchling", "hatch-vcs"]
+build-backend = "hatchling.build"
+
+[project]
+name = "fileformats-medimage-fsl"
+description = "Classes for representing different file formats in Python classes for use in type hinting in data workflows"
+readme = "README.rst"
+requires-python = ">=3.8"
+dependencies = [
+    "fileformats",
+    "fileformats-medimage"
+]
+license = {file = "LICENSE"}
+authors = [
+    {name = "Thomas G. Close", email = "tom.g.close@gmail.com"},
+]
+maintainers = [
+    {name = "Thomas G. Close", email = "tom.g.close@gmail.com"},
+]
+keywords = [
+    "file formats",
+    "data",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: Apache Software License",
+    "Operating System :: MacOS :: MacOS X",
+    "Operating System :: Microsoft :: Windows",
+    "Operating System :: POSIX :: Linux",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Topic :: Scientific/Engineering",
+]
+dynamic = ["version"]
+
+[project.optional-dependencies]
+dev = [
+    "black",
+    "pre-commit",
+    "codespell",
+    "flake8",
+    "flake8-pyproject",
+]
+test = [
+    "pytest >=6.2.5",
+    "pytest-env>=0.6.2",
+    "pytest-cov>=2.12.1",
+    "codecov",
+    "fileformats-medimage-CHANGME-extras",
+]
+
+[project.urls]
+repository = "https://github.com/nipype/pydra-fsl"
+
+[tool.hatch.version]
+source = "vcs"
+raw-options = { root = "../.." }
+
+[tool.hatch.build.hooks.vcs]
+version-file = "fileformats/medimage_fsl/_version.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["fileformats"]
+
+[tool.black]
+target-version = ['py38']
+exclude = "fileformats/medimage_fsl/_version.py"
+
+[tool.codespell]
+ignore-words = ".codespell-ignorewords"
+
+[tool.flake8]
+doctests = true
+per-file-ignores = [
+    "__init__.py:F401"
+]
+max-line-length = 88
+select = "C,E,F,W,B,B950"
+extend-ignore = ['E203', 'E501', 'E129']
diff --git a/required-fileformats/meshfix/LICENSE b/required-fileformats/meshfix/LICENSE
new file mode 100644
index 00000000..e00bcb30
--- /dev/null
+++ b/required-fileformats/meshfix/LICENSE
@@ -0,0 +1,13 @@
+   Copyright 2021 Nipype developers
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/required-fileformats/meshfix/README.rst b/required-fileformats/meshfix/README.rst
new file mode 100644
index 00000000..efca1f98
--- /dev/null
+++ b/required-fileformats/meshfix/README.rst
@@ -0,0 +1,39 @@
+How to customise this template
+==============================
+
+#. Rename the `related-packages/fileformats/meshfix` directory to the name of the fileformats subpackage (e.g. `medimage_fsl`)
+#. Search and replace "meshfix" with the name of the fileformats subpackage the extras are to be added
+#. Replace name + email placeholders in `pyproject.toml` for developers and maintainers
+#. Add the extension file-format classes
+#. Ensure that all the extension file-format classes are imported into the extras package root, i.e. `fileformats/meshfix`
+#. Delete these instructions
+
+...
+
+FileFormats Extension - meshfix
+====================================
+.. image:: https://github.com/nipype/pydra-meshfix/actions/workflows/ci-cd.yml/badge.svg
+    :target: https://github.com/nipype/pydra-meshfix/actions/workflows/ci-cd.yml
+
+This is the "meshfix" extension module for the
+`fileformats <https://github.com/ArcanaFramework/fileformats-core>`__ package
+
+
+Quick Installation
+------------------
+
+This extension can be installed for Python 3 using *pip*::
+
+    $ pip3 install fileformats-meshfix
+
+This will install the core package and any other dependencies
+
+License
+-------
+
+This work is licensed under a
+`Creative Commons Attribution 4.0 International License <http://creativecommons.org/licenses/by/4.0/>`_
+
+.. image:: https://i.creativecommons.org/l/by/4.0/88x31.png
+  :target: http://creativecommons.org/licenses/by/4.0/
+  :alt: Creative Commons Attribution 4.0 International License
diff --git a/required-fileformats/meshfix/fileformats/medimage_meshfix/__init__.py b/required-fileformats/meshfix/fileformats/medimage_meshfix/__init__.py
new file mode 100644
index 00000000..10bd9c0d
--- /dev/null
+++ b/required-fileformats/meshfix/fileformats/medimage_meshfix/__init__.py
@@ -0,0 +1 @@
+from fileformats.generic import File
\ No newline at end of file
diff --git a/required-fileformats/meshfix/fileformats/medimage_meshfix/_version.py b/required-fileformats/meshfix/fileformats/medimage_meshfix/_version.py
new file mode 100644
index 00000000..ecda9af7
--- /dev/null
+++ b/required-fileformats/meshfix/fileformats/medimage_meshfix/_version.py
@@ -0,0 +1,16 @@
+# file generated by setuptools_scm
+# don't change, don't track in version control
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple, Union
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '0.2.3.dev42+gb9e3ee9.d20240226'
+__version_tuple__ = version_tuple = (0, 2, 3, 'dev42', 'gb9e3ee9.d20240226')
diff --git a/required-fileformats/meshfix/pyproject.toml b/required-fileformats/meshfix/pyproject.toml
new file mode 100644
index 00000000..0d748ac1
--- /dev/null
+++ b/required-fileformats/meshfix/pyproject.toml
@@ -0,0 +1,84 @@
+[build-system]
+requires = ["hatchling", "hatch-vcs"]
+build-backend = "hatchling.build"
+
+[project]
+name = "fileformats-medimage-meshfix"
+description = "Classes for representing different file formats in Python classes for use in type hinting in data workflows"
+readme = "README.rst"
+requires-python = ">=3.8"
+dependencies = [
+    "fileformats",
+    "fileformats-medimage"
+]
+license = {file = "LICENSE"}
+authors = [
+    {name = "Thomas G. Close", email = "tom.g.close@gmail.com"},
+]
+maintainers = [
+    {name = "Thomas G. Close", email = "tom.g.close@gmail.com"},
+]
+keywords = [
+    "file formats",
+    "data",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: Apache Software License",
+    "Operating System :: MacOS :: MacOS X",
+    "Operating System :: Microsoft :: Windows",
+    "Operating System :: POSIX :: Linux",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Topic :: Scientific/Engineering",
+]
+dynamic = ["version"]
+
+[project.optional-dependencies]
+dev = [
+    "black",
+    "pre-commit",
+    "codespell",
+    "flake8",
+    "flake8-pyproject",
+]
+test = [
+    "pytest >=6.2.5",
+    "pytest-env>=0.6.2",
+    "pytest-cov>=2.12.1",
+    "codecov",
+    "fileformats-medimage-CHANGME-extras",
+]
+
+[project.urls]
+repository = "https://github.com/nipype/pydra-meshfix"
+
+[tool.hatch.version]
+source = "vcs"
+raw-options = { root = "../.." }
+
+[tool.hatch.build.hooks.vcs]
+version-file = "fileformats/medimage_meshfix/_version.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["fileformats"]
+
+[tool.black]
+target-version = ['py38']
+exclude = "fileformats/medimage_meshfix/_version.py"
+
+[tool.codespell]
+ignore-words = ".codespell-ignorewords"
+
+[tool.flake8]
+doctests = true
+per-file-ignores = [
+    "__init__.py:F401"
+]
+max-line-length = 88
+select = "C,E,F,W,B,B950"
+extend-ignore = ['E203', 'E501', 'E129']
diff --git a/required-fileformats/minc/LICENSE b/required-fileformats/minc/LICENSE
new file mode 100644
index 00000000..e00bcb30
--- /dev/null
+++ b/required-fileformats/minc/LICENSE
@@ -0,0 +1,13 @@
+   Copyright 2021 Nipype developers
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/required-fileformats/minc/README.rst b/required-fileformats/minc/README.rst
new file mode 100644
index 00000000..31788496
--- /dev/null
+++ b/required-fileformats/minc/README.rst
@@ -0,0 +1,39 @@
+How to customise this template
+==============================
+
+#. Rename the `related-packages/fileformats/minc` directory to the name of the fileformats subpackage (e.g. `medimage_fsl`)
+#. Search and replace "minc" with the name of the fileformats subpackage the extras are to be added
+#. Replace name + email placeholders in `pyproject.toml` for developers and maintainers
+#. Add the extension file-format classes
+#. Ensure that all the extension file-format classes are imported into the extras package root, i.e. `fileformats/minc`
+#. Delete these instructions
+
+...
+
+FileFormats Extension - minc
+====================================
+.. image:: https://github.com/nipype/pydra-minc/actions/workflows/ci-cd.yml/badge.svg
+    :target: https://github.com/nipype/pydra-minc/actions/workflows/ci-cd.yml
+
+This is the "minc" extension module for the
+`fileformats <https://github.com/ArcanaFramework/fileformats-core>`__ package
+
+
+Quick Installation
+------------------
+
+This extension can be installed for Python 3 using *pip*::
+
+    $ pip3 install fileformats-minc
+
+This will install the core package and any other dependencies
+
+License
+-------
+
+This work is licensed under a
+`Creative Commons Attribution 4.0 International License <http://creativecommons.org/licenses/by/4.0/>`_
+
+.. image:: https://i.creativecommons.org/l/by/4.0/88x31.png
+  :target: http://creativecommons.org/licenses/by/4.0/
+  :alt: Creative Commons Attribution 4.0 International License
diff --git a/required-fileformats/minc/fileformats/medimage_minc/__init__.py b/required-fileformats/minc/fileformats/medimage_minc/__init__.py
new file mode 100644
index 00000000..10bd9c0d
--- /dev/null
+++ b/required-fileformats/minc/fileformats/medimage_minc/__init__.py
@@ -0,0 +1 @@
+from fileformats.generic import File
\ No newline at end of file
diff --git a/required-fileformats/minc/fileformats/medimage_minc/_version.py b/required-fileformats/minc/fileformats/medimage_minc/_version.py
new file mode 100644
index 00000000..ecda9af7
--- /dev/null
+++ b/required-fileformats/minc/fileformats/medimage_minc/_version.py
@@ -0,0 +1,16 @@
+# file generated by setuptools_scm
+# don't change, don't track in version control
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple, Union
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '0.2.3.dev42+gb9e3ee9.d20240226'
+__version_tuple__ = version_tuple = (0, 2, 3, 'dev42', 'gb9e3ee9.d20240226')
diff --git a/required-fileformats/minc/pyproject.toml b/required-fileformats/minc/pyproject.toml
new file mode 100644
index 00000000..f2d8e35e
--- /dev/null
+++ b/required-fileformats/minc/pyproject.toml
@@ -0,0 +1,84 @@
+[build-system]
+requires = ["hatchling", "hatch-vcs"]
+build-backend = "hatchling.build"
+
+[project]
+name = "fileformats-medimage-minc"
+description = "Classes for representing different file formats in Python classes for use in type hinting in data workflows"
+readme = "README.rst"
+requires-python = ">=3.8"
+dependencies = [
+    "fileformats",
+    "fileformats-medimage"
+]
+license = {file = "LICENSE"}
+authors = [
+    {name = "Thomas G. Close", email = "tom.g.close@gmail.com"},
+]
+maintainers = [
+    {name = "Thomas G. Close", email = "tom.g.close@gmail.com"},
+]
+keywords = [
+    "file formats",
+    "data",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: Apache Software License",
+    "Operating System :: MacOS :: MacOS X",
+    "Operating System :: Microsoft :: Windows",
+    "Operating System :: POSIX :: Linux",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Topic :: Scientific/Engineering",
+]
+dynamic = ["version"]
+
+[project.optional-dependencies]
+dev = [
+    "black",
+    "pre-commit",
+    "codespell",
+    "flake8",
+    "flake8-pyproject",
+]
+test = [
+    "pytest >=6.2.5",
+    "pytest-env>=0.6.2",
+    "pytest-cov>=2.12.1",
+    "codecov",
+    "fileformats-medimage-CHANGME-extras",
+]
+
+[project.urls]
+repository = "https://github.com/nipype/pydra-minc"
+
+[tool.hatch.version]
+source = "vcs"
+raw-options = { root = "../.." }
+
+[tool.hatch.build.hooks.vcs]
+version-file = "fileformats/medimage_minc/_version.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["fileformats"]
+
+[tool.black]
+target-version = ['py38']
+exclude = "fileformats/medimage_minc/_version.py"
+
+[tool.codespell]
+ignore-words = ".codespell-ignorewords"
+
+[tool.flake8]
+doctests = true
+per-file-ignores = [
+    "__init__.py:F401"
+]
+max-line-length = 88
+select = "C,E,F,W,B,B950"
+extend-ignore = ['E203', 'E501', 'E129']
diff --git a/required-fileformats/mipav/LICENSE b/required-fileformats/mipav/LICENSE
new file mode 100644
index 00000000..e00bcb30
--- /dev/null
+++ b/required-fileformats/mipav/LICENSE
@@ -0,0 +1,13 @@
+   Copyright 2021 Nipype developers
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/required-fileformats/mipav/README.rst b/required-fileformats/mipav/README.rst
new file mode 100644
index 00000000..eb84021b
--- /dev/null
+++ b/required-fileformats/mipav/README.rst
@@ -0,0 +1,39 @@
+How to customise this template
+==============================
+
+#. Rename the `related-packages/fileformats/mipav` directory to the name of the fileformats subpackage (e.g. `medimage_fsl`)
+#. Search and replace "mipav" with the name of the fileformats subpackage the extras are to be added
+#. Replace name + email placeholders in `pyproject.toml` for developers and maintainers
+#. Add the extension file-format classes
+#. Ensure that all the extension file-format classes are imported into the extras package root, i.e. `fileformats/mipav`
+#. Delete these instructions
+
+...
+
+FileFormats Extension - mipav
+====================================
+.. image:: https://github.com/nipype/pydra-mipav/actions/workflows/ci-cd.yml/badge.svg
+    :target: https://github.com/nipype/pydra-mipav/actions/workflows/ci-cd.yml
+
+This is the "mipav" extension module for the
+`fileformats <https://github.com/ArcanaFramework/fileformats-core>`__ package
+
+
+Quick Installation
+------------------
+
+This extension can be installed for Python 3 using *pip*::
+
+    $ pip3 install fileformats-mipav
+
+This will install the core package and any other dependencies
+
+License
+-------
+
+This work is licensed under a
+`Creative Commons Attribution 4.0 International License <http://creativecommons.org/licenses/by/4.0/>`_
+
+.. image:: https://i.creativecommons.org/l/by/4.0/88x31.png
+  :target: http://creativecommons.org/licenses/by/4.0/
+  :alt: Creative Commons Attribution 4.0 International License
diff --git a/required-fileformats/mipav/fileformats/medimage_mipav/__init__.py b/required-fileformats/mipav/fileformats/medimage_mipav/__init__.py
new file mode 100644
index 00000000..10bd9c0d
--- /dev/null
+++ b/required-fileformats/mipav/fileformats/medimage_mipav/__init__.py
@@ -0,0 +1 @@
+from fileformats.generic import File
\ No newline at end of file
diff --git a/required-fileformats/mipav/fileformats/medimage_mipav/_version.py b/required-fileformats/mipav/fileformats/medimage_mipav/_version.py
new file mode 100644
index 00000000..ecda9af7
--- /dev/null
+++ b/required-fileformats/mipav/fileformats/medimage_mipav/_version.py
@@ -0,0 +1,16 @@
+# file generated by setuptools_scm
+# don't change, don't track in version control
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple, Union
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '0.2.3.dev42+gb9e3ee9.d20240226'
+__version_tuple__ = version_tuple = (0, 2, 3, 'dev42', 'gb9e3ee9.d20240226')
diff --git a/required-fileformats/mipav/pyproject.toml b/required-fileformats/mipav/pyproject.toml
new file mode 100644
index 00000000..5af708db
--- /dev/null
+++ b/required-fileformats/mipav/pyproject.toml
@@ -0,0 +1,84 @@
+[build-system]
+requires = ["hatchling", "hatch-vcs"]
+build-backend = "hatchling.build"
+
+[project]
+name = "fileformats-medimage-mipav"
+description = "Classes for representing different file formats in Python classes for use in type hinting in data workflows"
+readme = "README.rst"
+requires-python = ">=3.8"
+dependencies = [
+    "fileformats",
+    "fileformats-medimage"
+]
+license = {file = "LICENSE"}
+authors = [
+    {name = "Thomas G. Close", email = "tom.g.close@gmail.com"},
+]
+maintainers = [
+    {name = "Thomas G. Close", email = "tom.g.close@gmail.com"},
+]
+keywords = [
+    "file formats",
+    "data",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: Apache Software License",
+    "Operating System :: MacOS :: MacOS X",
+    "Operating System :: Microsoft :: Windows",
+    "Operating System :: POSIX :: Linux",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Topic :: Scientific/Engineering",
+]
+dynamic = ["version"]
+
+[project.optional-dependencies]
+dev = [
+    "black",
+    "pre-commit",
+    "codespell",
+    "flake8",
+    "flake8-pyproject",
+]
+test = [
+    "pytest >=6.2.5",
+    "pytest-env>=0.6.2",
+    "pytest-cov>=2.12.1",
+    "codecov",
+    "fileformats-medimage-CHANGME-extras",
+]
+
+[project.urls]
+repository = "https://github.com/nipype/pydra-mipav"
+
+[tool.hatch.version]
+source = "vcs"
+raw-options = { root = "../.." }
+
+[tool.hatch.build.hooks.vcs]
+version-file = "fileformats/medimage_mipav/_version.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["fileformats"]
+
+[tool.black]
+target-version = ['py38']
+exclude = "fileformats/medimage_mipav/_version.py"
+
+[tool.codespell]
+ignore-words = ".codespell-ignorewords"
+
+[tool.flake8]
+doctests = true
+per-file-ignores = [
+    "__init__.py:F401"
+]
+max-line-length = 88
+select = "C,E,F,W,B,B950"
+extend-ignore = ['E203', 'E501', 'E129']
diff --git a/required-fileformats/niftyfit/LICENSE b/required-fileformats/niftyfit/LICENSE
new file mode 100644
index 00000000..e00bcb30
--- /dev/null
+++ b/required-fileformats/niftyfit/LICENSE
@@ -0,0 +1,13 @@
+   Copyright 2021 Nipype developers
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/required-fileformats/niftyfit/README.rst b/required-fileformats/niftyfit/README.rst
new file mode 100644
index 00000000..01f0003c
--- /dev/null
+++ b/required-fileformats/niftyfit/README.rst
@@ -0,0 +1,39 @@
+How to customise this template
+==============================
+
+#. Rename the `related-packages/fileformats/niftyfit` directory to the name of the fileformats subpackage (e.g. `medimage_fsl`)
+#. Search and replace "niftyfit" with the name of the fileformats subpackage the extras are to be added
+#. Replace name + email placeholders in `pyproject.toml` for developers and maintainers
+#. Add the extension file-format classes
+#. Ensure that all the extension file-format classes are imported into the extras package root, i.e. `fileformats/niftyfit`
+#. Delete these instructions
+
+...
+
+FileFormats Extension - niftyfit
+====================================
+.. image:: https://github.com/nipype/pydra-niftyfit/actions/workflows/ci-cd.yml/badge.svg
+    :target: https://github.com/nipype/pydra-niftyfit/actions/workflows/ci-cd.yml
+
+This is the "niftyfit" extension module for the
+`fileformats <https://github.com/ArcanaFramework/fileformats-core>`__ package
+
+
+Quick Installation
+------------------
+
+This extension can be installed for Python 3 using *pip*::
+
+    $ pip3 install fileformats-niftyfit
+
+This will install the core package and any other dependencies
+
+License
+-------
+
+This work is licensed under a
+`Creative Commons Attribution 4.0 International License <http://creativecommons.org/licenses/by/4.0/>`_
+
+.. image:: https://i.creativecommons.org/l/by/4.0/88x31.png
+  :target: http://creativecommons.org/licenses/by/4.0/
+  :alt: Creative Commons Attribution 4.0 International License
diff --git a/required-fileformats/niftyfit/fileformats/medimage_niftyfit/__init__.py b/required-fileformats/niftyfit/fileformats/medimage_niftyfit/__init__.py
new file mode 100644
index 00000000..10bd9c0d
--- /dev/null
+++ b/required-fileformats/niftyfit/fileformats/medimage_niftyfit/__init__.py
@@ -0,0 +1 @@
+from fileformats.generic import File
\ No newline at end of file
diff --git a/required-fileformats/niftyfit/fileformats/medimage_niftyfit/_version.py b/required-fileformats/niftyfit/fileformats/medimage_niftyfit/_version.py
new file mode 100644
index 00000000..ecda9af7
--- /dev/null
+++ b/required-fileformats/niftyfit/fileformats/medimage_niftyfit/_version.py
@@ -0,0 +1,16 @@
+# file generated by setuptools_scm
+# don't change, don't track in version control
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple, Union
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '0.2.3.dev42+gb9e3ee9.d20240226'
+__version_tuple__ = version_tuple = (0, 2, 3, 'dev42', 'gb9e3ee9.d20240226')
diff --git a/required-fileformats/niftyfit/pyproject.toml b/required-fileformats/niftyfit/pyproject.toml
new file mode 100644
index 00000000..049bb251
--- /dev/null
+++ b/required-fileformats/niftyfit/pyproject.toml
@@ -0,0 +1,84 @@
+[build-system]
+requires = ["hatchling", "hatch-vcs"]
+build-backend = "hatchling.build"
+
+[project]
+name = "fileformats-medimage-niftyfit"
+description = "Classes for representing different file formats in Python classes for use in type hinting in data workflows"
+readme = "README.rst"
+requires-python = ">=3.8"
+dependencies = [
+    "fileformats",
+    "fileformats-medimage"
+]
+license = {file = "LICENSE"}
+authors = [
+    {name = "Thomas G. Close", email = "tom.g.close@gmail.com"},
+]
+maintainers = [
+    {name = "Thomas G. Close", email = "tom.g.close@gmail.com"},
+]
+keywords = [
+    "file formats",
+    "data",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: Apache Software License",
+    "Operating System :: MacOS :: MacOS X",
+    "Operating System :: Microsoft :: Windows",
+    "Operating System :: POSIX :: Linux",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Topic :: Scientific/Engineering",
+]
+dynamic = ["version"]
+
+[project.optional-dependencies]
+dev = [
+    "black",
+    "pre-commit",
+    "codespell",
+    "flake8",
+    "flake8-pyproject",
+]
+test = [
+    "pytest >=6.2.5",
+    "pytest-env>=0.6.2",
+    "pytest-cov>=2.12.1",
+    "codecov",
+    "fileformats-medimage-CHANGME-extras",
+]
+
+[project.urls]
+repository = "https://github.com/nipype/pydra-niftyfit"
+
+[tool.hatch.version]
+source = "vcs"
+raw-options = { root = "../.." }
+
+[tool.hatch.build.hooks.vcs]
+version-file = "fileformats/medimage_niftyfit/_version.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["fileformats"]
+
+[tool.black]
+target-version = ['py38']
+exclude = "fileformats/medimage_niftyfit/_version.py"
+
+[tool.codespell]
+ignore-words = ".codespell-ignorewords"
+
+[tool.flake8]
+doctests = true
+per-file-ignores = [
+    "__init__.py:F401"
+]
+max-line-length = 88
+select = "C,E,F,W,B,B950"
+extend-ignore = ['E203', 'E501', 'E129']
diff --git a/required-fileformats/niftyreg/LICENSE b/required-fileformats/niftyreg/LICENSE
new file mode 100644
index 00000000..e00bcb30
--- /dev/null
+++ b/required-fileformats/niftyreg/LICENSE
@@ -0,0 +1,13 @@
+   Copyright 2021 Nipype developers
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/required-fileformats/niftyreg/README.rst b/required-fileformats/niftyreg/README.rst
new file mode 100644
index 00000000..8e5815ea
--- /dev/null
+++ b/required-fileformats/niftyreg/README.rst
@@ -0,0 +1,39 @@
+How to customise this template
+==============================
+
+#. Rename the `related-packages/fileformats/niftyreg` directory to the name of the fileformats subpackage (e.g. `medimage_fsl`)
+#. Search and replace "niftyreg" with the name of the fileformats subpackage the extras are to be added
+#. Replace name + email placeholders in `pyproject.toml` for developers and maintainers
+#. Add the extension file-format classes
+#. Ensure that all the extension file-format classes are imported into the extras package root, i.e. `fileformats/niftyreg`
+#. Delete these instructions
+
+...
+
+FileFormats Extension - niftyreg
+====================================
+.. image:: https://github.com/nipype/pydra-niftyreg/actions/workflows/ci-cd.yml/badge.svg
+    :target: https://github.com/nipype/pydra-niftyreg/actions/workflows/ci-cd.yml
+
+This is the "niftyreg" extension module for the
+`fileformats <https://github.com/ArcanaFramework/fileformats-core>`__ package
+
+
+Quick Installation
+------------------
+
+This extension can be installed for Python 3 using *pip*::
+
+    $ pip3 install fileformats-niftyreg
+
+This will install the core package and any other dependencies
+
+License
+-------
+
+This work is licensed under a
+`Creative Commons Attribution 4.0 International License <http://creativecommons.org/licenses/by/4.0/>`_
+
+.. image:: https://i.creativecommons.org/l/by/4.0/88x31.png
+  :target: http://creativecommons.org/licenses/by/4.0/
+  :alt: Creative Commons Attribution 4.0 International License
diff --git a/required-fileformats/niftyreg/fileformats/medimage_niftyreg/__init__.py b/required-fileformats/niftyreg/fileformats/medimage_niftyreg/__init__.py
new file mode 100644
index 00000000..10bd9c0d
--- /dev/null
+++ b/required-fileformats/niftyreg/fileformats/medimage_niftyreg/__init__.py
@@ -0,0 +1 @@
+from fileformats.generic import File
\ No newline at end of file
diff --git a/required-fileformats/niftyreg/fileformats/medimage_niftyreg/_version.py b/required-fileformats/niftyreg/fileformats/medimage_niftyreg/_version.py
new file mode 100644
index 00000000..ecda9af7
--- /dev/null
+++ b/required-fileformats/niftyreg/fileformats/medimage_niftyreg/_version.py
@@ -0,0 +1,16 @@
+# file generated by setuptools_scm
+# don't change, don't track in version control
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple, Union
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '0.2.3.dev42+gb9e3ee9.d20240226'
+__version_tuple__ = version_tuple = (0, 2, 3, 'dev42', 'gb9e3ee9.d20240226')
diff --git a/required-fileformats/niftyreg/pyproject.toml b/required-fileformats/niftyreg/pyproject.toml
new file mode 100644
index 00000000..1ffe69c8
--- /dev/null
+++ b/required-fileformats/niftyreg/pyproject.toml
@@ -0,0 +1,84 @@
+[build-system]
+requires = ["hatchling", "hatch-vcs"]
+build-backend = "hatchling.build"
+
+[project]
+name = "fileformats-medimage-niftyreg"
+description = "Classes for representing different file formats in Python classes for use in type hinting in data workflows"
+readme = "README.rst"
+requires-python = ">=3.8"
+dependencies = [
+    "fileformats",
+    "fileformats-medimage"
+]
+license = {file = "LICENSE"}
+authors = [
+    {name = "Thomas G. Close", email = "tom.g.close@gmail.com"},
+]
+maintainers = [
+    {name = "Thomas G. Close", email = "tom.g.close@gmail.com"},
+]
+keywords = [
+    "file formats",
+    "data",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: Apache Software License",
+    "Operating System :: MacOS :: MacOS X",
+    "Operating System :: Microsoft :: Windows",
+    "Operating System :: POSIX :: Linux",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Topic :: Scientific/Engineering",
+]
+dynamic = ["version"]
+
+[project.optional-dependencies]
+dev = [
+    "black",
+    "pre-commit",
+    "codespell",
+    "flake8",
+    "flake8-pyproject",
+]
+test = [
+    "pytest >=6.2.5",
+    "pytest-env>=0.6.2",
+    "pytest-cov>=2.12.1",
+    "codecov",
+    "fileformats-medimage-CHANGME-extras",
+]
+
+[project.urls]
+repository = "https://github.com/nipype/pydra-niftyreg"
+
+[tool.hatch.version]
+source = "vcs"
+raw-options = { root = "../.." }
+
+[tool.hatch.build.hooks.vcs]
+version-file = "fileformats/medimage_niftyreg/_version.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["fileformats"]
+
+[tool.black]
+target-version = ['py38']
+exclude = "fileformats/medimage_niftyreg/_version.py"
+
+[tool.codespell]
+ignore-words = ".codespell-ignorewords"
+
+[tool.flake8]
+doctests = true
+per-file-ignores = [
+    "__init__.py:F401"
+]
+max-line-length = 88
+select = "C,E,F,W,B,B950"
+extend-ignore = ['E203', 'E501', 'E129']
diff --git a/required-fileformats/niftyseg/LICENSE b/required-fileformats/niftyseg/LICENSE
new file mode 100644
index 00000000..e00bcb30
--- /dev/null
+++ b/required-fileformats/niftyseg/LICENSE
@@ -0,0 +1,13 @@
+   Copyright 2021 Nipype developers
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/required-fileformats/niftyseg/README.rst b/required-fileformats/niftyseg/README.rst
new file mode 100644
index 00000000..56da6488
--- /dev/null
+++ b/required-fileformats/niftyseg/README.rst
@@ -0,0 +1,39 @@
+How to customise this template
+==============================
+
+#. Rename the `related-packages/fileformats/niftyseg` directory to the name of the fileformats subpackage (e.g. `medimage_fsl`)
+#. Search and replace "niftyseg" with the name of the fileformats subpackage the extras are to be added
+#. Replace name + email placeholders in `pyproject.toml` for developers and maintainers
+#. Add the extension file-format classes
+#. Ensure that all the extension file-format classes are imported into the extras package root, i.e. `fileformats/niftyseg`
+#. Delete these instructions
+
+...
+
+FileFormats Extension - niftyseg
+====================================
+.. image:: https://github.com/nipype/pydra-niftyseg/actions/workflows/ci-cd.yml/badge.svg
+    :target: https://github.com/nipype/pydra-niftyseg/actions/workflows/ci-cd.yml
+
+This is the "niftyseg" extension module for the
+`fileformats <https://github.com/ArcanaFramework/fileformats-core>`__ package
+
+
+Quick Installation
+------------------
+
+This extension can be installed for Python 3 using *pip*::
+
+    $ pip3 install fileformats-niftyseg
+
+This will install the core package and any other dependencies
+
+License
+-------
+
+This work is licensed under a
+`Creative Commons Attribution 4.0 International License <http://creativecommons.org/licenses/by/4.0/>`_
+
+.. image:: https://i.creativecommons.org/l/by/4.0/88x31.png
+  :target: http://creativecommons.org/licenses/by/4.0/
+  :alt: Creative Commons Attribution 4.0 International License
diff --git a/required-fileformats/niftyseg/fileformats/medimage_niftyseg/__init__.py b/required-fileformats/niftyseg/fileformats/medimage_niftyseg/__init__.py
new file mode 100644
index 00000000..10bd9c0d
--- /dev/null
+++ b/required-fileformats/niftyseg/fileformats/medimage_niftyseg/__init__.py
@@ -0,0 +1 @@
+from fileformats.generic import File
\ No newline at end of file
diff --git a/required-fileformats/niftyseg/fileformats/medimage_niftyseg/_version.py b/required-fileformats/niftyseg/fileformats/medimage_niftyseg/_version.py
new file mode 100644
index 00000000..ecda9af7
--- /dev/null
+++ b/required-fileformats/niftyseg/fileformats/medimage_niftyseg/_version.py
@@ -0,0 +1,16 @@
+# file generated by setuptools_scm
+# don't change, don't track in version control
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple, Union
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '0.2.3.dev42+gb9e3ee9.d20240226'
+__version_tuple__ = version_tuple = (0, 2, 3, 'dev42', 'gb9e3ee9.d20240226')
diff --git a/required-fileformats/niftyseg/pyproject.toml b/required-fileformats/niftyseg/pyproject.toml
new file mode 100644
index 00000000..7c9caafc
--- /dev/null
+++ b/required-fileformats/niftyseg/pyproject.toml
@@ -0,0 +1,84 @@
+[build-system]
+requires = ["hatchling", "hatch-vcs"]
+build-backend = "hatchling.build"
+
+[project]
+name = "fileformats-medimage-niftyseg"
+description = "Classes for representing different file formats in Python classes for use in type hinting in data workflows"
+readme = "README.rst"
+requires-python = ">=3.8"
+dependencies = [
+    "fileformats",
+    "fileformats-medimage"
+]
+license = {file = "LICENSE"}
+authors = [
+    {name = "Thomas G. Close", email = "tom.g.close@gmail.com"},
+]
+maintainers = [
+    {name = "Thomas G. Close", email = "tom.g.close@gmail.com"},
+]
+keywords = [
+    "file formats",
+    "data",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: Apache Software License",
+    "Operating System :: MacOS :: MacOS X",
+    "Operating System :: Microsoft :: Windows",
+    "Operating System :: POSIX :: Linux",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Topic :: Scientific/Engineering",
+]
+dynamic = ["version"]
+
+[project.optional-dependencies]
+dev = [
+    "black",
+    "pre-commit",
+    "codespell",
+    "flake8",
+    "flake8-pyproject",
+]
+test = [
+    "pytest >=6.2.5",
+    "pytest-env>=0.6.2",
+    "pytest-cov>=2.12.1",
+    "codecov",
+    "fileformats-medimage-CHANGME-extras",
+]
+
+[project.urls]
+repository = "https://github.com/nipype/pydra-niftyseg"
+
+[tool.hatch.version]
+source = "vcs"
+raw-options = { root = "../.." }
+
+[tool.hatch.build.hooks.vcs]
+version-file = "fileformats/medimage_niftyseg/_version.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["fileformats"]
+
+[tool.black]
+target-version = ['py38']
+exclude = "fileformats/medimage_niftyseg/_version.py"
+
+[tool.codespell]
+ignore-words = ".codespell-ignorewords"
+
+[tool.flake8]
+doctests = true
+per-file-ignores = [
+    "__init__.py:F401"
+]
+max-line-length = 88
+select = "C,E,F,W,B,B950"
+extend-ignore = ['E203', 'E501', 'E129']
diff --git a/required-fileformats/nilearn/LICENSE b/required-fileformats/nilearn/LICENSE
new file mode 100644
index 00000000..e00bcb30
--- /dev/null
+++ b/required-fileformats/nilearn/LICENSE
@@ -0,0 +1,13 @@
+   Copyright 2021 Nipype developers
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/required-fileformats/nilearn/README.rst b/required-fileformats/nilearn/README.rst
new file mode 100644
index 00000000..13ec3065
--- /dev/null
+++ b/required-fileformats/nilearn/README.rst
@@ -0,0 +1,39 @@
+How to customise this template
+==============================
+
+#. Rename the `related-packages/fileformats/nilearn` directory to the name of the fileformats subpackage (e.g. `medimage_fsl`)
+#. Search and replace "nilearn" with the name of the fileformats subpackage the extras are to be added
+#. Replace name + email placeholders in `pyproject.toml` for developers and maintainers
+#. Add the extension file-format classes
+#. Ensure that all the extension file-format classes are imported into the extras package root, i.e. `fileformats/nilearn`
+#. Delete these instructions
+
+...
+
+FileFormats Extension - nilearn
+====================================
+.. image:: https://github.com/nipype/pydra-nilearn/actions/workflows/ci-cd.yml/badge.svg
+    :target: https://github.com/nipype/pydra-nilearn/actions/workflows/ci-cd.yml
+
+This is the "nilearn" extension module for the
+`fileformats <https://github.com/ArcanaFramework/fileformats-core>`__ package
+
+
+Quick Installation
+------------------
+
+This extension can be installed for Python 3 using *pip*::
+
+    $ pip3 install fileformats-nilearn
+
+This will install the core package and any other dependencies
+
+License
+-------
+
+This work is licensed under a
+`Creative Commons Attribution 4.0 International License <http://creativecommons.org/licenses/by/4.0/>`_
+
+.. image:: https://i.creativecommons.org/l/by/4.0/88x31.png
+  :target: http://creativecommons.org/licenses/by/4.0/
+  :alt: Creative Commons Attribution 4.0 International License
diff --git a/required-fileformats/nilearn/fileformats/medimage_nilearn/__init__.py b/required-fileformats/nilearn/fileformats/medimage_nilearn/__init__.py
new file mode 100644
index 00000000..10bd9c0d
--- /dev/null
+++ b/required-fileformats/nilearn/fileformats/medimage_nilearn/__init__.py
@@ -0,0 +1 @@
+from fileformats.generic import File
\ No newline at end of file
diff --git a/required-fileformats/nilearn/fileformats/medimage_nilearn/_version.py b/required-fileformats/nilearn/fileformats/medimage_nilearn/_version.py
new file mode 100644
index 00000000..ecda9af7
--- /dev/null
+++ b/required-fileformats/nilearn/fileformats/medimage_nilearn/_version.py
@@ -0,0 +1,16 @@
+# file generated by setuptools_scm
+# don't change, don't track in version control
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple, Union
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '0.2.3.dev42+gb9e3ee9.d20240226'
+__version_tuple__ = version_tuple = (0, 2, 3, 'dev42', 'gb9e3ee9.d20240226')
diff --git a/required-fileformats/nilearn/pyproject.toml b/required-fileformats/nilearn/pyproject.toml
new file mode 100644
index 00000000..2e86d5f3
--- /dev/null
+++ b/required-fileformats/nilearn/pyproject.toml
@@ -0,0 +1,84 @@
+[build-system]
+requires = ["hatchling", "hatch-vcs"]
+build-backend = "hatchling.build"
+
+[project]
+name = "fileformats-medimage-nilearn"
+description = "Classes for representing different file formats in Python classes for use in type hinting in data workflows"
+readme = "README.rst"
+requires-python = ">=3.8"
+dependencies = [
+    "fileformats",
+    "fileformats-medimage"
+]
+license = {file = "LICENSE"}
+authors = [
+    {name = "Thomas G. Close", email = "tom.g.close@gmail.com"},
+]
+maintainers = [
+    {name = "Thomas G. Close", email = "tom.g.close@gmail.com"},
+]
+keywords = [
+    "file formats",
+    "data",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: Apache Software License",
+    "Operating System :: MacOS :: MacOS X",
+    "Operating System :: Microsoft :: Windows",
+    "Operating System :: POSIX :: Linux",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Topic :: Scientific/Engineering",
+]
+dynamic = ["version"]
+
+[project.optional-dependencies]
+dev = [
+    "black",
+    "pre-commit",
+    "codespell",
+    "flake8",
+    "flake8-pyproject",
+]
+test = [
+    "pytest >=6.2.5",
+    "pytest-env>=0.6.2",
+    "pytest-cov>=2.12.1",
+    "codecov",
+    "fileformats-medimage-CHANGME-extras",
+]
+
+[project.urls]
+repository = "https://github.com/nipype/pydra-nilearn"
+
+[tool.hatch.version]
+source = "vcs"
+raw-options = { root = "../.." }
+
+[tool.hatch.build.hooks.vcs]
+version-file = "fileformats/medimage_nilearn/_version.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["fileformats"]
+
+[tool.black]
+target-version = ['py38']
+exclude = "fileformats/medimage_nilearn/_version.py"
+
+[tool.codespell]
+ignore-words = ".codespell-ignorewords"
+
+[tool.flake8]
+doctests = true
+per-file-ignores = [
+    "__init__.py:F401"
+]
+max-line-length = 88
+select = "C,E,F,W,B,B950"
+extend-ignore = ['E203', 'E501', 'E129']
diff --git a/required-fileformats/nitime/LICENSE b/required-fileformats/nitime/LICENSE
new file mode 100644
index 00000000..e00bcb30
--- /dev/null
+++ b/required-fileformats/nitime/LICENSE
@@ -0,0 +1,13 @@
+   Copyright 2021 Nipype developers
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/required-fileformats/nitime/README.rst b/required-fileformats/nitime/README.rst
new file mode 100644
index 00000000..ff021829
--- /dev/null
+++ b/required-fileformats/nitime/README.rst
@@ -0,0 +1,39 @@
+How to customise this template
+==============================
+
+#. Rename the `related-packages/fileformats/nitime` directory to the name of the fileformats subpackage (e.g. `medimage_fsl`)
+#. Search and replace "nitime" with the name of the fileformats subpackage the extras are to be added
+#. Replace name + email placeholders in `pyproject.toml` for developers and maintainers
+#. Add the extension file-format classes
+#. Ensure that all the extension file-format classes are imported into the extras package root, i.e. `fileformats/nitime`
+#. Delete these instructions
+
+...
+
+FileFormats Extension - nitime
+====================================
+.. image:: https://github.com/nipype/pydra-nitime/actions/workflows/ci-cd.yml/badge.svg
+    :target: https://github.com/nipype/pydra-nitime/actions/workflows/ci-cd.yml
+
+This is the "nitime" extension module for the
+`fileformats <https://github.com/ArcanaFramework/fileformats-core>`__ package
+
+
+Quick Installation
+------------------
+
+This extension can be installed for Python 3 using *pip*::
+
+    $ pip3 install fileformats-nitime
+
+This will install the core package and any other dependencies
+
+License
+-------
+
+This work is licensed under a
+`Creative Commons Attribution 4.0 International License <http://creativecommons.org/licenses/by/4.0/>`_
+
+.. image:: https://i.creativecommons.org/l/by/4.0/88x31.png
+  :target: http://creativecommons.org/licenses/by/4.0/
+  :alt: Creative Commons Attribution 4.0 International License
diff --git a/required-fileformats/nitime/fileformats/medimage_nitime/__init__.py b/required-fileformats/nitime/fileformats/medimage_nitime/__init__.py
new file mode 100644
index 00000000..10bd9c0d
--- /dev/null
+++ b/required-fileformats/nitime/fileformats/medimage_nitime/__init__.py
@@ -0,0 +1 @@
+from fileformats.generic import File
\ No newline at end of file
diff --git a/required-fileformats/nitime/fileformats/medimage_nitime/_version.py b/required-fileformats/nitime/fileformats/medimage_nitime/_version.py
new file mode 100644
index 00000000..ecda9af7
--- /dev/null
+++ b/required-fileformats/nitime/fileformats/medimage_nitime/_version.py
@@ -0,0 +1,16 @@
+# file generated by setuptools_scm
+# don't change, don't track in version control
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple, Union
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '0.2.3.dev42+gb9e3ee9.d20240226'
+__version_tuple__ = version_tuple = (0, 2, 3, 'dev42', 'gb9e3ee9.d20240226')
diff --git a/required-fileformats/nitime/pyproject.toml b/required-fileformats/nitime/pyproject.toml
new file mode 100644
index 00000000..bf9a3ffa
--- /dev/null
+++ b/required-fileformats/nitime/pyproject.toml
@@ -0,0 +1,84 @@
+[build-system]
+requires = ["hatchling", "hatch-vcs"]
+build-backend = "hatchling.build"
+
+[project]
+name = "fileformats-medimage-nitime"
+description = "Classes for representing different file formats in Python classes for use in type hinting in data workflows"
+readme = "README.rst"
+requires-python = ">=3.8"
+dependencies = [
+    "fileformats",
+    "fileformats-medimage"
+]
+license = {file = "LICENSE"}
+authors = [
+    {name = "Thomas G. Close", email = "tom.g.close@gmail.com"},
+]
+maintainers = [
+    {name = "Thomas G. Close", email = "tom.g.close@gmail.com"},
+]
+keywords = [
+    "file formats",
+    "data",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: Apache Software License",
+    "Operating System :: MacOS :: MacOS X",
+    "Operating System :: Microsoft :: Windows",
+    "Operating System :: POSIX :: Linux",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Topic :: Scientific/Engineering",
+]
+dynamic = ["version"]
+
+[project.optional-dependencies]
+dev = [
+    "black",
+    "pre-commit",
+    "codespell",
+    "flake8",
+    "flake8-pyproject",
+]
+test = [
+    "pytest >=6.2.5",
+    "pytest-env>=0.6.2",
+    "pytest-cov>=2.12.1",
+    "codecov",
+    "fileformats-medimage-CHANGME-extras",
+]
+
+[project.urls]
+repository = "https://github.com/nipype/pydra-nitime"
+
+[tool.hatch.version]
+source = "vcs"
+raw-options = { root = "../.." }
+
+[tool.hatch.build.hooks.vcs]
+version-file = "fileformats/medimage_nitime/_version.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["fileformats"]
+
+[tool.black]
+target-version = ['py38']
+exclude = "fileformats/medimage_nitime/_version.py"
+
+[tool.codespell]
+ignore-words = ".codespell-ignorewords"
+
+[tool.flake8]
+doctests = true
+per-file-ignores = [
+    "__init__.py:F401"
+]
+max-line-length = 88
+select = "C,E,F,W,B,B950"
+extend-ignore = ['E203', 'E501', 'E129']
diff --git a/required-fileformats/petpvc/LICENSE b/required-fileformats/petpvc/LICENSE
new file mode 100644
index 00000000..e00bcb30
--- /dev/null
+++ b/required-fileformats/petpvc/LICENSE
@@ -0,0 +1,13 @@
+   Copyright 2021 Nipype developers
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/required-fileformats/petpvc/README.rst b/required-fileformats/petpvc/README.rst
new file mode 100644
index 00000000..69672892
--- /dev/null
+++ b/required-fileformats/petpvc/README.rst
@@ -0,0 +1,39 @@
+How to customise this template
+==============================
+
+#. Rename the `related-packages/fileformats/petpvc` directory to the name of the fileformats subpackage (e.g. `medimage_fsl`)
+#. Search and replace "petpvc" with the name of the fileformats subpackage the extras are to be added
+#. Replace name + email placeholders in `pyproject.toml` for developers and maintainers
+#. Add the extension file-format classes
+#. Ensure that all the extension file-format classes are imported into the extras package root, i.e. `fileformats/petpvc`
+#. Delete these instructions
+
+...
+
+FileFormats Extension - petpvc
+====================================
+.. image:: https://github.com/nipype/pydra-petpvc/actions/workflows/ci-cd.yml/badge.svg
+    :target: https://github.com/nipype/pydra-petpvc/actions/workflows/ci-cd.yml
+
+This is the "petpvc" extension module for the
+`fileformats <https://github.com/ArcanaFramework/fileformats-core>`__ package
+
+
+Quick Installation
+------------------
+
+This extension can be installed for Python 3 using *pip*::
+
+    $ pip3 install fileformats-petpvc
+
+This will install the core package and any other dependencies
+
+License
+-------
+
+This work is licensed under a
+`Creative Commons Attribution 4.0 International License <http://creativecommons.org/licenses/by/4.0/>`_
+
+.. image:: https://i.creativecommons.org/l/by/4.0/88x31.png
+  :target: http://creativecommons.org/licenses/by/4.0/
+  :alt: Creative Commons Attribution 4.0 International License
diff --git a/required-fileformats/petpvc/fileformats/medimage_petpvc/__init__.py b/required-fileformats/petpvc/fileformats/medimage_petpvc/__init__.py
new file mode 100644
index 00000000..10bd9c0d
--- /dev/null
+++ b/required-fileformats/petpvc/fileformats/medimage_petpvc/__init__.py
@@ -0,0 +1 @@
+from fileformats.generic import File
\ No newline at end of file
diff --git a/required-fileformats/petpvc/fileformats/medimage_petpvc/_version.py b/required-fileformats/petpvc/fileformats/medimage_petpvc/_version.py
new file mode 100644
index 00000000..ecda9af7
--- /dev/null
+++ b/required-fileformats/petpvc/fileformats/medimage_petpvc/_version.py
@@ -0,0 +1,16 @@
+# file generated by setuptools_scm
+# don't change, don't track in version control
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple, Union
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '0.2.3.dev42+gb9e3ee9.d20240226'
+__version_tuple__ = version_tuple = (0, 2, 3, 'dev42', 'gb9e3ee9.d20240226')
diff --git a/required-fileformats/petpvc/pyproject.toml b/required-fileformats/petpvc/pyproject.toml
new file mode 100644
index 00000000..8a549cee
--- /dev/null
+++ b/required-fileformats/petpvc/pyproject.toml
@@ -0,0 +1,84 @@
+[build-system]
+requires = ["hatchling", "hatch-vcs"]
+build-backend = "hatchling.build"
+
+[project]
+name = "fileformats-medimage-petpvc"
+description = "Classes for representing different file formats in Python classes for use in type hinting in data workflows"
+readme = "README.rst"
+requires-python = ">=3.8"
+dependencies = [
+    "fileformats",
+    "fileformats-medimage"
+]
+license = {file = "LICENSE"}
+authors = [
+    {name = "Thomas G. Close", email = "tom.g.close@gmail.com"},
+]
+maintainers = [
+    {name = "Thomas G. Close", email = "tom.g.close@gmail.com"},
+]
+keywords = [
+    "file formats",
+    "data",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: Apache Software License",
+    "Operating System :: MacOS :: MacOS X",
+    "Operating System :: Microsoft :: Windows",
+    "Operating System :: POSIX :: Linux",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Topic :: Scientific/Engineering",
+]
+dynamic = ["version"]
+
+[project.optional-dependencies]
+dev = [
+    "black",
+    "pre-commit",
+    "codespell",
+    "flake8",
+    "flake8-pyproject",
+]
+test = [
+    "pytest >=6.2.5",
+    "pytest-env>=0.6.2",
+    "pytest-cov>=2.12.1",
+    "codecov",
+    "fileformats-medimage-CHANGME-extras",
+]
+
+[project.urls]
+repository = "https://github.com/nipype/pydra-petpvc"
+
+[tool.hatch.version]
+source = "vcs"
+raw-options = { root = "../.." }
+
+[tool.hatch.build.hooks.vcs]
+version-file = "fileformats/medimage_petpvc/_version.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["fileformats"]
+
+[tool.black]
+target-version = ['py38']
+exclude = "fileformats/medimage_petpvc/_version.py"
+
+[tool.codespell]
+ignore-words = ".codespell-ignorewords"
+
+[tool.flake8]
+doctests = true
+per-file-ignores = [
+    "__init__.py:F401"
+]
+max-line-length = 88
+select = "C,E,F,W,B,B950"
+extend-ignore = ['E203', 'E501', 'E129']
diff --git a/required-fileformats/quickshear/LICENSE b/required-fileformats/quickshear/LICENSE
new file mode 100644
index 00000000..e00bcb30
--- /dev/null
+++ b/required-fileformats/quickshear/LICENSE
@@ -0,0 +1,13 @@
+   Copyright 2021 Nipype developers
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/required-fileformats/quickshear/README.rst b/required-fileformats/quickshear/README.rst
new file mode 100644
index 00000000..35e09cb6
--- /dev/null
+++ b/required-fileformats/quickshear/README.rst
@@ -0,0 +1,39 @@
+How to customise this template
+==============================
+
+#. Rename the `related-packages/fileformats/quickshear` directory to the name of the fileformats subpackage (e.g. `medimage_fsl`)
+#. Search and replace "quickshear" with the name of the fileformats subpackage the extras are to be added
+#. Replace name + email placeholders in `pyproject.toml` for developers and maintainers
+#. Add the extension file-format classes
+#. Ensure that all the extension file-format classes are imported into the extras package root, i.e. `fileformats/quickshear`
+#. Delete these instructions
+
+...
+
+FileFormats Extension - quickshear
+====================================
+.. image:: https://github.com/nipype/pydra-quickshear/actions/workflows/ci-cd.yml/badge.svg
+    :target: https://github.com/nipype/pydra-quickshear/actions/workflows/ci-cd.yml
+
+This is the "quickshear" extension module for the
+`fileformats <https://github.com/ArcanaFramework/fileformats-core>`__ package
+
+
+Quick Installation
+------------------
+
+This extension can be installed for Python 3 using *pip*::
+
+    $ pip3 install fileformats-quickshear
+
+This will install the core package and any other dependencies
+
+License
+-------
+
+This work is licensed under a
+`Creative Commons Attribution 4.0 International License <http://creativecommons.org/licenses/by/4.0/>`_
+
+.. image:: https://i.creativecommons.org/l/by/4.0/88x31.png
+  :target: http://creativecommons.org/licenses/by/4.0/
+  :alt: Creative Commons Attribution 4.0 International License
diff --git a/required-fileformats/quickshear/fileformats/medimage_quickshear/__init__.py b/required-fileformats/quickshear/fileformats/medimage_quickshear/__init__.py
new file mode 100644
index 00000000..10bd9c0d
--- /dev/null
+++ b/required-fileformats/quickshear/fileformats/medimage_quickshear/__init__.py
@@ -0,0 +1 @@
+from fileformats.generic import File
\ No newline at end of file
diff --git a/required-fileformats/quickshear/fileformats/medimage_quickshear/_version.py b/required-fileformats/quickshear/fileformats/medimage_quickshear/_version.py
new file mode 100644
index 00000000..ecda9af7
--- /dev/null
+++ b/required-fileformats/quickshear/fileformats/medimage_quickshear/_version.py
@@ -0,0 +1,16 @@
+# file generated by setuptools_scm
+# don't change, don't track in version control
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple, Union
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '0.2.3.dev42+gb9e3ee9.d20240226'
+__version_tuple__ = version_tuple = (0, 2, 3, 'dev42', 'gb9e3ee9.d20240226')
diff --git a/required-fileformats/quickshear/pyproject.toml b/required-fileformats/quickshear/pyproject.toml
new file mode 100644
index 00000000..2efe1956
--- /dev/null
+++ b/required-fileformats/quickshear/pyproject.toml
@@ -0,0 +1,84 @@
+[build-system]
+requires = ["hatchling", "hatch-vcs"]
+build-backend = "hatchling.build"
+
+[project]
+name = "fileformats-medimage-quickshear"
+description = "Classes for representing different file formats in Python classes for use in type hinting in data workflows"
+readme = "README.rst"
+requires-python = ">=3.8"
+dependencies = [
+    "fileformats",
+    "fileformats-medimage"
+]
+license = {file = "LICENSE"}
+authors = [
+    {name = "Thomas G. Close", email = "tom.g.close@gmail.com"},
+]
+maintainers = [
+    {name = "Thomas G. Close", email = "tom.g.close@gmail.com"},
+]
+keywords = [
+    "file formats",
+    "data",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: Apache Software License",
+    "Operating System :: MacOS :: MacOS X",
+    "Operating System :: Microsoft :: Windows",
+    "Operating System :: POSIX :: Linux",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Topic :: Scientific/Engineering",
+]
+dynamic = ["version"]
+
+[project.optional-dependencies]
+dev = [
+    "black",
+    "pre-commit",
+    "codespell",
+    "flake8",
+    "flake8-pyproject",
+]
+test = [
+    "pytest >=6.2.5",
+    "pytest-env>=0.6.2",
+    "pytest-cov>=2.12.1",
+    "codecov",
+    "fileformats-medimage-CHANGME-extras",
+]
+
+[project.urls]
+repository = "https://github.com/nipype/pydra-quickshear"
+
+[tool.hatch.version]
+source = "vcs"
+raw-options = { root = "../.." }
+
+[tool.hatch.build.hooks.vcs]
+version-file = "fileformats/medimage_quickshear/_version.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["fileformats"]
+
+[tool.black]
+target-version = ['py38']
+exclude = "fileformats/medimage_quickshear/_version.py"
+
+[tool.codespell]
+ignore-words = ".codespell-ignorewords"
+
+[tool.flake8]
+doctests = true
+per-file-ignores = [
+    "__init__.py:F401"
+]
+max-line-length = 88
+select = "C,E,F,W,B,B950"
+extend-ignore = ['E203', 'E501', 'E129']
diff --git a/required-fileformats/requirements.txt b/required-fileformats/requirements.txt
new file mode 100644
index 00000000..3ac37073
--- /dev/null
+++ b/required-fileformats/requirements.txt
@@ -0,0 +1,33 @@
+-e ./afni
+-e ./ants
+-e ./brainsuite
+-e ./bru2nii
+-e ./c3
+-e ./camino
+-e ./camino2trackvis
+-e ./cat12
+-e ./cmtk
+-e ./dcmstack
+-e ./diffusion_toolkit
+-e ./dipy
+-e ./dtitk
+-e ./dynamic_slicer
+-e ./elastix
+-e ./freesurfer
+-e ./fsl
+-e ./meshfix
+-e ./minc
+-e ./mipav
+-e ./niftyfit
+-e ./niftyreg
+-e ./niftyseg
+-e ./nilearn
+-e ./nitime
+-e ./petpvc
+-e ./quickshear
+-e ./robex
+-e ./semtools
+-e ./slicer
+-e ./spm
+-e ./vista
+-e ./workbench
\ No newline at end of file
diff --git a/required-fileformats/robex/LICENSE b/required-fileformats/robex/LICENSE
new file mode 100644
index 00000000..e00bcb30
--- /dev/null
+++ b/required-fileformats/robex/LICENSE
@@ -0,0 +1,13 @@
+   Copyright 2021 Nipype developers
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/required-fileformats/robex/README.rst b/required-fileformats/robex/README.rst
new file mode 100644
index 00000000..016cd354
--- /dev/null
+++ b/required-fileformats/robex/README.rst
@@ -0,0 +1,39 @@
+How to customise this template
+==============================
+
+#. Rename the `related-packages/fileformats/robex` directory to the name of the fileformats subpackage (e.g. `medimage_fsl`)
+#. Search and replace "robex" with the name of the fileformats subpackage the extras are to be added
+#. Replace name + email placeholders in `pyproject.toml` for developers and maintainers
+#. Add the extension file-format classes
+#. Ensure that all the extension file-format classes are imported into the extras package root, i.e. `fileformats/robex`
+#. Delete these instructions
+
+...
+
+FileFormats Extension - robex
+====================================
+.. image:: https://github.com/nipype/pydra-robex/actions/workflows/ci-cd.yml/badge.svg
+    :target: https://github.com/nipype/pydra-robex/actions/workflows/ci-cd.yml
+
+This is the "robex" extension module for the
+`fileformats <https://github.com/ArcanaFramework/fileformats-core>`__ package
+
+
+Quick Installation
+------------------
+
+This extension can be installed for Python 3 using *pip*::
+
+    $ pip3 install fileformats-robex
+
+This will install the core package and any other dependencies
+
+License
+-------
+
+This work is licensed under a
+`Creative Commons Attribution 4.0 International License <http://creativecommons.org/licenses/by/4.0/>`_
+
+.. image:: https://i.creativecommons.org/l/by/4.0/88x31.png
+  :target: http://creativecommons.org/licenses/by/4.0/
+  :alt: Creative Commons Attribution 4.0 International License
diff --git a/required-fileformats/robex/fileformats/medimage_robex/__init__.py b/required-fileformats/robex/fileformats/medimage_robex/__init__.py
new file mode 100644
index 00000000..10bd9c0d
--- /dev/null
+++ b/required-fileformats/robex/fileformats/medimage_robex/__init__.py
@@ -0,0 +1 @@
+from fileformats.generic import File
\ No newline at end of file
diff --git a/required-fileformats/robex/fileformats/medimage_robex/_version.py b/required-fileformats/robex/fileformats/medimage_robex/_version.py
new file mode 100644
index 00000000..ecda9af7
--- /dev/null
+++ b/required-fileformats/robex/fileformats/medimage_robex/_version.py
@@ -0,0 +1,16 @@
+# file generated by setuptools_scm
+# don't change, don't track in version control
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple, Union
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '0.2.3.dev42+gb9e3ee9.d20240226'
+__version_tuple__ = version_tuple = (0, 2, 3, 'dev42', 'gb9e3ee9.d20240226')
diff --git a/required-fileformats/robex/pyproject.toml b/required-fileformats/robex/pyproject.toml
new file mode 100644
index 00000000..8e26dff6
--- /dev/null
+++ b/required-fileformats/robex/pyproject.toml
@@ -0,0 +1,84 @@
+[build-system]
+requires = ["hatchling", "hatch-vcs"]
+build-backend = "hatchling.build"
+
+[project]
+name = "fileformats-medimage-robex"
+description = "Classes for representing different file formats in Python classes for use in type hinting in data workflows"
+readme = "README.rst"
+requires-python = ">=3.8"
+dependencies = [
+    "fileformats",
+    "fileformats-medimage"
+]
+license = {file = "LICENSE"}
+authors = [
+    {name = "Thomas G. Close", email = "tom.g.close@gmail.com"},
+]
+maintainers = [
+    {name = "Thomas G. Close", email = "tom.g.close@gmail.com"},
+]
+keywords = [
+    "file formats",
+    "data",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: Apache Software License",
+    "Operating System :: MacOS :: MacOS X",
+    "Operating System :: Microsoft :: Windows",
+    "Operating System :: POSIX :: Linux",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Topic :: Scientific/Engineering",
+]
+dynamic = ["version"]
+
+[project.optional-dependencies]
+dev = [
+    "black",
+    "pre-commit",
+    "codespell",
+    "flake8",
+    "flake8-pyproject",
+]
+test = [
+    "pytest >=6.2.5",
+    "pytest-env>=0.6.2",
+    "pytest-cov>=2.12.1",
+    "codecov",
+    "fileformats-medimage-CHANGME-extras",
+]
+
+[project.urls]
+repository = "https://github.com/nipype/pydra-robex"
+
+[tool.hatch.version]
+source = "vcs"
+raw-options = { root = "../.." }
+
+[tool.hatch.build.hooks.vcs]
+version-file = "fileformats/medimage_robex/_version.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["fileformats"]
+
+[tool.black]
+target-version = ['py38']
+exclude = "fileformats/medimage_robex/_version.py"
+
+[tool.codespell]
+ignore-words = ".codespell-ignorewords"
+
+[tool.flake8]
+doctests = true
+per-file-ignores = [
+    "__init__.py:F401"
+]
+max-line-length = 88
+select = "C,E,F,W,B,B950"
+extend-ignore = ['E203', 'E501', 'E129']
diff --git a/required-fileformats/semtools/LICENSE b/required-fileformats/semtools/LICENSE
new file mode 100644
index 00000000..e00bcb30
--- /dev/null
+++ b/required-fileformats/semtools/LICENSE
@@ -0,0 +1,13 @@
+   Copyright 2021 Nipype developers
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/required-fileformats/semtools/README.rst b/required-fileformats/semtools/README.rst
new file mode 100644
index 00000000..24d10445
--- /dev/null
+++ b/required-fileformats/semtools/README.rst
@@ -0,0 +1,39 @@
+How to customise this template
+==============================
+
+#. Rename the `related-packages/fileformats/semtools` directory to the name of the fileformats subpackage (e.g. `medimage_fsl`)
+#. Search and replace "semtools" with the name of the fileformats subpackage the extras are to be added
+#. Replace name + email placeholders in `pyproject.toml` for developers and maintainers
+#. Add the extension file-format classes
+#. Ensure that all the extension file-format classes are imported into the extras package root, i.e. `fileformats/semtools`
+#. Delete these instructions
+
+...
+
+FileFormats Extension - semtools
+====================================
+.. image:: https://github.com/nipype/pydra-semtools/actions/workflows/ci-cd.yml/badge.svg
+    :target: https://github.com/nipype/pydra-semtools/actions/workflows/ci-cd.yml
+
+This is the "semtools" extension module for the
+`fileformats <https://github.com/ArcanaFramework/fileformats-core>`__ package
+
+
+Quick Installation
+------------------
+
+This extension can be installed for Python 3 using *pip*::
+
+    $ pip3 install fileformats-semtools
+
+This will install the core package and any other dependencies
+
+License
+-------
+
+This work is licensed under a
+`Creative Commons Attribution 4.0 International License <http://creativecommons.org/licenses/by/4.0/>`_
+
+.. image:: https://i.creativecommons.org/l/by/4.0/88x31.png
+  :target: http://creativecommons.org/licenses/by/4.0/
+  :alt: Creative Commons Attribution 4.0 International License
diff --git a/required-fileformats/semtools/fileformats/medimage_semtools/__init__.py b/required-fileformats/semtools/fileformats/medimage_semtools/__init__.py
new file mode 100644
index 00000000..10bd9c0d
--- /dev/null
+++ b/required-fileformats/semtools/fileformats/medimage_semtools/__init__.py
@@ -0,0 +1 @@
+from fileformats.generic import File
\ No newline at end of file
diff --git a/required-fileformats/semtools/fileformats/medimage_semtools/_version.py b/required-fileformats/semtools/fileformats/medimage_semtools/_version.py
new file mode 100644
index 00000000..ecda9af7
--- /dev/null
+++ b/required-fileformats/semtools/fileformats/medimage_semtools/_version.py
@@ -0,0 +1,16 @@
+# file generated by setuptools_scm
+# don't change, don't track in version control
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple, Union
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '0.2.3.dev42+gb9e3ee9.d20240226'
+__version_tuple__ = version_tuple = (0, 2, 3, 'dev42', 'gb9e3ee9.d20240226')
diff --git a/required-fileformats/semtools/pyproject.toml b/required-fileformats/semtools/pyproject.toml
new file mode 100644
index 00000000..f1352036
--- /dev/null
+++ b/required-fileformats/semtools/pyproject.toml
@@ -0,0 +1,84 @@
+[build-system]
+requires = ["hatchling", "hatch-vcs"]
+build-backend = "hatchling.build"
+
+[project]
+name = "fileformats-medimage-semtools"
+description = "Classes for representing different file formats in Python classes for use in type hinting in data workflows"
+readme = "README.rst"
+requires-python = ">=3.8"
+dependencies = [
+    "fileformats",
+    "fileformats-medimage"
+]
+license = {file = "LICENSE"}
+authors = [
+    {name = "Thomas G. Close", email = "tom.g.close@gmail.com"},
+]
+maintainers = [
+    {name = "Thomas G. Close", email = "tom.g.close@gmail.com"},
+]
+keywords = [
+    "file formats",
+    "data",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: Apache Software License",
+    "Operating System :: MacOS :: MacOS X",
+    "Operating System :: Microsoft :: Windows",
+    "Operating System :: POSIX :: Linux",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Topic :: Scientific/Engineering",
+]
+dynamic = ["version"]
+
+[project.optional-dependencies]
+dev = [
+    "black",
+    "pre-commit",
+    "codespell",
+    "flake8",
+    "flake8-pyproject",
+]
+test = [
+    "pytest >=6.2.5",
+    "pytest-env>=0.6.2",
+    "pytest-cov>=2.12.1",
+    "codecov",
+    "fileformats-medimage-CHANGME-extras",
+]
+
+[project.urls]
+repository = "https://github.com/nipype/pydra-semtools"
+
+[tool.hatch.version]
+source = "vcs"
+raw-options = { root = "../.." }
+
+[tool.hatch.build.hooks.vcs]
+version-file = "fileformats/medimage_semtools/_version.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["fileformats"]
+
+[tool.black]
+target-version = ['py38']
+exclude = "fileformats/medimage_semtools/_version.py"
+
+[tool.codespell]
+ignore-words = ".codespell-ignorewords"
+
+[tool.flake8]
+doctests = true
+per-file-ignores = [
+    "__init__.py:F401"
+]
+max-line-length = 88
+select = "C,E,F,W,B,B950"
+extend-ignore = ['E203', 'E501', 'E129']
diff --git a/required-fileformats/slicer/LICENSE b/required-fileformats/slicer/LICENSE
new file mode 100644
index 00000000..e00bcb30
--- /dev/null
+++ b/required-fileformats/slicer/LICENSE
@@ -0,0 +1,13 @@
+   Copyright 2021 Nipype developers
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/required-fileformats/slicer/README.rst b/required-fileformats/slicer/README.rst
new file mode 100644
index 00000000..44f67009
--- /dev/null
+++ b/required-fileformats/slicer/README.rst
@@ -0,0 +1,39 @@
+How to customise this template
+==============================
+
+#. Rename the `related-packages/fileformats/slicer` directory to the name of the fileformats subpackage (e.g. `medimage_fsl`)
+#. Search and replace "slicer" with the name of the fileformats subpackage the extras are to be added
+#. Replace name + email placeholders in `pyproject.toml` for developers and maintainers
+#. Add the extension file-format classes
+#. Ensure that all the extension file-format classes are imported into the extras package root, i.e. `fileformats/slicer`
+#. Delete these instructions
+
+...
+
+FileFormats Extension - slicer
+====================================
+.. image:: https://github.com/nipype/pydra-slicer/actions/workflows/ci-cd.yml/badge.svg
+    :target: https://github.com/nipype/pydra-slicer/actions/workflows/ci-cd.yml
+
+This is the "slicer" extension module for the
+`fileformats <https://github.com/ArcanaFramework/fileformats-core>`__ package
+
+
+Quick Installation
+------------------
+
+This extension can be installed for Python 3 using *pip*::
+
+    $ pip3 install fileformats-slicer
+
+This will install the core package and any other dependencies
+
+License
+-------
+
+This work is licensed under a
+`Creative Commons Attribution 4.0 International License <http://creativecommons.org/licenses/by/4.0/>`_
+
+.. image:: https://i.creativecommons.org/l/by/4.0/88x31.png
+  :target: http://creativecommons.org/licenses/by/4.0/
+  :alt: Creative Commons Attribution 4.0 International License
diff --git a/required-fileformats/slicer/fileformats/medimage_slicer/__init__.py b/required-fileformats/slicer/fileformats/medimage_slicer/__init__.py
new file mode 100644
index 00000000..10bd9c0d
--- /dev/null
+++ b/required-fileformats/slicer/fileformats/medimage_slicer/__init__.py
@@ -0,0 +1 @@
+from fileformats.generic import File
\ No newline at end of file
diff --git a/required-fileformats/slicer/fileformats/medimage_slicer/_version.py b/required-fileformats/slicer/fileformats/medimage_slicer/_version.py
new file mode 100644
index 00000000..ecda9af7
--- /dev/null
+++ b/required-fileformats/slicer/fileformats/medimage_slicer/_version.py
@@ -0,0 +1,16 @@
+# file generated by setuptools_scm
+# don't change, don't track in version control
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple, Union
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '0.2.3.dev42+gb9e3ee9.d20240226'
+__version_tuple__ = version_tuple = (0, 2, 3, 'dev42', 'gb9e3ee9.d20240226')
diff --git a/required-fileformats/slicer/pyproject.toml b/required-fileformats/slicer/pyproject.toml
new file mode 100644
index 00000000..87c95a8a
--- /dev/null
+++ b/required-fileformats/slicer/pyproject.toml
@@ -0,0 +1,84 @@
+[build-system]
+requires = ["hatchling", "hatch-vcs"]
+build-backend = "hatchling.build"
+
+[project]
+name = "fileformats-medimage-slicer"
+description = "Classes for representing different file formats in Python classes for use in type hinting in data workflows"
+readme = "README.rst"
+requires-python = ">=3.8"
+dependencies = [
+    "fileformats",
+    "fileformats-medimage"
+]
+license = {file = "LICENSE"}
+authors = [
+    {name = "Thomas G. Close", email = "tom.g.close@gmail.com"},
+]
+maintainers = [
+    {name = "Thomas G. Close", email = "tom.g.close@gmail.com"},
+]
+keywords = [
+    "file formats",
+    "data",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: Apache Software License",
+    "Operating System :: MacOS :: MacOS X",
+    "Operating System :: Microsoft :: Windows",
+    "Operating System :: POSIX :: Linux",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Topic :: Scientific/Engineering",
+]
+dynamic = ["version"]
+
+[project.optional-dependencies]
+dev = [
+    "black",
+    "pre-commit",
+    "codespell",
+    "flake8",
+    "flake8-pyproject",
+]
+test = [
+    "pytest >=6.2.5",
+    "pytest-env>=0.6.2",
+    "pytest-cov>=2.12.1",
+    "codecov",
+    "fileformats-medimage-CHANGME-extras",
+]
+
+[project.urls]
+repository = "https://github.com/nipype/pydra-slicer"
+
+[tool.hatch.version]
+source = "vcs"
+raw-options = { root = "../.." }
+
+[tool.hatch.build.hooks.vcs]
+version-file = "fileformats/medimage_slicer/_version.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["fileformats"]
+
+[tool.black]
+target-version = ['py38']
+exclude = "fileformats/medimage_slicer/_version.py"
+
+[tool.codespell]
+ignore-words = ".codespell-ignorewords"
+
+[tool.flake8]
+doctests = true
+per-file-ignores = [
+    "__init__.py:F401"
+]
+max-line-length = 88
+select = "C,E,F,W,B,B950"
+extend-ignore = ['E203', 'E501', 'E129']
diff --git a/required-fileformats/spm/LICENSE b/required-fileformats/spm/LICENSE
new file mode 100644
index 00000000..e00bcb30
--- /dev/null
+++ b/required-fileformats/spm/LICENSE
@@ -0,0 +1,13 @@
+   Copyright 2021 Nipype developers
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/required-fileformats/spm/README.rst b/required-fileformats/spm/README.rst
new file mode 100644
index 00000000..cd3d8564
--- /dev/null
+++ b/required-fileformats/spm/README.rst
@@ -0,0 +1,39 @@
+How to customise this template
+==============================
+
+#. Rename the `related-packages/fileformats/spm` directory to the name of the fileformats subpackage (e.g. `medimage_fsl`)
+#. Search and replace "spm" with the name of the fileformats subpackage the extras are to be added
+#. Replace name + email placeholders in `pyproject.toml` for developers and maintainers
+#. Add the extension file-format classes
+#. Ensure that all the extension file-format classes are imported into the extras package root, i.e. `fileformats/spm`
+#. Delete these instructions
+
+...
+
+FileFormats Extension - spm
+====================================
+.. image:: https://github.com/nipype/pydra-spm/actions/workflows/ci-cd.yml/badge.svg
+    :target: https://github.com/nipype/pydra-spm/actions/workflows/ci-cd.yml
+
+This is the "spm" extension module for the
+`fileformats <https://github.com/ArcanaFramework/fileformats-core>`__ package
+
+
+Quick Installation
+------------------
+
+This extension can be installed for Python 3 using *pip*::
+
+    $ pip3 install fileformats-spm
+
+This will install the core package and any other dependencies
+
+License
+-------
+
+This work is licensed under a
+`Creative Commons Attribution 4.0 International License <http://creativecommons.org/licenses/by/4.0/>`_
+
+.. image:: https://i.creativecommons.org/l/by/4.0/88x31.png
+  :target: http://creativecommons.org/licenses/by/4.0/
+  :alt: Creative Commons Attribution 4.0 International License
diff --git a/required-fileformats/spm/fileformats/medimage_spm/__init__.py b/required-fileformats/spm/fileformats/medimage_spm/__init__.py
new file mode 100644
index 00000000..10bd9c0d
--- /dev/null
+++ b/required-fileformats/spm/fileformats/medimage_spm/__init__.py
@@ -0,0 +1 @@
+from fileformats.generic import File
\ No newline at end of file
diff --git a/required-fileformats/spm/fileformats/medimage_spm/_version.py b/required-fileformats/spm/fileformats/medimage_spm/_version.py
new file mode 100644
index 00000000..ecda9af7
--- /dev/null
+++ b/required-fileformats/spm/fileformats/medimage_spm/_version.py
@@ -0,0 +1,16 @@
+# file generated by setuptools_scm
+# don't change, don't track in version control
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple, Union
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '0.2.3.dev42+gb9e3ee9.d20240226'
+__version_tuple__ = version_tuple = (0, 2, 3, 'dev42', 'gb9e3ee9.d20240226')
diff --git a/required-fileformats/spm/pyproject.toml b/required-fileformats/spm/pyproject.toml
new file mode 100644
index 00000000..cb29880b
--- /dev/null
+++ b/required-fileformats/spm/pyproject.toml
@@ -0,0 +1,84 @@
+[build-system]
+requires = ["hatchling", "hatch-vcs"]
+build-backend = "hatchling.build"
+
+[project]
+name = "fileformats-medimage-spm"
+description = "Classes for representing different file formats in Python classes for use in type hinting in data workflows"
+readme = "README.rst"
+requires-python = ">=3.8"
+dependencies = [
+    "fileformats",
+    "fileformats-medimage"
+]
+license = {file = "LICENSE"}
+authors = [
+    {name = "Thomas G. Close", email = "tom.g.close@gmail.com"},
+]
+maintainers = [
+    {name = "Thomas G. Close", email = "tom.g.close@gmail.com"},
+]
+keywords = [
+    "file formats",
+    "data",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: Apache Software License",
+    "Operating System :: MacOS :: MacOS X",
+    "Operating System :: Microsoft :: Windows",
+    "Operating System :: POSIX :: Linux",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Topic :: Scientific/Engineering",
+]
+dynamic = ["version"]
+
+[project.optional-dependencies]
+dev = [
+    "black",
+    "pre-commit",
+    "codespell",
+    "flake8",
+    "flake8-pyproject",
+]
+test = [
+    "pytest >=6.2.5",
+    "pytest-env>=0.6.2",
+    "pytest-cov>=2.12.1",
+    "codecov",
+    "fileformats-medimage-CHANGME-extras",
+]
+
+[project.urls]
+repository = "https://github.com/nipype/pydra-spm"
+
+[tool.hatch.version]
+source = "vcs"
+raw-options = { root = "../.." }
+
+[tool.hatch.build.hooks.vcs]
+version-file = "fileformats/medimage_spm/_version.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["fileformats"]
+
+[tool.black]
+target-version = ['py38']
+exclude = "fileformats/medimage_spm/_version.py"
+
+[tool.codespell]
+ignore-words = ".codespell-ignorewords"
+
+[tool.flake8]
+doctests = true
+per-file-ignores = [
+    "__init__.py:F401"
+]
+max-line-length = 88
+select = "C,E,F,W,B,B950"
+extend-ignore = ['E203', 'E501', 'E129']
diff --git a/required-fileformats/vista/LICENSE b/required-fileformats/vista/LICENSE
new file mode 100644
index 00000000..e00bcb30
--- /dev/null
+++ b/required-fileformats/vista/LICENSE
@@ -0,0 +1,13 @@
+   Copyright 2021 Nipype developers
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/required-fileformats/vista/README.rst b/required-fileformats/vista/README.rst
new file mode 100644
index 00000000..8bb32102
--- /dev/null
+++ b/required-fileformats/vista/README.rst
@@ -0,0 +1,39 @@
+How to customise this template
+==============================
+
+#. Rename the `related-packages/fileformats/vista` directory to the name of the fileformats subpackage (e.g. `medimage_fsl`)
+#. Search and replace "vista" with the name of the fileformats subpackage the extras are to be added
+#. Replace name + email placeholders in `pyproject.toml` for developers and maintainers
+#. Add the extension file-format classes
+#. Ensure that all the extension file-format classes are imported into the extras package root, i.e. `fileformats/vista`
+#. Delete these instructions
+
+...
+
+FileFormats Extension - vista
+====================================
+.. image:: https://github.com/nipype/pydra-vista/actions/workflows/ci-cd.yml/badge.svg
+    :target: https://github.com/nipype/pydra-vista/actions/workflows/ci-cd.yml
+
+This is the "vista" extension module for the
+`fileformats <https://github.com/ArcanaFramework/fileformats-core>`__ package
+
+
+Quick Installation
+------------------
+
+This extension can be installed for Python 3 using *pip*::
+
+    $ pip3 install fileformats-vista
+
+This will install the core package and any other dependencies
+
+License
+-------
+
+This work is licensed under a
+`Creative Commons Attribution 4.0 International License <http://creativecommons.org/licenses/by/4.0/>`_
+
+.. image:: https://i.creativecommons.org/l/by/4.0/88x31.png
+  :target: http://creativecommons.org/licenses/by/4.0/
+  :alt: Creative Commons Attribution 4.0 International License
diff --git a/required-fileformats/vista/fileformats/medimage_vista/__init__.py b/required-fileformats/vista/fileformats/medimage_vista/__init__.py
new file mode 100644
index 00000000..1783dd45
--- /dev/null
+++ b/required-fileformats/vista/fileformats/medimage_vista/__init__.py
@@ -0,0 +1,5 @@
+from fileformats.generic import File
+
+class V(File):
+    ext = ".v"
+    binary = True
diff --git a/required-fileformats/vista/fileformats/medimage_vista/_version.py b/required-fileformats/vista/fileformats/medimage_vista/_version.py
new file mode 100644
index 00000000..ecda9af7
--- /dev/null
+++ b/required-fileformats/vista/fileformats/medimage_vista/_version.py
@@ -0,0 +1,16 @@
+# file generated by setuptools_scm
+# don't change, don't track in version control
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple, Union
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '0.2.3.dev42+gb9e3ee9.d20240226'
+__version_tuple__ = version_tuple = (0, 2, 3, 'dev42', 'gb9e3ee9.d20240226')
diff --git a/required-fileformats/vista/pyproject.toml b/required-fileformats/vista/pyproject.toml
new file mode 100644
index 00000000..4e3bc882
--- /dev/null
+++ b/required-fileformats/vista/pyproject.toml
@@ -0,0 +1,84 @@
+[build-system]
+requires = ["hatchling", "hatch-vcs"]
+build-backend = "hatchling.build"
+
+[project]
+name = "fileformats-medimage-vista"
+description = "Classes for representing different file formats in Python classes for use in type hinting in data workflows"
+readme = "README.rst"
+requires-python = ">=3.8"
+dependencies = [
+    "fileformats",
+    "fileformats-medimage"
+]
+license = {file = "LICENSE"}
+authors = [
+    {name = "Thomas G. Close", email = "tom.g.close@gmail.com"},
+]
+maintainers = [
+    {name = "Thomas G. Close", email = "tom.g.close@gmail.com"},
+]
+keywords = [
+    "file formats",
+    "data",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: Apache Software License",
+    "Operating System :: MacOS :: MacOS X",
+    "Operating System :: Microsoft :: Windows",
+    "Operating System :: POSIX :: Linux",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Topic :: Scientific/Engineering",
+]
+dynamic = ["version"]
+
+[project.optional-dependencies]
+dev = [
+    "black",
+    "pre-commit",
+    "codespell",
+    "flake8",
+    "flake8-pyproject",
+]
+test = [
+    "pytest >=6.2.5",
+    "pytest-env>=0.6.2",
+    "pytest-cov>=2.12.1",
+    "codecov",
+    "fileformats-medimage-CHANGME-extras",
+]
+
+[project.urls]
+repository = "https://github.com/nipype/pydra-vista"
+
+[tool.hatch.version]
+source = "vcs"
+raw-options = { root = "../.." }
+
+[tool.hatch.build.hooks.vcs]
+version-file = "fileformats/medimage_vista/_version.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["fileformats"]
+
+[tool.black]
+target-version = ['py38']
+exclude = "fileformats/medimage_vista/_version.py"
+
+[tool.codespell]
+ignore-words = ".codespell-ignorewords"
+
+[tool.flake8]
+doctests = true
+per-file-ignores = [
+    "__init__.py:F401"
+]
+max-line-length = 88
+select = "C,E,F,W,B,B950"
+extend-ignore = ['E203', 'E501', 'E129']
diff --git a/required-fileformats/workbench/LICENSE b/required-fileformats/workbench/LICENSE
new file mode 100644
index 00000000..e00bcb30
--- /dev/null
+++ b/required-fileformats/workbench/LICENSE
@@ -0,0 +1,13 @@
+   Copyright 2021 Nipype developers
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/required-fileformats/workbench/README.rst b/required-fileformats/workbench/README.rst
new file mode 100644
index 00000000..3800b464
--- /dev/null
+++ b/required-fileformats/workbench/README.rst
@@ -0,0 +1,39 @@
+How to customise this template
+==============================
+
+#. Rename the `related-packages/fileformats/workbench` directory to the name of the fileformats subpackage (e.g. `medimage_fsl`)
+#. Search and replace "workbench" with the name of the fileformats subpackage the extras are to be added
+#. Replace name + email placeholders in `pyproject.toml` for developers and maintainers
+#. Add the extension file-format classes
+#. Ensure that all the extension file-format classes are imported into the extras package root, i.e. `fileformats/workbench`
+#. Delete these instructions
+
+...
+
+FileFormats Extension - workbench
+====================================
+.. image:: https://github.com/nipype/pydra-workbench/actions/workflows/ci-cd.yml/badge.svg
+    :target: https://github.com/nipype/pydra-workbench/actions/workflows/ci-cd.yml
+
+This is the "workbench" extension module for the
+`fileformats <https://github.com/ArcanaFramework/fileformats-core>`__ package
+
+
+Quick Installation
+------------------
+
+This extension can be installed for Python 3 using *pip*::
+
+    $ pip3 install fileformats-workbench
+
+This will install the core package and any other dependencies
+
+License
+-------
+
+This work is licensed under a
+`Creative Commons Attribution 4.0 International License <http://creativecommons.org/licenses/by/4.0/>`_
+
+.. image:: https://i.creativecommons.org/l/by/4.0/88x31.png
+  :target: http://creativecommons.org/licenses/by/4.0/
+  :alt: Creative Commons Attribution 4.0 International License
diff --git a/required-fileformats/workbench/fileformats/medimage_workbench/__init__.py b/required-fileformats/workbench/fileformats/medimage_workbench/__init__.py
new file mode 100644
index 00000000..10bd9c0d
--- /dev/null
+++ b/required-fileformats/workbench/fileformats/medimage_workbench/__init__.py
@@ -0,0 +1 @@
+from fileformats.generic import File
\ No newline at end of file
diff --git a/required-fileformats/workbench/fileformats/medimage_workbench/_version.py b/required-fileformats/workbench/fileformats/medimage_workbench/_version.py
new file mode 100644
index 00000000..ecda9af7
--- /dev/null
+++ b/required-fileformats/workbench/fileformats/medimage_workbench/_version.py
@@ -0,0 +1,16 @@
+# file generated by setuptools_scm
+# don't change, don't track in version control
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple, Union
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '0.2.3.dev42+gb9e3ee9.d20240226'
+__version_tuple__ = version_tuple = (0, 2, 3, 'dev42', 'gb9e3ee9.d20240226')
diff --git a/required-fileformats/workbench/pyproject.toml b/required-fileformats/workbench/pyproject.toml
new file mode 100644
index 00000000..1c446a5e
--- /dev/null
+++ b/required-fileformats/workbench/pyproject.toml
@@ -0,0 +1,84 @@
+[build-system]
+requires = ["hatchling", "hatch-vcs"]
+build-backend = "hatchling.build"
+
+[project]
+name = "fileformats-medimage-workbench"
+description = "Classes for representing different file formats in Python classes for use in type hinting in data workflows"
+readme = "README.rst"
+requires-python = ">=3.8"
+dependencies = [
+    "fileformats",
+    "fileformats-medimage"
+]
+license = {file = "LICENSE"}
+authors = [
+    {name = "Thomas G. Close", email = "tom.g.close@gmail.com"},
+]
+maintainers = [
+    {name = "Thomas G. Close", email = "tom.g.close@gmail.com"},
+]
+keywords = [
+    "file formats",
+    "data",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: Apache Software License",
+    "Operating System :: MacOS :: MacOS X",
+    "Operating System :: Microsoft :: Windows",
+    "Operating System :: POSIX :: Linux",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Topic :: Scientific/Engineering",
+]
+dynamic = ["version"]
+
+[project.optional-dependencies]
+dev = [
+    "black",
+    "pre-commit",
+    "codespell",
+    "flake8",
+    "flake8-pyproject",
+]
+test = [
+    "pytest >=6.2.5",
+    "pytest-env>=0.6.2",
+    "pytest-cov>=2.12.1",
+    "codecov",
+    "fileformats-medimage-CHANGME-extras",
+]
+
+[project.urls]
+repository = "https://github.com/nipype/pydra-workbench"
+
+[tool.hatch.version]
+source = "vcs"
+raw-options = { root = "../.." }
+
+[tool.hatch.build.hooks.vcs]
+version-file = "fileformats/medimage_workbench/_version.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["fileformats"]
+
+[tool.black]
+target-version = ['py38']
+exclude = "fileformats/medimage_workbench/_version.py"
+
+[tool.codespell]
+ignore-words = ".codespell-ignorewords"
+
+[tool.flake8]
+doctests = true
+per-file-ignores = [
+    "__init__.py:F401"
+]
+max-line-length = 88
+select = "C,E,F,W,B,B950"
+extend-ignore = ['E203', 'E501', 'E129']
diff --git a/tests/test_task.py b/tests/test_task.py
index a66f283c..ae57c983 100644
--- a/tests/test_task.py
+++ b/tests/test_task.py
@@ -4,7 +4,7 @@
 import logging
 from conftest import show_cli_trace
 from nipype2pydra.cli import task as task_cli
-from nipype2pydra.utils import add_to_sys_path
+from nipype2pydra.utils import add_to_sys_path, add_exc_note
 
 
 logging.basicConfig(level=logging.INFO)
@@ -43,7 +43,10 @@ def test_task_conversion(task_spec_file, cli_runner, work_dir, gen_test_conftest
     assert result.exit_code == 0, show_cli_trace(result)
 
     with add_to_sys_path(pkg_root):
-        pydra_module = import_module(output_module_path)
+        try:
+            pydra_module = import_module(output_module_path)
+        except Exception as e:
+            add_exc_note(e, f"Attempting to import {task_spec['task_name']} from '{output_module_path}'")
     pydra_task = getattr(pydra_module, task_spec["task_name"])
     nipype_interface = getattr(
         import_module(task_spec["nipype_module"]), task_spec["nipype_name"]
@@ -75,11 +78,11 @@ def test_task_conversion(task_spec_file, cli_runner, work_dir, gen_test_conftest
         )
     )    
 
-    tests_fspath = pkg_root.joinpath(*output_module_path.split(".")).parent / "tests"
+    # tests_fspath = pkg_root.joinpath(*output_module_path.split(".")).parent / "tests"
 
-    logging.info("Running generated tests for %s", output_module_path)
-    # Run generated pytests
-    with add_to_sys_path(pkg_root):
-        result = pytest.main([str(tests_fspath)])
+    # # logging.info("Running generated tests for %s", output_module_path)
+    # # # Run generated pytests
+    # # with add_to_sys_path(pkg_root):
+    # #     result = pytest.main([str(tests_fspath)])
 
-    assert result.value == 0
+    # assert result.value == 0

From d6246ca35d689fc010492fad10fdb3399ec8046f Mon Sep 17 00:00:00 2001
From: Tom Close <tom.g.close@gmail.com>
Date: Wed, 28 Feb 2024 11:03:13 +1100
Subject: [PATCH 44/78] bug fixes

---
 conftest.py                                   |  2 +-
 .../task/nipype_internal/pydra-afni/dot.yaml  |  2 +-
 .../nipype_internal/pydra-afni/net_corr.yaml  |  1 +
 .../nipype_internal/pydra-afni/t_norm.yaml    |  4 +--
 nipype2pydra/task/base.py                     | 14 +++++++---
 nipype2pydra/task/function.py                 | 27 ++++++++++++++-----
 nipype2pydra/task/shell_command.py            |  8 ++++++
 .../fileformats/medimage_afni/__init__.py     | 17 ++----------
 tests/test_task.py                            |  3 ++-
 9 files changed, 47 insertions(+), 31 deletions(-)

diff --git a/conftest.py b/conftest.py
index bf742568..0e1fb2e5 100644
--- a/conftest.py
+++ b/conftest.py
@@ -20,7 +20,7 @@ def gen_test_conftest():
 @pytest.fixture(
     params=[
         str(p.relative_to(EXAMPLE_TASKS_DIR)).replace("/", "__")[:-5]
-        for p in (EXAMPLE_TASKS_DIR).glob("nipype_internal/pydra-afni/**/*.yaml")
+        for p in (EXAMPLE_TASKS_DIR).glob("**/*.yaml")
     ]
 )
 def task_spec_file(request):
diff --git a/example-specs/task/nipype_internal/pydra-afni/dot.yaml b/example-specs/task/nipype_internal/pydra-afni/dot.yaml
index 591bd16d..080455bf 100644
--- a/example-specs/task/nipype_internal/pydra-afni/dot.yaml
+++ b/example-specs/task/nipype_internal/pydra-afni/dot.yaml
@@ -40,7 +40,7 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    in_files: medimage-afni/nii[0]+list-of
+    in_files: medimage/nifti+list-of
     # type=list|default=[]: list of input files, possibly with subbrick selectors
     out_file: text/text-file
     # type=file: output file
diff --git a/example-specs/task/nipype_internal/pydra-afni/net_corr.yaml b/example-specs/task/nipype_internal/pydra-afni/net_corr.yaml
index 93e00dba..7c22c5fd 100644
--- a/example-specs/task/nipype_internal/pydra-afni/net_corr.yaml
+++ b/example-specs/task/nipype_internal/pydra-afni/net_corr.yaml
@@ -56,6 +56,7 @@ inputs:
 outputs:
   omit:
   # list[str] - fields to omit from the Pydra interface
+  - out_file
   rename:
   # dict[str, str] - fields to rename in the Pydra interface
   types:
diff --git a/example-specs/task/nipype_internal/pydra-afni/t_norm.yaml b/example-specs/task/nipype_internal/pydra-afni/t_norm.yaml
index 064b244c..5235bffb 100644
--- a/example-specs/task/nipype_internal/pydra-afni/t_norm.yaml
+++ b/example-specs/task/nipype_internal/pydra-afni/t_norm.yaml
@@ -39,7 +39,7 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/nifti1
     # type=file|default=<undefined>: input file to 3dTNorm
-    out_file: medimage-afni/unit errts+tlrc
+    out_file: generic/file
     # type=file: output file
     # type=file|default=<undefined>: output image file name
   metadata:
@@ -55,7 +55,7 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    out_file: medimage-afni/unit errts+tlrc
+    out_file: generic/file
     # type=file: output file
     # type=file|default=<undefined>: output image file name
   callables:
diff --git a/nipype2pydra/task/base.py b/nipype2pydra/task/base.py
index 6946b45f..aa1453b1 100644
--- a/nipype2pydra/task/base.py
+++ b/nipype2pydra/task/base.py
@@ -2,6 +2,7 @@
 from pathlib import Path
 import typing as ty
 import re
+import logging
 from abc import ABCMeta, abstractmethod
 from importlib import import_module
 from types import ModuleType
@@ -24,6 +25,8 @@
 
 T = ty.TypeVar("T")
 
+logger = logging.getLogger("nipype2pydra")
+
 
 def from_dict_converter(
     obj: ty.Union[T, dict], klass: ty.Type[T], allow_none=False
@@ -534,9 +537,10 @@ def pydra_fld_input(self, field, nm):
                 tmpl = self.string_formats(argstr=template, name=name_source[0])
             else:
                 tmpl = template
-            pydra_metadata["output_file_template"] = tmpl
+            if nm in self.nipype_interface.output_spec().class_trait_names():
+                pydra_metadata["output_file_template"] = tmpl
             if pydra_type in [specs.File, specs.Directory]:
-                pydra_type = str
+                pydra_type = Path
         elif getattr(field, "genfile"):
             if nm in self.outputs.templates:
                 try:
@@ -713,8 +717,10 @@ def write_task(self, filename, input_fields, nonstd_types, output_fields):
             spec_str, fast=False, mode=black.FileMode()
         )
 
+        # FIXME: bit of a hack, should make sure that multi-input/output objects
+        #        are referenced properly without this substitution
         spec_str = re.sub(
-            r"(?<!specs\.)Multi(Input|Output)", r"specs.Multi\1", spec_str
+            r"(?<!specs\.|mport )Multi(Input|Output)", r"specs.Multi\1", spec_str
         )
 
         with open(filename, "w") as f:
@@ -745,7 +751,7 @@ def add_import(stmt):
                 pass
             else:
                 if prev_stmt != stmt:
-                    raise ValueError(
+                    logger.warning(
                         f"Cannot add import statement {stmt} as it clashes with "
                         f"previous import {prev_stmt}"
                     )
diff --git a/nipype2pydra/task/function.py b/nipype2pydra/task/function.py
index eb3474fb..b7ab0a79 100644
--- a/nipype2pydra/task/function.py
+++ b/nipype2pydra/task/function.py
@@ -497,9 +497,9 @@ def _get_referenced(
                 )
             )
         for func in ref_local_funcs:
-            referenced_inputs.update(
-                self._get_referenced(func, referenced_funcs, referenced_methods)
-            )
+            rf_inputs, rf_outputs = self._get_referenced(func, referenced_funcs, referenced_methods)
+            referenced_inputs.update(rf_inputs)
+            referenced_outputs.update(rf_outputs)
         for meth in ref_methods:
             ref_inputs, ref_outputs = self._get_referenced(
                 meth,
@@ -575,7 +575,7 @@ def insert_args_in_signature(cls, snippet: str, new_args: ty.Iterable[str]) -> s
         return pre + ", ".join(args + new_args) + post
 
 
-def split_parens_contents(snippet):
+def split_parens_contents(snippet, brackets: bool = False):
     """Splits the code snippet at the first opening parenthesis into a 3-tuple
     consisting of the pre-paren text, the contents of the parens and the post-paren
 
@@ -583,6 +583,8 @@ def split_parens_contents(snippet):
     ----------
     snippet: str
         the code snippet to split
+    brackets: bool, optional
+        whether to split at brackets instead of parens, by default False
 
     Returns
     -------
@@ -593,15 +595,23 @@ def split_parens_contents(snippet):
     post: str
         the text after the closing parenthesis
     """
-    splits = re.split(r"(\(|\))", snippet, flags=re.MULTILINE | re.DOTALL)
+    if brackets:
+        open = '['
+        close = ']'
+        pattern = r"(\[|\])"
+    else:
+        open = '('
+        close = ')'
+        pattern = r"(\(|\))"
+    splits = re.split(pattern, snippet, flags=re.MULTILINE | re.DOTALL)
     depth = 1
     pre = "".join(splits[:2])
     contents = ""
     for i, s in enumerate(splits[2:], start=2):
-        if s == "(":
+        if s == open:
             depth += 1
         else:
-            if s == ")":
+            if s == close:
                 depth -= 1
                 if depth == 0:
                     return pre, contents, "".join(splits[i:])
@@ -627,6 +637,9 @@ def get_local_constants(mod):
         if "(" in following.splitlines()[0]:
             pre, args, _ = split_parens_contents(following)
             local_vars.append((attr_name, pre + re.sub(r"\n *", "", args) + ")"))
+        elif "[" in following.splitlines()[0]:
+            pre, args, _ = split_parens_contents(following, brackets=True)
+            local_vars.append((attr_name, pre + re.sub(r"\n *", "", args) + "]"))
         else:
             local_vars.append((attr_name, following.splitlines()[0]))
     return local_vars
diff --git a/nipype2pydra/task/shell_command.py b/nipype2pydra/task/shell_command.py
index c877c733..ba8f184f 100644
--- a/nipype2pydra/task/shell_command.py
+++ b/nipype2pydra/task/shell_command.py
@@ -1,8 +1,10 @@
 import re
 import attrs
 import inspect
+from copy import copy
 from .base import BaseTaskConverter
 from fileformats.core.mixin import WithClassifiers
+from fileformats.generic import File, Directory
 
 
 @attrs.define
@@ -35,6 +37,8 @@ def unwrap_field_type(t):
                 return f"{t.unclassified.__name__}[{unwraped_classifiers}]"
             return t.__name__
 
+        nonstd_types = copy(nonstd_types)
+
         def types_to_names(spec_fields):
             spec_fields_str = []
             for el in spec_fields:
@@ -50,6 +54,10 @@ def types_to_names(spec_fields):
                         # Alter modules in type string to match those that will be imported
                         field_type_str = field_type_str.replace("typing", "ty")
                         field_type_str = re.sub(r"(\w+\.)+(?<!ty\.)(\w+)", r"\2", field_type_str)
+                if field_type_str == "File":
+                    nonstd_types.add(File)
+                elif field_type_str == "Directory":
+                    nonstd_types.add(Directory)
                 el[1] = "#" + field_type_str + "#"
                 spec_fields_str.append(tuple(el))
             return spec_fields_str
diff --git a/required-fileformats/afni/fileformats/medimage_afni/__init__.py b/required-fileformats/afni/fileformats/medimage_afni/__init__.py
index 92a2733f..c3c838d1 100644
--- a/required-fileformats/afni/fileformats/medimage_afni/__init__.py
+++ b/required-fileformats/afni/fileformats/medimage_afni/__init__.py
@@ -1,12 +1,9 @@
 from fileformats.generic import File
 
-class Oned(File):
-    ext = ".1D"
-    binary = True
-
 
 class Oned(File):
-    ext = ".1d"
+    ext = ".1D"
+    alternate_exts = (".1d",)
     binary = True
 
 
@@ -38,13 +35,3 @@ class Dset(File):
 class Head(File):
     ext = ".HEAD"
     binary = True
-
-
-class Nii[0](File):
-    ext = ".nii[0]"
-    binary = True
-
-
-class Unit errts+tlrc(File):
-    ext = ".unit errts+tlrc"
-    binary = True
diff --git a/tests/test_task.py b/tests/test_task.py
index ae57c983..ef2b505a 100644
--- a/tests/test_task.py
+++ b/tests/test_task.py
@@ -47,6 +47,7 @@ def test_task_conversion(task_spec_file, cli_runner, work_dir, gen_test_conftest
             pydra_module = import_module(output_module_path)
         except Exception as e:
             add_exc_note(e, f"Attempting to import {task_spec['task_name']} from '{output_module_path}'")
+            raise e
     pydra_task = getattr(pydra_module, task_spec["task_name"])
     nipype_interface = getattr(
         import_module(task_spec["nipype_module"]), task_spec["nipype_name"]
@@ -76,7 +77,7 @@ def test_task_conversion(task_spec_file, cli_runner, work_dir, gen_test_conftest
             or n in outputs_omit
             or (n.endswith("_items") and n[: -len("_items")] in nipype_output_names)
         )
-    )    
+    )
 
     # tests_fspath = pkg_root.joinpath(*output_module_path.split(".")).parent / "tests"
 

From 3571f8037c438bb491ed9b7c02e429fd63cde70a Mon Sep 17 00:00:00 2001
From: Tom Close <tom.g.close@gmail.com>
Date: Wed, 28 Feb 2024 14:24:07 +1100
Subject: [PATCH 45/78] added mriqc yaml

---
 scripts/pkg_gen/mriqc.yaml | 49 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 49 insertions(+)
 create mode 100644 scripts/pkg_gen/mriqc.yaml

diff --git a/scripts/pkg_gen/mriqc.yaml b/scripts/pkg_gen/mriqc.yaml
new file mode 100644
index 00000000..02cdb70a
--- /dev/null
+++ b/scripts/pkg_gen/mriqc.yaml
@@ -0,0 +1,49 @@
+packages:
+- anatomical
+- bids
+- common
+- data_types
+- datalad
+- diffusion
+- functional
+- reports
+- synthstrip
+- tests
+- transitional
+- webapi
+interfaces:
+  anatomical:
+  - ArtifactMask
+  - ComputeQI2
+  - Harmonize
+  - RotationMask   
+  - StructuralQC  
+  bids:
+  - IQMFileSink
+  common:
+  - EnsureSize
+  - ConformImage
+  datalad:
+  - DataladIdentityInterface
+  diffusion:
+  - ReadDWIMetadata
+  - WeightedStat
+  - NumberOfShells
+  - ExtractB0
+  - CorrectSignalDrift
+  - SplitShells
+  - FilterShells
+  - DipyDTI
+  functional:
+  - FunctionalQC
+  - Spikes
+  - SelectEcho
+  - GatherTimeseries
+  reports:
+  - AddProvenance
+  synthstrip:
+  - SynthStrip
+  transitional:
+  - GCOR
+  webapi:
+  - UploadIQMs

From d468d04765d75a80095f45a2e10fb628fe876c74 Mon Sep 17 00:00:00 2001
From: Tom Close <tom.g.close@gmail.com>
Date: Thu, 29 Feb 2024 18:14:16 +1100
Subject: [PATCH 46/78] updated generate script

---
 scripts/pkg_gen/resources/nipype-auto-convert.py | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/scripts/pkg_gen/resources/nipype-auto-convert.py b/scripts/pkg_gen/resources/nipype-auto-convert.py
index 72dc760f..32377c96 100644
--- a/scripts/pkg_gen/resources/nipype-auto-convert.py
+++ b/scripts/pkg_gen/resources/nipype-auto-convert.py
@@ -8,7 +8,7 @@
 import yaml
 import nipype
 import nipype2pydra.utils
-from nipype2pydra.task import TaskConverter
+from nipype2pydra.task import get_converter
 
 
 SPECS_DIR = Path(__file__).parent / "specs"
@@ -35,6 +35,7 @@
 if auto_dir.exists():
     shutil.rmtree(auto_dir)
 
+all_interfaces = []
 for fspath in sorted(SPECS_DIR.glob("**/*.yaml")):
     with open(fspath) as f:
         spec = yaml.load(f, Loader=yaml.SafeLoader)
@@ -49,13 +50,14 @@
 
     module_name = nipype2pydra.utils.to_snake_case(spec["task_name"])
 
-    converter = TaskConverter(
+    converter = get_converter(
         output_module=f"pydra.tasks.{PKG_NAME}.auto.{module_name}",
         callables_module=callables,  # type: ignore
         **spec,
     )
     converter.generate(PKG_ROOT)
     auto_init += f"from .{module_name} import {converter.task_name}\n"
+    all_interfaces.append(converter.task_name)
 
 
 with open(PKG_ROOT / "pydra" / "tasks" / PKG_NAME / "auto" / "_version.py", "w") as f:
@@ -68,5 +70,7 @@
 """
     )
 
+auto_init += "\n\n__all__ = [\n" + "\n".join(f"    \"{i}\"," for i in all_interfaces) + "\n]\n"
+
 with open(PKG_ROOT / "pydra" / "tasks" / PKG_NAME / "auto" / "__init__.py", "w") as f:
     f.write(auto_init)

From d2a834f8a92b27a0503f99f2a5ad6ecfdfadb06e Mon Sep 17 00:00:00 2001
From: Tom Close <tom.g.close@gmail.com>
Date: Fri, 1 Mar 2024 15:58:54 +1100
Subject: [PATCH 47/78] added in pass after time out worker

---
 conftest.py                        |  5 ++
 nipype2pydra/task/base.py          | 91 +++++++-----------------------
 nipype2pydra/testing.py            | 46 +++++++++++++++
 scripts/pkg_gen/create_packages.py |  1 +
 4 files changed, 73 insertions(+), 70 deletions(-)
 create mode 100644 nipype2pydra/testing.py

diff --git a/conftest.py b/conftest.py
index 0e1fb2e5..dea8fdd5 100644
--- a/conftest.py
+++ b/conftest.py
@@ -67,6 +67,11 @@ def pytest_exception_interact(call):
     def pytest_internalerror(excinfo):
         raise excinfo.value
 
+    def pytest_configure(config):
+        config.option.capture = 'no'  # allow print statements to show up in the console    
+        config.option.log_cli = True  # show log messages in the console
+        config.option.log_level = "INFO"  # set the log level to INFO
+
     CATCH_CLI_EXCEPTIONS = False
 else:
     CATCH_CLI_EXCEPTIONS = True
diff --git a/nipype2pydra/task/base.py b/nipype2pydra/task/base.py
index aa1453b1..7ff49cee 100644
--- a/nipype2pydra/task/base.py
+++ b/nipype2pydra/task/base.py
@@ -849,7 +849,7 @@ def write_tests(self, filename_test, input_fields, nonstd_types, run=False):
                         spec_str += f"    task.inputs.{nm} = {value}\n"
             if hasattr(self.nipype_interface, "_cmd"):
                 spec_str += r'    print(f"CMDLINE: {task.cmdline}\n\n")' + "\n"
-            spec_str += "    res = task(plugin=\"with-timeout\")\n"
+            spec_str += "    res = task(plugin=PassAfterTimeoutWorker)\n"
             spec_str += "    print('RESULT: ', res)\n"
             for name, value in test.expected_outputs.items():
                 spec_str += f"    assert res.output.{name} == {value}\n"
@@ -858,7 +858,7 @@ def write_tests(self, filename_test, input_fields, nonstd_types, run=False):
         imports = self.construct_imports(
             nonstd_types,
             spec_str,
-            base={"import pytest"}  # , "from conftest import pass_after_timeout"},
+            base={"import pytest", "from nipype2pydra.testing import PassAfterTimeoutWorker"},
         )
         spec_str = "\n".join(imports) + "\n\n" + spec_str
 
@@ -877,7 +877,7 @@ def write_tests(self, filename_test, input_fields, nonstd_types, run=False):
         conftest_fspath = filename_test.parent / "conftest.py"
         if not conftest_fspath.exists():
             with open(conftest_fspath, "w") as f:
-                f.write(self.TIMEOUT_PASS)
+                f.write(self.CONFTEST)
 
     def create_doctests(self, input_fields, nonstd_types):
         """adding doctests to the interfaces"""
@@ -894,7 +894,7 @@ def create_doctests(self, input_fields, nonstd_types):
                     else:
                         val = attrs.NOTHING
                 else:
-                    if type(val) is str:
+                    if isinstance(val, str):
                         val = f'"{val}"'
                 if val is not attrs.NOTHING:
                     doctest_str += f"    >>> task.inputs.{nm} = {val}\n"
@@ -933,74 +933,25 @@ def create_doctests(self, input_fields, nonstd_types):
         "trait_modified",
     ]
 
-    TIMEOUT_PASS = """import time
-from traceback import format_exc
-import threading
-from dataclasses import dataclass
-from _pytest.runner import TestReport
+    CONFTEST = """
+# For debugging in IDE's don't catch raised exceptions and let the IDE
+# break at it
+if os.getenv("_PYTEST_RAISE", "0") != "0":
 
+    @pytest.hookimpl(tryfirst=True)
+    def pytest_exception_interact(call):
+        raise call.excinfo.value  # raise internal errors instead of capturing them
 
-def pass_after_timeout(seconds, poll_interval=0.1):
-    \"\"\"Cancel the test after a certain period, after which it is assumed that the arguments
-    passed to the underying command have passed its internal validation (so we don't have
-    to wait until the tool completes)
+    @pytest.hookimpl(tryfirst=True)
+    def pytest_internalerror(excinfo):
+        raise excinfo.value  # raise internal errors instead of capturing them
 
-    Parameters
-    ----------
-    seconds : int
-        the number of seconds to wait until cancelling the test (and marking it as passed)
-    \"\"\"
-
-    def decorator(test_func):
-        def wrapper(*args, **kwargs):
-            @dataclass
-            class TestState:
-                \"\"\"A way of passing a reference to the result that can be updated by
-                the test thread\"\"\"
-
-                result = None
-                trace_back = None
-
-            state = TestState()
-
-            def test_runner():
-                try:
-                    state.result = test_func(*args, **kwargs)
-                except Exception:
-                    state.trace_back = format_exc()
-                    raise
-
-            thread = threading.Thread(target=test_runner)
-            thread.start()
-
-            # Calculate the end time for the timeout
-            end_time = time.time() + seconds
-
-            while thread.is_alive() and time.time() < end_time:
-                time.sleep(poll_interval)
-
-            if thread.is_alive():
-                thread.join()
-                return state.result
-
-            if state.trace_back:
-                raise state.trace_back
-
-            outcome = "passed after timeout"
-            rep = TestReport.from_item_and_call(
-                item=args[0],
-                when="call",
-                excinfo=None,
-                outcome=outcome,
-                sections=None,
-                duration=0,
-                keywords=None,
-            )
-            args[0].ihook.pytest_runtest_logreport(report=rep)
-
-            return state.result
-
-        return wrapper
+    def pytest_configure(config):
+        config.option.capture = 'no'  # allow print statements to show up in the console
+        config.option.log_cli = True  # show log messages in the console
+        config.option.log_level = "INFO"  # set the log level to INFO
 
-    return decorator
+    CATCH_CLI_EXCEPTIONS = False
+else:
+    CATCH_CLI_EXCEPTIONS = True
 """
diff --git a/nipype2pydra/testing.py b/nipype2pydra/testing.py
new file mode 100644
index 00000000..d718dcf2
--- /dev/null
+++ b/nipype2pydra/testing.py
@@ -0,0 +1,46 @@
+import logging
+import asyncio
+from pydra.engine.core import Result, TaskBase
+from pydra.engine.workers import ConcurrentFuturesWorker
+
+
+logger = logging.getLogger("pydra")
+
+
+class PassAfterTimeoutWorker(ConcurrentFuturesWorker):
+    """A worker used to test the start-up phase of long running tasks. Tasks are initiated
+    and run up until a specified timeout.
+
+    If the task completes before the timeout then results are returned as normal, if not,
+    then None is returned instead"""
+
+    def __init__(self, timeout=10, **kwargs):
+        """Initialize Worker."""
+        super().__init__(n_procs=1)
+        self.timeout = timeout
+        # self.loop = asyncio.get_event_loop()
+        logger.debug("Initialize worker with a timeout of %s seconds", self.timeout)
+
+    def run_el(self, runnable, rerun=False, **kwargs):
+        """Run a task."""
+        return self.exec_with_timeout(runnable, rerun=rerun)
+
+    async def exec_with_timeout(self, runnable: TaskBase, rerun=False):
+        try:
+            result = await asyncio.wait_for(
+                self.exec_as_coro(runnable, rerun=rerun), timeout=self.timeout
+            )
+        except asyncio.TimeoutError:
+            logger.debug(
+                "Killing '%s' task after timeout of %s seconds and assuming it has run successfully",
+                runnable.name,
+                self.timeout,
+            )
+            result = Result(output=None, runtime=None, errored=False)
+        else:
+            logger.debug(
+                "'%s' task completed successfully within the timeout period of %s seconds",
+                runnable.name,
+                self.timeout,
+            )
+        return result
diff --git a/scripts/pkg_gen/create_packages.py b/scripts/pkg_gen/create_packages.py
index 44ceccbb..a178c276 100644
--- a/scripts/pkg_gen/create_packages.py
+++ b/scripts/pkg_gen/create_packages.py
@@ -520,6 +520,7 @@ def copy_ignore(_, names):
     with open(pkg_dir / "pyproject.toml") as f:
         pyproject_toml = f.read()
     pyproject_toml = pyproject_toml.replace("README.md", "README.rst")
+    pyproject_toml = pyproject_toml.replace("test = [\n", "test = [\n    \"nipype2pydra\",\n")
     with open(pkg_dir / "pyproject.toml", "w") as f:
         f.write(pyproject_toml)
 

From 8ef6b0ecbaa5a924380da0072ad9bcf78e2059bc Mon Sep 17 00:00:00 2001
From: Tom Close <tom.g.close@gmail.com>
Date: Tue, 5 Mar 2024 18:07:01 +1100
Subject: [PATCH 48/78] trimmed down example specifications to core packages
 (e.g. afni, ants, fsl, etc...)

---
 conftest.py                                   |  12 +-
 .../afni}/a_boverlap.yaml                     |   7 +-
 .../afni}/a_boverlap_callables.py             |   0
 .../afni}/afn_ito_nifti.yaml                  |   7 +-
 .../afni}/afn_ito_nifti_callables.py          |   0
 .../afni}/align_epi_anat_py.yaml              |   0
 .../afni}/align_epi_anat_py_callables.py      |   0
 .../pydra-afni => nipype/afni}/allineate.yaml |  22 +-
 .../afni}/allineate_callables.py              |   0
 .../afni}/auto_tcorrelate.yaml                |   3 -
 .../afni}/auto_tcorrelate_callables.py        |   0
 .../pydra-afni => nipype/afni}/auto_tlrc.yaml |   0
 .../afni}/auto_tlrc_callables.py              |   0
 .../pydra-afni => nipype/afni}/autobox.yaml   |   3 -
 .../afni}/autobox_callables.py                |   0
 .../pydra-afni => nipype/afni}/automask.yaml  |   3 -
 .../afni}/automask_callables.py               |   0
 .../pydra-afni => nipype/afni}/axialize.yaml  |   7 +-
 .../afni}/axialize_callables.py               |   0
 .../pydra-afni => nipype/afni}/bandpass.yaml  |   3 -
 .../afni}/bandpass_callables.py               |   0
 .../afni}/blur_in_mask.yaml                   |   3 -
 .../afni}/blur_in_mask_callables.py           |   0
 .../afni}/blur_to_fwhm.yaml                   |   3 -
 .../afni}/blur_to_fwhm_callables.py           |   0
 .../afni}/brick_stat.yaml                     |   0
 .../afni}/brick_stat_callables.py             |   0
 .../pydra-afni => nipype/afni}/bucket.yaml    |   7 +-
 .../afni}/bucket_callables.py                 |   0
 .../pydra-afni => nipype/afni}/calc.yaml      |  11 +-
 .../afni}/calc_callables.py                   |   0
 .../pydra-afni => nipype/afni}/cat.yaml       |   7 +-
 .../afni}/cat_callables.py                    |   0
 .../afni}/cat_matvec.yaml                     |   7 +-
 .../afni}/cat_matvec_callables.py             |   0
 .../afni}/center_mass.yaml                    |   2 +-
 .../afni}/center_mass_callables.py            |   0
 .../afni}/clip_level.yaml                     |   0
 .../afni}/clip_level_callables.py             |   0
 .../afni}/convert_dset.yaml                   |   7 +-
 .../afni}/convert_dset_callables.py           |   0
 .../pydra-afni => nipype/afni}/copy.yaml      |   7 +-
 .../afni}/copy_callables.py                   |   0
 .../afni}/deconvolve.yaml                     |  14 +-
 .../afni}/deconvolve_callables.py             |   0
 .../afni}/degree_centrality.yaml              |  13 +-
 .../afni}/degree_centrality_callables.py      |   0
 .../pydra-afni => nipype/afni}/despike.yaml   |   3 -
 .../afni}/despike_callables.py                |   0
 .../pydra-afni => nipype/afni}/detrend.yaml   |   3 -
 .../afni}/detrend_callables.py                |   0
 .../pydra-afni => nipype/afni}/dot.yaml       |  11 +-
 .../afni}/dot_callables.py                    |   0
 .../pydra-afni => nipype/afni}/ecm.yaml       |   7 +-
 .../afni}/ecm_callables.py                    |   0
 .../pydra-afni => nipype/afni}/edge_3.yaml    |   7 +-
 .../afni}/edge_3_callables.py                 |   0
 .../pydra-afni => nipype/afni}/eval.yaml      |   7 +-
 .../afni}/eval_callables.py                   |   0
 .../pydra-afni => nipype/afni}/fim.yaml       |   7 +-
 .../afni}/fim_callables.py                    |   0
 .../pydra-afni => nipype/afni}/fourier.yaml   |   3 -
 .../afni}/fourier_callables.py                |   0
 .../pydra-afni => nipype/afni}/fwh_mx.yaml    |   9 -
 .../afni}/fwh_mx_callables.py                 |   0
 .../pydra-afni => nipype/afni}/gcor.yaml      |   0
 .../afni}/gcor_callables.py                   |   0
 .../pydra-afni => nipype/afni}/hist.yaml      |   6 -
 .../afni}/hist_callables.py                   |   0
 .../pydra-afni => nipype/afni}/lfcd.yaml      |   7 +-
 .../afni}/lfcd_callables.py                   |   0
 .../afni}/local_bistat.yaml                   |   3 -
 .../afni}/local_bistat_callables.py           |   0
 .../pydra-afni => nipype/afni}/localstat.yaml |   5 +-
 .../afni}/localstat_callables.py              |   0
 .../pydra-afni => nipype/afni}/mask_tool.yaml |   3 -
 .../afni}/mask_tool_callables.py              |   0
 .../pydra-afni => nipype/afni}/maskave.yaml   |   3 -
 .../afni}/maskave_callables.py                |   0
 .../pydra-afni => nipype/afni}/means.yaml     |  11 +-
 .../afni}/means_callables.py                  |   0
 .../pydra-afni => nipype/afni}/merge.yaml     |   7 +-
 .../afni}/merge_callables.py                  |   0
 .../pydra-afni => nipype/afni}/net_corr.yaml  |   9 +-
 .../afni}/net_corr_callables.py               |   0
 .../pydra-afni => nipype/afni}/notes.yaml     |   3 -
 .../afni}/notes_callables.py                  |   0
 .../afni}/nwarp_adjust.yaml                   |   3 -
 .../afni}/nwarp_adjust_callables.py           |   0
 .../afni}/nwarp_apply.yaml                    |   3 -
 .../afni}/nwarp_apply_callables.py            |   0
 .../pydra-afni => nipype/afni}/nwarp_cat.yaml |   7 +-
 .../afni}/nwarp_cat_callables.py              |   0
 .../afni}/one_d_tool_py.yaml                  |   9 +-
 .../afni}/one_d_tool_py_callables.py          |   0
 .../afni}/outlier_count.yaml                  |   7 +-
 .../afni}/outlier_count_callables.py          |   0
 .../afni}/quality_index.yaml                  |   3 -
 .../afni}/quality_index_callables.py          |   0
 .../pydra-afni => nipype/afni}/qwarp.yaml     |  22 +-
 .../afni}/qwarp_callables.py                  |   0
 .../afni}/qwarp_plus_minus.yaml               |  10 +-
 .../afni}/qwarp_plus_minus_callables.py       |   0
 .../pydra-afni => nipype/afni}/re_ho.yaml     |   7 +-
 .../afni}/re_ho_callables.py                  |   0
 .../pydra-afni => nipype/afni}/refit.yaml     |   0
 .../afni}/refit_callables.py                  |   0
 .../pydra-afni => nipype/afni}/remlfit.yaml   |  39 +--
 .../afni}/remlfit_callables.py                |   0
 .../pydra-afni => nipype/afni}/resample.yaml  |   3 -
 .../afni}/resample_callables.py               |   0
 .../pydra-afni => nipype/afni}/retroicor.yaml |   3 -
 .../afni}/retroicor_callables.py              |   0
 .../pydra-afni => nipype/afni}/roi_stats.yaml |   3 -
 .../afni}/roi_stats_callables.py              |   0
 .../pydra-afni => nipype/afni}/seg.yaml       |   0
 .../afni}/seg_callables.py                    |   0
 .../afni}/skull_strip.yaml                    |   3 -
 .../afni}/skull_strip_callables.py            |   0
 .../pydra-afni => nipype/afni}/svm_test.yaml  |   3 -
 .../afni}/svm_test_callables.py               |   0
 .../pydra-afni => nipype/afni}/svm_train.yaml |   3 -
 .../afni}/svm_train_callables.py              |   0
 .../afni}/synthesize.yaml                     |   3 -
 .../afni}/synthesize_callables.py             |   0
 .../pydra-afni => nipype/afni}/t_cat.yaml     |   7 +-
 .../afni}/t_cat_callables.py                  |   0
 .../afni}/t_cat_sub_brick.yaml                |   0
 .../afni}/t_cat_sub_brick_callables.py        |   0
 .../pydra-afni => nipype/afni}/t_corr_1d.yaml |   3 -
 .../afni}/t_corr_1d_callables.py              |   0
 .../afni}/t_corr_map.yaml                     |  10 +-
 .../afni}/t_corr_map_callables.py             |   0
 .../afni}/t_correlate.yaml                    |   7 +-
 .../afni}/t_correlate_callables.py            |   0
 .../pydra-afni => nipype/afni}/t_norm.yaml    |   7 +-
 .../afni}/t_norm_callables.py                 |   0
 .../pydra-afni => nipype/afni}/t_project.yaml |   7 +-
 .../afni}/t_project_callables.py              |   0
 .../pydra-afni => nipype/afni}/t_shift.yaml   |   7 +-
 .../afni}/t_shift_callables.py                |   0
 .../pydra-afni => nipype/afni}/t_smooth.yaml  |   3 -
 .../afni}/t_smooth_callables.py               |   0
 .../pydra-afni => nipype/afni}/t_stat.yaml    |   7 +-
 .../afni}/t_stat_callables.py                 |   0
 .../pydra-afni => nipype/afni}/to_3d.yaml     |   7 +-
 .../afni}/to_3d_callables.py                  |   0
 .../pydra-afni => nipype/afni}/undump.yaml    |   7 +-
 .../afni}/undump_callables.py                 |   0
 .../pydra-afni => nipype/afni}/unifize.yaml   |  13 +-
 .../afni}/unifize_callables.py                |   0
 .../pydra-afni => nipype/afni}/volreg.yaml    |   7 +-
 .../afni}/volreg_callables.py                 |   0
 .../pydra-afni => nipype/afni}/warp.yaml      |  11 +-
 .../afni}/warp_callables.py                   |   0
 .../pydra-afni => nipype/afni}/z_cut_up.yaml  |   7 +-
 .../afni}/z_cut_up_callables.py               |   0
 .../pydra-afni => nipype/afni}/zcat.yaml      |   7 +-
 .../afni}/zcat_callables.py                   |   0
 .../pydra-afni => nipype/afni}/zeropad.yaml   |   7 +-
 .../afni}/zeropad_callables.py                |   0
 .../ants}/affine_initializer.yaml             |   3 -
 .../ants}/affine_initializer_callables.py     |   0
 .../pydra-ants => nipype/ants}/ai.yaml        |   3 -
 .../ants}/ai_callables.py                     |   0
 .../pydra-ants => nipype/ants}/ants.yaml      |   0
 .../ants}/ants_callables.py                   |   0
 .../ants}/ants_introduction.yaml              |   0
 .../ants}/ants_introduction_callables.py      |   0
 .../ants}/apply_transforms.yaml               |   0
 .../ants}/apply_transforms_callables.py       |   0
 .../ants}/apply_transforms_to_points.yaml     |   0
 .../apply_transforms_to_points_callables.py   |   0
 .../pydra-ants => nipype/ants}/atropos.yaml   |   0
 .../ants}/atropos_callables.py                |   0
 .../ants}/average_affine_transform.yaml       |   0
 .../average_affine_transform_callables.py     |   0
 .../ants}/average_images.yaml                 |   7 +-
 .../ants}/average_images_callables.py         |   0
 .../ants}/brain_extraction.yaml               |   0
 .../ants}/brain_extraction_callables.py       |   0
 .../ants}/buildtemplateparallel.yaml          |   0
 .../ants}/buildtemplateparallel_callables.py  |   0
 .../ants}/compose_multi_transform.yaml        |   0
 .../compose_multi_transform_callables.py      |   0
 .../ants}/composite_transform_util.yaml       |  13 +-
 .../composite_transform_util_callables.py     |   0
 .../ants}/convert_scalar_image_to_rgb.yaml    |   0
 .../convert_scalar_image_to_rgb_callables.py  |   0
 .../ants}/cortical_thickness.yaml             |   0
 .../ants}/cortical_thickness_callables.py     |   0
 .../create_jacobian_determinant_image.yaml    |   0
 ...te_jacobian_determinant_image_callables.py |   0
 .../ants}/create_tiled_mosaic.yaml            |   0
 .../ants}/create_tiled_mosaic_callables.py    |   0
 .../ants}/denoise_image.yaml                  |   0
 .../ants}/denoise_image_callables.py          |   0
 .../ants}/gen_warp_fields.yaml                |   0
 .../ants}/gen_warp_fields_callables.py        |   0
 .../ants}/image_math.yaml                     |   0
 .../ants}/image_math_callables.py             |   0
 .../ants}/joint_fusion.yaml                   |  11 +-
 .../ants}/joint_fusion_callables.py           |   0
 .../ants}/kelly_kapowski.yaml                 |   0
 .../ants}/kelly_kapowski_callables.py         |   0
 .../ants}/label_geometry.yaml                 |   8 +-
 .../ants}/label_geometry_callables.py         |   0
 .../ants}/laplacian_thickness.yaml            |   0
 .../ants}/laplacian_thickness_callables.py    |   0
 .../ants}/measure_image_similarity.yaml       |   0
 .../measure_image_similarity_callables.py     |   0
 .../ants}/multiply_images.yaml                |   0
 .../ants}/multiply_images_callables.py        |   0
 .../ants}/n4_bias_field_correction.yaml       |   0
 .../n4_bias_field_correction_callables.py     |   0
 .../ants}/registration.yaml                   |   2 +-
 .../ants}/registration_callables.py           |   0
 .../ants}/registration_syn_quick.yaml         |   0
 .../ants}/registration_syn_quick_callables.py |   0
 .../ants}/resample_image_by_spacing.yaml      |   0
 .../resample_image_by_spacing_callables.py    |   0
 .../ants}/threshold_image.yaml                |   0
 .../ants}/threshold_image_callables.py        |   0
 .../ants}/warp_image_multi_transform.yaml     |   4 +-
 .../warp_image_multi_transform_callables.py   |   0
 ...arp_time_series_image_multi_transform.yaml |   0
 ..._series_image_multi_transform_callables.py |   0
 .../freesurfer}/add_x_form_to_header.yaml     |   3 -
 .../add_x_form_to_header_callables.py         |   0
 .../freesurfer}/aparc_2_aseg.yaml             |   7 +-
 .../freesurfer}/aparc_2_aseg_callables.py     |   0
 .../freesurfer}/apas_2_aseg.yaml              |   7 +-
 .../freesurfer}/apas_2_aseg_callables.py      |   0
 .../freesurfer}/apply_mask.yaml               |   3 -
 .../freesurfer}/apply_mask_callables.py       |   0
 .../freesurfer}/apply_vol_transform.yaml      |   0
 .../apply_vol_transform_callables.py          |   0
 .../freesurfer}/bb_register.yaml              |   0
 .../freesurfer}/bb_register_callables.py      |   0
 .../freesurfer}/binarize.yaml                 |   0
 .../freesurfer}/binarize_callables.py         |   0
 .../freesurfer}/ca_label.yaml                 |   7 +-
 .../freesurfer}/ca_label_callables.py         |   0
 .../freesurfer}/ca_normalize.yaml             |   3 -
 .../freesurfer}/ca_normalize_callables.py     |   0
 .../freesurfer}/ca_register.yaml              |   0
 .../freesurfer}/ca_register_callables.py      |   0
 .../check_talairach_alignment.yaml            |   0
 .../check_talairach_alignment_callables.py    |   0
 .../freesurfer}/concatenate.yaml              |   0
 .../freesurfer}/concatenate_callables.py      |   0
 .../freesurfer}/concatenate_lta.yaml          |   7 +-
 .../freesurfer}/concatenate_lta_callables.py  |   0
 .../freesurfer}/contrast.yaml                 |   0
 .../freesurfer}/contrast_callables.py         |   0
 .../freesurfer}/curvature.yaml                |   0
 .../freesurfer}/curvature_callables.py        |   0
 .../freesurfer}/curvature_stats.yaml          |   7 +-
 .../freesurfer}/curvature_stats_callables.py  |   0
 .../freesurfer}/dicom_convert.yaml            |   0
 .../freesurfer}/dicom_convert_callables.py    |   0
 .../freesurfer}/edit_w_mwith_aseg.yaml        |   7 +-
 .../edit_w_mwith_aseg_callables.py            |   0
 .../freesurfer}/em_register.yaml              |   7 +-
 .../freesurfer}/em_register_callables.py      |   0
 .../freesurfer}/euler_number.yaml             |   0
 .../freesurfer}/euler_number_callables.py     |   0
 .../freesurfer}/extract_main_component.yaml   |   3 -
 .../extract_main_component_callables.py       |   0
 .../freesurfer}/fit_ms_params.yaml            |   0
 .../freesurfer}/fit_ms_params_callables.py    |   0
 .../freesurfer}/fix_topology.yaml             |   0
 .../freesurfer}/fix_topology_callables.py     |   0
 .../freesurfer}/fuse_segmentations.yaml       |   7 +-
 .../fuse_segmentations_callables.py           |   0
 .../freesurfer}/glm_fit.yaml                  |   0
 .../freesurfer}/glm_fit_callables.py          |   0
 .../freesurfer}/gtm_seg.yaml                  |   3 -
 .../freesurfer}/gtm_seg_callables.py          |   0
 .../freesurfer}/gtmpvc.yaml                   |   0
 .../freesurfer}/gtmpvc_callables.py           |   0
 .../freesurfer}/image_info.yaml               |   0
 .../freesurfer}/image_info_callables.py       |   0
 .../freesurfer}/jacobian.yaml                 |   3 -
 .../freesurfer}/jacobian_callables.py         |   0
 .../freesurfer}/label_2_annot.yaml            |   0
 .../freesurfer}/label_2_annot_callables.py    |   0
 .../freesurfer}/label_2_label.yaml            |   3 -
 .../freesurfer}/label_2_label_callables.py    |   0
 .../freesurfer}/label_2_vol.yaml              |   0
 .../freesurfer}/label_2_vol_callables.py      |   0
 .../freesurfer}/logan_ref.yaml                |   0
 .../freesurfer}/logan_ref_callables.py        |   0
 .../freesurfer}/lta_convert.yaml              |   0
 .../freesurfer}/lta_convert_callables.py      |   0
 .../freesurfer}/make_average_subject.yaml     |   4 +-
 .../make_average_subject_callables.py         |   0
 .../freesurfer}/make_surfaces.yaml            |   0
 .../freesurfer}/make_surfaces_callables.py    |   0
 .../freesurfer}/mni_bias_correction.yaml      |   3 -
 .../mni_bias_correction_callables.py          |   0
 .../freesurfer}/mp_rto_mni305.yaml            |   0
 .../freesurfer}/mp_rto_mni305_callables.py    |   0
 .../freesurfer}/mr_is_ca_label.yaml           |   3 -
 .../freesurfer}/mr_is_ca_label_callables.py   |   0
 .../freesurfer}/mr_is_calc.yaml               |   7 +-
 .../freesurfer}/mr_is_calc_callables.py       |   0
 .../freesurfer}/mr_is_combine.yaml            |   0
 .../freesurfer}/mr_is_combine_callables.py    |   0
 .../freesurfer}/mr_is_convert.yaml            |   0
 .../freesurfer}/mr_is_convert_callables.py    |   0
 .../freesurfer}/mr_is_expand.yaml             |   0
 .../freesurfer}/mr_is_expand_callables.py     |   0
 .../freesurfer}/mr_is_inflate.yaml            |   6 -
 .../freesurfer}/mr_is_inflate_callables.py    |   0
 .../freesurfer}/mri_convert.yaml              |   0
 .../freesurfer}/mri_convert_callables.py      |   0
 .../freesurfer}/mri_coreg.yaml                |   0
 .../freesurfer}/mri_coreg_callables.py        |   0
 .../freesurfer}/mri_fill.yaml                 |   7 +-
 .../freesurfer}/mri_fill_callables.py         |   0
 .../freesurfer}/mri_marching_cubes.yaml       |   0
 .../mri_marching_cubes_callables.py           |   0
 .../freesurfer}/mri_pretess.yaml              |   3 -
 .../freesurfer}/mri_pretess_callables.py      |   0
 .../freesurfer}/mri_tessellate.yaml           |   0
 .../freesurfer}/mri_tessellate_callables.py   |   0
 .../freesurfer}/mris_preproc.yaml             |   0
 .../freesurfer}/mris_preproc_callables.py     |   0
 .../freesurfer}/mris_preproc_recon_all.yaml   |   0
 .../mris_preproc_recon_all_callables.py       |   0
 .../freesurfer}/mrtm.yaml                     |   0
 .../freesurfer}/mrtm2.yaml                    |   0
 .../freesurfer}/mrtm2_callables.py            |   0
 .../freesurfer}/mrtm_callables.py             |   0
 .../freesurfer}/ms__lda.yaml                  |   0
 .../freesurfer}/ms__lda_callables.py          |   0
 .../freesurfer}/normalize.yaml                |   3 -
 .../freesurfer}/normalize_callables.py        |   0
 .../freesurfer}/one_sample_t_test.yaml        |   0
 .../one_sample_t_test_callables.py            |   0
 .../freesurfer}/paint.yaml                    |   7 +-
 .../freesurfer}/paint_callables.py            |   0
 .../freesurfer}/parcellation_stats.yaml       |   0
 .../parcellation_stats_callables.py           |   0
 .../freesurfer}/parse_dicom_dir.yaml          |   3 -
 .../freesurfer}/parse_dicom_dir_callables.py  |   0
 .../freesurfer}/recon_all.yaml                | 124 +------
 .../freesurfer}/recon_all_callables.py        |   0
 .../freesurfer}/register.yaml                 |   0
 .../register_av_ito_talairach.yaml            |   3 -
 .../register_av_ito_talairach_callables.py    |   0
 .../freesurfer}/register_callables.py         |   0
 .../freesurfer}/relabel_hypointensities.yaml  |   3 -
 .../relabel_hypointensities_callables.py      |   0
 .../freesurfer}/remove_intersection.yaml      |   3 -
 .../remove_intersection_callables.py          |   0
 .../freesurfer}/remove_neck.yaml              |   3 -
 .../freesurfer}/remove_neck_callables.py      |   0
 .../freesurfer}/resample.yaml                 |   0
 .../freesurfer}/resample_callables.py         |   0
 .../freesurfer}/robust_register.yaml          |   0
 .../freesurfer}/robust_register_callables.py  |   0
 .../freesurfer}/robust_template.yaml          |  13 +-
 .../freesurfer}/robust_template_callables.py  |   0
 .../freesurfer}/sample_to_surface.yaml        |   0
 .../sample_to_surface_callables.py            |   0
 .../freesurfer}/seg_stats.yaml                |   0
 .../freesurfer}/seg_stats_callables.py        |   0
 .../freesurfer}/seg_stats_recon_all.yaml      |   0
 .../seg_stats_recon_all_callables.py          |   0
 .../freesurfer}/segment_cc.yaml               |  10 +-
 .../freesurfer}/segment_cc_callables.py       |   0
 .../freesurfer}/segment_wm.yaml               |   7 +-
 .../freesurfer}/segment_wm_callables.py       |   0
 .../freesurfer}/smooth.yaml                   |   0
 .../freesurfer}/smooth_callables.py           |   0
 .../freesurfer}/smooth_tessellation.yaml      |   8 +-
 .../smooth_tessellation_callables.py          |   0
 .../freesurfer}/sphere.yaml                   |   3 -
 .../freesurfer}/sphere_callables.py           |   0
 .../freesurfer}/spherical_average.yaml        |   0
 .../spherical_average_callables.py            |   0
 .../freesurfer}/surface_2_vol_transform.yaml  |   0
 .../surface_2_vol_transform_callables.py      |   0
 .../freesurfer}/surface_smooth.yaml           |   0
 .../freesurfer}/surface_smooth_callables.py   |   0
 .../freesurfer}/surface_snapshots.yaml        |   0
 .../surface_snapshots_callables.py            |   0
 .../freesurfer}/surface_transform.yaml        |   0
 .../surface_transform_callables.py            |   0
 .../freesurfer}/synthesize_flash.yaml         |   0
 .../freesurfer}/synthesize_flash_callables.py |   0
 .../freesurfer}/talairach_avi.yaml            |   7 +-
 .../freesurfer}/talairach_avi_callables.py    |   0
 .../freesurfer}/talairach_qc.yaml             |   0
 .../freesurfer}/talairach_qc_callables.py     |   0
 .../freesurfer}/tkregister_2.yaml             |   7 +-
 .../freesurfer}/tkregister_2_callables.py     |   0
 .../freesurfer}/unpack_sdicom_dir.yaml        |   0
 .../unpack_sdicom_dir_callables.py            |   0
 .../freesurfer}/volume_mask.yaml              |   0
 .../freesurfer}/volume_mask_callables.py      |   0
 .../freesurfer}/watershed_skull_strip.yaml    |   7 +-
 .../watershed_skull_strip_callables.py        |   0
 .../fsl}/accuracy_tester.yaml                 |   0
 .../fsl}/accuracy_tester_callables.py         |   0
 .../pydra-fsl => nipype/fsl}/apply_mask.yaml  |   0
 .../fsl}/apply_mask_callables.py              |   0
 .../pydra-fsl => nipype/fsl}/apply_topup.yaml |   3 -
 .../fsl}/apply_topup_callables.py             |   0
 .../pydra-fsl => nipype/fsl}/apply_warp.yaml  |   0
 .../fsl}/apply_warp_callables.py              |   0
 .../pydra-fsl => nipype/fsl}/apply_xfm.yaml   |   9 -
 .../fsl}/apply_xfm_callables.py               |   0
 .../pydra-fsl => nipype/fsl}/ar1_image.yaml   |   2 +-
 .../fsl}/ar1_image_callables.py               |   0
 .../pydra-fsl => nipype/fsl}/av_scale.yaml    |   0
 .../fsl}/av_scale_callables.py                |   0
 .../pydra-fsl => nipype/fsl}/b0_calc.yaml     |   3 -
 .../fsl}/b0_calc_callables.py                 |   0
 .../pydra-fsl => nipype/fsl}/bedpostx5.yaml   |   2 +-
 .../fsl}/bedpostx5_callables.py               |   0
 .../pydra-fsl => nipype/fsl}/bet.yaml         |  10 -
 .../pydra-fsl => nipype/fsl}/bet_callables.py |   0
 .../fsl}/binary_maths.yaml                    |   0
 .../fsl}/binary_maths_callables.py            |   0
 .../fsl}/change_data_type.yaml                |   0
 .../fsl}/change_data_type_callables.py        |   0
 .../pydra-fsl => nipype/fsl}/classifier.yaml  |   0
 .../fsl}/classifier_callables.py              |   0
 .../pydra-fsl => nipype/fsl}/cleaner.yaml     |   0
 .../fsl}/cleaner_callables.py                 |   0
 .../pydra-fsl => nipype/fsl}/cluster.yaml     |   4 +-
 .../fsl}/cluster_callables.py                 |   0
 .../pydra-fsl => nipype/fsl}/complex.yaml     |   0
 .../fsl}/complex_callables.py                 |   0
 .../fsl}/contrast_mgr.yaml                    |   0
 .../fsl}/contrast_mgr_callables.py            |   0
 .../fsl}/convert_warp.yaml                    |   3 -
 .../fsl}/convert_warp_callables.py            |   0
 .../pydra-fsl => nipype/fsl}/convert_xfm.yaml |   0
 .../fsl}/convert_xfm_callables.py             |   0
 .../pydra-fsl => nipype/fsl}/copy_geom.yaml   |   0
 .../fsl}/copy_geom_callables.py               |   0
 .../fsl}/dilate_image.yaml                    |   0
 .../fsl}/dilate_image_callables.py            |   0
 .../fsl}/distance_map.yaml                    |   0
 .../fsl}/distance_map_callables.py            |   0
 .../pydra-fsl => nipype/fsl}/dti_fit.yaml     |   0
 .../fsl}/dti_fit_callables.py                 |   0
 .../fsl}/dual_regression.yaml                 |   0
 .../fsl}/dual_regression_callables.py         |   0
 .../pydra-fsl => nipype/fsl}/eddy.yaml        |  12 +-
 .../fsl}/eddy_callables.py                    |   0
 .../fsl}/eddy_correct.yaml                    |   8 +-
 .../fsl}/eddy_correct_callables.py            |   0
 .../pydra-fsl => nipype/fsl}/eddy_quad.yaml   |   0
 .../fsl}/eddy_quad_callables.py               |   0
 .../pydra-fsl => nipype/fsl}/epi_de_warp.yaml |   0
 .../fsl}/epi_de_warp_callables.py             |   0
 .../pydra-fsl => nipype/fsl}/epi_reg.yaml     |   0
 .../fsl}/epi_reg_callables.py                 |   0
 .../pydra-fsl => nipype/fsl}/erode_image.yaml |   0
 .../fsl}/erode_image_callables.py             |   0
 .../pydra-fsl => nipype/fsl}/extract_roi.yaml |   0
 .../fsl}/extract_roi_callables.py             |   0
 .../pydra-fsl => nipype/fsl}/fast.yaml        |  18 +-
 .../fsl}/fast_callables.py                    |   0
 .../pydra-fsl => nipype/fsl}/feat.yaml        |   0
 .../fsl}/feat_callables.py                    |   0
 .../pydra-fsl => nipype/fsl}/feat_model.yaml  |   0
 .../fsl}/feat_model_callables.py              |   0
 .../fsl}/feature_extractor.yaml               |   0
 .../fsl}/feature_extractor_callables.py       |   0
 .../pydra-fsl => nipype/fsl}/filmgls.yaml     |   0
 .../fsl}/filmgls_callables.py                 |   0
 .../fsl}/filter_regressor.yaml                |   0
 .../fsl}/filter_regressor_callables.py        |   0
 .../fsl}/find_the_biggest.yaml                |   0
 .../fsl}/find_the_biggest_callables.py        |   0
 .../pydra-fsl => nipype/fsl}/first.yaml       |   4 +-
 .../fsl}/first_callables.py                   |   0
 .../pydra-fsl => nipype/fsl}/flameo.yaml      |   0
 .../fsl}/flameo_callables.py                  |   0
 .../pydra-fsl => nipype/fsl}/flirt.yaml       |   9 -
 .../fsl}/flirt_callables.py                   |   0
 .../pydra-fsl => nipype/fsl}/fnirt.yaml       |   0
 .../fsl}/fnirt_callables.py                   |   0
 .../fsl}/fslx_command.yaml                    |   2 +-
 .../fsl}/fslx_command_callables.py            |   0
 .../pydra-fsl => nipype/fsl}/fugue.yaml       |  18 +-
 .../fsl}/fugue_callables.py                   |   0
 .../pydra-fsl => nipype/fsl}/glm.yaml         |  35 +-
 .../pydra-fsl => nipype/fsl}/glm_callables.py |   0
 .../pydra-fsl => nipype/fsl}/ica__aroma.yaml  |   0
 .../fsl}/ica__aroma_callables.py              |   0
 .../pydra-fsl => nipype/fsl}/image_maths.yaml |   0
 .../fsl}/image_maths_callables.py             |   0
 .../fsl}/image_meants.yaml                    |   0
 .../fsl}/image_meants_callables.py            |   0
 .../pydra-fsl => nipype/fsl}/image_stats.yaml |   0
 .../fsl}/image_stats_callables.py             |   0
 .../pydra-fsl => nipype/fsl}/inv_warp.yaml    |   0
 .../fsl}/inv_warp_callables.py                |   0
 .../fsl}/isotropic_smooth.yaml                |   0
 .../fsl}/isotropic_smooth_callables.py        |   0
 .../pydra-fsl => nipype/fsl}/l2_model.yaml    |   0
 .../fsl}/l2_model_callables.py                |   0
 .../fsl}/level_1_design.yaml                  |   0
 .../fsl}/level_1_design_callables.py          |   0
 .../fsl}/make_dyadic_vectors.yaml             |   4 +-
 .../fsl}/make_dyadic_vectors_callables.py     |   0
 .../fsl}/maths_command.yaml                   |   0
 .../fsl}/maths_command_callables.py           |   0
 .../pydra-fsl => nipype/fsl}/max_image.yaml   |   0
 .../fsl}/max_image_callables.py               |   0
 .../pydra-fsl => nipype/fsl}/maxn_image.yaml  |   0
 .../fsl}/maxn_image_callables.py              |   0
 .../pydra-fsl => nipype/fsl}/mcflirt.yaml     |   0
 .../fsl}/mcflirt_callables.py                 |   0
 .../pydra-fsl => nipype/fsl}/mean_image.yaml  |   0
 .../fsl}/mean_image_callables.py              |   0
 .../fsl}/median_image.yaml                    |   0
 .../fsl}/median_image_callables.py            |   0
 .../pydra-fsl => nipype/fsl}/melodic.yaml     |   0
 .../fsl}/melodic_callables.py                 |   0
 .../pydra-fsl => nipype/fsl}/merge.yaml       |   0
 .../fsl}/merge_callables.py                   |   0
 .../pydra-fsl => nipype/fsl}/min_image.yaml   |   0
 .../fsl}/min_image_callables.py               |   0
 .../fsl}/motion_outliers.yaml                 |   9 -
 .../fsl}/motion_outliers_callables.py         |   0
 .../fsl}/multi_image_maths.yaml               |   0
 .../fsl}/multi_image_maths_callables.py       |   0
 .../fsl}/multiple_regress_design.yaml         |   0
 .../fsl}/multiple_regress_design_callables.py |   0
 .../pydra-fsl => nipype/fsl}/overlay.yaml     |   0
 .../fsl}/overlay_callables.py                 |   0
 .../fsl}/percentile_image.yaml                |   0
 .../fsl}/percentile_image_callables.py        |   0
 .../fsl}/plot_motion_params.yaml              |   0
 .../fsl}/plot_motion_params_callables.py      |   0
 .../fsl}/plot_time_series.yaml                |   0
 .../fsl}/plot_time_series_callables.py        |   0
 .../fsl}/power_spectrum.yaml                  |   0
 .../fsl}/power_spectrum_callables.py          |   0
 .../pydra-fsl => nipype/fsl}/prelude.yaml     |   0
 .../fsl}/prelude_callables.py                 |   0
 .../fsl}/prepare_fieldmap.yaml                |   3 -
 .../fsl}/prepare_fieldmap_callables.py        |   0
 .../fsl}/prob_track_x.yaml                    |   4 +-
 .../fsl}/prob_track_x2.yaml                   |   4 +-
 .../fsl}/prob_track_x2_callables.py           |   0
 .../fsl}/prob_track_x_callables.py            |   0
 .../pydra-fsl => nipype/fsl}/proj_thresh.yaml |   0
 .../fsl}/proj_thresh_callables.py             |   0
 .../pydra-fsl => nipype/fsl}/randomise.yaml   |   0
 .../fsl}/randomise_callables.py               |   0
 .../fsl}/reorient_2_std.yaml                  |   0
 .../fsl}/reorient_2_std_callables.py          |   0
 .../pydra-fsl => nipype/fsl}/robust_fov.yaml  |   6 -
 .../fsl}/robust_fov_callables.py              |   0
 .../pydra-fsl => nipype/fsl}/sig_loss.yaml    |   0
 .../fsl}/sig_loss_callables.py                |   0
 .../pydra-fsl => nipype/fsl}/slice.yaml       |   0
 .../fsl}/slice_callables.py                   |   0
 .../pydra-fsl => nipype/fsl}/slice_timer.yaml |   0
 .../fsl}/slice_timer_callables.py             |   0
 .../pydra-fsl => nipype/fsl}/slicer.yaml      |   0
 .../fsl}/slicer_callables.py                  |   0
 .../pydra-fsl => nipype/fsl}/smm.yaml         |   0
 .../pydra-fsl => nipype/fsl}/smm_callables.py |   0
 .../pydra-fsl => nipype/fsl}/smooth.yaml      |   0
 .../fsl}/smooth_callables.py                  |   0
 .../fsl}/smooth_estimate.yaml                 |   0
 .../fsl}/smooth_estimate_callables.py         |   0
 .../fsl}/spatial_filter.yaml                  |   0
 .../fsl}/spatial_filter_callables.py          |   0
 .../pydra-fsl => nipype/fsl}/split.yaml       |   0
 .../fsl}/split_callables.py                   |   0
 .../pydra-fsl => nipype/fsl}/std_image.yaml   |   0
 .../fsl}/std_image_callables.py               |   0
 .../pydra-fsl => nipype/fsl}/susan.yaml       |   0
 .../fsl}/susan_callables.py                   |   0
 .../fsl}/swap_dimensions.yaml                 |   0
 .../fsl}/swap_dimensions_callables.py         |   0
 .../fsl}/temporal_filter.yaml                 |   0
 .../fsl}/temporal_filter_callables.py         |   0
 .../pydra-fsl => nipype/fsl}/text_2_vest.yaml |   7 +-
 .../fsl}/text_2_vest_callables.py             |   0
 .../pydra-fsl => nipype/fsl}/threshold.yaml   |   0
 .../fsl}/threshold_callables.py               |   0
 .../pydra-fsl => nipype/fsl}/topup.yaml       |  25 +-
 .../fsl}/topup_callables.py                   |   0
 .../fsl}/tract_skeleton.yaml                  |   0
 .../fsl}/tract_skeleton_callables.py          |   0
 .../pydra-fsl => nipype/fsl}/training.yaml    |   0
 .../fsl}/training_callables.py                |   0
 .../fsl}/training_set_creator.yaml            |   0
 .../fsl}/training_set_creator_callables.py    |   0
 .../pydra-fsl => nipype/fsl}/unary_maths.yaml |   0
 .../fsl}/unary_maths_callables.py             |   0
 .../pydra-fsl => nipype/fsl}/vec_reg.yaml     |   0
 .../fsl}/vec_reg_callables.py                 |   0
 .../pydra-fsl => nipype/fsl}/vest_2_text.yaml |   3 -
 .../fsl}/vest_2_text_callables.py             |   0
 .../pydra-fsl => nipype/fsl}/warp_points.yaml |   3 -
 .../fsl}/warp_points_callables.py             |   0
 .../fsl}/warp_points_from_std.yaml            |   0
 .../fsl}/warp_points_from_std_callables.py    |   0
 .../fsl}/warp_points_to_std.yaml              |   3 -
 .../fsl}/warp_points_to_std_callables.py      |   0
 .../pydra-fsl => nipype/fsl}/warp_utils.yaml  |   6 -
 .../fsl}/warp_utils_callables.py              |   0
 .../pydra-fsl => nipype/fsl}/x_fibres_5.yaml  |   2 +-
 .../fsl}/x_fibres_5_callables.py              |   0
 .../nipype_internal/pydra-brainsuite/bdp.yaml | 206 -----------
 .../pydra-brainsuite/bdp_callables.py         |   1 -
 .../nipype_internal/pydra-brainsuite/bfc.yaml | 160 ---------
 .../pydra-brainsuite/bfc_callables.py         |   1 -
 .../nipype_internal/pydra-brainsuite/bse.yaml | 157 ---------
 .../pydra-brainsuite/bse_callables.py         |   1 -
 .../pydra-brainsuite/cerebro.yaml             | 156 ---------
 .../pydra-brainsuite/cerebro_callables.py     |   1 -
 .../pydra-brainsuite/cortex.yaml              | 112 ------
 .../pydra-brainsuite/cortex_callables.py      |   1 -
 .../pydra-brainsuite/dewisp.yaml              | 107 ------
 .../pydra-brainsuite/dewisp_callables.py      |   1 -
 .../nipype_internal/pydra-brainsuite/dfs.yaml | 122 -------
 .../pydra-brainsuite/dfs_callables.py         |   1 -
 .../pydra-brainsuite/hemisplit.yaml           | 135 -------
 .../pydra-brainsuite/hemisplit_callables.py   |   1 -
 .../pydra-brainsuite/pialmesh.yaml            | 130 -------
 .../pydra-brainsuite/pialmesh_callables.py    |   1 -
 .../nipype_internal/pydra-brainsuite/pvc.yaml | 117 -------
 .../pydra-brainsuite/pvc_callables.py         |   1 -
 .../pydra-brainsuite/scrubmask.yaml           | 105 ------
 .../pydra-brainsuite/scrubmask_callables.py   |   1 -
 .../pydra-brainsuite/skullfinder.yaml         | 116 -------
 .../pydra-brainsuite/skullfinder_callables.py |   1 -
 .../pydra-brainsuite/sv_reg.yaml              | 131 -------
 .../pydra-brainsuite/sv_reg_callables.py      |   1 -
 .../nipype_internal/pydra-brainsuite/tca.yaml | 103 ------
 .../pydra-brainsuite/tca_callables.py         |   1 -
 .../pydra-brainsuite/thickness_pvc.yaml       |  88 -----
 .../thickness_pvc_callables.py                |   1 -
 .../nipype_internal/pydra-bru2nii/bru_2.yaml  | 127 -------
 .../pydra-bru2nii/bru_2_callables.py          |   1 -
 .../task/nipype_internal/pydra-c3/c_3d.yaml   | 165 ---------
 .../pydra-c3/c_3d_affine_tool.yaml            | 141 --------
 .../pydra-c3/c_3d_affine_tool_callables.py    |   1 -
 .../pydra-c3/c_3d_callables.py                |   1 -
 .../pydra-camino/analyze_header.yaml          | 152 --------
 .../pydra-camino/analyze_header_callables.py  |   1 -
 .../pydra-camino/compute_eigensystem.yaml     | 102 ------
 .../compute_eigensystem_callables.py          |   1 -
 .../compute_fractional_anisotropy.yaml        | 103 ------
 ...compute_fractional_anisotropy_callables.py |   1 -
 .../compute_mean_diffusivity.yaml             |  97 ------
 .../compute_mean_diffusivity_callables.py     |   1 -
 .../pydra-camino/compute_tensor_trace.yaml    | 105 ------
 .../compute_tensor_trace_callables.py         |   1 -
 .../nipype_internal/pydra-camino/conmat.yaml  | 166 ---------
 .../pydra-camino/conmat_callables.py          |   1 -
 .../pydra-camino/dt2n_if_ti.yaml              |  88 -----
 .../pydra-camino/dt2n_if_ti_callables.py      |   1 -
 .../pydra-camino/dt_metric.yaml               | 120 -------
 .../pydra-camino/dt_metric_callables.py       |   1 -
 .../nipype_internal/pydra-camino/dti_fit.yaml | 112 ------
 .../pydra-camino/dtlut_gen.yaml               | 118 -------
 .../pydra-camino/dtlut_gen_callables.py       |   1 -
 .../pydra-camino/fsl2_scheme.yaml             | 108 ------
 .../pydra-camino/fsl2_scheme_callables.py     |   1 -
 .../pydra-camino/image_2_voxel.yaml           |  92 -----
 .../pydra-camino/image_2_voxel_callables.py   |   1 -
 .../pydra-camino/image_stats.yaml             |  93 -----
 .../pydra-camino/lin_recon.yaml               | 134 -------
 .../pydra-camino/lin_recon_callables.py       |   1 -
 .../nipype_internal/pydra-camino/mesd.yaml    | 170 ---------
 .../pydra-camino/mesd_callables.py            |   1 -
 .../pydra-camino/model_fit.yaml               | 134 -------
 .../pydra-camino/model_fit_callables.py       |   1 -
 .../pydra-camino/n_if_tidt2_camino.yaml       | 116 -------
 .../n_if_tidt2_camino_callables.py            |   1 -
 .../pydra-camino/pico_pd_fs.yaml              | 102 ------
 .../pydra-camino/pico_pd_fs_callables.py      |   1 -
 .../pydra-camino/proc_streamlines.yaml        | 161 ---------
 .../proc_streamlines_callables.py             |   1 -
 .../pydra-camino/q_ball_mx.yaml               | 122 -------
 .../pydra-camino/q_ball_mx_callables.py       |   1 -
 .../pydra-camino/sf_peaks.yaml                | 179 ----------
 .../pydra-camino/sf_peaks_callables.py        |   1 -
 .../pydra-camino/sflut_gen.yaml               | 141 --------
 .../pydra-camino/sflut_gen_callables.py       |   1 -
 .../pydra-camino/sfpico_calib_data.yaml       | 153 --------
 .../sfpico_calib_data_callables.py            |   1 -
 .../pydra-camino/shredder.yaml                | 103 ------
 .../pydra-camino/shredder_callables.py        |   1 -
 .../nipype_internal/pydra-camino/track.yaml   | 131 -------
 .../pydra-camino/track_ball_stick.yaml        | 129 -------
 .../track_ball_stick_callables.py             |   1 -
 .../pydra-camino/track_bayes_dirac.yaml       | 153 --------
 .../track_bayes_dirac_callables.py            |   1 -
 .../pydra-camino/track_bedpostx_deter.yaml    | 145 --------
 .../track_bedpostx_deter_callables.py         |   1 -
 .../pydra-camino/track_bedpostx_proba.yaml    | 152 --------
 .../track_bedpostx_proba_callables.py         |   1 -
 .../pydra-camino/track_bootstrap.yaml         | 147 --------
 .../pydra-camino/track_bootstrap_callables.py |   1 -
 .../pydra-camino/track_callables.py           |   1 -
 .../pydra-camino/track_dt.yaml                | 129 -------
 .../pydra-camino/track_dt_callables.py        |   1 -
 .../pydra-camino/track_pi_co.yaml             | 133 -------
 .../pydra-camino/track_pi_co_callables.py     |   1 -
 .../pydra-camino/tract_shredder.yaml          | 101 ------
 .../pydra-camino/tract_shredder_callables.py  |   1 -
 .../pydra-camino/vtk_streamlines.yaml         | 109 ------
 .../pydra-camino/vtk_streamlines_callables.py |   1 -
 .../camino_2_trackvis.yaml                    | 106 ------
 .../camino_2_trackvis_callables.py            |   1 -
 .../trackvis_2_camino.yaml                    |  80 -----
 .../trackvis_2_camino_callables.py            |   1 -
 .../pydra-cat12/cat12_segment.yaml            | 225 ------------
 .../pydra-cat12/cat12_segment_callables.py    |   1 -
 .../pydra-cat12/cat12sanlm_denoising.yaml     | 116 -------
 .../cat12sanlm_denoising_callables.py         |   1 -
 ...extract_additional_surface_parameters.yaml | 118 -------
 ...additional_surface_parameters_callables.py |   1 -
 .../extract_roi_based_surface_measures.yaml   | 117 -------
 ...ct_roi_based_surface_measures_callables.py |   1 -
 .../pydra-cmtk/average_networks.yaml          |  97 ------
 .../pydra-cmtk/average_networks_callables.py  |   1 -
 .../pydra-cmtk/cff_converter.yaml             | 137 --------
 .../pydra-cmtk/cff_converter_callables.py     |   1 -
 .../pydra-cmtk/create_matrix.yaml             | 145 --------
 .../pydra-cmtk/create_matrix_callables.py     |   1 -
 .../pydra-cmtk/create_nodes.yaml              |  87 -----
 .../pydra-cmtk/create_nodes_callables.py      |   1 -
 .../pydra-cmtk/merge_c_networks.yaml          |  82 -----
 .../pydra-cmtk/merge_c_networks_callables.py  |   1 -
 .../pydra-cmtk/network_based_statistic.yaml   | 110 ------
 .../network_based_statistic_callables.py      |   1 -
 .../pydra-cmtk/network_x_metrics.yaml         | 122 -------
 .../pydra-cmtk/network_x_metrics_callables.py |   1 -
 .../pydra-cmtk/parcellate.yaml                | 113 ------
 .../pydra-cmtk/parcellate_callables.py        |   1 -
 .../nipype_internal/pydra-cmtk/roi_gen.yaml   | 107 ------
 .../pydra-cmtk/roi_gen_callables.py           |   1 -
 .../pydra-dcmstack/copy_meta.yaml             |  80 -----
 .../pydra-dcmstack/copy_meta_callables.py     |   1 -
 .../pydra-dcmstack/dcm_stack.yaml             |  94 -----
 .../pydra-dcmstack/dcm_stack_callables.py     |   1 -
 .../pydra-dcmstack/group_and_stack.yaml       |  80 -----
 .../group_and_stack_callables.py              |   1 -
 .../pydra-dcmstack/lookup_meta.yaml           |  82 -----
 .../pydra-dcmstack/lookup_meta_callables.py   |   1 -
 .../pydra-dcmstack/merge_nifti.yaml           |  79 -----
 .../pydra-dcmstack/merge_nifti_callables.py   |   1 -
 .../pydra-dcmstack/nifti_generator_base.yaml  |  63 ----
 .../nifti_generator_base_callables.py         |   1 -
 .../pydra-dcmstack/split_nifti.yaml           |  79 -----
 .../pydra-dcmstack/split_nifti_callables.py   |   1 -
 .../pydra-diffusion_toolkit/dti_recon.yaml    | 114 ------
 .../dti_recon_callables.py                    |   1 -
 .../pydra-diffusion_toolkit/dti_tracker.yaml  | 122 -------
 .../dti_tracker_callables.py                  |   1 -
 .../pydra-diffusion_toolkit/hardi_mat.yaml    | 101 ------
 .../hardi_mat_callables.py                    |   1 -
 .../pydra-diffusion_toolkit/odf_recon.yaml    | 111 ------
 .../odf_recon_callables.py                    |   1 -
 .../pydra-diffusion_toolkit/odf_tracker.yaml  | 128 -------
 .../odf_tracker_callables.py                  |   1 -
 .../spline_filter.yaml                        |  94 -----
 .../spline_filter_callables.py                |   1 -
 .../pydra-diffusion_toolkit/track_merge.yaml  |  94 -----
 .../track_merge_callables.py                  |   1 -
 .../nipype_internal/pydra-dipy/apm_qball.yaml |  96 -----
 .../pydra-dipy/apm_qball_callables.py         |   1 -
 .../task/nipype_internal/pydra-dipy/csd.yaml  | 120 -------
 .../pydra-dipy/csd_callables.py               |   1 -
 .../nipype_internal/pydra-dipy/denoise.yaml   | 106 ------
 .../pydra-dipy/denoise_callables.py           |   1 -
 .../task/nipype_internal/pydra-dipy/dti.yaml  | 106 ------
 .../pydra-dipy/dti_callables.py               |   1 -
 .../pydra-dipy/estimate_response_sh.yaml      | 130 -------
 .../estimate_response_sh_callables.py         |   1 -
 .../nipype_internal/pydra-dipy/resample.yaml  |  84 -----
 .../nipype_internal/pydra-dipy/restore.yaml   | 120 -------
 .../pydra-dipy/restore_callables.py           |   1 -
 .../pydra-dipy/simulate_multi_tensor.yaml     | 159 ---------
 .../simulate_multi_tensor_callables.py        |   1 -
 .../pydra-dipy/streamline_tractography.yaml   | 123 -------
 .../streamline_tractography_callables.py      |   1 -
 .../pydra-dipy/tensor_mode.yaml               | 106 ------
 .../pydra-dipy/tensor_mode_callables.py       |   1 -
 .../pydra-dipy/track_density_map.yaml         |  94 -----
 .../pydra-dipy/track_density_map_callables.py |   1 -
 .../pydra-dtitk/aff_scalar_vol.yaml           | 146 --------
 .../pydra-dtitk/aff_scalar_vol_callables.py   |   1 -
 .../pydra-dtitk/aff_scalar_vol_task.yaml      |  95 -----
 .../aff_scalar_vol_task_callables.py          |   1 -
 .../pydra-dtitk/aff_sym_tensor_3d_vol.yaml    | 148 --------
 .../aff_sym_tensor_3d_vol_callables.py        |   1 -
 .../aff_sym_tensor_3d_vol_task.yaml           |  97 ------
 .../aff_sym_tensor_3d_vol_task_callables.py   |   1 -
 .../nipype_internal/pydra-dtitk/affine.yaml   | 157 ---------
 .../pydra-dtitk/affine_callables.py           |   1 -
 .../pydra-dtitk/affine_task.yaml              |  88 -----
 .../pydra-dtitk/affine_task_callables.py      |   1 -
 .../pydra-dtitk/bin_thresh.yaml               | 152 --------
 .../pydra-dtitk/bin_thresh_callables.py       |   1 -
 .../pydra-dtitk/bin_thresh_task.yaml          |  87 -----
 .../pydra-dtitk/bin_thresh_task_callables.py  |   1 -
 .../pydra-dtitk/compose_xfm.yaml              | 134 -------
 .../pydra-dtitk/compose_xfm_callables.py      |   1 -
 .../pydra-dtitk/compose_xfm_task.yaml         |  83 -----
 .../pydra-dtitk/compose_xfm_task_callables.py |   1 -
 .../nipype_internal/pydra-dtitk/diffeo.yaml   | 157 ---------
 .../pydra-dtitk/diffeo_callables.py           |   1 -
 .../pydra-dtitk/diffeo_scalar_vol.yaml        | 146 --------
 .../diffeo_scalar_vol_callables.py            |   1 -
 .../pydra-dtitk/diffeo_scalar_vol_task.yaml   |  95 -----
 .../diffeo_scalar_vol_task_callables.py       |   1 -
 .../pydra-dtitk/diffeo_sym_tensor_3d_vol.yaml | 150 --------
 .../diffeo_sym_tensor_3d_vol_callables.py     |   1 -
 .../diffeo_sym_tensor_3d_vol_task.yaml        |  99 ------
 ...diffeo_sym_tensor_3d_vol_task_callables.py |   1 -
 .../pydra-dtitk/diffeo_task.yaml              |  88 -----
 .../pydra-dtitk/diffeo_task_callables.py      |   1 -
 .../nipype_internal/pydra-dtitk/rigid.yaml    | 152 --------
 .../pydra-dtitk/rigid_callables.py            |   1 -
 .../pydra-dtitk/rigid_task.yaml               |  88 -----
 .../pydra-dtitk/rigid_task_callables.py       |   1 -
 .../pydra-dtitk/sv_adjust_vox_sp.yaml         | 137 --------
 .../pydra-dtitk/sv_adjust_vox_sp_callables.py |   1 -
 .../pydra-dtitk/sv_adjust_vox_sp_task.yaml    |  87 -----
 .../sv_adjust_vox_sp_task_callables.py        |   1 -
 .../pydra-dtitk/sv_resample.yaml              | 141 --------
 .../pydra-dtitk/sv_resample_callables.py      |   1 -
 .../pydra-dtitk/sv_resample_task.yaml         |  91 -----
 .../pydra-dtitk/sv_resample_task_callables.py |   1 -
 .../nipype_internal/pydra-dtitk/t_vtool.yaml  | 131 -------
 .../pydra-dtitk/t_vtool_callables.py          |   1 -
 .../pydra-dtitk/t_vtool_task.yaml             |  81 -----
 .../pydra-dtitk/t_vtool_task_callables.py     |   1 -
 .../pydra-dtitk/tv_adjust_origin_task.yaml    |  87 -----
 .../tv_adjust_origin_task_callables.py        |   1 -
 .../pydra-dtitk/tv_adjust_vox_sp.yaml         | 137 --------
 .../pydra-dtitk/tv_adjust_vox_sp_callables.py |   1 -
 .../pydra-dtitk/tv_adjust_vox_sp_task.yaml    |  87 -----
 .../tv_adjust_vox_sp_task_callables.py        |   1 -
 .../pydra-dtitk/tv_resample.yaml              | 143 --------
 .../pydra-dtitk/tv_resample_callables.py      |   1 -
 .../pydra-dtitk/tv_resample_task.yaml         |  93 -----
 .../pydra-dtitk/tv_resample_task_callables.py |   1 -
 .../slicer_command_line.yaml                  |  68 ----
 .../slicer_command_line_callables.py          |   1 -
 .../pydra-elastix/analyze_warp.yaml           | 140 --------
 .../pydra-elastix/analyze_warp_callables.py   |   1 -
 .../pydra-elastix/apply_warp.yaml             | 134 -------
 .../pydra-elastix/edit_transform.yaml         |  98 ------
 .../pydra-elastix/edit_transform_callables.py |   1 -
 .../pydra-elastix/points_warp.yaml            | 133 -------
 .../pydra-elastix/points_warp_callables.py    |   1 -
 .../pydra-elastix/registration.yaml           | 154 --------
 .../pydra-elastix/registration_callables.py   |   1 -
 .../pydra-freesurfer/resample_callables.py    |   1 -
 .../pydra-fsl/apply_warp_callables.py         |   1 -
 .../pydra-fsl/dti_fit_callables.py            |   1 -
 .../pydra-fsl/image_stats_callables.py        |   1 -
 .../pydra-meshfix/mesh_fix.yaml               | 198 -----------
 .../pydra-meshfix/mesh_fix_callables.py       |   1 -
 .../nipype_internal/pydra-minc/average.yaml   | 155 ---------
 .../pydra-minc/average_callables.py           |   1 -
 .../nipype_internal/pydra-minc/b_box.yaml     | 106 ------
 .../pydra-minc/b_box_callables.py             |   1 -
 .../nipype_internal/pydra-minc/beast.yaml     | 131 -------
 .../pydra-minc/beast_callables.py             |   1 -
 .../pydra-minc/best_lin_reg.yaml              | 112 ------
 .../pydra-minc/best_lin_reg_callables.py      |   1 -
 .../pydra-minc/big_average.yaml               | 130 -------
 .../pydra-minc/big_average_callables.py       |   1 -
 .../task/nipype_internal/pydra-minc/blob.yaml |  97 ------
 .../pydra-minc/blob_callables.py              |   1 -
 .../task/nipype_internal/pydra-minc/blur.yaml | 140 --------
 .../pydra-minc/blur_callables.py              |   1 -
 .../task/nipype_internal/pydra-minc/calc.yaml | 155 ---------
 .../pydra-minc/calc_callables.py              |   1 -
 .../nipype_internal/pydra-minc/convert.yaml   |  98 ------
 .../pydra-minc/convert_callables.py           |   1 -
 .../task/nipype_internal/pydra-minc/copy.yaml |  92 -----
 .../pydra-minc/copy_callables.py              |   1 -
 .../task/nipype_internal/pydra-minc/dump.yaml | 113 ------
 .../pydra-minc/dump_callables.py              |   1 -
 .../nipype_internal/pydra-minc/extract.yaml   | 154 --------
 .../pydra-minc/extract_callables.py           |   1 -
 .../nipype_internal/pydra-minc/gennlxfm.yaml  | 104 ------
 .../pydra-minc/gennlxfm_callables.py          |   1 -
 .../task/nipype_internal/pydra-minc/math.yaml | 205 -----------
 .../pydra-minc/math_callables.py              |   1 -
 .../nipype_internal/pydra-minc/nlp_fit.yaml   | 125 -------
 .../pydra-minc/nlp_fit_callables.py           |   1 -
 .../task/nipype_internal/pydra-minc/norm.yaml | 124 -------
 .../pydra-minc/norm_callables.py              |   1 -
 .../task/nipype_internal/pydra-minc/pik.yaml  | 140 --------
 .../pydra-minc/pik_callables.py               |   1 -
 .../nipype_internal/pydra-minc/resample.yaml  | 202 -----------
 .../pydra-minc/resample_callables.py          |   1 -
 .../nipype_internal/pydra-minc/reshape.yaml   | 100 ------
 .../pydra-minc/reshape_callables.py           |   1 -
 .../nipype_internal/pydra-minc/to_ecat.yaml   | 110 ------
 .../pydra-minc/to_ecat_callables.py           |   1 -
 .../nipype_internal/pydra-minc/to_raw.yaml    | 119 -------
 .../pydra-minc/to_raw_callables.py            |   1 -
 .../nipype_internal/pydra-minc/vol_symm.yaml  | 132 -------
 .../pydra-minc/vol_symm_callables.py          |   1 -
 .../nipype_internal/pydra-minc/volcentre.yaml |  98 ------
 .../pydra-minc/volcentre_callables.py         |   1 -
 .../nipype_internal/pydra-minc/voliso.yaml    |  99 ------
 .../pydra-minc/voliso_callables.py            |   1 -
 .../nipype_internal/pydra-minc/volpad.yaml    | 102 ------
 .../pydra-minc/volpad_callables.py            |   1 -
 .../nipype_internal/pydra-minc/xfm_avg.yaml   | 115 ------
 .../pydra-minc/xfm_avg_callables.py           |   1 -
 .../pydra-minc/xfm_concat.yaml                |  98 ------
 .../pydra-minc/xfm_concat_callables.py        |   1 -
 .../pydra-minc/xfm_invert.yaml                |  96 -----
 .../pydra-minc/xfm_invert_callables.py        |   1 -
 .../jist_brain_mgdm_segmentation.yaml         | 146 --------
 .../jist_brain_mgdm_segmentation_callables.py |   1 -
 .../jist_brain_mp_2rage_dura_estimation.yaml  |  91 -----
 ...rain_mp_2rage_dura_estimation_callables.py |   1 -
 .../jist_brain_mp_2rage_skull_stripping.yaml  | 119 -------
 ...rain_mp_2rage_skull_stripping_callables.py |   1 -
 .../jist_brain_partial_volume_filter.yaml     |  91 -----
 ...t_brain_partial_volume_filter_callables.py |   1 -
 .../jist_cortex_surface_mesh_inflation.yaml   | 108 ------
 ...cortex_surface_mesh_inflation_callables.py |   1 -
 .../jist_intensity_mp_2rage_masking.yaml      | 115 ------
 ...st_intensity_mp_2rage_masking_callables.py |   1 -
 .../jist_laminar_profile_calculator.yaml      |  89 -----
 ...st_laminar_profile_calculator_callables.py |   1 -
 .../jist_laminar_profile_geometry.yaml        |  91 -----
 ...jist_laminar_profile_geometry_callables.py |   1 -
 .../jist_laminar_profile_sampling.yaml        |  97 ------
 ...jist_laminar_profile_sampling_callables.py |   1 -
 .../jist_laminar_roi_averaging.yaml           |  93 -----
 .../jist_laminar_roi_averaging_callables.py   |   1 -
 .../jist_laminar_volumetric_layering.yaml     | 127 -------
 ...t_laminar_volumetric_layering_callables.py |   1 -
 .../medic_algorithm_image_calculator.yaml     |  93 -----
 ...ic_algorithm_image_calculator_callables.py |   1 -
 .../medic_algorithm_lesion_toads.yaml         | 192 ----------
 .../medic_algorithm_lesion_toads_callables.py |   1 -
 .../medic_algorithm_mipav_reorient.yaml       |  99 ------
 ...edic_algorithm_mipav_reorient_callables.py |   1 -
 .../pydra-mipav/medic_algorithm_n3.yaml       | 105 ------
 .../medic_algorithm_n3_callables.py           |   1 -
 .../medic_algorithm_spectre2010.yaml          | 212 -----------
 .../medic_algorithm_spectre2010_callables.py  |   1 -
 ...ic_algorithm_threshold_to_binary_mask.yaml |  91 -----
 ...ithm_threshold_to_binary_mask_callables.py |   1 -
 .../pydra-mipav/random_vol.yaml               |  97 ------
 .../pydra-mipav/random_vol_callables.py       |   1 -
 .../pydra-niftyfit/dwi_tool.yaml              | 252 --------------
 .../pydra-niftyfit/dwi_tool_callables.py      |   1 -
 .../pydra-niftyfit/fit_asl.yaml               | 227 ------------
 .../pydra-niftyfit/fit_asl_callables.py       |   1 -
 .../pydra-niftyfit/fit_dwi.yaml               | 328 ------------------
 .../pydra-niftyfit/fit_dwi_callables.py       |   1 -
 .../pydra-niftyfit/fit_qt_1.yaml              | 248 -------------
 .../pydra-niftyfit/fit_qt_1_callables.py      |   1 -
 .../pydra-niftyreg/reg_aladin.yaml            | 209 -----------
 .../pydra-niftyreg/reg_aladin_callables.py    |   1 -
 .../pydra-niftyreg/reg_average.yaml           | 161 ---------
 .../pydra-niftyreg/reg_average_callables.py   |   1 -
 .../pydra-niftyreg/reg_f3d.yaml               | 262 --------------
 .../pydra-niftyreg/reg_f3d_callables.py       |   1 -
 .../pydra-niftyreg/reg_jacobian.yaml          | 145 --------
 .../pydra-niftyreg/reg_jacobian_callables.py  |   1 -
 .../pydra-niftyreg/reg_measure.yaml           | 149 --------
 .../pydra-niftyreg/reg_measure_callables.py   |   1 -
 .../pydra-niftyreg/reg_resample.yaml          | 172 ---------
 .../pydra-niftyreg/reg_resample_callables.py  |   1 -
 .../pydra-niftyreg/reg_tools.yaml             | 174 ----------
 .../pydra-niftyreg/reg_tools_callables.py     |   1 -
 .../pydra-niftyreg/reg_transform.yaml         | 184 ----------
 .../pydra-niftyreg/reg_transform_callables.py |   1 -
 .../pydra-niftyseg/binary_maths.yaml          | 295 ----------------
 .../pydra-niftyseg/binary_maths_callables.py  |   1 -
 .../pydra-niftyseg/binary_maths_integer.yaml  | 167 ---------
 .../binary_maths_integer_callables.py         |   1 -
 .../pydra-niftyseg/binary_stats.yaml          | 165 ---------
 .../pydra-niftyseg/binary_stats_callables.py  |   1 -
 .../pydra-niftyseg/calc_top_ncc.yaml          | 140 --------
 .../pydra-niftyseg/calc_top_ncc_callables.py  |   1 -
 .../nipype_internal/pydra-niftyseg/em.yaml    | 180 ----------
 .../pydra-niftyseg/em_callables.py            |   1 -
 .../pydra-niftyseg/fill_lesions.yaml          | 162 ---------
 .../pydra-niftyseg/fill_lesions_callables.py  |   1 -
 .../pydra-niftyseg/label_fusion.yaml          | 208 -----------
 .../pydra-niftyseg/label_fusion_callables.py  |   1 -
 .../pydra-niftyseg/maths_command.yaml         |  96 -----
 .../pydra-niftyseg/maths_command_callables.py |   1 -
 .../nipype_internal/pydra-niftyseg/merge.yaml | 151 --------
 .../pydra-niftyseg/merge_callables.py         |   1 -
 .../pydra-niftyseg/patch_match.yaml           | 165 ---------
 .../pydra-niftyseg/patch_match_callables.py   |   1 -
 .../pydra-niftyseg/stats_command.yaml         |  88 -----
 .../pydra-niftyseg/stats_command_callables.py |   1 -
 .../pydra-niftyseg/tuple_maths.yaml           | 269 --------------
 .../pydra-niftyseg/tuple_maths_callables.py   |   1 -
 .../pydra-niftyseg/unary_maths.yaml           | 307 ----------------
 .../pydra-niftyseg/unary_maths_callables.py   |   1 -
 .../pydra-niftyseg/unary_stats.yaml           | 217 ------------
 .../pydra-niftyseg/unary_stats_callables.py   |   1 -
 .../pydra-nilearn/nilearn_base_interface.yaml |  62 ----
 .../nilearn_base_interface_callables.py       |   1 -
 .../pydra-nilearn/signal_extraction.yaml      |  98 ------
 .../signal_extraction_callables.py            |   1 -
 .../pydra-nitime/coherence_analyzer.yaml      |  94 -----
 .../coherence_analyzer_callables.py           |   1 -
 .../nipype_internal/pydra-petpvc/petpvc.yaml  | 128 -------
 .../pydra-petpvc/petpvc_callables.py          |   1 -
 .../pydra-quickshear/quickshear.yaml          | 155 ---------
 .../pydra-quickshear/quickshear_callables.py  |   1 -
 .../pydra-robex/robex_segment.yaml            | 142 --------
 .../pydra-robex/robex_segment_callables.py    |   1 -
 ...binary_mask_editor_based_on_landmarks.yaml |  95 -----
 ...ask_editor_based_on_landmarks_callables.py |   1 -
 .../pydra-semtools/brains_align_msp.yaml      | 105 ------
 .../brains_align_msp_callables.py             |   1 -
 .../pydra-semtools/brains_clip_inferior.yaml  |  89 -----
 .../brains_clip_inferior_callables.py         |   1 -
 .../brains_constellation_detector.yaml        | 209 -----------
 ...brains_constellation_detector_callables.py |   1 -
 .../brains_constellation_modeler.yaml         | 107 ------
 .../brains_constellation_modeler_callables.py |   1 -
 ...reate_label_map_from_probability_maps.yaml |  97 ------
 ...bel_map_from_probability_maps_callables.py |   1 -
 .../pydra-semtools/brains_cut.yaml            | 115 ------
 .../pydra-semtools/brains_cut_callables.py    |   1 -
 .../pydra-semtools/brains_demon_warp.yaml     | 185 ----------
 .../brains_demon_warp_callables.py            |   1 -
 .../pydra-semtools/brains_eye_detector.yaml   |  87 -----
 .../brains_eye_detector_callables.py          |   1 -
 .../pydra-semtools/brains_fit.yaml            | 257 --------------
 .../pydra-semtools/brains_fit_callables.py    |   1 -
 .../brains_initialized_control_points.yaml    |  97 ------
 ...ns_initialized_control_points_callables.py |   1 -
 .../brains_landmark_initializer.yaml          |  95 -----
 .../brains_landmark_initializer_callables.py  |   1 -
 .../brains_linear_modeler_epca.yaml           |  81 -----
 .../brains_linear_modeler_epca_callables.py   |   1 -
 .../pydra-semtools/brains_lmk_transform.yaml  | 105 ------
 .../brains_lmk_transform_callables.py         |   1 -
 .../pydra-semtools/brains_multi_staple.yaml   | 101 ------
 .../brains_multi_staple_callables.py          |   1 -
 .../pydra-semtools/brains_mush.yaml           | 131 -------
 .../pydra-semtools/brains_mush_callables.py   |   1 -
 .../brains_posterior_to_continuous_class.yaml | 115 ------
 ...posterior_to_continuous_class_callables.py |   1 -
 .../pydra-semtools/brains_resample.yaml       | 115 ------
 .../brains_resample_callables.py              |   1 -
 .../pydra-semtools/brains_resize.yaml         |  93 -----
 .../pydra-semtools/brains_resize_callables.py |   1 -
 .../brains_snap_shot_writer.yaml              |  99 ------
 .../brains_snap_shot_writer_callables.py      |   1 -
 .../pydra-semtools/brains_talairach.yaml      | 113 ------
 .../brains_talairach_callables.py             |   1 -
 .../pydra-semtools/brains_talairach_mask.yaml | 103 ------
 .../brains_talairach_mask_callables.py        |   1 -
 .../brains_transform_convert.yaml             | 103 ------
 .../brains_transform_convert_callables.py     |   1 -
 .../brains_transform_from_fiducials.yaml      | 101 ------
 ...ains_transform_from_fiducials_callables.py |   1 -
 .../brains_trim_foreground_in_direction.yaml  |  97 ------
 ..._trim_foreground_in_direction_callables.py |   1 -
 .../pydra-semtools/brainsabc.yaml             | 167 ---------
 .../pydra-semtools/brainsabc_callables.py     |   1 -
 .../pydra-semtools/brainsroi_auto.yaml        | 111 ------
 .../brainsroi_auto_callables.py               |   1 -
 .../pydra-semtools/canny_edge.yaml            |  95 -----
 .../pydra-semtools/canny_edge_callables.py    |   1 -
 ...y_segmentation_level_set_image_filter.yaml | 109 ------
 ...tation_level_set_image_filter_callables.py |   1 -
 .../clean_up_overlap_labels.yaml              |  82 -----
 .../clean_up_overlap_labels_callables.py      |   1 -
 .../compare_tract_inclusion.yaml              | 101 ------
 .../compare_tract_inclusion_callables.py      |   1 -
 .../pydra-semtools/dilate_image.yaml          |  95 -----
 .../pydra-semtools/dilate_image_callables.py  |   1 -
 .../pydra-semtools/dilate_mask.yaml           |  97 ------
 .../pydra-semtools/dilate_mask_callables.py   |   1 -
 .../pydra-semtools/distance_maps.yaml         |  95 -----
 .../pydra-semtools/distance_maps_callables.py |   1 -
 .../pydra-semtools/dtiaverage.yaml            |  98 ------
 .../pydra-semtools/dtiaverage_callables.py    |   1 -
 .../pydra-semtools/dtiestim.yaml              | 163 ---------
 .../pydra-semtools/dtiestim_callables.py      |   1 -
 .../pydra-semtools/dtiprocess.yaml            | 225 ------------
 .../pydra-semtools/dtiprocess_callables.py    |   1 -
 .../dump_binary_training_vectors.yaml         |  87 -----
 .../dump_binary_training_vectors_callables.py |   1 -
 .../pydra-semtools/dwi_compare.yaml           |  89 -----
 .../pydra-semtools/dwi_compare_callables.py   |   1 -
 .../pydra-semtools/dwi_convert.yaml           | 147 --------
 .../pydra-semtools/dwi_convert_callables.py   |   1 -
 .../pydra-semtools/dwi_simple_compare.yaml    |  91 -----
 .../dwi_simple_compare_callables.py           |   1 -
 .../pydra-semtools/erode_image.yaml           |  95 -----
 .../pydra-semtools/erode_image_callables.py   |   1 -
 .../nipype_internal/pydra-semtools/eslr.yaml  |  95 -----
 .../pydra-semtools/eslr_callables.py          |   1 -
 .../extract_nrrd_vector_index.yaml            |  97 ------
 .../extract_nrrd_vector_index_callables.py    |   1 -
 .../pydra-semtools/fcsv_to_hdf_5.yaml         |  93 -----
 .../pydra-semtools/fcsv_to_hdf_5_callables.py |   1 -
 .../pydra-semtools/fiberprocess.yaml          | 129 -------
 .../pydra-semtools/fiberprocess_callables.py  |   1 -
 .../pydra-semtools/fiberstats.yaml            |  91 -----
 .../pydra-semtools/fiberstats_callables.py    |   1 -
 .../pydra-semtools/fibertrack.yaml            | 122 -------
 .../pydra-semtools/fibertrack_callables.py    |   1 -
 .../pydra-semtools/find_center_of_brain.yaml  | 139 --------
 .../find_center_of_brain_callables.py         |   1 -
 .../pydra-semtools/flipped_difference.yaml    |  93 -----
 .../flipped_difference_callables.py           |   1 -
 .../generate_average_lmk_file.yaml            |  81 -----
 .../generate_average_lmk_file_callables.py    |   1 -
 .../generate_brain_clipped_image.yaml         |  93 -----
 .../generate_brain_clipped_image_callables.py |   1 -
 ...ate_csf_clipped_from_classified_image.yaml |  89 -----
 ...clipped_from_classified_image_callables.py |   1 -
 .../generate_edge_map_image.yaml              | 105 ------
 .../generate_edge_map_image_callables.py      |   1 -
 ...nerate_label_map_from_probability_map.yaml |  87 -----
 ...abel_map_from_probability_map_callables.py |   1 -
 .../generate_pure_plug_mask.yaml              |  89 -----
 .../generate_pure_plug_mask_callables.py      |   1 -
 .../generate_summed_gradient_image.yaml       |  95 -----
 ...enerate_summed_gradient_image_callables.py |   1 -
 .../pydra-semtools/generate_test_image.yaml   |  93 -----
 .../generate_test_image_callables.py          |   1 -
 ...nt_anisotropic_diffusion_image_filter.yaml |  89 -----
 ...tropic_diffusion_image_filter_callables.py |   1 -
 .../pydra-semtools/gtract_anisotropy_map.yaml |  95 -----
 .../gtract_anisotropy_map_callables.py        |   1 -
 .../gtract_average_bvalues.yaml               |  97 ------
 .../gtract_average_bvalues_callables.py       |   1 -
 .../gtract_clip_anisotropy.yaml               |  97 ------
 .../gtract_clip_anisotropy_callables.py       |   1 -
 .../pydra-semtools/gtract_co_reg_anatomy.yaml | 139 --------
 .../gtract_co_reg_anatomy_callables.py        |   1 -
 .../pydra-semtools/gtract_concat_dwi.yaml     |  95 -----
 .../gtract_concat_dwi_callables.py            |   1 -
 .../gtract_copy_image_orientation.yaml        |  97 ------
 ...gtract_copy_image_orientation_callables.py |   1 -
 .../pydra-semtools/gtract_coreg_bvalues.yaml  | 125 -------
 .../gtract_coreg_bvalues_callables.py         |   1 -
 .../gtract_cost_fast_marching.yaml            | 115 ------
 .../gtract_cost_fast_marching_callables.py    |   1 -
 .../gtract_create_guide_fiber.yaml            |  97 ------
 .../gtract_create_guide_fiber_callables.py    |   1 -
 .../gtract_fast_marching_tracking.yaml        | 121 -------
 ...gtract_fast_marching_tracking_callables.py |   1 -
 .../pydra-semtools/gtract_fiber_tracking.yaml | 151 --------
 .../gtract_fiber_tracking_callables.py        |   1 -
 .../gtract_image_conformity.yaml              |  97 ------
 .../gtract_image_conformity_callables.py      |   1 -
 .../gtract_invert_b_spline_transform.yaml     |  99 ------
 ...act_invert_b_spline_transform_callables.py |   1 -
 .../gtract_invert_displacement_field.yaml     |  99 ------
 ...act_invert_displacement_field_callables.py |   1 -
 .../gtract_invert_rigid_transform.yaml        |  93 -----
 ...gtract_invert_rigid_transform_callables.py |   1 -
 .../gtract_resample_anisotropy.yaml           | 103 ------
 .../gtract_resample_anisotropy_callables.py   |   1 -
 .../pydra-semtools/gtract_resample_b0.yaml    | 105 ------
 .../gtract_resample_b0_callables.py           |   1 -
 .../gtract_resample_code_image.yaml           | 103 ------
 .../gtract_resample_code_image_callables.py   |   1 -
 .../gtract_resample_dwi_in_place.yaml         | 115 ------
 .../gtract_resample_dwi_in_place_callables.py |   1 -
 .../gtract_resample_fibers.yaml               | 103 ------
 .../gtract_resample_fibers_callables.py       |   1 -
 .../pydra-semtools/gtract_tensor.yaml         | 113 ------
 .../pydra-semtools/gtract_tensor_callables.py |   1 -
 ...tract_transform_to_displacement_field.yaml |  97 ------
 ...ansform_to_displacement_field_callables.py |   1 -
 .../hammer_attribute_creator.yaml             |  97 ------
 .../hammer_attribute_creator_callables.py     |   1 -
 .../histogram_matching_filter.yaml            | 107 ------
 .../histogram_matching_filter_callables.py    |   1 -
 .../pydra-semtools/image_region_plotter.yaml  | 101 ------
 .../image_region_plotter_callables.py         |   1 -
 .../pydra-semtools/insert_mid_acp_cpoint.yaml |  83 -----
 .../insert_mid_acp_cpoint_callables.py        |   1 -
 .../pydra-semtools/joint_histogram.yaml       |  95 -----
 .../joint_histogram_callables.py              |   1 -
 .../pydra-semtools/landmarks_compare.yaml     |  83 -----
 .../landmarks_compare_callables.py            |   1 -
 .../landmarks_constellation_aligner.yaml      |  83 -----
 ...ndmarks_constellation_aligner_callables.py |   1 -
 .../landmarks_constellation_weights.yaml      |  89 -----
 ...ndmarks_constellation_weights_callables.py |   1 -
 .../pydra-semtools/maxcurvature.yaml          |  99 ------
 .../pydra-semtools/maxcurvature_callables.py  |   1 -
 .../pydra-semtools/neighborhood_mean.yaml     |  95 -----
 .../neighborhood_mean_callables.py            |   1 -
 .../pydra-semtools/neighborhood_median.yaml   |  95 -----
 .../neighborhood_median_callables.py          |   1 -
 .../pydra-semtools/scalartransform.yaml       | 107 ------
 .../scalartransform_callables.py              |   1 -
 .../shuffle_vectors_module.yaml               |  89 -----
 .../shuffle_vectors_module_callables.py       |   1 -
 .../pydra-semtools/similarity_index.yaml      |  91 -----
 .../similarity_index_callables.py             |   1 -
 .../spherical_coordinate_generation.yaml      |  81 -----
 ...herical_coordinate_generation_callables.py |   1 -
 .../pydra-semtools/staple_analysis.yaml       |  91 -----
 .../staple_analysis_callables.py              |   1 -
 .../texture_from_noise_image_filter.yaml      |  91 -----
 ...xture_from_noise_image_filter_callables.py |   1 -
 .../texture_measure_filter.yaml               |  97 ------
 .../texture_measure_filter_callables.py       |   1 -
 .../pydra-semtools/ukf_tractography.yaml      | 159 ---------
 .../ukf_tractography_callables.py             |   1 -
 .../unbiased_non_local_means.yaml             | 107 ------
 .../unbiased_non_local_means_callables.py     |   1 -
 .../pydra-semtools/vbrains_demon_warp.yaml    | 187 ----------
 .../vbrains_demon_warp_callables.py           |   1 -
 .../pydra-slicer/acpc_transform.yaml          |  93 -----
 .../pydra-slicer/acpc_transform_callables.py  |   1 -
 .../pydra-slicer/add_scalar_volumes.yaml      |  95 -----
 .../add_scalar_volumes_callables.py           |   1 -
 .../pydra-slicer/affine_registration.yaml     | 121 -------
 .../affine_registration_callables.py          |   1 -
 .../b_spline_deformable_registration.yaml     | 123 -------
 ...pline_deformable_registration_callables.py |   1 -
 .../b_spline_to_deformation_field.yaml        |  93 -----
 ...b_spline_to_deformation_field_callables.py |   1 -
 .../pydra-slicer/brains_demon_warp.yaml       | 188 ----------
 .../brains_demon_warp_callables.py            |   1 -
 .../pydra-slicer/brains_fit.yaml              | 241 -------------
 .../pydra-slicer/brains_fit_callables.py      |   1 -
 .../pydra-slicer/brains_resample.yaml         | 117 -------
 .../pydra-slicer/brains_resample_callables.py |   1 -
 .../pydra-slicer/brainsroi_auto.yaml          | 108 ------
 .../pydra-slicer/brainsroi_auto_callables.py  |   1 -
 .../pydra-slicer/cast_scalar_volume.yaml      |  93 -----
 .../cast_scalar_volume_callables.py           |   1 -
 .../pydra-slicer/checker_board_filter.yaml    |  95 -----
 .../checker_board_filter_callables.py         |   1 -
 .../curvature_anisotropic_diffusion.yaml      |  99 ------
 ...rvature_anisotropic_diffusion_callables.py |   1 -
 .../pydra-slicer/dicom_to_nrrd_converter.yaml | 101 ------
 .../dicom_to_nrrd_converter_callables.py      |   1 -
 .../diffusion_tensor_scalar_measurements.yaml |  91 -----
 ...on_tensor_scalar_measurements_callables.py |   1 -
 .../diffusion_weighted_volume_masking.yaml    |  99 ------
 ...usion_weighted_volume_masking_callables.py |   1 -
 .../pydra-slicer/dt_iexport.yaml              |  89 -----
 .../pydra-slicer/dt_iexport_callables.py      |   1 -
 .../pydra-slicer/dt_iimport.yaml              |  91 -----
 .../pydra-slicer/dt_iimport_callables.py      |   1 -
 .../dwi_joint_rician_lmmse_filter.yaml        | 100 ------
 ...dwi_joint_rician_lmmse_filter_callables.py |   1 -
 .../pydra-slicer/dwi_rician_lmmse_filter.yaml | 112 ------
 .../dwi_rician_lmmse_filter_callables.py      |   1 -
 .../pydra-slicer/dwi_to_dti_estimation.yaml   | 107 ------
 .../dwi_to_dti_estimation_callables.py        |   1 -
 .../dwi_unbiased_non_local_means_filter.yaml  | 103 ------
 ...biased_non_local_means_filter_callables.py |   1 -
 .../pydra-slicer/em_segment_command_line.yaml | 148 --------
 .../em_segment_command_line_callables.py      |   1 -
 .../em_segment_transform_to_new_format.yaml   |  89 -----
 ...gment_transform_to_new_format_callables.py |   1 -
 .../expert_automated_registration.yaml        | 151 --------
 ...expert_automated_registration_callables.py |   1 -
 .../pydra-slicer/extract_skeleton.yaml        |  97 ------
 .../extract_skeleton_callables.py             |   1 -
 .../pydra-slicer/fiducial_registration.yaml   |  95 -----
 .../fiducial_registration_callables.py        |   1 -
 .../gaussian_blur_image_filter.yaml           |  91 -----
 .../gaussian_blur_image_filter_callables.py   |   1 -
 .../gradient_anisotropic_diffusion.yaml       |  97 ------
 ...radient_anisotropic_diffusion_callables.py |   1 -
 .../grayscale_fill_hole_image_filter.yaml     |  97 ------
 ...yscale_fill_hole_image_filter_callables.py |   1 -
 .../grayscale_grind_peak_image_filter.yaml    |  99 ------
 ...scale_grind_peak_image_filter_callables.py |   1 -
 .../pydra-slicer/grayscale_model_maker.yaml   | 103 ------
 .../grayscale_model_maker_callables.py        |   1 -
 .../pydra-slicer/histogram_matching.yaml      | 105 ------
 .../histogram_matching_callables.py           |   1 -
 .../pydra-slicer/image_label_combine.yaml     |  93 -----
 .../image_label_combine_callables.py          |   1 -
 .../intensity_difference_metric.yaml          | 112 ------
 .../intensity_difference_metric_callables.py  |   1 -
 .../pydra-slicer/label_map_smoothing.yaml     |  97 ------
 .../label_map_smoothing_callables.py          |   1 -
 .../pydra-slicer/linear_registration.yaml     | 117 -------
 .../linear_registration_callables.py          |   1 -
 .../pydra-slicer/mask_scalar_volume.yaml      |  97 ------
 .../mask_scalar_volume_callables.py           |   1 -
 .../pydra-slicer/median_image_filter.yaml     |  91 -----
 .../median_image_filter_callables.py          |   1 -
 .../pydra-slicer/merge_models.yaml            |  93 -----
 .../pydra-slicer/merge_models_callables.py    |   1 -
 .../pydra-slicer/model_maker.yaml             | 122 -------
 .../pydra-slicer/model_maker_callables.py     |   1 -
 .../pydra-slicer/model_to_label_map.yaml      |  95 -----
 .../model_to_label_map_callables.py           |   1 -
 .../multi_resolution_affine_registration.yaml | 115 ------
 ...esolution_affine_registration_callables.py |   1 -
 .../pydra-slicer/multiply_scalar_volumes.yaml |  95 -----
 .../multiply_scalar_volumes_callables.py      |   1 -
 .../n4itk_bias_field_correction.yaml          | 117 -------
 .../n4itk_bias_field_correction_callables.py  |   1 -
 .../pydra-slicer/orient_scalar_volume.yaml    |  91 -----
 .../orient_scalar_volume_callables.py         |   1 -
 .../otsu_threshold_image_filter.yaml          |  99 ------
 .../otsu_threshold_image_filter_callables.py  |   1 -
 .../otsu_threshold_segmentation.yaml          |  97 ------
 .../otsu_threshold_segmentation_callables.py  |   1 -
 ...pet_standard_uptake_value_computation.yaml | 111 ------
 ...dard_uptake_value_computation_callables.py |   1 -
 .../pydra-slicer/probe_volume_with_model.yaml |  93 -----
 .../probe_volume_with_model_callables.py      |   1 -
 .../pydra-slicer/resample_dti_volume.yaml     | 143 --------
 .../resample_dti_volume_callables.py          |   1 -
 .../resample_scalar_vector_dwi_volume.yaml    | 143 --------
 ...mple_scalar_vector_dwi_volume_callables.py |   1 -
 .../pydra-slicer/resample_scalar_volume.yaml  |  93 -----
 .../resample_scalar_volume_callables.py       |   1 -
 .../pydra-slicer/rigid_registration.yaml      | 129 -------
 .../rigid_registration_callables.py           |   1 -
 .../robust_statistics_segmenter.yaml          | 103 ------
 .../robust_statistics_segmenter_callables.py  |   1 -
 .../simple_region_growing_segmentation.yaml   | 103 ------
 ...e_region_growing_segmentation_callables.py |   1 -
 .../pydra-slicer/subtract_scalar_volumes.yaml |  95 -----
 .../subtract_scalar_volumes_callables.py      |   1 -
 .../pydra-slicer/threshold_scalar_volume.yaml |  99 ------
 .../threshold_scalar_volume_callables.py      |   1 -
 .../tractography_label_map_seeding.yaml       | 127 -------
 ...ractography_label_map_seeding_callables.py |   1 -
 .../pydra-slicer/vbrains_demon_warp.yaml      | 190 ----------
 .../vbrains_demon_warp_callables.py           |   1 -
 ...ting_binary_hole_filling_image_filter.yaml |  97 ------
 ...ary_hole_filling_image_filter_callables.py |   1 -
 .../pydra-spm/analyze_2nii.yaml               |  86 -----
 .../pydra-spm/analyze_2nii_callables.py       |   1 -
 .../pydra-spm/apply_deformations.yaml         |  84 -----
 .../pydra-spm/apply_deformations_callables.py |   1 -
 .../pydra-spm/apply_inverse_deformation.yaml  | 108 ------
 .../apply_inverse_deformation_callables.py    |   1 -
 .../pydra-spm/apply_transform.yaml            | 102 ------
 .../pydra-spm/apply_transform_callables.py    |   1 -
 .../nipype_internal/pydra-spm/apply_vdm.yaml  | 103 ------
 .../pydra-spm/apply_vdm_callables.py          |   1 -
 .../pydra-spm/calc_coreg_affine.yaml          | 120 -------
 .../pydra-spm/calc_coreg_affine_callables.py  |   1 -
 .../nipype_internal/pydra-spm/coregister.yaml | 113 ------
 .../pydra-spm/coregister_callables.py         |   1 -
 .../pydra-spm/create_warped.yaml              |  96 -----
 .../pydra-spm/create_warped_callables.py      |   1 -
 .../nipype_internal/pydra-spm/dartel.yaml     |  97 ------
 .../pydra-spm/dartel_callables.py             |   1 -
 .../pydra-spm/dartel_norm_2mni.yaml           | 104 ------
 .../pydra-spm/dartel_norm_2mni_callables.py   |   1 -
 .../pydra-spm/dicom_import.yaml               |  95 -----
 .../pydra-spm/dicom_import_callables.py       |   1 -
 .../pydra-spm/estimate_contrast.yaml          | 110 ------
 .../pydra-spm/estimate_contrast_callables.py  |   1 -
 .../pydra-spm/estimate_model.yaml             |  99 ------
 .../pydra-spm/estimate_model_callables.py     |   1 -
 .../pydra-spm/factorial_design.yaml           | 108 ------
 .../pydra-spm/factorial_design_callables.py   |   1 -
 .../nipype_internal/pydra-spm/field_map.yaml  | 157 ---------
 .../pydra-spm/field_map_callables.py          |   1 -
 .../pydra-spm/level_1_design.yaml             | 123 -------
 .../pydra-spm/level_1_design_callables.py     |   1 -
 .../pydra-spm/multi_channel_new_segment.yaml  | 113 ------
 .../multi_channel_new_segment_callables.py    |   1 -
 .../pydra-spm/multiple_regression_design.yaml | 120 -------
 .../multiple_regression_design_callables.py   |   1 -
 .../pydra-spm/new_segment.yaml                | 116 -------
 .../pydra-spm/new_segment_callables.py        |   1 -
 .../nipype_internal/pydra-spm/normalize.yaml  | 131 -------
 .../pydra-spm/normalize_12.yaml               | 122 -------
 .../pydra-spm/normalize_12_callables.py       |   1 -
 .../pydra-spm/normalize_callables.py          |   1 -
 .../pydra-spm/one_sample_t_test_design.yaml   | 116 -------
 .../one_sample_t_test_design_callables.py     |   1 -
 .../pydra-spm/paired_t_test_design.yaml       | 118 -------
 .../paired_t_test_design_callables.py         |   1 -
 .../nipype_internal/pydra-spm/realign.yaml    | 119 -------
 .../pydra-spm/realign_callables.py            |   1 -
 .../pydra-spm/realign_unwarp.yaml             | 145 --------
 .../pydra-spm/realign_unwarp_callables.py     |   1 -
 .../nipype_internal/pydra-spm/reslice.yaml    |  93 -----
 .../pydra-spm/reslice_callables.py            |   1 -
 .../pydra-spm/reslice_to_reference.yaml       |  99 ------
 .../reslice_to_reference_callables.py         |   1 -
 .../nipype_internal/pydra-spm/segment.yaml    | 146 --------
 .../pydra-spm/segment_callables.py            |   1 -
 .../pydra-spm/slice_timing.yaml               | 105 ------
 .../pydra-spm/slice_timing_callables.py       |   1 -
 .../nipype_internal/pydra-spm/smooth.yaml     |  95 -----
 .../pydra-spm/smooth_callables.py             |   1 -
 .../nipype_internal/pydra-spm/threshold.yaml  | 117 -------
 .../pydra-spm/threshold_callables.py          |   1 -
 .../pydra-spm/threshold_statistics.yaml       | 100 ------
 .../threshold_statistics_callables.py         |   1 -
 .../pydra-spm/two_sample_t_test_design.yaml   | 125 -------
 .../two_sample_t_test_design_callables.py     |   1 -
 .../pydra-spm/vbm_segment.yaml                | 156 ---------
 .../pydra-spm/vbm_segment_callables.py        |   1 -
 .../pydra-vista/vnifti_2_image.yaml           | 127 -------
 .../pydra-vista/vnifti_2_image_callables.py   |   1 -
 .../nipype_internal/pydra-vista/vto_mat.yaml  | 123 -------
 .../pydra-vista/vto_mat_callables.py          |   1 -
 .../pydra-workbench/cifti_smooth.yaml         | 203 -----------
 .../pydra-workbench/cifti_smooth_callables.py |   1 -
 .../pydra-workbench/metric_resample.yaml      | 200 -----------
 .../metric_resample_callables.py              |   1 -
 nipype2pydra/task/function.py                 |  30 +-
 scripts/pkg_gen/afni-qwarp-only.yaml          |   6 +
 scripts/pkg_gen/create_packages.py            |  30 +-
 scripts/pkg_gen/example-packages.yaml         |   4 +
 tests/test_task.py                            |  14 +
 1434 files changed, 344 insertions(+), 49958 deletions(-)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/a_boverlap.yaml (97%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/a_boverlap_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/afn_ito_nifti.yaml (97%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/afn_ito_nifti_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/align_epi_anat_py.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/align_epi_anat_py_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/allineate.yaml (97%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/allineate_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/auto_tcorrelate.yaml (98%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/auto_tcorrelate_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/auto_tlrc.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/auto_tlrc_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/autobox.yaml (98%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/autobox_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/automask.yaml (98%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/automask_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/axialize.yaml (97%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/axialize_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/bandpass.yaml (98%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/bandpass_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/blur_in_mask.yaml (98%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/blur_in_mask_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/blur_to_fwhm.yaml (98%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/blur_to_fwhm_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/brick_stat.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/brick_stat_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/bucket.yaml (99%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/bucket_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/calc.yaml (98%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/calc_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/cat.yaml (97%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/cat_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/cat_matvec.yaml (97%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/cat_matvec_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/center_mass.yaml (98%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/center_mass_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/clip_level.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/clip_level_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/convert_dset.yaml (97%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/convert_dset_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/copy.yaml (98%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/copy_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/deconvolve.yaml (97%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/deconvolve_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/degree_centrality.yaml (98%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/degree_centrality_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/despike.yaml (98%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/despike_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/detrend.yaml (98%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/detrend_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/dot.yaml (97%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/dot_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/ecm.yaml (98%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/ecm_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/edge_3.yaml (98%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/edge_3_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/eval.yaml (98%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/eval_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/fim.yaml (98%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/fim_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/fourier.yaml (98%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/fourier_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/fwh_mx.yaml (96%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/fwh_mx_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/gcor.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/gcor_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/hist.yaml (96%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/hist_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/lfcd.yaml (98%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/lfcd_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/local_bistat.yaml (99%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/local_bistat_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/localstat.yaml (99%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/localstat_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/mask_tool.yaml (98%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/mask_tool_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/maskave.yaml (98%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/maskave_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/means.yaml (98%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/means_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/merge.yaml (97%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/merge_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/net_corr.yaml (99%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/net_corr_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/notes.yaml (98%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/notes_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/nwarp_adjust.yaml (96%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/nwarp_adjust_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/nwarp_apply.yaml (98%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/nwarp_apply_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/nwarp_cat.yaml (98%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/nwarp_cat_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/one_d_tool_py.yaml (96%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/one_d_tool_py_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/outlier_count.yaml (98%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/outlier_count_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/quality_index.yaml (97%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/quality_index_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/qwarp.yaml (99%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/qwarp_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/qwarp_plus_minus.yaml (99%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/qwarp_plus_minus_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/re_ho.yaml (98%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/re_ho_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/refit.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/refit_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/remlfit.yaml (96%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/remlfit_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/resample.yaml (98%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/resample_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/retroicor.yaml (98%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/retroicor_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/roi_stats.yaml (98%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/roi_stats_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/seg.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/seg_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/skull_strip.yaml (98%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/skull_strip_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/svm_test.yaml (97%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/svm_test_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/svm_train.yaml (97%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/svm_train_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/synthesize.yaml (98%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/synthesize_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/t_cat.yaml (98%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/t_cat_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/t_cat_sub_brick.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/t_cat_sub_brick_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/t_corr_1d.yaml (97%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/t_corr_1d_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/t_corr_map.yaml (99%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/t_corr_map_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/t_correlate.yaml (98%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/t_correlate_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/t_norm.yaml (98%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/t_norm_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/t_project.yaml (98%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/t_project_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/t_shift.yaml (99%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/t_shift_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/t_smooth.yaml (98%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/t_smooth_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/t_stat.yaml (97%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/t_stat_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/to_3d.yaml (98%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/to_3d_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/undump.yaml (98%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/undump_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/unifize.yaml (98%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/unifize_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/volreg.yaml (98%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/volreg_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/warp.yaml (98%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/warp_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/z_cut_up.yaml (97%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/z_cut_up_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/zcat.yaml (97%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/zcat_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/zeropad.yaml (98%)
 rename example-specs/task/{nipype_internal/pydra-afni => nipype/afni}/zeropad_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-ants => nipype/ants}/affine_initializer.yaml (98%)
 rename example-specs/task/{nipype_internal/pydra-ants => nipype/ants}/affine_initializer_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-ants => nipype/ants}/ai.yaml (97%)
 rename example-specs/task/{nipype_internal/pydra-ants => nipype/ants}/ai_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-ants => nipype/ants}/ants.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-ants => nipype/ants}/ants_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-ants => nipype/ants}/ants_introduction.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-ants => nipype/ants}/ants_introduction_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-ants => nipype/ants}/apply_transforms.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-ants => nipype/ants}/apply_transforms_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-ants => nipype/ants}/apply_transforms_to_points.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-ants => nipype/ants}/apply_transforms_to_points_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-ants => nipype/ants}/atropos.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-ants => nipype/ants}/atropos_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-ants => nipype/ants}/average_affine_transform.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-ants => nipype/ants}/average_affine_transform_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-ants => nipype/ants}/average_images.yaml (97%)
 rename example-specs/task/{nipype_internal/pydra-ants => nipype/ants}/average_images_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-ants => nipype/ants}/brain_extraction.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-ants => nipype/ants}/brain_extraction_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-ants => nipype/ants}/buildtemplateparallel.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-ants => nipype/ants}/buildtemplateparallel_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-ants => nipype/ants}/compose_multi_transform.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-ants => nipype/ants}/compose_multi_transform_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-ants => nipype/ants}/composite_transform_util.yaml (98%)
 rename example-specs/task/{nipype_internal/pydra-ants => nipype/ants}/composite_transform_util_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-ants => nipype/ants}/convert_scalar_image_to_rgb.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-ants => nipype/ants}/convert_scalar_image_to_rgb_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-ants => nipype/ants}/cortical_thickness.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-ants => nipype/ants}/cortical_thickness_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-ants => nipype/ants}/create_jacobian_determinant_image.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-ants => nipype/ants}/create_jacobian_determinant_image_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-ants => nipype/ants}/create_tiled_mosaic.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-ants => nipype/ants}/create_tiled_mosaic_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-ants => nipype/ants}/denoise_image.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-ants => nipype/ants}/denoise_image_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-ants => nipype/ants}/gen_warp_fields.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-ants => nipype/ants}/gen_warp_fields_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-ants => nipype/ants}/image_math.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-ants => nipype/ants}/image_math_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-ants => nipype/ants}/joint_fusion.yaml (99%)
 rename example-specs/task/{nipype_internal/pydra-ants => nipype/ants}/joint_fusion_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-ants => nipype/ants}/kelly_kapowski.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-ants => nipype/ants}/kelly_kapowski_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-ants => nipype/ants}/label_geometry.yaml (99%)
 rename example-specs/task/{nipype_internal/pydra-ants => nipype/ants}/label_geometry_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-ants => nipype/ants}/laplacian_thickness.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-ants => nipype/ants}/laplacian_thickness_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-ants => nipype/ants}/measure_image_similarity.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-ants => nipype/ants}/measure_image_similarity_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-ants => nipype/ants}/multiply_images.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-ants => nipype/ants}/multiply_images_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-ants => nipype/ants}/n4_bias_field_correction.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-ants => nipype/ants}/n4_bias_field_correction_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-ants => nipype/ants}/registration.yaml (99%)
 rename example-specs/task/{nipype_internal/pydra-ants => nipype/ants}/registration_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-ants => nipype/ants}/registration_syn_quick.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-ants => nipype/ants}/registration_syn_quick_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-ants => nipype/ants}/resample_image_by_spacing.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-ants => nipype/ants}/resample_image_by_spacing_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-ants => nipype/ants}/threshold_image.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-ants => nipype/ants}/threshold_image_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-ants => nipype/ants}/warp_image_multi_transform.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-ants => nipype/ants}/warp_image_multi_transform_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-ants => nipype/ants}/warp_time_series_image_multi_transform.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-ants => nipype/ants}/warp_time_series_image_multi_transform_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/add_x_form_to_header.yaml (98%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/add_x_form_to_header_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/aparc_2_aseg.yaml (98%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/aparc_2_aseg_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/apas_2_aseg.yaml (97%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/apas_2_aseg_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/apply_mask.yaml (97%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/apply_mask_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/apply_vol_transform.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/apply_vol_transform_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/bb_register.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/bb_register_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/binarize.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/binarize_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/ca_label.yaml (98%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/ca_label_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/ca_normalize.yaml (98%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/ca_normalize_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/ca_register.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/ca_register_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/check_talairach_alignment.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/check_talairach_alignment_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/concatenate.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/concatenate_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/concatenate_lta.yaml (98%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/concatenate_lta_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/contrast.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/contrast_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/curvature.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/curvature_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/curvature_stats.yaml (98%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/curvature_stats_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/dicom_convert.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/dicom_convert_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/edit_w_mwith_aseg.yaml (97%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/edit_w_mwith_aseg_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/em_register.yaml (97%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/em_register_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/euler_number.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/euler_number_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/extract_main_component.yaml (97%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/extract_main_component_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/fit_ms_params.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/fit_ms_params_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/fix_topology.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/fix_topology_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/fuse_segmentations.yaml (98%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/fuse_segmentations_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/glm_fit.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/glm_fit_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/gtm_seg.yaml (98%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/gtm_seg_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/gtmpvc.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/gtmpvc_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/image_info.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/image_info_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/jacobian.yaml (97%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/jacobian_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/label_2_annot.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/label_2_annot_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/label_2_label.yaml (98%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/label_2_label_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/label_2_vol.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/label_2_vol_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/logan_ref.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/logan_ref_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/lta_convert.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/lta_convert_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/make_average_subject.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/make_average_subject_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/make_surfaces.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/make_surfaces_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/mni_bias_correction.yaml (97%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/mni_bias_correction_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/mp_rto_mni305.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/mp_rto_mni305_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/mr_is_ca_label.yaml (98%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/mr_is_ca_label_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/mr_is_calc.yaml (97%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/mr_is_calc_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/mr_is_combine.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/mr_is_combine_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/mr_is_convert.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/mr_is_convert_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/mr_is_expand.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/mr_is_expand_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/mr_is_inflate.yaml (96%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/mr_is_inflate_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/mri_convert.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/mri_convert_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/mri_coreg.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/mri_coreg_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/mri_fill.yaml (97%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/mri_fill_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/mri_marching_cubes.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/mri_marching_cubes_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/mri_pretess.yaml (98%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/mri_pretess_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/mri_tessellate.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/mri_tessellate_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/mris_preproc.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/mris_preproc_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/mris_preproc_recon_all.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/mris_preproc_recon_all_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/mrtm.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/mrtm2.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/mrtm2_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/mrtm_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/ms__lda.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/ms__lda_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/normalize.yaml (97%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/normalize_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/one_sample_t_test.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/one_sample_t_test_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/paint.yaml (96%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/paint_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/parcellation_stats.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/parcellation_stats_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/parse_dicom_dir.yaml (97%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/parse_dicom_dir_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/recon_all.yaml (75%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/recon_all_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/register.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/register_av_ito_talairach.yaml (98%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/register_av_ito_talairach_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/register_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/relabel_hypointensities.yaml (98%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/relabel_hypointensities_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/remove_intersection.yaml (97%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/remove_intersection_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/remove_neck.yaml (98%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/remove_neck_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/resample.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-dipy => nipype/freesurfer}/resample_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/robust_register.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/robust_register_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/robust_template.yaml (97%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/robust_template_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/sample_to_surface.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/sample_to_surface_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/seg_stats.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/seg_stats_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/seg_stats_recon_all.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/seg_stats_recon_all_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/segment_cc.yaml (95%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/segment_cc_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/segment_wm.yaml (97%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/segment_wm_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/smooth.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/smooth_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/smooth_tessellation.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/smooth_tessellation_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/sphere.yaml (98%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/sphere_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/spherical_average.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/spherical_average_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/surface_2_vol_transform.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/surface_2_vol_transform_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/surface_smooth.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/surface_smooth_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/surface_snapshots.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/surface_snapshots_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/surface_transform.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/surface_transform_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/synthesize_flash.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/synthesize_flash_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/talairach_avi.yaml (97%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/talairach_avi_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/talairach_qc.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/talairach_qc_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/tkregister_2.yaml (98%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/tkregister_2_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/unpack_sdicom_dir.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/unpack_sdicom_dir_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/volume_mask.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/volume_mask_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/watershed_skull_strip.yaml (97%)
 rename example-specs/task/{nipype_internal/pydra-freesurfer => nipype/freesurfer}/watershed_skull_strip_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/accuracy_tester.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/accuracy_tester_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/apply_mask.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/apply_mask_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/apply_topup.yaml (98%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/apply_topup_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/apply_warp.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-elastix => nipype/fsl}/apply_warp_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/apply_xfm.yaml (95%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/apply_xfm_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/ar1_image.yaml (99%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/ar1_image_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/av_scale.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/av_scale_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/b0_calc.yaml (98%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/b0_calc_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/bedpostx5.yaml (99%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/bedpostx5_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/bet.yaml (96%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/bet_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/binary_maths.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/binary_maths_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/change_data_type.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/change_data_type_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/classifier.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/classifier_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/cleaner.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/cleaner_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/cluster.yaml (98%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/cluster_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/complex.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/complex_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/contrast_mgr.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/contrast_mgr_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/convert_warp.yaml (97%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/convert_warp_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/convert_xfm.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/convert_xfm_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/copy_geom.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/copy_geom_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/dilate_image.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/dilate_image_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/distance_map.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/distance_map_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/dti_fit.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-camino => nipype/fsl}/dti_fit_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/dual_regression.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/dual_regression_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/eddy.yaml (99%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/eddy_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/eddy_correct.yaml (98%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/eddy_correct_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/eddy_quad.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/eddy_quad_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/epi_de_warp.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/epi_de_warp_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/epi_reg.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/epi_reg_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/erode_image.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/erode_image_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/extract_roi.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/extract_roi_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/fast.yaml (97%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/fast_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/feat.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/feat_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/feat_model.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/feat_model_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/feature_extractor.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/feature_extractor_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/filmgls.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/filmgls_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/filter_regressor.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/filter_regressor_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/find_the_biggest.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/find_the_biggest_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/first.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/first_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/flameo.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/flameo_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/flirt.yaml (96%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/flirt_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/fnirt.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/fnirt_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/fslx_command.yaml (98%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/fslx_command_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/fugue.yaml (98%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/fugue_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/glm.yaml (98%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/glm_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/ica__aroma.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/ica__aroma_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/image_maths.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/image_maths_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/image_meants.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/image_meants_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/image_stats.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-camino => nipype/fsl}/image_stats_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/inv_warp.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/inv_warp_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/isotropic_smooth.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/isotropic_smooth_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/l2_model.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/l2_model_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/level_1_design.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/level_1_design_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/make_dyadic_vectors.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/make_dyadic_vectors_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/maths_command.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/maths_command_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/max_image.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/max_image_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/maxn_image.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/maxn_image_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/mcflirt.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/mcflirt_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/mean_image.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/mean_image_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/median_image.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/median_image_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/melodic.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/melodic_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/merge.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/merge_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/min_image.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/min_image_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/motion_outliers.yaml (95%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/motion_outliers_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/multi_image_maths.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/multi_image_maths_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/multiple_regress_design.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/multiple_regress_design_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/overlay.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/overlay_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/percentile_image.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/percentile_image_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/plot_motion_params.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/plot_motion_params_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/plot_time_series.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/plot_time_series_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/power_spectrum.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/power_spectrum_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/prelude.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/prelude_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/prepare_fieldmap.yaml (97%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/prepare_fieldmap_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/prob_track_x.yaml (99%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/prob_track_x2.yaml (99%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/prob_track_x2_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/prob_track_x_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/proj_thresh.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/proj_thresh_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/randomise.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/randomise_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/reorient_2_std.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/reorient_2_std_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/robust_fov.yaml (93%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/robust_fov_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/sig_loss.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/sig_loss_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/slice.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/slice_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/slice_timer.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/slice_timer_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/slicer.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/slicer_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/smm.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/smm_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/smooth.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/smooth_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/smooth_estimate.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/smooth_estimate_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/spatial_filter.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/spatial_filter_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/split.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/split_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/std_image.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/std_image_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/susan.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/susan_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/swap_dimensions.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/swap_dimensions_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/temporal_filter.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/temporal_filter_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/text_2_vest.yaml (96%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/text_2_vest_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/threshold.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/threshold_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/topup.yaml (96%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/topup_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/tract_skeleton.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/tract_skeleton_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/training.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/training_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/training_set_creator.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/training_set_creator_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/unary_maths.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/unary_maths_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/vec_reg.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/vec_reg_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/vest_2_text.yaml (97%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/vest_2_text_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/warp_points.yaml (97%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/warp_points_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/warp_points_from_std.yaml (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/warp_points_from_std_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/warp_points_to_std.yaml (98%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/warp_points_to_std_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/warp_utils.yaml (95%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/warp_utils_callables.py (100%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/x_fibres_5.yaml (98%)
 rename example-specs/task/{nipype_internal/pydra-fsl => nipype/fsl}/x_fibres_5_callables.py (100%)
 delete mode 100644 example-specs/task/nipype_internal/pydra-brainsuite/bdp.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-brainsuite/bdp_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-brainsuite/bfc.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-brainsuite/bfc_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-brainsuite/bse.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-brainsuite/bse_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-brainsuite/cerebro.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-brainsuite/cerebro_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-brainsuite/cortex.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-brainsuite/cortex_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-brainsuite/dewisp.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-brainsuite/dewisp_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-brainsuite/dfs.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-brainsuite/dfs_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-brainsuite/hemisplit.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-brainsuite/hemisplit_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-brainsuite/pialmesh.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-brainsuite/pialmesh_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-brainsuite/pvc.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-brainsuite/pvc_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-brainsuite/scrubmask.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-brainsuite/scrubmask_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-brainsuite/skullfinder.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-brainsuite/skullfinder_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-brainsuite/sv_reg.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-brainsuite/sv_reg_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-brainsuite/tca.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-brainsuite/tca_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-brainsuite/thickness_pvc.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-brainsuite/thickness_pvc_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-bru2nii/bru_2.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-bru2nii/bru_2_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-c3/c_3d.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-c3/c_3d_affine_tool.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-c3/c_3d_affine_tool_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-c3/c_3d_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-camino/analyze_header.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-camino/analyze_header_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-camino/compute_eigensystem.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-camino/compute_eigensystem_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-camino/compute_fractional_anisotropy.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-camino/compute_fractional_anisotropy_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-camino/compute_mean_diffusivity.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-camino/compute_mean_diffusivity_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-camino/compute_tensor_trace.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-camino/compute_tensor_trace_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-camino/conmat.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-camino/conmat_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-camino/dt2n_if_ti.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-camino/dt2n_if_ti_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-camino/dt_metric.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-camino/dt_metric_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-camino/dti_fit.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-camino/dtlut_gen.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-camino/dtlut_gen_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-camino/fsl2_scheme.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-camino/fsl2_scheme_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-camino/image_2_voxel.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-camino/image_2_voxel_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-camino/image_stats.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-camino/lin_recon.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-camino/lin_recon_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-camino/mesd.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-camino/mesd_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-camino/model_fit.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-camino/model_fit_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-camino/n_if_tidt2_camino.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-camino/n_if_tidt2_camino_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-camino/pico_pd_fs.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-camino/pico_pd_fs_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-camino/proc_streamlines.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-camino/proc_streamlines_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-camino/q_ball_mx.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-camino/q_ball_mx_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-camino/sf_peaks.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-camino/sf_peaks_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-camino/sflut_gen.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-camino/sflut_gen_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-camino/sfpico_calib_data.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-camino/sfpico_calib_data_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-camino/shredder.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-camino/shredder_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-camino/track.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-camino/track_ball_stick.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-camino/track_ball_stick_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-camino/track_bayes_dirac.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-camino/track_bayes_dirac_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-camino/track_bedpostx_deter.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-camino/track_bedpostx_deter_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-camino/track_bedpostx_proba.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-camino/track_bedpostx_proba_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-camino/track_bootstrap.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-camino/track_bootstrap_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-camino/track_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-camino/track_dt.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-camino/track_dt_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-camino/track_pi_co.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-camino/track_pi_co_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-camino/tract_shredder.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-camino/tract_shredder_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-camino/vtk_streamlines.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-camino/vtk_streamlines_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-camino2trackvis/camino_2_trackvis.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-camino2trackvis/camino_2_trackvis_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-camino2trackvis/trackvis_2_camino.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-camino2trackvis/trackvis_2_camino_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-cat12/cat12_segment.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-cat12/cat12_segment_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-cat12/cat12sanlm_denoising.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-cat12/cat12sanlm_denoising_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-cat12/extract_additional_surface_parameters.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-cat12/extract_additional_surface_parameters_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-cat12/extract_roi_based_surface_measures.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-cat12/extract_roi_based_surface_measures_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-cmtk/average_networks.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-cmtk/average_networks_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-cmtk/cff_converter.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-cmtk/cff_converter_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-cmtk/create_matrix.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-cmtk/create_matrix_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-cmtk/create_nodes.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-cmtk/create_nodes_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-cmtk/merge_c_networks.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-cmtk/merge_c_networks_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-cmtk/network_based_statistic.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-cmtk/network_based_statistic_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-cmtk/network_x_metrics.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-cmtk/network_x_metrics_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-cmtk/parcellate.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-cmtk/parcellate_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-cmtk/roi_gen.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-cmtk/roi_gen_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-dcmstack/copy_meta.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-dcmstack/copy_meta_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-dcmstack/dcm_stack.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-dcmstack/dcm_stack_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-dcmstack/group_and_stack.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-dcmstack/group_and_stack_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-dcmstack/lookup_meta.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-dcmstack/lookup_meta_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-dcmstack/merge_nifti.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-dcmstack/merge_nifti_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-dcmstack/nifti_generator_base.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-dcmstack/nifti_generator_base_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-dcmstack/split_nifti.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-dcmstack/split_nifti_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-diffusion_toolkit/dti_recon.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-diffusion_toolkit/dti_recon_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-diffusion_toolkit/dti_tracker.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-diffusion_toolkit/dti_tracker_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-diffusion_toolkit/hardi_mat.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-diffusion_toolkit/hardi_mat_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-diffusion_toolkit/odf_recon.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-diffusion_toolkit/odf_recon_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-diffusion_toolkit/odf_tracker.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-diffusion_toolkit/odf_tracker_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-diffusion_toolkit/spline_filter.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-diffusion_toolkit/spline_filter_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-diffusion_toolkit/track_merge.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-diffusion_toolkit/track_merge_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-dipy/apm_qball.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-dipy/apm_qball_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-dipy/csd.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-dipy/csd_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-dipy/denoise.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-dipy/denoise_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-dipy/dti.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-dipy/dti_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-dipy/estimate_response_sh.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-dipy/estimate_response_sh_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-dipy/resample.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-dipy/restore.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-dipy/restore_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-dipy/simulate_multi_tensor.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-dipy/simulate_multi_tensor_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-dipy/streamline_tractography.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-dipy/streamline_tractography_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-dipy/tensor_mode.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-dipy/tensor_mode_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-dipy/track_density_map.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-dipy/track_density_map_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-dtitk/aff_scalar_vol.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-dtitk/aff_scalar_vol_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-dtitk/aff_scalar_vol_task.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-dtitk/aff_scalar_vol_task_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-dtitk/aff_sym_tensor_3d_vol.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-dtitk/aff_sym_tensor_3d_vol_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-dtitk/aff_sym_tensor_3d_vol_task.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-dtitk/aff_sym_tensor_3d_vol_task_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-dtitk/affine.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-dtitk/affine_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-dtitk/affine_task.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-dtitk/affine_task_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-dtitk/bin_thresh.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-dtitk/bin_thresh_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-dtitk/bin_thresh_task.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-dtitk/bin_thresh_task_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-dtitk/compose_xfm.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-dtitk/compose_xfm_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-dtitk/compose_xfm_task.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-dtitk/compose_xfm_task_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-dtitk/diffeo.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-dtitk/diffeo_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-dtitk/diffeo_scalar_vol.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-dtitk/diffeo_scalar_vol_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-dtitk/diffeo_scalar_vol_task.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-dtitk/diffeo_scalar_vol_task_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-dtitk/diffeo_sym_tensor_3d_vol.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-dtitk/diffeo_sym_tensor_3d_vol_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-dtitk/diffeo_sym_tensor_3d_vol_task.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-dtitk/diffeo_sym_tensor_3d_vol_task_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-dtitk/diffeo_task.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-dtitk/diffeo_task_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-dtitk/rigid.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-dtitk/rigid_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-dtitk/rigid_task.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-dtitk/rigid_task_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-dtitk/sv_adjust_vox_sp.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-dtitk/sv_adjust_vox_sp_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-dtitk/sv_adjust_vox_sp_task.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-dtitk/sv_adjust_vox_sp_task_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-dtitk/sv_resample.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-dtitk/sv_resample_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-dtitk/sv_resample_task.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-dtitk/sv_resample_task_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-dtitk/t_vtool.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-dtitk/t_vtool_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-dtitk/t_vtool_task.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-dtitk/t_vtool_task_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-dtitk/tv_adjust_origin_task.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-dtitk/tv_adjust_origin_task_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-dtitk/tv_adjust_vox_sp.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-dtitk/tv_adjust_vox_sp_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-dtitk/tv_adjust_vox_sp_task.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-dtitk/tv_adjust_vox_sp_task_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-dtitk/tv_resample.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-dtitk/tv_resample_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-dtitk/tv_resample_task.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-dtitk/tv_resample_task_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-dynamic_slicer/slicer_command_line.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-dynamic_slicer/slicer_command_line_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-elastix/analyze_warp.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-elastix/analyze_warp_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-elastix/apply_warp.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-elastix/edit_transform.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-elastix/edit_transform_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-elastix/points_warp.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-elastix/points_warp_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-elastix/registration.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-elastix/registration_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-freesurfer/resample_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-fsl/apply_warp_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-fsl/dti_fit_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-fsl/image_stats_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-meshfix/mesh_fix.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-meshfix/mesh_fix_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-minc/average.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-minc/average_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-minc/b_box.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-minc/b_box_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-minc/beast.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-minc/beast_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-minc/best_lin_reg.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-minc/best_lin_reg_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-minc/big_average.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-minc/big_average_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-minc/blob.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-minc/blob_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-minc/blur.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-minc/blur_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-minc/calc.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-minc/calc_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-minc/convert.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-minc/convert_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-minc/copy.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-minc/copy_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-minc/dump.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-minc/dump_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-minc/extract.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-minc/extract_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-minc/gennlxfm.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-minc/gennlxfm_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-minc/math.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-minc/math_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-minc/nlp_fit.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-minc/nlp_fit_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-minc/norm.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-minc/norm_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-minc/pik.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-minc/pik_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-minc/resample.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-minc/resample_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-minc/reshape.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-minc/reshape_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-minc/to_ecat.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-minc/to_ecat_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-minc/to_raw.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-minc/to_raw_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-minc/vol_symm.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-minc/vol_symm_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-minc/volcentre.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-minc/volcentre_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-minc/voliso.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-minc/voliso_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-minc/volpad.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-minc/volpad_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-minc/xfm_avg.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-minc/xfm_avg_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-minc/xfm_concat.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-minc/xfm_concat_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-minc/xfm_invert.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-minc/xfm_invert_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-mipav/jist_brain_mgdm_segmentation.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-mipav/jist_brain_mgdm_segmentation_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-mipav/jist_brain_mp_2rage_dura_estimation.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-mipav/jist_brain_mp_2rage_dura_estimation_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-mipav/jist_brain_mp_2rage_skull_stripping.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-mipav/jist_brain_mp_2rage_skull_stripping_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-mipav/jist_brain_partial_volume_filter.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-mipav/jist_brain_partial_volume_filter_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-mipav/jist_cortex_surface_mesh_inflation.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-mipav/jist_cortex_surface_mesh_inflation_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-mipav/jist_intensity_mp_2rage_masking.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-mipav/jist_intensity_mp_2rage_masking_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-mipav/jist_laminar_profile_calculator.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-mipav/jist_laminar_profile_calculator_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-mipav/jist_laminar_profile_geometry.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-mipav/jist_laminar_profile_geometry_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-mipav/jist_laminar_profile_sampling.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-mipav/jist_laminar_profile_sampling_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-mipav/jist_laminar_roi_averaging.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-mipav/jist_laminar_roi_averaging_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-mipav/jist_laminar_volumetric_layering.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-mipav/jist_laminar_volumetric_layering_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_image_calculator.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_image_calculator_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_lesion_toads.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_lesion_toads_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_mipav_reorient.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_mipav_reorient_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_n3.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_n3_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_spectre2010.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_spectre2010_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_threshold_to_binary_mask.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_threshold_to_binary_mask_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-mipav/random_vol.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-mipav/random_vol_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-niftyfit/dwi_tool.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-niftyfit/dwi_tool_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-niftyfit/fit_asl.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-niftyfit/fit_asl_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-niftyfit/fit_dwi.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-niftyfit/fit_dwi_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-niftyfit/fit_qt_1.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-niftyfit/fit_qt_1_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-niftyreg/reg_aladin.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-niftyreg/reg_aladin_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-niftyreg/reg_average.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-niftyreg/reg_average_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-niftyreg/reg_f3d.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-niftyreg/reg_f3d_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-niftyreg/reg_jacobian.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-niftyreg/reg_jacobian_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-niftyreg/reg_measure.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-niftyreg/reg_measure_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-niftyreg/reg_resample.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-niftyreg/reg_resample_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-niftyreg/reg_tools.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-niftyreg/reg_tools_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-niftyreg/reg_transform.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-niftyreg/reg_transform_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-niftyseg/binary_maths.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-niftyseg/binary_maths_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-niftyseg/binary_maths_integer.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-niftyseg/binary_maths_integer_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-niftyseg/binary_stats.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-niftyseg/binary_stats_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-niftyseg/calc_top_ncc.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-niftyseg/calc_top_ncc_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-niftyseg/em.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-niftyseg/em_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-niftyseg/fill_lesions.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-niftyseg/fill_lesions_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-niftyseg/label_fusion.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-niftyseg/label_fusion_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-niftyseg/maths_command.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-niftyseg/maths_command_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-niftyseg/merge.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-niftyseg/merge_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-niftyseg/patch_match.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-niftyseg/patch_match_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-niftyseg/stats_command.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-niftyseg/stats_command_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-niftyseg/tuple_maths.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-niftyseg/tuple_maths_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-niftyseg/unary_maths.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-niftyseg/unary_maths_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-niftyseg/unary_stats.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-niftyseg/unary_stats_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-nilearn/nilearn_base_interface.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-nilearn/nilearn_base_interface_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-nilearn/signal_extraction.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-nilearn/signal_extraction_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-nitime/coherence_analyzer.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-nitime/coherence_analyzer_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-petpvc/petpvc.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-petpvc/petpvc_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-quickshear/quickshear.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-quickshear/quickshear_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-robex/robex_segment.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-robex/robex_segment_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/binary_mask_editor_based_on_landmarks.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/binary_mask_editor_based_on_landmarks_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_align_msp.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_align_msp_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_clip_inferior.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_clip_inferior_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_constellation_detector.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_constellation_detector_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_constellation_modeler.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_constellation_modeler_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_create_label_map_from_probability_maps.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_create_label_map_from_probability_maps_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_cut.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_cut_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_demon_warp.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_demon_warp_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_eye_detector.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_eye_detector_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_fit.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_fit_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_initialized_control_points.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_initialized_control_points_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_landmark_initializer.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_landmark_initializer_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_linear_modeler_epca.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_linear_modeler_epca_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_lmk_transform.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_lmk_transform_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_multi_staple.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_multi_staple_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_mush.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_mush_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_posterior_to_continuous_class.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_posterior_to_continuous_class_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_resample.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_resample_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_resize.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_resize_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_snap_shot_writer.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_snap_shot_writer_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_talairach.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_talairach_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_talairach_mask.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_talairach_mask_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_transform_convert.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_transform_convert_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_transform_from_fiducials.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_transform_from_fiducials_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_trim_foreground_in_direction.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/brains_trim_foreground_in_direction_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/brainsabc.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/brainsabc_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/brainsroi_auto.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/brainsroi_auto_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/canny_edge.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/canny_edge_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/canny_segmentation_level_set_image_filter.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/canny_segmentation_level_set_image_filter_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/clean_up_overlap_labels.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/clean_up_overlap_labels_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/compare_tract_inclusion.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/compare_tract_inclusion_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/dilate_image.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/dilate_image_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/dilate_mask.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/dilate_mask_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/distance_maps.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/distance_maps_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/dtiaverage.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/dtiaverage_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/dtiestim.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/dtiestim_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/dtiprocess.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/dtiprocess_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/dump_binary_training_vectors.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/dump_binary_training_vectors_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/dwi_compare.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/dwi_compare_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/dwi_convert.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/dwi_convert_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/dwi_simple_compare.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/dwi_simple_compare_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/erode_image.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/erode_image_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/eslr.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/eslr_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/extract_nrrd_vector_index.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/extract_nrrd_vector_index_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/fcsv_to_hdf_5.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/fcsv_to_hdf_5_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/fiberprocess.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/fiberprocess_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/fiberstats.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/fiberstats_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/fibertrack.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/fibertrack_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/find_center_of_brain.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/find_center_of_brain_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/flipped_difference.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/flipped_difference_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/generate_average_lmk_file.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/generate_average_lmk_file_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/generate_brain_clipped_image.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/generate_brain_clipped_image_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/generate_csf_clipped_from_classified_image.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/generate_csf_clipped_from_classified_image_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/generate_edge_map_image.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/generate_edge_map_image_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/generate_label_map_from_probability_map.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/generate_label_map_from_probability_map_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/generate_pure_plug_mask.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/generate_pure_plug_mask_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/generate_summed_gradient_image.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/generate_summed_gradient_image_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/generate_test_image.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/generate_test_image_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/gradient_anisotropic_diffusion_image_filter.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/gradient_anisotropic_diffusion_image_filter_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_anisotropy_map.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_anisotropy_map_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_average_bvalues.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_average_bvalues_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_clip_anisotropy.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_clip_anisotropy_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_co_reg_anatomy.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_co_reg_anatomy_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_concat_dwi.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_concat_dwi_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_copy_image_orientation.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_copy_image_orientation_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_coreg_bvalues.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_coreg_bvalues_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_cost_fast_marching.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_cost_fast_marching_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_create_guide_fiber.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_create_guide_fiber_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_fast_marching_tracking.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_fast_marching_tracking_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_fiber_tracking.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_fiber_tracking_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_image_conformity.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_image_conformity_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_invert_b_spline_transform.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_invert_b_spline_transform_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_invert_displacement_field.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_invert_displacement_field_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_invert_rigid_transform.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_invert_rigid_transform_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_resample_anisotropy.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_resample_anisotropy_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_resample_b0.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_resample_b0_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_resample_code_image.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_resample_code_image_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_resample_dwi_in_place.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_resample_dwi_in_place_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_resample_fibers.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_resample_fibers_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_tensor.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_tensor_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_transform_to_displacement_field.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/gtract_transform_to_displacement_field_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/hammer_attribute_creator.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/hammer_attribute_creator_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/histogram_matching_filter.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/histogram_matching_filter_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/image_region_plotter.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/image_region_plotter_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/insert_mid_acp_cpoint.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/insert_mid_acp_cpoint_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/joint_histogram.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/joint_histogram_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/landmarks_compare.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/landmarks_compare_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/landmarks_constellation_aligner.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/landmarks_constellation_aligner_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/landmarks_constellation_weights.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/landmarks_constellation_weights_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/maxcurvature.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/maxcurvature_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/neighborhood_mean.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/neighborhood_mean_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/neighborhood_median.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/neighborhood_median_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/scalartransform.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/scalartransform_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/shuffle_vectors_module.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/shuffle_vectors_module_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/similarity_index.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/similarity_index_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/spherical_coordinate_generation.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/spherical_coordinate_generation_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/staple_analysis.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/staple_analysis_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/texture_from_noise_image_filter.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/texture_from_noise_image_filter_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/texture_measure_filter.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/texture_measure_filter_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/ukf_tractography.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/ukf_tractography_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/unbiased_non_local_means.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/unbiased_non_local_means_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/vbrains_demon_warp.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-semtools/vbrains_demon_warp_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/acpc_transform.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/acpc_transform_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/add_scalar_volumes.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/add_scalar_volumes_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/affine_registration.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/affine_registration_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/b_spline_deformable_registration.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/b_spline_deformable_registration_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/b_spline_to_deformation_field.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/b_spline_to_deformation_field_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/brains_demon_warp.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/brains_demon_warp_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/brains_fit.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/brains_fit_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/brains_resample.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/brains_resample_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/brainsroi_auto.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/brainsroi_auto_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/cast_scalar_volume.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/cast_scalar_volume_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/checker_board_filter.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/checker_board_filter_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/curvature_anisotropic_diffusion.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/curvature_anisotropic_diffusion_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/dicom_to_nrrd_converter.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/dicom_to_nrrd_converter_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/diffusion_tensor_scalar_measurements.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/diffusion_tensor_scalar_measurements_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/diffusion_weighted_volume_masking.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/diffusion_weighted_volume_masking_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/dt_iexport.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/dt_iexport_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/dt_iimport.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/dt_iimport_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/dwi_joint_rician_lmmse_filter.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/dwi_joint_rician_lmmse_filter_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/dwi_rician_lmmse_filter.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/dwi_rician_lmmse_filter_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/dwi_to_dti_estimation.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/dwi_to_dti_estimation_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/dwi_unbiased_non_local_means_filter.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/dwi_unbiased_non_local_means_filter_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/em_segment_command_line.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/em_segment_command_line_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/em_segment_transform_to_new_format.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/em_segment_transform_to_new_format_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/expert_automated_registration.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/expert_automated_registration_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/extract_skeleton.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/extract_skeleton_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/fiducial_registration.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/fiducial_registration_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/gaussian_blur_image_filter.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/gaussian_blur_image_filter_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/gradient_anisotropic_diffusion.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/gradient_anisotropic_diffusion_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/grayscale_fill_hole_image_filter.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/grayscale_fill_hole_image_filter_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/grayscale_grind_peak_image_filter.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/grayscale_grind_peak_image_filter_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/grayscale_model_maker.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/grayscale_model_maker_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/histogram_matching.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/histogram_matching_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/image_label_combine.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/image_label_combine_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/intensity_difference_metric.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/intensity_difference_metric_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/label_map_smoothing.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/label_map_smoothing_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/linear_registration.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/linear_registration_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/mask_scalar_volume.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/mask_scalar_volume_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/median_image_filter.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/median_image_filter_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/merge_models.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/merge_models_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/model_maker.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/model_maker_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/model_to_label_map.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/model_to_label_map_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/multi_resolution_affine_registration.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/multi_resolution_affine_registration_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/multiply_scalar_volumes.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/multiply_scalar_volumes_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/n4itk_bias_field_correction.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/n4itk_bias_field_correction_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/orient_scalar_volume.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/orient_scalar_volume_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/otsu_threshold_image_filter.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/otsu_threshold_image_filter_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/otsu_threshold_segmentation.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/otsu_threshold_segmentation_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/pet_standard_uptake_value_computation.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/pet_standard_uptake_value_computation_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/probe_volume_with_model.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/probe_volume_with_model_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/resample_dti_volume.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/resample_dti_volume_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/resample_scalar_vector_dwi_volume.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/resample_scalar_vector_dwi_volume_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/resample_scalar_volume.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/resample_scalar_volume_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/rigid_registration.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/rigid_registration_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/robust_statistics_segmenter.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/robust_statistics_segmenter_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/simple_region_growing_segmentation.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/simple_region_growing_segmentation_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/subtract_scalar_volumes.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/subtract_scalar_volumes_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/threshold_scalar_volume.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/threshold_scalar_volume_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/tractography_label_map_seeding.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/tractography_label_map_seeding_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/vbrains_demon_warp.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/vbrains_demon_warp_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/voting_binary_hole_filling_image_filter.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-slicer/voting_binary_hole_filling_image_filter_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-spm/analyze_2nii.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-spm/analyze_2nii_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-spm/apply_deformations.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-spm/apply_deformations_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-spm/apply_inverse_deformation.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-spm/apply_inverse_deformation_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-spm/apply_transform.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-spm/apply_transform_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-spm/apply_vdm.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-spm/apply_vdm_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-spm/calc_coreg_affine.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-spm/calc_coreg_affine_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-spm/coregister.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-spm/coregister_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-spm/create_warped.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-spm/create_warped_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-spm/dartel.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-spm/dartel_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-spm/dartel_norm_2mni.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-spm/dartel_norm_2mni_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-spm/dicom_import.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-spm/dicom_import_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-spm/estimate_contrast.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-spm/estimate_contrast_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-spm/estimate_model.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-spm/estimate_model_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-spm/factorial_design.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-spm/factorial_design_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-spm/field_map.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-spm/field_map_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-spm/level_1_design.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-spm/level_1_design_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-spm/multi_channel_new_segment.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-spm/multi_channel_new_segment_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-spm/multiple_regression_design.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-spm/multiple_regression_design_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-spm/new_segment.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-spm/new_segment_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-spm/normalize.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-spm/normalize_12.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-spm/normalize_12_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-spm/normalize_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-spm/one_sample_t_test_design.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-spm/one_sample_t_test_design_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-spm/paired_t_test_design.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-spm/paired_t_test_design_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-spm/realign.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-spm/realign_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-spm/realign_unwarp.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-spm/realign_unwarp_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-spm/reslice.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-spm/reslice_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-spm/reslice_to_reference.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-spm/reslice_to_reference_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-spm/segment.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-spm/segment_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-spm/slice_timing.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-spm/slice_timing_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-spm/smooth.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-spm/smooth_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-spm/threshold.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-spm/threshold_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-spm/threshold_statistics.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-spm/threshold_statistics_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-spm/two_sample_t_test_design.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-spm/two_sample_t_test_design_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-spm/vbm_segment.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-spm/vbm_segment_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-vista/vnifti_2_image.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-vista/vnifti_2_image_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-vista/vto_mat.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-vista/vto_mat_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-workbench/cifti_smooth.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-workbench/cifti_smooth_callables.py
 delete mode 100644 example-specs/task/nipype_internal/pydra-workbench/metric_resample.yaml
 delete mode 100644 example-specs/task/nipype_internal/pydra-workbench/metric_resample_callables.py
 create mode 100644 scripts/pkg_gen/afni-qwarp-only.yaml
 create mode 100644 scripts/pkg_gen/example-packages.yaml

diff --git a/conftest.py b/conftest.py
index dea8fdd5..9ec78aba 100644
--- a/conftest.py
+++ b/conftest.py
@@ -8,7 +8,7 @@
 
 PKG_DIR = Path(__file__).parent
 EXAMPLE_SPECS_DIR = PKG_DIR / "example-specs"
-EXAMPLE_TASKS_DIR = EXAMPLE_SPECS_DIR / "task"
+EXAMPLE_TASKS_DIR = EXAMPLE_SPECS_DIR / "task" / "nipype"
 EXAMPLE_WORKFLOWS_DIR = EXAMPLE_SPECS_DIR / "workflow"
 
 
@@ -17,16 +17,6 @@ def gen_test_conftest():
     return PKG_DIR / "scripts" / "pkg_gen" / "resources" / "conftest.py"
 
 
-@pytest.fixture(
-    params=[
-        str(p.relative_to(EXAMPLE_TASKS_DIR)).replace("/", "__")[:-5]
-        for p in (EXAMPLE_TASKS_DIR).glob("**/*.yaml")
-    ]
-)
-def task_spec_file(request):
-    return EXAMPLE_TASKS_DIR.joinpath(*request.param.split("__")).with_suffix(".yaml")
-
-
 @pytest.fixture(params=[str(p.stem) for p in EXAMPLE_WORKFLOWS_DIR.glob("*.yaml")])
 def workflow_spec_file(request):
     return (EXAMPLE_WORKFLOWS_DIR / request.param).with_suffix(".yaml")
diff --git a/example-specs/task/nipype_internal/pydra-afni/a_boverlap.yaml b/example-specs/task/nipype/afni/a_boverlap.yaml
similarity index 97%
rename from example-specs/task/nipype_internal/pydra-afni/a_boverlap.yaml
rename to example-specs/task/nipype/afni/a_boverlap.yaml
index 03a86944..0d452646 100644
--- a/example-specs/task/nipype_internal/pydra-afni/a_boverlap.yaml
+++ b/example-specs/task/nipype/afni/a_boverlap.yaml
@@ -41,9 +41,6 @@ inputs:
     # type=file|default=<undefined>: input file A
     in_file_b: medimage/nifti1
     # type=file|default=<undefined>: input file B
-    out_file: text/text-file
-    # type=file: output file
-    # type=file|default=<undefined>: collect output to a file
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -114,7 +111,7 @@ tests:
     # type=file|default=<undefined>: input file A
     in_file_b:
     # type=file|default=<undefined>: input file B
-    out_file:
+    out_file: ' "out.mask_ae_overlap.txt"'
     # type=file: output file
     # type=file|default=<undefined>: collect output to a file
   imports:
@@ -143,7 +140,7 @@ doctests:
     # type=file|default=<undefined>: input file A
     in_file_b:
     # type=file|default=<undefined>: input file B
-    out_file:
+    out_file: ' "out.mask_ae_overlap.txt"'
     # type=file: output file
     # type=file|default=<undefined>: collect output to a file
   imports:
diff --git a/example-specs/task/nipype_internal/pydra-afni/a_boverlap_callables.py b/example-specs/task/nipype/afni/a_boverlap_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/a_boverlap_callables.py
rename to example-specs/task/nipype/afni/a_boverlap_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-afni/afn_ito_nifti.yaml b/example-specs/task/nipype/afni/afn_ito_nifti.yaml
similarity index 97%
rename from example-specs/task/nipype_internal/pydra-afni/afn_ito_nifti.yaml
rename to example-specs/task/nipype/afni/afn_ito_nifti.yaml
index 527707b8..88cab46c 100644
--- a/example-specs/task/nipype_internal/pydra-afni/afn_ito_nifti.yaml
+++ b/example-specs/task/nipype/afni/afn_ito_nifti.yaml
@@ -38,9 +38,6 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage-afni/threed
     # type=file|default=<undefined>: input file to 3dAFNItoNIFTI
-    out_file: medimage/nifti1
-    # type=file: output file
-    # type=file|default=<undefined>: output image file name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -109,7 +106,7 @@ tests:
   # (if not specified, will try to choose a sensible value)
     in_file:
     # type=file|default=<undefined>: input file to 3dAFNItoNIFTI
-    out_file:
+    out_file: ' "afni_output.nii"'
     # type=file: output file
     # type=file|default=<undefined>: output image file name
   imports:
@@ -136,7 +133,7 @@ doctests:
   # '.mock()' method of the corresponding class is used instead.
     in_file:
     # type=file|default=<undefined>: input file to 3dAFNItoNIFTI
-    out_file:
+    out_file: ' "afni_output.nii"'
     # type=file: output file
     # type=file|default=<undefined>: output image file name
   imports:
diff --git a/example-specs/task/nipype_internal/pydra-afni/afn_ito_nifti_callables.py b/example-specs/task/nipype/afni/afn_ito_nifti_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/afn_ito_nifti_callables.py
rename to example-specs/task/nipype/afni/afn_ito_nifti_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-afni/align_epi_anat_py.yaml b/example-specs/task/nipype/afni/align_epi_anat_py.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/align_epi_anat_py.yaml
rename to example-specs/task/nipype/afni/align_epi_anat_py.yaml
diff --git a/example-specs/task/nipype_internal/pydra-afni/align_epi_anat_py_callables.py b/example-specs/task/nipype/afni/align_epi_anat_py_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/align_epi_anat_py_callables.py
rename to example-specs/task/nipype/afni/align_epi_anat_py_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-afni/allineate.yaml b/example-specs/task/nipype/afni/allineate.yaml
similarity index 97%
rename from example-specs/task/nipype_internal/pydra-afni/allineate.yaml
rename to example-specs/task/nipype/afni/allineate.yaml
index 0f25b762..32481b8c 100644
--- a/example-specs/task/nipype_internal/pydra-afni/allineate.yaml
+++ b/example-specs/task/nipype/afni/allineate.yaml
@@ -55,17 +55,8 @@ inputs:
     # type=file|default=<undefined>: input file to 3dAllineate
     reference: medimage/nifti1
     # type=file|default=<undefined>: file to be used as reference, the first volume will be used if not given the reference will be the first volume of in_file.
-    out_file: medimage/nifti1
-    # type=file: output image file name
-    # type=file|default=<undefined>: output file from 3dAllineate
-    out_param_file: generic/file
-    # type=file: warp parameters
-    # type=file|default=<undefined>: Save the warp parameters in ASCII (.1D) format.
     in_param_file: generic/file
     # type=file|default=<undefined>: Read warp parameters from file and apply them to the source dataset, and produce a new dataset
-    out_matrix: generic/file
-    # type=file: matrix to align input file
-    # type=file|default=<undefined>: Save the transformation matrix for each volume.
     in_matrix: datascience/text-matrix
     # type=file|default=<undefined>: matrix to align input file
     allcostx: text/text-file
@@ -73,9 +64,6 @@ inputs:
     # type=file|default=<undefined>: Compute and print ALL available cost functionals for the un-warped inputsAND THEN QUIT. If you use this option none of the other expected outputs will be produced
     weight_file: generic/file
     # type=file|default=<undefined>: Set the weighting for each voxel in the base dataset; larger weights mean that voxel count more in the cost function. Must be defined on the same grid as the base dataset
-    out_weight_file: generic/file
-    # type=file: weight volume
-    # type=file|default=<undefined>: Write the weight volume to disk as a dataset
     source_mask: generic/file
     # type=file|default=<undefined>: mask the input dataset
     master: generic/file
@@ -96,12 +84,12 @@ outputs:
     out_file: medimage/nifti1
     # type=file: output image file name
     # type=file|default=<undefined>: output file from 3dAllineate
-    out_matrix: generic/file
-    # type=file: matrix to align input file
-    # type=file|default=<undefined>: Save the transformation matrix for each volume.
     out_param_file: generic/file
     # type=file: warp parameters
     # type=file|default=<undefined>: Save the warp parameters in ASCII (.1D) format.
+    out_matrix: generic/file
+    # type=file: matrix to align input file
+    # type=file|default=<undefined>: Save the transformation matrix for each volume.
     out_weight_file: generic/file
     # type=file: weight volume
     # type=file|default=<undefined>: Write the weight volume to disk as a dataset
@@ -252,7 +240,7 @@ tests:
   # (if not specified, will try to choose a sensible value)
     in_file:
     # type=file|default=<undefined>: input file to 3dAllineate
-    out_file:
+    out_file: '"functional_allineate.nii"'
     # type=file: output image file name
     # type=file|default=<undefined>: output file from 3dAllineate
     in_matrix:
@@ -330,7 +318,7 @@ doctests:
   # '.mock()' method of the corresponding class is used instead.
     in_file:
     # type=file|default=<undefined>: input file to 3dAllineate
-    out_file:
+    out_file: '"functional_allineate.nii"'
     # type=file: output image file name
     # type=file|default=<undefined>: output file from 3dAllineate
     in_matrix:
diff --git a/example-specs/task/nipype_internal/pydra-afni/allineate_callables.py b/example-specs/task/nipype/afni/allineate_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/allineate_callables.py
rename to example-specs/task/nipype/afni/allineate_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-afni/auto_tcorrelate.yaml b/example-specs/task/nipype/afni/auto_tcorrelate.yaml
similarity index 98%
rename from example-specs/task/nipype_internal/pydra-afni/auto_tcorrelate.yaml
rename to example-specs/task/nipype/afni/auto_tcorrelate.yaml
index 76d7e1d6..7df9cee1 100644
--- a/example-specs/task/nipype_internal/pydra-afni/auto_tcorrelate.yaml
+++ b/example-specs/task/nipype/afni/auto_tcorrelate.yaml
@@ -45,9 +45,6 @@ inputs:
     # type=file|default=<undefined>: mask of voxels
     mask_source: generic/file
     # type=file|default=<undefined>: mask for source voxels
-    out_file: generic/file
-    # type=file: output file
-    # type=file|default=<undefined>: output image file name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype_internal/pydra-afni/auto_tcorrelate_callables.py b/example-specs/task/nipype/afni/auto_tcorrelate_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/auto_tcorrelate_callables.py
rename to example-specs/task/nipype/afni/auto_tcorrelate_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-afni/auto_tlrc.yaml b/example-specs/task/nipype/afni/auto_tlrc.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/auto_tlrc.yaml
rename to example-specs/task/nipype/afni/auto_tlrc.yaml
diff --git a/example-specs/task/nipype_internal/pydra-afni/auto_tlrc_callables.py b/example-specs/task/nipype/afni/auto_tlrc_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/auto_tlrc_callables.py
rename to example-specs/task/nipype/afni/auto_tlrc_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-afni/autobox.yaml b/example-specs/task/nipype/afni/autobox.yaml
similarity index 98%
rename from example-specs/task/nipype_internal/pydra-afni/autobox.yaml
rename to example-specs/task/nipype/afni/autobox.yaml
index 869bb440..6305bae8 100644
--- a/example-specs/task/nipype_internal/pydra-afni/autobox.yaml
+++ b/example-specs/task/nipype/afni/autobox.yaml
@@ -38,9 +38,6 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/nifti1
     # type=file|default=<undefined>: input file
-    out_file: generic/file
-    # type=file: output file
-    # type=file|default=<undefined>: 
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype_internal/pydra-afni/autobox_callables.py b/example-specs/task/nipype/afni/autobox_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/autobox_callables.py
rename to example-specs/task/nipype/afni/autobox_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-afni/automask.yaml b/example-specs/task/nipype/afni/automask.yaml
similarity index 98%
rename from example-specs/task/nipype_internal/pydra-afni/automask.yaml
rename to example-specs/task/nipype/afni/automask.yaml
index b34a7371..c04f3d8f 100644
--- a/example-specs/task/nipype_internal/pydra-afni/automask.yaml
+++ b/example-specs/task/nipype/afni/automask.yaml
@@ -38,9 +38,6 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/nifti1
     # type=file|default=<undefined>: input file to 3dAutomask
-    out_file: generic/file
-    # type=file: mask file
-    # type=file|default=<undefined>: output image file name
     brain_file: generic/file
     # type=file: brain file (skull stripped)
     # type=file|default=<undefined>: output file from 3dAutomask
diff --git a/example-specs/task/nipype_internal/pydra-afni/automask_callables.py b/example-specs/task/nipype/afni/automask_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/automask_callables.py
rename to example-specs/task/nipype/afni/automask_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-afni/axialize.yaml b/example-specs/task/nipype/afni/axialize.yaml
similarity index 97%
rename from example-specs/task/nipype_internal/pydra-afni/axialize.yaml
rename to example-specs/task/nipype/afni/axialize.yaml
index 387861b4..c9bcfcb1 100644
--- a/example-specs/task/nipype_internal/pydra-afni/axialize.yaml
+++ b/example-specs/task/nipype/afni/axialize.yaml
@@ -38,9 +38,6 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/nifti1
     # type=file|default=<undefined>: input file to 3daxialize
-    out_file: medimage/nifti1
-    # type=file: output file
-    # type=file|default=<undefined>: output image file name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -111,7 +108,7 @@ tests:
   # (if not specified, will try to choose a sensible value)
     in_file:
     # type=file|default=<undefined>: input file to 3daxialize
-    out_file:
+    out_file: '"axialized.nii"'
     # type=file: output file
     # type=file|default=<undefined>: output image file name
   imports:
@@ -138,7 +135,7 @@ doctests:
   # '.mock()' method of the corresponding class is used instead.
     in_file:
     # type=file|default=<undefined>: input file to 3daxialize
-    out_file:
+    out_file: '"axialized.nii"'
     # type=file: output file
     # type=file|default=<undefined>: output image file name
   imports:
diff --git a/example-specs/task/nipype_internal/pydra-afni/axialize_callables.py b/example-specs/task/nipype/afni/axialize_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/axialize_callables.py
rename to example-specs/task/nipype/afni/axialize_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-afni/bandpass.yaml b/example-specs/task/nipype/afni/bandpass.yaml
similarity index 98%
rename from example-specs/task/nipype_internal/pydra-afni/bandpass.yaml
rename to example-specs/task/nipype/afni/bandpass.yaml
index 9929fabf..292e3dfd 100644
--- a/example-specs/task/nipype_internal/pydra-afni/bandpass.yaml
+++ b/example-specs/task/nipype/afni/bandpass.yaml
@@ -40,9 +40,6 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/nifti1
     # type=file|default=<undefined>: input file to 3dBandpass
-    out_file: generic/file
-    # type=file: output file
-    # type=file|default=<undefined>: output file from 3dBandpass
     mask: generic/file
     # type=file|default=<undefined>: mask file
     orthogonalize_file: generic/file+list-of
diff --git a/example-specs/task/nipype_internal/pydra-afni/bandpass_callables.py b/example-specs/task/nipype/afni/bandpass_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/bandpass_callables.py
rename to example-specs/task/nipype/afni/bandpass_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-afni/blur_in_mask.yaml b/example-specs/task/nipype/afni/blur_in_mask.yaml
similarity index 98%
rename from example-specs/task/nipype_internal/pydra-afni/blur_in_mask.yaml
rename to example-specs/task/nipype/afni/blur_in_mask.yaml
index ce948125..a693311e 100644
--- a/example-specs/task/nipype_internal/pydra-afni/blur_in_mask.yaml
+++ b/example-specs/task/nipype/afni/blur_in_mask.yaml
@@ -38,9 +38,6 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/nifti1
     # type=file|default=<undefined>: input file to 3dSkullStrip
-    out_file: generic/file
-    # type=file: output file
-    # type=file|default=<undefined>: output to the file
     mask: medimage/nifti1
     # type=file|default=<undefined>: Mask dataset, if desired.  Blurring will occur only within the mask. Voxels NOT in the mask will be set to zero in the output.
     multimask: generic/file
diff --git a/example-specs/task/nipype_internal/pydra-afni/blur_in_mask_callables.py b/example-specs/task/nipype/afni/blur_in_mask_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/blur_in_mask_callables.py
rename to example-specs/task/nipype/afni/blur_in_mask_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-afni/blur_to_fwhm.yaml b/example-specs/task/nipype/afni/blur_to_fwhm.yaml
similarity index 98%
rename from example-specs/task/nipype_internal/pydra-afni/blur_to_fwhm.yaml
rename to example-specs/task/nipype/afni/blur_to_fwhm.yaml
index db53cecd..245ed880 100644
--- a/example-specs/task/nipype_internal/pydra-afni/blur_to_fwhm.yaml
+++ b/example-specs/task/nipype/afni/blur_to_fwhm.yaml
@@ -42,9 +42,6 @@ inputs:
     # type=file|default=<undefined>: The dataset whose smoothness controls the process.
     mask: generic/file
     # type=file|default=<undefined>: Mask dataset, if desired. Voxels NOT in mask will be set to zero in output.
-    out_file: generic/file
-    # type=file: output file
-    # type=file|default=<undefined>: output image file name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype_internal/pydra-afni/blur_to_fwhm_callables.py b/example-specs/task/nipype/afni/blur_to_fwhm_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/blur_to_fwhm_callables.py
rename to example-specs/task/nipype/afni/blur_to_fwhm_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-afni/brick_stat.yaml b/example-specs/task/nipype/afni/brick_stat.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/brick_stat.yaml
rename to example-specs/task/nipype/afni/brick_stat.yaml
diff --git a/example-specs/task/nipype_internal/pydra-afni/brick_stat_callables.py b/example-specs/task/nipype/afni/brick_stat_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/brick_stat_callables.py
rename to example-specs/task/nipype/afni/brick_stat_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-afni/bucket.yaml b/example-specs/task/nipype/afni/bucket.yaml
similarity index 99%
rename from example-specs/task/nipype_internal/pydra-afni/bucket.yaml
rename to example-specs/task/nipype/afni/bucket.yaml
index 3a516360..16b1a973 100644
--- a/example-specs/task/nipype_internal/pydra-afni/bucket.yaml
+++ b/example-specs/task/nipype/afni/bucket.yaml
@@ -46,9 +46,6 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    out_file: generic/file
-    # type=file: output file
-    # type=file|default=<undefined>: 
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -109,7 +106,7 @@ tests:
   # (if not specified, will try to choose a sensible value)
     in_file: '[(''functional.nii'',"{2..$}"), (''functional.nii'',"{1}")]'
     # type=list|default=[]: List of tuples of input datasets and subbrick selection strings as described in more detail in the following afni help string Input dataset specified using one of these forms: ``prefix+view``, ``prefix+view.HEAD``, or ``prefix+view.BRIK``. You can also add a sub-brick selection list after the end of the dataset name.  This allows only a subset of the sub-bricks to be included into the output (by default, all of the input dataset is copied into the output).  A sub-brick selection list looks like one of the following forms::      fred+orig[5]                     ==> use only sub-brick #5     fred+orig[5,9,17]                ==> use #5, #9, and #17     fred+orig[5..8]     or [5-8]     ==> use #5, #6, #7, and #8     fred+orig[5..13(2)] or [5-13(2)] ==> use #5, #7, #9, #11, and #13  Sub-brick indexes start at 0.  You can use the character '$' to indicate the last sub-brick in a dataset; for example, you can select every third sub-brick by using the selection list ``fred+orig[0..$(3)]`` N.B.: The sub-bricks are output in the order specified, which may not be the order in the original datasets.  For example, using ``fred+orig[0..$(2),1..$(2)]`` will cause the sub-bricks in fred+orig to be output into the new dataset in an interleaved fashion. Using ``fred+orig[$..0]`` will reverse the order of the sub-bricks in the output. N.B.: Bucket datasets have multiple sub-bricks, but do NOT have a time dimension.  You can input sub-bricks from a 3D+time dataset into a bucket dataset.  You can use the '3dinfo' program to see how many sub-bricks a 3D+time or a bucket dataset contains. N.B.: In non-bucket functional datasets (like the 'fico' datasets output by FIM, or the 'fitt' datasets output by 3dttest), sub-brick ``[0]`` is the 'intensity' and sub-brick [1] is the statistical parameter used as a threshold.  Thus, to create a bucket dataset using the intensity from dataset A and the threshold from dataset B, and calling the output dataset C, you would type::      3dbucket -prefix C -fbuc 'A+orig[0]' -fbuc 'B+orig[1]  
-    out_file:
+    out_file: '"vr_base"'
     # type=file: output file
     # type=file|default=<undefined>: 
   imports:
@@ -136,7 +133,7 @@ doctests:
   # '.mock()' method of the corresponding class is used instead.
     in_file: '[(''functional.nii'',"{2..$}"), (''functional.nii'',"{1}")]'
     # type=list|default=[]: List of tuples of input datasets and subbrick selection strings as described in more detail in the following afni help string Input dataset specified using one of these forms: ``prefix+view``, ``prefix+view.HEAD``, or ``prefix+view.BRIK``. You can also add a sub-brick selection list after the end of the dataset name.  This allows only a subset of the sub-bricks to be included into the output (by default, all of the input dataset is copied into the output).  A sub-brick selection list looks like one of the following forms::      fred+orig[5]                     ==> use only sub-brick #5     fred+orig[5,9,17]                ==> use #5, #9, and #17     fred+orig[5..8]     or [5-8]     ==> use #5, #6, #7, and #8     fred+orig[5..13(2)] or [5-13(2)] ==> use #5, #7, #9, #11, and #13  Sub-brick indexes start at 0.  You can use the character '$' to indicate the last sub-brick in a dataset; for example, you can select every third sub-brick by using the selection list ``fred+orig[0..$(3)]`` N.B.: The sub-bricks are output in the order specified, which may not be the order in the original datasets.  For example, using ``fred+orig[0..$(2),1..$(2)]`` will cause the sub-bricks in fred+orig to be output into the new dataset in an interleaved fashion. Using ``fred+orig[$..0]`` will reverse the order of the sub-bricks in the output. N.B.: Bucket datasets have multiple sub-bricks, but do NOT have a time dimension.  You can input sub-bricks from a 3D+time dataset into a bucket dataset.  You can use the '3dinfo' program to see how many sub-bricks a 3D+time or a bucket dataset contains. N.B.: In non-bucket functional datasets (like the 'fico' datasets output by FIM, or the 'fitt' datasets output by 3dttest), sub-brick ``[0]`` is the 'intensity' and sub-brick [1] is the statistical parameter used as a threshold.  Thus, to create a bucket dataset using the intensity from dataset A and the threshold from dataset B, and calling the output dataset C, you would type::      3dbucket -prefix C -fbuc 'A+orig[0]' -fbuc 'B+orig[1]  
-    out_file:
+    out_file: '"vr_base"'
     # type=file: output file
     # type=file|default=<undefined>: 
   imports:
diff --git a/example-specs/task/nipype_internal/pydra-afni/bucket_callables.py b/example-specs/task/nipype/afni/bucket_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/bucket_callables.py
rename to example-specs/task/nipype/afni/bucket_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-afni/calc.yaml b/example-specs/task/nipype/afni/calc.yaml
similarity index 98%
rename from example-specs/task/nipype_internal/pydra-afni/calc.yaml
rename to example-specs/task/nipype/afni/calc.yaml
index c8593533..c861891b 100644
--- a/example-specs/task/nipype_internal/pydra-afni/calc.yaml
+++ b/example-specs/task/nipype/afni/calc.yaml
@@ -54,9 +54,6 @@ inputs:
     # type=file|default=<undefined>: operand file to 3dcalc
     in_file_c: generic/file
     # type=file|default=<undefined>: operand file to 3dcalc
-    out_file: medimage-afni/all1,medimage/nifti-gz
-    # type=file: output file
-    # type=file|default=<undefined>: output image file name
     other: generic/file
     # type=file|default=<undefined>: other options
   metadata:
@@ -139,7 +136,7 @@ tests:
     # type=file|default=<undefined>: operand file to 3dcalc
     expr: '"a*b"'
     # type=str|default='': expr
-    out_file:
+    out_file: ' "functional_calc.nii.gz"'
     # type=file: output file
     # type=file|default=<undefined>: output image file name
     outputtype: '"NIFTI"'
@@ -166,7 +163,7 @@ tests:
     # type=file|default=<undefined>: input file to 3dcalc
     expr: '"1"'
     # type=str|default='': expr
-    out_file:
+    out_file: '"rm.epi.all1"'
     # type=file: output file
     # type=file|default=<undefined>: output image file name
     overwrite: 'True'
@@ -199,7 +196,7 @@ doctests:
     # type=file|default=<undefined>: operand file to 3dcalc
     expr: '"a*b"'
     # type=str|default='': expr
-    out_file:
+    out_file: ' "functional_calc.nii.gz"'
     # type=file: output file
     # type=file|default=<undefined>: output image file name
     outputtype: '"NIFTI"'
@@ -219,7 +216,7 @@ doctests:
     # type=file|default=<undefined>: input file to 3dcalc
     expr: '"1"'
     # type=str|default='': expr
-    out_file:
+    out_file: '"rm.epi.all1"'
     # type=file: output file
     # type=file|default=<undefined>: output image file name
     overwrite: 'True'
diff --git a/example-specs/task/nipype_internal/pydra-afni/calc_callables.py b/example-specs/task/nipype/afni/calc_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/calc_callables.py
rename to example-specs/task/nipype/afni/calc_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-afni/cat.yaml b/example-specs/task/nipype/afni/cat.yaml
similarity index 97%
rename from example-specs/task/nipype_internal/pydra-afni/cat.yaml
rename to example-specs/task/nipype/afni/cat.yaml
index ca8da574..66237964 100644
--- a/example-specs/task/nipype_internal/pydra-afni/cat.yaml
+++ b/example-specs/task/nipype/afni/cat.yaml
@@ -40,9 +40,6 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_files: medimage-afni/oned+list-of
     # type=list|default=[]: 
-    out_file: medimage-afni/oned
-    # type=file: output file
-    # type=file|default='catout.1d': output (concatenated) file name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -125,7 +122,7 @@ tests:
     # type=str|default='': Apply the same column/row selection string to all filenames on the command line.
     in_files:
     # type=list|default=[]: 
-    out_file:
+    out_file: '"catout.1d"'
     # type=file: output file
     # type=file|default='catout.1d': output (concatenated) file name
   imports:
@@ -154,7 +151,7 @@ doctests:
     # type=str|default='': Apply the same column/row selection string to all filenames on the command line.
     in_files:
     # type=list|default=[]: 
-    out_file:
+    out_file: '"catout.1d"'
     # type=file: output file
     # type=file|default='catout.1d': output (concatenated) file name
   imports:
diff --git a/example-specs/task/nipype_internal/pydra-afni/cat_callables.py b/example-specs/task/nipype/afni/cat_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/cat_callables.py
rename to example-specs/task/nipype/afni/cat_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-afni/cat_matvec.yaml b/example-specs/task/nipype/afni/cat_matvec.yaml
similarity index 97%
rename from example-specs/task/nipype_internal/pydra-afni/cat_matvec.yaml
rename to example-specs/task/nipype/afni/cat_matvec.yaml
index 6bba9947..95d6c31b 100644
--- a/example-specs/task/nipype_internal/pydra-afni/cat_matvec.yaml
+++ b/example-specs/task/nipype/afni/cat_matvec.yaml
@@ -35,9 +35,6 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    out_file: medimage-afni/oned
-    # type=file: output file
-    # type=file|default=<undefined>: File to write concattenated matvecs to
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -104,7 +101,7 @@ tests:
   # (if not specified, will try to choose a sensible value)
     in_file: '[("structural.BRIK::WARP_DATA","I")]'
     # type=list|default=[]: list of tuples of mfiles and associated opkeys
-    out_file:
+    out_file: '"warp.anat.Xat.1D"'
     # type=file: output file
     # type=file|default=<undefined>: File to write concattenated matvecs to
   imports:
@@ -131,7 +128,7 @@ doctests:
   # '.mock()' method of the corresponding class is used instead.
     in_file: '[("structural.BRIK::WARP_DATA","I")]'
     # type=list|default=[]: list of tuples of mfiles and associated opkeys
-    out_file:
+    out_file: '"warp.anat.Xat.1D"'
     # type=file: output file
     # type=file|default=<undefined>: File to write concattenated matvecs to
   imports:
diff --git a/example-specs/task/nipype_internal/pydra-afni/cat_matvec_callables.py b/example-specs/task/nipype/afni/cat_matvec_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/cat_matvec_callables.py
rename to example-specs/task/nipype/afni/cat_matvec_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-afni/center_mass.yaml b/example-specs/task/nipype/afni/center_mass.yaml
similarity index 98%
rename from example-specs/task/nipype_internal/pydra-afni/center_mass.yaml
rename to example-specs/task/nipype/afni/center_mass.yaml
index 5358c109..1b7f79d6 100644
--- a/example-specs/task/nipype_internal/pydra-afni/center_mass.yaml
+++ b/example-specs/task/nipype/afni/center_mass.yaml
@@ -88,7 +88,7 @@ tests:
     automask:
     # type=bool|default=False: Generate the mask automatically
     set_cm:
-    # type=tuple|default=(<traits.trait_types.Float object at 0x11cfc68d0>, <traits.trait_types.Float object at 0x11cfc69d0>, <traits.trait_types.Float object at 0x11cfc6a50>): After computing the center of mass, set the origin fields in the header so that the center of mass will be at (x,y,z) in DICOM coords.
+    # type=tuple|default=(<traits.trait_types.Float object at 0x10beb75d0>, <traits.trait_types.Float object at 0x10beb76d0>, <traits.trait_types.Float object at 0x10beb7750>): After computing the center of mass, set the origin fields in the header so that the center of mass will be at (x,y,z) in DICOM coords.
     local_ijk:
     # type=bool|default=False: Output values as (i,j,k) in local orientation
     roi_vals:
diff --git a/example-specs/task/nipype_internal/pydra-afni/center_mass_callables.py b/example-specs/task/nipype/afni/center_mass_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/center_mass_callables.py
rename to example-specs/task/nipype/afni/center_mass_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-afni/clip_level.yaml b/example-specs/task/nipype/afni/clip_level.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/clip_level.yaml
rename to example-specs/task/nipype/afni/clip_level.yaml
diff --git a/example-specs/task/nipype_internal/pydra-afni/clip_level_callables.py b/example-specs/task/nipype/afni/clip_level_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/clip_level_callables.py
rename to example-specs/task/nipype/afni/clip_level_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-afni/convert_dset.yaml b/example-specs/task/nipype/afni/convert_dset.yaml
similarity index 97%
rename from example-specs/task/nipype_internal/pydra-afni/convert_dset.yaml
rename to example-specs/task/nipype/afni/convert_dset.yaml
index e943fa02..7250ed8e 100644
--- a/example-specs/task/nipype_internal/pydra-afni/convert_dset.yaml
+++ b/example-specs/task/nipype/afni/convert_dset.yaml
@@ -38,9 +38,6 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/gifti
     # type=file|default=<undefined>: input file to ConvertDset
-    out_file: medimage-afni/dset
-    # type=file: output file
-    # type=file|default=<undefined>: output file for ConvertDset
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -105,7 +102,7 @@ tests:
     # type=file|default=<undefined>: input file to ConvertDset
     out_type: '"niml_asc"'
     # type=enum|default='niml'|allowed['1D','1Dp','1Dpt','gii','gii_asc','gii_b64','gii_b64gz','niml','niml_asc','niml_bi']: output type
-    out_file:
+    out_file: '"lh.pial_converted.niml.dset"'
     # type=file: output file
     # type=file|default=<undefined>: output file for ConvertDset
   imports:
@@ -134,7 +131,7 @@ doctests:
     # type=file|default=<undefined>: input file to ConvertDset
     out_type: '"niml_asc"'
     # type=enum|default='niml'|allowed['1D','1Dp','1Dpt','gii','gii_asc','gii_b64','gii_b64gz','niml','niml_asc','niml_bi']: output type
-    out_file:
+    out_file: '"lh.pial_converted.niml.dset"'
     # type=file: output file
     # type=file|default=<undefined>: output file for ConvertDset
   imports:
diff --git a/example-specs/task/nipype_internal/pydra-afni/convert_dset_callables.py b/example-specs/task/nipype/afni/convert_dset_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/convert_dset_callables.py
rename to example-specs/task/nipype/afni/convert_dset_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-afni/copy.yaml b/example-specs/task/nipype/afni/copy.yaml
similarity index 98%
rename from example-specs/task/nipype_internal/pydra-afni/copy.yaml
rename to example-specs/task/nipype/afni/copy.yaml
index 4ad5ff85..74b3df0f 100644
--- a/example-specs/task/nipype_internal/pydra-afni/copy.yaml
+++ b/example-specs/task/nipype/afni/copy.yaml
@@ -56,9 +56,6 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/nifti1
     # type=file|default=<undefined>: input file to 3dcopy
-    out_file: medimage/nifti1
-    # type=file: output file
-    # type=file|default=<undefined>: output image file name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -182,7 +179,7 @@ tests:
 - inputs:
   # dict[str, str] - values to provide to inputs fields in the task initialisation
   # (if not specified, will try to choose a sensible value)
-    out_file:
+    out_file: '"new_func.nii"'
     # type=file: output file
     # type=file|default=<undefined>: output image file name
   imports:
@@ -246,7 +243,7 @@ doctests:
   # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
   # If the field is of file-format type and the value is None, then the
   # '.mock()' method of the corresponding class is used instead.
-    out_file:
+    out_file: '"new_func.nii"'
     # type=file: output file
     # type=file|default=<undefined>: output image file name
   imports:
diff --git a/example-specs/task/nipype_internal/pydra-afni/copy_callables.py b/example-specs/task/nipype/afni/copy_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/copy_callables.py
rename to example-specs/task/nipype/afni/copy_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-afni/deconvolve.yaml b/example-specs/task/nipype/afni/deconvolve.yaml
similarity index 97%
rename from example-specs/task/nipype_internal/pydra-afni/deconvolve.yaml
rename to example-specs/task/nipype/afni/deconvolve.yaml
index 3128b9b7..c7413431 100644
--- a/example-specs/task/nipype_internal/pydra-afni/deconvolve.yaml
+++ b/example-specs/task/nipype/afni/deconvolve.yaml
@@ -18,7 +18,8 @@
 #     >>> deconvolve.inputs.in_files = ['functional.nii', 'functional2.nii']
 #     >>> deconvolve.inputs.out_file = 'output.nii'
 #     >>> deconvolve.inputs.x1D = 'output.1D'
-#     >>> deconvolve.inputs.stim_times = [(1, 'timeseries.txt', 'SPMG1(4)')]
+#     >>> stim_times = [(1, 'timeseries.txt', 'SPMG1(4)')]
+#     >>> deconvolve.inputs.stim_times = stim_times
 #     >>> deconvolve.inputs.stim_label = [(1, 'Houses')]
 #     >>> deconvolve.inputs.gltsym = ['SYM: +Houses']
 #     >>> deconvolve.inputs.glt_label = [(1, 'Houses')]
@@ -53,9 +54,6 @@ inputs:
     x1D: medimage-afni/oned
     # type=file: save out X matrix
     # type=file|default=<undefined>: specify name for saved X matrix
-    out_file: medimage/nifti1
-    # type=file: output statistics file
-    # type=file|default=<undefined>: output statistics file
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -208,13 +206,13 @@ tests:
   # (if not specified, will try to choose a sensible value)
     in_files:
     # type=inputmultiobject|default=[]: filenames of 3D+time input datasets. More than one filename can be given and the datasets will be auto-catenated in time. You can input a 1D time series file here, but the time axis should run along the ROW direction, not the COLUMN direction as in the 'input1D' option.
-    out_file:
+    out_file: '"output.nii"'
     # type=file: output statistics file
     # type=file|default=<undefined>: output statistics file
     x1D:
     # type=file: save out X matrix
     # type=file|default=<undefined>: specify name for saved X matrix
-    stim_times: '[(1, "timeseries.txt", "SPMG1(4)")]'
+    stim_times: stim_times
     # type=list|default=[]: generate a response model from a set of stimulus times given in file.
     stim_label: '[(1, "Houses")]'
     # type=list|default=[]: label for kth input stimulus (e.g., Label1)
@@ -246,13 +244,13 @@ doctests:
   # '.mock()' method of the corresponding class is used instead.
     in_files:
     # type=inputmultiobject|default=[]: filenames of 3D+time input datasets. More than one filename can be given and the datasets will be auto-catenated in time. You can input a 1D time series file here, but the time axis should run along the ROW direction, not the COLUMN direction as in the 'input1D' option.
-    out_file:
+    out_file: '"output.nii"'
     # type=file: output statistics file
     # type=file|default=<undefined>: output statistics file
     x1D:
     # type=file: save out X matrix
     # type=file|default=<undefined>: specify name for saved X matrix
-    stim_times: '[(1, "timeseries.txt", "SPMG1(4)")]'
+    stim_times: stim_times
     # type=list|default=[]: generate a response model from a set of stimulus times given in file.
     stim_label: '[(1, "Houses")]'
     # type=list|default=[]: label for kth input stimulus (e.g., Label1)
diff --git a/example-specs/task/nipype_internal/pydra-afni/deconvolve_callables.py b/example-specs/task/nipype/afni/deconvolve_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/deconvolve_callables.py
rename to example-specs/task/nipype/afni/deconvolve_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-afni/degree_centrality.yaml b/example-specs/task/nipype/afni/degree_centrality.yaml
similarity index 98%
rename from example-specs/task/nipype_internal/pydra-afni/degree_centrality.yaml
rename to example-specs/task/nipype/afni/degree_centrality.yaml
index ce9098ef..d44ebefa 100644
--- a/example-specs/task/nipype_internal/pydra-afni/degree_centrality.yaml
+++ b/example-specs/task/nipype/afni/degree_centrality.yaml
@@ -42,9 +42,6 @@ inputs:
     # type=file|default=<undefined>: input file to 3dDegreeCentrality
     mask: medimage/nifti1
     # type=file|default=<undefined>: mask file to mask input data
-    out_file: medimage/nifti1
-    # type=file: output file
-    # type=file|default=<undefined>: output image file name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -58,12 +55,12 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    oned_file: generic/file
-    # type=file: The text output of the similarity matrix computed after thresholding with one-dimensional and ijk voxel indices, correlations, image extents, and affine matrix.
-    # type=str|default='': output filepath to text dump of correlation matrix
     out_file: medimage/nifti1
     # type=file: output file
     # type=file|default=<undefined>: output image file name
+    oned_file: generic/file
+    # type=file: The text output of the similarity matrix computed after thresholding with one-dimensional and ijk voxel indices, correlations, image extents, and affine matrix.
+    # type=str|default='': output filepath to text dump of correlation matrix
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
@@ -127,7 +124,7 @@ tests:
     # type=file|default=<undefined>: mask file to mask input data
     sparsity: '1 # keep the top one percent of connections'
     # type=float|default=0.0: only take the top percent of connections
-    out_file:
+    out_file: '"out.nii"'
     # type=file: output file
     # type=file|default=<undefined>: output image file name
   imports:
@@ -158,7 +155,7 @@ doctests:
     # type=file|default=<undefined>: mask file to mask input data
     sparsity: '1 # keep the top one percent of connections'
     # type=float|default=0.0: only take the top percent of connections
-    out_file:
+    out_file: '"out.nii"'
     # type=file: output file
     # type=file|default=<undefined>: output image file name
   imports:
diff --git a/example-specs/task/nipype_internal/pydra-afni/degree_centrality_callables.py b/example-specs/task/nipype/afni/degree_centrality_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/degree_centrality_callables.py
rename to example-specs/task/nipype/afni/degree_centrality_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-afni/despike.yaml b/example-specs/task/nipype/afni/despike.yaml
similarity index 98%
rename from example-specs/task/nipype_internal/pydra-afni/despike.yaml
rename to example-specs/task/nipype/afni/despike.yaml
index 35b7a555..5fdb3449 100644
--- a/example-specs/task/nipype_internal/pydra-afni/despike.yaml
+++ b/example-specs/task/nipype/afni/despike.yaml
@@ -36,9 +36,6 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/nifti1
     # type=file|default=<undefined>: input file to 3dDespike
-    out_file: generic/file
-    # type=file: output file
-    # type=file|default=<undefined>: output image file name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype_internal/pydra-afni/despike_callables.py b/example-specs/task/nipype/afni/despike_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/despike_callables.py
rename to example-specs/task/nipype/afni/despike_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-afni/detrend.yaml b/example-specs/task/nipype/afni/detrend.yaml
similarity index 98%
rename from example-specs/task/nipype_internal/pydra-afni/detrend.yaml
rename to example-specs/task/nipype/afni/detrend.yaml
index 659dab4d..24c2dfb9 100644
--- a/example-specs/task/nipype_internal/pydra-afni/detrend.yaml
+++ b/example-specs/task/nipype/afni/detrend.yaml
@@ -39,9 +39,6 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/nifti1
     # type=file|default=<undefined>: input file to 3dDetrend
-    out_file: generic/file
-    # type=file: output file
-    # type=file|default=<undefined>: output image file name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype_internal/pydra-afni/detrend_callables.py b/example-specs/task/nipype/afni/detrend_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/detrend_callables.py
rename to example-specs/task/nipype/afni/detrend_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-afni/dot.yaml b/example-specs/task/nipype/afni/dot.yaml
similarity index 97%
rename from example-specs/task/nipype_internal/pydra-afni/dot.yaml
rename to example-specs/task/nipype/afni/dot.yaml
index 080455bf..29087507 100644
--- a/example-specs/task/nipype_internal/pydra-afni/dot.yaml
+++ b/example-specs/task/nipype/afni/dot.yaml
@@ -40,11 +40,8 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    in_files: medimage/nifti+list-of
+    in_files: generic/file+list-of
     # type=list|default=[]: list of input files, possibly with subbrick selectors
-    out_file: text/text-file
-    # type=file: output file
-    # type=file|default=<undefined>: collect output to a file
     mask: generic/file
     # type=file|default=<undefined>: Use this dataset as a mask
   metadata:
@@ -82,7 +79,7 @@ tests:
     mask:
     # type=file|default=<undefined>: Use this dataset as a mask
     mrange:
-    # type=tuple|default=(<traits.trait_types.Float object at 0x11cfd1250>, <traits.trait_types.Float object at 0x11cfd1150>): Means to further restrict the voxels from 'mset' so thatonly those mask values within this range (inclusive) willbe used.
+    # type=tuple|default=(<traits.trait_types.Float object at 0x10bec5dd0>, <traits.trait_types.Float object at 0x10bec5cd0>): Means to further restrict the voxels from 'mset' so thatonly those mask values within this range (inclusive) willbe used.
     demean:
     # type=bool|default=False: Remove the mean from each volume prior to computing the correlation
     docor:
@@ -133,7 +130,7 @@ tests:
     # type=list|default=[]: list of input files, possibly with subbrick selectors
     dodice: 'True'
     # type=bool|default=False: Return the Dice coefficient (the Sorensen-Dice index).
-    out_file:
+    out_file: '"out.mask_ae_dice.txt"'
     # type=file: output file
     # type=file|default=<undefined>: collect output to a file
   imports:
@@ -162,7 +159,7 @@ doctests:
     # type=list|default=[]: list of input files, possibly with subbrick selectors
     dodice: 'True'
     # type=bool|default=False: Return the Dice coefficient (the Sorensen-Dice index).
-    out_file:
+    out_file: '"out.mask_ae_dice.txt"'
     # type=file: output file
     # type=file|default=<undefined>: collect output to a file
   imports:
diff --git a/example-specs/task/nipype_internal/pydra-afni/dot_callables.py b/example-specs/task/nipype/afni/dot_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/dot_callables.py
rename to example-specs/task/nipype/afni/dot_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-afni/ecm.yaml b/example-specs/task/nipype/afni/ecm.yaml
similarity index 98%
rename from example-specs/task/nipype_internal/pydra-afni/ecm.yaml
rename to example-specs/task/nipype/afni/ecm.yaml
index abbb056a..02bbf953 100644
--- a/example-specs/task/nipype_internal/pydra-afni/ecm.yaml
+++ b/example-specs/task/nipype/afni/ecm.yaml
@@ -42,9 +42,6 @@ inputs:
     # type=file|default=<undefined>: input file to 3dECM
     mask: medimage/nifti1
     # type=file|default=<undefined>: mask file to mask input data
-    out_file: medimage/nifti1
-    # type=file: output file
-    # type=file|default=<undefined>: output image file name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -135,7 +132,7 @@ tests:
     # type=file|default=<undefined>: mask file to mask input data
     sparsity: '0.1 # keep top 0.1% of connections'
     # type=float|default=0.0: only take the top percent of connections
-    out_file:
+    out_file: '"out.nii"'
     # type=file: output file
     # type=file|default=<undefined>: output image file name
   imports:
@@ -166,7 +163,7 @@ doctests:
     # type=file|default=<undefined>: mask file to mask input data
     sparsity: '0.1 # keep top 0.1% of connections'
     # type=float|default=0.0: only take the top percent of connections
-    out_file:
+    out_file: '"out.nii"'
     # type=file: output file
     # type=file|default=<undefined>: output image file name
   imports:
diff --git a/example-specs/task/nipype_internal/pydra-afni/ecm_callables.py b/example-specs/task/nipype/afni/ecm_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/ecm_callables.py
rename to example-specs/task/nipype/afni/ecm_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-afni/edge_3.yaml b/example-specs/task/nipype/afni/edge_3.yaml
similarity index 98%
rename from example-specs/task/nipype_internal/pydra-afni/edge_3.yaml
rename to example-specs/task/nipype/afni/edge_3.yaml
index 4f595ea9..8b907650 100644
--- a/example-specs/task/nipype_internal/pydra-afni/edge_3.yaml
+++ b/example-specs/task/nipype/afni/edge_3.yaml
@@ -39,9 +39,6 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/nifti1
     # type=file|default=<undefined>: input file to 3dedge3
-    out_file: medimage/nifti1
-    # type=file: output file
-    # type=file|default=<undefined>: output image file name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -114,7 +111,7 @@ tests:
   # (if not specified, will try to choose a sensible value)
     in_file:
     # type=file|default=<undefined>: input file to 3dedge3
-    out_file:
+    out_file: '"edges.nii"'
     # type=file: output file
     # type=file|default=<undefined>: output image file name
     datum: '"byte"'
@@ -143,7 +140,7 @@ doctests:
   # '.mock()' method of the corresponding class is used instead.
     in_file:
     # type=file|default=<undefined>: input file to 3dedge3
-    out_file:
+    out_file: '"edges.nii"'
     # type=file: output file
     # type=file|default=<undefined>: output image file name
     datum: '"byte"'
diff --git a/example-specs/task/nipype_internal/pydra-afni/edge_3_callables.py b/example-specs/task/nipype/afni/edge_3_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/edge_3_callables.py
rename to example-specs/task/nipype/afni/edge_3_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-afni/eval.yaml b/example-specs/task/nipype/afni/eval.yaml
similarity index 98%
rename from example-specs/task/nipype_internal/pydra-afni/eval.yaml
rename to example-specs/task/nipype/afni/eval.yaml
index 041d2776..cf9eb9ae 100644
--- a/example-specs/task/nipype_internal/pydra-afni/eval.yaml
+++ b/example-specs/task/nipype/afni/eval.yaml
@@ -45,9 +45,6 @@ inputs:
     # type=file|default=<undefined>: operand file to 1deval
     in_file_c: generic/file
     # type=file|default=<undefined>: operand file to 1deval
-    out_file: medimage-afni/oned
-    # type=file: output file
-    # type=file|default=<undefined>: output image file name
     other: generic/file
     # type=file|default=<undefined>: other options
   metadata:
@@ -132,7 +129,7 @@ tests:
     # type=str|default='': expr
     out1D: 'True'
     # type=bool|default=False: output in 1D
-    out_file:
+    out_file: ' "data_calc.1D"'
     # type=file: output file
     # type=file|default=<undefined>: output image file name
   imports:
@@ -165,7 +162,7 @@ doctests:
     # type=str|default='': expr
     out1D: 'True'
     # type=bool|default=False: output in 1D
-    out_file:
+    out_file: ' "data_calc.1D"'
     # type=file: output file
     # type=file|default=<undefined>: output image file name
   imports:
diff --git a/example-specs/task/nipype_internal/pydra-afni/eval_callables.py b/example-specs/task/nipype/afni/eval_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/eval_callables.py
rename to example-specs/task/nipype/afni/eval_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-afni/fim.yaml b/example-specs/task/nipype/afni/fim.yaml
similarity index 98%
rename from example-specs/task/nipype_internal/pydra-afni/fim.yaml
rename to example-specs/task/nipype/afni/fim.yaml
index 0a8344b0..9fa093e6 100644
--- a/example-specs/task/nipype_internal/pydra-afni/fim.yaml
+++ b/example-specs/task/nipype/afni/fim.yaml
@@ -41,9 +41,6 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/nifti1
     # type=file|default=<undefined>: input file to 3dfim+
-    out_file: medimage/nifti1
-    # type=file: output file
-    # type=file|default=<undefined>: output image file name
     ideal_file: medimage-afni/oned
     # type=file|default=<undefined>: ideal time series file name
   metadata:
@@ -114,7 +111,7 @@ tests:
     # type=file|default=<undefined>: input file to 3dfim+
     ideal_file:
     # type=file|default=<undefined>: ideal time series file name
-    out_file:
+    out_file: '"functional_corr.nii"'
     # type=file: output file
     # type=file|default=<undefined>: output image file name
     out: '"Correlation"'
@@ -147,7 +144,7 @@ doctests:
     # type=file|default=<undefined>: input file to 3dfim+
     ideal_file:
     # type=file|default=<undefined>: ideal time series file name
-    out_file:
+    out_file: '"functional_corr.nii"'
     # type=file: output file
     # type=file|default=<undefined>: output image file name
     out: '"Correlation"'
diff --git a/example-specs/task/nipype_internal/pydra-afni/fim_callables.py b/example-specs/task/nipype/afni/fim_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/fim_callables.py
rename to example-specs/task/nipype/afni/fim_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-afni/fourier.yaml b/example-specs/task/nipype/afni/fourier.yaml
similarity index 98%
rename from example-specs/task/nipype_internal/pydra-afni/fourier.yaml
rename to example-specs/task/nipype/afni/fourier.yaml
index f59aa2a8..3e528631 100644
--- a/example-specs/task/nipype_internal/pydra-afni/fourier.yaml
+++ b/example-specs/task/nipype/afni/fourier.yaml
@@ -40,9 +40,6 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/nifti1
     # type=file|default=<undefined>: input file to 3dFourier
-    out_file: generic/file
-    # type=file: output file
-    # type=file|default=<undefined>: output image file name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype_internal/pydra-afni/fourier_callables.py b/example-specs/task/nipype/afni/fourier_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/fourier_callables.py
rename to example-specs/task/nipype/afni/fourier_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-afni/fwh_mx.yaml b/example-specs/task/nipype/afni/fwh_mx.yaml
similarity index 96%
rename from example-specs/task/nipype_internal/pydra-afni/fwh_mx.yaml
rename to example-specs/task/nipype/afni/fwh_mx.yaml
index d32bdd7f..44584676 100644
--- a/example-specs/task/nipype_internal/pydra-afni/fwh_mx.yaml
+++ b/example-specs/task/nipype/afni/fwh_mx.yaml
@@ -115,17 +115,8 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/nifti1
     # type=file|default=<undefined>: input dataset
-    out_file: generic/file
-    # type=file: output file
-    # type=file|default=<undefined>: output file
-    out_subbricks: generic/file
-    # type=file: output file (subbricks)
-    # type=file|default=<undefined>: output file listing the subbricks FWHM
     mask: generic/file
     # type=file|default=<undefined>: use only voxels that are nonzero in mask
-    out_detrend: generic/file
-    # type=file: output file, detrended
-    # type=file|default=<undefined>: Save the detrended file into a dataset
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype_internal/pydra-afni/fwh_mx_callables.py b/example-specs/task/nipype/afni/fwh_mx_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/fwh_mx_callables.py
rename to example-specs/task/nipype/afni/fwh_mx_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-afni/gcor.yaml b/example-specs/task/nipype/afni/gcor.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/gcor.yaml
rename to example-specs/task/nipype/afni/gcor.yaml
diff --git a/example-specs/task/nipype_internal/pydra-afni/gcor_callables.py b/example-specs/task/nipype/afni/gcor_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/gcor_callables.py
rename to example-specs/task/nipype/afni/gcor_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-afni/hist.yaml b/example-specs/task/nipype/afni/hist.yaml
similarity index 96%
rename from example-specs/task/nipype_internal/pydra-afni/hist.yaml
rename to example-specs/task/nipype/afni/hist.yaml
index c54fb070..f5baaf50 100644
--- a/example-specs/task/nipype_internal/pydra-afni/hist.yaml
+++ b/example-specs/task/nipype/afni/hist.yaml
@@ -37,12 +37,6 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/nifti1
     # type=file|default=<undefined>: input file to 3dHist
-    out_file: generic/file
-    # type=file: output file
-    # type=file|default=<undefined>: Write histogram to niml file with this prefix
-    out_show: generic/file
-    # type=file: output visual histogram
-    # type=file|default=<undefined>: output image file name
     mask: generic/file
     # type=file|default=<undefined>: matrix to align input file
   metadata:
diff --git a/example-specs/task/nipype_internal/pydra-afni/hist_callables.py b/example-specs/task/nipype/afni/hist_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/hist_callables.py
rename to example-specs/task/nipype/afni/hist_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-afni/lfcd.yaml b/example-specs/task/nipype/afni/lfcd.yaml
similarity index 98%
rename from example-specs/task/nipype_internal/pydra-afni/lfcd.yaml
rename to example-specs/task/nipype/afni/lfcd.yaml
index 5e3343f6..2ed095e9 100644
--- a/example-specs/task/nipype_internal/pydra-afni/lfcd.yaml
+++ b/example-specs/task/nipype/afni/lfcd.yaml
@@ -41,9 +41,6 @@ inputs:
     # type=file|default=<undefined>: input file to 3dLFCD
     mask: medimage/nifti1
     # type=file|default=<undefined>: mask file to mask input data
-    out_file: medimage/nifti1
-    # type=file: output file
-    # type=file|default=<undefined>: output image file name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -118,7 +115,7 @@ tests:
     # type=file|default=<undefined>: mask file to mask input data
     thresh: '0.8 # keep all connections with corr >= 0.8'
     # type=float|default=0.0: threshold to exclude connections where corr <= thresh
-    out_file:
+    out_file: '"out.nii"'
     # type=file: output file
     # type=file|default=<undefined>: output image file name
   imports:
@@ -149,7 +146,7 @@ doctests:
     # type=file|default=<undefined>: mask file to mask input data
     thresh: '0.8 # keep all connections with corr >= 0.8'
     # type=float|default=0.0: threshold to exclude connections where corr <= thresh
-    out_file:
+    out_file: '"out.nii"'
     # type=file: output file
     # type=file|default=<undefined>: output image file name
   imports:
diff --git a/example-specs/task/nipype_internal/pydra-afni/lfcd_callables.py b/example-specs/task/nipype/afni/lfcd_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/lfcd_callables.py
rename to example-specs/task/nipype/afni/lfcd_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-afni/local_bistat.yaml b/example-specs/task/nipype/afni/local_bistat.yaml
similarity index 99%
rename from example-specs/task/nipype_internal/pydra-afni/local_bistat.yaml
rename to example-specs/task/nipype/afni/local_bistat.yaml
index f5c0558c..48afc1f5 100644
--- a/example-specs/task/nipype_internal/pydra-afni/local_bistat.yaml
+++ b/example-specs/task/nipype/afni/local_bistat.yaml
@@ -47,9 +47,6 @@ inputs:
     # type=file|default=<undefined>: mask image file name. Voxels NOT in the mask will not be used in the neighborhood of any voxel. Also, a voxel NOT in the mask will have its statistic(s) computed as zero (0).
     weight_file: generic/file
     # type=file|default=<undefined>: File name of an image to use as a weight.  Only applies to 'pearson' statistics.
-    out_file: generic/file
-    # type=file: output file
-    # type=file|default=<undefined>: Output dataset.
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype_internal/pydra-afni/local_bistat_callables.py b/example-specs/task/nipype/afni/local_bistat_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/local_bistat_callables.py
rename to example-specs/task/nipype/afni/local_bistat_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-afni/localstat.yaml b/example-specs/task/nipype/afni/localstat.yaml
similarity index 99%
rename from example-specs/task/nipype_internal/pydra-afni/localstat.yaml
rename to example-specs/task/nipype/afni/localstat.yaml
index ca394570..dcae292b 100644
--- a/example-specs/task/nipype_internal/pydra-afni/localstat.yaml
+++ b/example-specs/task/nipype/afni/localstat.yaml
@@ -44,9 +44,6 @@ inputs:
     # type=file|default=<undefined>: input dataset
     mask_file: medimage/nifti-gz
     # type=file|default=<undefined>: Mask image file name. Voxels NOT in the mask will not be used in the neighborhood of any voxel. Also, a voxel NOT in the mask will have its statistic(s) computed as zero (0) unless the parameter 'nonmask' is set to true.
-    out_file: generic/file
-    # type=file: output file
-    # type=file|default=<undefined>: Output dataset.
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -89,7 +86,7 @@ tests:
     reduce_grid:
     # type=traitcompound|default=None: Compute output on a grid that is reduced by the specified factors. If a single value is passed, output is resampled to the specified isotropic grid. Otherwise, the 3 inputs describe the reduction in the X, Y, and Z directions. This option speeds up computations at the expense of resolution. It should only be used when the nbhd is quite large with respect to the input's resolution, and the resultant stats are expected to be smooth.
     reduce_restore_grid:
-    # type=traitcompound|default=None: Like reduce_grid, but also resample output back to input grid.
+    # type=traitcompound|default=None: Like reduce_grid, but also resample output back to inputgrid.
     reduce_max_vox:
     # type=float|default=0.0: Like reduce_restore_grid, but automatically set Rx Ry Rz sothat the computation grid is at a resolution of nbhd/MAX_VOXvoxels.
     grid_rmode:
diff --git a/example-specs/task/nipype_internal/pydra-afni/localstat_callables.py b/example-specs/task/nipype/afni/localstat_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/localstat_callables.py
rename to example-specs/task/nipype/afni/localstat_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-afni/mask_tool.yaml b/example-specs/task/nipype/afni/mask_tool.yaml
similarity index 98%
rename from example-specs/task/nipype_internal/pydra-afni/mask_tool.yaml
rename to example-specs/task/nipype/afni/mask_tool.yaml
index a00cb5c3..b827a266 100644
--- a/example-specs/task/nipype_internal/pydra-afni/mask_tool.yaml
+++ b/example-specs/task/nipype/afni/mask_tool.yaml
@@ -37,9 +37,6 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/nifti1+list-of
     # type=inputmultiobject|default=[]: input file or files to 3dmask_tool
-    out_file: generic/file
-    # type=file: mask file
-    # type=file|default=<undefined>: output image file name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype_internal/pydra-afni/mask_tool_callables.py b/example-specs/task/nipype/afni/mask_tool_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/mask_tool_callables.py
rename to example-specs/task/nipype/afni/mask_tool_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-afni/maskave.yaml b/example-specs/task/nipype/afni/maskave.yaml
similarity index 98%
rename from example-specs/task/nipype_internal/pydra-afni/maskave.yaml
rename to example-specs/task/nipype/afni/maskave.yaml
index f1dfc3b0..c4148462 100644
--- a/example-specs/task/nipype_internal/pydra-afni/maskave.yaml
+++ b/example-specs/task/nipype/afni/maskave.yaml
@@ -39,9 +39,6 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/nifti1
     # type=file|default=<undefined>: input file to 3dmaskave
-    out_file: generic/file
-    # type=file: output file
-    # type=file|default=<undefined>: output image file name
     mask: medimage/nifti1
     # type=file|default=<undefined>: matrix to align input file
   metadata:
diff --git a/example-specs/task/nipype_internal/pydra-afni/maskave_callables.py b/example-specs/task/nipype/afni/maskave_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/maskave_callables.py
rename to example-specs/task/nipype/afni/maskave_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-afni/means.yaml b/example-specs/task/nipype/afni/means.yaml
similarity index 98%
rename from example-specs/task/nipype_internal/pydra-afni/means.yaml
rename to example-specs/task/nipype/afni/means.yaml
index 97492f66..7cad7552 100644
--- a/example-specs/task/nipype_internal/pydra-afni/means.yaml
+++ b/example-specs/task/nipype/afni/means.yaml
@@ -49,9 +49,6 @@ inputs:
     # type=file|default=<undefined>: input file to 3dMean
     in_file_b: medimage/nifti1
     # type=file|default=<undefined>: another input file to 3dMean
-    out_file: medimage/nifti1
-    # type=file: output file
-    # type=file|default=<undefined>: output image file name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -134,7 +131,7 @@ tests:
     # type=file|default=<undefined>: input file to 3dMean
     in_file_b:
     # type=file|default=<undefined>: another input file to 3dMean
-    out_file:
+    out_file: ' "output.nii"'
     # type=file: output file
     # type=file|default=<undefined>: output image file name
   imports:
@@ -157,7 +154,7 @@ tests:
   # (if not specified, will try to choose a sensible value)
     in_file_a:
     # type=file|default=<undefined>: input file to 3dMean
-    out_file:
+    out_file: ' "output.nii"'
     # type=file: output file
     # type=file|default=<undefined>: output image file name
     datum: '"short"'
@@ -188,7 +185,7 @@ doctests:
     # type=file|default=<undefined>: input file to 3dMean
     in_file_b:
     # type=file|default=<undefined>: another input file to 3dMean
-    out_file:
+    out_file: ' "output.nii"'
     # type=file: output file
     # type=file|default=<undefined>: output image file name
   imports:
@@ -204,7 +201,7 @@ doctests:
   # '.mock()' method of the corresponding class is used instead.
     in_file_a:
     # type=file|default=<undefined>: input file to 3dMean
-    out_file:
+    out_file: ' "output.nii"'
     # type=file: output file
     # type=file|default=<undefined>: output image file name
     datum: '"short"'
diff --git a/example-specs/task/nipype_internal/pydra-afni/means_callables.py b/example-specs/task/nipype/afni/means_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/means_callables.py
rename to example-specs/task/nipype/afni/means_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-afni/merge.yaml b/example-specs/task/nipype/afni/merge.yaml
similarity index 97%
rename from example-specs/task/nipype_internal/pydra-afni/merge.yaml
rename to example-specs/task/nipype/afni/merge.yaml
index 994ce9be..5b4b8605 100644
--- a/example-specs/task/nipype_internal/pydra-afni/merge.yaml
+++ b/example-specs/task/nipype/afni/merge.yaml
@@ -39,9 +39,6 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_files: medimage/nifti1+list-of
     # type=inputmultiobject|default=[]: 
-    out_file: medimage/nifti1
-    # type=file: output file
-    # type=file|default=<undefined>: output image file name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -110,7 +107,7 @@ tests:
     # type=int|default=0: FWHM blur value (mm)
     doall: 'True'
     # type=bool|default=False: apply options to all sub-bricks in dataset
-    out_file:
+    out_file: '"e7.nii"'
     # type=file: output file
     # type=file|default=<undefined>: output image file name
   imports:
@@ -141,7 +138,7 @@ doctests:
     # type=int|default=0: FWHM blur value (mm)
     doall: 'True'
     # type=bool|default=False: apply options to all sub-bricks in dataset
-    out_file:
+    out_file: '"e7.nii"'
     # type=file: output file
     # type=file|default=<undefined>: output image file name
   imports:
diff --git a/example-specs/task/nipype_internal/pydra-afni/merge_callables.py b/example-specs/task/nipype/afni/merge_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/merge_callables.py
rename to example-specs/task/nipype/afni/merge_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-afni/net_corr.yaml b/example-specs/task/nipype/afni/net_corr.yaml
similarity index 99%
rename from example-specs/task/nipype_internal/pydra-afni/net_corr.yaml
rename to example-specs/task/nipype/afni/net_corr.yaml
index 7c22c5fd..55b5f5c2 100644
--- a/example-specs/task/nipype_internal/pydra-afni/net_corr.yaml
+++ b/example-specs/task/nipype/afni/net_corr.yaml
@@ -49,14 +49,11 @@ inputs:
     # type=file|default=<undefined>: can include a whole brain mask within which to calculate correlation. Otherwise, data should be masked already
     weight_ts: generic/file
     # type=file|default=<undefined>: input a 1D file WTS of weights that will be applied multiplicatively to each ROI's average time series. WTS can be a column- or row-file of values, but it must have the same length as the input time series volume. If the initial average time series was A[n] for n=0,..,(N-1) time points, then applying a set of weights W[n] of the same length from WTS would produce a new time series:  B[n] = A[n] * W[n]
-    out_file: medimage-afni/ncorr
-    # type=file|default=<undefined>: output file name part
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
   omit:
   # list[str] - fields to omit from the Pydra interface
-  - out_file
   rename:
   # dict[str, str] - fields to rename in the Pydra interface
   types:
@@ -65,6 +62,8 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    out_file: medimage-afni/ncorr
+    # type=file|default=<undefined>: output file name part
     out_corr_matrix: generic/file
     # type=file: output correlation matrix between ROIs written to a text file with .netcc suffix
   callables:
@@ -150,7 +149,7 @@ tests:
     # type=bool|default=False: same as above in '-ts_wb_corr', except that the maps have been Fisher transformed to Z-scores the relation: Z=atanh(r). To avoid infinities in the transform, Pearson values are effectively capped at |r| = 0.999329 (where |Z| = 4.0). Files are labelled WB_Z_ROI_001+orig, etc
     fish_z: 'True'
     # type=bool|default=False: switch to also output a matrix of Fisher Z-transform values for the corr coefs (r): Z = atanh(r) , (with Z=4 being output along matrix diagonals where r=1, as the r-to-Z conversion is ceilinged at Z = atanh(r=0.999329) = 4, which is still *quite* a high Pearson-r value
-    out_file:
+    out_file: '"sub0.tp1.ncorr"'
     # type=file|default=<undefined>: output file name part
   imports:
   # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
@@ -186,7 +185,7 @@ doctests:
     # type=bool|default=False: same as above in '-ts_wb_corr', except that the maps have been Fisher transformed to Z-scores the relation: Z=atanh(r). To avoid infinities in the transform, Pearson values are effectively capped at |r| = 0.999329 (where |Z| = 4.0). Files are labelled WB_Z_ROI_001+orig, etc
     fish_z: 'True'
     # type=bool|default=False: switch to also output a matrix of Fisher Z-transform values for the corr coefs (r): Z = atanh(r) , (with Z=4 being output along matrix diagonals where r=1, as the r-to-Z conversion is ceilinged at Z = atanh(r=0.999329) = 4, which is still *quite* a high Pearson-r value
-    out_file:
+    out_file: '"sub0.tp1.ncorr"'
     # type=file|default=<undefined>: output file name part
   imports:
   # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
diff --git a/example-specs/task/nipype_internal/pydra-afni/net_corr_callables.py b/example-specs/task/nipype/afni/net_corr_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/net_corr_callables.py
rename to example-specs/task/nipype/afni/net_corr_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-afni/notes.yaml b/example-specs/task/nipype/afni/notes.yaml
similarity index 98%
rename from example-specs/task/nipype_internal/pydra-afni/notes.yaml
rename to example-specs/task/nipype/afni/notes.yaml
index 8654f5fc..da50e782 100644
--- a/example-specs/task/nipype_internal/pydra-afni/notes.yaml
+++ b/example-specs/task/nipype/afni/notes.yaml
@@ -38,9 +38,6 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage-afni/head
     # type=file|default=<undefined>: input file to 3dNotes
-    out_file: generic/file
-    # type=file: output file
-    # type=file|default=<undefined>: output image file name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype_internal/pydra-afni/notes_callables.py b/example-specs/task/nipype/afni/notes_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/notes_callables.py
rename to example-specs/task/nipype/afni/notes_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-afni/nwarp_adjust.yaml b/example-specs/task/nipype/afni/nwarp_adjust.yaml
similarity index 96%
rename from example-specs/task/nipype_internal/pydra-afni/nwarp_adjust.yaml
rename to example-specs/task/nipype/afni/nwarp_adjust.yaml
index 304c4791..f5af9166 100644
--- a/example-specs/task/nipype_internal/pydra-afni/nwarp_adjust.yaml
+++ b/example-specs/task/nipype/afni/nwarp_adjust.yaml
@@ -43,9 +43,6 @@ inputs:
     # type=inputmultiobject|default=[]: List of input 3D warp datasets
     in_files: generic/file+list-of
     # type=inputmultiobject|default=[]: List of input 3D datasets to be warped by the adjusted warp datasets.  There must be exactly as many of these datasets as there are input warps.
-    out_file: generic/file
-    # type=file: output file
-    # type=file|default=<undefined>: Output mean dataset, only needed if in_files are also given. The output dataset will be on the common grid shared by the source datasets.
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype_internal/pydra-afni/nwarp_adjust_callables.py b/example-specs/task/nipype/afni/nwarp_adjust_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/nwarp_adjust_callables.py
rename to example-specs/task/nipype/afni/nwarp_adjust_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-afni/nwarp_apply.yaml b/example-specs/task/nipype/afni/nwarp_apply.yaml
similarity index 98%
rename from example-specs/task/nipype_internal/pydra-afni/nwarp_apply.yaml
rename to example-specs/task/nipype/afni/nwarp_apply.yaml
index 3e6f321b..212e03f4 100644
--- a/example-specs/task/nipype_internal/pydra-afni/nwarp_apply.yaml
+++ b/example-specs/task/nipype/afni/nwarp_apply.yaml
@@ -40,9 +40,6 @@ inputs:
   # passed to the field in the automatically generated unittests.
     master: generic/file
     # type=file|default=<undefined>: the name of the master dataset, which defines the output grid
-    out_file: generic/file
-    # type=file: output file
-    # type=file|default=<undefined>: output image file name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype_internal/pydra-afni/nwarp_apply_callables.py b/example-specs/task/nipype/afni/nwarp_apply_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/nwarp_apply_callables.py
rename to example-specs/task/nipype/afni/nwarp_apply_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-afni/nwarp_cat.yaml b/example-specs/task/nipype/afni/nwarp_cat.yaml
similarity index 98%
rename from example-specs/task/nipype_internal/pydra-afni/nwarp_cat.yaml
rename to example-specs/task/nipype/afni/nwarp_cat.yaml
index 7b957472..68cf9ed3 100644
--- a/example-specs/task/nipype_internal/pydra-afni/nwarp_cat.yaml
+++ b/example-specs/task/nipype/afni/nwarp_cat.yaml
@@ -69,9 +69,6 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    out_file: generic/file
-    # type=file: output file
-    # type=file|default=<undefined>: output image file name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -142,7 +139,7 @@ tests:
   # (if not specified, will try to choose a sensible value)
     in_files: '["Q25_warp+tlrc.HEAD", ("IDENT", "structural.nii")]'
     # type=list|default=[]: list of tuples of 3D warps and associated functions
-    out_file:
+    out_file: '"Fred_total_WARP"'
     # type=file: output file
     # type=file|default=<undefined>: output image file name
   imports:
@@ -169,7 +166,7 @@ doctests:
   # '.mock()' method of the corresponding class is used instead.
     in_files: '["Q25_warp+tlrc.HEAD", ("IDENT", "structural.nii")]'
     # type=list|default=[]: list of tuples of 3D warps and associated functions
-    out_file:
+    out_file: '"Fred_total_WARP"'
     # type=file: output file
     # type=file|default=<undefined>: output image file name
   imports:
diff --git a/example-specs/task/nipype_internal/pydra-afni/nwarp_cat_callables.py b/example-specs/task/nipype/afni/nwarp_cat_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/nwarp_cat_callables.py
rename to example-specs/task/nipype/afni/nwarp_cat_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-afni/one_d_tool_py.yaml b/example-specs/task/nipype/afni/one_d_tool_py.yaml
similarity index 96%
rename from example-specs/task/nipype_internal/pydra-afni/one_d_tool_py.yaml
rename to example-specs/task/nipype/afni/one_d_tool_py.yaml
index a93c9468..f53a53d3 100644
--- a/example-specs/task/nipype_internal/pydra-afni/one_d_tool_py.yaml
+++ b/example-specs/task/nipype/afni/one_d_tool_py.yaml
@@ -33,9 +33,6 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage-afni/oned
     # type=file|default=<undefined>: input file to OneDTool
-    out_file: medimage-afni/oned
-    # type=file: output of 1D_tool.py
-    # type=file|default=<undefined>: write the current 1D data to FILE
     show_cormat_warnings: generic/file
     # type=file|default=<undefined>: Write cormat warnings to a file
   metadata:
@@ -79,7 +76,7 @@ tests:
     show_censor_count:
     # type=bool|default=False: display the total number of censored TRs  Note : if input is a valid xmat.1D dataset, then the count will come from the header.  Otherwise the input is assumed to be a binary censorfile, and zeros are simply counted.
     censor_motion:
-    # type=tuple|default=(<traits.trait_types.Float object at 0x11cffdc50>, <nipype.interfaces.base.traits_extension.File object at 0x11cffdd10>): Tuple of motion limit and outfile prefix. need to also set set_nruns -r set_run_lengths
+    # type=tuple|default=(<traits.trait_types.Float object at 0x10bee9cd0>, <nipype.interfaces.base.traits_extension.File object at 0x10bee9d90>): Tuple of motion limit and outfile prefix. need to also set set_nruns -r set_run_lengths
     censor_prev_TR:
     # type=bool|default=False: for each censored TR, also censor previous
     show_trs_uncensored:
@@ -122,7 +119,7 @@ tests:
     # type=int|default=0: treat the input data as if it has nruns
     demean: 'True'
     # type=bool|default=False: demean each run (new mean of each run = 0.0)
-    out_file:
+    out_file: '"motion_dmean.1D"'
     # type=file: output of 1D_tool.py
     # type=file|default=<undefined>: write the current 1D data to FILE
   imports:
@@ -153,7 +150,7 @@ doctests:
     # type=int|default=0: treat the input data as if it has nruns
     demean: 'True'
     # type=bool|default=False: demean each run (new mean of each run = 0.0)
-    out_file:
+    out_file: '"motion_dmean.1D"'
     # type=file: output of 1D_tool.py
     # type=file|default=<undefined>: write the current 1D data to FILE
   imports:
diff --git a/example-specs/task/nipype_internal/pydra-afni/one_d_tool_py_callables.py b/example-specs/task/nipype/afni/one_d_tool_py_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/one_d_tool_py_callables.py
rename to example-specs/task/nipype/afni/one_d_tool_py_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-afni/outlier_count.yaml b/example-specs/task/nipype/afni/outlier_count.yaml
similarity index 98%
rename from example-specs/task/nipype_internal/pydra-afni/outlier_count.yaml
rename to example-specs/task/nipype/afni/outlier_count.yaml
index 2f1f197b..c2734a0d 100644
--- a/example-specs/task/nipype_internal/pydra-afni/outlier_count.yaml
+++ b/example-specs/task/nipype/afni/outlier_count.yaml
@@ -41,9 +41,6 @@ inputs:
     # type=file|default=<undefined>: only count voxels within the given mask
     outliers_file: generic/file
     # type=file|default=<undefined>: output image file name
-    out_file: generic/file
-    # type=file: capture standard output
-    # type=file|default=<undefined>: capture standard output
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -57,11 +54,11 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    out_outliers: generic/file
-    # type=file: output image file name
     out_file: generic/file
     # type=file: capture standard output
     # type=file|default=<undefined>: capture standard output
+    out_outliers: generic/file
+    # type=file: output image file name
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype_internal/pydra-afni/outlier_count_callables.py b/example-specs/task/nipype/afni/outlier_count_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/outlier_count_callables.py
rename to example-specs/task/nipype/afni/outlier_count_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-afni/quality_index.yaml b/example-specs/task/nipype/afni/quality_index.yaml
similarity index 97%
rename from example-specs/task/nipype_internal/pydra-afni/quality_index.yaml
rename to example-specs/task/nipype/afni/quality_index.yaml
index 1437cf53..fb95678a 100644
--- a/example-specs/task/nipype_internal/pydra-afni/quality_index.yaml
+++ b/example-specs/task/nipype/afni/quality_index.yaml
@@ -42,9 +42,6 @@ inputs:
     # type=file|default=<undefined>: input dataset
     mask: generic/file
     # type=file|default=<undefined>: compute correlation only across masked voxels
-    out_file: generic/file
-    # type=file: file containing the captured standard output
-    # type=file|default=<undefined>: capture standard output
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype_internal/pydra-afni/quality_index_callables.py b/example-specs/task/nipype/afni/quality_index_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/quality_index_callables.py
rename to example-specs/task/nipype/afni/quality_index_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-afni/qwarp.yaml b/example-specs/task/nipype/afni/qwarp.yaml
similarity index 99%
rename from example-specs/task/nipype_internal/pydra-afni/qwarp.yaml
rename to example-specs/task/nipype/afni/qwarp.yaml
index d56c4622..d8a5bd5a 100644
--- a/example-specs/task/nipype_internal/pydra-afni/qwarp.yaml
+++ b/example-specs/task/nipype/afni/qwarp.yaml
@@ -113,12 +113,8 @@ inputs:
     # type=file|default=<undefined>: Source image (opposite phase encoding direction than base image).
     base_file: medimage/nifti1,medimage/nifti-gz
     # type=file|default=<undefined>: Base image (opposite phase encoding direction than source image).
-    out_file: medimage/nifti-gz
-    # type=file|default=<undefined>: Sets the prefix/suffix for the output datasets.  * The source dataset is warped to match the base   and gets prefix 'ppp'. (Except if '-plusminus' is used * The final interpolation to this output dataset is   done using the 'wsinc5' method.  See the output of   3dAllineate -HELP   (in the "Modifying '-final wsinc5'" section) for   the lengthy technical details. * The 3D warp used is saved in a dataset with   prefix 'ppp_WARP' -- this dataset can be used   with 3dNwarpApply and 3dNwarpCat, for example. * To be clear, this is the warp from source dataset   coordinates to base dataset coordinates, where the   values at each base grid point are the xyz displacements   needed to move that grid point's xyz values to the   corresponding xyz values in the source dataset:   base( (x,y,z) + WARP(x,y,z) ) matches source(x,y,z)   Another way to think of this warp is that it 'pulls'   values back from source space to base space. * 3dNwarpApply would use 'ppp_WARP' to transform datasets   aligned with the source dataset to be aligned with the   base dataset.  **If you do NOT want this warp saved, use the option '-nowarp'**. (However, this warp is usually the most valuable possible output!)  * If you want to calculate and save the inverse 3D warp,   use the option '-iwarp'.  This inverse warp will then be   saved in a dataset with prefix 'ppp_WARPINV'. * This inverse warp could be used to transform data from base   space to source space, if you need to do such an operation. * You can easily compute the inverse later, say by a command like   3dNwarpCat -prefix Z_WARPINV 'INV(Z_WARP+tlrc)'   or the inverse can be computed as needed in 3dNwarpApply, like   3dNwarpApply -nwarp 'INV(Z_WARP+tlrc)' -source Dataset.nii ...  
     weight: generic/file
     # type=file|default=<undefined>: Instead of computing the weight from the base dataset,directly input the weight volume from dataset 'www'.Useful if you know what over parts of the base image youwant to emphasize or de-emphasize the matching functional.
-    out_weight_file: generic/file
-    # type=file|default=<undefined>: Write the weight volume to disk as a dataset
     emask: generic/file
     # type=file|default=<undefined>: Here, 'ee' is a dataset to specify a mask of voxelsto EXCLUDE from the analysis -- all voxels in 'ee'that are NONZERO will not be used in the alignment.The base image always automasked -- the emask isextra, to indicate voxels you definitely DON'T wantincluded in the matching process, even if they areinside the brain.
     iniwarp: medimage-afni/head+list-of
@@ -138,6 +134,10 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    out_file: medimage/nifti-gz
+    # type=file|default=<undefined>: Sets the prefix/suffix for the output datasets.  * The source dataset is warped to match the base   and gets prefix 'ppp'. (Except if '-plusminus' is used * The final interpolation to this output dataset is   done using the 'wsinc5' method.  See the output of   3dAllineate -HELP   (in the "Modifying '-final wsinc5'" section) for   the lengthy technical details. * The 3D warp used is saved in a dataset with   prefix 'ppp_WARP' -- this dataset can be used   with 3dNwarpApply and 3dNwarpCat, for example. * To be clear, this is the warp from source dataset   coordinates to base dataset coordinates, where the   values at each base grid point are the xyz displacements   needed to move that grid point's xyz values to the   corresponding xyz values in the source dataset:   base( (x,y,z) + WARP(x,y,z) ) matches source(x,y,z)   Another way to think of this warp is that it 'pulls'   values back from source space to base space. * 3dNwarpApply would use 'ppp_WARP' to transform datasets   aligned with the source dataset to be aligned with the   base dataset.  **If you do NOT want this warp saved, use the option '-nowarp'**. (However, this warp is usually the most valuable possible output!)  * If you want to calculate and save the inverse 3D warp,   use the option '-iwarp'.  This inverse warp will then be   saved in a dataset with prefix 'ppp_WARPINV'. * This inverse warp could be used to transform data from base   space to source space, if you need to do such an operation. * You can easily compute the inverse later, say by a command like   3dNwarpCat -prefix Z_WARPINV 'INV(Z_WARP+tlrc)'   or the inverse can be computed as needed in 3dNwarpApply, like   3dNwarpApply -nwarp 'INV(Z_WARP+tlrc)' -source Dataset.nii ...  
+    out_weight_file: generic/file
+    # type=file|default=<undefined>: Write the weight volume to disk as a dataset
     warped_source: generic/file
     # type=file: Warped source file. If plusminus is used, this is the undistortedsource file.
     warped_base: generic/file
@@ -190,7 +190,7 @@ tests:
     wball:
     # type=list|default=[]: "``-wball x y z r f`` Enhance automatic weight from '-useweight' by a factor of 1+f\*Gaussian(FWHM=r) centered in the base image at DICOM coordinates (x,y,z) and with radius 'r'. The goal of this option is to try and make the alignment better in a specific part of the brain. Example:  -wball 0 14 6 30 40 to emphasize the thalamic area (in MNI/Talairach space).  * The 'r' parameter must be positive! * The 'f' parameter must be between 1 and 100 (inclusive). * '-wball' does nothing if you input your own weight   with the '-weight' option. * '-wball' does change the binary weight created by   the '-noweight' option. * You can only use '-wball' once in a run of 3dQwarp.  **The effect of '-wball' is not dramatic.** The example above makes the average brain image across a collection of subjects a little sharper in the thalamic area, which might have some small value.  If you care enough about alignment to use '-wball', then you should examine the results from 3dQwarp for each subject, to see if the alignments are good enough for your purposes.
     wmask:
-    # type=tuple|default=(<nipype.interfaces.base.traits_extension.File object at 0x11cef9410>, <traits.trait_types.Float object at 0x11cef8f10>): Similar to '-wball', but here, you provide a dataset 'ws' that indicates where to increase the weight.  * The 'ws' dataset must be on the same 3D grid as the base dataset. * 'ws' is treated as a mask -- it only matters where it   is nonzero -- otherwise, the values inside are not used. * After 'ws' comes the factor 'f' by which to increase the   automatically computed weight.  Where 'ws' is nonzero,   the weighting will be multiplied by (1+f). * As with '-wball', the factor 'f' should be between 1 and 100.  
+    # type=tuple|default=(<nipype.interfaces.base.traits_extension.File object at 0x10bdedfd0>, <traits.trait_types.Float object at 0x10bdee010>): Similar to '-wball', but here, you provide a dataset 'ws' that indicates where to increase the weight.  * The 'ws' dataset must be on the same 3D grid as the base dataset. * 'ws' is treated as a mask -- it only matters where it   is nonzero -- otherwise, the values inside are not used. * After 'ws' comes the factor 'f' by which to increase the   automatically computed weight.  Where 'ws' is nonzero,   the weighting will be multiplied by (1+f). * As with '-wball', the factor 'f' should be between 1 and 100.  
     out_weight_file:
     # type=file|default=<undefined>: Write the weight volume to disk as a dataset
     blur:
@@ -333,7 +333,7 @@ tests:
     # type=file|default=<undefined>: Source image (opposite phase encoding direction than base image).
     base_file:
     # type=file|default=<undefined>: Base image (opposite phase encoding direction than source image).
-    out_file:
+    out_file: '"anatSSQ.nii.gz"'
     # type=file|default=<undefined>: Sets the prefix/suffix for the output datasets.  * The source dataset is warped to match the base   and gets prefix 'ppp'. (Except if '-plusminus' is used * The final interpolation to this output dataset is   done using the 'wsinc5' method.  See the output of   3dAllineate -HELP   (in the "Modifying '-final wsinc5'" section) for   the lengthy technical details. * The 3D warp used is saved in a dataset with   prefix 'ppp_WARP' -- this dataset can be used   with 3dNwarpApply and 3dNwarpCat, for example. * To be clear, this is the warp from source dataset   coordinates to base dataset coordinates, where the   values at each base grid point are the xyz displacements   needed to move that grid point's xyz values to the   corresponding xyz values in the source dataset:   base( (x,y,z) + WARP(x,y,z) ) matches source(x,y,z)   Another way to think of this warp is that it 'pulls'   values back from source space to base space. * 3dNwarpApply would use 'ppp_WARP' to transform datasets   aligned with the source dataset to be aligned with the   base dataset.  **If you do NOT want this warp saved, use the option '-nowarp'**. (However, this warp is usually the most valuable possible output!)  * If you want to calculate and save the inverse 3D warp,   use the option '-iwarp'.  This inverse warp will then be   saved in a dataset with prefix 'ppp_WARPINV'. * This inverse warp could be used to transform data from base   space to source space, if you need to do such an operation. * You can easily compute the inverse later, say by a command like   3dNwarpCat -prefix Z_WARPINV 'INV(Z_WARP+tlrc)'   or the inverse can be computed as needed in 3dNwarpApply, like   3dNwarpApply -nwarp 'INV(Z_WARP+tlrc)' -source Dataset.nii ...  
     resample: 'True'
     # type=bool|default=False: This option simply resamples the source dataset to match the base dataset grid.  You can use this if the two datasets overlap well (as seen in the AFNI GUI), but are not on the same 3D grid.  * If they don't overlap well, allineate them first * The reampling here is done with the   'wsinc5' method, which has very little blurring artifact. * If the base and source datasets ARE on the same 3D grid,   then the -resample option will be ignored. * You CAN use -resample with these 3dQwarp options:   -plusminus  -inilev  -iniwarp  -duplo  
@@ -399,7 +399,7 @@ tests:
     # type=int|default=0: The value of mm should be an odd integer.  * The default value of mm is 25. * For more accurate results than mm=25, try 19 or 13. * The smallest allowed patch size is 5. * You may want stop at a larger patch size (say 7 or 9) and use   the -Qfinal option to run that final level with quintic warps,   which might run faster and provide the same degree of warp detail. * Trying to make two different brain volumes match in fine detail   is usually a waste of time, especially in humans.  There is too   much variability in anatomy to match gyrus to gyrus accurately.   For this reason, the default minimum patch size is 25 voxels.   Using a smaller '-minpatch' might try to force the warp to   match features that do not match, and the result can be useless   image distortions -- another reason to LOOK AT THE RESULTS.  
     blur: '[0,3]'
     # type=list|default=[]: Gaussian blur the input images by 'bb' (FWHM) voxels before doing the alignment (the output dataset will not be blurred). The default is 2.345 (for no good reason).  * Optionally, you can provide 2 values for 'bb', and then   the first one is applied to the base volume, the second   to the source volume.   e.g., '-blur 0 3' to skip blurring the base image   (if the base is a blurry template, for example). * A negative blur radius means to use 3D median filtering,   rather than Gaussian blurring.  This type of filtering will   better preserve edges, which can be important in alignment. * If the base is a template volume that is already blurry,   you probably don't want to blur it again, but blurring   the source volume a little is probably a good idea, to   help the program avoid trying to match tiny features. * Note that -duplo will blur the volumes some extra   amount for the initial small-scale warping, to make   that phase of the program converge more rapidly.  
-    out_file:
+    out_file: '"Q25"'
     # type=file|default=<undefined>: Sets the prefix/suffix for the output datasets.  * The source dataset is warped to match the base   and gets prefix 'ppp'. (Except if '-plusminus' is used * The final interpolation to this output dataset is   done using the 'wsinc5' method.  See the output of   3dAllineate -HELP   (in the "Modifying '-final wsinc5'" section) for   the lengthy technical details. * The 3D warp used is saved in a dataset with   prefix 'ppp_WARP' -- this dataset can be used   with 3dNwarpApply and 3dNwarpCat, for example. * To be clear, this is the warp from source dataset   coordinates to base dataset coordinates, where the   values at each base grid point are the xyz displacements   needed to move that grid point's xyz values to the   corresponding xyz values in the source dataset:   base( (x,y,z) + WARP(x,y,z) ) matches source(x,y,z)   Another way to think of this warp is that it 'pulls'   values back from source space to base space. * 3dNwarpApply would use 'ppp_WARP' to transform datasets   aligned with the source dataset to be aligned with the   base dataset.  **If you do NOT want this warp saved, use the option '-nowarp'**. (However, this warp is usually the most valuable possible output!)  * If you want to calculate and save the inverse 3D warp,   use the option '-iwarp'.  This inverse warp will then be   saved in a dataset with prefix 'ppp_WARPINV'. * This inverse warp could be used to transform data from base   space to source space, if you need to do such an operation. * You can easily compute the inverse later, say by a command like   3dNwarpCat -prefix Z_WARPINV 'INV(Z_WARP+tlrc)'   or the inverse can be computed as needed in 3dNwarpApply, like   3dNwarpApply -nwarp 'INV(Z_WARP+tlrc)' -source Dataset.nii ...  
   imports:
   # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
@@ -425,7 +425,7 @@ tests:
     # type=file|default=<undefined>: Base image (opposite phase encoding direction than source image).
     blur: '[0,2]'
     # type=list|default=[]: Gaussian blur the input images by 'bb' (FWHM) voxels before doing the alignment (the output dataset will not be blurred). The default is 2.345 (for no good reason).  * Optionally, you can provide 2 values for 'bb', and then   the first one is applied to the base volume, the second   to the source volume.   e.g., '-blur 0 3' to skip blurring the base image   (if the base is a blurry template, for example). * A negative blur radius means to use 3D median filtering,   rather than Gaussian blurring.  This type of filtering will   better preserve edges, which can be important in alignment. * If the base is a template volume that is already blurry,   you probably don't want to blur it again, but blurring   the source volume a little is probably a good idea, to   help the program avoid trying to match tiny features. * Note that -duplo will blur the volumes some extra   amount for the initial small-scale warping, to make   that phase of the program converge more rapidly.  
-    out_file:
+    out_file: '"Q11"'
     # type=file|default=<undefined>: Sets the prefix/suffix for the output datasets.  * The source dataset is warped to match the base   and gets prefix 'ppp'. (Except if '-plusminus' is used * The final interpolation to this output dataset is   done using the 'wsinc5' method.  See the output of   3dAllineate -HELP   (in the "Modifying '-final wsinc5'" section) for   the lengthy technical details. * The 3D warp used is saved in a dataset with   prefix 'ppp_WARP' -- this dataset can be used   with 3dNwarpApply and 3dNwarpCat, for example. * To be clear, this is the warp from source dataset   coordinates to base dataset coordinates, where the   values at each base grid point are the xyz displacements   needed to move that grid point's xyz values to the   corresponding xyz values in the source dataset:   base( (x,y,z) + WARP(x,y,z) ) matches source(x,y,z)   Another way to think of this warp is that it 'pulls'   values back from source space to base space. * 3dNwarpApply would use 'ppp_WARP' to transform datasets   aligned with the source dataset to be aligned with the   base dataset.  **If you do NOT want this warp saved, use the option '-nowarp'**. (However, this warp is usually the most valuable possible output!)  * If you want to calculate and save the inverse 3D warp,   use the option '-iwarp'.  This inverse warp will then be   saved in a dataset with prefix 'ppp_WARPINV'. * This inverse warp could be used to transform data from base   space to source space, if you need to do such an operation. * You can easily compute the inverse later, say by a command like   3dNwarpCat -prefix Z_WARPINV 'INV(Z_WARP+tlrc)'   or the inverse can be computed as needed in 3dNwarpApply, like   3dNwarpApply -nwarp 'INV(Z_WARP+tlrc)' -source Dataset.nii ...  
     inilev: '7'
     # type=int|default=0: The initial refinement 'level' at which to start.  * Usually used with -iniwarp; CANNOT be used with -duplo. * The combination of -inilev and -iniwarp lets you take the   results of a previous 3dQwarp run and refine them further:   Note that the source dataset in the second run is the SAME as   in the first run.  If you don't see why this is necessary,   then you probably need to seek help from an AFNI guru.  
@@ -519,7 +519,7 @@ doctests:
     # type=file|default=<undefined>: Source image (opposite phase encoding direction than base image).
     base_file:
     # type=file|default=<undefined>: Base image (opposite phase encoding direction than source image).
-    out_file:
+    out_file: '"anatSSQ.nii.gz"'
     # type=file|default=<undefined>: Sets the prefix/suffix for the output datasets.  * The source dataset is warped to match the base   and gets prefix 'ppp'. (Except if '-plusminus' is used * The final interpolation to this output dataset is   done using the 'wsinc5' method.  See the output of   3dAllineate -HELP   (in the "Modifying '-final wsinc5'" section) for   the lengthy technical details. * The 3D warp used is saved in a dataset with   prefix 'ppp_WARP' -- this dataset can be used   with 3dNwarpApply and 3dNwarpCat, for example. * To be clear, this is the warp from source dataset   coordinates to base dataset coordinates, where the   values at each base grid point are the xyz displacements   needed to move that grid point's xyz values to the   corresponding xyz values in the source dataset:   base( (x,y,z) + WARP(x,y,z) ) matches source(x,y,z)   Another way to think of this warp is that it 'pulls'   values back from source space to base space. * 3dNwarpApply would use 'ppp_WARP' to transform datasets   aligned with the source dataset to be aligned with the   base dataset.  **If you do NOT want this warp saved, use the option '-nowarp'**. (However, this warp is usually the most valuable possible output!)  * If you want to calculate and save the inverse 3D warp,   use the option '-iwarp'.  This inverse warp will then be   saved in a dataset with prefix 'ppp_WARPINV'. * This inverse warp could be used to transform data from base   space to source space, if you need to do such an operation. * You can easily compute the inverse later, say by a command like   3dNwarpCat -prefix Z_WARPINV 'INV(Z_WARP+tlrc)'   or the inverse can be computed as needed in 3dNwarpApply, like   3dNwarpApply -nwarp 'INV(Z_WARP+tlrc)' -source Dataset.nii ...  
     resample: 'True'
     # type=bool|default=False: This option simply resamples the source dataset to match the base dataset grid.  You can use this if the two datasets overlap well (as seen in the AFNI GUI), but are not on the same 3D grid.  * If they don't overlap well, allineate them first * The reampling here is done with the   'wsinc5' method, which has very little blurring artifact. * If the base and source datasets ARE on the same 3D grid,   then the -resample option will be ignored. * You CAN use -resample with these 3dQwarp options:   -plusminus  -inilev  -iniwarp  -duplo  
@@ -571,7 +571,7 @@ doctests:
     # type=int|default=0: The value of mm should be an odd integer.  * The default value of mm is 25. * For more accurate results than mm=25, try 19 or 13. * The smallest allowed patch size is 5. * You may want stop at a larger patch size (say 7 or 9) and use   the -Qfinal option to run that final level with quintic warps,   which might run faster and provide the same degree of warp detail. * Trying to make two different brain volumes match in fine detail   is usually a waste of time, especially in humans.  There is too   much variability in anatomy to match gyrus to gyrus accurately.   For this reason, the default minimum patch size is 25 voxels.   Using a smaller '-minpatch' might try to force the warp to   match features that do not match, and the result can be useless   image distortions -- another reason to LOOK AT THE RESULTS.  
     blur: '[0,3]'
     # type=list|default=[]: Gaussian blur the input images by 'bb' (FWHM) voxels before doing the alignment (the output dataset will not be blurred). The default is 2.345 (for no good reason).  * Optionally, you can provide 2 values for 'bb', and then   the first one is applied to the base volume, the second   to the source volume.   e.g., '-blur 0 3' to skip blurring the base image   (if the base is a blurry template, for example). * A negative blur radius means to use 3D median filtering,   rather than Gaussian blurring.  This type of filtering will   better preserve edges, which can be important in alignment. * If the base is a template volume that is already blurry,   you probably don't want to blur it again, but blurring   the source volume a little is probably a good idea, to   help the program avoid trying to match tiny features. * Note that -duplo will blur the volumes some extra   amount for the initial small-scale warping, to make   that phase of the program converge more rapidly.  
-    out_file:
+    out_file: '"Q25"'
     # type=file|default=<undefined>: Sets the prefix/suffix for the output datasets.  * The source dataset is warped to match the base   and gets prefix 'ppp'. (Except if '-plusminus' is used * The final interpolation to this output dataset is   done using the 'wsinc5' method.  See the output of   3dAllineate -HELP   (in the "Modifying '-final wsinc5'" section) for   the lengthy technical details. * The 3D warp used is saved in a dataset with   prefix 'ppp_WARP' -- this dataset can be used   with 3dNwarpApply and 3dNwarpCat, for example. * To be clear, this is the warp from source dataset   coordinates to base dataset coordinates, where the   values at each base grid point are the xyz displacements   needed to move that grid point's xyz values to the   corresponding xyz values in the source dataset:   base( (x,y,z) + WARP(x,y,z) ) matches source(x,y,z)   Another way to think of this warp is that it 'pulls'   values back from source space to base space. * 3dNwarpApply would use 'ppp_WARP' to transform datasets   aligned with the source dataset to be aligned with the   base dataset.  **If you do NOT want this warp saved, use the option '-nowarp'**. (However, this warp is usually the most valuable possible output!)  * If you want to calculate and save the inverse 3D warp,   use the option '-iwarp'.  This inverse warp will then be   saved in a dataset with prefix 'ppp_WARPINV'. * This inverse warp could be used to transform data from base   space to source space, if you need to do such an operation. * You can easily compute the inverse later, say by a command like   3dNwarpCat -prefix Z_WARPINV 'INV(Z_WARP+tlrc)'   or the inverse can be computed as needed in 3dNwarpApply, like   3dNwarpApply -nwarp 'INV(Z_WARP+tlrc)' -source Dataset.nii ...  
   imports:
   # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
@@ -590,7 +590,7 @@ doctests:
     # type=file|default=<undefined>: Base image (opposite phase encoding direction than source image).
     blur: '[0,2]'
     # type=list|default=[]: Gaussian blur the input images by 'bb' (FWHM) voxels before doing the alignment (the output dataset will not be blurred). The default is 2.345 (for no good reason).  * Optionally, you can provide 2 values for 'bb', and then   the first one is applied to the base volume, the second   to the source volume.   e.g., '-blur 0 3' to skip blurring the base image   (if the base is a blurry template, for example). * A negative blur radius means to use 3D median filtering,   rather than Gaussian blurring.  This type of filtering will   better preserve edges, which can be important in alignment. * If the base is a template volume that is already blurry,   you probably don't want to blur it again, but blurring   the source volume a little is probably a good idea, to   help the program avoid trying to match tiny features. * Note that -duplo will blur the volumes some extra   amount for the initial small-scale warping, to make   that phase of the program converge more rapidly.  
-    out_file:
+    out_file: '"Q11"'
     # type=file|default=<undefined>: Sets the prefix/suffix for the output datasets.  * The source dataset is warped to match the base   and gets prefix 'ppp'. (Except if '-plusminus' is used * The final interpolation to this output dataset is   done using the 'wsinc5' method.  See the output of   3dAllineate -HELP   (in the "Modifying '-final wsinc5'" section) for   the lengthy technical details. * The 3D warp used is saved in a dataset with   prefix 'ppp_WARP' -- this dataset can be used   with 3dNwarpApply and 3dNwarpCat, for example. * To be clear, this is the warp from source dataset   coordinates to base dataset coordinates, where the   values at each base grid point are the xyz displacements   needed to move that grid point's xyz values to the   corresponding xyz values in the source dataset:   base( (x,y,z) + WARP(x,y,z) ) matches source(x,y,z)   Another way to think of this warp is that it 'pulls'   values back from source space to base space. * 3dNwarpApply would use 'ppp_WARP' to transform datasets   aligned with the source dataset to be aligned with the   base dataset.  **If you do NOT want this warp saved, use the option '-nowarp'**. (However, this warp is usually the most valuable possible output!)  * If you want to calculate and save the inverse 3D warp,   use the option '-iwarp'.  This inverse warp will then be   saved in a dataset with prefix 'ppp_WARPINV'. * This inverse warp could be used to transform data from base   space to source space, if you need to do such an operation. * You can easily compute the inverse later, say by a command like   3dNwarpCat -prefix Z_WARPINV 'INV(Z_WARP+tlrc)'   or the inverse can be computed as needed in 3dNwarpApply, like   3dNwarpApply -nwarp 'INV(Z_WARP+tlrc)' -source Dataset.nii ...  
     inilev: '7'
     # type=int|default=0: The initial refinement 'level' at which to start.  * Usually used with -iniwarp; CANNOT be used with -duplo. * The combination of -inilev and -iniwarp lets you take the   results of a previous 3dQwarp run and refine them further:   Note that the source dataset in the second run is the SAME as   in the first run.  If you don't see why this is necessary,   then you probably need to seek help from an AFNI guru.  
diff --git a/example-specs/task/nipype_internal/pydra-afni/qwarp_callables.py b/example-specs/task/nipype/afni/qwarp_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/qwarp_callables.py
rename to example-specs/task/nipype/afni/qwarp_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-afni/qwarp_plus_minus.yaml b/example-specs/task/nipype/afni/qwarp_plus_minus.yaml
similarity index 99%
rename from example-specs/task/nipype_internal/pydra-afni/qwarp_plus_minus.yaml
rename to example-specs/task/nipype/afni/qwarp_plus_minus.yaml
index 607d022e..3aaa2016 100644
--- a/example-specs/task/nipype_internal/pydra-afni/qwarp_plus_minus.yaml
+++ b/example-specs/task/nipype/afni/qwarp_plus_minus.yaml
@@ -41,16 +41,12 @@ inputs:
   # passed to the field in the automatically generated unittests.
     source_file: generic/file
     # type=file|default=<undefined>: Source image (opposite phase encoding direction than base image)
-    out_file: generic/file
-    # type=file|default='Qwarp.nii.gz': Output file
     in_file: medimage/nifti-gz
     # type=file|default=<undefined>: Source image (opposite phase encoding direction than base image).
     base_file: medimage/nifti-gz
     # type=file|default=<undefined>: Base image (opposite phase encoding direction than source image).
     weight: generic/file
     # type=file|default=<undefined>: Instead of computing the weight from the base dataset,directly input the weight volume from dataset 'www'.Useful if you know what over parts of the base image youwant to emphasize or de-emphasize the matching functional.
-    out_weight_file: generic/file
-    # type=file|default=<undefined>: Write the weight volume to disk as a dataset
     emask: generic/file
     # type=file|default=<undefined>: Here, 'ee' is a dataset to specify a mask of voxelsto EXCLUDE from the analysis -- all voxels in 'ee'that are NONZERO will not be used in the alignment.The base image always automasked -- the emask isextra, to indicate voxels you definitely DON'T wantincluded in the matching process, even if they areinside the brain.
     iniwarp: generic/file+list-of
@@ -70,6 +66,10 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file|default='Qwarp.nii.gz': Output file
+    out_weight_file: generic/file
+    # type=file|default=<undefined>: Write the weight volume to disk as a dataset
     warped_source: generic/file
     # type=file: Warped source file. If plusminus is used, this is the undistortedsource file.
     warped_base: generic/file
@@ -126,7 +126,7 @@ tests:
     wball:
     # type=list|default=[]: "``-wball x y z r f`` Enhance automatic weight from '-useweight' by a factor of 1+f\*Gaussian(FWHM=r) centered in the base image at DICOM coordinates (x,y,z) and with radius 'r'. The goal of this option is to try and make the alignment better in a specific part of the brain. Example:  -wball 0 14 6 30 40 to emphasize the thalamic area (in MNI/Talairach space).  * The 'r' parameter must be positive! * The 'f' parameter must be between 1 and 100 (inclusive). * '-wball' does nothing if you input your own weight   with the '-weight' option. * '-wball' does change the binary weight created by   the '-noweight' option. * You can only use '-wball' once in a run of 3dQwarp.  **The effect of '-wball' is not dramatic.** The example above makes the average brain image across a collection of subjects a little sharper in the thalamic area, which might have some small value.  If you care enough about alignment to use '-wball', then you should examine the results from 3dQwarp for each subject, to see if the alignments are good enough for your purposes.
     wmask:
-    # type=tuple|default=(<nipype.interfaces.base.traits_extension.File object at 0x11cef9410>, <traits.trait_types.Float object at 0x11cef8f10>): Similar to '-wball', but here, you provide a dataset 'ws' that indicates where to increase the weight.  * The 'ws' dataset must be on the same 3D grid as the base dataset. * 'ws' is treated as a mask -- it only matters where it   is nonzero -- otherwise, the values inside are not used. * After 'ws' comes the factor 'f' by which to increase the   automatically computed weight.  Where 'ws' is nonzero,   the weighting will be multiplied by (1+f). * As with '-wball', the factor 'f' should be between 1 and 100.  
+    # type=tuple|default=(<nipype.interfaces.base.traits_extension.File object at 0x10bdedfd0>, <traits.trait_types.Float object at 0x10bdee010>): Similar to '-wball', but here, you provide a dataset 'ws' that indicates where to increase the weight.  * The 'ws' dataset must be on the same 3D grid as the base dataset. * 'ws' is treated as a mask -- it only matters where it   is nonzero -- otherwise, the values inside are not used. * After 'ws' comes the factor 'f' by which to increase the   automatically computed weight.  Where 'ws' is nonzero,   the weighting will be multiplied by (1+f). * As with '-wball', the factor 'f' should be between 1 and 100.  
     out_weight_file:
     # type=file|default=<undefined>: Write the weight volume to disk as a dataset
     blur:
diff --git a/example-specs/task/nipype_internal/pydra-afni/qwarp_plus_minus_callables.py b/example-specs/task/nipype/afni/qwarp_plus_minus_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/qwarp_plus_minus_callables.py
rename to example-specs/task/nipype/afni/qwarp_plus_minus_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-afni/re_ho.yaml b/example-specs/task/nipype/afni/re_ho.yaml
similarity index 98%
rename from example-specs/task/nipype_internal/pydra-afni/re_ho.yaml
rename to example-specs/task/nipype/afni/re_ho.yaml
index fca91352..c9cb2b20 100644
--- a/example-specs/task/nipype_internal/pydra-afni/re_ho.yaml
+++ b/example-specs/task/nipype/afni/re_ho.yaml
@@ -39,9 +39,6 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/nifti1
     # type=file|default=<undefined>: input dataset
-    out_file: medimage/nifti-gz
-    # type=file: Voxelwise regional homogeneity map
-    # type=file|default=<undefined>: Output dataset.
     mask_file: generic/file
     # type=file|default=<undefined>: Mask within which ReHo should be calculated voxelwise
     label_set: generic/file
@@ -118,7 +115,7 @@ tests:
   # (if not specified, will try to choose a sensible value)
     in_file:
     # type=file|default=<undefined>: input dataset
-    out_file:
+    out_file: '"reho.nii.gz"'
     # type=file: Voxelwise regional homogeneity map
     # type=file|default=<undefined>: Output dataset.
     neighborhood: '"vertices"'
@@ -147,7 +144,7 @@ doctests:
   # '.mock()' method of the corresponding class is used instead.
     in_file:
     # type=file|default=<undefined>: input dataset
-    out_file:
+    out_file: '"reho.nii.gz"'
     # type=file: Voxelwise regional homogeneity map
     # type=file|default=<undefined>: Output dataset.
     neighborhood: '"vertices"'
diff --git a/example-specs/task/nipype_internal/pydra-afni/re_ho_callables.py b/example-specs/task/nipype/afni/re_ho_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/re_ho_callables.py
rename to example-specs/task/nipype/afni/re_ho_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-afni/refit.yaml b/example-specs/task/nipype/afni/refit.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/refit.yaml
rename to example-specs/task/nipype/afni/refit.yaml
diff --git a/example-specs/task/nipype_internal/pydra-afni/refit_callables.py b/example-specs/task/nipype/afni/refit_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/refit_callables.py
rename to example-specs/task/nipype/afni/refit_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-afni/remlfit.yaml b/example-specs/task/nipype/afni/remlfit.yaml
similarity index 96%
rename from example-specs/task/nipype_internal/pydra-afni/remlfit.yaml
rename to example-specs/task/nipype/afni/remlfit.yaml
index a3a9f842..dd13e72c 100644
--- a/example-specs/task/nipype_internal/pydra-afni/remlfit.yaml
+++ b/example-specs/task/nipype/afni/remlfit.yaml
@@ -57,14 +57,11 @@ inputs:
     # type=inputmultiobject|default=[]: similar to 'slibase', BUT each file much be in slice major order (i.e. all slice0 columns come first, then all slice1 columns, etc).
     dsort: generic/file
     # type=file|default=<undefined>: 4D dataset to be used as voxelwise baseline regressor
-    out_file: medimage/nifti1
-    # type=file: dataset for beta + statistics from the REML estimation (if generated)
-    # type=file|default=<undefined>: output dataset for beta + statistics from the REML estimation; also contains the results of any GLT analysis requested in the Deconvolve setup, similar to the 'bucket' output from Deconvolve. This dataset does NOT get the betas (or statistics) of those regressors marked as 'baseline' in the matrix file.
     var_file: generic/file
     # type=file: dataset for REML variance parameters (if generated)
     # type=file|default=<undefined>: output dataset for REML variance parameters
     rbeta_file: generic/file
-    # type=file: output dataset for beta weights from the REML estimation (if generated)
+    # type=file: output dataset for beta weights from the REML estimation (if generated
     # type=file|default=<undefined>: output dataset for beta weights from the REML estimation, similar to the 'cbucket' output from Deconvolve. This dataset will contain all the beta weights, for baseline and stimulus regressors alike, unless the '-nobout' option is given -- in that case, this dataset will only get the betas for the stimulus regressors.
     glt_file: generic/file
     # type=file: output dataset for beta + statistics from the REML estimation, but ONLY for the GLTs added on the REMLfit command line itself via 'gltsym' (if generated)
@@ -73,7 +70,7 @@ inputs:
     # type=file: output dataset for REML fitted model (if generated)
     # type=file|default=<undefined>: output dataset for REML fitted model
     errts_file: generic/file
-    # type=file: output dataset for REML residuals = data - fitted model (if generated)
+    # type=file: output dataset for REML residuals = data - fitted model (if generated
     # type=file|default=<undefined>: output dataset for REML residuals = data - fitted model
     wherr_file: generic/file
     # type=file: dataset for REML residual, whitened using the estimated ARMA(1,1) correlation matrix of the noise (if generated)
@@ -88,13 +85,13 @@ inputs:
     # type=file: dataset for beta + statistics from the OLSQ estimation (if generated)
     # type=file|default=<undefined>: dataset for beta + statistics from the OLSQ estimation
     oglt: generic/file
-    # type=file: dataset for beta + statistics from 'gltsym' options (if generated)
+    # type=file: dataset for beta + statistics from 'gltsym' options (if generated
     # type=file|default=<undefined>: dataset for beta + statistics from 'gltsym' options
     ofitts: generic/file
     # type=file: dataset for OLSQ fitted model (if generated)
     # type=file|default=<undefined>: dataset for OLSQ fitted model
     oerrts: generic/file
-    # type=file: dataset for OLSQ residuals = data - fitted model (if generated)
+    # type=file: dataset for OLSQ residuals = data - fitted model (if generated
     # type=file|default=<undefined>: dataset for OLSQ residuals (data - fitted model)
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
@@ -110,13 +107,13 @@ outputs:
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
     out_file: medimage/nifti1
-    # type=file: dataset for beta + statistics from the REML estimation (if generated)
+    # type=file: dataset for beta + statistics from the REML estimation (if generated
     # type=file|default=<undefined>: output dataset for beta + statistics from the REML estimation; also contains the results of any GLT analysis requested in the Deconvolve setup, similar to the 'bucket' output from Deconvolve. This dataset does NOT get the betas (or statistics) of those regressors marked as 'baseline' in the matrix file.
     var_file: generic/file
     # type=file: dataset for REML variance parameters (if generated)
     # type=file|default=<undefined>: output dataset for REML variance parameters
     rbeta_file: generic/file
-    # type=file: output dataset for beta weights from the REML estimation (if generated)
+    # type=file: output dataset for beta weights from the REML estimation (if generated
     # type=file|default=<undefined>: output dataset for beta weights from the REML estimation, similar to the 'cbucket' output from Deconvolve. This dataset will contain all the beta weights, for baseline and stimulus regressors alike, unless the '-nobout' option is given -- in that case, this dataset will only get the betas for the stimulus regressors.
     glt_file: generic/file
     # type=file: output dataset for beta + statistics from the REML estimation, but ONLY for the GLTs added on the REMLfit command line itself via 'gltsym' (if generated)
@@ -125,7 +122,7 @@ outputs:
     # type=file: output dataset for REML fitted model (if generated)
     # type=file|default=<undefined>: output dataset for REML fitted model
     errts_file: generic/file
-    # type=file: output dataset for REML residuals = data - fitted model (if generated)
+    # type=file: output dataset for REML residuals = data - fitted model (if generated
     # type=file|default=<undefined>: output dataset for REML residuals = data - fitted model
     wherr_file: generic/file
     # type=file: dataset for REML residual, whitened using the estimated ARMA(1,1) correlation matrix of the noise (if generated)
@@ -140,13 +137,13 @@ outputs:
     # type=file: dataset for beta + statistics from the OLSQ estimation (if generated)
     # type=file|default=<undefined>: dataset for beta + statistics from the OLSQ estimation
     oglt: generic/file
-    # type=file: dataset for beta + statistics from 'gltsym' options (if generated)
+    # type=file: dataset for beta + statistics from 'gltsym' options (if generated
     # type=file|default=<undefined>: dataset for beta + statistics from 'gltsym' options
     ofitts: generic/file
     # type=file: dataset for OLSQ fitted model (if generated)
     # type=file|default=<undefined>: dataset for OLSQ fitted model
     oerrts: generic/file
-    # type=file: dataset for OLSQ residuals = data - fitted model (if generated)
+    # type=file: dataset for OLSQ residuals = data - fitted model (if generated
     # type=file|default=<undefined>: dataset for OLSQ residuals (data - fitted model)
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
@@ -200,13 +197,13 @@ tests:
     gltsym:
     # type=list|default=[]: read a symbolic GLT from input file and associate it with a label. As in Deconvolve, you can also use the 'SYM:' method to provide the definition of the GLT directly as a string (e.g., with 'SYM: +Label1 -Label2'). Unlike Deconvolve, you MUST specify 'SYM: ' if providing the GLT directly as a string instead of from a file
     out_file:
-    # type=file: dataset for beta + statistics from the REML estimation (if generated)
+    # type=file: dataset for beta + statistics from the REML estimation (if generated
     # type=file|default=<undefined>: output dataset for beta + statistics from the REML estimation; also contains the results of any GLT analysis requested in the Deconvolve setup, similar to the 'bucket' output from Deconvolve. This dataset does NOT get the betas (or statistics) of those regressors marked as 'baseline' in the matrix file.
     var_file:
     # type=file: dataset for REML variance parameters (if generated)
     # type=file|default=<undefined>: output dataset for REML variance parameters
     rbeta_file:
-    # type=file: output dataset for beta weights from the REML estimation (if generated)
+    # type=file: output dataset for beta weights from the REML estimation (if generated
     # type=file|default=<undefined>: output dataset for beta weights from the REML estimation, similar to the 'cbucket' output from Deconvolve. This dataset will contain all the beta weights, for baseline and stimulus regressors alike, unless the '-nobout' option is given -- in that case, this dataset will only get the betas for the stimulus regressors.
     glt_file:
     # type=file: output dataset for beta + statistics from the REML estimation, but ONLY for the GLTs added on the REMLfit command line itself via 'gltsym' (if generated)
@@ -215,7 +212,7 @@ tests:
     # type=file: output dataset for REML fitted model (if generated)
     # type=file|default=<undefined>: output dataset for REML fitted model
     errts_file:
-    # type=file: output dataset for REML residuals = data - fitted model (if generated)
+    # type=file: output dataset for REML residuals = data - fitted model (if generated
     # type=file|default=<undefined>: output dataset for REML residuals = data - fitted model
     wherr_file:
     # type=file: dataset for REML residual, whitened using the estimated ARMA(1,1) correlation matrix of the noise (if generated)
@@ -236,13 +233,13 @@ tests:
     # type=file: dataset for beta + statistics from the OLSQ estimation (if generated)
     # type=file|default=<undefined>: dataset for beta + statistics from the OLSQ estimation
     oglt:
-    # type=file: dataset for beta + statistics from 'gltsym' options (if generated)
+    # type=file: dataset for beta + statistics from 'gltsym' options (if generated
     # type=file|default=<undefined>: dataset for beta + statistics from 'gltsym' options
     ofitts:
     # type=file: dataset for OLSQ fitted model (if generated)
     # type=file|default=<undefined>: dataset for OLSQ fitted model
     oerrts:
-    # type=file: dataset for OLSQ residuals = data - fitted model (if generated)
+    # type=file: dataset for OLSQ residuals = data - fitted model (if generated
     # type=file|default=<undefined>: dataset for OLSQ residuals (data - fitted model)
     num_threads:
     # type=int|default=1: set number of threads
@@ -272,8 +269,8 @@ tests:
   # (if not specified, will try to choose a sensible value)
     in_files:
     # type=inputmultiobject|default=[]: Read time series dataset
-    out_file:
-    # type=file: dataset for beta + statistics from the REML estimation (if generated)
+    out_file: '"output.nii"'
+    # type=file: dataset for beta + statistics from the REML estimation (if generated
     # type=file|default=<undefined>: output dataset for beta + statistics from the REML estimation; also contains the results of any GLT analysis requested in the Deconvolve setup, similar to the 'bucket' output from Deconvolve. This dataset does NOT get the betas (or statistics) of those regressors marked as 'baseline' in the matrix file.
     matrix:
     # type=file|default=<undefined>: the design matrix file, which should have been output from Deconvolve via the 'x1D' option
@@ -303,8 +300,8 @@ doctests:
   # '.mock()' method of the corresponding class is used instead.
     in_files:
     # type=inputmultiobject|default=[]: Read time series dataset
-    out_file:
-    # type=file: dataset for beta + statistics from the REML estimation (if generated)
+    out_file: '"output.nii"'
+    # type=file: dataset for beta + statistics from the REML estimation (if generated
     # type=file|default=<undefined>: output dataset for beta + statistics from the REML estimation; also contains the results of any GLT analysis requested in the Deconvolve setup, similar to the 'bucket' output from Deconvolve. This dataset does NOT get the betas (or statistics) of those regressors marked as 'baseline' in the matrix file.
     matrix:
     # type=file|default=<undefined>: the design matrix file, which should have been output from Deconvolve via the 'x1D' option
diff --git a/example-specs/task/nipype_internal/pydra-afni/remlfit_callables.py b/example-specs/task/nipype/afni/remlfit_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/remlfit_callables.py
rename to example-specs/task/nipype/afni/remlfit_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-afni/resample.yaml b/example-specs/task/nipype/afni/resample.yaml
similarity index 98%
rename from example-specs/task/nipype_internal/pydra-afni/resample.yaml
rename to example-specs/task/nipype/afni/resample.yaml
index 45c8688d..c7b08452 100644
--- a/example-specs/task/nipype_internal/pydra-afni/resample.yaml
+++ b/example-specs/task/nipype/afni/resample.yaml
@@ -38,9 +38,6 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/nifti1
     # type=file|default=<undefined>: input file to 3dresample
-    out_file: generic/file
-    # type=file: output file
-    # type=file|default=<undefined>: output image file name
     master: generic/file
     # type=file|default=<undefined>: align dataset grid to a reference file
   metadata:
diff --git a/example-specs/task/nipype_internal/pydra-afni/resample_callables.py b/example-specs/task/nipype/afni/resample_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/resample_callables.py
rename to example-specs/task/nipype/afni/resample_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-afni/retroicor.yaml b/example-specs/task/nipype/afni/retroicor.yaml
similarity index 98%
rename from example-specs/task/nipype_internal/pydra-afni/retroicor.yaml
rename to example-specs/task/nipype/afni/retroicor.yaml
index 40299a22..f99b9451 100644
--- a/example-specs/task/nipype_internal/pydra-afni/retroicor.yaml
+++ b/example-specs/task/nipype/afni/retroicor.yaml
@@ -54,9 +54,6 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/nifti1
     # type=file|default=<undefined>: input file to 3dretroicor
-    out_file: generic/file
-    # type=file: output file
-    # type=file|default=<undefined>: output image file name
     card: medimage-afni/oned
     # type=file|default=<undefined>: 1D cardiac data file for cardiac correction
     resp: medimage-afni/oned
diff --git a/example-specs/task/nipype_internal/pydra-afni/retroicor_callables.py b/example-specs/task/nipype/afni/retroicor_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/retroicor_callables.py
rename to example-specs/task/nipype/afni/retroicor_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-afni/roi_stats.yaml b/example-specs/task/nipype/afni/roi_stats.yaml
similarity index 98%
rename from example-specs/task/nipype_internal/pydra-afni/roi_stats.yaml
rename to example-specs/task/nipype/afni/roi_stats.yaml
index 1d9750a5..81426286 100644
--- a/example-specs/task/nipype_internal/pydra-afni/roi_stats.yaml
+++ b/example-specs/task/nipype/afni/roi_stats.yaml
@@ -45,9 +45,6 @@ inputs:
     # type=file|default=<undefined>: input mask
     roisel: generic/file
     # type=file|default=<undefined>: Only considers ROIs denoted by values found in the specified file. Note that the order of the ROIs as specified in the file is not preserved. So an SEL.1D of '2 8 20' produces the same output as '8 20 2'
-    out_file: generic/file
-    # type=file: output tab-separated values file
-    # type=file|default=<undefined>: output file
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype_internal/pydra-afni/roi_stats_callables.py b/example-specs/task/nipype/afni/roi_stats_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/roi_stats_callables.py
rename to example-specs/task/nipype/afni/roi_stats_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-afni/seg.yaml b/example-specs/task/nipype/afni/seg.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/seg.yaml
rename to example-specs/task/nipype/afni/seg.yaml
diff --git a/example-specs/task/nipype_internal/pydra-afni/seg_callables.py b/example-specs/task/nipype/afni/seg_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/seg_callables.py
rename to example-specs/task/nipype/afni/seg_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-afni/skull_strip.yaml b/example-specs/task/nipype/afni/skull_strip.yaml
similarity index 98%
rename from example-specs/task/nipype_internal/pydra-afni/skull_strip.yaml
rename to example-specs/task/nipype/afni/skull_strip.yaml
index 5a0de4ab..01320162 100644
--- a/example-specs/task/nipype_internal/pydra-afni/skull_strip.yaml
+++ b/example-specs/task/nipype/afni/skull_strip.yaml
@@ -39,9 +39,6 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/nifti1
     # type=file|default=<undefined>: input file to 3dSkullStrip
-    out_file: generic/file
-    # type=file: output file
-    # type=file|default=<undefined>: output image file name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype_internal/pydra-afni/skull_strip_callables.py b/example-specs/task/nipype/afni/skull_strip_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/skull_strip_callables.py
rename to example-specs/task/nipype/afni/skull_strip_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-afni/svm_test.yaml b/example-specs/task/nipype/afni/svm_test.yaml
similarity index 97%
rename from example-specs/task/nipype_internal/pydra-afni/svm_test.yaml
rename to example-specs/task/nipype/afni/svm_test.yaml
index 137a78ea..805948d3 100644
--- a/example-specs/task/nipype_internal/pydra-afni/svm_test.yaml
+++ b/example-specs/task/nipype/afni/svm_test.yaml
@@ -38,9 +38,6 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: generic/file
     # type=file|default=<undefined>: A 3D or 3D+t AFNI brik dataset to be used for testing.
-    out_file: generic/file
-    # type=file: output file
-    # type=file|default=<undefined>: filename for .1D prediction file(s).
     testlabels: generic/file
     # type=file|default=<undefined>: *true* class category .1D labels for the test dataset. It is used to calculate the prediction accuracy performance
   metadata:
diff --git a/example-specs/task/nipype_internal/pydra-afni/svm_test_callables.py b/example-specs/task/nipype/afni/svm_test_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/svm_test_callables.py
rename to example-specs/task/nipype/afni/svm_test_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-afni/svm_train.yaml b/example-specs/task/nipype/afni/svm_train.yaml
similarity index 97%
rename from example-specs/task/nipype_internal/pydra-afni/svm_train.yaml
rename to example-specs/task/nipype/afni/svm_train.yaml
index 316006f5..5dc2c05e 100644
--- a/example-specs/task/nipype_internal/pydra-afni/svm_train.yaml
+++ b/example-specs/task/nipype/afni/svm_train.yaml
@@ -40,9 +40,6 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: generic/file
     # type=file|default=<undefined>: A 3D+t AFNI brik dataset to be used for training.
-    out_file: generic/file
-    # type=file: sum of weighted linear support vectors file name
-    # type=file|default=<undefined>: output sum of weighted linear support vectors file name
     model: generic/file
     # type=file: brik containing the SVM model file name
     # type=file|default=<undefined>: basename for the brik containing the SVM model
diff --git a/example-specs/task/nipype_internal/pydra-afni/svm_train_callables.py b/example-specs/task/nipype/afni/svm_train_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/svm_train_callables.py
rename to example-specs/task/nipype/afni/svm_train_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-afni/synthesize.yaml b/example-specs/task/nipype/afni/synthesize.yaml
similarity index 98%
rename from example-specs/task/nipype_internal/pydra-afni/synthesize.yaml
rename to example-specs/task/nipype/afni/synthesize.yaml
index 7bcb1446..4070e5a0 100644
--- a/example-specs/task/nipype_internal/pydra-afni/synthesize.yaml
+++ b/example-specs/task/nipype/afni/synthesize.yaml
@@ -42,9 +42,6 @@ inputs:
     # type=file|default=<undefined>: Read the dataset output from 3dDeconvolve via the '-cbucket' option.
     matrix: medimage-afni/oned
     # type=file|default=<undefined>: Read the matrix output from 3dDeconvolve via the '-x1D' option.
-    out_file: generic/file
-    # type=file: output file
-    # type=file|default=<undefined>: output dataset prefix name (default 'syn')
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype_internal/pydra-afni/synthesize_callables.py b/example-specs/task/nipype/afni/synthesize_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/synthesize_callables.py
rename to example-specs/task/nipype/afni/synthesize_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-afni/t_cat.yaml b/example-specs/task/nipype/afni/t_cat.yaml
similarity index 98%
rename from example-specs/task/nipype_internal/pydra-afni/t_cat.yaml
rename to example-specs/task/nipype/afni/t_cat.yaml
index 099585aa..afd93371 100644
--- a/example-specs/task/nipype_internal/pydra-afni/t_cat.yaml
+++ b/example-specs/task/nipype/afni/t_cat.yaml
@@ -41,9 +41,6 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_files: medimage/nifti1+list-of
     # type=inputmultiobject|default=[]: input file to 3dTcat
-    out_file: medimage/nifti1
-    # type=file: output file
-    # type=file|default=<undefined>: output image file name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -108,7 +105,7 @@ tests:
   # (if not specified, will try to choose a sensible value)
     in_files:
     # type=inputmultiobject|default=[]: input file to 3dTcat
-    out_file:
+    out_file: '"functional_tcat.nii"'
     # type=file: output file
     # type=file|default=<undefined>: output image file name
     rlt: '"+"'
@@ -137,7 +134,7 @@ doctests:
   # '.mock()' method of the corresponding class is used instead.
     in_files:
     # type=inputmultiobject|default=[]: input file to 3dTcat
-    out_file:
+    out_file: '"functional_tcat.nii"'
     # type=file: output file
     # type=file|default=<undefined>: output image file name
     rlt: '"+"'
diff --git a/example-specs/task/nipype_internal/pydra-afni/t_cat_callables.py b/example-specs/task/nipype/afni/t_cat_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/t_cat_callables.py
rename to example-specs/task/nipype/afni/t_cat_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-afni/t_cat_sub_brick.yaml b/example-specs/task/nipype/afni/t_cat_sub_brick.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/t_cat_sub_brick.yaml
rename to example-specs/task/nipype/afni/t_cat_sub_brick.yaml
diff --git a/example-specs/task/nipype_internal/pydra-afni/t_cat_sub_brick_callables.py b/example-specs/task/nipype/afni/t_cat_sub_brick_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/t_cat_sub_brick_callables.py
rename to example-specs/task/nipype/afni/t_cat_sub_brick_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-afni/t_corr_1d.yaml b/example-specs/task/nipype/afni/t_corr_1d.yaml
similarity index 97%
rename from example-specs/task/nipype_internal/pydra-afni/t_corr_1d.yaml
rename to example-specs/task/nipype/afni/t_corr_1d.yaml
index cd1c3ac8..05b028e2 100644
--- a/example-specs/task/nipype_internal/pydra-afni/t_corr_1d.yaml
+++ b/example-specs/task/nipype/afni/t_corr_1d.yaml
@@ -38,9 +38,6 @@ inputs:
     # type=file|default=<undefined>: 3d+time dataset input
     y_1d: medimage-afni/oned
     # type=file|default=<undefined>: 1D time series file input
-    out_file: generic/file
-    # type=file: output file containing correlations
-    # type=file|default=<undefined>: output filename prefix
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype_internal/pydra-afni/t_corr_1d_callables.py b/example-specs/task/nipype/afni/t_corr_1d_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/t_corr_1d_callables.py
rename to example-specs/task/nipype/afni/t_corr_1d_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-afni/t_corr_map.yaml b/example-specs/task/nipype/afni/t_corr_map.yaml
similarity index 99%
rename from example-specs/task/nipype_internal/pydra-afni/t_corr_map.yaml
rename to example-specs/task/nipype/afni/t_corr_map.yaml
index 97b52b12..e7694234 100644
--- a/example-specs/task/nipype_internal/pydra-afni/t_corr_map.yaml
+++ b/example-specs/task/nipype/afni/t_corr_map.yaml
@@ -44,8 +44,6 @@ inputs:
     # type=file|default=<undefined>: 
     mask: medimage/nifti1
     # type=file|default=<undefined>: 
-    regress_out_timeseries: generic/file
-    # type=file|default=<undefined>: 
     mean_file: generic/file
     # type=file: 
     # type=file|default=<undefined>: 
@@ -85,8 +83,6 @@ inputs:
     histogram: generic/file
     # type=file: 
     # type=file|default=<undefined>: 
-    out_file: generic/file
-    # type=file|default=<undefined>: output image file name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -100,6 +96,10 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    regress_out_timeseries: generic/file
+    # type=file|default=<undefined>: 
+    out_file: generic/file
+    # type=file|default=<undefined>: output image file name
     mean_file: generic/file
     # type=file: 
     # type=file|default=<undefined>: 
@@ -161,7 +161,7 @@ tests:
     polort:
     # type=int|default=0: 
     bandpass:
-    # type=tuple|default=(<traits.trait_types.Float object at 0x11cede190>, <traits.trait_types.Float object at 0x11cede550>): 
+    # type=tuple|default=(<traits.trait_types.Float object at 0x10bdcf490>, <traits.trait_types.Float object at 0x10bdcf650>): 
     regress_out_timeseries:
     # type=file|default=<undefined>: 
     blur_fwhm:
diff --git a/example-specs/task/nipype_internal/pydra-afni/t_corr_map_callables.py b/example-specs/task/nipype/afni/t_corr_map_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/t_corr_map_callables.py
rename to example-specs/task/nipype/afni/t_corr_map_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-afni/t_correlate.yaml b/example-specs/task/nipype/afni/t_correlate.yaml
similarity index 98%
rename from example-specs/task/nipype_internal/pydra-afni/t_correlate.yaml
rename to example-specs/task/nipype/afni/t_correlate.yaml
index 02048c01..4a3b7b60 100644
--- a/example-specs/task/nipype_internal/pydra-afni/t_correlate.yaml
+++ b/example-specs/task/nipype/afni/t_correlate.yaml
@@ -43,9 +43,6 @@ inputs:
     # type=file|default=<undefined>: input xset
     yset: medimage/nifti1
     # type=file|default=<undefined>: input yset
-    out_file: medimage/nifti-gz
-    # type=file: output file
-    # type=file|default=<undefined>: output image file name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -114,7 +111,7 @@ tests:
     # type=file|default=<undefined>: input xset
     yset:
     # type=file|default=<undefined>: input yset
-    out_file:
+    out_file: '"functional_tcorrelate.nii.gz"'
     # type=file: output file
     # type=file|default=<undefined>: output image file name
     polort: '-1'
@@ -147,7 +144,7 @@ doctests:
     # type=file|default=<undefined>: input xset
     yset:
     # type=file|default=<undefined>: input yset
-    out_file:
+    out_file: '"functional_tcorrelate.nii.gz"'
     # type=file: output file
     # type=file|default=<undefined>: output image file name
     polort: '-1'
diff --git a/example-specs/task/nipype_internal/pydra-afni/t_correlate_callables.py b/example-specs/task/nipype/afni/t_correlate_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/t_correlate_callables.py
rename to example-specs/task/nipype/afni/t_correlate_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-afni/t_norm.yaml b/example-specs/task/nipype/afni/t_norm.yaml
similarity index 98%
rename from example-specs/task/nipype_internal/pydra-afni/t_norm.yaml
rename to example-specs/task/nipype/afni/t_norm.yaml
index 5235bffb..2d6ea9ff 100644
--- a/example-specs/task/nipype_internal/pydra-afni/t_norm.yaml
+++ b/example-specs/task/nipype/afni/t_norm.yaml
@@ -39,9 +39,6 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/nifti1
     # type=file|default=<undefined>: input file to 3dTNorm
-    out_file: generic/file
-    # type=file: output file
-    # type=file|default=<undefined>: output image file name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -116,7 +113,7 @@ tests:
     # type=file|default=<undefined>: input file to 3dTNorm
     norm2: 'True'
     # type=bool|default=False: L2 normalize (sum of squares = 1) [DEFAULT]
-    out_file:
+    out_file: '"rm.errts.unit errts+tlrc"'
     # type=file: output file
     # type=file|default=<undefined>: output image file name
   imports:
@@ -145,7 +142,7 @@ doctests:
     # type=file|default=<undefined>: input file to 3dTNorm
     norm2: 'True'
     # type=bool|default=False: L2 normalize (sum of squares = 1) [DEFAULT]
-    out_file:
+    out_file: '"rm.errts.unit errts+tlrc"'
     # type=file: output file
     # type=file|default=<undefined>: output image file name
   imports:
diff --git a/example-specs/task/nipype_internal/pydra-afni/t_norm_callables.py b/example-specs/task/nipype/afni/t_norm_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/t_norm_callables.py
rename to example-specs/task/nipype/afni/t_norm_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-afni/t_project.yaml b/example-specs/task/nipype/afni/t_project.yaml
similarity index 98%
rename from example-specs/task/nipype_internal/pydra-afni/t_project.yaml
rename to example-specs/task/nipype/afni/t_project.yaml
index 914b1867..b285cee3 100644
--- a/example-specs/task/nipype_internal/pydra-afni/t_project.yaml
+++ b/example-specs/task/nipype/afni/t_project.yaml
@@ -50,9 +50,6 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/nifti1
     # type=file|default=<undefined>: input file to 3dTproject
-    out_file: medimage/nifti-gz
-    # type=file: output file
-    # type=file|default=<undefined>: output image file name
     censor: generic/file
     # type=file|default=<undefined>: Filename of censor .1D time series. This is a file of 1s and 0s, indicating which time points are to be included (1) and which are to be excluded (0).
     concat: generic/file
@@ -159,7 +156,7 @@ tests:
     # type=int|default=0: Remove polynomials up to and including degree pp.  * Default value is 2. * It makes no sense to use a value of pp greater than   2, if you are bandpassing out the lower frequencies! * For catenated datasets, each run gets a separate set   set of pp+1 Legendre polynomial regressors. * Use of -polort -1 is not advised (if data mean != 0),   even if -ort contains constant terms, as all means are   removed.  
     automask: 'True'
     # type=bool|default=False: Generate a mask automatically
-    out_file:
+    out_file: '"projected.nii.gz"'
     # type=file: output file
     # type=file|default=<undefined>: output image file name
   imports:
@@ -192,7 +189,7 @@ doctests:
     # type=int|default=0: Remove polynomials up to and including degree pp.  * Default value is 2. * It makes no sense to use a value of pp greater than   2, if you are bandpassing out the lower frequencies! * For catenated datasets, each run gets a separate set   set of pp+1 Legendre polynomial regressors. * Use of -polort -1 is not advised (if data mean != 0),   even if -ort contains constant terms, as all means are   removed.  
     automask: 'True'
     # type=bool|default=False: Generate a mask automatically
-    out_file:
+    out_file: '"projected.nii.gz"'
     # type=file: output file
     # type=file|default=<undefined>: output image file name
   imports:
diff --git a/example-specs/task/nipype_internal/pydra-afni/t_project_callables.py b/example-specs/task/nipype/afni/t_project_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/t_project_callables.py
rename to example-specs/task/nipype/afni/t_project_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-afni/t_shift.yaml b/example-specs/task/nipype/afni/t_shift.yaml
similarity index 99%
rename from example-specs/task/nipype_internal/pydra-afni/t_shift.yaml
rename to example-specs/task/nipype/afni/t_shift.yaml
index 770d92da..4f0a412e 100644
--- a/example-specs/task/nipype_internal/pydra-afni/t_shift.yaml
+++ b/example-specs/task/nipype/afni/t_shift.yaml
@@ -109,9 +109,6 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/nifti1
     # type=file|default=<undefined>: input file to 3dTshift
-    out_file: generic/file
-    # type=file: output file
-    # type=file|default=<undefined>: output image file name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -125,11 +122,11 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    timing_file: generic/file
-    # type=file: AFNI formatted timing file, if ``slice_timing`` is a list
     out_file: generic/file
     # type=file: output file
     # type=file|default=<undefined>: output image file name
+    timing_file: generic/file
+    # type=file: AFNI formatted timing file, if ``slice_timing`` is a list
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype_internal/pydra-afni/t_shift_callables.py b/example-specs/task/nipype/afni/t_shift_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/t_shift_callables.py
rename to example-specs/task/nipype/afni/t_shift_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-afni/t_smooth.yaml b/example-specs/task/nipype/afni/t_smooth.yaml
similarity index 98%
rename from example-specs/task/nipype_internal/pydra-afni/t_smooth.yaml
rename to example-specs/task/nipype/afni/t_smooth.yaml
index bb08492e..5d5ad8d8 100644
--- a/example-specs/task/nipype_internal/pydra-afni/t_smooth.yaml
+++ b/example-specs/task/nipype/afni/t_smooth.yaml
@@ -39,9 +39,6 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/nifti1
     # type=file|default=<undefined>: input file to 3dTSmooth
-    out_file: generic/file
-    # type=file: output file
-    # type=file|default=<undefined>: output file from 3dTSmooth
     custom: generic/file
     # type=file|default=<undefined>: odd # of coefficients must be in a single column in ASCII file
   metadata:
diff --git a/example-specs/task/nipype_internal/pydra-afni/t_smooth_callables.py b/example-specs/task/nipype/afni/t_smooth_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/t_smooth_callables.py
rename to example-specs/task/nipype/afni/t_smooth_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-afni/t_stat.yaml b/example-specs/task/nipype/afni/t_stat.yaml
similarity index 97%
rename from example-specs/task/nipype_internal/pydra-afni/t_stat.yaml
rename to example-specs/task/nipype/afni/t_stat.yaml
index 37792a7a..4d0175d7 100644
--- a/example-specs/task/nipype_internal/pydra-afni/t_stat.yaml
+++ b/example-specs/task/nipype/afni/t_stat.yaml
@@ -38,9 +38,6 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/nifti1
     # type=file|default=<undefined>: input file to 3dTstat
-    out_file: generic/file
-    # type=file: output file
-    # type=file|default=<undefined>: output image file name
     mask: generic/file
     # type=file|default=<undefined>: mask file
   metadata:
@@ -109,7 +106,7 @@ tests:
     # type=file|default=<undefined>: input file to 3dTstat
     args: '"-mean"'
     # type=str|default='': Additional parameters to the command
-    out_file:
+    out_file: '"stats"'
     # type=file: output file
     # type=file|default=<undefined>: output image file name
   imports:
@@ -138,7 +135,7 @@ doctests:
     # type=file|default=<undefined>: input file to 3dTstat
     args: '"-mean"'
     # type=str|default='': Additional parameters to the command
-    out_file:
+    out_file: '"stats"'
     # type=file: output file
     # type=file|default=<undefined>: output image file name
   imports:
diff --git a/example-specs/task/nipype_internal/pydra-afni/t_stat_callables.py b/example-specs/task/nipype/afni/t_stat_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/t_stat_callables.py
rename to example-specs/task/nipype/afni/t_stat_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-afni/to_3d.yaml b/example-specs/task/nipype/afni/to_3d.yaml
similarity index 98%
rename from example-specs/task/nipype_internal/pydra-afni/to_3d.yaml
rename to example-specs/task/nipype/afni/to_3d.yaml
index ce14d135..886a9899 100644
--- a/example-specs/task/nipype_internal/pydra-afni/to_3d.yaml
+++ b/example-specs/task/nipype/afni/to_3d.yaml
@@ -37,9 +37,6 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    out_file: medimage/nifti1
-    # type=file: output file
-    # type=file|default=<undefined>: output image file name
     in_folder: generic/directory
     # type=directory|default=<undefined>: folder with DICOM images to convert
   metadata:
@@ -114,7 +111,7 @@ tests:
     # type=enum|default='short'|allowed['byte','complex','float','short']: set output file datatype
     in_folder: '"."'
     # type=directory|default=<undefined>: folder with DICOM images to convert
-    out_file:
+    out_file: '"dicomdir.nii"'
     # type=file: output file
     # type=file|default=<undefined>: output image file name
     filetype: '"anat"'
@@ -145,7 +142,7 @@ doctests:
     # type=enum|default='short'|allowed['byte','complex','float','short']: set output file datatype
     in_folder: '"."'
     # type=directory|default=<undefined>: folder with DICOM images to convert
-    out_file:
+    out_file: '"dicomdir.nii"'
     # type=file: output file
     # type=file|default=<undefined>: output image file name
     filetype: '"anat"'
diff --git a/example-specs/task/nipype_internal/pydra-afni/to_3d_callables.py b/example-specs/task/nipype/afni/to_3d_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/to_3d_callables.py
rename to example-specs/task/nipype/afni/to_3d_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-afni/undump.yaml b/example-specs/task/nipype/afni/undump.yaml
similarity index 98%
rename from example-specs/task/nipype_internal/pydra-afni/undump.yaml
rename to example-specs/task/nipype/afni/undump.yaml
index d6e13819..f8cdd960 100644
--- a/example-specs/task/nipype_internal/pydra-afni/undump.yaml
+++ b/example-specs/task/nipype/afni/undump.yaml
@@ -55,9 +55,6 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/nifti1
     # type=file|default=<undefined>: input file to 3dUndump, whose geometry will determinethe geometry of the output
-    out_file: medimage/nifti1
-    # type=file: assembled file
-    # type=file|default=<undefined>: output image file name
     mask_file: generic/file
     # type=file|default=<undefined>: mask image file name. Only voxels that are nonzero in the mask can be set.
   metadata:
@@ -136,7 +133,7 @@ tests:
   # (if not specified, will try to choose a sensible value)
     in_file:
     # type=file|default=<undefined>: input file to 3dUndump, whose geometry will determinethe geometry of the output
-    out_file:
+    out_file: '"structural_undumped.nii"'
     # type=file: assembled file
     # type=file|default=<undefined>: output image file name
   imports:
@@ -163,7 +160,7 @@ doctests:
   # '.mock()' method of the corresponding class is used instead.
     in_file:
     # type=file|default=<undefined>: input file to 3dUndump, whose geometry will determinethe geometry of the output
-    out_file:
+    out_file: '"structural_undumped.nii"'
     # type=file: assembled file
     # type=file|default=<undefined>: output image file name
   imports:
diff --git a/example-specs/task/nipype_internal/pydra-afni/undump_callables.py b/example-specs/task/nipype/afni/undump_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/undump_callables.py
rename to example-specs/task/nipype/afni/undump_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-afni/unifize.yaml b/example-specs/task/nipype/afni/unifize.yaml
similarity index 98%
rename from example-specs/task/nipype_internal/pydra-afni/unifize.yaml
rename to example-specs/task/nipype/afni/unifize.yaml
index afe444b7..c6f442d8 100644
--- a/example-specs/task/nipype_internal/pydra-afni/unifize.yaml
+++ b/example-specs/task/nipype/afni/unifize.yaml
@@ -62,9 +62,6 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/nifti1
     # type=file|default=<undefined>: input file to 3dUnifize
-    out_file: medimage/nifti1
-    # type=file: unifized file
-    # type=file|default=<undefined>: output image file name
     scale_file: generic/file
     # type=file: scale factor file
     # type=file|default=<undefined>: output file name to save the scale factor used at each voxel 
@@ -81,12 +78,12 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    scale_file: generic/file
-    # type=file: scale factor file
-    # type=file|default=<undefined>: output file name to save the scale factor used at each voxel 
     out_file: medimage/nifti1
     # type=file: unifized file
     # type=file|default=<undefined>: output image file name
+    scale_file: generic/file
+    # type=file: scale factor file
+    # type=file|default=<undefined>: output file name to save the scale factor used at each voxel 
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
@@ -152,7 +149,7 @@ tests:
   # (if not specified, will try to choose a sensible value)
     in_file:
     # type=file|default=<undefined>: input file to 3dUnifize
-    out_file:
+    out_file: '"structural_unifized.nii"'
     # type=file: unifized file
     # type=file|default=<undefined>: output image file name
   imports:
@@ -179,7 +176,7 @@ doctests:
   # '.mock()' method of the corresponding class is used instead.
     in_file:
     # type=file|default=<undefined>: input file to 3dUnifize
-    out_file:
+    out_file: '"structural_unifized.nii"'
     # type=file: unifized file
     # type=file|default=<undefined>: output image file name
   imports:
diff --git a/example-specs/task/nipype_internal/pydra-afni/unifize_callables.py b/example-specs/task/nipype/afni/unifize_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/unifize_callables.py
rename to example-specs/task/nipype/afni/unifize_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-afni/volreg.yaml b/example-specs/task/nipype/afni/volreg.yaml
similarity index 98%
rename from example-specs/task/nipype_internal/pydra-afni/volreg.yaml
rename to example-specs/task/nipype/afni/volreg.yaml
index 9c419c08..8eddd28c 100644
--- a/example-specs/task/nipype_internal/pydra-afni/volreg.yaml
+++ b/example-specs/task/nipype/afni/volreg.yaml
@@ -53,9 +53,6 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/nifti1
     # type=file|default=<undefined>: input file to 3dvolreg
-    out_file: medimage-afni/r1
-    # type=file: registered file
-    # type=file|default=<undefined>: output image file name
     basefile: medimage/nifti1
     # type=file|default=<undefined>: base file for registration
     md1d_file: generic/file
@@ -193,7 +190,7 @@ tests:
     # type=int|default=0: Zeropad around the edges by 'n' voxels during rotations
     basefile:
     # type=file|default=<undefined>: base file for registration
-    out_file:
+    out_file: '"rm.epi.volreg.r1"'
     # type=file: registered file
     # type=file|default=<undefined>: output image file name
     oned_file:
@@ -253,7 +250,7 @@ doctests:
     # type=int|default=0: Zeropad around the edges by 'n' voxels during rotations
     basefile:
     # type=file|default=<undefined>: base file for registration
-    out_file:
+    out_file: '"rm.epi.volreg.r1"'
     # type=file: registered file
     # type=file|default=<undefined>: output image file name
     oned_file:
diff --git a/example-specs/task/nipype_internal/pydra-afni/volreg_callables.py b/example-specs/task/nipype/afni/volreg_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/volreg_callables.py
rename to example-specs/task/nipype/afni/volreg_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-afni/warp.yaml b/example-specs/task/nipype/afni/warp.yaml
similarity index 98%
rename from example-specs/task/nipype_internal/pydra-afni/warp.yaml
rename to example-specs/task/nipype/afni/warp.yaml
index b4233a2f..f34a52ce 100644
--- a/example-specs/task/nipype_internal/pydra-afni/warp.yaml
+++ b/example-specs/task/nipype/afni/warp.yaml
@@ -48,9 +48,6 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/nifti1
     # type=file|default=<undefined>: input file to 3dWarp
-    out_file: medimage/nifti-gz
-    # type=file: Warped file.
-    # type=file|default=<undefined>: output image file name
     matparent: generic/file
     # type=file|default=<undefined>: apply transformation from 3dWarpDrive
     oblique_parent: generic/file
@@ -143,7 +140,7 @@ tests:
     # type=file|default=<undefined>: input file to 3dWarp
     deoblique: 'True'
     # type=bool|default=False: transform dataset from oblique to cardinal
-    out_file:
+    out_file: '"trans.nii.gz"'
     # type=file: Warped file.
     # type=file|default=<undefined>: output image file name
   imports:
@@ -168,7 +165,7 @@ tests:
     # type=file|default=<undefined>: input file to 3dWarp
     newgrid: '1.0'
     # type=float|default=0.0: specify grid of this size (mm)
-    out_file:
+    out_file: '"trans.nii.gz"'
     # type=file: Warped file.
     # type=file|default=<undefined>: output image file name
   imports:
@@ -197,7 +194,7 @@ doctests:
     # type=file|default=<undefined>: input file to 3dWarp
     deoblique: 'True'
     # type=bool|default=False: transform dataset from oblique to cardinal
-    out_file:
+    out_file: '"trans.nii.gz"'
     # type=file: Warped file.
     # type=file|default=<undefined>: output image file name
   imports:
@@ -215,7 +212,7 @@ doctests:
     # type=file|default=<undefined>: input file to 3dWarp
     newgrid: '1.0'
     # type=float|default=0.0: specify grid of this size (mm)
-    out_file:
+    out_file: '"trans.nii.gz"'
     # type=file: Warped file.
     # type=file|default=<undefined>: output image file name
   imports:
diff --git a/example-specs/task/nipype_internal/pydra-afni/warp_callables.py b/example-specs/task/nipype/afni/warp_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/warp_callables.py
rename to example-specs/task/nipype/afni/warp_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-afni/z_cut_up.yaml b/example-specs/task/nipype/afni/z_cut_up.yaml
similarity index 97%
rename from example-specs/task/nipype_internal/pydra-afni/z_cut_up.yaml
rename to example-specs/task/nipype/afni/z_cut_up.yaml
index f2b70681..17785aac 100644
--- a/example-specs/task/nipype_internal/pydra-afni/z_cut_up.yaml
+++ b/example-specs/task/nipype/afni/z_cut_up.yaml
@@ -38,9 +38,6 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/nifti1
     # type=file|default=<undefined>: input file to 3dZcutup
-    out_file: medimage/nifti1
-    # type=file: output file
-    # type=file|default=<undefined>: output image file name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -103,7 +100,7 @@ tests:
   # (if not specified, will try to choose a sensible value)
     in_file:
     # type=file|default=<undefined>: input file to 3dZcutup
-    out_file:
+    out_file: '"functional_zcutup.nii"'
     # type=file: output file
     # type=file|default=<undefined>: output image file name
     keep: '"0 10"'
@@ -132,7 +129,7 @@ doctests:
   # '.mock()' method of the corresponding class is used instead.
     in_file:
     # type=file|default=<undefined>: input file to 3dZcutup
-    out_file:
+    out_file: '"functional_zcutup.nii"'
     # type=file: output file
     # type=file|default=<undefined>: output image file name
     keep: '"0 10"'
diff --git a/example-specs/task/nipype_internal/pydra-afni/z_cut_up_callables.py b/example-specs/task/nipype/afni/z_cut_up_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/z_cut_up_callables.py
rename to example-specs/task/nipype/afni/z_cut_up_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-afni/zcat.yaml b/example-specs/task/nipype/afni/zcat.yaml
similarity index 97%
rename from example-specs/task/nipype_internal/pydra-afni/zcat.yaml
rename to example-specs/task/nipype/afni/zcat.yaml
index b2e87a0c..8b9f480c 100644
--- a/example-specs/task/nipype_internal/pydra-afni/zcat.yaml
+++ b/example-specs/task/nipype/afni/zcat.yaml
@@ -38,9 +38,6 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_files: medimage/nifti1+list-of
     # type=inputmultiobject|default=[]: 
-    out_file: medimage/nifti1
-    # type=file: output file
-    # type=file|default=<undefined>: output dataset prefix name (default 'zcat')
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -109,7 +106,7 @@ tests:
   # (if not specified, will try to choose a sensible value)
     in_files:
     # type=inputmultiobject|default=[]: 
-    out_file:
+    out_file: '"cat_functional.nii"'
     # type=file: output file
     # type=file|default=<undefined>: output dataset prefix name (default 'zcat')
   imports:
@@ -136,7 +133,7 @@ doctests:
   # '.mock()' method of the corresponding class is used instead.
     in_files:
     # type=inputmultiobject|default=[]: 
-    out_file:
+    out_file: '"cat_functional.nii"'
     # type=file: output file
     # type=file|default=<undefined>: output dataset prefix name (default 'zcat')
   imports:
diff --git a/example-specs/task/nipype_internal/pydra-afni/zcat_callables.py b/example-specs/task/nipype/afni/zcat_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/zcat_callables.py
rename to example-specs/task/nipype/afni/zcat_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-afni/zeropad.yaml b/example-specs/task/nipype/afni/zeropad.yaml
similarity index 98%
rename from example-specs/task/nipype_internal/pydra-afni/zeropad.yaml
rename to example-specs/task/nipype/afni/zeropad.yaml
index 5efa450b..b103d1fe 100644
--- a/example-specs/task/nipype_internal/pydra-afni/zeropad.yaml
+++ b/example-specs/task/nipype/afni/zeropad.yaml
@@ -43,9 +43,6 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_files: medimage/nifti1
     # type=file|default=<undefined>: input dataset
-    out_file: medimage/nifti1
-    # type=file: output file
-    # type=file|default=<undefined>: output dataset prefix name (default 'zeropad')
     master: generic/file
     # type=file|default=<undefined>: match the volume described in dataset 'mset', where mset must have the same orientation and grid spacing as dataset to be padded. the goal of -master is to make the output dataset from 3dZeropad match the spatial 'extents' of mset by adding or subtracting slices as needed. You can't use -I,-S,..., or -mm with -master
   metadata:
@@ -132,7 +129,7 @@ tests:
   # (if not specified, will try to choose a sensible value)
     in_files:
     # type=file|default=<undefined>: input dataset
-    out_file:
+    out_file: '"pad_functional.nii"'
     # type=file: output file
     # type=file|default=<undefined>: output dataset prefix name (default 'zeropad')
     I: '10'
@@ -171,7 +168,7 @@ doctests:
   # '.mock()' method of the corresponding class is used instead.
     in_files:
     # type=file|default=<undefined>: input dataset
-    out_file:
+    out_file: '"pad_functional.nii"'
     # type=file: output file
     # type=file|default=<undefined>: output dataset prefix name (default 'zeropad')
     I: '10'
diff --git a/example-specs/task/nipype_internal/pydra-afni/zeropad_callables.py b/example-specs/task/nipype/afni/zeropad_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-afni/zeropad_callables.py
rename to example-specs/task/nipype/afni/zeropad_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-ants/affine_initializer.yaml b/example-specs/task/nipype/ants/affine_initializer.yaml
similarity index 98%
rename from example-specs/task/nipype_internal/pydra-ants/affine_initializer.yaml
rename to example-specs/task/nipype/ants/affine_initializer.yaml
index d0e27959..2a7ee761 100644
--- a/example-specs/task/nipype_internal/pydra-ants/affine_initializer.yaml
+++ b/example-specs/task/nipype/ants/affine_initializer.yaml
@@ -34,9 +34,6 @@ inputs:
     # type=file|default=<undefined>: reference image
     moving_image: medimage/nifti1
     # type=file|default=<undefined>: moving image
-    out_file: generic/file
-    # type=file: output transform file
-    # type=file|default='transform.mat': output transform file
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype_internal/pydra-ants/affine_initializer_callables.py b/example-specs/task/nipype/ants/affine_initializer_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-ants/affine_initializer_callables.py
rename to example-specs/task/nipype/ants/affine_initializer_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-ants/ai.yaml b/example-specs/task/nipype/ants/ai.yaml
similarity index 97%
rename from example-specs/task/nipype_internal/pydra-ants/ai.yaml
rename to example-specs/task/nipype/ants/ai.yaml
index 6394b713..b57fec2c 100644
--- a/example-specs/task/nipype_internal/pydra-ants/ai.yaml
+++ b/example-specs/task/nipype/ants/ai.yaml
@@ -49,9 +49,6 @@ inputs:
     # type=file|default=<undefined>: fixed mage mask
     moving_image_mask: generic/file
     # type=file|default=<undefined>: moving mage mask
-    output_transform: generic/file
-    # type=file: output file name
-    # type=file|default='initialization.mat': output file name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype_internal/pydra-ants/ai_callables.py b/example-specs/task/nipype/ants/ai_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-ants/ai_callables.py
rename to example-specs/task/nipype/ants/ai_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-ants/ants.yaml b/example-specs/task/nipype/ants/ants.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-ants/ants.yaml
rename to example-specs/task/nipype/ants/ants.yaml
diff --git a/example-specs/task/nipype_internal/pydra-ants/ants_callables.py b/example-specs/task/nipype/ants/ants_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-ants/ants_callables.py
rename to example-specs/task/nipype/ants/ants_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-ants/ants_introduction.yaml b/example-specs/task/nipype/ants/ants_introduction.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-ants/ants_introduction.yaml
rename to example-specs/task/nipype/ants/ants_introduction.yaml
diff --git a/example-specs/task/nipype_internal/pydra-ants/ants_introduction_callables.py b/example-specs/task/nipype/ants/ants_introduction_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-ants/ants_introduction_callables.py
rename to example-specs/task/nipype/ants/ants_introduction_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-ants/apply_transforms.yaml b/example-specs/task/nipype/ants/apply_transforms.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-ants/apply_transforms.yaml
rename to example-specs/task/nipype/ants/apply_transforms.yaml
diff --git a/example-specs/task/nipype_internal/pydra-ants/apply_transforms_callables.py b/example-specs/task/nipype/ants/apply_transforms_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-ants/apply_transforms_callables.py
rename to example-specs/task/nipype/ants/apply_transforms_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-ants/apply_transforms_to_points.yaml b/example-specs/task/nipype/ants/apply_transforms_to_points.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-ants/apply_transforms_to_points.yaml
rename to example-specs/task/nipype/ants/apply_transforms_to_points.yaml
diff --git a/example-specs/task/nipype_internal/pydra-ants/apply_transforms_to_points_callables.py b/example-specs/task/nipype/ants/apply_transforms_to_points_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-ants/apply_transforms_to_points_callables.py
rename to example-specs/task/nipype/ants/apply_transforms_to_points_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-ants/atropos.yaml b/example-specs/task/nipype/ants/atropos.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-ants/atropos.yaml
rename to example-specs/task/nipype/ants/atropos.yaml
diff --git a/example-specs/task/nipype_internal/pydra-ants/atropos_callables.py b/example-specs/task/nipype/ants/atropos_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-ants/atropos_callables.py
rename to example-specs/task/nipype/ants/atropos_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-ants/average_affine_transform.yaml b/example-specs/task/nipype/ants/average_affine_transform.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-ants/average_affine_transform.yaml
rename to example-specs/task/nipype/ants/average_affine_transform.yaml
diff --git a/example-specs/task/nipype_internal/pydra-ants/average_affine_transform_callables.py b/example-specs/task/nipype/ants/average_affine_transform_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-ants/average_affine_transform_callables.py
rename to example-specs/task/nipype/ants/average_affine_transform_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-ants/average_images.yaml b/example-specs/task/nipype/ants/average_images.yaml
similarity index 97%
rename from example-specs/task/nipype_internal/pydra-ants/average_images.yaml
rename to example-specs/task/nipype/ants/average_images.yaml
index 12b3b9ee..b29b7f8e 100644
--- a/example-specs/task/nipype_internal/pydra-ants/average_images.yaml
+++ b/example-specs/task/nipype/ants/average_images.yaml
@@ -31,9 +31,6 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    output_average_image: medimage/nifti-gz
-    # type=file: average image file
-    # type=file|default='average.nii': the name of the resulting image.
     images: medimage/nifti1+list-of
     # type=inputmultiobject|default=[]: image to apply transformation to (generally a coregistered functional)
   metadata:
@@ -98,7 +95,7 @@ tests:
   # (if not specified, will try to choose a sensible value)
     dimension: '3'
     # type=enum|default=3|allowed[2,3]: image dimension (2 or 3)
-    output_average_image:
+    output_average_image: '"average.nii.gz"'
     # type=file: average image file
     # type=file|default='average.nii': the name of the resulting image.
     normalize: 'True'
@@ -129,7 +126,7 @@ doctests:
   # '.mock()' method of the corresponding class is used instead.
     dimension: '3'
     # type=enum|default=3|allowed[2,3]: image dimension (2 or 3)
-    output_average_image:
+    output_average_image: '"average.nii.gz"'
     # type=file: average image file
     # type=file|default='average.nii': the name of the resulting image.
     normalize: 'True'
diff --git a/example-specs/task/nipype_internal/pydra-ants/average_images_callables.py b/example-specs/task/nipype/ants/average_images_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-ants/average_images_callables.py
rename to example-specs/task/nipype/ants/average_images_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-ants/brain_extraction.yaml b/example-specs/task/nipype/ants/brain_extraction.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-ants/brain_extraction.yaml
rename to example-specs/task/nipype/ants/brain_extraction.yaml
diff --git a/example-specs/task/nipype_internal/pydra-ants/brain_extraction_callables.py b/example-specs/task/nipype/ants/brain_extraction_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-ants/brain_extraction_callables.py
rename to example-specs/task/nipype/ants/brain_extraction_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-ants/buildtemplateparallel.yaml b/example-specs/task/nipype/ants/buildtemplateparallel.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-ants/buildtemplateparallel.yaml
rename to example-specs/task/nipype/ants/buildtemplateparallel.yaml
diff --git a/example-specs/task/nipype_internal/pydra-ants/buildtemplateparallel_callables.py b/example-specs/task/nipype/ants/buildtemplateparallel_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-ants/buildtemplateparallel_callables.py
rename to example-specs/task/nipype/ants/buildtemplateparallel_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-ants/compose_multi_transform.yaml b/example-specs/task/nipype/ants/compose_multi_transform.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-ants/compose_multi_transform.yaml
rename to example-specs/task/nipype/ants/compose_multi_transform.yaml
diff --git a/example-specs/task/nipype_internal/pydra-ants/compose_multi_transform_callables.py b/example-specs/task/nipype/ants/compose_multi_transform_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-ants/compose_multi_transform_callables.py
rename to example-specs/task/nipype/ants/compose_multi_transform_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-ants/composite_transform_util.yaml b/example-specs/task/nipype/ants/composite_transform_util.yaml
similarity index 98%
rename from example-specs/task/nipype_internal/pydra-ants/composite_transform_util.yaml
rename to example-specs/task/nipype/ants/composite_transform_util.yaml
index 5dc89255..9cd42fa1 100644
--- a/example-specs/task/nipype_internal/pydra-ants/composite_transform_util.yaml
+++ b/example-specs/task/nipype/ants/composite_transform_util.yaml
@@ -45,9 +45,6 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    out_file: datascience/hdf5
-    # type=file: Compound transformation file
-    # type=file|default=<undefined>: Output file path (only used for disassembly).
     in_file: '[datascience/text-matrix,datascience/hdf5]+list-of'
     # type=inputmultiobject|default=[]: Input transform file(s)
   metadata:
@@ -63,13 +60,13 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    out_file: datascience/hdf5
+    # type=file: Compound transformation file
+    # type=file|default=<undefined>: Output file path (only used for disassembly).
     affine_transform: generic/file
     # type=file: Affine transform component
     displacement_field: generic/file
     # type=file: Displacement field component
-    out_file: datascience/hdf5
-    # type=file: Compound transformation file
-    # type=file|default=<undefined>: Output file path (only used for disassembly).
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
@@ -138,7 +135,7 @@ tests:
   # (if not specified, will try to choose a sensible value)
     process: '"assemble"'
     # type=enum|default='assemble'|allowed['assemble','disassemble']: What to do with the transform inputs (assemble or disassemble)
-    out_file:
+    out_file: '"my.h5"'
     # type=file: Compound transformation file
     # type=file|default=<undefined>: Output file path (only used for disassembly).
     in_file:
@@ -182,7 +179,7 @@ doctests:
   # '.mock()' method of the corresponding class is used instead.
     process: '"assemble"'
     # type=enum|default='assemble'|allowed['assemble','disassemble']: What to do with the transform inputs (assemble or disassemble)
-    out_file:
+    out_file: '"my.h5"'
     # type=file: Compound transformation file
     # type=file|default=<undefined>: Output file path (only used for disassembly).
     in_file:
diff --git a/example-specs/task/nipype_internal/pydra-ants/composite_transform_util_callables.py b/example-specs/task/nipype/ants/composite_transform_util_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-ants/composite_transform_util_callables.py
rename to example-specs/task/nipype/ants/composite_transform_util_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-ants/convert_scalar_image_to_rgb.yaml b/example-specs/task/nipype/ants/convert_scalar_image_to_rgb.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-ants/convert_scalar_image_to_rgb.yaml
rename to example-specs/task/nipype/ants/convert_scalar_image_to_rgb.yaml
diff --git a/example-specs/task/nipype_internal/pydra-ants/convert_scalar_image_to_rgb_callables.py b/example-specs/task/nipype/ants/convert_scalar_image_to_rgb_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-ants/convert_scalar_image_to_rgb_callables.py
rename to example-specs/task/nipype/ants/convert_scalar_image_to_rgb_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-ants/cortical_thickness.yaml b/example-specs/task/nipype/ants/cortical_thickness.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-ants/cortical_thickness.yaml
rename to example-specs/task/nipype/ants/cortical_thickness.yaml
diff --git a/example-specs/task/nipype_internal/pydra-ants/cortical_thickness_callables.py b/example-specs/task/nipype/ants/cortical_thickness_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-ants/cortical_thickness_callables.py
rename to example-specs/task/nipype/ants/cortical_thickness_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-ants/create_jacobian_determinant_image.yaml b/example-specs/task/nipype/ants/create_jacobian_determinant_image.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-ants/create_jacobian_determinant_image.yaml
rename to example-specs/task/nipype/ants/create_jacobian_determinant_image.yaml
diff --git a/example-specs/task/nipype_internal/pydra-ants/create_jacobian_determinant_image_callables.py b/example-specs/task/nipype/ants/create_jacobian_determinant_image_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-ants/create_jacobian_determinant_image_callables.py
rename to example-specs/task/nipype/ants/create_jacobian_determinant_image_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-ants/create_tiled_mosaic.yaml b/example-specs/task/nipype/ants/create_tiled_mosaic.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-ants/create_tiled_mosaic.yaml
rename to example-specs/task/nipype/ants/create_tiled_mosaic.yaml
diff --git a/example-specs/task/nipype_internal/pydra-ants/create_tiled_mosaic_callables.py b/example-specs/task/nipype/ants/create_tiled_mosaic_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-ants/create_tiled_mosaic_callables.py
rename to example-specs/task/nipype/ants/create_tiled_mosaic_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-ants/denoise_image.yaml b/example-specs/task/nipype/ants/denoise_image.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-ants/denoise_image.yaml
rename to example-specs/task/nipype/ants/denoise_image.yaml
diff --git a/example-specs/task/nipype_internal/pydra-ants/denoise_image_callables.py b/example-specs/task/nipype/ants/denoise_image_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-ants/denoise_image_callables.py
rename to example-specs/task/nipype/ants/denoise_image_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-ants/gen_warp_fields.yaml b/example-specs/task/nipype/ants/gen_warp_fields.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-ants/gen_warp_fields.yaml
rename to example-specs/task/nipype/ants/gen_warp_fields.yaml
diff --git a/example-specs/task/nipype_internal/pydra-ants/gen_warp_fields_callables.py b/example-specs/task/nipype/ants/gen_warp_fields_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-ants/gen_warp_fields_callables.py
rename to example-specs/task/nipype/ants/gen_warp_fields_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-ants/image_math.yaml b/example-specs/task/nipype/ants/image_math.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-ants/image_math.yaml
rename to example-specs/task/nipype/ants/image_math.yaml
diff --git a/example-specs/task/nipype_internal/pydra-ants/image_math_callables.py b/example-specs/task/nipype/ants/image_math_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-ants/image_math_callables.py
rename to example-specs/task/nipype/ants/image_math_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-ants/joint_fusion.yaml b/example-specs/task/nipype/ants/joint_fusion.yaml
similarity index 99%
rename from example-specs/task/nipype_internal/pydra-ants/joint_fusion.yaml
rename to example-specs/task/nipype/ants/joint_fusion.yaml
index 8ef27792..4f771450 100644
--- a/example-specs/task/nipype_internal/pydra-ants/joint_fusion.yaml
+++ b/example-specs/task/nipype/ants/joint_fusion.yaml
@@ -99,9 +99,6 @@ inputs:
     # type=list|default=[]: Specify an exclusion region for the given label.
     mask_image: generic/file
     # type=file|default=<undefined>: If a mask image is specified, fusion is only performed in the mask region.
-    out_label_fusion: medimage/nifti1
-    # type=file: 
-    # type=file|default=<undefined>: The output label fusion image.
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -194,7 +191,7 @@ tests:
 - inputs:
   # dict[str, str] - values to provide to inputs fields in the task initialisation
   # (if not specified, will try to choose a sensible value)
-    out_label_fusion:
+    out_label_fusion: '"ants_fusion_label_output.nii"'
     # type=file: 
     # type=file|default=<undefined>: The output label fusion image.
     atlas_image: '[ ["rc1s1.nii","rc1s2.nii"] ]'
@@ -317,7 +314,7 @@ tests:
 - inputs:
   # dict[str, str] - values to provide to inputs fields in the task initialisation
   # (if not specified, will try to choose a sensible value)
-    out_label_fusion:
+    out_label_fusion: '"ants_fusion_label_output.nii"'
     # type=file: 
     # type=file|default=<undefined>: The output label fusion image.
     out_intensity_fusion_name_format: '"ants_joint_fusion_intensity_%d.nii.gz"'
@@ -348,7 +345,7 @@ doctests:
   # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
   # If the field is of file-format type and the value is None, then the
   # '.mock()' method of the corresponding class is used instead.
-    out_label_fusion:
+    out_label_fusion: '"ants_fusion_label_output.nii"'
     # type=file: 
     # type=file|default=<undefined>: The output label fusion image.
     atlas_image: '[ ["rc1s1.nii","rc1s2.nii"] ]'
@@ -436,7 +433,7 @@ doctests:
   # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
   # If the field is of file-format type and the value is None, then the
   # '.mock()' method of the corresponding class is used instead.
-    out_label_fusion:
+    out_label_fusion: '"ants_fusion_label_output.nii"'
     # type=file: 
     # type=file|default=<undefined>: The output label fusion image.
     out_intensity_fusion_name_format: '"ants_joint_fusion_intensity_%d.nii.gz"'
diff --git a/example-specs/task/nipype_internal/pydra-ants/joint_fusion_callables.py b/example-specs/task/nipype/ants/joint_fusion_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-ants/joint_fusion_callables.py
rename to example-specs/task/nipype/ants/joint_fusion_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-ants/kelly_kapowski.yaml b/example-specs/task/nipype/ants/kelly_kapowski.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-ants/kelly_kapowski.yaml
rename to example-specs/task/nipype/ants/kelly_kapowski.yaml
diff --git a/example-specs/task/nipype_internal/pydra-ants/kelly_kapowski_callables.py b/example-specs/task/nipype/ants/kelly_kapowski_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-ants/kelly_kapowski_callables.py
rename to example-specs/task/nipype/ants/kelly_kapowski_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-ants/label_geometry.yaml b/example-specs/task/nipype/ants/label_geometry.yaml
similarity index 99%
rename from example-specs/task/nipype_internal/pydra-ants/label_geometry.yaml
rename to example-specs/task/nipype/ants/label_geometry.yaml
index 94288523..36aafd24 100644
--- a/example-specs/task/nipype_internal/pydra-ants/label_geometry.yaml
+++ b/example-specs/task/nipype/ants/label_geometry.yaml
@@ -38,8 +38,6 @@ inputs:
   # passed to the field in the automatically generated unittests.
     label_image: medimage/nifti-gz
     # type=file|default=<undefined>: label image to use for extracting geometry measures
-    intensity_image: medimage/nifti-gz
-    # type=file|default='[]': Intensity image to extract values from. This is an optional input
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -53,6 +51,8 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    intensity_image: medimage/nifti-gz
+    # type=file|default='[]': Intensity image to extract values from. This is an optional input
     output_file: generic/file
     # type=file: CSV file of geometry measures
     # type=str|default='': name of output file
@@ -122,7 +122,7 @@ tests:
 - inputs:
   # dict[str, str] - values to provide to inputs fields in the task initialisation
   # (if not specified, will try to choose a sensible value)
-    intensity_image:
+    intensity_image: '"ants_Warp.nii.gz"'
     # type=file|default='[]': Intensity image to extract values from. This is an optional input
   imports:
   # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
@@ -161,7 +161,7 @@ doctests:
   # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
   # If the field is of file-format type and the value is None, then the
   # '.mock()' method of the corresponding class is used instead.
-    intensity_image:
+    intensity_image: '"ants_Warp.nii.gz"'
     # type=file|default='[]': Intensity image to extract values from. This is an optional input
   imports:
   # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
diff --git a/example-specs/task/nipype_internal/pydra-ants/label_geometry_callables.py b/example-specs/task/nipype/ants/label_geometry_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-ants/label_geometry_callables.py
rename to example-specs/task/nipype/ants/label_geometry_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-ants/laplacian_thickness.yaml b/example-specs/task/nipype/ants/laplacian_thickness.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-ants/laplacian_thickness.yaml
rename to example-specs/task/nipype/ants/laplacian_thickness.yaml
diff --git a/example-specs/task/nipype_internal/pydra-ants/laplacian_thickness_callables.py b/example-specs/task/nipype/ants/laplacian_thickness_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-ants/laplacian_thickness_callables.py
rename to example-specs/task/nipype/ants/laplacian_thickness_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-ants/measure_image_similarity.yaml b/example-specs/task/nipype/ants/measure_image_similarity.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-ants/measure_image_similarity.yaml
rename to example-specs/task/nipype/ants/measure_image_similarity.yaml
diff --git a/example-specs/task/nipype_internal/pydra-ants/measure_image_similarity_callables.py b/example-specs/task/nipype/ants/measure_image_similarity_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-ants/measure_image_similarity_callables.py
rename to example-specs/task/nipype/ants/measure_image_similarity_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-ants/multiply_images.yaml b/example-specs/task/nipype/ants/multiply_images.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-ants/multiply_images.yaml
rename to example-specs/task/nipype/ants/multiply_images.yaml
diff --git a/example-specs/task/nipype_internal/pydra-ants/multiply_images_callables.py b/example-specs/task/nipype/ants/multiply_images_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-ants/multiply_images_callables.py
rename to example-specs/task/nipype/ants/multiply_images_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-ants/n4_bias_field_correction.yaml b/example-specs/task/nipype/ants/n4_bias_field_correction.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-ants/n4_bias_field_correction.yaml
rename to example-specs/task/nipype/ants/n4_bias_field_correction.yaml
diff --git a/example-specs/task/nipype_internal/pydra-ants/n4_bias_field_correction_callables.py b/example-specs/task/nipype/ants/n4_bias_field_correction_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-ants/n4_bias_field_correction_callables.py
rename to example-specs/task/nipype/ants/n4_bias_field_correction_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-ants/registration.yaml b/example-specs/task/nipype/ants/registration.yaml
similarity index 99%
rename from example-specs/task/nipype_internal/pydra-ants/registration.yaml
rename to example-specs/task/nipype/ants/registration.yaml
index a88a4468..e842c235 100644
--- a/example-specs/task/nipype_internal/pydra-ants/registration.yaml
+++ b/example-specs/task/nipype/ants/registration.yaml
@@ -183,7 +183,7 @@
 #     'antsRegistration --collapse-output-transforms 1 --dimensionality 3 --initial-moving-transform [ trans.mat, 1 ] --initialize-transforms-per-stage 1 --interpolation Linear --output [ output_, output_warped_image.nii.gz ] --restore-state trans.mat --save-state trans.mat --transform Affine[ 2.0 ] --metric Mattes[ fixed1.nii, moving1.nii, 1, 32, Random, 0.05 ] --convergence [ 1500x200, 1e-08, 20 ] --smoothing-sigmas 1.0x0.0vox --shrink-factors 2x1 --use-estimate-learning-rate-once 1 --use-histogram-matching 1 --transform SyN[ 0.25, 3.0, 0.0 ] --metric Mattes[ fixed1.nii, moving1.nii, 1, 32 ] --convergence [ 100x50x30, 1e-09, 20 ] --smoothing-sigmas 2.0x1.0x0.0vox --shrink-factors 3x2x1 --use-estimate-learning-rate-once 1 --use-histogram-matching 1 --winsorize-image-intensities [ 0.0, 1.0 ]  --write-composite-transform 0'
 # 
 #     One can use multiple similarity metrics in a single registration stage.The Node below first
-#     performs a linear registration using only the Mutual Information ('Mattes')-metric.
+#     performs a linear registation using only the Mutual Information ('Mattes')-metric.
 #     In a second stage, it performs a non-linear registration ('Syn') using both a
 #     Mutual Information and a local cross-correlation ('CC')-metric. Both metrics are weighted
 #     equally ('metric_weight' is .5 for both). The Mutual Information- metric uses 32 bins.
diff --git a/example-specs/task/nipype_internal/pydra-ants/registration_callables.py b/example-specs/task/nipype/ants/registration_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-ants/registration_callables.py
rename to example-specs/task/nipype/ants/registration_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-ants/registration_syn_quick.yaml b/example-specs/task/nipype/ants/registration_syn_quick.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-ants/registration_syn_quick.yaml
rename to example-specs/task/nipype/ants/registration_syn_quick.yaml
diff --git a/example-specs/task/nipype_internal/pydra-ants/registration_syn_quick_callables.py b/example-specs/task/nipype/ants/registration_syn_quick_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-ants/registration_syn_quick_callables.py
rename to example-specs/task/nipype/ants/registration_syn_quick_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-ants/resample_image_by_spacing.yaml b/example-specs/task/nipype/ants/resample_image_by_spacing.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-ants/resample_image_by_spacing.yaml
rename to example-specs/task/nipype/ants/resample_image_by_spacing.yaml
diff --git a/example-specs/task/nipype_internal/pydra-ants/resample_image_by_spacing_callables.py b/example-specs/task/nipype/ants/resample_image_by_spacing_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-ants/resample_image_by_spacing_callables.py
rename to example-specs/task/nipype/ants/resample_image_by_spacing_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-ants/threshold_image.yaml b/example-specs/task/nipype/ants/threshold_image.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-ants/threshold_image.yaml
rename to example-specs/task/nipype/ants/threshold_image.yaml
diff --git a/example-specs/task/nipype_internal/pydra-ants/threshold_image_callables.py b/example-specs/task/nipype/ants/threshold_image_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-ants/threshold_image_callables.py
rename to example-specs/task/nipype/ants/threshold_image_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-ants/warp_image_multi_transform.yaml b/example-specs/task/nipype/ants/warp_image_multi_transform.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-ants/warp_image_multi_transform.yaml
rename to example-specs/task/nipype/ants/warp_image_multi_transform.yaml
index 82206b42..339bc8db 100644
--- a/example-specs/task/nipype_internal/pydra-ants/warp_image_multi_transform.yaml
+++ b/example-specs/task/nipype/ants/warp_image_multi_transform.yaml
@@ -43,8 +43,6 @@ inputs:
   # passed to the field in the automatically generated unittests.
     input_image: medimage/nifti1
     # type=file|default=<undefined>: image to apply transformation to (generally a coregistered functional)
-    out_postfix: generic/file
-    # type=file|default='_wimt': Postfix that is prepended to all output files (default = _wimt)
     reference_image: medimage/nifti1,medimage/nifti-gz
     # type=file|default=<undefined>: reference image space that you wish to warp INTO
     transformation_series: '[text/text-file,medimage/nifti-gz]+list-of'
@@ -62,6 +60,8 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    out_postfix: generic/file
+    # type=file|default='_wimt': Postfix that is prepended to all output files (default = _wimt)
     output_image: generic/file
     # type=file: Warped image
     # type=file|default=<undefined>: name of the output warped image
diff --git a/example-specs/task/nipype_internal/pydra-ants/warp_image_multi_transform_callables.py b/example-specs/task/nipype/ants/warp_image_multi_transform_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-ants/warp_image_multi_transform_callables.py
rename to example-specs/task/nipype/ants/warp_image_multi_transform_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-ants/warp_time_series_image_multi_transform.yaml b/example-specs/task/nipype/ants/warp_time_series_image_multi_transform.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-ants/warp_time_series_image_multi_transform.yaml
rename to example-specs/task/nipype/ants/warp_time_series_image_multi_transform.yaml
diff --git a/example-specs/task/nipype_internal/pydra-ants/warp_time_series_image_multi_transform_callables.py b/example-specs/task/nipype/ants/warp_time_series_image_multi_transform_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-ants/warp_time_series_image_multi_transform_callables.py
rename to example-specs/task/nipype/ants/warp_time_series_image_multi_transform_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/add_x_form_to_header.yaml b/example-specs/task/nipype/freesurfer/add_x_form_to_header.yaml
similarity index 98%
rename from example-specs/task/nipype_internal/pydra-freesurfer/add_x_form_to_header.yaml
rename to example-specs/task/nipype/freesurfer/add_x_form_to_header.yaml
index 57db557d..5a065e54 100644
--- a/example-specs/task/nipype_internal/pydra-freesurfer/add_x_form_to_header.yaml
+++ b/example-specs/task/nipype/freesurfer/add_x_form_to_header.yaml
@@ -50,9 +50,6 @@ inputs:
     # type=file|default=<undefined>: input volume
     transform: datascience/text-matrix
     # type=file|default=<undefined>: xfm file
-    out_file: generic/file
-    # type=file: output volume
-    # type=file|default='output.mgz': output volume
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
   metadata:
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/add_x_form_to_header_callables.py b/example-specs/task/nipype/freesurfer/add_x_form_to_header_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/add_x_form_to_header_callables.py
rename to example-specs/task/nipype/freesurfer/add_x_form_to_header_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/aparc_2_aseg.yaml b/example-specs/task/nipype/freesurfer/aparc_2_aseg.yaml
similarity index 98%
rename from example-specs/task/nipype_internal/pydra-freesurfer/aparc_2_aseg.yaml
rename to example-specs/task/nipype/freesurfer/aparc_2_aseg.yaml
index d894bbb3..db55ba53 100644
--- a/example-specs/task/nipype_internal/pydra-freesurfer/aparc_2_aseg.yaml
+++ b/example-specs/task/nipype/freesurfer/aparc_2_aseg.yaml
@@ -55,9 +55,6 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    out_file: medimage/mgh-gz
-    # type=file: Output aseg file
-    # type=file|default=<undefined>: Full path of file to save the output segmentation in
     lh_white: medimage-freesurfer/pial
     # type=file|default=<undefined>: Input file must be <subject_id>/surf/lh.white
     rh_white: medimage-freesurfer/pial
@@ -194,7 +191,7 @@ tests:
     # type=file|default=<undefined>: Input file must be <subject_id>/label/lh.aparc.annot
     rh_annotation:
     # type=file|default=<undefined>: Input file must be <subject_id>/label/rh.aparc.annot
-    out_file:
+    out_file: '"aparc+aseg.mgz"'
     # type=file: Output aseg file
     # type=file|default=<undefined>: Full path of file to save the output segmentation in
     label_wm: 'True'
@@ -241,7 +238,7 @@ doctests:
     # type=file|default=<undefined>: Input file must be <subject_id>/label/lh.aparc.annot
     rh_annotation:
     # type=file|default=<undefined>: Input file must be <subject_id>/label/rh.aparc.annot
-    out_file:
+    out_file: '"aparc+aseg.mgz"'
     # type=file: Output aseg file
     # type=file|default=<undefined>: Full path of file to save the output segmentation in
     label_wm: 'True'
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/aparc_2_aseg_callables.py b/example-specs/task/nipype/freesurfer/aparc_2_aseg_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/aparc_2_aseg_callables.py
rename to example-specs/task/nipype/freesurfer/aparc_2_aseg_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/apas_2_aseg.yaml b/example-specs/task/nipype/freesurfer/apas_2_aseg.yaml
similarity index 97%
rename from example-specs/task/nipype_internal/pydra-freesurfer/apas_2_aseg.yaml
rename to example-specs/task/nipype/freesurfer/apas_2_aseg.yaml
index a6a79760..649b5775 100644
--- a/example-specs/task/nipype_internal/pydra-freesurfer/apas_2_aseg.yaml
+++ b/example-specs/task/nipype/freesurfer/apas_2_aseg.yaml
@@ -37,9 +37,6 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/mgh-gz
     # type=file|default=<undefined>: Input aparc+aseg.mgz
-    out_file: medimage/mgh-gz
-    # type=file: Output aseg file
-    # type=file|default=<undefined>: Output aseg file
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
   metadata:
@@ -100,7 +97,7 @@ tests:
   # (if not specified, will try to choose a sensible value)
     in_file:
     # type=file|default=<undefined>: Input aparc+aseg.mgz
-    out_file:
+    out_file: '"output.mgz"'
     # type=file: Output aseg file
     # type=file|default=<undefined>: Output aseg file
   imports:
@@ -127,7 +124,7 @@ doctests:
   # '.mock()' method of the corresponding class is used instead.
     in_file:
     # type=file|default=<undefined>: Input aparc+aseg.mgz
-    out_file:
+    out_file: '"output.mgz"'
     # type=file: Output aseg file
     # type=file|default=<undefined>: Output aseg file
   imports:
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/apas_2_aseg_callables.py b/example-specs/task/nipype/freesurfer/apas_2_aseg_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/apas_2_aseg_callables.py
rename to example-specs/task/nipype/freesurfer/apas_2_aseg_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/apply_mask.yaml b/example-specs/task/nipype/freesurfer/apply_mask.yaml
similarity index 97%
rename from example-specs/task/nipype_internal/pydra-freesurfer/apply_mask.yaml
rename to example-specs/task/nipype/freesurfer/apply_mask.yaml
index 6f6fdfbb..2f828c56 100644
--- a/example-specs/task/nipype_internal/pydra-freesurfer/apply_mask.yaml
+++ b/example-specs/task/nipype/freesurfer/apply_mask.yaml
@@ -30,9 +30,6 @@ inputs:
     # type=file|default=<undefined>: input image (will be masked)
     mask_file: generic/file
     # type=file|default=<undefined>: image defining mask space
-    out_file: generic/file
-    # type=file: masked image
-    # type=file|default=<undefined>: final image to write
     xfm_file: generic/file
     # type=file|default=<undefined>: LTA-format transformation matrix to align mask with input
     xfm_source: generic/file
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/apply_mask_callables.py b/example-specs/task/nipype/freesurfer/apply_mask_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/apply_mask_callables.py
rename to example-specs/task/nipype/freesurfer/apply_mask_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/apply_vol_transform.yaml b/example-specs/task/nipype/freesurfer/apply_vol_transform.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/apply_vol_transform.yaml
rename to example-specs/task/nipype/freesurfer/apply_vol_transform.yaml
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/apply_vol_transform_callables.py b/example-specs/task/nipype/freesurfer/apply_vol_transform_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/apply_vol_transform_callables.py
rename to example-specs/task/nipype/freesurfer/apply_vol_transform_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/bb_register.yaml b/example-specs/task/nipype/freesurfer/bb_register.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/bb_register.yaml
rename to example-specs/task/nipype/freesurfer/bb_register.yaml
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/bb_register_callables.py b/example-specs/task/nipype/freesurfer/bb_register_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/bb_register_callables.py
rename to example-specs/task/nipype/freesurfer/bb_register_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/binarize.yaml b/example-specs/task/nipype/freesurfer/binarize.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/binarize.yaml
rename to example-specs/task/nipype/freesurfer/binarize.yaml
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/binarize_callables.py b/example-specs/task/nipype/freesurfer/binarize_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/binarize_callables.py
rename to example-specs/task/nipype/freesurfer/binarize_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/ca_label.yaml b/example-specs/task/nipype/freesurfer/ca_label.yaml
similarity index 98%
rename from example-specs/task/nipype_internal/pydra-freesurfer/ca_label.yaml
rename to example-specs/task/nipype/freesurfer/ca_label.yaml
index 025fac4c..ee9379ef 100644
--- a/example-specs/task/nipype_internal/pydra-freesurfer/ca_label.yaml
+++ b/example-specs/task/nipype/freesurfer/ca_label.yaml
@@ -40,9 +40,6 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/mgh-gz
     # type=file|default=<undefined>: Input volume for CALabel
-    out_file: medimage/mgh-gz
-    # type=file: Output volume from CALabel
-    # type=file|default=<undefined>: Output file for CALabel
     transform: datascience/text-matrix
     # type=file|default=<undefined>: Input transform for CALabel
     template: medimage/nifti1
@@ -137,7 +134,7 @@ tests:
   # (if not specified, will try to choose a sensible value)
     in_file:
     # type=file|default=<undefined>: Input volume for CALabel
-    out_file:
+    out_file: '"out.mgz"'
     # type=file: Output volume from CALabel
     # type=file|default=<undefined>: Output file for CALabel
     transform:
@@ -168,7 +165,7 @@ doctests:
   # '.mock()' method of the corresponding class is used instead.
     in_file:
     # type=file|default=<undefined>: Input volume for CALabel
-    out_file:
+    out_file: '"out.mgz"'
     # type=file: Output volume from CALabel
     # type=file|default=<undefined>: Output file for CALabel
     transform:
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/ca_label_callables.py b/example-specs/task/nipype/freesurfer/ca_label_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/ca_label_callables.py
rename to example-specs/task/nipype/freesurfer/ca_label_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/ca_normalize.yaml b/example-specs/task/nipype/freesurfer/ca_normalize.yaml
similarity index 98%
rename from example-specs/task/nipype_internal/pydra-freesurfer/ca_normalize.yaml
rename to example-specs/task/nipype/freesurfer/ca_normalize.yaml
index 6c64c82c..f277c3e0 100644
--- a/example-specs/task/nipype_internal/pydra-freesurfer/ca_normalize.yaml
+++ b/example-specs/task/nipype/freesurfer/ca_normalize.yaml
@@ -40,9 +40,6 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/mgh-gz
     # type=file|default=<undefined>: The input file for CANormalize
-    out_file: generic/file
-    # type=file: The output file for Normalize
-    # type=file|default=<undefined>: The output file for CANormalize
     atlas: medimage/nifti-gz
     # type=file|default=<undefined>: The atlas file in gca format
     transform: datascience/text-matrix
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/ca_normalize_callables.py b/example-specs/task/nipype/freesurfer/ca_normalize_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/ca_normalize_callables.py
rename to example-specs/task/nipype/freesurfer/ca_normalize_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/ca_register.yaml b/example-specs/task/nipype/freesurfer/ca_register.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/ca_register.yaml
rename to example-specs/task/nipype/freesurfer/ca_register.yaml
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/ca_register_callables.py b/example-specs/task/nipype/freesurfer/ca_register_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/ca_register_callables.py
rename to example-specs/task/nipype/freesurfer/ca_register_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/check_talairach_alignment.yaml b/example-specs/task/nipype/freesurfer/check_talairach_alignment.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/check_talairach_alignment.yaml
rename to example-specs/task/nipype/freesurfer/check_talairach_alignment.yaml
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/check_talairach_alignment_callables.py b/example-specs/task/nipype/freesurfer/check_talairach_alignment_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/check_talairach_alignment_callables.py
rename to example-specs/task/nipype/freesurfer/check_talairach_alignment_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/concatenate.yaml b/example-specs/task/nipype/freesurfer/concatenate.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/concatenate.yaml
rename to example-specs/task/nipype/freesurfer/concatenate.yaml
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/concatenate_callables.py b/example-specs/task/nipype/freesurfer/concatenate_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/concatenate_callables.py
rename to example-specs/task/nipype/freesurfer/concatenate_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/concatenate_lta.yaml b/example-specs/task/nipype/freesurfer/concatenate_lta.yaml
similarity index 98%
rename from example-specs/task/nipype_internal/pydra-freesurfer/concatenate_lta.yaml
rename to example-specs/task/nipype/freesurfer/concatenate_lta.yaml
index e803ec81..a4b9ffe0 100644
--- a/example-specs/task/nipype_internal/pydra-freesurfer/concatenate_lta.yaml
+++ b/example-specs/task/nipype/freesurfer/concatenate_lta.yaml
@@ -49,9 +49,6 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_lta1: medimage-freesurfer/lta
     # type=file|default=<undefined>: maps some src1 to dst1
-    out_file: medimage-freesurfer/lta
-    # type=file: the combined LTA maps: src1 to dst2 = LTA2*LTA1
-    # type=file|default=<undefined>: the combined LTA maps: src1 to dst2 = LTA2*LTA1
     tal_source_file: generic/file
     # type=file|default=<undefined>: if in_lta2 is talairach.xfm, specify source for talairach
     tal_template_file: generic/file
@@ -156,7 +153,7 @@ tests:
     # type=traitcompound|default=None: maps dst1(src2) to dst2
     invert_1: 'True'
     # type=bool|default=False: invert in_lta1 before applying it
-    out_file:
+    out_file: '"inv1.lta"'
     # type=file: the combined LTA maps: src1 to dst2 = LTA2*LTA1
     # type=file|default=<undefined>: the combined LTA maps: src1 to dst2 = LTA2*LTA1
   imports:
@@ -220,7 +217,7 @@ doctests:
     # type=traitcompound|default=None: maps dst1(src2) to dst2
     invert_1: 'True'
     # type=bool|default=False: invert in_lta1 before applying it
-    out_file:
+    out_file: '"inv1.lta"'
     # type=file: the combined LTA maps: src1 to dst2 = LTA2*LTA1
     # type=file|default=<undefined>: the combined LTA maps: src1 to dst2 = LTA2*LTA1
   imports:
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/concatenate_lta_callables.py b/example-specs/task/nipype/freesurfer/concatenate_lta_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/concatenate_lta_callables.py
rename to example-specs/task/nipype/freesurfer/concatenate_lta_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/contrast.yaml b/example-specs/task/nipype/freesurfer/contrast.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/contrast.yaml
rename to example-specs/task/nipype/freesurfer/contrast.yaml
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/contrast_callables.py b/example-specs/task/nipype/freesurfer/contrast_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/contrast_callables.py
rename to example-specs/task/nipype/freesurfer/contrast_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/curvature.yaml b/example-specs/task/nipype/freesurfer/curvature.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/curvature.yaml
rename to example-specs/task/nipype/freesurfer/curvature.yaml
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/curvature_callables.py b/example-specs/task/nipype/freesurfer/curvature_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/curvature_callables.py
rename to example-specs/task/nipype/freesurfer/curvature_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/curvature_stats.yaml b/example-specs/task/nipype/freesurfer/curvature_stats.yaml
similarity index 98%
rename from example-specs/task/nipype_internal/pydra-freesurfer/curvature_stats.yaml
rename to example-specs/task/nipype/freesurfer/curvature_stats.yaml
index 066e03ab..e5e87797 100644
--- a/example-specs/task/nipype_internal/pydra-freesurfer/curvature_stats.yaml
+++ b/example-specs/task/nipype/freesurfer/curvature_stats.yaml
@@ -62,9 +62,6 @@ inputs:
     # type=file|default=<undefined>: Input file for CurvatureStats
     curvfile2: medimage-freesurfer/pial
     # type=file|default=<undefined>: Input file for CurvatureStats
-    out_file: medimage-freesurfer/stats
-    # type=file: Output curvature stats file
-    # type=file|default=<undefined>: Output curvature stats file
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
   metadata:
@@ -147,7 +144,7 @@ tests:
     # type=file|default=<undefined>: Input file for CurvatureStats
     surface:
     # type=file|default=<undefined>: Specify surface file for CurvatureStats
-    out_file:
+    out_file: '"lh.curv.stats"'
     # type=file: Output curvature stats file
     # type=file|default=<undefined>: Output curvature stats file
     values: 'True'
@@ -186,7 +183,7 @@ doctests:
     # type=file|default=<undefined>: Input file for CurvatureStats
     surface:
     # type=file|default=<undefined>: Specify surface file for CurvatureStats
-    out_file:
+    out_file: '"lh.curv.stats"'
     # type=file: Output curvature stats file
     # type=file|default=<undefined>: Output curvature stats file
     values: 'True'
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/curvature_stats_callables.py b/example-specs/task/nipype/freesurfer/curvature_stats_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/curvature_stats_callables.py
rename to example-specs/task/nipype/freesurfer/curvature_stats_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/dicom_convert.yaml b/example-specs/task/nipype/freesurfer/dicom_convert.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/dicom_convert.yaml
rename to example-specs/task/nipype/freesurfer/dicom_convert.yaml
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/dicom_convert_callables.py b/example-specs/task/nipype/freesurfer/dicom_convert_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/dicom_convert_callables.py
rename to example-specs/task/nipype/freesurfer/dicom_convert_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/edit_w_mwith_aseg.yaml b/example-specs/task/nipype/freesurfer/edit_w_mwith_aseg.yaml
similarity index 97%
rename from example-specs/task/nipype_internal/pydra-freesurfer/edit_w_mwith_aseg.yaml
rename to example-specs/task/nipype/freesurfer/edit_w_mwith_aseg.yaml
index 62f2202b..933009e2 100644
--- a/example-specs/task/nipype_internal/pydra-freesurfer/edit_w_mwith_aseg.yaml
+++ b/example-specs/task/nipype/freesurfer/edit_w_mwith_aseg.yaml
@@ -40,9 +40,6 @@ inputs:
     # type=file|default=<undefined>: Input brain/T1 file
     seg_file: medimage/mgh-gz
     # type=file|default=<undefined>: Input presurf segmentation file
-    out_file: medimage/mgh-gz
-    # type=file: Output edited WM file
-    # type=file|default=<undefined>: File to be written as output
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
   metadata:
@@ -113,7 +110,7 @@ tests:
     # type=file|default=<undefined>: Input brain/T1 file
     seg_file:
     # type=file|default=<undefined>: Input presurf segmentation file
-    out_file:
+    out_file: '"wm.asegedit.mgz"'
     # type=file: Output edited WM file
     # type=file|default=<undefined>: File to be written as output
     keep_in: 'True'
@@ -146,7 +143,7 @@ doctests:
     # type=file|default=<undefined>: Input brain/T1 file
     seg_file:
     # type=file|default=<undefined>: Input presurf segmentation file
-    out_file:
+    out_file: '"wm.asegedit.mgz"'
     # type=file: Output edited WM file
     # type=file|default=<undefined>: File to be written as output
     keep_in: 'True'
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/edit_w_mwith_aseg_callables.py b/example-specs/task/nipype/freesurfer/edit_w_mwith_aseg_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/edit_w_mwith_aseg_callables.py
rename to example-specs/task/nipype/freesurfer/edit_w_mwith_aseg_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/em_register.yaml b/example-specs/task/nipype/freesurfer/em_register.yaml
similarity index 97%
rename from example-specs/task/nipype_internal/pydra-freesurfer/em_register.yaml
rename to example-specs/task/nipype/freesurfer/em_register.yaml
index 63a7b5a1..bcfbd6d9 100644
--- a/example-specs/task/nipype_internal/pydra-freesurfer/em_register.yaml
+++ b/example-specs/task/nipype/freesurfer/em_register.yaml
@@ -37,9 +37,6 @@ inputs:
     # type=file|default=<undefined>: in brain volume
     template: medimage/mgh-gz
     # type=file|default=<undefined>: template gca
-    out_file: medimage-freesurfer/lta
-    # type=file: output transform
-    # type=file|default=<undefined>: output transform
     mask: generic/file
     # type=file|default=<undefined>: use volume as a mask
     transform: generic/file
@@ -118,7 +115,7 @@ tests:
     # type=file|default=<undefined>: in brain volume
     template:
     # type=file|default=<undefined>: template gca
-    out_file:
+    out_file: '"norm_transform.lta"'
     # type=file: output transform
     # type=file|default=<undefined>: output transform
     skull: 'True'
@@ -151,7 +148,7 @@ doctests:
     # type=file|default=<undefined>: in brain volume
     template:
     # type=file|default=<undefined>: template gca
-    out_file:
+    out_file: '"norm_transform.lta"'
     # type=file: output transform
     # type=file|default=<undefined>: output transform
     skull: 'True'
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/em_register_callables.py b/example-specs/task/nipype/freesurfer/em_register_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/em_register_callables.py
rename to example-specs/task/nipype/freesurfer/em_register_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/euler_number.yaml b/example-specs/task/nipype/freesurfer/euler_number.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/euler_number.yaml
rename to example-specs/task/nipype/freesurfer/euler_number.yaml
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/euler_number_callables.py b/example-specs/task/nipype/freesurfer/euler_number_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/euler_number_callables.py
rename to example-specs/task/nipype/freesurfer/euler_number_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/extract_main_component.yaml b/example-specs/task/nipype/freesurfer/extract_main_component.yaml
similarity index 97%
rename from example-specs/task/nipype_internal/pydra-freesurfer/extract_main_component.yaml
rename to example-specs/task/nipype/freesurfer/extract_main_component.yaml
index 5e144f10..496f856b 100644
--- a/example-specs/task/nipype_internal/pydra-freesurfer/extract_main_component.yaml
+++ b/example-specs/task/nipype/freesurfer/extract_main_component.yaml
@@ -32,9 +32,6 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage-freesurfer/pial
     # type=file|default=<undefined>: input surface file
-    out_file: generic/file
-    # type=file: surface containing main component
-    # type=file|default=<undefined>: surface containing main component
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/extract_main_component_callables.py b/example-specs/task/nipype/freesurfer/extract_main_component_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/extract_main_component_callables.py
rename to example-specs/task/nipype/freesurfer/extract_main_component_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/fit_ms_params.yaml b/example-specs/task/nipype/freesurfer/fit_ms_params.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/fit_ms_params.yaml
rename to example-specs/task/nipype/freesurfer/fit_ms_params.yaml
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/fit_ms_params_callables.py b/example-specs/task/nipype/freesurfer/fit_ms_params_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/fit_ms_params_callables.py
rename to example-specs/task/nipype/freesurfer/fit_ms_params_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/fix_topology.yaml b/example-specs/task/nipype/freesurfer/fix_topology.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/fix_topology.yaml
rename to example-specs/task/nipype/freesurfer/fix_topology.yaml
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/fix_topology_callables.py b/example-specs/task/nipype/freesurfer/fix_topology_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/fix_topology_callables.py
rename to example-specs/task/nipype/freesurfer/fix_topology_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/fuse_segmentations.yaml b/example-specs/task/nipype/freesurfer/fuse_segmentations.yaml
similarity index 98%
rename from example-specs/task/nipype_internal/pydra-freesurfer/fuse_segmentations.yaml
rename to example-specs/task/nipype/freesurfer/fuse_segmentations.yaml
index cf0eccf8..bcacf617 100644
--- a/example-specs/task/nipype_internal/pydra-freesurfer/fuse_segmentations.yaml
+++ b/example-specs/task/nipype/freesurfer/fuse_segmentations.yaml
@@ -34,9 +34,6 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    out_file: medimage/mgh-gz
-    # type=file: output fused segmentation file
-    # type=file|default=<undefined>: output fused segmentation file
     in_segmentations: medimage/mgh-gz+list-of
     # type=inputmultiobject|default=[]: name of aseg file to use (default: aseg.mgz)         must include the aseg files for all the given timepoints
     in_segmentations_noCC: medimage/mgh-gz+list-of
@@ -113,7 +110,7 @@ tests:
     # type=string|default='': subject_id being processed
     timepoints: '["tp1", "tp2"]'
     # type=inputmultiobject|default=[]: subject_ids or timepoints to be processed
-    out_file:
+    out_file: '"aseg.fused.mgz"'
     # type=file: output fused segmentation file
     # type=file|default=<undefined>: output fused segmentation file
     in_segmentations:
@@ -148,7 +145,7 @@ doctests:
     # type=string|default='': subject_id being processed
     timepoints: '["tp1", "tp2"]'
     # type=inputmultiobject|default=[]: subject_ids or timepoints to be processed
-    out_file:
+    out_file: '"aseg.fused.mgz"'
     # type=file: output fused segmentation file
     # type=file|default=<undefined>: output fused segmentation file
     in_segmentations:
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/fuse_segmentations_callables.py b/example-specs/task/nipype/freesurfer/fuse_segmentations_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/fuse_segmentations_callables.py
rename to example-specs/task/nipype/freesurfer/fuse_segmentations_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/glm_fit.yaml b/example-specs/task/nipype/freesurfer/glm_fit.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/glm_fit.yaml
rename to example-specs/task/nipype/freesurfer/glm_fit.yaml
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/glm_fit_callables.py b/example-specs/task/nipype/freesurfer/glm_fit_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/glm_fit_callables.py
rename to example-specs/task/nipype/freesurfer/glm_fit_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/gtm_seg.yaml b/example-specs/task/nipype/freesurfer/gtm_seg.yaml
similarity index 98%
rename from example-specs/task/nipype_internal/pydra-freesurfer/gtm_seg.yaml
rename to example-specs/task/nipype/freesurfer/gtm_seg.yaml
index e0aaf197..301b9c50 100644
--- a/example-specs/task/nipype_internal/pydra-freesurfer/gtm_seg.yaml
+++ b/example-specs/task/nipype/freesurfer/gtm_seg.yaml
@@ -28,9 +28,6 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    out_file: generic/file
-    # type=file: GTM segmentation
-    # type=file|default='gtmseg.mgz': output volume relative to subject/mri
     colortable: generic/file
     # type=file|default=<undefined>: colortable
     subjects_dir: generic/directory
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/gtm_seg_callables.py b/example-specs/task/nipype/freesurfer/gtm_seg_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/gtm_seg_callables.py
rename to example-specs/task/nipype/freesurfer/gtm_seg_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/gtmpvc.yaml b/example-specs/task/nipype/freesurfer/gtmpvc.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/gtmpvc.yaml
rename to example-specs/task/nipype/freesurfer/gtmpvc.yaml
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/gtmpvc_callables.py b/example-specs/task/nipype/freesurfer/gtmpvc_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/gtmpvc_callables.py
rename to example-specs/task/nipype/freesurfer/gtmpvc_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/image_info.yaml b/example-specs/task/nipype/freesurfer/image_info.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/image_info.yaml
rename to example-specs/task/nipype/freesurfer/image_info.yaml
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/image_info_callables.py b/example-specs/task/nipype/freesurfer/image_info_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/image_info_callables.py
rename to example-specs/task/nipype/freesurfer/image_info_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/jacobian.yaml b/example-specs/task/nipype/freesurfer/jacobian.yaml
similarity index 97%
rename from example-specs/task/nipype_internal/pydra-freesurfer/jacobian.yaml
rename to example-specs/task/nipype/freesurfer/jacobian.yaml
index ce30d3b2..315bc120 100644
--- a/example-specs/task/nipype_internal/pydra-freesurfer/jacobian.yaml
+++ b/example-specs/task/nipype/freesurfer/jacobian.yaml
@@ -35,9 +35,6 @@ inputs:
     # type=file|default=<undefined>: Original surface
     in_mappedsurf: medimage-freesurfer/pial
     # type=file|default=<undefined>: Mapped surface
-    out_file: generic/file
-    # type=file: Output Jacobian of the surface mapping
-    # type=file|default=<undefined>: Output Jacobian of the surface mapping
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
   metadata:
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/jacobian_callables.py b/example-specs/task/nipype/freesurfer/jacobian_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/jacobian_callables.py
rename to example-specs/task/nipype/freesurfer/jacobian_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/label_2_annot.yaml b/example-specs/task/nipype/freesurfer/label_2_annot.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/label_2_annot.yaml
rename to example-specs/task/nipype/freesurfer/label_2_annot.yaml
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/label_2_annot_callables.py b/example-specs/task/nipype/freesurfer/label_2_annot_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/label_2_annot_callables.py
rename to example-specs/task/nipype/freesurfer/label_2_annot_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/label_2_label.yaml b/example-specs/task/nipype/freesurfer/label_2_label.yaml
similarity index 98%
rename from example-specs/task/nipype_internal/pydra-freesurfer/label_2_label.yaml
rename to example-specs/task/nipype/freesurfer/label_2_label.yaml
index d10ad0cd..24982b77 100644
--- a/example-specs/task/nipype_internal/pydra-freesurfer/label_2_label.yaml
+++ b/example-specs/task/nipype/freesurfer/label_2_label.yaml
@@ -55,9 +55,6 @@ inputs:
     # type=file|default=<undefined>: Implicit input <hemisphere>.white
     source_label: model/stl
     # type=file|default=<undefined>: Source label
-    out_file: generic/file
-    # type=file: Output label
-    # type=file|default=<undefined>: Target label
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
   metadata:
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/label_2_label_callables.py b/example-specs/task/nipype/freesurfer/label_2_label_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/label_2_label_callables.py
rename to example-specs/task/nipype/freesurfer/label_2_label_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/label_2_vol.yaml b/example-specs/task/nipype/freesurfer/label_2_vol.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/label_2_vol.yaml
rename to example-specs/task/nipype/freesurfer/label_2_vol.yaml
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/label_2_vol_callables.py b/example-specs/task/nipype/freesurfer/label_2_vol_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/label_2_vol_callables.py
rename to example-specs/task/nipype/freesurfer/label_2_vol_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/logan_ref.yaml b/example-specs/task/nipype/freesurfer/logan_ref.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/logan_ref.yaml
rename to example-specs/task/nipype/freesurfer/logan_ref.yaml
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/logan_ref_callables.py b/example-specs/task/nipype/freesurfer/logan_ref_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/logan_ref_callables.py
rename to example-specs/task/nipype/freesurfer/logan_ref_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/lta_convert.yaml b/example-specs/task/nipype/freesurfer/lta_convert.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/lta_convert.yaml
rename to example-specs/task/nipype/freesurfer/lta_convert.yaml
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/lta_convert_callables.py b/example-specs/task/nipype/freesurfer/lta_convert_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/lta_convert_callables.py
rename to example-specs/task/nipype/freesurfer/lta_convert_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/make_average_subject.yaml b/example-specs/task/nipype/freesurfer/make_average_subject.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/make_average_subject.yaml
rename to example-specs/task/nipype/freesurfer/make_average_subject.yaml
index 9a288940..b697d7d5 100644
--- a/example-specs/task/nipype_internal/pydra-freesurfer/make_average_subject.yaml
+++ b/example-specs/task/nipype/freesurfer/make_average_subject.yaml
@@ -30,8 +30,6 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    out_name: generic/file
-    # type=file|default='average': name for the average subject
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
   metadata:
@@ -47,6 +45,8 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    out_name: generic/file
+    # type=file|default='average': name for the average subject
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/make_average_subject_callables.py b/example-specs/task/nipype/freesurfer/make_average_subject_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/make_average_subject_callables.py
rename to example-specs/task/nipype/freesurfer/make_average_subject_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/make_surfaces.yaml b/example-specs/task/nipype/freesurfer/make_surfaces.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/make_surfaces.yaml
rename to example-specs/task/nipype/freesurfer/make_surfaces.yaml
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/make_surfaces_callables.py b/example-specs/task/nipype/freesurfer/make_surfaces_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/make_surfaces_callables.py
rename to example-specs/task/nipype/freesurfer/make_surfaces_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/mni_bias_correction.yaml b/example-specs/task/nipype/freesurfer/mni_bias_correction.yaml
similarity index 97%
rename from example-specs/task/nipype_internal/pydra-freesurfer/mni_bias_correction.yaml
rename to example-specs/task/nipype/freesurfer/mni_bias_correction.yaml
index 56a77139..5fa4a1e2 100644
--- a/example-specs/task/nipype_internal/pydra-freesurfer/mni_bias_correction.yaml
+++ b/example-specs/task/nipype/freesurfer/mni_bias_correction.yaml
@@ -48,9 +48,6 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/mgh-gz
     # type=file|default=<undefined>: input volume. Input can be any format accepted by mri_convert.
-    out_file: generic/file
-    # type=file: output volume
-    # type=file|default=<undefined>: output volume. Output can be any format accepted by mri_convert. If the output format is COR, then the directory must exist.
     mask: generic/file
     # type=file|default=<undefined>: brainmask volume. Input can be any format accepted by mri_convert.
     transform: generic/file
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/mni_bias_correction_callables.py b/example-specs/task/nipype/freesurfer/mni_bias_correction_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/mni_bias_correction_callables.py
rename to example-specs/task/nipype/freesurfer/mni_bias_correction_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/mp_rto_mni305.yaml b/example-specs/task/nipype/freesurfer/mp_rto_mni305.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/mp_rto_mni305.yaml
rename to example-specs/task/nipype/freesurfer/mp_rto_mni305.yaml
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/mp_rto_mni305_callables.py b/example-specs/task/nipype/freesurfer/mp_rto_mni305_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/mp_rto_mni305_callables.py
rename to example-specs/task/nipype/freesurfer/mp_rto_mni305_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/mr_is_ca_label.yaml b/example-specs/task/nipype/freesurfer/mr_is_ca_label.yaml
similarity index 98%
rename from example-specs/task/nipype_internal/pydra-freesurfer/mr_is_ca_label.yaml
rename to example-specs/task/nipype/freesurfer/mr_is_ca_label.yaml
index 049c71eb..a9f5a063 100644
--- a/example-specs/task/nipype_internal/pydra-freesurfer/mr_is_ca_label.yaml
+++ b/example-specs/task/nipype/freesurfer/mr_is_ca_label.yaml
@@ -54,9 +54,6 @@ inputs:
     # type=file|default=<undefined>: implicit input {hemisphere}.curv
     sulc: medimage-freesurfer/pial
     # type=file|default=<undefined>: implicit input {hemisphere}.sulc
-    out_file: generic/file
-    # type=file: Output volume from MRIsCALabel
-    # type=file|default=<undefined>: Annotated surface output file
     label: generic/file
     # type=file|default=<undefined>: Undocumented flag. Autorecon3 uses ../label/{hemisphere}.cortex.label as input file
     aseg: generic/file
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/mr_is_ca_label_callables.py b/example-specs/task/nipype/freesurfer/mr_is_ca_label_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/mr_is_ca_label_callables.py
rename to example-specs/task/nipype/freesurfer/mr_is_ca_label_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/mr_is_calc.yaml b/example-specs/task/nipype/freesurfer/mr_is_calc.yaml
similarity index 97%
rename from example-specs/task/nipype_internal/pydra-freesurfer/mr_is_calc.yaml
rename to example-specs/task/nipype/freesurfer/mr_is_calc.yaml
index b8830ad1..cdd1e863 100644
--- a/example-specs/task/nipype_internal/pydra-freesurfer/mr_is_calc.yaml
+++ b/example-specs/task/nipype/freesurfer/mr_is_calc.yaml
@@ -44,9 +44,6 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file1: medimage-freesurfer/area
     # type=file|default=<undefined>: Input file 1
-    out_file: audio/sp-midi
-    # type=file: Output file after calculation
-    # type=file|default=<undefined>: Output file after calculation
     in_file2: medimage-freesurfer/pial
     # type=file|default=<undefined>: Input file 2
     subjects_dir: generic/directory
@@ -121,7 +118,7 @@ tests:
     # type=file|default=<undefined>: Input file 2
     action: '"add"'
     # type=string|default='': Action to perform on input file(s)
-    out_file:
+    out_file: '"area.mid"'
     # type=file: Output file after calculation
     # type=file|default=<undefined>: Output file after calculation
   imports:
@@ -152,7 +149,7 @@ doctests:
     # type=file|default=<undefined>: Input file 2
     action: '"add"'
     # type=string|default='': Action to perform on input file(s)
-    out_file:
+    out_file: '"area.mid"'
     # type=file: Output file after calculation
     # type=file|default=<undefined>: Output file after calculation
   imports:
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/mr_is_calc_callables.py b/example-specs/task/nipype/freesurfer/mr_is_calc_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/mr_is_calc_callables.py
rename to example-specs/task/nipype/freesurfer/mr_is_calc_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/mr_is_combine.yaml b/example-specs/task/nipype/freesurfer/mr_is_combine.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/mr_is_combine.yaml
rename to example-specs/task/nipype/freesurfer/mr_is_combine.yaml
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/mr_is_combine_callables.py b/example-specs/task/nipype/freesurfer/mr_is_combine_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/mr_is_combine_callables.py
rename to example-specs/task/nipype/freesurfer/mr_is_combine_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/mr_is_convert.yaml b/example-specs/task/nipype/freesurfer/mr_is_convert.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/mr_is_convert.yaml
rename to example-specs/task/nipype/freesurfer/mr_is_convert.yaml
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/mr_is_convert_callables.py b/example-specs/task/nipype/freesurfer/mr_is_convert_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/mr_is_convert_callables.py
rename to example-specs/task/nipype/freesurfer/mr_is_convert_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/mr_is_expand.yaml b/example-specs/task/nipype/freesurfer/mr_is_expand.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/mr_is_expand.yaml
rename to example-specs/task/nipype/freesurfer/mr_is_expand.yaml
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/mr_is_expand_callables.py b/example-specs/task/nipype/freesurfer/mr_is_expand_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/mr_is_expand_callables.py
rename to example-specs/task/nipype/freesurfer/mr_is_expand_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/mr_is_inflate.yaml b/example-specs/task/nipype/freesurfer/mr_is_inflate.yaml
similarity index 96%
rename from example-specs/task/nipype_internal/pydra-freesurfer/mr_is_inflate.yaml
rename to example-specs/task/nipype/freesurfer/mr_is_inflate.yaml
index 6f9e737c..92f046ef 100644
--- a/example-specs/task/nipype_internal/pydra-freesurfer/mr_is_inflate.yaml
+++ b/example-specs/task/nipype/freesurfer/mr_is_inflate.yaml
@@ -33,12 +33,6 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage-freesurfer/pial
     # type=file|default=<undefined>: Input file for MRIsInflate
-    out_file: generic/file
-    # type=file: Output file for MRIsInflate
-    # type=file|default=<undefined>: Output file for MRIsInflate
-    out_sulc: generic/file
-    # type=file: Output sulc file
-    # type=file|default=<undefined>: Output sulc file
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
   metadata:
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/mr_is_inflate_callables.py b/example-specs/task/nipype/freesurfer/mr_is_inflate_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/mr_is_inflate_callables.py
rename to example-specs/task/nipype/freesurfer/mr_is_inflate_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/mri_convert.yaml b/example-specs/task/nipype/freesurfer/mri_convert.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/mri_convert.yaml
rename to example-specs/task/nipype/freesurfer/mri_convert.yaml
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/mri_convert_callables.py b/example-specs/task/nipype/freesurfer/mri_convert_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/mri_convert_callables.py
rename to example-specs/task/nipype/freesurfer/mri_convert_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/mri_coreg.yaml b/example-specs/task/nipype/freesurfer/mri_coreg.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/mri_coreg.yaml
rename to example-specs/task/nipype/freesurfer/mri_coreg.yaml
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/mri_coreg_callables.py b/example-specs/task/nipype/freesurfer/mri_coreg_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/mri_coreg_callables.py
rename to example-specs/task/nipype/freesurfer/mri_coreg_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/mri_fill.yaml b/example-specs/task/nipype/freesurfer/mri_fill.yaml
similarity index 97%
rename from example-specs/task/nipype_internal/pydra-freesurfer/mri_fill.yaml
rename to example-specs/task/nipype/freesurfer/mri_fill.yaml
index 01404180..894b22c7 100644
--- a/example-specs/task/nipype_internal/pydra-freesurfer/mri_fill.yaml
+++ b/example-specs/task/nipype/freesurfer/mri_fill.yaml
@@ -34,9 +34,6 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/mgh-gz
     # type=file|default=<undefined>: Input white matter file
-    out_file: medimage/mgh-gz
-    # type=file: Output file from MRIFill
-    # type=file|default=<undefined>: Output filled volume file name for MRIFill
     segmentation: generic/file
     # type=file|default=<undefined>: Input segmentation file for MRIFill
     transform: generic/file
@@ -114,7 +111,7 @@ tests:
   # (if not specified, will try to choose a sensible value)
     in_file:
     # type=file|default=<undefined>: Input white matter file
-    out_file:
+    out_file: '"filled.mgz" # doctest: +SKIP'
     # type=file: Output file from MRIFill
     # type=file|default=<undefined>: Output filled volume file name for MRIFill
   imports:
@@ -141,7 +138,7 @@ doctests:
   # '.mock()' method of the corresponding class is used instead.
     in_file:
     # type=file|default=<undefined>: Input white matter file
-    out_file:
+    out_file: '"filled.mgz" # doctest: +SKIP'
     # type=file: Output file from MRIFill
     # type=file|default=<undefined>: Output filled volume file name for MRIFill
   imports:
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/mri_fill_callables.py b/example-specs/task/nipype/freesurfer/mri_fill_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/mri_fill_callables.py
rename to example-specs/task/nipype/freesurfer/mri_fill_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/mri_marching_cubes.yaml b/example-specs/task/nipype/freesurfer/mri_marching_cubes.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/mri_marching_cubes.yaml
rename to example-specs/task/nipype/freesurfer/mri_marching_cubes.yaml
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/mri_marching_cubes_callables.py b/example-specs/task/nipype/freesurfer/mri_marching_cubes_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/mri_marching_cubes_callables.py
rename to example-specs/task/nipype/freesurfer/mri_marching_cubes_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/mri_pretess.yaml b/example-specs/task/nipype/freesurfer/mri_pretess.yaml
similarity index 98%
rename from example-specs/task/nipype_internal/pydra-freesurfer/mri_pretess.yaml
rename to example-specs/task/nipype/freesurfer/mri_pretess.yaml
index 9539aa16..92a73eee 100644
--- a/example-specs/task/nipype_internal/pydra-freesurfer/mri_pretess.yaml
+++ b/example-specs/task/nipype/freesurfer/mri_pretess.yaml
@@ -42,9 +42,6 @@ inputs:
     # type=file|default=<undefined>: filled volume, usually wm.mgz
     in_norm: medimage/mgh-gz
     # type=file|default=<undefined>: the normalized, brain-extracted T1w image. Usually norm.mgz
-    out_file: generic/file
-    # type=file: output file after mri_pretess
-    # type=file|default=<undefined>: the output file after mri_pretess.
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
   metadata:
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/mri_pretess_callables.py b/example-specs/task/nipype/freesurfer/mri_pretess_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/mri_pretess_callables.py
rename to example-specs/task/nipype/freesurfer/mri_pretess_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/mri_tessellate.yaml b/example-specs/task/nipype/freesurfer/mri_tessellate.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/mri_tessellate.yaml
rename to example-specs/task/nipype/freesurfer/mri_tessellate.yaml
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/mri_tessellate_callables.py b/example-specs/task/nipype/freesurfer/mri_tessellate_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/mri_tessellate_callables.py
rename to example-specs/task/nipype/freesurfer/mri_tessellate_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/mris_preproc.yaml b/example-specs/task/nipype/freesurfer/mris_preproc.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/mris_preproc.yaml
rename to example-specs/task/nipype/freesurfer/mris_preproc.yaml
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/mris_preproc_callables.py b/example-specs/task/nipype/freesurfer/mris_preproc_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/mris_preproc_callables.py
rename to example-specs/task/nipype/freesurfer/mris_preproc_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/mris_preproc_recon_all.yaml b/example-specs/task/nipype/freesurfer/mris_preproc_recon_all.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/mris_preproc_recon_all.yaml
rename to example-specs/task/nipype/freesurfer/mris_preproc_recon_all.yaml
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/mris_preproc_recon_all_callables.py b/example-specs/task/nipype/freesurfer/mris_preproc_recon_all_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/mris_preproc_recon_all_callables.py
rename to example-specs/task/nipype/freesurfer/mris_preproc_recon_all_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/mrtm.yaml b/example-specs/task/nipype/freesurfer/mrtm.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/mrtm.yaml
rename to example-specs/task/nipype/freesurfer/mrtm.yaml
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/mrtm2.yaml b/example-specs/task/nipype/freesurfer/mrtm2.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/mrtm2.yaml
rename to example-specs/task/nipype/freesurfer/mrtm2.yaml
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/mrtm2_callables.py b/example-specs/task/nipype/freesurfer/mrtm2_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/mrtm2_callables.py
rename to example-specs/task/nipype/freesurfer/mrtm2_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/mrtm_callables.py b/example-specs/task/nipype/freesurfer/mrtm_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/mrtm_callables.py
rename to example-specs/task/nipype/freesurfer/mrtm_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/ms__lda.yaml b/example-specs/task/nipype/freesurfer/ms__lda.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/ms__lda.yaml
rename to example-specs/task/nipype/freesurfer/ms__lda.yaml
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/ms__lda_callables.py b/example-specs/task/nipype/freesurfer/ms__lda_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/ms__lda_callables.py
rename to example-specs/task/nipype/freesurfer/ms__lda_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/normalize.yaml b/example-specs/task/nipype/freesurfer/normalize.yaml
similarity index 97%
rename from example-specs/task/nipype_internal/pydra-freesurfer/normalize.yaml
rename to example-specs/task/nipype/freesurfer/normalize.yaml
index 592b9354..b08139a8 100644
--- a/example-specs/task/nipype_internal/pydra-freesurfer/normalize.yaml
+++ b/example-specs/task/nipype/freesurfer/normalize.yaml
@@ -35,9 +35,6 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/mgh-gz
     # type=file|default=<undefined>: The input file for Normalize
-    out_file: generic/file
-    # type=file: The output file for Normalize
-    # type=file|default=<undefined>: The output file for Normalize
     mask: generic/file
     # type=file|default=<undefined>: The input mask file for Normalize
     segmentation: generic/file
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/normalize_callables.py b/example-specs/task/nipype/freesurfer/normalize_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/normalize_callables.py
rename to example-specs/task/nipype/freesurfer/normalize_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/one_sample_t_test.yaml b/example-specs/task/nipype/freesurfer/one_sample_t_test.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/one_sample_t_test.yaml
rename to example-specs/task/nipype/freesurfer/one_sample_t_test.yaml
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/one_sample_t_test_callables.py b/example-specs/task/nipype/freesurfer/one_sample_t_test_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/one_sample_t_test_callables.py
rename to example-specs/task/nipype/freesurfer/one_sample_t_test_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/paint.yaml b/example-specs/task/nipype/freesurfer/paint.yaml
similarity index 96%
rename from example-specs/task/nipype_internal/pydra-freesurfer/paint.yaml
rename to example-specs/task/nipype/freesurfer/paint.yaml
index 1546a476..0184ca1f 100644
--- a/example-specs/task/nipype_internal/pydra-freesurfer/paint.yaml
+++ b/example-specs/task/nipype/freesurfer/paint.yaml
@@ -41,9 +41,6 @@ inputs:
     # type=file|default=<undefined>: Surface file with grid (vertices) onto which the template data is to be sampled or 'painted'
     template: medimage/mgh-gz
     # type=file|default=<undefined>: Template file
-    out_file: medimage-freesurfer/avg_curv
-    # type=file: File containing a surface-worth of per-vertex values, saved in 'curvature' format.
-    # type=file|default=<undefined>: File containing a surface-worth of per-vertex values, saved in 'curvature' format.
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
   metadata:
@@ -114,7 +111,7 @@ tests:
     # type=file|default=<undefined>: Template file
     averages: '5'
     # type=int|default=0: Average curvature patterns
-    out_file:
+    out_file: '"lh.avg_curv"'
     # type=file: File containing a surface-worth of per-vertex values, saved in 'curvature' format.
     # type=file|default=<undefined>: File containing a surface-worth of per-vertex values, saved in 'curvature' format.
   imports:
@@ -145,7 +142,7 @@ doctests:
     # type=file|default=<undefined>: Template file
     averages: '5'
     # type=int|default=0: Average curvature patterns
-    out_file:
+    out_file: '"lh.avg_curv"'
     # type=file: File containing a surface-worth of per-vertex values, saved in 'curvature' format.
     # type=file|default=<undefined>: File containing a surface-worth of per-vertex values, saved in 'curvature' format.
   imports:
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/paint_callables.py b/example-specs/task/nipype/freesurfer/paint_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/paint_callables.py
rename to example-specs/task/nipype/freesurfer/paint_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/parcellation_stats.yaml b/example-specs/task/nipype/freesurfer/parcellation_stats.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/parcellation_stats.yaml
rename to example-specs/task/nipype/freesurfer/parcellation_stats.yaml
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/parcellation_stats_callables.py b/example-specs/task/nipype/freesurfer/parcellation_stats_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/parcellation_stats_callables.py
rename to example-specs/task/nipype/freesurfer/parcellation_stats_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/parse_dicom_dir.yaml b/example-specs/task/nipype/freesurfer/parse_dicom_dir.yaml
similarity index 97%
rename from example-specs/task/nipype_internal/pydra-freesurfer/parse_dicom_dir.yaml
rename to example-specs/task/nipype/freesurfer/parse_dicom_dir.yaml
index 767f91ed..00c593a7 100644
--- a/example-specs/task/nipype_internal/pydra-freesurfer/parse_dicom_dir.yaml
+++ b/example-specs/task/nipype/freesurfer/parse_dicom_dir.yaml
@@ -33,9 +33,6 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    dicom_info_file: generic/file
-    # type=file: text file containing dicom information
-    # type=file|default='dicominfo.txt': file to which results are written
     dicom_dir: generic/directory
     # type=directory|default=<undefined>: path to siemens dicom directory
     subjects_dir: generic/directory
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/parse_dicom_dir_callables.py b/example-specs/task/nipype/freesurfer/parse_dicom_dir_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/parse_dicom_dir_callables.py
rename to example-specs/task/nipype/freesurfer/parse_dicom_dir_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/recon_all.yaml b/example-specs/task/nipype/freesurfer/recon_all.yaml
similarity index 75%
rename from example-specs/task/nipype_internal/pydra-freesurfer/recon_all.yaml
rename to example-specs/task/nipype/freesurfer/recon_all.yaml
index 1afc192b..7a1deafd 100644
--- a/example-specs/task/nipype_internal/pydra-freesurfer/recon_all.yaml
+++ b/example-specs/task/nipype/freesurfer/recon_all.yaml
@@ -16,7 +16,7 @@
 #     >>> reconall.inputs.subject_id = 'foo'
 #     >>> reconall.inputs.directive = 'all'
 #     >>> reconall.inputs.subjects_dir = '.'
-#     >>> reconall.inputs.T1_files = ['structural.nii']
+#     >>> reconall.inputs.T1_files = 'structural.nii'
 #     >>> reconall.cmdline
 #     'recon-all -all -i structural.nii -subjid foo -sd .'
 #     >>> reconall.inputs.flags = "-qcache"
@@ -46,7 +46,7 @@
 #     >>> reconall_subfields.inputs.subject_id = 'foo'
 #     >>> reconall_subfields.inputs.directive = 'all'
 #     >>> reconall_subfields.inputs.subjects_dir = '.'
-#     >>> reconall_subfields.inputs.T1_files = ['structural.nii']
+#     >>> reconall_subfields.inputs.T1_files = 'structural.nii'
 #     >>> reconall_subfields.inputs.hippocampal_subfields_T1 = True
 #     >>> reconall_subfields.cmdline
 #     'recon-all -all -i structural.nii -hippocampal-subfields-T1 -subjid foo -sd .'
@@ -57,24 +57,6 @@
 #     >>> reconall_subfields.inputs.hippocampal_subfields_T1 = False
 #     >>> reconall_subfields.cmdline
 #     'recon-all -all -i structural.nii -hippocampal-subfields-T2 structural.nii test -subjid foo -sd .'
-# 
-#     Base template creation for longitudinal pipeline:
-#     >>> baserecon = ReconAll()
-#     >>> baserecon.inputs.base_template_id = 'sub-template'
-#     >>> baserecon.inputs.base_timepoint_ids = ['ses-1','ses-2']
-#     >>> baserecon.inputs.directive = 'all'
-#     >>> baserecon.inputs.subjects_dir = '.'
-#     >>> baserecon.cmdline
-#     'recon-all -all -base sub-template -base-tp ses-1 -base-tp ses-2 -sd .'
-# 
-#     Longitudinal timepoint run:
-#     >>> longrecon = ReconAll()
-#     >>> longrecon.inputs.longitudinal_timepoint_id = 'ses-1'
-#     >>> longrecon.inputs.longitudinal_template_id = 'sub-template'
-#     >>> longrecon.inputs.directive = 'all'
-#     >>> longrecon.inputs.subjects_dir = '.'
-#     >>> longrecon.cmdline
-#     'recon-all -all -long ses-1 sub-template -sd .'
 #     
 task_name: ReconAll
 nipype_name: ReconAll
@@ -192,14 +174,6 @@ tests:
     # type=directory|default=<undefined>: path to subjects directory
     flags:
     # type=inputmultiobject|default=[]: additional parameters
-    base_template_id:
-    # type=str|default='': base template id
-    base_timepoint_ids:
-    # type=inputmultiobject|default=[]: processed timepoint to use in template
-    longitudinal_timepoint_id:
-    # type=str|default='': longitudinal session/timepoint id
-    longitudinal_template_id:
-    # type=str|default='': longitudinal base template id
     talairach:
     # type=str|default='': Flags to pass to talairach commands
     mri_normalize:
@@ -375,60 +349,6 @@ tests:
   xfail: true
   # bool - whether the unittest is expected to fail or not. Set to false
   # when you are satisfied with the edits you have made to this file
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    base_template_id: '"sub-template"'
-    # type=str|default='': base template id
-    base_timepoint_ids: '["ses-1","ses-2"]'
-    # type=inputmultiobject|default=[]: processed timepoint to use in template
-    directive: '"all"'
-    # type=enum|default='all'|allowed['all','autorecon-hemi','autorecon-pial','autorecon1','autorecon2','autorecon2-cp','autorecon2-inflate1','autorecon2-perhemi','autorecon2-volonly','autorecon2-wm','autorecon3','autorecon3-T2pial','localGI','qcache']: process directive
-    subjects_dir: '"."'
-    # type=directory: Freesurfer subjects directory.
-    # type=directory|default=<undefined>: path to subjects directory
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    longitudinal_timepoint_id: '"ses-1"'
-    # type=str|default='': longitudinal session/timepoint id
-    longitudinal_template_id: '"sub-template"'
-    # type=str|default='': longitudinal base template id
-    directive: '"all"'
-    # type=enum|default='all'|allowed['all','autorecon-hemi','autorecon-pial','autorecon1','autorecon2','autorecon2-cp','autorecon2-inflate1','autorecon2-perhemi','autorecon2-volonly','autorecon2-wm','autorecon3','autorecon3-T2pial','localGI','qcache']: process directive
-    subjects_dir: '"."'
-    # type=directory: Freesurfer subjects directory.
-    # type=directory|default=<undefined>: path to subjects directory
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
 doctests:
 - cmdline: recon-all -all -i structural.nii -cw256 -qcache -subjid foo -sd .
   # str - the expected cmdline output
@@ -506,43 +426,3 @@ doctests:
   # consisting of 'module', 'name', and optionally 'alias' keys
   directive:
   # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
-- cmdline: recon-all -all -base sub-template -base-tp ses-1 -base-tp ses-2 -sd .
-  # str - the expected cmdline output
-  inputs:
-  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
-  # If the field is of file-format type and the value is None, then the
-  # '.mock()' method of the corresponding class is used instead.
-    base_template_id: '"sub-template"'
-    # type=str|default='': base template id
-    base_timepoint_ids: '["ses-1","ses-2"]'
-    # type=inputmultiobject|default=[]: processed timepoint to use in template
-    directive: '"all"'
-    # type=enum|default='all'|allowed['all','autorecon-hemi','autorecon-pial','autorecon1','autorecon2','autorecon2-cp','autorecon2-inflate1','autorecon2-perhemi','autorecon2-volonly','autorecon2-wm','autorecon3','autorecon3-T2pial','localGI','qcache']: process directive
-    subjects_dir: '"."'
-    # type=directory: Freesurfer subjects directory.
-    # type=directory|default=<undefined>: path to subjects directory
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  directive:
-  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
-- cmdline: recon-all -all -long ses-1 sub-template -sd .
-  # str - the expected cmdline output
-  inputs:
-  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
-  # If the field is of file-format type and the value is None, then the
-  # '.mock()' method of the corresponding class is used instead.
-    longitudinal_timepoint_id: '"ses-1"'
-    # type=str|default='': longitudinal session/timepoint id
-    longitudinal_template_id: '"sub-template"'
-    # type=str|default='': longitudinal base template id
-    directive: '"all"'
-    # type=enum|default='all'|allowed['all','autorecon-hemi','autorecon-pial','autorecon1','autorecon2','autorecon2-cp','autorecon2-inflate1','autorecon2-perhemi','autorecon2-volonly','autorecon2-wm','autorecon3','autorecon3-T2pial','localGI','qcache']: process directive
-    subjects_dir: '"."'
-    # type=directory: Freesurfer subjects directory.
-    # type=directory|default=<undefined>: path to subjects directory
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  directive:
-  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/recon_all_callables.py b/example-specs/task/nipype/freesurfer/recon_all_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/recon_all_callables.py
rename to example-specs/task/nipype/freesurfer/recon_all_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/register.yaml b/example-specs/task/nipype/freesurfer/register.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/register.yaml
rename to example-specs/task/nipype/freesurfer/register.yaml
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/register_av_ito_talairach.yaml b/example-specs/task/nipype/freesurfer/register_av_ito_talairach.yaml
similarity index 98%
rename from example-specs/task/nipype_internal/pydra-freesurfer/register_av_ito_talairach.yaml
rename to example-specs/task/nipype/freesurfer/register_av_ito_talairach.yaml
index 007840a1..b24e9878 100644
--- a/example-specs/task/nipype_internal/pydra-freesurfer/register_av_ito_talairach.yaml
+++ b/example-specs/task/nipype/freesurfer/register_av_ito_talairach.yaml
@@ -50,9 +50,6 @@ inputs:
     # type=file|default=<undefined>: The target file
     vox2vox: text/text-file
     # type=file|default=<undefined>: The vox2vox file
-    out_file: generic/file
-    # type=file: The output file for RegisterAVItoTalairach
-    # type=file|default='talairach.auto.xfm': The transform output
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
   metadata:
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/register_av_ito_talairach_callables.py b/example-specs/task/nipype/freesurfer/register_av_ito_talairach_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/register_av_ito_talairach_callables.py
rename to example-specs/task/nipype/freesurfer/register_av_ito_talairach_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/register_callables.py b/example-specs/task/nipype/freesurfer/register_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/register_callables.py
rename to example-specs/task/nipype/freesurfer/register_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/relabel_hypointensities.yaml b/example-specs/task/nipype/freesurfer/relabel_hypointensities.yaml
similarity index 98%
rename from example-specs/task/nipype_internal/pydra-freesurfer/relabel_hypointensities.yaml
rename to example-specs/task/nipype/freesurfer/relabel_hypointensities.yaml
index f63bcbb4..5eefca06 100644
--- a/example-specs/task/nipype_internal/pydra-freesurfer/relabel_hypointensities.yaml
+++ b/example-specs/task/nipype/freesurfer/relabel_hypointensities.yaml
@@ -39,9 +39,6 @@ inputs:
     # type=file|default=<undefined>: Implicit input file must be rh.white
     aseg: medimage/mgh-gz
     # type=file|default=<undefined>: Input aseg file
-    out_file: generic/file
-    # type=file: Output aseg file
-    # type=file|default=<undefined>: Output aseg file
     surf_directory: generic/directory
     # type=directory|default='.': Directory containing lh.white and rh.white
     subjects_dir: generic/directory
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/relabel_hypointensities_callables.py b/example-specs/task/nipype/freesurfer/relabel_hypointensities_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/relabel_hypointensities_callables.py
rename to example-specs/task/nipype/freesurfer/relabel_hypointensities_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/remove_intersection.yaml b/example-specs/task/nipype/freesurfer/remove_intersection.yaml
similarity index 97%
rename from example-specs/task/nipype_internal/pydra-freesurfer/remove_intersection.yaml
rename to example-specs/task/nipype/freesurfer/remove_intersection.yaml
index 43652f90..cf7102bc 100644
--- a/example-specs/task/nipype_internal/pydra-freesurfer/remove_intersection.yaml
+++ b/example-specs/task/nipype/freesurfer/remove_intersection.yaml
@@ -32,9 +32,6 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage-freesurfer/pial
     # type=file|default=<undefined>: Input file for RemoveIntersection
-    out_file: generic/file
-    # type=file: Output file for RemoveIntersection
-    # type=file|default=<undefined>: Output file for RemoveIntersection
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
   metadata:
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/remove_intersection_callables.py b/example-specs/task/nipype/freesurfer/remove_intersection_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/remove_intersection_callables.py
rename to example-specs/task/nipype/freesurfer/remove_intersection_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/remove_neck.yaml b/example-specs/task/nipype/freesurfer/remove_neck.yaml
similarity index 98%
rename from example-specs/task/nipype_internal/pydra-freesurfer/remove_neck.yaml
rename to example-specs/task/nipype/freesurfer/remove_neck.yaml
index 96931db4..71797446 100644
--- a/example-specs/task/nipype_internal/pydra-freesurfer/remove_neck.yaml
+++ b/example-specs/task/nipype/freesurfer/remove_neck.yaml
@@ -35,9 +35,6 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/mgh-gz
     # type=file|default=<undefined>: Input file for RemoveNeck
-    out_file: generic/file
-    # type=file: Output file with neck removed
-    # type=file|default=<undefined>: Output file for RemoveNeck
     transform: datascience/text-matrix
     # type=file|default=<undefined>: Input transform file for RemoveNeck
     template: datascience/text-matrix
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/remove_neck_callables.py b/example-specs/task/nipype/freesurfer/remove_neck_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/remove_neck_callables.py
rename to example-specs/task/nipype/freesurfer/remove_neck_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/resample.yaml b/example-specs/task/nipype/freesurfer/resample.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/resample.yaml
rename to example-specs/task/nipype/freesurfer/resample.yaml
diff --git a/example-specs/task/nipype_internal/pydra-dipy/resample_callables.py b/example-specs/task/nipype/freesurfer/resample_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-dipy/resample_callables.py
rename to example-specs/task/nipype/freesurfer/resample_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/robust_register.yaml b/example-specs/task/nipype/freesurfer/robust_register.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/robust_register.yaml
rename to example-specs/task/nipype/freesurfer/robust_register.yaml
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/robust_register_callables.py b/example-specs/task/nipype/freesurfer/robust_register_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/robust_register_callables.py
rename to example-specs/task/nipype/freesurfer/robust_register_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/robust_template.yaml b/example-specs/task/nipype/freesurfer/robust_template.yaml
similarity index 97%
rename from example-specs/task/nipype_internal/pydra-freesurfer/robust_template.yaml
rename to example-specs/task/nipype/freesurfer/robust_template.yaml
index a71baf75..ddd4e0cf 100644
--- a/example-specs/task/nipype_internal/pydra-freesurfer/robust_template.yaml
+++ b/example-specs/task/nipype/freesurfer/robust_template.yaml
@@ -59,9 +59,6 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_files: medimage/nifti1+list-of
     # type=inputmultiobject|default=[]: input movable volumes to be aligned to common mean/median template
-    out_file: medimage/nifti1
-    # type=file: output template volume (final mean/median image)
-    # type=file|default='mri_robust_template_out.mgz': output template volume (final mean/median image)
     initial_transforms: generic/file+list-of
     # type=inputmultiobject|default=[]: use initial transforms (lta) on source
     in_intensity_scales: generic/file+list-of
@@ -117,7 +114,7 @@ tests:
     average_metric:
     # type=enum|default='median'|allowed['mean','median']: construct template from: 0 Mean, 1 Median (default)
     initial_timepoint:
-    # type=int|default=0: use TP# for special init (default random), 0: no init
+    # type=int|default=0: use TP# for spacial init (default random), 0: no init
     fixed_timepoint:
     # type=bool|default=False: map everything to init TP# (init TP is not resampled)
     no_iteration:
@@ -159,14 +156,14 @@ tests:
     average_metric: '"mean"'
     # type=enum|default='median'|allowed['mean','median']: construct template from: 0 Mean, 1 Median (default)
     initial_timepoint: '1'
-    # type=int|default=0: use TP# for special init (default random), 0: no init
+    # type=int|default=0: use TP# for spacial init (default random), 0: no init
     fixed_timepoint: 'True'
     # type=bool|default=False: map everything to init TP# (init TP is not resampled)
     no_iteration: 'True'
     # type=bool|default=False: do not iterate, just create first template
     subsample_threshold: '200'
     # type=int|default=0: subsample if dim > # on all axes (default no subs.)
-    out_file:
+    out_file: '"T1.nii"'
     # type=file: output template volume (final mean/median image)
     # type=file|default='mri_robust_template_out.mgz': output template volume (final mean/median image)
   imports:
@@ -246,14 +243,14 @@ doctests:
     average_metric: '"mean"'
     # type=enum|default='median'|allowed['mean','median']: construct template from: 0 Mean, 1 Median (default)
     initial_timepoint: '1'
-    # type=int|default=0: use TP# for special init (default random), 0: no init
+    # type=int|default=0: use TP# for spacial init (default random), 0: no init
     fixed_timepoint: 'True'
     # type=bool|default=False: map everything to init TP# (init TP is not resampled)
     no_iteration: 'True'
     # type=bool|default=False: do not iterate, just create first template
     subsample_threshold: '200'
     # type=int|default=0: subsample if dim > # on all axes (default no subs.)
-    out_file:
+    out_file: '"T1.nii"'
     # type=file: output template volume (final mean/median image)
     # type=file|default='mri_robust_template_out.mgz': output template volume (final mean/median image)
   imports:
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/robust_template_callables.py b/example-specs/task/nipype/freesurfer/robust_template_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/robust_template_callables.py
rename to example-specs/task/nipype/freesurfer/robust_template_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/sample_to_surface.yaml b/example-specs/task/nipype/freesurfer/sample_to_surface.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/sample_to_surface.yaml
rename to example-specs/task/nipype/freesurfer/sample_to_surface.yaml
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/sample_to_surface_callables.py b/example-specs/task/nipype/freesurfer/sample_to_surface_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/sample_to_surface_callables.py
rename to example-specs/task/nipype/freesurfer/sample_to_surface_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/seg_stats.yaml b/example-specs/task/nipype/freesurfer/seg_stats.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/seg_stats.yaml
rename to example-specs/task/nipype/freesurfer/seg_stats.yaml
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/seg_stats_callables.py b/example-specs/task/nipype/freesurfer/seg_stats_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/seg_stats_callables.py
rename to example-specs/task/nipype/freesurfer/seg_stats_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/seg_stats_recon_all.yaml b/example-specs/task/nipype/freesurfer/seg_stats_recon_all.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/seg_stats_recon_all.yaml
rename to example-specs/task/nipype/freesurfer/seg_stats_recon_all.yaml
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/seg_stats_recon_all_callables.py b/example-specs/task/nipype/freesurfer/seg_stats_recon_all_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/seg_stats_recon_all_callables.py
rename to example-specs/task/nipype/freesurfer/seg_stats_recon_all_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/segment_cc.yaml b/example-specs/task/nipype/freesurfer/segment_cc.yaml
similarity index 95%
rename from example-specs/task/nipype_internal/pydra-freesurfer/segment_cc.yaml
rename to example-specs/task/nipype/freesurfer/segment_cc.yaml
index 58a497df..79ba3f6b 100644
--- a/example-specs/task/nipype_internal/pydra-freesurfer/segment_cc.yaml
+++ b/example-specs/task/nipype/freesurfer/segment_cc.yaml
@@ -44,12 +44,6 @@ inputs:
     # type=file|default=<undefined>: Input aseg file to read from subjects directory
     in_norm: medimage/mgh-gz
     # type=file|default=<undefined>: Required undocumented input {subject}/mri/norm.mgz
-    out_file: generic/file
-    # type=file: Output segmentation uncluding corpus collosum
-    # type=file|default=<undefined>: Filename to write aseg including CC
-    out_rotation: medimage-freesurfer/lta
-    # type=file: Output lta rotation file
-    # type=file|default=<undefined>: Global filepath for writing rotation lta
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
   metadata:
@@ -124,7 +118,7 @@ tests:
     # type=file|default=<undefined>: Input aseg file to read from subjects directory
     in_norm:
     # type=file|default=<undefined>: Required undocumented input {subject}/mri/norm.mgz
-    out_rotation:
+    out_rotation: '"cc.lta"'
     # type=file: Output lta rotation file
     # type=file|default=<undefined>: Global filepath for writing rotation lta
     subject_id: '"test"'
@@ -155,7 +149,7 @@ doctests:
     # type=file|default=<undefined>: Input aseg file to read from subjects directory
     in_norm:
     # type=file|default=<undefined>: Required undocumented input {subject}/mri/norm.mgz
-    out_rotation:
+    out_rotation: '"cc.lta"'
     # type=file: Output lta rotation file
     # type=file|default=<undefined>: Global filepath for writing rotation lta
     subject_id: '"test"'
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/segment_cc_callables.py b/example-specs/task/nipype/freesurfer/segment_cc_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/segment_cc_callables.py
rename to example-specs/task/nipype/freesurfer/segment_cc_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/segment_wm.yaml b/example-specs/task/nipype/freesurfer/segment_wm.yaml
similarity index 97%
rename from example-specs/task/nipype_internal/pydra-freesurfer/segment_wm.yaml
rename to example-specs/task/nipype/freesurfer/segment_wm.yaml
index 987bdbe2..4878172d 100644
--- a/example-specs/task/nipype_internal/pydra-freesurfer/segment_wm.yaml
+++ b/example-specs/task/nipype/freesurfer/segment_wm.yaml
@@ -36,9 +36,6 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/mgh-gz
     # type=file|default=<undefined>: Input file for SegmentWM
-    out_file: medimage/mgh-gz
-    # type=file: Output white matter segmentation
-    # type=file|default=<undefined>: File to be written as output for SegmentWM
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
   metadata:
@@ -99,7 +96,7 @@ tests:
   # (if not specified, will try to choose a sensible value)
     in_file:
     # type=file|default=<undefined>: Input file for SegmentWM
-    out_file:
+    out_file: '"wm.seg.mgz"'
     # type=file: Output white matter segmentation
     # type=file|default=<undefined>: File to be written as output for SegmentWM
   imports:
@@ -126,7 +123,7 @@ doctests:
   # '.mock()' method of the corresponding class is used instead.
     in_file:
     # type=file|default=<undefined>: Input file for SegmentWM
-    out_file:
+    out_file: '"wm.seg.mgz"'
     # type=file: Output white matter segmentation
     # type=file|default=<undefined>: File to be written as output for SegmentWM
   imports:
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/segment_wm_callables.py b/example-specs/task/nipype/freesurfer/segment_wm_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/segment_wm_callables.py
rename to example-specs/task/nipype/freesurfer/segment_wm_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/smooth.yaml b/example-specs/task/nipype/freesurfer/smooth.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/smooth.yaml
rename to example-specs/task/nipype/freesurfer/smooth.yaml
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/smooth_callables.py b/example-specs/task/nipype/freesurfer/smooth_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/smooth_callables.py
rename to example-specs/task/nipype/freesurfer/smooth_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/smooth_tessellation.yaml b/example-specs/task/nipype/freesurfer/smooth_tessellation.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/smooth_tessellation.yaml
rename to example-specs/task/nipype/freesurfer/smooth_tessellation.yaml
index ee00618b..2763de80 100644
--- a/example-specs/task/nipype_internal/pydra-freesurfer/smooth_tessellation.yaml
+++ b/example-specs/task/nipype/freesurfer/smooth_tessellation.yaml
@@ -37,10 +37,6 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: generic/file
     # type=file|default=<undefined>: Input volume to tessellate voxels from.
-    out_curvature_file: generic/file
-    # type=file|default=<undefined>: Write curvature to ``?h.curvname`` (default "curv")
-    out_area_file: generic/file
-    # type=file|default=<undefined>: Write area to ``?h.areaname`` (default "area")
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
   metadata:
@@ -56,6 +52,10 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    out_curvature_file: generic/file
+    # type=file|default=<undefined>: Write curvature to ``?h.curvname`` (default "curv")
+    out_area_file: generic/file
+    # type=file|default=<undefined>: Write area to ``?h.areaname`` (default "area")
     surface: generic/file
     # type=file: Smoothed surface file.
   callables:
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/smooth_tessellation_callables.py b/example-specs/task/nipype/freesurfer/smooth_tessellation_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/smooth_tessellation_callables.py
rename to example-specs/task/nipype/freesurfer/smooth_tessellation_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/sphere.yaml b/example-specs/task/nipype/freesurfer/sphere.yaml
similarity index 98%
rename from example-specs/task/nipype_internal/pydra-freesurfer/sphere.yaml
rename to example-specs/task/nipype/freesurfer/sphere.yaml
index f7a15dff..e1644dc1 100644
--- a/example-specs/task/nipype_internal/pydra-freesurfer/sphere.yaml
+++ b/example-specs/task/nipype/freesurfer/sphere.yaml
@@ -32,9 +32,6 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage-freesurfer/pial
     # type=file|default=<undefined>: Input file for Sphere
-    out_file: generic/file
-    # type=file: Output file for Sphere
-    # type=file|default=<undefined>: Output file for Sphere
     in_smoothwm: generic/file
     # type=file|default=<undefined>: Input surface required when -q flag is not selected
     subjects_dir: generic/directory
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/sphere_callables.py b/example-specs/task/nipype/freesurfer/sphere_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/sphere_callables.py
rename to example-specs/task/nipype/freesurfer/sphere_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/spherical_average.yaml b/example-specs/task/nipype/freesurfer/spherical_average.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/spherical_average.yaml
rename to example-specs/task/nipype/freesurfer/spherical_average.yaml
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/spherical_average_callables.py b/example-specs/task/nipype/freesurfer/spherical_average_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/spherical_average_callables.py
rename to example-specs/task/nipype/freesurfer/spherical_average_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/surface_2_vol_transform.yaml b/example-specs/task/nipype/freesurfer/surface_2_vol_transform.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/surface_2_vol_transform.yaml
rename to example-specs/task/nipype/freesurfer/surface_2_vol_transform.yaml
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/surface_2_vol_transform_callables.py b/example-specs/task/nipype/freesurfer/surface_2_vol_transform_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/surface_2_vol_transform_callables.py
rename to example-specs/task/nipype/freesurfer/surface_2_vol_transform_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/surface_smooth.yaml b/example-specs/task/nipype/freesurfer/surface_smooth.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/surface_smooth.yaml
rename to example-specs/task/nipype/freesurfer/surface_smooth.yaml
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/surface_smooth_callables.py b/example-specs/task/nipype/freesurfer/surface_smooth_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/surface_smooth_callables.py
rename to example-specs/task/nipype/freesurfer/surface_smooth_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/surface_snapshots.yaml b/example-specs/task/nipype/freesurfer/surface_snapshots.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/surface_snapshots.yaml
rename to example-specs/task/nipype/freesurfer/surface_snapshots.yaml
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/surface_snapshots_callables.py b/example-specs/task/nipype/freesurfer/surface_snapshots_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/surface_snapshots_callables.py
rename to example-specs/task/nipype/freesurfer/surface_snapshots_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/surface_transform.yaml b/example-specs/task/nipype/freesurfer/surface_transform.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/surface_transform.yaml
rename to example-specs/task/nipype/freesurfer/surface_transform.yaml
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/surface_transform_callables.py b/example-specs/task/nipype/freesurfer/surface_transform_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/surface_transform_callables.py
rename to example-specs/task/nipype/freesurfer/surface_transform_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/synthesize_flash.yaml b/example-specs/task/nipype/freesurfer/synthesize_flash.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/synthesize_flash.yaml
rename to example-specs/task/nipype/freesurfer/synthesize_flash.yaml
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/synthesize_flash_callables.py b/example-specs/task/nipype/freesurfer/synthesize_flash_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/synthesize_flash_callables.py
rename to example-specs/task/nipype/freesurfer/synthesize_flash_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/talairach_avi.yaml b/example-specs/task/nipype/freesurfer/talairach_avi.yaml
similarity index 97%
rename from example-specs/task/nipype_internal/pydra-freesurfer/talairach_avi.yaml
rename to example-specs/task/nipype/freesurfer/talairach_avi.yaml
index 1e264a42..b1a5d280 100644
--- a/example-specs/task/nipype_internal/pydra-freesurfer/talairach_avi.yaml
+++ b/example-specs/task/nipype/freesurfer/talairach_avi.yaml
@@ -40,9 +40,6 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/mgh-gz
     # type=file|default=<undefined>: input volume
-    out_file: datascience/text-matrix
-    # type=file: The output transform for TalairachAVI
-    # type=file|default=<undefined>: output xfm file
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
   metadata:
@@ -109,7 +106,7 @@ tests:
   # (if not specified, will try to choose a sensible value)
     in_file:
     # type=file|default=<undefined>: input volume
-    out_file:
+    out_file: '"trans.mat"'
     # type=file: The output transform for TalairachAVI
     # type=file|default=<undefined>: output xfm file
   imports:
@@ -136,7 +133,7 @@ doctests:
   # '.mock()' method of the corresponding class is used instead.
     in_file:
     # type=file|default=<undefined>: input volume
-    out_file:
+    out_file: '"trans.mat"'
     # type=file: The output transform for TalairachAVI
     # type=file|default=<undefined>: output xfm file
   imports:
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/talairach_avi_callables.py b/example-specs/task/nipype/freesurfer/talairach_avi_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/talairach_avi_callables.py
rename to example-specs/task/nipype/freesurfer/talairach_avi_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/talairach_qc.yaml b/example-specs/task/nipype/freesurfer/talairach_qc.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/talairach_qc.yaml
rename to example-specs/task/nipype/freesurfer/talairach_qc.yaml
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/talairach_qc_callables.py b/example-specs/task/nipype/freesurfer/talairach_qc_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/talairach_qc_callables.py
rename to example-specs/task/nipype/freesurfer/talairach_qc_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/tkregister_2.yaml b/example-specs/task/nipype/freesurfer/tkregister_2.yaml
similarity index 98%
rename from example-specs/task/nipype_internal/pydra-freesurfer/tkregister_2.yaml
rename to example-specs/task/nipype/freesurfer/tkregister_2.yaml
index 756cdb5b..d8d85f33 100644
--- a/example-specs/task/nipype_internal/pydra-freesurfer/tkregister_2.yaml
+++ b/example-specs/task/nipype/freesurfer/tkregister_2.yaml
@@ -59,9 +59,6 @@ inputs:
     # type=file|default=<undefined>: use a matrix in MNI coordinates as initial registration
     lta_in: generic/file
     # type=file|default=<undefined>: use a matrix in MNI coordinates as initial registration
-    reg_file: datascience/dat-file
-    # type=file: freesurfer-style registration file
-    # type=file|default='register.dat': freesurfer-style registration file
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
   metadata:
@@ -158,7 +155,7 @@ tests:
     # type=file|default=<undefined>: target volume
     reg_header: 'True'
     # type=bool|default=False: compute regstration from headers
-    reg_file:
+    reg_file: '"T1_to_native.dat"'
     # type=file: freesurfer-style registration file
     # type=file|default='register.dat': freesurfer-style registration file
   imports:
@@ -211,7 +208,7 @@ doctests:
     # type=file|default=<undefined>: target volume
     reg_header: 'True'
     # type=bool|default=False: compute regstration from headers
-    reg_file:
+    reg_file: '"T1_to_native.dat"'
     # type=file: freesurfer-style registration file
     # type=file|default='register.dat': freesurfer-style registration file
   imports:
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/tkregister_2_callables.py b/example-specs/task/nipype/freesurfer/tkregister_2_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/tkregister_2_callables.py
rename to example-specs/task/nipype/freesurfer/tkregister_2_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/unpack_sdicom_dir.yaml b/example-specs/task/nipype/freesurfer/unpack_sdicom_dir.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/unpack_sdicom_dir.yaml
rename to example-specs/task/nipype/freesurfer/unpack_sdicom_dir.yaml
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/unpack_sdicom_dir_callables.py b/example-specs/task/nipype/freesurfer/unpack_sdicom_dir_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/unpack_sdicom_dir_callables.py
rename to example-specs/task/nipype/freesurfer/unpack_sdicom_dir_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/volume_mask.yaml b/example-specs/task/nipype/freesurfer/volume_mask.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/volume_mask.yaml
rename to example-specs/task/nipype/freesurfer/volume_mask.yaml
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/volume_mask_callables.py b/example-specs/task/nipype/freesurfer/volume_mask_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/volume_mask_callables.py
rename to example-specs/task/nipype/freesurfer/volume_mask_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/watershed_skull_strip.yaml b/example-specs/task/nipype/freesurfer/watershed_skull_strip.yaml
similarity index 97%
rename from example-specs/task/nipype_internal/pydra-freesurfer/watershed_skull_strip.yaml
rename to example-specs/task/nipype/freesurfer/watershed_skull_strip.yaml
index 627c9ce0..66ad18d4 100644
--- a/example-specs/task/nipype_internal/pydra-freesurfer/watershed_skull_strip.yaml
+++ b/example-specs/task/nipype/freesurfer/watershed_skull_strip.yaml
@@ -45,9 +45,6 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/mgh-gz
     # type=file|default=<undefined>: input volume
-    out_file: medimage/mgh-gz
-    # type=file: skull stripped brain volume
-    # type=file|default='brainmask.auto.mgz': output volume
     brain_atlas: generic/file
     # type=file|default=<undefined>: 
     transform: medimage-freesurfer/lta
@@ -122,7 +119,7 @@ tests:
     # type=bool|default=False: specify T1 input volume (T1 grey value = 110)
     transform:
     # type=file|default=<undefined>: undocumented
-    out_file:
+    out_file: '"brainmask.auto.mgz"'
     # type=file: skull stripped brain volume
     # type=file|default='brainmask.auto.mgz': output volume
   imports:
@@ -153,7 +150,7 @@ doctests:
     # type=bool|default=False: specify T1 input volume (T1 grey value = 110)
     transform:
     # type=file|default=<undefined>: undocumented
-    out_file:
+    out_file: '"brainmask.auto.mgz"'
     # type=file: skull stripped brain volume
     # type=file|default='brainmask.auto.mgz': output volume
   imports:
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/watershed_skull_strip_callables.py b/example-specs/task/nipype/freesurfer/watershed_skull_strip_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-freesurfer/watershed_skull_strip_callables.py
rename to example-specs/task/nipype/freesurfer/watershed_skull_strip_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/accuracy_tester.yaml b/example-specs/task/nipype/fsl/accuracy_tester.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/accuracy_tester.yaml
rename to example-specs/task/nipype/fsl/accuracy_tester.yaml
diff --git a/example-specs/task/nipype_internal/pydra-fsl/accuracy_tester_callables.py b/example-specs/task/nipype/fsl/accuracy_tester_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/accuracy_tester_callables.py
rename to example-specs/task/nipype/fsl/accuracy_tester_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/apply_mask.yaml b/example-specs/task/nipype/fsl/apply_mask.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/apply_mask.yaml
rename to example-specs/task/nipype/fsl/apply_mask.yaml
diff --git a/example-specs/task/nipype_internal/pydra-fsl/apply_mask_callables.py b/example-specs/task/nipype/fsl/apply_mask_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/apply_mask_callables.py
rename to example-specs/task/nipype/fsl/apply_mask_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/apply_topup.yaml b/example-specs/task/nipype/fsl/apply_topup.yaml
similarity index 98%
rename from example-specs/task/nipype_internal/pydra-fsl/apply_topup.yaml
rename to example-specs/task/nipype/fsl/apply_topup.yaml
index 10f58e9b..2a5ae1e0 100644
--- a/example-specs/task/nipype_internal/pydra-fsl/apply_topup.yaml
+++ b/example-specs/task/nipype/fsl/apply_topup.yaml
@@ -51,9 +51,6 @@ inputs:
     # type=file|default=<undefined>: topup file containing the field coefficients
     in_topup_movpar: text/text-file
     # type=file|default=<undefined>: topup movpar.txt file
-    out_corrected: generic/file
-    # type=file: name of 4D image file with unwarped images
-    # type=file|default=<undefined>: output (warped) image
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype_internal/pydra-fsl/apply_topup_callables.py b/example-specs/task/nipype/fsl/apply_topup_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/apply_topup_callables.py
rename to example-specs/task/nipype/fsl/apply_topup_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/apply_warp.yaml b/example-specs/task/nipype/fsl/apply_warp.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/apply_warp.yaml
rename to example-specs/task/nipype/fsl/apply_warp.yaml
diff --git a/example-specs/task/nipype_internal/pydra-elastix/apply_warp_callables.py b/example-specs/task/nipype/fsl/apply_warp_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-elastix/apply_warp_callables.py
rename to example-specs/task/nipype/fsl/apply_warp_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/apply_xfm.yaml b/example-specs/task/nipype/fsl/apply_xfm.yaml
similarity index 95%
rename from example-specs/task/nipype_internal/pydra-fsl/apply_xfm.yaml
rename to example-specs/task/nipype/fsl/apply_xfm.yaml
index 5d4f853c..2b2880a4 100644
--- a/example-specs/task/nipype_internal/pydra-fsl/apply_xfm.yaml
+++ b/example-specs/task/nipype/fsl/apply_xfm.yaml
@@ -43,15 +43,6 @@ inputs:
     # type=file|default=<undefined>: input file
     reference: generic/file
     # type=file|default=<undefined>: reference file
-    out_file: generic/file
-    # type=file: path/name of registered file (if generated)
-    # type=file|default=<undefined>: registered output file
-    out_matrix_file: generic/file
-    # type=file: path/name of calculated affine transform (if generated)
-    # type=file|default=<undefined>: output affine matrix in 4x4 asciii format
-    out_log: generic/file
-    # type=file: path/name of output log (if generated)
-    # type=file|default=<undefined>: output log
     in_matrix_file: generic/file
     # type=file|default=<undefined>: input 4x4 affine matrix
     schedule: generic/file
diff --git a/example-specs/task/nipype_internal/pydra-fsl/apply_xfm_callables.py b/example-specs/task/nipype/fsl/apply_xfm_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/apply_xfm_callables.py
rename to example-specs/task/nipype/fsl/apply_xfm_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/ar1_image.yaml b/example-specs/task/nipype/fsl/ar1_image.yaml
similarity index 99%
rename from example-specs/task/nipype_internal/pydra-fsl/ar1_image.yaml
rename to example-specs/task/nipype/fsl/ar1_image.yaml
index d88777ab..b6ca33d6 100644
--- a/example-specs/task/nipype_internal/pydra-fsl/ar1_image.yaml
+++ b/example-specs/task/nipype/fsl/ar1_image.yaml
@@ -56,7 +56,7 @@ tests:
   # dict[str, str] - values to provide to inputs fields in the task initialisation
   # (if not specified, will try to choose a sensible value)
     dimension:
-    # type=enum|default='T'|allowed['T','X','Y','Z']: dimension to find AR(1) coefficient across
+    # type=enum|default='T'|allowed['T','X','Y','Z']: dimension to find AR(1) coefficientacross
     in_file:
     # type=file|default=<undefined>: image to operate on
     out_file:
diff --git a/example-specs/task/nipype_internal/pydra-fsl/ar1_image_callables.py b/example-specs/task/nipype/fsl/ar1_image_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/ar1_image_callables.py
rename to example-specs/task/nipype/fsl/ar1_image_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/av_scale.yaml b/example-specs/task/nipype/fsl/av_scale.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/av_scale.yaml
rename to example-specs/task/nipype/fsl/av_scale.yaml
diff --git a/example-specs/task/nipype_internal/pydra-fsl/av_scale_callables.py b/example-specs/task/nipype/fsl/av_scale_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/av_scale_callables.py
rename to example-specs/task/nipype/fsl/av_scale_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/b0_calc.yaml b/example-specs/task/nipype/fsl/b0_calc.yaml
similarity index 98%
rename from example-specs/task/nipype_internal/pydra-fsl/b0_calc.yaml
rename to example-specs/task/nipype/fsl/b0_calc.yaml
index cff8344c..2508aaa4 100644
--- a/example-specs/task/nipype_internal/pydra-fsl/b0_calc.yaml
+++ b/example-specs/task/nipype/fsl/b0_calc.yaml
@@ -39,9 +39,6 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/nifti1
     # type=file|default=<undefined>: filename of input image (usually a tissue/air segmentation)
-    out_file: generic/file
-    # type=file: filename of B0 output volume
-    # type=file|default=<undefined>: filename of B0 output volume
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype_internal/pydra-fsl/b0_calc_callables.py b/example-specs/task/nipype/fsl/b0_calc_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/b0_calc_callables.py
rename to example-specs/task/nipype/fsl/b0_calc_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/bedpostx5.yaml b/example-specs/task/nipype/fsl/bedpostx5.yaml
similarity index 99%
rename from example-specs/task/nipype_internal/pydra-fsl/bedpostx5.yaml
rename to example-specs/task/nipype/fsl/bedpostx5.yaml
index d9b0585f..d22f95a3 100644
--- a/example-specs/task/nipype_internal/pydra-fsl/bedpostx5.yaml
+++ b/example-specs/task/nipype/fsl/bedpostx5.yaml
@@ -73,7 +73,7 @@ outputs:
     mean_dsamples: generic/file
     # type=file: Mean of distribution on diffusivity d
     mean_S0samples: generic/file
-    # type=file: Mean of distribution on T2w baseline signal intensity S0
+    # type=file: Mean of distribution on T2wbaseline signal intensity S0
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype_internal/pydra-fsl/bedpostx5_callables.py b/example-specs/task/nipype/fsl/bedpostx5_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/bedpostx5_callables.py
rename to example-specs/task/nipype/fsl/bedpostx5_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/bet.yaml b/example-specs/task/nipype/fsl/bet.yaml
similarity index 96%
rename from example-specs/task/nipype_internal/pydra-fsl/bet.yaml
rename to example-specs/task/nipype/fsl/bet.yaml
index a0c81937..2ed11121 100644
--- a/example-specs/task/nipype_internal/pydra-fsl/bet.yaml
+++ b/example-specs/task/nipype/fsl/bet.yaml
@@ -29,16 +29,6 @@ inputs:
   omit:
   # list[str] - fields to omit from the Pydra interface
   rename:
-    in_file: input_image
-    out_file: output_image
-    outline: save_brain_surface_outline
-    mask: save_brain_mask
-    skull: save_skull_image
-    mesh: save_brain_surface_mesh
-    frac: fractional_intensity_threshold
-    radius: head_radius
-    center: center_of_gravity
-    threshold: apply_thresholding
   # dict[str, str] - fields to rename in the Pydra interface
   types:
   # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
diff --git a/example-specs/task/nipype_internal/pydra-fsl/bet_callables.py b/example-specs/task/nipype/fsl/bet_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/bet_callables.py
rename to example-specs/task/nipype/fsl/bet_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/binary_maths.yaml b/example-specs/task/nipype/fsl/binary_maths.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/binary_maths.yaml
rename to example-specs/task/nipype/fsl/binary_maths.yaml
diff --git a/example-specs/task/nipype_internal/pydra-fsl/binary_maths_callables.py b/example-specs/task/nipype/fsl/binary_maths_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/binary_maths_callables.py
rename to example-specs/task/nipype/fsl/binary_maths_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/change_data_type.yaml b/example-specs/task/nipype/fsl/change_data_type.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/change_data_type.yaml
rename to example-specs/task/nipype/fsl/change_data_type.yaml
diff --git a/example-specs/task/nipype_internal/pydra-fsl/change_data_type_callables.py b/example-specs/task/nipype/fsl/change_data_type_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/change_data_type_callables.py
rename to example-specs/task/nipype/fsl/change_data_type_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/classifier.yaml b/example-specs/task/nipype/fsl/classifier.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/classifier.yaml
rename to example-specs/task/nipype/fsl/classifier.yaml
diff --git a/example-specs/task/nipype_internal/pydra-fsl/classifier_callables.py b/example-specs/task/nipype/fsl/classifier_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/classifier_callables.py
rename to example-specs/task/nipype/fsl/classifier_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/cleaner.yaml b/example-specs/task/nipype/fsl/cleaner.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/cleaner.yaml
rename to example-specs/task/nipype/fsl/cleaner.yaml
diff --git a/example-specs/task/nipype_internal/pydra-fsl/cleaner_callables.py b/example-specs/task/nipype/fsl/cleaner_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/cleaner_callables.py
rename to example-specs/task/nipype/fsl/cleaner_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/cluster.yaml b/example-specs/task/nipype/fsl/cluster.yaml
similarity index 98%
rename from example-specs/task/nipype_internal/pydra-fsl/cluster.yaml
rename to example-specs/task/nipype/fsl/cluster.yaml
index aeb8e2be..75f69e45 100644
--- a/example-specs/task/nipype_internal/pydra-fsl/cluster.yaml
+++ b/example-specs/task/nipype/fsl/cluster.yaml
@@ -42,7 +42,7 @@ inputs:
     std_space_file: generic/file
     # type=file|default=<undefined>: filename for standard-space volume
     warpfield_file: generic/file
-    # type=file|default=<undefined>: file containing warpfield
+    # type=file|default=<undefined>: file contining warpfield
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -132,7 +132,7 @@ tests:
     num_maxima:
     # type=int|default=0: no of local maxima to report
     warpfield_file:
-    # type=file|default=<undefined>: file containing warpfield
+    # type=file|default=<undefined>: file contining warpfield
     output_type:
     # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
     args:
diff --git a/example-specs/task/nipype_internal/pydra-fsl/cluster_callables.py b/example-specs/task/nipype/fsl/cluster_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/cluster_callables.py
rename to example-specs/task/nipype/fsl/cluster_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/complex.yaml b/example-specs/task/nipype/fsl/complex.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/complex.yaml
rename to example-specs/task/nipype/fsl/complex.yaml
diff --git a/example-specs/task/nipype_internal/pydra-fsl/complex_callables.py b/example-specs/task/nipype/fsl/complex_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/complex_callables.py
rename to example-specs/task/nipype/fsl/complex_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/contrast_mgr.yaml b/example-specs/task/nipype/fsl/contrast_mgr.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/contrast_mgr.yaml
rename to example-specs/task/nipype/fsl/contrast_mgr.yaml
diff --git a/example-specs/task/nipype_internal/pydra-fsl/contrast_mgr_callables.py b/example-specs/task/nipype/fsl/contrast_mgr_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/contrast_mgr_callables.py
rename to example-specs/task/nipype/fsl/contrast_mgr_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/convert_warp.yaml b/example-specs/task/nipype/fsl/convert_warp.yaml
similarity index 97%
rename from example-specs/task/nipype_internal/pydra-fsl/convert_warp.yaml
rename to example-specs/task/nipype/fsl/convert_warp.yaml
index 9d8703a1..2f9f22b0 100644
--- a/example-specs/task/nipype_internal/pydra-fsl/convert_warp.yaml
+++ b/example-specs/task/nipype/fsl/convert_warp.yaml
@@ -40,9 +40,6 @@ inputs:
   # passed to the field in the automatically generated unittests.
     reference: medimage/nifti1
     # type=file|default=<undefined>: Name of a file in target space of the full transform.
-    out_file: generic/file
-    # type=file: Name of output file, containing the warp as field or coefficients.
-    # type=file|default=<undefined>: Name of output file, containing warps that are the combination of all those given as arguments. The format of this will be a field-file (rather than spline coefficients) with any affine components included.
     premat: generic/file
     # type=file|default=<undefined>: filename for pre-transform (affine matrix)
     warp1: medimage/nifti1
diff --git a/example-specs/task/nipype_internal/pydra-fsl/convert_warp_callables.py b/example-specs/task/nipype/fsl/convert_warp_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/convert_warp_callables.py
rename to example-specs/task/nipype/fsl/convert_warp_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/convert_xfm.yaml b/example-specs/task/nipype/fsl/convert_xfm.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/convert_xfm.yaml
rename to example-specs/task/nipype/fsl/convert_xfm.yaml
diff --git a/example-specs/task/nipype_internal/pydra-fsl/convert_xfm_callables.py b/example-specs/task/nipype/fsl/convert_xfm_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/convert_xfm_callables.py
rename to example-specs/task/nipype/fsl/convert_xfm_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/copy_geom.yaml b/example-specs/task/nipype/fsl/copy_geom.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/copy_geom.yaml
rename to example-specs/task/nipype/fsl/copy_geom.yaml
diff --git a/example-specs/task/nipype_internal/pydra-fsl/copy_geom_callables.py b/example-specs/task/nipype/fsl/copy_geom_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/copy_geom_callables.py
rename to example-specs/task/nipype/fsl/copy_geom_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/dilate_image.yaml b/example-specs/task/nipype/fsl/dilate_image.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/dilate_image.yaml
rename to example-specs/task/nipype/fsl/dilate_image.yaml
diff --git a/example-specs/task/nipype_internal/pydra-fsl/dilate_image_callables.py b/example-specs/task/nipype/fsl/dilate_image_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/dilate_image_callables.py
rename to example-specs/task/nipype/fsl/dilate_image_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/distance_map.yaml b/example-specs/task/nipype/fsl/distance_map.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/distance_map.yaml
rename to example-specs/task/nipype/fsl/distance_map.yaml
diff --git a/example-specs/task/nipype_internal/pydra-fsl/distance_map_callables.py b/example-specs/task/nipype/fsl/distance_map_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/distance_map_callables.py
rename to example-specs/task/nipype/fsl/distance_map_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/dti_fit.yaml b/example-specs/task/nipype/fsl/dti_fit.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/dti_fit.yaml
rename to example-specs/task/nipype/fsl/dti_fit.yaml
diff --git a/example-specs/task/nipype_internal/pydra-camino/dti_fit_callables.py b/example-specs/task/nipype/fsl/dti_fit_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-camino/dti_fit_callables.py
rename to example-specs/task/nipype/fsl/dti_fit_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/dual_regression.yaml b/example-specs/task/nipype/fsl/dual_regression.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/dual_regression.yaml
rename to example-specs/task/nipype/fsl/dual_regression.yaml
diff --git a/example-specs/task/nipype_internal/pydra-fsl/dual_regression_callables.py b/example-specs/task/nipype/fsl/dual_regression_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/dual_regression_callables.py
rename to example-specs/task/nipype/fsl/dual_regression_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/eddy.yaml b/example-specs/task/nipype/fsl/eddy.yaml
similarity index 99%
rename from example-specs/task/nipype_internal/pydra-fsl/eddy.yaml
rename to example-specs/task/nipype/fsl/eddy.yaml
index ffe16f1e..b54bdabf 100644
--- a/example-specs/task/nipype_internal/pydra-fsl/eddy.yaml
+++ b/example-specs/task/nipype/fsl/eddy.yaml
@@ -80,10 +80,6 @@ inputs:
     # type=file|default=<undefined>: Non-topup derived fieldmap scaled in Hz
     field_mat: generic/file
     # type=file|default=<undefined>: Matrix specifying the relative positions of the fieldmap, --field, and the first volume of the input file, --imain
-    slice_order: text/text-file
-    # type=file|default='': Name of text file completely specifying slice/group acquisition
-    json: generic/file
-    # type=file|default='': Name of .json text file with information about slice timing
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -97,6 +93,10 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    slice_order: text/text-file
+    # type=file|default='': Name of text file completely specifying slice/group acquisition
+    json: generic/file
+    # type=file|default='': Name of .json text file with information about slice timing
     out_corrected: generic/file
     # type=file: 4D image file containing all the corrected volumes
     out_parameter: generic/file
@@ -306,7 +306,7 @@ tests:
     # type=int|default=0: Regularisation weight for slice-to-vol movement (reasonable range 1-10)
     slice2vol_interp: '"trilinear"'
     # type=enum|default='trilinear'|allowed['spline','trilinear']: Slice-to-vol interpolation model for estimation step
-    slice_order:
+    slice_order: '"epi_slspec.txt"'
     # type=file|default='': Name of text file completely specifying slice/group acquisition
   imports:
   # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
@@ -366,7 +366,7 @@ doctests:
     # type=int|default=0: Regularisation weight for slice-to-vol movement (reasonable range 1-10)
     slice2vol_interp: '"trilinear"'
     # type=enum|default='trilinear'|allowed['spline','trilinear']: Slice-to-vol interpolation model for estimation step
-    slice_order:
+    slice_order: '"epi_slspec.txt"'
     # type=file|default='': Name of text file completely specifying slice/group acquisition
   imports:
   # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
diff --git a/example-specs/task/nipype_internal/pydra-fsl/eddy_callables.py b/example-specs/task/nipype/fsl/eddy_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/eddy_callables.py
rename to example-specs/task/nipype/fsl/eddy_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/eddy_correct.yaml b/example-specs/task/nipype/fsl/eddy_correct.yaml
similarity index 98%
rename from example-specs/task/nipype_internal/pydra-fsl/eddy_correct.yaml
rename to example-specs/task/nipype/fsl/eddy_correct.yaml
index 4b48aa5d..a95169a4 100644
--- a/example-specs/task/nipype_internal/pydra-fsl/eddy_correct.yaml
+++ b/example-specs/task/nipype/fsl/eddy_correct.yaml
@@ -36,8 +36,6 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/nifti1
     # type=file|default=<undefined>: 4D input file
-    out_file: medimage/nifti1
-    # type=file|default=<undefined>: 4D output file
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -51,6 +49,8 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    out_file: medimage/nifti1
+    # type=file|default=<undefined>: 4D output file
     eddy_corrected: generic/file
     # type=file: path/name of 4D eddy corrected output file
   callables:
@@ -96,7 +96,7 @@ tests:
   # (if not specified, will try to choose a sensible value)
     in_file:
     # type=file|default=<undefined>: 4D input file
-    out_file:
+    out_file: '"diffusion_edc.nii"'
     # type=file|default=<undefined>: 4D output file
     ref_num: '0'
     # type=int|default=0: reference number
@@ -124,7 +124,7 @@ doctests:
   # '.mock()' method of the corresponding class is used instead.
     in_file:
     # type=file|default=<undefined>: 4D input file
-    out_file:
+    out_file: '"diffusion_edc.nii"'
     # type=file|default=<undefined>: 4D output file
     ref_num: '0'
     # type=int|default=0: reference number
diff --git a/example-specs/task/nipype_internal/pydra-fsl/eddy_correct_callables.py b/example-specs/task/nipype/fsl/eddy_correct_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/eddy_correct_callables.py
rename to example-specs/task/nipype/fsl/eddy_correct_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/eddy_quad.yaml b/example-specs/task/nipype/fsl/eddy_quad.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/eddy_quad.yaml
rename to example-specs/task/nipype/fsl/eddy_quad.yaml
diff --git a/example-specs/task/nipype_internal/pydra-fsl/eddy_quad_callables.py b/example-specs/task/nipype/fsl/eddy_quad_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/eddy_quad_callables.py
rename to example-specs/task/nipype/fsl/eddy_quad_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/epi_de_warp.yaml b/example-specs/task/nipype/fsl/epi_de_warp.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/epi_de_warp.yaml
rename to example-specs/task/nipype/fsl/epi_de_warp.yaml
diff --git a/example-specs/task/nipype_internal/pydra-fsl/epi_de_warp_callables.py b/example-specs/task/nipype/fsl/epi_de_warp_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/epi_de_warp_callables.py
rename to example-specs/task/nipype/fsl/epi_de_warp_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/epi_reg.yaml b/example-specs/task/nipype/fsl/epi_reg.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/epi_reg.yaml
rename to example-specs/task/nipype/fsl/epi_reg.yaml
diff --git a/example-specs/task/nipype_internal/pydra-fsl/epi_reg_callables.py b/example-specs/task/nipype/fsl/epi_reg_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/epi_reg_callables.py
rename to example-specs/task/nipype/fsl/epi_reg_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/erode_image.yaml b/example-specs/task/nipype/fsl/erode_image.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/erode_image.yaml
rename to example-specs/task/nipype/fsl/erode_image.yaml
diff --git a/example-specs/task/nipype_internal/pydra-fsl/erode_image_callables.py b/example-specs/task/nipype/fsl/erode_image_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/erode_image_callables.py
rename to example-specs/task/nipype/fsl/erode_image_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/extract_roi.yaml b/example-specs/task/nipype/fsl/extract_roi.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/extract_roi.yaml
rename to example-specs/task/nipype/fsl/extract_roi.yaml
diff --git a/example-specs/task/nipype_internal/pydra-fsl/extract_roi_callables.py b/example-specs/task/nipype/fsl/extract_roi_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/extract_roi_callables.py
rename to example-specs/task/nipype/fsl/extract_roi_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/fast.yaml b/example-specs/task/nipype/fsl/fast.yaml
similarity index 97%
rename from example-specs/task/nipype_internal/pydra-fsl/fast.yaml
rename to example-specs/task/nipype/fsl/fast.yaml
index c6179d97..94f22f14 100644
--- a/example-specs/task/nipype_internal/pydra-fsl/fast.yaml
+++ b/example-specs/task/nipype/fsl/fast.yaml
@@ -13,12 +13,12 @@
 #     Examples
 #     --------
 #     >>> from nipype.interfaces import fsl
-#     >>> fast = fsl.FAST()
-#     >>> fast.inputs.in_files = 'structural.nii'
-#     >>> fast.inputs.out_basename = 'fast_'
-#     >>> fast.cmdline
+#     >>> fastr = fsl.FAST()
+#     >>> fastr.inputs.in_files = 'structural.nii'
+#     >>> fastr.inputs.out_basename = 'fast_'
+#     >>> fastr.cmdline
 #     'fast -o fast_ -S 1 structural.nii'
-#     >>> out = fast.run()  # doctest: +SKIP
+#     >>> out = fastr.run()  # doctest: +SKIP
 # 
 #     
 task_name: FAST
@@ -37,8 +37,6 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_files: medimage/nifti1+list-of
     # type=inputmultiobject|default=[]: image, or multi-channel set of images, to be segmented
-    out_basename: generic/file
-    # type=file|default=<undefined>: base name of output files
     init_transform: generic/file
     # type=file|default=<undefined>: <standard2input.mat> initialise using priors
     other_priors: generic/file+list-of
@@ -58,6 +56,8 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    out_basename: generic/file
+    # type=file|default=<undefined>: base name of output files
     tissue_class_map: generic/file
     # type=file: path/name of binary segmented volume file one val for each class  _seg
     mixeltype: generic/file
@@ -146,7 +146,7 @@ tests:
   # (if not specified, will try to choose a sensible value)
     in_files:
     # type=inputmultiobject|default=[]: image, or multi-channel set of images, to be segmented
-    out_basename:
+    out_basename: '"fast_"'
     # type=file|default=<undefined>: base name of output files
   imports:
   # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
@@ -172,7 +172,7 @@ doctests:
   # '.mock()' method of the corresponding class is used instead.
     in_files:
     # type=inputmultiobject|default=[]: image, or multi-channel set of images, to be segmented
-    out_basename:
+    out_basename: '"fast_"'
     # type=file|default=<undefined>: base name of output files
   imports:
   # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
diff --git a/example-specs/task/nipype_internal/pydra-fsl/fast_callables.py b/example-specs/task/nipype/fsl/fast_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/fast_callables.py
rename to example-specs/task/nipype/fsl/fast_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/feat.yaml b/example-specs/task/nipype/fsl/feat.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/feat.yaml
rename to example-specs/task/nipype/fsl/feat.yaml
diff --git a/example-specs/task/nipype_internal/pydra-fsl/feat_callables.py b/example-specs/task/nipype/fsl/feat_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/feat_callables.py
rename to example-specs/task/nipype/fsl/feat_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/feat_model.yaml b/example-specs/task/nipype/fsl/feat_model.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/feat_model.yaml
rename to example-specs/task/nipype/fsl/feat_model.yaml
diff --git a/example-specs/task/nipype_internal/pydra-fsl/feat_model_callables.py b/example-specs/task/nipype/fsl/feat_model_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/feat_model_callables.py
rename to example-specs/task/nipype/fsl/feat_model_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/feature_extractor.yaml b/example-specs/task/nipype/fsl/feature_extractor.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/feature_extractor.yaml
rename to example-specs/task/nipype/fsl/feature_extractor.yaml
diff --git a/example-specs/task/nipype_internal/pydra-fsl/feature_extractor_callables.py b/example-specs/task/nipype/fsl/feature_extractor_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/feature_extractor_callables.py
rename to example-specs/task/nipype/fsl/feature_extractor_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/filmgls.yaml b/example-specs/task/nipype/fsl/filmgls.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/filmgls.yaml
rename to example-specs/task/nipype/fsl/filmgls.yaml
diff --git a/example-specs/task/nipype_internal/pydra-fsl/filmgls_callables.py b/example-specs/task/nipype/fsl/filmgls_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/filmgls_callables.py
rename to example-specs/task/nipype/fsl/filmgls_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/filter_regressor.yaml b/example-specs/task/nipype/fsl/filter_regressor.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/filter_regressor.yaml
rename to example-specs/task/nipype/fsl/filter_regressor.yaml
diff --git a/example-specs/task/nipype_internal/pydra-fsl/filter_regressor_callables.py b/example-specs/task/nipype/fsl/filter_regressor_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/filter_regressor_callables.py
rename to example-specs/task/nipype/fsl/filter_regressor_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/find_the_biggest.yaml b/example-specs/task/nipype/fsl/find_the_biggest.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/find_the_biggest.yaml
rename to example-specs/task/nipype/fsl/find_the_biggest.yaml
diff --git a/example-specs/task/nipype_internal/pydra-fsl/find_the_biggest_callables.py b/example-specs/task/nipype/fsl/find_the_biggest_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/find_the_biggest_callables.py
rename to example-specs/task/nipype/fsl/find_the_biggest_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/first.yaml b/example-specs/task/nipype/fsl/first.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/first.yaml
rename to example-specs/task/nipype/fsl/first.yaml
index 1863f910..add51779 100644
--- a/example-specs/task/nipype_internal/pydra-fsl/first.yaml
+++ b/example-specs/task/nipype/fsl/first.yaml
@@ -35,8 +35,6 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: generic/file
     # type=file|default=<undefined>: input data file
-    out_file: generic/file
-    # type=file|default='segmented': output data file
     affine_file: generic/file
     # type=file|default=<undefined>: Affine matrix to use (e.g. img2std.mat) (does not re-run registration)
   metadata:
@@ -52,6 +50,8 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file|default='segmented': output data file
     original_segmentations: generic/file
     # type=file: 3D image file containing the segmented regions as integer values. Uses CMA labelling
     segmentation_file: generic/file
diff --git a/example-specs/task/nipype_internal/pydra-fsl/first_callables.py b/example-specs/task/nipype/fsl/first_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/first_callables.py
rename to example-specs/task/nipype/fsl/first_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/flameo.yaml b/example-specs/task/nipype/fsl/flameo.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/flameo.yaml
rename to example-specs/task/nipype/fsl/flameo.yaml
diff --git a/example-specs/task/nipype_internal/pydra-fsl/flameo_callables.py b/example-specs/task/nipype/fsl/flameo_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/flameo_callables.py
rename to example-specs/task/nipype/fsl/flameo_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/flirt.yaml b/example-specs/task/nipype/fsl/flirt.yaml
similarity index 96%
rename from example-specs/task/nipype_internal/pydra-fsl/flirt.yaml
rename to example-specs/task/nipype/fsl/flirt.yaml
index 9a99fb15..b4a786f8 100644
--- a/example-specs/task/nipype_internal/pydra-fsl/flirt.yaml
+++ b/example-specs/task/nipype/fsl/flirt.yaml
@@ -44,15 +44,6 @@ inputs:
     # type=file|default=<undefined>: input file
     reference: medimage/nifti1
     # type=file|default=<undefined>: reference file
-    out_file: generic/file
-    # type=file: path/name of registered file (if generated)
-    # type=file|default=<undefined>: registered output file
-    out_matrix_file: generic/file
-    # type=file: path/name of calculated affine transform (if generated)
-    # type=file|default=<undefined>: output affine matrix in 4x4 asciii format
-    out_log: generic/file
-    # type=file: path/name of output log (if generated)
-    # type=file|default=<undefined>: output log
     in_matrix_file: generic/file
     # type=file|default=<undefined>: input 4x4 affine matrix
     schedule: generic/file
diff --git a/example-specs/task/nipype_internal/pydra-fsl/flirt_callables.py b/example-specs/task/nipype/fsl/flirt_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/flirt_callables.py
rename to example-specs/task/nipype/fsl/flirt_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/fnirt.yaml b/example-specs/task/nipype/fsl/fnirt.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/fnirt.yaml
rename to example-specs/task/nipype/fsl/fnirt.yaml
diff --git a/example-specs/task/nipype_internal/pydra-fsl/fnirt_callables.py b/example-specs/task/nipype/fsl/fnirt_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/fnirt_callables.py
rename to example-specs/task/nipype/fsl/fnirt_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/fslx_command.yaml b/example-specs/task/nipype/fsl/fslx_command.yaml
similarity index 98%
rename from example-specs/task/nipype_internal/pydra-fsl/fslx_command.yaml
rename to example-specs/task/nipype/fsl/fslx_command.yaml
index eacd2c56..d4a94a91 100644
--- a/example-specs/task/nipype_internal/pydra-fsl/fslx_command.yaml
+++ b/example-specs/task/nipype/fsl/fslx_command.yaml
@@ -48,7 +48,7 @@ outputs:
     mean_dsamples: generic/file
     # type=file: Mean of distribution on diffusivity d
     mean_S0samples: generic/file
-    # type=file: Mean of distribution on T2w baseline signal intensity S0
+    # type=file: Mean of distribution on T2wbaseline signal intensity S0
     mean_tausamples: generic/file
     # type=file: Mean of distribution on tau samples (only with rician noise)
   callables:
diff --git a/example-specs/task/nipype_internal/pydra-fsl/fslx_command_callables.py b/example-specs/task/nipype/fsl/fslx_command_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/fslx_command_callables.py
rename to example-specs/task/nipype/fsl/fslx_command_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/fugue.yaml b/example-specs/task/nipype/fsl/fugue.yaml
similarity index 98%
rename from example-specs/task/nipype_internal/pydra-fsl/fugue.yaml
rename to example-specs/task/nipype/fsl/fugue.yaml
index 96e7a0b8..e62cfc15 100644
--- a/example-specs/task/nipype_internal/pydra-fsl/fugue.yaml
+++ b/example-specs/task/nipype/fsl/fugue.yaml
@@ -98,12 +98,6 @@ inputs:
     # type=file|default=<undefined>: apply forward warping and save as filename
     mask_file: medimage/nifti1
     # type=file|default=<undefined>: filename for loading valid mask
-    shift_out_file: generic/file
-    # type=file: voxel shift map file
-    # type=file|default=<undefined>: filename for saving pixel shift volume
-    fmap_out_file: generic/file
-    # type=file: fieldmap file
-    # type=file|default=<undefined>: filename for saving fieldmap (rad/s)
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -117,18 +111,18 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    unwarped_file: generic/file
-    # type=file: unwarped file
-    # type=file|default=<undefined>: apply unwarping and save as filename
-    warped_file: generic/file
-    # type=file: forward warped file
-    # type=file|default=<undefined>: apply forward warping and save as filename
     shift_out_file: generic/file
     # type=file: voxel shift map file
     # type=file|default=<undefined>: filename for saving pixel shift volume
     fmap_out_file: generic/file
     # type=file: fieldmap file
     # type=file|default=<undefined>: filename for saving fieldmap (rad/s)
+    unwarped_file: generic/file
+    # type=file: unwarped file
+    # type=file|default=<undefined>: apply unwarping and save as filename
+    warped_file: generic/file
+    # type=file: forward warped file
+    # type=file|default=<undefined>: apply forward warping and save as filename
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype_internal/pydra-fsl/fugue_callables.py b/example-specs/task/nipype/fsl/fugue_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/fugue_callables.py
rename to example-specs/task/nipype/fsl/fugue_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/glm.yaml b/example-specs/task/nipype/fsl/glm.yaml
similarity index 98%
rename from example-specs/task/nipype_internal/pydra-fsl/glm.yaml
rename to example-specs/task/nipype/fsl/glm.yaml
index e14e3c4d..f0f9afcd 100644
--- a/example-specs/task/nipype_internal/pydra-fsl/glm.yaml
+++ b/example-specs/task/nipype/fsl/glm.yaml
@@ -32,15 +32,28 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/nifti1
     # type=file|default=<undefined>: input file name (text matrix or 3D/4D image file)
-    out_file: generic/file
-    # type=file: file name of GLM parameters (if generated)
-    # type=file|default=<undefined>: filename for GLM parameter estimates (GLM betas)
     design: medimage/nifti1
     # type=file|default=<undefined>: file name of the GLM design matrix (text time courses for temporal regression or an image file for spatial regression)
     contrasts: generic/file
     # type=file|default=<undefined>: matrix of t-statics contrasts
     mask: generic/file
     # type=file|default=<undefined>: mask image file name if input is image
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: file name of GLM parameters (if generated)
+    # type=file|default=<undefined>: filename for GLM parameter estimates (GLM betas)
     out_cope: generic/file
     # type=outputmultiobject: output file name for COPEs (either as text file or image)
     # type=file|default=<undefined>: output file name for COPE (either as txt or image
@@ -64,22 +77,6 @@ inputs:
     # type=file|default=<undefined>: output file name for pre-processed data
     out_vnscales_name: generic/file
     # type=file|default=<undefined>: output file name for scaling factors for variance normalisation
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    out_file: generic/file
-    # type=file: file name of GLM parameters (if generated)
-    # type=file|default=<undefined>: filename for GLM parameter estimates (GLM betas)
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype_internal/pydra-fsl/glm_callables.py b/example-specs/task/nipype/fsl/glm_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/glm_callables.py
rename to example-specs/task/nipype/fsl/glm_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/ica__aroma.yaml b/example-specs/task/nipype/fsl/ica__aroma.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/ica__aroma.yaml
rename to example-specs/task/nipype/fsl/ica__aroma.yaml
diff --git a/example-specs/task/nipype_internal/pydra-fsl/ica__aroma_callables.py b/example-specs/task/nipype/fsl/ica__aroma_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/ica__aroma_callables.py
rename to example-specs/task/nipype/fsl/ica__aroma_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/image_maths.yaml b/example-specs/task/nipype/fsl/image_maths.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/image_maths.yaml
rename to example-specs/task/nipype/fsl/image_maths.yaml
diff --git a/example-specs/task/nipype_internal/pydra-fsl/image_maths_callables.py b/example-specs/task/nipype/fsl/image_maths_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/image_maths_callables.py
rename to example-specs/task/nipype/fsl/image_maths_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/image_meants.yaml b/example-specs/task/nipype/fsl/image_meants.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/image_meants.yaml
rename to example-specs/task/nipype/fsl/image_meants.yaml
diff --git a/example-specs/task/nipype_internal/pydra-fsl/image_meants_callables.py b/example-specs/task/nipype/fsl/image_meants_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/image_meants_callables.py
rename to example-specs/task/nipype/fsl/image_meants_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/image_stats.yaml b/example-specs/task/nipype/fsl/image_stats.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/image_stats.yaml
rename to example-specs/task/nipype/fsl/image_stats.yaml
diff --git a/example-specs/task/nipype_internal/pydra-camino/image_stats_callables.py b/example-specs/task/nipype/fsl/image_stats_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-camino/image_stats_callables.py
rename to example-specs/task/nipype/fsl/image_stats_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/inv_warp.yaml b/example-specs/task/nipype/fsl/inv_warp.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/inv_warp.yaml
rename to example-specs/task/nipype/fsl/inv_warp.yaml
diff --git a/example-specs/task/nipype_internal/pydra-fsl/inv_warp_callables.py b/example-specs/task/nipype/fsl/inv_warp_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/inv_warp_callables.py
rename to example-specs/task/nipype/fsl/inv_warp_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/isotropic_smooth.yaml b/example-specs/task/nipype/fsl/isotropic_smooth.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/isotropic_smooth.yaml
rename to example-specs/task/nipype/fsl/isotropic_smooth.yaml
diff --git a/example-specs/task/nipype_internal/pydra-fsl/isotropic_smooth_callables.py b/example-specs/task/nipype/fsl/isotropic_smooth_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/isotropic_smooth_callables.py
rename to example-specs/task/nipype/fsl/isotropic_smooth_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/l2_model.yaml b/example-specs/task/nipype/fsl/l2_model.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/l2_model.yaml
rename to example-specs/task/nipype/fsl/l2_model.yaml
diff --git a/example-specs/task/nipype_internal/pydra-fsl/l2_model_callables.py b/example-specs/task/nipype/fsl/l2_model_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/l2_model_callables.py
rename to example-specs/task/nipype/fsl/l2_model_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/level_1_design.yaml b/example-specs/task/nipype/fsl/level_1_design.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/level_1_design.yaml
rename to example-specs/task/nipype/fsl/level_1_design.yaml
diff --git a/example-specs/task/nipype_internal/pydra-fsl/level_1_design_callables.py b/example-specs/task/nipype/fsl/level_1_design_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/level_1_design_callables.py
rename to example-specs/task/nipype/fsl/level_1_design_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/make_dyadic_vectors.yaml b/example-specs/task/nipype/fsl/make_dyadic_vectors.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/make_dyadic_vectors.yaml
rename to example-specs/task/nipype/fsl/make_dyadic_vectors.yaml
index 633027e9..ba2e7dd0 100644
--- a/example-specs/task/nipype_internal/pydra-fsl/make_dyadic_vectors.yaml
+++ b/example-specs/task/nipype/fsl/make_dyadic_vectors.yaml
@@ -27,8 +27,6 @@ inputs:
     # type=file|default=<undefined>: 
     mask: generic/file
     # type=file|default=<undefined>: 
-    output: generic/file
-    # type=file|default='dyads': 
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -42,6 +40,8 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    output: generic/file
+    # type=file|default='dyads': 
     dyads: generic/file
     # type=file: 
     dispersion: generic/file
diff --git a/example-specs/task/nipype_internal/pydra-fsl/make_dyadic_vectors_callables.py b/example-specs/task/nipype/fsl/make_dyadic_vectors_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/make_dyadic_vectors_callables.py
rename to example-specs/task/nipype/fsl/make_dyadic_vectors_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/maths_command.yaml b/example-specs/task/nipype/fsl/maths_command.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/maths_command.yaml
rename to example-specs/task/nipype/fsl/maths_command.yaml
diff --git a/example-specs/task/nipype_internal/pydra-fsl/maths_command_callables.py b/example-specs/task/nipype/fsl/maths_command_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/maths_command_callables.py
rename to example-specs/task/nipype/fsl/maths_command_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/max_image.yaml b/example-specs/task/nipype/fsl/max_image.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/max_image.yaml
rename to example-specs/task/nipype/fsl/max_image.yaml
diff --git a/example-specs/task/nipype_internal/pydra-fsl/max_image_callables.py b/example-specs/task/nipype/fsl/max_image_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/max_image_callables.py
rename to example-specs/task/nipype/fsl/max_image_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/maxn_image.yaml b/example-specs/task/nipype/fsl/maxn_image.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/maxn_image.yaml
rename to example-specs/task/nipype/fsl/maxn_image.yaml
diff --git a/example-specs/task/nipype_internal/pydra-fsl/maxn_image_callables.py b/example-specs/task/nipype/fsl/maxn_image_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/maxn_image_callables.py
rename to example-specs/task/nipype/fsl/maxn_image_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/mcflirt.yaml b/example-specs/task/nipype/fsl/mcflirt.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/mcflirt.yaml
rename to example-specs/task/nipype/fsl/mcflirt.yaml
diff --git a/example-specs/task/nipype_internal/pydra-fsl/mcflirt_callables.py b/example-specs/task/nipype/fsl/mcflirt_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/mcflirt_callables.py
rename to example-specs/task/nipype/fsl/mcflirt_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/mean_image.yaml b/example-specs/task/nipype/fsl/mean_image.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/mean_image.yaml
rename to example-specs/task/nipype/fsl/mean_image.yaml
diff --git a/example-specs/task/nipype_internal/pydra-fsl/mean_image_callables.py b/example-specs/task/nipype/fsl/mean_image_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/mean_image_callables.py
rename to example-specs/task/nipype/fsl/mean_image_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/median_image.yaml b/example-specs/task/nipype/fsl/median_image.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/median_image.yaml
rename to example-specs/task/nipype/fsl/median_image.yaml
diff --git a/example-specs/task/nipype_internal/pydra-fsl/median_image_callables.py b/example-specs/task/nipype/fsl/median_image_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/median_image_callables.py
rename to example-specs/task/nipype/fsl/median_image_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/melodic.yaml b/example-specs/task/nipype/fsl/melodic.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/melodic.yaml
rename to example-specs/task/nipype/fsl/melodic.yaml
diff --git a/example-specs/task/nipype_internal/pydra-fsl/melodic_callables.py b/example-specs/task/nipype/fsl/melodic_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/melodic_callables.py
rename to example-specs/task/nipype/fsl/melodic_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/merge.yaml b/example-specs/task/nipype/fsl/merge.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/merge.yaml
rename to example-specs/task/nipype/fsl/merge.yaml
diff --git a/example-specs/task/nipype_internal/pydra-fsl/merge_callables.py b/example-specs/task/nipype/fsl/merge_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/merge_callables.py
rename to example-specs/task/nipype/fsl/merge_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/min_image.yaml b/example-specs/task/nipype/fsl/min_image.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/min_image.yaml
rename to example-specs/task/nipype/fsl/min_image.yaml
diff --git a/example-specs/task/nipype_internal/pydra-fsl/min_image_callables.py b/example-specs/task/nipype/fsl/min_image_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/min_image_callables.py
rename to example-specs/task/nipype/fsl/min_image_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/motion_outliers.yaml b/example-specs/task/nipype/fsl/motion_outliers.yaml
similarity index 95%
rename from example-specs/task/nipype_internal/pydra-fsl/motion_outliers.yaml
rename to example-specs/task/nipype/fsl/motion_outliers.yaml
index ccd418bf..78856c98 100644
--- a/example-specs/task/nipype_internal/pydra-fsl/motion_outliers.yaml
+++ b/example-specs/task/nipype/fsl/motion_outliers.yaml
@@ -32,17 +32,8 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/nifti1
     # type=file|default=<undefined>: unfiltered 4D image
-    out_file: generic/file
-    # type=file: 
-    # type=file|default=<undefined>: output outlier file name
     mask: generic/file
     # type=file|default=<undefined>: mask image for calculating metric
-    out_metric_values: generic/file
-    # type=file: 
-    # type=file|default=<undefined>: output metric values (DVARS etc.) file name
-    out_metric_plot: generic/file
-    # type=file: 
-    # type=file|default=<undefined>: output metric values plot (DVARS etc.) file name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype_internal/pydra-fsl/motion_outliers_callables.py b/example-specs/task/nipype/fsl/motion_outliers_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/motion_outliers_callables.py
rename to example-specs/task/nipype/fsl/motion_outliers_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/multi_image_maths.yaml b/example-specs/task/nipype/fsl/multi_image_maths.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/multi_image_maths.yaml
rename to example-specs/task/nipype/fsl/multi_image_maths.yaml
diff --git a/example-specs/task/nipype_internal/pydra-fsl/multi_image_maths_callables.py b/example-specs/task/nipype/fsl/multi_image_maths_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/multi_image_maths_callables.py
rename to example-specs/task/nipype/fsl/multi_image_maths_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/multiple_regress_design.yaml b/example-specs/task/nipype/fsl/multiple_regress_design.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/multiple_regress_design.yaml
rename to example-specs/task/nipype/fsl/multiple_regress_design.yaml
diff --git a/example-specs/task/nipype_internal/pydra-fsl/multiple_regress_design_callables.py b/example-specs/task/nipype/fsl/multiple_regress_design_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/multiple_regress_design_callables.py
rename to example-specs/task/nipype/fsl/multiple_regress_design_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/overlay.yaml b/example-specs/task/nipype/fsl/overlay.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/overlay.yaml
rename to example-specs/task/nipype/fsl/overlay.yaml
diff --git a/example-specs/task/nipype_internal/pydra-fsl/overlay_callables.py b/example-specs/task/nipype/fsl/overlay_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/overlay_callables.py
rename to example-specs/task/nipype/fsl/overlay_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/percentile_image.yaml b/example-specs/task/nipype/fsl/percentile_image.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/percentile_image.yaml
rename to example-specs/task/nipype/fsl/percentile_image.yaml
diff --git a/example-specs/task/nipype_internal/pydra-fsl/percentile_image_callables.py b/example-specs/task/nipype/fsl/percentile_image_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/percentile_image_callables.py
rename to example-specs/task/nipype/fsl/percentile_image_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/plot_motion_params.yaml b/example-specs/task/nipype/fsl/plot_motion_params.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/plot_motion_params.yaml
rename to example-specs/task/nipype/fsl/plot_motion_params.yaml
diff --git a/example-specs/task/nipype_internal/pydra-fsl/plot_motion_params_callables.py b/example-specs/task/nipype/fsl/plot_motion_params_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/plot_motion_params_callables.py
rename to example-specs/task/nipype/fsl/plot_motion_params_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/plot_time_series.yaml b/example-specs/task/nipype/fsl/plot_time_series.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/plot_time_series.yaml
rename to example-specs/task/nipype/fsl/plot_time_series.yaml
diff --git a/example-specs/task/nipype_internal/pydra-fsl/plot_time_series_callables.py b/example-specs/task/nipype/fsl/plot_time_series_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/plot_time_series_callables.py
rename to example-specs/task/nipype/fsl/plot_time_series_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/power_spectrum.yaml b/example-specs/task/nipype/fsl/power_spectrum.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/power_spectrum.yaml
rename to example-specs/task/nipype/fsl/power_spectrum.yaml
diff --git a/example-specs/task/nipype_internal/pydra-fsl/power_spectrum_callables.py b/example-specs/task/nipype/fsl/power_spectrum_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/power_spectrum_callables.py
rename to example-specs/task/nipype/fsl/power_spectrum_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/prelude.yaml b/example-specs/task/nipype/fsl/prelude.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/prelude.yaml
rename to example-specs/task/nipype/fsl/prelude.yaml
diff --git a/example-specs/task/nipype_internal/pydra-fsl/prelude_callables.py b/example-specs/task/nipype/fsl/prelude_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/prelude_callables.py
rename to example-specs/task/nipype/fsl/prelude_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/prepare_fieldmap.yaml b/example-specs/task/nipype/fsl/prepare_fieldmap.yaml
similarity index 97%
rename from example-specs/task/nipype_internal/pydra-fsl/prepare_fieldmap.yaml
rename to example-specs/task/nipype/fsl/prepare_fieldmap.yaml
index 008e00eb..f4ddde19 100644
--- a/example-specs/task/nipype_internal/pydra-fsl/prepare_fieldmap.yaml
+++ b/example-specs/task/nipype/fsl/prepare_fieldmap.yaml
@@ -45,9 +45,6 @@ inputs:
     # type=file|default=<undefined>: Phase difference map, in SIEMENS format range from 0-4096 or 0-8192)
     in_magnitude: medimage/nifti1
     # type=file|default=<undefined>: Magnitude difference map, brain extracted
-    out_fieldmap: generic/file
-    # type=file: output name for prepared fieldmap
-    # type=file|default=<undefined>: output name for prepared fieldmap
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype_internal/pydra-fsl/prepare_fieldmap_callables.py b/example-specs/task/nipype/fsl/prepare_fieldmap_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/prepare_fieldmap_callables.py
rename to example-specs/task/nipype/fsl/prepare_fieldmap_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/prob_track_x.yaml b/example-specs/task/nipype/fsl/prob_track_x.yaml
similarity index 99%
rename from example-specs/task/nipype_internal/pydra-fsl/prob_track_x.yaml
rename to example-specs/task/nipype/fsl/prob_track_x.yaml
index c1025493..458ec845 100644
--- a/example-specs/task/nipype_internal/pydra-fsl/prob_track_x.yaml
+++ b/example-specs/task/nipype/fsl/prob_track_x.yaml
@@ -141,7 +141,7 @@ tests:
     c_thresh:
     # type=float|default=0.0: curvature threshold - default=0.2
     sample_random_points:
-    # type=float|default=0.0: sample random points within seed voxels
+    # type=bool|default=False: sample random points within seed voxels
     step_length:
     # type=float|default=0.0: step_length in mm - default=0.5
     loop_check:
@@ -155,7 +155,7 @@ tests:
     mod_euler:
     # type=bool|default=False: use modified euler streamlining
     random_seed:
-    # type=int|default=0: random seed
+    # type=bool|default=False: random seed
     s2tastext:
     # type=bool|default=False: output seed-to-target counts as a text file (useful when seeding from a mesh)
     verbose:
diff --git a/example-specs/task/nipype_internal/pydra-fsl/prob_track_x2.yaml b/example-specs/task/nipype/fsl/prob_track_x2.yaml
similarity index 99%
rename from example-specs/task/nipype_internal/pydra-fsl/prob_track_x2.yaml
rename to example-specs/task/nipype/fsl/prob_track_x2.yaml
index c2e66368..149443cd 100644
--- a/example-specs/task/nipype_internal/pydra-fsl/prob_track_x2.yaml
+++ b/example-specs/task/nipype/fsl/prob_track_x2.yaml
@@ -192,7 +192,7 @@ tests:
     c_thresh:
     # type=float|default=0.0: curvature threshold - default=0.2
     sample_random_points:
-    # type=float|default=0.0: sample random points within seed voxels
+    # type=bool|default=False: sample random points within seed voxels
     step_length:
     # type=float|default=0.0: step_length in mm - default=0.5
     loop_check:
@@ -206,7 +206,7 @@ tests:
     mod_euler:
     # type=bool|default=False: use modified euler streamlining
     random_seed:
-    # type=int|default=0: random seed
+    # type=bool|default=False: random seed
     s2tastext:
     # type=bool|default=False: output seed-to-target counts as a text file (useful when seeding from a mesh)
     verbose:
diff --git a/example-specs/task/nipype_internal/pydra-fsl/prob_track_x2_callables.py b/example-specs/task/nipype/fsl/prob_track_x2_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/prob_track_x2_callables.py
rename to example-specs/task/nipype/fsl/prob_track_x2_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/prob_track_x_callables.py b/example-specs/task/nipype/fsl/prob_track_x_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/prob_track_x_callables.py
rename to example-specs/task/nipype/fsl/prob_track_x_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/proj_thresh.yaml b/example-specs/task/nipype/fsl/proj_thresh.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/proj_thresh.yaml
rename to example-specs/task/nipype/fsl/proj_thresh.yaml
diff --git a/example-specs/task/nipype_internal/pydra-fsl/proj_thresh_callables.py b/example-specs/task/nipype/fsl/proj_thresh_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/proj_thresh_callables.py
rename to example-specs/task/nipype/fsl/proj_thresh_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/randomise.yaml b/example-specs/task/nipype/fsl/randomise.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/randomise.yaml
rename to example-specs/task/nipype/fsl/randomise.yaml
diff --git a/example-specs/task/nipype_internal/pydra-fsl/randomise_callables.py b/example-specs/task/nipype/fsl/randomise_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/randomise_callables.py
rename to example-specs/task/nipype/fsl/randomise_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/reorient_2_std.yaml b/example-specs/task/nipype/fsl/reorient_2_std.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/reorient_2_std.yaml
rename to example-specs/task/nipype/fsl/reorient_2_std.yaml
diff --git a/example-specs/task/nipype_internal/pydra-fsl/reorient_2_std_callables.py b/example-specs/task/nipype/fsl/reorient_2_std_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/reorient_2_std_callables.py
rename to example-specs/task/nipype/fsl/reorient_2_std_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/robust_fov.yaml b/example-specs/task/nipype/fsl/robust_fov.yaml
similarity index 93%
rename from example-specs/task/nipype_internal/pydra-fsl/robust_fov.yaml
rename to example-specs/task/nipype/fsl/robust_fov.yaml
index 72f6ee3e..e3130f56 100644
--- a/example-specs/task/nipype_internal/pydra-fsl/robust_fov.yaml
+++ b/example-specs/task/nipype/fsl/robust_fov.yaml
@@ -26,12 +26,6 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: generic/file
     # type=file|default=<undefined>: input filename
-    out_roi: generic/file
-    # type=file: ROI volume output name
-    # type=file|default=<undefined>: ROI volume output name
-    out_transform: generic/file
-    # type=file: Transformation matrix in_file to out_roi output name
-    # type=file|default=<undefined>: Transformation matrix in_file to out_roi output name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype_internal/pydra-fsl/robust_fov_callables.py b/example-specs/task/nipype/fsl/robust_fov_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/robust_fov_callables.py
rename to example-specs/task/nipype/fsl/robust_fov_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/sig_loss.yaml b/example-specs/task/nipype/fsl/sig_loss.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/sig_loss.yaml
rename to example-specs/task/nipype/fsl/sig_loss.yaml
diff --git a/example-specs/task/nipype_internal/pydra-fsl/sig_loss_callables.py b/example-specs/task/nipype/fsl/sig_loss_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/sig_loss_callables.py
rename to example-specs/task/nipype/fsl/sig_loss_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/slice.yaml b/example-specs/task/nipype/fsl/slice.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/slice.yaml
rename to example-specs/task/nipype/fsl/slice.yaml
diff --git a/example-specs/task/nipype_internal/pydra-fsl/slice_callables.py b/example-specs/task/nipype/fsl/slice_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/slice_callables.py
rename to example-specs/task/nipype/fsl/slice_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/slice_timer.yaml b/example-specs/task/nipype/fsl/slice_timer.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/slice_timer.yaml
rename to example-specs/task/nipype/fsl/slice_timer.yaml
diff --git a/example-specs/task/nipype_internal/pydra-fsl/slice_timer_callables.py b/example-specs/task/nipype/fsl/slice_timer_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/slice_timer_callables.py
rename to example-specs/task/nipype/fsl/slice_timer_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/slicer.yaml b/example-specs/task/nipype/fsl/slicer.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/slicer.yaml
rename to example-specs/task/nipype/fsl/slicer.yaml
diff --git a/example-specs/task/nipype_internal/pydra-fsl/slicer_callables.py b/example-specs/task/nipype/fsl/slicer_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/slicer_callables.py
rename to example-specs/task/nipype/fsl/slicer_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/smm.yaml b/example-specs/task/nipype/fsl/smm.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/smm.yaml
rename to example-specs/task/nipype/fsl/smm.yaml
diff --git a/example-specs/task/nipype_internal/pydra-fsl/smm_callables.py b/example-specs/task/nipype/fsl/smm_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/smm_callables.py
rename to example-specs/task/nipype/fsl/smm_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/smooth.yaml b/example-specs/task/nipype/fsl/smooth.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/smooth.yaml
rename to example-specs/task/nipype/fsl/smooth.yaml
diff --git a/example-specs/task/nipype_internal/pydra-fsl/smooth_callables.py b/example-specs/task/nipype/fsl/smooth_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/smooth_callables.py
rename to example-specs/task/nipype/fsl/smooth_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/smooth_estimate.yaml b/example-specs/task/nipype/fsl/smooth_estimate.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/smooth_estimate.yaml
rename to example-specs/task/nipype/fsl/smooth_estimate.yaml
diff --git a/example-specs/task/nipype_internal/pydra-fsl/smooth_estimate_callables.py b/example-specs/task/nipype/fsl/smooth_estimate_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/smooth_estimate_callables.py
rename to example-specs/task/nipype/fsl/smooth_estimate_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/spatial_filter.yaml b/example-specs/task/nipype/fsl/spatial_filter.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/spatial_filter.yaml
rename to example-specs/task/nipype/fsl/spatial_filter.yaml
diff --git a/example-specs/task/nipype_internal/pydra-fsl/spatial_filter_callables.py b/example-specs/task/nipype/fsl/spatial_filter_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/spatial_filter_callables.py
rename to example-specs/task/nipype/fsl/spatial_filter_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/split.yaml b/example-specs/task/nipype/fsl/split.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/split.yaml
rename to example-specs/task/nipype/fsl/split.yaml
diff --git a/example-specs/task/nipype_internal/pydra-fsl/split_callables.py b/example-specs/task/nipype/fsl/split_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/split_callables.py
rename to example-specs/task/nipype/fsl/split_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/std_image.yaml b/example-specs/task/nipype/fsl/std_image.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/std_image.yaml
rename to example-specs/task/nipype/fsl/std_image.yaml
diff --git a/example-specs/task/nipype_internal/pydra-fsl/std_image_callables.py b/example-specs/task/nipype/fsl/std_image_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/std_image_callables.py
rename to example-specs/task/nipype/fsl/std_image_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/susan.yaml b/example-specs/task/nipype/fsl/susan.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/susan.yaml
rename to example-specs/task/nipype/fsl/susan.yaml
diff --git a/example-specs/task/nipype_internal/pydra-fsl/susan_callables.py b/example-specs/task/nipype/fsl/susan_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/susan_callables.py
rename to example-specs/task/nipype/fsl/susan_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/swap_dimensions.yaml b/example-specs/task/nipype/fsl/swap_dimensions.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/swap_dimensions.yaml
rename to example-specs/task/nipype/fsl/swap_dimensions.yaml
diff --git a/example-specs/task/nipype_internal/pydra-fsl/swap_dimensions_callables.py b/example-specs/task/nipype/fsl/swap_dimensions_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/swap_dimensions_callables.py
rename to example-specs/task/nipype/fsl/swap_dimensions_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/temporal_filter.yaml b/example-specs/task/nipype/fsl/temporal_filter.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/temporal_filter.yaml
rename to example-specs/task/nipype/fsl/temporal_filter.yaml
diff --git a/example-specs/task/nipype_internal/pydra-fsl/temporal_filter_callables.py b/example-specs/task/nipype/fsl/temporal_filter_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/temporal_filter_callables.py
rename to example-specs/task/nipype/fsl/temporal_filter_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/text_2_vest.yaml b/example-specs/task/nipype/fsl/text_2_vest.yaml
similarity index 96%
rename from example-specs/task/nipype_internal/pydra-fsl/text_2_vest.yaml
rename to example-specs/task/nipype/fsl/text_2_vest.yaml
index b78fffba..47e7ad77 100644
--- a/example-specs/task/nipype_internal/pydra-fsl/text_2_vest.yaml
+++ b/example-specs/task/nipype/fsl/text_2_vest.yaml
@@ -35,9 +35,6 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: text/text-file
     # type=file|default=<undefined>: plain text file representing your design, contrast, or f-test matrix
-    out_file: datascience/text-matrix
-    # type=file: matrix data in the format used by FSL tools
-    # type=file|default=<undefined>: file name to store matrix data in the format used by FSL tools (e.g., design.mat, design.con design.fts)
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -96,7 +93,7 @@ tests:
   # (if not specified, will try to choose a sensible value)
     in_file:
     # type=file|default=<undefined>: plain text file representing your design, contrast, or f-test matrix
-    out_file:
+    out_file: '"design.mat"'
     # type=file: matrix data in the format used by FSL tools
     # type=file|default=<undefined>: file name to store matrix data in the format used by FSL tools (e.g., design.mat, design.con design.fts)
   imports:
@@ -123,7 +120,7 @@ doctests:
   # '.mock()' method of the corresponding class is used instead.
     in_file:
     # type=file|default=<undefined>: plain text file representing your design, contrast, or f-test matrix
-    out_file:
+    out_file: '"design.mat"'
     # type=file: matrix data in the format used by FSL tools
     # type=file|default=<undefined>: file name to store matrix data in the format used by FSL tools (e.g., design.mat, design.con design.fts)
   imports:
diff --git a/example-specs/task/nipype_internal/pydra-fsl/text_2_vest_callables.py b/example-specs/task/nipype/fsl/text_2_vest_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/text_2_vest_callables.py
rename to example-specs/task/nipype/fsl/text_2_vest_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/threshold.yaml b/example-specs/task/nipype/fsl/threshold.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/threshold.yaml
rename to example-specs/task/nipype/fsl/threshold.yaml
diff --git a/example-specs/task/nipype_internal/pydra-fsl/threshold_callables.py b/example-specs/task/nipype/fsl/threshold_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/threshold_callables.py
rename to example-specs/task/nipype/fsl/threshold_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/topup.yaml b/example-specs/task/nipype/fsl/topup.yaml
similarity index 96%
rename from example-specs/task/nipype_internal/pydra-fsl/topup.yaml
rename to example-specs/task/nipype/fsl/topup.yaml
index 5e597d67..ae2d5391 100644
--- a/example-specs/task/nipype_internal/pydra-fsl/topup.yaml
+++ b/example-specs/task/nipype/fsl/topup.yaml
@@ -45,17 +45,6 @@ inputs:
     # type=file|default=<undefined>: name of 4D file with images
     encoding_file: text/text-file
     # type=file|default=<undefined>: name of text file with PE directions/times
-    out_base: generic/file
-    # type=file|default=<undefined>: base-name of output files (spline coefficients (Hz) and movement parameters)
-    out_field: generic/file
-    # type=file: name of image file with field (Hz)
-    # type=file|default=<undefined>: name of image file with field (Hz)
-    out_corrected: generic/file
-    # type=file: name of 4D image file with unwarped images
-    # type=file|default=<undefined>: name of 4D image file with unwarped images
-    out_logfile: generic/file
-    # type=file: name of log-file
-    # type=file|default=<undefined>: name of log-file
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -69,12 +58,8 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    out_fieldcoef: generic/file
-    # type=file: file containing the field coefficients
-    out_movpar: generic/file
-    # type=file: movpar.txt output file
-    out_enc_file: generic/file
-    # type=file: encoding directions file output for applytopup
+    out_base: generic/file
+    # type=file|default=<undefined>: base-name of output files (spline coefficients (Hz) and movement parameters)
     out_field: generic/file
     # type=file: name of image file with field (Hz)
     # type=file|default=<undefined>: name of image file with field (Hz)
@@ -84,6 +69,12 @@ outputs:
     out_logfile: generic/file
     # type=file: name of log-file
     # type=file|default=<undefined>: name of log-file
+    out_fieldcoef: generic/file
+    # type=file: file containing the field coefficients
+    out_movpar: generic/file
+    # type=file: movpar.txt output file
+    out_enc_file: generic/file
+    # type=file: encoding directions file output for applytopup
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype_internal/pydra-fsl/topup_callables.py b/example-specs/task/nipype/fsl/topup_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/topup_callables.py
rename to example-specs/task/nipype/fsl/topup_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/tract_skeleton.yaml b/example-specs/task/nipype/fsl/tract_skeleton.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/tract_skeleton.yaml
rename to example-specs/task/nipype/fsl/tract_skeleton.yaml
diff --git a/example-specs/task/nipype_internal/pydra-fsl/tract_skeleton_callables.py b/example-specs/task/nipype/fsl/tract_skeleton_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/tract_skeleton_callables.py
rename to example-specs/task/nipype/fsl/tract_skeleton_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/training.yaml b/example-specs/task/nipype/fsl/training.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/training.yaml
rename to example-specs/task/nipype/fsl/training.yaml
diff --git a/example-specs/task/nipype_internal/pydra-fsl/training_callables.py b/example-specs/task/nipype/fsl/training_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/training_callables.py
rename to example-specs/task/nipype/fsl/training_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/training_set_creator.yaml b/example-specs/task/nipype/fsl/training_set_creator.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/training_set_creator.yaml
rename to example-specs/task/nipype/fsl/training_set_creator.yaml
diff --git a/example-specs/task/nipype_internal/pydra-fsl/training_set_creator_callables.py b/example-specs/task/nipype/fsl/training_set_creator_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/training_set_creator_callables.py
rename to example-specs/task/nipype/fsl/training_set_creator_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/unary_maths.yaml b/example-specs/task/nipype/fsl/unary_maths.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/unary_maths.yaml
rename to example-specs/task/nipype/fsl/unary_maths.yaml
diff --git a/example-specs/task/nipype_internal/pydra-fsl/unary_maths_callables.py b/example-specs/task/nipype/fsl/unary_maths_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/unary_maths_callables.py
rename to example-specs/task/nipype/fsl/unary_maths_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/vec_reg.yaml b/example-specs/task/nipype/fsl/vec_reg.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/vec_reg.yaml
rename to example-specs/task/nipype/fsl/vec_reg.yaml
diff --git a/example-specs/task/nipype_internal/pydra-fsl/vec_reg_callables.py b/example-specs/task/nipype/fsl/vec_reg_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/vec_reg_callables.py
rename to example-specs/task/nipype/fsl/vec_reg_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/vest_2_text.yaml b/example-specs/task/nipype/fsl/vest_2_text.yaml
similarity index 97%
rename from example-specs/task/nipype_internal/pydra-fsl/vest_2_text.yaml
rename to example-specs/task/nipype/fsl/vest_2_text.yaml
index f63c0301..9028f77c 100644
--- a/example-specs/task/nipype_internal/pydra-fsl/vest_2_text.yaml
+++ b/example-specs/task/nipype/fsl/vest_2_text.yaml
@@ -34,9 +34,6 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: datascience/text-matrix
     # type=file|default=<undefined>: matrix data stored in the format used by FSL tools
-    out_file: generic/file
-    # type=file: plain text representation of FSL matrix
-    # type=file|default='design.txt': file name to store text output from matrix
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype_internal/pydra-fsl/vest_2_text_callables.py b/example-specs/task/nipype/fsl/vest_2_text_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/vest_2_text_callables.py
rename to example-specs/task/nipype/fsl/vest_2_text_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/warp_points.yaml b/example-specs/task/nipype/fsl/warp_points.yaml
similarity index 97%
rename from example-specs/task/nipype_internal/pydra-fsl/warp_points.yaml
rename to example-specs/task/nipype/fsl/warp_points.yaml
index e29720e2..dd7e73f1 100644
--- a/example-specs/task/nipype_internal/pydra-fsl/warp_points.yaml
+++ b/example-specs/task/nipype/fsl/warp_points.yaml
@@ -51,9 +51,6 @@ inputs:
     # type=file|default=<undefined>: filename of affine transform (e.g. source2dest.mat)
     warp_file: medimage/nifti1
     # type=file|default=<undefined>: filename of warpfield (e.g. intermediate2dest_warp.nii.gz)
-    out_file: generic/file
-    # type=file: Name of output file, containing the warp as field or coefficients.
-    # type=file|default=<undefined>: output file name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype_internal/pydra-fsl/warp_points_callables.py b/example-specs/task/nipype/fsl/warp_points_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/warp_points_callables.py
rename to example-specs/task/nipype/fsl/warp_points_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/warp_points_from_std.yaml b/example-specs/task/nipype/fsl/warp_points_from_std.yaml
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/warp_points_from_std.yaml
rename to example-specs/task/nipype/fsl/warp_points_from_std.yaml
diff --git a/example-specs/task/nipype_internal/pydra-fsl/warp_points_from_std_callables.py b/example-specs/task/nipype/fsl/warp_points_from_std_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/warp_points_from_std_callables.py
rename to example-specs/task/nipype/fsl/warp_points_from_std_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/warp_points_to_std.yaml b/example-specs/task/nipype/fsl/warp_points_to_std.yaml
similarity index 98%
rename from example-specs/task/nipype_internal/pydra-fsl/warp_points_to_std.yaml
rename to example-specs/task/nipype/fsl/warp_points_to_std.yaml
index 1ee0c210..d7808b21 100644
--- a/example-specs/task/nipype_internal/pydra-fsl/warp_points_to_std.yaml
+++ b/example-specs/task/nipype/fsl/warp_points_to_std.yaml
@@ -55,9 +55,6 @@ inputs:
     # type=file|default=<undefined>: filename of affine transform (e.g. source2dest.mat)
     warp_file: medimage/nifti1
     # type=file|default=<undefined>: filename of warpfield (e.g. intermediate2dest_warp.nii.gz)
-    out_file: generic/file
-    # type=file: Name of output file, containing the warp as field or coefficients.
-    # type=file|default=<undefined>: output file name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype_internal/pydra-fsl/warp_points_to_std_callables.py b/example-specs/task/nipype/fsl/warp_points_to_std_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/warp_points_to_std_callables.py
rename to example-specs/task/nipype/fsl/warp_points_to_std_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/warp_utils.yaml b/example-specs/task/nipype/fsl/warp_utils.yaml
similarity index 95%
rename from example-specs/task/nipype_internal/pydra-fsl/warp_utils.yaml
rename to example-specs/task/nipype/fsl/warp_utils.yaml
index 8b08dd4b..f9369aaa 100644
--- a/example-specs/task/nipype_internal/pydra-fsl/warp_utils.yaml
+++ b/example-specs/task/nipype/fsl/warp_utils.yaml
@@ -43,12 +43,6 @@ inputs:
     # type=file|default=<undefined>: Name of file containing warp-coefficients/fields. This would typically be the output from the --cout switch of fnirt (but can also use fields, like the output from --fout).
     reference: medimage/nifti1
     # type=file|default=<undefined>: Name of a file in target space. Note that the target space is now different from the target space that was used to create the --warp file. It would typically be the file that was specified with the --in argument when running fnirt.
-    out_file: generic/file
-    # type=file: Name of output file, containing the warp as field or coefficients.
-    # type=file|default=<undefined>: Name of output file. The format of the output depends on what other parameters are set. The default format is a (4D) field-file. If the --outformat is set to spline the format will be a (4D) file of spline coefficients.
-    out_jacobian: generic/file
-    # type=file: Name of output file, containing the map of the determinant of the Jacobian
-    # type=file|default=<undefined>: Specifies that a (3D) file of Jacobian determinants corresponding to --in should be produced and written to filename.
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype_internal/pydra-fsl/warp_utils_callables.py b/example-specs/task/nipype/fsl/warp_utils_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/warp_utils_callables.py
rename to example-specs/task/nipype/fsl/warp_utils_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-fsl/x_fibres_5.yaml b/example-specs/task/nipype/fsl/x_fibres_5.yaml
similarity index 98%
rename from example-specs/task/nipype_internal/pydra-fsl/x_fibres_5.yaml
rename to example-specs/task/nipype/fsl/x_fibres_5.yaml
index 73909879..7236d371 100644
--- a/example-specs/task/nipype_internal/pydra-fsl/x_fibres_5.yaml
+++ b/example-specs/task/nipype/fsl/x_fibres_5.yaml
@@ -51,7 +51,7 @@ outputs:
     mean_dsamples: generic/file
     # type=file: Mean of distribution on diffusivity d
     mean_S0samples: generic/file
-    # type=file: Mean of distribution on T2w baseline signal intensity S0
+    # type=file: Mean of distribution on T2wbaseline signal intensity S0
     mean_tausamples: generic/file
     # type=file: Mean of distribution on tau samples (only with rician noise)
   callables:
diff --git a/example-specs/task/nipype_internal/pydra-fsl/x_fibres_5_callables.py b/example-specs/task/nipype/fsl/x_fibres_5_callables.py
similarity index 100%
rename from example-specs/task/nipype_internal/pydra-fsl/x_fibres_5_callables.py
rename to example-specs/task/nipype/fsl/x_fibres_5_callables.py
diff --git a/example-specs/task/nipype_internal/pydra-brainsuite/bdp.yaml b/example-specs/task/nipype_internal/pydra-brainsuite/bdp.yaml
deleted file mode 100644
index 6753fc5b..00000000
--- a/example-specs/task/nipype_internal/pydra-brainsuite/bdp.yaml
+++ /dev/null
@@ -1,206 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.brainsuite.brainsuite.BDP' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     BrainSuite Diffusion Pipeline (BDP) enables fusion of diffusion and
-#     structural MRI information for advanced image and connectivity analysis.
-#     It provides various methods for distortion correction, co-registration,
-#     diffusion modeling (DTI and ODF) and basic ROI-wise statistic. BDP is a
-#     flexible and diverse tool which supports wide variety of diffusion
-#     datasets.
-#     For more information, please see:
-# 
-#     http://brainsuite.org/processing/diffusion/
-# 
-#     Examples
-#     --------
-# 
-#     >>> from nipype.interfaces import brainsuite
-#     >>> bdp = brainsuite.BDP()
-#     >>> bdp.inputs.bfcFile = '/directory/subdir/prefix.bfc.nii.gz'
-#     >>> bdp.inputs.inputDiffusionData = '/directory/subdir/prefix.dwi.nii.gz'
-#     >>> bdp.inputs.BVecBValPair = ['/directory/subdir/prefix.dwi.bvec', '/directory/subdir/prefix.dwi.bval']
-#     >>> results = bdp.run() #doctest: +SKIP
-# 
-# 
-#     
-task_name: BDP
-nipype_name: BDP
-nipype_module: nipype.interfaces.brainsuite.brainsuite
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    bfcFile: generic/file
-    # type=file|default=<undefined>: Specify absolute path to file produced by bfc. By default, bfc produces the file in the format: prefix.bfc.nii.gz
-    inputDiffusionData: generic/file
-    # type=file|default=<undefined>: Specifies the absolute path and filename of the input diffusion data in 4D NIfTI-1 format. The flag must be followed by the filename. Only NIfTI-1 files with extension .nii or .nii.gz are supported. Furthermore, either  bMatrixFile, or a combination of both bValueFile and diffusionGradientFile must be used to provide the necessary b-matrices/b-values and gradient vectors. 
-    bMatrixFile: generic/file
-    # type=file|default=<undefined>: Specifies the absolute path and filename of the file containing b-matrices for diffusion-weighted scans. The flag must be followed by the filename. This file must be a plain text file containing 3x3 matrices for each diffusion encoding direction. It should contain zero matrices corresponding to b=0 images. This file usually has ".bmat" as its extension, and can be used to provide BDP with the more-accurate b-matrices as saved by some proprietary scanners. The b-matrices specified by the file must be in the voxel coordinates of the input diffusion weighted image (NIfTI file). In case b-matrices are not known/calculated, bvec and .bval files can be used instead (see diffusionGradientFile and bValueFile). 
-    t1Mask: generic/file
-    # type=file|default=<undefined>: Specifies the filename of the brain-mask file for input T1-weighted image. This mask can be same as the brain mask generated during BrainSuite extraction sequence. For best results, the mask should not include any extra-meningial tissues from T1-weighted image. The mask must be in the same coordinates as input T1-weighted image (i.e. should overlay correctly with input <fileprefix>.bfc.nii.gz file in BrainSuite). This mask is used for co-registration and defining brain boundary for statistics computation. The mask can be generated and/or edited in BrainSuite. In case outputDiffusionCoordinates is also used, this mask is first transformed to diffusion coordinate and the transformed mask is used for defining brain boundary in diffusion coordinates. When t1Mask is not set, BDP will try to use fileprefix>.mask.nii.gz as brain-mask. If <fileprefix>.mask.nii.gz is not found, then BDP will use the input <fileprefix>.bfc.nii.gz itself as mask (i.e. all non-zero voxels in <fileprefix>.bfc.nii.gz is assumed to constitute brain mask).  
-    dwiMask: generic/file
-    # type=file|default=<undefined>: Specifies the filename of the brain-mask file for diffusion data. This mask is used only for co-registration purposes and can affect overall quality of co-registration (see t1Mask for definition of brain mask for statistics computation). The mask must be a 3D volume and should be in the same coordinates as input Diffusion file/data (i.e. should overlay correctly with input diffusion data in BrainSuite). For best results, the mask should include only brain voxels (CSF voxels around brain is also acceptable). When this flag is not used, BDP will generate a pseudo mask using first b=0 image volume and would save it as fileprefix>.dwi.RSA.mask.nii.gz. In case co-registration is not accurate with automatically generated pseudo mask, BDP should be re-run with a refined diffusion mask. The mask can be generated and/or edited in BrainSuite. 
-    fieldmapCorrection: generic/file
-    # type=file|default=<undefined>: Use an acquired fieldmap for distortion correction. The fieldmap must have units of radians/second. Specify the filename of the fieldmap file. The field of view (FOV) of the fieldmap scan must cover the FOV of the diffusion scan. BDP will try to check the overlap of the FOV of the two scans and will issue a warning/error if the diffusion scan"s FOV is not fully covered by the fieldmap"s FOV. BDP uses all of the information saved in the NIfTI header to compute the FOV. If you get this error and think that it is incorrect, then it can be suppressed using the flag ignore-fieldmap-FOV. Neither the image matrix size nor the imaging grid resolution of the fieldmap needs to be the same as that of the diffusion scan, but the fieldmap must be pre-registred to the diffusion scan. BDP does NOT align the fieldmap to the diffusion scan, nor does it check the alignment of the fieldmap and diffusion scans. Only NIfTI files with extension of .nii or .nii.gz are supported. Fieldmap-based distortion correction also requires the echoSpacing. Also fieldmapCorrectionMethod allows you to define method for distortion correction. least squares is the default method. 
-    transformDiffusionVolume: generic/file
-    # type=file|default=<undefined>: This flag allows to define custom volumes in diffusion coordinate which would be transformed into T1 coordinate in a rigid fashion. The flag must be followed by the name of either a NIfTI file or of a folder that contains one or more NIfTI files. All of the files must be in diffusion coordinate, i.e. the files should overlay correctly with the diffusion scan in BrainSuite. Only NIfTI files with an extension of .nii or .nii.gz are supported. The transformed files are written to the output directory with suffix ".T1_coord" in the filename and will not be corrected for distortion, if any. The trait transformInterpolation can be used to define the type of interpolation that would be used (default is set to linear). If you are attempting to transform a label file or mask file, use "nearest" interpolation method with transformInterpolation. See also transformT1Volume and transformInterpolation
-    transformT1Volume: generic/file
-    # type=file|default=<undefined>: Same as transformDiffusionVolume except that files specified must be in T1 coordinate, i.e. the files should overlay correctly with the input <fileprefix>.bfc.nii.gz files in BrainSuite. BDP transforms these data/images from T1 coordinate to diffusion coordinate. The transformed files are written to the output directory with suffix ".D_coord" in the filename. See also transformDiffusionVolume  and transformInterpolation. 
-    transformT1Surface: generic/file
-    # type=file|default=<undefined>: Similar to transformT1Volume, except that this flag allows transforming surfaces (instead of volumes) in T1 coordinate into diffusion coordinate in a rigid fashion. The flag must be followed by the name of either a .dfs file or of a folder that contains one or more dfs files. All of the files must be in T1 coordinate, i.e. the files should overlay correctly with the T1-weighted scan in BrainSuite. The transformed files are written to the output directory with suffix D_coord" in the filename. 
-    transformDiffusionSurface: generic/file
-    # type=file|default=<undefined>: Same as transformT1Volume, except that the .dfs files specified must be in diffusion coordinate, i.e. the surface files should overlay correctly with the diffusion scan in BrainSuite. The transformed files are written to the output directory with suffix ".T1_coord" in the filename. See also transformT1Volume. 
-    customDiffusionLabel: generic/file
-    # type=file|default=<undefined>: BDP supports custom ROIs in addition to those generated by BrainSuite SVReg) for ROI-wise statistics calculation. The flag must be followed by the name of either a file (custom ROI file) or of a folder that contains one or more ROI files. All of the files must be in diffusion coordinate, i.e. the label files should overlay correctly with the diffusion scan in BrainSuite. These input label files are also transferred (and saved) to T1 coordinate for statistics in T1 coordinate. BDP uses nearest-neighborhood interpolation for this transformation. Only NIfTI files, with an extension of .nii or .nii.gz are supported. In order to avoid confusion with other ROI IDs in the statistic files, a 5-digit ROI ID is generated for each custom label found and the mapping of ID to label file is saved in the file fileprefix>.BDP_ROI_MAP.xml. Custom label files can also be generated by using the label painter tool in BrainSuite. See also customLabelXML
-    customT1Label: generic/file
-    # type=file|default=<undefined>: Same as customDiffusionLabelexcept that the label files specified must be in T1 coordinate, i.e. the label files should overlay correctly with the T1-weighted scan in BrainSuite. If the trait outputDiffusionCoordinates is also used then these input label files are also transferred (and saved) to diffusion coordinate for statistics in diffusion coordinate. BDP uses nearest-neighborhood interpolation for this transformation. See also customLabelXML. 
-    customLabelXML: generic/file
-    # type=file|default=<undefined>: BrainSuite saves a descriptions of the SVReg labels (ROI name, ID, color, and description) in an .xml file brainsuite_labeldescription.xml). BDP uses the ROI ID"s from this xml file to report statistics. This flag allows for the use of a custom label description xml file. The flag must be followed by an xml filename. This can be useful when you want to limit the ROIs for which you compute statistics. You can also use custom xml files to name your own ROIs (assign ID"s) for custom labels. BrainSuite can save a label description in .xml format after using the label painter tool to create a ROI label. The xml file MUST be in the same format as BrainSuite"s label description file (see brainsuite_labeldescription.xml for an example). When this flag is used, NO 5-digit ROI ID is generated for custom label files and NO Statistics will be calculated for ROIs not identified in the custom xml file. See also customDiffusionLabel and customT1Label.
-    flagConfigFile: generic/file
-    # type=file|default=<undefined>: Uses the defined file to specify BDP flags which can be useful for batch processing. A flag configuration file is a plain text file which can contain any number of BDP"s optional flags (and their parameters) separated by whitespace. Everything coming after # until end-of-line is treated as comment and is ignored. If a flag is defined in configuration file and is also specified in the command used to run BDP, then the later get preference and overrides the definition in configuration file. 
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    bfcFile:
-    # type=file|default=<undefined>: Specify absolute path to file produced by bfc. By default, bfc produces the file in the format: prefix.bfc.nii.gz
-    noStructuralRegistration:
-    # type=bool|default=False: Allows BDP to work without any structural input. This can useful when one is only interested in diffusion modelling part of BDP. With this flag only fieldmap-based distortion correction is supported. outPrefix can be used to specify fileprefix of the output filenames. Change dwiMask to define region of interest for diffusion modelling.
-    inputDiffusionData:
-    # type=file|default=<undefined>: Specifies the absolute path and filename of the input diffusion data in 4D NIfTI-1 format. The flag must be followed by the filename. Only NIfTI-1 files with extension .nii or .nii.gz are supported. Furthermore, either  bMatrixFile, or a combination of both bValueFile and diffusionGradientFile must be used to provide the necessary b-matrices/b-values and gradient vectors. 
-    bMatrixFile:
-    # type=file|default=<undefined>: Specifies the absolute path and filename of the file containing b-matrices for diffusion-weighted scans. The flag must be followed by the filename. This file must be a plain text file containing 3x3 matrices for each diffusion encoding direction. It should contain zero matrices corresponding to b=0 images. This file usually has ".bmat" as its extension, and can be used to provide BDP with the more-accurate b-matrices as saved by some proprietary scanners. The b-matrices specified by the file must be in the voxel coordinates of the input diffusion weighted image (NIfTI file). In case b-matrices are not known/calculated, bvec and .bval files can be used instead (see diffusionGradientFile and bValueFile). 
-    BVecBValPair:
-    # type=list|default=[]: Must input a list containing first the BVector file, then the BValue file (both must be absolute paths) Example: bdp.inputs.BVecBValPair = ['/directory/subdir/prefix.dwi.bvec', '/directory/subdir/prefix.dwi.bval'] The first item in the list specifies the filename of the file containing b-values for the diffusion scan. The b-value file must be a plain-text file and usually has an extension of .bval The second item in the list specifies the filename of the file containing the diffusion gradient directions (specified in the voxel coordinates of the input diffusion-weighted image)The b-vectors file must be a plain text file and usually has an extension of .bvec 
-    dataSinkDelay:
-    # type=list|default=[]: For use in parallel processing workflows including Brainsuite Cortical Surface Extraction sequence. Connect datasink out_file to dataSinkDelay to delay execution of BDP until dataSink has finished sinking outputs. In particular, BDP may be run after BFC has finished. For more information see http://brainsuite.org/processing/diffusion/pipeline/
-    phaseEncodingDirection:
-    # type=enum|default='x'|allowed['x','x-','y','y-','z','z-']: Specifies the phase-encoding direction of the EPI (diffusion) images. It is same as the dominant direction of distortion in the images. This information is used to constrain the distortion correction along the specified direction. Directions are represented by any one of x, x-, y, y-, z or z-. "x" direction increases towards the right side of the subject, while "x-" increases towards the left side of the subject. Similarly, "y" and "y-" are along the anterior-posterior direction of the subject, and "z" & "z-" are along the inferior-superior direction. When this flag is not used, BDP uses "y" as the default phase-encoding direction. 
-    echoSpacing:
-    # type=float|default=0.0: Sets the echo spacing to t seconds, which is used for fieldmap-based distortion correction. This flag is required when using fieldmapCorrection
-    bValRatioThreshold:
-    # type=float|default=0.0: Sets a threshold which is used to determine b=0 images. When there are no diffusion weighted image with b-value of zero, then BDP tries to use diffusion weighted images with a low b-value in place of b=0 image. The diffusion images with minimum b-value is used as b=0 image only if the ratio of the maximum and minimum b-value is more than the specified threshold. A lower value of threshold will allow diffusion images with higher b-value to be used as b=0 image. The default value of this threshold is set to 45, if this trait is not set. 
-    estimateTensors:
-    # type=bool|default=False: Estimates diffusion tensors using a weighted log-linear estimation and saves derived diffusion tensor parameters (FA, MD, axial, radial, L2, L3). This is the default behavior if no diffusion modeling flags are specified. The estimated diffusion tensors can be visualized by loading the saved ``*.eig.nii.gz`` file in BrainSuite. BDP reports diffusivity (MD, axial, radial, L2 and L3) in a unit which is reciprocal inverse of the unit of input b-value. 
-    estimateODF_FRACT:
-    # type=bool|default=False: Estimates ODFs using the Funk-Radon and Cosine Transformation (FRACT). The outputs are saved in a separate directory with name "FRACT" and the ODFs can be visualized by loading the saved ".odf" file in BrainSuite. 
-    estimateODF_FRT:
-    # type=bool|default=False: Estimates ODFs using Funk-Radon Transformation (FRT). The coefficient maps for ODFs are saved in a separate directory with name "FRT" and the ODFs can be visualized by loading the saved ".odf" file in BrainSuite. The derived generalized-FA (GFA) maps are also saved in the output directory. 
-    estimateODF_3DShore:
-    # type=float|default=0.0: Estimates ODFs using 3Dshore. Pass in diffusion time, in ms
-    odfLambta:
-    # type=bool|default=False: Sets the regularization parameter, lambda, of the Laplace-Beltrami operator while estimating ODFs. The default value is set to 0.006 . This can be used to set the appropriate regularization for the input diffusion data. 
-    t1Mask:
-    # type=file|default=<undefined>: Specifies the filename of the brain-mask file for input T1-weighted image. This mask can be same as the brain mask generated during BrainSuite extraction sequence. For best results, the mask should not include any extra-meningial tissues from T1-weighted image. The mask must be in the same coordinates as input T1-weighted image (i.e. should overlay correctly with input <fileprefix>.bfc.nii.gz file in BrainSuite). This mask is used for co-registration and defining brain boundary for statistics computation. The mask can be generated and/or edited in BrainSuite. In case outputDiffusionCoordinates is also used, this mask is first transformed to diffusion coordinate and the transformed mask is used for defining brain boundary in diffusion coordinates. When t1Mask is not set, BDP will try to use fileprefix>.mask.nii.gz as brain-mask. If <fileprefix>.mask.nii.gz is not found, then BDP will use the input <fileprefix>.bfc.nii.gz itself as mask (i.e. all non-zero voxels in <fileprefix>.bfc.nii.gz is assumed to constitute brain mask).  
-    dwiMask:
-    # type=file|default=<undefined>: Specifies the filename of the brain-mask file for diffusion data. This mask is used only for co-registration purposes and can affect overall quality of co-registration (see t1Mask for definition of brain mask for statistics computation). The mask must be a 3D volume and should be in the same coordinates as input Diffusion file/data (i.e. should overlay correctly with input diffusion data in BrainSuite). For best results, the mask should include only brain voxels (CSF voxels around brain is also acceptable). When this flag is not used, BDP will generate a pseudo mask using first b=0 image volume and would save it as fileprefix>.dwi.RSA.mask.nii.gz. In case co-registration is not accurate with automatically generated pseudo mask, BDP should be re-run with a refined diffusion mask. The mask can be generated and/or edited in BrainSuite. 
-    rigidRegMeasure:
-    # type=enum|default='MI'|allowed['BDP','INVERSION','MI']: Defines the similarity measure to be used for rigid registration. Possible measures are "MI", "INVERSION" and "BDP". MI measure uses normalized mutual information based cost function. INVERSION measure uses simpler cost function based on sum of squared difference by exploiting the approximate inverse-contrast relationship in T1- and T2-weighted images. BDP measure combines MI and INVERSION. It starts with INVERSION measure and refines the result with MI measure. BDP is the default measure when this trait is not set.  
-    dcorrRegMeasure:
-    # type=enum|default='MI'|allowed['BDP','INVERSION-BOTH','INVERSION-EPI','INVERSION-T1','MI']: Defines the method for registration-based distortion correction. Possible methods are "MI", "INVERSION-EPI", "INVERSION-T1", INVERSION-BOTH", and "BDP". MI method uses normalized mutual information based cost-function while estimating the distortion field. INVERSION-based method uses simpler cost function based on sum of squared difference by exploiting the known approximate contrast relationship in T1- and T2-weighted images. T2-weighted EPI is inverted when INVERSION-EPI is used; T1-image is inverted when INVERSION-T1 is used; and both are inverted when INVERSION-BOTH is used. BDP method add the MI-based refinement after the correction using INVERSION-BOTH method. BDP is the default method when this trait is not set.  
-    dcorrWeight:
-    # type=float|default=0.0: Sets the (scalar) weighting parameter for regularization penalty in registration-based distortion correction. Set this trait to a single, non-negative number which specifies the weight. A large regularization weight encourages smoother distortion field at the cost of low measure of image similarity after distortion correction. On the other hand, a smaller regularization weight can result into higher measure of image similarity but with unrealistic and unsmooth distortion field. A weight of 0.5 would reduce the penalty to half of the default regularization penalty (By default, this weight is set to 1.0). Similarly, a weight of 2.0 would increase the penalty to twice of the default penalty.  
-    skipDistortionCorr:
-    # type=bool|default=False: Skips distortion correction completely and performs only a rigid registration of diffusion and T1-weighted image. This can be useful when the input diffusion images do not have any distortion or they have been corrected for distortion. 
-    skipNonuniformityCorr:
-    # type=bool|default=False: Skips intensity non-uniformity correction in b=0 image for registration-based distortion correction. The intensity non-uniformity correction does not affect any diffusion modeling. 
-    skipIntensityCorr:
-    # type=bool|default=False: Disables intensity correction when performing distortion correction. Intensity correction can change the noise distribution in the corrected image, but it does not affect estimated diffusion parameters like FA, etc. 
-    fieldmapCorrection:
-    # type=file|default=<undefined>: Use an acquired fieldmap for distortion correction. The fieldmap must have units of radians/second. Specify the filename of the fieldmap file. The field of view (FOV) of the fieldmap scan must cover the FOV of the diffusion scan. BDP will try to check the overlap of the FOV of the two scans and will issue a warning/error if the diffusion scan"s FOV is not fully covered by the fieldmap"s FOV. BDP uses all of the information saved in the NIfTI header to compute the FOV. If you get this error and think that it is incorrect, then it can be suppressed using the flag ignore-fieldmap-FOV. Neither the image matrix size nor the imaging grid resolution of the fieldmap needs to be the same as that of the diffusion scan, but the fieldmap must be pre-registred to the diffusion scan. BDP does NOT align the fieldmap to the diffusion scan, nor does it check the alignment of the fieldmap and diffusion scans. Only NIfTI files with extension of .nii or .nii.gz are supported. Fieldmap-based distortion correction also requires the echoSpacing. Also fieldmapCorrectionMethod allows you to define method for distortion correction. least squares is the default method. 
-    fieldmapCorrectionMethod:
-    # type=enum|default='pixelshift'|allowed['leastsq','pixelshift']: Defines the distortion correction method while using fieldmap. Possible methods are "pixelshift" and "leastsq". leastsq is the default method when this flag is not used. Pixel-shift (pixelshift) method uses image interpolation to un-distort the distorted diffusion images. Least squares (leastsq) method uses a physical model of distortion which is more accurate (and more computationally expensive) than pixel-shift method.
-    ignoreFieldmapFOV:
-    # type=bool|default=False: Suppresses the error generated by an insufficient field of view of the input fieldmap and continues with the processing. It is useful only when used with fieldmap-based distortion correction. See fieldmap-correction for a detailed explanation. 
-    fieldmapSmooth:
-    # type=float|default=0.0: Applies 3D Gaussian smoothing with a standard deviation of S millimeters (mm) to the input fieldmap before applying distortion correction. This trait is only useful with fieldmapCorrection. Skip this trait for no smoothing. 
-    transformDiffusionVolume:
-    # type=file|default=<undefined>: This flag allows to define custom volumes in diffusion coordinate which would be transformed into T1 coordinate in a rigid fashion. The flag must be followed by the name of either a NIfTI file or of a folder that contains one or more NIfTI files. All of the files must be in diffusion coordinate, i.e. the files should overlay correctly with the diffusion scan in BrainSuite. Only NIfTI files with an extension of .nii or .nii.gz are supported. The transformed files are written to the output directory with suffix ".T1_coord" in the filename and will not be corrected for distortion, if any. The trait transformInterpolation can be used to define the type of interpolation that would be used (default is set to linear). If you are attempting to transform a label file or mask file, use "nearest" interpolation method with transformInterpolation. See also transformT1Volume and transformInterpolation
-    transformT1Volume:
-    # type=file|default=<undefined>: Same as transformDiffusionVolume except that files specified must be in T1 coordinate, i.e. the files should overlay correctly with the input <fileprefix>.bfc.nii.gz files in BrainSuite. BDP transforms these data/images from T1 coordinate to diffusion coordinate. The transformed files are written to the output directory with suffix ".D_coord" in the filename. See also transformDiffusionVolume  and transformInterpolation. 
-    transformInterpolation:
-    # type=enum|default='linear'|allowed['cubic','linear','nearest','spline']: Defines the type of interpolation method which would be used while transforming volumes defined by transformT1Volume and transformDiffusionVolume. Possible methods are "linear", "nearest", "cubic" and "spline". By default, "linear" interpolation is used. 
-    transformT1Surface:
-    # type=file|default=<undefined>: Similar to transformT1Volume, except that this flag allows transforming surfaces (instead of volumes) in T1 coordinate into diffusion coordinate in a rigid fashion. The flag must be followed by the name of either a .dfs file or of a folder that contains one or more dfs files. All of the files must be in T1 coordinate, i.e. the files should overlay correctly with the T1-weighted scan in BrainSuite. The transformed files are written to the output directory with suffix D_coord" in the filename. 
-    transformDiffusionSurface:
-    # type=file|default=<undefined>: Same as transformT1Volume, except that the .dfs files specified must be in diffusion coordinate, i.e. the surface files should overlay correctly with the diffusion scan in BrainSuite. The transformed files are written to the output directory with suffix ".T1_coord" in the filename. See also transformT1Volume. 
-    transformDataOnly:
-    # type=bool|default=False: Skip all of the processing (co-registration, distortion correction and tensor/ODF estimation) and directly start transformation of defined custom volumes, mask and labels (using transformT1Volume, transformDiffusionVolume, transformT1Surface, transformDiffusionSurface, customDiffusionLabel, customT1Label). This flag is useful when BDP was previously run on a subject (or <fileprefix>) and some more data (volumes, mask or labels) need to be transformed across the T1-diffusion coordinate spaces. This assumes that all the necessary files were generated earlier and all of the other flags MUST be used in the same way as they were in the initial BDP run that processed the data. 
-    generateStats:
-    # type=bool|default=False: Generate ROI-wise statistics of estimated diffusion tensor parameters. Units of the reported statistics are same as that of the estimated tensor parameters (see estimateTensors). Mean, variance, and voxel counts of white matter(WM), grey matter(GM), and both WM and GM combined are written for each estimated parameter in a separate comma-seperated value csv) file. BDP uses the ROI labels generated by Surface-Volume Registration (SVReg) in the BrainSuite extraction sequence. Specifically, it looks for labels saved in either fileprefix>.svreg.corr.label.nii.gz or <fileprefix>.svreg.label.nii.gz. In case both files are present, only the first file is used. Also see customDiffusionLabel and customT1Label for specifying your own ROIs. It is also possible to forgo computing the SVReg ROI-wise statistics and only compute stats with custom labels if SVReg label is missing. BDP also transfers (and saves) the label/mask files to appropriate coordinates before computing statistics. Also see outputDiffusionCoordinates for outputs in diffusion coordinate and forcePartialROIStats for an important note about field of view of diffusion and T1-weighted scans. 
-    onlyStats:
-    # type=bool|default=False: Skip all of the processing (co-registration, distortion correction and tensor/ODF estimation) and directly start computation of statistics. This flag is useful when BDP was previously run on a subject (or fileprefix>) and statistics need to be (re-)computed later. This assumes that all the necessary files were generated earlier. All of the other flags MUST be used in the same way as they were in the initial BDP run that processed the data. 
-    forcePartialROIStats:
-    # type=bool|default=False: The field of view (FOV) of the diffusion and T1-weighted scans may differ significantly in some situations. This may result in partial acquisitions of some ROIs in the diffusion scan. By default, BDP does not compute statistics for partially acquired ROIs and shows warnings. This flag forces computation of statistics for all ROIs, including those which are partially acquired. When this flag is used, number of missing voxels are also reported for each ROI in statistics files. Number of missing voxels are reported in the same coordinate system as the statistics file.  
-    customDiffusionLabel:
-    # type=file|default=<undefined>: BDP supports custom ROIs in addition to those generated by BrainSuite SVReg) for ROI-wise statistics calculation. The flag must be followed by the name of either a file (custom ROI file) or of a folder that contains one or more ROI files. All of the files must be in diffusion coordinate, i.e. the label files should overlay correctly with the diffusion scan in BrainSuite. These input label files are also transferred (and saved) to T1 coordinate for statistics in T1 coordinate. BDP uses nearest-neighborhood interpolation for this transformation. Only NIfTI files, with an extension of .nii or .nii.gz are supported. In order to avoid confusion with other ROI IDs in the statistic files, a 5-digit ROI ID is generated for each custom label found and the mapping of ID to label file is saved in the file fileprefix>.BDP_ROI_MAP.xml. Custom label files can also be generated by using the label painter tool in BrainSuite. See also customLabelXML
-    customT1Label:
-    # type=file|default=<undefined>: Same as customDiffusionLabelexcept that the label files specified must be in T1 coordinate, i.e. the label files should overlay correctly with the T1-weighted scan in BrainSuite. If the trait outputDiffusionCoordinates is also used then these input label files are also transferred (and saved) to diffusion coordinate for statistics in diffusion coordinate. BDP uses nearest-neighborhood interpolation for this transformation. See also customLabelXML. 
-    customLabelXML:
-    # type=file|default=<undefined>: BrainSuite saves a descriptions of the SVReg labels (ROI name, ID, color, and description) in an .xml file brainsuite_labeldescription.xml). BDP uses the ROI ID"s from this xml file to report statistics. This flag allows for the use of a custom label description xml file. The flag must be followed by an xml filename. This can be useful when you want to limit the ROIs for which you compute statistics. You can also use custom xml files to name your own ROIs (assign ID"s) for custom labels. BrainSuite can save a label description in .xml format after using the label painter tool to create a ROI label. The xml file MUST be in the same format as BrainSuite"s label description file (see brainsuite_labeldescription.xml for an example). When this flag is used, NO 5-digit ROI ID is generated for custom label files and NO Statistics will be calculated for ROIs not identified in the custom xml file. See also customDiffusionLabel and customT1Label.
-    outputSubdir:
-    # type=str|default='': By default, BDP writes out all the output (and intermediate) files in the same directory (or folder) as the BFC file. This flag allows to specify a sub-directory name in which output (and intermediate) files would be written. BDP will create the sub-directory in the same directory as BFC file. <directory_name> should be the name of the sub-directory without any path. This can be useful to organize all outputs generated by BDP in a separate sub-directory. 
-    outputDiffusionCoordinates:
-    # type=bool|default=False: Enables estimation of diffusion tensors and/or ODFs (and statistics if applicable) in the native diffusion coordinate in addition to the default T1-coordinate. All native diffusion coordinate files are saved in a separate folder named "diffusion_coord_outputs". In case statistics computation is required, it will also transform/save all label/mask files required to diffusion coordinate (see generateStats for details). 
-    flagConfigFile:
-    # type=file|default=<undefined>: Uses the defined file to specify BDP flags which can be useful for batch processing. A flag configuration file is a plain text file which can contain any number of BDP"s optional flags (and their parameters) separated by whitespace. Everything coming after # until end-of-line is treated as comment and is ignored. If a flag is defined in configuration file and is also specified in the command used to run BDP, then the later get preference and overrides the definition in configuration file. 
-    outPrefix:
-    # type=str|default='': Specifies output fileprefix when noStructuralRegistration is used. The fileprefix can not start with a dash (-) and should be a simple string reflecting the absolute path to desired location, along with outPrefix. When this flag is not specified (and noStructuralRegistration is used) then the output files have same file-base as the input diffusion file. This trait is ignored when noStructuralRegistration is not used. 
-    threads:
-    # type=int|default=0: Sets the number of parallel process threads which can be used for computations to N, where N must be an integer. Default value of N is  
-    lowMemory:
-    # type=bool|default=False: Activates low-memory mode. This will run the registration-based distortion correction at a lower resolution, which could result in a less-accurate correction. This should only be used when no other alternative is available. 
-    ignoreMemory:
-    # type=bool|default=False: Deactivates the inbuilt memory checks and forces BDP to run registration-based distortion correction at its default resolution even on machines with a low amount of memory. This may result in an out-of-memory error when BDP cannot allocate sufficient memory. 
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-brainsuite/bdp_callables.py b/example-specs/task/nipype_internal/pydra-brainsuite/bdp_callables.py
deleted file mode 100644
index ff745b83..00000000
--- a/example-specs/task/nipype_internal/pydra-brainsuite/bdp_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in BDP.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-brainsuite/bfc.yaml b/example-specs/task/nipype_internal/pydra-brainsuite/bfc.yaml
deleted file mode 100644
index 3c05c844..00000000
--- a/example-specs/task/nipype_internal/pydra-brainsuite/bfc.yaml
+++ /dev/null
@@ -1,160 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.brainsuite.brainsuite.Bfc' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     bias field corrector (BFC)
-#     This program corrects gain variation in T1-weighted MRI.
-# 
-#     http://brainsuite.org/processing/surfaceextraction/bfc/
-# 
-#     Examples
-#     --------
-# 
-#     >>> from nipype.interfaces import brainsuite
-#     >>> from nipype.testing import example_data
-#     >>> bfc = brainsuite.Bfc()
-#     >>> bfc.inputs.inputMRIFile = example_data('structural.nii')
-#     >>> bfc.inputs.inputMaskFile = example_data('mask.nii')
-#     >>> results = bfc.run() #doctest: +SKIP
-# 
-#     
-task_name: Bfc
-nipype_name: Bfc
-nipype_module: nipype.interfaces.brainsuite.brainsuite
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputMRIFile: generic/file
-    # type=file|default=<undefined>: input skull-stripped MRI volume
-    inputMaskFile: generic/file
-    # type=file|default=<undefined>: mask file
-    outputBiasField: generic/file
-    # type=file: path/name of bias field output file
-    # type=file|default=<undefined>: save bias field estimate
-    outputMaskedBiasField: generic/file
-    # type=file: path/name of masked bias field output
-    # type=file|default=<undefined>: save bias field estimate (masked)
-    correctionScheduleFile: generic/file
-    # type=file: path/name of schedule file
-    # type=file|default=<undefined>: list of parameters 
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputMRIVolume: generic/file
-    # type=file: path/name of output file
-    # type=file|default=<undefined>: output bias-corrected MRI volume. If unspecified, output file name will be auto generated.
-    outputBiasField: generic/file
-    # type=file: path/name of bias field output file
-    # type=file|default=<undefined>: save bias field estimate
-    outputMaskedBiasField: generic/file
-    # type=file: path/name of masked bias field output
-    # type=file|default=<undefined>: save bias field estimate (masked)
-    correctionScheduleFile: generic/file
-    # type=file: path/name of schedule file
-    # type=file|default=<undefined>: list of parameters 
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    outputMRIVolume: outputMRIVolume
-    # type=file: path/name of output file
-    # type=file|default=<undefined>: output bias-corrected MRI volume. If unspecified, output file name will be auto generated.
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputMRIFile:
-    # type=file|default=<undefined>: input skull-stripped MRI volume
-    inputMaskFile:
-    # type=file|default=<undefined>: mask file
-    outputMRIVolume:
-    # type=file: path/name of output file
-    # type=file|default=<undefined>: output bias-corrected MRI volume. If unspecified, output file name will be auto generated.
-    outputBiasField:
-    # type=file: path/name of bias field output file
-    # type=file|default=<undefined>: save bias field estimate
-    outputMaskedBiasField:
-    # type=file: path/name of masked bias field output
-    # type=file|default=<undefined>: save bias field estimate (masked)
-    histogramRadius:
-    # type=int|default=0: histogram radius (voxels)
-    biasEstimateSpacing:
-    # type=int|default=0: bias sample spacing (voxels)
-    controlPointSpacing:
-    # type=int|default=0: control point spacing (voxels)
-    splineLambda:
-    # type=float|default=0.0: spline stiffness weighting parameter
-    histogramType:
-    # type=enum|default='ellipse'|allowed['block','ellipse']: Options for type of histogram:    * ``ellipse``: use ellipsoid for ROI histogram   * ``block``:use block for ROI histogram  
-    iterativeMode:
-    # type=bool|default=False: iterative mode (overrides -r, -s, -c, -w settings)
-    correctionScheduleFile:
-    # type=file: path/name of schedule file
-    # type=file|default=<undefined>: list of parameters 
-    biasFieldEstimatesOutputPrefix:
-    # type=str|default='': save iterative bias field estimates as <prefix>.n.field.nii.gz
-    correctedImagesOutputPrefix:
-    # type=str|default='': save iterative corrected images as <prefix>.n.bfc.nii.gz
-    correctWholeVolume:
-    # type=bool|default=False: apply correction field to entire volume
-    minBias:
-    # type=float|default=0.5: minimum allowed bias value
-    maxBias:
-    # type=float|default=1.5: maximum allowed bias value
-    biasRange:
-    # type=enum|default='low'|allowed['high','low','medium']: Preset options for bias_model    * low: small bias model [0.95,1.05]   * medium: medium bias model [0.90,1.10]   * high: high bias model [0.80,1.20]  
-    intermediate_file_type:
-    # type=enum|default='analyze'|allowed['analyze','gzippedAnalyze','gzippedNifti','nifti']: Options for the format in which intermediate files are generated
-    convergenceThreshold:
-    # type=float|default=0.0: convergence threshold
-    biasEstimateConvergenceThreshold:
-    # type=float|default=0.0: bias estimate convergence threshold (values > 0.1 disable)
-    verbosityLevel:
-    # type=int|default=0: verbosity level (0=silent)
-    timer:
-    # type=bool|default=False: display timing information
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-brainsuite/bfc_callables.py b/example-specs/task/nipype_internal/pydra-brainsuite/bfc_callables.py
deleted file mode 100644
index 8aefa14d..00000000
--- a/example-specs/task/nipype_internal/pydra-brainsuite/bfc_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in Bfc.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-brainsuite/bse.yaml b/example-specs/task/nipype_internal/pydra-brainsuite/bse.yaml
deleted file mode 100644
index d4d01779..00000000
--- a/example-specs/task/nipype_internal/pydra-brainsuite/bse.yaml
+++ /dev/null
@@ -1,157 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.brainsuite.brainsuite.Bse' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     brain surface extractor (BSE)
-#     This program performs automated skull and scalp removal on T1-weighted MRI volumes.
-# 
-#     http://brainsuite.org/processing/surfaceextraction/bse/
-# 
-#     Examples
-#     --------
-# 
-#     >>> from nipype.interfaces import brainsuite
-#     >>> from nipype.testing import example_data
-#     >>> bse = brainsuite.Bse()
-#     >>> bse.inputs.inputMRIFile = example_data('structural.nii')
-#     >>> results = bse.run() #doctest: +SKIP
-# 
-#     
-task_name: Bse
-nipype_name: Bse
-nipype_module: nipype.interfaces.brainsuite.brainsuite
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputMRIFile: generic/file
-    # type=file|default=<undefined>: input MRI volume
-    outputDiffusionFilter: generic/file
-    # type=file: path/name of diffusion filter output
-    # type=file|default=<undefined>: diffusion filter output
-    outputEdgeMap: generic/file
-    # type=file: path/name of edge map output
-    # type=file|default=<undefined>: edge map output
-    outputDetailedBrainMask: generic/file
-    # type=file: path/name of detailed brain mask
-    # type=file|default=<undefined>: save detailed brain mask
-    outputCortexFile: generic/file
-    # type=file: path/name of cortex file
-    # type=file|default=<undefined>: cortex file
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputMRIVolume: generic/file
-    # type=file: path/name of brain-masked MRI volume
-    # type=file|default=<undefined>: output brain-masked MRI volume. If unspecified, output file name will be auto generated.
-    outputMaskFile: generic/file
-    # type=file: path/name of smooth brain mask
-    # type=file|default=<undefined>: save smooth brain mask. If unspecified, output file name will be auto generated.
-    outputDiffusionFilter: generic/file
-    # type=file: path/name of diffusion filter output
-    # type=file|default=<undefined>: diffusion filter output
-    outputEdgeMap: generic/file
-    # type=file: path/name of edge map output
-    # type=file|default=<undefined>: edge map output
-    outputDetailedBrainMask: generic/file
-    # type=file: path/name of detailed brain mask
-    # type=file|default=<undefined>: save detailed brain mask
-    outputCortexFile: generic/file
-    # type=file: path/name of cortex file
-    # type=file|default=<undefined>: cortex file
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    outputMRIVolume: outputMRIVolume
-    # type=file: path/name of brain-masked MRI volume
-    # type=file|default=<undefined>: output brain-masked MRI volume. If unspecified, output file name will be auto generated.
-    outputMaskFile: outputMaskFile
-    # type=file: path/name of smooth brain mask
-    # type=file|default=<undefined>: save smooth brain mask. If unspecified, output file name will be auto generated.
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputMRIFile:
-    # type=file|default=<undefined>: input MRI volume
-    outputMRIVolume:
-    # type=file: path/name of brain-masked MRI volume
-    # type=file|default=<undefined>: output brain-masked MRI volume. If unspecified, output file name will be auto generated.
-    outputMaskFile:
-    # type=file: path/name of smooth brain mask
-    # type=file|default=<undefined>: save smooth brain mask. If unspecified, output file name will be auto generated.
-    diffusionConstant:
-    # type=float|default=25: diffusion constant
-    diffusionIterations:
-    # type=int|default=3: diffusion iterations
-    edgeDetectionConstant:
-    # type=float|default=0.64: edge detection constant
-    radius:
-    # type=float|default=1: radius of erosion/dilation filter
-    dilateFinalMask:
-    # type=bool|default=True: dilate final mask
-    trim:
-    # type=bool|default=True: trim brainstem
-    outputDiffusionFilter:
-    # type=file: path/name of diffusion filter output
-    # type=file|default=<undefined>: diffusion filter output
-    outputEdgeMap:
-    # type=file: path/name of edge map output
-    # type=file|default=<undefined>: edge map output
-    outputDetailedBrainMask:
-    # type=file: path/name of detailed brain mask
-    # type=file|default=<undefined>: save detailed brain mask
-    outputCortexFile:
-    # type=file: path/name of cortex file
-    # type=file|default=<undefined>: cortex file
-    verbosityLevel:
-    # type=float|default=1:  verbosity level (0=silent)
-    noRotate:
-    # type=bool|default=False: retain original orientation(default behavior will auto-rotate input NII files to LPI orientation)
-    timer:
-    # type=bool|default=False: show timing
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-brainsuite/bse_callables.py b/example-specs/task/nipype_internal/pydra-brainsuite/bse_callables.py
deleted file mode 100644
index 90e1e12d..00000000
--- a/example-specs/task/nipype_internal/pydra-brainsuite/bse_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in Bse.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-brainsuite/cerebro.yaml b/example-specs/task/nipype_internal/pydra-brainsuite/cerebro.yaml
deleted file mode 100644
index 2a0cd638..00000000
--- a/example-specs/task/nipype_internal/pydra-brainsuite/cerebro.yaml
+++ /dev/null
@@ -1,156 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.brainsuite.brainsuite.Cerebro' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Cerebrum/cerebellum labeling tool
-#     This program performs automated labeling of cerebellum and cerebrum in T1 MRI.
-#     Input MRI should be skull-stripped or a brain-only mask should be provided.
-# 
-# 
-#     http://brainsuite.org/processing/surfaceextraction/cerebrum/
-# 
-#     Examples
-#     --------
-# 
-#     >>> from nipype.interfaces import brainsuite
-#     >>> from nipype.testing import example_data
-#     >>> cerebro = brainsuite.Cerebro()
-#     >>> cerebro.inputs.inputMRIFile = example_data('structural.nii')
-#     >>> cerebro.inputs.inputAtlasMRIFile = 'atlasMRIVolume.img'
-#     >>> cerebro.inputs.inputAtlasLabelFile = 'atlasLabels.img'
-#     >>> cerebro.inputs.inputBrainMaskFile = example_data('mask.nii')
-#     >>> results = cerebro.run() #doctest: +SKIP
-# 
-#     
-task_name: Cerebro
-nipype_name: Cerebro
-nipype_module: nipype.interfaces.brainsuite.brainsuite
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputMRIFile: generic/file
-    # type=file|default=<undefined>: input 3D MRI volume
-    inputAtlasMRIFile: generic/file
-    # type=file|default=<undefined>: atlas MRI volume
-    inputAtlasLabelFile: generic/file
-    # type=file|default=<undefined>: atlas labeling
-    inputBrainMaskFile: generic/file
-    # type=file|default=<undefined>: brain mask file
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputCerebrumMaskFile: generic/file
-    # type=file: path/name of cerebrum mask file
-    # type=file|default=<undefined>: output cerebrum mask volume. If unspecified, output file name will be auto generated.
-    outputLabelVolumeFile: generic/file
-    # type=file: path/name of label mask file
-    # type=file|default=<undefined>: output labeled hemisphere/cerebrum volume. If unspecified, output file name will be auto generated.
-    outputAffineTransformFile: generic/file
-    # type=file: path/name of affine transform file
-    # type=file|default=<undefined>: save affine transform to file.
-    outputWarpTransformFile: generic/file
-    # type=file: path/name of warp transform file
-    # type=file|default=<undefined>: save warp transform to file.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    outputCerebrumMaskFile: outputCerebrumMaskFile
-    # type=file: path/name of cerebrum mask file
-    # type=file|default=<undefined>: output cerebrum mask volume. If unspecified, output file name will be auto generated.
-    outputLabelVolumeFile: outputLabelVolumeFile
-    # type=file: path/name of label mask file
-    # type=file|default=<undefined>: output labeled hemisphere/cerebrum volume. If unspecified, output file name will be auto generated.
-    outputAffineTransformFile: outputAffineTransformFile
-    # type=file: path/name of affine transform file
-    # type=file|default=<undefined>: save affine transform to file.
-    outputWarpTransformFile: outputWarpTransformFile
-    # type=file: path/name of warp transform file
-    # type=file|default=<undefined>: save warp transform to file.
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputMRIFile:
-    # type=file|default=<undefined>: input 3D MRI volume
-    inputAtlasMRIFile:
-    # type=file|default=<undefined>: atlas MRI volume
-    inputAtlasLabelFile:
-    # type=file|default=<undefined>: atlas labeling
-    inputBrainMaskFile:
-    # type=file|default=<undefined>: brain mask file
-    outputCerebrumMaskFile:
-    # type=file: path/name of cerebrum mask file
-    # type=file|default=<undefined>: output cerebrum mask volume. If unspecified, output file name will be auto generated.
-    outputLabelVolumeFile:
-    # type=file: path/name of label mask file
-    # type=file|default=<undefined>: output labeled hemisphere/cerebrum volume. If unspecified, output file name will be auto generated.
-    costFunction:
-    # type=int|default=2: 0,1,2
-    useCentroids:
-    # type=bool|default=False: use centroids of data to initialize position
-    outputAffineTransformFile:
-    # type=file: path/name of affine transform file
-    # type=file|default=<undefined>: save affine transform to file.
-    outputWarpTransformFile:
-    # type=file: path/name of warp transform file
-    # type=file|default=<undefined>: save warp transform to file.
-    verbosity:
-    # type=int|default=0: verbosity level (0=silent)
-    linearConvergence:
-    # type=float|default=0.0: linear convergence
-    warpLabel:
-    # type=int|default=0: warp order (2,3,4,5,6,7,8)
-    warpConvergence:
-    # type=float|default=0.0: warp convergence
-    keepTempFiles:
-    # type=bool|default=False: don't remove temporary files
-    tempDirectory:
-    # type=str|default='': specify directory to use for temporary files
-    tempDirectoryBase:
-    # type=str|default='': create a temporary directory within this directory
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-brainsuite/cerebro_callables.py b/example-specs/task/nipype_internal/pydra-brainsuite/cerebro_callables.py
deleted file mode 100644
index 21d206df..00000000
--- a/example-specs/task/nipype_internal/pydra-brainsuite/cerebro_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in Cerebro.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-brainsuite/cortex.yaml b/example-specs/task/nipype_internal/pydra-brainsuite/cortex.yaml
deleted file mode 100644
index e4e2a715..00000000
--- a/example-specs/task/nipype_internal/pydra-brainsuite/cortex.yaml
+++ /dev/null
@@ -1,112 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.brainsuite.brainsuite.Cortex' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     cortex extractor
-#     This program produces a cortical mask using tissue fraction estimates
-#     and a co-registered cerebellum/hemisphere mask.
-# 
-#     http://brainsuite.org/processing/surfaceextraction/cortex/
-# 
-#     Examples
-#     --------
-# 
-#     >>> from nipype.interfaces import brainsuite
-#     >>> from nipype.testing import example_data
-#     >>> cortex = brainsuite.Cortex()
-#     >>> cortex.inputs.inputHemisphereLabelFile = example_data('mask.nii')
-#     >>> cortex.inputs.inputTissueFractionFile = example_data('tissues.nii.gz')
-#     >>> results = cortex.run() #doctest: +SKIP
-# 
-#     
-task_name: Cortex
-nipype_name: Cortex
-nipype_module: nipype.interfaces.brainsuite.brainsuite
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputHemisphereLabelFile: generic/file
-    # type=file|default=<undefined>: hemisphere / lobe label volume
-    inputTissueFractionFile: generic/file
-    # type=file|default=<undefined>: tissue fraction file (32-bit float)
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputCerebrumMask: generic/file
-    # type=file: path/name of cerebrum mask
-    # type=file|default=<undefined>: output structure mask. If unspecified, output file name will be auto generated.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    outputCerebrumMask: outputCerebrumMask
-    # type=file: path/name of cerebrum mask
-    # type=file|default=<undefined>: output structure mask. If unspecified, output file name will be auto generated.
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputHemisphereLabelFile:
-    # type=file|default=<undefined>: hemisphere / lobe label volume
-    outputCerebrumMask:
-    # type=file: path/name of cerebrum mask
-    # type=file|default=<undefined>: output structure mask. If unspecified, output file name will be auto generated.
-    inputTissueFractionFile:
-    # type=file|default=<undefined>: tissue fraction file (32-bit float)
-    tissueFractionThreshold:
-    # type=float|default=50.0: tissue fraction threshold (percentage)
-    computeWGBoundary:
-    # type=bool|default=True: compute WM/GM boundary
-    computeGCBoundary:
-    # type=bool|default=False: compute GM/CSF boundary
-    includeAllSubcorticalAreas:
-    # type=bool|default=True: include all subcortical areas in WM mask
-    verbosity:
-    # type=int|default=0: verbosity level
-    timer:
-    # type=bool|default=False: timing function
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-brainsuite/cortex_callables.py b/example-specs/task/nipype_internal/pydra-brainsuite/cortex_callables.py
deleted file mode 100644
index 544a440f..00000000
--- a/example-specs/task/nipype_internal/pydra-brainsuite/cortex_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in Cortex.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-brainsuite/dewisp.yaml b/example-specs/task/nipype_internal/pydra-brainsuite/dewisp.yaml
deleted file mode 100644
index dd8707b7..00000000
--- a/example-specs/task/nipype_internal/pydra-brainsuite/dewisp.yaml
+++ /dev/null
@@ -1,107 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.brainsuite.brainsuite.Dewisp' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     dewisp
-#     removes wispy tendril structures from cortex model binary masks.
-#     It does so based on graph theoretic analysis of connected components,
-#     similar to TCA. Each branch of the structure graph is analyzed to determine
-#     pinch points that indicate a likely error in segmentation that attaches noise
-#     to the image. The pinch threshold determines how many voxels the cross-section
-#     can be before it is considered part of the image.
-# 
-#     http://brainsuite.org/processing/surfaceextraction/dewisp/
-# 
-#     Examples
-#     --------
-# 
-#     >>> from nipype.interfaces import brainsuite
-#     >>> from nipype.testing import example_data
-#     >>> dewisp = brainsuite.Dewisp()
-#     >>> dewisp.inputs.inputMaskFile = example_data('mask.nii')
-#     >>> results = dewisp.run() #doctest: +SKIP
-# 
-#     
-task_name: Dewisp
-nipype_name: Dewisp
-nipype_module: nipype.interfaces.brainsuite.brainsuite
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputMaskFile: generic/file
-    # type=file|default=<undefined>: input file
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputMaskFile: generic/file
-    # type=file: path/name of mask file
-    # type=file|default=<undefined>: output file. If unspecified, output file name will be auto generated.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    outputMaskFile: outputMaskFile
-    # type=file: path/name of mask file
-    # type=file|default=<undefined>: output file. If unspecified, output file name will be auto generated.
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputMaskFile:
-    # type=file|default=<undefined>: input file
-    outputMaskFile:
-    # type=file: path/name of mask file
-    # type=file|default=<undefined>: output file. If unspecified, output file name will be auto generated.
-    verbosity:
-    # type=int|default=0: verbosity
-    sizeThreshold:
-    # type=int|default=0: size threshold
-    maximumIterations:
-    # type=int|default=0: maximum number of iterations
-    timer:
-    # type=bool|default=False: time processing
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-brainsuite/dewisp_callables.py b/example-specs/task/nipype_internal/pydra-brainsuite/dewisp_callables.py
deleted file mode 100644
index 516188ff..00000000
--- a/example-specs/task/nipype_internal/pydra-brainsuite/dewisp_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in Dewisp.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-brainsuite/dfs.yaml b/example-specs/task/nipype_internal/pydra-brainsuite/dfs.yaml
deleted file mode 100644
index c11ae2b7..00000000
--- a/example-specs/task/nipype_internal/pydra-brainsuite/dfs.yaml
+++ /dev/null
@@ -1,122 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.brainsuite.brainsuite.Dfs' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Surface Generator
-#     Generates mesh surfaces using an isosurface algorithm.
-# 
-#     http://brainsuite.org/processing/surfaceextraction/inner-cortical-surface/
-# 
-#     Examples
-#     --------
-# 
-#     >>> from nipype.interfaces import brainsuite
-#     >>> from nipype.testing import example_data
-#     >>> dfs = brainsuite.Dfs()
-#     >>> dfs.inputs.inputVolumeFile = example_data('structural.nii')
-#     >>> results = dfs.run() #doctest: +SKIP
-# 
-#     
-task_name: Dfs
-nipype_name: Dfs
-nipype_module: nipype.interfaces.brainsuite.brainsuite
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputVolumeFile: generic/file
-    # type=file|default=<undefined>: input 3D volume
-    inputShadingVolume: generic/file
-    # type=file|default=<undefined>: shade surface model with data from image volume
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputSurfaceFile: generic/file
-    # type=file: path/name of surface file
-    # type=file|default=<undefined>: output surface mesh file. If unspecified, output file name will be auto generated.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    outputSurfaceFile: outputSurfaceFile
-    # type=file: path/name of surface file
-    # type=file|default=<undefined>: output surface mesh file. If unspecified, output file name will be auto generated.
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputVolumeFile:
-    # type=file|default=<undefined>: input 3D volume
-    outputSurfaceFile:
-    # type=file: path/name of surface file
-    # type=file|default=<undefined>: output surface mesh file. If unspecified, output file name will be auto generated.
-    inputShadingVolume:
-    # type=file|default=<undefined>: shade surface model with data from image volume
-    smoothingIterations:
-    # type=int|default=10: number of smoothing iterations
-    smoothingConstant:
-    # type=float|default=0.5: smoothing constant
-    curvatureWeighting:
-    # type=float|default=5.0: curvature weighting
-    scalingPercentile:
-    # type=float|default=0.0: scaling percentile
-    nonZeroTessellation:
-    # type=bool|default=False: tessellate non-zero voxels
-    tessellationThreshold:
-    # type=float|default=0.0: To be used with specialTessellation. Set this value first, then set specialTessellation value. Usage: tessellate voxels greater_than, less_than, or equal_to <tessellationThreshold>
-    specialTessellation:
-    # type=enum|default='greater_than'|allowed['equal_to','greater_than','less_than']: To avoid throwing a UserWarning, set tessellationThreshold first. Then set this attribute. Usage: tessellate voxels greater_than, less_than, or equal_to <tessellationThreshold>
-    zeroPadFlag:
-    # type=bool|default=False: zero-pad volume (avoids clipping at edges)
-    noNormalsFlag:
-    # type=bool|default=False: do not compute vertex normals
-    postSmoothFlag:
-    # type=bool|default=False: smooth vertices after coloring
-    verbosity:
-    # type=int|default=0: verbosity (0 = quiet)
-    timer:
-    # type=bool|default=False: timing function
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-brainsuite/dfs_callables.py b/example-specs/task/nipype_internal/pydra-brainsuite/dfs_callables.py
deleted file mode 100644
index 2614c1e9..00000000
--- a/example-specs/task/nipype_internal/pydra-brainsuite/dfs_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in Dfs.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-brainsuite/hemisplit.yaml b/example-specs/task/nipype_internal/pydra-brainsuite/hemisplit.yaml
deleted file mode 100644
index 2530a0e8..00000000
--- a/example-specs/task/nipype_internal/pydra-brainsuite/hemisplit.yaml
+++ /dev/null
@@ -1,135 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.brainsuite.brainsuite.Hemisplit' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Hemisphere splitter
-#     Splits a surface object into two separate surfaces given an input label volume.
-#     Each vertex is labeled left or right based on the labels being odd (left) or even (right).
-#     The largest contour on the split surface is then found and used as the separation between left and right.
-# 
-#     Examples
-#     --------
-# 
-#     >>> from nipype.interfaces import brainsuite
-#     >>> from nipype.testing import example_data
-#     >>> hemisplit = brainsuite.Hemisplit()
-#     >>> hemisplit.inputs.inputSurfaceFile = 'input_surf.dfs'
-#     >>> hemisplit.inputs.inputHemisphereLabelFile = 'label.nii'
-#     >>> hemisplit.inputs.pialSurfaceFile = 'pial.dfs'
-#     >>> results = hemisplit.run() #doctest: +SKIP
-# 
-#     
-task_name: Hemisplit
-nipype_name: Hemisplit
-nipype_module: nipype.interfaces.brainsuite.brainsuite
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputSurfaceFile: generic/file
-    # type=file|default=<undefined>: input surface
-    inputHemisphereLabelFile: generic/file
-    # type=file|default=<undefined>: input hemisphere label volume
-    pialSurfaceFile: generic/file
-    # type=file|default=<undefined>: pial surface file -- must have same geometry as input surface
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputLeftHemisphere: generic/file
-    # type=file: path/name of left hemisphere
-    # type=file|default=<undefined>: output surface file, left hemisphere. If unspecified, output file name will be auto generated.
-    outputRightHemisphere: generic/file
-    # type=file: path/name of right hemisphere
-    # type=file|default=<undefined>: output surface file, right hemisphere. If unspecified, output file name will be auto generated.
-    outputLeftPialHemisphere: generic/file
-    # type=file: path/name of left pial hemisphere
-    # type=file|default=<undefined>: output pial surface file, left hemisphere. If unspecified, output file name will be auto generated.
-    outputRightPialHemisphere: generic/file
-    # type=file: path/name of right pial hemisphere
-    # type=file|default=<undefined>: output pial surface file, right hemisphere. If unspecified, output file name will be auto generated.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    outputLeftHemisphere: outputLeftHemisphere
-    # type=file: path/name of left hemisphere
-    # type=file|default=<undefined>: output surface file, left hemisphere. If unspecified, output file name will be auto generated.
-    outputRightHemisphere: outputRightHemisphere
-    # type=file: path/name of right hemisphere
-    # type=file|default=<undefined>: output surface file, right hemisphere. If unspecified, output file name will be auto generated.
-    outputLeftPialHemisphere: outputLeftPialHemisphere
-    # type=file: path/name of left pial hemisphere
-    # type=file|default=<undefined>: output pial surface file, left hemisphere. If unspecified, output file name will be auto generated.
-    outputRightPialHemisphere: outputRightPialHemisphere
-    # type=file: path/name of right pial hemisphere
-    # type=file|default=<undefined>: output pial surface file, right hemisphere. If unspecified, output file name will be auto generated.
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputSurfaceFile:
-    # type=file|default=<undefined>: input surface
-    inputHemisphereLabelFile:
-    # type=file|default=<undefined>: input hemisphere label volume
-    outputLeftHemisphere:
-    # type=file: path/name of left hemisphere
-    # type=file|default=<undefined>: output surface file, left hemisphere. If unspecified, output file name will be auto generated.
-    outputRightHemisphere:
-    # type=file: path/name of right hemisphere
-    # type=file|default=<undefined>: output surface file, right hemisphere. If unspecified, output file name will be auto generated.
-    pialSurfaceFile:
-    # type=file|default=<undefined>: pial surface file -- must have same geometry as input surface
-    outputLeftPialHemisphere:
-    # type=file: path/name of left pial hemisphere
-    # type=file|default=<undefined>: output pial surface file, left hemisphere. If unspecified, output file name will be auto generated.
-    outputRightPialHemisphere:
-    # type=file: path/name of right pial hemisphere
-    # type=file|default=<undefined>: output pial surface file, right hemisphere. If unspecified, output file name will be auto generated.
-    verbosity:
-    # type=int|default=0: verbosity (0 = silent)
-    timer:
-    # type=bool|default=False: timing function
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-brainsuite/hemisplit_callables.py b/example-specs/task/nipype_internal/pydra-brainsuite/hemisplit_callables.py
deleted file mode 100644
index 6f782bb3..00000000
--- a/example-specs/task/nipype_internal/pydra-brainsuite/hemisplit_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in Hemisplit.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-brainsuite/pialmesh.yaml b/example-specs/task/nipype_internal/pydra-brainsuite/pialmesh.yaml
deleted file mode 100644
index 40e34dac..00000000
--- a/example-specs/task/nipype_internal/pydra-brainsuite/pialmesh.yaml
+++ /dev/null
@@ -1,130 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.brainsuite.brainsuite.Pialmesh' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     pialmesh
-#     computes a pial surface model using an inner WM/GM mesh and a tissue fraction map.
-# 
-#     http://brainsuite.org/processing/surfaceextraction/pial/
-# 
-#     Examples
-#     --------
-# 
-#     >>> from nipype.interfaces import brainsuite
-#     >>> from nipype.testing import example_data
-#     >>> pialmesh = brainsuite.Pialmesh()
-#     >>> pialmesh.inputs.inputSurfaceFile = 'input_mesh.dfs'
-#     >>> pialmesh.inputs.inputTissueFractionFile = 'frac_file.nii.gz'
-#     >>> pialmesh.inputs.inputMaskFile = example_data('mask.nii')
-#     >>> results = pialmesh.run() #doctest: +SKIP
-# 
-#     
-task_name: Pialmesh
-nipype_name: Pialmesh
-nipype_module: nipype.interfaces.brainsuite.brainsuite
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputSurfaceFile: generic/file
-    # type=file|default=<undefined>: input file
-    inputTissueFractionFile: generic/file
-    # type=file|default=<undefined>: floating point (32) tissue fraction image
-    inputMaskFile: generic/file
-    # type=file|default=<undefined>: restrict growth to mask file region
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputSurfaceFile: generic/file
-    # type=file: path/name of surface file
-    # type=file|default=<undefined>: output file. If unspecified, output file name will be auto generated.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    outputSurfaceFile: outputSurfaceFile
-    # type=file: path/name of surface file
-    # type=file|default=<undefined>: output file. If unspecified, output file name will be auto generated.
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputSurfaceFile:
-    # type=file|default=<undefined>: input file
-    outputSurfaceFile:
-    # type=file: path/name of surface file
-    # type=file|default=<undefined>: output file. If unspecified, output file name will be auto generated.
-    verbosity:
-    # type=int|default=0: verbosity
-    inputTissueFractionFile:
-    # type=file|default=<undefined>: floating point (32) tissue fraction image
-    numIterations:
-    # type=int|default=100: number of iterations
-    searchRadius:
-    # type=float|default=1: search radius
-    stepSize:
-    # type=float|default=0.4: step size
-    inputMaskFile:
-    # type=file|default=<undefined>: restrict growth to mask file region
-    maxThickness:
-    # type=float|default=20: maximum allowed tissue thickness
-    tissueThreshold:
-    # type=float|default=1.05: tissue threshold
-    outputInterval:
-    # type=int|default=10: output interval
-    exportPrefix:
-    # type=str|default='': prefix for exporting surfaces if interval is set
-    laplacianSmoothing:
-    # type=float|default=0.025: apply Laplacian smoothing
-    timer:
-    # type=bool|default=False: show timing
-    recomputeNormals:
-    # type=bool|default=False: recompute normals at each iteration
-    normalSmoother:
-    # type=float|default=0.2: strength of normal smoother.
-    tangentSmoother:
-    # type=float|default=0.0: strength of tangential smoother.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-brainsuite/pialmesh_callables.py b/example-specs/task/nipype_internal/pydra-brainsuite/pialmesh_callables.py
deleted file mode 100644
index 2f8bd31c..00000000
--- a/example-specs/task/nipype_internal/pydra-brainsuite/pialmesh_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in Pialmesh.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-brainsuite/pvc.yaml b/example-specs/task/nipype_internal/pydra-brainsuite/pvc.yaml
deleted file mode 100644
index f8afd1c6..00000000
--- a/example-specs/task/nipype_internal/pydra-brainsuite/pvc.yaml
+++ /dev/null
@@ -1,117 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.brainsuite.brainsuite.Pvc' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     partial volume classifier (PVC) tool.
-#     This program performs voxel-wise tissue classification T1-weighted MRI.
-#     Image should be skull-stripped and bias-corrected before tissue classification.
-# 
-#     http://brainsuite.org/processing/surfaceextraction/pvc/
-# 
-#     Examples
-#     --------
-# 
-#     >>> from nipype.interfaces import brainsuite
-#     >>> from nipype.testing import example_data
-#     >>> pvc = brainsuite.Pvc()
-#     >>> pvc.inputs.inputMRIFile = example_data('structural.nii')
-#     >>> pvc.inputs.inputMaskFile = example_data('mask.nii')
-#     >>> results = pvc.run() #doctest: +SKIP
-# 
-#     
-task_name: Pvc
-nipype_name: Pvc
-nipype_module: nipype.interfaces.brainsuite.brainsuite
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputMRIFile: generic/file
-    # type=file|default=<undefined>: MRI file
-    inputMaskFile: generic/file
-    # type=file|default=<undefined>: brain mask file
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputLabelFile: generic/file
-    # type=file: path/name of label file
-    # type=file|default=<undefined>: output label file. If unspecified, output file name will be auto generated.
-    outputTissueFractionFile: generic/file
-    # type=file: path/name of tissue fraction file
-    # type=file|default=<undefined>: output tissue fraction file
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    outputLabelFile: outputLabelFile
-    # type=file: path/name of label file
-    # type=file|default=<undefined>: output label file. If unspecified, output file name will be auto generated.
-    outputTissueFractionFile: outputTissueFractionFile
-    # type=file: path/name of tissue fraction file
-    # type=file|default=<undefined>: output tissue fraction file
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputMRIFile:
-    # type=file|default=<undefined>: MRI file
-    inputMaskFile:
-    # type=file|default=<undefined>: brain mask file
-    outputLabelFile:
-    # type=file: path/name of label file
-    # type=file|default=<undefined>: output label file. If unspecified, output file name will be auto generated.
-    outputTissueFractionFile:
-    # type=file: path/name of tissue fraction file
-    # type=file|default=<undefined>: output tissue fraction file
-    spatialPrior:
-    # type=float|default=0.0: spatial prior strength
-    verbosity:
-    # type=int|default=0: verbosity level (0 = silent)
-    threeClassFlag:
-    # type=bool|default=False: use a three-class (CSF=0,GM=1,WM=2) labeling
-    timer:
-    # type=bool|default=False: time processing
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-brainsuite/pvc_callables.py b/example-specs/task/nipype_internal/pydra-brainsuite/pvc_callables.py
deleted file mode 100644
index 2d3a10a3..00000000
--- a/example-specs/task/nipype_internal/pydra-brainsuite/pvc_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in Pvc.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-brainsuite/scrubmask.yaml b/example-specs/task/nipype_internal/pydra-brainsuite/scrubmask.yaml
deleted file mode 100644
index a2129211..00000000
--- a/example-specs/task/nipype_internal/pydra-brainsuite/scrubmask.yaml
+++ /dev/null
@@ -1,105 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.brainsuite.brainsuite.Scrubmask' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     ScrubMask tool
-#     scrubmask filters binary masks to trim loosely connected voxels that may
-#     result from segmentation errors and produce bumps on tessellated surfaces.
-# 
-#     http://brainsuite.org/processing/surfaceextraction/scrubmask/
-# 
-#     Examples
-#     --------
-# 
-#     >>> from nipype.interfaces import brainsuite
-#     >>> from nipype.testing import example_data
-#     >>> scrubmask = brainsuite.Scrubmask()
-#     >>> scrubmask.inputs.inputMaskFile = example_data('mask.nii')
-#     >>> results = scrubmask.run() #doctest: +SKIP
-# 
-#     
-task_name: Scrubmask
-nipype_name: Scrubmask
-nipype_module: nipype.interfaces.brainsuite.brainsuite
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputMaskFile: generic/file
-    # type=file|default=<undefined>: input structure mask file
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputMaskFile: generic/file
-    # type=file: path/name of mask file
-    # type=file|default=<undefined>: output structure mask file. If unspecified, output file name will be auto generated.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    outputMaskFile: outputMaskFile
-    # type=file: path/name of mask file
-    # type=file|default=<undefined>: output structure mask file. If unspecified, output file name will be auto generated.
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputMaskFile:
-    # type=file|default=<undefined>: input structure mask file
-    outputMaskFile:
-    # type=file: path/name of mask file
-    # type=file|default=<undefined>: output structure mask file. If unspecified, output file name will be auto generated.
-    backgroundFillThreshold:
-    # type=int|default=2: background fill threshold
-    foregroundTrimThreshold:
-    # type=int|default=0: foreground trim threshold
-    numberIterations:
-    # type=int|default=0: number of iterations
-    verbosity:
-    # type=int|default=0: verbosity (0=silent)
-    timer:
-    # type=bool|default=False: timing function
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-brainsuite/scrubmask_callables.py b/example-specs/task/nipype_internal/pydra-brainsuite/scrubmask_callables.py
deleted file mode 100644
index c4b687f9..00000000
--- a/example-specs/task/nipype_internal/pydra-brainsuite/scrubmask_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in Scrubmask.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-brainsuite/skullfinder.yaml b/example-specs/task/nipype_internal/pydra-brainsuite/skullfinder.yaml
deleted file mode 100644
index 2267352a..00000000
--- a/example-specs/task/nipype_internal/pydra-brainsuite/skullfinder.yaml
+++ /dev/null
@@ -1,116 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.brainsuite.brainsuite.Skullfinder' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Skull and scalp segmentation algorithm.
-# 
-#     Examples
-#     --------
-# 
-#     >>> from nipype.interfaces import brainsuite
-#     >>> from nipype.testing import example_data
-#     >>> skullfinder = brainsuite.Skullfinder()
-#     >>> skullfinder.inputs.inputMRIFile = example_data('structural.nii')
-#     >>> skullfinder.inputs.inputMaskFile = example_data('mask.nii')
-#     >>> results = skullfinder.run() #doctest: +SKIP
-# 
-#     
-task_name: Skullfinder
-nipype_name: Skullfinder
-nipype_module: nipype.interfaces.brainsuite.brainsuite
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputMRIFile: generic/file
-    # type=file|default=<undefined>: input file
-    inputMaskFile: generic/file
-    # type=file|default=<undefined>: A brain mask file, 8-bit image (0=non-brain, 255=brain)
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputLabelFile: generic/file
-    # type=file: path/name of label file
-    # type=file|default=<undefined>: output multi-colored label volume segmenting brain, scalp, inner skull & outer skull If unspecified, output file name will be auto generated.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    outputLabelFile: outputLabelFile
-    # type=file: path/name of label file
-    # type=file|default=<undefined>: output multi-colored label volume segmenting brain, scalp, inner skull & outer skull If unspecified, output file name will be auto generated.
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputMRIFile:
-    # type=file|default=<undefined>: input file
-    inputMaskFile:
-    # type=file|default=<undefined>: A brain mask file, 8-bit image (0=non-brain, 255=brain)
-    outputLabelFile:
-    # type=file: path/name of label file
-    # type=file|default=<undefined>: output multi-colored label volume segmenting brain, scalp, inner skull & outer skull If unspecified, output file name will be auto generated.
-    verbosity:
-    # type=int|default=0: verbosity
-    lowerThreshold:
-    # type=int|default=0: Lower threshold for segmentation
-    upperThreshold:
-    # type=int|default=0: Upper threshold for segmentation
-    surfaceFilePrefix:
-    # type=str|default='': if specified, generate surface files for brain, skull, and scalp
-    bgLabelValue:
-    # type=int|default=0: background label value (0-255)
-    scalpLabelValue:
-    # type=int|default=0: scalp label value (0-255)
-    skullLabelValue:
-    # type=int|default=0: skull label value (0-255)
-    spaceLabelValue:
-    # type=int|default=0: space label value (0-255)
-    brainLabelValue:
-    # type=int|default=0: brain label value (0-255)
-    performFinalOpening:
-    # type=bool|default=False: perform a final opening operation on the scalp mask
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-brainsuite/skullfinder_callables.py b/example-specs/task/nipype_internal/pydra-brainsuite/skullfinder_callables.py
deleted file mode 100644
index ba356187..00000000
--- a/example-specs/task/nipype_internal/pydra-brainsuite/skullfinder_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in Skullfinder.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-brainsuite/sv_reg.yaml b/example-specs/task/nipype_internal/pydra-brainsuite/sv_reg.yaml
deleted file mode 100644
index 5bb1056a..00000000
--- a/example-specs/task/nipype_internal/pydra-brainsuite/sv_reg.yaml
+++ /dev/null
@@ -1,131 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.brainsuite.brainsuite.SVReg' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     surface and volume registration (svreg)
-#     This program registers a subject's BrainSuite-processed volume and surfaces
-#     to an atlas, allowing for automatic labelling of volume and surface ROIs.
-# 
-#     For more information, please see:
-#     http://brainsuite.org/processing/svreg/usage/
-# 
-#     Examples
-#     --------
-# 
-#     >>> from nipype.interfaces import brainsuite
-#     >>> svreg = brainsuite.SVReg()
-#     >>> svreg.inputs.subjectFilePrefix = 'home/user/btestsubject/testsubject'
-#     >>> svreg.inputs.refineOutputs = True
-#     >>> svreg.inputs.skipToVolumeReg = False
-#     >>> svreg.inputs. keepIntermediates = True
-#     >>> svreg.inputs.verbosity2 = True
-#     >>> svreg.inputs.displayTimestamps = True
-#     >>> svreg.inputs.useSingleThreading = True
-#     >>> results = svreg.run() #doctest: +SKIP
-# 
-# 
-#     
-task_name: SVReg
-nipype_name: SVReg
-nipype_module: nipype.interfaces.brainsuite.brainsuite
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    subjectFilePrefix:
-    # type=str|default='': Absolute path and filename prefix of the subjects output from BrainSuite Cortical Surface Extraction Sequence
-    dataSinkDelay:
-    # type=list|default=[]: Connect datasink out_file to dataSinkDelay to delay execution of SVReg until dataSink has finished sinking CSE outputs.For use with parallel processing workflows including Brainsuites Cortical Surface Extraction sequence (SVReg requires certain files from Brainsuite CSE, which must all be in the pathway specified by subjectFilePrefix. see http://brainsuite.org/processing/svreg/usage/ for list of required inputs 
-    atlasFilePrefix:
-    # type=str|default='': Optional: Absolute Path and filename prefix of atlas files and labels to which the subject will be registered. If unspecified, SVRegwill use its own included atlas files
-    iterations:
-    # type=int|default=0: Assigns a number of iterations in the intensity registration step.if unspecified, performs 100 iterations
-    refineOutputs:
-    # type=bool|default=False: Refine outputs at the expense of more processing time.
-    skipToVolumeReg:
-    # type=bool|default=False: If surface registration was already performed at an earlier time and the user would not like to redo this step, then this flag may be used to skip ahead to the volumetric registration. Necessary input files will need to be present in the input directory called by the command.
-    skipToIntensityReg:
-    # type=bool|default=False: If the p-harmonic volumetric registration was already performed at an earlier time and the user would not like to redo this step, then this flag may be used to skip ahead to the intensity registration and label transfer step.
-    useManualMaskFile:
-    # type=bool|default=False: Can call a manually edited cerebrum mask to limit boundaries. Will use file: subbasename.cerebrum.mask.nii.gz Make sure to correctly replace your manually edited mask file in your input folder with the correct subbasename.
-    curveMatchingInstructions:
-    # type=str|default='': Used to take control of the curve matching process between the atlas and subject. One can specify the name of the .dfc file <sulname.dfc> and the sulcal numbers <#sul> to be used as constraints. example: curveMatchingInstructions = "subbasename.right.dfc 1 2 20"
-    useCerebrumMask:
-    # type=bool|default=False: The cerebrum mask <subbasename.cerebrum.mask.nii.gz> will be used for masking the final labels instead of the default pial surface mask. Every voxel will be labeled within the cerebrum mask regardless of the boundaries of the pial surface.
-    pialSurfaceMaskDilation:
-    # type=int|default=0: Cortical volume labels found in file output subbasename.svreg.label.nii.gz find its boundaries by using the pial surface then dilating by 1 voxel. Use this flag in order to control the number of pial surface mask dilation. (ie. -D 0 will assign no voxel dilation)
-    keepIntermediates:
-    # type=bool|default=False: Keep the intermediate files after the svreg sequence is complete.
-    verbosity0:
-    # type=bool|default=False: no messages will be reported
-    verbosity1:
-    # type=bool|default=False: messages will be reported but not the iteration-wise detailed messages
-    verbosity2:
-    # type=bool|default=False: all the messages, including per-iteration, will be displayed
-    shortMessages:
-    # type=bool|default=False: Short messages instead of detailed messages
-    displayModuleName:
-    # type=bool|default=False: Module name will be displayed in the messages
-    displayTimestamps:
-    # type=bool|default=False: Timestamps will be displayed in the messages
-    skipVolumetricProcessing:
-    # type=bool|default=False: Only surface registration and labeling will be performed. Volumetric processing will be skipped.
-    useMultiThreading:
-    # type=bool|default=False: If multiple CPUs are present on the system, the code will try to use multithreading to make the execution fast.
-    useSingleThreading:
-    # type=bool|default=False: Use single threaded mode.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-brainsuite/sv_reg_callables.py b/example-specs/task/nipype_internal/pydra-brainsuite/sv_reg_callables.py
deleted file mode 100644
index ef6e5d5d..00000000
--- a/example-specs/task/nipype_internal/pydra-brainsuite/sv_reg_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in SVReg.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-brainsuite/tca.yaml b/example-specs/task/nipype_internal/pydra-brainsuite/tca.yaml
deleted file mode 100644
index 11b54c9e..00000000
--- a/example-specs/task/nipype_internal/pydra-brainsuite/tca.yaml
+++ /dev/null
@@ -1,103 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.brainsuite.brainsuite.Tca' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     topological correction algorithm (TCA)
-#     This program removes topological handles from a binary object.
-# 
-#     http://brainsuite.org/processing/surfaceextraction/tca/
-# 
-#     Examples
-#     --------
-#     >>> from nipype.interfaces import brainsuite
-#     >>> from nipype.testing import example_data
-#     >>> tca = brainsuite.Tca()
-#     >>> tca.inputs.inputMaskFile = example_data('mask.nii')
-#     >>> results = tca.run() #doctest: +SKIP
-# 
-#     
-task_name: Tca
-nipype_name: Tca
-nipype_module: nipype.interfaces.brainsuite.brainsuite
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputMaskFile: generic/file
-    # type=file|default=<undefined>: input mask volume
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputMaskFile: generic/file
-    # type=file: path/name of mask file
-    # type=file|default=<undefined>: output mask volume. If unspecified, output file name will be auto generated.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    outputMaskFile: outputMaskFile
-    # type=file: path/name of mask file
-    # type=file|default=<undefined>: output mask volume. If unspecified, output file name will be auto generated.
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputMaskFile:
-    # type=file|default=<undefined>: input mask volume
-    outputMaskFile:
-    # type=file: path/name of mask file
-    # type=file|default=<undefined>: output mask volume. If unspecified, output file name will be auto generated.
-    minCorrectionSize:
-    # type=int|default=2500: maximum correction size
-    maxCorrectionSize:
-    # type=int|default=0: minimum correction size
-    foregroundDelta:
-    # type=int|default=20: foreground delta
-    verbosity:
-    # type=int|default=0: verbosity (0 = quiet)
-    timer:
-    # type=bool|default=False: timing function
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-brainsuite/tca_callables.py b/example-specs/task/nipype_internal/pydra-brainsuite/tca_callables.py
deleted file mode 100644
index 038e2b06..00000000
--- a/example-specs/task/nipype_internal/pydra-brainsuite/tca_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in Tca.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-brainsuite/thickness_pvc.yaml b/example-specs/task/nipype_internal/pydra-brainsuite/thickness_pvc.yaml
deleted file mode 100644
index 6ceafa08..00000000
--- a/example-specs/task/nipype_internal/pydra-brainsuite/thickness_pvc.yaml
+++ /dev/null
@@ -1,88 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.brainsuite.brainsuite.ThicknessPVC' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     ThicknessPVC computes cortical thickness using partial tissue fractions.
-#     This thickness measure is then transferred to the atlas surface to
-#     facilitate population studies. It also stores the computed thickness into
-#     separate hemisphere files and subject thickness mapped to the atlas
-#     hemisphere surfaces. ThicknessPVC is not run through the main SVReg
-#     sequence, and should be used after executing the BrainSuite and SVReg
-#     sequence.
-#     For more informaction, please see:
-# 
-#     http://brainsuite.org/processing/svreg/svreg_modules/
-# 
-#     Examples
-#     --------
-# 
-#     >>> from nipype.interfaces import brainsuite
-#     >>> thicknessPVC = brainsuite.ThicknessPVC()
-#     >>> thicknessPVC.inputs.subjectFilePrefix = 'home/user/btestsubject/testsubject'
-#     >>> results = thicknessPVC.run() #doctest: +SKIP
-# 
-#     
-task_name: ThicknessPVC
-nipype_name: ThicknessPVC
-nipype_module: nipype.interfaces.brainsuite.brainsuite
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    subjectFilePrefix:
-    # type=str|default='': Absolute path and filename prefix of the subject data
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-brainsuite/thickness_pvc_callables.py b/example-specs/task/nipype_internal/pydra-brainsuite/thickness_pvc_callables.py
deleted file mode 100644
index 728f0f19..00000000
--- a/example-specs/task/nipype_internal/pydra-brainsuite/thickness_pvc_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in ThicknessPVC.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-bru2nii/bru_2.yaml b/example-specs/task/nipype_internal/pydra-bru2nii/bru_2.yaml
deleted file mode 100644
index 14e60c56..00000000
--- a/example-specs/task/nipype_internal/pydra-bru2nii/bru_2.yaml
+++ /dev/null
@@ -1,127 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.bru2nii.Bru2' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Uses bru2nii's Bru2 to convert Bruker files
-# 
-#     Examples
-#     ========
-# 
-#     >>> from nipype.interfaces.bru2nii import Bru2
-#     >>> converter = Bru2()
-#     >>> converter.inputs.input_dir = "brukerdir"
-#     >>> converter.cmdline  # doctest: +ELLIPSIS
-#     'Bru2 -o .../data/brukerdir brukerdir'
-#     
-task_name: Bru2
-nipype_name: Bru2
-nipype_module: nipype.interfaces.bru2nii
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    input_dir: generic/directory
-    # type=directory|default=<undefined>: Input Directory
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    nii_file: generic/file
-    # type=file: 
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    output_filename: output_filename
-    # type=str|default='': Output filename (".nii" will be appended, or ".nii.gz" if the "-z" compress option is selected)
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    input_dir:
-    # type=directory|default=<undefined>: Input Directory
-    actual_size:
-    # type=bool|default=False: Keep actual size - otherwise x10 scale so animals match human.
-    force_conversion:
-    # type=bool|default=False: Force conversion of localizers images (multiple slice orientations).
-    compress:
-    # type=bool|default=False: gz compress images (".nii.gz").
-    append_protocol_name:
-    # type=bool|default=False: Append protocol name to output filename.
-    output_filename:
-    # type=str|default='': Output filename (".nii" will be appended, or ".nii.gz" if the "-z" compress option is selected)
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    input_dir: '"brukerdir"'
-    # type=directory|default=<undefined>: Input Directory
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests:
-- cmdline: Bru2 -o .../data/brukerdir brukerdir
-  # str - the expected cmdline output
-  inputs:
-  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
-  # If the field is of file-format type and the value is None, then the
-  # '.mock()' method of the corresponding class is used instead.
-    input_dir: '"brukerdir"'
-    # type=directory|default=<undefined>: Input Directory
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  directive:
-  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-bru2nii/bru_2_callables.py b/example-specs/task/nipype_internal/pydra-bru2nii/bru_2_callables.py
deleted file mode 100644
index d452f09c..00000000
--- a/example-specs/task/nipype_internal/pydra-bru2nii/bru_2_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in Bru2.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-c3/c_3d.yaml b/example-specs/task/nipype_internal/pydra-c3/c_3d.yaml
deleted file mode 100644
index b07f1226..00000000
--- a/example-specs/task/nipype_internal/pydra-c3/c_3d.yaml
+++ /dev/null
@@ -1,165 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.c3.C3d' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Convert3d is a command-line tool for converting 3D (or 4D) images between
-#     common file formats. The tool also includes a growing list of commands for
-#     image manipulation, such as thresholding and resampling. The tool can also
-#     be used to obtain information about image files. More information on
-#     Convert3d can be found at:
-#     https://sourceforge.net/p/c3d/git/ci/master/tree/doc/c3d.md
-# 
-# 
-#     Example
-#     =======
-# 
-#     >>> from nipype.interfaces.c3 import C3d
-#     >>> c3 = C3d()
-#     >>> c3.inputs.in_file = "T1.nii"
-#     >>> c3.inputs.pix_type = "short"
-#     >>> c3.inputs.out_file = "T1.img"
-#     >>> c3.cmdline
-#     'c3d T1.nii -type short -o T1.img'
-#     >>> c3.inputs.is_4d = True
-#     >>> c3.inputs.in_file = "epi.nii"
-#     >>> c3.inputs.out_file = "epi.img"
-#     >>> c3.cmdline
-#     'c4d epi.nii -type short -o epi.img'
-#     
-task_name: C3d
-nipype_name: C3d
-nipype_module: nipype.interfaces.c3
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_file: medimage/nifti1+list-of
-    # type=inputmultiobject|default=[]: Input file (wildcard and multiple are supported).
-    out_file: medimage/analyze
-    # type=file|default=<undefined>: Output file of last image on the stack.
-    out_files: generic/file+list-of
-    # type=outputmultiobject: 
-    # type=inputmultiobject|default=[]: Write all images on the convert3d stack as multiple files. Supports both list of output files or a pattern for the output filenames (using %d substitution).
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=inputmultiobject|default=[]: Input file (wildcard and multiple are supported).
-    out_file:
-    # type=file|default=<undefined>: Output file of last image on the stack.
-    out_files:
-    # type=outputmultiobject: 
-    # type=inputmultiobject|default=[]: Write all images on the convert3d stack as multiple files. Supports both list of output files or a pattern for the output filenames (using %d substitution).
-    pix_type:
-    # type=enum|default='float'|allowed['char','double','float','int','short','uchar','uint','ushort']: Specifies the pixel type for the output image. By default, images are written in floating point (float) format
-    scale:
-    # type=traitcompound|default=None: Multiplies the intensity of each voxel in the last image on the stack by the given factor.
-    shift:
-    # type=traitcompound|default=None: Adds the given constant to every voxel.
-    interp:
-    # type=enum|default='Linear'|allowed['Cubic','Gaussian','Linear','NearestNeighbor','Sinc']: Specifies the interpolation used with -resample and other commands. Default is Linear.
-    resample:
-    # type=str|default='': Resamples the image, keeping the bounding box the same, but changing the number of voxels in the image. The dimensions can be specified as a percentage, for example to double the number of voxels in each direction. The -interpolation flag affects how sampling is performed.
-    smooth:
-    # type=str|default='': Applies Gaussian smoothing to the image. The parameter vector specifies the standard deviation of the Gaussian kernel.
-    multicomp_split:
-    # type=bool|default=False: Enable reading of multi-component images.
-    is_4d:
-    # type=bool|default=False: Changes command to support 4D file operations (default is false).
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=inputmultiobject|default=[]: Input file (wildcard and multiple are supported).
-    pix_type: '"short"'
-    # type=enum|default='float'|allowed['char','double','float','int','short','uchar','uint','ushort']: Specifies the pixel type for the output image. By default, images are written in floating point (float) format
-    out_file:
-    # type=file|default=<undefined>: Output file of last image on the stack.
-    is_4d: 'True'
-    # type=bool|default=False: Changes command to support 4D file operations (default is false).
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests:
-- cmdline: c4d epi.nii -type short -o epi.img
-  # str - the expected cmdline output
-  inputs:
-  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
-  # If the field is of file-format type and the value is None, then the
-  # '.mock()' method of the corresponding class is used instead.
-    in_file:
-    # type=inputmultiobject|default=[]: Input file (wildcard and multiple are supported).
-    pix_type: '"short"'
-    # type=enum|default='float'|allowed['char','double','float','int','short','uchar','uint','ushort']: Specifies the pixel type for the output image. By default, images are written in floating point (float) format
-    out_file:
-    # type=file|default=<undefined>: Output file of last image on the stack.
-    is_4d: 'True'
-    # type=bool|default=False: Changes command to support 4D file operations (default is false).
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  directive:
-  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-c3/c_3d_affine_tool.yaml b/example-specs/task/nipype_internal/pydra-c3/c_3d_affine_tool.yaml
deleted file mode 100644
index 73a37301..00000000
--- a/example-specs/task/nipype_internal/pydra-c3/c_3d_affine_tool.yaml
+++ /dev/null
@@ -1,141 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.c3.C3dAffineTool' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Converts fsl-style Affine registration into ANTS compatible itk format
-# 
-#     Example
-#     =======
-# 
-#     >>> from nipype.interfaces.c3 import C3dAffineTool
-#     >>> c3 = C3dAffineTool()
-#     >>> c3.inputs.source_file = 'cmatrix.mat'
-#     >>> c3.inputs.itk_transform = 'affine.txt'
-#     >>> c3.inputs.fsl2ras = True
-#     >>> c3.cmdline
-#     'c3d_affine_tool -src cmatrix.mat -fsl2ras -oitk affine.txt'
-#     
-task_name: C3dAffineTool
-nipype_name: C3dAffineTool
-nipype_module: nipype.interfaces.c3
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    reference_file: generic/file
-    # type=file|default=<undefined>: 
-    source_file: datascience/text-matrix
-    # type=file|default=<undefined>: 
-    transform_file: generic/file
-    # type=file|default=<undefined>: 
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    itk_transform: text/text-file
-    # type=file: 
-    # type=traitcompound|default=None: Export ITK transform.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    reference_file:
-    # type=file|default=<undefined>: 
-    source_file:
-    # type=file|default=<undefined>: 
-    transform_file:
-    # type=file|default=<undefined>: 
-    itk_transform:
-    # type=file: 
-    # type=traitcompound|default=None: Export ITK transform.
-    fsl2ras:
-    # type=bool|default=False: 
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    source_file:
-    # type=file|default=<undefined>: 
-    itk_transform: '"affine.txt"'
-    # type=file: 
-    # type=traitcompound|default=None: Export ITK transform.
-    fsl2ras: 'True'
-    # type=bool|default=False: 
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests:
-- cmdline: c3d_affine_tool -src cmatrix.mat -fsl2ras -oitk affine.txt
-  # str - the expected cmdline output
-  inputs:
-  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
-  # If the field is of file-format type and the value is None, then the
-  # '.mock()' method of the corresponding class is used instead.
-    source_file:
-    # type=file|default=<undefined>: 
-    itk_transform: '"affine.txt"'
-    # type=file: 
-    # type=traitcompound|default=None: Export ITK transform.
-    fsl2ras: 'True'
-    # type=bool|default=False: 
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  directive:
-  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-c3/c_3d_affine_tool_callables.py b/example-specs/task/nipype_internal/pydra-c3/c_3d_affine_tool_callables.py
deleted file mode 100644
index a1e0afa3..00000000
--- a/example-specs/task/nipype_internal/pydra-c3/c_3d_affine_tool_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in C3dAffineTool.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-c3/c_3d_callables.py b/example-specs/task/nipype_internal/pydra-c3/c_3d_callables.py
deleted file mode 100644
index a71b7076..00000000
--- a/example-specs/task/nipype_internal/pydra-c3/c_3d_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in C3d.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-camino/analyze_header.yaml b/example-specs/task/nipype_internal/pydra-camino/analyze_header.yaml
deleted file mode 100644
index d5feafcb..00000000
--- a/example-specs/task/nipype_internal/pydra-camino/analyze_header.yaml
+++ /dev/null
@@ -1,152 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.camino.convert.AnalyzeHeader' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Create or read an Analyze 7.5 header file.
-# 
-#     Analyze image header, provides support for the most common header fields.
-#     Some fields, such as patient_id, are not currently supported. The program allows
-#     three nonstandard options: the field image_dimension.funused1 is the image scale.
-#     The intensity of each pixel in the associated .img file is (image value from file) * scale.
-#     Also, the origin of the Talairach coordinates (midline of the anterior commisure) are encoded
-#     in the field data_history.originator. These changes are included for compatibility with SPM.
-# 
-#     All headers written with this program are big endian by default.
-# 
-#     Example
-#     -------
-# 
-#     >>> import nipype.interfaces.camino as cmon
-#     >>> hdr = cmon.AnalyzeHeader()
-#     >>> hdr.inputs.in_file = 'tensor_fitted_data.Bdouble'
-#     >>> hdr.inputs.scheme_file = 'A.scheme'
-#     >>> hdr.inputs.data_dims = [256,256,256]
-#     >>> hdr.inputs.voxel_dims = [1,1,1]
-#     >>> hdr.run()          # doctest: +SKIP
-#     
-task_name: AnalyzeHeader
-nipype_name: AnalyzeHeader
-nipype_module: nipype.interfaces.camino.convert
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_file: generic/file
-    # type=file|default=<undefined>: Tensor-fitted data filename
-    scheme_file: generic/file
-    # type=file|default=<undefined>: Camino scheme file (b values / vectors, see camino.fsl2scheme)
-    readheader: generic/file
-    # type=file|default=<undefined>: Reads header information from file and prints to stdout. If this option is not specified, then the program writes a header based on the other arguments.
-    printimagedims: generic/file
-    # type=file|default=<undefined>: Prints image data and voxel dimensions as Camino arguments and exits.
-    printprogargs: generic/file
-    # type=file|default=<undefined>: Prints data dimension (and type, if relevant) arguments for a specific Camino program, where prog is one of shredder, scanner2voxel, vcthreshselect, pdview, track.
-    printintelbyteorder: generic/file
-    # type=file|default=<undefined>: Prints 1 if the header is little-endian, 0 otherwise.
-    printbigendian: generic/file
-    # type=file|default=<undefined>: Prints 1 if the header is big-endian, 0 otherwise.
-    initfromheader: generic/file
-    # type=file|default=<undefined>: Reads header information from file and initializes a new header with the values read from the file. You may replace any combination of fields in the new header by specifying subsequent options.
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    header: generic/file
-    # type=file: Analyze header
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    out_file: out_file
-    # type=file|default=<undefined>: 
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: Tensor-fitted data filename
-    scheme_file:
-    # type=file|default=<undefined>: Camino scheme file (b values / vectors, see camino.fsl2scheme)
-    readheader:
-    # type=file|default=<undefined>: Reads header information from file and prints to stdout. If this option is not specified, then the program writes a header based on the other arguments.
-    printimagedims:
-    # type=file|default=<undefined>: Prints image data and voxel dimensions as Camino arguments and exits.
-    printprogargs:
-    # type=file|default=<undefined>: Prints data dimension (and type, if relevant) arguments for a specific Camino program, where prog is one of shredder, scanner2voxel, vcthreshselect, pdview, track.
-    printintelbyteorder:
-    # type=file|default=<undefined>: Prints 1 if the header is little-endian, 0 otherwise.
-    printbigendian:
-    # type=file|default=<undefined>: Prints 1 if the header is big-endian, 0 otherwise.
-    initfromheader:
-    # type=file|default=<undefined>: Reads header information from file and initializes a new header with the values read from the file. You may replace any combination of fields in the new header by specifying subsequent options.
-    data_dims:
-    # type=list|default=[]: data dimensions in voxels
-    voxel_dims:
-    # type=list|default=[]: voxel dimensions in mm
-    centre:
-    # type=list|default=[]: Voxel specifying origin of Talairach coordinate system for SPM, default [0 0 0].
-    picoseed:
-    # type=list|default=[]: Voxel specifying the seed (for PICo maps), default [0 0 0].
-    nimages:
-    # type=int|default=0: Number of images in the img file. Default 1.
-    datatype:
-    # type=enum|default='byte'|allowed['[u]int','[u]short','byte','char','complex','double','float']: The char datatype is 8 bit (not the 16 bit char of Java), as specified by the Analyze 7.5 standard. The byte, ushort and uint types are not part of the Analyze specification but are supported by SPM.
-    offset:
-    # type=int|default=0: According to the Analyze 7.5 standard, this is the byte offset in the .img file at which voxels start. This value can be negative to specify that the absolute value is applied for every image in the file.
-    greylevels:
-    # type=list|default=[]: Minimum and maximum greylevels. Stored as shorts in the header.
-    scaleslope:
-    # type=float|default=0.0: Intensities in the image are scaled by this factor by SPM and MRICro. Default is 1.0.
-    scaleinter:
-    # type=float|default=0.0: Constant to add to the image intensities. Used by SPM and MRIcro.
-    description:
-    # type=string|default='': Short description - No spaces, max length 79 bytes. Will be null terminated automatically.
-    intelbyteorder:
-    # type=bool|default=False: Write header in intel byte order (little-endian).
-    networkbyteorder:
-    # type=bool|default=False: Write header in network byte order (big-endian). This is the default for new headers.
-    out_file:
-    # type=file|default=<undefined>: 
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-camino/analyze_header_callables.py b/example-specs/task/nipype_internal/pydra-camino/analyze_header_callables.py
deleted file mode 100644
index 439f1ddc..00000000
--- a/example-specs/task/nipype_internal/pydra-camino/analyze_header_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in AnalyzeHeader.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-camino/compute_eigensystem.yaml b/example-specs/task/nipype_internal/pydra-camino/compute_eigensystem.yaml
deleted file mode 100644
index f66cf244..00000000
--- a/example-specs/task/nipype_internal/pydra-camino/compute_eigensystem.yaml
+++ /dev/null
@@ -1,102 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.camino.dti.ComputeEigensystem' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Computes the eigensystem from tensor fitted data.
-# 
-#     Reads diffusion tensor (single, two-tensor, three-tensor or multitensor) data from the
-#     standard input, computes the eigenvalues and eigenvectors of each tensor and outputs the
-#     results to the standard output. For multiple-tensor data the program outputs the
-#     eigensystem of each tensor. For each tensor the program outputs: {l_1, e_11, e_12, e_13,
-#     l_2, e_21, e_22, e_33, l_3, e_31, e_32, e_33}, where l_1 >= l_2 >= l_3 and e_i = (e_i1,
-#     e_i2, e_i3) is the eigenvector with eigenvalue l_i. For three-tensor data, for example,
-#     the output contains thirty-six values per voxel.
-# 
-#     Example
-#     -------
-# 
-#     >>> import nipype.interfaces.camino as cmon
-#     >>> dteig = cmon.ComputeEigensystem()
-#     >>> dteig.inputs.in_file = 'tensor_fitted_data.Bdouble'
-#     >>> dteig.run()          # doctest: +SKIP
-#     
-task_name: ComputeEigensystem
-nipype_name: ComputeEigensystem
-nipype_module: nipype.interfaces.camino.dti
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_file: generic/file
-    # type=file|default=<undefined>: Tensor-fitted data filename
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    eigen: generic/file
-    # type=file: Trace of the diffusion tensor
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    out_file: out_file
-    # type=file|default=<undefined>: 
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: Tensor-fitted data filename
-    inputmodel:
-    # type=enum|default='dt'|allowed['dt','multitensor']: Specifies the model that the input data contains parameters for
-    maxcomponents:
-    # type=int|default=0: The maximum number of tensor components in a voxel of the input data.
-    inputdatatype:
-    # type=enum|default='double'|allowed['char','double','float','int','long','short']: Specifies the data type of the input data. The data type can be any of the following strings: "char", "short", "int", "long", "float" or "double".Default is double data type
-    outputdatatype:
-    # type=enum|default='double'|allowed['char','double','float','int','long','short']: Specifies the data type of the output data.
-    out_file:
-    # type=file|default=<undefined>: 
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-camino/compute_eigensystem_callables.py b/example-specs/task/nipype_internal/pydra-camino/compute_eigensystem_callables.py
deleted file mode 100644
index ec83a83e..00000000
--- a/example-specs/task/nipype_internal/pydra-camino/compute_eigensystem_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in ComputeEigensystem.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-camino/compute_fractional_anisotropy.yaml b/example-specs/task/nipype_internal/pydra-camino/compute_fractional_anisotropy.yaml
deleted file mode 100644
index da2baec5..00000000
--- a/example-specs/task/nipype_internal/pydra-camino/compute_fractional_anisotropy.yaml
+++ /dev/null
@@ -1,103 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.camino.dti.ComputeFractionalAnisotropy' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Computes the fractional anisotropy of tensors.
-# 
-#     Reads diffusion tensor (single, two-tensor or three-tensor) data from the standard input,
-#     computes the fractional anisotropy (FA) of each tensor and outputs the results to the
-#     standard output. For multiple-tensor data the program outputs the FA of each tensor,
-#     so for three-tensor data, for example, the output contains three fractional anisotropy
-#     values per voxel.
-# 
-#     Example
-#     -------
-#     >>> import nipype.interfaces.camino as cmon
-#     >>> fa = cmon.ComputeFractionalAnisotropy()
-#     >>> fa.inputs.in_file = 'tensor_fitted_data.Bdouble'
-#     >>> fa.inputs.scheme_file = 'A.scheme'
-#     >>> fa.run()          # doctest: +SKIP
-# 
-#     
-task_name: ComputeFractionalAnisotropy
-nipype_name: ComputeFractionalAnisotropy
-nipype_module: nipype.interfaces.camino.dti
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_file: generic/file
-    # type=file|default=<undefined>: Tensor-fitted data filename
-    scheme_file: generic/file
-    # type=file|default=<undefined>: Camino scheme file (b values / vectors, see camino.fsl2scheme)
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    fa: generic/file
-    # type=file: Fractional Anisotropy Map
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    out_file: out_file
-    # type=file|default=<undefined>: 
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: Tensor-fitted data filename
-    scheme_file:
-    # type=file|default=<undefined>: Camino scheme file (b values / vectors, see camino.fsl2scheme)
-    inputmodel:
-    # type=enum|default='dt'|allowed['dt','multitensor','threetensor','twotensor']: Specifies the model that the input tensor data contains parameters for. By default, the program assumes that the input data contains a single diffusion tensor in each voxel.
-    inputdatatype:
-    # type=enum|default='char'|allowed['char','double','float','int','long','short']: Specifies the data type of the input file.
-    outputdatatype:
-    # type=enum|default='char'|allowed['char','double','float','int','long','short']: Specifies the data type of the output data.
-    out_file:
-    # type=file|default=<undefined>: 
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-camino/compute_fractional_anisotropy_callables.py b/example-specs/task/nipype_internal/pydra-camino/compute_fractional_anisotropy_callables.py
deleted file mode 100644
index b8d6d506..00000000
--- a/example-specs/task/nipype_internal/pydra-camino/compute_fractional_anisotropy_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in ComputeFractionalAnisotropy.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-camino/compute_mean_diffusivity.yaml b/example-specs/task/nipype_internal/pydra-camino/compute_mean_diffusivity.yaml
deleted file mode 100644
index 5eb821aa..00000000
--- a/example-specs/task/nipype_internal/pydra-camino/compute_mean_diffusivity.yaml
+++ /dev/null
@@ -1,97 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.camino.dti.ComputeMeanDiffusivity' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Computes the mean diffusivity (trace/3) from diffusion tensors.
-# 
-#     Example
-#     -------
-#     >>> import nipype.interfaces.camino as cmon
-#     >>> md = cmon.ComputeMeanDiffusivity()
-#     >>> md.inputs.in_file = 'tensor_fitted_data.Bdouble'
-#     >>> md.inputs.scheme_file = 'A.scheme'
-#     >>> md.run()          # doctest: +SKIP
-# 
-#     
-task_name: ComputeMeanDiffusivity
-nipype_name: ComputeMeanDiffusivity
-nipype_module: nipype.interfaces.camino.dti
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_file: generic/file
-    # type=file|default=<undefined>: Tensor-fitted data filename
-    scheme_file: generic/file
-    # type=file|default=<undefined>: Camino scheme file (b values / vectors, see camino.fsl2scheme)
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    md: generic/file
-    # type=file: Mean Diffusivity Map
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    out_file: out_file
-    # type=file|default=<undefined>: 
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: Tensor-fitted data filename
-    scheme_file:
-    # type=file|default=<undefined>: Camino scheme file (b values / vectors, see camino.fsl2scheme)
-    out_file:
-    # type=file|default=<undefined>: 
-    inputmodel:
-    # type=enum|default='dt'|allowed['dt','threetensor','twotensor']: Specifies the model that the input tensor data contains parameters for. By default, the program assumes that the input data contains a single diffusion tensor in each voxel.
-    inputdatatype:
-    # type=enum|default='char'|allowed['char','double','float','int','long','short']: Specifies the data type of the input file.
-    outputdatatype:
-    # type=enum|default='char'|allowed['char','double','float','int','long','short']: Specifies the data type of the output data.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-camino/compute_mean_diffusivity_callables.py b/example-specs/task/nipype_internal/pydra-camino/compute_mean_diffusivity_callables.py
deleted file mode 100644
index f665c8b8..00000000
--- a/example-specs/task/nipype_internal/pydra-camino/compute_mean_diffusivity_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in ComputeMeanDiffusivity.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-camino/compute_tensor_trace.yaml b/example-specs/task/nipype_internal/pydra-camino/compute_tensor_trace.yaml
deleted file mode 100644
index ef481bc5..00000000
--- a/example-specs/task/nipype_internal/pydra-camino/compute_tensor_trace.yaml
+++ /dev/null
@@ -1,105 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.camino.dti.ComputeTensorTrace' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Computes the trace of tensors.
-# 
-#     Reads diffusion tensor (single, two-tensor or three-tensor) data from the standard input,
-#     computes the trace of each tensor, i.e., three times the mean diffusivity, and outputs
-#     the results to the standard output. For multiple-tensor data the program outputs the
-#     trace of each tensor, so for three-tensor data, for example, the output contains three
-#     values per voxel.
-# 
-#     Divide the output by three to get the mean diffusivity.
-# 
-#     Example
-#     -------
-#     >>> import nipype.interfaces.camino as cmon
-#     >>> trace = cmon.ComputeTensorTrace()
-#     >>> trace.inputs.in_file = 'tensor_fitted_data.Bdouble'
-#     >>> trace.inputs.scheme_file = 'A.scheme'
-#     >>> trace.run()         # doctest: +SKIP
-# 
-#     
-task_name: ComputeTensorTrace
-nipype_name: ComputeTensorTrace
-nipype_module: nipype.interfaces.camino.dti
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_file: generic/file
-    # type=file|default=<undefined>: Tensor-fitted data filename
-    scheme_file: generic/file
-    # type=file|default=<undefined>: Camino scheme file (b values / vectors, see camino.fsl2scheme)
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    trace: generic/file
-    # type=file: Trace of the diffusion tensor
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    out_file: out_file
-    # type=file|default=<undefined>: 
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: Tensor-fitted data filename
-    scheme_file:
-    # type=file|default=<undefined>: Camino scheme file (b values / vectors, see camino.fsl2scheme)
-    inputmodel:
-    # type=enum|default='dt'|allowed['dt','multitensor','threetensor','twotensor']: Specifies the model that the input tensor data contains parameters for. By default, the program assumes that the input data contains a single diffusion tensor in each voxel.
-    inputdatatype:
-    # type=enum|default='char'|allowed['char','double','float','int','long','short']: Specifies the data type of the input file.
-    outputdatatype:
-    # type=enum|default='char'|allowed['char','double','float','int','long','short']: Specifies the data type of the output data.
-    out_file:
-    # type=file|default=<undefined>: 
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-camino/compute_tensor_trace_callables.py b/example-specs/task/nipype_internal/pydra-camino/compute_tensor_trace_callables.py
deleted file mode 100644
index a78642fe..00000000
--- a/example-specs/task/nipype_internal/pydra-camino/compute_tensor_trace_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in ComputeTensorTrace.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-camino/conmat.yaml b/example-specs/task/nipype_internal/pydra-camino/conmat.yaml
deleted file mode 100644
index a9a0d27e..00000000
--- a/example-specs/task/nipype_internal/pydra-camino/conmat.yaml
+++ /dev/null
@@ -1,166 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.camino.connectivity.Conmat' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Creates  a  connectivity  matrix  using a 3D label image (the target image)
-#     and a set of streamlines. The connectivity matrix records how many stream-
-#     lines connect each pair of targets, and optionally the mean tractwise
-#     statistic (eg tract-averaged FA, or length).
-# 
-#     The output is a comma separated variable file or files. The first row of
-#     the output matrix is label names. Label names may be defined by the user,
-#     otherwise  they  are assigned based on label intensity.
-# 
-#     Starting  from the seed point, we move along the streamline until we find
-#     a point in a labeled region. This is done in both directions from the seed
-#     point. Streamlines are counted if they connect two target regions, one on
-#     either side of the seed point. Only the labeled region closest to the seed
-#     is counted, for example if the  input contains two streamlines: ::
-# 
-#          1: A-----B------SEED---C
-#          2: A--------SEED-----------
-# 
-#     then the output would be ::
-# 
-#          A,B,C
-#          0,0,0
-#          0,0,1
-#          0,1,0
-# 
-#     There  are  zero  connections  to A because in streamline 1, the connection
-#     to B is closer to the seed than the connection to A, and in streamline 2
-#     there is no region reached in the other direction.
-# 
-#     The connected target regions can have the same label, as long as the seed
-#     point is outside of the labeled region and both ends connect to the same
-#     label (which may  be in different locations). Therefore this is allowed: ::
-# 
-#          A------SEED-------A
-# 
-#     Such fibers will add to the diagonal elements of the matrix. To remove
-#     these entries, run procstreamlines with -endpointfile before running conmat.
-# 
-#     If the seed point is inside a labeled region, it counts as one end of the
-#     connection.  So ::
-# 
-#          ----[SEED inside A]---------B
-# 
-#     counts as a connection between A and B, while ::
-# 
-#          C----[SEED inside A]---------B
-# 
-#     counts as a connection between A and C, because C is closer to the seed point.
-# 
-#     In all cases, distance to the seed point is defined along the streamline path.
-# 
-#     Examples
-#     --------
-#     To create a standard connectivity matrix based on streamline counts.
-# 
-#     >>> import nipype.interfaces.camino as cam
-#     >>> conmat = cam.Conmat()
-#     >>> conmat.inputs.in_file = 'tracts.Bdouble'
-#     >>> conmat.inputs.target_file = 'atlas.nii.gz'
-#     >>> conmat.run()# doctest: +SKIP
-# 
-#     To create a standard connectivity matrix and mean tractwise FA statistics.
-# 
-#     >>> import nipype.interfaces.camino as cam
-#     >>> conmat = cam.Conmat()
-#     >>> conmat.inputs.in_file = 'tracts.Bdouble'
-#     >>> conmat.inputs.target_file = 'atlas.nii.gz'
-#     >>> conmat.inputs.scalar_file = 'fa.nii.gz'
-#     >>> conmat.tract_stat         = 'mean'
-#     >>> conmat.run()# doctest: +SKIP
-# 
-#     
-task_name: Conmat
-nipype_name: Conmat
-nipype_module: nipype.interfaces.camino.connectivity
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_file: generic/file
-    # type=file|default=<undefined>: Streamlines as generated by the Track interface
-    target_file: generic/file
-    # type=file|default=<undefined>: An image containing targets, as used in ProcStreamlines interface.
-    scalar_file: generic/file
-    # type=file|default=<undefined>: Optional scalar file for computing tract-based statistics. Must be in the same space as the target file.
-    targetname_file: generic/file
-    # type=file|default=<undefined>: Optional names of targets. This file should contain one entry per line, with the target intensity followed by the name, separated by white space. For example:   1  some_brain_region   2     some_other_region These names will be used in the output. The names themselves should not contain spaces or commas. The labels may be in any order but the output matrices will be ordered by label intensity.
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    conmat_sc: generic/file
-    # type=file: Connectivity matrix in CSV file.
-    conmat_ts: generic/file
-    # type=file: Tract statistics in CSV file.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    output_root: output_root
-    # type=file|default=<undefined>: filename root prepended onto the names of the output files. The extension will be determined from the input.
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: Streamlines as generated by the Track interface
-    target_file:
-    # type=file|default=<undefined>: An image containing targets, as used in ProcStreamlines interface.
-    scalar_file:
-    # type=file|default=<undefined>: Optional scalar file for computing tract-based statistics. Must be in the same space as the target file.
-    targetname_file:
-    # type=file|default=<undefined>: Optional names of targets. This file should contain one entry per line, with the target intensity followed by the name, separated by white space. For example:   1  some_brain_region   2     some_other_region These names will be used in the output. The names themselves should not contain spaces or commas. The labels may be in any order but the output matrices will be ordered by label intensity.
-    tract_stat:
-    # type=enum|default='mean'|allowed['max','mean','median','min','sum','var']: Tract statistic to use. See TractStats for other options.
-    tract_prop:
-    # type=enum|default='length'|allowed['endpointsep','length']: Tract property average to compute in the connectivity matrix. See TractStats for details.
-    output_root:
-    # type=file|default=<undefined>: filename root prepended onto the names of the output files. The extension will be determined from the input.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-camino/conmat_callables.py b/example-specs/task/nipype_internal/pydra-camino/conmat_callables.py
deleted file mode 100644
index 377a4ac4..00000000
--- a/example-specs/task/nipype_internal/pydra-camino/conmat_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in Conmat.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-camino/dt2n_if_ti.yaml b/example-specs/task/nipype_internal/pydra-camino/dt2n_if_ti.yaml
deleted file mode 100644
index e7865ffa..00000000
--- a/example-specs/task/nipype_internal/pydra-camino/dt2n_if_ti.yaml
+++ /dev/null
@@ -1,88 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.camino.convert.DT2NIfTI' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Converts camino tensor data to NIfTI format
-# 
-#     Reads Camino diffusion tensors, and converts them to NIFTI format as three .nii files.
-#     
-task_name: DT2NIfTI
-nipype_name: DT2NIfTI
-nipype_module: nipype.interfaces.camino.convert
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_file: generic/file
-    # type=file|default=<undefined>: tract file
-    header_file: generic/file
-    # type=file|default=<undefined>:  A Nifti .nii or .hdr file containing the header information
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    dt: generic/file
-    # type=file: diffusion tensors in NIfTI format
-    exitcode: generic/file
-    # type=file: exit codes from Camino reconstruction in NIfTI format
-    lns0: generic/file
-    # type=file: estimated lns0 from Camino reconstruction in NIfTI format
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    output_root: output_root
-    # type=file|default=<undefined>: filename root prepended onto the names of three output files.
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: tract file
-    output_root:
-    # type=file|default=<undefined>: filename root prepended onto the names of three output files.
-    header_file:
-    # type=file|default=<undefined>:  A Nifti .nii or .hdr file containing the header information
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-camino/dt2n_if_ti_callables.py b/example-specs/task/nipype_internal/pydra-camino/dt2n_if_ti_callables.py
deleted file mode 100644
index 6e8b01b8..00000000
--- a/example-specs/task/nipype_internal/pydra-camino/dt2n_if_ti_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in DT2NIfTI.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-camino/dt_metric.yaml b/example-specs/task/nipype_internal/pydra-camino/dt_metric.yaml
deleted file mode 100644
index fb59d552..00000000
--- a/example-specs/task/nipype_internal/pydra-camino/dt_metric.yaml
+++ /dev/null
@@ -1,120 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.camino.dti.DTMetric' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Computes tensor metric statistics based on the eigenvalues l1 >= l2 >= l3
-#     typically obtained from ComputeEigensystem.
-# 
-#     The full list of statistics is:
-# 
-#      - <cl> = (l1 - l2) / l1 , a measure of linearity
-#      - <cp> = (l2 - l3) / l1 , a measure of planarity
-#      - <cs> = l3 / l1 , a measure of isotropy
-#        with: cl + cp + cs = 1
-#      - <l1> = first eigenvalue
-#      - <l2> = second eigenvalue
-#      - <l3> = third eigenvalue
-#      - <tr> = l1 + l2 + l3
-#      - <md> = tr / 3
-#      - <rd> = (l2 + l3) / 2
-#      - <fa> = fractional anisotropy. (Basser et al, J Magn Reson B 1996)
-#      - <ra> = relative anisotropy (Basser et al, J Magn Reson B 1996)
-#      - <2dfa> = 2D FA of the two minor eigenvalues l2 and l3
-#        i.e. sqrt( 2 * [(l2 - <l>)^2 + (l3 - <l>)^2] / (l2^2 + l3^2) )
-#        with: <l> = (l2 + l3) / 2
-# 
-# 
-#     Example
-#     -------
-#     Compute the CP planar metric as float data type.
-# 
-#     >>> import nipype.interfaces.camino as cam
-#     >>> dtmetric = cam.DTMetric()
-#     >>> dtmetric.inputs.eigen_data = 'dteig.Bdouble'
-#     >>> dtmetric.inputs.metric = 'cp'
-#     >>> dtmetric.inputs.outputdatatype = 'float'
-#     >>> dtmetric.run()          # doctest: +SKIP
-# 
-#     
-task_name: DTMetric
-nipype_name: DTMetric
-nipype_module: nipype.interfaces.camino.dti
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    eigen_data: generic/file
-    # type=file|default=<undefined>: voxel-order data filename
-    data_header: generic/file
-    # type=file|default=<undefined>: A Nifti .nii or .nii.gz file containing the header information. Usually this will be the header of the raw data file from which the diffusion tensors were reconstructed.
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    metric_stats: generic/file
-    # type=file: Diffusion Tensor statistics of the chosen metric
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    outputfile: outputfile
-    # type=file|default=<undefined>: Output name. Output will be a .nii.gz file if data_header is provided andin voxel order with outputdatatype datatype (default: double) otherwise.
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    eigen_data:
-    # type=file|default=<undefined>: voxel-order data filename
-    metric:
-    # type=enum|default='fa'|allowed['2dfa','cl','cp','cs','fa','l1','l2','l3','md','ra','rd','tr']: Specifies the metric to compute.
-    inputdatatype:
-    # type=enum|default='double'|allowed['char','double','float','int','long','short']: Specifies the data type of the input data.
-    outputdatatype:
-    # type=enum|default='double'|allowed['char','double','float','int','long','short']: Specifies the data type of the output data.
-    data_header:
-    # type=file|default=<undefined>: A Nifti .nii or .nii.gz file containing the header information. Usually this will be the header of the raw data file from which the diffusion tensors were reconstructed.
-    outputfile:
-    # type=file|default=<undefined>: Output name. Output will be a .nii.gz file if data_header is provided andin voxel order with outputdatatype datatype (default: double) otherwise.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-camino/dt_metric_callables.py b/example-specs/task/nipype_internal/pydra-camino/dt_metric_callables.py
deleted file mode 100644
index 49454cb2..00000000
--- a/example-specs/task/nipype_internal/pydra-camino/dt_metric_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in DTMetric.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-camino/dti_fit.yaml b/example-specs/task/nipype_internal/pydra-camino/dti_fit.yaml
deleted file mode 100644
index 40aa6ded..00000000
--- a/example-specs/task/nipype_internal/pydra-camino/dti_fit.yaml
+++ /dev/null
@@ -1,112 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.camino.dti.DTIFit' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Reads diffusion MRI data, acquired using the acquisition scheme detailed in the scheme file,
-#     from the data file.
-# 
-#     Use non-linear fitting instead of the default linear regression to the log measurements.
-#     The data file stores the diffusion MRI data in voxel order with the measurements stored
-#     in big-endian format and ordered as in the scheme file.
-#     The default input data type is four-byte float.
-#     The default output data type is eight-byte double.
-#     See modelfit and camino for the format of the data file and scheme file.
-#     The program fits the diffusion tensor to each voxel and outputs the results,
-#     in voxel order and as big-endian eight-byte doubles, to the standard output.
-#     The program outputs eight values in each voxel:
-#     [exit code, ln(S(0)), D_xx, D_xy, D_xz, D_yy, D_yz, D_zz].
-#     An exit code of zero indicates no problems.
-#     For a list of other exit codes, see modelfit(1).
-#     The entry S(0) is an estimate of the signal at q=0.
-# 
-#     Example
-#     -------
-#     >>> import nipype.interfaces.camino as cmon
-#     >>> fit = cmon.DTIFit()
-#     >>> fit.inputs.scheme_file = 'A.scheme'
-#     >>> fit.inputs.in_file = 'tensor_fitted_data.Bdouble'
-#     >>> fit.run()          # doctest: +SKIP
-# 
-#     
-task_name: DTIFit
-nipype_name: DTIFit
-nipype_module: nipype.interfaces.camino.dti
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_file: generic/file
-    # type=file|default=<undefined>: voxel-order data filename
-    bgmask: generic/file
-    # type=file|default=<undefined>: Provides the name of a file containing a background mask computed using, for example, FSL bet2 program. The mask file contains zero in background voxels and non-zero in foreground.
-    scheme_file: generic/file
-    # type=file|default=<undefined>: Camino scheme file (b values / vectors, see camino.fsl2scheme)
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    tensor_fitted: generic/file
-    # type=file: path/name of 4D volume in voxel order
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    out_file: out_file
-    # type=file|default=<undefined>: 
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: voxel-order data filename
-    bgmask:
-    # type=file|default=<undefined>: Provides the name of a file containing a background mask computed using, for example, FSL bet2 program. The mask file contains zero in background voxels and non-zero in foreground.
-    scheme_file:
-    # type=file|default=<undefined>: Camino scheme file (b values / vectors, see camino.fsl2scheme)
-    non_linear:
-    # type=bool|default=False: Use non-linear fitting instead of the default linear regression to the log measurements. 
-    out_file:
-    # type=file|default=<undefined>: 
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-camino/dtlut_gen.yaml b/example-specs/task/nipype_internal/pydra-camino/dtlut_gen.yaml
deleted file mode 100644
index 85f8c91b..00000000
--- a/example-specs/task/nipype_internal/pydra-camino/dtlut_gen.yaml
+++ /dev/null
@@ -1,118 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.camino.dti.DTLUTGen' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Calibrates the PDFs for PICo probabilistic tractography.
-# 
-#     This program needs to be run once for every acquisition scheme.
-#     It outputs a lookup table that is used by the dtpicoparams program to find PICo PDF
-#     parameters for an image.
-#     The default single tensor LUT contains parameters of the Bingham distribution and is
-#     generated by supplying a scheme file and an estimated signal to noise in white matter
-#     regions of the (q=0) image.
-#     The default inversion is linear (inversion index 1).
-# 
-#     Advanced users can control several options, including the extent and resolution of the LUT,
-#     the inversion index, and the type of PDF. See dtlutgen(1) for details.
-# 
-#     Example
-#     -------
-#     >>> import nipype.interfaces.camino as cmon
-#     >>> dtl = cmon.DTLUTGen()
-#     >>> dtl.inputs.snr = 16
-#     >>> dtl.inputs.scheme_file = 'A.scheme'
-#     >>> dtl.run()          # doctest: +SKIP
-# 
-#     
-task_name: DTLUTGen
-nipype_name: DTLUTGen
-nipype_module: nipype.interfaces.camino.dti
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    scheme_file: generic/file
-    # type=file|default=<undefined>: The scheme file of the images to be processed using this LUT.
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    dtLUT: generic/file
-    # type=file: Lookup Table
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    out_file: out_file
-    # type=file|default=<undefined>: 
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    lrange:
-    # type=list|default=[]: Index to one-tensor LUTs. This is the ratio L1/L3 and L2 / L3.The LUT is square, with half the values calculated (because L2 / L3 cannot be less than L1 / L3 by definition).The minimum must be >= 1. For comparison, a ratio L1 / L3 = 10 with L2 / L3 = 1 corresponds to an FA of 0.891, and L1 / L3 = 15 with L2 / L3 = 1 corresponds to an FA of 0.929. The default range is 1 to 10.
-    frange:
-    # type=list|default=[]: Index to two-tensor LUTs. This is the fractional anisotropy of the two tensors. The default is 0.3 to 0.94
-    step:
-    # type=float|default=0.0: Distance between points in the LUT.For example, if lrange is 1 to 10 and the step is 0.1, LUT entries will be computed at L1 / L3 = 1, 1.1, 1.2 ... 10.0 and at L2 / L3 = 1.0, 1.1 ... L1 / L3.For single tensor LUTs, the default step is 0.2, for two-tensor LUTs it is 0.02.
-    samples:
-    # type=int|default=0: The number of synthetic measurements to generate at each point in the LUT. The default is 2000.
-    snr:
-    # type=float|default=0.0: The signal to noise ratio of the unweighted (q = 0) measurements.This should match the SNR (in white matter) of the images that the LUTs are used with.
-    bingham:
-    # type=bool|default=False: Compute a LUT for the Bingham PDF. This is the default.
-    acg:
-    # type=bool|default=False: Compute a LUT for the ACG PDF.
-    watson:
-    # type=bool|default=False: Compute a LUT for the Watson PDF.
-    inversion:
-    # type=int|default=0: Index of the inversion to use. The default is 1 (linear single tensor inversion).
-    trace:
-    # type=float|default=0.0: Trace of the diffusion tensor(s) used in the test function in the LUT generation. The default is 2100E-12 m^2 s^-1.
-    scheme_file:
-    # type=file|default=<undefined>: The scheme file of the images to be processed using this LUT.
-    out_file:
-    # type=file|default=<undefined>: 
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-camino/dtlut_gen_callables.py b/example-specs/task/nipype_internal/pydra-camino/dtlut_gen_callables.py
deleted file mode 100644
index 287642b4..00000000
--- a/example-specs/task/nipype_internal/pydra-camino/dtlut_gen_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in DTLUTGen.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-camino/fsl2_scheme.yaml b/example-specs/task/nipype_internal/pydra-camino/fsl2_scheme.yaml
deleted file mode 100644
index 37111f86..00000000
--- a/example-specs/task/nipype_internal/pydra-camino/fsl2_scheme.yaml
+++ /dev/null
@@ -1,108 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.camino.convert.FSL2Scheme' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Converts b-vectors and b-values from FSL format to a Camino scheme file.
-# 
-#     Examples
-#     --------
-# 
-#     >>> import nipype.interfaces.camino as cmon
-#     >>> makescheme = cmon.FSL2Scheme()
-#     >>> makescheme.inputs.bvec_file = 'bvecs'
-#     >>> makescheme.inputs.bvec_file = 'bvals'
-#     >>> makescheme.run()          # doctest: +SKIP
-# 
-#     
-task_name: FSL2Scheme
-nipype_name: FSL2Scheme
-nipype_module: nipype.interfaces.camino.convert
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    bvec_file: generic/file
-    # type=file|default=<undefined>: b vector file
-    bval_file: generic/file
-    # type=file|default=<undefined>: b value file
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    scheme: generic/file
-    # type=file: Scheme file
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    out_file: out_file
-    # type=file|default=<undefined>: 
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    bvec_file:
-    # type=file|default=<undefined>: b vector file
-    bval_file:
-    # type=file|default=<undefined>: b value file
-    numscans:
-    # type=int|default=0: Output all measurements numerous (n) times, used when combining multiple scans from the same imaging session.
-    interleave:
-    # type=bool|default=False: Interleave repeated scans. Only used with -numscans.
-    bscale:
-    # type=float|default=0.0: Scaling factor to convert the b-values into different units. Default is 10^6.
-    diffusiontime:
-    # type=float|default=0.0: Diffusion time
-    flipx:
-    # type=bool|default=False: Negate the x component of all the vectors.
-    flipy:
-    # type=bool|default=False: Negate the y component of all the vectors.
-    flipz:
-    # type=bool|default=False: Negate the z component of all the vectors.
-    usegradmod:
-    # type=bool|default=False: Use the gradient magnitude to scale b. This option has no effect if your gradient directions have unit magnitude.
-    out_file:
-    # type=file|default=<undefined>: 
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-camino/fsl2_scheme_callables.py b/example-specs/task/nipype_internal/pydra-camino/fsl2_scheme_callables.py
deleted file mode 100644
index d2108215..00000000
--- a/example-specs/task/nipype_internal/pydra-camino/fsl2_scheme_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in FSL2Scheme.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-camino/image_2_voxel.yaml b/example-specs/task/nipype_internal/pydra-camino/image_2_voxel.yaml
deleted file mode 100644
index 51972352..00000000
--- a/example-specs/task/nipype_internal/pydra-camino/image_2_voxel.yaml
+++ /dev/null
@@ -1,92 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.camino.convert.Image2Voxel' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Converts Analyze / NIFTI / MHA files to voxel order.
-# 
-#     Converts scanner-order data in a supported image format to voxel-order data.
-#     Either takes a 4D file (all measurements in single image)
-#     or a list of 3D images.
-# 
-#     Examples
-#     --------
-# 
-#     >>> import nipype.interfaces.camino as cmon
-#     >>> img2vox = cmon.Image2Voxel()
-#     >>> img2vox.inputs.in_file = '4d_dwi.nii'
-#     >>> img2vox.run()          # doctest: +SKIP
-#     
-task_name: Image2Voxel
-nipype_name: Image2Voxel
-nipype_module: nipype.interfaces.camino.convert
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_file: generic/file
-    # type=file|default=<undefined>: 4d image file
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    voxel_order: generic/file
-    # type=file: path/name of 4D volume in voxel order
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    out_file: out_file
-    # type=file|default=<undefined>: 
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: 4d image file
-    out_type:
-    # type=enum|default='float'|allowed['char','double','float','int','long','short']: "i.e. Bfloat". Can be "char", "short", "int", "long", "float" or "double"
-    out_file:
-    # type=file|default=<undefined>: 
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-camino/image_2_voxel_callables.py b/example-specs/task/nipype_internal/pydra-camino/image_2_voxel_callables.py
deleted file mode 100644
index 9c194f09..00000000
--- a/example-specs/task/nipype_internal/pydra-camino/image_2_voxel_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in Image2Voxel.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-camino/image_stats.yaml b/example-specs/task/nipype_internal/pydra-camino/image_stats.yaml
deleted file mode 100644
index ee087531..00000000
--- a/example-specs/task/nipype_internal/pydra-camino/image_stats.yaml
+++ /dev/null
@@ -1,93 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.camino.utils.ImageStats' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     This program computes voxelwise statistics on a series of 3D images. The images
-#     must be in the same space; the operation is performed voxelwise and one output
-#     is produced per voxel.
-# 
-#     Examples
-#     --------
-# 
-#     >>> import nipype.interfaces.camino as cam
-#     >>> imstats = cam.ImageStats()
-#     >>> imstats.inputs.in_files = ['im1.nii','im2.nii','im3.nii']
-#     >>> imstats.inputs.stat = 'max'
-#     >>> imstats.run()          # doctest: +SKIP
-#     
-task_name: ImageStats
-nipype_name: ImageStats
-nipype_module: nipype.interfaces.camino.utils
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_files: generic/file+list-of
-    # type=inputmultiobject|default=[]: List of images to process. They must be in the same space and have the same dimensions.
-    output_root: generic/file
-    # type=file|default=<undefined>: Filename root prepended onto the names of the output  files. The extension will be determined from the input.
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    out_file: generic/file
-    # type=file: Path of the file computed with the statistic chosen
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_files:
-    # type=inputmultiobject|default=[]: List of images to process. They must be in the same space and have the same dimensions.
-    stat:
-    # type=enum|default='min'|allowed['max','mean','median','min','std','sum','var']: The statistic to compute.
-    out_type:
-    # type=enum|default='float'|allowed['char','double','float','int','long','short']: A Camino data type string, default is "float". Type must be signed.
-    output_root:
-    # type=file|default=<undefined>: Filename root prepended onto the names of the output  files. The extension will be determined from the input.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-camino/lin_recon.yaml b/example-specs/task/nipype_internal/pydra-camino/lin_recon.yaml
deleted file mode 100644
index 15ce28cc..00000000
--- a/example-specs/task/nipype_internal/pydra-camino/lin_recon.yaml
+++ /dev/null
@@ -1,134 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.camino.odf.LinRecon' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Runs a linear transformation in each voxel.
-# 
-#     Reads  a  linear  transformation from the matrix file assuming the
-#     imaging scheme specified in the scheme file. Performs the linear
-#     transformation on the data in every voxel and outputs the result to
-#     the standard output. The output in every voxel is actually: ::
-# 
-#         [exit code, ln(S(0)), p1, ..., pR]
-# 
-#     where p1, ..., pR are the parameters of the reconstruction.
-#     Possible exit codes are:
-# 
-#         - 0. No problems.
-#         - 6. Bad data replaced by substitution of zero.
-# 
-#     The matrix must be R by N+M where N+M is the number of measurements
-#     and R is the number of parameters of the reconstruction. The matrix
-#     file contains binary double-precision floats. The matrix elements
-#     are stored row by row.
-# 
-#     Example
-#     -------
-#     First run QBallMX and create a linear transform matrix using
-#     Spherical Harmonics (sh).
-# 
-#     >>> import nipype.interfaces.camino as cam
-#     >>> qballmx = cam.QBallMX()
-#     >>> qballmx.inputs.scheme_file = 'A.scheme'
-#     >>> qballmx.inputs.basistype = 'sh'
-#     >>> qballmx.inputs.order = 4
-#     >>> qballmx.run()    # doctest: +SKIP
-# 
-#     Then run it over each voxel using LinRecon
-# 
-#     >>> qballcoeffs = cam.LinRecon()
-#     >>> qballcoeffs.inputs.in_file = 'SubjectA.Bfloat'
-#     >>> qballcoeffs.inputs.scheme_file = 'A.scheme'
-#     >>> qballcoeffs.inputs.qball_mat = 'A_qmat.Bdouble'
-#     >>> qballcoeffs.inputs.normalize = True
-#     >>> qballcoeffs.run() # doctest: +SKIP
-# 
-#     
-task_name: LinRecon
-nipype_name: LinRecon
-nipype_module: nipype.interfaces.camino.odf
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_file: generic/file
-    # type=file|default=<undefined>: voxel-order data filename
-    scheme_file: generic/file
-    # type=file|default=<undefined>: Specifies the scheme file for the diffusion MRI data
-    qball_mat: generic/file
-    # type=file|default=<undefined>: Linear transformation matrix.
-    bgmask: generic/file
-    # type=file|default=<undefined>: background mask
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    recon_data: generic/file
-    # type=file: Transformed data
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    out_file: out_file
-    # type=file|default=<undefined>: 
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: voxel-order data filename
-    scheme_file:
-    # type=file|default=<undefined>: Specifies the scheme file for the diffusion MRI data
-    qball_mat:
-    # type=file|default=<undefined>: Linear transformation matrix.
-    normalize:
-    # type=bool|default=False: Normalize the measurements and discard the zero measurements before the linear transform.
-    log:
-    # type=bool|default=False: Transform the log measurements rather than the measurements themselves
-    bgmask:
-    # type=file|default=<undefined>: background mask
-    out_file:
-    # type=file|default=<undefined>: 
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-camino/lin_recon_callables.py b/example-specs/task/nipype_internal/pydra-camino/lin_recon_callables.py
deleted file mode 100644
index e9bd573c..00000000
--- a/example-specs/task/nipype_internal/pydra-camino/lin_recon_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in LinRecon.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-camino/mesd.yaml b/example-specs/task/nipype_internal/pydra-camino/mesd.yaml
deleted file mode 100644
index f87b74a4..00000000
--- a/example-specs/task/nipype_internal/pydra-camino/mesd.yaml
+++ /dev/null
@@ -1,170 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.camino.odf.MESD' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     MESD is a general program for maximum entropy spherical deconvolution.
-#     It also runs PASMRI, which is a special case of spherical deconvolution.
-#     The input data must be in voxel order.
-# 
-#     The format of the output in each voxel is:
-#     { exitcode, ln(A^star(0)), lambda_0, lambda_1, ..., lambda_N }
-# 
-#     The  exitcode  contains  the  results of three tests. The first test thresholds
-#     the maximum relative error between the numerical integrals computed at con-
-#     vergence and those computed using a larger test point set; if the error is
-#     greater than a threshold the exitcode is increased from zero to one as a
-#     warning; if it is greater than a larger threshold the exitcode is increased to
-#     two to suggest failure. The  second  test  thresholds  the predicted  error in
-#     numerical integrals computed using the test point set; if the predicted error
-#     is greater than a threshold the exitcode is increased by 10. The third test
-#     thresholds the RMS error between the measurements and their predictions from
-#     the fitted deconvolution; if the errors are greater than a threshold, the exit
-#     code is increased by 100. An exitcode of 112 means that all three tests were
-#     failed and the result is likely to be unreliable.  If all is well the exitcode
-#     is zero. Results are often still reliable even if one or two of the tests are
-#     failed.
-# 
-#     Other possible exitcodes are:
-# 
-#         - 5 - The optimization failed to converge
-#         - -1 - Background
-#         - -100 - Something wrong in the MRI data, e.g. negative or zero measurements,
-#           so that the optimization could not run.
-# 
-#     The  standard  MESD  implementation  is computationally demanding, particularly
-#     as the number of measurements increases (computation is approximately O(N^2),
-#     where N is the number of measurements). There are two ways to obtain significant
-#     computational speed-up:
-# 
-#     i) Turn off error checks and use a small point set for computing numerical
-#     integrals in the algorithm by adding the flag -fastmesd. Sakaie CDMRI 2008
-#     shows that using the smallest point set  (-basepointset  0)  with  no
-#     error  checks  usually  has only a minor effect on the output of the algorithm,
-#     but provides a major reduction in computation time. You can increase the point
-#     set size using -basepointset with an argument higher than 0, which may produce
-#     better results in some voxels, but will increase computation time, which
-#     approximately doubles every time the point set index increases by 1.
-# 
-#     ii) Reduce the complexity of the maximum entropy encoding using -mepointset <X>.
-#     By default <X> = N, the number of measurements, and is the number of parameters
-#     in the max.  ent. representation of the  output  function, ie  the  number of
-#     lambda parameters, as described in Jansons and Alexander Inverse Problems 2003.
-#     However, we can represent the function using less components and <X> here
-#     specifies the number of lambda parameters. To obtain speed-up, set <X>
-#     < N; complexity become O(<X>^2) rather than O(N^2). Note that <X> must be chosen
-#     so that the camino/PointSets directory contains a point set  with  that  number
-#     of  elements.  When  -mepointset decreases, the  numerical  integration checks
-#     make less and less of a difference and smaller point sets for numerical
-#     integration (see -basepointset) become adequate. So when <X> is low -fastmesd is
-#     worth using to get even more speed-up.
-# 
-#     The choice of <X> is a parameter of the technique. Too low and you lose angular
-#     resoloution; too high and you see no computational benefit and may even suffer
-#     from overfitting. Empirically, we  have  found  that  <X>=16 often  gives  good
-#     results and good speed up, but it is worth trying a few values a comparing
-#     performance. The reduced encoding is described in the following ISMRM abstract:
-#     Sweet and Alexander "Reduced Encoding Persistent Angular Structure" 572 ISMRM 2010.
-# 
-#     Example
-#     -------
-#     Run MESD on every voxel of the data file SubjectA.Bfloat using the PASMRI kernel.
-# 
-#     >>> import nipype.interfaces.camino as cam
-#     >>> mesd = cam.MESD()
-#     >>> mesd.inputs.in_file = 'SubjectA.Bfloat'
-#     >>> mesd.inputs.scheme_file = 'A.scheme'
-#     >>> mesd.inputs.inverter = 'PAS'
-#     >>> mesd.inputs.inverter_param = 1.4
-#     >>> mesd.run()    # doctest: +SKIP
-# 
-#     
-task_name: MESD
-nipype_name: MESD
-nipype_module: nipype.interfaces.camino.odf
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_file: generic/file
-    # type=file|default=<undefined>: voxel-order data filename
-    scheme_file: generic/file
-    # type=file|default=<undefined>: Specifies the scheme file for the diffusion MRI data
-    bgmask: generic/file
-    # type=file|default=<undefined>: background mask
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    mesd_data: generic/file
-    # type=file: MESD data
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    out_file: out_file
-    # type=file|default=<undefined>: 
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: voxel-order data filename
-    inverter:
-    # type=enum|default='SPIKE'|allowed['PAS','SPIKE']:  The inversion index specifies the type of inversion to perform on the data. The currently available choices are:    +----------------+---------------------------------------------+   | Inverter name  | Inverter parameters                         |   +================+=============================================+   | SPIKE          | bd (b-value x diffusivity along the fibre.) |   +----------------+---------------------------------------------+   | PAS            | r                                           |   +----------------+---------------------------------------------+  
-    inverter_param:
-    # type=float|default=0.0: Parameter associated with the inverter. Cf. inverter description formore information.
-    fastmesd:
-    # type=bool|default=False: Turns off numerical integration checks and fixes the integration point set size at that ofthe index specified by -basepointset..
-    mepointset:
-    # type=int|default=0: Use a set of directions other than those in the scheme file for the deconvolution kernel.The number refers to the number of directions on the unit sphere. For example, "-mepointset 54" uses the directions in "camino/PointSets/Elec054.txt".
-    scheme_file:
-    # type=file|default=<undefined>: Specifies the scheme file for the diffusion MRI data
-    bgmask:
-    # type=file|default=<undefined>: background mask
-    inputdatatype:
-    # type=enum|default='float'|allowed['char','double','float','int','long','short']: Specifies the data type of the input file: "char", "short", "int", "long","float" or "double". The input file must have BIG-ENDIAN ordering.By default, the input type is "float".
-    out_file:
-    # type=file|default=<undefined>: 
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-camino/mesd_callables.py b/example-specs/task/nipype_internal/pydra-camino/mesd_callables.py
deleted file mode 100644
index 7576051d..00000000
--- a/example-specs/task/nipype_internal/pydra-camino/mesd_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in MESD.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-camino/model_fit.yaml b/example-specs/task/nipype_internal/pydra-camino/model_fit.yaml
deleted file mode 100644
index 8e5de115..00000000
--- a/example-specs/task/nipype_internal/pydra-camino/model_fit.yaml
+++ /dev/null
@@ -1,134 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.camino.dti.ModelFit' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Fits models of the spin-displacement density to diffusion MRI measurements.
-# 
-#     This is an interface to various model fitting routines for diffusion MRI data that
-#     fit models of the spin-displacement density function. In particular, it will fit the
-#     diffusion tensor to a set of measurements as well as various other models including
-#     two or three-tensor models. The program can read input data from a file or can
-#     generate synthetic data using various test functions for testing and simulations.
-# 
-#     Example
-#     -------
-#     >>> import nipype.interfaces.camino as cmon
-#     >>> fit = cmon.ModelFit()
-#     >>> fit.model = 'dt'
-#     >>> fit.inputs.scheme_file = 'A.scheme'
-#     >>> fit.inputs.in_file = 'tensor_fitted_data.Bdouble'
-#     >>> fit.run()          # doctest: +SKIP
-# 
-#     
-task_name: ModelFit
-nipype_name: ModelFit
-nipype_module: nipype.interfaces.camino.dti
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_file: generic/file
-    # type=file|default=<undefined>: voxel-order data filename
-    scheme_file: generic/file
-    # type=file|default=<undefined>: Camino scheme file (b values / vectors, see camino.fsl2scheme)
-    outputfile: generic/file
-    # type=file|default=<undefined>: Filename of the output file.
-    outlier: generic/file
-    # type=file|default=<undefined>: Specifies the name of the file to contain the outlier map generated by the RESTORE algorithm.
-    noisemap: generic/file
-    # type=file|default=<undefined>: Specifies the name of the file to contain the estimated noise variance on the diffusion-weighted signal, generated by a weighted tensor fit. The data type of this file is big-endian double.
-    residualmap: generic/file
-    # type=file|default=<undefined>: Specifies the name of the file to contain the weighted residual errors after computing a weighted linear tensor fit. One value is produced per measurement, in voxel order. The data type of this file is big-endian double. Images of the residuals for each measurement can be extracted with shredder.
-    bgmask: generic/file
-    # type=file|default=<undefined>: Provides the name of a file containing a background mask computed using, for example, FSL's bet2 program. The mask file contains zero in background voxels and non-zero in foreground.
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    fitted_data: generic/file
-    # type=file: output file of 4D volume in voxel order
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    out_file: out_file
-    # type=file|default=<undefined>: 
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    model:
-    # type=enum|default='dt'|allowed['adc','algdt','ball_stick','cylcyl adc','cylcyl algdt','cylcyl ball_stick','cylcyl dt','cylcyl ldt_wtd','cylcyl nldt','cylcyl nldt_pos','cylcyl restore','cylcyl_eq adc','cylcyl_eq algdt','cylcyl_eq ball_stick','cylcyl_eq dt','cylcyl_eq ldt_wtd','cylcyl_eq nldt','cylcyl_eq nldt_pos','cylcyl_eq restore','cylcylcyl adc','cylcylcyl algdt','cylcylcyl ball_stick','cylcylcyl dt','cylcylcyl ldt_wtd','cylcylcyl nldt','cylcylcyl nldt_pos','cylcylcyl restore','cylcylcyl_eq adc','cylcylcyl_eq algdt','cylcylcyl_eq ball_stick','cylcylcyl_eq dt','cylcylcyl_eq ldt_wtd','cylcylcyl_eq nldt','cylcylcyl_eq nldt_pos','cylcylcyl_eq restore','dt','ldt_wtd','nldt','nldt_pos','poscyl adc','poscyl algdt','poscyl ball_stick','poscyl dt','poscyl ldt_wtd','poscyl nldt','poscyl nldt_pos','poscyl restore','poscyl_eq adc','poscyl_eq algdt','poscyl_eq ball_stick','poscyl_eq dt','poscyl_eq ldt_wtd','poscyl_eq nldt','poscyl_eq nldt_pos','poscyl_eq restore','poscylcyl adc','poscylcyl algdt','poscylcyl ball_stick','poscylcyl dt','poscylcyl ldt_wtd','poscylcyl nldt','poscylcyl nldt_pos','poscylcyl restore','poscylcyl_eq adc','poscylcyl_eq algdt','poscylcyl_eq ball_stick','poscylcyl_eq dt','poscylcyl_eq ldt_wtd','poscylcyl_eq nldt','poscylcyl_eq nldt_pos','poscylcyl_eq restore','pospos adc','pospos algdt','pospos ball_stick','pospos dt','pospos ldt_wtd','pospos nldt','pospos nldt_pos','pospos restore','pospos_eq adc','pospos_eq algdt','pospos_eq ball_stick','pospos_eq dt','pospos_eq ldt_wtd','pospos_eq nldt','pospos_eq nldt_pos','pospos_eq restore','posposcyl adc','posposcyl algdt','posposcyl ball_stick','posposcyl dt','posposcyl ldt_wtd','posposcyl nldt','posposcyl nldt_pos','posposcyl restore','posposcyl_eq adc','posposcyl_eq algdt','posposcyl_eq ball_stick','posposcyl_eq dt','posposcyl_eq ldt_wtd','posposcyl_eq nldt','posposcyl_eq nldt_pos','posposcyl_eq restore','pospospos adc','pospospos algdt','pospospos ball_stick','pospospos dt','pospospos ldt_wtd','pospospos nldt','pospospos nldt_pos','pospospos restore','pospospos_eq adc','pospospos_eq algdt','pospospos_eq ball_stick','pospospos_eq dt','pospospos_eq ldt_wtd','pospospos_eq nldt','pospospos_eq nldt_pos','pospospos_eq restore','restore']: Specifies the model to be fit to the data.
-    in_file:
-    # type=file|default=<undefined>: voxel-order data filename
-    inputdatatype:
-    # type=enum|default='float'|allowed['char','double','float','int','long','short']: Specifies the data type of the input file. The input file must have BIG-ENDIAN ordering. By default, the input type is ``float``.
-    scheme_file:
-    # type=file|default=<undefined>: Camino scheme file (b values / vectors, see camino.fsl2scheme)
-    outputfile:
-    # type=file|default=<undefined>: Filename of the output file.
-    outlier:
-    # type=file|default=<undefined>: Specifies the name of the file to contain the outlier map generated by the RESTORE algorithm.
-    noisemap:
-    # type=file|default=<undefined>: Specifies the name of the file to contain the estimated noise variance on the diffusion-weighted signal, generated by a weighted tensor fit. The data type of this file is big-endian double.
-    residualmap:
-    # type=file|default=<undefined>: Specifies the name of the file to contain the weighted residual errors after computing a weighted linear tensor fit. One value is produced per measurement, in voxel order. The data type of this file is big-endian double. Images of the residuals for each measurement can be extracted with shredder.
-    sigma:
-    # type=float|default=0.0: Specifies the standard deviation of the noise in the data. Required by the RESTORE algorithm.
-    bgthresh:
-    # type=float|default=0.0: Sets a threshold on the average q=0 measurement to separate foreground and background. The program does not process background voxels, but outputs the same number of values in background voxels and foreground voxels. Each value is zero in background voxels apart from the exit code which is -1.
-    bgmask:
-    # type=file|default=<undefined>: Provides the name of a file containing a background mask computed using, for example, FSL's bet2 program. The mask file contains zero in background voxels and non-zero in foreground.
-    cfthresh:
-    # type=float|default=0.0: Sets a threshold on the average q=0 measurement to determine which voxels are CSF. This program does not treat CSF voxels any different to other voxels.
-    fixedmodq:
-    # type=list|default=[]: Specifies <M> <N> <Q> <tau> a spherical acquisition scheme with M measurements with q=0 and N measurements with :math:`|q|=Q` and diffusion time tau. The N measurements with :math:`|q|=Q` have unique directions. The program reads in the directions from the files in directory PointSets.
-    fixedbvalue:
-    # type=list|default=[]: As above, but specifies <M> <N> <b>. The resulting scheme is the same whether you specify b directly or indirectly using -fixedmodq.
-    tau:
-    # type=float|default=0.0: Sets the diffusion time separately. This overrides the diffusion time specified in a scheme file or by a scheme index for both the acquisition scheme and in the data synthesis.
-    out_file:
-    # type=file|default=<undefined>: 
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-camino/model_fit_callables.py b/example-specs/task/nipype_internal/pydra-camino/model_fit_callables.py
deleted file mode 100644
index 947d6446..00000000
--- a/example-specs/task/nipype_internal/pydra-camino/model_fit_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in ModelFit.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-camino/n_if_tidt2_camino.yaml b/example-specs/task/nipype_internal/pydra-camino/n_if_tidt2_camino.yaml
deleted file mode 100644
index 6d2cb784..00000000
--- a/example-specs/task/nipype_internal/pydra-camino/n_if_tidt2_camino.yaml
+++ /dev/null
@@ -1,116 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.camino.convert.NIfTIDT2Camino' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Converts NIFTI-1 diffusion tensors to Camino format. The program reads the
-#     NIFTI header but does not apply any spatial transformations to the data. The
-#     NIFTI intensity scaling parameters are applied.
-# 
-#     The output is the tensors in Camino voxel ordering: [exit, ln(S0), dxx, dxy,
-#     dxz, dyy, dyz, dzz].
-# 
-#     The exit code is set to 0 unless a background mask is supplied, in which case
-#     the code is 0 in brain voxels and -1 in background voxels.
-# 
-#     The value of ln(S0) in the output is taken from a file if one is supplied,
-#     otherwise it is set to 0.
-# 
-#     NOTE FOR FSL USERS - FSL's dtifit can output NIFTI tensors, but they are not
-#     stored in the usual way (which is using NIFTI_INTENT_SYMMATRIX). FSL's
-#     tensors follow the ITK / VTK "upper-triangular" convention, so you will need
-#     to use the -uppertriangular option to convert these correctly.
-# 
-#     
-task_name: NIfTIDT2Camino
-nipype_name: NIfTIDT2Camino
-nipype_module: nipype.interfaces.camino.convert
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_file: generic/file
-    # type=file|default=<undefined>: A NIFTI-1 dataset containing diffusion tensors. The tensors are assumed to be in lower-triangular order as specified by the NIFTI standard for the storage of symmetric matrices. This file should be either a .nii or a .hdr file.
-    s0_file: generic/file
-    # type=file|default=<undefined>: File containing the unweighted signal for each voxel, may be a raw binary file (specify type with -inputdatatype) or a supported image file.
-    lns0_file: generic/file
-    # type=file|default=<undefined>: File containing the log of the unweighted signal for each voxel, may be a raw binary file (specify type with -inputdatatype) or a supported image file.
-    bgmask: generic/file
-    # type=file|default=<undefined>: Binary valued brain / background segmentation, may be a raw binary file (specify type with -maskdatatype) or a supported image file.
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    out_file: generic/file
-    # type=file: diffusion tensors data in Camino format
-    # type=file|default=<undefined>: 
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    out_file: out_file
-    # type=file: diffusion tensors data in Camino format
-    # type=file|default=<undefined>: 
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: A NIFTI-1 dataset containing diffusion tensors. The tensors are assumed to be in lower-triangular order as specified by the NIFTI standard for the storage of symmetric matrices. This file should be either a .nii or a .hdr file.
-    s0_file:
-    # type=file|default=<undefined>: File containing the unweighted signal for each voxel, may be a raw binary file (specify type with -inputdatatype) or a supported image file.
-    lns0_file:
-    # type=file|default=<undefined>: File containing the log of the unweighted signal for each voxel, may be a raw binary file (specify type with -inputdatatype) or a supported image file.
-    bgmask:
-    # type=file|default=<undefined>: Binary valued brain / background segmentation, may be a raw binary file (specify type with -maskdatatype) or a supported image file.
-    scaleslope:
-    # type=float|default=0.0: A value v in the diffusion tensor is scaled to v * s + i. This is applied after any scaling specified by the input image. Default is 1.0.
-    scaleinter:
-    # type=float|default=0.0: A value v in the diffusion tensor is scaled to v * s + i. This is applied after any scaling specified by the input image. Default is 0.0.
-    uppertriangular:
-    # type=bool|default=False: Specifies input in upper-triangular (VTK style) order.
-    out_file:
-    # type=file: diffusion tensors data in Camino format
-    # type=file|default=<undefined>: 
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-camino/n_if_tidt2_camino_callables.py b/example-specs/task/nipype_internal/pydra-camino/n_if_tidt2_camino_callables.py
deleted file mode 100644
index 891d1a1f..00000000
--- a/example-specs/task/nipype_internal/pydra-camino/n_if_tidt2_camino_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in NIfTIDT2Camino.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-camino/pico_pd_fs.yaml b/example-specs/task/nipype_internal/pydra-camino/pico_pd_fs.yaml
deleted file mode 100644
index 093d2b69..00000000
--- a/example-specs/task/nipype_internal/pydra-camino/pico_pd_fs.yaml
+++ /dev/null
@@ -1,102 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.camino.dti.PicoPDFs' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Constructs a spherical PDF in each voxel for probabilistic tractography.
-# 
-#     Example
-#     -------
-#     >>> import nipype.interfaces.camino as cmon
-#     >>> pdf = cmon.PicoPDFs()
-#     >>> pdf.inputs.inputmodel = 'dt'
-#     >>> pdf.inputs.luts = ['lut_file']
-#     >>> pdf.inputs.in_file = 'voxel-order_data.Bfloat'
-#     >>> pdf.run()          # doctest: +SKIP
-# 
-#     
-task_name: PicoPDFs
-nipype_name: PicoPDFs
-nipype_module: nipype.interfaces.camino.dti
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_file: generic/file
-    # type=file|default=<undefined>: voxel-order data filename
-    luts: generic/file+list-of
-    # type=inputmultiobject|default=[]: Files containing the lookup tables.For tensor data, one lut must be specified for each type of inversion used in the image (one-tensor, two-tensor, three-tensor).For pds, the number of LUTs must match -numpds (it is acceptable to use the same LUT several times - see example, above).These LUTs may be generated with dtlutgen.
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    pdfs: generic/file
-    # type=file: path/name of 4D volume in voxel order
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    out_file: out_file
-    # type=file|default=<undefined>: 
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: voxel-order data filename
-    inputmodel:
-    # type=enum|default='dt'|allowed['dt','multitensor','pds']: input model type
-    luts:
-    # type=inputmultiobject|default=[]: Files containing the lookup tables.For tensor data, one lut must be specified for each type of inversion used in the image (one-tensor, two-tensor, three-tensor).For pds, the number of LUTs must match -numpds (it is acceptable to use the same LUT several times - see example, above).These LUTs may be generated with dtlutgen.
-    pdf:
-    # type=enum|default='bingham'|allowed['acg','bingham','watson']: Specifies the PDF to use. There are three choices:    * watson - The Watson distribution. This distribution is rotationally symmetric.   * bingham - The Bingham distributionn, which allows elliptical probability density contours.   * acg - The Angular Central Gaussian distribution, which also allows elliptical probability     density contours.  
-    directmap:
-    # type=bool|default=False: Only applicable when using pds as the inputmodel. Use direct mapping between the eigenvalues and the distribution parameters instead of the log of the eigenvalues.
-    maxcomponents:
-    # type=int|default=0: The maximum number of tensor components in a voxel (default 2) for multitensor data.Currently, only the default is supported, but future releases may allow the input of three-tensor data using this option.
-    numpds:
-    # type=int|default=0: The maximum number of PDs in a voxel (default 3) for PD data.This option determines the size of the input and output voxels.This means that the data file may be large enough to accommodate three or more PDs,but does not mean that any of the voxels are classified as containing three or more PDs.
-    out_file:
-    # type=file|default=<undefined>: 
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-camino/pico_pd_fs_callables.py b/example-specs/task/nipype_internal/pydra-camino/pico_pd_fs_callables.py
deleted file mode 100644
index 7301eea5..00000000
--- a/example-specs/task/nipype_internal/pydra-camino/pico_pd_fs_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in PicoPDFs.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-camino/proc_streamlines.yaml b/example-specs/task/nipype_internal/pydra-camino/proc_streamlines.yaml
deleted file mode 100644
index 576113b7..00000000
--- a/example-specs/task/nipype_internal/pydra-camino/proc_streamlines.yaml
+++ /dev/null
@@ -1,161 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.camino.convert.ProcStreamlines' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Process streamline data
-# 
-#     This program does post-processing of streamline output from track. It can either output streamlines or connection probability maps.
-#      * http://web4.cs.ucl.ac.uk/research/medic/camino/pmwiki/pmwiki.php?n=Man.procstreamlines
-# 
-#     Examples
-#     --------
-# 
-#     >>> import nipype.interfaces.camino as cmon
-#     >>> proc = cmon.ProcStreamlines()
-#     >>> proc.inputs.in_file = 'tract_data.Bfloat'
-#     >>> proc.run()          # doctest: +SKIP
-#     
-task_name: ProcStreamlines
-nipype_name: ProcStreamlines
-nipype_module: nipype.interfaces.camino.convert
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_file: generic/file
-    # type=file|default=<undefined>: data file
-    seedfile: generic/file
-    # type=file|default=<undefined>: Image Containing Seed Points
-    targetfile: generic/file
-    # type=file|default=<undefined>: Image containing target volumes.
-    waypointfile: generic/file
-    # type=file|default=<undefined>: Image containing waypoints. Waypoints are defined as regions of the image with the same intensity, where 0 is background and any value > 0 is a waypoint.
-    exclusionfile: generic/file
-    # type=file|default=<undefined>: Image containing exclusion ROIs. This should be an Analyze 7.5 header / image file.hdr and file.img.
-    endpointfile: generic/file
-    # type=file|default=<undefined>: Image containing endpoint ROIs. This should be an Analyze 7.5 header / image file.hdr and file.img.
-    outputroot: generic/file
-    # type=file|default=<undefined>: Prepended onto all output file names.
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    proc: generic/file
-    # type=file: Processed Streamlines
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    out_file: out_file
-    # type=file|default=<undefined>: 
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputmodel:
-    # type=enum|default='raw'|allowed['raw','voxels']: input model type (raw or voxels)
-    in_file:
-    # type=file|default=<undefined>: data file
-    maxtractpoints:
-    # type=int|default=0: maximum number of tract points
-    mintractpoints:
-    # type=int|default=0: minimum number of tract points
-    maxtractlength:
-    # type=int|default=0: maximum length of tracts
-    mintractlength:
-    # type=int|default=0: minimum length of tracts
-    datadims:
-    # type=list|default=[]: data dimensions in voxels
-    voxeldims:
-    # type=list|default=[]: voxel dimensions in mm
-    seedpointmm:
-    # type=list|default=[]: The coordinates of a single seed point for tractography in mm
-    seedpointvox:
-    # type=list|default=[]: The coordinates of a single seed point for tractography in voxels
-    seedfile:
-    # type=file|default=<undefined>: Image Containing Seed Points
-    regionindex:
-    # type=int|default=0: index of specific region to process
-    iterations:
-    # type=float|default=0.0: Number of streamlines generated for each seed. Not required when outputting streamlines, but needed to create PICo images. The default is 1 if the output is streamlines, and 5000 if the output is connection probability images.
-    targetfile:
-    # type=file|default=<undefined>: Image containing target volumes.
-    allowmultitargets:
-    # type=bool|default=False: Allows streamlines to connect to multiple target volumes.
-    directional:
-    # type=list|default=[]: Splits the streamlines at the seed point and computes separate connection probabilities for each segment. Streamline segments are grouped according to their dot product with the vector (X, Y, Z). The ideal vector will be tangential to the streamline trajectory at the seed, such that the streamline projects from the seed along (X, Y, Z) and -(X, Y, Z). However, it is only necessary for the streamline trajectory to not be orthogonal to (X, Y, Z).
-    waypointfile:
-    # type=file|default=<undefined>: Image containing waypoints. Waypoints are defined as regions of the image with the same intensity, where 0 is background and any value > 0 is a waypoint.
-    truncateloops:
-    # type=bool|default=False: This option allows streamlines to enter a waypoint exactly once. After the streamline leaves the waypoint, it is truncated upon a second entry to the waypoint.
-    discardloops:
-    # type=bool|default=False: This option allows streamlines to enter a waypoint exactly once. After the streamline leaves the waypoint, the entire streamline is discarded upon a second entry to the waypoint.
-    exclusionfile:
-    # type=file|default=<undefined>: Image containing exclusion ROIs. This should be an Analyze 7.5 header / image file.hdr and file.img.
-    truncateinexclusion:
-    # type=bool|default=False: Retain segments of a streamline before entry to an exclusion ROI.
-    endpointfile:
-    # type=file|default=<undefined>: Image containing endpoint ROIs. This should be an Analyze 7.5 header / image file.hdr and file.img.
-    resamplestepsize:
-    # type=float|default=0.0: Each point on a streamline is tested for entry into target, exclusion or waypoint volumes. If the length between points on a tract is not much smaller than the voxel length, then streamlines may pass through part of a voxel without being counted. To avoid this, the program resamples streamlines such that the step size is one tenth of the smallest voxel dimension in the image. This increases the size of raw or oogl streamline output and incurs some performance penalty. The resample resolution can be controlled with this option or disabled altogether by passing a negative step size or by passing the -noresample option.
-    noresample:
-    # type=bool|default=False: Disables resampling of input streamlines. Resampling is automatically disabled if the input model is voxels.
-    outputtracts:
-    # type=bool|default=False: Output streamlines in raw binary format.
-    outputroot:
-    # type=file|default=<undefined>: Prepended onto all output file names.
-    gzip:
-    # type=bool|default=False: save the output image in gzip format
-    outputcp:
-    # type=bool|default=False: output the connection probability map (Analyze image, float)
-    outputsc:
-    # type=bool|default=False: output the connection probability map (raw streamlines, int)
-    outputacm:
-    # type=bool|default=False: output all tracts in a single connection probability map (Analyze image)
-    outputcbs:
-    # type=bool|default=False: outputs connectivity-based segmentation maps; requires target outputfile
-    out_file:
-    # type=file|default=<undefined>: 
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-camino/proc_streamlines_callables.py b/example-specs/task/nipype_internal/pydra-camino/proc_streamlines_callables.py
deleted file mode 100644
index bbef8005..00000000
--- a/example-specs/task/nipype_internal/pydra-camino/proc_streamlines_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in ProcStreamlines.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-camino/q_ball_mx.yaml b/example-specs/task/nipype_internal/pydra-camino/q_ball_mx.yaml
deleted file mode 100644
index d4ecd9c7..00000000
--- a/example-specs/task/nipype_internal/pydra-camino/q_ball_mx.yaml
+++ /dev/null
@@ -1,122 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.camino.odf.QBallMX' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Generates a reconstruction matrix for Q-Ball. Used in LinRecon with
-#     the same scheme file to reconstruct data.
-# 
-#     Examples
-#     --------
-#     To create  a linear transform matrix using Spherical Harmonics (sh).
-# 
-#     >>> import nipype.interfaces.camino as cam
-#     >>> qballmx = cam.QBallMX()
-#     >>> qballmx.inputs.scheme_file = 'A.scheme'
-#     >>> qballmx.inputs.basistype = 'sh'
-#     >>> qballmx.inputs.order = 6
-#     >>> qballmx.run()    # doctest: +SKIP
-# 
-#     To create  a linear transform matrix using Radial Basis Functions
-#     (rbf). This command uses the default setting of rbf sigma = 0.2618
-#     (15 degrees), data smoothing sigma = 0.1309 (7.5 degrees), rbf
-#     pointset 246
-# 
-#     >>> import nipype.interfaces.camino as cam
-#     >>> qballmx = cam.QBallMX()
-#     >>> qballmx.inputs.scheme_file = 'A.scheme'
-#     >>> qballmx.run()      # doctest: +SKIP
-# 
-#     The linear transform matrix from any of these two examples can then
-#     be run over each voxel using LinRecon
-# 
-#     >>> qballcoeffs = cam.LinRecon()
-#     >>> qballcoeffs.inputs.in_file = 'SubjectA.Bfloat'
-#     >>> qballcoeffs.inputs.scheme_file = 'A.scheme'
-#     >>> qballcoeffs.inputs.qball_mat = 'A_qmat.Bdouble'
-#     >>> qballcoeffs.inputs.normalize = True
-#     >>> qballcoeffs.inputs.bgmask = 'brain_mask.nii'
-#     >>> qballcoeffs.run()     # doctest: +SKIP
-# 
-#     
-task_name: QBallMX
-nipype_name: QBallMX
-nipype_module: nipype.interfaces.camino.odf
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    scheme_file: generic/file
-    # type=file|default=<undefined>: Specifies the scheme file for the diffusion MRI data
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    qmat: generic/file
-    # type=file: Q-Ball reconstruction matrix
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    out_file: out_file
-    # type=file|default=<undefined>: 
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    basistype:
-    # type=enum|default='rbf'|allowed['rbf','sh']: Basis function type. "rbf" to use radial basis functions "sh" to use spherical harmonics
-    scheme_file:
-    # type=file|default=<undefined>: Specifies the scheme file for the diffusion MRI data
-    order:
-    # type=int|default=0: Specific to sh. Maximum order of the spherical harmonic series. Default is 4.
-    rbfpointset:
-    # type=int|default=0: Specific to rbf. Sets the number of radial basis functions to use. The value specified must be present in the Pointsets directory. The default value is 246.
-    rbfsigma:
-    # type=float|default=0.0: Specific to rbf. Sets the width of the interpolating basis functions. The default value is 0.2618 (15 degrees).
-    smoothingsigma:
-    # type=float|default=0.0: Specific to rbf. Sets the width of the smoothing basis functions. The default value is 0.1309 (7.5 degrees).
-    out_file:
-    # type=file|default=<undefined>: 
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-camino/q_ball_mx_callables.py b/example-specs/task/nipype_internal/pydra-camino/q_ball_mx_callables.py
deleted file mode 100644
index 4431d606..00000000
--- a/example-specs/task/nipype_internal/pydra-camino/q_ball_mx_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in QBallMX.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-camino/sf_peaks.yaml b/example-specs/task/nipype_internal/pydra-camino/sf_peaks.yaml
deleted file mode 100644
index 41b43c74..00000000
--- a/example-specs/task/nipype_internal/pydra-camino/sf_peaks.yaml
+++ /dev/null
@@ -1,179 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.camino.odf.SFPeaks' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Finds the peaks of spherical functions.
-# 
-#     This utility reads coefficients of the spherical functions and
-#     outputs a list of peak directions of the function. It computes the
-#     value of the function at each of a set of sample points. Then it
-#     finds local maxima by finding all points at which the function is
-#     larger than for any other point within a fixed search radius (the
-#     default  is 0.4). The utility then uses Powell's algorithm to
-#     optimize the position of each local maximum. Finally the utility
-#     removes duplicates and tiny peaks with function value smaller than
-#     some threshold, which is the mean of the function plus some number
-#     of standard deviations. By default the program checks for con-
-#     sistency with a second set of starting points, but skips the
-#     optimization step. To speed up execution, you can turn off the con-
-#     sistency check by setting the noconsistencycheck flag to True.
-# 
-#     By  default, the utility constructs a set of sample points by
-#     randomly rotating a unit icosahedron repeatedly (the default is 1000
-#     times, which produces a set of 6000 points) and concatenating the
-#     lists of vertices. The 'pointset = <index>' attribute can tell the
-#     utility to use an evenly distributed set of points (index 0 gives
-#     1082 points, 1 gives 1922, 2 gives 4322, 3 gives 8672, 4 gives 15872,
-#     5 gives 32762, 6 gives 72032), which is quicker, because you can get
-#     away with fewer points. We estimate that you can use a factor of 2.5
-#     less evenly distributed points than randomly distributed points and
-#     still expect similar performance levels.
-# 
-#     The output for each voxel is:
-# 
-#     - exitcode (inherited from the input data).
-#     - ln(A(0))
-#     - number of peaks found.
-#     - flag for consistency with a repeated run (number of directions is
-#       the same and the directions are the same to within a threshold.)
-#     - mean(f).
-#     - std(f).
-#     - direction 1 (x, y, z, f, H00, H01, H10, H11).
-#     - direction 2 (x, y, z, f, H00, H01, H10, H11).
-#     - direction 3 (x, y, z, f, H00, H01, H10, H11).
-# 
-#     H is the Hessian of f at the peak. It is the matrix: ::
-# 
-#         [d^2f/ds^2 d^2f/dsdt]
-#         [d^2f/dtds d^2f/dt^2]
-#         = [H00 H01]
-#           [H10 H11]
-# 
-#     where s and t are orthogonal coordinates local to the peak.
-# 
-#     By default the maximum number of peak directions output in each
-#     voxel is three. If less than three directions are found, zeros are
-#     output for later directions. The peaks are ordered by the value of
-#     the function at the peak. If more than the maximum number of
-#     directions are found only the strongest ones are output. The maximum
-#     number can be changed setting the 'numpds' attribute.
-# 
-#     The utility can read various kinds of spherical function, but must
-#     be told what kind of function is input using the 'inputmodel'
-#     attribute. The description of the 'inputmodel' attribute lists
-#     additional information required by SFPeaks for each input model.
-# 
-# 
-#     Example
-#     -------
-#     First run QBallMX and create a linear transform matrix using
-#     Spherical Harmonics (sh).
-# 
-#     >>> import nipype.interfaces.camino as cam
-#     >>> sf_peaks = cam.SFPeaks()
-#     >>> sf_peaks.inputs.in_file = 'A_recon_params.Bdouble'
-#     >>> sf_peaks.inputs.inputmodel = 'sh'
-#     >>> sf_peaks.inputs.order = 4
-#     >>> sf_peaks.inputs.density = 100
-#     >>> sf_peaks.inputs.searchradius = 1.0
-#     >>> sf_peaks.run()  # doctest: +SKIP
-# 
-#     
-task_name: SFPeaks
-nipype_name: SFPeaks
-nipype_module: nipype.interfaces.camino.odf
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_file: generic/file
-    # type=file|default=<undefined>: Voxel-order data of spherical functions
-    scheme_file: generic/file
-    # type=file|default=<undefined>: Specific to maxent. Specifies the scheme file.
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    peaks: generic/file
-    # type=file: Peaks of the spherical functions.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    out_file: out_file
-    # type=file|default=<undefined>: 
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: Voxel-order data of spherical functions
-    inputmodel:
-    # type=enum|default='sh'|allowed['maxent','rbf','sh']: Type of functions input via in_file. Currently supported options are:   sh - Spherical harmonic series. Specify the maximum order of the SH series        with the "order" attribute if different from the default of 4.   maxent - Maximum entropy representations output by MESD. The reconstruction            directions input to MESD must be specified. By default this is the            same set of gradient directions (excluding zero gradients) in the            scheme file, so specify the "schemefile" attribute unless the            "mepointset" attribute was set in MESD.   rbf - Sums of radial basis functions. Specify the pointset with the attribute         "rbfpointset" if different from the default. See QBallMX.
-    order:
-    # type=int|default=0: Specific to sh. Maximum order of the spherical harmonic series.
-    scheme_file:
-    # type=file|default=<undefined>: Specific to maxent. Specifies the scheme file.
-    rbfpointset:
-    # type=int|default=0: Specific to rbf. Sets the number of radial basis functions to use. The value specified must be present in the Pointsets directory. The default value is 246.
-    mepointset:
-    # type=int|default=0: Use a set of directions other than those in the scheme file for the deconvolution kernel. The number refers to the number of directions on the unit sphere. For example, "mepointset = 54" uses the directions in "camino/PointSets/Elec054.txt" Use this option only if you told MESD to use a custom set of directions with the same option. Otherwise, specify the scheme file with the "schemefile" attribute.
-    numpds:
-    # type=int|default=0: The largest number of peak directions to output in each voxel.
-    noconsistencycheck:
-    # type=bool|default=False: Turns off the consistency check. The output shows all consistencies as true.
-    searchradius:
-    # type=float|default=0.0: The search radius in the peak finding algorithm. The default is 0.4 (cf. "density")
-    density:
-    # type=int|default=0: The  number  of  randomly  rotated icosahedra to use in constructing the set of points for random sampling in the peak finding algorithm. Default is 1000, which works well for very spiky maxent functions. For other types of function, it is reasonable to set the density much lower and increase the search radius slightly, which speeds up the computation.
-    pointset:
-    # type=int|default=0: To sample using an evenly distributed set of points instead. The integer can be 0, 1, ..., 7. Index 0 gives 1082 points, 1 gives 1922, 2 gives 3002, 3 gives 4322, 4 gives 5882, 5 gives 8672, 6 gives 12002, 7 gives 15872.
-    pdthresh:
-    # type=float|default=0.0: Base threshold on the actual peak direction strength divided by the mean of the function.  The default is 1.0 (the peak must be equal or greater than the mean).
-    stdsfrommean:
-    # type=float|default=0.0: This is the number of standard deviations of the function to be added to the "pdthresh" attribute in the peak directions pruning.
-    out_file:
-    # type=file|default=<undefined>: 
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-camino/sf_peaks_callables.py b/example-specs/task/nipype_internal/pydra-camino/sf_peaks_callables.py
deleted file mode 100644
index 2f5fffd0..00000000
--- a/example-specs/task/nipype_internal/pydra-camino/sf_peaks_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in SFPeaks.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-camino/sflut_gen.yaml b/example-specs/task/nipype_internal/pydra-camino/sflut_gen.yaml
deleted file mode 100644
index b81c7d72..00000000
--- a/example-specs/task/nipype_internal/pydra-camino/sflut_gen.yaml
+++ /dev/null
@@ -1,141 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.camino.calib.SFLUTGen' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Generates PICo lookup tables (LUT) for multi-fibre methods such as
-#     PASMRI and Q-Ball.
-# 
-#     SFLUTGen creates the lookup tables for the generalized multi-fibre
-#     implementation of the PICo tractography algorithm.  The outputs of
-#     this utility are either surface or line coefficients up to a given
-#     order. The calibration can be performed for different distributions,
-#     such as the Bingham and Watson distributions.
-# 
-#     This utility uses calibration data generated from SFPICOCalibData
-#     and peak information created by SFPeaks.
-# 
-#     The utility outputs two lut's, ``*_oneFibreSurfaceCoeffs.Bdouble`` and
-#     ``*_twoFibreSurfaceCoeffs.Bdouble``. Each of these files contains big-endian doubles
-#     as standard. The format of the output is::
-# 
-#           dimensions    (1 for Watson, 2 for Bingham)
-#           order         (the order of the polynomial)
-#           coefficient_1
-#           coefficient_2
-#           ...
-#           coefficient_N
-# 
-#     In  the case of the Watson, there is a single set of coefficients,
-#     which are ordered::
-# 
-#           constant, x, x^2, ..., x^order.
-# 
-#     In the case of the Bingham, there are two sets of coefficients (one
-#     for each surface), ordered so that::
-# 
-#           for j = 1 to order
-#             for k = 1 to order
-#               coeff_i = x^j * y^k
-#           where j+k < order
-# 
-#     Example
-#     -------
-#     To create a calibration dataset using the default settings
-# 
-#     >>> import nipype.interfaces.camino as cam
-#     >>> lutgen = cam.SFLUTGen()
-#     >>> lutgen.inputs.in_file = 'QSH_peaks.Bdouble'
-#     >>> lutgen.inputs.info_file = 'PICO_calib.info'
-#     >>> lutgen.run()# doctest: +SKIP
-# 
-#     
-task_name: SFLUTGen
-nipype_name: SFLUTGen
-nipype_module: nipype.interfaces.camino.calib
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_file: generic/file
-    # type=file|default=<undefined>: Voxel-order data of the spherical functions peaks.
-    info_file: generic/file
-    # type=file|default=<undefined>: The Info file that corresponds to the calibration datafile used in the reconstruction.
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    lut_one_fibre: generic/file
-    # type=file: PICo lut for one-fibre model
-    lut_two_fibres: generic/file
-    # type=file: PICo lut for two-fibre model
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    out_file: out_file
-    # type=file|default=<undefined>: 
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: Voxel-order data of the spherical functions peaks.
-    info_file:
-    # type=file|default=<undefined>: The Info file that corresponds to the calibration datafile used in the reconstruction.
-    outputstem:
-    # type=str|default='LUT': Define the name of the generated luts.  The form of the filenames will be [outputstem]_oneFibreSurfaceCoeffs.Bdouble and [outputstem]_twoFibreSurfaceCoeffs.Bdouble
-    pdf:
-    # type=enum|default='bingham'|allowed['bingham','watson']: Sets the distribution to use for the calibration. The default is the Bingham distribution, which allows elliptical probability density contours. Currently supported options are:    * bingham -- The Bingham distribution, which allows elliptical probability     density contours.   * watson -- The Watson distribution. This distribution is rotationally symmetric.  
-    binincsize:
-    # type=int|default=0: Sets the size of the bins.  In the case of 2D histograms such as the Bingham, the bins are always square. Default is 1.
-    minvectsperbin:
-    # type=int|default=0: Specifies the minimum number of fibre-orientation estimates a bin must contain before it is used in the lut line/surface generation. Default is 50. If you get the error "no fibre-orientation estimates in histogram!", the calibration data set is too small to get enough samples in any of the  histogram  bins. You can decrease the minimum number  per  bin to get things running in quick tests, but the sta- tistics will not be reliable and for serious applications, you need  to increase the size of the calibration data set until the error goes.
-    directmap:
-    # type=bool|default=False: Use direct mapping between the eigenvalues and the distribution parameters instead of the log of the eigenvalues.
-    order:
-    # type=int|default=0: The order of the polynomial fitting the surface. Order 1 is linear. Order 2 (default) is quadratic.
-    out_file:
-    # type=file|default=<undefined>: 
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-camino/sflut_gen_callables.py b/example-specs/task/nipype_internal/pydra-camino/sflut_gen_callables.py
deleted file mode 100644
index 44c44e70..00000000
--- a/example-specs/task/nipype_internal/pydra-camino/sflut_gen_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in SFLUTGen.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-camino/sfpico_calib_data.yaml b/example-specs/task/nipype_internal/pydra-camino/sfpico_calib_data.yaml
deleted file mode 100644
index 68f0a938..00000000
--- a/example-specs/task/nipype_internal/pydra-camino/sfpico_calib_data.yaml
+++ /dev/null
@@ -1,153 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.camino.calib.SFPICOCalibData' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Generates Spherical Function PICo Calibration Data.
-# 
-#     SFPICOCalibData creates synthetic data for use with SFLUTGen. The
-#     synthetic data is generated using a mixture of gaussians, in the
-#     same way datasynth generates data.  Each voxel of data models a
-#     slightly different fibre configuration (varying FA and fibre-
-#     crossings) and undergoes a random rotation to help account for any
-#     directional bias in the chosen acquisition scheme.  A second file,
-#     which stores information about the datafile, is generated along with
-#     the datafile.
-# 
-#     Examples
-#     --------
-#     To create a calibration dataset using the default settings
-# 
-#     >>> import nipype.interfaces.camino as cam
-#     >>> calib = cam.SFPICOCalibData()
-#     >>> calib.inputs.scheme_file = 'A.scheme'
-#     >>> calib.inputs.snr = 20
-#     >>> calib.inputs.info_file = 'PICO_calib.info'
-#     >>> calib.run()   # doctest: +SKIP
-# 
-#     The default settings create a large dataset (249,231 voxels), of
-#     which 3401 voxels contain a single fibre population per voxel and
-#     the rest of the voxels contain two fibre-populations. The amount of
-#     data produced can be varied by specifying the ranges and steps of
-#     the parameters for both the one and two fibre datasets used.
-# 
-#     To create a custom calibration dataset
-# 
-#     >>> import nipype.interfaces.camino as cam
-#     >>> calib = cam.SFPICOCalibData()
-#     >>> calib.inputs.scheme_file = 'A.scheme'
-#     >>> calib.inputs.snr = 20
-#     >>> calib.inputs.info_file = 'PICO_calib.info'
-#     >>> calib.inputs.twodtfarange = [0.3, 0.9]
-#     >>> calib.inputs.twodtfastep = 0.02
-#     >>> calib.inputs.twodtanglerange = [0, 0.785]
-#     >>> calib.inputs.twodtanglestep = 0.03925
-#     >>> calib.inputs.twodtmixmax = 0.8
-#     >>> calib.inputs.twodtmixstep = 0.1
-#     >>> calib.run()      # doctest: +SKIP
-# 
-#     This would provide 76,313 voxels of synthetic data, where 3401 voxels
-#     simulate the one fibre cases and 72,912 voxels simulate the various
-#     two fibre cases. However, care should be taken to ensure that enough
-#     data is generated for calculating the LUT.      # doctest: +SKIP
-# 
-#     
-task_name: SFPICOCalibData
-nipype_name: SFPICOCalibData
-nipype_module: nipype.interfaces.camino.calib
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    scheme_file: generic/file
-    # type=file|default=<undefined>: Specifies the scheme file for the diffusion MRI data
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    PICOCalib: generic/file
-    # type=file: Calibration dataset
-    calib_info: generic/file
-    # type=file: Calibration dataset
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    info_file: info_file
-    # type=file|default=<undefined>: The name to be given to the information output filename.
-    out_file: out_file
-    # type=file|default=<undefined>: 
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    snr:
-    # type=float|default=0.0: Specifies  the  signal-to-noise ratio of the non-diffusion-weighted measurements to use in simulations.
-    scheme_file:
-    # type=file|default=<undefined>: Specifies the scheme file for the diffusion MRI data
-    info_file:
-    # type=file|default=<undefined>: The name to be given to the information output filename.
-    trace:
-    # type=float|default=0.0: Trace of the diffusion tensor(s) used in the test function.
-    onedtfarange:
-    # type=list|default=[]: Minimum and maximum FA for the single tensor synthetic data.
-    onedtfastep:
-    # type=float|default=0.0: FA step size controlling how many steps there are between the minimum and maximum FA settings.
-    twodtfarange:
-    # type=list|default=[]: Minimum and maximum FA for the two tensor synthetic data. FA is varied for both tensors to give all the different permutations.
-    twodtfastep:
-    # type=float|default=0.0: FA step size controlling how many steps there are between the minimum and maximum FA settings for the two tensor cases.
-    twodtanglerange:
-    # type=list|default=[]: Minimum and maximum crossing angles between the two fibres.
-    twodtanglestep:
-    # type=float|default=0.0: Angle step size controlling how many steps there are between the minimum and maximum crossing angles for the two tensor cases.
-    twodtmixmax:
-    # type=float|default=0.0: Mixing parameter controlling the proportion of one fibre population to the other. The minimum mixing parameter is (1 - twodtmixmax).
-    twodtmixstep:
-    # type=float|default=0.0: Mixing parameter step size for the two tensor cases. Specify how many mixing parameter increments to use.
-    seed:
-    # type=float|default=0.0: Specifies the random seed to use for noise generation in simulation trials.
-    out_file:
-    # type=file|default=<undefined>: 
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-camino/sfpico_calib_data_callables.py b/example-specs/task/nipype_internal/pydra-camino/sfpico_calib_data_callables.py
deleted file mode 100644
index 43f7521c..00000000
--- a/example-specs/task/nipype_internal/pydra-camino/sfpico_calib_data_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in SFPICOCalibData.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-camino/shredder.yaml b/example-specs/task/nipype_internal/pydra-camino/shredder.yaml
deleted file mode 100644
index 2a451810..00000000
--- a/example-specs/task/nipype_internal/pydra-camino/shredder.yaml
+++ /dev/null
@@ -1,103 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.camino.convert.Shredder' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Extracts periodic chunks from a data stream.
-# 
-#     Shredder makes an initial offset of offset bytes. It then reads and outputs
-#     chunksize bytes, skips space bytes, and repeats until there is no more input.
-# 
-#     If  the  chunksize  is  negative, chunks of size chunksize are read and the
-#     byte ordering of each chunk is reversed. The whole chunk will be reversed, so
-#     the chunk must be the same size as the data type, otherwise the order of the
-#     values in the chunk, as well as their endianness, will be reversed.
-# 
-#     Examples
-#     --------
-# 
-#     >>> import nipype.interfaces.camino as cam
-#     >>> shred = cam.Shredder()
-#     >>> shred.inputs.in_file = 'SubjectA.Bfloat'
-#     >>> shred.inputs.offset = 0
-#     >>> shred.inputs.chunksize = 1
-#     >>> shred.inputs.space = 2
-#     >>> shred.run()          # doctest: +SKIP
-#     
-task_name: Shredder
-nipype_name: Shredder
-nipype_module: nipype.interfaces.camino.convert
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_file: generic/file
-    # type=file|default=<undefined>: raw binary data file
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    shredded: generic/file
-    # type=file: Shredded binary data file
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    out_file: out_file
-    # type=file|default=<undefined>: 
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: raw binary data file
-    offset:
-    # type=int|default=0: initial offset of offset bytes
-    chunksize:
-    # type=int|default=0: reads and outputs a chunk of chunksize bytes
-    space:
-    # type=int|default=0: skips space bytes
-    out_file:
-    # type=file|default=<undefined>: 
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-camino/shredder_callables.py b/example-specs/task/nipype_internal/pydra-camino/shredder_callables.py
deleted file mode 100644
index 2d577c7a..00000000
--- a/example-specs/task/nipype_internal/pydra-camino/shredder_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in Shredder.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-camino/track.yaml b/example-specs/task/nipype_internal/pydra-camino/track.yaml
deleted file mode 100644
index 8c76890f..00000000
--- a/example-specs/task/nipype_internal/pydra-camino/track.yaml
+++ /dev/null
@@ -1,131 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.camino.dti.Track' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Performs tractography using one of the following models:
-#     dt', 'multitensor', 'pds', 'pico', 'bootstrap', 'ballstick', 'bayesdirac'
-# 
-#     Example
-#     -------
-#     >>> import nipype.interfaces.camino as cmon
-#     >>> track = cmon.Track()
-#     >>> track.inputs.inputmodel = 'dt'
-#     >>> track.inputs.in_file = 'data.Bfloat'
-#     >>> track.inputs.seed_file = 'seed_mask.nii'
-#     >>> track.run()          # doctest: +SKIP
-# 
-#     
-task_name: Track
-nipype_name: Track
-nipype_module: nipype.interfaces.camino.dti
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_file: generic/file
-    # type=file|default=<undefined>: input data file
-    seed_file: generic/file
-    # type=file|default=<undefined>: seed file
-    anisfile: generic/file
-    # type=file|default=<undefined>: File containing the anisotropy map. This is required to apply an anisotropy threshold with non tensor data. If the map issupplied it is always used, even in tensor data.
-    output_root: generic/file
-    # type=file|default=<undefined>: root directory for output
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    tracked: generic/file
-    # type=file: output file containing reconstructed tracts
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    out_file: out_file
-    # type=file|default=<undefined>: output data file
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: input data file
-    seed_file:
-    # type=file|default=<undefined>: seed file
-    inputmodel:
-    # type=enum|default='dt'|allowed['ballstick','bayesdirac','bayesdirac_dt','bedpostx','bedpostx_dyad','dt','multitensor','pico','repbs_dt','repbs_multitensor','sfpeak','wildbs_dt']: input model type
-    tracker:
-    # type=enum|default='fact'|allowed['euler','fact','rk4']: The tracking algorithm controls streamlines are generated from the data. The choices are: - FACT, which follows the local fibre orientation in each voxel. No interpolation is used.- EULER, which uses a fixed step size along the local fibre orientation. With nearest-neighbour interpolation, this method may be very similar to FACT, except that the step size is fixed, whereas FACT steps extend to the boundary of the next voxel (distance variable depending on the entry and exit points to the voxel).- RK4: Fourth-order Runge-Kutta method. The step size is fixed, however the eventual direction of the step is determined by taking and averaging a series of partial steps.
-    interpolator:
-    # type=enum|default='nn'|allowed['linear','nn','prob_nn']: The interpolation algorithm determines how the fiber orientation(s) are defined at a given continuous point within the input image. Interpolators are only used when the tracking algorithm is not FACT. The choices are: - NN: Nearest-neighbour interpolation, just uses the local voxel data directly.- PROB_NN: Probabilistic nearest-neighbor interpolation,  similar  to the method pro- posed by Behrens et al [Magnetic Resonance in Medicine, 50:1077-1088, 2003]. The data is not interpolated, but at each point we randomly choose one of the 8 voxels sur- rounding a point. The probability of choosing a particular voxel is based on how close the point is to the centre of that voxel.- LINEAR: Linear interpolation of the vector field containing the principal directions at each point.
-    stepsize:
-    # type=float|default=0.0: Step size for EULER and RK4 tracking. The default is 1mm.
-    inputdatatype:
-    # type=enum|default='float'|allowed['double','float']: input file type
-    gzip:
-    # type=bool|default=False: save the output image in gzip format
-    maxcomponents:
-    # type=int|default=0: The maximum number of tensor components in a voxel. This determines the size of the input file and does not say anything about the voxel classification. The default is 2 if the input model is multitensor and 1 if the input model is dt.
-    numpds:
-    # type=int|default=0: The maximum number of PDs in a voxel for input models sfpeak and pico. The default is 3 for input model sfpeak and 1 for input model pico. This option determines the size of the voxels in the input file and does not affect tracking. For tensor data, use the -maxcomponents option.
-    data_dims:
-    # type=list|default=[]: data dimensions in voxels
-    voxel_dims:
-    # type=list|default=[]: voxel dimensions in mm
-    ipthresh:
-    # type=float|default=0.0: Curvature threshold for tracking, expressed as the minimum dot product between two streamline orientations calculated over the length of a voxel. If the dot product between the previous and current directions is less than this threshold, then the streamline terminates. The default setting will terminate fibres that curve by more than 80 degrees. Set this to -1.0 to disable curvature checking completely.
-    curvethresh:
-    # type=float|default=0.0: Curvature threshold for tracking, expressed as the maximum angle (in degrees) between between two streamline orientations calculated over the length of a voxel. If the angle is greater than this, then the streamline terminates.
-    curveinterval:
-    # type=float|default=0.0: Interval over which the curvature threshold should be evaluated, in mm. The default is 5mm. When using the default curvature threshold of 90 degrees, this means that streamlines will terminate if they curve by more than  90  degrees over a path length of 5mm.
-    anisthresh:
-    # type=float|default=0.0: Terminate fibres that enter a voxel with lower anisotropy than the threshold.
-    anisfile:
-    # type=file|default=<undefined>: File containing the anisotropy map. This is required to apply an anisotropy threshold with non tensor data. If the map issupplied it is always used, even in tensor data.
-    outputtracts:
-    # type=enum|default='float'|allowed['double','float','oogl']: output tract file type
-    out_file:
-    # type=file|default=<undefined>: output data file
-    output_root:
-    # type=file|default=<undefined>: root directory for output
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-camino/track_ball_stick.yaml b/example-specs/task/nipype_internal/pydra-camino/track_ball_stick.yaml
deleted file mode 100644
index d81a109e..00000000
--- a/example-specs/task/nipype_internal/pydra-camino/track_ball_stick.yaml
+++ /dev/null
@@ -1,129 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.camino.dti.TrackBallStick' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Performs streamline tractography using ball-stick fitted data
-# 
-#     Example
-#     -------
-#     >>> import nipype.interfaces.camino as cmon
-#     >>> track = cmon.TrackBallStick()
-#     >>> track.inputs.in_file = 'ballstickfit_data.Bfloat'
-#     >>> track.inputs.seed_file = 'seed_mask.nii'
-#     >>> track.run()          # doctest: +SKIP
-# 
-#     
-task_name: TrackBallStick
-nipype_name: TrackBallStick
-nipype_module: nipype.interfaces.camino.dti
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_file: generic/file
-    # type=file|default=<undefined>: input data file
-    seed_file: generic/file
-    # type=file|default=<undefined>: seed file
-    anisfile: generic/file
-    # type=file|default=<undefined>: File containing the anisotropy map. This is required to apply an anisotropy threshold with non tensor data. If the map issupplied it is always used, even in tensor data.
-    output_root: generic/file
-    # type=file|default=<undefined>: root directory for output
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    tracked: generic/file
-    # type=file: output file containing reconstructed tracts
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    out_file: out_file
-    # type=file|default=<undefined>: output data file
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: input data file
-    seed_file:
-    # type=file|default=<undefined>: seed file
-    inputmodel:
-    # type=enum|default='dt'|allowed['ballstick','bayesdirac','bayesdirac_dt','bedpostx','bedpostx_dyad','dt','multitensor','pico','repbs_dt','repbs_multitensor','sfpeak','wildbs_dt']: input model type
-    tracker:
-    # type=enum|default='fact'|allowed['euler','fact','rk4']: The tracking algorithm controls streamlines are generated from the data. The choices are: - FACT, which follows the local fibre orientation in each voxel. No interpolation is used.- EULER, which uses a fixed step size along the local fibre orientation. With nearest-neighbour interpolation, this method may be very similar to FACT, except that the step size is fixed, whereas FACT steps extend to the boundary of the next voxel (distance variable depending on the entry and exit points to the voxel).- RK4: Fourth-order Runge-Kutta method. The step size is fixed, however the eventual direction of the step is determined by taking and averaging a series of partial steps.
-    interpolator:
-    # type=enum|default='nn'|allowed['linear','nn','prob_nn']: The interpolation algorithm determines how the fiber orientation(s) are defined at a given continuous point within the input image. Interpolators are only used when the tracking algorithm is not FACT. The choices are: - NN: Nearest-neighbour interpolation, just uses the local voxel data directly.- PROB_NN: Probabilistic nearest-neighbor interpolation,  similar  to the method pro- posed by Behrens et al [Magnetic Resonance in Medicine, 50:1077-1088, 2003]. The data is not interpolated, but at each point we randomly choose one of the 8 voxels sur- rounding a point. The probability of choosing a particular voxel is based on how close the point is to the centre of that voxel.- LINEAR: Linear interpolation of the vector field containing the principal directions at each point.
-    stepsize:
-    # type=float|default=0.0: Step size for EULER and RK4 tracking. The default is 1mm.
-    inputdatatype:
-    # type=enum|default='float'|allowed['double','float']: input file type
-    gzip:
-    # type=bool|default=False: save the output image in gzip format
-    maxcomponents:
-    # type=int|default=0: The maximum number of tensor components in a voxel. This determines the size of the input file and does not say anything about the voxel classification. The default is 2 if the input model is multitensor and 1 if the input model is dt.
-    numpds:
-    # type=int|default=0: The maximum number of PDs in a voxel for input models sfpeak and pico. The default is 3 for input model sfpeak and 1 for input model pico. This option determines the size of the voxels in the input file and does not affect tracking. For tensor data, use the -maxcomponents option.
-    data_dims:
-    # type=list|default=[]: data dimensions in voxels
-    voxel_dims:
-    # type=list|default=[]: voxel dimensions in mm
-    ipthresh:
-    # type=float|default=0.0: Curvature threshold for tracking, expressed as the minimum dot product between two streamline orientations calculated over the length of a voxel. If the dot product between the previous and current directions is less than this threshold, then the streamline terminates. The default setting will terminate fibres that curve by more than 80 degrees. Set this to -1.0 to disable curvature checking completely.
-    curvethresh:
-    # type=float|default=0.0: Curvature threshold for tracking, expressed as the maximum angle (in degrees) between between two streamline orientations calculated over the length of a voxel. If the angle is greater than this, then the streamline terminates.
-    curveinterval:
-    # type=float|default=0.0: Interval over which the curvature threshold should be evaluated, in mm. The default is 5mm. When using the default curvature threshold of 90 degrees, this means that streamlines will terminate if they curve by more than  90  degrees over a path length of 5mm.
-    anisthresh:
-    # type=float|default=0.0: Terminate fibres that enter a voxel with lower anisotropy than the threshold.
-    anisfile:
-    # type=file|default=<undefined>: File containing the anisotropy map. This is required to apply an anisotropy threshold with non tensor data. If the map issupplied it is always used, even in tensor data.
-    outputtracts:
-    # type=enum|default='float'|allowed['double','float','oogl']: output tract file type
-    out_file:
-    # type=file|default=<undefined>: output data file
-    output_root:
-    # type=file|default=<undefined>: root directory for output
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-camino/track_ball_stick_callables.py b/example-specs/task/nipype_internal/pydra-camino/track_ball_stick_callables.py
deleted file mode 100644
index 64677eb1..00000000
--- a/example-specs/task/nipype_internal/pydra-camino/track_ball_stick_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in TrackBallStick.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-camino/track_bayes_dirac.yaml b/example-specs/task/nipype_internal/pydra-camino/track_bayes_dirac.yaml
deleted file mode 100644
index 21be5bc6..00000000
--- a/example-specs/task/nipype_internal/pydra-camino/track_bayes_dirac.yaml
+++ /dev/null
@@ -1,153 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.camino.dti.TrackBayesDirac' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Perform streamline tractography using a Bayesian tracking with Dirac priors.
-# 
-#     Example
-#     -------
-# 
-#     >>> import nipype.interfaces.camino as cmon
-#     >>> track = cmon.TrackBayesDirac()
-#     >>> track.inputs.in_file = 'tensor_fitted_data.Bdouble'
-#     >>> track.inputs.seed_file = 'seed_mask.nii'
-#     >>> track.inputs.scheme_file = 'bvecs.scheme'
-#     >>> track.run()          # doctest: +SKIP
-# 
-#     
-task_name: TrackBayesDirac
-nipype_name: TrackBayesDirac
-nipype_module: nipype.interfaces.camino.dti
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    scheme_file: generic/file
-    # type=file|default=<undefined>: The scheme file corresponding to the data being processed.
-    extpriorfile: generic/file
-    # type=file|default=<undefined>: Path to a PICo image produced by picopdfs. The PDF in each voxel is used as a prior for the fibre orientation in Bayesian tracking. The prior image must be in the same space as the diffusion data.
-    in_file: generic/file
-    # type=file|default=<undefined>: input data file
-    seed_file: generic/file
-    # type=file|default=<undefined>: seed file
-    anisfile: generic/file
-    # type=file|default=<undefined>: File containing the anisotropy map. This is required to apply an anisotropy threshold with non tensor data. If the map issupplied it is always used, even in tensor data.
-    output_root: generic/file
-    # type=file|default=<undefined>: root directory for output
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    tracked: generic/file
-    # type=file: output file containing reconstructed tracts
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    out_file: out_file
-    # type=file|default=<undefined>: output data file
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    scheme_file:
-    # type=file|default=<undefined>: The scheme file corresponding to the data being processed.
-    iterations:
-    # type=int|default=0: Number of streamlines to generate at each seed point. The default is 5000.
-    pdf:
-    # type=enum|default='bingham'|allowed['acg','bingham','watson']: Specifies the model for PICo priors (not the curvature priors). The default is 'bingham'.
-    pointset:
-    # type=int|default=0: Index to the point set to use for Bayesian likelihood calculation. The index specifies a set of evenly distributed points on the unit sphere, where each point x defines two possible step directions (x or -x) for the streamline path. A larger number indexes a larger point set, which gives higher angular resolution at the expense of computation time. The default is index 1, which gives 1922 points, index 0 gives 1082 points, index 2 gives 3002 points.
-    datamodel:
-    # type=enum|default='cylsymmdt'|allowed['ballstick','cylsymmdt']: Model of the data for Bayesian tracking. The default model is "cylsymmdt", a diffusion tensor with cylindrical symmetry about e_1, ie L1 >= L_2 = L_3. The other model is "ballstick", the partial volume model (see ballstickfit).
-    curvepriork:
-    # type=float|default=0.0: Concentration parameter for the prior distribution on fibre orientations given the fibre orientation at the previous step. Larger values of k make curvature less likely.
-    curvepriorg:
-    # type=float|default=0.0: Concentration parameter for the prior distribution on fibre orientations given the fibre orientation at the previous step. Larger values of g make curvature less likely.
-    extpriorfile:
-    # type=file|default=<undefined>: Path to a PICo image produced by picopdfs. The PDF in each voxel is used as a prior for the fibre orientation in Bayesian tracking. The prior image must be in the same space as the diffusion data.
-    extpriordatatype:
-    # type=enum|default='float'|allowed['double','float']: Datatype of the prior image. The default is "double".
-    in_file:
-    # type=file|default=<undefined>: input data file
-    seed_file:
-    # type=file|default=<undefined>: seed file
-    inputmodel:
-    # type=enum|default='dt'|allowed['ballstick','bayesdirac','bayesdirac_dt','bedpostx','bedpostx_dyad','dt','multitensor','pico','repbs_dt','repbs_multitensor','sfpeak','wildbs_dt']: input model type
-    tracker:
-    # type=enum|default='fact'|allowed['euler','fact','rk4']: The tracking algorithm controls streamlines are generated from the data. The choices are: - FACT, which follows the local fibre orientation in each voxel. No interpolation is used.- EULER, which uses a fixed step size along the local fibre orientation. With nearest-neighbour interpolation, this method may be very similar to FACT, except that the step size is fixed, whereas FACT steps extend to the boundary of the next voxel (distance variable depending on the entry and exit points to the voxel).- RK4: Fourth-order Runge-Kutta method. The step size is fixed, however the eventual direction of the step is determined by taking and averaging a series of partial steps.
-    interpolator:
-    # type=enum|default='nn'|allowed['linear','nn','prob_nn']: The interpolation algorithm determines how the fiber orientation(s) are defined at a given continuous point within the input image. Interpolators are only used when the tracking algorithm is not FACT. The choices are: - NN: Nearest-neighbour interpolation, just uses the local voxel data directly.- PROB_NN: Probabilistic nearest-neighbor interpolation,  similar  to the method pro- posed by Behrens et al [Magnetic Resonance in Medicine, 50:1077-1088, 2003]. The data is not interpolated, but at each point we randomly choose one of the 8 voxels sur- rounding a point. The probability of choosing a particular voxel is based on how close the point is to the centre of that voxel.- LINEAR: Linear interpolation of the vector field containing the principal directions at each point.
-    stepsize:
-    # type=float|default=0.0: Step size for EULER and RK4 tracking. The default is 1mm.
-    inputdatatype:
-    # type=enum|default='float'|allowed['double','float']: input file type
-    gzip:
-    # type=bool|default=False: save the output image in gzip format
-    maxcomponents:
-    # type=int|default=0: The maximum number of tensor components in a voxel. This determines the size of the input file and does not say anything about the voxel classification. The default is 2 if the input model is multitensor and 1 if the input model is dt.
-    numpds:
-    # type=int|default=0: The maximum number of PDs in a voxel for input models sfpeak and pico. The default is 3 for input model sfpeak and 1 for input model pico. This option determines the size of the voxels in the input file and does not affect tracking. For tensor data, use the -maxcomponents option.
-    data_dims:
-    # type=list|default=[]: data dimensions in voxels
-    voxel_dims:
-    # type=list|default=[]: voxel dimensions in mm
-    ipthresh:
-    # type=float|default=0.0: Curvature threshold for tracking, expressed as the minimum dot product between two streamline orientations calculated over the length of a voxel. If the dot product between the previous and current directions is less than this threshold, then the streamline terminates. The default setting will terminate fibres that curve by more than 80 degrees. Set this to -1.0 to disable curvature checking completely.
-    curvethresh:
-    # type=float|default=0.0: Curvature threshold for tracking, expressed as the maximum angle (in degrees) between between two streamline orientations calculated over the length of a voxel. If the angle is greater than this, then the streamline terminates.
-    curveinterval:
-    # type=float|default=0.0: Interval over which the curvature threshold should be evaluated, in mm. The default is 5mm. When using the default curvature threshold of 90 degrees, this means that streamlines will terminate if they curve by more than  90  degrees over a path length of 5mm.
-    anisthresh:
-    # type=float|default=0.0: Terminate fibres that enter a voxel with lower anisotropy than the threshold.
-    anisfile:
-    # type=file|default=<undefined>: File containing the anisotropy map. This is required to apply an anisotropy threshold with non tensor data. If the map issupplied it is always used, even in tensor data.
-    outputtracts:
-    # type=enum|default='float'|allowed['double','float','oogl']: output tract file type
-    out_file:
-    # type=file|default=<undefined>: output data file
-    output_root:
-    # type=file|default=<undefined>: root directory for output
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-camino/track_bayes_dirac_callables.py b/example-specs/task/nipype_internal/pydra-camino/track_bayes_dirac_callables.py
deleted file mode 100644
index da1da4b9..00000000
--- a/example-specs/task/nipype_internal/pydra-camino/track_bayes_dirac_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in TrackBayesDirac.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-camino/track_bedpostx_deter.yaml b/example-specs/task/nipype_internal/pydra-camino/track_bedpostx_deter.yaml
deleted file mode 100644
index 8650d1df..00000000
--- a/example-specs/task/nipype_internal/pydra-camino/track_bedpostx_deter.yaml
+++ /dev/null
@@ -1,145 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.camino.dti.TrackBedpostxDeter' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Data from FSL's bedpostx can be imported into Camino for deterministic tracking.
-#     (Use TrackBedpostxProba for bedpostx probabilistic tractography.)
-# 
-#     The tracking is based on the vector images dyads1.nii.gz, ... , dyadsN.nii.gz,
-#     where there are a maximum of N compartments (corresponding to each fiber
-#     population) in each voxel.
-# 
-#     It also uses the N images mean_f1samples.nii.gz, ..., mean_fNsamples.nii.gz,
-#     normalized such that the sum of all compartments is 1. Compartments where the
-#     mean_f is less than a threshold are discarded and not used for tracking.
-#     The default value is 0.01. This can be changed with the min_vol_frac option.
-# 
-#     Example
-#     -------
-#     >>> import nipype.interfaces.camino as cam
-#     >>> track = cam.TrackBedpostxDeter()
-#     >>> track.inputs.bedpostxdir = 'bedpostxout'
-#     >>> track.inputs.seed_file = 'seed_mask.nii'
-#     >>> track.run()          # doctest: +SKIP
-# 
-#     
-task_name: TrackBedpostxDeter
-nipype_name: TrackBedpostxDeter
-nipype_module: nipype.interfaces.camino.dti
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_file: generic/file
-    # type=file|default=<undefined>: input data file
-    seed_file: generic/file
-    # type=file|default=<undefined>: seed file
-    anisfile: generic/file
-    # type=file|default=<undefined>: File containing the anisotropy map. This is required to apply an anisotropy threshold with non tensor data. If the map issupplied it is always used, even in tensor data.
-    output_root: generic/file
-    # type=file|default=<undefined>: root directory for output
-    bedpostxdir: generic/directory
-    # type=directory|default=<undefined>: Directory containing bedpostx output
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    tracked: generic/file
-    # type=file: output file containing reconstructed tracts
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    out_file: out_file
-    # type=file|default=<undefined>: output data file
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    bedpostxdir:
-    # type=directory|default=<undefined>: Directory containing bedpostx output
-    min_vol_frac:
-    # type=float|default=0.0: Zeros out compartments in bedpostx data with a mean volume fraction f of less than min_vol_frac.  The default is 0.01.
-    in_file:
-    # type=file|default=<undefined>: input data file
-    seed_file:
-    # type=file|default=<undefined>: seed file
-    inputmodel:
-    # type=enum|default='dt'|allowed['ballstick','bayesdirac','bayesdirac_dt','bedpostx','bedpostx_dyad','dt','multitensor','pico','repbs_dt','repbs_multitensor','sfpeak','wildbs_dt']: input model type
-    tracker:
-    # type=enum|default='fact'|allowed['euler','fact','rk4']: The tracking algorithm controls streamlines are generated from the data. The choices are: - FACT, which follows the local fibre orientation in each voxel. No interpolation is used.- EULER, which uses a fixed step size along the local fibre orientation. With nearest-neighbour interpolation, this method may be very similar to FACT, except that the step size is fixed, whereas FACT steps extend to the boundary of the next voxel (distance variable depending on the entry and exit points to the voxel).- RK4: Fourth-order Runge-Kutta method. The step size is fixed, however the eventual direction of the step is determined by taking and averaging a series of partial steps.
-    interpolator:
-    # type=enum|default='nn'|allowed['linear','nn','prob_nn']: The interpolation algorithm determines how the fiber orientation(s) are defined at a given continuous point within the input image. Interpolators are only used when the tracking algorithm is not FACT. The choices are: - NN: Nearest-neighbour interpolation, just uses the local voxel data directly.- PROB_NN: Probabilistic nearest-neighbor interpolation,  similar  to the method pro- posed by Behrens et al [Magnetic Resonance in Medicine, 50:1077-1088, 2003]. The data is not interpolated, but at each point we randomly choose one of the 8 voxels sur- rounding a point. The probability of choosing a particular voxel is based on how close the point is to the centre of that voxel.- LINEAR: Linear interpolation of the vector field containing the principal directions at each point.
-    stepsize:
-    # type=float|default=0.0: Step size for EULER and RK4 tracking. The default is 1mm.
-    inputdatatype:
-    # type=enum|default='float'|allowed['double','float']: input file type
-    gzip:
-    # type=bool|default=False: save the output image in gzip format
-    maxcomponents:
-    # type=int|default=0: The maximum number of tensor components in a voxel. This determines the size of the input file and does not say anything about the voxel classification. The default is 2 if the input model is multitensor and 1 if the input model is dt.
-    numpds:
-    # type=int|default=0: The maximum number of PDs in a voxel for input models sfpeak and pico. The default is 3 for input model sfpeak and 1 for input model pico. This option determines the size of the voxels in the input file and does not affect tracking. For tensor data, use the -maxcomponents option.
-    data_dims:
-    # type=list|default=[]: data dimensions in voxels
-    voxel_dims:
-    # type=list|default=[]: voxel dimensions in mm
-    ipthresh:
-    # type=float|default=0.0: Curvature threshold for tracking, expressed as the minimum dot product between two streamline orientations calculated over the length of a voxel. If the dot product between the previous and current directions is less than this threshold, then the streamline terminates. The default setting will terminate fibres that curve by more than 80 degrees. Set this to -1.0 to disable curvature checking completely.
-    curvethresh:
-    # type=float|default=0.0: Curvature threshold for tracking, expressed as the maximum angle (in degrees) between between two streamline orientations calculated over the length of a voxel. If the angle is greater than this, then the streamline terminates.
-    curveinterval:
-    # type=float|default=0.0: Interval over which the curvature threshold should be evaluated, in mm. The default is 5mm. When using the default curvature threshold of 90 degrees, this means that streamlines will terminate if they curve by more than  90  degrees over a path length of 5mm.
-    anisthresh:
-    # type=float|default=0.0: Terminate fibres that enter a voxel with lower anisotropy than the threshold.
-    anisfile:
-    # type=file|default=<undefined>: File containing the anisotropy map. This is required to apply an anisotropy threshold with non tensor data. If the map issupplied it is always used, even in tensor data.
-    outputtracts:
-    # type=enum|default='float'|allowed['double','float','oogl']: output tract file type
-    out_file:
-    # type=file|default=<undefined>: output data file
-    output_root:
-    # type=file|default=<undefined>: root directory for output
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-camino/track_bedpostx_deter_callables.py b/example-specs/task/nipype_internal/pydra-camino/track_bedpostx_deter_callables.py
deleted file mode 100644
index 86f1341c..00000000
--- a/example-specs/task/nipype_internal/pydra-camino/track_bedpostx_deter_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in TrackBedpostxDeter.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-camino/track_bedpostx_proba.yaml b/example-specs/task/nipype_internal/pydra-camino/track_bedpostx_proba.yaml
deleted file mode 100644
index d95edaf0..00000000
--- a/example-specs/task/nipype_internal/pydra-camino/track_bedpostx_proba.yaml
+++ /dev/null
@@ -1,152 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.camino.dti.TrackBedpostxProba' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Data from FSL's bedpostx can be imported into Camino for probabilistic tracking.
-#     (Use TrackBedpostxDeter for bedpostx deterministic tractography.)
-# 
-#     The tracking uses the files merged_th1samples.nii.gz, merged_ph1samples.nii.gz,
-#     ... , merged_thNsamples.nii.gz, merged_phNsamples.nii.gz where there are a
-#     maximum of N compartments (corresponding to each fiber population) in each
-#     voxel. These images contain M samples of theta and phi, the polar coordinates
-#     describing the "stick" for each compartment. At each iteration, a random number
-#     X between 1 and M is drawn and the Xth samples of theta and phi become the
-#     principal directions in the voxel.
-# 
-#     It also uses the N images mean_f1samples.nii.gz, ..., mean_fNsamples.nii.gz,
-#     normalized such that the sum of all compartments is 1. Compartments where the
-#     mean_f is less than a threshold are discarded and not used for tracking.
-#     The default value is 0.01. This can be changed with the min_vol_frac option.
-# 
-#     Example
-#     -------
-#     >>> import nipype.interfaces.camino as cam
-#     >>> track = cam.TrackBedpostxProba()
-#     >>> track.inputs.bedpostxdir = 'bedpostxout'
-#     >>> track.inputs.seed_file = 'seed_mask.nii'
-#     >>> track.inputs.iterations = 100
-#     >>> track.run()          # doctest: +SKIP
-# 
-#     
-task_name: TrackBedpostxProba
-nipype_name: TrackBedpostxProba
-nipype_module: nipype.interfaces.camino.dti
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_file: generic/file
-    # type=file|default=<undefined>: input data file
-    seed_file: generic/file
-    # type=file|default=<undefined>: seed file
-    anisfile: generic/file
-    # type=file|default=<undefined>: File containing the anisotropy map. This is required to apply an anisotropy threshold with non tensor data. If the map issupplied it is always used, even in tensor data.
-    output_root: generic/file
-    # type=file|default=<undefined>: root directory for output
-    bedpostxdir: generic/directory
-    # type=directory|default=<undefined>: Directory containing bedpostx output
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    tracked: generic/file
-    # type=file: output file containing reconstructed tracts
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    out_file: out_file
-    # type=file|default=<undefined>: output data file
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    bedpostxdir:
-    # type=directory|default=<undefined>: Directory containing bedpostx output
-    min_vol_frac:
-    # type=float|default=0.0: Zeros out compartments in bedpostx data with a mean volume fraction f of less than min_vol_frac.  The default is 0.01.
-    iterations:
-    # type=int|default=0: Number of streamlines to generate at each seed point. The default is 1.
-    in_file:
-    # type=file|default=<undefined>: input data file
-    seed_file:
-    # type=file|default=<undefined>: seed file
-    inputmodel:
-    # type=enum|default='dt'|allowed['ballstick','bayesdirac','bayesdirac_dt','bedpostx','bedpostx_dyad','dt','multitensor','pico','repbs_dt','repbs_multitensor','sfpeak','wildbs_dt']: input model type
-    tracker:
-    # type=enum|default='fact'|allowed['euler','fact','rk4']: The tracking algorithm controls streamlines are generated from the data. The choices are: - FACT, which follows the local fibre orientation in each voxel. No interpolation is used.- EULER, which uses a fixed step size along the local fibre orientation. With nearest-neighbour interpolation, this method may be very similar to FACT, except that the step size is fixed, whereas FACT steps extend to the boundary of the next voxel (distance variable depending on the entry and exit points to the voxel).- RK4: Fourth-order Runge-Kutta method. The step size is fixed, however the eventual direction of the step is determined by taking and averaging a series of partial steps.
-    interpolator:
-    # type=enum|default='nn'|allowed['linear','nn','prob_nn']: The interpolation algorithm determines how the fiber orientation(s) are defined at a given continuous point within the input image. Interpolators are only used when the tracking algorithm is not FACT. The choices are: - NN: Nearest-neighbour interpolation, just uses the local voxel data directly.- PROB_NN: Probabilistic nearest-neighbor interpolation,  similar  to the method pro- posed by Behrens et al [Magnetic Resonance in Medicine, 50:1077-1088, 2003]. The data is not interpolated, but at each point we randomly choose one of the 8 voxels sur- rounding a point. The probability of choosing a particular voxel is based on how close the point is to the centre of that voxel.- LINEAR: Linear interpolation of the vector field containing the principal directions at each point.
-    stepsize:
-    # type=float|default=0.0: Step size for EULER and RK4 tracking. The default is 1mm.
-    inputdatatype:
-    # type=enum|default='float'|allowed['double','float']: input file type
-    gzip:
-    # type=bool|default=False: save the output image in gzip format
-    maxcomponents:
-    # type=int|default=0: The maximum number of tensor components in a voxel. This determines the size of the input file and does not say anything about the voxel classification. The default is 2 if the input model is multitensor and 1 if the input model is dt.
-    numpds:
-    # type=int|default=0: The maximum number of PDs in a voxel for input models sfpeak and pico. The default is 3 for input model sfpeak and 1 for input model pico. This option determines the size of the voxels in the input file and does not affect tracking. For tensor data, use the -maxcomponents option.
-    data_dims:
-    # type=list|default=[]: data dimensions in voxels
-    voxel_dims:
-    # type=list|default=[]: voxel dimensions in mm
-    ipthresh:
-    # type=float|default=0.0: Curvature threshold for tracking, expressed as the minimum dot product between two streamline orientations calculated over the length of a voxel. If the dot product between the previous and current directions is less than this threshold, then the streamline terminates. The default setting will terminate fibres that curve by more than 80 degrees. Set this to -1.0 to disable curvature checking completely.
-    curvethresh:
-    # type=float|default=0.0: Curvature threshold for tracking, expressed as the maximum angle (in degrees) between between two streamline orientations calculated over the length of a voxel. If the angle is greater than this, then the streamline terminates.
-    curveinterval:
-    # type=float|default=0.0: Interval over which the curvature threshold should be evaluated, in mm. The default is 5mm. When using the default curvature threshold of 90 degrees, this means that streamlines will terminate if they curve by more than  90  degrees over a path length of 5mm.
-    anisthresh:
-    # type=float|default=0.0: Terminate fibres that enter a voxel with lower anisotropy than the threshold.
-    anisfile:
-    # type=file|default=<undefined>: File containing the anisotropy map. This is required to apply an anisotropy threshold with non tensor data. If the map issupplied it is always used, even in tensor data.
-    outputtracts:
-    # type=enum|default='float'|allowed['double','float','oogl']: output tract file type
-    out_file:
-    # type=file|default=<undefined>: output data file
-    output_root:
-    # type=file|default=<undefined>: root directory for output
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-camino/track_bedpostx_proba_callables.py b/example-specs/task/nipype_internal/pydra-camino/track_bedpostx_proba_callables.py
deleted file mode 100644
index c73548a7..00000000
--- a/example-specs/task/nipype_internal/pydra-camino/track_bedpostx_proba_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in TrackBedpostxProba.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-camino/track_bootstrap.yaml b/example-specs/task/nipype_internal/pydra-camino/track_bootstrap.yaml
deleted file mode 100644
index 7f56a7b4..00000000
--- a/example-specs/task/nipype_internal/pydra-camino/track_bootstrap.yaml
+++ /dev/null
@@ -1,147 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.camino.dti.TrackBootstrap' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Performs bootstrap streamline tractography using multiple scans of the same subject
-# 
-#     Example
-#     -------
-#     >>> import nipype.interfaces.camino as cmon
-#     >>> track = cmon.TrackBootstrap()
-#     >>> track.inputs.inputmodel='repbs_dt'
-#     >>> track.inputs.scheme_file = 'bvecs.scheme'
-#     >>> track.inputs.bsdatafiles = ['fitted_data1.Bfloat', 'fitted_data2.Bfloat']
-#     >>> track.inputs.seed_file = 'seed_mask.nii'
-#     >>> track.run()          # doctest: +SKIP
-# 
-#     
-task_name: TrackBootstrap
-nipype_name: TrackBootstrap
-nipype_module: nipype.interfaces.camino.dti
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    scheme_file: generic/file
-    # type=file|default=<undefined>: The scheme file corresponding to the data being processed.
-    bsdatafiles: generic/file+list-of
-    # type=list|default=[]: Specifies files containing raw data for repetition bootstrapping. Use -inputfile for wild bootstrap data.
-    bgmask: generic/file
-    # type=file|default=<undefined>: Provides the name of a file containing a background mask computed using, for example, FSL's bet2 program. The mask file contains zero in background voxels and non-zero in foreground.
-    in_file: generic/file
-    # type=file|default=<undefined>: input data file
-    seed_file: generic/file
-    # type=file|default=<undefined>: seed file
-    anisfile: generic/file
-    # type=file|default=<undefined>: File containing the anisotropy map. This is required to apply an anisotropy threshold with non tensor data. If the map issupplied it is always used, even in tensor data.
-    output_root: generic/file
-    # type=file|default=<undefined>: root directory for output
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    tracked: generic/file
-    # type=file: output file containing reconstructed tracts
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    out_file: out_file
-    # type=file|default=<undefined>: output data file
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    scheme_file:
-    # type=file|default=<undefined>: The scheme file corresponding to the data being processed.
-    iterations:
-    # type=int|default=0: Number of streamlines to generate at each seed point.
-    inversion:
-    # type=int|default=0: Tensor reconstruction algorithm for repetition bootstrapping. Default is 1 (linear reconstruction, single tensor).
-    bsdatafiles:
-    # type=list|default=[]: Specifies files containing raw data for repetition bootstrapping. Use -inputfile for wild bootstrap data.
-    bgmask:
-    # type=file|default=<undefined>: Provides the name of a file containing a background mask computed using, for example, FSL's bet2 program. The mask file contains zero in background voxels and non-zero in foreground.
-    in_file:
-    # type=file|default=<undefined>: input data file
-    seed_file:
-    # type=file|default=<undefined>: seed file
-    inputmodel:
-    # type=enum|default='dt'|allowed['ballstick','bayesdirac','bayesdirac_dt','bedpostx','bedpostx_dyad','dt','multitensor','pico','repbs_dt','repbs_multitensor','sfpeak','wildbs_dt']: input model type
-    tracker:
-    # type=enum|default='fact'|allowed['euler','fact','rk4']: The tracking algorithm controls streamlines are generated from the data. The choices are: - FACT, which follows the local fibre orientation in each voxel. No interpolation is used.- EULER, which uses a fixed step size along the local fibre orientation. With nearest-neighbour interpolation, this method may be very similar to FACT, except that the step size is fixed, whereas FACT steps extend to the boundary of the next voxel (distance variable depending on the entry and exit points to the voxel).- RK4: Fourth-order Runge-Kutta method. The step size is fixed, however the eventual direction of the step is determined by taking and averaging a series of partial steps.
-    interpolator:
-    # type=enum|default='nn'|allowed['linear','nn','prob_nn']: The interpolation algorithm determines how the fiber orientation(s) are defined at a given continuous point within the input image. Interpolators are only used when the tracking algorithm is not FACT. The choices are: - NN: Nearest-neighbour interpolation, just uses the local voxel data directly.- PROB_NN: Probabilistic nearest-neighbor interpolation,  similar  to the method pro- posed by Behrens et al [Magnetic Resonance in Medicine, 50:1077-1088, 2003]. The data is not interpolated, but at each point we randomly choose one of the 8 voxels sur- rounding a point. The probability of choosing a particular voxel is based on how close the point is to the centre of that voxel.- LINEAR: Linear interpolation of the vector field containing the principal directions at each point.
-    stepsize:
-    # type=float|default=0.0: Step size for EULER and RK4 tracking. The default is 1mm.
-    inputdatatype:
-    # type=enum|default='float'|allowed['double','float']: input file type
-    gzip:
-    # type=bool|default=False: save the output image in gzip format
-    maxcomponents:
-    # type=int|default=0: The maximum number of tensor components in a voxel. This determines the size of the input file and does not say anything about the voxel classification. The default is 2 if the input model is multitensor and 1 if the input model is dt.
-    numpds:
-    # type=int|default=0: The maximum number of PDs in a voxel for input models sfpeak and pico. The default is 3 for input model sfpeak and 1 for input model pico. This option determines the size of the voxels in the input file and does not affect tracking. For tensor data, use the -maxcomponents option.
-    data_dims:
-    # type=list|default=[]: data dimensions in voxels
-    voxel_dims:
-    # type=list|default=[]: voxel dimensions in mm
-    ipthresh:
-    # type=float|default=0.0: Curvature threshold for tracking, expressed as the minimum dot product between two streamline orientations calculated over the length of a voxel. If the dot product between the previous and current directions is less than this threshold, then the streamline terminates. The default setting will terminate fibres that curve by more than 80 degrees. Set this to -1.0 to disable curvature checking completely.
-    curvethresh:
-    # type=float|default=0.0: Curvature threshold for tracking, expressed as the maximum angle (in degrees) between between two streamline orientations calculated over the length of a voxel. If the angle is greater than this, then the streamline terminates.
-    curveinterval:
-    # type=float|default=0.0: Interval over which the curvature threshold should be evaluated, in mm. The default is 5mm. When using the default curvature threshold of 90 degrees, this means that streamlines will terminate if they curve by more than  90  degrees over a path length of 5mm.
-    anisthresh:
-    # type=float|default=0.0: Terminate fibres that enter a voxel with lower anisotropy than the threshold.
-    anisfile:
-    # type=file|default=<undefined>: File containing the anisotropy map. This is required to apply an anisotropy threshold with non tensor data. If the map issupplied it is always used, even in tensor data.
-    outputtracts:
-    # type=enum|default='float'|allowed['double','float','oogl']: output tract file type
-    out_file:
-    # type=file|default=<undefined>: output data file
-    output_root:
-    # type=file|default=<undefined>: root directory for output
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-camino/track_bootstrap_callables.py b/example-specs/task/nipype_internal/pydra-camino/track_bootstrap_callables.py
deleted file mode 100644
index ecc2fe59..00000000
--- a/example-specs/task/nipype_internal/pydra-camino/track_bootstrap_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in TrackBootstrap.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-camino/track_callables.py b/example-specs/task/nipype_internal/pydra-camino/track_callables.py
deleted file mode 100644
index ef486ae5..00000000
--- a/example-specs/task/nipype_internal/pydra-camino/track_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in Track.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-camino/track_dt.yaml b/example-specs/task/nipype_internal/pydra-camino/track_dt.yaml
deleted file mode 100644
index 94584085..00000000
--- a/example-specs/task/nipype_internal/pydra-camino/track_dt.yaml
+++ /dev/null
@@ -1,129 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.camino.dti.TrackDT' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Performs streamline tractography using tensor data
-# 
-#     Example
-#     -------
-#     >>> import nipype.interfaces.camino as cmon
-#     >>> track = cmon.TrackDT()
-#     >>> track.inputs.in_file = 'tensor_fitted_data.Bdouble'
-#     >>> track.inputs.seed_file = 'seed_mask.nii'
-#     >>> track.run()         # doctest: +SKIP
-# 
-#     
-task_name: TrackDT
-nipype_name: TrackDT
-nipype_module: nipype.interfaces.camino.dti
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_file: generic/file
-    # type=file|default=<undefined>: input data file
-    seed_file: generic/file
-    # type=file|default=<undefined>: seed file
-    anisfile: generic/file
-    # type=file|default=<undefined>: File containing the anisotropy map. This is required to apply an anisotropy threshold with non tensor data. If the map issupplied it is always used, even in tensor data.
-    output_root: generic/file
-    # type=file|default=<undefined>: root directory for output
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    tracked: generic/file
-    # type=file: output file containing reconstructed tracts
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    out_file: out_file
-    # type=file|default=<undefined>: output data file
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: input data file
-    seed_file:
-    # type=file|default=<undefined>: seed file
-    inputmodel:
-    # type=enum|default='dt'|allowed['ballstick','bayesdirac','bayesdirac_dt','bedpostx','bedpostx_dyad','dt','multitensor','pico','repbs_dt','repbs_multitensor','sfpeak','wildbs_dt']: input model type
-    tracker:
-    # type=enum|default='fact'|allowed['euler','fact','rk4']: The tracking algorithm controls streamlines are generated from the data. The choices are: - FACT, which follows the local fibre orientation in each voxel. No interpolation is used.- EULER, which uses a fixed step size along the local fibre orientation. With nearest-neighbour interpolation, this method may be very similar to FACT, except that the step size is fixed, whereas FACT steps extend to the boundary of the next voxel (distance variable depending on the entry and exit points to the voxel).- RK4: Fourth-order Runge-Kutta method. The step size is fixed, however the eventual direction of the step is determined by taking and averaging a series of partial steps.
-    interpolator:
-    # type=enum|default='nn'|allowed['linear','nn','prob_nn']: The interpolation algorithm determines how the fiber orientation(s) are defined at a given continuous point within the input image. Interpolators are only used when the tracking algorithm is not FACT. The choices are: - NN: Nearest-neighbour interpolation, just uses the local voxel data directly.- PROB_NN: Probabilistic nearest-neighbor interpolation,  similar  to the method pro- posed by Behrens et al [Magnetic Resonance in Medicine, 50:1077-1088, 2003]. The data is not interpolated, but at each point we randomly choose one of the 8 voxels sur- rounding a point. The probability of choosing a particular voxel is based on how close the point is to the centre of that voxel.- LINEAR: Linear interpolation of the vector field containing the principal directions at each point.
-    stepsize:
-    # type=float|default=0.0: Step size for EULER and RK4 tracking. The default is 1mm.
-    inputdatatype:
-    # type=enum|default='float'|allowed['double','float']: input file type
-    gzip:
-    # type=bool|default=False: save the output image in gzip format
-    maxcomponents:
-    # type=int|default=0: The maximum number of tensor components in a voxel. This determines the size of the input file and does not say anything about the voxel classification. The default is 2 if the input model is multitensor and 1 if the input model is dt.
-    numpds:
-    # type=int|default=0: The maximum number of PDs in a voxel for input models sfpeak and pico. The default is 3 for input model sfpeak and 1 for input model pico. This option determines the size of the voxels in the input file and does not affect tracking. For tensor data, use the -maxcomponents option.
-    data_dims:
-    # type=list|default=[]: data dimensions in voxels
-    voxel_dims:
-    # type=list|default=[]: voxel dimensions in mm
-    ipthresh:
-    # type=float|default=0.0: Curvature threshold for tracking, expressed as the minimum dot product between two streamline orientations calculated over the length of a voxel. If the dot product between the previous and current directions is less than this threshold, then the streamline terminates. The default setting will terminate fibres that curve by more than 80 degrees. Set this to -1.0 to disable curvature checking completely.
-    curvethresh:
-    # type=float|default=0.0: Curvature threshold for tracking, expressed as the maximum angle (in degrees) between between two streamline orientations calculated over the length of a voxel. If the angle is greater than this, then the streamline terminates.
-    curveinterval:
-    # type=float|default=0.0: Interval over which the curvature threshold should be evaluated, in mm. The default is 5mm. When using the default curvature threshold of 90 degrees, this means that streamlines will terminate if they curve by more than  90  degrees over a path length of 5mm.
-    anisthresh:
-    # type=float|default=0.0: Terminate fibres that enter a voxel with lower anisotropy than the threshold.
-    anisfile:
-    # type=file|default=<undefined>: File containing the anisotropy map. This is required to apply an anisotropy threshold with non tensor data. If the map issupplied it is always used, even in tensor data.
-    outputtracts:
-    # type=enum|default='float'|allowed['double','float','oogl']: output tract file type
-    out_file:
-    # type=file|default=<undefined>: output data file
-    output_root:
-    # type=file|default=<undefined>: root directory for output
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-camino/track_dt_callables.py b/example-specs/task/nipype_internal/pydra-camino/track_dt_callables.py
deleted file mode 100644
index 85ffc74f..00000000
--- a/example-specs/task/nipype_internal/pydra-camino/track_dt_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in TrackDT.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-camino/track_pi_co.yaml b/example-specs/task/nipype_internal/pydra-camino/track_pi_co.yaml
deleted file mode 100644
index d82bad6e..00000000
--- a/example-specs/task/nipype_internal/pydra-camino/track_pi_co.yaml
+++ /dev/null
@@ -1,133 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.camino.dti.TrackPICo' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Performs streamline tractography using Probabilistic Index of Connectivity (PICo).
-# 
-#     Example
-#     -------
-#     >>> import nipype.interfaces.camino as cmon
-#     >>> track = cmon.TrackPICo()
-#     >>> track.inputs.in_file = 'pdfs.Bfloat'
-#     >>> track.inputs.seed_file = 'seed_mask.nii'
-#     >>> track.run()          # doctest: +SKIP
-# 
-#     
-task_name: TrackPICo
-nipype_name: TrackPICo
-nipype_module: nipype.interfaces.camino.dti
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_file: generic/file
-    # type=file|default=<undefined>: input data file
-    seed_file: generic/file
-    # type=file|default=<undefined>: seed file
-    anisfile: generic/file
-    # type=file|default=<undefined>: File containing the anisotropy map. This is required to apply an anisotropy threshold with non tensor data. If the map issupplied it is always used, even in tensor data.
-    output_root: generic/file
-    # type=file|default=<undefined>: root directory for output
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    tracked: generic/file
-    # type=file: output file containing reconstructed tracts
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    out_file: out_file
-    # type=file|default=<undefined>: output data file
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    pdf:
-    # type=enum|default='bingham'|allowed['acg','bingham','watson']: Specifies the model for PICo parameters. The default is "bingham.
-    iterations:
-    # type=int|default=0: Number of streamlines to generate at each seed point. The default is 5000.
-    in_file:
-    # type=file|default=<undefined>: input data file
-    seed_file:
-    # type=file|default=<undefined>: seed file
-    inputmodel:
-    # type=enum|default='dt'|allowed['ballstick','bayesdirac','bayesdirac_dt','bedpostx','bedpostx_dyad','dt','multitensor','pico','repbs_dt','repbs_multitensor','sfpeak','wildbs_dt']: input model type
-    tracker:
-    # type=enum|default='fact'|allowed['euler','fact','rk4']: The tracking algorithm controls streamlines are generated from the data. The choices are: - FACT, which follows the local fibre orientation in each voxel. No interpolation is used.- EULER, which uses a fixed step size along the local fibre orientation. With nearest-neighbour interpolation, this method may be very similar to FACT, except that the step size is fixed, whereas FACT steps extend to the boundary of the next voxel (distance variable depending on the entry and exit points to the voxel).- RK4: Fourth-order Runge-Kutta method. The step size is fixed, however the eventual direction of the step is determined by taking and averaging a series of partial steps.
-    interpolator:
-    # type=enum|default='nn'|allowed['linear','nn','prob_nn']: The interpolation algorithm determines how the fiber orientation(s) are defined at a given continuous point within the input image. Interpolators are only used when the tracking algorithm is not FACT. The choices are: - NN: Nearest-neighbour interpolation, just uses the local voxel data directly.- PROB_NN: Probabilistic nearest-neighbor interpolation,  similar  to the method pro- posed by Behrens et al [Magnetic Resonance in Medicine, 50:1077-1088, 2003]. The data is not interpolated, but at each point we randomly choose one of the 8 voxels sur- rounding a point. The probability of choosing a particular voxel is based on how close the point is to the centre of that voxel.- LINEAR: Linear interpolation of the vector field containing the principal directions at each point.
-    stepsize:
-    # type=float|default=0.0: Step size for EULER and RK4 tracking. The default is 1mm.
-    inputdatatype:
-    # type=enum|default='float'|allowed['double','float']: input file type
-    gzip:
-    # type=bool|default=False: save the output image in gzip format
-    maxcomponents:
-    # type=int|default=0: The maximum number of tensor components in a voxel. This determines the size of the input file and does not say anything about the voxel classification. The default is 2 if the input model is multitensor and 1 if the input model is dt.
-    numpds:
-    # type=int|default=0: The maximum number of PDs in a voxel for input models sfpeak and pico. The default is 3 for input model sfpeak and 1 for input model pico. This option determines the size of the voxels in the input file and does not affect tracking. For tensor data, use the -maxcomponents option.
-    data_dims:
-    # type=list|default=[]: data dimensions in voxels
-    voxel_dims:
-    # type=list|default=[]: voxel dimensions in mm
-    ipthresh:
-    # type=float|default=0.0: Curvature threshold for tracking, expressed as the minimum dot product between two streamline orientations calculated over the length of a voxel. If the dot product between the previous and current directions is less than this threshold, then the streamline terminates. The default setting will terminate fibres that curve by more than 80 degrees. Set this to -1.0 to disable curvature checking completely.
-    curvethresh:
-    # type=float|default=0.0: Curvature threshold for tracking, expressed as the maximum angle (in degrees) between between two streamline orientations calculated over the length of a voxel. If the angle is greater than this, then the streamline terminates.
-    curveinterval:
-    # type=float|default=0.0: Interval over which the curvature threshold should be evaluated, in mm. The default is 5mm. When using the default curvature threshold of 90 degrees, this means that streamlines will terminate if they curve by more than  90  degrees over a path length of 5mm.
-    anisthresh:
-    # type=float|default=0.0: Terminate fibres that enter a voxel with lower anisotropy than the threshold.
-    anisfile:
-    # type=file|default=<undefined>: File containing the anisotropy map. This is required to apply an anisotropy threshold with non tensor data. If the map issupplied it is always used, even in tensor data.
-    outputtracts:
-    # type=enum|default='float'|allowed['double','float','oogl']: output tract file type
-    out_file:
-    # type=file|default=<undefined>: output data file
-    output_root:
-    # type=file|default=<undefined>: root directory for output
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-camino/track_pi_co_callables.py b/example-specs/task/nipype_internal/pydra-camino/track_pi_co_callables.py
deleted file mode 100644
index 15f107a4..00000000
--- a/example-specs/task/nipype_internal/pydra-camino/track_pi_co_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in TrackPICo.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-camino/tract_shredder.yaml b/example-specs/task/nipype_internal/pydra-camino/tract_shredder.yaml
deleted file mode 100644
index 763362e5..00000000
--- a/example-specs/task/nipype_internal/pydra-camino/tract_shredder.yaml
+++ /dev/null
@@ -1,101 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.camino.convert.TractShredder' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Extracts bunches of streamlines.
-# 
-#     tractshredder works in a similar way to shredder, but processes streamlines instead of scalar data.
-#     The input is raw streamlines, in the format produced by track or procstreamlines.
-# 
-#     The program first makes an initial offset of offset tracts.  It then reads and outputs a group of
-#     bunchsize tracts, skips space tracts, and repeats until there is no more input.
-# 
-#     Examples
-#     --------
-# 
-#     >>> import nipype.interfaces.camino as cmon
-#     >>> shred = cmon.TractShredder()
-#     >>> shred.inputs.in_file = 'tract_data.Bfloat'
-#     >>> shred.inputs.offset = 0
-#     >>> shred.inputs.bunchsize = 1
-#     >>> shred.inputs.space = 2
-#     >>> shred.run()          # doctest: +SKIP
-#     
-task_name: TractShredder
-nipype_name: TractShredder
-nipype_module: nipype.interfaces.camino.convert
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_file: generic/file
-    # type=file|default=<undefined>: tract file
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    shredded: generic/file
-    # type=file: Shredded tract file
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    out_file: out_file
-    # type=file|default=<undefined>: 
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: tract file
-    offset:
-    # type=int|default=0: initial offset of offset tracts
-    bunchsize:
-    # type=int|default=0: reads and outputs a group of bunchsize tracts
-    space:
-    # type=int|default=0: skips space tracts
-    out_file:
-    # type=file|default=<undefined>: 
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-camino/tract_shredder_callables.py b/example-specs/task/nipype_internal/pydra-camino/tract_shredder_callables.py
deleted file mode 100644
index bd0a1ed5..00000000
--- a/example-specs/task/nipype_internal/pydra-camino/tract_shredder_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in TractShredder.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-camino/vtk_streamlines.yaml b/example-specs/task/nipype_internal/pydra-camino/vtk_streamlines.yaml
deleted file mode 100644
index e29ea631..00000000
--- a/example-specs/task/nipype_internal/pydra-camino/vtk_streamlines.yaml
+++ /dev/null
@@ -1,109 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.camino.convert.VtkStreamlines' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Use vtkstreamlines to convert raw or voxel format streamlines to VTK polydata
-# 
-#     Examples
-#     --------
-# 
-#     >>> import nipype.interfaces.camino as cmon
-#     >>> vtk = cmon.VtkStreamlines()
-#     >>> vtk.inputs.in_file = 'tract_data.Bfloat'
-#     >>> vtk.inputs.voxeldims = [1,1,1]
-#     >>> vtk.run()          # doctest: +SKIP
-#     
-task_name: VtkStreamlines
-nipype_name: VtkStreamlines
-nipype_module: nipype.interfaces.camino.convert
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_file: generic/file
-    # type=file|default=<undefined>: data file
-    seed_file: generic/file
-    # type=file|default=<undefined>: image containing seed points
-    target_file: generic/file
-    # type=file|default=<undefined>: image containing integer-valued target regions
-    scalar_file: generic/file
-    # type=file|default=<undefined>: image that is in the same physical space as the tracts
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    vtk: generic/file
-    # type=file: Streamlines in VTK format
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    out_file: out_file
-    # type=file|default=<undefined>: 
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputmodel:
-    # type=enum|default='raw'|allowed['raw','voxels']: input model type (raw or voxels)
-    in_file:
-    # type=file|default=<undefined>: data file
-    voxeldims:
-    # type=list|default=[]: voxel dimensions in mm
-    seed_file:
-    # type=file|default=<undefined>: image containing seed points
-    target_file:
-    # type=file|default=<undefined>: image containing integer-valued target regions
-    scalar_file:
-    # type=file|default=<undefined>: image that is in the same physical space as the tracts
-    colourorient:
-    # type=bool|default=False: Each point on the streamline is coloured by the local orientation.
-    interpolatescalars:
-    # type=bool|default=False: the scalar value at each point on the streamline is calculated by trilinear interpolation
-    interpolate:
-    # type=bool|default=False: the scalar value at each point on the streamline is calculated by trilinear interpolation
-    out_file:
-    # type=file|default=<undefined>: 
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-camino/vtk_streamlines_callables.py b/example-specs/task/nipype_internal/pydra-camino/vtk_streamlines_callables.py
deleted file mode 100644
index de7e4131..00000000
--- a/example-specs/task/nipype_internal/pydra-camino/vtk_streamlines_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in VtkStreamlines.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-camino2trackvis/camino_2_trackvis.yaml b/example-specs/task/nipype_internal/pydra-camino2trackvis/camino_2_trackvis.yaml
deleted file mode 100644
index b9873595..00000000
--- a/example-specs/task/nipype_internal/pydra-camino2trackvis/camino_2_trackvis.yaml
+++ /dev/null
@@ -1,106 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.camino2trackvis.convert.Camino2Trackvis' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Wraps camino_to_trackvis from Camino-Trackvis
-# 
-#     Convert files from camino .Bfloat format to trackvis .trk format.
-# 
-#     Example
-#     -------
-# 
-#     >>> import nipype.interfaces.camino2trackvis as cam2trk
-#     >>> c2t = cam2trk.Camino2Trackvis()
-#     >>> c2t.inputs.in_file = 'data.Bfloat'
-#     >>> c2t.inputs.out_file = 'streamlines.trk'
-#     >>> c2t.inputs.min_length = 30
-#     >>> c2t.inputs.data_dims = [128, 104, 64]
-#     >>> c2t.inputs.voxel_dims = [2.0, 2.0, 2.0]
-#     >>> c2t.inputs.voxel_order = 'LAS'
-#     >>> c2t.run()          # doctest: +SKIP
-#     
-task_name: Camino2Trackvis
-nipype_name: Camino2Trackvis
-nipype_module: nipype.interfaces.camino2trackvis.convert
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_file: generic/file
-    # type=file|default=<undefined>: The input .Bfloat (camino) file.
-    voxel_order: generic/file
-    # type=file|default=<undefined>: Set the order in which various directions were stored.        Specify with three letters consisting of one each          from the pairs LR, AP, and SI. These stand for Left-Right,         Anterior-Posterior, and Superior-Inferior.          Whichever is specified in each position will          be the direction of increasing order.          Read coordinate system from a NIfTI file.
-    nifti_file: generic/file
-    # type=file|default=<undefined>: Read coordinate system from a NIfTI file.
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    trackvis: generic/file
-    # type=file: The filename to which to write the .trk (trackvis) file.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    out_file: out_file
-    # type=file|default=<undefined>: The filename to which to write the .trk (trackvis) file.
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: The input .Bfloat (camino) file.
-    out_file:
-    # type=file|default=<undefined>: The filename to which to write the .trk (trackvis) file.
-    min_length:
-    # type=float|default=0.0: The minimum length of tracts to output
-    data_dims:
-    # type=list|default=[]: Three comma-separated integers giving the number of voxels along each dimension of the source scans.
-    voxel_dims:
-    # type=list|default=[]: Three comma-separated numbers giving the size of each voxel in mm.
-    voxel_order:
-    # type=file|default=<undefined>: Set the order in which various directions were stored.        Specify with three letters consisting of one each          from the pairs LR, AP, and SI. These stand for Left-Right,         Anterior-Posterior, and Superior-Inferior.          Whichever is specified in each position will          be the direction of increasing order.          Read coordinate system from a NIfTI file.
-    nifti_file:
-    # type=file|default=<undefined>: Read coordinate system from a NIfTI file.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-camino2trackvis/camino_2_trackvis_callables.py b/example-specs/task/nipype_internal/pydra-camino2trackvis/camino_2_trackvis_callables.py
deleted file mode 100644
index f9f86721..00000000
--- a/example-specs/task/nipype_internal/pydra-camino2trackvis/camino_2_trackvis_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in Camino2Trackvis.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-camino2trackvis/trackvis_2_camino.yaml b/example-specs/task/nipype_internal/pydra-camino2trackvis/trackvis_2_camino.yaml
deleted file mode 100644
index 2f22b71e..00000000
--- a/example-specs/task/nipype_internal/pydra-camino2trackvis/trackvis_2_camino.yaml
+++ /dev/null
@@ -1,80 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.camino2trackvis.convert.Trackvis2Camino' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-task_name: Trackvis2Camino
-nipype_name: Trackvis2Camino
-nipype_module: nipype.interfaces.camino2trackvis.convert
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_file: generic/file
-    # type=file|default=<undefined>: The input .trk (trackvis) file.
-    append_file: generic/file
-    # type=file|default=<undefined>: A file to which the append the .Bfloat data. 
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    camino: generic/file
-    # type=file: The filename to which to write the .Bfloat (camino).
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    out_file: out_file
-    # type=file|default=<undefined>: The filename to which to write the .Bfloat (camino).
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: The input .trk (trackvis) file.
-    out_file:
-    # type=file|default=<undefined>: The filename to which to write the .Bfloat (camino).
-    append_file:
-    # type=file|default=<undefined>: A file to which the append the .Bfloat data. 
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-camino2trackvis/trackvis_2_camino_callables.py b/example-specs/task/nipype_internal/pydra-camino2trackvis/trackvis_2_camino_callables.py
deleted file mode 100644
index 66cf5203..00000000
--- a/example-specs/task/nipype_internal/pydra-camino2trackvis/trackvis_2_camino_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in Trackvis2Camino.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-cat12/cat12_segment.yaml b/example-specs/task/nipype_internal/pydra-cat12/cat12_segment.yaml
deleted file mode 100644
index 10bad416..00000000
--- a/example-specs/task/nipype_internal/pydra-cat12/cat12_segment.yaml
+++ /dev/null
@@ -1,225 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.cat12.preprocess.CAT12Segment' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     CAT12: Segmentation
-# 
-#     This toolbox is an extension to the default segmentation in SPM12, but uses a completely different segmentation
-#     approach.
-#     The segmentation approach is based on an Adaptive Maximum A Posterior (MAP) technique without the need for a priori
-#     information about tissue probabilities. That is, the Tissue Probability Maps (TPM) are not used constantly in the
-#     sense of the classical Unified Segmentation approach (Ashburner et. al. 2005), but just for spatial normalization.
-#     The following AMAP estimation is adaptive in the sense that local variations of the parameters (i.e., means and
-#     variance) are modeled as slowly varying spatial functions (Rajapakse et al. 1997). This not only accounts for
-#     intensity inhomogeneities but also for other local variations of intensity.
-#     Additionally, the segmentation approach uses a Partial Volume Estimation (PVE) with a simplified mixed model of at
-#     most two tissue types (Tohka et al. 2004). We start with an initial segmentation into three pure classes: gray
-#     matter (GM), white matter (WM), and cerebrospinal fluid (CSF) based on the above described AMAP estimation. The
-#     initial segmentation is followed by a PVE of two additional mixed classes: GM-WM and GM-CSF. This results in an
-#     estimation of the amount (or fraction) of each pure tissue type present in every voxel (as single voxels - given by
-#     Another important extension to the SPM12 segmentation is the integration of the Dartel or Geodesic Shooting
-#     registration into the toolbox by an already existing Dartel/Shooting template in MNI space. This template was
-#     derived from 555 healthy control subjects of the IXI-database (http://www.brain-development.org) and provides the
-#     several Dartel or Shooting iterations. Thus, for the majority of studies the creation of sample-specific templates
-#     is not necessary anymore and is mainly recommended for children data.'};
-# 
-#     http://www.neuro.uni-jena.de/cat12/CAT12-Manual.pdf#page=15
-# 
-#     Examples
-#     --------
-#     >>> path_mr = 'structural.nii'
-#     >>> cat = CAT12Segment(in_files=path_mr)
-#     >>> cat.run() # doctest: +SKIP
-#     
-task_name: CAT12Segment
-nipype_name: CAT12Segment
-nipype_module: nipype.interfaces.cat12.preprocess
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    paths: generic/directory+list-of
-    # type=inputmultiobject|default=[]: Paths to add to matlabpath
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    label_rois: generic/file
-    # type=file: Files with thickness values of ROIs.
-    label_roi: generic/file
-    # type=file: Files with thickness values of ROI.
-    gm_modulated_image: generic/file
-    # type=file: Grey matter modulated image.
-    gm_dartel_image: generic/file
-    # type=file: Grey matter dartel image.
-    gm_native_image: generic/file
-    # type=file: Grey matter native space.
-    wm_modulated_image: generic/file
-    # type=file: White matter modulated image.
-    wm_dartel_image: generic/file
-    # type=file: White matter dartel image.
-    wm_native_image: generic/file
-    # type=file: White matter in native space.
-    csf_modulated_image: generic/file
-    # type=file: CSF modulated image.
-    csf_dartel_image: generic/file
-    # type=file: CSF dartel image.
-    csf_native_image: generic/file
-    # type=file: CSF in native space.
-    bias_corrected_image: generic/file
-    # type=file: Bias corrected image
-    rh_central_surface: generic/file
-    # type=file: Central right hemisphere files
-    rh_sphere_surface: generic/file
-    # type=file: Sphere right hemisphere files
-    lh_central_surface: generic/file
-    # type=file: Central left hemisphere files
-    lh_sphere_surface: generic/file
-    # type=file: Sphere left hemisphere files
-    report: generic/file
-    # type=file: Report file.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_files:
-    # type=inputmultiobject|default=[]: file to segment
-    tpm:
-    # type=inputmultiobject|default=[]: Tissue Probability Map. Select the tissue probability image that includes 6 tissue probability classes for (1) grey matter, (2) white matter, (3) cerebrospinal fluid, (4) bone, (5) non-brain  soft tissue, and (6) the background.  CAT uses the TPM only for the initial SPM segmentation.
-    shooting_tpm:
-    # type=imagefilespm|default=<undefined>: Shooting Template 0.  The Shooting template must be in multi-volume nifti format and should contain GM, WM, and background segmentations and have to be saved with at least 16 bit. 
-    shooting_tpm_template_1:
-    # type=imagefilespm|default=<undefined>: Shooting Template 1.  The Shooting template must be in multi-volume nifti format and should contain GM, WM, and background segmentations and have to be saved with at least 16 bit. 
-    shooting_tpm_template_2:
-    # type=imagefilespm|default=<undefined>: Shooting Template 2.  The Shooting template must be in multi-volume nifti format and should contain GM, WM, and background segmentations and have to be saved with at least 16 bit. 
-    shooting_tpm_template_3:
-    # type=imagefilespm|default=<undefined>: Shooting Template 3.  The Shooting template must be in multi-volume nifti format and should contain GM, WM, and background segmentations and have to be saved with at least 16 bit. 
-    shooting_tpm_template_4:
-    # type=imagefilespm|default=<undefined>: Shooting Template 4.  The Shooting template must be in multi-volume nifti format and should contain GM, WM, and background segmentations and have to be saved with at least 16 bit. 
-    n_jobs:
-    # type=int|default=1: Number of threads
-    affine_regularization:
-    # type=str|default='mni': Affine Regularization. The procedure is a local optimisation, so it needs reasonable initial starting estimates. Images should be placed in approximate alignment using the Display function of SPM before beginning.  A Mutual Information affine registration with the tissue probability maps (DAgostino et al, 2004) is used to achieve approximate alignment.
-    power_spm_inhomogeneity_correction:
-    # type=float|default=0.5: Strength of the SPM inhomogeneity (bias) correction that simultaneously controls the SPM biasreg, biasfwhm, samp (resolution), and tol (iteration) parameter.
-    affine_preprocessing:
-    # type=int|default=1070: Affine registration and SPM preprocessing can fail in some subjects with deviating anatomy (e.g. other species/neonates) or in images with strong signal inhomogeneities, or untypical intensities (e.g. synthetic images). An initial bias correction can help to reduce such problems (see details below). Recommended are the "default" and "full" option.
-    initial_segmentation:
-    # type=int|default=0: In rare cases the Unified Segmentation can fail in highly abnormal brains, where e.g. the cerebrospinal fluid of superlarge ventricles (hydrocephalus) were classified as white matter. However, if the affine registration is correct, the AMAP segmentation with an prior-independent k-means initialization can be used to replace the SPM brain tissue classification. Moreover, if the default Dartel and Shooting registrations will fail then rhe "Optimized Shooting - superlarge ventricles" option for "Spatial registration" is ! required Values:  none: 0; light: 1; full: 2; default: 1070.
-    local_adaptive_seg:
-    # type=float|default=0.5: Additionally to WM-inhomogeneities, GM intensity can vary across different regions such as the motor cortex, the basal ganglia, or the occipital lobe. These changes have an anatomical background (e.g. iron content, myelinization), but are dependent on the MR-protocol and often lead to underestimation of GM at higher intensities and overestimation of CSF at lower intensities. Therefore, a local intensity transformation of all tissue classes is used to reduce these effects in the image. This local adaptive segmentation (LAS) is applied before the final AMAP segmentation.Possible Values:  SPM Unified Segmentation: 0  k-means AMAP: 2
-    skull_strip:
-    # type=float|default=2: Method of initial skull-stripping before AMAP segmentation. The SPM approach works quite stable for the majority of data. However, in some rare cases parts of GM (i.e. in frontal lobe) might be cut. If this happens the GCUT approach is a good alternative. GCUT is a graph-cut/region-growing approach starting from the WM area. APRG (adaptive probability region-growing) is a new method that refines the probability maps of the SPM approach by region-growing techniques of the gcut approach with a final surface-based optimization strategy. This is currently the method with the most accurate and reliable results. If you use already skull-stripped data you can turn off skull-stripping although this is automatically detected in most cases. Please note that the choice of the skull-stripping method will also influence the estimation of TIV, because the methods mainly differ in the handling of the outer CSF around the cortical surface.  Possible Values:  - none (already skull-stripped): -1;  - SPM approach: 0;   - GCUT approach: 0.50;   - APRG approach: 2
-    wm_hyper_intensity_correction:
-    # type=int|default=1: WARNING: Please note that the detection of WM hyperintensies is still under development and does not have the same accuracy as approaches that additionally consider FLAIR images (e.g. Lesion Segmentation Toolbox)! In aging or (neurodegenerative) diseases WM intensity can be reduced locally in T1 or increased in T2/PD images. These so-called WM hyperintensies (WMHs) can lead to preprocessing errors. Large GM areas next to the ventricle can cause normalization problems. Therefore, a temporary correction for normalization is useful if WMHs are expected. CAT allows different ways to handle WMHs:  0) No Correction (handled as GM).  1) Temporary (internal) correction as WM for spatial normalization and estimation of cortical thickness.  2) Permanent correction to WM. 
-    voxel_size:
-    # type=float|default=1.5: The (isotropic) voxel sizes of any spatially normalised written images. A non-finite value will be replaced by the average voxel size of the tissue probability maps used by the segmentation.
-    internal_resampling_process:
-    # type=tuple|default=(1, 0.1): help_resampling
-    ignore_errors:
-    # type=int|default=1: Error handling. Try to catch preprocessing errors and continue with the next data set or ignore all warnings (e.g., bad intensities) and use an experimental pipeline which is still in development. In case of errors, CAT continues with the next subject if this option is enabled. If the experimental option with backup functions is selected and warnings occur, CAT will try to use backup routines and skip some processing steps which require good T1 contrasts (e.g., LAS). If you want to avoid processing of critical data and ensure that only the main pipeline is used then select the option "Ignore errors (continue with the next subject)". It is strongly recommended to check for preprocessing problems, especially with non-T1 contrasts.  Values: none: 0, default: 1, details: 2.
-    surface_and_thickness_estimation:
-    # type=int|default=1: Surface and thickness estimation.  Use projection-based thickness (PBT) (Dahnke et al. 2012) to estimate cortical thickness and to create the central cortical surface for left and right hemisphere. Surface reconstruction includes topology correction (Yotter et al. 2011), spherical inflation (Yotter et al.) and spherical registration. Additionally you can also estimate surface parameters such as gyrification, cortical complexity or sulcal depth that can be subsequently analyzed at each vertex of the surface. Please note, that surface reconstruction and spherical registration additionally requires about 20-60 min of computation time. A fast (1-3 min) surface pipeline is available for visual preview (e.g., to check preprocessing quality) in the cross-sectional, but not in the longitudinal pipeline.  Only the initial surfaces are created with a lower resolution and without topology correction, spherical mapping and surface registration. Please note that the files with the estimated surface thickness can therefore not be used for further analysis!  For distinction, these files contain "preview" in their filename and they are not available as batch dependencies objects. 
-    surface_measures:
-    # type=int|default=1: Extract surface measures
-    neuromorphometrics:
-    # type=bool|default=True: Extract brain measures for Neuromorphometrics template
-    lpba40:
-    # type=bool|default=True: Extract brain measures for LPBA40 template
-    cobra:
-    # type=bool|default=True: Extract brain measures for COBRA template
-    hammers:
-    # type=bool|default=True: Extract brain measures for Hammers template
-    own_atlas:
-    # type=inputmultiobject|default=[]: Extract brain measures for a given template
-    gm_output_native:
-    # type=bool|default=False: Save modulated grey matter images.
-    gm_output_modulated:
-    # type=bool|default=True: Save native grey matter images.
-    gm_output_dartel:
-    # type=bool|default=False: Save dartel grey matter images.
-    wm_output_native:
-    # type=bool|default=False: Save dartel white matter images.
-    wm_output_modulated:
-    # type=bool|default=True: Save dartel white matter images.
-    wm_output_dartel:
-    # type=bool|default=False: Save dartel white matter images.
-    csf_output_native:
-    # type=bool|default=False: Save dartel CSF images.
-    csf_output_modulated:
-    # type=bool|default=True: Save dartel CSF images.
-    csf_output_dartel:
-    # type=bool|default=False: Save dartel CSF images.
-    label_native:
-    # type=bool|default=False: This is the option to save a labeled version of your segmentations in the native space for fast visual comparison. Labels are saved as Partial Volume Estimation (PVE) values with different mix classes for GM-WM (2.5) and GM-CSF (1.5). BG=0, CSF=1, GM=2, WM=3, WMH=4 (if WMHC=3), SL=1.5 (if SLC)
-    label_warped:
-    # type=bool|default=True: This is the option to save a labeled version of your segmentations in the warped space for fast visual comparison. Labels are saved as Partial Volume Estimation (PVE) values with different mix classes for GM-WM (2.5) and GM-CSF (1.5). BG=0, CSF=1, GM=2, WM=3, WMH=4 (if WMHC=3), SL=1.5 (if SLC)
-    label_dartel:
-    # type=bool|default=False: This is the option to save a labeled version of your segmentations in the dartel space for fast visual comparison. Labels are saved as Partial Volume Estimation (PVE) values with different mix classes for GM-WM (2.5) and GM-CSF (1.5). BG=0, CSF=1, GM=2, WM=3, WMH=4 (if WMHC=3), SL=1.5 (if SLC)
-    output_labelnative:
-    # type=bool|default=False: This is the option to save a labeled version of your segmentations in the native space for fast visual comparison. Labels are saved as Partial Volume Estimation (PVE) values with different mix classes for GM-WM (2.5) and GM-CSF (1.5). BG=0, CSF=1, GM=2, WM=3, WMH=4 (if WMHC=3), SL=1.5 (if SLC)
-    save_bias_corrected:
-    # type=bool|default=True: Save bias corrected image
-    las_native:
-    # type=bool|default=False: This is the option to save a bias, noise, and local intensity corrected version of the original T1 image in the native space. MR images are usually corrupted by a smooth, spatially varying artifact that modulates the intensity of the image (bias). These artifacts, although not usually a problem for visual inspection, can impede automated processing of the images. The bias corrected version should have more uniform intensities within the different types of tissues and can be saved in native space and/or normalised. Noise is corrected by an adaptive non-local mean (NLM) filter (Manjon 2008, Medical Image Analysis 12).
-    las_warped:
-    # type=bool|default=True: This is the option to save a bias, noise, and local intensity corrected version of the original T1 image in the warped space. MR images are usually corrupted by a smooth, spatially varying artifact that modulates the intensity of the image (bias). These artifacts, although not usually a problem for visual inspection, can impede automated processing of the images. The bias corrected version should have more uniform intensities within the different types of tissues and can be saved in native space and/or normalised. Noise is corrected by an adaptive non-local mean (NLM) filter (Manjon 2008, Medical Image Analysis 12).
-    las_dartel:
-    # type=bool|default=False: This is the option to save a bias, noise, and local intensity corrected version of the original T1 image in the dartel space. MR images are usually corrupted by a smooth, spatially varying artifact that modulates the intensity of the image (bias). These artifacts, although not usually a problem for visual inspection, can impede automated processing of the images. The bias corrected version should have more uniform intensities within the different types of tissues and can be saved in native space and/or normalised. Noise is corrected by an adaptive non-local mean (NLM) filter (Manjon 2008, Medical Image Analysis 12).
-    jacobianwarped:
-    # type=bool|default=True: This is the option to save the Jacobian determinant, which expresses local volume changes. This image can be used in a pure deformation based morphometry (DBM) design. Please note that the affine part of the deformation field is ignored. Thus, there is no need for any additional correction for different brain sizes using ICV.
-    warps:
-    # type=tuple|default=(1, 0): Deformation fields can be saved to disk, and used by the Deformations Utility and/or applied to coregistered data from other modalities (e.g. fMRI). For spatially normalising images to MNI space, you will need the forward deformation, whereas for spatially normalising (eg) GIFTI surface files, youll need the inverse. It is also possible to transform data in MNI space on to the individual subject, which also requires the inverse transform. Deformations are saved as .nii files, which contain three volumes to encode the x, y and z coordinates. Values: No:[0 0]; Image->Template (forward): [1 0]; Template->Image (inverse): [0 1];  inverse + forward: [1 1]
-    matlab_cmd:
-    # type=str|default='': matlab command to use
-    paths:
-    # type=inputmultiobject|default=[]: Paths to add to matlabpath
-    mfile:
-    # type=bool|default=True: Run m-code using m-file
-    use_mcr:
-    # type=bool|default=False: Run m-code using SPM MCR
-    use_v8struct:
-    # type=bool|default=True: Generate SPM8 and higher compatible jobs
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-cat12/cat12_segment_callables.py b/example-specs/task/nipype_internal/pydra-cat12/cat12_segment_callables.py
deleted file mode 100644
index b548e2e7..00000000
--- a/example-specs/task/nipype_internal/pydra-cat12/cat12_segment_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in CAT12Segment.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-cat12/cat12sanlm_denoising.yaml b/example-specs/task/nipype_internal/pydra-cat12/cat12sanlm_denoising.yaml
deleted file mode 100644
index ca88f4f5..00000000
--- a/example-specs/task/nipype_internal/pydra-cat12/cat12sanlm_denoising.yaml
+++ /dev/null
@@ -1,116 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.cat12.preprocess.CAT12SANLMDenoising' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Spatially adaptive non-local means (SANLM) denoising filter
-# 
-#     This  function  applies  an spatial adaptive (sub-resolution) non-local means denoising filter
-#     to  the  data.  This  filter  will  remove  noise  while  preserving  edges. The filter strength is
-#     automatically estimated based on the standard deviation of the noise.
-# 
-#     This   filter   is  internally  used  in  the  segmentation  procedure  anyway.  Thus,  it  is  not
-#     necessary (and not recommended) to apply the filter before segmentation.
-#     ______________________________________________________________________
-#     Christian Gaser, Robert Dahnke
-#     Structural Brain Mapping Group (http://www.neuro.uni-jena.de)
-#     Departments of Neurology and Psychiatry
-#     Jena University Hospital
-#     ______________________________________________________________________
-# 
-#     Examples
-#     --------
-#     >>> from nipype.interfaces import cat12
-#     >>> c = cat12.CAT12SANLMDenoising()
-#     >>> c.inputs.in_files = 'anatomical.nii'
-#     >>> c.run() # doctest: +SKIP
-#     
-task_name: CAT12SANLMDenoising
-nipype_name: CAT12SANLMDenoising
-nipype_module: nipype.interfaces.cat12.preprocess
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    paths: generic/directory+list-of
-    # type=inputmultiobject|default=[]: Paths to add to matlabpath
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    out_file: generic/file
-    # type=file: out file
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_files:
-    # type=inputmultiobject|default=[]: Images for filtering.
-    spm_type:
-    # type=enum|default='float32'|allowed['float32','same','uint16','uint8']: Data type of the output images. 'same' matches the input image type.
-    intlim:
-    # type=int|default=100: intensity limitation (default = 100)
-    filename_prefix:
-    # type=str|default='sanlm_': Filename prefix. Specify  the  string  to be prepended to the filenames of the filtered image file(s).
-    filename_suffix:
-    # type=str|default='': Filename suffix. Specify  the  string  to  be  appended  to the filenames of the filtered image file(s).
-    addnoise:
-    # type=float|default=0.5: Strength of additional noise in noise-free regions.         Add  minimal  amount  of noise in regions without any noise to avoid image segmentation problems.         This parameter defines the strength of additional noise as percentage of the average signal intensity.
-    rician:
-    # type=bool|default=True: Rician noise         MRIs  can  have  Gaussian  or  Rician  distributed  noise with uniform or nonuniform variance across the image.         If SNR is high enough (>3)  noise  can  be  well  approximated by Gaussian noise in the foreground. However, for         SENSE reconstruction or DTI data a Rician distribution is expected. Please note that the Rician noise estimation         is sensitive for large signals in the neighbourhood and can lead to artefacts, e.g. cortex can be affected by         very high values in the scalp or in blood vessels.
-    replace_nan_and_inf:
-    # type=bool|default=True: Replace NAN by 0, -INF by the minimum and INF by the maximum of the image.
-    noisecorr_strength:
-    # type=enum|default='-Inf'|allowed['-Inf',2,4]: Strength of Noise Corrections         Strength  of  the  (sub-resolution)  spatial  adaptive    non local means (SANLM) noise correction. Please note         that the filter strength is automatically  estimated.  Change this parameter only for specific conditions. The         "light" option applies half of the filter strength of the adaptive  "medium"  cases,  whereas  the  "strong"         option  uses  the  full  filter  strength,  force sub-resolution filtering and applies an additional  iteration.         Sub-resolution  filtering  is  only  used  in  case  of  high image resolution below 0.8 mm or in case of the         "strong" option. light = 2, medium = -Inf, strong = 4
-    matlab_cmd:
-    # type=str|default='': matlab command to use
-    paths:
-    # type=inputmultiobject|default=[]: Paths to add to matlabpath
-    mfile:
-    # type=bool|default=True: Run m-code using m-file
-    use_mcr:
-    # type=bool|default=False: Run m-code using SPM MCR
-    use_v8struct:
-    # type=bool|default=True: Generate SPM8 and higher compatible jobs
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-cat12/cat12sanlm_denoising_callables.py b/example-specs/task/nipype_internal/pydra-cat12/cat12sanlm_denoising_callables.py
deleted file mode 100644
index b4652138..00000000
--- a/example-specs/task/nipype_internal/pydra-cat12/cat12sanlm_denoising_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in CAT12SANLMDenoising.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-cat12/extract_additional_surface_parameters.yaml b/example-specs/task/nipype_internal/pydra-cat12/extract_additional_surface_parameters.yaml
deleted file mode 100644
index 0afd2706..00000000
--- a/example-specs/task/nipype_internal/pydra-cat12/extract_additional_surface_parameters.yaml
+++ /dev/null
@@ -1,118 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.cat12.surface.ExtractAdditionalSurfaceParameters' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Additional surface parameters can be extracted that can be used for statistical analysis, such as:
-# 
-#     * Central surfaces
-#     * Surface area
-#     * Surface GM volume
-#     * Gyrification Index
-#     * Sulcus depth
-#     * Toro's gyrification index
-#     * Shaer's local gyrification index
-#     * Laplacian gyrification indices
-#     * Addicional surfaces
-#     * Measure normalization
-#     * Lazy processing
-# 
-#     http://www.neuro.uni-jena.de/cat12/CAT12-Manual.pdf#page=53
-# 
-#     Examples
-#     --------
-#     >>> # Set the left surface files, both will be processed
-#     >>> lh_path_central = 'lh.central.structural.gii'
-#     >>> # Put here all surface files generated by CAT12 Segment, this is only required if the this approach is putted in
-#     >>> surf_files = ['lh.sphere.reg.structural.gii', 'rh.sphere.reg.structural.gii', 'lh.sphere.structural.gii', 'rh.sphere.structural.gii', 'rh.central.structural.gii', 'lh.pbt.structural', 'rh.pbt.structural']
-#     >>> extract_additional_measures = ExtractAdditionalSurfaceParameters(left_central_surfaces=lh_path_central, surface_files=surf_files)
-#     >>> extract_additional_measures.run() # doctest: +SKIP
-# 
-#     
-task_name: ExtractAdditionalSurfaceParameters
-nipype_name: ExtractAdditionalSurfaceParameters
-nipype_module: nipype.interfaces.cat12.surface
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    left_central_surfaces: generic/file+list-of
-    # type=inputmultiobject|default=[]: Left and central surfaces files
-    surface_files: generic/file+list-of
-    # type=inputmultiobject|default=[]: All surface files
-    paths: generic/directory+list-of
-    # type=inputmultiobject|default=[]: Paths to add to matlabpath
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    left_central_surfaces:
-    # type=inputmultiobject|default=[]: Left and central surfaces files
-    surface_files:
-    # type=inputmultiobject|default=[]: All surface files
-    gyrification:
-    # type=bool|default=True: Extract gyrification index (GI) based on absolute mean curvature. The method is described in Luders et al. Neuroimage, 29:1224-1230, 2006
-    gmv:
-    # type=bool|default=True: Extract volume
-    area:
-    # type=bool|default=True: Extract area surface
-    depth:
-    # type=bool|default=False: Extract sulcus depth based on euclidean distance between the central surface anf its convex hull.
-    fractal_dimension:
-    # type=bool|default=False: Extract cortical complexity (fractal dimension) which is described in Yotter ar al. Neuroimage, 56(3): 961-973, 2011
-    matlab_cmd:
-    # type=str|default='': matlab command to use
-    paths:
-    # type=inputmultiobject|default=[]: Paths to add to matlabpath
-    mfile:
-    # type=bool|default=True: Run m-code using m-file
-    use_mcr:
-    # type=bool|default=False: Run m-code using SPM MCR
-    use_v8struct:
-    # type=bool|default=True: Generate SPM8 and higher compatible jobs
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-cat12/extract_additional_surface_parameters_callables.py b/example-specs/task/nipype_internal/pydra-cat12/extract_additional_surface_parameters_callables.py
deleted file mode 100644
index 5c53cded..00000000
--- a/example-specs/task/nipype_internal/pydra-cat12/extract_additional_surface_parameters_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in ExtractAdditionalSurfaceParameters.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-cat12/extract_roi_based_surface_measures.yaml b/example-specs/task/nipype_internal/pydra-cat12/extract_roi_based_surface_measures.yaml
deleted file mode 100644
index c502dc86..00000000
--- a/example-specs/task/nipype_internal/pydra-cat12/extract_roi_based_surface_measures.yaml
+++ /dev/null
@@ -1,117 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.cat12.surface.ExtractROIBasedSurfaceMeasures' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Extract ROI-based surface values
-#     While ROI-based values for VBM (volume) data are automatically saved in the ``label`` folder as XML file it is
-#     necessary to additionally extract these values for surface data (except for thickness which is automatically
-#     extracted during segmentation). This has to be done after preprocessing the data and creating cortical surfaces.
-# 
-#     You can extract ROI-based values for cortical thickness but also for any other surface parameter that was extracted
-#     using the Extract Additional Surface Parameters such as volume, area, depth, gyrification and fractal dimension.
-# 
-# 
-#      http://www.neuro.uni-jena.de/cat12/CAT12-Manual.pdf#page=53
-# 
-#      Examples
-#      --------
-#     >>> # Template surface files
-#     >>> lh_atlas = 'lh.aparc_a2009s.freesurfer.annot'
-#     >>> rh_atlas = 'rh.aparc_a2009s.freesurfer.annot'
-#     >>> surf_files = ['lh.sphere.reg.structural.gii', 'rh.sphere.reg.structural.gii', 'lh.sphere.structural.gii', 'rh.sphere.structural.gii', 'lh.central.structural.gii', 'rh.central.structural.gii', 'lh.pbt.structural', 'rh.pbt.structural']
-#     >>> lh_measure = 'lh.area.structural'
-#     >>> extract_additional_measures = ExtractROIBasedSurfaceMeasures(surface_files=surf_files, lh_surface_measure=lh_measure, lh_roi_atlas=lh_atlas, rh_roi_atlas=rh_atlas)
-#     >>> extract_additional_measures.run() # doctest: +SKIP
-# 
-# 
-#     
-task_name: ExtractROIBasedSurfaceMeasures
-nipype_name: ExtractROIBasedSurfaceMeasures
-nipype_module: nipype.interfaces.cat12.surface
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    surface_files: generic/file+list-of
-    # type=inputmultiobject|default=[]: Surface data files. This variable should be a list with all
-    lh_roi_atlas: generic/file+list-of
-    # type=inputmultiobject|default=[]: (Left) ROI Atlas. These are the ROI's 
-    rh_roi_atlas: generic/file+list-of
-    # type=inputmultiobject|default=[]: (Right) ROI Atlas. These are the ROI's 
-    lh_surface_measure: generic/file+list-of
-    # type=inputmultiobject|default=[]: (Left) Surface data files. 
-    rh_surface_measure: generic/file+list-of
-    # type=inputmultiobject|default=[]: (Right) Surface data files.
-    paths: generic/directory+list-of
-    # type=inputmultiobject|default=[]: Paths to add to matlabpath
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    surface_files:
-    # type=inputmultiobject|default=[]: Surface data files. This variable should be a list with all
-    lh_roi_atlas:
-    # type=inputmultiobject|default=[]: (Left) ROI Atlas. These are the ROI's 
-    rh_roi_atlas:
-    # type=inputmultiobject|default=[]: (Right) ROI Atlas. These are the ROI's 
-    lh_surface_measure:
-    # type=inputmultiobject|default=[]: (Left) Surface data files. 
-    rh_surface_measure:
-    # type=inputmultiobject|default=[]: (Right) Surface data files.
-    matlab_cmd:
-    # type=str|default='': matlab command to use
-    paths:
-    # type=inputmultiobject|default=[]: Paths to add to matlabpath
-    mfile:
-    # type=bool|default=True: Run m-code using m-file
-    use_mcr:
-    # type=bool|default=False: Run m-code using SPM MCR
-    use_v8struct:
-    # type=bool|default=True: Generate SPM8 and higher compatible jobs
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-cat12/extract_roi_based_surface_measures_callables.py b/example-specs/task/nipype_internal/pydra-cat12/extract_roi_based_surface_measures_callables.py
deleted file mode 100644
index 554c68d2..00000000
--- a/example-specs/task/nipype_internal/pydra-cat12/extract_roi_based_surface_measures_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in ExtractROIBasedSurfaceMeasures.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-cmtk/average_networks.yaml b/example-specs/task/nipype_internal/pydra-cmtk/average_networks.yaml
deleted file mode 100644
index c4137da3..00000000
--- a/example-specs/task/nipype_internal/pydra-cmtk/average_networks.yaml
+++ /dev/null
@@ -1,97 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.cmtk.nx.AverageNetworks' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Calculates and outputs the average network given a set of input NetworkX gpickle files
-# 
-#     This interface will only keep an edge in the averaged network if that edge is present in
-#     at least half of the input networks.
-# 
-#     Example
-#     -------
-#     >>> import nipype.interfaces.cmtk as cmtk
-#     >>> avg = cmtk.AverageNetworks()
-#     >>> avg.inputs.in_files = ['subj1.pck', 'subj2.pck']
-#     >>> avg.run()         # doctest: +SKIP
-# 
-#     
-task_name: AverageNetworks
-nipype_name: AverageNetworks
-nipype_module: nipype.interfaces.cmtk.nx
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_files: generic/file+list-of
-    # type=inputmultiobject|default=[]: Networks for a group of subjects
-    resolution_network_file: generic/file
-    # type=file|default=<undefined>: Parcellation files from Connectome Mapping Toolkit. This is not necessary, but if included, the interface will output the statistical maps as networkx graphs.
-    out_gpickled_groupavg: generic/file
-    # type=file|default=<undefined>: Average network saved as a NetworkX .pck
-    out_gexf_groupavg: generic/file
-    # type=file|default=<undefined>: Average network saved as a .gexf file
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    gpickled_groupavg: generic/file
-    # type=file: Average network saved as a NetworkX .pck
-    gexf_groupavg: generic/file
-    # type=file: Average network saved as a .gexf file
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_files:
-    # type=inputmultiobject|default=[]: Networks for a group of subjects
-    resolution_network_file:
-    # type=file|default=<undefined>: Parcellation files from Connectome Mapping Toolkit. This is not necessary, but if included, the interface will output the statistical maps as networkx graphs.
-    group_id:
-    # type=str|default='group1': ID for group
-    out_gpickled_groupavg:
-    # type=file|default=<undefined>: Average network saved as a NetworkX .pck
-    out_gexf_groupavg:
-    # type=file|default=<undefined>: Average network saved as a .gexf file
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-cmtk/average_networks_callables.py b/example-specs/task/nipype_internal/pydra-cmtk/average_networks_callables.py
deleted file mode 100644
index 863baeb8..00000000
--- a/example-specs/task/nipype_internal/pydra-cmtk/average_networks_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in AverageNetworks.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-cmtk/cff_converter.yaml b/example-specs/task/nipype_internal/pydra-cmtk/cff_converter.yaml
deleted file mode 100644
index 6d726965..00000000
--- a/example-specs/task/nipype_internal/pydra-cmtk/cff_converter.yaml
+++ /dev/null
@@ -1,137 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.cmtk.convert.CFFConverter' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Creates a Connectome File Format (CFF) file from input networks, surfaces, volumes, tracts, etcetera....
-# 
-#     Example
-#     -------
-# 
-#     >>> import nipype.interfaces.cmtk as cmtk
-#     >>> cvt = cmtk.CFFConverter()
-#     >>> cvt.inputs.title = 'subject 1'
-#     >>> cvt.inputs.gifti_surfaces = ['lh.pial_converted.gii', 'rh.pial_converted.gii']
-#     >>> cvt.inputs.tract_files = ['streamlines.trk']
-#     >>> cvt.inputs.gpickled_networks = ['network0.gpickle']
-#     >>> cvt.run()         # doctest: +SKIP
-#     
-task_name: CFFConverter
-nipype_name: CFFConverter
-nipype_module: nipype.interfaces.cmtk.convert
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    graphml_networks: generic/file+list-of
-    # type=inputmultiobject|default=[]: list of graphML networks
-    gpickled_networks: generic/file+list-of
-    # type=inputmultiobject|default=[]: list of gpickled Networkx graphs
-    gifti_surfaces: generic/file+list-of
-    # type=inputmultiobject|default=[]: list of GIFTI surfaces
-    gifti_labels: generic/file+list-of
-    # type=inputmultiobject|default=[]: list of GIFTI labels
-    nifti_volumes: generic/file+list-of
-    # type=inputmultiobject|default=[]: list of NIFTI volumes
-    tract_files: generic/file+list-of
-    # type=inputmultiobject|default=[]: list of Trackvis fiber files
-    timeseries_files: generic/file+list-of
-    # type=inputmultiobject|default=[]: list of HDF5 timeseries files
-    script_files: generic/file+list-of
-    # type=inputmultiobject|default=[]: list of script files to include
-    data_files: generic/file+list-of
-    # type=inputmultiobject|default=[]: list of external data files (i.e. Numpy, HD5, XML) 
-    out_file: generic/file
-    # type=file|default='connectome.cff': Output connectome file
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    connectome_file: generic/file
-    # type=file: Output connectome file
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    graphml_networks:
-    # type=inputmultiobject|default=[]: list of graphML networks
-    gpickled_networks:
-    # type=inputmultiobject|default=[]: list of gpickled Networkx graphs
-    gifti_surfaces:
-    # type=inputmultiobject|default=[]: list of GIFTI surfaces
-    gifti_labels:
-    # type=inputmultiobject|default=[]: list of GIFTI labels
-    nifti_volumes:
-    # type=inputmultiobject|default=[]: list of NIFTI volumes
-    tract_files:
-    # type=inputmultiobject|default=[]: list of Trackvis fiber files
-    timeseries_files:
-    # type=inputmultiobject|default=[]: list of HDF5 timeseries files
-    script_files:
-    # type=inputmultiobject|default=[]: list of script files to include
-    data_files:
-    # type=inputmultiobject|default=[]: list of external data files (i.e. Numpy, HD5, XML) 
-    title:
-    # type=str|default='': Connectome Title
-    creator:
-    # type=str|default='': Creator
-    email:
-    # type=str|default='': Email address
-    publisher:
-    # type=str|default='': Publisher
-    license:
-    # type=str|default='': License
-    rights:
-    # type=str|default='': Rights
-    references:
-    # type=str|default='': References
-    relation:
-    # type=str|default='': Relation
-    species:
-    # type=str|default='Homo sapiens': Species
-    description:
-    # type=str|default='Created with the Nipype CFF converter': Description
-    out_file:
-    # type=file|default='connectome.cff': Output connectome file
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-cmtk/cff_converter_callables.py b/example-specs/task/nipype_internal/pydra-cmtk/cff_converter_callables.py
deleted file mode 100644
index 80595b06..00000000
--- a/example-specs/task/nipype_internal/pydra-cmtk/cff_converter_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in CFFConverter.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-cmtk/create_matrix.yaml b/example-specs/task/nipype_internal/pydra-cmtk/create_matrix.yaml
deleted file mode 100644
index 9fb195b2..00000000
--- a/example-specs/task/nipype_internal/pydra-cmtk/create_matrix.yaml
+++ /dev/null
@@ -1,145 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.cmtk.cmtk.CreateMatrix' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Performs connectivity mapping and outputs the result as a NetworkX graph and a Matlab matrix
-# 
-#     Example
-#     -------
-# 
-#     >>> import nipype.interfaces.cmtk as cmtk
-#     >>> conmap = cmtk.CreateMatrix()
-#     >>> conmap.inputs.roi_file = 'fsLUT_aparc+aseg.nii'
-#     >>> conmap.inputs.tract_file = 'fibers.trk'
-#     >>> conmap.run()         # doctest: +SKIP
-#     
-task_name: CreateMatrix
-nipype_name: CreateMatrix
-nipype_module: nipype.interfaces.cmtk.cmtk
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    roi_file: generic/file
-    # type=file|default=<undefined>: Freesurfer aparc+aseg file
-    tract_file: generic/file
-    # type=file|default=<undefined>: Trackvis tract file
-    resolution_network_file: generic/file
-    # type=file|default=<undefined>: Parcellation files from Connectome Mapping Toolkit
-    out_matrix_mat_file: generic/file
-    # type=file|default='cmatrix.mat': Matlab matrix describing the connectivity
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    matrix_file: generic/file
-    # type=file: NetworkX graph describing the connectivity
-    intersection_matrix_file: generic/file
-    # type=file: NetworkX graph describing the connectivity
-    matrix_mat_file: generic/file
-    # type=file: Matlab matrix describing the connectivity
-    intersection_matrix_mat_file: generic/file
-    # type=file: Matlab matrix describing the mean fiber lengths between each node.
-    mean_fiber_length_matrix_mat_file: generic/file
-    # type=file: Matlab matrix describing the mean fiber lengths between each node.
-    median_fiber_length_matrix_mat_file: generic/file
-    # type=file: Matlab matrix describing the median fiber lengths between each node.
-    fiber_length_std_matrix_mat_file: generic/file
-    # type=file: Matlab matrix describing the deviation in fiber lengths connecting each node.
-    endpoint_file: generic/file
-    # type=file: Saved Numpy array with the endpoints of each fiber
-    endpoint_file_mm: generic/file
-    # type=file: Saved Numpy array with the endpoints of each fiber (in millimeters)
-    fiber_length_file: generic/file
-    # type=file: Saved Numpy array with the lengths of each fiber
-    fiber_label_file: generic/file
-    # type=file: Saved Numpy array with the labels for each fiber
-    fiber_labels_noorphans: generic/file
-    # type=file: Saved Numpy array with the labels for each non-orphan fiber
-    filtered_tractography: generic/file
-    # type=file: TrackVis file containing only those fibers originate in one and terminate in another region
-    filtered_tractography_by_intersections: generic/file
-    # type=file: TrackVis file containing all fibers which connect two regions
-    stats_file: generic/file
-    # type=file: Saved Matlab .mat file with the number of fibers saved at each stage
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    out_matrix_file: out_matrix_file
-    # type=file|default=<undefined>: NetworkX graph describing the connectivity
-    out_mean_fiber_length_matrix_mat_file: out_mean_fiber_length_matrix_mat_file
-    # type=file|default=<undefined>: Matlab matrix describing the mean fiber lengths between each node.
-    out_median_fiber_length_matrix_mat_file: out_median_fiber_length_matrix_mat_file
-    # type=file|default=<undefined>: Matlab matrix describing the mean fiber lengths between each node.
-    out_fiber_length_std_matrix_mat_file: out_fiber_length_std_matrix_mat_file
-    # type=file|default=<undefined>: Matlab matrix describing the deviation in fiber lengths connecting each node.
-    out_intersection_matrix_mat_file: out_intersection_matrix_mat_file
-    # type=file|default=<undefined>: Matlab connectivity matrix if all region/fiber intersections are counted.
-    out_endpoint_array_name: out_endpoint_array_name
-    # type=file|default=<undefined>: Name for the generated endpoint arrays
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    roi_file:
-    # type=file|default=<undefined>: Freesurfer aparc+aseg file
-    tract_file:
-    # type=file|default=<undefined>: Trackvis tract file
-    resolution_network_file:
-    # type=file|default=<undefined>: Parcellation files from Connectome Mapping Toolkit
-    count_region_intersections:
-    # type=bool|default=False: Counts all of the fiber-region traversals in the connectivity matrix (requires significantly more computational time)
-    out_matrix_file:
-    # type=file|default=<undefined>: NetworkX graph describing the connectivity
-    out_matrix_mat_file:
-    # type=file|default='cmatrix.mat': Matlab matrix describing the connectivity
-    out_mean_fiber_length_matrix_mat_file:
-    # type=file|default=<undefined>: Matlab matrix describing the mean fiber lengths between each node.
-    out_median_fiber_length_matrix_mat_file:
-    # type=file|default=<undefined>: Matlab matrix describing the mean fiber lengths between each node.
-    out_fiber_length_std_matrix_mat_file:
-    # type=file|default=<undefined>: Matlab matrix describing the deviation in fiber lengths connecting each node.
-    out_intersection_matrix_mat_file:
-    # type=file|default=<undefined>: Matlab connectivity matrix if all region/fiber intersections are counted.
-    out_endpoint_array_name:
-    # type=file|default=<undefined>: Name for the generated endpoint arrays
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-cmtk/create_matrix_callables.py b/example-specs/task/nipype_internal/pydra-cmtk/create_matrix_callables.py
deleted file mode 100644
index e4f4d6a6..00000000
--- a/example-specs/task/nipype_internal/pydra-cmtk/create_matrix_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in CreateMatrix.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-cmtk/create_nodes.yaml b/example-specs/task/nipype_internal/pydra-cmtk/create_nodes.yaml
deleted file mode 100644
index b21a82f1..00000000
--- a/example-specs/task/nipype_internal/pydra-cmtk/create_nodes.yaml
+++ /dev/null
@@ -1,87 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.cmtk.cmtk.CreateNodes' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Generates a NetworkX graph containing nodes at the centroid of each region in the input ROI file.
-#     Node data is added from the resolution network file.
-# 
-#     Example
-#     -------
-# 
-#     >>> import nipype.interfaces.cmtk as cmtk
-#     >>> mknode = cmtk.CreateNodes()
-#     >>> mknode.inputs.roi_file = 'ROI_scale500.nii.gz'
-#     >>> mknode.run() # doctest: +SKIP
-#     
-task_name: CreateNodes
-nipype_name: CreateNodes
-nipype_module: nipype.interfaces.cmtk.cmtk
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    roi_file: generic/file
-    # type=file|default=<undefined>: Region of interest file
-    resolution_network_file: generic/file
-    # type=file|default=<undefined>: Parcellation file from Connectome Mapping Toolkit
-    out_filename: generic/file
-    # type=file|default='nodenetwork.pck': Output gpickled network with the nodes defined.
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    node_network: generic/file
-    # type=file: Output gpickled network with the nodes defined.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    roi_file:
-    # type=file|default=<undefined>: Region of interest file
-    resolution_network_file:
-    # type=file|default=<undefined>: Parcellation file from Connectome Mapping Toolkit
-    out_filename:
-    # type=file|default='nodenetwork.pck': Output gpickled network with the nodes defined.
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-cmtk/create_nodes_callables.py b/example-specs/task/nipype_internal/pydra-cmtk/create_nodes_callables.py
deleted file mode 100644
index b9c411cb..00000000
--- a/example-specs/task/nipype_internal/pydra-cmtk/create_nodes_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in CreateNodes.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-cmtk/merge_c_networks.yaml b/example-specs/task/nipype_internal/pydra-cmtk/merge_c_networks.yaml
deleted file mode 100644
index 0ba17877..00000000
--- a/example-specs/task/nipype_internal/pydra-cmtk/merge_c_networks.yaml
+++ /dev/null
@@ -1,82 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.cmtk.convert.MergeCNetworks' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Merges networks from multiple CFF files into one new CFF file.
-# 
-#     Example
-#     -------
-# 
-#     >>> import nipype.interfaces.cmtk as cmtk
-#     >>> mrg = cmtk.MergeCNetworks()
-#     >>> mrg.inputs.in_files = ['subj1.cff','subj2.cff']
-#     >>> mrg.run()          # doctest: +SKIP
-# 
-#     
-task_name: MergeCNetworks
-nipype_name: MergeCNetworks
-nipype_module: nipype.interfaces.cmtk.convert
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_files: generic/file+list-of
-    # type=inputmultiobject|default=[]: List of CFF files to extract networks from
-    out_file: generic/file
-    # type=file|default='merged_network_connectome.cff': Output CFF file with all the networks added
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    connectome_file: generic/file
-    # type=file: Output CFF file with all the networks added
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_files:
-    # type=inputmultiobject|default=[]: List of CFF files to extract networks from
-    out_file:
-    # type=file|default='merged_network_connectome.cff': Output CFF file with all the networks added
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-cmtk/merge_c_networks_callables.py b/example-specs/task/nipype_internal/pydra-cmtk/merge_c_networks_callables.py
deleted file mode 100644
index 399f1205..00000000
--- a/example-specs/task/nipype_internal/pydra-cmtk/merge_c_networks_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in MergeCNetworks.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-cmtk/network_based_statistic.yaml b/example-specs/task/nipype_internal/pydra-cmtk/network_based_statistic.yaml
deleted file mode 100644
index f387d96a..00000000
--- a/example-specs/task/nipype_internal/pydra-cmtk/network_based_statistic.yaml
+++ /dev/null
@@ -1,110 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.cmtk.nbs.NetworkBasedStatistic' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Calculates and outputs the average network given a set of input NetworkX gpickle files
-# 
-#     See Also
-#     --------
-#     For documentation of Network-based statistic parameters:
-#     https://github.com/LTS5/connectomeviewer/blob/master/cviewer/libs/pyconto/groupstatistics/nbs/_nbs.py
-# 
-#     Example
-#     -------
-#     >>> import nipype.interfaces.cmtk as cmtk
-#     >>> nbs = cmtk.NetworkBasedStatistic()
-#     >>> nbs.inputs.in_group1 = ['subj1.pck', 'subj2.pck'] # doctest: +SKIP
-#     >>> nbs.inputs.in_group2 = ['pat1.pck', 'pat2.pck'] # doctest: +SKIP
-#     >>> nbs.run()         # doctest: +SKIP
-# 
-#     
-task_name: NetworkBasedStatistic
-nipype_name: NetworkBasedStatistic
-nipype_module: nipype.interfaces.cmtk.nbs
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_group1: generic/file+list-of
-    # type=inputmultiobject|default=[]: Networks for the first group of subjects
-    in_group2: generic/file+list-of
-    # type=inputmultiobject|default=[]: Networks for the second group of subjects
-    node_position_network: generic/file
-    # type=file|default=<undefined>: An optional network used to position the nodes for the output networks
-    out_nbs_network: generic/file
-    # type=file|default=<undefined>: Output network with edges identified by the NBS
-    out_nbs_pval_network: generic/file
-    # type=file|default=<undefined>: Output network with p-values to weight the edges identified by the NBS
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    nbs_network: generic/file
-    # type=file: Output network with edges identified by the NBS
-    nbs_pval_network: generic/file
-    # type=file: Output network with p-values to weight the edges identified by the NBS
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_group1:
-    # type=inputmultiobject|default=[]: Networks for the first group of subjects
-    in_group2:
-    # type=inputmultiobject|default=[]: Networks for the second group of subjects
-    node_position_network:
-    # type=file|default=<undefined>: An optional network used to position the nodes for the output networks
-    number_of_permutations:
-    # type=int|default=1000: Number of permutations to perform
-    threshold:
-    # type=float|default=3: T-statistic threshold
-    t_tail:
-    # type=enum|default='left'|allowed['both','left','right']: Can be one of "left", "right", or "both"
-    edge_key:
-    # type=str|default='number_of_fibers': Usually "number_of_fibers, "fiber_length_mean", "fiber_length_std" for matrices made with CMTKSometimes "weight" or "value" for functional networks.
-    out_nbs_network:
-    # type=file|default=<undefined>: Output network with edges identified by the NBS
-    out_nbs_pval_network:
-    # type=file|default=<undefined>: Output network with p-values to weight the edges identified by the NBS
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-cmtk/network_based_statistic_callables.py b/example-specs/task/nipype_internal/pydra-cmtk/network_based_statistic_callables.py
deleted file mode 100644
index 913112fe..00000000
--- a/example-specs/task/nipype_internal/pydra-cmtk/network_based_statistic_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in NetworkBasedStatistic.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-cmtk/network_x_metrics.yaml b/example-specs/task/nipype_internal/pydra-cmtk/network_x_metrics.yaml
deleted file mode 100644
index 457bacb1..00000000
--- a/example-specs/task/nipype_internal/pydra-cmtk/network_x_metrics.yaml
+++ /dev/null
@@ -1,122 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.cmtk.nx.NetworkXMetrics' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Calculates and outputs NetworkX-based measures for an input network
-# 
-#     Example
-#     -------
-#     >>> import nipype.interfaces.cmtk as cmtk
-#     >>> nxmetrics = cmtk.NetworkXMetrics()
-#     >>> nxmetrics.inputs.in_file = 'subj1.pck'
-#     >>> nxmetrics.run()         # doctest: +SKIP
-# 
-#     
-task_name: NetworkXMetrics
-nipype_name: NetworkXMetrics
-nipype_module: nipype.interfaces.cmtk.nx
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_file: generic/file
-    # type=file|default=<undefined>: Input network
-    out_k_core: generic/file
-    # type=file|default='k_core': Computed k-core network stored as a NetworkX pickle.
-    out_k_shell: generic/file
-    # type=file|default='k_shell': Computed k-shell network stored as a NetworkX pickle.
-    out_k_crust: generic/file
-    # type=file|default='k_crust': Computed k-crust network stored as a NetworkX pickle.
-    out_pickled_extra_measures: generic/file
-    # type=file|default='extra_measures': Network measures for group 1 that return dictionaries stored as a Pickle.
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    global_measures_matlab: generic/file
-    # type=file: Output global metrics in MATLAB .mat format
-    node_measures_matlab: generic/file
-    # type=file: Output node metrics in MATLAB .mat format
-    edge_measures_matlab: generic/file
-    # type=file: Output edge metrics in MATLAB .mat format
-    k_core: generic/file
-    # type=file: Computed k-core network stored as a NetworkX pickle.
-    k_shell: generic/file
-    # type=file: Computed k-shell network stored as a NetworkX pickle.
-    k_crust: generic/file
-    # type=file: Computed k-crust network stored as a NetworkX pickle.
-    pickled_extra_measures: generic/file
-    # type=file: Network measures for the group that return dictionaries, stored as a Pickle.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    out_global_metrics_matlab: out_global_metrics_matlab
-    # type=file|default=<undefined>: Output node metrics in MATLAB .mat format
-    out_node_metrics_matlab: out_node_metrics_matlab
-    # type=file|default=<undefined>: Output node metrics in MATLAB .mat format
-    out_edge_metrics_matlab: out_edge_metrics_matlab
-    # type=file|default=<undefined>: Output edge metrics in MATLAB .mat format
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: Input network
-    out_k_core:
-    # type=file|default='k_core': Computed k-core network stored as a NetworkX pickle.
-    out_k_shell:
-    # type=file|default='k_shell': Computed k-shell network stored as a NetworkX pickle.
-    out_k_crust:
-    # type=file|default='k_crust': Computed k-crust network stored as a NetworkX pickle.
-    treat_as_weighted_graph:
-    # type=bool|default=True: Some network metrics can be calculated while considering only a binarized version of the graph
-    compute_clique_related_measures:
-    # type=bool|default=False: Computing clique-related measures (e.g. node clique number) can be very time consuming
-    out_global_metrics_matlab:
-    # type=file|default=<undefined>: Output node metrics in MATLAB .mat format
-    out_node_metrics_matlab:
-    # type=file|default=<undefined>: Output node metrics in MATLAB .mat format
-    out_edge_metrics_matlab:
-    # type=file|default=<undefined>: Output edge metrics in MATLAB .mat format
-    out_pickled_extra_measures:
-    # type=file|default='extra_measures': Network measures for group 1 that return dictionaries stored as a Pickle.
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-cmtk/network_x_metrics_callables.py b/example-specs/task/nipype_internal/pydra-cmtk/network_x_metrics_callables.py
deleted file mode 100644
index 75555b38..00000000
--- a/example-specs/task/nipype_internal/pydra-cmtk/network_x_metrics_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in NetworkXMetrics.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-cmtk/parcellate.yaml b/example-specs/task/nipype_internal/pydra-cmtk/parcellate.yaml
deleted file mode 100644
index 8a91af56..00000000
--- a/example-specs/task/nipype_internal/pydra-cmtk/parcellate.yaml
+++ /dev/null
@@ -1,113 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.cmtk.parcellation.Parcellate' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Subdivides segmented ROI file into smaller subregions
-# 
-#     This interface implements the same procedure as in the ConnectomeMapper's
-#     parcellation stage (cmp/stages/parcellation/maskcreation.py) for a single
-#     parcellation scheme (e.g. 'scale500').
-# 
-#     Example
-#     -------
-# 
-#     >>> import nipype.interfaces.cmtk as cmtk
-#     >>> parcellate = cmtk.Parcellate()
-#     >>> parcellate.inputs.freesurfer_dir = '.'
-#     >>> parcellate.inputs.subjects_dir = '.'
-#     >>> parcellate.inputs.subject_id = 'subj1'
-#     >>> parcellate.inputs.dilation = True
-#     >>> parcellate.inputs.parcellation_name = 'scale500'
-#     >>> parcellate.run()         # doctest: +SKIP
-#     
-task_name: Parcellate
-nipype_name: Parcellate
-nipype_module: nipype.interfaces.cmtk.parcellation
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    freesurfer_dir: generic/directory
-    # type=directory|default=<undefined>: Freesurfer main directory
-    subjects_dir: generic/directory
-    # type=directory|default=<undefined>: Freesurfer subjects directory
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    roi_file: generic/file
-    # type=file: Region of Interest file for connectivity mapping
-    roiv_file: generic/file
-    # type=file: Region of Interest file for fMRI connectivity mapping
-    white_matter_mask_file: generic/file
-    # type=file: White matter mask file
-    cc_unknown_file: generic/file
-    # type=file: Image file with regions labelled as unknown cortical structures
-    ribbon_file: generic/file
-    # type=file: Image file detailing the cortical ribbon
-    aseg_file: generic/file
-    # type=file: Automated segmentation file converted from Freesurfer "subjects" directory
-    roi_file_in_structural_space: generic/file
-    # type=file: ROI image resliced to the dimensions of the original structural image
-    dilated_roi_file_in_structural_space: generic/file
-    # type=file: dilated ROI image resliced to the dimensions of the original structural image
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    out_roi_file: out_roi_file
-    # type=file|default=<undefined>: Region of Interest file for connectivity mapping
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    subject_id:
-    # type=string|default='': Subject ID
-    parcellation_name:
-    # type=enum|default='scale500'|allowed['scale125','scale250','scale33','scale500','scale60']: 
-    freesurfer_dir:
-    # type=directory|default=<undefined>: Freesurfer main directory
-    subjects_dir:
-    # type=directory|default=<undefined>: Freesurfer subjects directory
-    out_roi_file:
-    # type=file|default=<undefined>: Region of Interest file for connectivity mapping
-    dilation:
-    # type=bool|default=False: Dilate cortical parcels? Useful for fMRI connectivity
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-cmtk/parcellate_callables.py b/example-specs/task/nipype_internal/pydra-cmtk/parcellate_callables.py
deleted file mode 100644
index f89b306b..00000000
--- a/example-specs/task/nipype_internal/pydra-cmtk/parcellate_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in Parcellate.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-cmtk/roi_gen.yaml b/example-specs/task/nipype_internal/pydra-cmtk/roi_gen.yaml
deleted file mode 100644
index 8ef0ea6f..00000000
--- a/example-specs/task/nipype_internal/pydra-cmtk/roi_gen.yaml
+++ /dev/null
@@ -1,107 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.cmtk.cmtk.ROIGen' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Generates a ROI file for connectivity mapping and a dictionary file containing relevant node information
-# 
-#     Example
-#     -------
-# 
-#     >>> import nipype.interfaces.cmtk as cmtk
-#     >>> rg = cmtk.ROIGen()
-#     >>> rg.inputs.aparc_aseg_file = 'aparc+aseg.nii'
-#     >>> rg.inputs.use_freesurfer_LUT = True
-#     >>> rg.inputs.freesurfer_dir = '/usr/local/freesurfer'
-#     >>> rg.run() # doctest: +SKIP
-# 
-#     The label dictionary is written to disk using Pickle. Resulting data can be loaded using:
-# 
-#     >>> file = open("FreeSurferColorLUT_adapted_aparc+aseg_out.pck", "r")
-#     >>> file = open("fsLUT_aparc+aseg.pck", "r")
-#     >>> labelDict = pickle.load(file) # doctest: +SKIP
-#     >>> labelDict             # doctest: +SKIP
-#     
-task_name: ROIGen
-nipype_name: ROIGen
-nipype_module: nipype.interfaces.cmtk.cmtk
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    aparc_aseg_file: generic/file
-    # type=file|default=<undefined>: Freesurfer aparc+aseg file
-    LUT_file: generic/file
-    # type=file|default=<undefined>: Custom lookup table (cf. FreeSurferColorLUT.txt)
-    freesurfer_dir: generic/directory
-    # type=directory|default=<undefined>: Freesurfer main directory
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    roi_file: generic/file
-    # type=file: Region of Interest file for connectivity mapping
-    dict_file: generic/file
-    # type=file: Label dictionary saved in Pickle format
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    out_roi_file: out_roi_file
-    # type=file|default=<undefined>: Region of Interest file for connectivity mapping
-    out_dict_file: out_dict_file
-    # type=file|default=<undefined>: Label dictionary saved in Pickle format
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    aparc_aseg_file:
-    # type=file|default=<undefined>: Freesurfer aparc+aseg file
-    LUT_file:
-    # type=file|default=<undefined>: Custom lookup table (cf. FreeSurferColorLUT.txt)
-    use_freesurfer_LUT:
-    # type=bool|default=False: Boolean value; Set to True to use default Freesurfer LUT, False for custom LUT
-    freesurfer_dir:
-    # type=directory|default=<undefined>: Freesurfer main directory
-    out_roi_file:
-    # type=file|default=<undefined>: Region of Interest file for connectivity mapping
-    out_dict_file:
-    # type=file|default=<undefined>: Label dictionary saved in Pickle format
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-cmtk/roi_gen_callables.py b/example-specs/task/nipype_internal/pydra-cmtk/roi_gen_callables.py
deleted file mode 100644
index 02d257c5..00000000
--- a/example-specs/task/nipype_internal/pydra-cmtk/roi_gen_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in ROIGen.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dcmstack/copy_meta.yaml b/example-specs/task/nipype_internal/pydra-dcmstack/copy_meta.yaml
deleted file mode 100644
index 80a4aad3..00000000
--- a/example-specs/task/nipype_internal/pydra-dcmstack/copy_meta.yaml
+++ /dev/null
@@ -1,80 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.dcmstack.CopyMeta' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Copy meta data from one Nifti file to another. Useful for preserving
-#     meta data after some processing steps.
-task_name: CopyMeta
-nipype_name: CopyMeta
-nipype_module: nipype.interfaces.dcmstack
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    src_file: generic/file
-    # type=file|default=<undefined>: 
-    dest_file: generic/file
-    # type=file: 
-    # type=file|default=<undefined>: 
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    dest_file: generic/file
-    # type=file: 
-    # type=file|default=<undefined>: 
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    src_file:
-    # type=file|default=<undefined>: 
-    dest_file:
-    # type=file: 
-    # type=file|default=<undefined>: 
-    include_classes:
-    # type=list|default=[]: List of specific meta data classifications to include. If not specified include everything.
-    exclude_classes:
-    # type=list|default=[]: List of meta data classifications to exclude
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-dcmstack/copy_meta_callables.py b/example-specs/task/nipype_internal/pydra-dcmstack/copy_meta_callables.py
deleted file mode 100644
index b657da5f..00000000
--- a/example-specs/task/nipype_internal/pydra-dcmstack/copy_meta_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in CopyMeta.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dcmstack/dcm_stack.yaml b/example-specs/task/nipype_internal/pydra-dcmstack/dcm_stack.yaml
deleted file mode 100644
index 9e1b9441..00000000
--- a/example-specs/task/nipype_internal/pydra-dcmstack/dcm_stack.yaml
+++ /dev/null
@@ -1,94 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.dcmstack.DcmStack' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Create one Nifti file from a set of DICOM files. Can optionally embed
-#     meta data.
-# 
-#     Example
-#     -------
-# 
-#     >>> from nipype.interfaces.dcmstack import DcmStack
-#     >>> stacker = DcmStack()
-#     >>> stacker.inputs.dicom_files = 'path/to/series/'
-#     >>> stacker.run() # doctest: +SKIP
-#     >>> result.outputs.out_file # doctest: +SKIP
-#     '/path/to/cwd/sequence.nii.gz'
-#     
-task_name: DcmStack
-nipype_name: DcmStack
-nipype_module: nipype.interfaces.dcmstack
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    out_path: generic/directory
-    # type=directory|default=<undefined>: output path, current working directory if not set
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    out_file: generic/file
-    # type=file: 
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    dicom_files:
-    # type=traitcompound|default=[None]: 
-    embed_meta:
-    # type=bool|default=False: Embed DICOM meta data into result
-    exclude_regexes:
-    # type=list|default=[]: Meta data to exclude, suplementing any default exclude filters
-    include_regexes:
-    # type=list|default=[]: Meta data to include, overriding any exclude filters
-    force_read:
-    # type=bool|default=True: Force reading files without DICM marker
-    out_format:
-    # type=str|default='': String which can be formatted with meta data to create the output filename(s)
-    out_ext:
-    # type=str|default='.nii.gz': Determines output file type
-    out_path:
-    # type=directory|default=<undefined>: output path, current working directory if not set
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-dcmstack/dcm_stack_callables.py b/example-specs/task/nipype_internal/pydra-dcmstack/dcm_stack_callables.py
deleted file mode 100644
index 394aa6a3..00000000
--- a/example-specs/task/nipype_internal/pydra-dcmstack/dcm_stack_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in DcmStack.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dcmstack/group_and_stack.yaml b/example-specs/task/nipype_internal/pydra-dcmstack/group_and_stack.yaml
deleted file mode 100644
index 87bc591a..00000000
--- a/example-specs/task/nipype_internal/pydra-dcmstack/group_and_stack.yaml
+++ /dev/null
@@ -1,80 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.dcmstack.GroupAndStack' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Create (potentially) multiple Nifti files for a set of DICOM files.
-task_name: GroupAndStack
-nipype_name: GroupAndStack
-nipype_module: nipype.interfaces.dcmstack
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    out_path: generic/directory
-    # type=directory|default=<undefined>: output path, current working directory if not set
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    dicom_files:
-    # type=traitcompound|default=[None]: 
-    embed_meta:
-    # type=bool|default=False: Embed DICOM meta data into result
-    exclude_regexes:
-    # type=list|default=[]: Meta data to exclude, suplementing any default exclude filters
-    include_regexes:
-    # type=list|default=[]: Meta data to include, overriding any exclude filters
-    force_read:
-    # type=bool|default=True: Force reading files without DICM marker
-    out_format:
-    # type=str|default='': String which can be formatted with meta data to create the output filename(s)
-    out_ext:
-    # type=str|default='.nii.gz': Determines output file type
-    out_path:
-    # type=directory|default=<undefined>: output path, current working directory if not set
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-dcmstack/group_and_stack_callables.py b/example-specs/task/nipype_internal/pydra-dcmstack/group_and_stack_callables.py
deleted file mode 100644
index a4ab5d7d..00000000
--- a/example-specs/task/nipype_internal/pydra-dcmstack/group_and_stack_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in GroupAndStack.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dcmstack/lookup_meta.yaml b/example-specs/task/nipype_internal/pydra-dcmstack/lookup_meta.yaml
deleted file mode 100644
index 94817020..00000000
--- a/example-specs/task/nipype_internal/pydra-dcmstack/lookup_meta.yaml
+++ /dev/null
@@ -1,82 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.dcmstack.LookupMeta' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Lookup meta data values from a Nifti with embedded meta data.
-# 
-#     Example
-#     -------
-# 
-#     >>> from nipype.interfaces import dcmstack
-#     >>> lookup = dcmstack.LookupMeta()
-#     >>> lookup.inputs.in_file = 'functional.nii'
-#     >>> lookup.inputs.meta_keys = {'RepetitionTime' : 'TR',                                    'EchoTime' : 'TE'}
-#     >>> result = lookup.run() # doctest: +SKIP
-#     >>> result.outputs.TR # doctest: +SKIP
-#     9500.0
-#     >>> result.outputs.TE # doctest: +SKIP
-#     95.0
-#     
-task_name: LookupMeta
-nipype_name: LookupMeta
-nipype_module: nipype.interfaces.dcmstack
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_file: generic/file
-    # type=file|default=<undefined>: The input Nifti file
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: The input Nifti file
-    meta_keys:
-    # type=traitcompound|default=None: List of meta data keys to lookup, or a dict where keys specify the meta data keys to lookup and the values specify the output names
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-dcmstack/lookup_meta_callables.py b/example-specs/task/nipype_internal/pydra-dcmstack/lookup_meta_callables.py
deleted file mode 100644
index e5cd4092..00000000
--- a/example-specs/task/nipype_internal/pydra-dcmstack/lookup_meta_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in LookupMeta.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dcmstack/merge_nifti.yaml b/example-specs/task/nipype_internal/pydra-dcmstack/merge_nifti.yaml
deleted file mode 100644
index 1a4668fe..00000000
--- a/example-specs/task/nipype_internal/pydra-dcmstack/merge_nifti.yaml
+++ /dev/null
@@ -1,79 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.dcmstack.MergeNifti' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Merge multiple Nifti files into one. Merges together meta data
-#     extensions as well.
-task_name: MergeNifti
-nipype_name: MergeNifti
-nipype_module: nipype.interfaces.dcmstack
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    out_path: generic/directory
-    # type=directory|default=<undefined>: output path, current working directory if not set
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    out_file: generic/file
-    # type=file: Merged Nifti file
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_files:
-    # type=list|default=[]: List of Nifti files to merge
-    sort_order:
-    # type=traitcompound|default=None: One or more meta data keys to sort files by.
-    merge_dim:
-    # type=int|default=0: Dimension to merge along. If not specified, the last singular or non-existent dimension is used.
-    out_format:
-    # type=str|default='': String which can be formatted with meta data to create the output filename(s)
-    out_ext:
-    # type=str|default='.nii.gz': Determines output file type
-    out_path:
-    # type=directory|default=<undefined>: output path, current working directory if not set
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-dcmstack/merge_nifti_callables.py b/example-specs/task/nipype_internal/pydra-dcmstack/merge_nifti_callables.py
deleted file mode 100644
index 18653890..00000000
--- a/example-specs/task/nipype_internal/pydra-dcmstack/merge_nifti_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in MergeNifti.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dcmstack/nifti_generator_base.yaml b/example-specs/task/nipype_internal/pydra-dcmstack/nifti_generator_base.yaml
deleted file mode 100644
index b3090206..00000000
--- a/example-specs/task/nipype_internal/pydra-dcmstack/nifti_generator_base.yaml
+++ /dev/null
@@ -1,63 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.dcmstack.NiftiGeneratorBase' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Base class for interfaces that produce Nifti files, potentially with
-#     embedded meta data.
-task_name: NiftiGeneratorBase
-nipype_name: NiftiGeneratorBase
-nipype_module: nipype.interfaces.dcmstack
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-dcmstack/nifti_generator_base_callables.py b/example-specs/task/nipype_internal/pydra-dcmstack/nifti_generator_base_callables.py
deleted file mode 100644
index 7366fad2..00000000
--- a/example-specs/task/nipype_internal/pydra-dcmstack/nifti_generator_base_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in NiftiGeneratorBase.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dcmstack/split_nifti.yaml b/example-specs/task/nipype_internal/pydra-dcmstack/split_nifti.yaml
deleted file mode 100644
index e7c1dc2d..00000000
--- a/example-specs/task/nipype_internal/pydra-dcmstack/split_nifti.yaml
+++ /dev/null
@@ -1,79 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.dcmstack.SplitNifti' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Split one Nifti file into many along the specified dimension. Each
-#     result has an updated meta data extension as well.
-#     
-task_name: SplitNifti
-nipype_name: SplitNifti
-nipype_module: nipype.interfaces.dcmstack
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_file: generic/file
-    # type=file|default=<undefined>: Nifti file to split
-    out_path: generic/directory
-    # type=directory|default=<undefined>: output path, current working directory if not set
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: Nifti file to split
-    split_dim:
-    # type=int|default=0: Dimension to split along. If not specified, the last dimension is used.
-    out_format:
-    # type=str|default='': String which can be formatted with meta data to create the output filename(s)
-    out_ext:
-    # type=str|default='.nii.gz': Determines output file type
-    out_path:
-    # type=directory|default=<undefined>: output path, current working directory if not set
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-dcmstack/split_nifti_callables.py b/example-specs/task/nipype_internal/pydra-dcmstack/split_nifti_callables.py
deleted file mode 100644
index 7ee89996..00000000
--- a/example-specs/task/nipype_internal/pydra-dcmstack/split_nifti_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in SplitNifti.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-diffusion_toolkit/dti_recon.yaml b/example-specs/task/nipype_internal/pydra-diffusion_toolkit/dti_recon.yaml
deleted file mode 100644
index 6a586140..00000000
--- a/example-specs/task/nipype_internal/pydra-diffusion_toolkit/dti_recon.yaml
+++ /dev/null
@@ -1,114 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.diffusion_toolkit.dti.DTIRecon' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Use dti_recon to generate tensors and other maps
-task_name: DTIRecon
-nipype_name: DTIRecon
-nipype_module: nipype.interfaces.diffusion_toolkit.dti
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    DWI: generic/file
-    # type=file|default=<undefined>: Input diffusion volume
-    bvecs: generic/file
-    # type=file|default=<undefined>: b vectors file
-    bvals: generic/file
-    # type=file|default=<undefined>: b values file
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    ADC: generic/file
-    # type=file: 
-    B0: generic/file
-    # type=file: 
-    L1: generic/file
-    # type=file: 
-    L2: generic/file
-    # type=file: 
-    L3: generic/file
-    # type=file: 
-    exp: generic/file
-    # type=file: 
-    FA: generic/file
-    # type=file: 
-    FA_color: generic/file
-    # type=file: 
-    tensor: generic/file
-    # type=file: 
-    V1: generic/file
-    # type=file: 
-    V2: generic/file
-    # type=file: 
-    V3: generic/file
-    # type=file: 
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    DWI:
-    # type=file|default=<undefined>: Input diffusion volume
-    out_prefix:
-    # type=str|default='dti': Output file prefix
-    output_type:
-    # type=enum|default='nii'|allowed['analyze','ni1','nii','nii.gz']: output file type
-    bvecs:
-    # type=file|default=<undefined>: b vectors file
-    bvals:
-    # type=file|default=<undefined>: b values file
-    n_averages:
-    # type=int|default=0: Number of averages
-    image_orientation_vectors:
-    # type=list|default=[]: Specify image orientation vectors. if just one argument given, will treat it as filename and read the orientation vectors from the file. If 6 arguments are given, will treat them as 6 float numbers and construct the 1st and 2nd vector and calculate the 3rd one automatically. This information will be used to determine image orientation, as well as to adjust gradient vectors with oblique angle when.
-    oblique_correction:
-    # type=bool|default=False: When oblique angle(s) applied, some SIEMENS DTI protocols do not adjust gradient accordingly, thus it requires adjustment for correct diffusion tensor calculation
-    b0_threshold:
-    # type=float|default=0.0: Program will use b0 image with the given threshold to mask out high background of fa/adc maps. by default it will calculate threshold automatically. but if it failed, you need to set it manually.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-diffusion_toolkit/dti_recon_callables.py b/example-specs/task/nipype_internal/pydra-diffusion_toolkit/dti_recon_callables.py
deleted file mode 100644
index a759e3e4..00000000
--- a/example-specs/task/nipype_internal/pydra-diffusion_toolkit/dti_recon_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in DTIRecon.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-diffusion_toolkit/dti_tracker.yaml b/example-specs/task/nipype_internal/pydra-diffusion_toolkit/dti_tracker.yaml
deleted file mode 100644
index fb01efd1..00000000
--- a/example-specs/task/nipype_internal/pydra-diffusion_toolkit/dti_tracker.yaml
+++ /dev/null
@@ -1,122 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.diffusion_toolkit.dti.DTITracker' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-task_name: DTITracker
-nipype_name: DTITracker
-nipype_module: nipype.interfaces.diffusion_toolkit.dti
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    tensor_file: generic/file
-    # type=file|default=<undefined>: reconstructed tensor file
-    mask1_file: generic/file
-    # type=file|default=<undefined>: first mask image
-    mask2_file: generic/file
-    # type=file|default=<undefined>: second mask image
-    output_file: generic/file
-    # type=file|default='tracks.trk': 
-    output_mask: generic/file
-    # type=file|default=<undefined>: output a binary mask file in analyze format
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    track_file: generic/file
-    # type=file: 
-    mask_file: generic/file
-    # type=file: 
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    tensor_file:
-    # type=file|default=<undefined>: reconstructed tensor file
-    input_type:
-    # type=enum|default='nii'|allowed['analyze','ni1','nii','nii.gz']: Input and output file type. Accepted values are:  * analyze -> analyze format 7.5 * ni1     -> nifti format saved in separate .hdr and .img file * nii     -> nifti format with one .nii file * nii.gz  -> nifti format with compression  Default type is 'nii' 
-    tracking_method:
-    # type=enum|default='fact'|allowed['fact','rk2','sl','tl']: Tracking algorithm.  * fact -> use FACT method for tracking. This is the default method. * rk2  -> use 2nd order Runge-Kutta method for tracking. * tl   -> use tensorline method for tracking. * sl   -> use interpolated streamline method with fixed step-length  
-    step_length:
-    # type=float|default=0.0: Step length, in the unit of minimum voxel size. default value is 0.5 for interpolated streamline method and 0.1 for other methods
-    angle_threshold:
-    # type=float|default=0.0: set angle threshold. default value is 35 degree
-    angle_threshold_weight:
-    # type=float|default=0.0: set angle threshold weighting factor. weighting will be applied on top of the angle_threshold
-    random_seed:
-    # type=int|default=0: use random location in a voxel instead of the center of the voxel to seed. can also define number of seed per voxel. default is 1
-    invert_x:
-    # type=bool|default=False: invert x component of the vector
-    invert_y:
-    # type=bool|default=False: invert y component of the vector
-    invert_z:
-    # type=bool|default=False: invert z component of the vector
-    swap_xy:
-    # type=bool|default=False: swap x & y vectors while tracking
-    swap_yz:
-    # type=bool|default=False: swap y & z vectors while tracking
-    swap_zx:
-    # type=bool|default=False: swap x & z vectors while tracking
-    mask1_file:
-    # type=file|default=<undefined>: first mask image
-    mask1_threshold:
-    # type=float|default=0.0: threshold value for the first mask image, if not given, the program will try automatically find the threshold
-    mask2_file:
-    # type=file|default=<undefined>: second mask image
-    mask2_threshold:
-    # type=float|default=0.0: threshold value for the second mask image, if not given, the program will try automatically find the threshold
-    input_data_prefix:
-    # type=str|default='dti': for internal naming use only
-    output_file:
-    # type=file|default='tracks.trk': 
-    output_mask:
-    # type=file|default=<undefined>: output a binary mask file in analyze format
-    primary_vector:
-    # type=enum|default='v2'|allowed['v2','v3']: which vector to use for fibre tracking: v2 or v3. If not set use v1
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-diffusion_toolkit/dti_tracker_callables.py b/example-specs/task/nipype_internal/pydra-diffusion_toolkit/dti_tracker_callables.py
deleted file mode 100644
index 916e0701..00000000
--- a/example-specs/task/nipype_internal/pydra-diffusion_toolkit/dti_tracker_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in DTITracker.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-diffusion_toolkit/hardi_mat.yaml b/example-specs/task/nipype_internal/pydra-diffusion_toolkit/hardi_mat.yaml
deleted file mode 100644
index d7aeb313..00000000
--- a/example-specs/task/nipype_internal/pydra-diffusion_toolkit/hardi_mat.yaml
+++ /dev/null
@@ -1,101 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.diffusion_toolkit.odf.HARDIMat' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Use hardi_mat to calculate a reconstruction matrix from a gradient table
-task_name: HARDIMat
-nipype_name: HARDIMat
-nipype_module: nipype.interfaces.diffusion_toolkit.odf
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    bvecs: generic/file
-    # type=file|default=<undefined>: b vectors file
-    bvals: generic/file
-    # type=file|default=<undefined>: b values file
-    out_file: generic/file
-    # type=file: output matrix file
-    # type=file|default='recon_mat.dat': output matrix file
-    odf_file: generic/file
-    # type=file|default=<undefined>: Filename that contains the reconstruction points on a HEMI-sphere. Use the pre-set 181 points by default
-    reference_file: generic/file
-    # type=file|default=<undefined>: Provide a dicom or nifti image as the reference for the program to figure out the image orientation information. if no such info was found in the given image header, the next 5 options -info, etc., will be used if provided. if image orientation info can be found in the given reference, all other 5 image orientation options will be IGNORED
-    image_info: generic/file
-    # type=file|default=<undefined>: specify image information file. the image info file is generated from original dicom image by diff_unpack program and contains image orientation and other information needed for reconstruction and tracking. by default will look into the image folder for .info file
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    out_file: generic/file
-    # type=file: output matrix file
-    # type=file|default='recon_mat.dat': output matrix file
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    bvecs:
-    # type=file|default=<undefined>: b vectors file
-    bvals:
-    # type=file|default=<undefined>: b values file
-    out_file:
-    # type=file: output matrix file
-    # type=file|default='recon_mat.dat': output matrix file
-    order:
-    # type=int|default=0: maximum order of spherical harmonics. must be even number. default is 4
-    odf_file:
-    # type=file|default=<undefined>: Filename that contains the reconstruction points on a HEMI-sphere. Use the pre-set 181 points by default
-    reference_file:
-    # type=file|default=<undefined>: Provide a dicom or nifti image as the reference for the program to figure out the image orientation information. if no such info was found in the given image header, the next 5 options -info, etc., will be used if provided. if image orientation info can be found in the given reference, all other 5 image orientation options will be IGNORED
-    image_info:
-    # type=file|default=<undefined>: specify image information file. the image info file is generated from original dicom image by diff_unpack program and contains image orientation and other information needed for reconstruction and tracking. by default will look into the image folder for .info file
-    image_orientation_vectors:
-    # type=list|default=[]: specify image orientation vectors. if just one argument given, will treat it as filename and read the orientation vectors from the file. if 6 arguments are given, will treat them as 6 float numbers and construct the 1st and 2nd vector and calculate the 3rd one automatically. this information will be used to determine image orientation, as well as to adjust gradient vectors with oblique angle when
-    oblique_correction:
-    # type=bool|default=False: when oblique angle(s) applied, some SIEMENS dti protocols do not adjust gradient accordingly, thus it requires adjustment for correct diffusion tensor calculation
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-diffusion_toolkit/hardi_mat_callables.py b/example-specs/task/nipype_internal/pydra-diffusion_toolkit/hardi_mat_callables.py
deleted file mode 100644
index d0dc5d6a..00000000
--- a/example-specs/task/nipype_internal/pydra-diffusion_toolkit/hardi_mat_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in HARDIMat.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-diffusion_toolkit/odf_recon.yaml b/example-specs/task/nipype_internal/pydra-diffusion_toolkit/odf_recon.yaml
deleted file mode 100644
index 4b6f1df0..00000000
--- a/example-specs/task/nipype_internal/pydra-diffusion_toolkit/odf_recon.yaml
+++ /dev/null
@@ -1,111 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.diffusion_toolkit.odf.ODFRecon' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Use odf_recon to generate tensors and other maps
-task_name: ODFRecon
-nipype_name: ODFRecon
-nipype_module: nipype.interfaces.diffusion_toolkit.odf
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    DWI: generic/file
-    # type=file: 
-    # type=file|default=<undefined>: Input raw data
-    matrix: generic/file
-    # type=file|default=<undefined>: use given file as reconstruction matrix.
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    B0: generic/file
-    # type=file: 
-    DWI: generic/file
-    # type=file: 
-    # type=file|default=<undefined>: Input raw data
-    max: generic/file
-    # type=file: 
-    ODF: generic/file
-    # type=file: 
-    entropy: generic/file
-    # type=file: 
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    DWI:
-    # type=file: 
-    # type=file|default=<undefined>: Input raw data
-    n_directions:
-    # type=int|default=0: Number of directions
-    n_output_directions:
-    # type=int|default=0: Number of output directions
-    out_prefix:
-    # type=str|default='odf': Output file prefix
-    matrix:
-    # type=file|default=<undefined>: use given file as reconstruction matrix.
-    n_b0:
-    # type=int|default=0: number of b0 scans. by default the program gets this information from the number of directions and number of volumes in the raw data. useful when dealing with incomplete raw data set or only using part of raw data set to reconstruct
-    output_type:
-    # type=enum|default='nii'|allowed['analyze','ni1','nii','nii.gz']: output file type
-    sharpness:
-    # type=float|default=0.0: smooth or sharpen the raw data. factor > 0 is smoothing. factor < 0 is sharpening. default value is 0 NOTE: this option applies to DSI study only
-    filter:
-    # type=bool|default=False: apply a filter (e.g. high pass) to the raw image
-    subtract_background:
-    # type=bool|default=False: subtract the background value before reconstruction
-    dsi:
-    # type=bool|default=False: indicates that the data is dsi
-    output_entropy:
-    # type=bool|default=False: output entropy map
-    image_orientation_vectors:
-    # type=list|default=[]: specify image orientation vectors. if just one argument given, will treat it as filename and read the orientation vectors from the file. if 6 arguments are given, will treat them as 6 float numbers and construct the 1st and 2nd vector and calculate the 3rd one automatically. this information will be used to determine image orientation, as well as to adjust gradient vectors with oblique angle when
-    oblique_correction:
-    # type=bool|default=False: when oblique angle(s) applied, some SIEMENS dti protocols do not adjust gradient accordingly, thus it requires adjustment for correct diffusion tensor calculation
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-diffusion_toolkit/odf_recon_callables.py b/example-specs/task/nipype_internal/pydra-diffusion_toolkit/odf_recon_callables.py
deleted file mode 100644
index 1e5abb7f..00000000
--- a/example-specs/task/nipype_internal/pydra-diffusion_toolkit/odf_recon_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in ODFRecon.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-diffusion_toolkit/odf_tracker.yaml b/example-specs/task/nipype_internal/pydra-diffusion_toolkit/odf_tracker.yaml
deleted file mode 100644
index b465c3bf..00000000
--- a/example-specs/task/nipype_internal/pydra-diffusion_toolkit/odf_tracker.yaml
+++ /dev/null
@@ -1,128 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.diffusion_toolkit.odf.ODFTracker' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Use odf_tracker to generate track file
-task_name: ODFTracker
-nipype_name: ODFTracker
-nipype_module: nipype.interfaces.diffusion_toolkit.odf
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    max: generic/file
-    # type=file|default=<undefined>: 
-    ODF: generic/file
-    # type=file|default=<undefined>: 
-    out_file: generic/file
-    # type=file|default='tracks.trk': output track file
-    mask1_file: generic/file
-    # type=file|default=<undefined>: first mask image
-    mask2_file: generic/file
-    # type=file|default=<undefined>: second mask image
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    track_file: generic/file
-    # type=file: output track file
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    max:
-    # type=file|default=<undefined>: 
-    ODF:
-    # type=file|default=<undefined>: 
-    input_data_prefix:
-    # type=str|default='odf': recon data prefix
-    out_file:
-    # type=file|default='tracks.trk': output track file
-    input_output_type:
-    # type=enum|default='nii'|allowed['analyze','ni1','nii','nii.gz']: input and output file type
-    runge_kutta2:
-    # type=bool|default=False: use 2nd order Runge-Kutta method for tracking. default tracking method is non-interpolate streamline
-    step_length:
-    # type=float|default=0.0: set step length, in the unit of minimum voxel size. default value is 0.1.
-    angle_threshold:
-    # type=float|default=0.0: set angle threshold. default value is 35 degree for default tracking method and 25 for rk2
-    random_seed:
-    # type=int|default=0: use random location in a voxel instead of the center of the voxel to seed. can also define number of seed per voxel. default is 1
-    invert_x:
-    # type=bool|default=False: invert x component of the vector
-    invert_y:
-    # type=bool|default=False: invert y component of the vector
-    invert_z:
-    # type=bool|default=False: invert z component of the vector
-    swap_xy:
-    # type=bool|default=False: swap x and y vectors while tracking
-    swap_yz:
-    # type=bool|default=False: swap y and z vectors while tracking
-    swap_zx:
-    # type=bool|default=False: swap x and z vectors while tracking
-    disc:
-    # type=bool|default=False: use disc tracking
-    mask1_file:
-    # type=file|default=<undefined>: first mask image
-    mask1_threshold:
-    # type=float|default=0.0: threshold value for the first mask image, if not given, the program will try automatically find the threshold
-    mask2_file:
-    # type=file|default=<undefined>: second mask image
-    mask2_threshold:
-    # type=float|default=0.0: threshold value for the second mask image, if not given, the program will try automatically find the threshold
-    limit:
-    # type=int|default=0: in some special case, such as heart data, some track may go into infinite circle and take long time to stop. this option allows setting a limit for the longest tracking steps (voxels)
-    dsi:
-    # type=bool|default=False: specify the input odf data is dsi. because dsi recon uses fixed pre-calculated matrix, some special orientation patch needs to be applied to keep dti/dsi/q-ball consistent.
-    image_orientation_vectors:
-    # type=list|default=[]: specify image orientation vectors. if just one argument given, will treat it as filename and read the orientation vectors from the file. if 6 arguments are given, will treat them as 6 float numbers and construct the 1st and 2nd vector and calculate the 3rd one automatically. this information will be used to determine image orientation, as well as to adjust gradient vectors with oblique angle when
-    slice_order:
-    # type=int|default=0: set the slice order. 1 means normal, -1 means reversed. default value is 1
-    voxel_order:
-    # type=enum|default='RAS'|allowed['LAI','LAS','LPI','LPS','RAI','RAS','RPI','RPS']: specify the voxel order in RL/AP/IS (human brain) reference. must be 3 letters with no space in between. for example, RAS means the voxel row is from L->R, the column is from P->A and the slice order is from I->S. by default voxel order is determined by the image orientation (but NOT guaranteed to be correct because of various standards). for example, siemens axial image is LPS, coronal image is LIP and sagittal image is PIL. this information also is NOT needed for tracking but will be saved in the track file and is essential for track display to map onto the right coordinates
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-diffusion_toolkit/odf_tracker_callables.py b/example-specs/task/nipype_internal/pydra-diffusion_toolkit/odf_tracker_callables.py
deleted file mode 100644
index b00b8e1d..00000000
--- a/example-specs/task/nipype_internal/pydra-diffusion_toolkit/odf_tracker_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in ODFTracker.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-diffusion_toolkit/spline_filter.yaml b/example-specs/task/nipype_internal/pydra-diffusion_toolkit/spline_filter.yaml
deleted file mode 100644
index 241da441..00000000
--- a/example-specs/task/nipype_internal/pydra-diffusion_toolkit/spline_filter.yaml
+++ /dev/null
@@ -1,94 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.diffusion_toolkit.postproc.SplineFilter' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Smoothes TrackVis track files with a B-Spline filter.
-# 
-#     Helps remove redundant track points and segments
-#     (thus reducing the size of the track file) and also
-#     make tracks nicely smoothed. It will NOT change the
-#     quality of the tracks or lose any original information.
-# 
-#     Example
-#     -------
-# 
-#     >>> import nipype.interfaces.diffusion_toolkit as dtk
-#     >>> filt = dtk.SplineFilter()
-#     >>> filt.inputs.track_file = 'tracks.trk'
-#     >>> filt.inputs.step_length = 0.5
-#     >>> filt.run()                         # doctest: +SKIP
-#     
-task_name: SplineFilter
-nipype_name: SplineFilter
-nipype_module: nipype.interfaces.diffusion_toolkit.postproc
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    track_file: generic/file
-    # type=file|default=<undefined>: file containing tracks to be filtered
-    output_file: generic/file
-    # type=file|default='spline_tracks.trk': target file for smoothed tracks
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    smoothed_track_file: generic/file
-    # type=file: 
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    track_file:
-    # type=file|default=<undefined>: file containing tracks to be filtered
-    step_length:
-    # type=float|default=0.0: in the unit of minimum voxel size
-    output_file:
-    # type=file|default='spline_tracks.trk': target file for smoothed tracks
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-diffusion_toolkit/spline_filter_callables.py b/example-specs/task/nipype_internal/pydra-diffusion_toolkit/spline_filter_callables.py
deleted file mode 100644
index 6948bec6..00000000
--- a/example-specs/task/nipype_internal/pydra-diffusion_toolkit/spline_filter_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in SplineFilter.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-diffusion_toolkit/track_merge.yaml b/example-specs/task/nipype_internal/pydra-diffusion_toolkit/track_merge.yaml
deleted file mode 100644
index 3283d43c..00000000
--- a/example-specs/task/nipype_internal/pydra-diffusion_toolkit/track_merge.yaml
+++ /dev/null
@@ -1,94 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.diffusion_toolkit.postproc.TrackMerge' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Merges several TrackVis track files into a single track
-#     file.
-# 
-#     An id type property tag is added to each track in the
-#     newly merged file, with each unique id representing where
-#     the track was originally from. When the merged file is
-#     loaded in TrackVis, a property filter will show up in
-#     Track Property panel. Users can adjust that to distinguish
-#     and sub-group tracks by its id (origin).
-# 
-#     Example
-#     -------
-# 
-#     >>> import nipype.interfaces.diffusion_toolkit as dtk
-#     >>> mrg = dtk.TrackMerge()
-#     >>> mrg.inputs.track_files = ['track1.trk','track2.trk']
-#     >>> mrg.run()                         # doctest: +SKIP
-#     
-task_name: TrackMerge
-nipype_name: TrackMerge
-nipype_module: nipype.interfaces.diffusion_toolkit.postproc
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    track_files: generic/file+list-of
-    # type=inputmultiobject|default=[]: file containing tracks to be filtered
-    output_file: generic/file
-    # type=file|default='merged_tracks.trk': target file for merged tracks
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    track_file: generic/file
-    # type=file: 
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    track_files:
-    # type=inputmultiobject|default=[]: file containing tracks to be filtered
-    output_file:
-    # type=file|default='merged_tracks.trk': target file for merged tracks
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-diffusion_toolkit/track_merge_callables.py b/example-specs/task/nipype_internal/pydra-diffusion_toolkit/track_merge_callables.py
deleted file mode 100644
index a0b86625..00000000
--- a/example-specs/task/nipype_internal/pydra-diffusion_toolkit/track_merge_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in TrackMerge.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dipy/apm_qball.yaml b/example-specs/task/nipype_internal/pydra-dipy/apm_qball.yaml
deleted file mode 100644
index 5955835a..00000000
--- a/example-specs/task/nipype_internal/pydra-dipy/apm_qball.yaml
+++ /dev/null
@@ -1,96 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.dipy.anisotropic_power.APMQball' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Calculates the anisotropic power map
-# 
-#     Example
-#     -------
-# 
-#     >>> import nipype.interfaces.dipy as dipy
-#     >>> apm = dipy.APMQball()
-#     >>> apm.inputs.in_file = 'diffusion.nii'
-#     >>> apm.inputs.in_bvec = 'bvecs'
-#     >>> apm.inputs.in_bval = 'bvals'
-#     >>> apm.run()                           # doctest: +SKIP
-#     
-task_name: APMQball
-nipype_name: APMQball
-nipype_module: nipype.interfaces.dipy.anisotropic_power
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    mask_file: generic/file
-    # type=file|default=<undefined>: An optional brain mask
-    in_file: generic/file
-    # type=file|default=<undefined>: input diffusion data
-    in_bval: generic/file
-    # type=file|default=<undefined>: input b-values table
-    in_bvec: generic/file
-    # type=file|default=<undefined>: input b-vectors table
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    out_file: generic/file
-    # type=file: 
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    mask_file:
-    # type=file|default=<undefined>: An optional brain mask
-    in_file:
-    # type=file|default=<undefined>: input diffusion data
-    in_bval:
-    # type=file|default=<undefined>: input b-values table
-    in_bvec:
-    # type=file|default=<undefined>: input b-vectors table
-    b0_thres:
-    # type=int|default=700: b0 threshold
-    out_prefix:
-    # type=str|default='': output prefix for file names
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-dipy/apm_qball_callables.py b/example-specs/task/nipype_internal/pydra-dipy/apm_qball_callables.py
deleted file mode 100644
index b71de4a9..00000000
--- a/example-specs/task/nipype_internal/pydra-dipy/apm_qball_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in APMQball.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dipy/csd.yaml b/example-specs/task/nipype_internal/pydra-dipy/csd.yaml
deleted file mode 100644
index 495920f0..00000000
--- a/example-specs/task/nipype_internal/pydra-dipy/csd.yaml
+++ /dev/null
@@ -1,120 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.dipy.reconstruction.CSD' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Uses CSD [Tournier2007]_ to generate the fODF of DWIs. The interface uses
-#     :py:mod:`dipy`, as explained in `dipy's CSD example
-#     <http://nipy.org/dipy/examples_built/reconst_csd.html>`_.
-# 
-#     .. [Tournier2007] Tournier, J.D., et al. NeuroImage 2007.
-#       Robust determination of the fibre orientation distribution in diffusion
-#       MRI: Non-negativity constrained super-resolved spherical deconvolution
-# 
-# 
-#     Example
-#     -------
-# 
-#     >>> from nipype.interfaces import dipy as ndp
-#     >>> csd = ndp.CSD()
-#     >>> csd.inputs.in_file = '4d_dwi.nii'
-#     >>> csd.inputs.in_bval = 'bvals'
-#     >>> csd.inputs.in_bvec = 'bvecs'
-#     >>> res = csd.run() # doctest: +SKIP
-#     
-task_name: CSD
-nipype_name: CSD
-nipype_module: nipype.interfaces.dipy.reconstruction
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_mask: generic/file
-    # type=file|default=<undefined>: input mask in which compute tensors
-    response: generic/file
-    # type=file|default=<undefined>: single fiber estimated response
-    out_fods: generic/file
-    # type=file: fODFs output file name
-    # type=file|default=<undefined>: fODFs output file name
-    in_file: generic/file
-    # type=file|default=<undefined>: input diffusion data
-    in_bval: generic/file
-    # type=file|default=<undefined>: input b-values table
-    in_bvec: generic/file
-    # type=file|default=<undefined>: input b-vectors table
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    model: generic/file
-    # type=file: Python pickled object of the CSD model fitted.
-    out_fods: generic/file
-    # type=file: fODFs output file name
-    # type=file|default=<undefined>: fODFs output file name
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_mask:
-    # type=file|default=<undefined>: input mask in which compute tensors
-    response:
-    # type=file|default=<undefined>: single fiber estimated response
-    sh_order:
-    # type=int|default=8: maximal shperical harmonics order
-    save_fods:
-    # type=bool|default=True: save fODFs in file
-    out_fods:
-    # type=file: fODFs output file name
-    # type=file|default=<undefined>: fODFs output file name
-    in_file:
-    # type=file|default=<undefined>: input diffusion data
-    in_bval:
-    # type=file|default=<undefined>: input b-values table
-    in_bvec:
-    # type=file|default=<undefined>: input b-vectors table
-    b0_thres:
-    # type=int|default=700: b0 threshold
-    out_prefix:
-    # type=str|default='': output prefix for file names
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-dipy/csd_callables.py b/example-specs/task/nipype_internal/pydra-dipy/csd_callables.py
deleted file mode 100644
index 38c8747e..00000000
--- a/example-specs/task/nipype_internal/pydra-dipy/csd_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in CSD.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dipy/denoise.yaml b/example-specs/task/nipype_internal/pydra-dipy/denoise.yaml
deleted file mode 100644
index 91a5b67b..00000000
--- a/example-specs/task/nipype_internal/pydra-dipy/denoise.yaml
+++ /dev/null
@@ -1,106 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.dipy.preprocess.Denoise' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     An interface to denoising diffusion datasets [Coupe2008]_.
-#     See
-#     http://nipy.org/dipy/examples_built/denoise_nlmeans.html#example-denoise-nlmeans.
-# 
-#     .. [Coupe2008] Coupe P et al., `An Optimized Blockwise Non Local Means
-#       Denoising Filter for 3D Magnetic Resonance Images
-#       <https://doi.org/10.1109%2FTMI.2007.906087>`_,
-#       IEEE Transactions on Medical Imaging, 27(4):425-441, 2008.
-# 
-# 
-#     Example
-#     -------
-# 
-#     >>> import nipype.interfaces.dipy as dipy
-#     >>> denoise = dipy.Denoise()
-#     >>> denoise.inputs.in_file = 'diffusion.nii'
-#     >>> denoise.run() # doctest: +SKIP
-#     
-task_name: Denoise
-nipype_name: Denoise
-nipype_module: nipype.interfaces.dipy.preprocess
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_file: generic/file
-    # type=file|default=<undefined>: The input 4D diffusion-weighted image file
-    in_mask: generic/file
-    # type=file|default=<undefined>: brain mask
-    signal_mask: generic/file
-    # type=file|default=<undefined>: mask in which the mean signal will be computed
-    noise_mask: generic/file
-    # type=file|default=<undefined>: mask in which the standard deviation of noise will be computed
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    out_file: generic/file
-    # type=file: 
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: The input 4D diffusion-weighted image file
-    in_mask:
-    # type=file|default=<undefined>: brain mask
-    noise_model:
-    # type=enum|default='rician'|allowed['gaussian','rician']: noise distribution model
-    signal_mask:
-    # type=file|default=<undefined>: mask in which the mean signal will be computed
-    noise_mask:
-    # type=file|default=<undefined>: mask in which the standard deviation of noise will be computed
-    patch_radius:
-    # type=int|default=1: patch radius
-    block_radius:
-    # type=int|default=5: block_radius
-    snr:
-    # type=float|default=0.0: manually set an SNR
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-dipy/denoise_callables.py b/example-specs/task/nipype_internal/pydra-dipy/denoise_callables.py
deleted file mode 100644
index 3396479d..00000000
--- a/example-specs/task/nipype_internal/pydra-dipy/denoise_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in Denoise.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dipy/dti.yaml b/example-specs/task/nipype_internal/pydra-dipy/dti.yaml
deleted file mode 100644
index c405b97f..00000000
--- a/example-specs/task/nipype_internal/pydra-dipy/dti.yaml
+++ /dev/null
@@ -1,106 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.dipy.tensors.DTI' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Calculates the diffusion tensor model parameters
-# 
-#     Example
-#     -------
-# 
-#     >>> import nipype.interfaces.dipy as dipy
-#     >>> dti = dipy.DTI()
-#     >>> dti.inputs.in_file = 'diffusion.nii'
-#     >>> dti.inputs.in_bvec = 'bvecs'
-#     >>> dti.inputs.in_bval = 'bvals'
-#     >>> dti.run()                           # doctest: +SKIP
-#     
-task_name: DTI
-nipype_name: DTI
-nipype_module: nipype.interfaces.dipy.tensors
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    mask_file: generic/file
-    # type=file|default=<undefined>: An optional white matter mask
-    in_file: generic/file
-    # type=file|default=<undefined>: input diffusion data
-    in_bval: generic/file
-    # type=file|default=<undefined>: input b-values table
-    in_bvec: generic/file
-    # type=file|default=<undefined>: input b-vectors table
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    out_file: generic/file
-    # type=file: 
-    fa_file: generic/file
-    # type=file: 
-    md_file: generic/file
-    # type=file: 
-    rd_file: generic/file
-    # type=file: 
-    ad_file: generic/file
-    # type=file: 
-    color_fa_file: generic/file
-    # type=file: 
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    mask_file:
-    # type=file|default=<undefined>: An optional white matter mask
-    in_file:
-    # type=file|default=<undefined>: input diffusion data
-    in_bval:
-    # type=file|default=<undefined>: input b-values table
-    in_bvec:
-    # type=file|default=<undefined>: input b-vectors table
-    b0_thres:
-    # type=int|default=700: b0 threshold
-    out_prefix:
-    # type=str|default='': output prefix for file names
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-dipy/dti_callables.py b/example-specs/task/nipype_internal/pydra-dipy/dti_callables.py
deleted file mode 100644
index aea1a740..00000000
--- a/example-specs/task/nipype_internal/pydra-dipy/dti_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in DTI.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dipy/estimate_response_sh.yaml b/example-specs/task/nipype_internal/pydra-dipy/estimate_response_sh.yaml
deleted file mode 100644
index b64214a1..00000000
--- a/example-specs/task/nipype_internal/pydra-dipy/estimate_response_sh.yaml
+++ /dev/null
@@ -1,130 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.dipy.reconstruction.EstimateResponseSH' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Uses dipy to compute the single fiber response to be used in spherical
-#     deconvolution methods, in a similar way to MRTrix's command
-#     ``estimate_response``.
-# 
-# 
-#     Example
-#     -------
-# 
-#     >>> from nipype.interfaces import dipy as ndp
-#     >>> dti = ndp.EstimateResponseSH()
-#     >>> dti.inputs.in_file = '4d_dwi.nii'
-#     >>> dti.inputs.in_bval = 'bvals'
-#     >>> dti.inputs.in_bvec = 'bvecs'
-#     >>> dti.inputs.in_evals = 'dwi_evals.nii'
-#     >>> res = dti.run() # doctest: +SKIP
-# 
-# 
-#     
-task_name: EstimateResponseSH
-nipype_name: EstimateResponseSH
-nipype_module: nipype.interfaces.dipy.reconstruction
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_evals: generic/file
-    # type=file|default=<undefined>: input eigenvalues file
-    in_mask: generic/file
-    # type=file|default=<undefined>: input mask in which we find single fibers
-    response: generic/file
-    # type=file: the response file
-    # type=file|default='response.txt': the output response file
-    out_mask: generic/file
-    # type=file: output wm mask
-    # type=file|default='wm_mask.nii.gz': computed wm mask
-    in_file: generic/file
-    # type=file|default=<undefined>: input diffusion data
-    in_bval: generic/file
-    # type=file|default=<undefined>: input b-values table
-    in_bvec: generic/file
-    # type=file|default=<undefined>: input b-vectors table
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    response: generic/file
-    # type=file: the response file
-    # type=file|default='response.txt': the output response file
-    out_mask: generic/file
-    # type=file: output wm mask
-    # type=file|default='wm_mask.nii.gz': computed wm mask
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_evals:
-    # type=file|default=<undefined>: input eigenvalues file
-    in_mask:
-    # type=file|default=<undefined>: input mask in which we find single fibers
-    fa_thresh:
-    # type=float|default=0.7: FA threshold
-    roi_radius:
-    # type=int|default=10: ROI radius to be used in auto_response
-    auto:
-    # type=bool|default=False: use the auto_response estimator from dipy
-    recursive:
-    # type=bool|default=False: use the recursive response estimator from dipy
-    response:
-    # type=file: the response file
-    # type=file|default='response.txt': the output response file
-    out_mask:
-    # type=file: output wm mask
-    # type=file|default='wm_mask.nii.gz': computed wm mask
-    in_file:
-    # type=file|default=<undefined>: input diffusion data
-    in_bval:
-    # type=file|default=<undefined>: input b-values table
-    in_bvec:
-    # type=file|default=<undefined>: input b-vectors table
-    b0_thres:
-    # type=int|default=700: b0 threshold
-    out_prefix:
-    # type=str|default='': output prefix for file names
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-dipy/estimate_response_sh_callables.py b/example-specs/task/nipype_internal/pydra-dipy/estimate_response_sh_callables.py
deleted file mode 100644
index 1a7f226f..00000000
--- a/example-specs/task/nipype_internal/pydra-dipy/estimate_response_sh_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in EstimateResponseSH.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dipy/resample.yaml b/example-specs/task/nipype_internal/pydra-dipy/resample.yaml
deleted file mode 100644
index ed3dad79..00000000
--- a/example-specs/task/nipype_internal/pydra-dipy/resample.yaml
+++ /dev/null
@@ -1,84 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.dipy.preprocess.Resample' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     An interface to reslicing diffusion datasets.
-#     See
-#     http://nipy.org/dipy/examples_built/reslice_datasets.html#example-reslice-datasets.
-# 
-#     Example
-#     -------
-# 
-#     >>> import nipype.interfaces.dipy as dipy
-#     >>> reslice = dipy.Resample()
-#     >>> reslice.inputs.in_file = 'diffusion.nii'
-#     >>> reslice.run() # doctest: +SKIP
-#     
-task_name: Resample
-nipype_name: Resample
-nipype_module: nipype.interfaces.dipy.preprocess
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_file: generic/file
-    # type=file|default=<undefined>: The input 4D diffusion-weighted image file
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    out_file: generic/file
-    # type=file: 
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: The input 4D diffusion-weighted image file
-    vox_size:
-    # type=tuple|default=(0.0, 0.0, 0.0): specify the new voxel zooms. If no vox_size is set, then isotropic regridding will be performed, with spacing equal to the smallest current zoom.
-    interp:
-    # type=int|default=1: order of the interpolator (0 = nearest, 1 = linear, etc.
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-dipy/restore.yaml b/example-specs/task/nipype_internal/pydra-dipy/restore.yaml
deleted file mode 100644
index ecae0700..00000000
--- a/example-specs/task/nipype_internal/pydra-dipy/restore.yaml
+++ /dev/null
@@ -1,120 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.dipy.reconstruction.RESTORE' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Uses RESTORE [Chang2005]_ to perform DTI fitting with outlier detection.
-#     The interface uses :py:mod:`dipy`, as explained in `dipy's documentation`_.
-# 
-#     .. [Chang2005] Chang, LC, Jones, DK and Pierpaoli, C. RESTORE: robust     estimation of tensors by outlier rejection. MRM, 53:1088-95, (2005).
-# 
-#     .. _dipy's documentation:     http://nipy.org/dipy/examples_built/restore_dti.html
-# 
-# 
-#     Example
-#     -------
-# 
-#     >>> from nipype.interfaces import dipy as ndp
-#     >>> dti = ndp.RESTORE()
-#     >>> dti.inputs.in_file = '4d_dwi.nii'
-#     >>> dti.inputs.in_bval = 'bvals'
-#     >>> dti.inputs.in_bvec = 'bvecs'
-#     >>> res = dti.run() # doctest: +SKIP
-# 
-# 
-#     
-task_name: RESTORE
-nipype_name: RESTORE
-nipype_module: nipype.interfaces.dipy.reconstruction
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_mask: generic/file
-    # type=file|default=<undefined>: input mask in which compute tensors
-    noise_mask: generic/file
-    # type=file|default=<undefined>: input mask in which compute noise variance
-    in_file: generic/file
-    # type=file|default=<undefined>: input diffusion data
-    in_bval: generic/file
-    # type=file|default=<undefined>: input b-values table
-    in_bvec: generic/file
-    # type=file|default=<undefined>: input b-vectors table
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    fa: generic/file
-    # type=file: output fractional anisotropy (FA) map computed from the fitted DTI
-    md: generic/file
-    # type=file: output mean diffusivity (MD) map computed from the fitted DTI
-    rd: generic/file
-    # type=file: output radial diffusivity (RD) map computed from the fitted DTI
-    mode: generic/file
-    # type=file: output mode (MO) map computed from the fitted DTI
-    trace: generic/file
-    # type=file: output the tensor trace map computed from the fitted DTI
-    evals: generic/file
-    # type=file: output the eigenvalues of the fitted DTI
-    evecs: generic/file
-    # type=file: output the eigenvectors of the fitted DTI
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_mask:
-    # type=file|default=<undefined>: input mask in which compute tensors
-    noise_mask:
-    # type=file|default=<undefined>: input mask in which compute noise variance
-    in_file:
-    # type=file|default=<undefined>: input diffusion data
-    in_bval:
-    # type=file|default=<undefined>: input b-values table
-    in_bvec:
-    # type=file|default=<undefined>: input b-vectors table
-    b0_thres:
-    # type=int|default=700: b0 threshold
-    out_prefix:
-    # type=str|default='': output prefix for file names
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-dipy/restore_callables.py b/example-specs/task/nipype_internal/pydra-dipy/restore_callables.py
deleted file mode 100644
index ff72be87..00000000
--- a/example-specs/task/nipype_internal/pydra-dipy/restore_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in RESTORE.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dipy/simulate_multi_tensor.yaml b/example-specs/task/nipype_internal/pydra-dipy/simulate_multi_tensor.yaml
deleted file mode 100644
index c96a19c1..00000000
--- a/example-specs/task/nipype_internal/pydra-dipy/simulate_multi_tensor.yaml
+++ /dev/null
@@ -1,159 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.dipy.simulate.SimulateMultiTensor' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Interface to MultiTensor model simulator in dipy
-#     http://nipy.org/dipy/examples_built/simulate_multi_tensor.html
-# 
-#     Example
-#     -------
-# 
-#     >>> import nipype.interfaces.dipy as dipy
-#     >>> sim = dipy.SimulateMultiTensor()
-#     >>> sim.inputs.in_dirs = ['fdir00.nii', 'fdir01.nii']
-#     >>> sim.inputs.in_frac = ['ffra00.nii', 'ffra01.nii']
-#     >>> sim.inputs.in_vfms = ['tpm_00.nii.gz', 'tpm_01.nii.gz',
-#     ...                       'tpm_02.nii.gz']
-#     >>> sim.inputs.baseline = 'b0.nii'
-#     >>> sim.inputs.in_bvec = 'bvecs'
-#     >>> sim.inputs.in_bval = 'bvals'
-#     >>> sim.run()                           # doctest: +SKIP
-#     
-task_name: SimulateMultiTensor
-nipype_name: SimulateMultiTensor
-nipype_module: nipype.interfaces.dipy.simulate
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_dirs: generic/file+list-of
-    # type=inputmultiobject|default=[]: list of fibers (principal directions)
-    in_frac: generic/file+list-of
-    # type=inputmultiobject|default=[]: volume fraction of each fiber
-    in_vfms: generic/file+list-of
-    # type=inputmultiobject|default=[]: volume fractions of isotropic compartiments
-    in_mask: generic/file
-    # type=file|default=<undefined>: mask to simulate data
-    baseline: generic/file
-    # type=file|default=<undefined>: baseline T2 signal
-    gradients: generic/file
-    # type=file|default=<undefined>: gradients file
-    in_bvec: generic/file
-    # type=file|default=<undefined>: input bvecs file
-    in_bval: generic/file
-    # type=file|default=<undefined>: input bvals file
-    out_file: generic/file
-    # type=file: simulated DWIs
-    # type=file|default='sim_dwi.nii.gz': output file with fractions to be simluated
-    out_mask: generic/file
-    # type=file: mask file
-    # type=file|default='sim_msk.nii.gz': file with the mask simulated
-    out_bvec: generic/file
-    # type=file: simulated b vectors
-    # type=file|default='bvec.sim': simulated b vectors
-    out_bval: generic/file
-    # type=file: simulated b values
-    # type=file|default='bval.sim': simulated b values
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    out_file: generic/file
-    # type=file: simulated DWIs
-    # type=file|default='sim_dwi.nii.gz': output file with fractions to be simluated
-    out_mask: generic/file
-    # type=file: mask file
-    # type=file|default='sim_msk.nii.gz': file with the mask simulated
-    out_bvec: generic/file
-    # type=file: simulated b vectors
-    # type=file|default='bvec.sim': simulated b vectors
-    out_bval: generic/file
-    # type=file: simulated b values
-    # type=file|default='bval.sim': simulated b values
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_dirs:
-    # type=inputmultiobject|default=[]: list of fibers (principal directions)
-    in_frac:
-    # type=inputmultiobject|default=[]: volume fraction of each fiber
-    in_vfms:
-    # type=inputmultiobject|default=[]: volume fractions of isotropic compartiments
-    in_mask:
-    # type=file|default=<undefined>: mask to simulate data
-    diff_iso:
-    # type=list|default=[0.003, 0.00096, 0.00068]: Diffusivity of isotropic compartments
-    diff_sf:
-    # type=tuple|default=(0.0017, 0.0002, 0.0002): Single fiber tensor
-    n_proc:
-    # type=int|default=0: number of processes
-    baseline:
-    # type=file|default=<undefined>: baseline T2 signal
-    gradients:
-    # type=file|default=<undefined>: gradients file
-    in_bvec:
-    # type=file|default=<undefined>: input bvecs file
-    in_bval:
-    # type=file|default=<undefined>: input bvals file
-    num_dirs:
-    # type=int|default=32: number of gradient directions (when table is automatically generated)
-    bvalues:
-    # type=list|default=[1000, 3000]: list of b-values (when table is automatically generated)
-    out_file:
-    # type=file: simulated DWIs
-    # type=file|default='sim_dwi.nii.gz': output file with fractions to be simluated
-    out_mask:
-    # type=file: mask file
-    # type=file|default='sim_msk.nii.gz': file with the mask simulated
-    out_bvec:
-    # type=file: simulated b vectors
-    # type=file|default='bvec.sim': simulated b vectors
-    out_bval:
-    # type=file: simulated b values
-    # type=file|default='bval.sim': simulated b values
-    snr:
-    # type=int|default=0: signal-to-noise ratio (dB)
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-dipy/simulate_multi_tensor_callables.py b/example-specs/task/nipype_internal/pydra-dipy/simulate_multi_tensor_callables.py
deleted file mode 100644
index af59eb89..00000000
--- a/example-specs/task/nipype_internal/pydra-dipy/simulate_multi_tensor_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in SimulateMultiTensor.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dipy/streamline_tractography.yaml b/example-specs/task/nipype_internal/pydra-dipy/streamline_tractography.yaml
deleted file mode 100644
index cc3af6c7..00000000
--- a/example-specs/task/nipype_internal/pydra-dipy/streamline_tractography.yaml
+++ /dev/null
@@ -1,123 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.dipy.tracks.StreamlineTractography' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Streamline tractography using EuDX [Garyfallidis12]_.
-# 
-#     .. [Garyfallidis12] Garyfallidis E., “Towards an accurate brain
-#       tractography”, PhD thesis, University of Cambridge, 2012
-# 
-#     Example
-#     -------
-# 
-#     >>> from nipype.interfaces import dipy as ndp
-#     >>> track = ndp.StreamlineTractography()
-#     >>> track.inputs.in_file = '4d_dwi.nii'
-#     >>> track.inputs.in_model = 'model.pklz'
-#     >>> track.inputs.tracking_mask = 'dilated_wm_mask.nii'
-#     >>> res = track.run() # doctest: +SKIP
-#     
-task_name: StreamlineTractography
-nipype_name: StreamlineTractography
-nipype_module: nipype.interfaces.dipy.tracks
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_file: generic/file
-    # type=file|default=<undefined>: input diffusion data
-    in_model: generic/file
-    # type=file|default=<undefined>: input f/d-ODF model extracted from.
-    tracking_mask: generic/file
-    # type=file|default=<undefined>: input mask within which perform tracking
-    seed_mask: generic/file
-    # type=file|default=<undefined>: input mask within which perform seeding
-    in_peaks: generic/file
-    # type=file|default=<undefined>: peaks computed from the odf
-    seed_coord: generic/file
-    # type=file|default=<undefined>: file containing the list of seed voxel coordinates (N,3)
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    tracks: generic/file
-    # type=file: TrackVis file containing extracted streamlines
-    gfa: generic/file
-    # type=file: The resulting GFA (generalized FA) computed using the peaks of the ODF
-    odf_peaks: generic/file
-    # type=file: peaks computed from the odf
-    out_seeds: generic/file
-    # type=file: file containing the (N,3) *voxel* coordinates used in seeding.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: input diffusion data
-    in_model:
-    # type=file|default=<undefined>: input f/d-ODF model extracted from.
-    tracking_mask:
-    # type=file|default=<undefined>: input mask within which perform tracking
-    seed_mask:
-    # type=file|default=<undefined>: input mask within which perform seeding
-    in_peaks:
-    # type=file|default=<undefined>: peaks computed from the odf
-    seed_coord:
-    # type=file|default=<undefined>: file containing the list of seed voxel coordinates (N,3)
-    gfa_thresh:
-    # type=float|default=0.2: GFA threshold to compute tracking mask
-    peak_threshold:
-    # type=float|default=0.5: threshold to consider peaks from model
-    min_angle:
-    # type=float|default=25.0: minimum separation angle
-    multiprocess:
-    # type=bool|default=True: use multiprocessing
-    save_seeds:
-    # type=bool|default=False: save seeding voxels coordinates
-    num_seeds:
-    # type=int|default=10000: desired number of tracks in tractography
-    out_prefix:
-    # type=str|default='': output prefix for file names
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-dipy/streamline_tractography_callables.py b/example-specs/task/nipype_internal/pydra-dipy/streamline_tractography_callables.py
deleted file mode 100644
index 628e7989..00000000
--- a/example-specs/task/nipype_internal/pydra-dipy/streamline_tractography_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in StreamlineTractography.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dipy/tensor_mode.yaml b/example-specs/task/nipype_internal/pydra-dipy/tensor_mode.yaml
deleted file mode 100644
index 4a0d0649..00000000
--- a/example-specs/task/nipype_internal/pydra-dipy/tensor_mode.yaml
+++ /dev/null
@@ -1,106 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.dipy.tensors.TensorMode' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Creates a map of the mode of the diffusion tensors given a set of
-#     diffusion-weighted images, as well as their associated b-values and
-#     b-vectors [1]_. Fits the diffusion tensors and calculates tensor mode
-#     with Dipy.
-# 
-#     Example
-#     -------
-#     >>> import nipype.interfaces.dipy as dipy
-#     >>> mode = dipy.TensorMode()
-#     >>> mode.inputs.in_file = 'diffusion.nii'
-#     >>> mode.inputs.in_bvec = 'bvecs'
-#     >>> mode.inputs.in_bval = 'bvals'
-#     >>> mode.run()                           # doctest: +SKIP
-# 
-#     References
-#     ----------
-#     .. [1] Daniel B. Ennis and G. Kindlmann, "Orthogonal Tensor
-#         Invariants and the Analysis of Diffusion Tensor Magnetic Resonance
-#         Images", Magnetic Resonance in Medicine, vol. 55, no. 1, pp. 136-146,
-#         2006.
-# 
-#     
-task_name: TensorMode
-nipype_name: TensorMode
-nipype_module: nipype.interfaces.dipy.tensors
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    mask_file: generic/file
-    # type=file|default=<undefined>: An optional white matter mask
-    in_file: generic/file
-    # type=file|default=<undefined>: input diffusion data
-    in_bval: generic/file
-    # type=file|default=<undefined>: input b-values table
-    in_bvec: generic/file
-    # type=file|default=<undefined>: input b-vectors table
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    out_file: generic/file
-    # type=file: 
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    mask_file:
-    # type=file|default=<undefined>: An optional white matter mask
-    in_file:
-    # type=file|default=<undefined>: input diffusion data
-    in_bval:
-    # type=file|default=<undefined>: input b-values table
-    in_bvec:
-    # type=file|default=<undefined>: input b-vectors table
-    b0_thres:
-    # type=int|default=700: b0 threshold
-    out_prefix:
-    # type=str|default='': output prefix for file names
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-dipy/tensor_mode_callables.py b/example-specs/task/nipype_internal/pydra-dipy/tensor_mode_callables.py
deleted file mode 100644
index 99b4a6b0..00000000
--- a/example-specs/task/nipype_internal/pydra-dipy/tensor_mode_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in TensorMode.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dipy/track_density_map.yaml b/example-specs/task/nipype_internal/pydra-dipy/track_density_map.yaml
deleted file mode 100644
index 7a806711..00000000
--- a/example-specs/task/nipype_internal/pydra-dipy/track_density_map.yaml
+++ /dev/null
@@ -1,94 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.dipy.tracks.TrackDensityMap' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Creates a tract density image from a TrackVis track file using functions
-#     from dipy
-# 
-#     Example
-#     -------
-# 
-#     >>> import nipype.interfaces.dipy as dipy
-#     >>> trk2tdi = dipy.TrackDensityMap()
-#     >>> trk2tdi.inputs.in_file = 'converted.trk'
-#     >>> trk2tdi.run()                           # doctest: +SKIP
-# 
-#     
-task_name: TrackDensityMap
-nipype_name: TrackDensityMap
-nipype_module: nipype.interfaces.dipy.tracks
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_file: generic/file
-    # type=file|default=<undefined>: The input TrackVis track file
-    reference: generic/file
-    # type=file|default=<undefined>: A reference file to define RAS coordinates space
-    out_filename: generic/file
-    # type=file|default='tdi.nii': The output filename for the tracks in TrackVis (.trk) format
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    out_file: generic/file
-    # type=file: 
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: The input TrackVis track file
-    reference:
-    # type=file|default=<undefined>: A reference file to define RAS coordinates space
-    points_space:
-    # type=enum|default='rasmm'|allowed['rasmm','voxel',None]: coordinates of trk file
-    voxel_dims:
-    # type=list|default=[]: The size of each voxel in mm.
-    data_dims:
-    # type=list|default=[]: The size of the image in voxels.
-    out_filename:
-    # type=file|default='tdi.nii': The output filename for the tracks in TrackVis (.trk) format
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-dipy/track_density_map_callables.py b/example-specs/task/nipype_internal/pydra-dipy/track_density_map_callables.py
deleted file mode 100644
index 34dc898d..00000000
--- a/example-specs/task/nipype_internal/pydra-dipy/track_density_map_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in TrackDensityMap.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/aff_scalar_vol.yaml b/example-specs/task/nipype_internal/pydra-dtitk/aff_scalar_vol.yaml
deleted file mode 100644
index 0cb3af43..00000000
--- a/example-specs/task/nipype_internal/pydra-dtitk/aff_scalar_vol.yaml
+++ /dev/null
@@ -1,146 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.dtitk.registration.AffScalarVol' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Applies affine transform to a scalar volume
-# 
-#     Example
-#     -------
-# 
-#     >>> from nipype.interfaces import dtitk
-#     >>> node = dtitk.AffScalarVol()
-#     >>> node.inputs.in_file = 'im1.nii'
-#     >>> node.inputs.transform = 'im_affine.aff'
-#     >>> node.cmdline
-#     'affineScalarVolume -in im1.nii -interp 0 -out im1_affxfmd.nii -trans
-#      im_affine.aff'
-#     >>> node.run() # doctest: +SKIP
-#     
-task_name: AffScalarVol
-nipype_name: AffScalarVol
-nipype_module: nipype.interfaces.dtitk.registration
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_file: medimage/nifti1
-    # type=file|default=<undefined>: moving scalar volume
-    out_file: generic/file
-    # type=file: moved volume
-    # type=file|default=<undefined>: output filename
-    transform: medimage-dtitk/aff
-    # type=file|default=<undefined>: transform to apply: specify an input transformation file; parameters input will be ignored
-    target: generic/file
-    # type=file|default=<undefined>: output volume specification read from the target volume if specified
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    out_file: generic/file
-    # type=file: moved volume
-    # type=file|default=<undefined>: output filename
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: moving scalar volume
-    out_file:
-    # type=file: moved volume
-    # type=file|default=<undefined>: output filename
-    transform:
-    # type=file|default=<undefined>: transform to apply: specify an input transformation file; parameters input will be ignored
-    interpolation:
-    # type=enum|default='trilinear'|allowed['NN','trilinear']: trilinear or nearest neighbor interpolation
-    target:
-    # type=file|default=<undefined>: output volume specification read from the target volume if specified
-    translation:
-    # type=tuple|default=(<traits.trait_types.Float object at 0x1416c0c10>, <traits.trait_types.Float object at 0x1416c0bd0>, <traits.trait_types.Float object at 0x1416c0c90>): translation (x,y,z) in mm
-    euler:
-    # type=tuple|default=(<traits.trait_types.Float object at 0x1416c0ed0>, <traits.trait_types.Float object at 0x1416c1090>, <traits.trait_types.Float object at 0x1416c10d0>): (theta, phi, psi) in degrees
-    deformation:
-    # type=tuple|default=(<traits.trait_types.Float object at 0x1416c1250>, <traits.trait_types.Float object at 0x1416c1250>, <traits.trait_types.Float object at 0x1416c1250>, <traits.trait_types.Float object at 0x1416c1250>, <traits.trait_types.Float object at 0x1416c1250>, <traits.trait_types.Float object at 0x1416c1250>): (xx,yy,zz,xy,yz,xz)
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: moving scalar volume
-    transform:
-    # type=file|default=<undefined>: transform to apply: specify an input transformation file; parameters input will be ignored
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests:
-- cmdline: affineScalarVolume -in im1.nii -interp 0 -out im1_affxfmd.nii -trans im_affine.aff
-  # str - the expected cmdline output
-  inputs:
-  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
-  # If the field is of file-format type and the value is None, then the
-  # '.mock()' method of the corresponding class is used instead.
-    in_file:
-    # type=file|default=<undefined>: moving scalar volume
-    transform:
-    # type=file|default=<undefined>: transform to apply: specify an input transformation file; parameters input will be ignored
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  directive:
-  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/aff_scalar_vol_callables.py b/example-specs/task/nipype_internal/pydra-dtitk/aff_scalar_vol_callables.py
deleted file mode 100644
index 0d20614d..00000000
--- a/example-specs/task/nipype_internal/pydra-dtitk/aff_scalar_vol_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in AffScalarVol.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/aff_scalar_vol_task.yaml b/example-specs/task/nipype_internal/pydra-dtitk/aff_scalar_vol_task.yaml
deleted file mode 100644
index d07264d2..00000000
--- a/example-specs/task/nipype_internal/pydra-dtitk/aff_scalar_vol_task.yaml
+++ /dev/null
@@ -1,95 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.dtitk.registration.affScalarVolTask' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-task_name: affScalarVolTask
-nipype_name: affScalarVolTask
-nipype_module: nipype.interfaces.dtitk.registration
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_file: generic/file
-    # type=file|default=<undefined>: moving scalar volume
-    out_file: generic/file
-    # type=file: moved volume
-    # type=file|default=<undefined>: output filename
-    transform: generic/file
-    # type=file|default=<undefined>: transform to apply: specify an input transformation file; parameters input will be ignored
-    target: generic/file
-    # type=file|default=<undefined>: output volume specification read from the target volume if specified
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    out_file: generic/file
-    # type=file: moved volume
-    # type=file|default=<undefined>: output filename
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: moving scalar volume
-    out_file:
-    # type=file: moved volume
-    # type=file|default=<undefined>: output filename
-    transform:
-    # type=file|default=<undefined>: transform to apply: specify an input transformation file; parameters input will be ignored
-    interpolation:
-    # type=enum|default='trilinear'|allowed['NN','trilinear']: trilinear or nearest neighbor interpolation
-    target:
-    # type=file|default=<undefined>: output volume specification read from the target volume if specified
-    translation:
-    # type=tuple|default=(<traits.trait_types.Float object at 0x1416c0c10>, <traits.trait_types.Float object at 0x1416c0bd0>, <traits.trait_types.Float object at 0x1416c0c90>): translation (x,y,z) in mm
-    euler:
-    # type=tuple|default=(<traits.trait_types.Float object at 0x1416c0ed0>, <traits.trait_types.Float object at 0x1416c1090>, <traits.trait_types.Float object at 0x1416c10d0>): (theta, phi, psi) in degrees
-    deformation:
-    # type=tuple|default=(<traits.trait_types.Float object at 0x1416c1250>, <traits.trait_types.Float object at 0x1416c1250>, <traits.trait_types.Float object at 0x1416c1250>, <traits.trait_types.Float object at 0x1416c1250>, <traits.trait_types.Float object at 0x1416c1250>, <traits.trait_types.Float object at 0x1416c1250>): (xx,yy,zz,xy,yz,xz)
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/aff_scalar_vol_task_callables.py b/example-specs/task/nipype_internal/pydra-dtitk/aff_scalar_vol_task_callables.py
deleted file mode 100644
index a88c2592..00000000
--- a/example-specs/task/nipype_internal/pydra-dtitk/aff_scalar_vol_task_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in affScalarVolTask.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/aff_sym_tensor_3d_vol.yaml b/example-specs/task/nipype_internal/pydra-dtitk/aff_sym_tensor_3d_vol.yaml
deleted file mode 100644
index fb09aff0..00000000
--- a/example-specs/task/nipype_internal/pydra-dtitk/aff_sym_tensor_3d_vol.yaml
+++ /dev/null
@@ -1,148 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.dtitk.registration.AffSymTensor3DVol' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Applies affine transform to a tensor volume
-# 
-#     Example
-#     -------
-# 
-#     >>> from nipype.interfaces import dtitk
-#     >>> node = dtitk.AffSymTensor3DVol()
-#     >>> node.inputs.in_file = 'im1.nii'
-#     >>> node.inputs.transform = 'im_affine.aff'
-#     >>> node.cmdline
-#     'affineSymTensor3DVolume -in im1.nii -interp LEI -out im1_affxfmd.nii
-#      -reorient PPD -trans im_affine.aff'
-#     >>> node.run() # doctest: +SKIP
-#     
-task_name: AffSymTensor3DVol
-nipype_name: AffSymTensor3DVol
-nipype_module: nipype.interfaces.dtitk.registration
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_file: medimage/nifti1
-    # type=file|default=<undefined>: moving tensor volume
-    out_file: generic/file
-    # type=file: 
-    # type=file|default=<undefined>: output filename
-    transform: medimage-dtitk/aff
-    # type=file|default=<undefined>: transform to apply: specify an input transformation file; parameters input will be ignored
-    target: generic/file
-    # type=file|default=<undefined>: output volume specification read from the target volume if specified
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    out_file: generic/file
-    # type=file: 
-    # type=file|default=<undefined>: output filename
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: moving tensor volume
-    out_file:
-    # type=file: 
-    # type=file|default=<undefined>: output filename
-    transform:
-    # type=file|default=<undefined>: transform to apply: specify an input transformation file; parameters input will be ignored
-    interpolation:
-    # type=enum|default='LEI'|allowed['EI','LEI']: Log Euclidean/Euclidean Interpolation
-    reorient:
-    # type=enum|default='PPD'|allowed['FS','NO','PPD']: Reorientation strategy: preservation of principal direction, no reorientation, or finite strain
-    target:
-    # type=file|default=<undefined>: output volume specification read from the target volume if specified
-    translation:
-    # type=tuple|default=(<traits.trait_types.Float object at 0x1416bb090>, <traits.trait_types.Float object at 0x1416bb050>, <traits.trait_types.Float object at 0x1416bb150>): translation (x,y,z) in mm
-    euler:
-    # type=tuple|default=(<traits.trait_types.Float object at 0x1416bb310>, <traits.trait_types.Float object at 0x1416bb390>, <traits.trait_types.Float object at 0x1416bb550>): (theta, phi, psi) in degrees
-    deformation:
-    # type=tuple|default=(<traits.trait_types.Float object at 0x1416bb6d0>, <traits.trait_types.Float object at 0x1416bb6d0>, <traits.trait_types.Float object at 0x1416bb6d0>, <traits.trait_types.Float object at 0x1416bb6d0>, <traits.trait_types.Float object at 0x1416bb6d0>, <traits.trait_types.Float object at 0x1416bb6d0>): (xx,yy,zz,xy,yz,xz)
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: moving tensor volume
-    transform:
-    # type=file|default=<undefined>: transform to apply: specify an input transformation file; parameters input will be ignored
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests:
-- cmdline: affineSymTensor3DVolume -in im1.nii -interp LEI -out im1_affxfmd.nii -reorient PPD -trans im_affine.aff
-  # str - the expected cmdline output
-  inputs:
-  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
-  # If the field is of file-format type and the value is None, then the
-  # '.mock()' method of the corresponding class is used instead.
-    in_file:
-    # type=file|default=<undefined>: moving tensor volume
-    transform:
-    # type=file|default=<undefined>: transform to apply: specify an input transformation file; parameters input will be ignored
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  directive:
-  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/aff_sym_tensor_3d_vol_callables.py b/example-specs/task/nipype_internal/pydra-dtitk/aff_sym_tensor_3d_vol_callables.py
deleted file mode 100644
index ea407dc6..00000000
--- a/example-specs/task/nipype_internal/pydra-dtitk/aff_sym_tensor_3d_vol_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in AffSymTensor3DVol.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/aff_sym_tensor_3d_vol_task.yaml b/example-specs/task/nipype_internal/pydra-dtitk/aff_sym_tensor_3d_vol_task.yaml
deleted file mode 100644
index c3ce3a60..00000000
--- a/example-specs/task/nipype_internal/pydra-dtitk/aff_sym_tensor_3d_vol_task.yaml
+++ /dev/null
@@ -1,97 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.dtitk.registration.affSymTensor3DVolTask' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-task_name: affSymTensor3DVolTask
-nipype_name: affSymTensor3DVolTask
-nipype_module: nipype.interfaces.dtitk.registration
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_file: generic/file
-    # type=file|default=<undefined>: moving tensor volume
-    out_file: generic/file
-    # type=file: 
-    # type=file|default=<undefined>: output filename
-    transform: generic/file
-    # type=file|default=<undefined>: transform to apply: specify an input transformation file; parameters input will be ignored
-    target: generic/file
-    # type=file|default=<undefined>: output volume specification read from the target volume if specified
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    out_file: generic/file
-    # type=file: 
-    # type=file|default=<undefined>: output filename
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: moving tensor volume
-    out_file:
-    # type=file: 
-    # type=file|default=<undefined>: output filename
-    transform:
-    # type=file|default=<undefined>: transform to apply: specify an input transformation file; parameters input will be ignored
-    interpolation:
-    # type=enum|default='LEI'|allowed['EI','LEI']: Log Euclidean/Euclidean Interpolation
-    reorient:
-    # type=enum|default='PPD'|allowed['FS','NO','PPD']: Reorientation strategy: preservation of principal direction, no reorientation, or finite strain
-    target:
-    # type=file|default=<undefined>: output volume specification read from the target volume if specified
-    translation:
-    # type=tuple|default=(<traits.trait_types.Float object at 0x1416bb090>, <traits.trait_types.Float object at 0x1416bb050>, <traits.trait_types.Float object at 0x1416bb150>): translation (x,y,z) in mm
-    euler:
-    # type=tuple|default=(<traits.trait_types.Float object at 0x1416bb310>, <traits.trait_types.Float object at 0x1416bb390>, <traits.trait_types.Float object at 0x1416bb550>): (theta, phi, psi) in degrees
-    deformation:
-    # type=tuple|default=(<traits.trait_types.Float object at 0x1416bb6d0>, <traits.trait_types.Float object at 0x1416bb6d0>, <traits.trait_types.Float object at 0x1416bb6d0>, <traits.trait_types.Float object at 0x1416bb6d0>, <traits.trait_types.Float object at 0x1416bb6d0>, <traits.trait_types.Float object at 0x1416bb6d0>): (xx,yy,zz,xy,yz,xz)
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/aff_sym_tensor_3d_vol_task_callables.py b/example-specs/task/nipype_internal/pydra-dtitk/aff_sym_tensor_3d_vol_task_callables.py
deleted file mode 100644
index 26bd31a6..00000000
--- a/example-specs/task/nipype_internal/pydra-dtitk/aff_sym_tensor_3d_vol_task_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in affSymTensor3DVolTask.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/affine.yaml b/example-specs/task/nipype_internal/pydra-dtitk/affine.yaml
deleted file mode 100644
index 413aa98f..00000000
--- a/example-specs/task/nipype_internal/pydra-dtitk/affine.yaml
+++ /dev/null
@@ -1,157 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.dtitk.registration.Affine' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Performs affine registration between two tensor volumes
-# 
-#     Example
-#     -------
-# 
-#     >>> from nipype.interfaces import dtitk
-#     >>> node = dtitk.Affine()
-#     >>> node.inputs.fixed_file = 'im1.nii'
-#     >>> node.inputs.moving_file = 'im2.nii'
-#     >>> node.inputs.similarity_metric = 'EDS'
-#     >>> node.inputs.sampling_xyz = (4,4,4)
-#     >>> node.inputs.ftol = 0.01
-#     >>> node.inputs.initialize_xfm = 'im_affine.aff'
-#     >>> node.cmdline
-#     'dti_affine_reg im1.nii im2.nii EDS 4 4 4 0.01 im_affine.aff'
-#     >>> node.run() # doctest: +SKIP
-#     
-task_name: Affine
-nipype_name: Affine
-nipype_module: nipype.interfaces.dtitk.registration
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    fixed_file: medimage/nifti1
-    # type=file|default=<undefined>: fixed tensor volume
-    moving_file: medimage/nifti1
-    # type=file|default=<undefined>: moving tensor volume
-    initialize_xfm: medimage-dtitk/aff
-    # type=file|default=<undefined>: Initialize w/DTITK-FORMAT affine
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    out_file: generic/file
-    # type=file: 
-    out_file_xfm: generic/file
-    # type=file: 
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    fixed_file:
-    # type=file|default=<undefined>: fixed tensor volume
-    moving_file:
-    # type=file|default=<undefined>: moving tensor volume
-    similarity_metric:
-    # type=enum|default='EDS'|allowed['DDS','EDS','GDS','NMI']: similarity metric
-    sampling_xyz:
-    # type=tuple|default=(4, 4, 4): dist between samp points (mm) (x,y,z)
-    ftol:
-    # type=float|default=0.01: cost function tolerance
-    initialize_xfm:
-    # type=file|default=<undefined>: Initialize w/DTITK-FORMAT affine
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    fixed_file:
-    # type=file|default=<undefined>: fixed tensor volume
-    moving_file:
-    # type=file|default=<undefined>: moving tensor volume
-    similarity_metric: '"EDS"'
-    # type=enum|default='EDS'|allowed['DDS','EDS','GDS','NMI']: similarity metric
-    sampling_xyz: (4,4,4)
-    # type=tuple|default=(4, 4, 4): dist between samp points (mm) (x,y,z)
-    ftol: '0.01'
-    # type=float|default=0.01: cost function tolerance
-    initialize_xfm:
-    # type=file|default=<undefined>: Initialize w/DTITK-FORMAT affine
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests:
-- cmdline: dti_affine_reg im1.nii im2.nii EDS 4 4 4 0.01 im_affine.aff
-  # str - the expected cmdline output
-  inputs:
-  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
-  # If the field is of file-format type and the value is None, then the
-  # '.mock()' method of the corresponding class is used instead.
-    fixed_file:
-    # type=file|default=<undefined>: fixed tensor volume
-    moving_file:
-    # type=file|default=<undefined>: moving tensor volume
-    similarity_metric: '"EDS"'
-    # type=enum|default='EDS'|allowed['DDS','EDS','GDS','NMI']: similarity metric
-    sampling_xyz: (4,4,4)
-    # type=tuple|default=(4, 4, 4): dist between samp points (mm) (x,y,z)
-    ftol: '0.01'
-    # type=float|default=0.01: cost function tolerance
-    initialize_xfm:
-    # type=file|default=<undefined>: Initialize w/DTITK-FORMAT affine
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  directive:
-  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/affine_callables.py b/example-specs/task/nipype_internal/pydra-dtitk/affine_callables.py
deleted file mode 100644
index 61840691..00000000
--- a/example-specs/task/nipype_internal/pydra-dtitk/affine_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in Affine.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/affine_task.yaml b/example-specs/task/nipype_internal/pydra-dtitk/affine_task.yaml
deleted file mode 100644
index d5a81cd7..00000000
--- a/example-specs/task/nipype_internal/pydra-dtitk/affine_task.yaml
+++ /dev/null
@@ -1,88 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.dtitk.registration.AffineTask' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-task_name: AffineTask
-nipype_name: AffineTask
-nipype_module: nipype.interfaces.dtitk.registration
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    fixed_file: generic/file
-    # type=file|default=<undefined>: fixed tensor volume
-    moving_file: generic/file
-    # type=file|default=<undefined>: moving tensor volume
-    initialize_xfm: generic/file
-    # type=file|default=<undefined>: Initialize w/DTITK-FORMAT affine
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    out_file: generic/file
-    # type=file: 
-    out_file_xfm: generic/file
-    # type=file: 
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    fixed_file:
-    # type=file|default=<undefined>: fixed tensor volume
-    moving_file:
-    # type=file|default=<undefined>: moving tensor volume
-    similarity_metric:
-    # type=enum|default='EDS'|allowed['DDS','EDS','GDS','NMI']: similarity metric
-    sampling_xyz:
-    # type=tuple|default=(4, 4, 4): dist between samp points (mm) (x,y,z)
-    ftol:
-    # type=float|default=0.01: cost function tolerance
-    initialize_xfm:
-    # type=file|default=<undefined>: Initialize w/DTITK-FORMAT affine
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/affine_task_callables.py b/example-specs/task/nipype_internal/pydra-dtitk/affine_task_callables.py
deleted file mode 100644
index fca167db..00000000
--- a/example-specs/task/nipype_internal/pydra-dtitk/affine_task_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in AffineTask.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/bin_thresh.yaml b/example-specs/task/nipype_internal/pydra-dtitk/bin_thresh.yaml
deleted file mode 100644
index 815cd3f0..00000000
--- a/example-specs/task/nipype_internal/pydra-dtitk/bin_thresh.yaml
+++ /dev/null
@@ -1,152 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.dtitk.utils.BinThresh' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Binarizes an image.
-# 
-#     Example
-#     -------
-#     >>> from nipype.interfaces import dtitk
-#     >>> node = dtitk.BinThresh()
-#     >>> node.inputs.in_file = 'im1.nii'
-#     >>> node.inputs.lower_bound = 0
-#     >>> node.inputs.upper_bound = 100
-#     >>> node.inputs.inside_value = 1
-#     >>> node.inputs.outside_value = 0
-#     >>> node.cmdline
-#     'BinaryThresholdImageFilter im1.nii im1_thrbin.nii 0 100 1 0'
-#     >>> node.run() # doctest: +SKIP
-# 
-#     
-task_name: BinThresh
-nipype_name: BinThresh
-nipype_module: nipype.interfaces.dtitk.utils
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_file: medimage/nifti1
-    # type=file|default=<undefined>: Image to threshold/binarize
-    out_file: generic/file
-    # type=file: 
-    # type=file|default=<undefined>: output path
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    out_file: generic/file
-    # type=file: 
-    # type=file|default=<undefined>: output path
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: Image to threshold/binarize
-    out_file:
-    # type=file: 
-    # type=file|default=<undefined>: output path
-    lower_bound:
-    # type=float|default=0.01: lower bound of binarization range
-    upper_bound:
-    # type=float|default=100: upper bound of binarization range
-    inside_value:
-    # type=float|default=1: value for voxels in binarization range
-    outside_value:
-    # type=float|default=0: value for voxels outside of binarization range
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: Image to threshold/binarize
-    lower_bound: '0'
-    # type=float|default=0.01: lower bound of binarization range
-    upper_bound: '100'
-    # type=float|default=100: upper bound of binarization range
-    inside_value: '1'
-    # type=float|default=1: value for voxels in binarization range
-    outside_value: '0'
-    # type=float|default=0: value for voxels outside of binarization range
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests:
-- cmdline: BinaryThresholdImageFilter im1.nii im1_thrbin.nii 0 100 1 0
-  # str - the expected cmdline output
-  inputs:
-  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
-  # If the field is of file-format type and the value is None, then the
-  # '.mock()' method of the corresponding class is used instead.
-    in_file:
-    # type=file|default=<undefined>: Image to threshold/binarize
-    lower_bound: '0'
-    # type=float|default=0.01: lower bound of binarization range
-    upper_bound: '100'
-    # type=float|default=100: upper bound of binarization range
-    inside_value: '1'
-    # type=float|default=1: value for voxels in binarization range
-    outside_value: '0'
-    # type=float|default=0: value for voxels outside of binarization range
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  directive:
-  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/bin_thresh_callables.py b/example-specs/task/nipype_internal/pydra-dtitk/bin_thresh_callables.py
deleted file mode 100644
index c89f3730..00000000
--- a/example-specs/task/nipype_internal/pydra-dtitk/bin_thresh_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in BinThresh.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/bin_thresh_task.yaml b/example-specs/task/nipype_internal/pydra-dtitk/bin_thresh_task.yaml
deleted file mode 100644
index e1919270..00000000
--- a/example-specs/task/nipype_internal/pydra-dtitk/bin_thresh_task.yaml
+++ /dev/null
@@ -1,87 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.dtitk.utils.BinThreshTask' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-task_name: BinThreshTask
-nipype_name: BinThreshTask
-nipype_module: nipype.interfaces.dtitk.utils
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_file: generic/file
-    # type=file|default=<undefined>: Image to threshold/binarize
-    out_file: generic/file
-    # type=file: 
-    # type=file|default=<undefined>: output path
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    out_file: generic/file
-    # type=file: 
-    # type=file|default=<undefined>: output path
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: Image to threshold/binarize
-    out_file:
-    # type=file: 
-    # type=file|default=<undefined>: output path
-    lower_bound:
-    # type=float|default=0.01: lower bound of binarization range
-    upper_bound:
-    # type=float|default=100: upper bound of binarization range
-    inside_value:
-    # type=float|default=1: value for voxels in binarization range
-    outside_value:
-    # type=float|default=0: value for voxels outside of binarization range
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/bin_thresh_task_callables.py b/example-specs/task/nipype_internal/pydra-dtitk/bin_thresh_task_callables.py
deleted file mode 100644
index f775d432..00000000
--- a/example-specs/task/nipype_internal/pydra-dtitk/bin_thresh_task_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in BinThreshTask.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/compose_xfm.yaml b/example-specs/task/nipype_internal/pydra-dtitk/compose_xfm.yaml
deleted file mode 100644
index 8ae1b4a7..00000000
--- a/example-specs/task/nipype_internal/pydra-dtitk/compose_xfm.yaml
+++ /dev/null
@@ -1,134 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.dtitk.registration.ComposeXfm' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#      Combines diffeomorphic and affine transforms
-# 
-#     Example
-#     -------
-# 
-#     >>> from nipype.interfaces import dtitk
-#     >>> node = dtitk.ComposeXfm()
-#     >>> node.inputs.in_df = 'im_warp.df.nii'
-#     >>> node.inputs.in_aff= 'im_affine.aff'
-#     >>> node.cmdline
-#     'dfRightComposeAffine -aff im_affine.aff -df im_warp.df.nii -out
-#      im_warp_affdf.df.nii'
-#     >>> node.run() # doctest: +SKIP
-#     
-task_name: ComposeXfm
-nipype_name: ComposeXfm
-nipype_module: nipype.interfaces.dtitk.registration
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_df: medimage/nifti1
-    # type=file|default=<undefined>: diffeomorphic warp file
-    in_aff: medimage-dtitk/aff
-    # type=file|default=<undefined>: affine transform file
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    out_file: generic/file
-    # type=file: 
-    # type=file|default=<undefined>: output path
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    out_file: out_file
-    # type=file: 
-    # type=file|default=<undefined>: output path
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_df:
-    # type=file|default=<undefined>: diffeomorphic warp file
-    in_aff:
-    # type=file|default=<undefined>: affine transform file
-    out_file:
-    # type=file: 
-    # type=file|default=<undefined>: output path
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_df:
-    # type=file|default=<undefined>: diffeomorphic warp file
-    in_aff:
-    # type=file|default=<undefined>: affine transform file
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests:
-- cmdline: dfRightComposeAffine -aff im_affine.aff -df im_warp.df.nii -out im_warp_affdf.df.nii
-  # str - the expected cmdline output
-  inputs:
-  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
-  # If the field is of file-format type and the value is None, then the
-  # '.mock()' method of the corresponding class is used instead.
-    in_df:
-    # type=file|default=<undefined>: diffeomorphic warp file
-    in_aff:
-    # type=file|default=<undefined>: affine transform file
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  directive:
-  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/compose_xfm_callables.py b/example-specs/task/nipype_internal/pydra-dtitk/compose_xfm_callables.py
deleted file mode 100644
index 84747e4a..00000000
--- a/example-specs/task/nipype_internal/pydra-dtitk/compose_xfm_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in ComposeXfm.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/compose_xfm_task.yaml b/example-specs/task/nipype_internal/pydra-dtitk/compose_xfm_task.yaml
deleted file mode 100644
index 5259057f..00000000
--- a/example-specs/task/nipype_internal/pydra-dtitk/compose_xfm_task.yaml
+++ /dev/null
@@ -1,83 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.dtitk.registration.ComposeXfmTask' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-task_name: ComposeXfmTask
-nipype_name: ComposeXfmTask
-nipype_module: nipype.interfaces.dtitk.registration
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_df: generic/file
-    # type=file|default=<undefined>: diffeomorphic warp file
-    in_aff: generic/file
-    # type=file|default=<undefined>: affine transform file
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    out_file: generic/file
-    # type=file: 
-    # type=file|default=<undefined>: output path
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    out_file: out_file
-    # type=file: 
-    # type=file|default=<undefined>: output path
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_df:
-    # type=file|default=<undefined>: diffeomorphic warp file
-    in_aff:
-    # type=file|default=<undefined>: affine transform file
-    out_file:
-    # type=file: 
-    # type=file|default=<undefined>: output path
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/compose_xfm_task_callables.py b/example-specs/task/nipype_internal/pydra-dtitk/compose_xfm_task_callables.py
deleted file mode 100644
index ced1d1dd..00000000
--- a/example-specs/task/nipype_internal/pydra-dtitk/compose_xfm_task_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in ComposeXfmTask.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/diffeo.yaml b/example-specs/task/nipype_internal/pydra-dtitk/diffeo.yaml
deleted file mode 100644
index e232fe04..00000000
--- a/example-specs/task/nipype_internal/pydra-dtitk/diffeo.yaml
+++ /dev/null
@@ -1,157 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.dtitk.registration.Diffeo' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Performs diffeomorphic registration between two tensor volumes
-# 
-#     Example
-#     -------
-# 
-#     >>> from nipype.interfaces import dtitk
-#     >>> node = dtitk.Diffeo()
-#     >>> node.inputs.fixed_file = 'im1.nii'
-#     >>> node.inputs.moving_file = 'im2.nii'
-#     >>> node.inputs.mask_file = 'mask.nii'
-#     >>> node.inputs.legacy = 1
-#     >>> node.inputs.n_iters = 6
-#     >>> node.inputs.ftol = 0.002
-#     >>> node.cmdline
-#     'dti_diffeomorphic_reg im1.nii im2.nii mask.nii 1 6 0.002'
-#     >>> node.run() # doctest: +SKIP
-#     
-task_name: Diffeo
-nipype_name: Diffeo
-nipype_module: nipype.interfaces.dtitk.registration
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    fixed_file: medimage/nifti1
-    # type=file|default=<undefined>: fixed tensor volume
-    moving_file: medimage/nifti1
-    # type=file|default=<undefined>: moving tensor volume
-    mask_file: medimage/nifti1
-    # type=file|default=<undefined>: mask
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    out_file: generic/file
-    # type=file: 
-    out_file_xfm: generic/file
-    # type=file: 
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    fixed_file:
-    # type=file|default=<undefined>: fixed tensor volume
-    moving_file:
-    # type=file|default=<undefined>: moving tensor volume
-    mask_file:
-    # type=file|default=<undefined>: mask
-    legacy:
-    # type=enum|default=1|allowed[1]: legacy parameter; always set to 1
-    n_iters:
-    # type=int|default=6: number of iterations
-    ftol:
-    # type=float|default=0.002: iteration for the optimization to stop
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    fixed_file:
-    # type=file|default=<undefined>: fixed tensor volume
-    moving_file:
-    # type=file|default=<undefined>: moving tensor volume
-    mask_file:
-    # type=file|default=<undefined>: mask
-    legacy: '1'
-    # type=enum|default=1|allowed[1]: legacy parameter; always set to 1
-    n_iters: '6'
-    # type=int|default=6: number of iterations
-    ftol: '0.002'
-    # type=float|default=0.002: iteration for the optimization to stop
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests:
-- cmdline: dti_diffeomorphic_reg im1.nii im2.nii mask.nii 1 6 0.002
-  # str - the expected cmdline output
-  inputs:
-  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
-  # If the field is of file-format type and the value is None, then the
-  # '.mock()' method of the corresponding class is used instead.
-    fixed_file:
-    # type=file|default=<undefined>: fixed tensor volume
-    moving_file:
-    # type=file|default=<undefined>: moving tensor volume
-    mask_file:
-    # type=file|default=<undefined>: mask
-    legacy: '1'
-    # type=enum|default=1|allowed[1]: legacy parameter; always set to 1
-    n_iters: '6'
-    # type=int|default=6: number of iterations
-    ftol: '0.002'
-    # type=float|default=0.002: iteration for the optimization to stop
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  directive:
-  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/diffeo_callables.py b/example-specs/task/nipype_internal/pydra-dtitk/diffeo_callables.py
deleted file mode 100644
index 3f705d76..00000000
--- a/example-specs/task/nipype_internal/pydra-dtitk/diffeo_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in Diffeo.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/diffeo_scalar_vol.yaml b/example-specs/task/nipype_internal/pydra-dtitk/diffeo_scalar_vol.yaml
deleted file mode 100644
index 19984e5a..00000000
--- a/example-specs/task/nipype_internal/pydra-dtitk/diffeo_scalar_vol.yaml
+++ /dev/null
@@ -1,146 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.dtitk.registration.DiffeoScalarVol' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Applies diffeomorphic transform to a scalar volume
-# 
-#     Example
-#     -------
-# 
-#     >>> from nipype.interfaces import dtitk
-#     >>> node = dtitk.DiffeoScalarVol()
-#     >>> node.inputs.in_file = 'im1.nii'
-#     >>> node.inputs.transform = 'im_warp.df.nii'
-#     >>> node.cmdline
-#     'deformationScalarVolume -in im1.nii -interp 0 -out im1_diffeoxfmd.nii
-#      -trans im_warp.df.nii'
-#     >>> node.run() # doctest: +SKIP
-#     
-task_name: DiffeoScalarVol
-nipype_name: DiffeoScalarVol
-nipype_module: nipype.interfaces.dtitk.registration
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_file: medimage/nifti1
-    # type=file|default=<undefined>: moving scalar volume
-    out_file: generic/file
-    # type=file: moved volume
-    # type=file|default=<undefined>: output filename
-    transform: medimage/nifti1
-    # type=file|default=<undefined>: transform to apply
-    target: generic/file
-    # type=file|default=<undefined>: output volume specification read from the target volume if specified
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    out_file: generic/file
-    # type=file: moved volume
-    # type=file|default=<undefined>: output filename
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: moving scalar volume
-    out_file:
-    # type=file: moved volume
-    # type=file|default=<undefined>: output filename
-    transform:
-    # type=file|default=<undefined>: transform to apply
-    target:
-    # type=file|default=<undefined>: output volume specification read from the target volume if specified
-    voxel_size:
-    # type=tuple|default=(<traits.trait_types.Float object at 0x1416c3f10>, <traits.trait_types.Float object at 0x1416c3e50>, <traits.trait_types.Float object at 0x1416c3f90>): xyz voxel size (superseded by target)
-    flip:
-    # type=tuple|default=(<traits.trait_types.Int object at 0x1416cc210>, <traits.trait_types.Int object at 0x1416cc3d0>, <traits.trait_types.Int object at 0x1416cc410>): 
-    resampling_type:
-    # type=enum|default='backward'|allowed['backward','forward']: use backward or forward resampling
-    interpolation:
-    # type=enum|default='trilinear'|allowed['NN','trilinear']: trilinear, or nearest neighbor
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: moving scalar volume
-    transform:
-    # type=file|default=<undefined>: transform to apply
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests:
-- cmdline: deformationScalarVolume -in im1.nii -interp 0 -out im1_diffeoxfmd.nii -trans im_warp.df.nii
-  # str - the expected cmdline output
-  inputs:
-  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
-  # If the field is of file-format type and the value is None, then the
-  # '.mock()' method of the corresponding class is used instead.
-    in_file:
-    # type=file|default=<undefined>: moving scalar volume
-    transform:
-    # type=file|default=<undefined>: transform to apply
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  directive:
-  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/diffeo_scalar_vol_callables.py b/example-specs/task/nipype_internal/pydra-dtitk/diffeo_scalar_vol_callables.py
deleted file mode 100644
index 87bbb225..00000000
--- a/example-specs/task/nipype_internal/pydra-dtitk/diffeo_scalar_vol_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in DiffeoScalarVol.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/diffeo_scalar_vol_task.yaml b/example-specs/task/nipype_internal/pydra-dtitk/diffeo_scalar_vol_task.yaml
deleted file mode 100644
index 24776140..00000000
--- a/example-specs/task/nipype_internal/pydra-dtitk/diffeo_scalar_vol_task.yaml
+++ /dev/null
@@ -1,95 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.dtitk.registration.diffeoScalarVolTask' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-task_name: diffeoScalarVolTask
-nipype_name: diffeoScalarVolTask
-nipype_module: nipype.interfaces.dtitk.registration
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_file: generic/file
-    # type=file|default=<undefined>: moving scalar volume
-    out_file: generic/file
-    # type=file: moved volume
-    # type=file|default=<undefined>: output filename
-    transform: generic/file
-    # type=file|default=<undefined>: transform to apply
-    target: generic/file
-    # type=file|default=<undefined>: output volume specification read from the target volume if specified
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    out_file: generic/file
-    # type=file: moved volume
-    # type=file|default=<undefined>: output filename
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: moving scalar volume
-    out_file:
-    # type=file: moved volume
-    # type=file|default=<undefined>: output filename
-    transform:
-    # type=file|default=<undefined>: transform to apply
-    target:
-    # type=file|default=<undefined>: output volume specification read from the target volume if specified
-    voxel_size:
-    # type=tuple|default=(<traits.trait_types.Float object at 0x1416c3f10>, <traits.trait_types.Float object at 0x1416c3e50>, <traits.trait_types.Float object at 0x1416c3f90>): xyz voxel size (superseded by target)
-    flip:
-    # type=tuple|default=(<traits.trait_types.Int object at 0x1416cc210>, <traits.trait_types.Int object at 0x1416cc3d0>, <traits.trait_types.Int object at 0x1416cc410>): 
-    resampling_type:
-    # type=enum|default='backward'|allowed['backward','forward']: use backward or forward resampling
-    interpolation:
-    # type=enum|default='trilinear'|allowed['NN','trilinear']: trilinear, or nearest neighbor
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/diffeo_scalar_vol_task_callables.py b/example-specs/task/nipype_internal/pydra-dtitk/diffeo_scalar_vol_task_callables.py
deleted file mode 100644
index 65dfccc0..00000000
--- a/example-specs/task/nipype_internal/pydra-dtitk/diffeo_scalar_vol_task_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in diffeoScalarVolTask.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/diffeo_sym_tensor_3d_vol.yaml b/example-specs/task/nipype_internal/pydra-dtitk/diffeo_sym_tensor_3d_vol.yaml
deleted file mode 100644
index 5642290a..00000000
--- a/example-specs/task/nipype_internal/pydra-dtitk/diffeo_sym_tensor_3d_vol.yaml
+++ /dev/null
@@ -1,150 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.dtitk.registration.DiffeoSymTensor3DVol' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Applies diffeomorphic transform to a tensor volume
-# 
-#     Example
-#     -------
-# 
-#     >>> from nipype.interfaces import dtitk
-#     >>> node = dtitk.DiffeoSymTensor3DVol()
-#     >>> node.inputs.in_file = 'im1.nii'
-#     >>> node.inputs.transform = 'im_warp.df.nii'
-#     >>> node.cmdline
-#     'deformationSymTensor3DVolume -df FD -in im1.nii -interp LEI -out
-#      im1_diffeoxfmd.nii -reorient PPD -trans im_warp.df.nii'
-#     >>> node.run() # doctest: +SKIP
-#     
-task_name: DiffeoSymTensor3DVol
-nipype_name: DiffeoSymTensor3DVol
-nipype_module: nipype.interfaces.dtitk.registration
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_file: medimage/nifti1
-    # type=file|default=<undefined>: moving tensor volume
-    out_file: generic/file
-    # type=file: 
-    # type=file|default=<undefined>: output filename
-    transform: medimage/nifti1
-    # type=file|default=<undefined>: transform to apply
-    target: generic/file
-    # type=file|default=<undefined>: output volume specification read from the target volume if specified
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    out_file: generic/file
-    # type=file: 
-    # type=file|default=<undefined>: output filename
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: moving tensor volume
-    out_file:
-    # type=file: 
-    # type=file|default=<undefined>: output filename
-    transform:
-    # type=file|default=<undefined>: transform to apply
-    df:
-    # type=str|default='FD': 
-    interpolation:
-    # type=enum|default='LEI'|allowed['EI','LEI']: Log Euclidean/Euclidean Interpolation
-    reorient:
-    # type=enum|default='PPD'|allowed['FS','PPD']: Reorientation strategy: preservation of principal direction or finite strain
-    target:
-    # type=file|default=<undefined>: output volume specification read from the target volume if specified
-    voxel_size:
-    # type=tuple|default=(<traits.trait_types.Float object at 0x1416c2690>, <traits.trait_types.Float object at 0x1416c2650>, <traits.trait_types.Float object at 0x1416c2750>): xyz voxel size (superseded by target)
-    flip:
-    # type=tuple|default=(<traits.trait_types.Int object at 0x1416c2990>, <traits.trait_types.Int object at 0x1416c2b50>, <traits.trait_types.Int object at 0x1416c2b90>): 
-    resampling_type:
-    # type=enum|default='backward'|allowed['backward','forward']: use backward or forward resampling
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: moving tensor volume
-    transform:
-    # type=file|default=<undefined>: transform to apply
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests:
-- cmdline: deformationSymTensor3DVolume -df FD -in im1.nii -interp LEI -out im1_diffeoxfmd.nii -reorient PPD -trans im_warp.df.nii
-  # str - the expected cmdline output
-  inputs:
-  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
-  # If the field is of file-format type and the value is None, then the
-  # '.mock()' method of the corresponding class is used instead.
-    in_file:
-    # type=file|default=<undefined>: moving tensor volume
-    transform:
-    # type=file|default=<undefined>: transform to apply
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  directive:
-  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/diffeo_sym_tensor_3d_vol_callables.py b/example-specs/task/nipype_internal/pydra-dtitk/diffeo_sym_tensor_3d_vol_callables.py
deleted file mode 100644
index 870dd500..00000000
--- a/example-specs/task/nipype_internal/pydra-dtitk/diffeo_sym_tensor_3d_vol_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in DiffeoSymTensor3DVol.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/diffeo_sym_tensor_3d_vol_task.yaml b/example-specs/task/nipype_internal/pydra-dtitk/diffeo_sym_tensor_3d_vol_task.yaml
deleted file mode 100644
index 6a21e37d..00000000
--- a/example-specs/task/nipype_internal/pydra-dtitk/diffeo_sym_tensor_3d_vol_task.yaml
+++ /dev/null
@@ -1,99 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.dtitk.registration.diffeoSymTensor3DVolTask' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-task_name: diffeoSymTensor3DVolTask
-nipype_name: diffeoSymTensor3DVolTask
-nipype_module: nipype.interfaces.dtitk.registration
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_file: generic/file
-    # type=file|default=<undefined>: moving tensor volume
-    out_file: generic/file
-    # type=file: 
-    # type=file|default=<undefined>: output filename
-    transform: generic/file
-    # type=file|default=<undefined>: transform to apply
-    target: generic/file
-    # type=file|default=<undefined>: output volume specification read from the target volume if specified
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    out_file: generic/file
-    # type=file: 
-    # type=file|default=<undefined>: output filename
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: moving tensor volume
-    out_file:
-    # type=file: 
-    # type=file|default=<undefined>: output filename
-    transform:
-    # type=file|default=<undefined>: transform to apply
-    df:
-    # type=str|default='FD': 
-    interpolation:
-    # type=enum|default='LEI'|allowed['EI','LEI']: Log Euclidean/Euclidean Interpolation
-    reorient:
-    # type=enum|default='PPD'|allowed['FS','PPD']: Reorientation strategy: preservation of principal direction or finite strain
-    target:
-    # type=file|default=<undefined>: output volume specification read from the target volume if specified
-    voxel_size:
-    # type=tuple|default=(<traits.trait_types.Float object at 0x1416c2690>, <traits.trait_types.Float object at 0x1416c2650>, <traits.trait_types.Float object at 0x1416c2750>): xyz voxel size (superseded by target)
-    flip:
-    # type=tuple|default=(<traits.trait_types.Int object at 0x1416c2990>, <traits.trait_types.Int object at 0x1416c2b50>, <traits.trait_types.Int object at 0x1416c2b90>): 
-    resampling_type:
-    # type=enum|default='backward'|allowed['backward','forward']: use backward or forward resampling
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/diffeo_sym_tensor_3d_vol_task_callables.py b/example-specs/task/nipype_internal/pydra-dtitk/diffeo_sym_tensor_3d_vol_task_callables.py
deleted file mode 100644
index ffe46e92..00000000
--- a/example-specs/task/nipype_internal/pydra-dtitk/diffeo_sym_tensor_3d_vol_task_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in diffeoSymTensor3DVolTask.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/diffeo_task.yaml b/example-specs/task/nipype_internal/pydra-dtitk/diffeo_task.yaml
deleted file mode 100644
index 886b0230..00000000
--- a/example-specs/task/nipype_internal/pydra-dtitk/diffeo_task.yaml
+++ /dev/null
@@ -1,88 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.dtitk.registration.DiffeoTask' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-task_name: DiffeoTask
-nipype_name: DiffeoTask
-nipype_module: nipype.interfaces.dtitk.registration
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    fixed_file: generic/file
-    # type=file|default=<undefined>: fixed tensor volume
-    moving_file: generic/file
-    # type=file|default=<undefined>: moving tensor volume
-    mask_file: generic/file
-    # type=file|default=<undefined>: mask
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    out_file: generic/file
-    # type=file: 
-    out_file_xfm: generic/file
-    # type=file: 
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    fixed_file:
-    # type=file|default=<undefined>: fixed tensor volume
-    moving_file:
-    # type=file|default=<undefined>: moving tensor volume
-    mask_file:
-    # type=file|default=<undefined>: mask
-    legacy:
-    # type=enum|default=1|allowed[1]: legacy parameter; always set to 1
-    n_iters:
-    # type=int|default=6: number of iterations
-    ftol:
-    # type=float|default=0.002: iteration for the optimization to stop
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/diffeo_task_callables.py b/example-specs/task/nipype_internal/pydra-dtitk/diffeo_task_callables.py
deleted file mode 100644
index e17bb936..00000000
--- a/example-specs/task/nipype_internal/pydra-dtitk/diffeo_task_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in DiffeoTask.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/rigid.yaml b/example-specs/task/nipype_internal/pydra-dtitk/rigid.yaml
deleted file mode 100644
index b138a72d..00000000
--- a/example-specs/task/nipype_internal/pydra-dtitk/rigid.yaml
+++ /dev/null
@@ -1,152 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.dtitk.registration.Rigid' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Performs rigid registration between two tensor volumes
-# 
-#     Example
-#     -------
-# 
-#     >>> from nipype.interfaces import dtitk
-#     >>> node = dtitk.Rigid()
-#     >>> node.inputs.fixed_file = 'im1.nii'
-#     >>> node.inputs.moving_file = 'im2.nii'
-#     >>> node.inputs.similarity_metric = 'EDS'
-#     >>> node.inputs.sampling_xyz = (4,4,4)
-#     >>> node.inputs.ftol = 0.01
-#     >>> node.cmdline
-#     'dti_rigid_reg im1.nii im2.nii EDS 4 4 4 0.01'
-#     >>> node.run() # doctest: +SKIP
-#     
-task_name: Rigid
-nipype_name: Rigid
-nipype_module: nipype.interfaces.dtitk.registration
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    fixed_file: medimage/nifti1
-    # type=file|default=<undefined>: fixed tensor volume
-    moving_file: medimage/nifti1
-    # type=file|default=<undefined>: moving tensor volume
-    initialize_xfm: generic/file
-    # type=file|default=<undefined>: Initialize w/DTITK-FORMAT affine
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    out_file: generic/file
-    # type=file: 
-    out_file_xfm: generic/file
-    # type=file: 
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    fixed_file:
-    # type=file|default=<undefined>: fixed tensor volume
-    moving_file:
-    # type=file|default=<undefined>: moving tensor volume
-    similarity_metric:
-    # type=enum|default='EDS'|allowed['DDS','EDS','GDS','NMI']: similarity metric
-    sampling_xyz:
-    # type=tuple|default=(4, 4, 4): dist between samp points (mm) (x,y,z)
-    ftol:
-    # type=float|default=0.01: cost function tolerance
-    initialize_xfm:
-    # type=file|default=<undefined>: Initialize w/DTITK-FORMAT affine
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    fixed_file:
-    # type=file|default=<undefined>: fixed tensor volume
-    moving_file:
-    # type=file|default=<undefined>: moving tensor volume
-    similarity_metric: '"EDS"'
-    # type=enum|default='EDS'|allowed['DDS','EDS','GDS','NMI']: similarity metric
-    sampling_xyz: (4,4,4)
-    # type=tuple|default=(4, 4, 4): dist between samp points (mm) (x,y,z)
-    ftol: '0.01'
-    # type=float|default=0.01: cost function tolerance
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests:
-- cmdline: dti_rigid_reg im1.nii im2.nii EDS 4 4 4 0.01
-  # str - the expected cmdline output
-  inputs:
-  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
-  # If the field is of file-format type and the value is None, then the
-  # '.mock()' method of the corresponding class is used instead.
-    fixed_file:
-    # type=file|default=<undefined>: fixed tensor volume
-    moving_file:
-    # type=file|default=<undefined>: moving tensor volume
-    similarity_metric: '"EDS"'
-    # type=enum|default='EDS'|allowed['DDS','EDS','GDS','NMI']: similarity metric
-    sampling_xyz: (4,4,4)
-    # type=tuple|default=(4, 4, 4): dist between samp points (mm) (x,y,z)
-    ftol: '0.01'
-    # type=float|default=0.01: cost function tolerance
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  directive:
-  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/rigid_callables.py b/example-specs/task/nipype_internal/pydra-dtitk/rigid_callables.py
deleted file mode 100644
index 76f4fd3c..00000000
--- a/example-specs/task/nipype_internal/pydra-dtitk/rigid_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in Rigid.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/rigid_task.yaml b/example-specs/task/nipype_internal/pydra-dtitk/rigid_task.yaml
deleted file mode 100644
index 69845806..00000000
--- a/example-specs/task/nipype_internal/pydra-dtitk/rigid_task.yaml
+++ /dev/null
@@ -1,88 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.dtitk.registration.RigidTask' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-task_name: RigidTask
-nipype_name: RigidTask
-nipype_module: nipype.interfaces.dtitk.registration
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    fixed_file: generic/file
-    # type=file|default=<undefined>: fixed tensor volume
-    moving_file: generic/file
-    # type=file|default=<undefined>: moving tensor volume
-    initialize_xfm: generic/file
-    # type=file|default=<undefined>: Initialize w/DTITK-FORMAT affine
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    out_file: generic/file
-    # type=file: 
-    out_file_xfm: generic/file
-    # type=file: 
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    fixed_file:
-    # type=file|default=<undefined>: fixed tensor volume
-    moving_file:
-    # type=file|default=<undefined>: moving tensor volume
-    similarity_metric:
-    # type=enum|default='EDS'|allowed['DDS','EDS','GDS','NMI']: similarity metric
-    sampling_xyz:
-    # type=tuple|default=(4, 4, 4): dist between samp points (mm) (x,y,z)
-    ftol:
-    # type=float|default=0.01: cost function tolerance
-    initialize_xfm:
-    # type=file|default=<undefined>: Initialize w/DTITK-FORMAT affine
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/rigid_task_callables.py b/example-specs/task/nipype_internal/pydra-dtitk/rigid_task_callables.py
deleted file mode 100644
index 310d098b..00000000
--- a/example-specs/task/nipype_internal/pydra-dtitk/rigid_task_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in RigidTask.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/sv_adjust_vox_sp.yaml b/example-specs/task/nipype_internal/pydra-dtitk/sv_adjust_vox_sp.yaml
deleted file mode 100644
index 754acdf5..00000000
--- a/example-specs/task/nipype_internal/pydra-dtitk/sv_adjust_vox_sp.yaml
+++ /dev/null
@@ -1,137 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.dtitk.utils.SVAdjustVoxSp' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Adjusts the voxel space of a scalar volume.
-# 
-#     Example
-#     -------
-#     >>> from nipype.interfaces import dtitk
-#     >>> node = dtitk.SVAdjustVoxSp()
-#     >>> node.inputs.in_file = 'im1.nii'
-#     >>> node.inputs.target_file = 'im2.nii'
-#     >>> node.cmdline
-#     'SVAdjustVoxelspace -in im1.nii -out im1_avs.nii -target im2.nii'
-#     >>> node.run() # doctest: +SKIP
-# 
-#     
-task_name: SVAdjustVoxSp
-nipype_name: SVAdjustVoxSp
-nipype_module: nipype.interfaces.dtitk.utils
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_file: medimage/nifti1
-    # type=file|default=<undefined>: scalar volume to modify
-    out_file: generic/file
-    # type=file: 
-    # type=file|default=<undefined>: output path
-    target_file: medimage/nifti1
-    # type=file|default=<undefined>: target volume to match
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    out_file: generic/file
-    # type=file: 
-    # type=file|default=<undefined>: output path
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: scalar volume to modify
-    out_file:
-    # type=file: 
-    # type=file|default=<undefined>: output path
-    target_file:
-    # type=file|default=<undefined>: target volume to match
-    voxel_size:
-    # type=tuple|default=(<traits.trait_types.Float object at 0x1416cfed0>, <traits.trait_types.Float object at 0x1416cfe90>, <traits.trait_types.Float object at 0x1416cff50>): xyz voxel size (superseded by target)
-    origin:
-    # type=tuple|default=(<traits.trait_types.Float object at 0x1416d41d0>, <traits.trait_types.Float object at 0x1416d4390>, <traits.trait_types.Float object at 0x1416d43d0>): xyz origin (superseded by target)
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: scalar volume to modify
-    target_file:
-    # type=file|default=<undefined>: target volume to match
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests:
-- cmdline: SVAdjustVoxelspace -in im1.nii -out im1_avs.nii -target im2.nii
-  # str - the expected cmdline output
-  inputs:
-  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
-  # If the field is of file-format type and the value is None, then the
-  # '.mock()' method of the corresponding class is used instead.
-    in_file:
-    # type=file|default=<undefined>: scalar volume to modify
-    target_file:
-    # type=file|default=<undefined>: target volume to match
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  directive:
-  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/sv_adjust_vox_sp_callables.py b/example-specs/task/nipype_internal/pydra-dtitk/sv_adjust_vox_sp_callables.py
deleted file mode 100644
index 365acffb..00000000
--- a/example-specs/task/nipype_internal/pydra-dtitk/sv_adjust_vox_sp_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in SVAdjustVoxSp.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/sv_adjust_vox_sp_task.yaml b/example-specs/task/nipype_internal/pydra-dtitk/sv_adjust_vox_sp_task.yaml
deleted file mode 100644
index 5e52cddd..00000000
--- a/example-specs/task/nipype_internal/pydra-dtitk/sv_adjust_vox_sp_task.yaml
+++ /dev/null
@@ -1,87 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.dtitk.utils.SVAdjustVoxSpTask' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-task_name: SVAdjustVoxSpTask
-nipype_name: SVAdjustVoxSpTask
-nipype_module: nipype.interfaces.dtitk.utils
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_file: generic/file
-    # type=file|default=<undefined>: scalar volume to modify
-    out_file: generic/file
-    # type=file: 
-    # type=file|default=<undefined>: output path
-    target_file: generic/file
-    # type=file|default=<undefined>: target volume to match
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    out_file: generic/file
-    # type=file: 
-    # type=file|default=<undefined>: output path
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: scalar volume to modify
-    out_file:
-    # type=file: 
-    # type=file|default=<undefined>: output path
-    target_file:
-    # type=file|default=<undefined>: target volume to match
-    voxel_size:
-    # type=tuple|default=(<traits.trait_types.Float object at 0x1416cfed0>, <traits.trait_types.Float object at 0x1416cfe90>, <traits.trait_types.Float object at 0x1416cff50>): xyz voxel size (superseded by target)
-    origin:
-    # type=tuple|default=(<traits.trait_types.Float object at 0x1416d41d0>, <traits.trait_types.Float object at 0x1416d4390>, <traits.trait_types.Float object at 0x1416d43d0>): xyz origin (superseded by target)
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/sv_adjust_vox_sp_task_callables.py b/example-specs/task/nipype_internal/pydra-dtitk/sv_adjust_vox_sp_task_callables.py
deleted file mode 100644
index f2baecbe..00000000
--- a/example-specs/task/nipype_internal/pydra-dtitk/sv_adjust_vox_sp_task_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in SVAdjustVoxSpTask.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/sv_resample.yaml b/example-specs/task/nipype_internal/pydra-dtitk/sv_resample.yaml
deleted file mode 100644
index 66be7aa9..00000000
--- a/example-specs/task/nipype_internal/pydra-dtitk/sv_resample.yaml
+++ /dev/null
@@ -1,141 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.dtitk.utils.SVResample' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Resamples a scalar volume.
-# 
-#     Example
-#     -------
-#     >>> from nipype.interfaces import dtitk
-#     >>> node = dtitk.SVResample()
-#     >>> node.inputs.in_file = 'im1.nii'
-#     >>> node.inputs.target_file = 'im2.nii'
-#     >>> node.cmdline
-#     'SVResample -in im1.nii -out im1_resampled.nii -target im2.nii'
-#     >>> node.run() # doctest: +SKIP
-# 
-#     
-task_name: SVResample
-nipype_name: SVResample
-nipype_module: nipype.interfaces.dtitk.utils
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_file: medimage/nifti1
-    # type=file|default=<undefined>: image to resample
-    out_file: generic/file
-    # type=file: 
-    # type=file|default=<undefined>: output path
-    target_file: medimage/nifti1
-    # type=file|default=<undefined>: specs read from the target volume
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    out_file: generic/file
-    # type=file: 
-    # type=file|default=<undefined>: output path
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: image to resample
-    out_file:
-    # type=file: 
-    # type=file|default=<undefined>: output path
-    target_file:
-    # type=file|default=<undefined>: specs read from the target volume
-    align:
-    # type=enum|default='center'|allowed['center','origin']: how to align output volume to input volume
-    array_size:
-    # type=tuple|default=(<traits.trait_types.Int object at 0x1416d6f10>, <traits.trait_types.Int object at 0x1416d6ed0>, <traits.trait_types.Int object at 0x1416d6f50>): resampled array size
-    voxel_size:
-    # type=tuple|default=(<traits.trait_types.Float object at 0x1416d71d0>, <traits.trait_types.Float object at 0x1416d7390>, <traits.trait_types.Float object at 0x1416d73d0>): resampled voxel size
-    origin:
-    # type=tuple|default=(<traits.trait_types.Float object at 0x1416d7550>, <traits.trait_types.Float object at 0x1416d7710>, <traits.trait_types.Float object at 0x1416d7750>): xyz origin
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: image to resample
-    target_file:
-    # type=file|default=<undefined>: specs read from the target volume
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests:
-- cmdline: SVResample -in im1.nii -out im1_resampled.nii -target im2.nii
-  # str - the expected cmdline output
-  inputs:
-  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
-  # If the field is of file-format type and the value is None, then the
-  # '.mock()' method of the corresponding class is used instead.
-    in_file:
-    # type=file|default=<undefined>: image to resample
-    target_file:
-    # type=file|default=<undefined>: specs read from the target volume
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  directive:
-  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/sv_resample_callables.py b/example-specs/task/nipype_internal/pydra-dtitk/sv_resample_callables.py
deleted file mode 100644
index b7d579fe..00000000
--- a/example-specs/task/nipype_internal/pydra-dtitk/sv_resample_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in SVResample.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/sv_resample_task.yaml b/example-specs/task/nipype_internal/pydra-dtitk/sv_resample_task.yaml
deleted file mode 100644
index ba3d4317..00000000
--- a/example-specs/task/nipype_internal/pydra-dtitk/sv_resample_task.yaml
+++ /dev/null
@@ -1,91 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.dtitk.utils.SVResampleTask' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-task_name: SVResampleTask
-nipype_name: SVResampleTask
-nipype_module: nipype.interfaces.dtitk.utils
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_file: generic/file
-    # type=file|default=<undefined>: image to resample
-    out_file: generic/file
-    # type=file: 
-    # type=file|default=<undefined>: output path
-    target_file: generic/file
-    # type=file|default=<undefined>: specs read from the target volume
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    out_file: generic/file
-    # type=file: 
-    # type=file|default=<undefined>: output path
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: image to resample
-    out_file:
-    # type=file: 
-    # type=file|default=<undefined>: output path
-    target_file:
-    # type=file|default=<undefined>: specs read from the target volume
-    align:
-    # type=enum|default='center'|allowed['center','origin']: how to align output volume to input volume
-    array_size:
-    # type=tuple|default=(<traits.trait_types.Int object at 0x1416d6f10>, <traits.trait_types.Int object at 0x1416d6ed0>, <traits.trait_types.Int object at 0x1416d6f50>): resampled array size
-    voxel_size:
-    # type=tuple|default=(<traits.trait_types.Float object at 0x1416d71d0>, <traits.trait_types.Float object at 0x1416d7390>, <traits.trait_types.Float object at 0x1416d73d0>): resampled voxel size
-    origin:
-    # type=tuple|default=(<traits.trait_types.Float object at 0x1416d7550>, <traits.trait_types.Float object at 0x1416d7710>, <traits.trait_types.Float object at 0x1416d7750>): xyz origin
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/sv_resample_task_callables.py b/example-specs/task/nipype_internal/pydra-dtitk/sv_resample_task_callables.py
deleted file mode 100644
index 08d5d9df..00000000
--- a/example-specs/task/nipype_internal/pydra-dtitk/sv_resample_task_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in SVResampleTask.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/t_vtool.yaml b/example-specs/task/nipype_internal/pydra-dtitk/t_vtool.yaml
deleted file mode 100644
index e5e6b51a..00000000
--- a/example-specs/task/nipype_internal/pydra-dtitk/t_vtool.yaml
+++ /dev/null
@@ -1,131 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.dtitk.utils.TVtool' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Calculates a tensor metric volume from a tensor volume.
-# 
-#     Example
-#     -------
-#     >>> from nipype.interfaces import dtitk
-#     >>> node = dtitk.TVtool()
-#     >>> node.inputs.in_file = 'im1.nii'
-#     >>> node.inputs.in_flag = 'fa'
-#     >>> node.cmdline
-#     'TVtool -in im1.nii -fa -out im1_fa.nii'
-#     >>> node.run() # doctest: +SKIP
-# 
-#     
-task_name: TVtool
-nipype_name: TVtool
-nipype_module: nipype.interfaces.dtitk.utils
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_file: medimage/nifti1
-    # type=file|default=<undefined>: scalar volume to resample
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    out_file: generic/file
-    # type=file: 
-    # type=file|default=<undefined>: 
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    out_file: out_file
-    # type=file: 
-    # type=file|default=<undefined>: 
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: scalar volume to resample
-    in_flag:
-    # type=enum|default='fa'|allowed['ad','fa','pd','rd','rgb','tr']: 
-    out_file:
-    # type=file: 
-    # type=file|default=<undefined>: 
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: scalar volume to resample
-    in_flag: '"fa"'
-    # type=enum|default='fa'|allowed['ad','fa','pd','rd','rgb','tr']: 
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests:
-- cmdline: TVtool -in im1.nii -fa -out im1_fa.nii
-  # str - the expected cmdline output
-  inputs:
-  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
-  # If the field is of file-format type and the value is None, then the
-  # '.mock()' method of the corresponding class is used instead.
-    in_file:
-    # type=file|default=<undefined>: scalar volume to resample
-    in_flag: '"fa"'
-    # type=enum|default='fa'|allowed['ad','fa','pd','rd','rgb','tr']: 
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  directive:
-  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/t_vtool_callables.py b/example-specs/task/nipype_internal/pydra-dtitk/t_vtool_callables.py
deleted file mode 100644
index 424484e8..00000000
--- a/example-specs/task/nipype_internal/pydra-dtitk/t_vtool_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in TVtool.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/t_vtool_task.yaml b/example-specs/task/nipype_internal/pydra-dtitk/t_vtool_task.yaml
deleted file mode 100644
index 4d250e58..00000000
--- a/example-specs/task/nipype_internal/pydra-dtitk/t_vtool_task.yaml
+++ /dev/null
@@ -1,81 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.dtitk.utils.TVtoolTask' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-task_name: TVtoolTask
-nipype_name: TVtoolTask
-nipype_module: nipype.interfaces.dtitk.utils
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_file: generic/file
-    # type=file|default=<undefined>: scalar volume to resample
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    out_file: generic/file
-    # type=file: 
-    # type=file|default=<undefined>: 
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    out_file: out_file
-    # type=file: 
-    # type=file|default=<undefined>: 
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: scalar volume to resample
-    in_flag:
-    # type=enum|default='fa'|allowed['ad','fa','pd','rd','rgb','tr']: 
-    out_file:
-    # type=file: 
-    # type=file|default=<undefined>: 
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/t_vtool_task_callables.py b/example-specs/task/nipype_internal/pydra-dtitk/t_vtool_task_callables.py
deleted file mode 100644
index 2e8fb4fd..00000000
--- a/example-specs/task/nipype_internal/pydra-dtitk/t_vtool_task_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in TVtoolTask.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/tv_adjust_origin_task.yaml b/example-specs/task/nipype_internal/pydra-dtitk/tv_adjust_origin_task.yaml
deleted file mode 100644
index 31b4f54c..00000000
--- a/example-specs/task/nipype_internal/pydra-dtitk/tv_adjust_origin_task.yaml
+++ /dev/null
@@ -1,87 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.dtitk.utils.TVAdjustOriginTask' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-task_name: TVAdjustOriginTask
-nipype_name: TVAdjustOriginTask
-nipype_module: nipype.interfaces.dtitk.utils
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_file: generic/file
-    # type=file|default=<undefined>: tensor volume to modify
-    out_file: generic/file
-    # type=file: 
-    # type=file|default=<undefined>: output path
-    target_file: generic/file
-    # type=file|default=<undefined>: target volume to match
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    out_file: generic/file
-    # type=file: 
-    # type=file|default=<undefined>: output path
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: tensor volume to modify
-    out_file:
-    # type=file: 
-    # type=file|default=<undefined>: output path
-    target_file:
-    # type=file|default=<undefined>: target volume to match
-    voxel_size:
-    # type=tuple|default=(<traits.trait_types.Float object at 0x1416ce8d0>, <traits.trait_types.Float object at 0x1416ce890>, <traits.trait_types.Float object at 0x1416ce950>): xyz voxel size (superseded by target)
-    origin:
-    # type=tuple|default=(<traits.trait_types.Float object at 0x1416ceb90>, <traits.trait_types.Float object at 0x1416ced50>, <traits.trait_types.Float object at 0x1416ced90>): xyz origin (superseded by target)
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/tv_adjust_origin_task_callables.py b/example-specs/task/nipype_internal/pydra-dtitk/tv_adjust_origin_task_callables.py
deleted file mode 100644
index 862f17c0..00000000
--- a/example-specs/task/nipype_internal/pydra-dtitk/tv_adjust_origin_task_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in TVAdjustOriginTask.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/tv_adjust_vox_sp.yaml b/example-specs/task/nipype_internal/pydra-dtitk/tv_adjust_vox_sp.yaml
deleted file mode 100644
index 0797b006..00000000
--- a/example-specs/task/nipype_internal/pydra-dtitk/tv_adjust_vox_sp.yaml
+++ /dev/null
@@ -1,137 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.dtitk.utils.TVAdjustVoxSp' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#      Adjusts the voxel space of a tensor volume.
-# 
-#     Example
-#     -------
-#     >>> from nipype.interfaces import dtitk
-#     >>> node = dtitk.TVAdjustVoxSp()
-#     >>> node.inputs.in_file = 'im1.nii'
-#     >>> node.inputs.target_file = 'im2.nii'
-#     >>> node.cmdline
-#     'TVAdjustVoxelspace -in im1.nii -out im1_avs.nii -target im2.nii'
-#     >>> node.run() # doctest: +SKIP
-# 
-#     
-task_name: TVAdjustVoxSp
-nipype_name: TVAdjustVoxSp
-nipype_module: nipype.interfaces.dtitk.utils
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_file: medimage/nifti1
-    # type=file|default=<undefined>: tensor volume to modify
-    out_file: generic/file
-    # type=file: 
-    # type=file|default=<undefined>: output path
-    target_file: medimage/nifti1
-    # type=file|default=<undefined>: target volume to match
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    out_file: generic/file
-    # type=file: 
-    # type=file|default=<undefined>: output path
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: tensor volume to modify
-    out_file:
-    # type=file: 
-    # type=file|default=<undefined>: output path
-    target_file:
-    # type=file|default=<undefined>: target volume to match
-    voxel_size:
-    # type=tuple|default=(<traits.trait_types.Float object at 0x1416ce8d0>, <traits.trait_types.Float object at 0x1416ce890>, <traits.trait_types.Float object at 0x1416ce950>): xyz voxel size (superseded by target)
-    origin:
-    # type=tuple|default=(<traits.trait_types.Float object at 0x1416ceb90>, <traits.trait_types.Float object at 0x1416ced50>, <traits.trait_types.Float object at 0x1416ced90>): xyz origin (superseded by target)
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: tensor volume to modify
-    target_file:
-    # type=file|default=<undefined>: target volume to match
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests:
-- cmdline: TVAdjustVoxelspace -in im1.nii -out im1_avs.nii -target im2.nii
-  # str - the expected cmdline output
-  inputs:
-  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
-  # If the field is of file-format type and the value is None, then the
-  # '.mock()' method of the corresponding class is used instead.
-    in_file:
-    # type=file|default=<undefined>: tensor volume to modify
-    target_file:
-    # type=file|default=<undefined>: target volume to match
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  directive:
-  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/tv_adjust_vox_sp_callables.py b/example-specs/task/nipype_internal/pydra-dtitk/tv_adjust_vox_sp_callables.py
deleted file mode 100644
index b63636f5..00000000
--- a/example-specs/task/nipype_internal/pydra-dtitk/tv_adjust_vox_sp_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in TVAdjustVoxSp.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/tv_adjust_vox_sp_task.yaml b/example-specs/task/nipype_internal/pydra-dtitk/tv_adjust_vox_sp_task.yaml
deleted file mode 100644
index 09e53961..00000000
--- a/example-specs/task/nipype_internal/pydra-dtitk/tv_adjust_vox_sp_task.yaml
+++ /dev/null
@@ -1,87 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.dtitk.utils.TVAdjustVoxSpTask' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-task_name: TVAdjustVoxSpTask
-nipype_name: TVAdjustVoxSpTask
-nipype_module: nipype.interfaces.dtitk.utils
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_file: generic/file
-    # type=file|default=<undefined>: tensor volume to modify
-    out_file: generic/file
-    # type=file: 
-    # type=file|default=<undefined>: output path
-    target_file: generic/file
-    # type=file|default=<undefined>: target volume to match
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    out_file: generic/file
-    # type=file: 
-    # type=file|default=<undefined>: output path
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: tensor volume to modify
-    out_file:
-    # type=file: 
-    # type=file|default=<undefined>: output path
-    target_file:
-    # type=file|default=<undefined>: target volume to match
-    voxel_size:
-    # type=tuple|default=(<traits.trait_types.Float object at 0x1416ce8d0>, <traits.trait_types.Float object at 0x1416ce890>, <traits.trait_types.Float object at 0x1416ce950>): xyz voxel size (superseded by target)
-    origin:
-    # type=tuple|default=(<traits.trait_types.Float object at 0x1416ceb90>, <traits.trait_types.Float object at 0x1416ced50>, <traits.trait_types.Float object at 0x1416ced90>): xyz origin (superseded by target)
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/tv_adjust_vox_sp_task_callables.py b/example-specs/task/nipype_internal/pydra-dtitk/tv_adjust_vox_sp_task_callables.py
deleted file mode 100644
index 9a84ba5f..00000000
--- a/example-specs/task/nipype_internal/pydra-dtitk/tv_adjust_vox_sp_task_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in TVAdjustVoxSpTask.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/tv_resample.yaml b/example-specs/task/nipype_internal/pydra-dtitk/tv_resample.yaml
deleted file mode 100644
index ad0c0809..00000000
--- a/example-specs/task/nipype_internal/pydra-dtitk/tv_resample.yaml
+++ /dev/null
@@ -1,143 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.dtitk.utils.TVResample' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Resamples a tensor volume.
-# 
-#     Example
-#     -------
-#     >>> from nipype.interfaces import dtitk
-#     >>> node = dtitk.TVResample()
-#     >>> node.inputs.in_file = 'im1.nii'
-#     >>> node.inputs.target_file = 'im2.nii'
-#     >>> node.cmdline
-#     'TVResample -in im1.nii -out im1_resampled.nii -target im2.nii'
-#     >>> node.run() # doctest: +SKIP
-# 
-#     
-task_name: TVResample
-nipype_name: TVResample
-nipype_module: nipype.interfaces.dtitk.utils
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_file: medimage/nifti1
-    # type=file|default=<undefined>: tensor volume to resample
-    out_file: generic/file
-    # type=file: 
-    # type=file|default=<undefined>: output path
-    target_file: medimage/nifti1
-    # type=file|default=<undefined>: specs read from the target volume
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    out_file: generic/file
-    # type=file: 
-    # type=file|default=<undefined>: output path
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: tensor volume to resample
-    out_file:
-    # type=file: 
-    # type=file|default=<undefined>: output path
-    target_file:
-    # type=file|default=<undefined>: specs read from the target volume
-    align:
-    # type=enum|default='center'|allowed['center','origin']: how to align output volume to input volume
-    interpolation:
-    # type=enum|default='LEI'|allowed['EI','LEI']: Log Euclidean Interpolation
-    array_size:
-    # type=tuple|default=(<traits.trait_types.Int object at 0x1416d5410>, <traits.trait_types.Int object at 0x1416d53d0>, <traits.trait_types.Int object at 0x1416d5450>): resampled array size
-    voxel_size:
-    # type=tuple|default=(<traits.trait_types.Float object at 0x1416d5710>, <traits.trait_types.Float object at 0x1416d58d0>, <traits.trait_types.Float object at 0x1416d5910>): resampled voxel size
-    origin:
-    # type=tuple|default=(<traits.trait_types.Float object at 0x1416d5a90>, <traits.trait_types.Float object at 0x1416d5c50>, <traits.trait_types.Float object at 0x1416d5c90>): xyz origin
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: tensor volume to resample
-    target_file:
-    # type=file|default=<undefined>: specs read from the target volume
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests:
-- cmdline: TVResample -in im1.nii -out im1_resampled.nii -target im2.nii
-  # str - the expected cmdline output
-  inputs:
-  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
-  # If the field is of file-format type and the value is None, then the
-  # '.mock()' method of the corresponding class is used instead.
-    in_file:
-    # type=file|default=<undefined>: tensor volume to resample
-    target_file:
-    # type=file|default=<undefined>: specs read from the target volume
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  directive:
-  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/tv_resample_callables.py b/example-specs/task/nipype_internal/pydra-dtitk/tv_resample_callables.py
deleted file mode 100644
index 00c4dcd8..00000000
--- a/example-specs/task/nipype_internal/pydra-dtitk/tv_resample_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in TVResample.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/tv_resample_task.yaml b/example-specs/task/nipype_internal/pydra-dtitk/tv_resample_task.yaml
deleted file mode 100644
index d829801c..00000000
--- a/example-specs/task/nipype_internal/pydra-dtitk/tv_resample_task.yaml
+++ /dev/null
@@ -1,93 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.dtitk.utils.TVResampleTask' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-task_name: TVResampleTask
-nipype_name: TVResampleTask
-nipype_module: nipype.interfaces.dtitk.utils
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_file: generic/file
-    # type=file|default=<undefined>: tensor volume to resample
-    out_file: generic/file
-    # type=file: 
-    # type=file|default=<undefined>: output path
-    target_file: generic/file
-    # type=file|default=<undefined>: specs read from the target volume
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    out_file: generic/file
-    # type=file: 
-    # type=file|default=<undefined>: output path
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: tensor volume to resample
-    out_file:
-    # type=file: 
-    # type=file|default=<undefined>: output path
-    target_file:
-    # type=file|default=<undefined>: specs read from the target volume
-    align:
-    # type=enum|default='center'|allowed['center','origin']: how to align output volume to input volume
-    interpolation:
-    # type=enum|default='LEI'|allowed['EI','LEI']: Log Euclidean Interpolation
-    array_size:
-    # type=tuple|default=(<traits.trait_types.Int object at 0x1416d5410>, <traits.trait_types.Int object at 0x1416d53d0>, <traits.trait_types.Int object at 0x1416d5450>): resampled array size
-    voxel_size:
-    # type=tuple|default=(<traits.trait_types.Float object at 0x1416d5710>, <traits.trait_types.Float object at 0x1416d58d0>, <traits.trait_types.Float object at 0x1416d5910>): resampled voxel size
-    origin:
-    # type=tuple|default=(<traits.trait_types.Float object at 0x1416d5a90>, <traits.trait_types.Float object at 0x1416d5c50>, <traits.trait_types.Float object at 0x1416d5c90>): xyz origin
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-dtitk/tv_resample_task_callables.py b/example-specs/task/nipype_internal/pydra-dtitk/tv_resample_task_callables.py
deleted file mode 100644
index 33996900..00000000
--- a/example-specs/task/nipype_internal/pydra-dtitk/tv_resample_task_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in TVResampleTask.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-dynamic_slicer/slicer_command_line.yaml b/example-specs/task/nipype_internal/pydra-dynamic_slicer/slicer_command_line.yaml
deleted file mode 100644
index dfede76c..00000000
--- a/example-specs/task/nipype_internal/pydra-dynamic_slicer/slicer_command_line.yaml
+++ /dev/null
@@ -1,68 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.dynamic_slicer.SlicerCommandLine' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Experimental Slicer wrapper. Work in progress.
-task_name: SlicerCommandLine
-nipype_name: SlicerCommandLine
-nipype_module: nipype.interfaces.dynamic_slicer
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    module:
-    # type=str|default='': name of the Slicer command line module you want to use
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-dynamic_slicer/slicer_command_line_callables.py b/example-specs/task/nipype_internal/pydra-dynamic_slicer/slicer_command_line_callables.py
deleted file mode 100644
index a21556e6..00000000
--- a/example-specs/task/nipype_internal/pydra-dynamic_slicer/slicer_command_line_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in SlicerCommandLine.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-elastix/analyze_warp.yaml b/example-specs/task/nipype_internal/pydra-elastix/analyze_warp.yaml
deleted file mode 100644
index 0bf31d31..00000000
--- a/example-specs/task/nipype_internal/pydra-elastix/analyze_warp.yaml
+++ /dev/null
@@ -1,140 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.elastix.registration.AnalyzeWarp' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Use transformix to get details from the input transform (generate
-#     the corresponding deformation field, generate the determinant of the
-#     Jacobian map or the Jacobian map itself)
-# 
-#     Example
-#     -------
-# 
-#     >>> from nipype.interfaces.elastix import AnalyzeWarp
-#     >>> reg = AnalyzeWarp()
-#     >>> reg.inputs.transform_file = 'TransformParameters.0.txt'
-#     >>> reg.cmdline
-#     'transformix -def all -jac all -jacmat all -threads 1 -out ./ -tp TransformParameters.0.txt'
-# 
-# 
-#     
-task_name: AnalyzeWarp
-nipype_name: AnalyzeWarp
-nipype_module: nipype.interfaces.elastix.registration
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    moving_image: generic/file
-    # type=file|default=<undefined>: input image to deform (not used)
-    transform_file: text/text-file
-    # type=file|default=<undefined>: transform-parameter file, only 1
-    output_path: generic/directory
-    # type=directory|default='./': output directory
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    disp_field: generic/file
-    # type=file: displacements field
-    jacdet_map: generic/file
-    # type=file: det(Jacobian) map
-    jacmat_map: generic/file
-    # type=file: Jacobian matrix map
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    points:
-    # type=enum|default='all'|allowed['all']: transform all points from the input-image, which effectively generates a deformation field.
-    jac:
-    # type=enum|default='all'|allowed['all']: generate an image with the determinant of the spatial Jacobian
-    jacmat:
-    # type=enum|default='all'|allowed['all']: generate an image with the spatial Jacobian matrix at each voxel
-    moving_image:
-    # type=file|default=<undefined>: input image to deform (not used)
-    transform_file:
-    # type=file|default=<undefined>: transform-parameter file, only 1
-    output_path:
-    # type=directory|default='./': output directory
-    num_threads:
-    # type=int|default=1: set the maximum number of threads of elastix
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    transform_file:
-    # type=file|default=<undefined>: transform-parameter file, only 1
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests:
-- cmdline: transformix -def all -jac all -jacmat all -threads 1 -out ./ -tp TransformParameters.0.txt
-  # str - the expected cmdline output
-  inputs:
-  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
-  # If the field is of file-format type and the value is None, then the
-  # '.mock()' method of the corresponding class is used instead.
-    transform_file:
-    # type=file|default=<undefined>: transform-parameter file, only 1
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  directive:
-  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-elastix/analyze_warp_callables.py b/example-specs/task/nipype_internal/pydra-elastix/analyze_warp_callables.py
deleted file mode 100644
index 26c9dc5b..00000000
--- a/example-specs/task/nipype_internal/pydra-elastix/analyze_warp_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in AnalyzeWarp.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-elastix/apply_warp.yaml b/example-specs/task/nipype_internal/pydra-elastix/apply_warp.yaml
deleted file mode 100644
index fc177c0b..00000000
--- a/example-specs/task/nipype_internal/pydra-elastix/apply_warp.yaml
+++ /dev/null
@@ -1,134 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.elastix.registration.ApplyWarp' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Use ``transformix`` to apply a transform on an input image.
-#     The transform is specified in the transform-parameter file.
-# 
-#     Example
-#     -------
-# 
-#     >>> from nipype.interfaces.elastix import ApplyWarp
-#     >>> reg = ApplyWarp()
-#     >>> reg.inputs.moving_image = 'moving1.nii'
-#     >>> reg.inputs.transform_file = 'TransformParameters.0.txt'
-#     >>> reg.cmdline
-#     'transformix -in moving1.nii -threads 1 -out ./ -tp TransformParameters.0.txt'
-# 
-# 
-#     
-task_name: ApplyWarp
-nipype_name: ApplyWarp
-nipype_module: nipype.interfaces.elastix.registration
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    transform_file: text/text-file
-    # type=file|default=<undefined>: transform-parameter file, only 1
-    moving_image: medimage/nifti1
-    # type=file|default=<undefined>: input image to deform
-    output_path: generic/directory
-    # type=directory|default='./': output directory
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    warped_file: generic/file
-    # type=file: input moving image warped to fixed image
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    transform_file:
-    # type=file|default=<undefined>: transform-parameter file, only 1
-    moving_image:
-    # type=file|default=<undefined>: input image to deform
-    output_path:
-    # type=directory|default='./': output directory
-    num_threads:
-    # type=int|default=1: set the maximum number of threads of elastix
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    moving_image:
-    # type=file|default=<undefined>: input image to deform
-    transform_file:
-    # type=file|default=<undefined>: transform-parameter file, only 1
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests:
-- cmdline: transformix -in moving1.nii -threads 1 -out ./ -tp TransformParameters.0.txt
-  # str - the expected cmdline output
-  inputs:
-  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
-  # If the field is of file-format type and the value is None, then the
-  # '.mock()' method of the corresponding class is used instead.
-    moving_image:
-    # type=file|default=<undefined>: input image to deform
-    transform_file:
-    # type=file|default=<undefined>: transform-parameter file, only 1
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  directive:
-  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-elastix/edit_transform.yaml b/example-specs/task/nipype_internal/pydra-elastix/edit_transform.yaml
deleted file mode 100644
index a93e2f24..00000000
--- a/example-specs/task/nipype_internal/pydra-elastix/edit_transform.yaml
+++ /dev/null
@@ -1,98 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.elastix.utils.EditTransform' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Manipulates an existing transform file generated with elastix
-# 
-#     Example
-#     -------
-# 
-#     >>> from nipype.interfaces.elastix import EditTransform
-#     >>> tfm = EditTransform()
-#     >>> tfm.inputs.transform_file = 'TransformParameters.0.txt'  # doctest: +SKIP
-#     >>> tfm.inputs.reference_image = 'fixed1.nii'  # doctest: +SKIP
-#     >>> tfm.inputs.output_type = 'unsigned char'
-#     >>> tfm.run() # doctest: +SKIP
-# 
-#     
-task_name: EditTransform
-nipype_name: EditTransform
-nipype_module: nipype.interfaces.elastix.utils
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    transform_file: generic/file
-    # type=file|default=<undefined>: transform-parameter file, only 1
-    reference_image: generic/file
-    # type=file|default=<undefined>: set a new reference image to change the target coordinate system.
-    output_file: generic/file
-    # type=file: output transform file
-    # type=file|default=<undefined>: the filename for the resulting transform file
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    output_file: generic/file
-    # type=file: output transform file
-    # type=file|default=<undefined>: the filename for the resulting transform file
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    transform_file:
-    # type=file|default=<undefined>: transform-parameter file, only 1
-    reference_image:
-    # type=file|default=<undefined>: set a new reference image to change the target coordinate system.
-    interpolation:
-    # type=enum|default='cubic'|allowed['cubic','linear','nearest']: set a new interpolator for transformation
-    output_type:
-    # type=enum|default='float'|allowed['double','float','long','short','unsigned char','unsigned long','unsigned short']: set a new output pixel type for resampled images
-    output_format:
-    # type=enum|default='nii.gz'|allowed['hdr','mhd','nii','nii.gz','vtk']: set a new image format for resampled images
-    output_file:
-    # type=file: output transform file
-    # type=file|default=<undefined>: the filename for the resulting transform file
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-elastix/edit_transform_callables.py b/example-specs/task/nipype_internal/pydra-elastix/edit_transform_callables.py
deleted file mode 100644
index d27fadf5..00000000
--- a/example-specs/task/nipype_internal/pydra-elastix/edit_transform_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in EditTransform.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-elastix/points_warp.yaml b/example-specs/task/nipype_internal/pydra-elastix/points_warp.yaml
deleted file mode 100644
index f8c7cf4f..00000000
--- a/example-specs/task/nipype_internal/pydra-elastix/points_warp.yaml
+++ /dev/null
@@ -1,133 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.elastix.registration.PointsWarp' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Use ``transformix`` to apply a transform on an input point set.
-#     The transform is specified in the transform-parameter file.
-# 
-#     Example
-#     -------
-# 
-#     >>> from nipype.interfaces.elastix import PointsWarp
-#     >>> reg = PointsWarp()
-#     >>> reg.inputs.points_file = 'surf1.vtk'
-#     >>> reg.inputs.transform_file = 'TransformParameters.0.txt'
-#     >>> reg.cmdline
-#     'transformix -threads 1 -out ./ -def surf1.vtk -tp TransformParameters.0.txt'
-# 
-# 
-#     
-task_name: PointsWarp
-nipype_name: PointsWarp
-nipype_module: nipype.interfaces.elastix.registration
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    points_file: medimage-elastix/vtk
-    # type=file|default=<undefined>: input points (accepts .vtk triangular meshes).
-    transform_file: text/text-file
-    # type=file|default=<undefined>: transform-parameter file, only 1
-    output_path: generic/directory
-    # type=directory|default='./': output directory
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    warped_file: generic/file
-    # type=file: input points displaced in fixed image domain
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    points_file:
-    # type=file|default=<undefined>: input points (accepts .vtk triangular meshes).
-    transform_file:
-    # type=file|default=<undefined>: transform-parameter file, only 1
-    output_path:
-    # type=directory|default='./': output directory
-    num_threads:
-    # type=int|default=1: set the maximum number of threads of elastix
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    points_file:
-    # type=file|default=<undefined>: input points (accepts .vtk triangular meshes).
-    transform_file:
-    # type=file|default=<undefined>: transform-parameter file, only 1
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests:
-- cmdline: transformix -threads 1 -out ./ -def surf1.vtk -tp TransformParameters.0.txt
-  # str - the expected cmdline output
-  inputs:
-  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
-  # If the field is of file-format type and the value is None, then the
-  # '.mock()' method of the corresponding class is used instead.
-    points_file:
-    # type=file|default=<undefined>: input points (accepts .vtk triangular meshes).
-    transform_file:
-    # type=file|default=<undefined>: transform-parameter file, only 1
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  directive:
-  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-elastix/points_warp_callables.py b/example-specs/task/nipype_internal/pydra-elastix/points_warp_callables.py
deleted file mode 100644
index 1369b9e1..00000000
--- a/example-specs/task/nipype_internal/pydra-elastix/points_warp_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in PointsWarp.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-elastix/registration.yaml b/example-specs/task/nipype_internal/pydra-elastix/registration.yaml
deleted file mode 100644
index cdec3684..00000000
--- a/example-specs/task/nipype_internal/pydra-elastix/registration.yaml
+++ /dev/null
@@ -1,154 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.elastix.registration.Registration' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Elastix nonlinear registration interface
-# 
-#     Example
-#     -------
-# 
-#     >>> from nipype.interfaces.elastix import Registration
-#     >>> reg = Registration()
-#     >>> reg.inputs.fixed_image = 'fixed1.nii'
-#     >>> reg.inputs.moving_image = 'moving1.nii'
-#     >>> reg.inputs.parameters = ['elastix.txt']
-#     >>> reg.cmdline
-#     'elastix -f fixed1.nii -m moving1.nii -threads 1 -out ./ -p elastix.txt'
-# 
-# 
-#     
-task_name: Registration
-nipype_name: Registration
-nipype_module: nipype.interfaces.elastix.registration
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    fixed_image: medimage/nifti1
-    # type=file|default=<undefined>: fixed image
-    moving_image: medimage/nifti1
-    # type=file|default=<undefined>: moving image
-    parameters: text/text-file+list-of
-    # type=inputmultiobject|default=[]: parameter file, elastix handles 1 or more -p
-    fixed_mask: generic/file
-    # type=file|default=<undefined>: mask for fixed image
-    moving_mask: generic/file
-    # type=file|default=<undefined>: mask for moving image
-    initial_transform: generic/file
-    # type=file|default=<undefined>: parameter file for initial transform
-    output_path: generic/directory
-    # type=directory|default='./': output directory
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    warped_file: generic/file
-    # type=file: input moving image warped to fixed image
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    fixed_image:
-    # type=file|default=<undefined>: fixed image
-    moving_image:
-    # type=file|default=<undefined>: moving image
-    parameters:
-    # type=inputmultiobject|default=[]: parameter file, elastix handles 1 or more -p
-    fixed_mask:
-    # type=file|default=<undefined>: mask for fixed image
-    moving_mask:
-    # type=file|default=<undefined>: mask for moving image
-    initial_transform:
-    # type=file|default=<undefined>: parameter file for initial transform
-    output_path:
-    # type=directory|default='./': output directory
-    num_threads:
-    # type=int|default=1: set the maximum number of threads of elastix
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    fixed_image:
-    # type=file|default=<undefined>: fixed image
-    moving_image:
-    # type=file|default=<undefined>: moving image
-    parameters:
-    # type=inputmultiobject|default=[]: parameter file, elastix handles 1 or more -p
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests:
-- cmdline: elastix -f fixed1.nii -m moving1.nii -threads 1 -out ./ -p elastix.txt
-  # str - the expected cmdline output
-  inputs:
-  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
-  # If the field is of file-format type and the value is None, then the
-  # '.mock()' method of the corresponding class is used instead.
-    fixed_image:
-    # type=file|default=<undefined>: fixed image
-    moving_image:
-    # type=file|default=<undefined>: moving image
-    parameters:
-    # type=inputmultiobject|default=[]: parameter file, elastix handles 1 or more -p
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  directive:
-  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-elastix/registration_callables.py b/example-specs/task/nipype_internal/pydra-elastix/registration_callables.py
deleted file mode 100644
index 5191c22f..00000000
--- a/example-specs/task/nipype_internal/pydra-elastix/registration_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in Registration.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-freesurfer/resample_callables.py b/example-specs/task/nipype_internal/pydra-freesurfer/resample_callables.py
deleted file mode 100644
index 1e012806..00000000
--- a/example-specs/task/nipype_internal/pydra-freesurfer/resample_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in Resample.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/apply_warp_callables.py b/example-specs/task/nipype_internal/pydra-fsl/apply_warp_callables.py
deleted file mode 100644
index 827cf9f6..00000000
--- a/example-specs/task/nipype_internal/pydra-fsl/apply_warp_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in ApplyWarp.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/dti_fit_callables.py b/example-specs/task/nipype_internal/pydra-fsl/dti_fit_callables.py
deleted file mode 100644
index 5d71e93e..00000000
--- a/example-specs/task/nipype_internal/pydra-fsl/dti_fit_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in DTIFit.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-fsl/image_stats_callables.py b/example-specs/task/nipype_internal/pydra-fsl/image_stats_callables.py
deleted file mode 100644
index 1a145967..00000000
--- a/example-specs/task/nipype_internal/pydra-fsl/image_stats_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in ImageStats.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-meshfix/mesh_fix.yaml b/example-specs/task/nipype_internal/pydra-meshfix/mesh_fix.yaml
deleted file mode 100644
index 0a7f6038..00000000
--- a/example-specs/task/nipype_internal/pydra-meshfix/mesh_fix.yaml
+++ /dev/null
@@ -1,198 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.meshfix.MeshFix' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     MeshFix v1.2-alpha - by Marco Attene, Mirko Windhoff, Axel Thielscher.
-# 
-#     .. seealso::
-# 
-#         http://jmeshlib.sourceforge.net
-#             Sourceforge page
-# 
-#         http://simnibs.de/installation/meshfixandgetfem
-#             Ubuntu installation instructions
-# 
-#     If MeshFix is used for research purposes, please cite the following paper:
-#     M. Attene - A lightweight approach to repairing digitized polygon meshes.
-#     The Visual Computer, 2010. (c) Springer.
-# 
-#     Accepted input formats are OFF, PLY and STL.
-#     Other formats (like .msh for gmsh) are supported only partially.
-# 
-#     Example
-#     -------
-# 
-#     >>> import nipype.interfaces.meshfix as mf
-#     >>> fix = mf.MeshFix()
-#     >>> fix.inputs.in_file1 = 'lh-pial.stl'
-#     >>> fix.inputs.in_file2 = 'rh-pial.stl'
-#     >>> fix.run()                            # doctest: +SKIP
-#     >>> fix.cmdline
-#     'meshfix lh-pial.stl rh-pial.stl -o lh-pial_fixed.off'
-#     
-task_name: MeshFix
-nipype_name: MeshFix
-nipype_module: nipype.interfaces.meshfix
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_file1: model/stl
-    # type=file|default=<undefined>: 
-    in_file2: model/stl
-    # type=file|default=<undefined>: 
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    mesh_file: generic/file
-    # type=file: The output mesh file
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    out_filename: out_filename
-    # type=file|default=<undefined>: The output filename for the fixed mesh file
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    number_of_biggest_shells:
-    # type=int|default=0: Only the N biggest shells are kept
-    epsilon_angle:
-    # type=range|default=0.0: Epsilon angle in degrees (must be between 0 and 2)
-    join_overlapping_largest_components:
-    # type=bool|default=False: Join 2 biggest components if they overlap, remove the rest.
-    join_closest_components:
-    # type=bool|default=False: Join the closest pair of components.
-    quiet_mode:
-    # type=bool|default=False: Quiet mode, don't write much to stdout.
-    dont_clean:
-    # type=bool|default=False: Don't Clean
-    save_as_stl:
-    # type=bool|default=False: Result is saved in stereolithographic format (.stl)
-    save_as_vrml:
-    # type=bool|default=False: Result is saved in VRML1.0 format (.wrl)
-    save_as_freesurfer_mesh:
-    # type=bool|default=False: Result is saved in freesurfer mesh format
-    remove_handles:
-    # type=bool|default=False: Remove handles
-    uniform_remeshing_steps:
-    # type=int|default=0: Number of steps for uniform remeshing of the whole mesh
-    uniform_remeshing_vertices:
-    # type=int|default=0: Constrains the number of vertices.Must be used with uniform_remeshing_steps
-    laplacian_smoothing_steps:
-    # type=int|default=0: The number of laplacian smoothing steps to apply
-    x_shift:
-    # type=int|default=0: Shifts the coordinates of the vertices when saving. Output must be in FreeSurfer format
-    cut_outer:
-    # type=int|default=0: Remove triangles of 1st that are outside of the 2nd shell.
-    cut_inner:
-    # type=int|default=0: Remove triangles of 1st that are inside of the 2nd shell. Dilate 2nd by N; Fill holes and keep only 1st afterwards.
-    decouple_inin:
-    # type=int|default=0: Treat 1st file as inner, 2nd file as outer component.Resolve overlaps by moving inners triangles inwards. Constrain the min distance between the components > d.
-    decouple_outin:
-    # type=int|default=0: Treat 1st file as outer, 2nd file as inner component.Resolve overlaps by moving outers triangles inwards. Constrain the min distance between the components > d.
-    decouple_outout:
-    # type=int|default=0: Treat 1st file as outer, 2nd file as inner component.Resolve overlaps by moving outers triangles outwards. Constrain the min distance between the components > d.
-    finetuning_inwards:
-    # type=bool|default=False: Used to fine-tune the minimal distance between surfaces.
-    finetuning_outwards:
-    # type=bool|default=False: Similar to finetuning_inwards, but ensures minimal distance in the other direction
-    finetuning_distance:
-    # type=float|default=0.0: Used to fine-tune the minimal distance between surfaces.A minimal distance d is ensured, and reached in n substeps. When using the surfaces for subsequent volume meshing by gmsh, this step prevent too flat tetrahedra2)
-    finetuning_substeps:
-    # type=int|default=0: Used to fine-tune the minimal distance between surfaces.A minimal distance d is ensured, and reached in n substeps. When using the surfaces for subsequent volume meshing by gmsh, this step prevent too flat tetrahedra2)
-    dilation:
-    # type=int|default=0: Dilate the surface by d. d < 0 means shrinking.
-    set_intersections_to_one:
-    # type=bool|default=False: If the mesh contains intersections, return value = 1.If saved in gmsh format, intersections will be highlighted.
-    in_file1:
-    # type=file|default=<undefined>: 
-    in_file2:
-    # type=file|default=<undefined>: 
-    output_type:
-    # type=enum|default='off'|allowed['fs','msh','off','stl','vrml','wrl']: The output type to save the file as.
-    out_filename:
-    # type=file|default=<undefined>: The output filename for the fixed mesh file
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file1:
-    # type=file|default=<undefined>: 
-    in_file2:
-    # type=file|default=<undefined>: 
-  imports: &id001
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  - module: nipype.interfaces.meshfix as mf
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests:
-- cmdline: meshfix lh-pial.stl rh-pial.stl -o lh-pial_fixed.off
-  # str - the expected cmdline output
-  inputs:
-  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
-  # If the field is of file-format type and the value is None, then the
-  # '.mock()' method of the corresponding class is used instead.
-    in_file1:
-    # type=file|default=<undefined>: 
-    in_file2:
-    # type=file|default=<undefined>: 
-  imports: *id001
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  directive:
-  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-meshfix/mesh_fix_callables.py b/example-specs/task/nipype_internal/pydra-meshfix/mesh_fix_callables.py
deleted file mode 100644
index f52e2aaf..00000000
--- a/example-specs/task/nipype_internal/pydra-meshfix/mesh_fix_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in MeshFix.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-minc/average.yaml b/example-specs/task/nipype_internal/pydra-minc/average.yaml
deleted file mode 100644
index 7efa441f..00000000
--- a/example-specs/task/nipype_internal/pydra-minc/average.yaml
+++ /dev/null
@@ -1,155 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.minc.minc.Average' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Average a number of MINC files.
-# 
-#     Examples
-#     --------
-# 
-#     >>> from nipype.interfaces.minc import Average
-#     >>> from nipype.interfaces.minc.testdata import nonempty_minc_data
-# 
-#     >>> files = [nonempty_minc_data(i) for i in range(3)]
-#     >>> average = Average(input_files=files, output_file='/tmp/tmp.mnc')
-#     >>> average.run() # doctest: +SKIP
-# 
-#     
-task_name: Average
-nipype_name: Average
-nipype_module: nipype.interfaces.minc.minc
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    input_files: generic/file+list-of
-    # type=inputmultiobject|default=[]: input file(s)
-    filelist: generic/file
-    # type=file|default=<undefined>: Specify the name of a file containing input file names.
-    sdfile: generic/file
-    # type=file|default=<undefined>: Specify an output sd file (default=none).
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    output_file: generic/file
-    # type=file: output file
-    # type=file|default=<undefined>: output file
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    output_file: output_file
-    # type=file: output file
-    # type=file|default=<undefined>: output file
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    input_files:
-    # type=inputmultiobject|default=[]: input file(s)
-    filelist:
-    # type=file|default=<undefined>: Specify the name of a file containing input file names.
-    output_file:
-    # type=file: output file
-    # type=file|default=<undefined>: output file
-    two:
-    # type=bool|default=False: Create a MINC 2 output file.
-    clobber:
-    # type=bool|default=True: Overwrite existing file.
-    verbose:
-    # type=bool|default=False: Print out log messages (default).
-    quiet:
-    # type=bool|default=False: Do not print out log messages.
-    debug:
-    # type=bool|default=False: Print out debugging messages.
-    check_dimensions:
-    # type=bool|default=False: Check that dimension info matches across files (default).
-    no_check_dimensions:
-    # type=bool|default=False: Do not check dimension info.
-    format_filetype:
-    # type=bool|default=False: Use data type of first file (default).
-    format_byte:
-    # type=bool|default=False: Write out byte data.
-    format_short:
-    # type=bool|default=False: Write out short integer data.
-    format_int:
-    # type=bool|default=False: Write out 32-bit integer data.
-    format_long:
-    # type=bool|default=False: Superseded by -int.
-    format_float:
-    # type=bool|default=False: Write out single-precision floating-point data.
-    format_double:
-    # type=bool|default=False: Write out double-precision floating-point data.
-    format_signed:
-    # type=bool|default=False: Write signed integer data.
-    format_unsigned:
-    # type=bool|default=False: Write unsigned integer data (default).
-    max_buffer_size_in_kb:
-    # type=range|default=4096: Specify the maximum size of the internal buffers (in kbytes).
-    normalize:
-    # type=bool|default=False: Normalize data sets for mean intensity.
-    nonormalize:
-    # type=bool|default=False: Do not normalize data sets (default).
-    voxel_range:
-    # type=tuple|default=(0, 0): Valid range for output data.
-    sdfile:
-    # type=file|default=<undefined>: Specify an output sd file (default=none).
-    copy_header:
-    # type=bool|default=False: Copy all of the header from the first file (default for one file).
-    no_copy_header:
-    # type=bool|default=False: Do not copy all of the header from the first file (default for many files)).
-    avgdim:
-    # type=str|default='': Specify a dimension along which we wish to average.
-    binarize:
-    # type=bool|default=False: Binarize the volume by looking for values in a given range.
-    binrange:
-    # type=tuple|default=(0.0, 0.0): Specify a range for binarization. Default value: 1.79769e+308 -1.79769e+308.
-    binvalue:
-    # type=float|default=0.0: Specify a target value (+/- 0.5) forbinarization. Default value: -1.79769e+308
-    weights:
-    # type=inputmultiobject|default=[]: Specify weights for averaging ("<w1>,<w2>,...").
-    width_weighted:
-    # type=bool|default=False: Weight by dimension widths when -avgdim is used.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-minc/average_callables.py b/example-specs/task/nipype_internal/pydra-minc/average_callables.py
deleted file mode 100644
index aa77629f..00000000
--- a/example-specs/task/nipype_internal/pydra-minc/average_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in Average.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-minc/b_box.yaml b/example-specs/task/nipype_internal/pydra-minc/b_box.yaml
deleted file mode 100644
index 58cf5f1f..00000000
--- a/example-specs/task/nipype_internal/pydra-minc/b_box.yaml
+++ /dev/null
@@ -1,106 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.minc.minc.BBox' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Determine a bounding box of image.
-# 
-#     Examples
-#     --------
-#     >>> from nipype.interfaces.minc import BBox
-#     >>> from nipype.interfaces.minc.testdata import nonempty_minc_data
-# 
-#     >>> file0 = nonempty_minc_data(0)
-#     >>> bbox = BBox(input_file=file0)
-#     >>> bbox.run() # doctest: +SKIP
-# 
-#     
-task_name: BBox
-nipype_name: BBox
-nipype_module: nipype.interfaces.minc.minc
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    input_file: generic/file
-    # type=file|default=<undefined>: input file
-    output_file: generic/file
-    # type=file: output file containing bounding box corners
-    # type=file|default=<undefined>: output file containing bounding box corners
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    output_file: generic/file
-    # type=file: output file containing bounding box corners
-    # type=file|default=<undefined>: output file containing bounding box corners
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    out_file: out_file
-    # type=file|default=<undefined>: 
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    input_file:
-    # type=file|default=<undefined>: input file
-    output_file:
-    # type=file: output file containing bounding box corners
-    # type=file|default=<undefined>: output file containing bounding box corners
-    threshold:
-    # type=int|default=0: VIO_Real value threshold for bounding box. Default value: 0.
-    one_line:
-    # type=bool|default=False: Output on one line (default): start_x y z width_x y z
-    two_lines:
-    # type=bool|default=False: Write output with two rows (start and width).
-    format_mincresample:
-    # type=bool|default=False: Output format for mincresample: (-step x y z -start x y z -nelements x y z
-    format_mincreshape:
-    # type=bool|default=False: Output format for mincreshape: (-start x,y,z -count dx,dy,dz
-    format_minccrop:
-    # type=bool|default=False: Output format for minccrop: (-xlim x1 x2 -ylim y1 y2 -zlim z1 z2
-    out_file:
-    # type=file|default=<undefined>: 
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-minc/b_box_callables.py b/example-specs/task/nipype_internal/pydra-minc/b_box_callables.py
deleted file mode 100644
index dfc1894a..00000000
--- a/example-specs/task/nipype_internal/pydra-minc/b_box_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in BBox.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-minc/beast.yaml b/example-specs/task/nipype_internal/pydra-minc/beast.yaml
deleted file mode 100644
index 1ba0ea91..00000000
--- a/example-specs/task/nipype_internal/pydra-minc/beast.yaml
+++ /dev/null
@@ -1,131 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.minc.minc.Beast' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Extract brain image using BEaST (Brain Extraction using
-#     non-local Segmentation Technique).
-# 
-#     Examples
-#     --------
-# 
-#     >>> from nipype.interfaces.minc import Beast
-#     >>> from nipype.interfaces.minc.testdata import nonempty_minc_data
-# 
-#     >>> file0 = nonempty_minc_data(0)
-#     >>> beast = Beast(input_file=file0)
-#     >>> beast .run() # doctest: +SKIP
-#     
-task_name: Beast
-nipype_name: Beast
-nipype_module: nipype.interfaces.minc.minc
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    configuration_file: generic/file
-    # type=file|default=<undefined>: Specify configuration file.
-    input_file: generic/file
-    # type=file|default=<undefined>: input file
-    output_file: generic/file
-    # type=file: output mask file
-    # type=file|default=<undefined>: output file
-    library_dir: generic/directory
-    # type=directory|default=<undefined>: library directory
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    output_file: generic/file
-    # type=file: output mask file
-    # type=file|default=<undefined>: output file
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    probability_map:
-    # type=bool|default=False: Output the probability map instead of crisp mask.
-    flip_images:
-    # type=bool|default=False: Flip images around the mid-sagittal plane to increase patch count.
-    load_moments:
-    # type=bool|default=False: Do not calculate moments instead use precalculatedlibrary moments. (for optimization purposes)
-    fill_holes:
-    # type=bool|default=False: Fill holes in the binary output.
-    median_filter:
-    # type=bool|default=False: Apply a median filter on the probability map.
-    nlm_filter:
-    # type=bool|default=False: Apply an NLM filter on the probability map (experimental).
-    clobber:
-    # type=bool|default=True: Overwrite existing file.
-    configuration_file:
-    # type=file|default=<undefined>: Specify configuration file.
-    voxel_size:
-    # type=int|default=4: Specify voxel size for calculations (4, 2, or 1).Default value: 4. Assumes no multiscale. Use configurationfile for multiscale.
-    abspath:
-    # type=bool|default=True: File paths in the library are absolute (default is relative to library root).
-    patch_size:
-    # type=int|default=1: Specify patch size for single scale approach. Default value: 1.
-    search_area:
-    # type=int|default=2: Specify size of search area for single scale approach. Default value: 2.
-    confidence_level_alpha:
-    # type=float|default=0.5: Specify confidence level Alpha. Default value: 0.5
-    smoothness_factor_beta:
-    # type=float|default=0.5: Specify smoothness factor Beta. Default value: 0.25
-    threshold_patch_selection:
-    # type=float|default=0.95: Specify threshold for patch selection. Default value: 0.95
-    number_selected_images:
-    # type=int|default=20: Specify number of selected images. Default value: 20
-    same_resolution:
-    # type=bool|default=False: Output final mask with the same resolution as input file.
-    library_dir:
-    # type=directory|default=<undefined>: library directory
-    input_file:
-    # type=file|default=<undefined>: input file
-    output_file:
-    # type=file: output mask file
-    # type=file|default=<undefined>: output file
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-minc/beast_callables.py b/example-specs/task/nipype_internal/pydra-minc/beast_callables.py
deleted file mode 100644
index a264bb30..00000000
--- a/example-specs/task/nipype_internal/pydra-minc/beast_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in Beast.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-minc/best_lin_reg.yaml b/example-specs/task/nipype_internal/pydra-minc/best_lin_reg.yaml
deleted file mode 100644
index 767dfd24..00000000
--- a/example-specs/task/nipype_internal/pydra-minc/best_lin_reg.yaml
+++ /dev/null
@@ -1,112 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.minc.minc.BestLinReg' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Hierachial linear fitting between two files.
-# 
-#     The bestlinreg script is part of the EZminc package:
-# 
-#     https://github.com/BIC-MNI/EZminc/blob/master/scripts/bestlinreg.pl
-# 
-#     Examples
-#     --------
-# 
-#     >>> from nipype.interfaces.minc import BestLinReg
-#     >>> from nipype.interfaces.minc.testdata import nonempty_minc_data
-# 
-#     >>> input_file = nonempty_minc_data(0)
-#     >>> target_file = nonempty_minc_data(1)
-#     >>> linreg = BestLinReg(source=input_file, target=target_file)
-#     >>> linreg.run() # doctest: +SKIP
-#     
-task_name: BestLinReg
-nipype_name: BestLinReg
-nipype_module: nipype.interfaces.minc.minc
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    source: generic/file
-    # type=file|default=<undefined>: source Minc file
-    target: generic/file
-    # type=file|default=<undefined>: target Minc file
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    output_xfm: generic/file
-    # type=file: output xfm file
-    # type=file|default=<undefined>: output xfm file
-    output_mnc: generic/file
-    # type=file: output mnc file
-    # type=file|default=<undefined>: output mnc file
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    output_xfm: output_xfm
-    # type=file: output xfm file
-    # type=file|default=<undefined>: output xfm file
-    output_mnc: output_mnc
-    # type=file: output mnc file
-    # type=file|default=<undefined>: output mnc file
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    source:
-    # type=file|default=<undefined>: source Minc file
-    target:
-    # type=file|default=<undefined>: target Minc file
-    output_xfm:
-    # type=file: output xfm file
-    # type=file|default=<undefined>: output xfm file
-    output_mnc:
-    # type=file: output mnc file
-    # type=file|default=<undefined>: output mnc file
-    verbose:
-    # type=bool|default=False: Print out log messages. Default: False.
-    clobber:
-    # type=bool|default=True: Overwrite existing file.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-minc/best_lin_reg_callables.py b/example-specs/task/nipype_internal/pydra-minc/best_lin_reg_callables.py
deleted file mode 100644
index bc1341e4..00000000
--- a/example-specs/task/nipype_internal/pydra-minc/best_lin_reg_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in BestLinReg.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-minc/big_average.yaml b/example-specs/task/nipype_internal/pydra-minc/big_average.yaml
deleted file mode 100644
index 9ae2cbc4..00000000
--- a/example-specs/task/nipype_internal/pydra-minc/big_average.yaml
+++ /dev/null
@@ -1,130 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.minc.minc.BigAverage' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Average 1000's of MINC files in linear time.
-# 
-#     mincbigaverage is designed to discretise the problem of averaging either
-#     a large number of input files or averaging a smaller number of large
-#     files. (>1GB each). There is also some code included to perform "robust"
-#     averaging in which only the most common features are kept via down-weighting
-#     outliers beyond a standard deviation.
-# 
-#     One advantage of mincbigaverage is that it avoids issues around the number
-#     of possible open files in HDF/netCDF. In short if you have more than 100
-#     files open at once while averaging things will slow down significantly.
-# 
-#     mincbigaverage does this via a iterative approach to averaging files and
-#     is a direct drop in replacement for mincaverage. That said not all the
-#     arguments of mincaverage are supported in mincbigaverage but they should
-#     be.
-# 
-#     This tool is part of the minc-widgets package:
-# 
-#     https://github.com/BIC-MNI/minc-widgets/blob/master/mincbigaverage/mincbigaverage
-# 
-#     Examples
-#     --------
-# 
-#     >>> from nipype.interfaces.minc import BigAverage
-#     >>> from nipype.interfaces.minc.testdata import nonempty_minc_data
-# 
-#     >>> files = [nonempty_minc_data(i) for i in range(3)]
-#     >>> average = BigAverage(input_files=files, output_float=True, robust=True)
-#     >>> average.run() # doctest: +SKIP
-#     
-task_name: BigAverage
-nipype_name: BigAverage
-nipype_module: nipype.interfaces.minc.minc
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    input_files: generic/file+list-of
-    # type=inputmultiobject|default=[]: input file(s)
-    sd_file: generic/file
-    # type=file: standard deviation image
-    # type=file|default=<undefined>: Place standard deviation image in specified file.
-    tmpdir: generic/directory
-    # type=directory|default=<undefined>: temporary files directory
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    output_file: generic/file
-    # type=file: output file
-    # type=file|default=<undefined>: output file
-    sd_file: generic/file
-    # type=file: standard deviation image
-    # type=file|default=<undefined>: Place standard deviation image in specified file.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    output_file: output_file
-    # type=file: output file
-    # type=file|default=<undefined>: output file
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    input_files:
-    # type=inputmultiobject|default=[]: input file(s)
-    output_file:
-    # type=file: output file
-    # type=file|default=<undefined>: output file
-    verbose:
-    # type=bool|default=False: Print out log messages. Default: False.
-    clobber:
-    # type=bool|default=True: Overwrite existing file.
-    output_float:
-    # type=bool|default=False: Output files with float precision.
-    robust:
-    # type=bool|default=False: Perform robust averaging, features that are outside 1 standarddeviation from the mean are downweighted. Works well for noisydata with artifacts. see the --tmpdir option if you have alarge number of input files.
-    tmpdir:
-    # type=directory|default=<undefined>: temporary files directory
-    sd_file:
-    # type=file: standard deviation image
-    # type=file|default=<undefined>: Place standard deviation image in specified file.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-minc/big_average_callables.py b/example-specs/task/nipype_internal/pydra-minc/big_average_callables.py
deleted file mode 100644
index ba427eaa..00000000
--- a/example-specs/task/nipype_internal/pydra-minc/big_average_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in BigAverage.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-minc/blob.yaml b/example-specs/task/nipype_internal/pydra-minc/blob.yaml
deleted file mode 100644
index 9f9ab901..00000000
--- a/example-specs/task/nipype_internal/pydra-minc/blob.yaml
+++ /dev/null
@@ -1,97 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.minc.minc.Blob' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Calculate blobs from minc deformation grids.
-# 
-#     Examples
-#     --------
-# 
-#     >>> from nipype.interfaces.minc import Blob
-#     >>> from nipype.interfaces.minc.testdata import minc2Dfile
-# 
-#     >>> blob = Blob(input_file=minc2Dfile, output_file='/tmp/tmp.mnc', trace=True)
-#     >>> blob.run() # doctest: +SKIP
-#     
-task_name: Blob
-nipype_name: Blob
-nipype_module: nipype.interfaces.minc.minc
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    input_file: generic/file
-    # type=file|default=<undefined>: input file to blob
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    output_file: generic/file
-    # type=file: output file
-    # type=file|default=<undefined>: output file
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    output_file: output_file
-    # type=file: output file
-    # type=file|default=<undefined>: output file
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    input_file:
-    # type=file|default=<undefined>: input file to blob
-    output_file:
-    # type=file: output file
-    # type=file|default=<undefined>: output file
-    trace:
-    # type=bool|default=False: compute the trace (approximate growth and shrinkage) -- FAST
-    determinant:
-    # type=bool|default=False: compute the determinant (exact growth and shrinkage) -- SLOW
-    translation:
-    # type=bool|default=False: compute translation (structure displacement)
-    magnitude:
-    # type=bool|default=False: compute the magnitude of the displacement vector
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-minc/blob_callables.py b/example-specs/task/nipype_internal/pydra-minc/blob_callables.py
deleted file mode 100644
index 39913d7f..00000000
--- a/example-specs/task/nipype_internal/pydra-minc/blob_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in Blob.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-minc/blur.yaml b/example-specs/task/nipype_internal/pydra-minc/blur.yaml
deleted file mode 100644
index 37fe9974..00000000
--- a/example-specs/task/nipype_internal/pydra-minc/blur.yaml
+++ /dev/null
@@ -1,140 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.minc.minc.Blur' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Convolve an input volume with a Gaussian blurring kernel of
-#     user-defined width.  Optionally, the first partial derivatives
-#     and the gradient magnitude volume can be calculated.
-# 
-#     Examples
-#     --------
-# 
-#     >>> from nipype.interfaces.minc import Blur
-#     >>> from nipype.interfaces.minc.testdata import minc3Dfile
-# 
-#     (1) Blur  an  input  volume with a 6mm fwhm isotropic Gaussian
-#     blurring kernel:
-# 
-#     >>> blur = Blur(input_file=minc3Dfile, fwhm=6, output_file_base='/tmp/out_6')
-#     >>> blur.run() # doctest: +SKIP
-# 
-#     mincblur will create /tmp/out_6_blur.mnc.
-# 
-#     (2) Calculate the blurred and gradient magnitude data:
-# 
-#     >>> blur = Blur(input_file=minc3Dfile, fwhm=6, gradient=True, output_file_base='/tmp/out_6')
-#     >>> blur.run() # doctest: +SKIP
-# 
-#     will create /tmp/out_6_blur.mnc and /tmp/out_6_dxyz.mnc.
-# 
-#     (3) Calculate the blurred data, the partial derivative volumes
-#     and  the gradient magnitude for the same data:
-# 
-#     >>> blur = Blur(input_file=minc3Dfile, fwhm=6, partial=True, output_file_base='/tmp/out_6')
-#     >>> blur.run() # doctest: +SKIP
-# 
-#     will create /tmp/out_6_blur.mnc, /tmp/out_6_dx.mnc,
-#     /tmp/out_6_dy.mnc, /tmp/out_6_dz.mnc and /tmp/out_6_dxyz.mnc.
-#     
-task_name: Blur
-nipype_name: Blur
-nipype_module: nipype.interfaces.minc.minc
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    input_file: generic/file
-    # type=file|default=<undefined>: input file
-    output_file_base: generic/file
-    # type=file|default=<undefined>: output file base
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    output_file: generic/file
-    # type=file: Blurred output file.
-    gradient_dxyz: generic/file
-    # type=file: Gradient dxyz.
-    partial_dx: generic/file
-    # type=file: Partial gradient dx.
-    partial_dy: generic/file
-    # type=file: Partial gradient dy.
-    partial_dz: generic/file
-    # type=file: Partial gradient dz.
-    partial_dxyz: generic/file
-    # type=file: Partial gradient dxyz.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    input_file:
-    # type=file|default=<undefined>: input file
-    output_file_base:
-    # type=file|default=<undefined>: output file base
-    clobber:
-    # type=bool|default=True: Overwrite existing file.
-    gaussian:
-    # type=bool|default=False: Use a gaussian smoothing kernel (default).
-    rect:
-    # type=bool|default=False: Use a rect (box) smoothing kernel.
-    gradient:
-    # type=bool|default=False: Create the gradient magnitude volume as well.
-    partial:
-    # type=bool|default=False: Create the partial derivative and gradient magnitude volumes as well.
-    no_apodize:
-    # type=bool|default=False: Do not apodize the data before blurring.
-    fwhm:
-    # type=float|default=0: Full-width-half-maximum of gaussian kernel. Default value: 0.
-    standard_dev:
-    # type=float|default=0: Standard deviation of gaussian kernel. Default value: 0.
-    fwhm3d:
-    # type=tuple|default=(0.0, 0.0, 0.0): Full-width-half-maximum of gaussian kernel.Default value: -1.79769e+308 -1.79769e+308 -1.79769e+308.
-    dimensions:
-    # type=enum|default=3|allowed[1,2,3]: Number of dimensions to blur (either 1,2 or 3). Default value: 3.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-minc/blur_callables.py b/example-specs/task/nipype_internal/pydra-minc/blur_callables.py
deleted file mode 100644
index 3373f83b..00000000
--- a/example-specs/task/nipype_internal/pydra-minc/blur_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in Blur.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-minc/calc.yaml b/example-specs/task/nipype_internal/pydra-minc/calc.yaml
deleted file mode 100644
index 5b9b49eb..00000000
--- a/example-specs/task/nipype_internal/pydra-minc/calc.yaml
+++ /dev/null
@@ -1,155 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.minc.minc.Calc' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Compute an expression using MINC files as input.
-# 
-#     Examples
-#     --------
-# 
-#     >>> from nipype.interfaces.minc import Calc
-#     >>> from nipype.interfaces.minc.testdata import nonempty_minc_data
-# 
-#     >>> file0 = nonempty_minc_data(0)
-#     >>> file1 = nonempty_minc_data(1)
-#     >>> calc = Calc(input_files=[file0, file1], output_file='/tmp/calc.mnc', expression='A[0] + A[1]') # add files together
-#     >>> calc.run() # doctest: +SKIP
-#     
-task_name: Calc
-nipype_name: Calc
-nipype_module: nipype.interfaces.minc.minc
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    input_files: generic/file+list-of
-    # type=inputmultiobject|default=[]: input file(s) for calculation
-    filelist: generic/file
-    # type=file|default=<undefined>: Specify the name of a file containing input file names.
-    expfile: generic/file
-    # type=file|default=<undefined>: Name of file containing expression.
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    output_file: generic/file
-    # type=file: output file
-    # type=file|default=<undefined>: output file
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    output_file: output_file
-    # type=file: output file
-    # type=file|default=<undefined>: output file
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    input_files:
-    # type=inputmultiobject|default=[]: input file(s) for calculation
-    output_file:
-    # type=file: output file
-    # type=file|default=<undefined>: output file
-    two:
-    # type=bool|default=False: Create a MINC 2 output file.
-    clobber:
-    # type=bool|default=True: Overwrite existing file.
-    verbose:
-    # type=bool|default=False: Print out log messages (default).
-    quiet:
-    # type=bool|default=False: Do not print out log messages.
-    debug:
-    # type=bool|default=False: Print out debugging messages.
-    filelist:
-    # type=file|default=<undefined>: Specify the name of a file containing input file names.
-    copy_header:
-    # type=bool|default=False: Copy all of the header from the first file.
-    no_copy_header:
-    # type=bool|default=False: Do not copy all of the header from the first file.
-    format_filetype:
-    # type=bool|default=False: Use data type of first file (default).
-    format_byte:
-    # type=bool|default=False: Write out byte data.
-    format_short:
-    # type=bool|default=False: Write out short integer data.
-    format_int:
-    # type=bool|default=False: Write out 32-bit integer data.
-    format_long:
-    # type=bool|default=False: Superseded by -int.
-    format_float:
-    # type=bool|default=False: Write out single-precision floating-point data.
-    format_double:
-    # type=bool|default=False: Write out double-precision floating-point data.
-    format_signed:
-    # type=bool|default=False: Write signed integer data.
-    format_unsigned:
-    # type=bool|default=False: Write unsigned integer data (default).
-    voxel_range:
-    # type=tuple|default=(0, 0): Valid range for output data.
-    max_buffer_size_in_kb:
-    # type=range|default=0: Specify the maximum size of the internal buffers (in kbytes).
-    check_dimensions:
-    # type=bool|default=False: Check that files have matching dimensions (default).
-    no_check_dimensions:
-    # type=bool|default=False: Do not check that files have matching dimensions.
-    ignore_nan:
-    # type=bool|default=False: Ignore invalid data (NaN) for accumulations.
-    propagate_nan:
-    # type=bool|default=False: Invalid data in any file at a voxel produces a NaN (default).
-    output_nan:
-    # type=bool|default=False: Output NaN when an illegal operation is done (default).
-    output_zero:
-    # type=bool|default=False: Output zero when an illegal operation is done.
-    output_illegal:
-    # type=bool|default=False: Value to write out when an illegal operation is done. Default value: 1.79769e+308
-    expression:
-    # type=str|default='': Expression to use in calculations.
-    expfile:
-    # type=file|default=<undefined>: Name of file containing expression.
-    outfiles:
-    # type=list|default=[]: 
-    eval_width:
-    # type=int|default=0: Number of voxels to evaluate simultaneously.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-minc/calc_callables.py b/example-specs/task/nipype_internal/pydra-minc/calc_callables.py
deleted file mode 100644
index e7ff3fa7..00000000
--- a/example-specs/task/nipype_internal/pydra-minc/calc_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in Calc.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-minc/convert.yaml b/example-specs/task/nipype_internal/pydra-minc/convert.yaml
deleted file mode 100644
index 4c9cb4f1..00000000
--- a/example-specs/task/nipype_internal/pydra-minc/convert.yaml
+++ /dev/null
@@ -1,98 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.minc.minc.Convert' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# convert between MINC 1 to MINC 2 format.
-# 
-#     Examples
-#     --------
-# 
-#     >>> from nipype.interfaces.minc import Convert
-#     >>> from nipype.interfaces.minc.testdata import minc2Dfile
-#     >>> c = Convert(input_file=minc2Dfile, output_file='/tmp/out.mnc', two=True) # Convert to MINC2 format.
-#     >>> c.run() # doctest: +SKIP
-#     
-task_name: Convert
-nipype_name: Convert
-nipype_module: nipype.interfaces.minc.minc
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    input_file: generic/file
-    # type=file|default=<undefined>: input file for converting
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    output_file: generic/file
-    # type=file: output file
-    # type=file|default=<undefined>: output file
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    output_file: output_file
-    # type=file: output file
-    # type=file|default=<undefined>: output file
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    input_file:
-    # type=file|default=<undefined>: input file for converting
-    output_file:
-    # type=file: output file
-    # type=file|default=<undefined>: output file
-    clobber:
-    # type=bool|default=True: Overwrite existing file.
-    two:
-    # type=bool|default=False: Create a MINC 2 output file.
-    template:
-    # type=bool|default=False: Create a template file. The dimensions, variables, andattributes of the input file are preserved but all data it set to zero.
-    compression:
-    # type=enum|default=0|allowed[0,1,2,3,4,5,6,7,8,9]: Set the compression level, from 0 (disabled) to 9 (maximum).
-    chunk:
-    # type=range|default=0: Set the target block size for chunking (0 default, >1 block size).
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-minc/convert_callables.py b/example-specs/task/nipype_internal/pydra-minc/convert_callables.py
deleted file mode 100644
index 4ff69023..00000000
--- a/example-specs/task/nipype_internal/pydra-minc/convert_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in Convert.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-minc/copy.yaml b/example-specs/task/nipype_internal/pydra-minc/copy.yaml
deleted file mode 100644
index 6b312bb8..00000000
--- a/example-specs/task/nipype_internal/pydra-minc/copy.yaml
+++ /dev/null
@@ -1,92 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.minc.minc.Copy' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Copy image values from one MINC file to another. Both the input
-#     and output files must exist, and the images in both files must
-#     have an equal number dimensions and equal dimension lengths.
-# 
-#     NOTE: This program is intended primarily for use with scripts
-#     such as mincedit. It does not follow the typical design rules of
-#     most MINC command-line tools and therefore should be used only
-#     with caution.
-#     
-task_name: Copy
-nipype_name: Copy
-nipype_module: nipype.interfaces.minc.minc
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    input_file: generic/file
-    # type=file|default=<undefined>: input file to copy
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    output_file: generic/file
-    # type=file: output file
-    # type=file|default=<undefined>: output file
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    output_file: output_file
-    # type=file: output file
-    # type=file|default=<undefined>: output file
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    input_file:
-    # type=file|default=<undefined>: input file to copy
-    output_file:
-    # type=file: output file
-    # type=file|default=<undefined>: output file
-    pixel_values:
-    # type=bool|default=False: Copy pixel values as is.
-    real_values:
-    # type=bool|default=False: Copy real pixel intensities (default).
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-minc/copy_callables.py b/example-specs/task/nipype_internal/pydra-minc/copy_callables.py
deleted file mode 100644
index df0aabd9..00000000
--- a/example-specs/task/nipype_internal/pydra-minc/copy_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in Copy.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-minc/dump.yaml b/example-specs/task/nipype_internal/pydra-minc/dump.yaml
deleted file mode 100644
index ff86a8e4..00000000
--- a/example-specs/task/nipype_internal/pydra-minc/dump.yaml
+++ /dev/null
@@ -1,113 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.minc.minc.Dump' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Dump a MINC file. Typically used in conjunction with mincgen (see Gen).
-# 
-#     Examples
-#     --------
-# 
-#     >>> from nipype.interfaces.minc import Dump
-#     >>> from nipype.interfaces.minc.testdata import minc2Dfile
-# 
-#     >>> dump = Dump(input_file=minc2Dfile)
-#     >>> dump.run() # doctest: +SKIP
-# 
-#     >>> dump = Dump(input_file=minc2Dfile, output_file='/tmp/out.txt', precision=(3, 4))
-#     >>> dump.run() # doctest: +SKIP
-# 
-#     
-task_name: Dump
-nipype_name: Dump
-nipype_module: nipype.interfaces.minc.minc
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    input_file: generic/file
-    # type=file|default=<undefined>: input file
-    output_file: generic/file
-    # type=file: output file
-    # type=file|default=<undefined>: output file
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    output_file: generic/file
-    # type=file: output file
-    # type=file|default=<undefined>: output file
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    out_file: out_file
-    # type=file|default=<undefined>: 
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    input_file:
-    # type=file|default=<undefined>: input file
-    output_file:
-    # type=file: output file
-    # type=file|default=<undefined>: output file
-    coordinate_data:
-    # type=bool|default=False: Coordinate variable data and header information.
-    header_data:
-    # type=bool|default=False: Header information only, no data.
-    annotations_brief:
-    # type=enum|default='c'|allowed['c','f']: Brief annotations for C or Fortran indices in data.
-    annotations_full:
-    # type=enum|default='c'|allowed['c','f']: Full annotations for C or Fortran indices in data.
-    variables:
-    # type=inputmultiobject|default=[]: Output data for specified variables only.
-    line_length:
-    # type=range|default=0: Line length maximum in data section (default 80).
-    netcdf_name:
-    # type=str|default='': Name for netCDF (default derived from file name).
-    precision:
-    # type=traitcompound|default=None: Display floating-point values with less precision
-    out_file:
-    # type=file|default=<undefined>: 
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-minc/dump_callables.py b/example-specs/task/nipype_internal/pydra-minc/dump_callables.py
deleted file mode 100644
index 26912dad..00000000
--- a/example-specs/task/nipype_internal/pydra-minc/dump_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in Dump.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-minc/extract.yaml b/example-specs/task/nipype_internal/pydra-minc/extract.yaml
deleted file mode 100644
index 2d80d5de..00000000
--- a/example-specs/task/nipype_internal/pydra-minc/extract.yaml
+++ /dev/null
@@ -1,154 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.minc.minc.Extract' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Dump a hyperslab of MINC file data.
-# 
-#     Examples
-#     --------
-# 
-#     >>> from nipype.interfaces.minc import Extract
-#     >>> from nipype.interfaces.minc.testdata import minc2Dfile
-# 
-#     >>> extract = Extract(input_file=minc2Dfile)
-#     >>> extract.run() # doctest: +SKIP
-# 
-#     >>> extract = Extract(input_file=minc2Dfile, start=[3, 10, 5], count=[4, 4, 4]) # extract a 4x4x4 slab at offset [3, 10, 5]
-#     >>> extract.run() # doctest: +SKIP
-#     
-task_name: Extract
-nipype_name: Extract
-nipype_module: nipype.interfaces.minc.minc
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    input_file: generic/file
-    # type=file|default=<undefined>: input file
-    output_file: generic/file
-    # type=file: output file in raw/text format
-    # type=file|default=<undefined>: output file
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    output_file: generic/file
-    # type=file: output file in raw/text format
-    # type=file|default=<undefined>: output file
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    out_file: out_file
-    # type=file|default=<undefined>: 
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    input_file:
-    # type=file|default=<undefined>: input file
-    output_file:
-    # type=file: output file in raw/text format
-    # type=file|default=<undefined>: output file
-    write_ascii:
-    # type=bool|default=False: Write out data as ascii strings (default).
-    write_byte:
-    # type=bool|default=False: Write out data as bytes.
-    write_short:
-    # type=bool|default=False: Write out data as short integers.
-    write_int:
-    # type=bool|default=False: Write out data as 32-bit integers.
-    write_long:
-    # type=bool|default=False: Superseded by write_int.
-    write_float:
-    # type=bool|default=False: Write out data as single precision floating-point values.
-    write_double:
-    # type=bool|default=False: Write out data as double precision floating-point values.
-    write_signed:
-    # type=bool|default=False: Write out signed data.
-    write_unsigned:
-    # type=bool|default=False: Write out unsigned data.
-    write_range:
-    # type=tuple|default=(0.0, 0.0): Specify the range of output values Default value: 1.79769e+308 1.79769e+308.
-    normalize:
-    # type=bool|default=False: Normalize integer pixel values to file max and min.
-    nonormalize:
-    # type=bool|default=False: Turn off pixel normalization.
-    image_range:
-    # type=tuple|default=(0.0, 0.0): Specify the range of real image values for normalization.
-    image_minimum:
-    # type=float|default=0.0: Specify the minimum real image value for normalization.Default value: 1.79769e+308.
-    image_maximum:
-    # type=float|default=0.0: Specify the maximum real image value for normalization.Default value: 1.79769e+308.
-    start:
-    # type=inputmultiobject|default=[]: Specifies corner of hyperslab (C conventions for indices).
-    count:
-    # type=inputmultiobject|default=[]: Specifies edge lengths of hyperslab to read.
-    flip_positive_direction:
-    # type=bool|default=False: Flip images to always have positive direction.
-    flip_negative_direction:
-    # type=bool|default=False: Flip images to always have negative direction.
-    flip_any_direction:
-    # type=bool|default=False: Do not flip images (Default).
-    flip_x_positive:
-    # type=bool|default=False: Flip images to give positive xspace:step value (left-to-right).
-    flip_x_negative:
-    # type=bool|default=False: Flip images to give negative xspace:step value (right-to-left).
-    flip_x_any:
-    # type=bool|default=False: Don't flip images along x-axis (default).
-    flip_y_positive:
-    # type=bool|default=False: Flip images to give positive yspace:step value (post-to-ant).
-    flip_y_negative:
-    # type=bool|default=False: Flip images to give negative yspace:step value (ant-to-post).
-    flip_y_any:
-    # type=bool|default=False: Don't flip images along y-axis (default).
-    flip_z_positive:
-    # type=bool|default=False: Flip images to give positive zspace:step value (inf-to-sup).
-    flip_z_negative:
-    # type=bool|default=False: Flip images to give negative zspace:step value (sup-to-inf).
-    flip_z_any:
-    # type=bool|default=False: Don't flip images along z-axis (default).
-    out_file:
-    # type=file|default=<undefined>: 
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-minc/extract_callables.py b/example-specs/task/nipype_internal/pydra-minc/extract_callables.py
deleted file mode 100644
index 40b78e07..00000000
--- a/example-specs/task/nipype_internal/pydra-minc/extract_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in Extract.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-minc/gennlxfm.yaml b/example-specs/task/nipype_internal/pydra-minc/gennlxfm.yaml
deleted file mode 100644
index c19b38ce..00000000
--- a/example-specs/task/nipype_internal/pydra-minc/gennlxfm.yaml
+++ /dev/null
@@ -1,104 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.minc.minc.Gennlxfm' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Generate nonlinear xfms. Currently only identity xfms
-#     are supported!
-# 
-#     This tool is part of minc-widgets:
-# 
-#     https://github.com/BIC-MNI/minc-widgets/blob/master/gennlxfm/gennlxfm
-# 
-#     Examples
-#     --------
-# 
-#     >>> from nipype.interfaces.minc import Gennlxfm
-#     >>> from nipype.interfaces.minc.testdata import minc2Dfile
-#     >>> gennlxfm = Gennlxfm(step=1, like=minc2Dfile)
-#     >>> gennlxfm.run() # doctest: +SKIP
-# 
-#     
-task_name: Gennlxfm
-nipype_name: Gennlxfm
-nipype_module: nipype.interfaces.minc.minc
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    like: generic/file
-    # type=file|default=<undefined>: Generate a nlxfm like this file.
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    output_file: generic/file
-    # type=file: output file
-    # type=file|default=<undefined>: output file
-    output_grid: generic/file
-    # type=file: output grid
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    output_file: output_file
-    # type=file: output file
-    # type=file|default=<undefined>: output file
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    output_file:
-    # type=file: output file
-    # type=file|default=<undefined>: output file
-    verbose:
-    # type=bool|default=False: Print out log messages. Default: False.
-    clobber:
-    # type=bool|default=True: Overwrite existing file.
-    ident:
-    # type=bool|default=False: Generate an identity xfm. Default: False.
-    step:
-    # type=int|default=0: Output ident xfm step [default: 1].
-    like:
-    # type=file|default=<undefined>: Generate a nlxfm like this file.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-minc/gennlxfm_callables.py b/example-specs/task/nipype_internal/pydra-minc/gennlxfm_callables.py
deleted file mode 100644
index 440b54e0..00000000
--- a/example-specs/task/nipype_internal/pydra-minc/gennlxfm_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in Gennlxfm.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-minc/math.yaml b/example-specs/task/nipype_internal/pydra-minc/math.yaml
deleted file mode 100644
index 6c75ef19..00000000
--- a/example-specs/task/nipype_internal/pydra-minc/math.yaml
+++ /dev/null
@@ -1,205 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.minc.minc.Math' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Various mathematical operations supplied by mincmath.
-# 
-#     Examples
-#     --------
-# 
-#     >>> from nipype.interfaces.minc import Math
-#     >>> from nipype.interfaces.minc.testdata import minc2Dfile
-# 
-#     Scale: volume*3.0 + 2:
-# 
-#     >>> scale = Math(input_files=[minc2Dfile], scale=(3.0, 2))
-#     >>> scale.run() # doctest: +SKIP
-# 
-#     Test if >= 1.5:
-# 
-#     >>> gt = Math(input_files=[minc2Dfile], test_gt=1.5)
-#     >>> gt.run() # doctest: +SKIP
-#     
-task_name: Math
-nipype_name: Math
-nipype_module: nipype.interfaces.minc.minc
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    input_files: generic/file+list-of
-    # type=inputmultiobject|default=[]: input file(s) for calculation
-    filelist: generic/file
-    # type=file|default=<undefined>: Specify the name of a file containing input file names.
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    output_file: generic/file
-    # type=file: output file
-    # type=file|default=<undefined>: output file
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    output_file: output_file
-    # type=file: output file
-    # type=file|default=<undefined>: output file
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    input_files:
-    # type=inputmultiobject|default=[]: input file(s) for calculation
-    output_file:
-    # type=file: output file
-    # type=file|default=<undefined>: output file
-    filelist:
-    # type=file|default=<undefined>: Specify the name of a file containing input file names.
-    clobber:
-    # type=bool|default=True: Overwrite existing file.
-    two:
-    # type=bool|default=False: Create a MINC 2 output file.
-    copy_header:
-    # type=bool|default=False: Copy all of the header from the first file (default for one file).
-    no_copy_header:
-    # type=bool|default=False: Do not copy all of the header from the first file (default for many files)).
-    format_filetype:
-    # type=bool|default=False: Use data type of first file (default).
-    format_byte:
-    # type=bool|default=False: Write out byte data.
-    format_short:
-    # type=bool|default=False: Write out short integer data.
-    format_int:
-    # type=bool|default=False: Write out 32-bit integer data.
-    format_long:
-    # type=bool|default=False: Superseded by -int.
-    format_float:
-    # type=bool|default=False: Write out single-precision floating-point data.
-    format_double:
-    # type=bool|default=False: Write out double-precision floating-point data.
-    format_signed:
-    # type=bool|default=False: Write signed integer data.
-    format_unsigned:
-    # type=bool|default=False: Write unsigned integer data (default).
-    voxel_range:
-    # type=tuple|default=(0, 0): Valid range for output data.
-    max_buffer_size_in_kb:
-    # type=range|default=4096: Specify the maximum size of the internal buffers (in kbytes).
-    check_dimensions:
-    # type=bool|default=False: Check that dimension info matches across files (default).
-    no_check_dimensions:
-    # type=bool|default=False: Do not check dimension info.
-    dimension:
-    # type=str|default='': Specify a dimension along which we wish to perform a calculation.
-    ignore_nan:
-    # type=bool|default=False: Ignore invalid data (NaN) for accumulations.
-    propagate_nan:
-    # type=bool|default=False: Invalid data in any file at a voxel produces a NaN (default).
-    output_nan:
-    # type=bool|default=False: Output NaN when an illegal operation is done (default).
-    output_zero:
-    # type=bool|default=False: Output zero when an illegal operation is done.
-    output_illegal:
-    # type=bool|default=False: Value to write out when an illegal operationis done. Default value: 1.79769e+308
-    test_gt:
-    # type=traitcompound|default=None: Test for vol1 > vol2 or vol1 > constant.
-    test_lt:
-    # type=traitcompound|default=None: Test for vol1 < vol2 or vol1 < constant.
-    test_eq:
-    # type=traitcompound|default=None: Test for integer vol1 == vol2 or vol1 == constant.
-    test_ne:
-    # type=traitcompound|default=None: Test for integer vol1 != vol2 or vol1 != const.
-    test_ge:
-    # type=traitcompound|default=None: Test for vol1 >= vol2 or vol1 >= const.
-    test_le:
-    # type=traitcompound|default=None: Test for vol1 <= vol2 or vol1 <= const.
-    calc_add:
-    # type=traitcompound|default=None: Add N volumes or volume + constant.
-    calc_sub:
-    # type=traitcompound|default=None: Subtract 2 volumes or volume - constant.
-    calc_mul:
-    # type=traitcompound|default=None: Multiply N volumes or volume * constant.
-    calc_div:
-    # type=traitcompound|default=None: Divide 2 volumes or volume / constant.
-    invert:
-    # type=float|default=None: Calculate 1/c.
-    calc_not:
-    # type=bool|default=False: Calculate !vol1.
-    sqrt:
-    # type=bool|default=False: Take square root of a volume.
-    square:
-    # type=bool|default=False: Take square of a volume.
-    abs:
-    # type=bool|default=False: Take absolute value of a volume.
-    exp:
-    # type=tuple|default=(0.0, 0.0): Calculate c2*exp(c1*x). Both constants must be specified.
-    log:
-    # type=tuple|default=(0.0, 0.0): Calculate log(x/c2)/c1. The constants c1 and c2 default to 1.
-    scale:
-    # type=tuple|default=(0.0, 0.0): Scale a volume: volume * c1 + c2.
-    clamp:
-    # type=tuple|default=(0.0, 0.0): Clamp a volume to lie between two values.
-    segment:
-    # type=tuple|default=(0.0, 0.0): Segment a volume using range of -const2: within range = 1, outside range = 0.
-    nsegment:
-    # type=tuple|default=(0.0, 0.0): Opposite of -segment: within range = 0, outside range = 1.
-    isnan:
-    # type=bool|default=False: Test for NaN values in vol1.
-    nisnan:
-    # type=bool|default=False: Negation of -isnan.
-    percentdiff:
-    # type=float|default=0.0: Percent difference between 2 volumes, thresholded (const def=0.0).
-    count_valid:
-    # type=bool|default=False: Count the number of valid values in N volumes.
-    maximum:
-    # type=bool|default=False: Find maximum of N volumes.
-    minimum:
-    # type=bool|default=False: Find minimum of N volumes.
-    calc_and:
-    # type=bool|default=False: Calculate vol1 && vol2 (&& ...).
-    calc_or:
-    # type=bool|default=False: Calculate vol1 || vol2 (|| ...).
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-minc/math_callables.py b/example-specs/task/nipype_internal/pydra-minc/math_callables.py
deleted file mode 100644
index a8b328fe..00000000
--- a/example-specs/task/nipype_internal/pydra-minc/math_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in Math.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-minc/nlp_fit.yaml b/example-specs/task/nipype_internal/pydra-minc/nlp_fit.yaml
deleted file mode 100644
index ac294203..00000000
--- a/example-specs/task/nipype_internal/pydra-minc/nlp_fit.yaml
+++ /dev/null
@@ -1,125 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.minc.minc.NlpFit' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Hierarchial non-linear fitting with bluring.
-# 
-#     This tool is part of the minc-widgets package:
-# 
-#     https://github.com/BIC-MNI/minc-widgets/blob/master/nlpfit/nlpfit
-# 
-#     Examples
-#     --------
-# 
-#     >>> from nipype.interfaces.minc import NlpFit
-#     >>> from nipype.interfaces.minc.testdata import nonempty_minc_data, nlp_config
-#     >>> from nipype.testing import example_data
-# 
-#     >>> source = nonempty_minc_data(0)
-#     >>> target = nonempty_minc_data(1)
-#     >>> source_mask = nonempty_minc_data(2)
-#     >>> config = nlp_config
-#     >>> initial = example_data('minc_initial.xfm')
-#     >>> nlpfit = NlpFit(config_file=config, init_xfm=initial, source_mask=source_mask, source=source, target=target)
-#     >>> nlpfit.run() # doctest: +SKIP
-#     
-task_name: NlpFit
-nipype_name: NlpFit
-nipype_module: nipype.interfaces.minc.minc
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    source: generic/file
-    # type=file|default=<undefined>: source Minc file
-    target: generic/file
-    # type=file|default=<undefined>: target Minc file
-    input_grid_files: generic/file+list-of
-    # type=inputmultiobject|default=[]: input grid file(s)
-    config_file: generic/file
-    # type=file|default=<undefined>: File containing the fitting configuration use.
-    init_xfm: generic/file
-    # type=file|default=<undefined>: Initial transformation (default identity).
-    source_mask: generic/file
-    # type=file|default=<undefined>: Source mask to use during fitting.
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    output_xfm: generic/file
-    # type=file: output xfm file
-    # type=file|default=<undefined>: output xfm file
-    output_grid: generic/file
-    # type=file: output grid file
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    output_xfm: output_xfm
-    # type=file: output xfm file
-    # type=file|default=<undefined>: output xfm file
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    source:
-    # type=file|default=<undefined>: source Minc file
-    target:
-    # type=file|default=<undefined>: target Minc file
-    output_xfm:
-    # type=file: output xfm file
-    # type=file|default=<undefined>: output xfm file
-    input_grid_files:
-    # type=inputmultiobject|default=[]: input grid file(s)
-    config_file:
-    # type=file|default=<undefined>: File containing the fitting configuration use.
-    init_xfm:
-    # type=file|default=<undefined>: Initial transformation (default identity).
-    source_mask:
-    # type=file|default=<undefined>: Source mask to use during fitting.
-    verbose:
-    # type=bool|default=False: Print out log messages. Default: False.
-    clobber:
-    # type=bool|default=True: Overwrite existing file.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-minc/nlp_fit_callables.py b/example-specs/task/nipype_internal/pydra-minc/nlp_fit_callables.py
deleted file mode 100644
index cb7f93a2..00000000
--- a/example-specs/task/nipype_internal/pydra-minc/nlp_fit_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in NlpFit.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-minc/norm.yaml b/example-specs/task/nipype_internal/pydra-minc/norm.yaml
deleted file mode 100644
index e048d8c7..00000000
--- a/example-specs/task/nipype_internal/pydra-minc/norm.yaml
+++ /dev/null
@@ -1,124 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.minc.minc.Norm' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Normalise a file between a max and minimum (possibly)
-#        using two histogram pct's.
-# 
-#     Examples
-#     --------
-# 
-#     >>> from nipype.interfaces.minc import Norm
-#     >>> from nipype.interfaces.minc.testdata import minc2Dfile
-#     >>> n = Norm(input_file=minc2Dfile, output_file='/tmp/out.mnc') # Normalise the file.
-#     >>> n.run() # doctest: +SKIP
-#     
-task_name: Norm
-nipype_name: Norm
-nipype_module: nipype.interfaces.minc.minc
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    input_file: generic/file
-    # type=file|default=<undefined>: input file to normalise
-    output_threshold_mask: generic/file
-    # type=file: threshold mask file
-    # type=file|default=<undefined>: File in which to store the threshold mask.
-    mask: generic/file
-    # type=file|default=<undefined>: Calculate the image normalisation within a mask.
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    output_file: generic/file
-    # type=file: output file
-    # type=file|default=<undefined>: output file
-    output_threshold_mask: generic/file
-    # type=file: threshold mask file
-    # type=file|default=<undefined>: File in which to store the threshold mask.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    output_file: output_file
-    # type=file: output file
-    # type=file|default=<undefined>: output file
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    input_file:
-    # type=file|default=<undefined>: input file to normalise
-    output_file:
-    # type=file: output file
-    # type=file|default=<undefined>: output file
-    output_threshold_mask:
-    # type=file: threshold mask file
-    # type=file|default=<undefined>: File in which to store the threshold mask.
-    clobber:
-    # type=bool|default=True: Overwrite existing file.
-    mask:
-    # type=file|default=<undefined>: Calculate the image normalisation within a mask.
-    clamp:
-    # type=bool|default=True: Force the output range between limits [default].
-    cutoff:
-    # type=range|default=0.0: Cutoff value to use to calculate thresholds by a histogram PcT in %. [default: 0.01]
-    lower:
-    # type=float|default=0.0: Lower real value to use.
-    upper:
-    # type=float|default=0.0: Upper real value to use.
-    out_floor:
-    # type=float|default=0.0: Output files maximum [default: 0]
-    out_ceil:
-    # type=float|default=0.0: Output files minimum [default: 100]
-    threshold:
-    # type=bool|default=False: Threshold the image (set values below threshold_perc to -out_floor).
-    threshold_perc:
-    # type=range|default=0.0: Threshold percentage (0.1 == lower 10% of intensity range) [default: 0.1].
-    threshold_bmt:
-    # type=bool|default=False: Use the resulting image BiModalT as the threshold.
-    threshold_blur:
-    # type=float|default=0.0: Blur FWHM for intensity edges then thresholding [default: 2].
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-minc/norm_callables.py b/example-specs/task/nipype_internal/pydra-minc/norm_callables.py
deleted file mode 100644
index 866c8ed5..00000000
--- a/example-specs/task/nipype_internal/pydra-minc/norm_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in Norm.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-minc/pik.yaml b/example-specs/task/nipype_internal/pydra-minc/pik.yaml
deleted file mode 100644
index ccce436b..00000000
--- a/example-specs/task/nipype_internal/pydra-minc/pik.yaml
+++ /dev/null
@@ -1,140 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.minc.minc.Pik' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Generate images from minc files.
-# 
-#     Mincpik uses Imagemagick to generate images
-#     from Minc files.
-# 
-#     Examples
-#     --------
-# 
-#     >>> from nipype.interfaces.minc import Pik
-#     >>> from nipype.interfaces.minc.testdata import nonempty_minc_data
-# 
-#     >>> file0 = nonempty_minc_data(0)
-#     >>> pik = Pik(input_file=file0, title='foo')
-#     >>> pik .run() # doctest: +SKIP
-# 
-#     
-task_name: Pik
-nipype_name: Pik
-nipype_module: nipype.interfaces.minc.minc
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    input_file: generic/file
-    # type=file|default=<undefined>: input file
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    output_file: generic/file
-    # type=file: output image
-    # type=file|default=<undefined>: output file
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    output_file: output_file
-    # type=file: output image
-    # type=file|default=<undefined>: output file
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    input_file:
-    # type=file|default=<undefined>: input file
-    jpg:
-    # type=bool|default=False: Output a jpg file.
-    png:
-    # type=bool|default=False: Output a png file (default).
-    output_file:
-    # type=file: output image
-    # type=file|default=<undefined>: output file
-    clobber:
-    # type=bool|default=True: Overwrite existing file.
-    scale:
-    # type=int|default=2: Scaling factor for resulting image. By default images areoutput at twice their original resolution.
-    width:
-    # type=int|default=0: Autoscale the resulting image to have a fixed image width (in pixels).
-    depth:
-    # type=enum|default=8|allowed[16,8]: Bitdepth for resulting image 8 or 16 (MSB machines only!)
-    title:
-    # type=traitcompound|default=None: 
-    title_size:
-    # type=int|default=0: Font point size for the title.
-    annotated_bar:
-    # type=bool|default=False: create an annotated bar to match the image (use height of the output image)
-    minc_range:
-    # type=tuple|default=(0.0, 0.0): Valid range of values for MINC file.
-    image_range:
-    # type=tuple|default=(0.0, 0.0): Range of image values to use for pixel intensity.
-    auto_range:
-    # type=bool|default=False: Automatically determine image range using a 5 and 95% PcT. (histogram)
-    start:
-    # type=int|default=0: Slice number to get. (note this is in voxel coordinates).
-    slice_z:
-    # type=bool|default=False: Get an axial/transverse (z) slice.
-    slice_y:
-    # type=bool|default=False: Get a coronal (y) slice.
-    slice_x:
-    # type=bool|default=False: Get a sagittal (x) slice.
-    triplanar:
-    # type=bool|default=False: Create a triplanar view of the input file.
-    tile_size:
-    # type=int|default=0: Pixel size for each image in a triplanar.
-    sagittal_offset:
-    # type=int|default=0: Offset the sagittal slice from the centre.
-    sagittal_offset_perc:
-    # type=range|default=0: Offset the sagittal slice by a percentage from the centre.
-    vertical_triplanar_view:
-    # type=bool|default=False: Create a vertical triplanar view (Default).
-    horizontal_triplanar_view:
-    # type=bool|default=False: Create a horizontal triplanar view.
-    lookup:
-    # type=str|default='': Arguments to pass to minclookup
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-minc/pik_callables.py b/example-specs/task/nipype_internal/pydra-minc/pik_callables.py
deleted file mode 100644
index 76000097..00000000
--- a/example-specs/task/nipype_internal/pydra-minc/pik_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in Pik.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-minc/resample.yaml b/example-specs/task/nipype_internal/pydra-minc/resample.yaml
deleted file mode 100644
index 2c9d42dc..00000000
--- a/example-specs/task/nipype_internal/pydra-minc/resample.yaml
+++ /dev/null
@@ -1,202 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.minc.minc.Resample' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Resample a minc file.'
-# 
-#     Examples
-#     --------
-# 
-#     >>> from nipype.interfaces.minc import Resample
-#     >>> from nipype.interfaces.minc.testdata import minc2Dfile
-#     >>> r = Resample(input_file=minc2Dfile, output_file='/tmp/out.mnc') # Resample the file.
-#     >>> r.run() # doctest: +SKIP
-# 
-#     
-task_name: Resample
-nipype_name: Resample
-nipype_module: nipype.interfaces.minc.minc
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    input_file: generic/file
-    # type=file|default=<undefined>: input file for resampling
-    input_grid_files: generic/file+list-of
-    # type=inputmultiobject|default=[]: input grid file(s)
-    transformation: generic/file
-    # type=file|default=<undefined>: File giving world transformation. (Default = identity).
-    like: generic/file
-    # type=file|default=<undefined>: Specifies a model file for the resampling.
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    output_file: generic/file
-    # type=file: output file
-    # type=file|default=<undefined>: output file
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    output_file: output_file
-    # type=file: output file
-    # type=file|default=<undefined>: output file
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    input_file:
-    # type=file|default=<undefined>: input file for resampling
-    output_file:
-    # type=file: output file
-    # type=file|default=<undefined>: output file
-    input_grid_files:
-    # type=inputmultiobject|default=[]: input grid file(s)
-    two:
-    # type=bool|default=False: Create a MINC 2 output file.
-    clobber:
-    # type=bool|default=True: Overwrite existing file.
-    trilinear_interpolation:
-    # type=bool|default=False: Do trilinear interpolation.
-    tricubic_interpolation:
-    # type=bool|default=False: Do tricubic interpolation.
-    nearest_neighbour_interpolation:
-    # type=bool|default=False: Do nearest neighbour interpolation.
-    sinc_interpolation:
-    # type=bool|default=False: Do windowed sinc interpolation.
-    half_width_sinc_window:
-    # type=enum|default=5|allowed[1,10,2,3,4,5,6,7,8,9]: Set half-width of sinc window (1-10). Default value: 5.
-    sinc_window_hanning:
-    # type=bool|default=False: Set sinc window type to Hanning.
-    sinc_window_hamming:
-    # type=bool|default=False: Set sinc window type to Hamming.
-    transformation:
-    # type=file|default=<undefined>: File giving world transformation. (Default = identity).
-    invert_transformation:
-    # type=bool|default=False: Invert the transformation before using it.
-    vio_transform:
-    # type=bool|default=False: VIO_Transform the input sampling with the transform (default).
-    no_input_sampling:
-    # type=bool|default=False: Use the input sampling without transforming (old behaviour).
-    like:
-    # type=file|default=<undefined>: Specifies a model file for the resampling.
-    format_byte:
-    # type=bool|default=False: Write out byte data.
-    format_short:
-    # type=bool|default=False: Write out short integer data.
-    format_int:
-    # type=bool|default=False: Write out 32-bit integer data.
-    format_long:
-    # type=bool|default=False: Superseded by -int.
-    format_float:
-    # type=bool|default=False: Write out single-precision floating-point data.
-    format_double:
-    # type=bool|default=False: Write out double-precision floating-point data.
-    format_signed:
-    # type=bool|default=False: Write signed integer data.
-    format_unsigned:
-    # type=bool|default=False: Write unsigned integer data (default).
-    output_range:
-    # type=tuple|default=(0.0, 0.0): Valid range for output data. Default value: -1.79769e+308 -1.79769e+308.
-    transverse_slices:
-    # type=bool|default=False: Write out transverse slices.
-    sagittal_slices:
-    # type=bool|default=False: Write out sagittal slices
-    coronal_slices:
-    # type=bool|default=False: Write out coronal slices
-    no_fill:
-    # type=bool|default=False: Use value zero for points outside of input volume.
-    fill:
-    # type=bool|default=False: Use a fill value for points outside of input volume.
-    fill_value:
-    # type=float|default=0.0: Specify a fill value for points outside of input volume.Default value: 1.79769e+308.
-    keep_real_range:
-    # type=bool|default=False: Keep the real scale of the input volume.
-    nokeep_real_range:
-    # type=bool|default=False: Do not keep the real scale of the data (default).
-    spacetype:
-    # type=str|default='': Set the spacetype attribute to a specified string.
-    talairach:
-    # type=bool|default=False: Output is in Talairach space.
-    origin:
-    # type=tuple|default=(0.0, 0.0, 0.0): Origin of first pixel in 3D space.Default value: 1.79769e+308 1.79769e+308 1.79769e+308.
-    standard_sampling:
-    # type=bool|default=False: Set the sampling to standard values (step, start and dircos).
-    units:
-    # type=str|default='': Specify the units of the output sampling.
-    nelements:
-    # type=tuple|default=(0, 0, 0): Number of elements along each dimension (X, Y, Z).
-    xnelements:
-    # type=int|default=0: Number of elements along the X dimension.
-    ynelements:
-    # type=int|default=0: Number of elements along the Y dimension.
-    znelements:
-    # type=int|default=0: Number of elements along the Z dimension.
-    step:
-    # type=tuple|default=(0, 0, 0): Step size along each dimension (X, Y, Z). Default value: (0, 0, 0).
-    xstep:
-    # type=int|default=0: Step size along the X dimension. Default value: 0.
-    ystep:
-    # type=int|default=0: Step size along the Y dimension. Default value: 0.
-    zstep:
-    # type=int|default=0: Step size along the Z dimension. Default value: 0.
-    start:
-    # type=tuple|default=(0.0, 0.0, 0.0): Start point along each dimension (X, Y, Z).Default value: 1.79769e+308 1.79769e+308 1.79769e+308.
-    xstart:
-    # type=float|default=0.0: Start point along the X dimension. Default value: 1.79769e+308.
-    ystart:
-    # type=float|default=0.0: Start point along the Y dimension. Default value: 1.79769e+308.
-    zstart:
-    # type=float|default=0.0: Start point along the Z dimension. Default value: 1.79769e+308.
-    dircos:
-    # type=tuple|default=(0.0, 0.0, 0.0): Direction cosines along each dimension (X, Y, Z). Default value:1.79769e+308 1.79769e+308 1.79769e+308 1.79769e+308 ...  1.79769e+308 1.79769e+308 1.79769e+308 1.79769e+308 1.79769e+308.
-    xdircos:
-    # type=float|default=0.0: Direction cosines along the X dimension.Default value: 1.79769e+308 1.79769e+308 1.79769e+308.
-    ydircos:
-    # type=float|default=0.0: Direction cosines along the Y dimension.Default value: 1.79769e+308 1.79769e+308 1.79769e+308.
-    zdircos:
-    # type=float|default=0.0: Direction cosines along the Z dimension.Default value: 1.79769e+308 1.79769e+308 1.79769e+308.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-minc/resample_callables.py b/example-specs/task/nipype_internal/pydra-minc/resample_callables.py
deleted file mode 100644
index 1e012806..00000000
--- a/example-specs/task/nipype_internal/pydra-minc/resample_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in Resample.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-minc/reshape.yaml b/example-specs/task/nipype_internal/pydra-minc/reshape.yaml
deleted file mode 100644
index 885eb165..00000000
--- a/example-specs/task/nipype_internal/pydra-minc/reshape.yaml
+++ /dev/null
@@ -1,100 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.minc.minc.Reshape' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Cut a hyperslab out of a minc file, with dimension reordering.
-# 
-#     This is also useful for rewriting with a different format, for
-#     example converting to short (see example below).
-# 
-#     Examples
-#     --------
-# 
-#     >>> from nipype.interfaces.minc import Reshape
-#     >>> from nipype.interfaces.minc.testdata import nonempty_minc_data
-# 
-#     >>> input_file = nonempty_minc_data(0)
-#     >>> reshape_to_short = Reshape(input_file=input_file, write_short=True)
-#     >>> reshape_to_short.run() # doctest: +SKIP
-# 
-#     
-task_name: Reshape
-nipype_name: Reshape
-nipype_module: nipype.interfaces.minc.minc
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    input_file: generic/file
-    # type=file|default=<undefined>: input file
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    output_file: generic/file
-    # type=file: output file
-    # type=file|default=<undefined>: output file
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    output_file: output_file
-    # type=file: output file
-    # type=file|default=<undefined>: output file
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    input_file:
-    # type=file|default=<undefined>: input file
-    output_file:
-    # type=file: output file
-    # type=file|default=<undefined>: output file
-    verbose:
-    # type=bool|default=False: Print out log messages. Default: False.
-    clobber:
-    # type=bool|default=True: Overwrite existing file.
-    write_short:
-    # type=bool|default=False: Convert to short integer data.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-minc/reshape_callables.py b/example-specs/task/nipype_internal/pydra-minc/reshape_callables.py
deleted file mode 100644
index 8246e719..00000000
--- a/example-specs/task/nipype_internal/pydra-minc/reshape_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in Reshape.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-minc/to_ecat.yaml b/example-specs/task/nipype_internal/pydra-minc/to_ecat.yaml
deleted file mode 100644
index 43db9740..00000000
--- a/example-specs/task/nipype_internal/pydra-minc/to_ecat.yaml
+++ /dev/null
@@ -1,110 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.minc.minc.ToEcat' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Convert a 2D image, a 3D volumes or a 4D dynamic volumes
-#     written in MINC file format to a 2D, 3D or 4D Ecat7 file.
-# 
-#     Examples
-#     --------
-# 
-#     >>> from nipype.interfaces.minc import ToEcat
-#     >>> from nipype.interfaces.minc.testdata import minc2Dfile
-# 
-#     >>> c = ToEcat(input_file=minc2Dfile)
-#     >>> c.run() # doctest: +SKIP
-# 
-#     >>> c = ToEcat(input_file=minc2Dfile, voxels_as_integers=True)
-#     >>> c.run() # doctest: +SKIP
-# 
-#     
-task_name: ToEcat
-nipype_name: ToEcat
-nipype_module: nipype.interfaces.minc.minc
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    input_file: generic/file
-    # type=file|default=<undefined>: input file to convert
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    output_file: generic/file
-    # type=file: output file
-    # type=file|default=<undefined>: output file
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    output_file: output_file
-    # type=file: output file
-    # type=file|default=<undefined>: output file
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    input_file:
-    # type=file|default=<undefined>: input file to convert
-    output_file:
-    # type=file: output file
-    # type=file|default=<undefined>: output file
-    ignore_patient_variable:
-    # type=bool|default=False: Ignore information from the minc patient variable.
-    ignore_study_variable:
-    # type=bool|default=False: Ignore information from the minc study variable.
-    ignore_acquisition_variable:
-    # type=bool|default=False: Ignore information from the minc acquisition variable.
-    ignore_ecat_acquisition_variable:
-    # type=bool|default=False: Ignore information from the minc ecat_acquisition variable.
-    ignore_ecat_main:
-    # type=bool|default=False: Ignore information from the minc ecat-main variable.
-    ignore_ecat_subheader_variable:
-    # type=bool|default=False: Ignore information from the minc ecat-subhdr variable.
-    no_decay_corr_fctr:
-    # type=bool|default=False: Do not compute the decay correction factors
-    voxels_as_integers:
-    # type=bool|default=False: Voxel values are treated as integers, scale andcalibration factors are set to unity
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-minc/to_ecat_callables.py b/example-specs/task/nipype_internal/pydra-minc/to_ecat_callables.py
deleted file mode 100644
index b98e1d2e..00000000
--- a/example-specs/task/nipype_internal/pydra-minc/to_ecat_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in ToEcat.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-minc/to_raw.yaml b/example-specs/task/nipype_internal/pydra-minc/to_raw.yaml
deleted file mode 100644
index 75f6e01e..00000000
--- a/example-specs/task/nipype_internal/pydra-minc/to_raw.yaml
+++ /dev/null
@@ -1,119 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.minc.minc.ToRaw' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Dump a chunk of MINC file data. This program is largely
-#     superseded by mincextract (see Extract).
-# 
-#     Examples
-#     --------
-# 
-#     >>> from nipype.interfaces.minc import ToRaw
-#     >>> from nipype.interfaces.minc.testdata import minc2Dfile
-# 
-#     >>> toraw = ToRaw(input_file=minc2Dfile)
-#     >>> toraw.run() # doctest: +SKIP
-# 
-#     >>> toraw = ToRaw(input_file=minc2Dfile, write_range=(0, 100))
-#     >>> toraw.run() # doctest: +SKIP
-#     
-task_name: ToRaw
-nipype_name: ToRaw
-nipype_module: nipype.interfaces.minc.minc
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    input_file: generic/file
-    # type=file|default=<undefined>: input file
-    output_file: generic/file
-    # type=file: output file in raw format
-    # type=file|default=<undefined>: output file
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    output_file: generic/file
-    # type=file: output file in raw format
-    # type=file|default=<undefined>: output file
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    out_file: out_file
-    # type=file|default=<undefined>: 
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    input_file:
-    # type=file|default=<undefined>: input file
-    output_file:
-    # type=file: output file in raw format
-    # type=file|default=<undefined>: output file
-    write_byte:
-    # type=bool|default=False: Write out data as bytes.
-    write_short:
-    # type=bool|default=False: Write out data as short integers.
-    write_int:
-    # type=bool|default=False: Write out data as 32-bit integers.
-    write_long:
-    # type=bool|default=False: Superseded by write_int.
-    write_float:
-    # type=bool|default=False: Write out data as single precision floating-point values.
-    write_double:
-    # type=bool|default=False: Write out data as double precision floating-point values.
-    write_signed:
-    # type=bool|default=False: Write out signed data.
-    write_unsigned:
-    # type=bool|default=False: Write out unsigned data.
-    write_range:
-    # type=tuple|default=(0.0, 0.0): Specify the range of output values.Default value: 1.79769e+308 1.79769e+308.
-    normalize:
-    # type=bool|default=False: Normalize integer pixel values to file max and min.
-    nonormalize:
-    # type=bool|default=False: Turn off pixel normalization.
-    out_file:
-    # type=file|default=<undefined>: 
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-minc/to_raw_callables.py b/example-specs/task/nipype_internal/pydra-minc/to_raw_callables.py
deleted file mode 100644
index 48959526..00000000
--- a/example-specs/task/nipype_internal/pydra-minc/to_raw_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in ToRaw.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-minc/vol_symm.yaml b/example-specs/task/nipype_internal/pydra-minc/vol_symm.yaml
deleted file mode 100644
index 3db9c3cf..00000000
--- a/example-specs/task/nipype_internal/pydra-minc/vol_symm.yaml
+++ /dev/null
@@ -1,132 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.minc.minc.VolSymm' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Make a volume symmetric about an axis either linearly
-#     and/or nonlinearly. This is done by registering a volume
-#     to a flipped image of itself.
-# 
-#     This tool is part of the minc-widgets package:
-# 
-#     https://github.com/BIC-MNI/minc-widgets/blob/master/volsymm/volsymm
-# 
-#     Examples
-#     --------
-# 
-#     >>> from nipype.interfaces.minc import VolSymm
-#     >>> from nipype.interfaces.minc.testdata import nonempty_minc_data
-# 
-#     >>> input_file = nonempty_minc_data(0)
-#     >>> volsymm = VolSymm(input_file=input_file)
-#     >>> volsymm.run() # doctest: +SKIP
-# 
-#     
-task_name: VolSymm
-nipype_name: VolSymm
-nipype_module: nipype.interfaces.minc.minc
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    input_file: generic/file
-    # type=file|default=<undefined>: input file
-    input_grid_files: generic/file+list-of
-    # type=inputmultiobject|default=[]: input grid file(s)
-    config_file: generic/file
-    # type=file|default=<undefined>: File containing the fitting configuration (nlpfit -help for info).
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    output_file: generic/file
-    # type=file: output file
-    # type=file|default=<undefined>: output file
-    trans_file: generic/file
-    # type=file: xfm trans file
-    # type=file|default=<undefined>: output xfm trans file
-    output_grid: generic/file
-    # type=file: output grid file
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    trans_file: trans_file
-    # type=file: xfm trans file
-    # type=file|default=<undefined>: output xfm trans file
-    output_file: output_file
-    # type=file: output file
-    # type=file|default=<undefined>: output file
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    input_file:
-    # type=file|default=<undefined>: input file
-    trans_file:
-    # type=file: xfm trans file
-    # type=file|default=<undefined>: output xfm trans file
-    output_file:
-    # type=file: output file
-    # type=file|default=<undefined>: output file
-    input_grid_files:
-    # type=inputmultiobject|default=[]: input grid file(s)
-    verbose:
-    # type=bool|default=False: Print out log messages. Default: False.
-    clobber:
-    # type=bool|default=True: Overwrite existing file.
-    fit_linear:
-    # type=bool|default=False: Fit using a linear xfm.
-    fit_nonlinear:
-    # type=bool|default=False: Fit using a non-linear xfm.
-    nofit:
-    # type=bool|default=False: Use the input transformation instead of generating one.
-    config_file:
-    # type=file|default=<undefined>: File containing the fitting configuration (nlpfit -help for info).
-    x:
-    # type=bool|default=False: Flip volume in x-plane (default).
-    y:
-    # type=bool|default=False: Flip volume in y-plane.
-    z:
-    # type=bool|default=False: Flip volume in z-plane.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-minc/vol_symm_callables.py b/example-specs/task/nipype_internal/pydra-minc/vol_symm_callables.py
deleted file mode 100644
index 4c7f40ab..00000000
--- a/example-specs/task/nipype_internal/pydra-minc/vol_symm_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in VolSymm.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-minc/volcentre.yaml b/example-specs/task/nipype_internal/pydra-minc/volcentre.yaml
deleted file mode 100644
index 1c457caa..00000000
--- a/example-specs/task/nipype_internal/pydra-minc/volcentre.yaml
+++ /dev/null
@@ -1,98 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.minc.minc.Volcentre' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Centre a MINC image's sampling about a point, typically (0,0,0).
-# 
-#     Example
-#     --------
-# 
-#     >>> from nipype.interfaces.minc import Volcentre
-#     >>> from nipype.interfaces.minc.testdata import minc2Dfile
-#     >>> vc = Volcentre(input_file=minc2Dfile)
-#     >>> vc.run() # doctest: +SKIP
-#     
-task_name: Volcentre
-nipype_name: Volcentre
-nipype_module: nipype.interfaces.minc.minc
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    input_file: generic/file
-    # type=file|default=<undefined>: input file to centre
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    output_file: generic/file
-    # type=file: output file
-    # type=file|default=<undefined>: output file
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    output_file: output_file
-    # type=file: output file
-    # type=file|default=<undefined>: output file
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    input_file:
-    # type=file|default=<undefined>: input file to centre
-    output_file:
-    # type=file: output file
-    # type=file|default=<undefined>: output file
-    verbose:
-    # type=bool|default=False: Print out log messages. Default: False.
-    clobber:
-    # type=bool|default=True: Overwrite existing file.
-    com:
-    # type=bool|default=False: Use the CoM of the volume for the new centre (via mincstats). Default: False
-    centre:
-    # type=tuple|default=(0.0, 0.0, 0.0): Centre to use (x,y,z) [default: 0 0 0].
-    zero_dircos:
-    # type=bool|default=False: Set the direction cosines to identity [default].
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-minc/volcentre_callables.py b/example-specs/task/nipype_internal/pydra-minc/volcentre_callables.py
deleted file mode 100644
index 70c0696b..00000000
--- a/example-specs/task/nipype_internal/pydra-minc/volcentre_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in Volcentre.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-minc/voliso.yaml b/example-specs/task/nipype_internal/pydra-minc/voliso.yaml
deleted file mode 100644
index e6b62b83..00000000
--- a/example-specs/task/nipype_internal/pydra-minc/voliso.yaml
+++ /dev/null
@@ -1,99 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.minc.minc.Voliso' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Changes the steps and starts in order that the output volume
-#     has isotropic sampling.
-# 
-#     Examples
-#     --------
-# 
-#     >>> from nipype.interfaces.minc import Voliso
-#     >>> from nipype.interfaces.minc.testdata import minc2Dfile
-#     >>> viso = Voliso(input_file=minc2Dfile, minstep=0.1, avgstep=True)
-#     >>> viso.run() # doctest: +SKIP
-#     
-task_name: Voliso
-nipype_name: Voliso
-nipype_module: nipype.interfaces.minc.minc
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    input_file: generic/file
-    # type=file|default=<undefined>: input file to convert to isotropic sampling
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    output_file: generic/file
-    # type=file: output file
-    # type=file|default=<undefined>: output file
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    output_file: output_file
-    # type=file: output file
-    # type=file|default=<undefined>: output file
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    input_file:
-    # type=file|default=<undefined>: input file to convert to isotropic sampling
-    output_file:
-    # type=file: output file
-    # type=file|default=<undefined>: output file
-    verbose:
-    # type=bool|default=False: Print out log messages. Default: False.
-    clobber:
-    # type=bool|default=True: Overwrite existing file.
-    maxstep:
-    # type=float|default=0.0: The target maximum step desired in the output volume.
-    minstep:
-    # type=float|default=0.0: The target minimum step desired in the output volume.
-    avgstep:
-    # type=bool|default=False: Calculate the maximum step from the average steps of the input volume.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-minc/voliso_callables.py b/example-specs/task/nipype_internal/pydra-minc/voliso_callables.py
deleted file mode 100644
index ea4a107d..00000000
--- a/example-specs/task/nipype_internal/pydra-minc/voliso_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in Voliso.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-minc/volpad.yaml b/example-specs/task/nipype_internal/pydra-minc/volpad.yaml
deleted file mode 100644
index 8194cfe7..00000000
--- a/example-specs/task/nipype_internal/pydra-minc/volpad.yaml
+++ /dev/null
@@ -1,102 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.minc.minc.Volpad' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Centre a MINC image's sampling about a point, typically (0,0,0).
-# 
-#     Examples
-#     --------
-# 
-#     >>> from nipype.interfaces.minc import Volpad
-#     >>> from nipype.interfaces.minc.testdata import minc2Dfile
-#     >>> vp = Volpad(input_file=minc2Dfile, smooth=True, smooth_distance=4)
-#     >>> vp.run() # doctest: +SKIP
-#     
-task_name: Volpad
-nipype_name: Volpad
-nipype_module: nipype.interfaces.minc.minc
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    input_file: generic/file
-    # type=file|default=<undefined>: input file to centre
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    output_file: generic/file
-    # type=file: output file
-    # type=file|default=<undefined>: output file
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    output_file: output_file
-    # type=file: output file
-    # type=file|default=<undefined>: output file
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    input_file:
-    # type=file|default=<undefined>: input file to centre
-    output_file:
-    # type=file: output file
-    # type=file|default=<undefined>: output file
-    verbose:
-    # type=bool|default=False: Print out log messages. Default: False.
-    clobber:
-    # type=bool|default=True: Overwrite existing file.
-    auto:
-    # type=bool|default=False: Automatically determine padding distances (uses -distance as max). Default: False.
-    auto_freq:
-    # type=float|default=0.0: Frequency of voxels over bimodalt threshold to stop at [default: 500].
-    distance:
-    # type=int|default=0: Padding distance (in voxels) [default: 4].
-    smooth:
-    # type=bool|default=False: Smooth (blur) edges before padding. Default: False.
-    smooth_distance:
-    # type=int|default=0: Smoothing distance (in voxels) [default: 4].
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-minc/volpad_callables.py b/example-specs/task/nipype_internal/pydra-minc/volpad_callables.py
deleted file mode 100644
index 2b030cf2..00000000
--- a/example-specs/task/nipype_internal/pydra-minc/volpad_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in Volpad.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-minc/xfm_avg.yaml b/example-specs/task/nipype_internal/pydra-minc/xfm_avg.yaml
deleted file mode 100644
index b9888377..00000000
--- a/example-specs/task/nipype_internal/pydra-minc/xfm_avg.yaml
+++ /dev/null
@@ -1,115 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.minc.minc.XfmAvg' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Average a number of xfm transforms using matrix logs and exponents.
-#     The program xfmavg calls Octave for numerical work.
-# 
-#     This tool is part of the minc-widgets package:
-# 
-#     https://github.com/BIC-MNI/minc-widgets/tree/master/xfmavg
-# 
-#     Examples
-#     --------
-# 
-#     >>> from nipype.interfaces.minc import XfmAvg
-#     >>> from nipype.interfaces.minc.testdata import nonempty_minc_data, nlp_config
-#     >>> from nipype.testing import example_data
-# 
-#     >>> xfm1 = example_data('minc_initial.xfm')
-#     >>> xfm2 = example_data('minc_initial.xfm')  # cheating for doctest
-#     >>> xfmavg = XfmAvg(input_files=[xfm1, xfm2])
-#     >>> xfmavg.run() # doctest: +SKIP
-#     
-task_name: XfmAvg
-nipype_name: XfmAvg
-nipype_module: nipype.interfaces.minc.minc
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    input_files: generic/file+list-of
-    # type=inputmultiobject|default=[]: input file(s)
-    input_grid_files: generic/file+list-of
-    # type=inputmultiobject|default=[]: input grid file(s)
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    output_file: generic/file
-    # type=file: output file
-    # type=file|default=<undefined>: output file
-    output_grid: generic/file
-    # type=file: output grid file
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    output_file: output_file
-    # type=file: output file
-    # type=file|default=<undefined>: output file
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    input_files:
-    # type=inputmultiobject|default=[]: input file(s)
-    input_grid_files:
-    # type=inputmultiobject|default=[]: input grid file(s)
-    output_file:
-    # type=file: output file
-    # type=file|default=<undefined>: output file
-    verbose:
-    # type=bool|default=False: Print out log messages. Default: False.
-    clobber:
-    # type=bool|default=True: Overwrite existing file.
-    avg_linear:
-    # type=bool|default=False: average the linear part [default].
-    avg_nonlinear:
-    # type=bool|default=False: average the non-linear part [default].
-    ignore_linear:
-    # type=bool|default=False: opposite of -avg_linear.
-    ignore_nonlinear:
-    # type=bool|default=False: opposite of -avg_nonlinear.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-minc/xfm_avg_callables.py b/example-specs/task/nipype_internal/pydra-minc/xfm_avg_callables.py
deleted file mode 100644
index faeaef89..00000000
--- a/example-specs/task/nipype_internal/pydra-minc/xfm_avg_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in XfmAvg.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-minc/xfm_concat.yaml b/example-specs/task/nipype_internal/pydra-minc/xfm_concat.yaml
deleted file mode 100644
index 296082f2..00000000
--- a/example-specs/task/nipype_internal/pydra-minc/xfm_concat.yaml
+++ /dev/null
@@ -1,98 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.minc.minc.XfmConcat' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Concatenate transforms together. The output transformation
-#     is equivalent to applying input1.xfm, then input2.xfm, ..., in
-#     that order.
-# 
-#     Examples
-#     --------
-# 
-#     >>> from nipype.interfaces.minc import XfmConcat
-#     >>> from nipype.interfaces.minc.testdata import minc2Dfile
-#     >>> conc = XfmConcat(input_files=['input1.xfm', 'input1.xfm'])
-#     >>> conc.run() # doctest: +SKIP
-#     
-task_name: XfmConcat
-nipype_name: XfmConcat
-nipype_module: nipype.interfaces.minc.minc
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    input_files: generic/file+list-of
-    # type=inputmultiobject|default=[]: input file(s)
-    input_grid_files: generic/file+list-of
-    # type=inputmultiobject|default=[]: input grid file(s)
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    output_file: generic/file
-    # type=file: output file
-    # type=file|default=<undefined>: output file
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    output_file: output_file
-    # type=file: output file
-    # type=file|default=<undefined>: output file
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    input_files:
-    # type=inputmultiobject|default=[]: input file(s)
-    input_grid_files:
-    # type=inputmultiobject|default=[]: input grid file(s)
-    output_file:
-    # type=file: output file
-    # type=file|default=<undefined>: output file
-    verbose:
-    # type=bool|default=False: Print out log messages. Default: False.
-    clobber:
-    # type=bool|default=True: Overwrite existing file.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-minc/xfm_concat_callables.py b/example-specs/task/nipype_internal/pydra-minc/xfm_concat_callables.py
deleted file mode 100644
index 6d82e185..00000000
--- a/example-specs/task/nipype_internal/pydra-minc/xfm_concat_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in XfmConcat.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-minc/xfm_invert.yaml b/example-specs/task/nipype_internal/pydra-minc/xfm_invert.yaml
deleted file mode 100644
index d678e5ae..00000000
--- a/example-specs/task/nipype_internal/pydra-minc/xfm_invert.yaml
+++ /dev/null
@@ -1,96 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.minc.minc.XfmInvert' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Invert an xfm transform file.
-# 
-#     Examples
-#     --------
-# 
-#     >>> from nipype.interfaces.minc import XfmAvg
-#     >>> from nipype.testing import example_data
-# 
-#     >>> xfm = example_data('minc_initial.xfm')
-#     >>> invert = XfmInvert(input_file=xfm)
-#     >>> invert.run() # doctest: +SKIP
-#     
-task_name: XfmInvert
-nipype_name: XfmInvert
-nipype_module: nipype.interfaces.minc.minc
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    input_file: generic/file
-    # type=file|default=<undefined>: input file
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    output_file: generic/file
-    # type=file: output file
-    # type=file|default=<undefined>: output file
-    output_grid: generic/file
-    # type=file: output grid file
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    output_file: output_file
-    # type=file: output file
-    # type=file|default=<undefined>: output file
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    input_file:
-    # type=file|default=<undefined>: input file
-    output_file:
-    # type=file: output file
-    # type=file|default=<undefined>: output file
-    verbose:
-    # type=bool|default=False: Print out log messages. Default: False.
-    clobber:
-    # type=bool|default=True: Overwrite existing file.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-minc/xfm_invert_callables.py b/example-specs/task/nipype_internal/pydra-minc/xfm_invert_callables.py
deleted file mode 100644
index ae791175..00000000
--- a/example-specs/task/nipype_internal/pydra-minc/xfm_invert_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in XfmInvert.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-mipav/jist_brain_mgdm_segmentation.yaml b/example-specs/task/nipype_internal/pydra-mipav/jist_brain_mgdm_segmentation.yaml
deleted file mode 100644
index 0cd441b6..00000000
--- a/example-specs/task/nipype_internal/pydra-mipav/jist_brain_mgdm_segmentation.yaml
+++ /dev/null
@@ -1,146 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.mipav.developer.JistBrainMgdmSegmentation' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# MGDM Whole Brain Segmentation.
-# 
-#     Estimate brain structures from an atlas for a MRI dataset (multiple input combinations
-#     are possible).
-# 
-#     
-task_name: JistBrainMgdmSegmentation
-nipype_name: JistBrainMgdmSegmentation
-nipype_module: nipype.interfaces.mipav.developer
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inMP2RAGE: generic/file
-    # type=file|default=<undefined>: MP2RAGE T1 Map Image
-    inMP2RAGE2: generic/file
-    # type=file|default=<undefined>: MP2RAGE T1-weighted Image
-    inPV: generic/file
-    # type=file|default=<undefined>: PV / Dura Image
-    inMPRAGE: generic/file
-    # type=file|default=<undefined>: MPRAGE T1-weighted Image
-    inFLAIR: generic/file
-    # type=file|default=<undefined>: FLAIR Image
-    inAtlas: generic/file
-    # type=file|default=<undefined>: Atlas file
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outSegmented: generic/file
-    # type=file: Segmented Brain Image
-    # type=traitcompound|default=None: Segmented Brain Image
-    outLevelset: generic/file
-    # type=file: Levelset Boundary Image
-    # type=traitcompound|default=None: Levelset Boundary Image
-    outPosterior2: generic/file
-    # type=file: Posterior Maximum Memberships (4D)
-    # type=traitcompound|default=None: Posterior Maximum Memberships (4D)
-    outPosterior3: generic/file
-    # type=file: Posterior Maximum Labels (4D)
-    # type=traitcompound|default=None: Posterior Maximum Labels (4D)
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inMP2RAGE:
-    # type=file|default=<undefined>: MP2RAGE T1 Map Image
-    inMP2RAGE2:
-    # type=file|default=<undefined>: MP2RAGE T1-weighted Image
-    inPV:
-    # type=file|default=<undefined>: PV / Dura Image
-    inMPRAGE:
-    # type=file|default=<undefined>: MPRAGE T1-weighted Image
-    inFLAIR:
-    # type=file|default=<undefined>: FLAIR Image
-    inAtlas:
-    # type=file|default=<undefined>: Atlas file
-    inData:
-    # type=float|default=0.0: Data weight
-    inCurvature:
-    # type=float|default=0.0: Curvature weight
-    inPosterior:
-    # type=float|default=0.0: Posterior scale (mm)
-    inMax:
-    # type=int|default=0: Max iterations
-    inMin:
-    # type=float|default=0.0: Min change
-    inSteps:
-    # type=int|default=0: Steps
-    inTopology:
-    # type=enum|default='26/6'|allowed['18/6','26/6','6/18','6/26','6/6','no','wco','wcs']: Topology
-    inCompute:
-    # type=enum|default='true'|allowed['false','true']: Compute posteriors
-    inAdjust:
-    # type=enum|default='true'|allowed['false','true']: Adjust intensity priors
-    inOutput:
-    # type=enum|default='segmentation'|allowed['memberships','segmentation']: Output images
-    xPrefExt:
-    # type=enum|default='nrrd'|allowed['nrrd']: Output File Type
-    outSegmented:
-    # type=file: Segmented Brain Image
-    # type=traitcompound|default=None: Segmented Brain Image
-    outLevelset:
-    # type=file: Levelset Boundary Image
-    # type=traitcompound|default=None: Levelset Boundary Image
-    outPosterior2:
-    # type=file: Posterior Maximum Memberships (4D)
-    # type=traitcompound|default=None: Posterior Maximum Memberships (4D)
-    outPosterior3:
-    # type=file: Posterior Maximum Labels (4D)
-    # type=traitcompound|default=None: Posterior Maximum Labels (4D)
-    'null':
-    xDefaultMem:
-    # type=int|default=0: Set default maximum heap size
-    xMaxProcess:
-    # type=int|default=1: Set default maximum number of processes.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-mipav/jist_brain_mgdm_segmentation_callables.py b/example-specs/task/nipype_internal/pydra-mipav/jist_brain_mgdm_segmentation_callables.py
deleted file mode 100644
index 0f2f5f0c..00000000
--- a/example-specs/task/nipype_internal/pydra-mipav/jist_brain_mgdm_segmentation_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in JistBrainMgdmSegmentation.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-mipav/jist_brain_mp_2rage_dura_estimation.yaml b/example-specs/task/nipype_internal/pydra-mipav/jist_brain_mp_2rage_dura_estimation.yaml
deleted file mode 100644
index 9e2fa684..00000000
--- a/example-specs/task/nipype_internal/pydra-mipav/jist_brain_mp_2rage_dura_estimation.yaml
+++ /dev/null
@@ -1,91 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.mipav.developer.JistBrainMp2rageDuraEstimation' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Filters a MP2RAGE brain image to obtain a probability map of dura matter.
-task_name: JistBrainMp2rageDuraEstimation
-nipype_name: JistBrainMp2rageDuraEstimation
-nipype_module: nipype.interfaces.mipav.developer
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inSecond: generic/file
-    # type=file|default=<undefined>: Second inversion (Inv2) Image
-    inSkull: generic/file
-    # type=file|default=<undefined>: Skull Stripping Mask
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outDura: generic/file
-    # type=file: Dura Image
-    # type=traitcompound|default=None: Dura Image
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inSecond:
-    # type=file|default=<undefined>: Second inversion (Inv2) Image
-    inSkull:
-    # type=file|default=<undefined>: Skull Stripping Mask
-    inDistance:
-    # type=float|default=0.0: Distance to background (mm)
-    inoutput:
-    # type=enum|default='dura_region'|allowed['bg_prior','boundary','dura_prior','dura_region','intens_prior']: Outputs an estimate of the dura / CSF boundary or an estimate of the entire dura region.
-    xPrefExt:
-    # type=enum|default='nrrd'|allowed['nrrd']: Output File Type
-    outDura:
-    # type=file: Dura Image
-    # type=traitcompound|default=None: Dura Image
-    'null':
-    xDefaultMem:
-    # type=int|default=0: Set default maximum heap size
-    xMaxProcess:
-    # type=int|default=1: Set default maximum number of processes.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-mipav/jist_brain_mp_2rage_dura_estimation_callables.py b/example-specs/task/nipype_internal/pydra-mipav/jist_brain_mp_2rage_dura_estimation_callables.py
deleted file mode 100644
index a3beeabd..00000000
--- a/example-specs/task/nipype_internal/pydra-mipav/jist_brain_mp_2rage_dura_estimation_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in JistBrainMp2rageDuraEstimation.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-mipav/jist_brain_mp_2rage_skull_stripping.yaml b/example-specs/task/nipype_internal/pydra-mipav/jist_brain_mp_2rage_skull_stripping.yaml
deleted file mode 100644
index 3aa2c5bf..00000000
--- a/example-specs/task/nipype_internal/pydra-mipav/jist_brain_mp_2rage_skull_stripping.yaml
+++ /dev/null
@@ -1,119 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.mipav.developer.JistBrainMp2rageSkullStripping' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Estimate a brain mask for a MP2RAGE dataset.
-# 
-#     At least a T1-weighted or a T1 map image is required.
-# 
-#     
-task_name: JistBrainMp2rageSkullStripping
-nipype_name: JistBrainMp2rageSkullStripping
-nipype_module: nipype.interfaces.mipav.developer
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inSecond: generic/file
-    # type=file|default=<undefined>: Second inversion (Inv2) Image
-    inT1: generic/file
-    # type=file|default=<undefined>: T1 Map (T1_Images) Image (opt)
-    inT1weighted: generic/file
-    # type=file|default=<undefined>: T1-weighted (UNI) Image (opt)
-    inFilter: generic/file
-    # type=file|default=<undefined>: Filter Image (opt)
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outBrain: generic/file
-    # type=file: Brain Mask Image
-    # type=traitcompound|default=None: Brain Mask Image
-    outMasked: generic/file
-    # type=file: Masked T1 Map Image
-    # type=traitcompound|default=None: Masked T1 Map Image
-    outMasked2: generic/file
-    # type=file: Masked T1-weighted Image
-    # type=traitcompound|default=None: Masked T1-weighted Image
-    outMasked3: generic/file
-    # type=file: Masked Filter Image
-    # type=traitcompound|default=None: Masked Filter Image
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inSecond:
-    # type=file|default=<undefined>: Second inversion (Inv2) Image
-    inT1:
-    # type=file|default=<undefined>: T1 Map (T1_Images) Image (opt)
-    inT1weighted:
-    # type=file|default=<undefined>: T1-weighted (UNI) Image (opt)
-    inFilter:
-    # type=file|default=<undefined>: Filter Image (opt)
-    inSkip:
-    # type=enum|default='true'|allowed['false','true']: Skip zero values
-    xPrefExt:
-    # type=enum|default='nrrd'|allowed['nrrd']: Output File Type
-    outBrain:
-    # type=file: Brain Mask Image
-    # type=traitcompound|default=None: Brain Mask Image
-    outMasked:
-    # type=file: Masked T1 Map Image
-    # type=traitcompound|default=None: Masked T1 Map Image
-    outMasked2:
-    # type=file: Masked T1-weighted Image
-    # type=traitcompound|default=None: Masked T1-weighted Image
-    outMasked3:
-    # type=file: Masked Filter Image
-    # type=traitcompound|default=None: Masked Filter Image
-    'null':
-    xDefaultMem:
-    # type=int|default=0: Set default maximum heap size
-    xMaxProcess:
-    # type=int|default=1: Set default maximum number of processes.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-mipav/jist_brain_mp_2rage_skull_stripping_callables.py b/example-specs/task/nipype_internal/pydra-mipav/jist_brain_mp_2rage_skull_stripping_callables.py
deleted file mode 100644
index 57e2a32c..00000000
--- a/example-specs/task/nipype_internal/pydra-mipav/jist_brain_mp_2rage_skull_stripping_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in JistBrainMp2rageSkullStripping.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-mipav/jist_brain_partial_volume_filter.yaml b/example-specs/task/nipype_internal/pydra-mipav/jist_brain_partial_volume_filter.yaml
deleted file mode 100644
index 2ad84577..00000000
--- a/example-specs/task/nipype_internal/pydra-mipav/jist_brain_partial_volume_filter.yaml
+++ /dev/null
@@ -1,91 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.mipav.developer.JistBrainPartialVolumeFilter' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Partial Volume Filter.
-# 
-#     Filters an image for regions of partial voluming assuming a ridge-like model of intensity.
-# 
-#     
-task_name: JistBrainPartialVolumeFilter
-nipype_name: JistBrainPartialVolumeFilter
-nipype_module: nipype.interfaces.mipav.developer
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inInput: generic/file
-    # type=file|default=<undefined>: Input Image
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outPartial: generic/file
-    # type=file: Partial Volume Image
-    # type=traitcompound|default=None: Partial Volume Image
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inInput:
-    # type=file|default=<undefined>: Input Image
-    inPV:
-    # type=enum|default='bright'|allowed['both','bright','dark']: Outputs the raw intensity values or a probability score for the partial volume regions.
-    inoutput:
-    # type=enum|default='probability'|allowed['intensity','probability']: output
-    xPrefExt:
-    # type=enum|default='nrrd'|allowed['nrrd']: Output File Type
-    outPartial:
-    # type=file: Partial Volume Image
-    # type=traitcompound|default=None: Partial Volume Image
-    'null':
-    xDefaultMem:
-    # type=int|default=0: Set default maximum heap size
-    xMaxProcess:
-    # type=int|default=1: Set default maximum number of processes.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-mipav/jist_brain_partial_volume_filter_callables.py b/example-specs/task/nipype_internal/pydra-mipav/jist_brain_partial_volume_filter_callables.py
deleted file mode 100644
index c76b15e1..00000000
--- a/example-specs/task/nipype_internal/pydra-mipav/jist_brain_partial_volume_filter_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in JistBrainPartialVolumeFilter.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-mipav/jist_cortex_surface_mesh_inflation.yaml b/example-specs/task/nipype_internal/pydra-mipav/jist_cortex_surface_mesh_inflation.yaml
deleted file mode 100644
index f7bf1588..00000000
--- a/example-specs/task/nipype_internal/pydra-mipav/jist_cortex_surface_mesh_inflation.yaml
+++ /dev/null
@@ -1,108 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.mipav.developer.JistCortexSurfaceMeshInflation' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Inflates a cortical surface mesh.
-# 
-#     References
-#     ----------
-#     D. Tosun, M. E. Rettmann, X. Han, X. Tao, C. Xu, S. M. Resnick, D. Pham, and J. L. Prince,
-#     Cortical Surface Segmentation and Mapping, NeuroImage, vol. 23, pp. S108--S118, 2004.
-# 
-#     
-task_name: JistCortexSurfaceMeshInflation
-nipype_name: JistCortexSurfaceMeshInflation
-nipype_module: nipype.interfaces.mipav.developer
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inLevelset: generic/file
-    # type=file|default=<undefined>: Levelset Image
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outOriginal: generic/file
-    # type=file: Original Surface
-    # type=traitcompound|default=None: Original Surface
-    outInflated: generic/file
-    # type=file: Inflated Surface
-    # type=traitcompound|default=None: Inflated Surface
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inLevelset:
-    # type=file|default=<undefined>: Levelset Image
-    inSOR:
-    # type=float|default=0.0: SOR Parameter
-    inMean:
-    # type=float|default=0.0: Mean Curvature Threshold
-    inStep:
-    # type=int|default=0: Step Size
-    inMax:
-    # type=int|default=0: Max Iterations
-    inLorentzian:
-    # type=enum|default='true'|allowed['false','true']: Lorentzian Norm
-    inTopology:
-    # type=enum|default='26/6'|allowed['18/6','26/6','6/18','6/26','6/6','no','wco','wcs']: Topology
-    xPrefExt:
-    # type=enum|default='nrrd'|allowed['nrrd']: Output File Type
-    outOriginal:
-    # type=file: Original Surface
-    # type=traitcompound|default=None: Original Surface
-    outInflated:
-    # type=file: Inflated Surface
-    # type=traitcompound|default=None: Inflated Surface
-    'null':
-    xDefaultMem:
-    # type=int|default=0: Set default maximum heap size
-    xMaxProcess:
-    # type=int|default=1: Set default maximum number of processes.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-mipav/jist_cortex_surface_mesh_inflation_callables.py b/example-specs/task/nipype_internal/pydra-mipav/jist_cortex_surface_mesh_inflation_callables.py
deleted file mode 100644
index 21aa8fe4..00000000
--- a/example-specs/task/nipype_internal/pydra-mipav/jist_cortex_surface_mesh_inflation_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in JistCortexSurfaceMeshInflation.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-mipav/jist_intensity_mp_2rage_masking.yaml b/example-specs/task/nipype_internal/pydra-mipav/jist_intensity_mp_2rage_masking.yaml
deleted file mode 100644
index 987b914b..00000000
--- a/example-specs/task/nipype_internal/pydra-mipav/jist_intensity_mp_2rage_masking.yaml
+++ /dev/null
@@ -1,115 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.mipav.developer.JistIntensityMp2rageMasking' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Estimate a background signal mask for a MP2RAGE dataset.
-task_name: JistIntensityMp2rageMasking
-nipype_name: JistIntensityMp2rageMasking
-nipype_module: nipype.interfaces.mipav.developer
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inSecond: generic/file
-    # type=file|default=<undefined>: Second inversion (Inv2) Image
-    inQuantitative: generic/file
-    # type=file|default=<undefined>: Quantitative T1 Map (T1_Images) Image
-    inT1weighted: generic/file
-    # type=file|default=<undefined>: T1-weighted (UNI) Image
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outSignal: generic/file
-    # type=file: Signal Proba Image
-    # type=traitcompound|default=None: Signal Proba Image
-    outSignal2: generic/file
-    # type=file: Signal Mask Image
-    # type=traitcompound|default=None: Signal Mask Image
-    outMasked: generic/file
-    # type=file: Masked T1 Map Image
-    # type=traitcompound|default=None: Masked T1 Map Image
-    outMasked2: generic/file
-    # type=file: Masked Iso Image
-    # type=traitcompound|default=None: Masked Iso Image
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inSecond:
-    # type=file|default=<undefined>: Second inversion (Inv2) Image
-    inQuantitative:
-    # type=file|default=<undefined>: Quantitative T1 Map (T1_Images) Image
-    inT1weighted:
-    # type=file|default=<undefined>: T1-weighted (UNI) Image
-    inBackground:
-    # type=enum|default='exponential'|allowed['exponential','half-normal']: Model distribution for background noise (default is half-normal, exponential is more stringent).
-    inSkip:
-    # type=enum|default='true'|allowed['false','true']: Skip zero values
-    inMasking:
-    # type=enum|default='binary'|allowed['binary','proba']: Whether to use a binary threshold or a weighted average based on the probability.
-    xPrefExt:
-    # type=enum|default='nrrd'|allowed['nrrd']: Output File Type
-    outSignal:
-    # type=file: Signal Proba Image
-    # type=traitcompound|default=None: Signal Proba Image
-    outSignal2:
-    # type=file: Signal Mask Image
-    # type=traitcompound|default=None: Signal Mask Image
-    outMasked:
-    # type=file: Masked T1 Map Image
-    # type=traitcompound|default=None: Masked T1 Map Image
-    outMasked2:
-    # type=file: Masked Iso Image
-    # type=traitcompound|default=None: Masked Iso Image
-    'null':
-    xDefaultMem:
-    # type=int|default=0: Set default maximum heap size
-    xMaxProcess:
-    # type=int|default=1: Set default maximum number of processes.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-mipav/jist_intensity_mp_2rage_masking_callables.py b/example-specs/task/nipype_internal/pydra-mipav/jist_intensity_mp_2rage_masking_callables.py
deleted file mode 100644
index 4d895704..00000000
--- a/example-specs/task/nipype_internal/pydra-mipav/jist_intensity_mp_2rage_masking_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in JistIntensityMp2rageMasking.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-mipav/jist_laminar_profile_calculator.yaml b/example-specs/task/nipype_internal/pydra-mipav/jist_laminar_profile_calculator.yaml
deleted file mode 100644
index bf92bdd8..00000000
--- a/example-specs/task/nipype_internal/pydra-mipav/jist_laminar_profile_calculator.yaml
+++ /dev/null
@@ -1,89 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.mipav.developer.JistLaminarProfileCalculator' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Compute various moments for intensities mapped along a cortical profile.
-task_name: JistLaminarProfileCalculator
-nipype_name: JistLaminarProfileCalculator
-nipype_module: nipype.interfaces.mipav.developer
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inIntensity: generic/file
-    # type=file|default=<undefined>: Intensity Profile Image
-    inMask: generic/file
-    # type=file|default=<undefined>: Mask Image (opt, 3D or 4D)
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outResult: generic/file
-    # type=file: Result
-    # type=traitcompound|default=None: Result
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inIntensity:
-    # type=file|default=<undefined>: Intensity Profile Image
-    inMask:
-    # type=file|default=<undefined>: Mask Image (opt, 3D or 4D)
-    incomputed:
-    # type=enum|default='mean'|allowed['kurtosis','mean','skewness','stdev']: computed statistic
-    xPrefExt:
-    # type=enum|default='nrrd'|allowed['nrrd']: Output File Type
-    outResult:
-    # type=file: Result
-    # type=traitcompound|default=None: Result
-    'null':
-    xDefaultMem:
-    # type=int|default=0: Set default maximum heap size
-    xMaxProcess:
-    # type=int|default=1: Set default maximum number of processes.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-mipav/jist_laminar_profile_calculator_callables.py b/example-specs/task/nipype_internal/pydra-mipav/jist_laminar_profile_calculator_callables.py
deleted file mode 100644
index 10232179..00000000
--- a/example-specs/task/nipype_internal/pydra-mipav/jist_laminar_profile_calculator_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in JistLaminarProfileCalculator.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-mipav/jist_laminar_profile_geometry.yaml b/example-specs/task/nipype_internal/pydra-mipav/jist_laminar_profile_geometry.yaml
deleted file mode 100644
index 43b64dae..00000000
--- a/example-specs/task/nipype_internal/pydra-mipav/jist_laminar_profile_geometry.yaml
+++ /dev/null
@@ -1,91 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.mipav.developer.JistLaminarProfileGeometry' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Compute various geometric quantities for a cortical layers.
-task_name: JistLaminarProfileGeometry
-nipype_name: JistLaminarProfileGeometry
-nipype_module: nipype.interfaces.mipav.developer
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inProfile: generic/file
-    # type=file|default=<undefined>: Profile Surface Image
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outResult: generic/file
-    # type=file: Result
-    # type=traitcompound|default=None: Result
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inProfile:
-    # type=file|default=<undefined>: Profile Surface Image
-    incomputed:
-    # type=enum|default='thickness'|allowed['curvedness','gauss_curvature','mean_curvature','profile_curvature','profile_length','profile_torsion','shape_index','thickness']: computed measure
-    inregularization:
-    # type=enum|default='none'|allowed['Gaussian','none']: regularization
-    insmoothing:
-    # type=float|default=0.0: smoothing parameter
-    inoutside:
-    # type=float|default=0.0: outside extension (mm)
-    xPrefExt:
-    # type=enum|default='nrrd'|allowed['nrrd']: Output File Type
-    outResult:
-    # type=file: Result
-    # type=traitcompound|default=None: Result
-    'null':
-    xDefaultMem:
-    # type=int|default=0: Set default maximum heap size
-    xMaxProcess:
-    # type=int|default=1: Set default maximum number of processes.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-mipav/jist_laminar_profile_geometry_callables.py b/example-specs/task/nipype_internal/pydra-mipav/jist_laminar_profile_geometry_callables.py
deleted file mode 100644
index 09543349..00000000
--- a/example-specs/task/nipype_internal/pydra-mipav/jist_laminar_profile_geometry_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in JistLaminarProfileGeometry.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-mipav/jist_laminar_profile_sampling.yaml b/example-specs/task/nipype_internal/pydra-mipav/jist_laminar_profile_sampling.yaml
deleted file mode 100644
index f28c442d..00000000
--- a/example-specs/task/nipype_internal/pydra-mipav/jist_laminar_profile_sampling.yaml
+++ /dev/null
@@ -1,97 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.mipav.developer.JistLaminarProfileSampling' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Sample some intensity image along a cortical profile across layer surfaces.
-task_name: JistLaminarProfileSampling
-nipype_name: JistLaminarProfileSampling
-nipype_module: nipype.interfaces.mipav.developer
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inProfile: generic/file
-    # type=file|default=<undefined>: Profile Surface Image
-    inIntensity: generic/file
-    # type=file|default=<undefined>: Intensity Image
-    inCortex: generic/file
-    # type=file|default=<undefined>: Cortex Mask (opt)
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outProfilemapped: generic/file
-    # type=file: Profile-mapped Intensity Image
-    # type=traitcompound|default=None: Profile-mapped Intensity Image
-    outProfile2: generic/file
-    # type=file: Profile 4D Mask
-    # type=traitcompound|default=None: Profile 4D Mask
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inProfile:
-    # type=file|default=<undefined>: Profile Surface Image
-    inIntensity:
-    # type=file|default=<undefined>: Intensity Image
-    inCortex:
-    # type=file|default=<undefined>: Cortex Mask (opt)
-    xPrefExt:
-    # type=enum|default='nrrd'|allowed['nrrd']: Output File Type
-    outProfilemapped:
-    # type=file: Profile-mapped Intensity Image
-    # type=traitcompound|default=None: Profile-mapped Intensity Image
-    outProfile2:
-    # type=file: Profile 4D Mask
-    # type=traitcompound|default=None: Profile 4D Mask
-    'null':
-    xDefaultMem:
-    # type=int|default=0: Set default maximum heap size
-    xMaxProcess:
-    # type=int|default=1: Set default maximum number of processes.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-mipav/jist_laminar_profile_sampling_callables.py b/example-specs/task/nipype_internal/pydra-mipav/jist_laminar_profile_sampling_callables.py
deleted file mode 100644
index 821bf7c6..00000000
--- a/example-specs/task/nipype_internal/pydra-mipav/jist_laminar_profile_sampling_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in JistLaminarProfileSampling.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-mipav/jist_laminar_roi_averaging.yaml b/example-specs/task/nipype_internal/pydra-mipav/jist_laminar_roi_averaging.yaml
deleted file mode 100644
index 6a60aa23..00000000
--- a/example-specs/task/nipype_internal/pydra-mipav/jist_laminar_roi_averaging.yaml
+++ /dev/null
@@ -1,93 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.mipav.developer.JistLaminarROIAveraging' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Compute an average profile over a given ROI.
-task_name: JistLaminarROIAveraging
-nipype_name: JistLaminarROIAveraging
-nipype_module: nipype.interfaces.mipav.developer
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inIntensity: generic/file
-    # type=file|default=<undefined>: Intensity Profile Image
-    inROI: generic/file
-    # type=file|default=<undefined>: ROI Mask
-    inMask: generic/file
-    # type=file|default=<undefined>: Mask Image (opt, 3D or 4D)
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outROI3: generic/file
-    # type=file: ROI Average
-    # type=traitcompound|default=None: ROI Average
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inIntensity:
-    # type=file|default=<undefined>: Intensity Profile Image
-    inROI:
-    # type=file|default=<undefined>: ROI Mask
-    inROI2:
-    # type=str|default='': ROI Name
-    inMask:
-    # type=file|default=<undefined>: Mask Image (opt, 3D or 4D)
-    xPrefExt:
-    # type=enum|default='nrrd'|allowed['nrrd']: Output File Type
-    outROI3:
-    # type=file: ROI Average
-    # type=traitcompound|default=None: ROI Average
-    'null':
-    xDefaultMem:
-    # type=int|default=0: Set default maximum heap size
-    xMaxProcess:
-    # type=int|default=1: Set default maximum number of processes.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-mipav/jist_laminar_roi_averaging_callables.py b/example-specs/task/nipype_internal/pydra-mipav/jist_laminar_roi_averaging_callables.py
deleted file mode 100644
index e72f4851..00000000
--- a/example-specs/task/nipype_internal/pydra-mipav/jist_laminar_roi_averaging_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in JistLaminarROIAveraging.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-mipav/jist_laminar_volumetric_layering.yaml b/example-specs/task/nipype_internal/pydra-mipav/jist_laminar_volumetric_layering.yaml
deleted file mode 100644
index d1b5f171..00000000
--- a/example-specs/task/nipype_internal/pydra-mipav/jist_laminar_volumetric_layering.yaml
+++ /dev/null
@@ -1,127 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.mipav.developer.JistLaminarVolumetricLayering' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Volumetric Layering.
-# 
-#     Builds a continuous layering of the cortex following distance-preserving or volume-preserving
-#     models of cortical folding.
-# 
-#     References
-#     ----------
-#     Waehnert MD, Dinse J, Weiss M, Streicher MN, Waehnert P, Geyer S, Turner R, Bazin PL,
-#     Anatomically motivated modeling of cortical laminae, Neuroimage, 2013.
-# 
-#     
-task_name: JistLaminarVolumetricLayering
-nipype_name: JistLaminarVolumetricLayering
-nipype_module: nipype.interfaces.mipav.developer
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inInner: generic/file
-    # type=file|default=<undefined>: Inner Distance Image (GM/WM boundary)
-    inOuter: generic/file
-    # type=file|default=<undefined>: Outer Distance Image (CSF/GM boundary)
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outContinuous: generic/file
-    # type=file: Continuous depth measurement
-    # type=traitcompound|default=None: Continuous depth measurement
-    outDiscrete: generic/file
-    # type=file: Discrete sampled layers
-    # type=traitcompound|default=None: Discrete sampled layers
-    outLayer: generic/file
-    # type=file: Layer boundary surfaces
-    # type=traitcompound|default=None: Layer boundary surfaces
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inInner:
-    # type=file|default=<undefined>: Inner Distance Image (GM/WM boundary)
-    inOuter:
-    # type=file|default=<undefined>: Outer Distance Image (CSF/GM boundary)
-    inNumber:
-    # type=int|default=0: Number of layers
-    inMax:
-    # type=int|default=0: Max iterations for narrow band evolution
-    inMin:
-    # type=float|default=0.0: Min change ratio for narrow band evolution
-    inLayering:
-    # type=enum|default='distance-preserving'|allowed['distance-preserving','volume-preserving']: Layering method
-    inLayering2:
-    # type=enum|default='outward'|allowed['inward','outward']: Layering direction
-    incurvature:
-    # type=int|default=0: curvature approximation scale (voxels)
-    inratio:
-    # type=float|default=0.0: ratio smoothing kernel size (voxels)
-    inpresmooth:
-    # type=enum|default='true'|allowed['false','true']: pre-smooth cortical surfaces
-    inTopology:
-    # type=enum|default='26/6'|allowed['18/6','26/6','6/18','6/26','6/6','no','wco','wcs']: Topology
-    xPrefExt:
-    # type=enum|default='nrrd'|allowed['nrrd']: Output File Type
-    outContinuous:
-    # type=file: Continuous depth measurement
-    # type=traitcompound|default=None: Continuous depth measurement
-    outDiscrete:
-    # type=file: Discrete sampled layers
-    # type=traitcompound|default=None: Discrete sampled layers
-    outLayer:
-    # type=file: Layer boundary surfaces
-    # type=traitcompound|default=None: Layer boundary surfaces
-    'null':
-    xDefaultMem:
-    # type=int|default=0: Set default maximum heap size
-    xMaxProcess:
-    # type=int|default=1: Set default maximum number of processes.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-mipav/jist_laminar_volumetric_layering_callables.py b/example-specs/task/nipype_internal/pydra-mipav/jist_laminar_volumetric_layering_callables.py
deleted file mode 100644
index a57c8d48..00000000
--- a/example-specs/task/nipype_internal/pydra-mipav/jist_laminar_volumetric_layering_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in JistLaminarVolumetricLayering.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_image_calculator.yaml b/example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_image_calculator.yaml
deleted file mode 100644
index 70fe3cbe..00000000
--- a/example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_image_calculator.yaml
+++ /dev/null
@@ -1,93 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.mipav.developer.MedicAlgorithmImageCalculator' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Perform simple image calculator operations on two images.
-# 
-#     The operations include 'Add', 'Subtract', 'Multiply', and 'Divide'
-# 
-#     
-task_name: MedicAlgorithmImageCalculator
-nipype_name: MedicAlgorithmImageCalculator
-nipype_module: nipype.interfaces.mipav.developer
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inVolume: generic/file
-    # type=file|default=<undefined>: Volume 1
-    inVolume2: generic/file
-    # type=file|default=<undefined>: Volume 2
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outResult: generic/file
-    # type=file: Result Volume
-    # type=traitcompound|default=None: Result Volume
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inVolume:
-    # type=file|default=<undefined>: Volume 1
-    inVolume2:
-    # type=file|default=<undefined>: Volume 2
-    inOperation:
-    # type=enum|default='Add'|allowed['Add','Divide','Max','Min','Multiply','Subtract']: Operation
-    xPrefExt:
-    # type=enum|default='nrrd'|allowed['nrrd']: Output File Type
-    outResult:
-    # type=file: Result Volume
-    # type=traitcompound|default=None: Result Volume
-    'null':
-    xDefaultMem:
-    # type=int|default=0: Set default maximum heap size
-    xMaxProcess:
-    # type=int|default=1: Set default maximum number of processes.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_image_calculator_callables.py b/example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_image_calculator_callables.py
deleted file mode 100644
index bb1e2ead..00000000
--- a/example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_image_calculator_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in MedicAlgorithmImageCalculator.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_lesion_toads.yaml b/example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_lesion_toads.yaml
deleted file mode 100644
index 88cf1874..00000000
--- a/example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_lesion_toads.yaml
+++ /dev/null
@@ -1,192 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.mipav.developer.MedicAlgorithmLesionToads' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Algorithm for simultaneous brain structures and MS lesion segmentation of MS Brains.
-# 
-#     The brain segmentation is topologically consistent and the algorithm can use multiple
-#     MR sequences as input data.
-# 
-#     References
-#     ----------
-#     N. Shiee, P.-L. Bazin, A.Z. Ozturk, P.A. Calabresi, D.S. Reich, D.L. Pham,
-#     "A Topology-Preserving Approach to the Segmentation of Brain Images with Multiple Sclerosis",
-#     NeuroImage, vol. 49, no. 2, pp. 1524-1535, 2010.
-# 
-#     
-task_name: MedicAlgorithmLesionToads
-nipype_name: MedicAlgorithmLesionToads
-nipype_module: nipype.interfaces.mipav.developer
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inT1_MPRAGE: generic/file
-    # type=file|default=<undefined>: T1_MPRAGE Image
-    inT1_SPGR: generic/file
-    # type=file|default=<undefined>: T1_SPGR Image
-    inFLAIR: generic/file
-    # type=file|default=<undefined>: FLAIR Image
-    inAtlas2: generic/file
-    # type=file|default=<undefined>: Atlas File - With Lesions
-    inAtlas3: generic/file
-    # type=file|default=<undefined>: Atlas File - No Lesion - T1 and FLAIR
-    inAtlas4: generic/file
-    # type=file|default=<undefined>: Atlas File - No Lesion - T1 Only
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outHard: generic/file
-    # type=file: Hard segmentation
-    # type=traitcompound|default=None: Hard segmentation
-    outHard2: generic/file
-    # type=file: Hard segmentationfrom memberships
-    # type=traitcompound|default=None: Hard segmentationfrom memberships
-    outInhomogeneity: generic/file
-    # type=file: Inhomogeneity Field
-    # type=traitcompound|default=None: Inhomogeneity Field
-    outMembership: generic/file
-    # type=file: Membership Functions
-    # type=traitcompound|default=None: Membership Functions
-    outLesion: generic/file
-    # type=file: Lesion Segmentation
-    # type=traitcompound|default=None: Lesion Segmentation
-    outSulcal: generic/file
-    # type=file: Sulcal CSF Membership
-    # type=traitcompound|default=None: Sulcal CSF Membership
-    outCortical: generic/file
-    # type=file: Cortical GM Membership
-    # type=traitcompound|default=None: Cortical GM Membership
-    outFilled: generic/file
-    # type=file: Filled WM Membership
-    # type=traitcompound|default=None: Filled WM Membership
-    outWM: generic/file
-    # type=file: WM Mask
-    # type=traitcompound|default=None: WM Mask
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inT1_MPRAGE:
-    # type=file|default=<undefined>: T1_MPRAGE Image
-    inT1_SPGR:
-    # type=file|default=<undefined>: T1_SPGR Image
-    inFLAIR:
-    # type=file|default=<undefined>: FLAIR Image
-    inAtlas:
-    # type=enum|default='With Lesion'|allowed['No Lesion','With Lesion']: Atlas to Use
-    inOutput:
-    # type=enum|default='hard segmentation'|allowed['cruise inputs','dura removal inputs','hard segmentation','hard segmentation+memberships']: Output images
-    inOutput2:
-    # type=enum|default='true'|allowed['false','true']: Output the hard classification using maximum membership (not neceesarily topologically correct)
-    inCorrect:
-    # type=enum|default='true'|allowed['false','true']: Correct MR field inhomogeneity.
-    inOutput3:
-    # type=enum|default='true'|allowed['false','true']: Output the estimated inhomogeneity field
-    inAtlas2:
-    # type=file|default=<undefined>: Atlas File - With Lesions
-    inAtlas3:
-    # type=file|default=<undefined>: Atlas File - No Lesion - T1 and FLAIR
-    inAtlas4:
-    # type=file|default=<undefined>: Atlas File - No Lesion - T1 Only
-    inMaximum:
-    # type=int|default=0: Maximum distance from the interventricular WM boundary to downweight the lesion membership to avoid false positives
-    inMaximum2:
-    # type=int|default=0: Maximum Ventircle Distance
-    inMaximum3:
-    # type=int|default=0: Maximum InterVentricular Distance
-    inInclude:
-    # type=enum|default='true'|allowed['false','true']: Include lesion in WM class in hard classification
-    inAtlas5:
-    # type=float|default=0.0: Controls the effect of the statistical atlas on the segmentation
-    inSmooting:
-    # type=float|default=0.0: Controls the effect of neighborhood voxels on the membership
-    inMaximum4:
-    # type=float|default=0.0: Maximum amount of relative change in the energy function considered as the convergence criteria
-    inMaximum5:
-    # type=int|default=0: Maximum iterations
-    inAtlas6:
-    # type=enum|default='rigid'|allowed['multi_fully_affine','rigid']: Atlas alignment
-    inConnectivity:
-    # type=enum|default='(26,6)'|allowed['(18,6)','(26,6)','(6,18)','(6,26)']: Connectivity (foreground,background)
-    xPrefExt:
-    # type=enum|default='nrrd'|allowed['nrrd']: Output File Type
-    outHard:
-    # type=file: Hard segmentation
-    # type=traitcompound|default=None: Hard segmentation
-    outHard2:
-    # type=file: Hard segmentationfrom memberships
-    # type=traitcompound|default=None: Hard segmentationfrom memberships
-    outInhomogeneity:
-    # type=file: Inhomogeneity Field
-    # type=traitcompound|default=None: Inhomogeneity Field
-    outMembership:
-    # type=file: Membership Functions
-    # type=traitcompound|default=None: Membership Functions
-    outLesion:
-    # type=file: Lesion Segmentation
-    # type=traitcompound|default=None: Lesion Segmentation
-    outSulcal:
-    # type=file: Sulcal CSF Membership
-    # type=traitcompound|default=None: Sulcal CSF Membership
-    outCortical:
-    # type=file: Cortical GM Membership
-    # type=traitcompound|default=None: Cortical GM Membership
-    outFilled:
-    # type=file: Filled WM Membership
-    # type=traitcompound|default=None: Filled WM Membership
-    outWM:
-    # type=file: WM Mask
-    # type=traitcompound|default=None: WM Mask
-    'null':
-    xDefaultMem:
-    # type=int|default=0: Set default maximum heap size
-    xMaxProcess:
-    # type=int|default=1: Set default maximum number of processes.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_lesion_toads_callables.py b/example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_lesion_toads_callables.py
deleted file mode 100644
index aed440ed..00000000
--- a/example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_lesion_toads_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in MedicAlgorithmLesionToads.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_mipav_reorient.yaml b/example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_mipav_reorient.yaml
deleted file mode 100644
index b5b5ed75..00000000
--- a/example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_mipav_reorient.yaml
+++ /dev/null
@@ -1,99 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.mipav.developer.MedicAlgorithmMipavReorient' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Reorient a volume to a particular anatomical orientation.
-task_name: MedicAlgorithmMipavReorient
-nipype_name: MedicAlgorithmMipavReorient
-nipype_module: nipype.interfaces.mipav.developer
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inSource: generic/file+list-of
-    # type=inputmultiobject|default=[]: Source
-    inTemplate: generic/file
-    # type=file|default=<undefined>: Template
-    outReoriented: generic/file+list-of
-    # type=inputmultiobject|default=[]: Reoriented Volume
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inSource:
-    # type=inputmultiobject|default=[]: Source
-    inTemplate:
-    # type=file|default=<undefined>: Template
-    inNew:
-    # type=enum|default='Dicom axial'|allowed['Dicom axial','Dicom coronal','Dicom sagittal','User defined']: New image orientation
-    inUser:
-    # type=enum|default='Unknown'|allowed['Patient Anterior to Posterior','Patient Inferior to Superior','Patient Left to Right','Patient Posterior to Anterior','Patient Right to Left','Patient Superior to Inferior','Unknown']: User defined X-axis orientation (image left to right)
-    inUser2:
-    # type=enum|default='Unknown'|allowed['Patient Anterior to Posterior','Patient Inferior to Superior','Patient Left to Right','Patient Posterior to Anterior','Patient Right to Left','Patient Superior to Inferior','Unknown']: User defined Y-axis orientation (image top to bottom)
-    inUser3:
-    # type=enum|default='Unknown'|allowed['Patient Anterior to Posterior','Patient Inferior to Superior','Patient Left to Right','Patient Posterior to Anterior','Patient Right to Left','Patient Superior to Inferior','Unknown']: User defined Z-axis orientation (into the screen)
-    inUser4:
-    # type=enum|default='Axial'|allowed['Axial','Coronal','Sagittal','Unknown']: User defined Image Orientation
-    inInterpolation:
-    # type=enum|default='Nearest Neighbor'|allowed['Bspline 3rd order','Bspline 4th order','Cubic Lagrangian','Heptic Lagrangian','Nearest Neighbor','Quintic Lagrangian','Trilinear','Windowed Sinc']: Interpolation
-    inResolution:
-    # type=enum|default='Unchanged'|allowed['Coarsest cubic','Finest cubic','Same as template','Unchanged']: Resolution
-    xPrefExt:
-    # type=enum|default='nrrd'|allowed['nrrd']: Output File Type
-    outReoriented:
-    # type=inputmultiobject|default=[]: Reoriented Volume
-    'null':
-    xDefaultMem:
-    # type=int|default=0: Set default maximum heap size
-    xMaxProcess:
-    # type=int|default=1: Set default maximum number of processes.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_mipav_reorient_callables.py b/example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_mipav_reorient_callables.py
deleted file mode 100644
index e1ad5c91..00000000
--- a/example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_mipav_reorient_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in MedicAlgorithmMipavReorient.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_n3.yaml b/example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_n3.yaml
deleted file mode 100644
index 8bb04dfa..00000000
--- a/example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_n3.yaml
+++ /dev/null
@@ -1,105 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.mipav.developer.MedicAlgorithmN3' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Non-parametric Intensity Non-uniformity Correction, N3, originally by J.G. Sled.
-task_name: MedicAlgorithmN3
-nipype_name: MedicAlgorithmN3
-nipype_module: nipype.interfaces.mipav.developer
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inInput: generic/file
-    # type=file|default=<undefined>: Input Volume
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outInhomogeneity: generic/file
-    # type=file: Inhomogeneity Corrected Volume
-    # type=traitcompound|default=None: Inhomogeneity Corrected Volume
-    outInhomogeneity2: generic/file
-    # type=file: Inhomogeneity Field
-    # type=traitcompound|default=None: Inhomogeneity Field
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inInput:
-    # type=file|default=<undefined>: Input Volume
-    inSignal:
-    # type=float|default=0.0: Default = min + 1, Values at less than threshold are treated as part of the background
-    inMaximum:
-    # type=int|default=0: Maximum number of Iterations
-    inEnd:
-    # type=float|default=0.0: Usually 0.01-0.00001, The measure used to terminate the iterations is the coefficient of variation of change in field estimates between successive iterations.
-    inField:
-    # type=float|default=0.0: Characteristic distance over which the field varies. The distance between adjacent knots in bspline fitting with at least 4 knots going in every dimension. The default in the dialog is one third the distance (resolution * extents) of the smallest dimension.
-    inSubsample:
-    # type=float|default=0.0: Usually between 1-32, The factor by which the data is subsampled to a lower resolution in estimating the slowly varying non-uniformity field. Reduce sampling in the finest sampling direction by the shrink factor.
-    inKernel:
-    # type=float|default=0.0: Usually between 0.05-0.50, Width of deconvolution kernel used to sharpen the histogram. Larger values give faster convergence while smaller values give greater accuracy.
-    inWeiner:
-    # type=float|default=0.0: Usually between 0.0-1.0
-    inAutomatic:
-    # type=enum|default='true'|allowed['false','true']: If true determines the threshold by histogram analysis. If true a VOI cannot be used and the input threshold is ignored.
-    xPrefExt:
-    # type=enum|default='nrrd'|allowed['nrrd']: Output File Type
-    outInhomogeneity:
-    # type=file: Inhomogeneity Corrected Volume
-    # type=traitcompound|default=None: Inhomogeneity Corrected Volume
-    outInhomogeneity2:
-    # type=file: Inhomogeneity Field
-    # type=traitcompound|default=None: Inhomogeneity Field
-    'null':
-    xDefaultMem:
-    # type=int|default=0: Set default maximum heap size
-    xMaxProcess:
-    # type=int|default=1: Set default maximum number of processes.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_n3_callables.py b/example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_n3_callables.py
deleted file mode 100644
index d950ae80..00000000
--- a/example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_n3_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in MedicAlgorithmN3.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_spectre2010.yaml b/example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_spectre2010.yaml
deleted file mode 100644
index 40c1680c..00000000
--- a/example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_spectre2010.yaml
+++ /dev/null
@@ -1,212 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.mipav.developer.MedicAlgorithmSPECTRE2010' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# SPECTRE 2010: Simple Paradigm for Extra-Cranial Tissue REmoval [1]_, [2]_.
-# 
-#     References
-#     ----------
-# 
-#     .. [1] A. Carass, M.B. Wheeler, J. Cuzzocreo, P.-L. Bazin, S.S. Bassett, and J.L. Prince,
-#            'A Joint Registration and Segmentation Approach to Skull Stripping',
-#            Fourth IEEE International Symposium on Biomedical Imaging (ISBI 2007), Arlington, VA,
-#            April 12-15, 2007.
-#     .. [2] A. Carass, J. Cuzzocreo, M.B. Wheeler, P.-L. Bazin, S.M. Resnick, and J.L. Prince,
-#            'Simple paradigm for extra-cerebral tissue removal: Algorithm and analysis',
-#            NeuroImage 56(4):1982-1992, 2011.
-# 
-#     
-task_name: MedicAlgorithmSPECTRE2010
-nipype_name: MedicAlgorithmSPECTRE2010
-nipype_module: nipype.interfaces.mipav.developer
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inInput: generic/file
-    # type=file|default=<undefined>: Input volume to be skullstripped.
-    inAtlas: generic/file
-    # type=file|default=<undefined>: SPECTRE atlas description file. A text file enumerating atlas files and landmarks.
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outOriginal: generic/file
-    # type=file: If Output in Original Space Flag is true then outputs the original input volume. Otherwise outputs the axialy reoriented input volume.
-    # type=traitcompound|default=None: If Output in Original Space Flag is true then outputs the original input volume. Otherwise outputs the axialy reoriented input volume.
-    outStripped: generic/file
-    # type=file: Skullstripped result of the input volume with just the brain.
-    # type=traitcompound|default=None: Skullstripped result of the input volume with just the brain.
-    outMask: generic/file
-    # type=file: Binary Mask of the skullstripped result with just the brain
-    # type=traitcompound|default=None: Binary Mask of the skullstripped result with just the brain
-    outPrior: generic/file
-    # type=file: Probability prior from the atlas registrations
-    # type=traitcompound|default=None: Probability prior from the atlas registrations
-    outFANTASM: generic/file
-    # type=file: Tissue classification of the whole input volume.
-    # type=traitcompound|default=None: Tissue classification of the whole input volume.
-    outd0: generic/file
-    # type=file: Initial Brainmask
-    # type=traitcompound|default=None: Initial Brainmask
-    outMidsagittal: generic/file
-    # type=file: Plane dividing the brain hemispheres
-    # type=traitcompound|default=None: Plane dividing the brain hemispheres
-    outSplitHalves: generic/file
-    # type=file: Skullstripped mask of the brain with the hemispheres divided.
-    # type=traitcompound|default=None: Skullstripped mask of the brain with the hemispheres divided.
-    outSegmentation: generic/file
-    # type=file: 2D image showing the tissue classification on the midsagittal plane
-    # type=traitcompound|default=None: 2D image showing the tissue classification on the midsagittal plane
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inInput:
-    # type=file|default=<undefined>: Input volume to be skullstripped.
-    inAtlas:
-    # type=file|default=<undefined>: SPECTRE atlas description file. A text file enumerating atlas files and landmarks.
-    inInitial:
-    # type=int|default=0: Erosion of the initial mask, which is based on the probability mask and the classification., The initial mask is output as the d0 volume at the conclusion of SPECTRE.
-    inImage:
-    # type=enum|default='T1_SPGR'|allowed['FLAIR','T1_ALT','T1_MPRAGE','T1_SPGR','T2']: Set the image modality. MP-RAGE is recommended for most T1 sequence images.
-    inOutput:
-    # type=enum|default='true'|allowed['false','true']: Determines if the output results are transformed back into the space of the original input image.
-    inFind:
-    # type=enum|default='true'|allowed['false','true']: Find Midsaggital Plane
-    inRun:
-    # type=enum|default='true'|allowed['false','true']: Run Smooth Brain Mask
-    inResample:
-    # type=enum|default='true'|allowed['false','true']: Determines if the data is resampled to be isotropic during the processing.
-    inInitial2:
-    # type=float|default=0.0: Initial probability threshold
-    inMinimum:
-    # type=float|default=0.0: Minimum probability threshold
-    inMMC:
-    # type=int|default=0: The size of the dilation step within the Modified Morphological Closing.
-    inMMC2:
-    # type=int|default=0: The size of the erosion step within the Modified Morphological Closing.
-    inInhomogeneity:
-    # type=enum|default='true'|allowed['false','true']: Set to false by default, this parameter will make FANTASM try to do inhomogeneity correction during it's iterative cycle.
-    inSmoothing:
-    # type=float|default=0.0: 
-    inBackground:
-    # type=float|default=0.0: 
-    inOutput2:
-    # type=enum|default='true'|allowed['false','true']: Output Plane?
-    inOutput3:
-    # type=enum|default='true'|allowed['false','true']: Output Split-Halves?
-    inOutput4:
-    # type=enum|default='true'|allowed['false','true']: Output Segmentation on Plane?
-    inDegrees:
-    # type=enum|default='Rigid - 6'|allowed['Affine - 12','Global rescale - 7','Rigid - 6','Specific rescale - 9']: Degrees of freedom
-    inCost:
-    # type=enum|default='Correlation ratio'|allowed['Correlation ratio','Least squares','Normalized cross correlation','Normalized mutual information']: Cost function
-    inRegistration:
-    # type=enum|default='Trilinear'|allowed['Bspline 3rd order','Bspline 4th order','Cubic Lagrangian','Heptic Lagrangian','Quintic Lagrangian','Trilinear','Windowed sinc']: Registration interpolation
-    inOutput5:
-    # type=enum|default='Trilinear'|allowed['Bspline 3rd order','Bspline 4th order','Cubic Lagrangian','Heptic Lagrangian','Nearest Neighbor','Quintic Lagrangian','Trilinear','Windowed sinc']: Output interpolation
-    inApply:
-    # type=enum|default='All'|allowed['All','X','Y','Z']: Apply rotation
-    inMinimum2:
-    # type=float|default=0.0: Minimum angle
-    inMaximum:
-    # type=float|default=0.0: Maximum angle
-    inCoarse:
-    # type=float|default=0.0: Coarse angle increment
-    inFine:
-    # type=float|default=0.0: Fine angle increment
-    inMultiple:
-    # type=int|default=0: Multiple of tolerance to bracket the minimum
-    inNumber:
-    # type=int|default=0: Number of iterations
-    inNumber2:
-    # type=int|default=0: Number of minima from Level 8 to test at Level 4
-    inUse:
-    # type=enum|default='true'|allowed['false','true']: Use the max of the min resolutions of the two datasets when resampling
-    inSubsample:
-    # type=enum|default='true'|allowed['false','true']: Subsample image for speed
-    inSkip:
-    # type=enum|default='true'|allowed['false','true']: Skip multilevel search (Assume images are close to alignment)
-    inMultithreading:
-    # type=enum|default='true'|allowed['false','true']: Set to false by default, this parameter controls the multithreaded behavior of the linear registration.
-    xPrefExt:
-    # type=enum|default='nrrd'|allowed['nrrd']: Output File Type
-    outOriginal:
-    # type=file: If Output in Original Space Flag is true then outputs the original input volume. Otherwise outputs the axialy reoriented input volume.
-    # type=traitcompound|default=None: If Output in Original Space Flag is true then outputs the original input volume. Otherwise outputs the axialy reoriented input volume.
-    outStripped:
-    # type=file: Skullstripped result of the input volume with just the brain.
-    # type=traitcompound|default=None: Skullstripped result of the input volume with just the brain.
-    outMask:
-    # type=file: Binary Mask of the skullstripped result with just the brain
-    # type=traitcompound|default=None: Binary Mask of the skullstripped result with just the brain
-    outPrior:
-    # type=file: Probability prior from the atlas registrations
-    # type=traitcompound|default=None: Probability prior from the atlas registrations
-    outFANTASM:
-    # type=file: Tissue classification of the whole input volume.
-    # type=traitcompound|default=None: Tissue classification of the whole input volume.
-    outd0:
-    # type=file: Initial Brainmask
-    # type=traitcompound|default=None: Initial Brainmask
-    outMidsagittal:
-    # type=file: Plane dividing the brain hemispheres
-    # type=traitcompound|default=None: Plane dividing the brain hemispheres
-    outSplitHalves:
-    # type=file: Skullstripped mask of the brain with the hemispheres divided.
-    # type=traitcompound|default=None: Skullstripped mask of the brain with the hemispheres divided.
-    outSegmentation:
-    # type=file: 2D image showing the tissue classification on the midsagittal plane
-    # type=traitcompound|default=None: 2D image showing the tissue classification on the midsagittal plane
-    'null':
-    xDefaultMem:
-    # type=int|default=0: Set default maximum heap size
-    xMaxProcess:
-    # type=int|default=1: Set default maximum number of processes.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_spectre2010_callables.py b/example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_spectre2010_callables.py
deleted file mode 100644
index 814db8ce..00000000
--- a/example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_spectre2010_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in MedicAlgorithmSPECTRE2010.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_threshold_to_binary_mask.yaml b/example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_threshold_to_binary_mask.yaml
deleted file mode 100644
index 75471636..00000000
--- a/example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_threshold_to_binary_mask.yaml
+++ /dev/null
@@ -1,91 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.mipav.developer.MedicAlgorithmThresholdToBinaryMask' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Threshold to Binary Mask.
-# 
-#     Given a volume and an intensity range create a binary mask for values within that range.
-# 
-#     
-task_name: MedicAlgorithmThresholdToBinaryMask
-nipype_name: MedicAlgorithmThresholdToBinaryMask
-nipype_module: nipype.interfaces.mipav.developer
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inLabel: generic/file+list-of
-    # type=inputmultiobject|default=[]: Input volumes
-    outBinary: generic/file+list-of
-    # type=inputmultiobject|default=[]: Binary Mask
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inLabel:
-    # type=inputmultiobject|default=[]: Input volumes
-    inMinimum:
-    # type=float|default=0.0: Minimum threshold value.
-    inMaximum:
-    # type=float|default=0.0: Maximum threshold value.
-    inUse:
-    # type=enum|default='true'|allowed['false','true']: Use the images max intensity as the max value of the range.
-    xPrefExt:
-    # type=enum|default='nrrd'|allowed['nrrd']: Output File Type
-    outBinary:
-    # type=inputmultiobject|default=[]: Binary Mask
-    'null':
-    xDefaultMem:
-    # type=int|default=0: Set default maximum heap size
-    xMaxProcess:
-    # type=int|default=1: Set default maximum number of processes.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_threshold_to_binary_mask_callables.py b/example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_threshold_to_binary_mask_callables.py
deleted file mode 100644
index 0a7cae4b..00000000
--- a/example-specs/task/nipype_internal/pydra-mipav/medic_algorithm_threshold_to_binary_mask_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in MedicAlgorithmThresholdToBinaryMask.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-mipav/random_vol.yaml b/example-specs/task/nipype_internal/pydra-mipav/random_vol.yaml
deleted file mode 100644
index eebf05fd..00000000
--- a/example-specs/task/nipype_internal/pydra-mipav/random_vol.yaml
+++ /dev/null
@@ -1,97 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.mipav.developer.RandomVol' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Generate a volume of random scalars.
-task_name: RandomVol
-nipype_name: RandomVol
-nipype_module: nipype.interfaces.mipav.developer
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outRand1: generic/file
-    # type=file: Rand1
-    # type=traitcompound|default=None: Rand1
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inSize:
-    # type=int|default=0: Size of Volume in X direction
-    inSize2:
-    # type=int|default=0: Size of Volume in Y direction
-    inSize3:
-    # type=int|default=0: Size of Volume in Z direction
-    inSize4:
-    # type=int|default=0: Size of Volume in t direction
-    inStandard:
-    # type=int|default=0: Standard Deviation for Normal Distribution
-    inLambda:
-    # type=float|default=0.0: Lambda Value for Exponential Distribution
-    inMaximum:
-    # type=int|default=0: Maximum Value
-    inMinimum:
-    # type=int|default=0: Minimum Value
-    inField:
-    # type=enum|default='Uniform'|allowed['Exponential','Normal','Uniform']: Field
-    xPrefExt:
-    # type=enum|default='nrrd'|allowed['nrrd']: Output File Type
-    outRand1:
-    # type=file: Rand1
-    # type=traitcompound|default=None: Rand1
-    'null':
-    xDefaultMem:
-    # type=int|default=0: Set default maximum heap size
-    xMaxProcess:
-    # type=int|default=1: Set default maximum number of processes.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-mipav/random_vol_callables.py b/example-specs/task/nipype_internal/pydra-mipav/random_vol_callables.py
deleted file mode 100644
index d5a8a91e..00000000
--- a/example-specs/task/nipype_internal/pydra-mipav/random_vol_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in RandomVol.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-niftyfit/dwi_tool.yaml b/example-specs/task/nipype_internal/pydra-niftyfit/dwi_tool.yaml
deleted file mode 100644
index 6fed5d44..00000000
--- a/example-specs/task/nipype_internal/pydra-niftyfit/dwi_tool.yaml
+++ /dev/null
@@ -1,252 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.niftyfit.dwi.DwiTool' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Interface for executable dwi_tool from Niftyfit platform.
-# 
-#     Use DwiTool.
-# 
-#     Diffusion-Weighted MR Prediction.
-#     Predicts DWI from previously fitted models and calculates model derived
-#     maps.
-# 
-#     `Source code <https://cmiclab.cs.ucl.ac.uk/CMIC/NiftyFit-Release>`_
-# 
-#     Examples
-#     --------
-# 
-#     >>> from nipype.interfaces import niftyfit
-#     >>> dwi_tool = niftyfit.DwiTool(dti_flag=True)
-#     >>> dwi_tool.inputs.source_file = 'dwi.nii.gz'
-#     >>> dwi_tool.inputs.bvec_file = 'bvecs'
-#     >>> dwi_tool.inputs.bval_file = 'bvals'
-#     >>> dwi_tool.inputs.mask_file = 'mask.nii.gz'
-#     >>> dwi_tool.inputs.b0_file = 'b0.nii.gz'
-#     >>> dwi_tool.inputs.rgbmap_file = 'rgb_map.nii.gz'
-#     >>> dwi_tool.cmdline
-#     'dwi_tool -source dwi.nii.gz -bval bvals -bvec bvecs -b0 b0.nii.gz -mask mask.nii.gz -dti -famap dwi_famap.nii.gz -logdti2 dwi_logdti2.nii.gz -mcmap dwi_mcmap.nii.gz -mdmap dwi_mdmap.nii.gz -rgbmap rgb_map.nii.gz -syn dwi_syn.nii.gz -v1map dwi_v1map.nii.gz'
-# 
-#     
-task_name: DwiTool
-nipype_name: DwiTool
-nipype_module: nipype.interfaces.niftyfit.dwi
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    source_file: medimage/nifti-gz
-    # type=file|default=<undefined>: The source image containing the fitted model.
-    bval_file: medimage/bval
-    # type=file|default=<undefined>: The file containing the bvalues of the source DWI.
-    bvec_file: medimage/bvec
-    # type=file|default=<undefined>: The file containing the bvectors of the source DWI.
-    b0_file: medimage/nifti-gz
-    # type=file|default=<undefined>: The B0 image corresponding to the source DWI
-    mask_file: medimage/nifti-gz
-    # type=file|default=<undefined>: The image mask
-    mcmap_file: generic/file
-    # type=file: Filename of multi-compartment model parameter map (-ivim,-ball,-nod)
-    # type=file|default=<undefined>: Filename of multi-compartment model parameter map (-ivim,-ball,-nod)
-    syn_file: generic/file
-    # type=file: Filename of synthetic image
-    # type=file|default=<undefined>: Filename of synthetic image. Requires: bvec_file/b0_file.
-    mdmap_file: generic/file
-    # type=file: Filename of MD map/ADC
-    # type=file|default=<undefined>: Filename of MD map/ADC
-    famap_file: generic/file
-    # type=file: Filename of FA map
-    # type=file|default=<undefined>: Filename of FA map
-    v1map_file: generic/file
-    # type=file: Filename of PDD map [x,y,z]
-    # type=file|default=<undefined>: Filename of PDD map [x,y,z]
-    rgbmap_file: medimage/nifti-gz
-    # type=file: Filename of colour FA map
-    # type=file|default=<undefined>: Filename of colour FA map.
-    logdti_file: generic/file
-    # type=file: Filename of output logdti map
-    # type=file|default=<undefined>: Filename of output logdti map.
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    mcmap_file: generic/file
-    # type=file: Filename of multi-compartment model parameter map (-ivim,-ball,-nod)
-    # type=file|default=<undefined>: Filename of multi-compartment model parameter map (-ivim,-ball,-nod)
-    syn_file: generic/file
-    # type=file: Filename of synthetic image
-    # type=file|default=<undefined>: Filename of synthetic image. Requires: bvec_file/b0_file.
-    mdmap_file: generic/file
-    # type=file: Filename of MD map/ADC
-    # type=file|default=<undefined>: Filename of MD map/ADC
-    famap_file: generic/file
-    # type=file: Filename of FA map
-    # type=file|default=<undefined>: Filename of FA map
-    v1map_file: generic/file
-    # type=file: Filename of PDD map [x,y,z]
-    # type=file|default=<undefined>: Filename of PDD map [x,y,z]
-    rgbmap_file: medimage/nifti-gz
-    # type=file: Filename of colour FA map
-    # type=file|default=<undefined>: Filename of colour FA map.
-    logdti_file: generic/file
-    # type=file: Filename of output logdti map
-    # type=file|default=<undefined>: Filename of output logdti map.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    source_file:
-    # type=file|default=<undefined>: The source image containing the fitted model.
-    bval_file:
-    # type=file|default=<undefined>: The file containing the bvalues of the source DWI.
-    bvec_file:
-    # type=file|default=<undefined>: The file containing the bvectors of the source DWI.
-    b0_file:
-    # type=file|default=<undefined>: The B0 image corresponding to the source DWI
-    mask_file:
-    # type=file|default=<undefined>: The image mask
-    mcmap_file:
-    # type=file: Filename of multi-compartment model parameter map (-ivim,-ball,-nod)
-    # type=file|default=<undefined>: Filename of multi-compartment model parameter map (-ivim,-ball,-nod)
-    syn_file:
-    # type=file: Filename of synthetic image
-    # type=file|default=<undefined>: Filename of synthetic image. Requires: bvec_file/b0_file.
-    mdmap_file:
-    # type=file: Filename of MD map/ADC
-    # type=file|default=<undefined>: Filename of MD map/ADC
-    famap_file:
-    # type=file: Filename of FA map
-    # type=file|default=<undefined>: Filename of FA map
-    v1map_file:
-    # type=file: Filename of PDD map [x,y,z]
-    # type=file|default=<undefined>: Filename of PDD map [x,y,z]
-    rgbmap_file:
-    # type=file: Filename of colour FA map
-    # type=file|default=<undefined>: Filename of colour FA map.
-    logdti_file:
-    # type=file: Filename of output logdti map
-    # type=file|default=<undefined>: Filename of output logdti map.
-    mono_flag:
-    # type=bool|default=False: Input is a single exponential to non-directional data [default with no b-vectors]
-    ivim_flag:
-    # type=bool|default=False: Inputs is an IVIM model to non-directional data.
-    dti_flag:
-    # type=bool|default=False: Input is a tensor model diag/off-diag.
-    dti_flag2:
-    # type=bool|default=False: Input is a tensor model lower triangular
-    ball_flag:
-    # type=bool|default=False: Input is a ball and stick model.
-    ballv_flag:
-    # type=bool|default=False: Input is a ball and stick model with optimised PDD.
-    nod_flag:
-    # type=bool|default=False: Input is a NODDI model
-    nodv_flag:
-    # type=bool|default=False: Input is a NODDI model with optimised PDD
-    diso_val:
-    # type=float|default=0.0: Isotropic diffusivity for -nod [3e-3]
-    dpr_val:
-    # type=float|default=0.0: Parallel diffusivity for -nod [1.7e-3].
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    source_file:
-    # type=file|default=<undefined>: The source image containing the fitted model.
-    bvec_file:
-    # type=file|default=<undefined>: The file containing the bvectors of the source DWI.
-    bval_file:
-    # type=file|default=<undefined>: The file containing the bvalues of the source DWI.
-    mask_file:
-    # type=file|default=<undefined>: The image mask
-    b0_file:
-    # type=file|default=<undefined>: The B0 image corresponding to the source DWI
-    rgbmap_file:
-    # type=file: Filename of colour FA map
-    # type=file|default=<undefined>: Filename of colour FA map.
-    dti_flag: 'True'
-    # type=bool|default=False: Input is a tensor model diag/off-diag.
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests:
-- cmdline: dwi_tool -source dwi.nii.gz -bval bvals -bvec bvecs -b0 b0.nii.gz -mask mask.nii.gz -dti -famap dwi_famap.nii.gz -logdti2 dwi_logdti2.nii.gz -mcmap dwi_mcmap.nii.gz -mdmap dwi_mdmap.nii.gz -rgbmap rgb_map.nii.gz -syn dwi_syn.nii.gz -v1map dwi_v1map.nii.gz
-  # str - the expected cmdline output
-  inputs:
-  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
-  # If the field is of file-format type and the value is None, then the
-  # '.mock()' method of the corresponding class is used instead.
-    source_file:
-    # type=file|default=<undefined>: The source image containing the fitted model.
-    bvec_file:
-    # type=file|default=<undefined>: The file containing the bvectors of the source DWI.
-    bval_file:
-    # type=file|default=<undefined>: The file containing the bvalues of the source DWI.
-    mask_file:
-    # type=file|default=<undefined>: The image mask
-    b0_file:
-    # type=file|default=<undefined>: The B0 image corresponding to the source DWI
-    rgbmap_file:
-    # type=file: Filename of colour FA map
-    # type=file|default=<undefined>: Filename of colour FA map.
-    dti_flag: 'True'
-    # type=bool|default=False: Input is a tensor model diag/off-diag.
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  directive:
-  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-niftyfit/dwi_tool_callables.py b/example-specs/task/nipype_internal/pydra-niftyfit/dwi_tool_callables.py
deleted file mode 100644
index d5325340..00000000
--- a/example-specs/task/nipype_internal/pydra-niftyfit/dwi_tool_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in DwiTool.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-niftyfit/fit_asl.yaml b/example-specs/task/nipype_internal/pydra-niftyfit/fit_asl.yaml
deleted file mode 100644
index 808006ad..00000000
--- a/example-specs/task/nipype_internal/pydra-niftyfit/fit_asl.yaml
+++ /dev/null
@@ -1,227 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.niftyfit.asl.FitAsl' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Interface for executable fit_asl from Niftyfit platform.
-# 
-#     Use NiftyFit to perform ASL fitting.
-# 
-#     ASL fitting routines (following EU Cost Action White Paper recommendations)
-#     Fits Cerebral Blood Flow maps in the first instance.
-# 
-#     `Source code <https://cmiclab.cs.ucl.ac.uk/CMIC/NiftyFit-Release>`_
-# 
-#     Examples
-#     --------
-#     >>> from nipype.interfaces import niftyfit
-#     >>> node = niftyfit.FitAsl()
-#     >>> node.inputs.source_file = 'asl.nii.gz'
-#     >>> node.cmdline
-#     'fit_asl -source asl.nii.gz -cbf asl_cbf.nii.gz -error asl_error.nii.gz -syn asl_syn.nii.gz'
-# 
-#     
-task_name: FitAsl
-nipype_name: FitAsl
-nipype_module: nipype.interfaces.niftyfit.asl
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    source_file: medimage/nifti-gz
-    # type=file|default=<undefined>: Filename of the 4D ASL (control/label) source image (mandatory).
-    cbf_file: generic/file
-    # type=file: Filename of the Cerebral Blood Flow map (in ml/100g/min).
-    # type=file|default=<undefined>: Filename of the Cerebral Blood Flow map (in ml/100g/min).
-    error_file: generic/file
-    # type=file: Filename of the CBF error map.
-    # type=file|default=<undefined>: Filename of the CBF error map.
-    syn_file: generic/file
-    # type=file: Filename of the synthetic ASL data.
-    # type=file|default=<undefined>: Filename of the synthetic ASL data.
-    t1map: generic/file
-    # type=file|default=<undefined>: Filename of the estimated input T1 map (in ms).
-    m0map: generic/file
-    # type=file|default=<undefined>: Filename of the estimated input M0 map.
-    m0mape: generic/file
-    # type=file|default=<undefined>: Filename of the estimated input M0 map error.
-    ir_volume: generic/file
-    # type=file|default=<undefined>: Filename of a [1,2,5]s Inversion Recovery volume (T1/M0 fitting carried out internally).
-    ir_output: generic/file
-    # type=file|default=<undefined>: Output of [1,2,5]s Inversion Recovery fitting.
-    mask: generic/file
-    # type=file|default=<undefined>: Filename of image mask.
-    seg: generic/file
-    # type=file|default=<undefined>: Filename of the 4D segmentation (in ASL space) for L/T1 estimation and PV correction {WM,GM,CSF}.
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    cbf_file: generic/file
-    # type=file: Filename of the Cerebral Blood Flow map (in ml/100g/min).
-    # type=file|default=<undefined>: Filename of the Cerebral Blood Flow map (in ml/100g/min).
-    error_file: generic/file
-    # type=file: Filename of the CBF error map.
-    # type=file|default=<undefined>: Filename of the CBF error map.
-    syn_file: generic/file
-    # type=file: Filename of the synthetic ASL data.
-    # type=file|default=<undefined>: Filename of the synthetic ASL data.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    source_file:
-    # type=file|default=<undefined>: Filename of the 4D ASL (control/label) source image (mandatory).
-    pasl:
-    # type=bool|default=False: Fit PASL ASL data [default]
-    pcasl:
-    # type=bool|default=False: Fit PCASL ASL data
-    cbf_file:
-    # type=file: Filename of the Cerebral Blood Flow map (in ml/100g/min).
-    # type=file|default=<undefined>: Filename of the Cerebral Blood Flow map (in ml/100g/min).
-    error_file:
-    # type=file: Filename of the CBF error map.
-    # type=file|default=<undefined>: Filename of the CBF error map.
-    syn_file:
-    # type=file: Filename of the synthetic ASL data.
-    # type=file|default=<undefined>: Filename of the synthetic ASL data.
-    t1map:
-    # type=file|default=<undefined>: Filename of the estimated input T1 map (in ms).
-    m0map:
-    # type=file|default=<undefined>: Filename of the estimated input M0 map.
-    m0mape:
-    # type=file|default=<undefined>: Filename of the estimated input M0 map error.
-    ir_volume:
-    # type=file|default=<undefined>: Filename of a [1,2,5]s Inversion Recovery volume (T1/M0 fitting carried out internally).
-    ir_output:
-    # type=file|default=<undefined>: Output of [1,2,5]s Inversion Recovery fitting.
-    mask:
-    # type=file|default=<undefined>: Filename of image mask.
-    t1_art_cmp:
-    # type=float|default=0.0: T1 of arterial component [1650ms].
-    plasma_coeff:
-    # type=float|default=0.0: Single plasma/tissue partition coefficient [0.9ml/g].
-    eff:
-    # type=float|default=0.0: Labelling efficiency [0.99 (pasl), 0.85 (pcasl)], ensure any background suppression pulses are included in -eff
-    out:
-    # type=float|default=0.0: Outlier rejection for multi CL volumes (enter z-score threshold (e.g. 2.5)) [off].
-    pld:
-    # type=float|default=0.0: Post Labelling Delay [2000ms].
-    ldd:
-    # type=float|default=0.0: Labelling Duration [1800ms].
-    dpld:
-    # type=float|default=0.0: Difference in labelling delay per slice [0.0 ms/slice.
-    t_inv1:
-    # type=float|default=0.0: Saturation pulse time [800ms].
-    t_inv2:
-    # type=float|default=0.0: Inversion time [2000ms].
-    dt_inv2:
-    # type=float|default=0.0: Difference in inversion time per slice [0ms/slice].
-    gm_t1:
-    # type=float|default=0.0: T1 of GM [1150ms].
-    gm_plasma:
-    # type=float|default=0.0: Plasma/GM water partition [0.95ml/g].
-    gm_ttt:
-    # type=float|default=0.0: Time to GM [ATT+0ms].
-    wm_t1:
-    # type=float|default=0.0: T1 of WM [800ms].
-    wm_plasma:
-    # type=float|default=0.0: Plasma/WM water partition [0.82ml/g].
-    wm_ttt:
-    # type=float|default=0.0: Time to WM [ATT+0ms].
-    seg:
-    # type=file|default=<undefined>: Filename of the 4D segmentation (in ASL space) for L/T1 estimation and PV correction {WM,GM,CSF}.
-    sig:
-    # type=bool|default=False: Use sigmoid to estimate L from T1: L(T1|gmL,wmL) [Off].
-    pv0:
-    # type=int|default=0: Simple PV correction (CBF=vg*CBFg + vw*CBFw, with CBFw=f*CBFg) [0.25].
-    pv2:
-    # type=int|default=0: In plane PV kernel size [3x3].
-    pv3:
-    # type=tuple|default=(0, 0, 0): 3D kernel size [3x3x1].
-    mul:
-    # type=float|default=0.0: Multiply CBF by this value (e.g. if CL are mislabelled use -1.0).
-    mulgm:
-    # type=bool|default=False: Multiply CBF by segmentation [Off].
-    pv_threshold:
-    # type=bool|default=False: Set PV threshold for switching off LSQR [O.05].
-    segstyle:
-    # type=bool|default=False: Set CBF as [gm,wm] not [wm,gm].
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    source_file:
-    # type=file|default=<undefined>: Filename of the 4D ASL (control/label) source image (mandatory).
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests:
-- cmdline: fit_asl -source asl.nii.gz -cbf asl_cbf.nii.gz -error asl_error.nii.gz -syn asl_syn.nii.gz
-  # str - the expected cmdline output
-  inputs:
-  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
-  # If the field is of file-format type and the value is None, then the
-  # '.mock()' method of the corresponding class is used instead.
-    source_file:
-    # type=file|default=<undefined>: Filename of the 4D ASL (control/label) source image (mandatory).
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  directive:
-  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-niftyfit/fit_asl_callables.py b/example-specs/task/nipype_internal/pydra-niftyfit/fit_asl_callables.py
deleted file mode 100644
index 753aabb6..00000000
--- a/example-specs/task/nipype_internal/pydra-niftyfit/fit_asl_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in FitAsl.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-niftyfit/fit_dwi.yaml b/example-specs/task/nipype_internal/pydra-niftyfit/fit_dwi.yaml
deleted file mode 100644
index 94e94772..00000000
--- a/example-specs/task/nipype_internal/pydra-niftyfit/fit_dwi.yaml
+++ /dev/null
@@ -1,328 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.niftyfit.dwi.FitDwi' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Interface for executable fit_dwi from Niftyfit platform.
-# 
-#     Use NiftyFit to perform diffusion model fitting.
-# 
-#     Diffusion-weighted MR Fitting.
-#     Fits DWI parameter maps to multi-shell, multi-directional data.
-# 
-#     `Source code <https://cmiclab.cs.ucl.ac.uk/CMIC/NiftyFit-Release>`_
-# 
-#     Examples
-#     --------
-# 
-#     >>> from nipype.interfaces import niftyfit
-#     >>> fit_dwi = niftyfit.FitDwi(dti_flag=True)
-#     >>> fit_dwi.inputs.source_file = 'dwi.nii.gz'
-#     >>> fit_dwi.inputs.bvec_file = 'bvecs'
-#     >>> fit_dwi.inputs.bval_file = 'bvals'
-#     >>> fit_dwi.inputs.rgbmap_file = 'rgb.nii.gz'
-#     >>> fit_dwi.cmdline
-#     'fit_dwi -source dwi.nii.gz -bval bvals -bvec bvecs -dti -error dwi_error.nii.gz -famap dwi_famap.nii.gz -mcout dwi_mcout.txt -mdmap dwi_mdmap.nii.gz -nodiff dwi_no_diff.nii.gz -res dwi_resmap.nii.gz -rgbmap rgb.nii.gz -syn dwi_syn.nii.gz -tenmap2 dwi_tenmap2.nii.gz -v1map dwi_v1map.nii.gz'
-# 
-#     
-task_name: FitDwi
-nipype_name: FitDwi
-nipype_module: nipype.interfaces.niftyfit.dwi
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    source_file: medimage/nifti-gz
-    # type=file|default=<undefined>: The source image containing the dwi data.
-    bval_file: medimage/bval
-    # type=file|default=<undefined>: The file containing the bvalues of the source DWI.
-    bvec_file: medimage/bvec
-    # type=file|default=<undefined>: The file containing the bvectors of the source DWI.
-    te_file: generic/file
-    # type=file|default=<undefined>: Filename of TEs (ms).
-    te_value: generic/file
-    # type=file|default=<undefined>: Value of TEs (ms).
-    mask_file: generic/file
-    # type=file|default=<undefined>: The image mask
-    prior_file: generic/file
-    # type=file|default=<undefined>: Filename of parameter priors for -ball and -nod.
-    error_file: generic/file
-    # type=file: Filename of parameter error maps
-    # type=file|default=<undefined>: Filename of parameter error maps.
-    res_file: generic/file
-    # type=file: Filename of model residual map
-    # type=file|default=<undefined>: Filename of model residual map.
-    syn_file: generic/file
-    # type=file: Filename of synthetic image
-    # type=file|default=<undefined>: Filename of synthetic image.
-    nodiff_file: generic/file
-    # type=file: Filename of average no diffusion image.
-    # type=file|default=<undefined>: Filename of average no diffusion image.
-    mcmap_file: generic/file
-    # type=file: Filename of multi-compartment model parameter map (-ivim,-ball,-nod).
-    # type=file|default=<undefined>: Filename of multi-compartment model parameter map (-ivim,-ball,-nod)
-    mdmap_file: generic/file
-    # type=file: Filename of MD map/ADC
-    # type=file|default=<undefined>: Filename of MD map/ADC
-    famap_file: generic/file
-    # type=file: Filename of FA map
-    # type=file|default=<undefined>: Filename of FA map
-    v1map_file: generic/file
-    # type=file: Filename of PDD map [x,y,z]
-    # type=file|default=<undefined>: Filename of PDD map [x,y,z]
-    rgbmap_file: medimage/nifti-gz
-    # type=file: Filename of colour FA map
-    # type=file|default=<undefined>: Filename of colour-coded FA map
-    tenmap_file: generic/file
-    # type=file: Filename of tensor map
-    # type=file|default=<undefined>: Filename of tensor map [diag,offdiag].
-    tenmap2_file: generic/file
-    # type=file: Filename of tensor map [lower tri]
-    # type=file|default=<undefined>: Filename of tensor map [lower tri]
-    cov_file: generic/file
-    # type=file|default=<undefined>: Filename of ithe nc*nc covariance matrix [I]
-    mcout: generic/file
-    # type=file: Filename of mc samples (ascii text file)
-    # type=file|default=<undefined>: Filename of mc samples (ascii text file)
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    error_file: generic/file
-    # type=file: Filename of parameter error maps
-    # type=file|default=<undefined>: Filename of parameter error maps.
-    res_file: generic/file
-    # type=file: Filename of model residual map
-    # type=file|default=<undefined>: Filename of model residual map.
-    syn_file: generic/file
-    # type=file: Filename of synthetic image
-    # type=file|default=<undefined>: Filename of synthetic image.
-    nodiff_file: generic/file
-    # type=file: Filename of average no diffusion image.
-    # type=file|default=<undefined>: Filename of average no diffusion image.
-    mdmap_file: generic/file
-    # type=file: Filename of MD map/ADC
-    # type=file|default=<undefined>: Filename of MD map/ADC
-    famap_file: generic/file
-    # type=file: Filename of FA map
-    # type=file|default=<undefined>: Filename of FA map
-    v1map_file: generic/file
-    # type=file: Filename of PDD map [x,y,z]
-    # type=file|default=<undefined>: Filename of PDD map [x,y,z]
-    rgbmap_file: medimage/nifti-gz
-    # type=file: Filename of colour FA map
-    # type=file|default=<undefined>: Filename of colour-coded FA map
-    tenmap_file: generic/file
-    # type=file: Filename of tensor map
-    # type=file|default=<undefined>: Filename of tensor map [diag,offdiag].
-    tenmap2_file: generic/file
-    # type=file: Filename of tensor map [lower tri]
-    # type=file|default=<undefined>: Filename of tensor map [lower tri]
-    mcmap_file: generic/file
-    # type=file: Filename of multi-compartment model parameter map (-ivim,-ball,-nod).
-    # type=file|default=<undefined>: Filename of multi-compartment model parameter map (-ivim,-ball,-nod)
-    mcout: generic/file
-    # type=file: Filename of mc samples (ascii text file)
-    # type=file|default=<undefined>: Filename of mc samples (ascii text file)
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    source_file:
-    # type=file|default=<undefined>: The source image containing the dwi data.
-    bval_file:
-    # type=file|default=<undefined>: The file containing the bvalues of the source DWI.
-    bvec_file:
-    # type=file|default=<undefined>: The file containing the bvectors of the source DWI.
-    te_file:
-    # type=file|default=<undefined>: Filename of TEs (ms).
-    te_value:
-    # type=file|default=<undefined>: Value of TEs (ms).
-    mask_file:
-    # type=file|default=<undefined>: The image mask
-    prior_file:
-    # type=file|default=<undefined>: Filename of parameter priors for -ball and -nod.
-    rot_sform_flag:
-    # type=int|default=0: Rotate the output tensors according to the q/s form of the image (resulting tensors will be in mm coordinates, default: 0).
-    error_file:
-    # type=file: Filename of parameter error maps
-    # type=file|default=<undefined>: Filename of parameter error maps.
-    res_file:
-    # type=file: Filename of model residual map
-    # type=file|default=<undefined>: Filename of model residual map.
-    syn_file:
-    # type=file: Filename of synthetic image
-    # type=file|default=<undefined>: Filename of synthetic image.
-    nodiff_file:
-    # type=file: Filename of average no diffusion image.
-    # type=file|default=<undefined>: Filename of average no diffusion image.
-    mcmap_file:
-    # type=file: Filename of multi-compartment model parameter map (-ivim,-ball,-nod).
-    # type=file|default=<undefined>: Filename of multi-compartment model parameter map (-ivim,-ball,-nod)
-    mdmap_file:
-    # type=file: Filename of MD map/ADC
-    # type=file|default=<undefined>: Filename of MD map/ADC
-    famap_file:
-    # type=file: Filename of FA map
-    # type=file|default=<undefined>: Filename of FA map
-    v1map_file:
-    # type=file: Filename of PDD map [x,y,z]
-    # type=file|default=<undefined>: Filename of PDD map [x,y,z]
-    rgbmap_file:
-    # type=file: Filename of colour FA map
-    # type=file|default=<undefined>: Filename of colour-coded FA map
-    ten_type:
-    # type=enum|default='lower-tri'|allowed['diag-off-diag','lower-tri']: Use lower triangular (tenmap2) or diagonal, off-diagonal tensor format
-    tenmap_file:
-    # type=file: Filename of tensor map
-    # type=file|default=<undefined>: Filename of tensor map [diag,offdiag].
-    tenmap2_file:
-    # type=file: Filename of tensor map [lower tri]
-    # type=file|default=<undefined>: Filename of tensor map [lower tri]
-    mono_flag:
-    # type=bool|default=False: Fit single exponential to non-directional data [default with no b-vectors]
-    ivim_flag:
-    # type=bool|default=False: Fit IVIM model to non-directional data.
-    dti_flag:
-    # type=bool|default=False: Fit the tensor model [default with b-vectors].
-    ball_flag:
-    # type=bool|default=False: Fit the ball and stick model.
-    ballv_flag:
-    # type=bool|default=False: Fit the ball and stick model with optimised PDD.
-    nod_flag:
-    # type=bool|default=False: Fit the NODDI model
-    nodv_flag:
-    # type=bool|default=False: Fit the NODDI model with optimised PDD
-    maxit_val:
-    # type=int|default=0: Maximum number of non-linear LSQR iterations [100x2 passes])
-    lm_vals:
-    # type=tuple|default=(0.0, 0.0): LM parameters (initial value, decrease rate) [100,1.2].
-    gn_flag:
-    # type=bool|default=False: Use Gauss-Newton algorithm [Levenberg-Marquardt].
-    vb_flag:
-    # type=bool|default=False: Use Variational Bayes fitting with known prior (currently identity covariance...).
-    cov_file:
-    # type=file|default=<undefined>: Filename of ithe nc*nc covariance matrix [I]
-    wls_flag:
-    # type=bool|default=False: Use Variational Bayes fitting with known prior (currently identity covariance...).
-    swls_val:
-    # type=float|default=0.0: Use location-weighted least squares for DTI fitting [3x3 Gaussian]
-    slice_no:
-    # type=int|default=0: Fit to single slice number.
-    voxel:
-    # type=tuple|default=(0, 0, 0): Fit to single voxel only.
-    diso_val:
-    # type=float|default=0.0: Isotropic diffusivity for -nod [3e-3]
-    dpr_val:
-    # type=float|default=0.0: Parallel diffusivity for -nod [1.7e-3].
-    wm_t2_val:
-    # type=float|default=0.0: White matter T2 value [80ms].
-    csf_t2_val:
-    # type=float|default=0.0: CSF T2 value [400ms].
-    perf_thr:
-    # type=float|default=0.0: Threshold for perfusion/diffsuion effects [100].
-    mcout:
-    # type=file: Filename of mc samples (ascii text file)
-    # type=file|default=<undefined>: Filename of mc samples (ascii text file)
-    mcsamples:
-    # type=int|default=0: Number of samples to keep [100].
-    mcmaxit:
-    # type=int|default=0: Number of iterations to run [10,000].
-    acceptance:
-    # type=float|default=0.0: Fraction of iterations to accept [0.23].
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    source_file:
-    # type=file|default=<undefined>: The source image containing the dwi data.
-    bvec_file:
-    # type=file|default=<undefined>: The file containing the bvectors of the source DWI.
-    bval_file:
-    # type=file|default=<undefined>: The file containing the bvalues of the source DWI.
-    rgbmap_file:
-    # type=file: Filename of colour FA map
-    # type=file|default=<undefined>: Filename of colour-coded FA map
-    dti_flag: 'True'
-    # type=bool|default=False: Fit the tensor model [default with b-vectors].
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests:
-- cmdline: fit_dwi -source dwi.nii.gz -bval bvals -bvec bvecs -dti -error dwi_error.nii.gz -famap dwi_famap.nii.gz -mcout dwi_mcout.txt -mdmap dwi_mdmap.nii.gz -nodiff dwi_no_diff.nii.gz -res dwi_resmap.nii.gz -rgbmap rgb.nii.gz -syn dwi_syn.nii.gz -tenmap2 dwi_tenmap2.nii.gz -v1map dwi_v1map.nii.gz
-  # str - the expected cmdline output
-  inputs:
-  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
-  # If the field is of file-format type and the value is None, then the
-  # '.mock()' method of the corresponding class is used instead.
-    source_file:
-    # type=file|default=<undefined>: The source image containing the dwi data.
-    bvec_file:
-    # type=file|default=<undefined>: The file containing the bvectors of the source DWI.
-    bval_file:
-    # type=file|default=<undefined>: The file containing the bvalues of the source DWI.
-    rgbmap_file:
-    # type=file: Filename of colour FA map
-    # type=file|default=<undefined>: Filename of colour-coded FA map
-    dti_flag: 'True'
-    # type=bool|default=False: Fit the tensor model [default with b-vectors].
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  directive:
-  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-niftyfit/fit_dwi_callables.py b/example-specs/task/nipype_internal/pydra-niftyfit/fit_dwi_callables.py
deleted file mode 100644
index 4126c31d..00000000
--- a/example-specs/task/nipype_internal/pydra-niftyfit/fit_dwi_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in FitDwi.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-niftyfit/fit_qt_1.yaml b/example-specs/task/nipype_internal/pydra-niftyfit/fit_qt_1.yaml
deleted file mode 100644
index 2f3626b8..00000000
--- a/example-specs/task/nipype_internal/pydra-niftyfit/fit_qt_1.yaml
+++ /dev/null
@@ -1,248 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.niftyfit.qt1.FitQt1' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Interface for executable fit_qt1 from Niftyfit platform.
-# 
-#     Use NiftyFit to perform Qt1 fitting.
-# 
-#     T1 Fitting Routine (To inversion recovery or spgr data).
-#     Fits single component T1 maps in the first instance.
-# 
-#     `Source code <https://cmiclab.cs.ucl.ac.uk/CMIC/NiftyFit-Release>`_
-# 
-#     Examples
-#     --------
-# 
-#     >>> from nipype.interfaces.niftyfit import FitQt1
-#     >>> fit_qt1 = FitQt1()
-#     >>> fit_qt1.inputs.source_file = 'TI4D.nii.gz'
-#     >>> fit_qt1.cmdline
-#     'fit_qt1 -source TI4D.nii.gz -comp TI4D_comp.nii.gz -error TI4D_error.nii.gz -m0map TI4D_m0map.nii.gz -mcmap TI4D_mcmap.nii.gz -res TI4D_res.nii.gz -syn TI4D_syn.nii.gz -t1map TI4D_t1map.nii.gz'
-# 
-#     
-task_name: FitQt1
-nipype_name: FitQt1
-nipype_module: nipype.interfaces.niftyfit.qt1
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    source_file: medimage/nifti-gz
-    # type=file|default=<undefined>: Filename of the 4D Multi-Echo T1 source image.
-    t1map_file: generic/file
-    # type=file: Filename of the estimated output T1 map (in ms)
-    # type=file|default=<undefined>: Filename of the estimated output T1 map (in ms).
-    m0map_file: generic/file
-    # type=file: Filename of the m0 map
-    # type=file|default=<undefined>: Filename of the estimated input M0 map.
-    mcmap_file: generic/file
-    # type=file: Filename of the estimated output multi-parameter map
-    # type=file|default=<undefined>: Filename of the estimated output multi-parameter map.
-    comp_file: generic/file
-    # type=file: Filename of the estimated multi-component T1 map.
-    # type=file|default=<undefined>: Filename of the estimated multi-component T1 map.
-    error_file: generic/file
-    # type=file: Filename of the error map (symmetric matrix, [Diag,OffDiag])
-    # type=file|default=<undefined>: Filename of the error map (symmetric matrix, [Diag,OffDiag]).
-    syn_file: generic/file
-    # type=file: Filename of the synthetic ASL data
-    # type=file|default=<undefined>: Filename of the synthetic ASL data.
-    res_file: generic/file
-    # type=file: Filename of the model fit residuals
-    # type=file|default=<undefined>: Filename of the model fit residuals
-    mask: generic/file
-    # type=file|default=<undefined>: Filename of image mask.
-    prior: generic/file
-    # type=file|default=<undefined>: Filename of parameter prior.
-    tis_list: generic/file
-    # type=file|default=<undefined>: Filename of list of pre-defined TIs.
-    t1_list: generic/file
-    # type=file|default=<undefined>: Filename of list of pre-defined T1s
-    flips_list: generic/file
-    # type=file|default=<undefined>: Filename of list of pre-defined flip angles (deg).
-    b1map: generic/file
-    # type=file|default=<undefined>: Filename of B1 estimate for fitting (or include in prior).
-    mcout: generic/file
-    # type=file|default=<undefined>: Filename of mc samples (ascii text file)
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    t1map_file: generic/file
-    # type=file: Filename of the estimated output T1 map (in ms)
-    # type=file|default=<undefined>: Filename of the estimated output T1 map (in ms).
-    m0map_file: generic/file
-    # type=file: Filename of the m0 map
-    # type=file|default=<undefined>: Filename of the estimated input M0 map.
-    mcmap_file: generic/file
-    # type=file: Filename of the estimated output multi-parameter map
-    # type=file|default=<undefined>: Filename of the estimated output multi-parameter map.
-    comp_file: generic/file
-    # type=file: Filename of the estimated multi-component T1 map.
-    # type=file|default=<undefined>: Filename of the estimated multi-component T1 map.
-    error_file: generic/file
-    # type=file: Filename of the error map (symmetric matrix, [Diag,OffDiag])
-    # type=file|default=<undefined>: Filename of the error map (symmetric matrix, [Diag,OffDiag]).
-    syn_file: generic/file
-    # type=file: Filename of the synthetic ASL data
-    # type=file|default=<undefined>: Filename of the synthetic ASL data.
-    res_file: generic/file
-    # type=file: Filename of the model fit residuals
-    # type=file|default=<undefined>: Filename of the model fit residuals
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    source_file:
-    # type=file|default=<undefined>: Filename of the 4D Multi-Echo T1 source image.
-    t1map_file:
-    # type=file: Filename of the estimated output T1 map (in ms)
-    # type=file|default=<undefined>: Filename of the estimated output T1 map (in ms).
-    m0map_file:
-    # type=file: Filename of the m0 map
-    # type=file|default=<undefined>: Filename of the estimated input M0 map.
-    mcmap_file:
-    # type=file: Filename of the estimated output multi-parameter map
-    # type=file|default=<undefined>: Filename of the estimated output multi-parameter map.
-    comp_file:
-    # type=file: Filename of the estimated multi-component T1 map.
-    # type=file|default=<undefined>: Filename of the estimated multi-component T1 map.
-    error_file:
-    # type=file: Filename of the error map (symmetric matrix, [Diag,OffDiag])
-    # type=file|default=<undefined>: Filename of the error map (symmetric matrix, [Diag,OffDiag]).
-    syn_file:
-    # type=file: Filename of the synthetic ASL data
-    # type=file|default=<undefined>: Filename of the synthetic ASL data.
-    res_file:
-    # type=file: Filename of the model fit residuals
-    # type=file|default=<undefined>: Filename of the model fit residuals
-    mask:
-    # type=file|default=<undefined>: Filename of image mask.
-    prior:
-    # type=file|default=<undefined>: Filename of parameter prior.
-    te_value:
-    # type=float|default=0.0: TE Echo Time [0ms!].
-    tr_value:
-    # type=float|default=0.0: TR Repetition Time [10s!].
-    nb_comp:
-    # type=int|default=0: Number of components to fit [1] (currently IR/SR only)
-    lm_val:
-    # type=tuple|default=(0.0, 0.0): Set LM parameters (initial value, decrease rate) [100,1.2].
-    gn_flag:
-    # type=bool|default=False: Use Gauss-Newton algorithm [Levenberg-Marquardt].
-    slice_no:
-    # type=int|default=0: Fit to single slice number.
-    voxel:
-    # type=tuple|default=(0, 0, 0): Fit to single voxel only.
-    maxit:
-    # type=int|default=0: NLSQR iterations [100].
-    sr_flag:
-    # type=bool|default=False: Saturation Recovery fitting [default].
-    ir_flag:
-    # type=bool|default=False: Inversion Recovery fitting [default].
-    tis:
-    # type=list|default=[]: Inversion times for T1 data [1s,2s,5s].
-    tis_list:
-    # type=file|default=<undefined>: Filename of list of pre-defined TIs.
-    t1_list:
-    # type=file|default=<undefined>: Filename of list of pre-defined T1s
-    t1min:
-    # type=float|default=0.0: Minimum tissue T1 value [400ms].
-    t1max:
-    # type=float|default=0.0: Maximum tissue T1 value [4000ms].
-    spgr:
-    # type=bool|default=False: Spoiled Gradient Echo fitting
-    flips:
-    # type=list|default=[]: Flip angles
-    flips_list:
-    # type=file|default=<undefined>: Filename of list of pre-defined flip angles (deg).
-    b1map:
-    # type=file|default=<undefined>: Filename of B1 estimate for fitting (or include in prior).
-    mcout:
-    # type=file|default=<undefined>: Filename of mc samples (ascii text file)
-    mcsamples:
-    # type=int|default=0: Number of samples to keep [100].
-    mcmaxit:
-    # type=int|default=0: Number of iterations to run [10,000].
-    acceptance:
-    # type=float|default=0.0: Fraction of iterations to accept [0.23].
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    source_file:
-    # type=file|default=<undefined>: Filename of the 4D Multi-Echo T1 source image.
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests:
-- cmdline: fit_qt1 -source TI4D.nii.gz -comp TI4D_comp.nii.gz -error TI4D_error.nii.gz -m0map TI4D_m0map.nii.gz -mcmap TI4D_mcmap.nii.gz -res TI4D_res.nii.gz -syn TI4D_syn.nii.gz -t1map TI4D_t1map.nii.gz
-  # str - the expected cmdline output
-  inputs:
-  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
-  # If the field is of file-format type and the value is None, then the
-  # '.mock()' method of the corresponding class is used instead.
-    source_file:
-    # type=file|default=<undefined>: Filename of the 4D Multi-Echo T1 source image.
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  directive:
-  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-niftyfit/fit_qt_1_callables.py b/example-specs/task/nipype_internal/pydra-niftyfit/fit_qt_1_callables.py
deleted file mode 100644
index a2a3a5e7..00000000
--- a/example-specs/task/nipype_internal/pydra-niftyfit/fit_qt_1_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in FitQt1.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-niftyreg/reg_aladin.yaml b/example-specs/task/nipype_internal/pydra-niftyreg/reg_aladin.yaml
deleted file mode 100644
index 87fccc3b..00000000
--- a/example-specs/task/nipype_internal/pydra-niftyreg/reg_aladin.yaml
+++ /dev/null
@@ -1,209 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.niftyreg.reg.RegAladin' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Interface for executable reg_aladin from NiftyReg platform.
-# 
-#     Block Matching algorithm for symmetric global registration.
-#     Based on Modat et al., "Global image registration using
-#     asymmetric block-matching approach"
-#     J. Med. Img. 1(2) 024003, 2014, doi: 10.1117/1.JMI.1.2.024003
-# 
-#     `Source code <https://cmiclab.cs.ucl.ac.uk/mmodat/niftyreg>`_
-# 
-#     Examples
-#     --------
-#     >>> from nipype.interfaces import niftyreg
-#     >>> node = niftyreg.RegAladin()
-#     >>> node.inputs.ref_file = 'im1.nii'
-#     >>> node.inputs.flo_file = 'im2.nii'
-#     >>> node.inputs.rmask_file = 'mask.nii'
-#     >>> node.inputs.omp_core_val = 4
-#     >>> node.cmdline
-#     'reg_aladin -aff im2_aff.txt -flo im2.nii -omp 4 -ref im1.nii -res im2_res.nii.gz -rmask mask.nii'
-# 
-#     
-task_name: RegAladin
-nipype_name: RegAladin
-nipype_module: nipype.interfaces.niftyreg.reg
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    ref_file: medimage/nifti1
-    # type=file|default=<undefined>: The input reference/target image
-    flo_file: medimage/nifti1
-    # type=file|default=<undefined>: The input floating/source image
-    in_aff_file: generic/file
-    # type=file|default=<undefined>: The input affine transformation
-    rmask_file: medimage/nifti1
-    # type=file|default=<undefined>: The input reference mask
-    fmask_file: generic/file
-    # type=file|default=<undefined>: The input floating mask
-    aff_file: generic/file
-    # type=file: The output affine file
-    # type=file|default=<undefined>: The output affine matrix file
-    res_file: generic/file
-    # type=file: The output transformed image
-    # type=file|default=<undefined>: The affine transformed floating image
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    aff_file: generic/file
-    # type=file: The output affine file
-    # type=file|default=<undefined>: The output affine matrix file
-    res_file: generic/file
-    # type=file: The output transformed image
-    # type=file|default=<undefined>: The affine transformed floating image
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    ref_file:
-    # type=file|default=<undefined>: The input reference/target image
-    flo_file:
-    # type=file|default=<undefined>: The input floating/source image
-    nosym_flag:
-    # type=bool|default=False: Turn off symmetric registration
-    rig_only_flag:
-    # type=bool|default=False: Do only a rigid registration
-    aff_direct_flag:
-    # type=bool|default=False: Directly optimise the affine parameters
-    in_aff_file:
-    # type=file|default=<undefined>: The input affine transformation
-    rmask_file:
-    # type=file|default=<undefined>: The input reference mask
-    fmask_file:
-    # type=file|default=<undefined>: The input floating mask
-    maxit_val:
-    # type=range|default=0: Maximum number of iterations
-    ln_val:
-    # type=range|default=0: Number of resolution levels to create
-    lp_val:
-    # type=range|default=0: Number of resolution levels to perform
-    smoo_r_val:
-    # type=float|default=0.0: Amount of smoothing to apply to reference image
-    smoo_f_val:
-    # type=float|default=0.0: Amount of smoothing to apply to floating image
-    nac_flag:
-    # type=bool|default=False: Use nifti header to initialise transformation
-    cog_flag:
-    # type=bool|default=False: Use the masks centre of mass to initialise the transformation
-    v_val:
-    # type=range|default=0: Percent of blocks that are active
-    i_val:
-    # type=range|default=0: Percent of inlier blocks
-    ref_low_val:
-    # type=float|default=0.0: Lower threshold value on reference image
-    ref_up_val:
-    # type=float|default=0.0: Upper threshold value on reference image
-    flo_low_val:
-    # type=float|default=0.0: Lower threshold value on floating image
-    flo_up_val:
-    # type=float|default=0.0: Upper threshold value on floating image
-    platform_val:
-    # type=int|default=0: Platform index
-    gpuid_val:
-    # type=int|default=0: Device to use id
-    verbosity_off_flag:
-    # type=bool|default=False: Turn off verbose output
-    aff_file:
-    # type=file: The output affine file
-    # type=file|default=<undefined>: The output affine matrix file
-    res_file:
-    # type=file: The output transformed image
-    # type=file|default=<undefined>: The affine transformed floating image
-    omp_core_val:
-    # type=int|default=1: Number of openmp thread to use
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    ref_file:
-    # type=file|default=<undefined>: The input reference/target image
-    flo_file:
-    # type=file|default=<undefined>: The input floating/source image
-    rmask_file:
-    # type=file|default=<undefined>: The input reference mask
-    omp_core_val: '4'
-    # type=int|default=1: Number of openmp thread to use
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests:
-- cmdline: reg_aladin -aff im2_aff.txt -flo im2.nii -omp 4 -ref im1.nii -res im2_res.nii.gz -rmask mask.nii
-  # str - the expected cmdline output
-  inputs:
-  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
-  # If the field is of file-format type and the value is None, then the
-  # '.mock()' method of the corresponding class is used instead.
-    ref_file:
-    # type=file|default=<undefined>: The input reference/target image
-    flo_file:
-    # type=file|default=<undefined>: The input floating/source image
-    rmask_file:
-    # type=file|default=<undefined>: The input reference mask
-    omp_core_val: '4'
-    # type=int|default=1: Number of openmp thread to use
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  directive:
-  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-niftyreg/reg_aladin_callables.py b/example-specs/task/nipype_internal/pydra-niftyreg/reg_aladin_callables.py
deleted file mode 100644
index e482a6d4..00000000
--- a/example-specs/task/nipype_internal/pydra-niftyreg/reg_aladin_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in RegAladin.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-niftyreg/reg_average.yaml b/example-specs/task/nipype_internal/pydra-niftyreg/reg_average.yaml
deleted file mode 100644
index 59dca0d3..00000000
--- a/example-specs/task/nipype_internal/pydra-niftyreg/reg_average.yaml
+++ /dev/null
@@ -1,161 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.niftyreg.regutils.RegAverage' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Interface for executable reg_average from NiftyReg platform.
-# 
-#     Compute average matrix or image from a list of matrices or image.
-#     The tool can be use to resample images given input transformation
-#     parametrisation as well as to demean transformations in Euclidean or
-#     log-Euclidean space.
-# 
-#     This interface is different than the others in the way that the options
-#     will be written in a command file that is given as a parameter.
-# 
-#     `Source code <https://cmiclab.cs.ucl.ac.uk/mmodat/niftyreg>`_
-# 
-#     Examples
-#     --------
-# 
-#     >>> from nipype.interfaces import niftyreg
-#     >>> node = niftyreg.RegAverage()
-#     >>> one_file = 'im1.nii'
-#     >>> two_file = 'im2.nii'
-#     >>> three_file = 'im3.nii'
-#     >>> node.inputs.avg_files = [one_file, two_file, three_file]
-#     >>> node.cmdline  # doctest: +ELLIPSIS
-#     'reg_average --cmd_file .../reg_average_cmd'
-#     
-task_name: RegAverage
-nipype_name: RegAverage
-nipype_module: nipype.interfaces.niftyreg.regutils
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    avg_files: generic/file+list-of
-    # type=list|default=[]: Averaging of images/affine transformations
-    avg_lts_files: generic/file+list-of
-    # type=list|default=[]: Robust average of affine transformations
-    avg_ref_file: generic/file
-    # type=file|default=<undefined>: All input images are resampled into the space of <reference image> and averaged. A cubic spline interpolation scheme is used for resampling
-    demean1_ref_file: generic/file
-    # type=file|default=<undefined>: Average images and demean average image that have affine transformations to a common space
-    demean2_ref_file: generic/file
-    # type=file|default=<undefined>: Average images and demean average image that have non-rigid transformations to a common space
-    demean3_ref_file: generic/file
-    # type=file|default=<undefined>: Average images and demean average image that have linear and non-rigid transformations to a common space
-    warp_files: generic/file+list-of
-    # type=list|default=[]: transformation files and floating image pairs/triplets to the reference space
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    out_file: generic/file
-    # type=file: Output file name
-    # type=file|default=<undefined>: Output file name
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    out_file: out_file
-    # type=file: Output file name
-    # type=file|default=<undefined>: Output file name
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    avg_files:
-    # type=list|default=[]: Averaging of images/affine transformations
-    avg_lts_files:
-    # type=list|default=[]: Robust average of affine transformations
-    avg_ref_file:
-    # type=file|default=<undefined>: All input images are resampled into the space of <reference image> and averaged. A cubic spline interpolation scheme is used for resampling
-    demean1_ref_file:
-    # type=file|default=<undefined>: Average images and demean average image that have affine transformations to a common space
-    demean2_ref_file:
-    # type=file|default=<undefined>: Average images and demean average image that have non-rigid transformations to a common space
-    demean3_ref_file:
-    # type=file|default=<undefined>: Average images and demean average image that have linear and non-rigid transformations to a common space
-    warp_files:
-    # type=list|default=[]: transformation files and floating image pairs/triplets to the reference space
-    out_file:
-    # type=file: Output file name
-    # type=file|default=<undefined>: Output file name
-    omp_core_val:
-    # type=int|default=1: Number of openmp thread to use
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    avg_files:
-    # type=list|default=[]: Averaging of images/affine transformations
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests:
-- cmdline: reg_average --cmd_file .../reg_average_cmd
-  # str - the expected cmdline output
-  inputs:
-  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
-  # If the field is of file-format type and the value is None, then the
-  # '.mock()' method of the corresponding class is used instead.
-    avg_files:
-    # type=list|default=[]: Averaging of images/affine transformations
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  directive:
-  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-niftyreg/reg_average_callables.py b/example-specs/task/nipype_internal/pydra-niftyreg/reg_average_callables.py
deleted file mode 100644
index c1a8b396..00000000
--- a/example-specs/task/nipype_internal/pydra-niftyreg/reg_average_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in RegAverage.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-niftyreg/reg_f3d.yaml b/example-specs/task/nipype_internal/pydra-niftyreg/reg_f3d.yaml
deleted file mode 100644
index d78f7817..00000000
--- a/example-specs/task/nipype_internal/pydra-niftyreg/reg_f3d.yaml
+++ /dev/null
@@ -1,262 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.niftyreg.reg.RegF3D' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Interface for executable reg_f3d from NiftyReg platform.
-# 
-#     Fast Free-Form Deformation (F3D) algorithm for non-rigid registration.
-#     Initially based on Modat et al., "Fast Free-Form Deformation using
-#     graphics processing units", CMPB, 2010
-# 
-#     `Source code <https://cmiclab.cs.ucl.ac.uk/mmodat/niftyreg>`_
-# 
-#     Examples
-#     --------
-#     >>> from nipype.interfaces import niftyreg
-#     >>> node = niftyreg.RegF3D()
-#     >>> node.inputs.ref_file = 'im1.nii'
-#     >>> node.inputs.flo_file = 'im2.nii'
-#     >>> node.inputs.rmask_file = 'mask.nii'
-#     >>> node.inputs.omp_core_val = 4
-#     >>> node.cmdline
-#     'reg_f3d -cpp im2_cpp.nii.gz -flo im2.nii -omp 4 -ref im1.nii -res im2_res.nii.gz -rmask mask.nii'
-# 
-#     
-task_name: RegF3D
-nipype_name: RegF3D
-nipype_module: nipype.interfaces.niftyreg.reg
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    ref_file: medimage/nifti1
-    # type=file|default=<undefined>: The input reference/target image
-    flo_file: medimage/nifti1
-    # type=file|default=<undefined>: The input floating/source image
-    aff_file: generic/file
-    # type=file|default=<undefined>: The input affine transformation file
-    incpp_file: generic/file
-    # type=file|default=<undefined>: The input cpp transformation file
-    rmask_file: medimage/nifti1
-    # type=file|default=<undefined>: Reference image mask
-    fmask_file: generic/file
-    # type=file|default=<undefined>: Floating image mask
-    cpp_file: generic/file
-    # type=file: The output CPP file
-    # type=file|default=<undefined>: The output CPP file
-    res_file: generic/file
-    # type=file: The output resampled image
-    # type=file|default=<undefined>: The output resampled image
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    cpp_file: generic/file
-    # type=file: The output CPP file
-    # type=file|default=<undefined>: The output CPP file
-    res_file: generic/file
-    # type=file: The output resampled image
-    # type=file|default=<undefined>: The output resampled image
-    invcpp_file: generic/file
-    # type=file: The output inverse CPP file
-    invres_file: generic/file
-    # type=file: The output inverse res file
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    ref_file:
-    # type=file|default=<undefined>: The input reference/target image
-    flo_file:
-    # type=file|default=<undefined>: The input floating/source image
-    aff_file:
-    # type=file|default=<undefined>: The input affine transformation file
-    incpp_file:
-    # type=file|default=<undefined>: The input cpp transformation file
-    rmask_file:
-    # type=file|default=<undefined>: Reference image mask
-    ref_smooth_val:
-    # type=float|default=0.0: Smoothing kernel width for reference image
-    flo_smooth_val:
-    # type=float|default=0.0: Smoothing kernel width for floating image
-    rlwth_thr_val:
-    # type=float|default=0.0: Lower threshold for reference image
-    rupth_thr_val:
-    # type=float|default=0.0: Upper threshold for reference image
-    flwth_thr_val:
-    # type=float|default=0.0: Lower threshold for floating image
-    fupth_thr_val:
-    # type=float|default=0.0: Upper threshold for floating image
-    rlwth2_thr_val:
-    # type=tuple|default=(0, 0.0): Lower threshold for reference image at the specified time point
-    rupth2_thr_val:
-    # type=tuple|default=(0, 0.0): Upper threshold for reference image at the specified time point
-    flwth2_thr_val:
-    # type=tuple|default=(0, 0.0): Lower threshold for floating image at the specified time point
-    fupth2_thr_val:
-    # type=tuple|default=(0, 0.0): Upper threshold for floating image at the specified time point
-    sx_val:
-    # type=float|default=0.0: Final grid spacing along the x axes
-    sy_val:
-    # type=float|default=0.0: Final grid spacing along the y axes
-    sz_val:
-    # type=float|default=0.0: Final grid spacing along the z axes
-    be_val:
-    # type=float|default=0.0: Bending energy value
-    le_val:
-    # type=float|default=0.0: Linear elasticity penalty term
-    jl_val:
-    # type=float|default=0.0: Log of jacobian of deformation penalty value
-    no_app_jl_flag:
-    # type=bool|default=False: Do not approximate the log of jacobian penalty at control points only
-    nmi_flag:
-    # type=bool|default=False: use NMI even when other options are specified
-    rbn_val:
-    # type=range|default=0: Number of bins in the histogram for reference image
-    fbn_val:
-    # type=range|default=0: Number of bins in the histogram for reference image
-    rbn2_val:
-    # type=tuple|default=(0, 0): Number of bins in the histogram for reference image for given time point
-    fbn2_val:
-    # type=tuple|default=(0, 0): Number of bins in the histogram for reference image for given time point
-    lncc_val:
-    # type=float|default=0.0: SD of the Gaussian for computing LNCC
-    lncc2_val:
-    # type=tuple|default=(0, 0.0): SD of the Gaussian for computing LNCC for a given time point
-    ssd_flag:
-    # type=bool|default=False: Use SSD as the similarity measure
-    ssd2_flag:
-    # type=range|default=0: Use SSD as the similarity measure for a given time point
-    kld_flag:
-    # type=bool|default=False: Use KL divergence as the similarity measure
-    kld2_flag:
-    # type=range|default=0: Use KL divergence as the similarity measure for a given time point
-    amc_flag:
-    # type=bool|default=False: Use additive NMI
-    nox_flag:
-    # type=bool|default=False: Don't optimise in x direction
-    noy_flag:
-    # type=bool|default=False: Don't optimise in y direction
-    noz_flag:
-    # type=bool|default=False: Don't optimise in z direction
-    maxit_val:
-    # type=range|default=0: Maximum number of iterations per level
-    ln_val:
-    # type=range|default=0: Number of resolution levels to create
-    lp_val:
-    # type=range|default=0: Number of resolution levels to perform
-    nopy_flag:
-    # type=bool|default=False: Do not use the multiresolution approach
-    noconj_flag:
-    # type=bool|default=False: Use simple GD optimization
-    pert_val:
-    # type=range|default=0: Add perturbation steps after each optimization step
-    vel_flag:
-    # type=bool|default=False: Use velocity field integration
-    fmask_file:
-    # type=file|default=<undefined>: Floating image mask
-    smooth_grad_val:
-    # type=float|default=0.0: Kernel width for smoothing the metric gradient
-    pad_val:
-    # type=float|default=0.0: Padding value
-    verbosity_off_flag:
-    # type=bool|default=False: Turn off verbose output
-    cpp_file:
-    # type=file: The output CPP file
-    # type=file|default=<undefined>: The output CPP file
-    res_file:
-    # type=file: The output resampled image
-    # type=file|default=<undefined>: The output resampled image
-    omp_core_val:
-    # type=int|default=1: Number of openmp thread to use
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    ref_file:
-    # type=file|default=<undefined>: The input reference/target image
-    flo_file:
-    # type=file|default=<undefined>: The input floating/source image
-    rmask_file:
-    # type=file|default=<undefined>: Reference image mask
-    omp_core_val: '4'
-    # type=int|default=1: Number of openmp thread to use
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests:
-- cmdline: reg_f3d -cpp im2_cpp.nii.gz -flo im2.nii -omp 4 -ref im1.nii -res im2_res.nii.gz -rmask mask.nii
-  # str - the expected cmdline output
-  inputs:
-  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
-  # If the field is of file-format type and the value is None, then the
-  # '.mock()' method of the corresponding class is used instead.
-    ref_file:
-    # type=file|default=<undefined>: The input reference/target image
-    flo_file:
-    # type=file|default=<undefined>: The input floating/source image
-    rmask_file:
-    # type=file|default=<undefined>: Reference image mask
-    omp_core_val: '4'
-    # type=int|default=1: Number of openmp thread to use
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  directive:
-  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-niftyreg/reg_f3d_callables.py b/example-specs/task/nipype_internal/pydra-niftyreg/reg_f3d_callables.py
deleted file mode 100644
index b176f3c6..00000000
--- a/example-specs/task/nipype_internal/pydra-niftyreg/reg_f3d_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in RegF3D.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-niftyreg/reg_jacobian.yaml b/example-specs/task/nipype_internal/pydra-niftyreg/reg_jacobian.yaml
deleted file mode 100644
index 68012a34..00000000
--- a/example-specs/task/nipype_internal/pydra-niftyreg/reg_jacobian.yaml
+++ /dev/null
@@ -1,145 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.niftyreg.regutils.RegJacobian' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Interface for executable reg_resample from NiftyReg platform.
-# 
-#     Tool to generate Jacobian determinant maps from transformation
-#     parametrisation generated by reg_f3d
-# 
-#     `Source code <https://cmiclab.cs.ucl.ac.uk/mmodat/niftyreg>`_
-# 
-#     Examples
-#     --------
-#     >>> from nipype.interfaces import niftyreg
-#     >>> node = niftyreg.RegJacobian()
-#     >>> node.inputs.ref_file = 'im1.nii'
-#     >>> node.inputs.trans_file = 'warpfield.nii'
-#     >>> node.inputs.omp_core_val = 4
-#     >>> node.cmdline
-#     'reg_jacobian -omp 4 -ref im1.nii -trans warpfield.nii -jac warpfield_jac.nii.gz'
-# 
-#     
-task_name: RegJacobian
-nipype_name: RegJacobian
-nipype_module: nipype.interfaces.niftyreg.regutils
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    ref_file: medimage/nifti1
-    # type=file|default=<undefined>: Reference/target file (required if specifying CPP transformations.
-    trans_file: medimage/nifti1
-    # type=file|default=<undefined>: The input non-rigid transformation
-    out_file: generic/file
-    # type=file: The output file
-    # type=file|default=<undefined>: The output jacobian determinant file name
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    out_file: generic/file
-    # type=file: The output file
-    # type=file|default=<undefined>: The output jacobian determinant file name
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    ref_file:
-    # type=file|default=<undefined>: Reference/target file (required if specifying CPP transformations.
-    trans_file:
-    # type=file|default=<undefined>: The input non-rigid transformation
-    type:
-    # type=enum|default='jac'|allowed['jac','jacL','jacM']: Type of jacobian outcome
-    out_file:
-    # type=file: The output file
-    # type=file|default=<undefined>: The output jacobian determinant file name
-    omp_core_val:
-    # type=int|default=1: Number of openmp thread to use
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    ref_file:
-    # type=file|default=<undefined>: Reference/target file (required if specifying CPP transformations.
-    trans_file:
-    # type=file|default=<undefined>: The input non-rigid transformation
-    omp_core_val: '4'
-    # type=int|default=1: Number of openmp thread to use
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests:
-- cmdline: reg_jacobian -omp 4 -ref im1.nii -trans warpfield.nii -jac warpfield_jac.nii.gz
-  # str - the expected cmdline output
-  inputs:
-  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
-  # If the field is of file-format type and the value is None, then the
-  # '.mock()' method of the corresponding class is used instead.
-    ref_file:
-    # type=file|default=<undefined>: Reference/target file (required if specifying CPP transformations.
-    trans_file:
-    # type=file|default=<undefined>: The input non-rigid transformation
-    omp_core_val: '4'
-    # type=int|default=1: Number of openmp thread to use
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  directive:
-  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-niftyreg/reg_jacobian_callables.py b/example-specs/task/nipype_internal/pydra-niftyreg/reg_jacobian_callables.py
deleted file mode 100644
index a8426361..00000000
--- a/example-specs/task/nipype_internal/pydra-niftyreg/reg_jacobian_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in RegJacobian.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-niftyreg/reg_measure.yaml b/example-specs/task/nipype_internal/pydra-niftyreg/reg_measure.yaml
deleted file mode 100644
index b2f3bae5..00000000
--- a/example-specs/task/nipype_internal/pydra-niftyreg/reg_measure.yaml
+++ /dev/null
@@ -1,149 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.niftyreg.regutils.RegMeasure' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Interface for executable reg_measure from NiftyReg platform.
-# 
-#     Given two input images, compute the specified measure(s) of similarity
-# 
-#     `Source code <https://cmiclab.cs.ucl.ac.uk/mmodat/niftyreg>`_
-# 
-#     Examples
-#     --------
-#     >>> from nipype.interfaces import niftyreg
-#     >>> node = niftyreg.RegMeasure()
-#     >>> node.inputs.ref_file = 'im1.nii'
-#     >>> node.inputs.flo_file = 'im2.nii'
-#     >>> node.inputs.measure_type = 'lncc'
-#     >>> node.inputs.omp_core_val = 4
-#     >>> node.cmdline
-#     'reg_measure -flo im2.nii -lncc -omp 4 -out im2_lncc.txt -ref im1.nii'
-# 
-#     
-task_name: RegMeasure
-nipype_name: RegMeasure
-nipype_module: nipype.interfaces.niftyreg.regutils
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    ref_file: medimage/nifti1
-    # type=file|default=<undefined>: The input reference/target image
-    flo_file: medimage/nifti1
-    # type=file|default=<undefined>: The input floating/source image
-    out_file: generic/file
-    # type=file: The output text file containing the measure
-    # type=file|default=<undefined>: The output text file containing the measure
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    out_file: generic/file
-    # type=file: The output text file containing the measure
-    # type=file|default=<undefined>: The output text file containing the measure
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    ref_file:
-    # type=file|default=<undefined>: The input reference/target image
-    flo_file:
-    # type=file|default=<undefined>: The input floating/source image
-    measure_type:
-    # type=enum|default='ncc'|allowed['lncc','ncc','nmi','ssd']: Measure of similarity to compute
-    out_file:
-    # type=file: The output text file containing the measure
-    # type=file|default=<undefined>: The output text file containing the measure
-    omp_core_val:
-    # type=int|default=1: Number of openmp thread to use
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    ref_file:
-    # type=file|default=<undefined>: The input reference/target image
-    flo_file:
-    # type=file|default=<undefined>: The input floating/source image
-    measure_type: '"lncc"'
-    # type=enum|default='ncc'|allowed['lncc','ncc','nmi','ssd']: Measure of similarity to compute
-    omp_core_val: '4'
-    # type=int|default=1: Number of openmp thread to use
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests:
-- cmdline: reg_measure -flo im2.nii -lncc -omp 4 -out im2_lncc.txt -ref im1.nii
-  # str - the expected cmdline output
-  inputs:
-  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
-  # If the field is of file-format type and the value is None, then the
-  # '.mock()' method of the corresponding class is used instead.
-    ref_file:
-    # type=file|default=<undefined>: The input reference/target image
-    flo_file:
-    # type=file|default=<undefined>: The input floating/source image
-    measure_type: '"lncc"'
-    # type=enum|default='ncc'|allowed['lncc','ncc','nmi','ssd']: Measure of similarity to compute
-    omp_core_val: '4'
-    # type=int|default=1: Number of openmp thread to use
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  directive:
-  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-niftyreg/reg_measure_callables.py b/example-specs/task/nipype_internal/pydra-niftyreg/reg_measure_callables.py
deleted file mode 100644
index c352e88c..00000000
--- a/example-specs/task/nipype_internal/pydra-niftyreg/reg_measure_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in RegMeasure.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-niftyreg/reg_resample.yaml b/example-specs/task/nipype_internal/pydra-niftyreg/reg_resample.yaml
deleted file mode 100644
index 31ade135..00000000
--- a/example-specs/task/nipype_internal/pydra-niftyreg/reg_resample.yaml
+++ /dev/null
@@ -1,172 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.niftyreg.regutils.RegResample' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Interface for executable reg_resample from NiftyReg platform.
-# 
-#     Tool to resample floating image in the space of a defined reference image
-#     given a transformation parametrisation generated by reg_aladin, reg_f3d or
-#     reg_transform
-# 
-#     `Source code <https://cmiclab.cs.ucl.ac.uk/mmodat/niftyreg>`_
-# 
-#     Examples
-#     --------
-#     >>> from nipype.interfaces import niftyreg
-#     >>> node = niftyreg.RegResample()
-#     >>> node.inputs.ref_file = 'im1.nii'
-#     >>> node.inputs.flo_file = 'im2.nii'
-#     >>> node.inputs.trans_file = 'warpfield.nii'
-#     >>> node.inputs.inter_val = 'LIN'
-#     >>> node.inputs.omp_core_val = 4
-#     >>> node.cmdline
-#     'reg_resample -flo im2.nii -inter 1 -omp 4 -ref im1.nii -trans warpfield.nii -res im2_res.nii.gz'
-# 
-#     
-task_name: RegResample
-nipype_name: RegResample
-nipype_module: nipype.interfaces.niftyreg.regutils
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    ref_file: medimage/nifti1
-    # type=file|default=<undefined>: The input reference/target image
-    flo_file: medimage/nifti1
-    # type=file|default=<undefined>: The input floating/source image
-    trans_file: medimage/nifti1
-    # type=file|default=<undefined>: The input transformation file
-    out_file: generic/file
-    # type=file: The output filename of the transformed image
-    # type=file|default=<undefined>: The output filename of the transformed image
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    out_file: generic/file
-    # type=file: The output filename of the transformed image
-    # type=file|default=<undefined>: The output filename of the transformed image
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    ref_file:
-    # type=file|default=<undefined>: The input reference/target image
-    flo_file:
-    # type=file|default=<undefined>: The input floating/source image
-    trans_file:
-    # type=file|default=<undefined>: The input transformation file
-    type:
-    # type=enum|default='res'|allowed['blank','res']: Type of output
-    out_file:
-    # type=file: The output filename of the transformed image
-    # type=file|default=<undefined>: The output filename of the transformed image
-    inter_val:
-    # type=enum|default='NN'|allowed['CUB','LIN','NN','SINC']: Interpolation type
-    pad_val:
-    # type=float|default=0.0: Padding value
-    tensor_flag:
-    # type=bool|default=False: Resample Tensor Map
-    verbosity_off_flag:
-    # type=bool|default=False: Turn off verbose output
-    psf_flag:
-    # type=bool|default=False: Perform the resampling in two steps to resample an image to a lower resolution
-    psf_alg:
-    # type=enum|default=0|allowed[0,1]: Minimise the matrix metric (0) or the determinant (1) when estimating the PSF [0]
-    omp_core_val:
-    # type=int|default=1: Number of openmp thread to use
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    ref_file:
-    # type=file|default=<undefined>: The input reference/target image
-    flo_file:
-    # type=file|default=<undefined>: The input floating/source image
-    trans_file:
-    # type=file|default=<undefined>: The input transformation file
-    inter_val: '"LIN"'
-    # type=enum|default='NN'|allowed['CUB','LIN','NN','SINC']: Interpolation type
-    omp_core_val: '4'
-    # type=int|default=1: Number of openmp thread to use
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests:
-- cmdline: reg_resample -flo im2.nii -inter 1 -omp 4 -ref im1.nii -trans warpfield.nii -res im2_res.nii.gz
-  # str - the expected cmdline output
-  inputs:
-  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
-  # If the field is of file-format type and the value is None, then the
-  # '.mock()' method of the corresponding class is used instead.
-    ref_file:
-    # type=file|default=<undefined>: The input reference/target image
-    flo_file:
-    # type=file|default=<undefined>: The input floating/source image
-    trans_file:
-    # type=file|default=<undefined>: The input transformation file
-    inter_val: '"LIN"'
-    # type=enum|default='NN'|allowed['CUB','LIN','NN','SINC']: Interpolation type
-    omp_core_val: '4'
-    # type=int|default=1: Number of openmp thread to use
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  directive:
-  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-niftyreg/reg_resample_callables.py b/example-specs/task/nipype_internal/pydra-niftyreg/reg_resample_callables.py
deleted file mode 100644
index 0ed41722..00000000
--- a/example-specs/task/nipype_internal/pydra-niftyreg/reg_resample_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in RegResample.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-niftyreg/reg_tools.yaml b/example-specs/task/nipype_internal/pydra-niftyreg/reg_tools.yaml
deleted file mode 100644
index 6cdafe68..00000000
--- a/example-specs/task/nipype_internal/pydra-niftyreg/reg_tools.yaml
+++ /dev/null
@@ -1,174 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.niftyreg.regutils.RegTools' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Interface for executable reg_tools from NiftyReg platform.
-# 
-#     Tool delivering various actions related to registration such as
-#     resampling the input image to a chosen resolution or remove the nan and
-#     inf in the input image by a specified value.
-# 
-#     `Source code <https://cmiclab.cs.ucl.ac.uk/mmodat/niftyreg>`_
-# 
-#     Examples
-#     --------
-#     >>> from nipype.interfaces import niftyreg
-#     >>> node = niftyreg.RegTools()
-#     >>> node.inputs.in_file = 'im1.nii'
-#     >>> node.inputs.mul_val = 4
-#     >>> node.inputs.omp_core_val = 4
-#     >>> node.cmdline
-#     'reg_tools -in im1.nii -mul 4.0 -omp 4 -out im1_tools.nii.gz'
-# 
-#     
-task_name: RegTools
-nipype_name: RegTools
-nipype_module: nipype.interfaces.niftyreg.regutils
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_file: medimage/nifti1
-    # type=file|default=<undefined>: The input image file path
-    out_file: generic/file
-    # type=file: The output file
-    # type=file|default=<undefined>: The output file name
-    mask_file: generic/file
-    # type=file|default=<undefined>: Values outside the mask are set to NaN
-    rms_val: generic/file
-    # type=file|default=<undefined>: Compute the mean RMS between the images
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    out_file: generic/file
-    # type=file: The output file
-    # type=file|default=<undefined>: The output file name
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: The input image file path
-    out_file:
-    # type=file: The output file
-    # type=file|default=<undefined>: The output file name
-    iso_flag:
-    # type=bool|default=False: Make output image isotropic
-    noscl_flag:
-    # type=bool|default=False: Set scale, slope to 0 and 1
-    mask_file:
-    # type=file|default=<undefined>: Values outside the mask are set to NaN
-    thr_val:
-    # type=float|default=0.0: Binarise the input image with the given threshold
-    bin_flag:
-    # type=bool|default=False: Binarise the input image
-    rms_val:
-    # type=file|default=<undefined>: Compute the mean RMS between the images
-    div_val:
-    # type=traitcompound|default=None: Divide the input by image or value
-    mul_val:
-    # type=traitcompound|default=None: Multiply the input by image or value
-    add_val:
-    # type=traitcompound|default=None: Add to the input image or value
-    sub_val:
-    # type=traitcompound|default=None: Add to the input image or value
-    down_flag:
-    # type=bool|default=False: Downsample the image by a factor of 2
-    smo_s_val:
-    # type=tuple|default=(0.0, 0.0, 0.0): Smooth the input image using a cubic spline kernel
-    chg_res_val:
-    # type=tuple|default=(0.0, 0.0, 0.0): Change the resolution of the input image
-    smo_g_val:
-    # type=tuple|default=(0.0, 0.0, 0.0): Smooth the input image using a Gaussian kernel
-    inter_val:
-    # type=enum|default='NN'|allowed['CUB','LIN','NN','SINC']: Interpolation order to use to warp the floating image
-    omp_core_val:
-    # type=int|default=1: Number of openmp thread to use
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: The input image file path
-    mul_val: '4'
-    # type=traitcompound|default=None: Multiply the input by image or value
-    omp_core_val: '4'
-    # type=int|default=1: Number of openmp thread to use
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests:
-- cmdline: reg_tools -in im1.nii -mul 4.0 -omp 4 -out im1_tools.nii.gz
-  # str - the expected cmdline output
-  inputs:
-  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
-  # If the field is of file-format type and the value is None, then the
-  # '.mock()' method of the corresponding class is used instead.
-    in_file:
-    # type=file|default=<undefined>: The input image file path
-    mul_val: '4'
-    # type=traitcompound|default=None: Multiply the input by image or value
-    omp_core_val: '4'
-    # type=int|default=1: Number of openmp thread to use
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  directive:
-  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-niftyreg/reg_tools_callables.py b/example-specs/task/nipype_internal/pydra-niftyreg/reg_tools_callables.py
deleted file mode 100644
index ff12b1cf..00000000
--- a/example-specs/task/nipype_internal/pydra-niftyreg/reg_tools_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in RegTools.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-niftyreg/reg_transform.yaml b/example-specs/task/nipype_internal/pydra-niftyreg/reg_transform.yaml
deleted file mode 100644
index 619d24ad..00000000
--- a/example-specs/task/nipype_internal/pydra-niftyreg/reg_transform.yaml
+++ /dev/null
@@ -1,184 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.niftyreg.regutils.RegTransform' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Interface for executable reg_transform from NiftyReg platform.
-# 
-#     Tools to convert transformation parametrisation from one type to another
-#     as well as to compose, inverse or half transformations.
-# 
-#     `Source code <https://cmiclab.cs.ucl.ac.uk/mmodat/niftyreg>`_
-# 
-#     Examples
-#     --------
-#     >>> from nipype.interfaces import niftyreg
-#     >>> node = niftyreg.RegTransform()
-#     >>> node.inputs.def_input = 'warpfield.nii'
-#     >>> node.inputs.omp_core_val = 4
-#     >>> node.cmdline  # doctest: +ELLIPSIS
-#     'reg_transform -omp 4 -def warpfield.nii .../warpfield_trans.nii.gz'
-# 
-#     
-task_name: RegTransform
-nipype_name: RegTransform
-nipype_module: nipype.interfaces.niftyreg.regutils
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    ref1_file: generic/file
-    # type=file|default=<undefined>: The input reference/target image
-    ref2_file: generic/file
-    # type=file|default=<undefined>: The input second reference/target image
-    def_input: medimage/nifti1
-    # type=file|default=<undefined>: Compute deformation field from transformation
-    disp_input: generic/file
-    # type=file|default=<undefined>: Compute displacement field from transformation
-    flow_input: generic/file
-    # type=file|default=<undefined>: Compute flow field from spline SVF
-    comp_input: generic/file
-    # type=file|default=<undefined>: compose two transformations
-    comp_input2: generic/file
-    # type=file|default=<undefined>: compose two transformations
-    upd_s_form_input: generic/file
-    # type=file|default=<undefined>: Update s-form using the affine transformation
-    upd_s_form_input2: generic/file
-    # type=file|default=<undefined>: Update s-form using the affine transformation
-    inv_aff_input: generic/file
-    # type=file|default=<undefined>: Invert an affine transformation
-    half_input: generic/file
-    # type=file|default=<undefined>: Half way to the input transformation
-    aff_2_rig_input: generic/file
-    # type=file|default=<undefined>: Extract the rigid component from affine transformation
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    out_file: generic/file
-    # type=file: Output File (transformation in any format)
-    # type=file|default=<undefined>: transformation file to write
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    out_file: out_file
-    # type=file: Output File (transformation in any format)
-    # type=file|default=<undefined>: transformation file to write
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    ref1_file:
-    # type=file|default=<undefined>: The input reference/target image
-    ref2_file:
-    # type=file|default=<undefined>: The input second reference/target image
-    def_input:
-    # type=file|default=<undefined>: Compute deformation field from transformation
-    disp_input:
-    # type=file|default=<undefined>: Compute displacement field from transformation
-    flow_input:
-    # type=file|default=<undefined>: Compute flow field from spline SVF
-    comp_input:
-    # type=file|default=<undefined>: compose two transformations
-    comp_input2:
-    # type=file|default=<undefined>: compose two transformations
-    upd_s_form_input:
-    # type=file|default=<undefined>: Update s-form using the affine transformation
-    upd_s_form_input2:
-    # type=file|default=<undefined>: Update s-form using the affine transformation
-    inv_aff_input:
-    # type=file|default=<undefined>: Invert an affine transformation
-    inv_nrr_input:
-    # type=tuple|default=(<undefined>, <undefined>): Invert a non-linear transformation
-    half_input:
-    # type=file|default=<undefined>: Half way to the input transformation
-    make_aff_input:
-    # type=tuple|default=(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0): Make an affine transformation matrix
-    aff_2_rig_input:
-    # type=file|default=<undefined>: Extract the rigid component from affine transformation
-    flirt_2_nr_input:
-    # type=tuple|default=(<undefined>, <undefined>, <undefined>): Convert a FLIRT affine transformation to niftyreg affine transformation
-    out_file:
-    # type=file: Output File (transformation in any format)
-    # type=file|default=<undefined>: transformation file to write
-    omp_core_val:
-    # type=int|default=1: Number of openmp thread to use
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    def_input:
-    # type=file|default=<undefined>: Compute deformation field from transformation
-    omp_core_val: '4'
-    # type=int|default=1: Number of openmp thread to use
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests:
-- cmdline: reg_transform -omp 4 -def warpfield.nii .../warpfield_trans.nii.gz
-  # str - the expected cmdline output
-  inputs:
-  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
-  # If the field is of file-format type and the value is None, then the
-  # '.mock()' method of the corresponding class is used instead.
-    def_input:
-    # type=file|default=<undefined>: Compute deformation field from transformation
-    omp_core_val: '4'
-    # type=int|default=1: Number of openmp thread to use
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  directive:
-  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-niftyreg/reg_transform_callables.py b/example-specs/task/nipype_internal/pydra-niftyreg/reg_transform_callables.py
deleted file mode 100644
index 42c8ed3a..00000000
--- a/example-specs/task/nipype_internal/pydra-niftyreg/reg_transform_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in RegTransform.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-niftyseg/binary_maths.yaml b/example-specs/task/nipype_internal/pydra-niftyseg/binary_maths.yaml
deleted file mode 100644
index a34abc4b..00000000
--- a/example-specs/task/nipype_internal/pydra-niftyseg/binary_maths.yaml
+++ /dev/null
@@ -1,295 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.niftyseg.maths.BinaryMaths' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Binary mathematical operations.
-# 
-#     See Also
-#     --------
-#     `Source code <http://cmictig.cs.ucl.ac.uk/wiki/index.php/NiftySeg>`__ --
-#     `Documentation <http://cmictig.cs.ucl.ac.uk/wiki/index.php/NiftySeg_documentation>`__
-# 
-#     Examples
-#     --------
-#     >>> import copy
-#     >>> from nipype.interfaces import niftyseg
-#     >>> binary = niftyseg.BinaryMaths()
-#     >>> binary.inputs.in_file = 'im1.nii'
-#     >>> binary.inputs.output_datatype = 'float'
-# 
-#     >>> # Test sub operation
-#     >>> binary_sub = copy.deepcopy(binary)
-#     >>> binary_sub.inputs.operation = 'sub'
-#     >>> binary_sub.inputs.operand_file = 'im2.nii'
-#     >>> binary_sub.cmdline
-#     'seg_maths im1.nii -sub im2.nii -odt float im1_sub.nii'
-#     >>> binary_sub.run()  # doctest: +SKIP
-# 
-#     >>> # Test mul operation
-#     >>> binary_mul = copy.deepcopy(binary)
-#     >>> binary_mul.inputs.operation = 'mul'
-#     >>> binary_mul.inputs.operand_value = 2.0
-#     >>> binary_mul.cmdline
-#     'seg_maths im1.nii -mul 2.00000000 -odt float im1_mul.nii'
-#     >>> binary_mul.run()  # doctest: +SKIP
-# 
-#     >>> # Test llsnorm operation
-#     >>> binary_llsnorm = copy.deepcopy(binary)
-#     >>> binary_llsnorm.inputs.operation = 'llsnorm'
-#     >>> binary_llsnorm.inputs.operand_file = 'im2.nii'
-#     >>> binary_llsnorm.cmdline
-#     'seg_maths im1.nii -llsnorm im2.nii -odt float im1_llsnorm.nii'
-#     >>> binary_llsnorm.run()  # doctest: +SKIP
-# 
-#     >>> # Test splitinter operation
-#     >>> binary_splitinter = copy.deepcopy(binary)
-#     >>> binary_splitinter.inputs.operation = 'splitinter'
-#     >>> binary_splitinter.inputs.operand_str = 'z'
-#     >>> binary_splitinter.cmdline
-#     'seg_maths im1.nii -splitinter z -odt float im1_splitinter.nii'
-#     >>> binary_splitinter.run()  # doctest: +SKIP
-# 
-#     
-task_name: BinaryMaths
-nipype_name: BinaryMaths
-nipype_module: nipype.interfaces.niftyseg.maths
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    operand_file: medimage/nifti1
-    # type=file|default=<undefined>: second image to perform operation with
-    in_file: medimage/nifti1
-    # type=file|default=<undefined>: image to operate on
-    out_file: generic/file
-    # type=file: image written after calculations
-    # type=file|default=<undefined>: image to write
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    out_file: generic/file
-    # type=file: image written after calculations
-    # type=file|default=<undefined>: image to write
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    operation:
-    # type=enum|default='mul'|allowed['add','div','edge','geo','hdr_copy','llsnorm','masknan','min','mul','pow','smo','smol','sobel3','sobel5','splitinter','sub','thr','uthr']: Operation to perform:      * mul - <float/file> - Multiply image <float> value or by other image.     * div - <float/file> - Divide image by <float> or by other image.     * add - <float/file> - Add image by <float> or by other image.     * sub - <float/file> - Subtract image by <float> or by other image.     * pow - <float> - Image to the power of <float>.     * thr - <float> - Threshold the image below <float>.     * uthr - <float> - Threshold image above <float>.     * smo - <float> - Gaussian smoothing by std <float> (in voxels and up to 4-D).     * edge - <float> - Calculate the edges of the image using a threshold <float>.     * sobel3 - <float> - Calculate the edges of all timepoints using a Sobel filter       with a 3x3x3 kernel and applying <float> gaussian smoothing.     * sobel5 - <float> - Calculate the edges of all timepoints using a Sobel filter       with a 5x5x5 kernel and applying <float> gaussian smoothing.     * min - <file> - Get the min per voxel between <current> and <file>.     * smol - <float> - Gaussian smoothing of a 3D label image.     * geo - <float/file> - Geodesic distance according to the speed function <float/file>     * llsnorm  <file_norm> - Linear LS normalisation between current and <file_norm>     * masknan <file_norm> - Assign everything outside the mask (mask==0) with NaNs     * hdr_copy <file> - Copy header from working image to <file> and save in <output>.     * splitinter <x/y/z> - Split interleaved slices in direction <x/y/z>       into separate time points  
-    operand_file:
-    # type=file|default=<undefined>: second image to perform operation with
-    operand_value:
-    # type=float|default=0.0: float value to perform operation with
-    operand_str:
-    # type=enum|default='x'|allowed['x','y','z']: string value to perform operation splitinter
-    in_file:
-    # type=file|default=<undefined>: image to operate on
-    out_file:
-    # type=file: image written after calculations
-    # type=file|default=<undefined>: image to write
-    output_datatype:
-    # type=enum|default='float'|allowed['char','double','float','input','int','short']: datatype to use for output (default uses input type)
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: image to operate on
-    output_datatype: '"float"'
-    # type=enum|default='float'|allowed['char','double','float','input','int','short']: datatype to use for output (default uses input type)
-    operation: '"sub"'
-    # type=enum|default='mul'|allowed['add','div','edge','geo','hdr_copy','llsnorm','masknan','min','mul','pow','smo','smol','sobel3','sobel5','splitinter','sub','thr','uthr']: Operation to perform:      * mul - <float/file> - Multiply image <float> value or by other image.     * div - <float/file> - Divide image by <float> or by other image.     * add - <float/file> - Add image by <float> or by other image.     * sub - <float/file> - Subtract image by <float> or by other image.     * pow - <float> - Image to the power of <float>.     * thr - <float> - Threshold the image below <float>.     * uthr - <float> - Threshold image above <float>.     * smo - <float> - Gaussian smoothing by std <float> (in voxels and up to 4-D).     * edge - <float> - Calculate the edges of the image using a threshold <float>.     * sobel3 - <float> - Calculate the edges of all timepoints using a Sobel filter       with a 3x3x3 kernel and applying <float> gaussian smoothing.     * sobel5 - <float> - Calculate the edges of all timepoints using a Sobel filter       with a 5x5x5 kernel and applying <float> gaussian smoothing.     * min - <file> - Get the min per voxel between <current> and <file>.     * smol - <float> - Gaussian smoothing of a 3D label image.     * geo - <float/file> - Geodesic distance according to the speed function <float/file>     * llsnorm  <file_norm> - Linear LS normalisation between current and <file_norm>     * masknan <file_norm> - Assign everything outside the mask (mask==0) with NaNs     * hdr_copy <file> - Copy header from working image to <file> and save in <output>.     * splitinter <x/y/z> - Split interleaved slices in direction <x/y/z>       into separate time points  
-    operand_file:
-    # type=file|default=<undefined>: second image to perform operation with
-  imports: &id001
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  - module: copy
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    operation: '"mul"'
-    # type=enum|default='mul'|allowed['add','div','edge','geo','hdr_copy','llsnorm','masknan','min','mul','pow','smo','smol','sobel3','sobel5','splitinter','sub','thr','uthr']: Operation to perform:      * mul - <float/file> - Multiply image <float> value or by other image.     * div - <float/file> - Divide image by <float> or by other image.     * add - <float/file> - Add image by <float> or by other image.     * sub - <float/file> - Subtract image by <float> or by other image.     * pow - <float> - Image to the power of <float>.     * thr - <float> - Threshold the image below <float>.     * uthr - <float> - Threshold image above <float>.     * smo - <float> - Gaussian smoothing by std <float> (in voxels and up to 4-D).     * edge - <float> - Calculate the edges of the image using a threshold <float>.     * sobel3 - <float> - Calculate the edges of all timepoints using a Sobel filter       with a 3x3x3 kernel and applying <float> gaussian smoothing.     * sobel5 - <float> - Calculate the edges of all timepoints using a Sobel filter       with a 5x5x5 kernel and applying <float> gaussian smoothing.     * min - <file> - Get the min per voxel between <current> and <file>.     * smol - <float> - Gaussian smoothing of a 3D label image.     * geo - <float/file> - Geodesic distance according to the speed function <float/file>     * llsnorm  <file_norm> - Linear LS normalisation between current and <file_norm>     * masknan <file_norm> - Assign everything outside the mask (mask==0) with NaNs     * hdr_copy <file> - Copy header from working image to <file> and save in <output>.     * splitinter <x/y/z> - Split interleaved slices in direction <x/y/z>       into separate time points  
-    operand_value: '2.0'
-    # type=float|default=0.0: float value to perform operation with
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    operation: '"llsnorm"'
-    # type=enum|default='mul'|allowed['add','div','edge','geo','hdr_copy','llsnorm','masknan','min','mul','pow','smo','smol','sobel3','sobel5','splitinter','sub','thr','uthr']: Operation to perform:      * mul - <float/file> - Multiply image <float> value or by other image.     * div - <float/file> - Divide image by <float> or by other image.     * add - <float/file> - Add image by <float> or by other image.     * sub - <float/file> - Subtract image by <float> or by other image.     * pow - <float> - Image to the power of <float>.     * thr - <float> - Threshold the image below <float>.     * uthr - <float> - Threshold image above <float>.     * smo - <float> - Gaussian smoothing by std <float> (in voxels and up to 4-D).     * edge - <float> - Calculate the edges of the image using a threshold <float>.     * sobel3 - <float> - Calculate the edges of all timepoints using a Sobel filter       with a 3x3x3 kernel and applying <float> gaussian smoothing.     * sobel5 - <float> - Calculate the edges of all timepoints using a Sobel filter       with a 5x5x5 kernel and applying <float> gaussian smoothing.     * min - <file> - Get the min per voxel between <current> and <file>.     * smol - <float> - Gaussian smoothing of a 3D label image.     * geo - <float/file> - Geodesic distance according to the speed function <float/file>     * llsnorm  <file_norm> - Linear LS normalisation between current and <file_norm>     * masknan <file_norm> - Assign everything outside the mask (mask==0) with NaNs     * hdr_copy <file> - Copy header from working image to <file> and save in <output>.     * splitinter <x/y/z> - Split interleaved slices in direction <x/y/z>       into separate time points  
-    operand_file:
-    # type=file|default=<undefined>: second image to perform operation with
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    operation: '"splitinter"'
-    # type=enum|default='mul'|allowed['add','div','edge','geo','hdr_copy','llsnorm','masknan','min','mul','pow','smo','smol','sobel3','sobel5','splitinter','sub','thr','uthr']: Operation to perform:      * mul - <float/file> - Multiply image <float> value or by other image.     * div - <float/file> - Divide image by <float> or by other image.     * add - <float/file> - Add image by <float> or by other image.     * sub - <float/file> - Subtract image by <float> or by other image.     * pow - <float> - Image to the power of <float>.     * thr - <float> - Threshold the image below <float>.     * uthr - <float> - Threshold image above <float>.     * smo - <float> - Gaussian smoothing by std <float> (in voxels and up to 4-D).     * edge - <float> - Calculate the edges of the image using a threshold <float>.     * sobel3 - <float> - Calculate the edges of all timepoints using a Sobel filter       with a 3x3x3 kernel and applying <float> gaussian smoothing.     * sobel5 - <float> - Calculate the edges of all timepoints using a Sobel filter       with a 5x5x5 kernel and applying <float> gaussian smoothing.     * min - <file> - Get the min per voxel between <current> and <file>.     * smol - <float> - Gaussian smoothing of a 3D label image.     * geo - <float/file> - Geodesic distance according to the speed function <float/file>     * llsnorm  <file_norm> - Linear LS normalisation between current and <file_norm>     * masknan <file_norm> - Assign everything outside the mask (mask==0) with NaNs     * hdr_copy <file> - Copy header from working image to <file> and save in <output>.     * splitinter <x/y/z> - Split interleaved slices in direction <x/y/z>       into separate time points  
-    operand_str: '"z"'
-    # type=enum|default='x'|allowed['x','y','z']: string value to perform operation splitinter
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests:
-- cmdline: seg_maths im1.nii -sub im2.nii -odt float im1_sub.nii
-  # str - the expected cmdline output
-  inputs:
-  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
-  # If the field is of file-format type and the value is None, then the
-  # '.mock()' method of the corresponding class is used instead.
-    in_file:
-    # type=file|default=<undefined>: image to operate on
-    output_datatype: '"float"'
-    # type=enum|default='float'|allowed['char','double','float','input','int','short']: datatype to use for output (default uses input type)
-    operation: '"sub"'
-    # type=enum|default='mul'|allowed['add','div','edge','geo','hdr_copy','llsnorm','masknan','min','mul','pow','smo','smol','sobel3','sobel5','splitinter','sub','thr','uthr']: Operation to perform:      * mul - <float/file> - Multiply image <float> value or by other image.     * div - <float/file> - Divide image by <float> or by other image.     * add - <float/file> - Add image by <float> or by other image.     * sub - <float/file> - Subtract image by <float> or by other image.     * pow - <float> - Image to the power of <float>.     * thr - <float> - Threshold the image below <float>.     * uthr - <float> - Threshold image above <float>.     * smo - <float> - Gaussian smoothing by std <float> (in voxels and up to 4-D).     * edge - <float> - Calculate the edges of the image using a threshold <float>.     * sobel3 - <float> - Calculate the edges of all timepoints using a Sobel filter       with a 3x3x3 kernel and applying <float> gaussian smoothing.     * sobel5 - <float> - Calculate the edges of all timepoints using a Sobel filter       with a 5x5x5 kernel and applying <float> gaussian smoothing.     * min - <file> - Get the min per voxel between <current> and <file>.     * smol - <float> - Gaussian smoothing of a 3D label image.     * geo - <float/file> - Geodesic distance according to the speed function <float/file>     * llsnorm  <file_norm> - Linear LS normalisation between current and <file_norm>     * masknan <file_norm> - Assign everything outside the mask (mask==0) with NaNs     * hdr_copy <file> - Copy header from working image to <file> and save in <output>.     * splitinter <x/y/z> - Split interleaved slices in direction <x/y/z>       into separate time points  
-    operand_file:
-    # type=file|default=<undefined>: second image to perform operation with
-  imports: *id001
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  directive:
-  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
-- cmdline: seg_maths im1.nii -mul 2.00000000 -odt float im1_mul.nii
-  # str - the expected cmdline output
-  inputs:
-  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
-  # If the field is of file-format type and the value is None, then the
-  # '.mock()' method of the corresponding class is used instead.
-    operation: '"mul"'
-    # type=enum|default='mul'|allowed['add','div','edge','geo','hdr_copy','llsnorm','masknan','min','mul','pow','smo','smol','sobel3','sobel5','splitinter','sub','thr','uthr']: Operation to perform:      * mul - <float/file> - Multiply image <float> value or by other image.     * div - <float/file> - Divide image by <float> or by other image.     * add - <float/file> - Add image by <float> or by other image.     * sub - <float/file> - Subtract image by <float> or by other image.     * pow - <float> - Image to the power of <float>.     * thr - <float> - Threshold the image below <float>.     * uthr - <float> - Threshold image above <float>.     * smo - <float> - Gaussian smoothing by std <float> (in voxels and up to 4-D).     * edge - <float> - Calculate the edges of the image using a threshold <float>.     * sobel3 - <float> - Calculate the edges of all timepoints using a Sobel filter       with a 3x3x3 kernel and applying <float> gaussian smoothing.     * sobel5 - <float> - Calculate the edges of all timepoints using a Sobel filter       with a 5x5x5 kernel and applying <float> gaussian smoothing.     * min - <file> - Get the min per voxel between <current> and <file>.     * smol - <float> - Gaussian smoothing of a 3D label image.     * geo - <float/file> - Geodesic distance according to the speed function <float/file>     * llsnorm  <file_norm> - Linear LS normalisation between current and <file_norm>     * masknan <file_norm> - Assign everything outside the mask (mask==0) with NaNs     * hdr_copy <file> - Copy header from working image to <file> and save in <output>.     * splitinter <x/y/z> - Split interleaved slices in direction <x/y/z>       into separate time points  
-    operand_value: '2.0'
-    # type=float|default=0.0: float value to perform operation with
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  directive:
-  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
-- cmdline: seg_maths im1.nii -llsnorm im2.nii -odt float im1_llsnorm.nii
-  # str - the expected cmdline output
-  inputs:
-  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
-  # If the field is of file-format type and the value is None, then the
-  # '.mock()' method of the corresponding class is used instead.
-    operation: '"llsnorm"'
-    # type=enum|default='mul'|allowed['add','div','edge','geo','hdr_copy','llsnorm','masknan','min','mul','pow','smo','smol','sobel3','sobel5','splitinter','sub','thr','uthr']: Operation to perform:      * mul - <float/file> - Multiply image <float> value or by other image.     * div - <float/file> - Divide image by <float> or by other image.     * add - <float/file> - Add image by <float> or by other image.     * sub - <float/file> - Subtract image by <float> or by other image.     * pow - <float> - Image to the power of <float>.     * thr - <float> - Threshold the image below <float>.     * uthr - <float> - Threshold image above <float>.     * smo - <float> - Gaussian smoothing by std <float> (in voxels and up to 4-D).     * edge - <float> - Calculate the edges of the image using a threshold <float>.     * sobel3 - <float> - Calculate the edges of all timepoints using a Sobel filter       with a 3x3x3 kernel and applying <float> gaussian smoothing.     * sobel5 - <float> - Calculate the edges of all timepoints using a Sobel filter       with a 5x5x5 kernel and applying <float> gaussian smoothing.     * min - <file> - Get the min per voxel between <current> and <file>.     * smol - <float> - Gaussian smoothing of a 3D label image.     * geo - <float/file> - Geodesic distance according to the speed function <float/file>     * llsnorm  <file_norm> - Linear LS normalisation between current and <file_norm>     * masknan <file_norm> - Assign everything outside the mask (mask==0) with NaNs     * hdr_copy <file> - Copy header from working image to <file> and save in <output>.     * splitinter <x/y/z> - Split interleaved slices in direction <x/y/z>       into separate time points  
-    operand_file:
-    # type=file|default=<undefined>: second image to perform operation with
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  directive:
-  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
-- cmdline: seg_maths im1.nii -splitinter z -odt float im1_splitinter.nii
-  # str - the expected cmdline output
-  inputs:
-  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
-  # If the field is of file-format type and the value is None, then the
-  # '.mock()' method of the corresponding class is used instead.
-    operation: '"splitinter"'
-    # type=enum|default='mul'|allowed['add','div','edge','geo','hdr_copy','llsnorm','masknan','min','mul','pow','smo','smol','sobel3','sobel5','splitinter','sub','thr','uthr']: Operation to perform:      * mul - <float/file> - Multiply image <float> value or by other image.     * div - <float/file> - Divide image by <float> or by other image.     * add - <float/file> - Add image by <float> or by other image.     * sub - <float/file> - Subtract image by <float> or by other image.     * pow - <float> - Image to the power of <float>.     * thr - <float> - Threshold the image below <float>.     * uthr - <float> - Threshold image above <float>.     * smo - <float> - Gaussian smoothing by std <float> (in voxels and up to 4-D).     * edge - <float> - Calculate the edges of the image using a threshold <float>.     * sobel3 - <float> - Calculate the edges of all timepoints using a Sobel filter       with a 3x3x3 kernel and applying <float> gaussian smoothing.     * sobel5 - <float> - Calculate the edges of all timepoints using a Sobel filter       with a 5x5x5 kernel and applying <float> gaussian smoothing.     * min - <file> - Get the min per voxel between <current> and <file>.     * smol - <float> - Gaussian smoothing of a 3D label image.     * geo - <float/file> - Geodesic distance according to the speed function <float/file>     * llsnorm  <file_norm> - Linear LS normalisation between current and <file_norm>     * masknan <file_norm> - Assign everything outside the mask (mask==0) with NaNs     * hdr_copy <file> - Copy header from working image to <file> and save in <output>.     * splitinter <x/y/z> - Split interleaved slices in direction <x/y/z>       into separate time points  
-    operand_str: '"z"'
-    # type=enum|default='x'|allowed['x','y','z']: string value to perform operation splitinter
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  directive:
-  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-niftyseg/binary_maths_callables.py b/example-specs/task/nipype_internal/pydra-niftyseg/binary_maths_callables.py
deleted file mode 100644
index 68e6b721..00000000
--- a/example-specs/task/nipype_internal/pydra-niftyseg/binary_maths_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in BinaryMaths.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-niftyseg/binary_maths_integer.yaml b/example-specs/task/nipype_internal/pydra-niftyseg/binary_maths_integer.yaml
deleted file mode 100644
index 25a9c99c..00000000
--- a/example-specs/task/nipype_internal/pydra-niftyseg/binary_maths_integer.yaml
+++ /dev/null
@@ -1,167 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.niftyseg.maths.BinaryMathsInteger' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Integer mathematical operations.
-# 
-#     See Also
-#     --------
-#     `Source code <http://cmictig.cs.ucl.ac.uk/wiki/index.php/NiftySeg>`__ --
-#     `Documentation <http://cmictig.cs.ucl.ac.uk/wiki/index.php/NiftySeg_documentation>`__
-# 
-#     Examples
-#     --------
-#     >>> import copy
-#     >>> from nipype.interfaces.niftyseg import BinaryMathsInteger
-#     >>> binaryi = BinaryMathsInteger()
-#     >>> binaryi.inputs.in_file = 'im1.nii'
-#     >>> binaryi.inputs.output_datatype = 'float'
-#     >>> # Test dil operation
-#     >>> binaryi_dil = copy.deepcopy(binaryi)
-#     >>> binaryi_dil.inputs.operation = 'dil'
-#     >>> binaryi_dil.inputs.operand_value = 2
-#     >>> binaryi_dil.cmdline
-#     'seg_maths im1.nii -dil 2 -odt float im1_dil.nii'
-#     >>> binaryi_dil.run()  # doctest: +SKIP
-#     >>> # Test dil operation
-#     >>> binaryi_ero = copy.deepcopy(binaryi)
-#     >>> binaryi_ero.inputs.operation = 'ero'
-#     >>> binaryi_ero.inputs.operand_value = 1
-#     >>> binaryi_ero.cmdline
-#     'seg_maths im1.nii -ero 1 -odt float im1_ero.nii'
-#     >>> binaryi_ero.run()  # doctest: +SKIP
-#     >>> # Test pad operation
-#     >>> binaryi_pad = copy.deepcopy(binaryi)
-#     >>> binaryi_pad.inputs.operation = 'pad'
-#     >>> binaryi_pad.inputs.operand_value = 4
-#     >>> binaryi_pad.cmdline
-#     'seg_maths im1.nii -pad 4 -odt float im1_pad.nii'
-#     >>> binaryi_pad.run()  # doctest: +SKIP
-# 
-#     
-task_name: BinaryMathsInteger
-nipype_name: BinaryMathsInteger
-nipype_module: nipype.interfaces.niftyseg.maths
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_file: medimage/nifti1
-    # type=file|default=<undefined>: image to operate on
-    out_file: generic/file
-    # type=file: image written after calculations
-    # type=file|default=<undefined>: image to write
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    out_file: generic/file
-    # type=file: image written after calculations
-    # type=file|default=<undefined>: image to write
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    operation:
-    # type=enum|default='dil'|allowed['crop','dil','equal','ero','pad','tp']: Operation to perform:      * equal - <int> - Get voxels equal to <int>     * dil - <int>  - Dilate the image <int> times (in voxels).     * ero - <int> - Erode the image <int> times (in voxels).     * tp - <int> - Extract time point <int>     * crop - <int> - Crop <int> voxels around each 3D volume.     * pad - <int> -  Pad <int> voxels with NaN value around each 3D volume.  
-    operand_value:
-    # type=int|default=0: int value to perform operation with
-    in_file:
-    # type=file|default=<undefined>: image to operate on
-    out_file:
-    # type=file: image written after calculations
-    # type=file|default=<undefined>: image to write
-    output_datatype:
-    # type=enum|default='float'|allowed['char','double','float','input','int','short']: datatype to use for output (default uses input type)
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: image to operate on
-    output_datatype: '"float"'
-    # type=enum|default='float'|allowed['char','double','float','input','int','short']: datatype to use for output (default uses input type)
-    operation: '"pad"'
-    # type=enum|default='dil'|allowed['crop','dil','equal','ero','pad','tp']: Operation to perform:      * equal - <int> - Get voxels equal to <int>     * dil - <int>  - Dilate the image <int> times (in voxels).     * ero - <int> - Erode the image <int> times (in voxels).     * tp - <int> - Extract time point <int>     * crop - <int> - Crop <int> voxels around each 3D volume.     * pad - <int> -  Pad <int> voxels with NaN value around each 3D volume.  
-    operand_value: '4'
-    # type=int|default=0: int value to perform operation with
-  imports: &id001
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  - module: copy
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests:
-- cmdline: seg_maths im1.nii -pad 4 -odt float im1_pad.nii
-  # str - the expected cmdline output
-  inputs:
-  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
-  # If the field is of file-format type and the value is None, then the
-  # '.mock()' method of the corresponding class is used instead.
-    in_file:
-    # type=file|default=<undefined>: image to operate on
-    output_datatype: '"float"'
-    # type=enum|default='float'|allowed['char','double','float','input','int','short']: datatype to use for output (default uses input type)
-    operation: '"pad"'
-    # type=enum|default='dil'|allowed['crop','dil','equal','ero','pad','tp']: Operation to perform:      * equal - <int> - Get voxels equal to <int>     * dil - <int>  - Dilate the image <int> times (in voxels).     * ero - <int> - Erode the image <int> times (in voxels).     * tp - <int> - Extract time point <int>     * crop - <int> - Crop <int> voxels around each 3D volume.     * pad - <int> -  Pad <int> voxels with NaN value around each 3D volume.  
-    operand_value: '4'
-    # type=int|default=0: int value to perform operation with
-  imports: *id001
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  directive:
-  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-niftyseg/binary_maths_integer_callables.py b/example-specs/task/nipype_internal/pydra-niftyseg/binary_maths_integer_callables.py
deleted file mode 100644
index d1edb96e..00000000
--- a/example-specs/task/nipype_internal/pydra-niftyseg/binary_maths_integer_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in BinaryMathsInteger.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-niftyseg/binary_stats.yaml b/example-specs/task/nipype_internal/pydra-niftyseg/binary_stats.yaml
deleted file mode 100644
index a91d3683..00000000
--- a/example-specs/task/nipype_internal/pydra-niftyseg/binary_stats.yaml
+++ /dev/null
@@ -1,165 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.niftyseg.stats.BinaryStats' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Binary statistical operations.
-# 
-#     See Also
-#     --------
-#     `Source code <http://cmictig.cs.ucl.ac.uk/wiki/index.php/NiftySeg>`__ --
-#     `Documentation <http://cmictig.cs.ucl.ac.uk/wiki/index.php/NiftySeg_documentation>`__
-# 
-#     Examples
-#     --------
-#     >>> import copy
-#     >>> from nipype.interfaces import niftyseg
-#     >>> binary = niftyseg.BinaryStats()
-#     >>> binary.inputs.in_file = 'im1.nii'
-#     >>> # Test sa operation
-#     >>> binary_sa = copy.deepcopy(binary)
-#     >>> binary_sa.inputs.operation = 'sa'
-#     >>> binary_sa.inputs.operand_value = 2.0
-#     >>> binary_sa.cmdline
-#     'seg_stats im1.nii -sa 2.00000000'
-#     >>> binary_sa.run()  # doctest: +SKIP
-#     >>> # Test ncc operation
-#     >>> binary_ncc = copy.deepcopy(binary)
-#     >>> binary_ncc.inputs.operation = 'ncc'
-#     >>> binary_ncc.inputs.operand_file = 'im2.nii'
-#     >>> binary_ncc.cmdline
-#     'seg_stats im1.nii -ncc im2.nii'
-#     >>> binary_ncc.run()  # doctest: +SKIP
-#     >>> # Test Nl operation
-#     >>> binary_nl = copy.deepcopy(binary)
-#     >>> binary_nl.inputs.operation = 'Nl'
-#     >>> binary_nl.inputs.operand_file = 'output.csv'
-#     >>> binary_nl.cmdline
-#     'seg_stats im1.nii -Nl output.csv'
-#     >>> binary_nl.run()  # doctest: +SKIP
-# 
-#     
-task_name: BinaryStats
-nipype_name: BinaryStats
-nipype_module: nipype.interfaces.niftyseg.stats
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    operand_file: text/csv
-    # type=file|default=<undefined>: second image to perform operation with
-    in_file: medimage/nifti1
-    # type=file|default=<undefined>: image to operate on
-    mask_file: generic/file
-    # type=file|default=<undefined>: statistics within the masked area
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    operation:
-    # type=enum|default='p'|allowed['Nl','Vl','al','d','ncc','nmi','p','sa','ss','svp']: Operation to perform:      * p - <float> - The <float>th percentile of all voxels intensity (float=[0,100])     * sa - <ax> - Average of all voxels     * ss - <ax> - Standard deviation of all voxels     * svp - <ax> - Volume of all probabilsitic voxels (sum(<in>) x <volume per voxel>)     * al - <in2> - Average value in <in> for each label in <in2>     * d - <in2> - Calculate the Dice score between all classes in <in> and <in2>     * ncc - <in2> - Normalized cross correlation between <in> and <in2>     * nmi - <in2> - Normalized Mutual Information between <in> and <in2>     * Vl - <csv> - Volume of each integer label <in>. Save to <csv>file.     * Nl - <csv> - Count of each label <in>. Save to <csv> file.  
-    operand_file:
-    # type=file|default=<undefined>: second image to perform operation with
-    operand_value:
-    # type=float|default=0.0: value to perform operation with
-    in_file:
-    # type=file|default=<undefined>: image to operate on
-    mask_file:
-    # type=file|default=<undefined>: statistics within the masked area
-    larger_voxel:
-    # type=float|default=0.0: Only estimate statistics if voxel is larger than <float>
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: image to operate on
-    operation: '"Nl"'
-    # type=enum|default='p'|allowed['Nl','Vl','al','d','ncc','nmi','p','sa','ss','svp']: Operation to perform:      * p - <float> - The <float>th percentile of all voxels intensity (float=[0,100])     * sa - <ax> - Average of all voxels     * ss - <ax> - Standard deviation of all voxels     * svp - <ax> - Volume of all probabilsitic voxels (sum(<in>) x <volume per voxel>)     * al - <in2> - Average value in <in> for each label in <in2>     * d - <in2> - Calculate the Dice score between all classes in <in> and <in2>     * ncc - <in2> - Normalized cross correlation between <in> and <in2>     * nmi - <in2> - Normalized Mutual Information between <in> and <in2>     * Vl - <csv> - Volume of each integer label <in>. Save to <csv>file.     * Nl - <csv> - Count of each label <in>. Save to <csv> file.  
-    operand_value: '2.0'
-    # type=float|default=0.0: value to perform operation with
-    operand_file:
-    # type=file|default=<undefined>: second image to perform operation with
-  imports: &id001
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  - module: copy
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests:
-- cmdline: seg_stats im1.nii -Nl output.csv
-  # str - the expected cmdline output
-  inputs:
-  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
-  # If the field is of file-format type and the value is None, then the
-  # '.mock()' method of the corresponding class is used instead.
-    in_file:
-    # type=file|default=<undefined>: image to operate on
-    operation: '"Nl"'
-    # type=enum|default='p'|allowed['Nl','Vl','al','d','ncc','nmi','p','sa','ss','svp']: Operation to perform:      * p - <float> - The <float>th percentile of all voxels intensity (float=[0,100])     * sa - <ax> - Average of all voxels     * ss - <ax> - Standard deviation of all voxels     * svp - <ax> - Volume of all probabilsitic voxels (sum(<in>) x <volume per voxel>)     * al - <in2> - Average value in <in> for each label in <in2>     * d - <in2> - Calculate the Dice score between all classes in <in> and <in2>     * ncc - <in2> - Normalized cross correlation between <in> and <in2>     * nmi - <in2> - Normalized Mutual Information between <in> and <in2>     * Vl - <csv> - Volume of each integer label <in>. Save to <csv>file.     * Nl - <csv> - Count of each label <in>. Save to <csv> file.  
-    operand_value: '2.0'
-    # type=float|default=0.0: value to perform operation with
-    operand_file:
-    # type=file|default=<undefined>: second image to perform operation with
-  imports: *id001
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  directive:
-  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-niftyseg/binary_stats_callables.py b/example-specs/task/nipype_internal/pydra-niftyseg/binary_stats_callables.py
deleted file mode 100644
index bfcafb23..00000000
--- a/example-specs/task/nipype_internal/pydra-niftyseg/binary_stats_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in BinaryStats.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-niftyseg/calc_top_ncc.yaml b/example-specs/task/nipype_internal/pydra-niftyseg/calc_top_ncc.yaml
deleted file mode 100644
index bfe3e37a..00000000
--- a/example-specs/task/nipype_internal/pydra-niftyseg/calc_top_ncc.yaml
+++ /dev/null
@@ -1,140 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.niftyseg.label_fusion.CalcTopNCC' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Interface for executable seg_CalcTopNCC from NiftySeg platform.
-# 
-#     Examples
-#     --------
-#     >>> from nipype.interfaces import niftyseg
-#     >>> node = niftyseg.CalcTopNCC()
-#     >>> node.inputs.in_file = 'im1.nii'
-#     >>> node.inputs.num_templates = 2
-#     >>> node.inputs.in_templates = ['im2.nii', 'im3.nii']
-#     >>> node.inputs.top_templates = 1
-#     >>> node.cmdline
-#     'seg_CalcTopNCC -target im1.nii -templates 2 im2.nii im3.nii -n 1'
-# 
-#     
-task_name: CalcTopNCC
-nipype_name: CalcTopNCC
-nipype_module: nipype.interfaces.niftyseg.label_fusion
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_file: medimage/nifti1
-    # type=file|default=<undefined>: Target file
-    in_templates: medimage/nifti1+list-of
-    # type=list|default=[]: 
-    mask_file: generic/file
-    # type=file|default=<undefined>: Filename of the ROI for label fusion
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: Target file
-    num_templates:
-    # type=int|default=0: Number of Templates
-    in_templates:
-    # type=list|default=[]: 
-    top_templates:
-    # type=int|default=0: Number of Top Templates
-    mask_file:
-    # type=file|default=<undefined>: Filename of the ROI for label fusion
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: Target file
-    num_templates: '2'
-    # type=int|default=0: Number of Templates
-    in_templates:
-    # type=list|default=[]: 
-    top_templates: '1'
-    # type=int|default=0: Number of Top Templates
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests:
-- cmdline: seg_CalcTopNCC -target im1.nii -templates 2 im2.nii im3.nii -n 1
-  # str - the expected cmdline output
-  inputs:
-  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
-  # If the field is of file-format type and the value is None, then the
-  # '.mock()' method of the corresponding class is used instead.
-    in_file:
-    # type=file|default=<undefined>: Target file
-    num_templates: '2'
-    # type=int|default=0: Number of Templates
-    in_templates:
-    # type=list|default=[]: 
-    top_templates: '1'
-    # type=int|default=0: Number of Top Templates
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  directive:
-  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-niftyseg/calc_top_ncc_callables.py b/example-specs/task/nipype_internal/pydra-niftyseg/calc_top_ncc_callables.py
deleted file mode 100644
index 48a54d55..00000000
--- a/example-specs/task/nipype_internal/pydra-niftyseg/calc_top_ncc_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in CalcTopNCC.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-niftyseg/em.yaml b/example-specs/task/nipype_internal/pydra-niftyseg/em.yaml
deleted file mode 100644
index 69f09c06..00000000
--- a/example-specs/task/nipype_internal/pydra-niftyseg/em.yaml
+++ /dev/null
@@ -1,180 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.niftyseg.em.EM' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Interface for executable seg_EM from NiftySeg platform.
-# 
-#     seg_EM is a general purpose intensity based image segmentation tool. In
-#     it's simplest form, it takes in one 2D or 3D image and segments it in n
-#     classes.
-# 
-#     `Source code <http://cmictig.cs.ucl.ac.uk/wiki/index.php/NiftySeg>`_ |
-#     `Documentation <http://cmictig.cs.ucl.ac.uk/wiki/index.php/NiftySeg_documentation>`_
-# 
-#     Examples
-#     --------
-#     >>> from nipype.interfaces import niftyseg
-#     >>> node = niftyseg.EM()
-#     >>> node.inputs.in_file = 'im1.nii'
-#     >>> node.inputs.no_prior = 4
-#     >>> node.cmdline
-#     'seg_EM -in im1.nii -bc_order 3 -bc_thresh 0 -max_iter 100 -min_iter 0 -nopriors 4 -bc_out im1_bc_em.nii.gz -out im1_em.nii.gz -out_outlier im1_outlier_em.nii.gz'
-# 
-#     
-task_name: EM
-nipype_name: EM
-nipype_module: nipype.interfaces.niftyseg.em
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_file: medimage/nifti1
-    # type=file|default=<undefined>: Input image to segment
-    mask_file: generic/file
-    # type=file|default=<undefined>: Filename of the ROI for label fusion
-    prior_4D: generic/file
-    # type=file|default=<undefined>: 4D file containing the priors
-    out_file: generic/file
-    # type=file: Output segmentation
-    # type=file|default=<undefined>: Output segmentation
-    out_bc_file: generic/file
-    # type=file: Output bias corrected image
-    # type=file|default=<undefined>: Output bias corrected image
-    out_outlier_file: generic/file
-    # type=file: Output outlierness image
-    # type=file|default=<undefined>: Output outlierness image
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    out_file: generic/file
-    # type=file: Output segmentation
-    # type=file|default=<undefined>: Output segmentation
-    out_bc_file: generic/file
-    # type=file: Output bias corrected image
-    # type=file|default=<undefined>: Output bias corrected image
-    out_outlier_file: generic/file
-    # type=file: Output outlierness image
-    # type=file|default=<undefined>: Output outlierness image
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: Input image to segment
-    mask_file:
-    # type=file|default=<undefined>: Filename of the ROI for label fusion
-    no_prior:
-    # type=int|default=0: Number of classes to use without prior
-    prior_4D:
-    # type=file|default=<undefined>: 4D file containing the priors
-    priors:
-    # type=inputmultiobject|default=[]: List of priors filepaths.
-    max_iter:
-    # type=int|default=100: Maximum number of iterations
-    min_iter:
-    # type=int|default=0: Minimum number of iterations
-    bc_order_val:
-    # type=int|default=3: Polynomial order for the bias field
-    mrf_beta_val:
-    # type=float|default=0.0: Weight of the Markov Random Field
-    bc_thresh_val:
-    # type=float|default=0: Bias field correction will run only if the ratio of improvement is below bc_thresh. (default=0 [OFF])
-    reg_val:
-    # type=float|default=0.0: Amount of regularization over the diagonal of the covariance matrix [above 1]
-    outlier_val:
-    # type=tuple|default=(0.0, 0.0): Outlier detection as in (Van Leemput TMI 2003). <fl1> is the Mahalanobis threshold [recommended between 3 and 7] <fl2> is a convergence ratio below which the outlier detection is going to be done [recommended 0.01]
-    relax_priors:
-    # type=tuple|default=(0.0, 0.0): Relax Priors [relaxation factor: 0<rf<1 (recommended=0.5), gaussian regularization: gstd>0 (recommended=2.0)] /only 3D/
-    out_file:
-    # type=file: Output segmentation
-    # type=file|default=<undefined>: Output segmentation
-    out_bc_file:
-    # type=file: Output bias corrected image
-    # type=file|default=<undefined>: Output bias corrected image
-    out_outlier_file:
-    # type=file: Output outlierness image
-    # type=file|default=<undefined>: Output outlierness image
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: Input image to segment
-    no_prior: '4'
-    # type=int|default=0: Number of classes to use without prior
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests:
-- cmdline: seg_EM -in im1.nii -bc_order 3 -bc_thresh 0 -max_iter 100 -min_iter 0 -nopriors 4 -bc_out im1_bc_em.nii.gz -out im1_em.nii.gz -out_outlier im1_outlier_em.nii.gz
-  # str - the expected cmdline output
-  inputs:
-  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
-  # If the field is of file-format type and the value is None, then the
-  # '.mock()' method of the corresponding class is used instead.
-    in_file:
-    # type=file|default=<undefined>: Input image to segment
-    no_prior: '4'
-    # type=int|default=0: Number of classes to use without prior
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  directive:
-  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-niftyseg/em_callables.py b/example-specs/task/nipype_internal/pydra-niftyseg/em_callables.py
deleted file mode 100644
index 5727596b..00000000
--- a/example-specs/task/nipype_internal/pydra-niftyseg/em_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in EM.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-niftyseg/fill_lesions.yaml b/example-specs/task/nipype_internal/pydra-niftyseg/fill_lesions.yaml
deleted file mode 100644
index 102b9935..00000000
--- a/example-specs/task/nipype_internal/pydra-niftyseg/fill_lesions.yaml
+++ /dev/null
@@ -1,162 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.niftyseg.lesions.FillLesions' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Interface for executable seg_FillLesions from NiftySeg platform.
-# 
-#     Fill all the masked lesions with WM intensity average.
-# 
-#     `Source code <http://cmictig.cs.ucl.ac.uk/wiki/index.php/NiftySeg>`_ |
-#     `Documentation <http://cmictig.cs.ucl.ac.uk/wiki/index.php/NiftySeg_documentation>`_
-# 
-#     Examples
-#     --------
-#     >>> from nipype.interfaces import niftyseg
-#     >>> node = niftyseg.FillLesions()
-#     >>> node.inputs.in_file = 'im1.nii'
-#     >>> node.inputs.lesion_mask = 'im2.nii'
-#     >>> node.cmdline
-#     'seg_FillLesions -i im1.nii -l im2.nii -o im1_lesions_filled.nii.gz'
-# 
-#     
-task_name: FillLesions
-nipype_name: FillLesions
-nipype_module: nipype.interfaces.niftyseg.lesions
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_file: medimage/nifti1
-    # type=file|default=<undefined>: Input image to fill lesions
-    lesion_mask: medimage/nifti1
-    # type=file|default=<undefined>: Lesion mask
-    out_file: generic/file
-    # type=file: Output segmentation
-    # type=file|default=<undefined>: The output filename of the fill lesions results
-    bin_mask: generic/file
-    # type=file|default=<undefined>: Give a binary mask with the valid search areas.
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    out_file: generic/file
-    # type=file: Output segmentation
-    # type=file|default=<undefined>: The output filename of the fill lesions results
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: Input image to fill lesions
-    lesion_mask:
-    # type=file|default=<undefined>: Lesion mask
-    out_file:
-    # type=file: Output segmentation
-    # type=file|default=<undefined>: The output filename of the fill lesions results
-    in_dilation:
-    # type=int|default=0: Dilate the mask <int> times (in voxels, by default 0)
-    match:
-    # type=float|default=0.0: Percentage of minimum number of voxels between patches <float> (by default 0.5).
-    search:
-    # type=float|default=0.0: Minimum percentage of valid voxels in target patch <float> (by default 0).
-    smooth:
-    # type=float|default=0.0: Smoothing by <float> (in minimal 6-neighbourhood voxels (by default 0.1)).
-    size:
-    # type=int|default=0: Search regions size respect biggest patch size (by default 4).
-    cwf:
-    # type=float|default=0.0: Patch cardinality weighting factor (by default 2).
-    bin_mask:
-    # type=file|default=<undefined>: Give a binary mask with the valid search areas.
-    other:
-    # type=bool|default=False: Guizard et al. (FIN 2015) method, it doesn't include the multiresolution/hierarchical inpainting part, this part needs to be done with some external software such as reg_tools and reg_resample from NiftyReg. By default it uses the method presented in Prados et al. (Neuroimage 2016).
-    use_2d:
-    # type=bool|default=False: Uses 2D patches in the Z axis, by default 3D.
-    debug:
-    # type=bool|default=False: Save all intermidium files (by default OFF).
-    out_datatype:
-    # type=string|default='': Set output <datatype> (char, short, int, uchar, ushort, uint, float, double).
-    verbose:
-    # type=bool|default=False: Verbose (by default OFF).
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: Input image to fill lesions
-    lesion_mask:
-    # type=file|default=<undefined>: Lesion mask
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests:
-- cmdline: seg_FillLesions -i im1.nii -l im2.nii -o im1_lesions_filled.nii.gz
-  # str - the expected cmdline output
-  inputs:
-  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
-  # If the field is of file-format type and the value is None, then the
-  # '.mock()' method of the corresponding class is used instead.
-    in_file:
-    # type=file|default=<undefined>: Input image to fill lesions
-    lesion_mask:
-    # type=file|default=<undefined>: Lesion mask
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  directive:
-  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-niftyseg/fill_lesions_callables.py b/example-specs/task/nipype_internal/pydra-niftyseg/fill_lesions_callables.py
deleted file mode 100644
index 9de29704..00000000
--- a/example-specs/task/nipype_internal/pydra-niftyseg/fill_lesions_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in FillLesions.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-niftyseg/label_fusion.yaml b/example-specs/task/nipype_internal/pydra-niftyseg/label_fusion.yaml
deleted file mode 100644
index cb32245a..00000000
--- a/example-specs/task/nipype_internal/pydra-niftyseg/label_fusion.yaml
+++ /dev/null
@@ -1,208 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.niftyseg.label_fusion.LabelFusion' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Interface for executable seg_LabelFusion from NiftySeg platform using
-#     type STEPS as classifier Fusion.
-# 
-#     This executable implements 4 fusion strategies (-STEPS, -STAPLE, -MV or
-#     - SBA), all of them using either a global (-GNCC), ROI-based (-ROINCC),
-#     local (-LNCC) or no image similarity (-ALL). Combinations of fusion
-#     algorithms and similarity metrics give rise to different variants of known
-#     algorithms. As an example, using LNCC and MV as options will run a locally
-#     weighted voting strategy with LNCC derived weights, while using STAPLE and
-#     LNCC is equivalent to running STEPS as per its original formulation.
-#     A few other options pertaining the use of an MRF (-MRF beta), the initial
-#     sensitivity and specificity estimates and the use of only non-consensus
-#     voxels (-unc) for the STAPLE and STEPS algorithm. All processing can be
-#     masked (-mask), greatly reducing memory consumption.
-# 
-#     As an example, the command to use STEPS should be:
-#     seg_LabFusion -in 4D_Propragated_Labels_to_fuse.nii -out     FusedSegmentation.nii -STEPS 2 15 TargetImage.nii     4D_Propagated_Intensities.nii
-# 
-#     `Source code <http://cmictig.cs.ucl.ac.uk/wiki/index.php/NiftySeg>`_ |
-#     `Documentation <http://cmictig.cs.ucl.ac.uk/wiki/index.php/NiftySeg_documentation>`_
-# 
-#     Examples
-#     --------
-#     >>> from nipype.interfaces import niftyseg
-#     >>> node = niftyseg.LabelFusion()
-#     >>> node.inputs.in_file = 'im1.nii'
-#     >>> node.inputs.kernel_size = 2.0
-#     >>> node.inputs.file_to_seg = 'im2.nii'
-#     >>> node.inputs.template_file = 'im3.nii'
-#     >>> node.inputs.template_num = 2
-#     >>> node.inputs.classifier_type = 'STEPS'
-#     >>> node.cmdline
-#     'seg_LabFusion -in im1.nii -STEPS 2.000000 2 im2.nii im3.nii -out im1_steps.nii'
-# 
-#     
-task_name: LabelFusion
-nipype_name: LabelFusion
-nipype_module: nipype.interfaces.niftyseg.label_fusion
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_file: medimage/nifti1
-    # type=file|default=<undefined>: Filename of the 4D integer label image.
-    template_file: medimage/nifti1
-    # type=file|default=<undefined>: Registered templates (4D Image)
-    file_to_seg: medimage/nifti1
-    # type=file|default=<undefined>: Original image to segment (3D Image)
-    mask_file: generic/file
-    # type=file|default=<undefined>: Filename of the ROI for label fusion
-    out_file: generic/file
-    # type=file: image written after calculations
-    # type=file|default=<undefined>: Output consensus segmentation
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    out_file: generic/file
-    # type=file: image written after calculations
-    # type=file|default=<undefined>: Output consensus segmentation
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: Filename of the 4D integer label image.
-    template_file:
-    # type=file|default=<undefined>: Registered templates (4D Image)
-    file_to_seg:
-    # type=file|default=<undefined>: Original image to segment (3D Image)
-    mask_file:
-    # type=file|default=<undefined>: Filename of the ROI for label fusion
-    out_file:
-    # type=file: image written after calculations
-    # type=file|default=<undefined>: Output consensus segmentation
-    prob_flag:
-    # type=bool|default=False: Probabilistic/Fuzzy segmented image
-    verbose:
-    # type=enum|default='0'|allowed['0','1','2']: Verbose level [0 = off, 1 = on, 2 = debug] (default = 0)
-    unc:
-    # type=bool|default=False: Only consider non-consensus voxels to calculate statistics
-    classifier_type:
-    # type=enum|default='STEPS'|allowed['MV','SBA','STAPLE','STEPS']: Type of Classifier Fusion.
-    kernel_size:
-    # type=float|default=0.0: Gaussian kernel size in mm to compute the local similarity
-    template_num:
-    # type=int|default=0: Number of labels to use
-    sm_ranking:
-    # type=enum|default='ALL'|allowed['ALL','GNCC','LNCC','ROINCC']: Ranking for STAPLE and MV
-    dilation_roi:
-    # type=int|default=0: Dilation of the ROI ( <int> d>=1 )
-    proportion:
-    # type=float|default=0.0: Proportion of the label (only for single labels).
-    prob_update_flag:
-    # type=bool|default=False: Update label proportions at each iteration
-    set_pq:
-    # type=tuple|default=(0.0, 0.0): Value of P and Q [ 0 < (P,Q) < 1 ] (default = 0.99 0.99)
-    mrf_value:
-    # type=float|default=0.0: MRF prior strength (between 0 and 5)
-    max_iter:
-    # type=int|default=0: Maximum number of iterations (default = 15).
-    unc_thresh:
-    # type=float|default=0.0: If <float> percent of labels agree, then area is not uncertain.
-    conv:
-    # type=float|default=0.0: Ratio for convergence (default epsilon = 10^-5).
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: Filename of the 4D integer label image.
-    kernel_size: '2.0'
-    # type=float|default=0.0: Gaussian kernel size in mm to compute the local similarity
-    file_to_seg:
-    # type=file|default=<undefined>: Original image to segment (3D Image)
-    template_file:
-    # type=file|default=<undefined>: Registered templates (4D Image)
-    template_num: '2'
-    # type=int|default=0: Number of labels to use
-    classifier_type: '"STEPS"'
-    # type=enum|default='STEPS'|allowed['MV','SBA','STAPLE','STEPS']: Type of Classifier Fusion.
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests:
-- cmdline: seg_LabFusion -in im1.nii -STEPS 2.000000 2 im2.nii im3.nii -out im1_steps.nii
-  # str - the expected cmdline output
-  inputs:
-  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
-  # If the field is of file-format type and the value is None, then the
-  # '.mock()' method of the corresponding class is used instead.
-    in_file:
-    # type=file|default=<undefined>: Filename of the 4D integer label image.
-    kernel_size: '2.0'
-    # type=float|default=0.0: Gaussian kernel size in mm to compute the local similarity
-    file_to_seg:
-    # type=file|default=<undefined>: Original image to segment (3D Image)
-    template_file:
-    # type=file|default=<undefined>: Registered templates (4D Image)
-    template_num: '2'
-    # type=int|default=0: Number of labels to use
-    classifier_type: '"STEPS"'
-    # type=enum|default='STEPS'|allowed['MV','SBA','STAPLE','STEPS']: Type of Classifier Fusion.
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  directive:
-  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-niftyseg/label_fusion_callables.py b/example-specs/task/nipype_internal/pydra-niftyseg/label_fusion_callables.py
deleted file mode 100644
index 77a5401a..00000000
--- a/example-specs/task/nipype_internal/pydra-niftyseg/label_fusion_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in LabelFusion.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-niftyseg/maths_command.yaml b/example-specs/task/nipype_internal/pydra-niftyseg/maths_command.yaml
deleted file mode 100644
index b00d9ae5..00000000
--- a/example-specs/task/nipype_internal/pydra-niftyseg/maths_command.yaml
+++ /dev/null
@@ -1,96 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.niftyseg.maths.MathsCommand' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Base Command Interface for seg_maths interfaces.
-# 
-#     The executable seg_maths enables the sequential execution of arithmetic
-#     operations, like multiplication (-mul), division (-div) or addition
-#     (-add), binarisation (-bin) or thresholding (-thr) operations and
-#     convolution by a Gaussian kernel (-smo). It also allows mathematical
-#     morphology based operations like dilation (-dil), erosion (-ero),
-#     connected components (-lconcomp) and hole filling (-fill), Euclidean
-#     (- euc) and geodesic (-geo) distance transforms, local image similarity
-#     metric calculation (-lncc and -lssd). Finally, it allows multiple
-#     operations over the dimensionality of the image, from merging 3D images
-#     together as a 4D image (-merge) or splitting (-split or -tp) 4D images
-#     into several 3D images, to estimating the maximum, minimum and average
-#     over all time-points, etc.
-#     
-task_name: MathsCommand
-nipype_name: MathsCommand
-nipype_module: nipype.interfaces.niftyseg.maths
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_file: generic/file
-    # type=file|default=<undefined>: image to operate on
-    out_file: generic/file
-    # type=file: image written after calculations
-    # type=file|default=<undefined>: image to write
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    out_file: generic/file
-    # type=file: image written after calculations
-    # type=file|default=<undefined>: image to write
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: image to operate on
-    out_file:
-    # type=file: image written after calculations
-    # type=file|default=<undefined>: image to write
-    output_datatype:
-    # type=enum|default='float'|allowed['char','double','float','input','int','short']: datatype to use for output (default uses input type)
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-niftyseg/maths_command_callables.py b/example-specs/task/nipype_internal/pydra-niftyseg/maths_command_callables.py
deleted file mode 100644
index 84e0f131..00000000
--- a/example-specs/task/nipype_internal/pydra-niftyseg/maths_command_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in MathsCommand.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-niftyseg/merge.yaml b/example-specs/task/nipype_internal/pydra-niftyseg/merge.yaml
deleted file mode 100644
index 843f2ac8..00000000
--- a/example-specs/task/nipype_internal/pydra-niftyseg/merge.yaml
+++ /dev/null
@@ -1,151 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.niftyseg.maths.Merge' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Merge image files.
-# 
-#     See Also
-#     --------
-#     `Source code <http://cmictig.cs.ucl.ac.uk/wiki/index.php/NiftySeg>`__ --
-#     `Documentation <http://cmictig.cs.ucl.ac.uk/wiki/index.php/NiftySeg_documentation>`__
-# 
-#     Examples
-#     --------
-#     >>> from nipype.interfaces import niftyseg
-#     >>> node = niftyseg.Merge()
-#     >>> node.inputs.in_file = 'im1.nii'
-#     >>> files = ['im2.nii', 'im3.nii']
-#     >>> node.inputs.merge_files = files
-#     >>> node.inputs.dimension = 2
-#     >>> node.inputs.output_datatype = 'float'
-#     >>> node.cmdline
-#     'seg_maths im1.nii -merge 2 2 im2.nii im3.nii -odt float im1_merged.nii'
-# 
-#     
-task_name: Merge
-nipype_name: Merge
-nipype_module: nipype.interfaces.niftyseg.maths
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    merge_files: generic/file+list-of
-    # type=list|default=[]: List of images to merge to the working image <input>.
-    in_file: medimage/nifti1
-    # type=file|default=<undefined>: image to operate on
-    out_file: generic/file
-    # type=file: image written after calculations
-    # type=file|default=<undefined>: image to write
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    out_file: generic/file
-    # type=file: image written after calculations
-    # type=file|default=<undefined>: image to write
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    dimension:
-    # type=int|default=0: Dimension to merge the images.
-    merge_files:
-    # type=list|default=[]: List of images to merge to the working image <input>.
-    in_file:
-    # type=file|default=<undefined>: image to operate on
-    out_file:
-    # type=file: image written after calculations
-    # type=file|default=<undefined>: image to write
-    output_datatype:
-    # type=enum|default='float'|allowed['char','double','float','input','int','short']: datatype to use for output (default uses input type)
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: image to operate on
-    merge_files:
-    # type=list|default=[]: List of images to merge to the working image <input>.
-    dimension: '2'
-    # type=int|default=0: Dimension to merge the images.
-    output_datatype: '"float"'
-    # type=enum|default='float'|allowed['char','double','float','input','int','short']: datatype to use for output (default uses input type)
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests:
-- cmdline: seg_maths im1.nii -merge 2 2 im2.nii im3.nii -odt float im1_merged.nii
-  # str - the expected cmdline output
-  inputs:
-  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
-  # If the field is of file-format type and the value is None, then the
-  # '.mock()' method of the corresponding class is used instead.
-    in_file:
-    # type=file|default=<undefined>: image to operate on
-    merge_files:
-    # type=list|default=[]: List of images to merge to the working image <input>.
-    dimension: '2'
-    # type=int|default=0: Dimension to merge the images.
-    output_datatype: '"float"'
-    # type=enum|default='float'|allowed['char','double','float','input','int','short']: datatype to use for output (default uses input type)
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  directive:
-  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-niftyseg/merge_callables.py b/example-specs/task/nipype_internal/pydra-niftyseg/merge_callables.py
deleted file mode 100644
index 1950a89d..00000000
--- a/example-specs/task/nipype_internal/pydra-niftyseg/merge_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in Merge.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-niftyseg/patch_match.yaml b/example-specs/task/nipype_internal/pydra-niftyseg/patch_match.yaml
deleted file mode 100644
index dff477db..00000000
--- a/example-specs/task/nipype_internal/pydra-niftyseg/patch_match.yaml
+++ /dev/null
@@ -1,165 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.niftyseg.patchmatch.PatchMatch' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Interface for executable seg_PatchMatch from NiftySeg platform.
-# 
-#     The database file is a text file and in each line we have a template
-#     file, a mask with the search region to consider and a file with the
-#     label to propagate.
-# 
-#     Input image, input mask, template images from database and masks from
-#     database must have the same 4D resolution (same number of XxYxZ voxels,
-#     modalities and/or time-points).
-#     Label files from database must have the same 3D resolution
-#     (XxYxZ voxels) than input image but can have different number of
-#     volumes than the input image allowing to propagate multiple labels
-#     in the same execution.
-# 
-#     `Source code <http://cmictig.cs.ucl.ac.uk/wiki/index.php/NiftySeg>`_ |
-#     `Documentation <http://cmictig.cs.ucl.ac.uk/wiki/index.php/NiftySeg_documentation>`_
-# 
-#     Examples
-#     --------
-#     >>> from nipype.interfaces import niftyseg
-#     >>> node = niftyseg.PatchMatch()
-#     >>> node.inputs.in_file = 'im1.nii'
-#     >>> node.inputs.mask_file = 'im2.nii'
-#     >>> node.inputs.database_file = 'db.xml'
-#     >>> node.cmdline
-#     'seg_PatchMatch -i im1.nii -m im2.nii -db db.xml -o im1_pm.nii.gz'
-# 
-#     
-task_name: PatchMatch
-nipype_name: PatchMatch
-nipype_module: nipype.interfaces.niftyseg.patchmatch
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_file: medimage/nifti1
-    # type=file|default=<undefined>: Input image to segment
-    mask_file: medimage/nifti1
-    # type=file|default=<undefined>: Input mask for the area where applies PatchMatch
-    database_file: application/xml
-    # type=file|default=<undefined>: Database with the segmentations
-    out_file: generic/file
-    # type=file: Output segmentation
-    # type=file|default=<undefined>: The output filename of the patchmatch results
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    out_file: generic/file
-    # type=file: Output segmentation
-    # type=file|default=<undefined>: The output filename of the patchmatch results
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: Input image to segment
-    mask_file:
-    # type=file|default=<undefined>: Input mask for the area where applies PatchMatch
-    database_file:
-    # type=file|default=<undefined>: Database with the segmentations
-    out_file:
-    # type=file: Output segmentation
-    # type=file|default=<undefined>: The output filename of the patchmatch results
-    patch_size:
-    # type=int|default=0: Patch size, #voxels
-    cs_size:
-    # type=int|default=0: Constrained search area size, number of times bigger than the patchsize
-    match_num:
-    # type=int|default=0: Number of better matching
-    pm_num:
-    # type=int|default=0: Number of patchmatch executions
-    it_num:
-    # type=int|default=0: Number of iterations for the patchmatch algorithm
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: Input image to segment
-    mask_file:
-    # type=file|default=<undefined>: Input mask for the area where applies PatchMatch
-    database_file:
-    # type=file|default=<undefined>: Database with the segmentations
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests:
-- cmdline: seg_PatchMatch -i im1.nii -m im2.nii -db db.xml -o im1_pm.nii.gz
-  # str - the expected cmdline output
-  inputs:
-  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
-  # If the field is of file-format type and the value is None, then the
-  # '.mock()' method of the corresponding class is used instead.
-    in_file:
-    # type=file|default=<undefined>: Input image to segment
-    mask_file:
-    # type=file|default=<undefined>: Input mask for the area where applies PatchMatch
-    database_file:
-    # type=file|default=<undefined>: Database with the segmentations
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  directive:
-  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-niftyseg/patch_match_callables.py b/example-specs/task/nipype_internal/pydra-niftyseg/patch_match_callables.py
deleted file mode 100644
index e32afef5..00000000
--- a/example-specs/task/nipype_internal/pydra-niftyseg/patch_match_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in PatchMatch.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-niftyseg/stats_command.yaml b/example-specs/task/nipype_internal/pydra-niftyseg/stats_command.yaml
deleted file mode 100644
index b2679fc4..00000000
--- a/example-specs/task/nipype_internal/pydra-niftyseg/stats_command.yaml
+++ /dev/null
@@ -1,88 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.niftyseg.stats.StatsCommand' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Base Command Interface for seg_stats interfaces.
-# 
-#     The executable seg_stats enables the estimation of image statistics on
-#     continuous voxel intensities (average, standard deviation, min/max, robust
-#     range, percentiles, sum, probabilistic volume, entropy, etc) either over
-#     the full image or on a per slice basis (slice axis can be specified),
-#     statistics over voxel coordinates (location of max, min and centre of
-#     mass, bounding box, etc) and statistics over categorical images (e.g. per
-#     region volume, count, average, Dice scores, etc). These statistics are
-#     robust to the presence of NaNs, and can be constrained by a mask and/or
-#     thresholded at a certain level.
-#     
-task_name: StatsCommand
-nipype_name: StatsCommand
-nipype_module: nipype.interfaces.niftyseg.stats
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_file: generic/file
-    # type=file|default=<undefined>: image to operate on
-    mask_file: generic/file
-    # type=file|default=<undefined>: statistics within the masked area
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: image to operate on
-    mask_file:
-    # type=file|default=<undefined>: statistics within the masked area
-    larger_voxel:
-    # type=float|default=0.0: Only estimate statistics if voxel is larger than <float>
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-niftyseg/stats_command_callables.py b/example-specs/task/nipype_internal/pydra-niftyseg/stats_command_callables.py
deleted file mode 100644
index 59622afe..00000000
--- a/example-specs/task/nipype_internal/pydra-niftyseg/stats_command_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in StatsCommand.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-niftyseg/tuple_maths.yaml b/example-specs/task/nipype_internal/pydra-niftyseg/tuple_maths.yaml
deleted file mode 100644
index f747c691..00000000
--- a/example-specs/task/nipype_internal/pydra-niftyseg/tuple_maths.yaml
+++ /dev/null
@@ -1,269 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.niftyseg.maths.TupleMaths' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Mathematical operations on tuples.
-# 
-#     See Also
-#     --------
-#     `Source code <http://cmictig.cs.ucl.ac.uk/wiki/index.php/NiftySeg>`__ --
-#     `Documentation <http://cmictig.cs.ucl.ac.uk/wiki/index.php/NiftySeg_documentation>`__
-# 
-#     Examples
-#     --------
-#     >>> import copy
-#     >>> from nipype.interfaces import niftyseg
-#     >>> tuple = niftyseg.TupleMaths()
-#     >>> tuple.inputs.in_file = 'im1.nii'
-#     >>> tuple.inputs.output_datatype = 'float'
-# 
-#     >>> # Test lncc operation
-#     >>> tuple_lncc = copy.deepcopy(tuple)
-#     >>> tuple_lncc.inputs.operation = 'lncc'
-#     >>> tuple_lncc.inputs.operand_file1 = 'im2.nii'
-#     >>> tuple_lncc.inputs.operand_value2 = 2.0
-#     >>> tuple_lncc.cmdline
-#     'seg_maths im1.nii -lncc im2.nii 2.00000000 -odt float im1_lncc.nii'
-#     >>> tuple_lncc.run()  # doctest: +SKIP
-# 
-#     >>> # Test lssd operation
-#     >>> tuple_lssd = copy.deepcopy(tuple)
-#     >>> tuple_lssd.inputs.operation = 'lssd'
-#     >>> tuple_lssd.inputs.operand_file1 = 'im2.nii'
-#     >>> tuple_lssd.inputs.operand_value2 = 1.0
-#     >>> tuple_lssd.cmdline
-#     'seg_maths im1.nii -lssd im2.nii 1.00000000 -odt float im1_lssd.nii'
-#     >>> tuple_lssd.run()  # doctest: +SKIP
-# 
-#     >>> # Test lltsnorm operation
-#     >>> tuple_lltsnorm = copy.deepcopy(tuple)
-#     >>> tuple_lltsnorm.inputs.operation = 'lltsnorm'
-#     >>> tuple_lltsnorm.inputs.operand_file1 = 'im2.nii'
-#     >>> tuple_lltsnorm.inputs.operand_value2 = 0.01
-#     >>> tuple_lltsnorm.cmdline
-#     'seg_maths im1.nii -lltsnorm im2.nii 0.01000000 -odt float im1_lltsnorm.nii'
-#     >>> tuple_lltsnorm.run()  # doctest: +SKIP
-# 
-#     
-task_name: TupleMaths
-nipype_name: TupleMaths
-nipype_module: nipype.interfaces.niftyseg.maths
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    operand_file1: medimage/nifti1
-    # type=file|default=<undefined>: image to perform operation 1 with
-    operand_file2: generic/file
-    # type=file|default=<undefined>: image to perform operation 2 with
-    in_file: medimage/nifti1
-    # type=file|default=<undefined>: image to operate on
-    out_file: generic/file
-    # type=file: image written after calculations
-    # type=file|default=<undefined>: image to write
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    out_file: generic/file
-    # type=file: image written after calculations
-    # type=file|default=<undefined>: image to write
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    operation:
-    # type=enum|default='lncc'|allowed['lltsnorm','lncc','lssd']: Operation to perform:      * lncc <file> <std> Local CC between current img and <file> on a kernel with <std>     * lssd <file> <std> Local SSD between current img and <file> on a kernel with <std>     * lltsnorm <file_norm> <float>  Linear LTS normalisation assuming <float> percent outliers  
-    operand_file1:
-    # type=file|default=<undefined>: image to perform operation 1 with
-    operand_value1:
-    # type=float|default=0.0: float value to perform operation 1 with
-    operand_file2:
-    # type=file|default=<undefined>: image to perform operation 2 with
-    operand_value2:
-    # type=float|default=0.0: float value to perform operation 2 with
-    in_file:
-    # type=file|default=<undefined>: image to operate on
-    out_file:
-    # type=file: image written after calculations
-    # type=file|default=<undefined>: image to write
-    output_datatype:
-    # type=enum|default='float'|allowed['char','double','float','input','int','short']: datatype to use for output (default uses input type)
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: image to operate on
-    output_datatype: '"float"'
-    # type=enum|default='float'|allowed['char','double','float','input','int','short']: datatype to use for output (default uses input type)
-    operation: '"lncc"'
-    # type=enum|default='lncc'|allowed['lltsnorm','lncc','lssd']: Operation to perform:      * lncc <file> <std> Local CC between current img and <file> on a kernel with <std>     * lssd <file> <std> Local SSD between current img and <file> on a kernel with <std>     * lltsnorm <file_norm> <float>  Linear LTS normalisation assuming <float> percent outliers  
-    operand_file1:
-    # type=file|default=<undefined>: image to perform operation 1 with
-    operand_value2: '2.0'
-    # type=float|default=0.0: float value to perform operation 2 with
-  imports: &id001
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  - module: copy
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    operation: '"lssd"'
-    # type=enum|default='lncc'|allowed['lltsnorm','lncc','lssd']: Operation to perform:      * lncc <file> <std> Local CC between current img and <file> on a kernel with <std>     * lssd <file> <std> Local SSD between current img and <file> on a kernel with <std>     * lltsnorm <file_norm> <float>  Linear LTS normalisation assuming <float> percent outliers  
-    operand_file1:
-    # type=file|default=<undefined>: image to perform operation 1 with
-    operand_value2: '1.0'
-    # type=float|default=0.0: float value to perform operation 2 with
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    operation: '"lltsnorm"'
-    # type=enum|default='lncc'|allowed['lltsnorm','lncc','lssd']: Operation to perform:      * lncc <file> <std> Local CC between current img and <file> on a kernel with <std>     * lssd <file> <std> Local SSD between current img and <file> on a kernel with <std>     * lltsnorm <file_norm> <float>  Linear LTS normalisation assuming <float> percent outliers  
-    operand_file1:
-    # type=file|default=<undefined>: image to perform operation 1 with
-    operand_value2: '0.01'
-    # type=float|default=0.0: float value to perform operation 2 with
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests:
-- cmdline: seg_maths im1.nii -lncc im2.nii 2.00000000 -odt float im1_lncc.nii
-  # str - the expected cmdline output
-  inputs:
-  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
-  # If the field is of file-format type and the value is None, then the
-  # '.mock()' method of the corresponding class is used instead.
-    in_file:
-    # type=file|default=<undefined>: image to operate on
-    output_datatype: '"float"'
-    # type=enum|default='float'|allowed['char','double','float','input','int','short']: datatype to use for output (default uses input type)
-    operation: '"lncc"'
-    # type=enum|default='lncc'|allowed['lltsnorm','lncc','lssd']: Operation to perform:      * lncc <file> <std> Local CC between current img and <file> on a kernel with <std>     * lssd <file> <std> Local SSD between current img and <file> on a kernel with <std>     * lltsnorm <file_norm> <float>  Linear LTS normalisation assuming <float> percent outliers  
-    operand_file1:
-    # type=file|default=<undefined>: image to perform operation 1 with
-    operand_value2: '2.0'
-    # type=float|default=0.0: float value to perform operation 2 with
-  imports: *id001
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  directive:
-  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
-- cmdline: seg_maths im1.nii -lssd im2.nii 1.00000000 -odt float im1_lssd.nii
-  # str - the expected cmdline output
-  inputs:
-  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
-  # If the field is of file-format type and the value is None, then the
-  # '.mock()' method of the corresponding class is used instead.
-    operation: '"lssd"'
-    # type=enum|default='lncc'|allowed['lltsnorm','lncc','lssd']: Operation to perform:      * lncc <file> <std> Local CC between current img and <file> on a kernel with <std>     * lssd <file> <std> Local SSD between current img and <file> on a kernel with <std>     * lltsnorm <file_norm> <float>  Linear LTS normalisation assuming <float> percent outliers  
-    operand_file1:
-    # type=file|default=<undefined>: image to perform operation 1 with
-    operand_value2: '1.0'
-    # type=float|default=0.0: float value to perform operation 2 with
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  directive:
-  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
-- cmdline: seg_maths im1.nii -lltsnorm im2.nii 0.01000000 -odt float im1_lltsnorm.nii
-  # str - the expected cmdline output
-  inputs:
-  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
-  # If the field is of file-format type and the value is None, then the
-  # '.mock()' method of the corresponding class is used instead.
-    operation: '"lltsnorm"'
-    # type=enum|default='lncc'|allowed['lltsnorm','lncc','lssd']: Operation to perform:      * lncc <file> <std> Local CC between current img and <file> on a kernel with <std>     * lssd <file> <std> Local SSD between current img and <file> on a kernel with <std>     * lltsnorm <file_norm> <float>  Linear LTS normalisation assuming <float> percent outliers  
-    operand_file1:
-    # type=file|default=<undefined>: image to perform operation 1 with
-    operand_value2: '0.01'
-    # type=float|default=0.0: float value to perform operation 2 with
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  directive:
-  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-niftyseg/tuple_maths_callables.py b/example-specs/task/nipype_internal/pydra-niftyseg/tuple_maths_callables.py
deleted file mode 100644
index 7a6b9e82..00000000
--- a/example-specs/task/nipype_internal/pydra-niftyseg/tuple_maths_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in TupleMaths.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-niftyseg/unary_maths.yaml b/example-specs/task/nipype_internal/pydra-niftyseg/unary_maths.yaml
deleted file mode 100644
index 83ef5b48..00000000
--- a/example-specs/task/nipype_internal/pydra-niftyseg/unary_maths.yaml
+++ /dev/null
@@ -1,307 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.niftyseg.maths.UnaryMaths' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Unary mathematical operations.
-# 
-#     See Also
-#     --------
-#     `Source code <http://cmictig.cs.ucl.ac.uk/wiki/index.php/NiftySeg>`__ --
-#     `Documentation <http://cmictig.cs.ucl.ac.uk/wiki/index.php/NiftySeg_documentation>`__
-# 
-#     Examples
-#     --------
-#     >>> import copy
-#     >>> from nipype.interfaces import niftyseg
-#     >>> unary = niftyseg.UnaryMaths()
-#     >>> unary.inputs.output_datatype = 'float'
-#     >>> unary.inputs.in_file = 'im1.nii'
-# 
-#     >>> # Test sqrt operation
-#     >>> unary_sqrt = copy.deepcopy(unary)
-#     >>> unary_sqrt.inputs.operation = 'sqrt'
-#     >>> unary_sqrt.cmdline
-#     'seg_maths im1.nii -sqrt -odt float im1_sqrt.nii'
-#     >>> unary_sqrt.run()  # doctest: +SKIP
-# 
-#     >>> # Test sqrt operation
-#     >>> unary_abs = copy.deepcopy(unary)
-#     >>> unary_abs.inputs.operation = 'abs'
-#     >>> unary_abs.cmdline
-#     'seg_maths im1.nii -abs -odt float im1_abs.nii'
-#     >>> unary_abs.run()  # doctest: +SKIP
-# 
-#     >>> # Test bin operation
-#     >>> unary_bin = copy.deepcopy(unary)
-#     >>> unary_bin.inputs.operation = 'bin'
-#     >>> unary_bin.cmdline
-#     'seg_maths im1.nii -bin -odt float im1_bin.nii'
-#     >>> unary_bin.run()  # doctest: +SKIP
-# 
-#     >>> # Test otsu operation
-#     >>> unary_otsu = copy.deepcopy(unary)
-#     >>> unary_otsu.inputs.operation = 'otsu'
-#     >>> unary_otsu.cmdline
-#     'seg_maths im1.nii -otsu -odt float im1_otsu.nii'
-#     >>> unary_otsu.run()  # doctest: +SKIP
-# 
-#     >>> # Test isnan operation
-#     >>> unary_isnan = copy.deepcopy(unary)
-#     >>> unary_isnan.inputs.operation = 'isnan'
-#     >>> unary_isnan.cmdline
-#     'seg_maths im1.nii -isnan -odt float im1_isnan.nii'
-#     >>> unary_isnan.run()  # doctest: +SKIP
-# 
-#     
-task_name: UnaryMaths
-nipype_name: UnaryMaths
-nipype_module: nipype.interfaces.niftyseg.maths
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_file: medimage/nifti1
-    # type=file|default=<undefined>: image to operate on
-    out_file: generic/file
-    # type=file: image written after calculations
-    # type=file|default=<undefined>: image to write
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    out_file: generic/file
-    # type=file: image written after calculations
-    # type=file|default=<undefined>: image to write
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    operation:
-    # type=enum|default='sqrt'|allowed['4to5','abs','bin','concomp26','concomp6','euc','exp','fill','isnan','lconcomp','log','otsu','range','recip','removenan','scl','splitlab','sqrt','subsamp2','tmax','tmean','tmin','tpmax']: Operation to perform:      * sqrt - Square root of the image).     * exp - Exponential root of the image.     * log - Log of the image.     * recip - Reciprocal (1/I) of the image.     * abs - Absolute value of the image.     * bin - Binarise the image.     * otsu - Otsu thresholding of the current image.     * lconcomp - Take the largest connected component     * concomp6 - Label the different connected components with a 6NN kernel     * concomp26 - Label the different connected components with a 26NN kernel     * fill - Fill holes in binary object (e.g. fill ventricle in brain mask).     * euc - Euclidean distance transform     * tpmax - Get the time point with the highest value (binarise 4D probabilities)     * tmean - Mean value of all time points.     * tmax - Max value of all time points.     * tmin - Mean value of all time points.     * splitlab - Split the integer labels into multiple timepoints     * removenan - Remove all NaNs and replace then with 0     * isnan - Binary image equal to 1 if the value is NaN and 0 otherwise     * subsamp2 - Subsample the image by 2 using NN sampling (qform and sform scaled)     * scl  - Reset scale and slope info.     * 4to5 - Flip the 4th and 5th dimension.     * range - Reset the image range to the min max.  
-    in_file:
-    # type=file|default=<undefined>: image to operate on
-    out_file:
-    # type=file: image written after calculations
-    # type=file|default=<undefined>: image to write
-    output_datatype:
-    # type=enum|default='float'|allowed['char','double','float','input','int','short']: datatype to use for output (default uses input type)
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    output_datatype: '"float"'
-    # type=enum|default='float'|allowed['char','double','float','input','int','short']: datatype to use for output (default uses input type)
-    in_file:
-    # type=file|default=<undefined>: image to operate on
-    operation: '"sqrt"'
-    # type=enum|default='sqrt'|allowed['4to5','abs','bin','concomp26','concomp6','euc','exp','fill','isnan','lconcomp','log','otsu','range','recip','removenan','scl','splitlab','sqrt','subsamp2','tmax','tmean','tmin','tpmax']: Operation to perform:      * sqrt - Square root of the image).     * exp - Exponential root of the image.     * log - Log of the image.     * recip - Reciprocal (1/I) of the image.     * abs - Absolute value of the image.     * bin - Binarise the image.     * otsu - Otsu thresholding of the current image.     * lconcomp - Take the largest connected component     * concomp6 - Label the different connected components with a 6NN kernel     * concomp26 - Label the different connected components with a 26NN kernel     * fill - Fill holes in binary object (e.g. fill ventricle in brain mask).     * euc - Euclidean distance transform     * tpmax - Get the time point with the highest value (binarise 4D probabilities)     * tmean - Mean value of all time points.     * tmax - Max value of all time points.     * tmin - Mean value of all time points.     * splitlab - Split the integer labels into multiple timepoints     * removenan - Remove all NaNs and replace then with 0     * isnan - Binary image equal to 1 if the value is NaN and 0 otherwise     * subsamp2 - Subsample the image by 2 using NN sampling (qform and sform scaled)     * scl  - Reset scale and slope info.     * 4to5 - Flip the 4th and 5th dimension.     * range - Reset the image range to the min max.  
-  imports: &id001
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  - module: copy
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    operation: '"abs"'
-    # type=enum|default='sqrt'|allowed['4to5','abs','bin','concomp26','concomp6','euc','exp','fill','isnan','lconcomp','log','otsu','range','recip','removenan','scl','splitlab','sqrt','subsamp2','tmax','tmean','tmin','tpmax']: Operation to perform:      * sqrt - Square root of the image).     * exp - Exponential root of the image.     * log - Log of the image.     * recip - Reciprocal (1/I) of the image.     * abs - Absolute value of the image.     * bin - Binarise the image.     * otsu - Otsu thresholding of the current image.     * lconcomp - Take the largest connected component     * concomp6 - Label the different connected components with a 6NN kernel     * concomp26 - Label the different connected components with a 26NN kernel     * fill - Fill holes in binary object (e.g. fill ventricle in brain mask).     * euc - Euclidean distance transform     * tpmax - Get the time point with the highest value (binarise 4D probabilities)     * tmean - Mean value of all time points.     * tmax - Max value of all time points.     * tmin - Mean value of all time points.     * splitlab - Split the integer labels into multiple timepoints     * removenan - Remove all NaNs and replace then with 0     * isnan - Binary image equal to 1 if the value is NaN and 0 otherwise     * subsamp2 - Subsample the image by 2 using NN sampling (qform and sform scaled)     * scl  - Reset scale and slope info.     * 4to5 - Flip the 4th and 5th dimension.     * range - Reset the image range to the min max.  
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    operation: '"bin"'
-    # type=enum|default='sqrt'|allowed['4to5','abs','bin','concomp26','concomp6','euc','exp','fill','isnan','lconcomp','log','otsu','range','recip','removenan','scl','splitlab','sqrt','subsamp2','tmax','tmean','tmin','tpmax']: Operation to perform:      * sqrt - Square root of the image).     * exp - Exponential root of the image.     * log - Log of the image.     * recip - Reciprocal (1/I) of the image.     * abs - Absolute value of the image.     * bin - Binarise the image.     * otsu - Otsu thresholding of the current image.     * lconcomp - Take the largest connected component     * concomp6 - Label the different connected components with a 6NN kernel     * concomp26 - Label the different connected components with a 26NN kernel     * fill - Fill holes in binary object (e.g. fill ventricle in brain mask).     * euc - Euclidean distance transform     * tpmax - Get the time point with the highest value (binarise 4D probabilities)     * tmean - Mean value of all time points.     * tmax - Max value of all time points.     * tmin - Mean value of all time points.     * splitlab - Split the integer labels into multiple timepoints     * removenan - Remove all NaNs and replace then with 0     * isnan - Binary image equal to 1 if the value is NaN and 0 otherwise     * subsamp2 - Subsample the image by 2 using NN sampling (qform and sform scaled)     * scl  - Reset scale and slope info.     * 4to5 - Flip the 4th and 5th dimension.     * range - Reset the image range to the min max.  
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    operation: '"otsu"'
-    # type=enum|default='sqrt'|allowed['4to5','abs','bin','concomp26','concomp6','euc','exp','fill','isnan','lconcomp','log','otsu','range','recip','removenan','scl','splitlab','sqrt','subsamp2','tmax','tmean','tmin','tpmax']: Operation to perform:      * sqrt - Square root of the image).     * exp - Exponential root of the image.     * log - Log of the image.     * recip - Reciprocal (1/I) of the image.     * abs - Absolute value of the image.     * bin - Binarise the image.     * otsu - Otsu thresholding of the current image.     * lconcomp - Take the largest connected component     * concomp6 - Label the different connected components with a 6NN kernel     * concomp26 - Label the different connected components with a 26NN kernel     * fill - Fill holes in binary object (e.g. fill ventricle in brain mask).     * euc - Euclidean distance transform     * tpmax - Get the time point with the highest value (binarise 4D probabilities)     * tmean - Mean value of all time points.     * tmax - Max value of all time points.     * tmin - Mean value of all time points.     * splitlab - Split the integer labels into multiple timepoints     * removenan - Remove all NaNs and replace then with 0     * isnan - Binary image equal to 1 if the value is NaN and 0 otherwise     * subsamp2 - Subsample the image by 2 using NN sampling (qform and sform scaled)     * scl  - Reset scale and slope info.     * 4to5 - Flip the 4th and 5th dimension.     * range - Reset the image range to the min max.  
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    operation: '"isnan"'
-    # type=enum|default='sqrt'|allowed['4to5','abs','bin','concomp26','concomp6','euc','exp','fill','isnan','lconcomp','log','otsu','range','recip','removenan','scl','splitlab','sqrt','subsamp2','tmax','tmean','tmin','tpmax']: Operation to perform:      * sqrt - Square root of the image).     * exp - Exponential root of the image.     * log - Log of the image.     * recip - Reciprocal (1/I) of the image.     * abs - Absolute value of the image.     * bin - Binarise the image.     * otsu - Otsu thresholding of the current image.     * lconcomp - Take the largest connected component     * concomp6 - Label the different connected components with a 6NN kernel     * concomp26 - Label the different connected components with a 26NN kernel     * fill - Fill holes in binary object (e.g. fill ventricle in brain mask).     * euc - Euclidean distance transform     * tpmax - Get the time point with the highest value (binarise 4D probabilities)     * tmean - Mean value of all time points.     * tmax - Max value of all time points.     * tmin - Mean value of all time points.     * splitlab - Split the integer labels into multiple timepoints     * removenan - Remove all NaNs and replace then with 0     * isnan - Binary image equal to 1 if the value is NaN and 0 otherwise     * subsamp2 - Subsample the image by 2 using NN sampling (qform and sform scaled)     * scl  - Reset scale and slope info.     * 4to5 - Flip the 4th and 5th dimension.     * range - Reset the image range to the min max.  
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests:
-- cmdline: seg_maths im1.nii -sqrt -odt float im1_sqrt.nii
-  # str - the expected cmdline output
-  inputs:
-  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
-  # If the field is of file-format type and the value is None, then the
-  # '.mock()' method of the corresponding class is used instead.
-    output_datatype: '"float"'
-    # type=enum|default='float'|allowed['char','double','float','input','int','short']: datatype to use for output (default uses input type)
-    in_file:
-    # type=file|default=<undefined>: image to operate on
-    operation: '"sqrt"'
-    # type=enum|default='sqrt'|allowed['4to5','abs','bin','concomp26','concomp6','euc','exp','fill','isnan','lconcomp','log','otsu','range','recip','removenan','scl','splitlab','sqrt','subsamp2','tmax','tmean','tmin','tpmax']: Operation to perform:      * sqrt - Square root of the image).     * exp - Exponential root of the image.     * log - Log of the image.     * recip - Reciprocal (1/I) of the image.     * abs - Absolute value of the image.     * bin - Binarise the image.     * otsu - Otsu thresholding of the current image.     * lconcomp - Take the largest connected component     * concomp6 - Label the different connected components with a 6NN kernel     * concomp26 - Label the different connected components with a 26NN kernel     * fill - Fill holes in binary object (e.g. fill ventricle in brain mask).     * euc - Euclidean distance transform     * tpmax - Get the time point with the highest value (binarise 4D probabilities)     * tmean - Mean value of all time points.     * tmax - Max value of all time points.     * tmin - Mean value of all time points.     * splitlab - Split the integer labels into multiple timepoints     * removenan - Remove all NaNs and replace then with 0     * isnan - Binary image equal to 1 if the value is NaN and 0 otherwise     * subsamp2 - Subsample the image by 2 using NN sampling (qform and sform scaled)     * scl  - Reset scale and slope info.     * 4to5 - Flip the 4th and 5th dimension.     * range - Reset the image range to the min max.  
-  imports: *id001
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  directive:
-  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
-- cmdline: seg_maths im1.nii -abs -odt float im1_abs.nii
-  # str - the expected cmdline output
-  inputs:
-  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
-  # If the field is of file-format type and the value is None, then the
-  # '.mock()' method of the corresponding class is used instead.
-    operation: '"abs"'
-    # type=enum|default='sqrt'|allowed['4to5','abs','bin','concomp26','concomp6','euc','exp','fill','isnan','lconcomp','log','otsu','range','recip','removenan','scl','splitlab','sqrt','subsamp2','tmax','tmean','tmin','tpmax']: Operation to perform:      * sqrt - Square root of the image).     * exp - Exponential root of the image.     * log - Log of the image.     * recip - Reciprocal (1/I) of the image.     * abs - Absolute value of the image.     * bin - Binarise the image.     * otsu - Otsu thresholding of the current image.     * lconcomp - Take the largest connected component     * concomp6 - Label the different connected components with a 6NN kernel     * concomp26 - Label the different connected components with a 26NN kernel     * fill - Fill holes in binary object (e.g. fill ventricle in brain mask).     * euc - Euclidean distance transform     * tpmax - Get the time point with the highest value (binarise 4D probabilities)     * tmean - Mean value of all time points.     * tmax - Max value of all time points.     * tmin - Mean value of all time points.     * splitlab - Split the integer labels into multiple timepoints     * removenan - Remove all NaNs and replace then with 0     * isnan - Binary image equal to 1 if the value is NaN and 0 otherwise     * subsamp2 - Subsample the image by 2 using NN sampling (qform and sform scaled)     * scl  - Reset scale and slope info.     * 4to5 - Flip the 4th and 5th dimension.     * range - Reset the image range to the min max.  
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  directive:
-  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
-- cmdline: seg_maths im1.nii -bin -odt float im1_bin.nii
-  # str - the expected cmdline output
-  inputs:
-  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
-  # If the field is of file-format type and the value is None, then the
-  # '.mock()' method of the corresponding class is used instead.
-    operation: '"bin"'
-    # type=enum|default='sqrt'|allowed['4to5','abs','bin','concomp26','concomp6','euc','exp','fill','isnan','lconcomp','log','otsu','range','recip','removenan','scl','splitlab','sqrt','subsamp2','tmax','tmean','tmin','tpmax']: Operation to perform:      * sqrt - Square root of the image).     * exp - Exponential root of the image.     * log - Log of the image.     * recip - Reciprocal (1/I) of the image.     * abs - Absolute value of the image.     * bin - Binarise the image.     * otsu - Otsu thresholding of the current image.     * lconcomp - Take the largest connected component     * concomp6 - Label the different connected components with a 6NN kernel     * concomp26 - Label the different connected components with a 26NN kernel     * fill - Fill holes in binary object (e.g. fill ventricle in brain mask).     * euc - Euclidean distance transform     * tpmax - Get the time point with the highest value (binarise 4D probabilities)     * tmean - Mean value of all time points.     * tmax - Max value of all time points.     * tmin - Mean value of all time points.     * splitlab - Split the integer labels into multiple timepoints     * removenan - Remove all NaNs and replace then with 0     * isnan - Binary image equal to 1 if the value is NaN and 0 otherwise     * subsamp2 - Subsample the image by 2 using NN sampling (qform and sform scaled)     * scl  - Reset scale and slope info.     * 4to5 - Flip the 4th and 5th dimension.     * range - Reset the image range to the min max.  
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  directive:
-  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
-- cmdline: seg_maths im1.nii -otsu -odt float im1_otsu.nii
-  # str - the expected cmdline output
-  inputs:
-  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
-  # If the field is of file-format type and the value is None, then the
-  # '.mock()' method of the corresponding class is used instead.
-    operation: '"otsu"'
-    # type=enum|default='sqrt'|allowed['4to5','abs','bin','concomp26','concomp6','euc','exp','fill','isnan','lconcomp','log','otsu','range','recip','removenan','scl','splitlab','sqrt','subsamp2','tmax','tmean','tmin','tpmax']: Operation to perform:      * sqrt - Square root of the image).     * exp - Exponential root of the image.     * log - Log of the image.     * recip - Reciprocal (1/I) of the image.     * abs - Absolute value of the image.     * bin - Binarise the image.     * otsu - Otsu thresholding of the current image.     * lconcomp - Take the largest connected component     * concomp6 - Label the different connected components with a 6NN kernel     * concomp26 - Label the different connected components with a 26NN kernel     * fill - Fill holes in binary object (e.g. fill ventricle in brain mask).     * euc - Euclidean distance transform     * tpmax - Get the time point with the highest value (binarise 4D probabilities)     * tmean - Mean value of all time points.     * tmax - Max value of all time points.     * tmin - Mean value of all time points.     * splitlab - Split the integer labels into multiple timepoints     * removenan - Remove all NaNs and replace then with 0     * isnan - Binary image equal to 1 if the value is NaN and 0 otherwise     * subsamp2 - Subsample the image by 2 using NN sampling (qform and sform scaled)     * scl  - Reset scale and slope info.     * 4to5 - Flip the 4th and 5th dimension.     * range - Reset the image range to the min max.  
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  directive:
-  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
-- cmdline: seg_maths im1.nii -isnan -odt float im1_isnan.nii
-  # str - the expected cmdline output
-  inputs:
-  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
-  # If the field is of file-format type and the value is None, then the
-  # '.mock()' method of the corresponding class is used instead.
-    operation: '"isnan"'
-    # type=enum|default='sqrt'|allowed['4to5','abs','bin','concomp26','concomp6','euc','exp','fill','isnan','lconcomp','log','otsu','range','recip','removenan','scl','splitlab','sqrt','subsamp2','tmax','tmean','tmin','tpmax']: Operation to perform:      * sqrt - Square root of the image).     * exp - Exponential root of the image.     * log - Log of the image.     * recip - Reciprocal (1/I) of the image.     * abs - Absolute value of the image.     * bin - Binarise the image.     * otsu - Otsu thresholding of the current image.     * lconcomp - Take the largest connected component     * concomp6 - Label the different connected components with a 6NN kernel     * concomp26 - Label the different connected components with a 26NN kernel     * fill - Fill holes in binary object (e.g. fill ventricle in brain mask).     * euc - Euclidean distance transform     * tpmax - Get the time point with the highest value (binarise 4D probabilities)     * tmean - Mean value of all time points.     * tmax - Max value of all time points.     * tmin - Mean value of all time points.     * splitlab - Split the integer labels into multiple timepoints     * removenan - Remove all NaNs and replace then with 0     * isnan - Binary image equal to 1 if the value is NaN and 0 otherwise     * subsamp2 - Subsample the image by 2 using NN sampling (qform and sform scaled)     * scl  - Reset scale and slope info.     * 4to5 - Flip the 4th and 5th dimension.     * range - Reset the image range to the min max.  
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  directive:
-  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-niftyseg/unary_maths_callables.py b/example-specs/task/nipype_internal/pydra-niftyseg/unary_maths_callables.py
deleted file mode 100644
index ae1ae260..00000000
--- a/example-specs/task/nipype_internal/pydra-niftyseg/unary_maths_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in UnaryMaths.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-niftyseg/unary_stats.yaml b/example-specs/task/nipype_internal/pydra-niftyseg/unary_stats.yaml
deleted file mode 100644
index e7f235db..00000000
--- a/example-specs/task/nipype_internal/pydra-niftyseg/unary_stats.yaml
+++ /dev/null
@@ -1,217 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.niftyseg.stats.UnaryStats' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Unary statistical operations.
-# 
-#     See Also
-#     --------
-#     `Source code <http://cmictig.cs.ucl.ac.uk/wiki/index.php/NiftySeg>`__ --
-#     `Documentation <http://cmictig.cs.ucl.ac.uk/wiki/index.php/NiftySeg_documentation>`__
-# 
-#     Examples
-#     --------
-#     >>> import copy
-#     >>> from nipype.interfaces import niftyseg
-#     >>> unary = niftyseg.UnaryStats()
-#     >>> unary.inputs.in_file = 'im1.nii'
-# 
-#     >>> # Test v operation
-#     >>> unary_v = copy.deepcopy(unary)
-#     >>> unary_v.inputs.operation = 'v'
-#     >>> unary_v.cmdline
-#     'seg_stats im1.nii -v'
-#     >>> unary_v.run()  # doctest: +SKIP
-# 
-#     >>> # Test vl operation
-#     >>> unary_vl = copy.deepcopy(unary)
-#     >>> unary_vl.inputs.operation = 'vl'
-#     >>> unary_vl.cmdline
-#     'seg_stats im1.nii -vl'
-#     >>> unary_vl.run()  # doctest: +SKIP
-# 
-#     >>> # Test x operation
-#     >>> unary_x = copy.deepcopy(unary)
-#     >>> unary_x.inputs.operation = 'x'
-#     >>> unary_x.cmdline
-#     'seg_stats im1.nii -x'
-#     >>> unary_x.run()  # doctest: +SKIP
-# 
-#     
-task_name: UnaryStats
-nipype_name: UnaryStats
-nipype_module: nipype.interfaces.niftyseg.stats
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_file: medimage/nifti1
-    # type=file|default=<undefined>: image to operate on
-    mask_file: generic/file
-    # type=file|default=<undefined>: statistics within the masked area
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    operation:
-    # type=enum|default='r'|allowed['B','R','X','a','c','e','n','ne','np','r','s','v','vl','vp','x','xdim','xvox']: Operation to perform:      * r - The range <min max> of all voxels.     * R - The robust range (assuming 2% outliers on both sides) of all voxels     * a - Average of all voxels     * s - Standard deviation of all voxels     * v - Volume of all voxels above 0 (<# voxels> * <volume per voxel>)     * vl - Volume of each integer label (<# voxels per label> x <volume per voxel>)     * vp - Volume of all probabilsitic voxels (sum(<in>) x <volume per voxel>)     * n - Count of all voxels above 0 (<# voxels>)     * np - Sum of all fuzzy voxels (sum(<in>))     * e - Entropy of all voxels     * ne - Normalized entropy of all voxels     * x - Location (i j k x y z) of the smallest value in the image     * X - Location (i j k x y z) of the largest value in the image     * c - Location (i j k x y z) of the centre of mass of the object     * B - Bounding box of all nonzero voxels [ xmin xsize ymin ysize zmin zsize ]     * xvox - Output the number of voxels in the x direction.       Replace x with y/z for other directions.     * xdim - Output the voxel dimension in the x direction.       Replace x with y/z for other directions.  
-    in_file:
-    # type=file|default=<undefined>: image to operate on
-    mask_file:
-    # type=file|default=<undefined>: statistics within the masked area
-    larger_voxel:
-    # type=float|default=0.0: Only estimate statistics if voxel is larger than <float>
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: image to operate on
-    operation: '"v"'
-    # type=enum|default='r'|allowed['B','R','X','a','c','e','n','ne','np','r','s','v','vl','vp','x','xdim','xvox']: Operation to perform:      * r - The range <min max> of all voxels.     * R - The robust range (assuming 2% outliers on both sides) of all voxels     * a - Average of all voxels     * s - Standard deviation of all voxels     * v - Volume of all voxels above 0 (<# voxels> * <volume per voxel>)     * vl - Volume of each integer label (<# voxels per label> x <volume per voxel>)     * vp - Volume of all probabilsitic voxels (sum(<in>) x <volume per voxel>)     * n - Count of all voxels above 0 (<# voxels>)     * np - Sum of all fuzzy voxels (sum(<in>))     * e - Entropy of all voxels     * ne - Normalized entropy of all voxels     * x - Location (i j k x y z) of the smallest value in the image     * X - Location (i j k x y z) of the largest value in the image     * c - Location (i j k x y z) of the centre of mass of the object     * B - Bounding box of all nonzero voxels [ xmin xsize ymin ysize zmin zsize ]     * xvox - Output the number of voxels in the x direction.       Replace x with y/z for other directions.     * xdim - Output the voxel dimension in the x direction.       Replace x with y/z for other directions.  
-  imports: &id001
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  - module: copy
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    operation: '"vl"'
-    # type=enum|default='r'|allowed['B','R','X','a','c','e','n','ne','np','r','s','v','vl','vp','x','xdim','xvox']: Operation to perform:      * r - The range <min max> of all voxels.     * R - The robust range (assuming 2% outliers on both sides) of all voxels     * a - Average of all voxels     * s - Standard deviation of all voxels     * v - Volume of all voxels above 0 (<# voxels> * <volume per voxel>)     * vl - Volume of each integer label (<# voxels per label> x <volume per voxel>)     * vp - Volume of all probabilsitic voxels (sum(<in>) x <volume per voxel>)     * n - Count of all voxels above 0 (<# voxels>)     * np - Sum of all fuzzy voxels (sum(<in>))     * e - Entropy of all voxels     * ne - Normalized entropy of all voxels     * x - Location (i j k x y z) of the smallest value in the image     * X - Location (i j k x y z) of the largest value in the image     * c - Location (i j k x y z) of the centre of mass of the object     * B - Bounding box of all nonzero voxels [ xmin xsize ymin ysize zmin zsize ]     * xvox - Output the number of voxels in the x direction.       Replace x with y/z for other directions.     * xdim - Output the voxel dimension in the x direction.       Replace x with y/z for other directions.  
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    operation: '"x"'
-    # type=enum|default='r'|allowed['B','R','X','a','c','e','n','ne','np','r','s','v','vl','vp','x','xdim','xvox']: Operation to perform:      * r - The range <min max> of all voxels.     * R - The robust range (assuming 2% outliers on both sides) of all voxels     * a - Average of all voxels     * s - Standard deviation of all voxels     * v - Volume of all voxels above 0 (<# voxels> * <volume per voxel>)     * vl - Volume of each integer label (<# voxels per label> x <volume per voxel>)     * vp - Volume of all probabilsitic voxels (sum(<in>) x <volume per voxel>)     * n - Count of all voxels above 0 (<# voxels>)     * np - Sum of all fuzzy voxels (sum(<in>))     * e - Entropy of all voxels     * ne - Normalized entropy of all voxels     * x - Location (i j k x y z) of the smallest value in the image     * X - Location (i j k x y z) of the largest value in the image     * c - Location (i j k x y z) of the centre of mass of the object     * B - Bounding box of all nonzero voxels [ xmin xsize ymin ysize zmin zsize ]     * xvox - Output the number of voxels in the x direction.       Replace x with y/z for other directions.     * xdim - Output the voxel dimension in the x direction.       Replace x with y/z for other directions.  
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests:
-- cmdline: seg_stats im1.nii -v
-  # str - the expected cmdline output
-  inputs:
-  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
-  # If the field is of file-format type and the value is None, then the
-  # '.mock()' method of the corresponding class is used instead.
-    in_file:
-    # type=file|default=<undefined>: image to operate on
-    operation: '"v"'
-    # type=enum|default='r'|allowed['B','R','X','a','c','e','n','ne','np','r','s','v','vl','vp','x','xdim','xvox']: Operation to perform:      * r - The range <min max> of all voxels.     * R - The robust range (assuming 2% outliers on both sides) of all voxels     * a - Average of all voxels     * s - Standard deviation of all voxels     * v - Volume of all voxels above 0 (<# voxels> * <volume per voxel>)     * vl - Volume of each integer label (<# voxels per label> x <volume per voxel>)     * vp - Volume of all probabilsitic voxels (sum(<in>) x <volume per voxel>)     * n - Count of all voxels above 0 (<# voxels>)     * np - Sum of all fuzzy voxels (sum(<in>))     * e - Entropy of all voxels     * ne - Normalized entropy of all voxels     * x - Location (i j k x y z) of the smallest value in the image     * X - Location (i j k x y z) of the largest value in the image     * c - Location (i j k x y z) of the centre of mass of the object     * B - Bounding box of all nonzero voxels [ xmin xsize ymin ysize zmin zsize ]     * xvox - Output the number of voxels in the x direction.       Replace x with y/z for other directions.     * xdim - Output the voxel dimension in the x direction.       Replace x with y/z for other directions.  
-  imports: *id001
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  directive:
-  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
-- cmdline: seg_stats im1.nii -vl
-  # str - the expected cmdline output
-  inputs:
-  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
-  # If the field is of file-format type and the value is None, then the
-  # '.mock()' method of the corresponding class is used instead.
-    operation: '"vl"'
-    # type=enum|default='r'|allowed['B','R','X','a','c','e','n','ne','np','r','s','v','vl','vp','x','xdim','xvox']: Operation to perform:      * r - The range <min max> of all voxels.     * R - The robust range (assuming 2% outliers on both sides) of all voxels     * a - Average of all voxels     * s - Standard deviation of all voxels     * v - Volume of all voxels above 0 (<# voxels> * <volume per voxel>)     * vl - Volume of each integer label (<# voxels per label> x <volume per voxel>)     * vp - Volume of all probabilsitic voxels (sum(<in>) x <volume per voxel>)     * n - Count of all voxels above 0 (<# voxels>)     * np - Sum of all fuzzy voxels (sum(<in>))     * e - Entropy of all voxels     * ne - Normalized entropy of all voxels     * x - Location (i j k x y z) of the smallest value in the image     * X - Location (i j k x y z) of the largest value in the image     * c - Location (i j k x y z) of the centre of mass of the object     * B - Bounding box of all nonzero voxels [ xmin xsize ymin ysize zmin zsize ]     * xvox - Output the number of voxels in the x direction.       Replace x with y/z for other directions.     * xdim - Output the voxel dimension in the x direction.       Replace x with y/z for other directions.  
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  directive:
-  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
-- cmdline: seg_stats im1.nii -x
-  # str - the expected cmdline output
-  inputs:
-  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
-  # If the field is of file-format type and the value is None, then the
-  # '.mock()' method of the corresponding class is used instead.
-    operation: '"x"'
-    # type=enum|default='r'|allowed['B','R','X','a','c','e','n','ne','np','r','s','v','vl','vp','x','xdim','xvox']: Operation to perform:      * r - The range <min max> of all voxels.     * R - The robust range (assuming 2% outliers on both sides) of all voxels     * a - Average of all voxels     * s - Standard deviation of all voxels     * v - Volume of all voxels above 0 (<# voxels> * <volume per voxel>)     * vl - Volume of each integer label (<# voxels per label> x <volume per voxel>)     * vp - Volume of all probabilsitic voxels (sum(<in>) x <volume per voxel>)     * n - Count of all voxels above 0 (<# voxels>)     * np - Sum of all fuzzy voxels (sum(<in>))     * e - Entropy of all voxels     * ne - Normalized entropy of all voxels     * x - Location (i j k x y z) of the smallest value in the image     * X - Location (i j k x y z) of the largest value in the image     * c - Location (i j k x y z) of the centre of mass of the object     * B - Bounding box of all nonzero voxels [ xmin xsize ymin ysize zmin zsize ]     * xvox - Output the number of voxels in the x direction.       Replace x with y/z for other directions.     * xdim - Output the voxel dimension in the x direction.       Replace x with y/z for other directions.  
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  directive:
-  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-niftyseg/unary_stats_callables.py b/example-specs/task/nipype_internal/pydra-niftyseg/unary_stats_callables.py
deleted file mode 100644
index 6a045e76..00000000
--- a/example-specs/task/nipype_internal/pydra-niftyseg/unary_stats_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in UnaryStats.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-nilearn/nilearn_base_interface.yaml b/example-specs/task/nipype_internal/pydra-nilearn/nilearn_base_interface.yaml
deleted file mode 100644
index b724a38c..00000000
--- a/example-specs/task/nipype_internal/pydra-nilearn/nilearn_base_interface.yaml
+++ /dev/null
@@ -1,62 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.nilearn.NilearnBaseInterface' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-task_name: NilearnBaseInterface
-nipype_name: NilearnBaseInterface
-nipype_module: nipype.interfaces.nilearn
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-nilearn/nilearn_base_interface_callables.py b/example-specs/task/nipype_internal/pydra-nilearn/nilearn_base_interface_callables.py
deleted file mode 100644
index 92f926a6..00000000
--- a/example-specs/task/nipype_internal/pydra-nilearn/nilearn_base_interface_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in NilearnBaseInterface.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-nilearn/signal_extraction.yaml b/example-specs/task/nipype_internal/pydra-nilearn/signal_extraction.yaml
deleted file mode 100644
index 84a56847..00000000
--- a/example-specs/task/nipype_internal/pydra-nilearn/signal_extraction.yaml
+++ /dev/null
@@ -1,98 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.nilearn.SignalExtraction' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Extracts signals over tissue classes or brain regions
-# 
-#     >>> seinterface = SignalExtraction()
-#     >>> seinterface.inputs.in_file = 'functional.nii'
-#     >>> seinterface.inputs.label_files = 'segmentation0.nii.gz'
-#     >>> seinterface.inputs.out_file = 'means.tsv'
-#     >>> segments = ['CSF', 'GrayMatter', 'WhiteMatter']
-#     >>> seinterface.inputs.class_labels = segments
-#     >>> seinterface.inputs.detrend = True
-#     >>> seinterface.inputs.include_global = True
-#     
-task_name: SignalExtraction
-nipype_name: SignalExtraction
-nipype_module: nipype.interfaces.nilearn
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_file: generic/file
-    # type=file|default=<undefined>: 4-D fMRI nii file
-    label_files: generic/file+list-of
-    # type=inputmultiobject|default=[]: a 3-D label image, with 0 denoting background, or a list of 3-D probability maps (one per label) or the equivalent 4D file.
-    out_file: generic/file
-    # type=file: tsv file containing the computed signals, with as many columns as there are labels and as many rows as there are timepoints in in_file, plus a header row with values from class_labels
-    # type=file|default='signals.tsv': The name of the file to output to. signals.tsv by default
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    out_file: generic/file
-    # type=file: tsv file containing the computed signals, with as many columns as there are labels and as many rows as there are timepoints in in_file, plus a header row with values from class_labels
-    # type=file|default='signals.tsv': The name of the file to output to. signals.tsv by default
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: 4-D fMRI nii file
-    label_files:
-    # type=inputmultiobject|default=[]: a 3-D label image, with 0 denoting background, or a list of 3-D probability maps (one per label) or the equivalent 4D file.
-    class_labels:
-    # type=list|default=[]: Human-readable labels for each segment in the label file, in order. The length of class_labels must be equal to the number of segments (background excluded). This list corresponds to the class labels in label_file in ascending order
-    out_file:
-    # type=file: tsv file containing the computed signals, with as many columns as there are labels and as many rows as there are timepoints in in_file, plus a header row with values from class_labels
-    # type=file|default='signals.tsv': The name of the file to output to. signals.tsv by default
-    incl_shared_variance:
-    # type=bool|default=True: By default (True), returns simple time series calculated from each region independently (e.g., for noise regression). If False, returns unique signals for each region, discarding shared variance (e.g., for connectivity. Only has effect with 4D probability maps.
-    include_global:
-    # type=bool|default=False: If True, include an extra column labeled "GlobalSignal", with values calculated from the entire brain (instead of just regions).
-    detrend:
-    # type=bool|default=False: If True, perform detrending using nilearn.
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-nilearn/signal_extraction_callables.py b/example-specs/task/nipype_internal/pydra-nilearn/signal_extraction_callables.py
deleted file mode 100644
index d1ae6627..00000000
--- a/example-specs/task/nipype_internal/pydra-nilearn/signal_extraction_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in SignalExtraction.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-nitime/coherence_analyzer.yaml b/example-specs/task/nipype_internal/pydra-nitime/coherence_analyzer.yaml
deleted file mode 100644
index 83ec4c22..00000000
--- a/example-specs/task/nipype_internal/pydra-nitime/coherence_analyzer.yaml
+++ /dev/null
@@ -1,94 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.nitime.analysis.CoherenceAnalyzer' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Wraps nitime.analysis.CoherenceAnalyzer: Coherence/y
-task_name: CoherenceAnalyzer
-nipype_name: CoherenceAnalyzer
-nipype_module: nipype.interfaces.nitime.analysis
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_file: generic/file
-    # type=file|default=<undefined>: csv file with ROIs on the columns and time-points on the rows. ROI names at the top row
-    output_csv_file: generic/file
-    # type=file|default=<undefined>: File to write outputs (coherence,time-delay) with file-names: ``file_name_{coherence,timedelay}``
-    output_figure_file: generic/file
-    # type=file|default=<undefined>: File to write output figures (coherence,time-delay) with file-names: ``file_name_{coherence,timedelay}``. Possible formats: .png,.svg,.pdf,.jpg,...
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    coherence_csv: generic/file
-    # type=file: A csv file containing the pairwise  coherence values
-    timedelay_csv: generic/file
-    # type=file: A csv file containing the pairwise time delay values
-    coherence_fig: generic/file
-    # type=file: Figure representing coherence values
-    timedelay_fig: generic/file
-    # type=file: Figure representing coherence values
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: csv file with ROIs on the columns and time-points on the rows. ROI names at the top row
-    TR:
-    # type=float|default=0.0: The TR used to collect the data in your csv file <in_file>
-    in_TS:
-    # type=any|default=None: a nitime TimeSeries object
-    NFFT:
-    # type=range|default=64: This is the size of the window used for the spectral estimation. Use values between 32 and the number of samples in your time-series.(Defaults to 64.)
-    n_overlap:
-    # type=range|default=0: The number of samples which overlapbetween subsequent windows.(Defaults to 0)
-    frequency_range:
-    # type=list|default=[0.02, 0.15]: The range of frequencies overwhich the analysis will average.[low,high] (Default [0.02,0.15]
-    output_csv_file:
-    # type=file|default=<undefined>: File to write outputs (coherence,time-delay) with file-names: ``file_name_{coherence,timedelay}``
-    output_figure_file:
-    # type=file|default=<undefined>: File to write output figures (coherence,time-delay) with file-names: ``file_name_{coherence,timedelay}``. Possible formats: .png,.svg,.pdf,.jpg,...
-    figure_type:
-    # type=enum|default='matrix'|allowed['matrix','network']: The type of plot to generate, where 'matrix' denotes a matrix image and'network' denotes a graph representation. Default: 'matrix'
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-nitime/coherence_analyzer_callables.py b/example-specs/task/nipype_internal/pydra-nitime/coherence_analyzer_callables.py
deleted file mode 100644
index f81d3da2..00000000
--- a/example-specs/task/nipype_internal/pydra-nitime/coherence_analyzer_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in CoherenceAnalyzer.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-petpvc/petpvc.yaml b/example-specs/task/nipype_internal/pydra-petpvc/petpvc.yaml
deleted file mode 100644
index 9d536425..00000000
--- a/example-specs/task/nipype_internal/pydra-petpvc/petpvc.yaml
+++ /dev/null
@@ -1,128 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.petpvc.PETPVC' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Use PETPVC for partial volume correction of PET images.
-# 
-#     PETPVC ([1]_, [2]_) is a software from the Nuclear Medicine Department
-#     of the UCL University Hospital, London, UK.
-# 
-#     Examples
-#     --------
-#     >>> from ..testing import example_data
-#     >>> #TODO get data for PETPVC
-#     >>> pvc = PETPVC()
-#     >>> pvc.inputs.in_file   = 'pet.nii.gz'
-#     >>> pvc.inputs.mask_file = 'tissues.nii.gz'
-#     >>> pvc.inputs.out_file  = 'pet_pvc_rbv.nii.gz'
-#     >>> pvc.inputs.pvc = 'RBV'
-#     >>> pvc.inputs.fwhm_x = 2.0
-#     >>> pvc.inputs.fwhm_y = 2.0
-#     >>> pvc.inputs.fwhm_z = 2.0
-#     >>> outs = pvc.run() #doctest: +SKIP
-# 
-#     References
-#     ----------
-#     .. [1] K. Erlandsson, I. Buvat, P. H. Pretorius, B. A. Thomas, and B. F. Hutton,
-#            "A review of partial volume correction techniques for emission tomography
-#            and their applications in neurology, cardiology and oncology," Phys. Med.
-#            Biol., vol. 57, no. 21, p. R119, 2012.
-#     .. [2] https://github.com/UCL/PETPVC
-# 
-#     
-task_name: PETPVC
-nipype_name: PETPVC
-nipype_module: nipype.interfaces.petpvc
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_file: generic/file
-    # type=file|default=<undefined>: PET image file
-    mask_file: generic/file
-    # type=file|default=<undefined>: Mask image file
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    out_file: generic/file
-    # type=file: Output file
-    # type=file|default=<undefined>: Output file
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    out_file: out_file
-    # type=file: Output file
-    # type=file|default=<undefined>: Output file
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: PET image file
-    out_file:
-    # type=file: Output file
-    # type=file|default=<undefined>: Output file
-    mask_file:
-    # type=file|default=<undefined>: Mask image file
-    pvc:
-    # type=enum|default='GTM'|allowed['GTM','IY','IY+RL','IY+VC','LABBE','LABBE+MTC','LABBE+MTC+RL','LABBE+MTC+VC','LABBE+RBV','LABBE+RBV+RL','LABBE+RBV+VC','MG','MG+RL','MG+VC','MTC','MTC+RL','MTC+VC','RBV','RBV+RL','RBV+VC','RL','VC']: Desired PVC method:      * Geometric transfer matrix -- ``GTM``     * Labbe approach -- ``LABBE``     * Richardson-Lucy -- ``RL``     * Van-Cittert -- ``VC``     * Region-based voxel-wise correction -- ``RBV``     * RBV with Labbe -- ``LABBE+RBV``     * RBV with Van-Cittert -- ``RBV+VC``     * RBV with Richardson-Lucy -- ``RBV+RL``     * RBV with Labbe and Van-Cittert -- ``LABBE+RBV+VC``     * RBV with Labbe and Richardson-Lucy -- ``LABBE+RBV+RL``     * Multi-target correction -- ``MTC``     * MTC with Labbe -- ``LABBE+MTC``     * MTC with Van-Cittert -- ``MTC+VC``     * MTC with Richardson-Lucy -- ``MTC+RL``     * MTC with Labbe and Van-Cittert -- ``LABBE+MTC+VC``     * MTC with Labbe and Richardson-Lucy -- ``LABBE+MTC+RL``     * Iterative Yang -- ``IY``     * Iterative Yang with Van-Cittert -- ``IY+VC``     * Iterative Yang with Richardson-Lucy -- ``IY+RL``     * Muller Gartner -- ``MG``     * Muller Gartner with Van-Cittert -- ``MG+VC``     * Muller Gartner with Richardson-Lucy -- ``MG+RL``  
-    fwhm_x:
-    # type=float|default=0.0: The full-width at half maximum in mm along x-axis
-    fwhm_y:
-    # type=float|default=0.0: The full-width at half maximum in mm along y-axis
-    fwhm_z:
-    # type=float|default=0.0: The full-width at half maximum in mm along z-axis
-    debug:
-    # type=bool|default=False: Prints debug information
-    n_iter:
-    # type=int|default=10: Number of iterations
-    n_deconv:
-    # type=int|default=10: Number of deconvolution iterations
-    alpha:
-    # type=float|default=1.5: Alpha value
-    stop_crit:
-    # type=float|default=0.01: Stopping criterion
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-petpvc/petpvc_callables.py b/example-specs/task/nipype_internal/pydra-petpvc/petpvc_callables.py
deleted file mode 100644
index 4316b213..00000000
--- a/example-specs/task/nipype_internal/pydra-petpvc/petpvc_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in PETPVC.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-quickshear/quickshear.yaml b/example-specs/task/nipype_internal/pydra-quickshear/quickshear.yaml
deleted file mode 100644
index fcd5f5ee..00000000
--- a/example-specs/task/nipype_internal/pydra-quickshear/quickshear.yaml
+++ /dev/null
@@ -1,155 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.quickshear.Quickshear' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Quickshear is a simple geometric defacing algorithm
-# 
-#     Given an anatomical image and a reasonable brainmask, Quickshear estimates
-#     a shearing plane with the brain mask on one side and the face on the other,
-#     zeroing out the face side.
-# 
-#     >>> from nipype.interfaces.quickshear import Quickshear
-#     >>> qs = Quickshear(in_file='T1.nii', mask_file='brain_mask.nii')
-#     >>> qs.cmdline
-#     'quickshear T1.nii brain_mask.nii T1_defaced.nii'
-# 
-#     In the absence of a precomputed mask, a simple pipeline can be generated
-#     with any tool that generates brain masks:
-# 
-#     >>> from nipype.pipeline import engine as pe
-#     >>> from nipype.interfaces import utility as niu
-#     >>> from nipype.interfaces.fsl import BET
-#     >>> deface_wf = pe.Workflow('deface_wf')
-#     >>> inputnode = pe.Node(niu.IdentityInterface(['in_file']),
-#     ...                     name='inputnode')
-#     >>> outputnode = pe.Node(niu.IdentityInterface(['out_file']),
-#     ...                      name='outputnode')
-#     >>> bet = pe.Node(BET(mask=True), name='bet')
-#     >>> quickshear = pe.Node(Quickshear(), name='quickshear')
-#     >>> deface_wf.connect([
-#     ...     (inputnode, bet, [('in_file', 'in_file')]),
-#     ...     (inputnode, quickshear, [('in_file', 'in_file')]),
-#     ...     (bet, quickshear, [('mask_file', 'mask_file')]),
-#     ...     (quickshear, outputnode, [('out_file', 'out_file')]),
-#     ...     ])
-#     >>> inputnode.inputs.in_file = 'T1.nii'
-#     >>> res = deface_wf.run()  # doctest: +SKIP
-#     
-task_name: Quickshear
-nipype_name: Quickshear
-nipype_module: nipype.interfaces.quickshear
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_file: medimage/nifti1
-    # type=file|default=<undefined>: neuroimage to deface
-    mask_file: medimage/nifti1
-    # type=file|default=<undefined>: brain mask
-    out_file: generic/file
-    # type=file: defaced output image
-    # type=file|default=<undefined>: defaced output image
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    out_file: generic/file
-    # type=file: defaced output image
-    # type=file|default=<undefined>: defaced output image
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: neuroimage to deface
-    mask_file:
-    # type=file|default=<undefined>: brain mask
-    out_file:
-    # type=file: defaced output image
-    # type=file|default=<undefined>: defaced output image
-    buff:
-    # type=int|default=0: buffer size (in voxels) between shearing plane and the brain
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: neuroimage to deface
-    mask_file:
-    # type=file|default=<undefined>: brain mask
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests:
-- cmdline: quickshear T1.nii brain_mask.nii T1_defaced.nii
-  # str - the expected cmdline output
-  inputs:
-  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
-  # If the field is of file-format type and the value is None, then the
-  # '.mock()' method of the corresponding class is used instead.
-    in_file:
-    # type=file|default=<undefined>: neuroimage to deface
-    mask_file:
-    # type=file|default=<undefined>: brain mask
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  directive:
-  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-quickshear/quickshear_callables.py b/example-specs/task/nipype_internal/pydra-quickshear/quickshear_callables.py
deleted file mode 100644
index a744f4a7..00000000
--- a/example-specs/task/nipype_internal/pydra-quickshear/quickshear_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in Quickshear.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-robex/robex_segment.yaml b/example-specs/task/nipype_internal/pydra-robex/robex_segment.yaml
deleted file mode 100644
index 1e7314a5..00000000
--- a/example-specs/task/nipype_internal/pydra-robex/robex_segment.yaml
+++ /dev/null
@@ -1,142 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.robex.preprocess.RobexSegment' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-# 
-#     ROBEX is an automatic whole-brain extraction tool for T1-weighted MRI data (commonly known as skull stripping).
-#     ROBEX aims for robust skull-stripping across datasets with no parameter settings. It fits a triangular mesh,
-#     constrained by a shape model, to the probabilistic output of a supervised brain boundary classifier.
-#     Because the shape model cannot perfectly accommodate unseen cases, a small free deformation is subsequently allowed.
-#     The deformation is optimized using graph cuts.
-#     The method ROBEX is based on was published in IEEE Transactions on Medical Imaging;
-#     please visit the website http://www.jeiglesias.com to download the paper.
-# 
-#     Examples
-#     --------
-#     >>> from nipype.interfaces.robex.preprocess import RobexSegment
-#     >>> robex = RobexSegment()
-#     >>> robex.inputs.in_file = 'structural.nii'
-#     >>> robex.cmdline
-#     'runROBEX.sh structural.nii structural_brain.nii structural_brainmask.nii'
-#     >>> robex.run() # doctest: +SKIP
-# 
-#     
-task_name: RobexSegment
-nipype_name: RobexSegment
-nipype_module: nipype.interfaces.robex.preprocess
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_file: medimage/nifti1
-    # type=file|default=<undefined>: Input volume
-    out_file: generic/file
-    # type=file: Output volume
-    # type=file|default=<undefined>: Output volume
-    out_mask: generic/file
-    # type=file: Output mask
-    # type=file|default=<undefined>: Output mask
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    out_file: generic/file
-    # type=file: Output volume
-    # type=file|default=<undefined>: Output volume
-    out_mask: generic/file
-    # type=file: Output mask
-    # type=file|default=<undefined>: Output mask
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: Input volume
-    out_file:
-    # type=file: Output volume
-    # type=file|default=<undefined>: Output volume
-    out_mask:
-    # type=file: Output mask
-    # type=file|default=<undefined>: Output mask
-    seed:
-    # type=int|default=0: Seed for random number generator
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: Input volume
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests:
-- cmdline: runROBEX.sh structural.nii structural_brain.nii structural_brainmask.nii
-  # str - the expected cmdline output
-  inputs:
-  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
-  # If the field is of file-format type and the value is None, then the
-  # '.mock()' method of the corresponding class is used instead.
-    in_file:
-    # type=file|default=<undefined>: Input volume
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  directive:
-  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-robex/robex_segment_callables.py b/example-specs/task/nipype_internal/pydra-robex/robex_segment_callables.py
deleted file mode 100644
index 392f200a..00000000
--- a/example-specs/task/nipype_internal/pydra-robex/robex_segment_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in RobexSegment.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/binary_mask_editor_based_on_landmarks.yaml b/example-specs/task/nipype_internal/pydra-semtools/binary_mask_editor_based_on_landmarks.yaml
deleted file mode 100644
index ed03737f..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/binary_mask_editor_based_on_landmarks.yaml
+++ /dev/null
@@ -1,95 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.segmentation.specialized.BinaryMaskEditorBasedOnLandmarks' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: BRAINS Binary Mask Editor Based On Landmarks(BRAINS)
-# 
-#     category: Segmentation.Specialized
-# 
-#     version: 1.0
-# 
-#     documentation-url: http://www.nitrc.org/projects/brainscdetector/
-#     
-task_name: BinaryMaskEditorBasedOnLandmarks
-nipype_name: BinaryMaskEditorBasedOnLandmarks
-nipype_module: nipype.interfaces.semtools.segmentation.specialized
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputBinaryVolume: generic/file
-    # type=file|default=<undefined>: Input binary image in which to be edited
-    inputLandmarksFilename: generic/file
-    # type=file|default=<undefined>:  The filename for the  landmark definition file in the same format produced by Slicer3 (.fcsv). 
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputBinaryVolume: generic/file
-    # type=file: Output binary image in which to be edited
-    # type=traitcompound|default=None: Output binary image in which to be edited
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputBinaryVolume:
-    # type=file|default=<undefined>: Input binary image in which to be edited
-    outputBinaryVolume:
-    # type=file: Output binary image in which to be edited
-    # type=traitcompound|default=None: Output binary image in which to be edited
-    inputLandmarksFilename:
-    # type=file|default=<undefined>:  The filename for the  landmark definition file in the same format produced by Slicer3 (.fcsv). 
-    inputLandmarkNames:
-    # type=inputmultiobject|default=[]:  A target input landmark name to be edited. This should be listed in the inputLandmakrFilename Given. 
-    setCutDirectionForLandmark:
-    # type=inputmultiobject|default=[]: Setting the cutting out direction of the input binary image to the one of anterior, posterior, left, right, superior or posterior. (ENUMERATION: ANTERIOR, POSTERIOR, LEFT, RIGHT, SUPERIOR, POSTERIOR) 
-    setCutDirectionForObliquePlane:
-    # type=inputmultiobject|default=[]: If this is true, the mask will be thresholded out to the direction of inferior, posterior,  and/or left. Default behavrior is that cutting out to the direction of superior, anterior and/or right. 
-    inputLandmarkNamesForObliquePlane:
-    # type=inputmultiobject|default=[]:  Three subset landmark names of inputLandmarksFilename for a oblique plane computation. The plane computed for binary volume editing. 
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/binary_mask_editor_based_on_landmarks_callables.py b/example-specs/task/nipype_internal/pydra-semtools/binary_mask_editor_based_on_landmarks_callables.py
deleted file mode 100644
index efbeba26..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/binary_mask_editor_based_on_landmarks_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in BinaryMaskEditorBasedOnLandmarks.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_align_msp.yaml b/example-specs/task/nipype_internal/pydra-semtools/brains_align_msp.yaml
deleted file mode 100644
index 6606334f..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/brains_align_msp.yaml
+++ /dev/null
@@ -1,105 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.utilities.brains.BRAINSAlignMSP' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Align Mid Sagittal Brain (BRAINS)
-# 
-#     category: Utilities.BRAINS
-# 
-#     description: Resample an image into ACPC alignment ACPCDetect
-#     
-task_name: BRAINSAlignMSP
-nipype_name: BRAINSAlignMSP
-nipype_module: nipype.interfaces.semtools.utilities.brains
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputVolume: generic/file
-    # type=file|default=<undefined>: ,         The Image to be resampled,       
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    OutputresampleMSP: generic/file
-    # type=file: ,         The image to be output.,       
-    # type=traitcompound|default=None: ,         The image to be output.,       
-    resultsDir: generic/directory
-    # type=directory: ,         The directory for the results to be written.,       
-    # type=traitcompound|default=None: ,         The directory for the results to be written.,       
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputVolume:
-    # type=file|default=<undefined>: ,         The Image to be resampled,       
-    OutputresampleMSP:
-    # type=file: ,         The image to be output.,       
-    # type=traitcompound|default=None: ,         The image to be output.,       
-    verbose:
-    # type=bool|default=False: ,         Show more verbose output,       
-    resultsDir:
-    # type=directory: ,         The directory for the results to be written.,       
-    # type=traitcompound|default=None: ,         The directory for the results to be written.,       
-    writedebuggingImagesLevel:
-    # type=int|default=0: ,           This flag controls if debugging images are produced.  By default value of 0 is no images.  Anything greater than zero will be increasing level of debugging images.,       
-    mspQualityLevel:
-    # type=int|default=0: ,           Flag controls how aggressive the MSP is estimated.  0=quick estimate (9 seconds), 1=normal estimate (11 seconds), 2=great estimate (22 seconds), 3=best estimate (58 seconds).,       
-    rescaleIntensities:
-    # type=bool|default=False: ,           Flag to turn on rescaling image intensities on input.,       
-    trimRescaledIntensities:
-    # type=float|default=0.0: ,           Turn on clipping the rescaled image one-tailed on input.  Units of standard deviations above the mean.  Very large values are very permissive.  Non-positive value turns clipping off.  Defaults to removing 0.00001 of a normal tail above the mean.,       
-    rescaleIntensitiesOutputRange:
-    # type=inputmultiobject|default=[]: ,           This pair of integers gives the lower and upper bounds on the signal portion of the output image.  Out-of-field voxels are taken from BackgroundFillValue.,       
-    BackgroundFillValue:
-    # type=str|default='': Fill the background of image with specified short int value. Enter number or use BIGNEG for a large negative number.
-    interpolationMode:
-    # type=enum|default='NearestNeighbor'|allowed['BSpline','Blackman','Cosine','Hamming','Lanczos','Linear','NearestNeighbor','ResampleInPlace','Welch','WindowedSinc']: Type of interpolation to be used when applying transform to moving volume.  Options are Linear, ResampleInPlace, NearestNeighbor, BSpline, or WindowedSinc
-    numberOfThreads:
-    # type=int|default=0: Explicitly specify the maximum number of threads to use.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_align_msp_callables.py b/example-specs/task/nipype_internal/pydra-semtools/brains_align_msp_callables.py
deleted file mode 100644
index 40de2170..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/brains_align_msp_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in BRAINSAlignMSP.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_clip_inferior.yaml b/example-specs/task/nipype_internal/pydra-semtools/brains_clip_inferior.yaml
deleted file mode 100644
index 7e69e03f..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/brains_clip_inferior.yaml
+++ /dev/null
@@ -1,89 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.utilities.brains.BRAINSClipInferior' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Clip Inferior of Center of Brain (BRAINS)
-# 
-#     category: Utilities.BRAINS
-# 
-#     description: This program will read the inputVolume as a short int image, write the BackgroundFillValue everywhere inferior to the lower bound, and write the resulting clipped short int image in the outputVolume.
-# 
-#     version: 1.0
-#     
-task_name: BRAINSClipInferior
-nipype_name: BRAINSClipInferior
-nipype_module: nipype.interfaces.semtools.utilities.brains
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputVolume: generic/file
-    # type=file|default=<undefined>: Input image to make a clipped short int copy from.
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputVolume: generic/file
-    # type=file: Output image, a short int copy of the upper portion of the input image, filled with BackgroundFillValue.
-    # type=traitcompound|default=None: Output image, a short int copy of the upper portion of the input image, filled with BackgroundFillValue.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputVolume:
-    # type=file|default=<undefined>: Input image to make a clipped short int copy from.
-    outputVolume:
-    # type=file: Output image, a short int copy of the upper portion of the input image, filled with BackgroundFillValue.
-    # type=traitcompound|default=None: Output image, a short int copy of the upper portion of the input image, filled with BackgroundFillValue.
-    acLowerBound:
-    # type=float|default=0.0: ,                 When the input image to the output image, replace the image with the BackgroundFillValue everywhere below the plane This Far in physical units (millimeters) below (inferior to) the AC point (assumed to be the voxel field middle.)  The oversize default was chosen to have no effect.  Based on visualizing a thousand masks in the IPIG study, we recommend a limit no smaller than 80.0 mm.,             
-    BackgroundFillValue:
-    # type=str|default='': Fill the background of image with specified short int value. Enter number or use BIGNEG for a large negative number.
-    numberOfThreads:
-    # type=int|default=0: Explicitly specify the maximum number of threads to use.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_clip_inferior_callables.py b/example-specs/task/nipype_internal/pydra-semtools/brains_clip_inferior_callables.py
deleted file mode 100644
index c06f5275..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/brains_clip_inferior_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in BRAINSClipInferior.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_constellation_detector.yaml b/example-specs/task/nipype_internal/pydra-semtools/brains_constellation_detector.yaml
deleted file mode 100644
index 85de538d..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/brains_constellation_detector.yaml
+++ /dev/null
@@ -1,209 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.segmentation.specialized.BRAINSConstellationDetector' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Brain Landmark Constellation Detector (BRAINS)
-# 
-#     category: Segmentation.Specialized
-# 
-#     description: This program will find the mid-sagittal plane, a constellation of landmarks in a volume, and create an AC/PC aligned data set with the AC point at the center of the voxel lattice (labeled at the origin of the image physical space.)  Part of this work is an extension of the algorithms originally described by Dr. Babak A. Ardekani, Alvin H. Bachman, Model-based automatic detection of the anterior and posterior commissures on MRI scans, NeuroImage, Volume 46, Issue 3, 1 July 2009, Pages 677-682, ISSN 1053-8119, DOI: 10.1016/j.neuroimage.2009.02.030.  (http://www.sciencedirect.com/science/article/B6WNP-4VRP25C-4/2/8207b962a38aa83c822c6379bc43fe4c)
-# 
-#     version: 1.0
-# 
-#     documentation-url: http://www.nitrc.org/projects/brainscdetector/
-#     
-task_name: BRAINSConstellationDetector
-nipype_name: BRAINSConstellationDetector
-nipype_module: nipype.interfaces.semtools.segmentation.specialized
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputTemplateModel: generic/file
-    # type=file|default=<undefined>: User-specified template model.,             
-    LLSModel: generic/file
-    # type=file|default=<undefined>: Linear least squares model filename in HD5 format
-    inputVolume: generic/file
-    # type=file|default=<undefined>: Input image in which to find ACPC points
-    inputLandmarksEMSP: generic/file
-    # type=file|default=<undefined>: ,               The filename for the new subject-specific landmark definition file in the same format produced by Slicer3 (in .fcsv) with the landmarks in the estimated MSP aligned space to be loaded. The detector will only process landmarks not enlisted on the file.,             
-    atlasVolume: generic/file
-    # type=file|default=<undefined>: Atlas volume image to be used for BRAINSFit registration
-    atlasLandmarks: generic/file
-    # type=file|default=<undefined>: Atlas landmarks to be used for BRAINSFit registration initialization,             
-    atlasLandmarkWeights: generic/file
-    # type=file|default=<undefined>: Weights associated with atlas landmarks to be used for BRAINSFit registration initialization,             
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputVolume: generic/file
-    # type=file: ACPC-aligned output image with the same voxels, but updated origin, and direction cosign so that the AC point would fall at the physical location (0.0,0.0,0.0), and the mid-sagital plane is the plane where physical L/R coordinate is 0.0.
-    # type=traitcompound|default=None: ACPC-aligned output image with the same voxels, but updated origin, and direction cosign so that the AC point would fall at the physical location (0.0,0.0,0.0), and the mid-sagital plane is the plane where physical L/R coordinate is 0.0.
-    outputResampledVolume: generic/file
-    # type=file: ACPC-aligned output image in a resampled unifor space.  Currently this is a 1mm, 256^3, Identity direction image.
-    # type=traitcompound|default=None: ACPC-aligned output image in a resampled unifor space.  Currently this is a 1mm, 256^3, Identity direction image.
-    outputTransform: generic/file
-    # type=file: The filename for the original space to ACPC alignment to be written (in .h5 format).,             
-    # type=traitcompound|default=None: The filename for the original space to ACPC alignment to be written (in .h5 format).,             
-    outputLandmarksInInputSpace: generic/file
-    # type=file: ,               The filename for the new subject-specific landmark definition file in the same format produced by Slicer3 (.fcsv) with the landmarks in the original image space (the detected RP, AC, PC, and VN4) in it to be written.,             
-    # type=traitcompound|default=None: ,               The filename for the new subject-specific landmark definition file in the same format produced by Slicer3 (.fcsv) with the landmarks in the original image space (the detected RP, AC, PC, and VN4) in it to be written.,             
-    outputLandmarksInACPCAlignedSpace: generic/file
-    # type=file: ,               The filename for the new subject-specific landmark definition file in the same format produced by Slicer3 (.fcsv) with the landmarks in the output image space (the detected RP, AC, PC, and VN4) in it to be written.,             
-    # type=traitcompound|default=None: ,               The filename for the new subject-specific landmark definition file in the same format produced by Slicer3 (.fcsv) with the landmarks in the output image space (the detected RP, AC, PC, and VN4) in it to be written.,             
-    outputMRML: generic/file
-    # type=file: ,               The filename for the new subject-specific scene definition file in the same format produced by Slicer3 (in .mrml format). Only the components that were specified by the user on command line would be generated. Compatible components include inputVolume, outputVolume, outputLandmarksInInputSpace, outputLandmarksInACPCAlignedSpace, and outputTransform.,             
-    # type=traitcompound|default=None: ,               The filename for the new subject-specific scene definition file in the same format produced by Slicer3 (in .mrml format). Only the components that were specified by the user on command line would be generated. Compatible components include inputVolume, outputVolume, outputLandmarksInInputSpace, outputLandmarksInACPCAlignedSpace, and outputTransform.,             
-    outputVerificationScript: generic/file
-    # type=file: ,               The filename for the Slicer3 script that verifies the aligned landmarks against the aligned image file.  This will happen only in conjunction with saveOutputLandmarks and an outputVolume.,             
-    # type=traitcompound|default=None: ,               The filename for the Slicer3 script that verifies the aligned landmarks against the aligned image file.  This will happen only in conjunction with saveOutputLandmarks and an outputVolume.,             
-    outputUntransformedClippedVolume: generic/file
-    # type=file: Output image in which to store neck-clipped input image, with the use of --acLowerBound and maybe --cutOutHeadInUntransformedVolume.
-    # type=traitcompound|default=None: Output image in which to store neck-clipped input image, with the use of --acLowerBound and maybe --cutOutHeadInUntransformedVolume.
-    writeBranded2DImage: generic/file
-    # type=file: ,               The filename for the 2D .png branded midline debugging image.  This will happen only in conjunction with requesting an outputVolume.,             
-    # type=traitcompound|default=None: ,               The filename for the 2D .png branded midline debugging image.  This will happen only in conjunction with requesting an outputVolume.,             
-    resultsDir: generic/directory
-    # type=directory: ,               The directory for the debugging images to be written.,             
-    # type=traitcompound|default=None: ,               The directory for the debugging images to be written.,             
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    houghEyeDetectorMode:
-    # type=int|default=0: ,                 This flag controls the mode of Hough eye detector.  By default, value of 1 is for T1W images, while the value of 0 is for T2W and PD images.,             
-    inputTemplateModel:
-    # type=file|default=<undefined>: User-specified template model.,             
-    LLSModel:
-    # type=file|default=<undefined>: Linear least squares model filename in HD5 format
-    inputVolume:
-    # type=file|default=<undefined>: Input image in which to find ACPC points
-    outputVolume:
-    # type=file: ACPC-aligned output image with the same voxels, but updated origin, and direction cosign so that the AC point would fall at the physical location (0.0,0.0,0.0), and the mid-sagital plane is the plane where physical L/R coordinate is 0.0.
-    # type=traitcompound|default=None: ACPC-aligned output image with the same voxels, but updated origin, and direction cosign so that the AC point would fall at the physical location (0.0,0.0,0.0), and the mid-sagital plane is the plane where physical L/R coordinate is 0.0.
-    outputResampledVolume:
-    # type=file: ACPC-aligned output image in a resampled unifor space.  Currently this is a 1mm, 256^3, Identity direction image.
-    # type=traitcompound|default=None: ACPC-aligned output image in a resampled unifor space.  Currently this is a 1mm, 256^3, Identity direction image.
-    outputTransform:
-    # type=file: The filename for the original space to ACPC alignment to be written (in .h5 format).,             
-    # type=traitcompound|default=None: The filename for the original space to ACPC alignment to be written (in .h5 format).,             
-    outputLandmarksInInputSpace:
-    # type=file: ,               The filename for the new subject-specific landmark definition file in the same format produced by Slicer3 (.fcsv) with the landmarks in the original image space (the detected RP, AC, PC, and VN4) in it to be written.,             
-    # type=traitcompound|default=None: ,               The filename for the new subject-specific landmark definition file in the same format produced by Slicer3 (.fcsv) with the landmarks in the original image space (the detected RP, AC, PC, and VN4) in it to be written.,             
-    outputLandmarksInACPCAlignedSpace:
-    # type=file: ,               The filename for the new subject-specific landmark definition file in the same format produced by Slicer3 (.fcsv) with the landmarks in the output image space (the detected RP, AC, PC, and VN4) in it to be written.,             
-    # type=traitcompound|default=None: ,               The filename for the new subject-specific landmark definition file in the same format produced by Slicer3 (.fcsv) with the landmarks in the output image space (the detected RP, AC, PC, and VN4) in it to be written.,             
-    outputMRML:
-    # type=file: ,               The filename for the new subject-specific scene definition file in the same format produced by Slicer3 (in .mrml format). Only the components that were specified by the user on command line would be generated. Compatible components include inputVolume, outputVolume, outputLandmarksInInputSpace, outputLandmarksInACPCAlignedSpace, and outputTransform.,             
-    # type=traitcompound|default=None: ,               The filename for the new subject-specific scene definition file in the same format produced by Slicer3 (in .mrml format). Only the components that were specified by the user on command line would be generated. Compatible components include inputVolume, outputVolume, outputLandmarksInInputSpace, outputLandmarksInACPCAlignedSpace, and outputTransform.,             
-    outputVerificationScript:
-    # type=file: ,               The filename for the Slicer3 script that verifies the aligned landmarks against the aligned image file.  This will happen only in conjunction with saveOutputLandmarks and an outputVolume.,             
-    # type=traitcompound|default=None: ,               The filename for the Slicer3 script that verifies the aligned landmarks against the aligned image file.  This will happen only in conjunction with saveOutputLandmarks and an outputVolume.,             
-    mspQualityLevel:
-    # type=int|default=0: ,                 Flag controls how aggressive the MSP is estimated. 0=quick estimate (9 seconds), 1=normal estimate (11 seconds), 2=great estimate (22 seconds), 3=best estimate (58 seconds), NOTE: -1= Prealigned so no estimate!.,             
-    otsuPercentileThreshold:
-    # type=float|default=0.0: ,                 This is a parameter to FindLargestForegroundFilledMask, which is employed when acLowerBound is set and an outputUntransformedClippedVolume is requested.,             
-    acLowerBound:
-    # type=float|default=0.0: ,                 When generating a resampled output image, replace the image with the BackgroundFillValue everywhere below the plane This Far in physical units (millimeters) below (inferior to) the AC point (as found by the model.)  The oversize default was chosen to have no effect.  Based on visualizing a thousand masks in the IPIG study, we recommend a limit no smaller than 80.0 mm.,             
-    cutOutHeadInOutputVolume:
-    # type=bool|default=False: ,                 Flag to cut out just the head tissue when producing an (un)transformed clipped volume.,             
-    outputUntransformedClippedVolume:
-    # type=file: Output image in which to store neck-clipped input image, with the use of --acLowerBound and maybe --cutOutHeadInUntransformedVolume.
-    # type=traitcompound|default=None: Output image in which to store neck-clipped input image, with the use of --acLowerBound and maybe --cutOutHeadInUntransformedVolume.
-    rescaleIntensities:
-    # type=bool|default=False: ,                 Flag to turn on rescaling image intensities on input.,             
-    trimRescaledIntensities:
-    # type=float|default=0.0: ,                 Turn on clipping the rescaled image one-tailed on input.  Units of standard deviations above the mean.  Very large values are very permissive.  Non-positive value turns clipping off.  Defaults to removing 0.00001 of a normal tail above the mean.,             
-    rescaleIntensitiesOutputRange:
-    # type=inputmultiobject|default=[]: ,                 This pair of integers gives the lower and upper bounds on the signal portion of the output image.  Out-of-field voxels are taken from BackgroundFillValue.,             
-    BackgroundFillValue:
-    # type=str|default='': Fill the background of image with specified short int value. Enter number or use BIGNEG for a large negative number.
-    interpolationMode:
-    # type=enum|default='NearestNeighbor'|allowed['BSpline','Blackman','Cosine','Hamming','Lanczos','Linear','NearestNeighbor','ResampleInPlace','Welch','WindowedSinc']: Type of interpolation to be used when applying transform to moving volume.  Options are Linear, ResampleInPlace, NearestNeighbor, BSpline, or WindowedSinc
-    forceACPoint:
-    # type=inputmultiobject|default=[]: ,                 Use this flag to manually specify the AC point from the original image on the command line.,             
-    forcePCPoint:
-    # type=inputmultiobject|default=[]: ,                 Use this flag to manually specify the PC point from the original image on the command line.,             
-    forceVN4Point:
-    # type=inputmultiobject|default=[]: ,                 Use this flag to manually specify the VN4 point from the original image on the command line.,             
-    forceRPPoint:
-    # type=inputmultiobject|default=[]: ,                 Use this flag to manually specify the RP point from the original image on the command line.,             
-    inputLandmarksEMSP:
-    # type=file|default=<undefined>: ,               The filename for the new subject-specific landmark definition file in the same format produced by Slicer3 (in .fcsv) with the landmarks in the estimated MSP aligned space to be loaded. The detector will only process landmarks not enlisted on the file.,             
-    forceHoughEyeDetectorReportFailure:
-    # type=bool|default=False: ,                 Flag indicates whether the Hough eye detector should report failure,             
-    rmpj:
-    # type=float|default=0.0: ,               Search radius for MPJ in unit of mm,             
-    rac:
-    # type=float|default=0.0: ,               Search radius for AC in unit of mm,             
-    rpc:
-    # type=float|default=0.0: ,               Search radius for PC in unit of mm,             
-    rVN4:
-    # type=float|default=0.0: ,               Search radius for VN4 in unit of mm,             
-    debug:
-    # type=bool|default=False: ,               Show internal debugging information.,             
-    verbose:
-    # type=bool|default=False: ,               Show more verbose output,             
-    writeBranded2DImage:
-    # type=file: ,               The filename for the 2D .png branded midline debugging image.  This will happen only in conjunction with requesting an outputVolume.,             
-    # type=traitcompound|default=None: ,               The filename for the 2D .png branded midline debugging image.  This will happen only in conjunction with requesting an outputVolume.,             
-    resultsDir:
-    # type=directory: ,               The directory for the debugging images to be written.,             
-    # type=traitcompound|default=None: ,               The directory for the debugging images to be written.,             
-    writedebuggingImagesLevel:
-    # type=int|default=0: ,                 This flag controls if debugging images are produced.  By default value of 0 is no images.  Anything greater than zero will be increasing level of debugging images.,             
-    numberOfThreads:
-    # type=int|default=0: Explicitly specify the maximum number of threads to use.
-    atlasVolume:
-    # type=file|default=<undefined>: Atlas volume image to be used for BRAINSFit registration
-    atlasLandmarks:
-    # type=file|default=<undefined>: Atlas landmarks to be used for BRAINSFit registration initialization,             
-    atlasLandmarkWeights:
-    # type=file|default=<undefined>: Weights associated with atlas landmarks to be used for BRAINSFit registration initialization,             
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_constellation_detector_callables.py b/example-specs/task/nipype_internal/pydra-semtools/brains_constellation_detector_callables.py
deleted file mode 100644
index e9384916..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/brains_constellation_detector_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in BRAINSConstellationDetector.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_constellation_modeler.yaml b/example-specs/task/nipype_internal/pydra-semtools/brains_constellation_modeler.yaml
deleted file mode 100644
index cbc3cb7a..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/brains_constellation_modeler.yaml
+++ /dev/null
@@ -1,107 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.utilities.brains.BRAINSConstellationModeler' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Generate Landmarks Model (BRAINS)
-# 
-#     category: Utilities.BRAINS
-# 
-#     description: Train up a model for BRAINSConstellationDetector
-#     
-task_name: BRAINSConstellationModeler
-nipype_name: BRAINSConstellationModeler
-nipype_module: nipype.interfaces.semtools.utilities.brains
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputTrainingList: generic/file
-    # type=file|default=<undefined>: ,               Setup file, giving all parameters for training up a template model for each landmark.,             
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputModel: generic/file
-    # type=file: ,               The full filename of the output model file.,             
-    # type=traitcompound|default=None: ,               The full filename of the output model file.,             
-    resultsDir: generic/directory
-    # type=directory: ,               The directory for the results to be written.,             
-    # type=traitcompound|default=None: ,               The directory for the results to be written.,             
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    verbose:
-    # type=bool|default=False: ,               Show more verbose output,             
-    inputTrainingList:
-    # type=file|default=<undefined>: ,               Setup file, giving all parameters for training up a template model for each landmark.,             
-    outputModel:
-    # type=file: ,               The full filename of the output model file.,             
-    # type=traitcompound|default=None: ,               The full filename of the output model file.,             
-    saveOptimizedLandmarks:
-    # type=bool|default=False: ,               Flag to make a new subject-specific landmark definition file in the same format produced by Slicer3 with the optimized landmark (the detected RP, AC, and PC) in it.  Useful to tighten the variances in the ConstellationModeler.,             
-    optimizedLandmarksFilenameExtender:
-    # type=str|default='': ,                If the trainingList is (indexFullPathName) and contains landmark data filenames [path]/[filename].fcsv ,  make the optimized landmarks filenames out of [path]/[filename](thisExtender) and the optimized version of the input trainingList out of (indexFullPathName)(thisExtender) , when you rewrite all the landmarks according to the saveOptimizedLandmarks flag.,             
-    resultsDir:
-    # type=directory: ,               The directory for the results to be written.,             
-    # type=traitcompound|default=None: ,               The directory for the results to be written.,             
-    mspQualityLevel:
-    # type=int|default=0: ,                 Flag controls how aggressive the MSP is estimated.  0=quick estimate (9 seconds), 1=normal estimate (11 seconds), 2=great estimate (22 seconds), 3=best estimate (58 seconds).,             
-    rescaleIntensities:
-    # type=bool|default=False: ,                 Flag to turn on rescaling image intensities on input.,             
-    trimRescaledIntensities:
-    # type=float|default=0.0: ,                 Turn on clipping the rescaled image one-tailed on input.  Units of standard deviations above the mean.  Very large values are very permissive.  Non-positive value turns clipping off.  Defaults to removing 0.00001 of a normal tail above the mean.,             
-    rescaleIntensitiesOutputRange:
-    # type=inputmultiobject|default=[]: ,                 This pair of integers gives the lower and upper bounds on the signal portion of the output image.  Out-of-field voxels are taken from BackgroundFillValue.,             
-    BackgroundFillValue:
-    # type=str|default='': Fill the background of image with specified short int value. Enter number or use BIGNEG for a large negative number.
-    writedebuggingImagesLevel:
-    # type=int|default=0: ,                 This flag controls if debugging images are produced.  By default value of 0 is no images.  Anything greater than zero will be increasing level of debugging images.,             
-    numberOfThreads:
-    # type=int|default=0: Explicitly specify the maximum number of threads to use.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_constellation_modeler_callables.py b/example-specs/task/nipype_internal/pydra-semtools/brains_constellation_modeler_callables.py
deleted file mode 100644
index dc30b88b..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/brains_constellation_modeler_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in BRAINSConstellationModeler.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_create_label_map_from_probability_maps.yaml b/example-specs/task/nipype_internal/pydra-semtools/brains_create_label_map_from_probability_maps.yaml
deleted file mode 100644
index 57ecb4a3..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/brains_create_label_map_from_probability_maps.yaml
+++ /dev/null
@@ -1,97 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.segmentation.specialized.BRAINSCreateLabelMapFromProbabilityMaps' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Create Label Map From Probability Maps (BRAINS)
-# 
-#     category: Segmentation.Specialized
-# 
-#     description: Given A list of Probability Maps, generate a LabelMap.
-#     
-task_name: BRAINSCreateLabelMapFromProbabilityMaps
-nipype_name: BRAINSCreateLabelMapFromProbabilityMaps
-nipype_module: nipype.interfaces.semtools.segmentation.specialized
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputProbabilityVolume: generic/file+list-of
-    # type=inputmultiobject|default=[]: The list of proobabilityimages.
-    nonAirRegionMask: generic/file
-    # type=file|default=<undefined>: a mask representing the 'NonAirRegion' -- Just force pixels in this region to zero
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    dirtyLabelVolume: generic/file
-    # type=file: the labels prior to cleaning
-    # type=traitcompound|default=None: the labels prior to cleaning
-    cleanLabelVolume: generic/file
-    # type=file: the foreground labels volume
-    # type=traitcompound|default=None: the foreground labels volume
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputProbabilityVolume:
-    # type=inputmultiobject|default=[]: The list of proobabilityimages.
-    priorLabelCodes:
-    # type=inputmultiobject|default=[]: A list of PriorLabelCode values used for coding the output label images
-    foregroundPriors:
-    # type=inputmultiobject|default=[]: A list: For each Prior Label, 1 if foreground, 0 if background
-    nonAirRegionMask:
-    # type=file|default=<undefined>: a mask representing the 'NonAirRegion' -- Just force pixels in this region to zero
-    inclusionThreshold:
-    # type=float|default=0.0: tolerance for inclusion
-    dirtyLabelVolume:
-    # type=file: the labels prior to cleaning
-    # type=traitcompound|default=None: the labels prior to cleaning
-    cleanLabelVolume:
-    # type=file: the foreground labels volume
-    # type=traitcompound|default=None: the foreground labels volume
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_create_label_map_from_probability_maps_callables.py b/example-specs/task/nipype_internal/pydra-semtools/brains_create_label_map_from_probability_maps_callables.py
deleted file mode 100644
index e2f10eae..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/brains_create_label_map_from_probability_maps_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in BRAINSCreateLabelMapFromProbabilityMaps.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_cut.yaml b/example-specs/task/nipype_internal/pydra-semtools/brains_cut.yaml
deleted file mode 100644
index 6dbcd6d2..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/brains_cut.yaml
+++ /dev/null
@@ -1,115 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.segmentation.specialized.BRAINSCut' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: BRAINSCut (BRAINS)
-# 
-#     category: Segmentation.Specialized
-# 
-#     description: Automatic Segmentation using neural networks
-# 
-#     version: 1.0
-# 
-#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
-# 
-#     contributor: Vince Magnotta, Hans Johnson, Greg Harris, Kent Williams, Eunyoung Regina Kim
-#     
-task_name: BRAINSCut
-nipype_name: BRAINSCut
-nipype_module: nipype.interfaces.semtools.segmentation.specialized
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    netConfiguration: generic/file
-    # type=file|default=<undefined>: XML File defining BRAINSCut parameters. OLD NAME. PLEASE USE modelConfigurationFilename instead.
-    modelConfigurationFilename: generic/file
-    # type=file|default=<undefined>: XML File defining BRAINSCut parameters
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    netConfiguration:
-    # type=file|default=<undefined>: XML File defining BRAINSCut parameters. OLD NAME. PLEASE USE modelConfigurationFilename instead.
-    modelConfigurationFilename:
-    # type=file|default=<undefined>: XML File defining BRAINSCut parameters
-    trainModelStartIndex:
-    # type=int|default=0: Starting iteration for training
-    verbose:
-    # type=int|default=0: print out some debugging information
-    multiStructureThreshold:
-    # type=bool|default=False: multiStructureThreshold module to deal with overlapping area
-    histogramEqualization:
-    # type=bool|default=False: A Histogram Equalization process could be added to the creating/applying process from Subject To Atlas. Default is false, which generate input vectors without Histogram Equalization. 
-    computeSSEOn:
-    # type=bool|default=False: compute Sum of Square Error (SSE) along the trained model until the number of iteration given in the modelConfigurationFilename file
-    generateProbability:
-    # type=bool|default=False: Generate probability map
-    createVectors:
-    # type=bool|default=False: create vectors for training neural net
-    trainModel:
-    # type=bool|default=False: train the neural net
-    NoTrainingVectorShuffling:
-    # type=bool|default=False: If this flag is on, there will be no shuffling.
-    applyModel:
-    # type=bool|default=False: apply the neural net
-    validate:
-    # type=bool|default=False: validate data set.Just need for the first time run ( This is for validation of xml file and not working yet )
-    method:
-    # type=enum|default='RandomForest'|allowed['ANN','RandomForest']: 
-    numberOfTrees:
-    # type=int|default=0:  Random tree: number of trees. This is to be used when only one model with specified depth wish to be created. 
-    randomTreeDepth:
-    # type=int|default=0:  Random tree depth. This is to be used when only one model with specified depth wish to be created. 
-    modelFilename:
-    # type=str|default='':  model file name given from user (not by xml  configuration file) 
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_cut_callables.py b/example-specs/task/nipype_internal/pydra-semtools/brains_cut_callables.py
deleted file mode 100644
index 52afda6d..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/brains_cut_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in BRAINSCut.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_demon_warp.yaml b/example-specs/task/nipype_internal/pydra-semtools/brains_demon_warp.yaml
deleted file mode 100644
index 2e59146a..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/brains_demon_warp.yaml
+++ /dev/null
@@ -1,185 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.registration.specialized.BRAINSDemonWarp' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Demon Registration (BRAINS)
-# 
-#     category: Registration.Specialized
-# 
-#     description: This program finds a deformation field to warp a moving image onto a fixed image.  The images must be of the same signal kind, and contain an image of the same kind of object.  This program uses the Thirion Demons warp software in ITK, the Insight Toolkit.  Additional information is available at: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/BRAINSDemonWarp.
-# 
-#     version: 3.0.0
-# 
-#     documentation-url: http://www.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/BRAINSDemonWarp
-# 
-#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
-# 
-#     contributor: This tool was developed by Hans J. Johnson and Greg Harris.
-# 
-#     acknowledgements: The development of this tool was supported by funding from grants NS050568 and NS40068 from the National Institute of Neurological Disorders and Stroke and grants MH31593, MH40856, from the National Institute of Mental Health.
-#     
-task_name: BRAINSDemonWarp
-nipype_name: BRAINSDemonWarp
-nipype_module: nipype.interfaces.semtools.registration.specialized
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    movingVolume: generic/file
-    # type=file|default=<undefined>: Required: input moving image
-    fixedVolume: generic/file
-    # type=file|default=<undefined>: Required: input fixed (target) image
-    initializeWithDisplacementField: generic/file
-    # type=file|default=<undefined>: Initial deformation field vector image file name
-    initializeWithTransform: generic/file
-    # type=file|default=<undefined>: Initial Transform filename
-    fixedBinaryVolume: generic/file
-    # type=file|default=<undefined>: Mask filename for desired region of interest in the Fixed image.
-    movingBinaryVolume: generic/file
-    # type=file|default=<undefined>: Mask filename for desired region of interest in the Moving image.
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputVolume: generic/file
-    # type=file: Required: output resampled moving image (will have the same physical space as the fixedVolume).
-    # type=traitcompound|default=None: Required: output resampled moving image (will have the same physical space as the fixedVolume).
-    outputDisplacementFieldVolume: generic/file
-    # type=file: Output deformation field vector image (will have the same physical space as the fixedVolume).
-    # type=traitcompound|default=None: Output deformation field vector image (will have the same physical space as the fixedVolume).
-    outputCheckerboardVolume: generic/file
-    # type=file: Genete a checkerboard image volume between the fixedVolume and the deformed movingVolume.
-    # type=traitcompound|default=None: Genete a checkerboard image volume between the fixedVolume and the deformed movingVolume.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    movingVolume:
-    # type=file|default=<undefined>: Required: input moving image
-    fixedVolume:
-    # type=file|default=<undefined>: Required: input fixed (target) image
-    inputPixelType:
-    # type=enum|default='float'|allowed['float','int','short','uchar','ushort']: Input volumes will be typecast to this format: float|short|ushort|int|uchar
-    outputVolume:
-    # type=file: Required: output resampled moving image (will have the same physical space as the fixedVolume).
-    # type=traitcompound|default=None: Required: output resampled moving image (will have the same physical space as the fixedVolume).
-    outputDisplacementFieldVolume:
-    # type=file: Output deformation field vector image (will have the same physical space as the fixedVolume).
-    # type=traitcompound|default=None: Output deformation field vector image (will have the same physical space as the fixedVolume).
-    outputPixelType:
-    # type=enum|default='float'|allowed['float','int','short','uchar','ushort']: outputVolume will be typecast to this format: float|short|ushort|int|uchar
-    interpolationMode:
-    # type=enum|default='NearestNeighbor'|allowed['BSpline','Blackman','Cosine','Hamming','Lanczos','Linear','NearestNeighbor','ResampleInPlace','Welch','WindowedSinc']: Type of interpolation to be used when applying transform to moving volume.  Options are Linear, ResampleInPlace, NearestNeighbor, BSpline, or WindowedSinc
-    registrationFilterType:
-    # type=enum|default='Demons'|allowed['Demons','Diffeomorphic','FastSymmetricForces']: Registration Filter Type: Demons|FastSymmetricForces|Diffeomorphic
-    smoothDisplacementFieldSigma:
-    # type=float|default=0.0: A gaussian smoothing value to be applied to the deformation field at each iteration.
-    numberOfPyramidLevels:
-    # type=int|default=0: Number of image pyramid levels to use in the multi-resolution registration.
-    minimumFixedPyramid:
-    # type=inputmultiobject|default=[]: The shrink factor for the first level of the fixed image pyramid. (i.e. start at 1/16 scale, then 1/8, then 1/4, then 1/2, and finally full scale)
-    minimumMovingPyramid:
-    # type=inputmultiobject|default=[]: The shrink factor for the first level of the moving image pyramid. (i.e. start at 1/16 scale, then 1/8, then 1/4, then 1/2, and finally full scale)
-    arrayOfPyramidLevelIterations:
-    # type=inputmultiobject|default=[]: The number of iterations for each pyramid level
-    histogramMatch:
-    # type=bool|default=False: Histogram Match the input images.  This is suitable for images of the same modality that may have different absolute scales, but the same overall intensity profile.
-    numberOfHistogramBins:
-    # type=int|default=0: The number of histogram levels
-    numberOfMatchPoints:
-    # type=int|default=0: The number of match points for histrogramMatch
-    medianFilterSize:
-    # type=inputmultiobject|default=[]: Median filter radius in all 3 directions.  When images have a lot of salt and pepper noise, this step can improve the registration.
-    initializeWithDisplacementField:
-    # type=file|default=<undefined>: Initial deformation field vector image file name
-    initializeWithTransform:
-    # type=file|default=<undefined>: Initial Transform filename
-    maskProcessingMode:
-    # type=enum|default='NOMASK'|allowed['BOBF','NOMASK','ROI','ROIAUTO']: What mode to use for using the masks: NOMASK|ROIAUTO|ROI|BOBF.  If ROIAUTO is chosen, then the mask is implicitly defined using a otsu foreground and hole filling algorithm. Where the Region Of Interest mode uses the masks to define what parts of the image should be used for computing the deformation field.  Brain Only Background Fill uses the masks to pre-process the input images by clipping and filling in the background with a predefined value.
-    fixedBinaryVolume:
-    # type=file|default=<undefined>: Mask filename for desired region of interest in the Fixed image.
-    movingBinaryVolume:
-    # type=file|default=<undefined>: Mask filename for desired region of interest in the Moving image.
-    lowerThresholdForBOBF:
-    # type=int|default=0: Lower threshold for performing BOBF
-    upperThresholdForBOBF:
-    # type=int|default=0: Upper threshold for performing BOBF
-    backgroundFillValue:
-    # type=int|default=0: Replacement value to overwrite background when performing BOBF
-    seedForBOBF:
-    # type=inputmultiobject|default=[]: coordinates in all 3 directions for Seed when performing BOBF
-    neighborhoodForBOBF:
-    # type=inputmultiobject|default=[]: neighborhood in all 3 directions to be included when performing BOBF
-    outputDisplacementFieldPrefix:
-    # type=str|default='': Displacement field filename prefix for writing separate x, y, and z component images
-    outputCheckerboardVolume:
-    # type=file: Genete a checkerboard image volume between the fixedVolume and the deformed movingVolume.
-    # type=traitcompound|default=None: Genete a checkerboard image volume between the fixedVolume and the deformed movingVolume.
-    checkerboardPatternSubdivisions:
-    # type=inputmultiobject|default=[]: Number of Checkerboard subdivisions in all 3 directions
-    outputNormalized:
-    # type=bool|default=False: Flag to warp and write the normalized images to output.  In normalized images the image values are fit-scaled to be between 0 and the maximum storage type value.
-    outputDebug:
-    # type=bool|default=False: Flag to write debugging images after each step.
-    gradient_type:
-    # type=enum|default='0'|allowed['0','1','2']: Type of gradient used for computing the demons force (0 is symmetrized, 1 is fixed image, 2 is moving image)
-    upFieldSmoothing:
-    # type=float|default=0.0: Smoothing sigma for the update field at each iteration
-    max_step_length:
-    # type=float|default=0.0: Maximum length of an update vector (0: no restriction)
-    use_vanilla_dem:
-    # type=bool|default=False: Run vanilla demons algorithm
-    gui:
-    # type=bool|default=False: Display intermediate image volumes for debugging
-    promptUser:
-    # type=bool|default=False: Prompt the user to hit enter each time an image is sent to the DebugImageViewer
-    numberOfBCHApproximationTerms:
-    # type=int|default=0: Number of terms in the BCH expansion
-    numberOfThreads:
-    # type=int|default=0: Explicitly specify the maximum number of threads to use.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_demon_warp_callables.py b/example-specs/task/nipype_internal/pydra-semtools/brains_demon_warp_callables.py
deleted file mode 100644
index bb153f9f..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/brains_demon_warp_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in BRAINSDemonWarp.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_eye_detector.yaml b/example-specs/task/nipype_internal/pydra-semtools/brains_eye_detector.yaml
deleted file mode 100644
index def8f012..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/brains_eye_detector.yaml
+++ /dev/null
@@ -1,87 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.utilities.brains.BRAINSEyeDetector' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Eye Detector (BRAINS)
-# 
-#     category: Utilities.BRAINS
-# 
-#     version: 1.0
-# 
-#     documentation-url: http://www.nitrc.org/projects/brainscdetector/
-#     
-task_name: BRAINSEyeDetector
-nipype_name: BRAINSEyeDetector
-nipype_module: nipype.interfaces.semtools.utilities.brains
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputVolume: generic/file
-    # type=file|default=<undefined>: The input volume
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputVolume: generic/file
-    # type=file: The output volume
-    # type=traitcompound|default=None: The output volume
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    numberOfThreads:
-    # type=int|default=0: Explicitly specify the maximum number of threads to use.
-    inputVolume:
-    # type=file|default=<undefined>: The input volume
-    outputVolume:
-    # type=file: The output volume
-    # type=traitcompound|default=None: The output volume
-    debugDir:
-    # type=str|default='': A place for debug information
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_eye_detector_callables.py b/example-specs/task/nipype_internal/pydra-semtools/brains_eye_detector_callables.py
deleted file mode 100644
index fa9130d0..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/brains_eye_detector_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in BRAINSEyeDetector.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_fit.yaml b/example-specs/task/nipype_internal/pydra-semtools/brains_fit.yaml
deleted file mode 100644
index 9da201fb..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/brains_fit.yaml
+++ /dev/null
@@ -1,257 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.registration.brainsfit.BRAINSFit' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: General Registration (BRAINS)
-# 
-#     category: Registration
-# 
-#     description: Register a three-dimensional volume to a reference volume (Mattes Mutual Information by default). Full documentation available here: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/BRAINSFit. Method described in BRAINSFit: Mutual Information Registrations of Whole-Brain 3D Images, Using the Insight Toolkit, Johnson H.J., Harris G., Williams K., The Insight Journal, 2007. http://hdl.handle.net/1926/1291
-# 
-#     version: 3.0.0
-# 
-#     documentation-url: http://www.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/BRAINSFit
-# 
-#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
-# 
-#     contributor: Hans J. Johnson, hans-johnson -at- uiowa.edu, http://www.psychiatry.uiowa.edu
-# 
-#     acknowledgements: Hans Johnson(1,3,4); Kent Williams(1); Gregory Harris(1), Vincent Magnotta(1,2,3);  Andriy Fedorov(5) 1=University of Iowa Department of Psychiatry, 2=University of Iowa Department of Radiology, 3=University of Iowa Department of Biomedical Engineering, 4=University of Iowa Department of Electrical and Computer Engineering, 5=Surgical Planning Lab, Harvard
-#     
-task_name: BRAINSFit
-nipype_name: BRAINSFit
-nipype_module: nipype.interfaces.semtools.registration.brainsfit
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    fixedVolume: generic/file
-    # type=file|default=<undefined>: Input fixed image (the moving image will be transformed into this image space).
-    movingVolume: generic/file
-    # type=file|default=<undefined>: Input moving image (this image will be transformed into the fixed image space).
-    initialTransform: generic/file
-    # type=file|default=<undefined>: Transform to be applied to the moving image to initialize the registration.  This can only be used if Initialize Transform Mode is Off.
-    fixedBinaryVolume: generic/file
-    # type=file|default=<undefined>: Fixed Image binary mask volume, required if Masking Option is ROI. Image areas where the mask volume has zero value are ignored during the registration.
-    movingBinaryVolume: generic/file
-    # type=file|default=<undefined>: Moving Image binary mask volume, required if Masking Option is ROI. Image areas where the mask volume has zero value are ignored during the registration.
-    fixedVolume2: generic/file
-    # type=file|default=<undefined>: Input fixed image that will be used for multimodal registration. (the moving image will be transformed into this image space).
-    movingVolume2: generic/file
-    # type=file|default=<undefined>: Input moving image that will be used for multimodal registration(this image will be transformed into the fixed image space).
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    linearTransform: generic/file
-    # type=file: (optional) Output estimated transform - in case the computed transform is not BSpline. NOTE: You must set at least one output object (transform and/or output volume).
-    # type=traitcompound|default=None: (optional) Output estimated transform - in case the computed transform is not BSpline. NOTE: You must set at least one output object (transform and/or output volume).
-    bsplineTransform: generic/file
-    # type=file: (optional) Output estimated transform - in case the computed transform is BSpline. NOTE: You must set at least one output object (transform and/or output volume).
-    # type=traitcompound|default=None: (optional) Output estimated transform - in case the computed transform is BSpline. NOTE: You must set at least one output object (transform and/or output volume).
-    outputVolume: generic/file
-    # type=file: (optional) Output image: the moving image warped to the fixed image space. NOTE: You must set at least one output object (transform and/or output volume).
-    # type=traitcompound|default=None: (optional) Output image: the moving image warped to the fixed image space. NOTE: You must set at least one output object (transform and/or output volume).
-    outputFixedVolumeROI: generic/file
-    # type=file: ROI that is automatically computed from the fixed image. Only available if Masking Option is ROIAUTO. Image areas where the mask volume has zero value are ignored during the registration.
-    # type=traitcompound|default=None: ROI that is automatically computed from the fixed image. Only available if Masking Option is ROIAUTO. Image areas where the mask volume has zero value are ignored during the registration.
-    outputMovingVolumeROI: generic/file
-    # type=file: ROI that is automatically computed from the moving image. Only available if Masking Option is ROIAUTO. Image areas where the mask volume has zero value are ignored during the registration.
-    # type=traitcompound|default=None: ROI that is automatically computed from the moving image. Only available if Masking Option is ROIAUTO. Image areas where the mask volume has zero value are ignored during the registration.
-    strippedOutputTransform: generic/file
-    # type=file: Rigid component of the estimated affine transform. Can be used to rigidly register the moving image to the fixed image. NOTE:  This value is overridden if either bsplineTransform or linearTransform is set.
-    # type=traitcompound|default=None: Rigid component of the estimated affine transform. Can be used to rigidly register the moving image to the fixed image. NOTE:  This value is overridden if either bsplineTransform or linearTransform is set.
-    outputTransform: generic/file
-    # type=file: (optional) Filename to which save the (optional) estimated transform. NOTE: You must select either the outputTransform or the outputVolume option.
-    # type=traitcompound|default=None: (optional) Filename to which save the (optional) estimated transform. NOTE: You must select either the outputTransform or the outputVolume option.
-    logFileReport: generic/file
-    # type=file: A file to write out final information report in CSV file: MetricName,MetricValue,FixedImageName,FixedMaskName,MovingImageName,MovingMaskName
-    # type=traitcompound|default=None: A file to write out final information report in CSV file: MetricName,MetricValue,FixedImageName,FixedMaskName,MovingImageName,MovingMaskName
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    fixedVolume:
-    # type=file|default=<undefined>: Input fixed image (the moving image will be transformed into this image space).
-    movingVolume:
-    # type=file|default=<undefined>: Input moving image (this image will be transformed into the fixed image space).
-    samplingPercentage:
-    # type=float|default=0.0: Fraction of voxels of the fixed image that will be used for registration. The number has to be larger than zero and less or equal to one. Higher values increase the computation time but may give more accurate results. You can also limit the sampling focus with ROI masks and ROIAUTO mask generation. The default is 0.002 (use approximately 0.2% of voxels, resulting in 100000 samples in a 512x512x192 volume) to provide a very fast registration in most cases. Typical values range from 0.01 (1%) for low detail images to 0.2 (20%) for high detail images.
-    splineGridSize:
-    # type=inputmultiobject|default=[]: Number of BSpline grid subdivisions along each axis of the fixed image, centered on the image space. Values must be 3 or higher for the BSpline to be correctly computed.
-    linearTransform:
-    # type=file: (optional) Output estimated transform - in case the computed transform is not BSpline. NOTE: You must set at least one output object (transform and/or output volume).
-    # type=traitcompound|default=None: (optional) Output estimated transform - in case the computed transform is not BSpline. NOTE: You must set at least one output object (transform and/or output volume).
-    bsplineTransform:
-    # type=file: (optional) Output estimated transform - in case the computed transform is BSpline. NOTE: You must set at least one output object (transform and/or output volume).
-    # type=traitcompound|default=None: (optional) Output estimated transform - in case the computed transform is BSpline. NOTE: You must set at least one output object (transform and/or output volume).
-    outputVolume:
-    # type=file: (optional) Output image: the moving image warped to the fixed image space. NOTE: You must set at least one output object (transform and/or output volume).
-    # type=traitcompound|default=None: (optional) Output image: the moving image warped to the fixed image space. NOTE: You must set at least one output object (transform and/or output volume).
-    initialTransform:
-    # type=file|default=<undefined>: Transform to be applied to the moving image to initialize the registration.  This can only be used if Initialize Transform Mode is Off.
-    initializeTransformMode:
-    # type=enum|default='Off'|allowed['Off','useCenterOfHeadAlign','useCenterOfROIAlign','useGeometryAlign','useMomentsAlign']: Determine how to initialize the transform center.  useMomentsAlign assumes that the center of mass of the images represent similar structures.  useCenterOfHeadAlign attempts to use the top of head and shape of neck to drive a center of mass estimate. useGeometryAlign on assumes that the center of the voxel lattice of the images represent similar structures.  Off assumes that the physical space of the images are close.  This flag is mutually exclusive with the Initialization transform.
-    useRigid:
-    # type=bool|default=False: Perform a rigid registration as part of the sequential registration steps.  This family of options overrides the use of transformType if any of them are set.
-    useScaleVersor3D:
-    # type=bool|default=False: Perform a ScaleVersor3D registration as part of the sequential registration steps.  This family of options overrides the use of transformType if any of them are set.
-    useScaleSkewVersor3D:
-    # type=bool|default=False: Perform a ScaleSkewVersor3D registration as part of the sequential registration steps.  This family of options overrides the use of transformType if any of them are set.
-    useAffine:
-    # type=bool|default=False: Perform an Affine registration as part of the sequential registration steps.  This family of options overrides the use of transformType if any of them are set.
-    useBSpline:
-    # type=bool|default=False: Perform a BSpline registration as part of the sequential registration steps.  This family of options overrides the use of transformType if any of them are set.
-    useSyN:
-    # type=bool|default=False: Perform a SyN registration as part of the sequential registration steps.  This family of options overrides the use of transformType if any of them are set.
-    useComposite:
-    # type=bool|default=False: Perform a Composite registration as part of the sequential registration steps.  This family of options overrides the use of transformType if any of them are set.
-    maskProcessingMode:
-    # type=enum|default='NOMASK'|allowed['NOMASK','ROI','ROIAUTO']: Specifies a mask to only consider a certain image region for the registration.  If ROIAUTO is chosen, then the mask is computed using Otsu thresholding and hole filling. If ROI is chosen then the mask has to be specified as in input.
-    fixedBinaryVolume:
-    # type=file|default=<undefined>: Fixed Image binary mask volume, required if Masking Option is ROI. Image areas where the mask volume has zero value are ignored during the registration.
-    movingBinaryVolume:
-    # type=file|default=<undefined>: Moving Image binary mask volume, required if Masking Option is ROI. Image areas where the mask volume has zero value are ignored during the registration.
-    outputFixedVolumeROI:
-    # type=file: ROI that is automatically computed from the fixed image. Only available if Masking Option is ROIAUTO. Image areas where the mask volume has zero value are ignored during the registration.
-    # type=traitcompound|default=None: ROI that is automatically computed from the fixed image. Only available if Masking Option is ROIAUTO. Image areas where the mask volume has zero value are ignored during the registration.
-    outputMovingVolumeROI:
-    # type=file: ROI that is automatically computed from the moving image. Only available if Masking Option is ROIAUTO. Image areas where the mask volume has zero value are ignored during the registration.
-    # type=traitcompound|default=None: ROI that is automatically computed from the moving image. Only available if Masking Option is ROIAUTO. Image areas where the mask volume has zero value are ignored during the registration.
-    useROIBSpline:
-    # type=bool|default=False: If enabled then the bounding box of the input ROIs defines the BSpline grid support region. Otherwise the BSpline grid support region is the whole fixed image.
-    histogramMatch:
-    # type=bool|default=False: Apply histogram matching operation for the input images to make them more similar.  This is suitable for images of the same modality that may have different brightness or contrast, but the same overall intensity profile. Do NOT use if registering images from different modalities.
-    medianFilterSize:
-    # type=inputmultiobject|default=[]: Apply median filtering to reduce noise in the input volumes. The 3 values specify the radius for the optional MedianImageFilter preprocessing in all 3 directions (in voxels).
-    removeIntensityOutliers:
-    # type=float|default=0.0: Remove very high and very low intensity voxels from the input volumes. The parameter specifies the half percentage to decide outliers of image intensities. The default value is zero, which means no outlier removal. If the value of 0.005 is given, the 0.005% of both tails will be thrown away, so 0.01% of intensities in total would be ignored in the statistic calculation.
-    fixedVolume2:
-    # type=file|default=<undefined>: Input fixed image that will be used for multimodal registration. (the moving image will be transformed into this image space).
-    movingVolume2:
-    # type=file|default=<undefined>: Input moving image that will be used for multimodal registration(this image will be transformed into the fixed image space).
-    outputVolumePixelType:
-    # type=enum|default='float'|allowed['float','int','short','uchar','uint','ushort']: Data type for representing a voxel of the Output Volume.
-    backgroundFillValue:
-    # type=float|default=0.0: This value will be used for filling those areas of the output image that have no corresponding voxels in the input moving image.
-    scaleOutputValues:
-    # type=bool|default=False: If true, and the voxel values do not fit within the minimum and maximum values of the desired outputVolumePixelType, then linearly scale the min/max output image voxel values to fit within the min/max range of the outputVolumePixelType.
-    interpolationMode:
-    # type=enum|default='NearestNeighbor'|allowed['BSpline','Blackman','Cosine','Hamming','Lanczos','Linear','NearestNeighbor','ResampleInPlace','Welch','WindowedSinc']: Type of interpolation to be used when applying transform to moving volume.  Options are Linear, NearestNeighbor, BSpline, WindowedSinc, Hamming, Cosine, Welch, Lanczos, or ResampleInPlace.  The ResampleInPlace option will create an image with the same discrete voxel values and will adjust the origin and direction of the physical space interpretation.
-    numberOfIterations:
-    # type=inputmultiobject|default=[]: The maximum number of iterations to try before stopping the optimization. When using a lower value (500-1000) then the registration is forced to terminate earlier but there is a higher risk of stopping before an optimal solution is reached.
-    maximumStepLength:
-    # type=float|default=0.0: Starting step length of the optimizer. In general, higher values allow for recovering larger initial misalignments but there is an increased chance that the registration will not converge.
-    minimumStepLength:
-    # type=inputmultiobject|default=[]: Each step in the optimization takes steps at least this big.  When none are possible, registration is complete. Smaller values allows the optimizer to make smaller adjustments, but the registration time may increase.
-    relaxationFactor:
-    # type=float|default=0.0: Specifies how quickly the optimization step length is decreased during registration. The value must be larger than 0 and smaller than 1. Larger values result in slower step size decrease, which allow for recovering larger initial misalignments but it increases the registration time and the chance that the registration will not converge.
-    translationScale:
-    # type=float|default=0.0: How much to scale up changes in position (in mm) compared to unit rotational changes (in radians) -- decrease this to allow for more rotation in the search pattern.
-    reproportionScale:
-    # type=float|default=0.0: ScaleVersor3D 'Scale' compensation factor.  Increase this to allow for more rescaling in a ScaleVersor3D or ScaleSkewVersor3D search pattern.  1.0 works well with a translationScale of 1000.0
-    skewScale:
-    # type=float|default=0.0: ScaleSkewVersor3D Skew compensation factor.  Increase this to allow for more skew in a ScaleSkewVersor3D search pattern.  1.0 works well with a translationScale of 1000.0
-    maxBSplineDisplacement:
-    # type=float|default=0.0: Maximum allowed displacements in image physical coordinates (mm) for BSpline control grid along each axis.  A value of 0.0 indicates that the problem should be unbounded.  NOTE:  This only constrains the BSpline portion, and does not limit the displacement from the associated bulk transform.  This can lead to a substantial reduction in computation time in the BSpline optimizer.,       
-    fixedVolumeTimeIndex:
-    # type=int|default=0: The index in the time series for the 3D fixed image to fit. Only allowed if the fixed input volume is 4-dimensional.
-    movingVolumeTimeIndex:
-    # type=int|default=0: The index in the time series for the 3D moving image to fit. Only allowed if the moving input volume is 4-dimensional
-    numberOfHistogramBins:
-    # type=int|default=0: The number of histogram levels used for mutual information metric estimation.
-    numberOfMatchPoints:
-    # type=int|default=0: Number of histogram match points used for mutual information metric estimation.
-    costMetric:
-    # type=enum|default='MMI'|allowed['MIH','MMI','MSE','NC']: The cost metric to be used during fitting. Defaults to MMI. Options are MMI (Mattes Mutual Information), MSE (Mean Square Error), NC (Normalized Correlation), MC (Match Cardinality for binary images)
-    maskInferiorCutOffFromCenter:
-    # type=float|default=0.0: If Initialize Transform Mode is set to useCenterOfHeadAlign or Masking Option is ROIAUTO then this value defines the how much is cut of from the inferior part of the image. The cut-off distance is specified in millimeters, relative to the image center. If the value is 1000 or larger then no cut-off performed.
-    ROIAutoDilateSize:
-    # type=float|default=0.0: This flag is only relevant when using ROIAUTO mode for initializing masks.  It defines the final dilation size to capture a bit of background outside the tissue region.  A setting of 10mm has been shown to help regularize a BSpline registration type so that there is some background constraints to match the edges of the head better.
-    ROIAutoClosingSize:
-    # type=float|default=0.0: This flag is only relevant when using ROIAUTO mode for initializing masks.  It defines the hole closing size in mm.  It is rounded up to the nearest whole pixel size in each direction. The default is to use a closing size of 9mm.  For mouse data this value may need to be reset to 0.9 or smaller.
-    numberOfSamples:
-    # type=int|default=0: The number of voxels sampled for mutual information computation.  Increase this for higher accuracy, at the cost of longer computation time., NOTE that it is suggested to use samplingPercentage instead of this option. However, if set to non-zero, numberOfSamples overwrites the samplingPercentage option.  
-    strippedOutputTransform:
-    # type=file: Rigid component of the estimated affine transform. Can be used to rigidly register the moving image to the fixed image. NOTE:  This value is overridden if either bsplineTransform or linearTransform is set.
-    # type=traitcompound|default=None: Rigid component of the estimated affine transform. Can be used to rigidly register the moving image to the fixed image. NOTE:  This value is overridden if either bsplineTransform or linearTransform is set.
-    transformType:
-    # type=inputmultiobject|default=[]: Specifies a list of registration types to be used.  The valid types are, Rigid, ScaleVersor3D, ScaleSkewVersor3D, Affine, BSpline and SyN.  Specifying more than one in a comma separated list will initialize the next stage with the previous results. If registrationClass flag is used, it overrides this parameter setting.
-    outputTransform:
-    # type=file: (optional) Filename to which save the (optional) estimated transform. NOTE: You must select either the outputTransform or the outputVolume option.
-    # type=traitcompound|default=None: (optional) Filename to which save the (optional) estimated transform. NOTE: You must select either the outputTransform or the outputVolume option.
-    initializeRegistrationByCurrentGenericTransform:
-    # type=bool|default=False: If this flag is ON, the current generic composite transform, resulted from the linear registration stages, is set to initialize the follow nonlinear registration process. However, by the default behaviour, the moving image is first warped based on the existent transform before it is passed to the BSpline registration filter. It is done to speed up the BSpline registration by reducing the computations of composite transform Jacobian.
-    failureExitCode:
-    # type=int|default=0: If the fit fails, exit with this status code.  (It can be used to force a successfult exit status of (0) if the registration fails due to reaching the maximum number of iterations.
-    writeTransformOnFailure:
-    # type=bool|default=False: Flag to save the final transform even if the numberOfIterations are reached without convergence. (Intended for use when --failureExitCode 0 )
-    numberOfThreads:
-    # type=int|default=0: Explicitly specify the maximum number of threads to use. (default is auto-detected)
-    debugLevel:
-    # type=int|default=0: Display debug messages, and produce debug intermediate results.  0=OFF, 1=Minimal, 10=Maximum debugging.
-    costFunctionConvergenceFactor:
-    # type=float|default=0.0: From itkLBFGSBOptimizer.h: Set/Get the CostFunctionConvergenceFactor. Algorithm terminates when the reduction in cost function is less than (factor * epsmcj) where epsmch is the machine precision. Typical values for factor: 1e+12 for low accuracy; 1e+7 for moderate accuracy and 1e+1 for extremely high accuracy.  1e+9 seems to work well.,       
-    projectedGradientTolerance:
-    # type=float|default=0.0: From itkLBFGSBOptimizer.h: Set/Get the ProjectedGradientTolerance. Algorithm terminates when the project gradient is below the tolerance. Default lbfgsb value is 1e-5, but 1e-4 seems to work well.,       
-    maximumNumberOfEvaluations:
-    # type=int|default=0: Maximum number of evaluations for line search in lbfgsb optimizer.
-    maximumNumberOfCorrections:
-    # type=int|default=0: Maximum number of corrections in lbfgsb optimizer.
-    gui:
-    # type=bool|default=False: Display intermediate image volumes for debugging.  NOTE:  This is not part of the standard build system, and probably does nothing on your installation.
-    promptUser:
-    # type=bool|default=False: Prompt the user to hit enter each time an image is sent to the DebugImageViewer
-    metricSamplingStrategy:
-    # type=enum|default='Random'|allowed['Random']: It defines the method that registration filter uses to sample the input fixed image. Only Random is supported for now.
-    logFileReport:
-    # type=file: A file to write out final information report in CSV file: MetricName,MetricValue,FixedImageName,FixedMaskName,MovingImageName,MovingMaskName
-    # type=traitcompound|default=None: A file to write out final information report in CSV file: MetricName,MetricValue,FixedImageName,FixedMaskName,MovingImageName,MovingMaskName
-    writeOutputTransformInFloat:
-    # type=bool|default=False: By default, the output registration transforms (either the output composite transform or each transform component) are written to the disk in double precision. If this flag is ON, the output transforms will be written in single (float) precision. It is especially important if the output transform is a displacement field transform, or it is a composite transform that includes several displacement fields.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_fit_callables.py b/example-specs/task/nipype_internal/pydra-semtools/brains_fit_callables.py
deleted file mode 100644
index 324aacce..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/brains_fit_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in BRAINSFit.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_initialized_control_points.yaml b/example-specs/task/nipype_internal/pydra-semtools/brains_initialized_control_points.yaml
deleted file mode 100644
index 527b9da7..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/brains_initialized_control_points.yaml
+++ /dev/null
@@ -1,97 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.utilities.brains.BRAINSInitializedControlPoints' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Initialized Control Points (BRAINS)
-# 
-#     category: Utilities.BRAINS
-# 
-#     description: Outputs bspline control points as landmarks
-# 
-#     version: 0.1.0.$Revision: 916 $(alpha)
-# 
-#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
-# 
-#     contributor: Mark Scully
-# 
-#     acknowledgements: This work is part of the National Alliance for Medical Image Computing (NAMIC), funded by the National Institutes of Health through the NIH Roadmap for Medical Research, Grant U54 EB005149.  Additional support for Mark Scully and Hans Johnson at the University of Iowa.
-#     
-task_name: BRAINSInitializedControlPoints
-nipype_name: BRAINSInitializedControlPoints
-nipype_module: nipype.interfaces.semtools.utilities.brains
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputVolume: generic/file
-    # type=file|default=<undefined>: Input Volume
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputVolume: generic/file
-    # type=file: Output Volume
-    # type=traitcompound|default=None: Output Volume
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputVolume:
-    # type=file|default=<undefined>: Input Volume
-    outputVolume:
-    # type=file: Output Volume
-    # type=traitcompound|default=None: Output Volume
-    splineGridSize:
-    # type=inputmultiobject|default=[]: The number of subdivisions of the BSpline Grid to be centered on the image space.  Each dimension must have at least 3 subdivisions for the BSpline to be correctly computed. 
-    permuteOrder:
-    # type=inputmultiobject|default=[]: The permutation order for the images.  The default is 0,1,2 (i.e. no permutation)
-    outputLandmarksFile:
-    # type=str|default='': Output filename
-    numberOfThreads:
-    # type=int|default=0: Explicitly specify the maximum number of threads to use.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_initialized_control_points_callables.py b/example-specs/task/nipype_internal/pydra-semtools/brains_initialized_control_points_callables.py
deleted file mode 100644
index d9351137..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/brains_initialized_control_points_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in BRAINSInitializedControlPoints.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_landmark_initializer.yaml b/example-specs/task/nipype_internal/pydra-semtools/brains_landmark_initializer.yaml
deleted file mode 100644
index 25bbdbeb..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/brains_landmark_initializer.yaml
+++ /dev/null
@@ -1,95 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.utilities.brains.BRAINSLandmarkInitializer' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: BRAINSLandmarkInitializer
-# 
-#     category: Utilities.BRAINS
-# 
-#     description: Create transformation file (*mat) from a pair of landmarks (*fcsv) files.
-# 
-#     version: 1.0
-# 
-#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
-# 
-#     contributor: Eunyoung Regina Kim
-#     
-task_name: BRAINSLandmarkInitializer
-nipype_name: BRAINSLandmarkInitializer
-nipype_module: nipype.interfaces.semtools.utilities.brains
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputFixedLandmarkFilename: generic/file
-    # type=file|default=<undefined>: input fixed landmark. *.fcsv
-    inputMovingLandmarkFilename: generic/file
-    # type=file|default=<undefined>: input moving landmark. *.fcsv
-    inputWeightFilename: generic/file
-    # type=file|default=<undefined>: Input weight file name for landmarks. Higher weighted landmark will be considered more heavily. Weights are proportional, that is the magnitude of weights will be normalized by its minimum and maximum value. 
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputTransformFilename: generic/file
-    # type=file: output transform file name (ex: ./outputTransform.mat) 
-    # type=traitcompound|default=None: output transform file name (ex: ./outputTransform.mat) 
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputFixedLandmarkFilename:
-    # type=file|default=<undefined>: input fixed landmark. *.fcsv
-    inputMovingLandmarkFilename:
-    # type=file|default=<undefined>: input moving landmark. *.fcsv
-    inputWeightFilename:
-    # type=file|default=<undefined>: Input weight file name for landmarks. Higher weighted landmark will be considered more heavily. Weights are proportional, that is the magnitude of weights will be normalized by its minimum and maximum value. 
-    outputTransformFilename:
-    # type=file: output transform file name (ex: ./outputTransform.mat) 
-    # type=traitcompound|default=None: output transform file name (ex: ./outputTransform.mat) 
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_landmark_initializer_callables.py b/example-specs/task/nipype_internal/pydra-semtools/brains_landmark_initializer_callables.py
deleted file mode 100644
index 6283aa56..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/brains_landmark_initializer_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in BRAINSLandmarkInitializer.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_linear_modeler_epca.yaml b/example-specs/task/nipype_internal/pydra-semtools/brains_linear_modeler_epca.yaml
deleted file mode 100644
index 86c2e098..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/brains_linear_modeler_epca.yaml
+++ /dev/null
@@ -1,81 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.utilities.brains.BRAINSLinearModelerEPCA' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Landmark Linear Modeler (BRAINS)
-# 
-#     category: Utilities.BRAINS
-# 
-#     description: Training linear model using EPCA. Implementation based on my MS thesis, "A METHOD FOR AUTOMATED LANDMARK CONSTELLATION DETECTION USING EVOLUTIONARY PRINCIPAL COMPONENTS AND STATISTICAL SHAPE MODELS"
-# 
-#     version: 1.0
-# 
-#     documentation-url: http://www.nitrc.org/projects/brainscdetector/
-#     
-task_name: BRAINSLinearModelerEPCA
-nipype_name: BRAINSLinearModelerEPCA
-nipype_module: nipype.interfaces.semtools.utilities.brains
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputTrainingList: generic/file
-    # type=file|default=<undefined>: Input Training Landmark List Filename,             
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputTrainingList:
-    # type=file|default=<undefined>: Input Training Landmark List Filename,             
-    numberOfThreads:
-    # type=int|default=0: Explicitly specify the maximum number of threads to use.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_linear_modeler_epca_callables.py b/example-specs/task/nipype_internal/pydra-semtools/brains_linear_modeler_epca_callables.py
deleted file mode 100644
index c7fab313..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/brains_linear_modeler_epca_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in BRAINSLinearModelerEPCA.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_lmk_transform.yaml b/example-specs/task/nipype_internal/pydra-semtools/brains_lmk_transform.yaml
deleted file mode 100644
index 8e06928e..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/brains_lmk_transform.yaml
+++ /dev/null
@@ -1,105 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.utilities.brains.BRAINSLmkTransform' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Landmark Transform (BRAINS)
-# 
-#     category: Utilities.BRAINS
-# 
-#     description: This utility program estimates the affine transform to align the fixed landmarks to the moving landmarks, and then generate the resampled moving image to the same physical space as that of the reference image.
-# 
-#     version: 1.0
-# 
-#     documentation-url: http://www.nitrc.org/projects/brainscdetector/
-#     
-task_name: BRAINSLmkTransform
-nipype_name: BRAINSLmkTransform
-nipype_module: nipype.interfaces.semtools.utilities.brains
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputMovingLandmarks: generic/file
-    # type=file|default=<undefined>: Input Moving Landmark list file in fcsv,             
-    inputFixedLandmarks: generic/file
-    # type=file|default=<undefined>: Input Fixed Landmark list file in fcsv,             
-    inputMovingVolume: generic/file
-    # type=file|default=<undefined>: The filename of input moving volume
-    inputReferenceVolume: generic/file
-    # type=file|default=<undefined>: The filename of the reference volume
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputAffineTransform: generic/file
-    # type=file: The filename for the estimated affine transform,             
-    # type=traitcompound|default=None: The filename for the estimated affine transform,             
-    outputResampledVolume: generic/file
-    # type=file: The filename of the output resampled volume
-    # type=traitcompound|default=None: The filename of the output resampled volume
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputMovingLandmarks:
-    # type=file|default=<undefined>: Input Moving Landmark list file in fcsv,             
-    inputFixedLandmarks:
-    # type=file|default=<undefined>: Input Fixed Landmark list file in fcsv,             
-    outputAffineTransform:
-    # type=file: The filename for the estimated affine transform,             
-    # type=traitcompound|default=None: The filename for the estimated affine transform,             
-    inputMovingVolume:
-    # type=file|default=<undefined>: The filename of input moving volume
-    inputReferenceVolume:
-    # type=file|default=<undefined>: The filename of the reference volume
-    outputResampledVolume:
-    # type=file: The filename of the output resampled volume
-    # type=traitcompound|default=None: The filename of the output resampled volume
-    numberOfThreads:
-    # type=int|default=0: Explicitly specify the maximum number of threads to use.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_lmk_transform_callables.py b/example-specs/task/nipype_internal/pydra-semtools/brains_lmk_transform_callables.py
deleted file mode 100644
index 844caf36..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/brains_lmk_transform_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in BRAINSLmkTransform.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_multi_staple.yaml b/example-specs/task/nipype_internal/pydra-semtools/brains_multi_staple.yaml
deleted file mode 100644
index 7d2a6ae1..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/brains_multi_staple.yaml
+++ /dev/null
@@ -1,101 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.segmentation.specialized.BRAINSMultiSTAPLE' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Create best representative label map)
-# 
-#     category: Segmentation.Specialized
-# 
-#     description: given a list of label map images, create a representative/average label map.
-#     
-task_name: BRAINSMultiSTAPLE
-nipype_name: BRAINSMultiSTAPLE
-nipype_module: nipype.interfaces.semtools.segmentation.specialized
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputCompositeT1Volume: generic/file
-    # type=file|default=<undefined>: Composite T1, all label maps transformed into the space for this image.
-    inputLabelVolume: generic/file+list-of
-    # type=inputmultiobject|default=[]: The list of proobabilityimages.
-    inputTransform: generic/file+list-of
-    # type=inputmultiobject|default=[]: transforms to apply to label volumes
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputMultiSTAPLE: generic/file
-    # type=file: the MultiSTAPLE average of input label volumes
-    # type=traitcompound|default=None: the MultiSTAPLE average of input label volumes
-    outputConfusionMatrix: generic/file
-    # type=file: Confusion Matrix
-    # type=traitcompound|default=None: Confusion Matrix
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputCompositeT1Volume:
-    # type=file|default=<undefined>: Composite T1, all label maps transformed into the space for this image.
-    inputLabelVolume:
-    # type=inputmultiobject|default=[]: The list of proobabilityimages.
-    inputTransform:
-    # type=inputmultiobject|default=[]: transforms to apply to label volumes
-    labelForUndecidedPixels:
-    # type=int|default=0: Label for undecided pixels
-    resampledVolumePrefix:
-    # type=str|default='': if given, write out resampled volumes with this prefix
-    skipResampling:
-    # type=bool|default=False: Omit resampling images into reference space
-    outputMultiSTAPLE:
-    # type=file: the MultiSTAPLE average of input label volumes
-    # type=traitcompound|default=None: the MultiSTAPLE average of input label volumes
-    outputConfusionMatrix:
-    # type=file: Confusion Matrix
-    # type=traitcompound|default=None: Confusion Matrix
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_multi_staple_callables.py b/example-specs/task/nipype_internal/pydra-semtools/brains_multi_staple_callables.py
deleted file mode 100644
index 78548902..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/brains_multi_staple_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in BRAINSMultiSTAPLE.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_mush.yaml b/example-specs/task/nipype_internal/pydra-semtools/brains_mush.yaml
deleted file mode 100644
index 73974849..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/brains_mush.yaml
+++ /dev/null
@@ -1,131 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.utilities.brains.BRAINSMush' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Brain Extraction from T1/T2 image (BRAINS)
-# 
-#     category: Utilities.BRAINS
-# 
-#     description: This program: 1) generates a weighted mixture image optimizing the mean and variance and 2) produces a mask of the brain volume
-# 
-#     version: 0.1.0.$Revision: 1.4 $(alpha)
-# 
-#     documentation-url: http:://mri.radiology.uiowa.edu
-# 
-#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
-# 
-#     contributor: This tool is a modification by Steven Dunn of a program developed by Greg Harris and Ron Pierson.
-# 
-#     acknowledgements: This work was developed by the University of Iowa Departments of Radiology and Psychiatry. This software was supported in part of NIH/NINDS award NS050568.
-#     
-task_name: BRAINSMush
-nipype_name: BRAINSMush
-nipype_module: nipype.interfaces.semtools.utilities.brains
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputFirstVolume: generic/file
-    # type=file|default=<undefined>: Input image (1) for mixture optimization
-    inputSecondVolume: generic/file
-    # type=file|default=<undefined>: Input image (2) for mixture optimization
-    inputMaskVolume: generic/file
-    # type=file|default=<undefined>: Input label image for mixture optimization
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputWeightsFile: generic/file
-    # type=file: Output Weights File
-    # type=traitcompound|default=None: Output Weights File
-    outputVolume: generic/file
-    # type=file: The MUSH image produced from the T1 and T2 weighted images
-    # type=traitcompound|default=None: The MUSH image produced from the T1 and T2 weighted images
-    outputMask: generic/file
-    # type=file: The brain volume mask generated from the MUSH image
-    # type=traitcompound|default=None: The brain volume mask generated from the MUSH image
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputFirstVolume:
-    # type=file|default=<undefined>: Input image (1) for mixture optimization
-    inputSecondVolume:
-    # type=file|default=<undefined>: Input image (2) for mixture optimization
-    inputMaskVolume:
-    # type=file|default=<undefined>: Input label image for mixture optimization
-    outputWeightsFile:
-    # type=file: Output Weights File
-    # type=traitcompound|default=None: Output Weights File
-    outputVolume:
-    # type=file: The MUSH image produced from the T1 and T2 weighted images
-    # type=traitcompound|default=None: The MUSH image produced from the T1 and T2 weighted images
-    outputMask:
-    # type=file: The brain volume mask generated from the MUSH image
-    # type=traitcompound|default=None: The brain volume mask generated from the MUSH image
-    seed:
-    # type=inputmultiobject|default=[]: Seed Point for Brain Region Filling
-    desiredMean:
-    # type=float|default=0.0: Desired mean within the mask for weighted sum of both images.
-    desiredVariance:
-    # type=float|default=0.0: Desired variance within the mask for weighted sum of both images.
-    lowerThresholdFactorPre:
-    # type=float|default=0.0: Lower threshold factor for finding an initial brain mask
-    upperThresholdFactorPre:
-    # type=float|default=0.0: Upper threshold factor for finding an initial brain mask
-    lowerThresholdFactor:
-    # type=float|default=0.0: Lower threshold factor for defining the brain mask
-    upperThresholdFactor:
-    # type=float|default=0.0: Upper threshold factor for defining the brain mask
-    boundingBoxSize:
-    # type=inputmultiobject|default=[]: Size of the cubic bounding box mask used when no brain mask is present
-    boundingBoxStart:
-    # type=inputmultiobject|default=[]: XYZ point-coordinate for the start of the cubic bounding box mask used when no brain mask is present
-    numberOfThreads:
-    # type=int|default=0: Explicitly specify the maximum number of threads to use.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_mush_callables.py b/example-specs/task/nipype_internal/pydra-semtools/brains_mush_callables.py
deleted file mode 100644
index 71bacf88..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/brains_mush_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in BRAINSMush.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_posterior_to_continuous_class.yaml b/example-specs/task/nipype_internal/pydra-semtools/brains_posterior_to_continuous_class.yaml
deleted file mode 100644
index 94ab5773..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/brains_posterior_to_continuous_class.yaml
+++ /dev/null
@@ -1,115 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.brains.classify.BRAINSPosteriorToContinuousClass' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Tissue Classification
-# 
-#     category: BRAINS.Classify
-# 
-#     description: This program will generate an 8-bit continuous tissue classified image based on BRAINSABC posterior images.
-# 
-#     version: 3.0
-# 
-#     documentation-url: http://www.nitrc.org/plugins/mwiki/index.php/brains:BRAINSClassify
-# 
-#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
-# 
-#     contributor: Vincent A. Magnotta
-# 
-#     acknowledgements: Funding for this work was provided by NIH/NINDS award NS050568
-#     
-task_name: BRAINSPosteriorToContinuousClass
-nipype_name: BRAINSPosteriorToContinuousClass
-nipype_module: nipype.interfaces.semtools.brains.classify
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputWhiteVolume: generic/file
-    # type=file|default=<undefined>: White Matter Posterior Volume
-    inputBasalGmVolume: generic/file
-    # type=file|default=<undefined>: Basal Grey Matter Posterior Volume
-    inputSurfaceGmVolume: generic/file
-    # type=file|default=<undefined>: Surface Grey Matter Posterior Volume
-    inputCsfVolume: generic/file
-    # type=file|default=<undefined>: CSF Posterior Volume
-    inputVbVolume: generic/file
-    # type=file|default=<undefined>: Venous Blood Posterior Volume
-    inputCrblGmVolume: generic/file
-    # type=file|default=<undefined>: Cerebellum Grey Matter Posterior Volume
-    inputCrblWmVolume: generic/file
-    # type=file|default=<undefined>: Cerebellum White Matter Posterior Volume
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputVolume: generic/file
-    # type=file: Output Continuous Tissue Classified Image
-    # type=traitcompound|default=None: Output Continuous Tissue Classified Image
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputWhiteVolume:
-    # type=file|default=<undefined>: White Matter Posterior Volume
-    inputBasalGmVolume:
-    # type=file|default=<undefined>: Basal Grey Matter Posterior Volume
-    inputSurfaceGmVolume:
-    # type=file|default=<undefined>: Surface Grey Matter Posterior Volume
-    inputCsfVolume:
-    # type=file|default=<undefined>: CSF Posterior Volume
-    inputVbVolume:
-    # type=file|default=<undefined>: Venous Blood Posterior Volume
-    inputCrblGmVolume:
-    # type=file|default=<undefined>: Cerebellum Grey Matter Posterior Volume
-    inputCrblWmVolume:
-    # type=file|default=<undefined>: Cerebellum White Matter Posterior Volume
-    outputVolume:
-    # type=file: Output Continuous Tissue Classified Image
-    # type=traitcompound|default=None: Output Continuous Tissue Classified Image
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_posterior_to_continuous_class_callables.py b/example-specs/task/nipype_internal/pydra-semtools/brains_posterior_to_continuous_class_callables.py
deleted file mode 100644
index 3e1c01af..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/brains_posterior_to_continuous_class_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in BRAINSPosteriorToContinuousClass.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_resample.yaml b/example-specs/task/nipype_internal/pydra-semtools/brains_resample.yaml
deleted file mode 100644
index 4821a423..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/brains_resample.yaml
+++ /dev/null
@@ -1,115 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.registration.brainsresample.BRAINSResample' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Resample Image (BRAINS)
-# 
-#     category: Registration
-# 
-#     description: This program collects together three common image processing tasks that all involve resampling an image volume: Resampling to a new resolution and spacing, applying a transformation (using an ITK transform IO mechanisms) and Warping (using a vector image deformation field).  Full documentation available here: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/BRAINSResample.
-# 
-#     version: 3.0.0
-# 
-#     documentation-url: http://www.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/BRAINSResample
-# 
-#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
-# 
-#     contributor: This tool was developed by Vincent Magnotta, Greg Harris, and Hans Johnson.
-# 
-#     acknowledgements: The development of this tool was supported by funding from grants NS050568 and NS40068 from the National Institute of Neurological Disorders and Stroke and grants MH31593, MH40856, from the National Institute of Mental Health.
-#     
-task_name: BRAINSResample
-nipype_name: BRAINSResample
-nipype_module: nipype.interfaces.semtools.registration.brainsresample
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputVolume: generic/file
-    # type=file|default=<undefined>: Image To Warp
-    referenceVolume: generic/file
-    # type=file|default=<undefined>: Reference image used only to define the output space. If not specified, the warping is done in the same space as the image to warp.
-    deformationVolume: generic/file
-    # type=file|default=<undefined>: Displacement Field to be used to warp the image (ITKv3 or earlier)
-    warpTransform: generic/file
-    # type=file|default=<undefined>: Filename for the BRAINSFit transform (ITKv3 or earlier) or composite transform file (ITKv4)
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputVolume: generic/file
-    # type=file: Resulting deformed image
-    # type=traitcompound|default=None: Resulting deformed image
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputVolume:
-    # type=file|default=<undefined>: Image To Warp
-    referenceVolume:
-    # type=file|default=<undefined>: Reference image used only to define the output space. If not specified, the warping is done in the same space as the image to warp.
-    outputVolume:
-    # type=file: Resulting deformed image
-    # type=traitcompound|default=None: Resulting deformed image
-    pixelType:
-    # type=enum|default='float'|allowed['binary','float','int','short','uchar','uint','ushort']: Specifies the pixel type for the input/output images.  The 'binary' pixel type uses a modified algorithm whereby the image is read in as unsigned char, a signed distance map is created, signed distance map is resampled, and then a thresholded image of type unsigned char is written to disk.
-    deformationVolume:
-    # type=file|default=<undefined>: Displacement Field to be used to warp the image (ITKv3 or earlier)
-    warpTransform:
-    # type=file|default=<undefined>: Filename for the BRAINSFit transform (ITKv3 or earlier) or composite transform file (ITKv4)
-    interpolationMode:
-    # type=enum|default='NearestNeighbor'|allowed['BSpline','Blackman','Cosine','Hamming','Lanczos','Linear','NearestNeighbor','ResampleInPlace','Welch','WindowedSinc']: Type of interpolation to be used when applying transform to moving volume.  Options are Linear, ResampleInPlace, NearestNeighbor, BSpline, or WindowedSinc
-    inverseTransform:
-    # type=bool|default=False: True/False is to compute inverse of given transformation. Default is false
-    defaultValue:
-    # type=float|default=0.0: Default voxel value
-    gridSpacing:
-    # type=inputmultiobject|default=[]: Add warped grid to output image to help show the deformation that occurred with specified spacing.   A spacing of 0 in a dimension indicates that grid lines should be rendered to fall exactly (i.e. do not allow displacements off that plane).  This is useful for making a 2D image of grid lines from the 3D space
-    numberOfThreads:
-    # type=int|default=0: Explicitly specify the maximum number of threads to use.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_resample_callables.py b/example-specs/task/nipype_internal/pydra-semtools/brains_resample_callables.py
deleted file mode 100644
index e8e4b158..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/brains_resample_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in BRAINSResample.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_resize.yaml b/example-specs/task/nipype_internal/pydra-semtools/brains_resize.yaml
deleted file mode 100644
index b36c41ff..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/brains_resize.yaml
+++ /dev/null
@@ -1,93 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.registration.brainsresize.BRAINSResize' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Resize Image (BRAINS)
-# 
-#     category: Registration
-# 
-#     description: This program is useful for downsampling an image by a constant scale factor.
-# 
-#     version: 3.0.0
-# 
-#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
-# 
-#     contributor: This tool was developed by Hans Johnson.
-# 
-#     acknowledgements: The development of this tool was supported by funding from grants NS050568 and NS40068 from the National Institute of Neurological Disorders and Stroke and grants MH31593, MH40856, from the National Institute of Mental Health.
-#     
-task_name: BRAINSResize
-nipype_name: BRAINSResize
-nipype_module: nipype.interfaces.semtools.registration.brainsresize
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputVolume: generic/file
-    # type=file|default=<undefined>: Image To Scale
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputVolume: generic/file
-    # type=file: Resulting scaled image
-    # type=traitcompound|default=None: Resulting scaled image
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputVolume:
-    # type=file|default=<undefined>: Image To Scale
-    outputVolume:
-    # type=file: Resulting scaled image
-    # type=traitcompound|default=None: Resulting scaled image
-    pixelType:
-    # type=enum|default='float'|allowed['binary','float','int','short','uchar','uint','ushort']: Specifies the pixel type for the input/output images.  The 'binary' pixel type uses a modified algorithm whereby the image is read in as unsigned char, a signed distance map is created, signed distance map is resampled, and then a thresholded image of type unsigned char is written to disk.
-    scaleFactor:
-    # type=float|default=0.0: The scale factor for the image spacing.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_resize_callables.py b/example-specs/task/nipype_internal/pydra-semtools/brains_resize_callables.py
deleted file mode 100644
index c2bd8950..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/brains_resize_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in BRAINSResize.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_snap_shot_writer.yaml b/example-specs/task/nipype_internal/pydra-semtools/brains_snap_shot_writer.yaml
deleted file mode 100644
index 5697e012..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/brains_snap_shot_writer.yaml
+++ /dev/null
@@ -1,99 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.utilities.brains.BRAINSSnapShotWriter' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: BRAINSSnapShotWriter
-# 
-#     category: Utilities.BRAINS
-# 
-#     description: Create 2D snapshot of input images. Mask images are color-coded
-# 
-#     version: 1.0
-# 
-#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
-# 
-#     contributor: Eunyoung Regina Kim
-#     
-task_name: BRAINSSnapShotWriter
-nipype_name: BRAINSSnapShotWriter
-nipype_module: nipype.interfaces.semtools.utilities.brains
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputVolumes: generic/file+list-of
-    # type=inputmultiobject|default=[]: Input image volume list to be extracted as 2D image. Multiple input is possible. At least one input is required.
-    inputBinaryVolumes: generic/file+list-of
-    # type=inputmultiobject|default=[]: Input mask (binary) volume list to be extracted as 2D image. Multiple input is possible.
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputFilename: generic/file
-    # type=file: 2D file name of input images. Required.
-    # type=traitcompound|default=None: 2D file name of input images. Required.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputVolumes:
-    # type=inputmultiobject|default=[]: Input image volume list to be extracted as 2D image. Multiple input is possible. At least one input is required.
-    inputBinaryVolumes:
-    # type=inputmultiobject|default=[]: Input mask (binary) volume list to be extracted as 2D image. Multiple input is possible.
-    inputSliceToExtractInPhysicalPoint:
-    # type=inputmultiobject|default=[]: 2D slice number of input images. For autoWorkUp output, which AC-PC aligned, 0,0,0 will be the center.
-    inputSliceToExtractInIndex:
-    # type=inputmultiobject|default=[]: 2D slice number of input images. For size of 256*256*256 image, 128 is usually used.
-    inputSliceToExtractInPercent:
-    # type=inputmultiobject|default=[]: 2D slice number of input images. Percentage input from 0%-100%. (ex. --inputSliceToExtractInPercent 50,50,50
-    inputPlaneDirection:
-    # type=inputmultiobject|default=[]: Plane to display. In general, 0=sagittal, 1=coronal, and 2=axial plane.
-    outputFilename:
-    # type=file: 2D file name of input images. Required.
-    # type=traitcompound|default=None: 2D file name of input images. Required.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_snap_shot_writer_callables.py b/example-specs/task/nipype_internal/pydra-semtools/brains_snap_shot_writer_callables.py
deleted file mode 100644
index 789aac69..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/brains_snap_shot_writer_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in BRAINSSnapShotWriter.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_talairach.yaml b/example-specs/task/nipype_internal/pydra-semtools/brains_talairach.yaml
deleted file mode 100644
index 5707024d..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/brains_talairach.yaml
+++ /dev/null
@@ -1,113 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.brains.segmentation.BRAINSTalairach' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: BRAINS Talairach
-# 
-#     category: BRAINS.Segmentation
-# 
-#     description: This program creates a VTK structured grid defining the Talairach coordinate system based on four points: AC, PC, IRP, and SLA. The resulting structured grid can be written as either a classic VTK file or the new VTK XML file format. Two representations of the resulting grid can be written. The first is a bounding box representation that also contains the location of the AC and PC points. The second representation is the full Talairach grid representation that includes the additional rows of boxes added to the inferior allowing full coverage of the cerebellum.
-# 
-#     version: 0.1
-# 
-#     documentation-url: http://www.nitrc.org/plugins/mwiki/index.php/brains:BRAINSTalairach
-# 
-#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
-# 
-#     contributor: Steven Dunn and Vincent Magnotta
-# 
-#     acknowledgements: Funding for this work was provided by NIH/NINDS award NS050568
-#     
-task_name: BRAINSTalairach
-nipype_name: BRAINSTalairach
-nipype_module: nipype.interfaces.semtools.brains.segmentation
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputVolume: generic/file
-    # type=file|default=<undefined>: Input image used to define physical space of images
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputBox: generic/file
-    # type=file: Name of the resulting Talairach Bounding Box file
-    # type=traitcompound|default=None: Name of the resulting Talairach Bounding Box file
-    outputGrid: generic/file
-    # type=file: Name of the resulting Talairach Grid file
-    # type=traitcompound|default=None: Name of the resulting Talairach Grid file
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    AC:
-    # type=inputmultiobject|default=[]: Location of AC Point 
-    ACisIndex:
-    # type=bool|default=False: AC Point is Index
-    PC:
-    # type=inputmultiobject|default=[]: Location of PC Point 
-    PCisIndex:
-    # type=bool|default=False: PC Point is Index
-    SLA:
-    # type=inputmultiobject|default=[]: Location of SLA Point 
-    SLAisIndex:
-    # type=bool|default=False: SLA Point is Index
-    IRP:
-    # type=inputmultiobject|default=[]: Location of IRP Point 
-    IRPisIndex:
-    # type=bool|default=False: IRP Point is Index
-    inputVolume:
-    # type=file|default=<undefined>: Input image used to define physical space of images
-    outputBox:
-    # type=file: Name of the resulting Talairach Bounding Box file
-    # type=traitcompound|default=None: Name of the resulting Talairach Bounding Box file
-    outputGrid:
-    # type=file: Name of the resulting Talairach Grid file
-    # type=traitcompound|default=None: Name of the resulting Talairach Grid file
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_talairach_callables.py b/example-specs/task/nipype_internal/pydra-semtools/brains_talairach_callables.py
deleted file mode 100644
index c5f88d78..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/brains_talairach_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in BRAINSTalairach.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_talairach_mask.yaml b/example-specs/task/nipype_internal/pydra-semtools/brains_talairach_mask.yaml
deleted file mode 100644
index 230b57c5..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/brains_talairach_mask.yaml
+++ /dev/null
@@ -1,103 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.brains.segmentation.BRAINSTalairachMask' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Talairach Mask
-# 
-#     category: BRAINS.Segmentation
-# 
-#     description: This program creates a binary image representing the specified Talairach region. The input is an example image to define the physical space for the resulting image, the Talairach grid representation in VTK format, and the file containing the Talairach box definitions to be generated. These can be combined in BRAINS to create a label map using the procedure Brains::WorkupUtils::CreateLabelMapFromBinaryImages.
-# 
-#     version: 0.1
-# 
-#     documentation-url: http://www.nitrc.org/plugins/mwiki/index.php/brains:BRAINSTalairachMask
-# 
-#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
-# 
-#     contributor: Steven Dunn and Vincent Magnotta
-# 
-#     acknowledgements: Funding for this work was provided by NIH/NINDS award NS050568
-#     
-task_name: BRAINSTalairachMask
-nipype_name: BRAINSTalairachMask
-nipype_module: nipype.interfaces.semtools.brains.segmentation
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputVolume: generic/file
-    # type=file|default=<undefined>: Input image used to define physical space of resulting mask
-    talairachParameters: generic/file
-    # type=file|default=<undefined>: Name of the Talairach parameter file.
-    talairachBox: generic/file
-    # type=file|default=<undefined>: Name of the Talairach box file.
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputVolume: generic/file
-    # type=file: Output filename for the resulting binary image
-    # type=traitcompound|default=None: Output filename for the resulting binary image
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputVolume:
-    # type=file|default=<undefined>: Input image used to define physical space of resulting mask
-    talairachParameters:
-    # type=file|default=<undefined>: Name of the Talairach parameter file.
-    talairachBox:
-    # type=file|default=<undefined>: Name of the Talairach box file.
-    hemisphereMode:
-    # type=enum|default='left'|allowed['both','left','right']: Mode for box creation: left, right, both
-    expand:
-    # type=bool|default=False: Expand exterior box to include surface CSF
-    outputVolume:
-    # type=file: Output filename for the resulting binary image
-    # type=traitcompound|default=None: Output filename for the resulting binary image
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_talairach_mask_callables.py b/example-specs/task/nipype_internal/pydra-semtools/brains_talairach_mask_callables.py
deleted file mode 100644
index 9e5b751f..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/brains_talairach_mask_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in BRAINSTalairachMask.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_transform_convert.yaml b/example-specs/task/nipype_internal/pydra-semtools/brains_transform_convert.yaml
deleted file mode 100644
index dd05c38e..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/brains_transform_convert.yaml
+++ /dev/null
@@ -1,103 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.utilities.brains.BRAINSTransformConvert' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: BRAINS Transform Convert
-# 
-#     category: Utilities.BRAINS
-# 
-#     description: Convert ITK transforms to higher order transforms
-# 
-#     version: 1.0
-# 
-#     documentation-url: A utility to convert between transform file formats.
-# 
-#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
-# 
-#     contributor: Hans J. Johnson,Kent Williams, Ali Ghayoor
-#     
-task_name: BRAINSTransformConvert
-nipype_name: BRAINSTransformConvert
-nipype_module: nipype.interfaces.semtools.utilities.brains
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputTransform: generic/file
-    # type=file|default=<undefined>: 
-    referenceVolume: generic/file
-    # type=file|default=<undefined>: 
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    displacementVolume: generic/file
-    # type=file: 
-    # type=traitcompound|default=None: 
-    outputTransform: generic/file
-    # type=file: 
-    # type=traitcompound|default=None: 
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputTransform:
-    # type=file|default=<undefined>: 
-    referenceVolume:
-    # type=file|default=<undefined>: 
-    outputTransformType:
-    # type=enum|default='Affine'|allowed['Affine','DisplacementField','Same','ScaleSkewVersor','ScaleVersor','VersorRigid']: The target transformation type. Must be conversion-compatible with the input transform type
-    outputPrecisionType:
-    # type=enum|default='double'|allowed['double','float']: Precision type of the output transform. It can be either single precision or double precision
-    displacementVolume:
-    # type=file: 
-    # type=traitcompound|default=None: 
-    outputTransform:
-    # type=file: 
-    # type=traitcompound|default=None: 
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_transform_convert_callables.py b/example-specs/task/nipype_internal/pydra-semtools/brains_transform_convert_callables.py
deleted file mode 100644
index bd22c4e3..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/brains_transform_convert_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in BRAINSTransformConvert.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_transform_from_fiducials.yaml b/example-specs/task/nipype_internal/pydra-semtools/brains_transform_from_fiducials.yaml
deleted file mode 100644
index 6cab2456..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/brains_transform_from_fiducials.yaml
+++ /dev/null
@@ -1,101 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.registration.specialized.BRAINSTransformFromFiducials' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Fiducial Registration (BRAINS)
-# 
-#     category: Registration.Specialized
-# 
-#     description: Computes a rigid, similarity or affine transform from a matched list of fiducials
-# 
-#     version: 0.1.0.$Revision$
-# 
-#     documentation-url: http://www.slicer.org/slicerWiki/index.php/Modules:TransformFromFiducials-Documentation-3.6
-# 
-#     contributor: Casey B Goodlett
-# 
-#     acknowledgements: This work is part of the National Alliance for Medical Image Computing (NAMIC), funded by the National Institutes of Health through the NIH Roadmap for Medical Research, Grant U54 EB005149.
-#     
-task_name: BRAINSTransformFromFiducials
-nipype_name: BRAINSTransformFromFiducials
-nipype_module: nipype.interfaces.semtools.registration.specialized
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    fixedLandmarksFile: generic/file
-    # type=file|default=<undefined>: An fcsv formatted file with a list of landmark points.
-    movingLandmarksFile: generic/file
-    # type=file|default=<undefined>: An fcsv formatted file with a list of landmark points.
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    saveTransform: generic/file
-    # type=file: Save the transform that results from registration
-    # type=traitcompound|default=None: Save the transform that results from registration
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    fixedLandmarks:
-    # type=inputmultiobject|default=[]: Ordered list of landmarks in the fixed image
-    movingLandmarks:
-    # type=inputmultiobject|default=[]: Ordered list of landmarks in the moving image
-    saveTransform:
-    # type=file: Save the transform that results from registration
-    # type=traitcompound|default=None: Save the transform that results from registration
-    transformType:
-    # type=enum|default='Translation'|allowed['Rigid','Similarity','Translation']: Type of transform to produce
-    fixedLandmarksFile:
-    # type=file|default=<undefined>: An fcsv formatted file with a list of landmark points.
-    movingLandmarksFile:
-    # type=file|default=<undefined>: An fcsv formatted file with a list of landmark points.
-    numberOfThreads:
-    # type=int|default=0: Explicitly specify the maximum number of threads to use.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_transform_from_fiducials_callables.py b/example-specs/task/nipype_internal/pydra-semtools/brains_transform_from_fiducials_callables.py
deleted file mode 100644
index 2f189fd2..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/brains_transform_from_fiducials_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in BRAINSTransformFromFiducials.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_trim_foreground_in_direction.yaml b/example-specs/task/nipype_internal/pydra-semtools/brains_trim_foreground_in_direction.yaml
deleted file mode 100644
index 81da64c6..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/brains_trim_foreground_in_direction.yaml
+++ /dev/null
@@ -1,97 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.utilities.brains.BRAINSTrimForegroundInDirection' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Trim Foreground In Direction (BRAINS)
-# 
-#     category: Utilities.BRAINS
-# 
-#     description: This program will trim off the neck and also air-filling noise from the inputImage.
-# 
-#     version: 0.1
-# 
-#     documentation-url: http://www.nitrc.org/projects/art/
-#     
-task_name: BRAINSTrimForegroundInDirection
-nipype_name: BRAINSTrimForegroundInDirection
-nipype_module: nipype.interfaces.semtools.utilities.brains
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputVolume: generic/file
-    # type=file|default=<undefined>: Input image to trim off the neck (and also air-filling noise.)
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputVolume: generic/file
-    # type=file: Output image with neck and air-filling noise trimmed isotropic image with AC at center of image.
-    # type=traitcompound|default=None: Output image with neck and air-filling noise trimmed isotropic image with AC at center of image.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputVolume:
-    # type=file|default=<undefined>: Input image to trim off the neck (and also air-filling noise.)
-    outputVolume:
-    # type=file: Output image with neck and air-filling noise trimmed isotropic image with AC at center of image.
-    # type=traitcompound|default=None: Output image with neck and air-filling noise trimmed isotropic image with AC at center of image.
-    directionCode:
-    # type=int|default=0: ,                 This flag chooses which dimension to compare.  The sign lets you flip direction.,             
-    otsuPercentileThreshold:
-    # type=float|default=0.0: ,                 This is a parameter to FindLargestForegroundFilledMask, which is employed to trim off air-filling noise.,             
-    closingSize:
-    # type=int|default=0: ,                 This is a parameter to FindLargestForegroundFilledMask,             
-    headSizeLimit:
-    # type=float|default=0.0: ,                 Use this to vary from the command line our search for how much upper tissue is head for the center-of-mass calculation.  Units are CCs, not cubic millimeters.,             
-    BackgroundFillValue:
-    # type=str|default='': Fill the background of image with specified short int value. Enter number or use BIGNEG for a large negative number.
-    numberOfThreads:
-    # type=int|default=0: Explicitly specify the maximum number of threads to use.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brains_trim_foreground_in_direction_callables.py b/example-specs/task/nipype_internal/pydra-semtools/brains_trim_foreground_in_direction_callables.py
deleted file mode 100644
index 78a1bd14..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/brains_trim_foreground_in_direction_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in BRAINSTrimForegroundInDirection.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brainsabc.yaml b/example-specs/task/nipype_internal/pydra-semtools/brainsabc.yaml
deleted file mode 100644
index 2a63237a..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/brainsabc.yaml
+++ /dev/null
@@ -1,167 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.segmentation.specialized.BRAINSABC' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Intra-subject registration, bias Correction, and tissue classification (BRAINS)
-# 
-#     category: Segmentation.Specialized
-# 
-#     description: Atlas-based tissue segmentation method.  This is an algorithmic extension of work done by XXXX at UNC and Utah XXXX need more description here.
-#     
-task_name: BRAINSABC
-nipype_name: BRAINSABC
-nipype_module: nipype.interfaces.semtools.segmentation.specialized
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputVolumes: generic/file+list-of
-    # type=inputmultiobject|default=[]: The list of input image files to be segmented.
-    atlasDefinition: generic/file
-    # type=file|default=<undefined>: Contains all parameters for Atlas
-    restoreState: generic/file
-    # type=file|default=<undefined>: The initial state for the registration process
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    saveState: generic/file
-    # type=file: (optional) Filename to which save the final state of the registration
-    # type=traitcompound|default=None: (optional) Filename to which save the final state of the registration
-    atlasToSubjectTransform: generic/file
-    # type=file: The transform from atlas to the subject
-    # type=traitcompound|default=None: The transform from atlas to the subject
-    atlasToSubjectInitialTransform: generic/file
-    # type=file: The initial transform from atlas to the subject
-    # type=traitcompound|default=None: The initial transform from atlas to the subject
-    outputLabels: generic/file
-    # type=file: Output Label Image
-    # type=traitcompound|default=None: Output Label Image
-    outputDirtyLabels: generic/file
-    # type=file: Output Dirty Label Image
-    # type=traitcompound|default=None: Output Dirty Label Image
-    outputDir: generic/directory
-    # type=directory: Output directory
-    # type=traitcompound|default=None: Output directory
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputVolumes:
-    # type=inputmultiobject|default=[]: The list of input image files to be segmented.
-    atlasDefinition:
-    # type=file|default=<undefined>: Contains all parameters for Atlas
-    restoreState:
-    # type=file|default=<undefined>: The initial state for the registration process
-    saveState:
-    # type=file: (optional) Filename to which save the final state of the registration
-    # type=traitcompound|default=None: (optional) Filename to which save the final state of the registration
-    inputVolumeTypes:
-    # type=inputmultiobject|default=[]: The list of input image types corresponding to the inputVolumes.
-    outputDir:
-    # type=directory: Output directory
-    # type=traitcompound|default=None: Output directory
-    atlasToSubjectTransformType:
-    # type=enum|default='Identity'|allowed['Affine','BSpline','Identity','Rigid','SyN']:  What type of linear transform type do you want to use to register the atlas to the reference subject image.
-    atlasToSubjectTransform:
-    # type=file: The transform from atlas to the subject
-    # type=traitcompound|default=None: The transform from atlas to the subject
-    atlasToSubjectInitialTransform:
-    # type=file: The initial transform from atlas to the subject
-    # type=traitcompound|default=None: The initial transform from atlas to the subject
-    subjectIntermodeTransformType:
-    # type=enum|default='Identity'|allowed['Affine','BSpline','Identity','Rigid']:  What type of linear transform type do you want to use to register the atlas to the reference subject image.
-    outputVolumes:
-    # type=outputmultiobject: Corrected Output Images: should specify the same number of images as inputVolume, if only one element is given, then it is used as a file pattern where %s is replaced by the imageVolumeType, and %d by the index list location.
-    # type=traitcompound|default=[None]: Corrected Output Images: should specify the same number of images as inputVolume, if only one element is given, then it is used as a file pattern where %s is replaced by the imageVolumeType, and %d by the index list location.
-    outputLabels:
-    # type=file: Output Label Image
-    # type=traitcompound|default=None: Output Label Image
-    outputDirtyLabels:
-    # type=file: Output Dirty Label Image
-    # type=traitcompound|default=None: Output Dirty Label Image
-    posteriorTemplate:
-    # type=str|default='': filename template for Posterior output files
-    outputFormat:
-    # type=enum|default='NIFTI'|allowed['Meta','NIFTI','Nrrd']: Output format
-    interpolationMode:
-    # type=enum|default='BSpline'|allowed['BSpline','Blackman','Cosine','Hamming','Lanczos','Linear','NearestNeighbor','ResampleInPlace','Welch','WindowedSinc']: Type of interpolation to be used when applying transform to moving volume.  Options are Linear, NearestNeighbor, BSpline, WindowedSinc, or ResampleInPlace.  The ResampleInPlace option will create an image with the same discrete voxel values and will adjust the origin and direction of the physical space interpretation.
-    maxIterations:
-    # type=int|default=0: Filter iterations
-    medianFilterSize:
-    # type=inputmultiobject|default=[]: The radius for the optional MedianImageFilter preprocessing in all 3 directions.
-    filterIteration:
-    # type=int|default=0: Filter iterations
-    filterTimeStep:
-    # type=float|default=0.0: Filter time step should be less than (PixelSpacing/(1^(DIM+1)), value is set to negative, then allow automatic setting of this value. 
-    filterMethod:
-    # type=enum|default='None'|allowed['CurvatureFlow','GradientAnisotropicDiffusion','Median','None']: Filter method for preprocessing of registration
-    maxBiasDegree:
-    # type=int|default=0: Maximum bias degree
-    useKNN:
-    # type=bool|default=False: Use the KNN stage of estimating posteriors.
-    purePlugsThreshold:
-    # type=float|default=0.0: If this threshold value is greater than zero, only pure samples are used to compute the distributions in EM classification, and only pure samples are used for KNN training. The default value is set to 0, that means not using pure plugs. However, a value of 0.2 is suggested if you want to activate using pure plugs option.
-    numberOfSubSamplesInEachPlugArea:
-    # type=inputmultiobject|default=[]: Number of continuous index samples taken at each direction of lattice space for each plug volume.
-    atlasWarpingOff:
-    # type=bool|default=False: Deformable registration of atlas to subject
-    gridSize:
-    # type=inputmultiobject|default=[]: Grid size for atlas warping with BSplines
-    defaultSuffix:
-    # type=str|default='': 
-    implicitOutputs:
-    # type=outputmultiobject: Outputs to be made available to NiPype. Needed because not all BRAINSABC outputs have command line arguments.
-    # type=traitcompound|default=[None]: Outputs to be made available to NiPype. Needed because not all BRAINSABC outputs have command line arguments.
-    debuglevel:
-    # type=int|default=0: Display debug messages, and produce debug intermediate results.  0=OFF, 1=Minimal, 10=Maximum debugging.
-    writeLess:
-    # type=bool|default=False: Does not write posteriors and filtered, bias corrected images
-    numberOfThreads:
-    # type=int|default=0: Explicitly specify the maximum number of threads to use.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brainsabc_callables.py b/example-specs/task/nipype_internal/pydra-semtools/brainsabc_callables.py
deleted file mode 100644
index c7eba2e0..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/brainsabc_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in BRAINSABC.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brainsroi_auto.yaml b/example-specs/task/nipype_internal/pydra-semtools/brainsroi_auto.yaml
deleted file mode 100644
index dc81ec25..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/brainsroi_auto.yaml
+++ /dev/null
@@ -1,111 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.segmentation.specialized.BRAINSROIAuto' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Foreground masking (BRAINS)
-# 
-#     category: Segmentation.Specialized
-# 
-#     description: This program is used to create a mask over the most prominent foreground region in an image.  This is accomplished via a combination of otsu thresholding and a closing operation.  More documentation is available here: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/ForegroundMasking.
-# 
-#     version: 2.4.1
-# 
-#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
-# 
-#     contributor: Hans J. Johnson, hans-johnson -at- uiowa.edu, http://www.psychiatry.uiowa.edu
-# 
-#     acknowledgements: Hans Johnson(1,3,4); Kent Williams(1); Gregory Harris(1), Vincent Magnotta(1,2,3);  Andriy Fedorov(5), fedorov -at- bwh.harvard.edu (Slicer integration); (1=University of Iowa Department of Psychiatry, 2=University of Iowa Department of Radiology, 3=University of Iowa Department of Biomedical Engineering, 4=University of Iowa Department of Electrical and Computer Engineering, 5=Surgical Planning Lab, Harvard)
-#     
-task_name: BRAINSROIAuto
-nipype_name: BRAINSROIAuto
-nipype_module: nipype.interfaces.semtools.segmentation.specialized
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputVolume: generic/file
-    # type=file|default=<undefined>: The input image for finding the largest region filled mask.
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputROIMaskVolume: generic/file
-    # type=file: The ROI automatically found from the input image.
-    # type=traitcompound|default=None: The ROI automatically found from the input image.
-    outputVolume: generic/file
-    # type=file: The inputVolume with optional [maskOutput|cropOutput] to the region of the brain mask.
-    # type=traitcompound|default=None: The inputVolume with optional [maskOutput|cropOutput] to the region of the brain mask.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputVolume:
-    # type=file|default=<undefined>: The input image for finding the largest region filled mask.
-    outputROIMaskVolume:
-    # type=file: The ROI automatically found from the input image.
-    # type=traitcompound|default=None: The ROI automatically found from the input image.
-    outputVolume:
-    # type=file: The inputVolume with optional [maskOutput|cropOutput] to the region of the brain mask.
-    # type=traitcompound|default=None: The inputVolume with optional [maskOutput|cropOutput] to the region of the brain mask.
-    maskOutput:
-    # type=bool|default=False: The inputVolume multiplied by the ROI mask.
-    cropOutput:
-    # type=bool|default=False: The inputVolume cropped to the region of the ROI mask.
-    otsuPercentileThreshold:
-    # type=float|default=0.0: Parameter to the Otsu threshold algorithm.
-    thresholdCorrectionFactor:
-    # type=float|default=0.0: A factor to scale the Otsu algorithm's result threshold, in case clipping mangles the image.
-    closingSize:
-    # type=float|default=0.0: The Closing Size (in millimeters) for largest connected filled mask.  This value is divided by image spacing and rounded to the next largest voxel number.
-    ROIAutoDilateSize:
-    # type=float|default=0.0: This flag is only relevant when using ROIAUTO mode for initializing masks.  It defines the final dilation size to capture a bit of background outside the tissue region.  At setting of 10mm has been shown to help regularize a BSpline registration type so that there is some background constraints to match the edges of the head better.
-    outputVolumePixelType:
-    # type=enum|default='float'|allowed['float','int','short','uchar','uint','ushort']: The output image Pixel Type is the scalar datatype for representation of the Output Volume.
-    numberOfThreads:
-    # type=int|default=0: Explicitly specify the maximum number of threads to use.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/brainsroi_auto_callables.py b/example-specs/task/nipype_internal/pydra-semtools/brainsroi_auto_callables.py
deleted file mode 100644
index 421d7dbf..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/brainsroi_auto_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in BRAINSROIAuto.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/canny_edge.yaml b/example-specs/task/nipype_internal/pydra-semtools/canny_edge.yaml
deleted file mode 100644
index c590bb18..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/canny_edge.yaml
+++ /dev/null
@@ -1,95 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.filtering.featuredetection.CannyEdge' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Canny Edge Detection
-# 
-#     category: Filtering.FeatureDetection
-# 
-#     description: Get the distance from a voxel to the nearest voxel of a given tissue type.
-# 
-#     version: 0.1.0.(alpha)
-# 
-#     documentation-url: http:://www.na-mic.org/
-# 
-#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
-# 
-#     contributor: This tool was written by Hans J. Johnson.
-#     
-task_name: CannyEdge
-nipype_name: CannyEdge
-nipype_module: nipype.interfaces.semtools.filtering.featuredetection
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputVolume: generic/file
-    # type=file|default=<undefined>: Required: input tissue label image
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputVolume: generic/file
-    # type=file: Required: output image
-    # type=traitcompound|default=None: Required: output image
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputVolume:
-    # type=file|default=<undefined>: Required: input tissue label image
-    variance:
-    # type=float|default=0.0: Variance and Maximum error are used in the Gaussian smoothing of the input image.  See  itkDiscreteGaussianImageFilter for information on these parameters.
-    upperThreshold:
-    # type=float|default=0.0: Threshold is the lowest allowed value in the output image.  Its data type is the same as the data type of the output image. Any values below the Threshold level will be replaced with the OutsideValue parameter value, whose default is zero.  
-    lowerThreshold:
-    # type=float|default=0.0: Threshold is the lowest allowed value in the output image.  Its data type is the same as the data type of the output image. Any values below the Threshold level will be replaced with the OutsideValue parameter value, whose default is zero.  
-    outputVolume:
-    # type=file: Required: output image
-    # type=traitcompound|default=None: Required: output image
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/canny_edge_callables.py b/example-specs/task/nipype_internal/pydra-semtools/canny_edge_callables.py
deleted file mode 100644
index 5bd76b55..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/canny_edge_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in CannyEdge.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/canny_segmentation_level_set_image_filter.yaml b/example-specs/task/nipype_internal/pydra-semtools/canny_segmentation_level_set_image_filter.yaml
deleted file mode 100644
index d062b252..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/canny_segmentation_level_set_image_filter.yaml
+++ /dev/null
@@ -1,109 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.filtering.featuredetection.CannySegmentationLevelSetImageFilter' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Canny Level Set Image Filter
-# 
-#     category: Filtering.FeatureDetection
-# 
-#     description: The CannySegmentationLevelSet is commonly used to refine a manually generated manual mask.
-# 
-#     version: 0.3.0
-# 
-#     license: CC
-# 
-#     contributor: Regina Kim
-# 
-#     acknowledgements: This command module was derived from Insight/Examples/Segmentation/CannySegmentationLevelSetImageFilter.cxx (copyright) Insight Software Consortium.  See http://wiki.na-mic.org/Wiki/index.php/Slicer3:Execution_Model_Documentation for more detailed descriptions.
-#     
-task_name: CannySegmentationLevelSetImageFilter
-nipype_name: CannySegmentationLevelSetImageFilter
-nipype_module: nipype.interfaces.semtools.filtering.featuredetection
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputVolume: generic/file
-    # type=file|default=<undefined>: 
-    initialModel: generic/file
-    # type=file|default=<undefined>: 
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputVolume: generic/file
-    # type=file: 
-    # type=traitcompound|default=None: 
-    outputSpeedVolume: generic/file
-    # type=file: 
-    # type=traitcompound|default=None: 
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputVolume:
-    # type=file|default=<undefined>: 
-    initialModel:
-    # type=file|default=<undefined>: 
-    outputVolume:
-    # type=file: 
-    # type=traitcompound|default=None: 
-    outputSpeedVolume:
-    # type=file: 
-    # type=traitcompound|default=None: 
-    cannyThreshold:
-    # type=float|default=0.0: Canny Threshold Value
-    cannyVariance:
-    # type=float|default=0.0: Canny variance
-    advectionWeight:
-    # type=float|default=0.0: Controls the smoothness of the resulting mask, small number are more smooth, large numbers allow more sharp corners.  
-    initialModelIsovalue:
-    # type=float|default=0.0: The identification of the input model iso-surface.  (for a binary image with 0s and 1s use 0.5) (for a binary image with 0s and 255's use 127.5).
-    maxIterations:
-    # type=int|default=0: The
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/canny_segmentation_level_set_image_filter_callables.py b/example-specs/task/nipype_internal/pydra-semtools/canny_segmentation_level_set_image_filter_callables.py
deleted file mode 100644
index 35463ffb..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/canny_segmentation_level_set_image_filter_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in CannySegmentationLevelSetImageFilter.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/clean_up_overlap_labels.yaml b/example-specs/task/nipype_internal/pydra-semtools/clean_up_overlap_labels.yaml
deleted file mode 100644
index cf31bb7e..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/clean_up_overlap_labels.yaml
+++ /dev/null
@@ -1,82 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.utilities.brains.CleanUpOverlapLabels' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Clean Up Overla Labels
-# 
-#     category: Utilities.BRAINS
-# 
-#     description: Take a series of input binary images and clean up for those overlapped area. Binary volumes given first always wins out
-# 
-#     version: 0.1.0
-# 
-#     contributor: Eun Young Kim
-#     
-task_name: CleanUpOverlapLabels
-nipype_name: CleanUpOverlapLabels
-nipype_module: nipype.interfaces.semtools.utilities.brains
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputBinaryVolumes: generic/file+list-of
-    # type=inputmultiobject|default=[]: The list of binary images to be checked and cleaned up. Order is important. Binary volume given first always wins out. 
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputBinaryVolumes:
-    # type=inputmultiobject|default=[]: The list of binary images to be checked and cleaned up. Order is important. Binary volume given first always wins out. 
-    outputBinaryVolumes:
-    # type=outputmultiobject: The output label map images, with integer values in it. Each label value specified in the inputLabels is combined into this output label map volume
-    # type=traitcompound|default=[None]: The output label map images, with integer values in it. Each label value specified in the inputLabels is combined into this output label map volume
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/clean_up_overlap_labels_callables.py b/example-specs/task/nipype_internal/pydra-semtools/clean_up_overlap_labels_callables.py
deleted file mode 100644
index 6917490b..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/clean_up_overlap_labels_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in CleanUpOverlapLabels.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/compare_tract_inclusion.yaml b/example-specs/task/nipype_internal/pydra-semtools/compare_tract_inclusion.yaml
deleted file mode 100644
index 9899513e..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/compare_tract_inclusion.yaml
+++ /dev/null
@@ -1,101 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.diffusion.gtract.compareTractInclusion' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Compare Tracts
-# 
-#     category: Diffusion.GTRACT
-# 
-#     description: This program will halt with a status code indicating whether a test tract is nearly enough included in a standard tract in the sense that every fiber in the test tract has a low enough sum of squares distance to some fiber in the standard tract modulo spline resampling of every fiber to a fixed number of points.
-# 
-#     version: 4.0.0
-# 
-#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Modules:GTRACT
-# 
-#     license: http://mri.radiology.uiowa.edu/copyright/GTRACT-Copyright.txt
-# 
-#     contributor: This tool was developed by Vincent Magnotta and Greg Harris.
-# 
-#     acknowledgements: Funding for this version of the GTRACT program was provided by NIH/NINDS R01NS050568-01A2S1
-#     
-task_name: compareTractInclusion
-nipype_name: compareTractInclusion
-nipype_module: nipype.interfaces.semtools.diffusion.gtract
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    testFiber: generic/file
-    # type=file|default=<undefined>: Required: test fiber tract file name
-    standardFiber: generic/file
-    # type=file|default=<undefined>: Required: standard fiber tract file name
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    testFiber:
-    # type=file|default=<undefined>: Required: test fiber tract file name
-    standardFiber:
-    # type=file|default=<undefined>: Required: standard fiber tract file name
-    closeness:
-    # type=float|default=0.0: Closeness of every test fiber to some fiber in the standard tract, computed as a sum of squares of spatial differences of standard points
-    numberOfPoints:
-    # type=int|default=0: Number of points in comparison fiber pairs
-    testForBijection:
-    # type=bool|default=False: Flag to apply the closeness criterion both ways
-    testForFiberCardinality:
-    # type=bool|default=False: Flag to require the same number of fibers in both tracts
-    writeXMLPolyDataFile:
-    # type=bool|default=False: Flag to make use of XML files when reading and writing vtkPolyData.
-    numberOfThreads:
-    # type=int|default=0: Explicitly specify the maximum number of threads to use.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/compare_tract_inclusion_callables.py b/example-specs/task/nipype_internal/pydra-semtools/compare_tract_inclusion_callables.py
deleted file mode 100644
index caa7221e..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/compare_tract_inclusion_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in compareTractInclusion.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/dilate_image.yaml b/example-specs/task/nipype_internal/pydra-semtools/dilate_image.yaml
deleted file mode 100644
index 7d27ffa6..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/dilate_image.yaml
+++ /dev/null
@@ -1,95 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.filtering.featuredetection.DilateImage' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Dilate Image
-# 
-#     category: Filtering.FeatureDetection
-# 
-#     description: Uses mathematical morphology to dilate the input images.
-# 
-#     version: 0.1.0.$Revision: 1 $(alpha)
-# 
-#     documentation-url: http:://www.na-mic.org/
-# 
-#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
-# 
-#     contributor: This tool was developed by Mark Scully and Jeremy Bockholt.
-#     
-task_name: DilateImage
-nipype_name: DilateImage
-nipype_module: nipype.interfaces.semtools.filtering.featuredetection
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputVolume: generic/file
-    # type=file|default=<undefined>: Required: input image
-    inputMaskVolume: generic/file
-    # type=file|default=<undefined>: Required: input brain mask image
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputVolume: generic/file
-    # type=file: Required: output image
-    # type=traitcompound|default=None: Required: output image
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputVolume:
-    # type=file|default=<undefined>: Required: input image
-    inputMaskVolume:
-    # type=file|default=<undefined>: Required: input brain mask image
-    inputRadius:
-    # type=int|default=0: Required: input neighborhood radius
-    outputVolume:
-    # type=file: Required: output image
-    # type=traitcompound|default=None: Required: output image
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/dilate_image_callables.py b/example-specs/task/nipype_internal/pydra-semtools/dilate_image_callables.py
deleted file mode 100644
index a27b1b06..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/dilate_image_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in DilateImage.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/dilate_mask.yaml b/example-specs/task/nipype_internal/pydra-semtools/dilate_mask.yaml
deleted file mode 100644
index 76072602..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/dilate_mask.yaml
+++ /dev/null
@@ -1,97 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.filtering.featuredetection.DilateMask' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Dilate Image
-# 
-#     category: Filtering.FeatureDetection
-# 
-#     description: Uses mathematical morphology to dilate the input images.
-# 
-#     version: 0.1.0.$Revision: 1 $(alpha)
-# 
-#     documentation-url: http:://www.na-mic.org/
-# 
-#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
-# 
-#     contributor: This tool was developed by Mark Scully and Jeremy Bockholt.
-#     
-task_name: DilateMask
-nipype_name: DilateMask
-nipype_module: nipype.interfaces.semtools.filtering.featuredetection
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputVolume: generic/file
-    # type=file|default=<undefined>: Required: input image
-    inputBinaryVolume: generic/file
-    # type=file|default=<undefined>: Required: input brain mask image
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputVolume: generic/file
-    # type=file: Required: output image
-    # type=traitcompound|default=None: Required: output image
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputVolume:
-    # type=file|default=<undefined>: Required: input image
-    inputBinaryVolume:
-    # type=file|default=<undefined>: Required: input brain mask image
-    sizeStructuralElement:
-    # type=int|default=0: size of structural element. sizeStructuralElement=1 means that 3x3x3 structuring element for 3D
-    lowerThreshold:
-    # type=float|default=0.0: Required: lowerThreshold value
-    outputVolume:
-    # type=file: Required: output image
-    # type=traitcompound|default=None: Required: output image
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/dilate_mask_callables.py b/example-specs/task/nipype_internal/pydra-semtools/dilate_mask_callables.py
deleted file mode 100644
index 1978f15a..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/dilate_mask_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in DilateMask.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/distance_maps.yaml b/example-specs/task/nipype_internal/pydra-semtools/distance_maps.yaml
deleted file mode 100644
index c36599bd..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/distance_maps.yaml
+++ /dev/null
@@ -1,95 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.filtering.featuredetection.DistanceMaps' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Mauerer Distance
-# 
-#     category: Filtering.FeatureDetection
-# 
-#     description: Get the distance from a voxel to the nearest voxel of a given tissue type.
-# 
-#     version: 0.1.0.$Revision: 1 $(alpha)
-# 
-#     documentation-url: http:://www.na-mic.org/
-# 
-#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
-# 
-#     contributor: This tool was developed by Mark Scully and Jeremy Bockholt.
-#     
-task_name: DistanceMaps
-nipype_name: DistanceMaps
-nipype_module: nipype.interfaces.semtools.filtering.featuredetection
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputLabelVolume: generic/file
-    # type=file|default=<undefined>: Required: input tissue label image
-    inputMaskVolume: generic/file
-    # type=file|default=<undefined>: Required: input brain mask image
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputVolume: generic/file
-    # type=file: Required: output image
-    # type=traitcompound|default=None: Required: output image
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputLabelVolume:
-    # type=file|default=<undefined>: Required: input tissue label image
-    inputMaskVolume:
-    # type=file|default=<undefined>: Required: input brain mask image
-    inputTissueLabel:
-    # type=int|default=0: Required: input integer value of tissue type used to calculate distance
-    outputVolume:
-    # type=file: Required: output image
-    # type=traitcompound|default=None: Required: output image
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/distance_maps_callables.py b/example-specs/task/nipype_internal/pydra-semtools/distance_maps_callables.py
deleted file mode 100644
index 2090b380..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/distance_maps_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in DistanceMaps.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/dtiaverage.yaml b/example-specs/task/nipype_internal/pydra-semtools/dtiaverage.yaml
deleted file mode 100644
index a8a085f6..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/dtiaverage.yaml
+++ /dev/null
@@ -1,98 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.diffusion.diffusion.dtiaverage' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: DTIAverage (DTIProcess)
-# 
-#     category: Diffusion.Diffusion Tensor Images.CommandLineOnly
-# 
-#     description: dtiaverage is a program that allows to compute the average of an arbitrary number of tensor fields (listed after the --inputs option) This program is used in our pipeline as the last step of the atlas building processing. When all the tensor fields have been deformed in the same space, to create the average tensor field (--tensor_output) we use dtiaverage.
-#      Several average method can be used (specified by the --method option): euclidean, log-euclidean and pga. The default being euclidean.
-# 
-#     version: 1.0.0
-# 
-#     documentation-url: http://www.slicer.org/slicerWiki/index.php/Documentation/Nightly/Extensions/DTIProcess
-# 
-#     license: Copyright (c)  Casey Goodlett. All rights reserved.
-#         See http://www.ia.unc.edu/dev/Copyright.htm for details.
-#         This software is distributed WITHOUT ANY WARRANTY; without even
-#         the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-#         PURPOSE.  See the above copyright notices for more information.
-# 
-#     contributor: Casey Goodlett
-#     
-task_name: dtiaverage
-nipype_name: dtiaverage
-nipype_module: nipype.interfaces.semtools.diffusion.diffusion
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputs: generic/file+list-of
-    # type=inputmultiobject|default=[]: List of all the tensor fields to be averaged
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    tensor_output: generic/file
-    # type=file: Averaged tensor volume
-    # type=traitcompound|default=None: Averaged tensor volume
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputs:
-    # type=inputmultiobject|default=[]: List of all the tensor fields to be averaged
-    tensor_output:
-    # type=file: Averaged tensor volume
-    # type=traitcompound|default=None: Averaged tensor volume
-    DTI_double:
-    # type=bool|default=False: Tensor components are saved as doubles (cannot be visualized in Slicer)
-    verbose:
-    # type=bool|default=False: produce verbose output
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/dtiaverage_callables.py b/example-specs/task/nipype_internal/pydra-semtools/dtiaverage_callables.py
deleted file mode 100644
index 010db5d5..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/dtiaverage_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in dtiaverage.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/dtiestim.yaml b/example-specs/task/nipype_internal/pydra-semtools/dtiestim.yaml
deleted file mode 100644
index e3cb8dee..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/dtiestim.yaml
+++ /dev/null
@@ -1,163 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.diffusion.diffusion.dtiestim' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: DTIEstim (DTIProcess)
-# 
-#     category: Diffusion.Diffusion Weighted Images
-# 
-#     description: dtiestim is a tool that takes in a set of DWIs (with --dwi_image option) in nrrd format and estimates a tensor field out of it. The output tensor file name is specified with the --tensor_output option
-#     There are several methods to estimate the tensors which you can specify with the option --method lls|wls|nls|ml . Here is a short description of the different methods:
-# 
-#     lls
-#           Linear least squares. Standard estimation technique that recovers the tensor parameters by multiplying the log of the normalized signal intensities by the pseudo-inverse of the gradient matrix. Default option.
-# 
-#     wls
-#         Weighted least squares. This method is similar to the linear least squares method except that the gradient matrix is weighted by the original lls estimate. (See Salvador, R., Pena, A., Menon, D. K., Carpenter, T. A., Pickard, J. D., and Bullmore, E. T. Formal characterization and extension of the linearized diffusion tensor model. Human Brain Mapping 24, 2 (Feb. 2005), 144-155. for more information on this method). This method is recommended for most applications. The weight for each iteration can be specified with the --weight_iterations.  It is not currently the default due to occasional matrix singularities.
-#     nls
-#         Non-linear least squares. This method does not take the log of the signal and requires an optimization based on levenberg-marquadt to optimize the parameters of the signal. The lls estimate is used as an initialization. For this method the step size can be specified with the --step option.
-#     ml
-#         Maximum likelihood estimation. This method is experimental and is not currently recommended. For this ml method the sigma can be specified with the option --sigma and the step size can be specified with the --step option.
-# 
-#     You can set a threshold (--threshold) to have the tensor estimated to only a subset of voxels. All the baseline voxel value higher than the threshold define the voxels where the tensors are computed. If not specified the threshold is calculated using an OTSU threshold on the baseline image.The masked generated by the -t option or by the otsu value can be saved with the --B0_mask_output option.
-# 
-#     dtiestim also can extract a few scalar images out of the DWI set of images:
-# 
-#             - the average baseline image (--B0) which is the average of all the B0s.
-#             - the IDWI (--idwi)which is the geometric mean of the diffusion images.
-# 
-#     You can also load a mask if you want to compute the tensors only where the voxels are non-zero (--brain_mask) or a negative mask and the tensors will be estimated where the negative mask has zero values (--bad_region_mask)
-# 
-#     version: 1.2.0
-# 
-#     documentation-url: http://www.slicer.org/slicerWiki/index.php/Documentation/Nightly/Extensions/DTIProcess
-# 
-#     license: Copyright (c)  Casey Goodlett. All rights reserved.
-#       See http://www.ia.unc.edu/dev/Copyright.htm for details.
-#          This software is distributed WITHOUT ANY WARRANTY; without even
-#          the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-#          PURPOSE.  See the above copyright notices for more information.
-# 
-#     contributor: Casey Goodlett, Francois Budin
-# 
-#     acknowledgements: Hans Johnson(1,3,4); Kent Williams(1); (1=University of Iowa Department of Psychiatry, 3=University of Iowa Department of Biomedical Engineering, 4=University of Iowa Department of Electrical and Computer Engineering) provided conversions to make DTIProcess compatible with Slicer execution, and simplified the stand-alone build requirements by removing the dependencies on boost and a fortran compiler.
-#     
-task_name: dtiestim
-nipype_name: dtiestim
-nipype_module: nipype.interfaces.semtools.diffusion.diffusion
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    dwi_image: generic/file
-    # type=file|default=<undefined>: DWI image volume (required)
-    brain_mask: generic/file
-    # type=file|default=<undefined>: Brain mask.  Image where for every voxel == 0 the tensors are not estimated. Be aware that in addition a threshold based masking will be performed by default. If such an additional threshold masking is NOT desired, then use option -t 0.
-    bad_region_mask: generic/file
-    # type=file|default=<undefined>: Bad region mask.  Image where for every voxel > 0 the tensors are not estimated
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    tensor_output: generic/file
-    # type=file: Tensor OutputImage
-    # type=traitcompound|default=None: Tensor OutputImage
-    B0: generic/file
-    # type=file: Baseline image, average of all baseline images
-    # type=traitcompound|default=None: Baseline image, average of all baseline images
-    idwi: generic/file
-    # type=file: idwi output image. Image with isotropic diffusion-weighted information = geometric mean of diffusion images
-    # type=traitcompound|default=None: idwi output image. Image with isotropic diffusion-weighted information = geometric mean of diffusion images
-    B0_mask_output: generic/file
-    # type=file: B0 mask used for the estimation. B0 thresholded either with the -t option value or the automatic OTSU value
-    # type=traitcompound|default=None: B0 mask used for the estimation. B0 thresholded either with the -t option value or the automatic OTSU value
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    dwi_image:
-    # type=file|default=<undefined>: DWI image volume (required)
-    tensor_output:
-    # type=file: Tensor OutputImage
-    # type=traitcompound|default=None: Tensor OutputImage
-    B0:
-    # type=file: Baseline image, average of all baseline images
-    # type=traitcompound|default=None: Baseline image, average of all baseline images
-    idwi:
-    # type=file: idwi output image. Image with isotropic diffusion-weighted information = geometric mean of diffusion images
-    # type=traitcompound|default=None: idwi output image. Image with isotropic diffusion-weighted information = geometric mean of diffusion images
-    B0_mask_output:
-    # type=file: B0 mask used for the estimation. B0 thresholded either with the -t option value or the automatic OTSU value
-    # type=traitcompound|default=None: B0 mask used for the estimation. B0 thresholded either with the -t option value or the automatic OTSU value
-    brain_mask:
-    # type=file|default=<undefined>: Brain mask.  Image where for every voxel == 0 the tensors are not estimated. Be aware that in addition a threshold based masking will be performed by default. If such an additional threshold masking is NOT desired, then use option -t 0.
-    bad_region_mask:
-    # type=file|default=<undefined>: Bad region mask.  Image where for every voxel > 0 the tensors are not estimated
-    method:
-    # type=enum|default='lls'|allowed['lls','ml','nls','wls']: Estimation method (lls:linear least squares, wls:weighted least squares, nls:non-linear least squares, ml:maximum likelihood)
-    correction:
-    # type=enum|default='none'|allowed['abs','nearest','none','zero']: Correct the tensors if computed tensor is not semi-definite positive
-    threshold:
-    # type=int|default=0: Baseline threshold for estimation. If not specified calculated using an OTSU threshold on the baseline image.
-    weight_iterations:
-    # type=int|default=0: Number of iterations to recaluate weightings from tensor estimate
-    step:
-    # type=float|default=0.0: Gradient descent step size (for nls and ml methods)
-    sigma:
-    # type=float|default=0.0: 
-    DTI_double:
-    # type=bool|default=False: Tensor components are saved as doubles (cannot be visualized in Slicer)
-    verbose:
-    # type=bool|default=False: produce verbose output
-    defaultTensor:
-    # type=inputmultiobject|default=[]: Default tensor used if estimated tensor is below a given threshold
-    shiftNeg:
-    # type=bool|default=False: Shift eigenvalues so all are positive (accounts for bad tensors related to noise or acquisition error). This is the same option as the one available in DWIToDTIEstimation in Slicer (but instead of just adding the minimum eigenvalue to all the eigenvalues if it is smaller than 0, we use a coefficient to have stictly positive eigenvalues
-    shiftNegCoeff:
-    # type=float|default=0.0: Shift eigenvalues so all are positive (accounts for bad tensors related to noise or acquisition error). Instead of just adding the minimum eigenvalue to all the eigenvalues if it is smaller than 0, we use a coefficient to have stictly positive eigenvalues. Coefficient must be between 1.0 and 1.001 (included).
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/dtiestim_callables.py b/example-specs/task/nipype_internal/pydra-semtools/dtiestim_callables.py
deleted file mode 100644
index a4d8741b..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/dtiestim_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in dtiestim.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/dtiprocess.yaml b/example-specs/task/nipype_internal/pydra-semtools/dtiprocess.yaml
deleted file mode 100644
index f573cecd..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/dtiprocess.yaml
+++ /dev/null
@@ -1,225 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.diffusion.diffusion.dtiprocess' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: DTIProcess (DTIProcess)
-# 
-#     category: Diffusion.Diffusion Tensor Images
-# 
-#     description: dtiprocess is a tool that handles tensor fields. It takes as an input a tensor field in nrrd format.
-#     It can generate diffusion scalar properties out of the tensor field such as : FA (--fa_output), Gradient FA image (--fa_gradient_output), color FA (--color_fa_output), MD (--md_output), Frobenius norm (--frobenius_norm_output), lbd1, lbd2, lbd3 (--lambda{1,2,3}_output), binary map of voxel where if any of the eigenvalue is negative, the voxel is set to 1 (--negative_eigenvector_output)
-# 
-#     It also creates 4D images out of the tensor field such as: Highest eigenvector map (highest eigenvector at each voxel) (--principal_eigenvector_output)
-# 
-#     Masking capabilities: For any of the processing done with dtiprocess, it's possible to apply it on a masked region of the tensor field. You need to use the --mask option for any of the option to be applied on that tensor field sub-region only. If you want to save the masked tensor field use the option --outmask and specify the new masked tensor field file name.
-#     dtiprocess also allows a range of transformations on the tensor fields. The transformed tensor field file name is specified with the option --deformation_output. There are 3 resampling interpolation methods specified with the tag --interpolation followed by the type to use (nearestneighbor, linear, cubic) Then you have several transformations possible to apply:
-# 
-#             - Affine transformations using as an input
-#             - itk affine transformation file (based on the itkAffineTransform class)
-#             - Affine transformations using rview (details and download at http://www.doc.ic.ac.uk/~dr/software/). There are 2 versions of rview both creating transformation files called dof files. The old version of rview outputs text files containing the transformation parameters. It can be read in with the --dof_file option. The new version outputs binary dof files. These dof files can be transformed into human readable file with the dof2mat tool which is part of the rview package. So you need to save the output of dof2mat into a text file which can then be used with the -- newdof_file option. Usage example: dof2mat mynewdoffile.dof >> mynewdoffile.txt       dtiprocess --dti_image mytensorfield.nhdr --newdof_file mynewdoffile.txt --rot_output myaffinetensorfield.nhdr
-# 
-#     Non linear transformations as an input: The default transformation file type is d-field (displacement field) in nrrd format. The option to use is --forward with the name of the file. If the transformation file is a h-field you have to add the option --hField.
-# 
-#     version: 1.0.1
-# 
-#     documentation-url: http://www.slicer.org/slicerWiki/index.php/Documentation/Nightly/Extensions/DTIProcess
-# 
-#     license: Copyright (c)  Casey Goodlett. All rights reserved.
-#       See http://www.ia.unc.edu/dev/Copyright.htm for details.
-#          This software is distributed WITHOUT ANY WARRANTY; without even
-#          the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-#          PURPOSE.  See the above copyright notices for more information.
-# 
-#     contributor: Casey Goodlett
-#     
-task_name: dtiprocess
-nipype_name: dtiprocess
-nipype_module: nipype.interfaces.semtools.diffusion.diffusion
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    dti_image: generic/file
-    # type=file|default=<undefined>: DTI tensor volume
-    affineitk_file: generic/file
-    # type=file|default=<undefined>: Transformation file for affine transformation.  ITK format.
-    dof_file: generic/file
-    # type=file|default=<undefined>: Transformation file for affine transformation.  This can be ITK format (or the outdated RView).
-    newdof_file: generic/file
-    # type=file|default=<undefined>: Transformation file for affine transformation.  RView NEW format. (txt file output of dof2mat)
-    mask: generic/file
-    # type=file|default=<undefined>: Mask tensors. Specify --outmask if you want to save the masked tensor field, otherwise the mask is applied just for the current processing 
-    forward: generic/file
-    # type=file|default=<undefined>: Forward transformation.  Assumed to be a deformation field in world coordinates, unless the --h-field option is specified.
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    fa_output: generic/file
-    # type=file: Fractional Anisotropy output file
-    # type=traitcompound|default=None: Fractional Anisotropy output file
-    md_output: generic/file
-    # type=file: Mean Diffusivity output file
-    # type=traitcompound|default=None: Mean Diffusivity output file
-    fa_gradient_output: generic/file
-    # type=file: Fractional Anisotropy Gradient output file
-    # type=traitcompound|default=None: Fractional Anisotropy Gradient output file
-    fa_gradmag_output: generic/file
-    # type=file: Fractional Anisotropy Gradient Magnitude output file
-    # type=traitcompound|default=None: Fractional Anisotropy Gradient Magnitude output file
-    color_fa_output: generic/file
-    # type=file: Color Fractional Anisotropy output file
-    # type=traitcompound|default=None: Color Fractional Anisotropy output file
-    principal_eigenvector_output: generic/file
-    # type=file: Principal Eigenvectors Output
-    # type=traitcompound|default=None: Principal Eigenvectors Output
-    negative_eigenvector_output: generic/file
-    # type=file: Negative Eigenvectors Output: create a binary image where if any of the eigen value is below zero, the voxel is set to 1, otherwise 0.
-    # type=traitcompound|default=None: Negative Eigenvectors Output: create a binary image where if any of the eigen value is below zero, the voxel is set to 1, otherwise 0.
-    frobenius_norm_output: generic/file
-    # type=file: Frobenius Norm Output
-    # type=traitcompound|default=None: Frobenius Norm Output
-    lambda1_output: generic/file
-    # type=file: Axial Diffusivity - Lambda 1 (largest eigenvalue) output
-    # type=traitcompound|default=None: Axial Diffusivity - Lambda 1 (largest eigenvalue) output
-    lambda2_output: generic/file
-    # type=file: Lambda 2 (middle eigenvalue) output
-    # type=traitcompound|default=None: Lambda 2 (middle eigenvalue) output
-    lambda3_output: generic/file
-    # type=file: Lambda 3 (smallest eigenvalue) output
-    # type=traitcompound|default=None: Lambda 3 (smallest eigenvalue) output
-    RD_output: generic/file
-    # type=file: RD (Radial Diffusivity 1/2*(lambda2+lambda3)) output
-    # type=traitcompound|default=None: RD (Radial Diffusivity 1/2*(lambda2+lambda3)) output
-    rot_output: generic/file
-    # type=file: Rotated tensor output file.  Must also specify the dof file.
-    # type=traitcompound|default=None: Rotated tensor output file.  Must also specify the dof file.
-    outmask: generic/file
-    # type=file: Name of the masked tensor field.
-    # type=traitcompound|default=None: Name of the masked tensor field.
-    deformation_output: generic/file
-    # type=file: Warped tensor field based on a deformation field.  This option requires the --forward,-F transformation to be specified.
-    # type=traitcompound|default=None: Warped tensor field based on a deformation field.  This option requires the --forward,-F transformation to be specified.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    dti_image:
-    # type=file|default=<undefined>: DTI tensor volume
-    fa_output:
-    # type=file: Fractional Anisotropy output file
-    # type=traitcompound|default=None: Fractional Anisotropy output file
-    md_output:
-    # type=file: Mean Diffusivity output file
-    # type=traitcompound|default=None: Mean Diffusivity output file
-    sigma:
-    # type=float|default=0.0: Scale of gradients
-    fa_gradient_output:
-    # type=file: Fractional Anisotropy Gradient output file
-    # type=traitcompound|default=None: Fractional Anisotropy Gradient output file
-    fa_gradmag_output:
-    # type=file: Fractional Anisotropy Gradient Magnitude output file
-    # type=traitcompound|default=None: Fractional Anisotropy Gradient Magnitude output file
-    color_fa_output:
-    # type=file: Color Fractional Anisotropy output file
-    # type=traitcompound|default=None: Color Fractional Anisotropy output file
-    principal_eigenvector_output:
-    # type=file: Principal Eigenvectors Output
-    # type=traitcompound|default=None: Principal Eigenvectors Output
-    negative_eigenvector_output:
-    # type=file: Negative Eigenvectors Output: create a binary image where if any of the eigen value is below zero, the voxel is set to 1, otherwise 0.
-    # type=traitcompound|default=None: Negative Eigenvectors Output: create a binary image where if any of the eigen value is below zero, the voxel is set to 1, otherwise 0.
-    frobenius_norm_output:
-    # type=file: Frobenius Norm Output
-    # type=traitcompound|default=None: Frobenius Norm Output
-    lambda1_output:
-    # type=file: Axial Diffusivity - Lambda 1 (largest eigenvalue) output
-    # type=traitcompound|default=None: Axial Diffusivity - Lambda 1 (largest eigenvalue) output
-    lambda2_output:
-    # type=file: Lambda 2 (middle eigenvalue) output
-    # type=traitcompound|default=None: Lambda 2 (middle eigenvalue) output
-    lambda3_output:
-    # type=file: Lambda 3 (smallest eigenvalue) output
-    # type=traitcompound|default=None: Lambda 3 (smallest eigenvalue) output
-    RD_output:
-    # type=file: RD (Radial Diffusivity 1/2*(lambda2+lambda3)) output
-    # type=traitcompound|default=None: RD (Radial Diffusivity 1/2*(lambda2+lambda3)) output
-    rot_output:
-    # type=file: Rotated tensor output file.  Must also specify the dof file.
-    # type=traitcompound|default=None: Rotated tensor output file.  Must also specify the dof file.
-    affineitk_file:
-    # type=file|default=<undefined>: Transformation file for affine transformation.  ITK format.
-    dof_file:
-    # type=file|default=<undefined>: Transformation file for affine transformation.  This can be ITK format (or the outdated RView).
-    newdof_file:
-    # type=file|default=<undefined>: Transformation file for affine transformation.  RView NEW format. (txt file output of dof2mat)
-    mask:
-    # type=file|default=<undefined>: Mask tensors. Specify --outmask if you want to save the masked tensor field, otherwise the mask is applied just for the current processing 
-    outmask:
-    # type=file: Name of the masked tensor field.
-    # type=traitcompound|default=None: Name of the masked tensor field.
-    hField:
-    # type=bool|default=False: forward and inverse transformations are h-fields instead of displacement fields
-    forward:
-    # type=file|default=<undefined>: Forward transformation.  Assumed to be a deformation field in world coordinates, unless the --h-field option is specified.
-    deformation_output:
-    # type=file: Warped tensor field based on a deformation field.  This option requires the --forward,-F transformation to be specified.
-    # type=traitcompound|default=None: Warped tensor field based on a deformation field.  This option requires the --forward,-F transformation to be specified.
-    interpolation:
-    # type=enum|default='nearestneighbor'|allowed['cubic','linear','nearestneighbor']: Interpolation type (nearestneighbor, linear, cubic)
-    reorientation:
-    # type=enum|default='fs'|allowed['fs','ppd']: Reorientation type (fs, ppd)
-    correction:
-    # type=enum|default='none'|allowed['abs','nearest','none','zero']: Correct the tensors if computed tensor is not semi-definite positive
-    scalar_float:
-    # type=bool|default=False: Write scalar [FA,MD] as unscaled float (with their actual values, otherwise scaled by 10 000).  Also causes FA to be unscaled [0..1].
-    DTI_double:
-    # type=bool|default=False: Tensor components are saved as doubles (cannot be visualized in Slicer)
-    verbose:
-    # type=bool|default=False: produce verbose output
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/dtiprocess_callables.py b/example-specs/task/nipype_internal/pydra-semtools/dtiprocess_callables.py
deleted file mode 100644
index a818ae5b..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/dtiprocess_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in dtiprocess.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/dump_binary_training_vectors.yaml b/example-specs/task/nipype_internal/pydra-semtools/dump_binary_training_vectors.yaml
deleted file mode 100644
index abcac5dc..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/dump_binary_training_vectors.yaml
+++ /dev/null
@@ -1,87 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.filtering.featuredetection.DumpBinaryTrainingVectors' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Erode Image
-# 
-#     category: Filtering.FeatureDetection
-# 
-#     description: Uses mathematical morphology to erode the input images.
-# 
-#     version: 0.1.0.$Revision: 1 $(alpha)
-# 
-#     documentation-url: http:://www.na-mic.org/
-# 
-#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
-# 
-#     contributor: This tool was developed by Mark Scully and Jeremy Bockholt.
-#     
-task_name: DumpBinaryTrainingVectors
-nipype_name: DumpBinaryTrainingVectors
-nipype_module: nipype.interfaces.semtools.filtering.featuredetection
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputHeaderFilename: generic/file
-    # type=file|default=<undefined>: Required: input header file name
-    inputVectorFilename: generic/file
-    # type=file|default=<undefined>: Required: input vector filename
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputHeaderFilename:
-    # type=file|default=<undefined>: Required: input header file name
-    inputVectorFilename:
-    # type=file|default=<undefined>: Required: input vector filename
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/dump_binary_training_vectors_callables.py b/example-specs/task/nipype_internal/pydra-semtools/dump_binary_training_vectors_callables.py
deleted file mode 100644
index 40c89865..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/dump_binary_training_vectors_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in DumpBinaryTrainingVectors.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/dwi_compare.yaml b/example-specs/task/nipype_internal/pydra-semtools/dwi_compare.yaml
deleted file mode 100644
index 89f0c354..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/dwi_compare.yaml
+++ /dev/null
@@ -1,89 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.converters.DWICompare' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Nrrd DWI comparison
-# 
-#     category: Converters
-# 
-#     description: Compares two nrrd format DWI images and verifies that gradient magnitudes, gradient directions, measurement frame, and max B0 value are identicle.  Used for testing DWIConvert.
-# 
-#     version: 0.1.0.$Revision: 916 $(alpha)
-# 
-#     documentation-url: http://www.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/DWIConvert
-# 
-#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
-# 
-#     contributor: Mark Scully (UIowa)
-# 
-#     acknowledgements: This work is part of the National Alliance for Medical Image Computing (NAMIC), funded by the National Institutes of Health through the NIH Roadmap for Medical Research, Grant U54 EB005149.  Additional support for DTI data produced on Philips scanners was contributed by Vincent Magnotta and Hans Johnson at the University of Iowa.
-#     
-task_name: DWICompare
-nipype_name: DWICompare
-nipype_module: nipype.interfaces.semtools.converters
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputVolume1: generic/file
-    # type=file|default=<undefined>: First input volume (.nhdr or .nrrd)
-    inputVolume2: generic/file
-    # type=file|default=<undefined>: Second input volume (.nhdr or .nrrd)
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputVolume1:
-    # type=file|default=<undefined>: First input volume (.nhdr or .nrrd)
-    inputVolume2:
-    # type=file|default=<undefined>: Second input volume (.nhdr or .nrrd)
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/dwi_compare_callables.py b/example-specs/task/nipype_internal/pydra-semtools/dwi_compare_callables.py
deleted file mode 100644
index d457104c..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/dwi_compare_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in DWICompare.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/dwi_convert.yaml b/example-specs/task/nipype_internal/pydra-semtools/dwi_convert.yaml
deleted file mode 100644
index bc162fdb..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/dwi_convert.yaml
+++ /dev/null
@@ -1,147 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.diffusion.diffusion.DWIConvert' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: DWIConverter
-# 
-#     category: Diffusion.Diffusion Data Conversion
-# 
-#     description: Converts diffusion weighted MR images in dicom series into Nrrd format for analysis in Slicer. This program has been tested on only a limited subset of DTI dicom formats available from Siemens, GE, and Phillips scanners. Work in progress to support dicom multi-frame data. The program parses dicom header to extract necessary information about measurement frame, diffusion weighting directions, b-values, etc, and write out a nrrd image. For non-diffusion weighted dicom images, it loads in an entire dicom series and writes out a single dicom volume in a .nhdr/.raw pair.
-# 
-#     version: Version 1.0
-# 
-#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/DWIConverter
-# 
-#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
-# 
-#     contributor: Vince Magnotta (UIowa), Hans Johnson (UIowa), Joy Matsui (UIowa), Kent Williams (UIowa), Mark Scully (Uiowa), Xiaodong Tao (GE)
-# 
-#     acknowledgements: This work is part of the National Alliance for Medical Image Computing (NAMIC), funded by the National Institutes of Health through the NIH Roadmap for Medical Research, Grant U54 EB005149.  Additional support for DTI data produced on Philips scanners was contributed by Vincent Magnotta and Hans Johnson at the University of Iowa.
-#     
-task_name: DWIConvert
-nipype_name: DWIConvert
-nipype_module: nipype.interfaces.semtools.diffusion.diffusion
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputVolume: generic/file
-    # type=file|default=<undefined>: Input DWI volume -- not used for DicomToNrrd mode.
-    fslNIFTIFile: generic/file
-    # type=file|default=<undefined>: 4D NIfTI file containing gradient volumes
-    inputBValues: generic/file
-    # type=file|default=<undefined>: The B Values are stored in FSL .bval text file format
-    inputBVectors: generic/file
-    # type=file|default=<undefined>: The Gradient Vectors are stored in FSL .bvec text file format
-    inputDicomDirectory: generic/directory
-    # type=directory|default=<undefined>: Directory holding Dicom series
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputVolume: generic/file
-    # type=file: Output filename (.nhdr or .nrrd)
-    # type=traitcompound|default=None: Output filename (.nhdr or .nrrd)
-    outputBValues: generic/file
-    # type=file: The B Values are stored in FSL .bval text file format (defaults to <outputVolume>.bval)
-    # type=traitcompound|default=None: The B Values are stored in FSL .bval text file format (defaults to <outputVolume>.bval)
-    outputBVectors: generic/file
-    # type=file: The Gradient Vectors are stored in FSL .bvec text file format (defaults to <outputVolume>.bvec)
-    # type=traitcompound|default=None: The Gradient Vectors are stored in FSL .bvec text file format (defaults to <outputVolume>.bvec)
-    gradientVectorFile: generic/file
-    # type=file: Text file giving gradient vectors
-    # type=traitcompound|default=None: Text file giving gradient vectors
-    outputDirectory: generic/directory
-    # type=directory: Directory holding the output NRRD file
-    # type=traitcompound|default=None: Directory holding the output NRRD file
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    conversionMode:
-    # type=enum|default='DicomToNrrd'|allowed['DicomToFSL','DicomToNrrd','FSLToNrrd','NrrdToFSL']: Determine which conversion to perform. DicomToNrrd (default): Convert DICOM series to NRRD DicomToFSL: Convert DICOM series to NIfTI File + gradient/bvalue text files NrrdToFSL: Convert DWI NRRD file to NIfTI File + gradient/bvalue text files FSLToNrrd: Convert NIfTI File + gradient/bvalue text files to NRRD file.
-    inputVolume:
-    # type=file|default=<undefined>: Input DWI volume -- not used for DicomToNrrd mode.
-    outputVolume:
-    # type=file: Output filename (.nhdr or .nrrd)
-    # type=traitcompound|default=None: Output filename (.nhdr or .nrrd)
-    inputDicomDirectory:
-    # type=directory|default=<undefined>: Directory holding Dicom series
-    fslNIFTIFile:
-    # type=file|default=<undefined>: 4D NIfTI file containing gradient volumes
-    inputBValues:
-    # type=file|default=<undefined>: The B Values are stored in FSL .bval text file format
-    inputBVectors:
-    # type=file|default=<undefined>: The Gradient Vectors are stored in FSL .bvec text file format
-    outputBValues:
-    # type=file: The B Values are stored in FSL .bval text file format (defaults to <outputVolume>.bval)
-    # type=traitcompound|default=None: The B Values are stored in FSL .bval text file format (defaults to <outputVolume>.bval)
-    outputBVectors:
-    # type=file: The Gradient Vectors are stored in FSL .bvec text file format (defaults to <outputVolume>.bvec)
-    # type=traitcompound|default=None: The Gradient Vectors are stored in FSL .bvec text file format (defaults to <outputVolume>.bvec)
-    fMRI:
-    # type=bool|default=False: Output a NRRD file, but without gradients
-    writeProtocolGradientsFile:
-    # type=bool|default=False: Write the protocol gradients to a file suffixed by '.txt' as they were specified in the procol by multiplying each diffusion gradient direction by the measurement frame.  This file is for debugging purposes only, the format is not fixed, and will likely change as debugging of new dicom formats is necessary.
-    useIdentityMeaseurementFrame:
-    # type=bool|default=False: Adjust all the gradients so that the measurement frame is an identity matrix.
-    useBMatrixGradientDirections:
-    # type=bool|default=False: Fill the nhdr header with the gradient directions and bvalues computed out of the BMatrix. Only changes behavior for Siemens data.  In some cases the standard public gradients are not properly computed.  The gradients can empirically computed from the private BMatrix fields.  In some cases the private BMatrix is consistent with the public grandients, but not in all cases, when it exists BMatrix is usually most robust.
-    outputDirectory:
-    # type=directory: Directory holding the output NRRD file
-    # type=traitcompound|default=None: Directory holding the output NRRD file
-    gradientVectorFile:
-    # type=file: Text file giving gradient vectors
-    # type=traitcompound|default=None: Text file giving gradient vectors
-    smallGradientThreshold:
-    # type=float|default=0.0: If a gradient magnitude is greater than 0 and less than smallGradientThreshold, then DWIConvert will display an error message and quit, unless the useBMatrixGradientDirections option is set.
-    allowLossyConversion:
-    # type=bool|default=False: The only supported output type is 'short'. Conversion from images of a different type may cause data loss due to rounding or truncation. Use with caution!
-    transposeInputBVectors:
-    # type=bool|default=False: FSL input BVectors are expected to be encoded in the input file as one vector per line. If it is not the case, use this option to transpose the file as it is read.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/dwi_convert_callables.py b/example-specs/task/nipype_internal/pydra-semtools/dwi_convert_callables.py
deleted file mode 100644
index 1778100f..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/dwi_convert_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in DWIConvert.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/dwi_simple_compare.yaml b/example-specs/task/nipype_internal/pydra-semtools/dwi_simple_compare.yaml
deleted file mode 100644
index 386507f5..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/dwi_simple_compare.yaml
+++ /dev/null
@@ -1,91 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.converters.DWISimpleCompare' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Nrrd DWI comparison
-# 
-#     category: Converters
-# 
-#     description: Compares two nrrd format DWI images and verifies that gradient magnitudes, gradient directions, measurement frame, and max B0 value are identicle.  Used for testing DWIConvert.
-# 
-#     version: 0.1.0.$Revision: 916 $(alpha)
-# 
-#     documentation-url: http://www.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/DWIConvert
-# 
-#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
-# 
-#     contributor: Mark Scully (UIowa)
-# 
-#     acknowledgements: This work is part of the National Alliance for Medical Image Computing (NAMIC), funded by the National Institutes of Health through the NIH Roadmap for Medical Research, Grant U54 EB005149.  Additional support for DTI data produced on Philips scanners was contributed by Vincent Magnotta and Hans Johnson at the University of Iowa.
-#     
-task_name: DWISimpleCompare
-nipype_name: DWISimpleCompare
-nipype_module: nipype.interfaces.semtools.converters
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputVolume1: generic/file
-    # type=file|default=<undefined>: First input volume (.nhdr or .nrrd)
-    inputVolume2: generic/file
-    # type=file|default=<undefined>: Second input volume (.nhdr or .nrrd)
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputVolume1:
-    # type=file|default=<undefined>: First input volume (.nhdr or .nrrd)
-    inputVolume2:
-    # type=file|default=<undefined>: Second input volume (.nhdr or .nrrd)
-    checkDWIData:
-    # type=bool|default=False: check for existence of DWI data, and if present, compare it
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/dwi_simple_compare_callables.py b/example-specs/task/nipype_internal/pydra-semtools/dwi_simple_compare_callables.py
deleted file mode 100644
index c3afa157..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/dwi_simple_compare_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in DWISimpleCompare.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/erode_image.yaml b/example-specs/task/nipype_internal/pydra-semtools/erode_image.yaml
deleted file mode 100644
index 7cd842a2..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/erode_image.yaml
+++ /dev/null
@@ -1,95 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.filtering.featuredetection.ErodeImage' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Erode Image
-# 
-#     category: Filtering.FeatureDetection
-# 
-#     description: Uses mathematical morphology to erode the input images.
-# 
-#     version: 0.1.0.$Revision: 1 $(alpha)
-# 
-#     documentation-url: http:://www.na-mic.org/
-# 
-#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
-# 
-#     contributor: This tool was developed by Mark Scully and Jeremy Bockholt.
-#     
-task_name: ErodeImage
-nipype_name: ErodeImage
-nipype_module: nipype.interfaces.semtools.filtering.featuredetection
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputVolume: generic/file
-    # type=file|default=<undefined>: Required: input image
-    inputMaskVolume: generic/file
-    # type=file|default=<undefined>: Required: input brain mask image
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputVolume: generic/file
-    # type=file: Required: output image
-    # type=traitcompound|default=None: Required: output image
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputVolume:
-    # type=file|default=<undefined>: Required: input image
-    inputMaskVolume:
-    # type=file|default=<undefined>: Required: input brain mask image
-    inputRadius:
-    # type=int|default=0: Required: input neighborhood radius
-    outputVolume:
-    # type=file: Required: output image
-    # type=traitcompound|default=None: Required: output image
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/erode_image_callables.py b/example-specs/task/nipype_internal/pydra-semtools/erode_image_callables.py
deleted file mode 100644
index 545fa4d7..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/erode_image_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in ErodeImage.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/eslr.yaml b/example-specs/task/nipype_internal/pydra-semtools/eslr.yaml
deleted file mode 100644
index 92b2f8fc..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/eslr.yaml
+++ /dev/null
@@ -1,95 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.segmentation.specialized.ESLR' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Clean Contiguous Label Map (BRAINS)
-# 
-#     category: Segmentation.Specialized
-# 
-#     description: From a range of label map values, extract the largest contiguous region of those labels
-#     
-task_name: ESLR
-nipype_name: ESLR
-nipype_module: nipype.interfaces.semtools.segmentation.specialized
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputVolume: generic/file
-    # type=file|default=<undefined>: Input Label Volume
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputVolume: generic/file
-    # type=file: Output Label Volume
-    # type=traitcompound|default=None: Output Label Volume
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputVolume:
-    # type=file|default=<undefined>: Input Label Volume
-    outputVolume:
-    # type=file: Output Label Volume
-    # type=traitcompound|default=None: Output Label Volume
-    low:
-    # type=int|default=0: The lower bound of the labels to be used.
-    high:
-    # type=int|default=0: The higher bound of the labels to be used.
-    closingSize:
-    # type=int|default=0: The closing size for hole filling.
-    openingSize:
-    # type=int|default=0: The opening size for hole filling.
-    safetySize:
-    # type=int|default=0: The safetySize size for the clipping region.
-    preserveOutside:
-    # type=bool|default=False: For values outside the specified range, preserve those values.
-    numberOfThreads:
-    # type=int|default=0: Explicitly specify the maximum number of threads to use.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/eslr_callables.py b/example-specs/task/nipype_internal/pydra-semtools/eslr_callables.py
deleted file mode 100644
index 8d2a0716..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/eslr_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in ESLR.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/extract_nrrd_vector_index.yaml b/example-specs/task/nipype_internal/pydra-semtools/extract_nrrd_vector_index.yaml
deleted file mode 100644
index 1d35a26f..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/extract_nrrd_vector_index.yaml
+++ /dev/null
@@ -1,97 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.diffusion.gtract.extractNrrdVectorIndex' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Extract Nrrd Index
-# 
-#     category: Diffusion.GTRACT
-# 
-#     description: This program will extract a 3D image (single vector) from a vector 3D image at a given vector index.
-# 
-#     version: 4.0.0
-# 
-#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Modules:GTRACT
-# 
-#     license: http://mri.radiology.uiowa.edu/copyright/GTRACT-Copyright.txt
-# 
-#     contributor: This tool was developed by Vincent Magnotta and Greg Harris.
-# 
-#     acknowledgements: Funding for this version of the GTRACT program was provided by NIH/NINDS R01NS050568-01A2S1
-#     
-task_name: extractNrrdVectorIndex
-nipype_name: extractNrrdVectorIndex
-nipype_module: nipype.interfaces.semtools.diffusion.gtract
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputVolume: generic/file
-    # type=file|default=<undefined>: Required: input file containing the vector that will be extracted
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputVolume: generic/file
-    # type=file: Required: name of output NRRD file containing the vector image at the given index
-    # type=traitcompound|default=None: Required: name of output NRRD file containing the vector image at the given index
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputVolume:
-    # type=file|default=<undefined>: Required: input file containing the vector that will be extracted
-    vectorIndex:
-    # type=int|default=0: Index in the vector image to extract
-    setImageOrientation:
-    # type=enum|default='AsAcquired'|allowed['AsAcquired','Axial','Coronal','Sagittal']: Sets the image orientation of the extracted vector (Axial, Coronal, Sagittal)
-    outputVolume:
-    # type=file: Required: name of output NRRD file containing the vector image at the given index
-    # type=traitcompound|default=None: Required: name of output NRRD file containing the vector image at the given index
-    numberOfThreads:
-    # type=int|default=0: Explicitly specify the maximum number of threads to use.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/extract_nrrd_vector_index_callables.py b/example-specs/task/nipype_internal/pydra-semtools/extract_nrrd_vector_index_callables.py
deleted file mode 100644
index 25af6cf3..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/extract_nrrd_vector_index_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in extractNrrdVectorIndex.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/fcsv_to_hdf_5.yaml b/example-specs/task/nipype_internal/pydra-semtools/fcsv_to_hdf_5.yaml
deleted file mode 100644
index c1eca51b..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/fcsv_to_hdf_5.yaml
+++ /dev/null
@@ -1,93 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.utilities.brains.fcsv_to_hdf5' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: fcsv_to_hdf5 (BRAINS)
-# 
-#     category: Utilities.BRAINS
-# 
-#     description: Convert a collection of fcsv files to a HDF5 format file
-#     
-task_name: fcsv_to_hdf5
-nipype_name: fcsv_to_hdf5
-nipype_module: nipype.interfaces.semtools.utilities.brains
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    landmarkTypesList: generic/file
-    # type=file|default=<undefined>: ,         file containing list of landmark types,       
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    landmarksInformationFile: generic/file
-    # type=file: ,         name of HDF5 file to write matrices into,       
-    # type=traitcompound|default=None: ,         name of HDF5 file to write matrices into,       
-    modelFile: generic/file
-    # type=file: ,         name of HDF5 file containing BRAINSConstellationDetector Model file (LLSMatrices, LLSMeans and LLSSearchRadii),       
-    # type=traitcompound|default=None: ,         name of HDF5 file containing BRAINSConstellationDetector Model file (LLSMatrices, LLSMeans and LLSSearchRadii),       
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    versionID:
-    # type=str|default='': ,         Current version ID. It should be match with the version of BCD that will be using the output model file,       
-    landmarksInformationFile:
-    # type=file: ,         name of HDF5 file to write matrices into,       
-    # type=traitcompound|default=None: ,         name of HDF5 file to write matrices into,       
-    landmarkTypesList:
-    # type=file|default=<undefined>: ,         file containing list of landmark types,       
-    modelFile:
-    # type=file: ,         name of HDF5 file containing BRAINSConstellationDetector Model file (LLSMatrices, LLSMeans and LLSSearchRadii),       
-    # type=traitcompound|default=None: ,         name of HDF5 file containing BRAINSConstellationDetector Model file (LLSMatrices, LLSMeans and LLSSearchRadii),       
-    landmarkGlobPattern:
-    # type=str|default='': Glob pattern to select fcsv files
-    numberOfThreads:
-    # type=int|default=0: Explicitly specify the maximum number of threads to use.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/fcsv_to_hdf_5_callables.py b/example-specs/task/nipype_internal/pydra-semtools/fcsv_to_hdf_5_callables.py
deleted file mode 100644
index f2b47baa..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/fcsv_to_hdf_5_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in fcsv_to_hdf5.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/fiberprocess.yaml b/example-specs/task/nipype_internal/pydra-semtools/fiberprocess.yaml
deleted file mode 100644
index 151b312d..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/fiberprocess.yaml
+++ /dev/null
@@ -1,129 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.diffusion.tractography.fiberprocess.fiberprocess' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: FiberProcess (DTIProcess)
-# 
-#     category: Diffusion.Tractography
-# 
-#     description: fiberprocess is a tool that manage fiber files extracted from the fibertrack tool or any fiber tracking algorithm. It takes as an input .fib and .vtk files (--fiber_file) and saves the changed fibers (--fiber_output) into the 2 same formats. The main purpose of this tool is to deform the fiber file with a transformation field as an input (--displacement_field or --h_field depending if you deal with dfield or hfield). To use that option you need to specify the tensor field from which the fiber file was extracted with the option --tensor_volume. The transformation applied on the fiber file is the inverse of the one input. If the transformation is from one case to an atlas, fiberprocess assumes that the fiber file is in the atlas space and you want it in the original case space, so it's the inverse of the transformation which has been computed.
-#     You have 2 options for fiber modification. You can either deform the fibers (their geometry) into the space OR you can keep the same geometry but map the diffusion properties (fa, md, lbd's...) of the original tensor field along the fibers at the corresponding locations. This is triggered by the --no_warp option. To use the previous example: when you have a tensor field in the original space and the deformed tensor field in the atlas space, you want to track the fibers in the atlas space, keeping this geometry but with the original case diffusion properties. Then you can specify the transformations field (from original case -> atlas) and the original tensor field with the --tensor_volume option.
-#     With fiberprocess you can also binarize a fiber file. Using the --voxelize option will create an image where each voxel through which a fiber is passing is set to 1. The output is going to be a binary image with the values 0 or 1 by default but the 1 value voxel can be set to any number with the --voxel_label option. Finally you can create an image where the value at the voxel is the number of fiber passing through. (--voxelize_count_fibers)
-# 
-#     version: 1.0.0
-# 
-#     documentation-url: http://www.slicer.org/slicerWiki/index.php/Documentation/Nightly/Extensions/DTIProcess
-# 
-#     license: Copyright (c)  Casey Goodlett. All rights reserved.
-#         See http://www.ia.unc.edu/dev/Copyright.htm for details.
-#         This software is distributed WITHOUT ANY WARRANTY; without even
-#         the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-#         PURPOSE.  See the above copyright notices for more information.
-# 
-#     contributor: Casey Goodlett
-#     
-task_name: fiberprocess
-nipype_name: fiberprocess
-nipype_module: nipype.interfaces.semtools.diffusion.tractography.fiberprocess
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    fiber_file: generic/file
-    # type=file|default=<undefined>: DTI fiber file
-    tensor_volume: generic/file
-    # type=file|default=<undefined>: Interpolate tensor values from the given field
-    h_field: generic/file
-    # type=file|default=<undefined>: HField for warp and statistics lookup. If this option is used tensor-volume must also be specified.
-    displacement_field: generic/file
-    # type=file|default=<undefined>: Displacement Field for warp and statistics lookup.  If this option is used tensor-volume must also be specified.
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    fiber_output: generic/file
-    # type=file: Output fiber file. May be warped or updated with new data depending on other options used.
-    # type=traitcompound|default=None: Output fiber file. May be warped or updated with new data depending on other options used.
-    voxelize: generic/file
-    # type=file: Voxelize fiber into a label map (the labelmap filename is the argument of -V). The tensor file must be specified using -T for information about the size, origin, spacing of the image. The deformation is applied before the voxelization 
-    # type=traitcompound|default=None: Voxelize fiber into a label map (the labelmap filename is the argument of -V). The tensor file must be specified using -T for information about the size, origin, spacing of the image. The deformation is applied before the voxelization 
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    fiber_file:
-    # type=file|default=<undefined>: DTI fiber file
-    fiber_output:
-    # type=file: Output fiber file. May be warped or updated with new data depending on other options used.
-    # type=traitcompound|default=None: Output fiber file. May be warped or updated with new data depending on other options used.
-    tensor_volume:
-    # type=file|default=<undefined>: Interpolate tensor values from the given field
-    h_field:
-    # type=file|default=<undefined>: HField for warp and statistics lookup. If this option is used tensor-volume must also be specified.
-    displacement_field:
-    # type=file|default=<undefined>: Displacement Field for warp and statistics lookup.  If this option is used tensor-volume must also be specified.
-    saveProperties:
-    # type=bool|default=False: save the tensor property as scalar data into the vtk (only works for vtk fiber files). 
-    no_warp:
-    # type=bool|default=False: Do not warp the geometry of the tensors only obtain the new statistics.
-    fiber_radius:
-    # type=float|default=0.0: set radius of all fibers to this value
-    index_space:
-    # type=bool|default=False: Use index-space for fiber output coordinates, otherwise us world space for fiber output coordinates (from tensor file).
-    voxelize:
-    # type=file: Voxelize fiber into a label map (the labelmap filename is the argument of -V). The tensor file must be specified using -T for information about the size, origin, spacing of the image. The deformation is applied before the voxelization 
-    # type=traitcompound|default=None: Voxelize fiber into a label map (the labelmap filename is the argument of -V). The tensor file must be specified using -T for information about the size, origin, spacing of the image. The deformation is applied before the voxelization 
-    voxelize_count_fibers:
-    # type=bool|default=False: Count number of fibers per-voxel instead of just setting to 1
-    voxel_label:
-    # type=int|default=0: Label for voxelized fiber
-    verbose:
-    # type=bool|default=False: produce verbose output
-    noDataChange:
-    # type=bool|default=False: Do not change data ??? 
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/fiberprocess_callables.py b/example-specs/task/nipype_internal/pydra-semtools/fiberprocess_callables.py
deleted file mode 100644
index c89a079e..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/fiberprocess_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in fiberprocess.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/fiberstats.yaml b/example-specs/task/nipype_internal/pydra-semtools/fiberstats.yaml
deleted file mode 100644
index 5717fb32..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/fiberstats.yaml
+++ /dev/null
@@ -1,91 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.diffusion.tractography.commandlineonly.fiberstats' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: FiberStats (DTIProcess)
-# 
-#     category: Diffusion.Tractography.CommandLineOnly
-# 
-#     description: Obsolete tool - Not used anymore
-# 
-#     version: 1.1.0
-# 
-#     documentation-url: http://www.slicer.org/slicerWiki/index.php/Documentation/Nightly/Extensions/DTIProcess
-# 
-#     license: Copyright (c)  Casey Goodlett. All rights reserved.
-#       See http://www.ia.unc.edu/dev/Copyright.htm for details.
-#          This software is distributed WITHOUT ANY WARRANTY; without even
-#          the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-#          PURPOSE.  See the above copyright notices for more information.
-# 
-#     contributor: Casey Goodlett
-# 
-#     acknowledgements: Hans Johnson(1,3,4); Kent Williams(1); (1=University of Iowa Department of Psychiatry, 3=University of Iowa Department of Biomedical Engineering, 4=University of Iowa Department of Electrical and Computer Engineering) provided conversions to make DTIProcess compatible with Slicer execution, and simplified the stand-alone build requirements by removing the dependencies on boost and a fortran compiler.
-#     
-task_name: fiberstats
-nipype_name: fiberstats
-nipype_module: nipype.interfaces.semtools.diffusion.tractography.commandlineonly
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    fiber_file: generic/file
-    # type=file|default=<undefined>: DTI Fiber File
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    fiber_file:
-    # type=file|default=<undefined>: DTI Fiber File
-    verbose:
-    # type=bool|default=False: produce verbose output
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/fiberstats_callables.py b/example-specs/task/nipype_internal/pydra-semtools/fiberstats_callables.py
deleted file mode 100644
index 91bf34be..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/fiberstats_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in fiberstats.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/fibertrack.yaml b/example-specs/task/nipype_internal/pydra-semtools/fibertrack.yaml
deleted file mode 100644
index e0af6c7d..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/fibertrack.yaml
+++ /dev/null
@@ -1,122 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.diffusion.tractography.fibertrack.fibertrack' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: FiberTrack (DTIProcess)
-# 
-#     category: Diffusion.Tractography
-# 
-#     description: This program implements a simple streamline tractography method based on the principal eigenvector of the tensor field. A fourth order Runge-Kutta integration rule used to advance the streamlines.
-#     As a first parameter you have to input the tensor field (with the --input_tensor_file option). Then the region of interest image file is set with the --input_roi_file. Next you want to set the output fiber file name after the --output_fiber_file option.
-#     You can specify the label value in the input_roi_file with the --target_label, --source_label and  --fobidden_label options. By default target label is 1, source label is 2 and forbidden label is 0. The source label is where the streamlines are seeded, the target label defines the voxels through which the fibers must pass by to be kept in the final fiber file and the forbidden label defines the voxels where the streamlines are stopped if they pass through it. There is also a --whole_brain option which, if enabled, consider both target and source labels of the roi image as target labels and all the voxels of the image are considered as sources.
-#     During the tractography, the --fa_min parameter is used as the minimum value needed at different voxel for the tracking to keep going along a streamline. The --step_size parameter is used for each iteration of the tracking algorithm and defines the length of each step. The --max_angle option defines the maximum angle allowed between two successive segments along the tracked fiber.
-# 
-#     version: 1.1.0
-# 
-#     documentation-url: http://www.slicer.org/slicerWiki/index.php/Documentation/Nightly/Extensions/DTIProcess
-# 
-#     license: Copyright (c)  Casey Goodlett. All rights reserved.
-#       See http://www.ia.unc.edu/dev/Copyright.htm for details.
-#          This software is distributed WITHOUT ANY WARRANTY; without even
-#          the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-#          PURPOSE.  See the above copyright notices for more information.
-# 
-#     contributor: Casey Goodlett
-# 
-#     acknowledgements: Hans Johnson(1,3,4); Kent Williams(1); (1=University of Iowa Department of Psychiatry, 3=University of Iowa Department of Biomedical Engineering, 4=University of Iowa Department of Electrical and Computer Engineering) provided conversions to make DTIProcess compatible with Slicer execution, and simplified the stand-alone build requirements by removing the dependencies on boost and a fortran compiler.
-#     
-task_name: fibertrack
-nipype_name: fibertrack
-nipype_module: nipype.interfaces.semtools.diffusion.tractography.fibertrack
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    input_tensor_file: generic/file
-    # type=file|default=<undefined>: Tensor Image
-    input_roi_file: generic/file
-    # type=file|default=<undefined>: The filename of the image which contains the labels used for seeding and constraining the algorithm.
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    output_fiber_file: generic/file
-    # type=file: The filename for the fiber file produced by the algorithm. This file must end in a .fib or .vtk extension for ITK spatial object and vtkPolyData formats respectively.
-    # type=traitcompound|default=None: The filename for the fiber file produced by the algorithm. This file must end in a .fib or .vtk extension for ITK spatial object and vtkPolyData formats respectively.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    input_tensor_file:
-    # type=file|default=<undefined>: Tensor Image
-    input_roi_file:
-    # type=file|default=<undefined>: The filename of the image which contains the labels used for seeding and constraining the algorithm.
-    output_fiber_file:
-    # type=file: The filename for the fiber file produced by the algorithm. This file must end in a .fib or .vtk extension for ITK spatial object and vtkPolyData formats respectively.
-    # type=traitcompound|default=None: The filename for the fiber file produced by the algorithm. This file must end in a .fib or .vtk extension for ITK spatial object and vtkPolyData formats respectively.
-    source_label:
-    # type=int|default=0: The label of voxels in the labelfile to use for seeding tractography. One tract is seeded from the center of each voxel with this label
-    target_label:
-    # type=int|default=0: The label of voxels in the labelfile used to constrain tractography. Tracts that do not pass through a voxel with this label are rejected. Set this keep all tracts.
-    forbidden_label:
-    # type=int|default=0: Forbidden label
-    whole_brain:
-    # type=bool|default=False: If this option is enabled all voxels in the image are used to seed tractography. When this option is enabled both source and target labels function as target labels
-    max_angle:
-    # type=float|default=0.0: Maximum angle of change in radians
-    step_size:
-    # type=float|default=0.0: Step size in mm for the tracking algorithm
-    min_fa:
-    # type=float|default=0.0: The minimum FA threshold to continue tractography
-    force:
-    # type=bool|default=False: Ignore sanity checks.
-    verbose:
-    # type=bool|default=False: produce verbose output
-    really_verbose:
-    # type=bool|default=False: Follow detail of fiber tracking algorithm
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/fibertrack_callables.py b/example-specs/task/nipype_internal/pydra-semtools/fibertrack_callables.py
deleted file mode 100644
index 9e13a9cc..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/fibertrack_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in fibertrack.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/find_center_of_brain.yaml b/example-specs/task/nipype_internal/pydra-semtools/find_center_of_brain.yaml
deleted file mode 100644
index 715328c1..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/find_center_of_brain.yaml
+++ /dev/null
@@ -1,139 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.utilities.brains.FindCenterOfBrain' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Center Of Brain (BRAINS)
-# 
-#     category: Utilities.BRAINS
-# 
-#     description: Finds the center point of a brain
-# 
-#     version: 3.0.0
-# 
-#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
-# 
-#     contributor: Hans J. Johnson, hans-johnson -at- uiowa.edu, http://wwww.psychiatry.uiowa.edu
-# 
-#     acknowledgements: Hans Johnson(1,3,4); Kent Williams(1);  (1=University of Iowa Department of Psychiatry, 3=University of Iowa Department of Biomedical Engineering, 4=University of Iowa Department of Electrical and Computer Engineering
-#     
-task_name: FindCenterOfBrain
-nipype_name: FindCenterOfBrain
-nipype_module: nipype.interfaces.semtools.utilities.brains
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputVolume: generic/file
-    # type=file|default=<undefined>: The image in which to find the center.
-    imageMask: generic/file
-    # type=file|default=<undefined>: 
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    clippedImageMask: generic/file
-    # type=file: 
-    # type=traitcompound|default=None: 
-    debugDistanceImage: generic/file
-    # type=file: 
-    # type=traitcompound|default=None: 
-    debugGridImage: generic/file
-    # type=file: 
-    # type=traitcompound|default=None: 
-    debugAfterGridComputationsForegroundImage: generic/file
-    # type=file: 
-    # type=traitcompound|default=None: 
-    debugClippedImageMask: generic/file
-    # type=file: 
-    # type=traitcompound|default=None: 
-    debugTrimmedImage: generic/file
-    # type=file: 
-    # type=traitcompound|default=None: 
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputVolume:
-    # type=file|default=<undefined>: The image in which to find the center.
-    imageMask:
-    # type=file|default=<undefined>: 
-    clippedImageMask:
-    # type=file: 
-    # type=traitcompound|default=None: 
-    maximize:
-    # type=bool|default=False: 
-    axis:
-    # type=int|default=0: 
-    otsuPercentileThreshold:
-    # type=float|default=0.0: 
-    closingSize:
-    # type=int|default=0: 
-    headSizeLimit:
-    # type=float|default=0.0: 
-    headSizeEstimate:
-    # type=float|default=0.0: 
-    backgroundValue:
-    # type=int|default=0: 
-    generateDebugImages:
-    # type=bool|default=False: 
-    debugDistanceImage:
-    # type=file: 
-    # type=traitcompound|default=None: 
-    debugGridImage:
-    # type=file: 
-    # type=traitcompound|default=None: 
-    debugAfterGridComputationsForegroundImage:
-    # type=file: 
-    # type=traitcompound|default=None: 
-    debugClippedImageMask:
-    # type=file: 
-    # type=traitcompound|default=None: 
-    debugTrimmedImage:
-    # type=file: 
-    # type=traitcompound|default=None: 
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/find_center_of_brain_callables.py b/example-specs/task/nipype_internal/pydra-semtools/find_center_of_brain_callables.py
deleted file mode 100644
index 2b90ca0f..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/find_center_of_brain_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in FindCenterOfBrain.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/flipped_difference.yaml b/example-specs/task/nipype_internal/pydra-semtools/flipped_difference.yaml
deleted file mode 100644
index 7c9e69b6..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/flipped_difference.yaml
+++ /dev/null
@@ -1,93 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.filtering.featuredetection.FlippedDifference' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Flip Image
-# 
-#     category: Filtering.FeatureDetection
-# 
-#     description: Difference between an image and the axially flipped version of that image.
-# 
-#     version: 0.1.0.$Revision: 1 $(alpha)
-# 
-#     documentation-url: http:://www.na-mic.org/
-# 
-#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
-# 
-#     contributor: This tool was developed by Mark Scully and Jeremy Bockholt.
-#     
-task_name: FlippedDifference
-nipype_name: FlippedDifference
-nipype_module: nipype.interfaces.semtools.filtering.featuredetection
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputVolume: generic/file
-    # type=file|default=<undefined>: Required: input image
-    inputMaskVolume: generic/file
-    # type=file|default=<undefined>: Required: input brain mask image
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputVolume: generic/file
-    # type=file: Required: output image
-    # type=traitcompound|default=None: Required: output image
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputVolume:
-    # type=file|default=<undefined>: Required: input image
-    inputMaskVolume:
-    # type=file|default=<undefined>: Required: input brain mask image
-    outputVolume:
-    # type=file: Required: output image
-    # type=traitcompound|default=None: Required: output image
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/flipped_difference_callables.py b/example-specs/task/nipype_internal/pydra-semtools/flipped_difference_callables.py
deleted file mode 100644
index e3d7824a..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/flipped_difference_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in FlippedDifference.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/generate_average_lmk_file.yaml b/example-specs/task/nipype_internal/pydra-semtools/generate_average_lmk_file.yaml
deleted file mode 100644
index 74d05ce2..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/generate_average_lmk_file.yaml
+++ /dev/null
@@ -1,81 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.testing.generateaveragelmkfile.GenerateAverageLmkFile' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Average Fiducials
-# 
-#     category: Testing
-# 
-#     description: This program gets several fcsv file each one contains several landmarks with the same name but slightly different coordinates. For EACH landmark we compute the average coordination.
-# 
-#     contributor: Ali Ghayoor
-#     
-task_name: GenerateAverageLmkFile
-nipype_name: GenerateAverageLmkFile
-nipype_module: nipype.interfaces.semtools.testing.generateaveragelmkfile
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputLandmarkFile: generic/file
-    # type=file: Output landmark file name that includes average values for landmarks (.fcsv or .wts)
-    # type=traitcompound|default=None: Output landmark file name that includes average values for landmarks (.fcsv or .wts)
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputLandmarkFiles:
-    # type=inputmultiobject|default=[]: Input landmark files names (.fcsv or .wts)
-    outputLandmarkFile:
-    # type=file: Output landmark file name that includes average values for landmarks (.fcsv or .wts)
-    # type=traitcompound|default=None: Output landmark file name that includes average values for landmarks (.fcsv or .wts)
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/generate_average_lmk_file_callables.py b/example-specs/task/nipype_internal/pydra-semtools/generate_average_lmk_file_callables.py
deleted file mode 100644
index 755121f1..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/generate_average_lmk_file_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in GenerateAverageLmkFile.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/generate_brain_clipped_image.yaml b/example-specs/task/nipype_internal/pydra-semtools/generate_brain_clipped_image.yaml
deleted file mode 100644
index 8f6ab521..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/generate_brain_clipped_image.yaml
+++ /dev/null
@@ -1,93 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.filtering.featuredetection.GenerateBrainClippedImage' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: GenerateBrainClippedImage
-# 
-#     category: Filtering.FeatureDetection
-# 
-#     description: Automatic FeatureImages using neural networks
-# 
-#     version: 1.0
-# 
-#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
-# 
-#     contributor: Eun Young Kim
-#     
-task_name: GenerateBrainClippedImage
-nipype_name: GenerateBrainClippedImage
-nipype_module: nipype.interfaces.semtools.filtering.featuredetection
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputImg: generic/file
-    # type=file|default=<undefined>: input volume 1, usually t1 image
-    inputMsk: generic/file
-    # type=file|default=<undefined>: input volume 2, usually t2 image
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputFileName: generic/file
-    # type=file: (required) output file name
-    # type=traitcompound|default=None: (required) output file name
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputImg:
-    # type=file|default=<undefined>: input volume 1, usually t1 image
-    inputMsk:
-    # type=file|default=<undefined>: input volume 2, usually t2 image
-    outputFileName:
-    # type=file: (required) output file name
-    # type=traitcompound|default=None: (required) output file name
-    numberOfThreads:
-    # type=int|default=0: Explicitly specify the maximum number of threads to use.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/generate_brain_clipped_image_callables.py b/example-specs/task/nipype_internal/pydra-semtools/generate_brain_clipped_image_callables.py
deleted file mode 100644
index 48b86121..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/generate_brain_clipped_image_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in GenerateBrainClippedImage.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/generate_csf_clipped_from_classified_image.yaml b/example-specs/task/nipype_internal/pydra-semtools/generate_csf_clipped_from_classified_image.yaml
deleted file mode 100644
index e1d44dc8..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/generate_csf_clipped_from_classified_image.yaml
+++ /dev/null
@@ -1,89 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.featurecreator.GenerateCsfClippedFromClassifiedImage' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: GenerateCsfClippedFromClassifiedImage
-# 
-#     category: FeatureCreator
-# 
-#     description: Get the distance from a voxel to the nearest voxel of a given tissue type.
-# 
-#     version: 0.1.0.$Revision: 1 $(alpha)
-# 
-#     documentation-url: http:://www.na-mic.org/
-# 
-#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
-# 
-#     contributor: This tool was written by Hans J. Johnson.
-#     
-task_name: GenerateCsfClippedFromClassifiedImage
-nipype_name: GenerateCsfClippedFromClassifiedImage
-nipype_module: nipype.interfaces.semtools.featurecreator
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputCassifiedVolume: generic/file
-    # type=file|default=<undefined>: Required: input tissue label image
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputVolume: generic/file
-    # type=file: Required: output image
-    # type=traitcompound|default=None: Required: output image
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputCassifiedVolume:
-    # type=file|default=<undefined>: Required: input tissue label image
-    outputVolume:
-    # type=file: Required: output image
-    # type=traitcompound|default=None: Required: output image
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/generate_csf_clipped_from_classified_image_callables.py b/example-specs/task/nipype_internal/pydra-semtools/generate_csf_clipped_from_classified_image_callables.py
deleted file mode 100644
index 9c2dfa09..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/generate_csf_clipped_from_classified_image_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in GenerateCsfClippedFromClassifiedImage.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/generate_edge_map_image.yaml b/example-specs/task/nipype_internal/pydra-semtools/generate_edge_map_image.yaml
deleted file mode 100644
index ebf9e787..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/generate_edge_map_image.yaml
+++ /dev/null
@@ -1,105 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.brains.utilities.GenerateEdgeMapImage' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: GenerateEdgeMapImage
-# 
-#     category: BRAINS.Utilities
-# 
-#     description: Automatic edgemap generation for edge-guided super-resolution reconstruction
-# 
-#     version: 1.0
-# 
-#     contributor: Ali Ghayoor
-#     
-task_name: GenerateEdgeMapImage
-nipype_name: GenerateEdgeMapImage
-nipype_module: nipype.interfaces.semtools.brains.utilities
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputMRVolumes: generic/file+list-of
-    # type=inputmultiobject|default=[]: List of input structural MR volumes to create the maximum edgemap
-    inputMask: generic/file
-    # type=file|default=<undefined>: Input mask file name. If set, image histogram percentiles will be calculated within the mask
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputEdgeMap: generic/file
-    # type=file: (required) output file name
-    # type=traitcompound|default=None: output edgemap file name
-    outputMaximumGradientImage: generic/file
-    # type=file: output gradient image file name
-    # type=traitcompound|default=None: output gradient image file name
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputMRVolumes:
-    # type=inputmultiobject|default=[]: List of input structural MR volumes to create the maximum edgemap
-    inputMask:
-    # type=file|default=<undefined>: Input mask file name. If set, image histogram percentiles will be calculated within the mask
-    minimumOutputRange:
-    # type=int|default=0: Map lower quantile and below to minimum output range. It should be a small number greater than zero. Default is 1
-    maximumOutputRange:
-    # type=int|default=0: Map upper quantile and above to maximum output range. Default is 255 that is the maximum range of unsigned char
-    lowerPercentileMatching:
-    # type=float|default=0.0: Map lower quantile and below to minOutputRange. It should be a value between zero and one
-    upperPercentileMatching:
-    # type=float|default=0.0: Map upper quantile and above to maxOutputRange. It should be a value between zero and one
-    outputEdgeMap:
-    # type=file: (required) output file name
-    # type=traitcompound|default=None: output edgemap file name
-    outputMaximumGradientImage:
-    # type=file: output gradient image file name
-    # type=traitcompound|default=None: output gradient image file name
-    numberOfThreads:
-    # type=int|default=0: Explicitly specify the maximum number of threads to use.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/generate_edge_map_image_callables.py b/example-specs/task/nipype_internal/pydra-semtools/generate_edge_map_image_callables.py
deleted file mode 100644
index ae2090d6..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/generate_edge_map_image_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in GenerateEdgeMapImage.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/generate_label_map_from_probability_map.yaml b/example-specs/task/nipype_internal/pydra-semtools/generate_label_map_from_probability_map.yaml
deleted file mode 100644
index ba2d6d53..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/generate_label_map_from_probability_map.yaml
+++ /dev/null
@@ -1,87 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.utilities.brains.GenerateLabelMapFromProbabilityMap' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Label Map from Probability Images
-# 
-#     category: Utilities.BRAINS
-# 
-#     description: Given a list of probability maps for labels, create a discrete label map where only the highest probability region is used for the labeling.
-# 
-#     version: 0.1
-# 
-#     contributor: University of Iowa Department of Psychiatry, http:://www.psychiatry.uiowa.edu
-#     
-task_name: GenerateLabelMapFromProbabilityMap
-nipype_name: GenerateLabelMapFromProbabilityMap
-nipype_module: nipype.interfaces.semtools.utilities.brains
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputVolumes: generic/file+list-of
-    # type=inputmultiobject|default=[]: The Input probaiblity images to be computed for label maps
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputLabelVolume: generic/file
-    # type=file: The Input binary image for region of interest
-    # type=traitcompound|default=None: The Input binary image for region of interest
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputVolumes:
-    # type=inputmultiobject|default=[]: The Input probaiblity images to be computed for label maps
-    outputLabelVolume:
-    # type=file: The Input binary image for region of interest
-    # type=traitcompound|default=None: The Input binary image for region of interest
-    numberOfThreads:
-    # type=int|default=0: Explicitly specify the maximum number of threads to use.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/generate_label_map_from_probability_map_callables.py b/example-specs/task/nipype_internal/pydra-semtools/generate_label_map_from_probability_map_callables.py
deleted file mode 100644
index 1a08ec5e..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/generate_label_map_from_probability_map_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in GenerateLabelMapFromProbabilityMap.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/generate_pure_plug_mask.yaml b/example-specs/task/nipype_internal/pydra-semtools/generate_pure_plug_mask.yaml
deleted file mode 100644
index 661149c2..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/generate_pure_plug_mask.yaml
+++ /dev/null
@@ -1,89 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.brains.utilities.GeneratePurePlugMask' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: GeneratePurePlugMask
-# 
-#     category: BRAINS.Utilities
-# 
-#     description: This program gets several modality image files and returns a binary mask that defines the pure plugs
-# 
-#     version: 1.0
-# 
-#     contributor: Ali Ghayoor
-#     
-task_name: GeneratePurePlugMask
-nipype_name: GeneratePurePlugMask
-nipype_module: nipype.interfaces.semtools.brains.utilities
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputImageModalities: generic/file+list-of
-    # type=inputmultiobject|default=[]: List of input image file names to create pure plugs mask
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputMaskFile: generic/file
-    # type=file: (required) Output binary mask file name
-    # type=traitcompound|default=None: Output binary mask file name
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputImageModalities:
-    # type=inputmultiobject|default=[]: List of input image file names to create pure plugs mask
-    threshold:
-    # type=float|default=0.0: threshold value to define class membership
-    numberOfSubSamples:
-    # type=inputmultiobject|default=[]: Number of continuous index samples taken at each direction of lattice space for each plug volume
-    outputMaskFile:
-    # type=file: (required) Output binary mask file name
-    # type=traitcompound|default=None: Output binary mask file name
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/generate_pure_plug_mask_callables.py b/example-specs/task/nipype_internal/pydra-semtools/generate_pure_plug_mask_callables.py
deleted file mode 100644
index 0d7df73d..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/generate_pure_plug_mask_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in GeneratePurePlugMask.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/generate_summed_gradient_image.yaml b/example-specs/task/nipype_internal/pydra-semtools/generate_summed_gradient_image.yaml
deleted file mode 100644
index fb227b86..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/generate_summed_gradient_image.yaml
+++ /dev/null
@@ -1,95 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.filtering.featuredetection.GenerateSummedGradientImage' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: GenerateSummedGradient
-# 
-#     category: Filtering.FeatureDetection
-# 
-#     description: Automatic FeatureImages using neural networks
-# 
-#     version: 1.0
-# 
-#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
-# 
-#     contributor: Greg Harris, Eun Young Kim
-#     
-task_name: GenerateSummedGradientImage
-nipype_name: GenerateSummedGradientImage
-nipype_module: nipype.interfaces.semtools.filtering.featuredetection
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputVolume1: generic/file
-    # type=file|default=<undefined>: input volume 1, usually t1 image
-    inputVolume2: generic/file
-    # type=file|default=<undefined>: input volume 2, usually t2 image
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputFileName: generic/file
-    # type=file: (required) output file name
-    # type=traitcompound|default=None: (required) output file name
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputVolume1:
-    # type=file|default=<undefined>: input volume 1, usually t1 image
-    inputVolume2:
-    # type=file|default=<undefined>: input volume 2, usually t2 image
-    outputFileName:
-    # type=file: (required) output file name
-    # type=traitcompound|default=None: (required) output file name
-    MaximumGradient:
-    # type=bool|default=False: If set this flag, it will compute maximum gradient between two input volumes instead of sum of it.
-    numberOfThreads:
-    # type=int|default=0: Explicitly specify the maximum number of threads to use.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/generate_summed_gradient_image_callables.py b/example-specs/task/nipype_internal/pydra-semtools/generate_summed_gradient_image_callables.py
deleted file mode 100644
index 16fe577e..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/generate_summed_gradient_image_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in GenerateSummedGradientImage.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/generate_test_image.yaml b/example-specs/task/nipype_internal/pydra-semtools/generate_test_image.yaml
deleted file mode 100644
index 0fde3121..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/generate_test_image.yaml
+++ /dev/null
@@ -1,93 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.filtering.featuredetection.GenerateTestImage' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: DownSampleImage
-# 
-#     category: Filtering.FeatureDetection
-# 
-#     description: Down sample image for testing
-# 
-#     version: 1.0
-# 
-#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
-# 
-#     contributor: Eun Young Kim
-#     
-task_name: GenerateTestImage
-nipype_name: GenerateTestImage
-nipype_module: nipype.interfaces.semtools.filtering.featuredetection
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputVolume: generic/file
-    # type=file|default=<undefined>: input volume 1, usually t1 image
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputVolume: generic/file
-    # type=file: (required) output file name
-    # type=traitcompound|default=None: (required) output file name
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputVolume:
-    # type=file|default=<undefined>: input volume 1, usually t1 image
-    outputVolume:
-    # type=file: (required) output file name
-    # type=traitcompound|default=None: (required) output file name
-    lowerBoundOfOutputVolume:
-    # type=float|default=0.0: 
-    upperBoundOfOutputVolume:
-    # type=float|default=0.0: 
-    outputVolumeSize:
-    # type=float|default=0.0: output Volume Size
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/generate_test_image_callables.py b/example-specs/task/nipype_internal/pydra-semtools/generate_test_image_callables.py
deleted file mode 100644
index 37295d92..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/generate_test_image_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in GenerateTestImage.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gradient_anisotropic_diffusion_image_filter.yaml b/example-specs/task/nipype_internal/pydra-semtools/gradient_anisotropic_diffusion_image_filter.yaml
deleted file mode 100644
index 063e0897..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/gradient_anisotropic_diffusion_image_filter.yaml
+++ /dev/null
@@ -1,89 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.filtering.featuredetection.GradientAnisotropicDiffusionImageFilter' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: GradientAnisopropicDiffusionFilter
-# 
-#     category: Filtering.FeatureDetection
-# 
-#     description: Image Smoothing using Gradient Anisotropic Diffuesion Filer
-# 
-#     contributor: This tool was developed by Eun Young Kim by modifying ITK Example
-#     
-task_name: GradientAnisotropicDiffusionImageFilter
-nipype_name: GradientAnisotropicDiffusionImageFilter
-nipype_module: nipype.interfaces.semtools.filtering.featuredetection
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputVolume: generic/file
-    # type=file|default=<undefined>: Required: input image
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputVolume: generic/file
-    # type=file: Required: output image
-    # type=traitcompound|default=None: Required: output image
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputVolume:
-    # type=file|default=<undefined>: Required: input image
-    numberOfIterations:
-    # type=int|default=0: Optional value for number of Iterations
-    timeStep:
-    # type=float|default=0.0: Time step for diffusion process
-    conductance:
-    # type=float|default=0.0: Conductance for diffusion process
-    outputVolume:
-    # type=file: Required: output image
-    # type=traitcompound|default=None: Required: output image
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gradient_anisotropic_diffusion_image_filter_callables.py b/example-specs/task/nipype_internal/pydra-semtools/gradient_anisotropic_diffusion_image_filter_callables.py
deleted file mode 100644
index 3de25b59..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/gradient_anisotropic_diffusion_image_filter_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in GradientAnisotropicDiffusionImageFilter.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_anisotropy_map.yaml b/example-specs/task/nipype_internal/pydra-semtools/gtract_anisotropy_map.yaml
deleted file mode 100644
index 342eea9b..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/gtract_anisotropy_map.yaml
+++ /dev/null
@@ -1,95 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.diffusion.gtract.gtractAnisotropyMap' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Anisotropy Map
-# 
-#     category: Diffusion.GTRACT
-# 
-#     description: This program will generate a scalar map of anisotropy, given a tensor representation. Anisotropy images are used for fiber tracking, but the anisotropy scalars are not defined along the path. Instead, the tensor representation is included as point data allowing all of these metrics to be computed using only the fiber tract point data. The images can be saved in any ITK supported format, but it is suggested that you use an image format that supports the definition of the image origin. This includes NRRD, NifTI, and Meta formats. These images can also be used for scalar analysis including regional anisotropy measures or VBM style analysis.
-# 
-#     version: 4.0.0
-# 
-#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Modules:GTRACT
-# 
-#     license: http://mri.radiology.uiowa.edu/copyright/GTRACT-Copyright.txt
-# 
-#     contributor: This tool was developed by Vincent Magnotta and Greg Harris.
-# 
-#     acknowledgements: Funding for this version of the GTRACT program was provided by NIH/NINDS R01NS050568-01A2S1
-#     
-task_name: gtractAnisotropyMap
-nipype_name: gtractAnisotropyMap
-nipype_module: nipype.interfaces.semtools.diffusion.gtract
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputTensorVolume: generic/file
-    # type=file|default=<undefined>: Required: input file containing the diffusion tensor image
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputVolume: generic/file
-    # type=file: Required: name of output NRRD file containing the selected kind of anisotropy scalar.
-    # type=traitcompound|default=None: Required: name of output NRRD file containing the selected kind of anisotropy scalar.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputTensorVolume:
-    # type=file|default=<undefined>: Required: input file containing the diffusion tensor image
-    anisotropyType:
-    # type=enum|default='ADC'|allowed['AD','ADC','FA','LI','RA','RD','VR']: Anisotropy Mapping Type: ADC, FA, RA, VR, AD, RD, LI
-    outputVolume:
-    # type=file: Required: name of output NRRD file containing the selected kind of anisotropy scalar.
-    # type=traitcompound|default=None: Required: name of output NRRD file containing the selected kind of anisotropy scalar.
-    numberOfThreads:
-    # type=int|default=0: Explicitly specify the maximum number of threads to use.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_anisotropy_map_callables.py b/example-specs/task/nipype_internal/pydra-semtools/gtract_anisotropy_map_callables.py
deleted file mode 100644
index 326b5aa3..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/gtract_anisotropy_map_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in gtractAnisotropyMap.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_average_bvalues.yaml b/example-specs/task/nipype_internal/pydra-semtools/gtract_average_bvalues.yaml
deleted file mode 100644
index 3d601962..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/gtract_average_bvalues.yaml
+++ /dev/null
@@ -1,97 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.diffusion.gtract.gtractAverageBvalues' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Average B-Values
-# 
-#     category: Diffusion.GTRACT
-# 
-#     description: This program will directly average together the baseline gradients (b value equals 0) within a DWI scan. This is usually used after gtractCoregBvalues.
-# 
-#     version: 4.0.0
-# 
-#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Modules:GTRACT
-# 
-#     license: http://mri.radiology.uiowa.edu/copyright/GTRACT-Copyright.txt
-# 
-#     contributor: This tool was developed by Vincent Magnotta and Greg Harris.
-# 
-#     acknowledgements: Funding for this version of the GTRACT program was provided by NIH/NINDS R01NS050568-01A2S1
-#     
-task_name: gtractAverageBvalues
-nipype_name: gtractAverageBvalues
-nipype_module: nipype.interfaces.semtools.diffusion.gtract
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputVolume: generic/file
-    # type=file|default=<undefined>: Required: input image file name containing multiple baseline gradients to average
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputVolume: generic/file
-    # type=file: Required: name of output NRRD file containing directly averaged baseline images
-    # type=traitcompound|default=None: Required: name of output NRRD file containing directly averaged baseline images
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputVolume:
-    # type=file|default=<undefined>: Required: input image file name containing multiple baseline gradients to average
-    outputVolume:
-    # type=file: Required: name of output NRRD file containing directly averaged baseline images
-    # type=traitcompound|default=None: Required: name of output NRRD file containing directly averaged baseline images
-    directionsTolerance:
-    # type=float|default=0.0: Tolerance for matching identical gradient direction pairs
-    averageB0only:
-    # type=bool|default=False: Average only baseline gradients. All other gradient directions are not averaged, but retained in the outputVolume
-    numberOfThreads:
-    # type=int|default=0: Explicitly specify the maximum number of threads to use.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_average_bvalues_callables.py b/example-specs/task/nipype_internal/pydra-semtools/gtract_average_bvalues_callables.py
deleted file mode 100644
index 776c1057..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/gtract_average_bvalues_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in gtractAverageBvalues.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_clip_anisotropy.yaml b/example-specs/task/nipype_internal/pydra-semtools/gtract_clip_anisotropy.yaml
deleted file mode 100644
index 39cb7ac0..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/gtract_clip_anisotropy.yaml
+++ /dev/null
@@ -1,97 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.diffusion.gtract.gtractClipAnisotropy' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Clip Anisotropy
-# 
-#     category: Diffusion.GTRACT
-# 
-#     description: This program will zero the first and/or last slice of an anisotropy image, creating a clipped anisotropy image.
-# 
-#     version: 4.0.0
-# 
-#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Modules:GTRACT
-# 
-#     license: http://mri.radiology.uiowa.edu/copyright/GTRACT-Copyright.txt
-# 
-#     contributor: This tool was developed by Vincent Magnotta and Greg Harris.
-# 
-#     acknowledgements: Funding for this version of the GTRACT program was provided by NIH/NINDS R01NS050568-01A2S1
-#     
-task_name: gtractClipAnisotropy
-nipype_name: gtractClipAnisotropy
-nipype_module: nipype.interfaces.semtools.diffusion.gtract
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputVolume: generic/file
-    # type=file|default=<undefined>: Required: input image file name
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputVolume: generic/file
-    # type=file: Required: name of output NRRD file containing the clipped anisotropy image
-    # type=traitcompound|default=None: Required: name of output NRRD file containing the clipped anisotropy image
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputVolume:
-    # type=file|default=<undefined>: Required: input image file name
-    outputVolume:
-    # type=file: Required: name of output NRRD file containing the clipped anisotropy image
-    # type=traitcompound|default=None: Required: name of output NRRD file containing the clipped anisotropy image
-    clipFirstSlice:
-    # type=bool|default=False: Clip the first slice of the anisotropy image
-    clipLastSlice:
-    # type=bool|default=False: Clip the last slice of the anisotropy image
-    numberOfThreads:
-    # type=int|default=0: Explicitly specify the maximum number of threads to use.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_clip_anisotropy_callables.py b/example-specs/task/nipype_internal/pydra-semtools/gtract_clip_anisotropy_callables.py
deleted file mode 100644
index 3fddaef0..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/gtract_clip_anisotropy_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in gtractClipAnisotropy.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_co_reg_anatomy.yaml b/example-specs/task/nipype_internal/pydra-semtools/gtract_co_reg_anatomy.yaml
deleted file mode 100644
index 920d3ccf..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/gtract_co_reg_anatomy.yaml
+++ /dev/null
@@ -1,139 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.diffusion.gtract.gtractCoRegAnatomy' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Coregister B0 to Anatomy B-Spline
-# 
-#     category: Diffusion.GTRACT
-# 
-#     description: This program will register a Nrrd diffusion weighted 4D vector image to a fixed anatomical image. Two registration methods are supported for alignment with anatomical images: Rigid and B-Spline. The rigid registration performs a rigid body registration with the anatomical images and should be done as well to initialize the B-Spline transform. The B-SPline transform is the deformable transform, where the user can control the amount of deformation based on the number of control points as well as the maximum distance that these points can move. The B-Spline registration places a low dimensional grid in the image, which is deformed. This allows for some susceptibility related distortions to be removed from the diffusion weighted images. In general the amount of motion in the slice selection and read-out directions direction should be kept low. The distortion is in the phase encoding direction in the images. It is recommended that skull stripped (i.e. image containing only brain with skull removed) images should be used for image co-registration with the B-Spline transform.
-# 
-#     version: 4.0.0
-# 
-#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Modules:GTRACT
-# 
-#     license: http://mri.radiology.uiowa.edu/copyright/GTRACT-Copyright.txt
-# 
-#     contributor: This tool was developed by Vincent Magnotta and Greg Harris.
-# 
-#     acknowledgements: Funding for this version of the GTRACT program was provided by NIH/NINDS R01NS050568-01A2S1
-#     
-task_name: gtractCoRegAnatomy
-nipype_name: gtractCoRegAnatomy
-nipype_module: nipype.interfaces.semtools.diffusion.gtract
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputVolume: generic/file
-    # type=file|default=<undefined>: Required: input vector image file name. It is recommended that the input volume is the skull stripped baseline image of the DWI scan.
-    inputAnatomicalVolume: generic/file
-    # type=file|default=<undefined>: Required: input anatomical image file name. It is recommended that the input anatomical image has been skull stripped and has the same orientation as the DWI scan.
-    inputRigidTransform: generic/file
-    # type=file|default=<undefined>: Required (for B-Spline type co-registration): input rigid transform file name. Used as a starting point for the anatomical B-Spline registration.
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputTransformName: generic/file
-    # type=file: Required: filename for the  fit transform.
-    # type=traitcompound|default=None: Required: filename for the  fit transform.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputVolume:
-    # type=file|default=<undefined>: Required: input vector image file name. It is recommended that the input volume is the skull stripped baseline image of the DWI scan.
-    inputAnatomicalVolume:
-    # type=file|default=<undefined>: Required: input anatomical image file name. It is recommended that the input anatomical image has been skull stripped and has the same orientation as the DWI scan.
-    vectorIndex:
-    # type=int|default=0: Vector image index in the moving image (within the DWI) to be used for registration.
-    inputRigidTransform:
-    # type=file|default=<undefined>: Required (for B-Spline type co-registration): input rigid transform file name. Used as a starting point for the anatomical B-Spline registration.
-    outputTransformName:
-    # type=file: Required: filename for the  fit transform.
-    # type=traitcompound|default=None: Required: filename for the  fit transform.
-    transformType:
-    # type=enum|default='Rigid'|allowed['Bspline','Rigid']: Transform Type: Rigid|Bspline
-    numberOfIterations:
-    # type=int|default=0: Number of iterations in the selected 3D fit
-    gridSize:
-    # type=inputmultiobject|default=[]: Number of grid subdivisions in all 3 directions
-    borderSize:
-    # type=int|default=0: Size of border
-    numberOfHistogramBins:
-    # type=int|default=0: Number of histogram bins
-    spatialScale:
-    # type=int|default=0: Scales the number of voxels in the image by this value to specify the number of voxels used in the registration
-    convergence:
-    # type=float|default=0.0: Convergence Factor
-    gradientTolerance:
-    # type=float|default=0.0: Gradient Tolerance
-    maxBSplineDisplacement:
-    # type=float|default=0.0:  Sets the maximum allowed displacements in image physical coordinates for BSpline control grid along each axis.  A value of 0.0 indicates that the problem should be unbounded.  NOTE:  This only constrains the BSpline portion, and does not limit the displacement from the associated bulk transform.  This can lead to a substantial reduction in computation time in the BSpline optimizer.,       
-    maximumStepSize:
-    # type=float|default=0.0: Maximum permitted step size to move in the selected 3D fit
-    minimumStepSize:
-    # type=float|default=0.0: Minimum required step size to move in the selected 3D fit without converging -- decrease this to make the fit more exacting
-    translationScale:
-    # type=float|default=0.0: How much to scale up changes in position compared to unit rotational changes in radians -- decrease this to put more translation in the fit
-    relaxationFactor:
-    # type=float|default=0.0: Fraction of gradient from Jacobian to attempt to move in the selected 3D fit
-    numberOfSamples:
-    # type=int|default=0: The number of voxels sampled for mutual information computation.  Increase this for a slower, more careful fit. NOTE that it is suggested to use samplingPercentage instead of this option. However, if set, it overwrites the samplingPercentage option.  
-    samplingPercentage:
-    # type=float|default=0.0: This is a number in (0.0,1.0] interval that shows the percentage of the input fixed image voxels that are sampled for mutual information computation.  Increase this for a slower, more careful fit. You can also limit the sampling focus with ROI masks and ROIAUTO mask generation. The default is to use approximately 5% of voxels (for backwards compatibility 5% ~= 500000/(256*256*256)). Typical values range from 1% for low detail images to 20% for high detail images.
-    useMomentsAlign:
-    # type=bool|default=False: MomentsAlign assumes that the center of mass of the images represent similar structures.  Perform a MomentsAlign registration as part of the sequential registration steps.   This option MUST come first, and CAN NOT be used with either CenterOfHeadLAlign, GeometryAlign, or initialTransform file.  This family of options superceeds the use of transformType if any of them are set.
-    useGeometryAlign:
-    # type=bool|default=False: GeometryAlign on assumes that the center of the voxel lattice of the images represent similar structures. Perform a GeometryCenterAlign registration as part of the sequential registration steps.   This option MUST come first, and CAN NOT be used with either MomentsAlign, CenterOfHeadAlign, or initialTransform file.  This family of options superceeds the use of transformType if any of them are set.
-    useCenterOfHeadAlign:
-    # type=bool|default=False: CenterOfHeadAlign attempts to find a hemisphere full of foreground voxels from the superior direction as an estimate of where the center of a head shape would be to drive a center of mass estimate.  Perform a CenterOfHeadAlign registration as part of the sequential registration steps.   This option MUST come first, and CAN NOT be used with either MomentsAlign, GeometryAlign, or initialTransform file.  This family of options superceeds the use of transformType if any of them are set.
-    numberOfThreads:
-    # type=int|default=0: Explicitly specify the maximum number of threads to use.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_co_reg_anatomy_callables.py b/example-specs/task/nipype_internal/pydra-semtools/gtract_co_reg_anatomy_callables.py
deleted file mode 100644
index 41723e80..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/gtract_co_reg_anatomy_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in gtractCoRegAnatomy.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_concat_dwi.yaml b/example-specs/task/nipype_internal/pydra-semtools/gtract_concat_dwi.yaml
deleted file mode 100644
index 8d8032b0..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/gtract_concat_dwi.yaml
+++ /dev/null
@@ -1,95 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.diffusion.gtract.gtractConcatDwi' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Concat DWI Images
-# 
-#     category: Diffusion.GTRACT
-# 
-#     description: This program will concatenate two DTI runs together.
-# 
-#     version: 4.0.0
-# 
-#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Modules:GTRACT
-# 
-#     license: http://mri.radiology.uiowa.edu/copyright/GTRACT-Copyright.txt
-# 
-#     contributor: This tool was developed by Vincent Magnotta and Greg Harris.
-# 
-#     acknowledgements: Funding for this version of the GTRACT program was provided by NIH/NINDS R01NS050568-01A2S1
-#     
-task_name: gtractConcatDwi
-nipype_name: gtractConcatDwi
-nipype_module: nipype.interfaces.semtools.diffusion.gtract
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputVolume: generic/file+list-of
-    # type=inputmultiobject|default=[]: Required: input file containing the first diffusion weighted image
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputVolume: generic/file
-    # type=file: Required: name of output NRRD file containing the combined diffusion weighted images.
-    # type=traitcompound|default=None: Required: name of output NRRD file containing the combined diffusion weighted images.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputVolume:
-    # type=inputmultiobject|default=[]: Required: input file containing the first diffusion weighted image
-    ignoreOrigins:
-    # type=bool|default=False: If image origins are different force all images to origin of first image
-    outputVolume:
-    # type=file: Required: name of output NRRD file containing the combined diffusion weighted images.
-    # type=traitcompound|default=None: Required: name of output NRRD file containing the combined diffusion weighted images.
-    numberOfThreads:
-    # type=int|default=0: Explicitly specify the maximum number of threads to use.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_concat_dwi_callables.py b/example-specs/task/nipype_internal/pydra-semtools/gtract_concat_dwi_callables.py
deleted file mode 100644
index 88e971f4..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/gtract_concat_dwi_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in gtractConcatDwi.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_copy_image_orientation.yaml b/example-specs/task/nipype_internal/pydra-semtools/gtract_copy_image_orientation.yaml
deleted file mode 100644
index 2ea89e23..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/gtract_copy_image_orientation.yaml
+++ /dev/null
@@ -1,97 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.diffusion.gtract.gtractCopyImageOrientation' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Copy Image Orientation
-# 
-#     category: Diffusion.GTRACT
-# 
-#     description: This program will copy the orientation from the reference image into the moving image. Currently, the registration process requires that the diffusion weighted images and the anatomical images have the same image orientation (i.e. Axial, Coronal, Sagittal). It is suggested that you copy the image orientation from the diffusion weighted images and apply this to the anatomical image. This image can be subsequently removed after the registration step is complete. We anticipate that this limitation will be removed in future versions of the registration programs.
-# 
-#     version: 4.0.0
-# 
-#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Modules:GTRACT
-# 
-#     license: http://mri.radiology.uiowa.edu/copyright/GTRACT-Copyright.txt
-# 
-#     contributor: This tool was developed by Vincent Magnotta and Greg Harris.
-# 
-#     acknowledgements: Funding for this version of the GTRACT program was provided by NIH/NINDS R01NS050568-01A2S1
-#     
-task_name: gtractCopyImageOrientation
-nipype_name: gtractCopyImageOrientation
-nipype_module: nipype.interfaces.semtools.diffusion.gtract
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputVolume: generic/file
-    # type=file|default=<undefined>: Required: input file containing the signed short image to reorient without resampling.
-    inputReferenceVolume: generic/file
-    # type=file|default=<undefined>: Required: input file containing orientation that will be cloned.
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputVolume: generic/file
-    # type=file: Required: name of output NRRD or Nifti file containing the reoriented image in reference image space.
-    # type=traitcompound|default=None: Required: name of output NRRD or Nifti file containing the reoriented image in reference image space.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputVolume:
-    # type=file|default=<undefined>: Required: input file containing the signed short image to reorient without resampling.
-    inputReferenceVolume:
-    # type=file|default=<undefined>: Required: input file containing orientation that will be cloned.
-    outputVolume:
-    # type=file: Required: name of output NRRD or Nifti file containing the reoriented image in reference image space.
-    # type=traitcompound|default=None: Required: name of output NRRD or Nifti file containing the reoriented image in reference image space.
-    numberOfThreads:
-    # type=int|default=0: Explicitly specify the maximum number of threads to use.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_copy_image_orientation_callables.py b/example-specs/task/nipype_internal/pydra-semtools/gtract_copy_image_orientation_callables.py
deleted file mode 100644
index bf2f62c7..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/gtract_copy_image_orientation_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in gtractCopyImageOrientation.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_coreg_bvalues.yaml b/example-specs/task/nipype_internal/pydra-semtools/gtract_coreg_bvalues.yaml
deleted file mode 100644
index 061881e1..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/gtract_coreg_bvalues.yaml
+++ /dev/null
@@ -1,125 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.diffusion.gtract.gtractCoregBvalues' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Coregister B-Values
-# 
-#     category: Diffusion.GTRACT
-# 
-#     description: This step should be performed after converting DWI scans from DICOM to NRRD format. This program will register all gradients in a NRRD diffusion weighted 4D vector image (moving image) to a specified index in a fixed image. It also supports co-registration with a T2 weighted image or field map in the same plane as the DWI data. The fixed image for the registration should be a b0 image. A mutual information metric cost function is used for the registration because of the differences in signal intensity as a result of the diffusion gradients. The full affine allows the registration procedure to correct for eddy current distortions that may exist in the data. If the eddyCurrentCorrection is enabled, relaxationFactor (0.25) and maximumStepSize (0.1) should be adjusted.
-# 
-#     version: 4.0.0
-# 
-#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Modules:GTRACT
-# 
-#     license: http://mri.radiology.uiowa.edu/copyright/GTRACT-Copyright.txt
-# 
-#     contributor: This tool was developed by Vincent Magnotta and Greg Harris.
-# 
-#     acknowledgements: Funding for this version of the GTRACT program was provided by NIH/NINDS R01NS050568-01A2S1
-#     
-task_name: gtractCoregBvalues
-nipype_name: gtractCoregBvalues
-nipype_module: nipype.interfaces.semtools.diffusion.gtract
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    movingVolume: generic/file
-    # type=file|default=<undefined>: Required: input moving image file name. In order to register gradients within a scan to its first gradient, set the movingVolume and fixedVolume as the same image.
-    fixedVolume: generic/file
-    # type=file|default=<undefined>: Required: input fixed image file name. It is recommended that this image should either contain or be a b0 image.
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputVolume: generic/file
-    # type=file: Required: name of output NRRD file containing moving images individually resampled and fit to the specified fixed image index.
-    # type=traitcompound|default=None: Required: name of output NRRD file containing moving images individually resampled and fit to the specified fixed image index.
-    outputTransform: generic/file
-    # type=file: Registration 3D transforms concatenated in a single output file.  There are no tools that can use this, but can be used for debugging purposes.
-    # type=traitcompound|default=None: Registration 3D transforms concatenated in a single output file.  There are no tools that can use this, but can be used for debugging purposes.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    movingVolume:
-    # type=file|default=<undefined>: Required: input moving image file name. In order to register gradients within a scan to its first gradient, set the movingVolume and fixedVolume as the same image.
-    fixedVolume:
-    # type=file|default=<undefined>: Required: input fixed image file name. It is recommended that this image should either contain or be a b0 image.
-    fixedVolumeIndex:
-    # type=int|default=0: Index in the fixed image for registration. It is recommended that this image should be a b0 image.
-    outputVolume:
-    # type=file: Required: name of output NRRD file containing moving images individually resampled and fit to the specified fixed image index.
-    # type=traitcompound|default=None: Required: name of output NRRD file containing moving images individually resampled and fit to the specified fixed image index.
-    outputTransform:
-    # type=file: Registration 3D transforms concatenated in a single output file.  There are no tools that can use this, but can be used for debugging purposes.
-    # type=traitcompound|default=None: Registration 3D transforms concatenated in a single output file.  There are no tools that can use this, but can be used for debugging purposes.
-    eddyCurrentCorrection:
-    # type=bool|default=False: Flag to perform eddy current correction in addition to motion correction (recommended)
-    numberOfIterations:
-    # type=int|default=0: Number of iterations in each 3D fit
-    numberOfSpatialSamples:
-    # type=int|default=0: The number of voxels sampled for mutual information computation.  Increase this for a slower, more careful fit. NOTE that it is suggested to use samplingPercentage instead of this option. However, if set, it overwrites the samplingPercentage option.  
-    samplingPercentage:
-    # type=float|default=0.0: This is a number in (0.0,1.0] interval that shows the percentage of the input fixed image voxels that are sampled for mutual information computation.  Increase this for a slower, more careful fit. You can also limit the sampling focus with ROI masks and ROIAUTO mask generation. The default is to use approximately 5% of voxels (for backwards compatibility 5% ~= 500000/(256*256*256)). Typical values range from 1% for low detail images to 20% for high detail images.
-    relaxationFactor:
-    # type=float|default=0.0: Fraction of gradient from Jacobian to attempt to move in each 3D fit step (adjust when eddyCurrentCorrection is enabled; suggested value = 0.25)
-    maximumStepSize:
-    # type=float|default=0.0: Maximum permitted step size to move in each 3D fit step (adjust when eddyCurrentCorrection is enabled; suggested value = 0.1)
-    minimumStepSize:
-    # type=float|default=0.0: Minimum required step size to move in each 3D fit step without converging -- decrease this to make the fit more exacting
-    spatialScale:
-    # type=float|default=0.0: How much to scale up changes in position compared to unit rotational changes in radians -- decrease this to put more rotation in the fit
-    registerB0Only:
-    # type=bool|default=False: Register the B0 images only
-    debugLevel:
-    # type=int|default=0: Display debug messages, and produce debug intermediate results.  0=OFF, 1=Minimal, 10=Maximum debugging.
-    numberOfThreads:
-    # type=int|default=0: Explicitly specify the maximum number of threads to use.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_coreg_bvalues_callables.py b/example-specs/task/nipype_internal/pydra-semtools/gtract_coreg_bvalues_callables.py
deleted file mode 100644
index 44f534c9..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/gtract_coreg_bvalues_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in gtractCoregBvalues.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_cost_fast_marching.yaml b/example-specs/task/nipype_internal/pydra-semtools/gtract_cost_fast_marching.yaml
deleted file mode 100644
index c266a400..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/gtract_cost_fast_marching.yaml
+++ /dev/null
@@ -1,115 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.diffusion.gtract.gtractCostFastMarching' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Cost Fast Marching
-# 
-#     category: Diffusion.GTRACT
-# 
-#     description: This program will use a fast marching fiber tracking algorithm to identify fiber tracts from a tensor image. This program is the first portion of the algorithm. The user must first run gtractFastMarchingTracking to generate the actual fiber tracts.  This algorithm is roughly based on the work by G. Parker et al. from IEEE Transactions On Medical Imaging, 21(5): 505-512, 2002. An additional feature of including anisotropy into the vcl_cost function calculation is included.
-# 
-#     version: 4.0.0
-# 
-#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Modules:GTRACT
-# 
-#     license: http://mri.radiology.uiowa.edu/copyright/GTRACT-Copyright.txt
-# 
-#     contributor: This tool was developed by Vincent Magnotta and Greg Harris. The original code here was developed by Daisy Espino.
-# 
-#     acknowledgements: Funding for this version of the GTRACT program was provided by NIH/NINDS R01NS050568-01A2S1
-#     
-task_name: gtractCostFastMarching
-nipype_name: gtractCostFastMarching
-nipype_module: nipype.interfaces.semtools.diffusion.gtract
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputTensorVolume: generic/file
-    # type=file|default=<undefined>: Required: input tensor image file name
-    inputAnisotropyVolume: generic/file
-    # type=file|default=<undefined>: Required: input anisotropy image file name
-    inputStartingSeedsLabelMapVolume: generic/file
-    # type=file|default=<undefined>: Required: input starting seeds LabelMap image file name
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputCostVolume: generic/file
-    # type=file: Output vcl_cost image
-    # type=traitcompound|default=None: Output vcl_cost image
-    outputSpeedVolume: generic/file
-    # type=file: Output speed image
-    # type=traitcompound|default=None: Output speed image
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputTensorVolume:
-    # type=file|default=<undefined>: Required: input tensor image file name
-    inputAnisotropyVolume:
-    # type=file|default=<undefined>: Required: input anisotropy image file name
-    inputStartingSeedsLabelMapVolume:
-    # type=file|default=<undefined>: Required: input starting seeds LabelMap image file name
-    startingSeedsLabel:
-    # type=int|default=0: Label value for Starting Seeds
-    outputCostVolume:
-    # type=file: Output vcl_cost image
-    # type=traitcompound|default=None: Output vcl_cost image
-    outputSpeedVolume:
-    # type=file: Output speed image
-    # type=traitcompound|default=None: Output speed image
-    anisotropyWeight:
-    # type=float|default=0.0: Anisotropy weight used for vcl_cost function calculations
-    stoppingValue:
-    # type=float|default=0.0: Terminiating value for vcl_cost function estimation
-    seedThreshold:
-    # type=float|default=0.0: Anisotropy threshold used for seed selection
-    numberOfThreads:
-    # type=int|default=0: Explicitly specify the maximum number of threads to use.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_cost_fast_marching_callables.py b/example-specs/task/nipype_internal/pydra-semtools/gtract_cost_fast_marching_callables.py
deleted file mode 100644
index 86210563..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/gtract_cost_fast_marching_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in gtractCostFastMarching.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_create_guide_fiber.yaml b/example-specs/task/nipype_internal/pydra-semtools/gtract_create_guide_fiber.yaml
deleted file mode 100644
index 125a8cc6..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/gtract_create_guide_fiber.yaml
+++ /dev/null
@@ -1,97 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.diffusion.gtract.gtractCreateGuideFiber' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Create Guide Fiber
-# 
-#     category: Diffusion.GTRACT
-# 
-#     description: This program will create a guide fiber by averaging fibers from a previously generated tract.
-# 
-#     version: 4.0.0
-# 
-#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Modules:GTRACT
-# 
-#     license: http://mri.radiology.uiowa.edu/copyright/GTRACT-Copyright.txt
-# 
-#     contributor: This tool was developed by Vincent Magnotta and Greg Harris.
-# 
-#     acknowledgements: Funding for this version of the GTRACT program was provided by NIH/NINDS R01NS050568-01A2S1
-#     
-task_name: gtractCreateGuideFiber
-nipype_name: gtractCreateGuideFiber
-nipype_module: nipype.interfaces.semtools.diffusion.gtract
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputFiber: generic/file
-    # type=file|default=<undefined>: Required: input fiber tract file name
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputFiber: generic/file
-    # type=file: Required: output guide fiber file name
-    # type=traitcompound|default=None: Required: output guide fiber file name
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputFiber:
-    # type=file|default=<undefined>: Required: input fiber tract file name
-    numberOfPoints:
-    # type=int|default=0: Number of points in output guide fiber
-    outputFiber:
-    # type=file: Required: output guide fiber file name
-    # type=traitcompound|default=None: Required: output guide fiber file name
-    writeXMLPolyDataFile:
-    # type=bool|default=False: Flag to make use of XML files when reading and writing vtkPolyData.
-    numberOfThreads:
-    # type=int|default=0: Explicitly specify the maximum number of threads to use.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_create_guide_fiber_callables.py b/example-specs/task/nipype_internal/pydra-semtools/gtract_create_guide_fiber_callables.py
deleted file mode 100644
index 52b4e240..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/gtract_create_guide_fiber_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in gtractCreateGuideFiber.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_fast_marching_tracking.yaml b/example-specs/task/nipype_internal/pydra-semtools/gtract_fast_marching_tracking.yaml
deleted file mode 100644
index 16a88617..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/gtract_fast_marching_tracking.yaml
+++ /dev/null
@@ -1,121 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.diffusion.gtract.gtractFastMarchingTracking' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Fast Marching Tracking
-# 
-#     category: Diffusion.GTRACT
-# 
-#     description: This program will use a fast marching fiber tracking algorithm to identify fiber tracts from a tensor image. This program is the second portion of the algorithm. The user must first run gtractCostFastMarching to generate the vcl_cost image. The second step of the algorithm implemented here is a gradient descent soplution from the defined ending region back to the seed points specified in gtractCostFastMarching. This algorithm is roughly based on the work by G. Parker et al. from IEEE Transactions On Medical Imaging, 21(5): 505-512, 2002. An additional feature of including anisotropy into the vcl_cost function calculation is included.
-# 
-#     version: 4.0.0
-# 
-#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Modules:GTRACT
-# 
-#     license: http://mri.radiology.uiowa.edu/copyright/GTRACT-Copyright.txt
-# 
-#     contributor: This tool was developed by Vincent Magnotta and Greg Harris. The original code here was developed by Daisy Espino.
-# 
-#     acknowledgements: Funding for this version of the GTRACT program was provided by NIH/NINDS R01NS050568-01A2S1
-#     
-task_name: gtractFastMarchingTracking
-nipype_name: gtractFastMarchingTracking
-nipype_module: nipype.interfaces.semtools.diffusion.gtract
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputTensorVolume: generic/file
-    # type=file|default=<undefined>: Required: input tensor image file name
-    inputAnisotropyVolume: generic/file
-    # type=file|default=<undefined>: Required: input anisotropy image file name
-    inputCostVolume: generic/file
-    # type=file|default=<undefined>: Required: input vcl_cost image file name
-    inputStartingSeedsLabelMapVolume: generic/file
-    # type=file|default=<undefined>: Required: input starting seeds LabelMap image file name
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputTract: generic/file
-    # type=file: Required: name of output vtkPolydata file containing tract lines and the point data collected along them.
-    # type=traitcompound|default=None: Required: name of output vtkPolydata file containing tract lines and the point data collected along them.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputTensorVolume:
-    # type=file|default=<undefined>: Required: input tensor image file name
-    inputAnisotropyVolume:
-    # type=file|default=<undefined>: Required: input anisotropy image file name
-    inputCostVolume:
-    # type=file|default=<undefined>: Required: input vcl_cost image file name
-    inputStartingSeedsLabelMapVolume:
-    # type=file|default=<undefined>: Required: input starting seeds LabelMap image file name
-    startingSeedsLabel:
-    # type=int|default=0: Label value for Starting Seeds
-    outputTract:
-    # type=file: Required: name of output vtkPolydata file containing tract lines and the point data collected along them.
-    # type=traitcompound|default=None: Required: name of output vtkPolydata file containing tract lines and the point data collected along them.
-    writeXMLPolyDataFile:
-    # type=bool|default=False: Flag to make use of the XML format for vtkPolyData fiber tracts.
-    numberOfIterations:
-    # type=int|default=0: Number of iterations used for the optimization
-    seedThreshold:
-    # type=float|default=0.0: Anisotropy threshold used for seed selection
-    trackingThreshold:
-    # type=float|default=0.0: Anisotropy threshold used for fiber tracking
-    costStepSize:
-    # type=float|default=0.0: Cost image sub-voxel sampling
-    maximumStepSize:
-    # type=float|default=0.0: Maximum step size to move when tracking
-    minimumStepSize:
-    # type=float|default=0.0: Minimum step size to move when tracking
-    numberOfThreads:
-    # type=int|default=0: Explicitly specify the maximum number of threads to use.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_fast_marching_tracking_callables.py b/example-specs/task/nipype_internal/pydra-semtools/gtract_fast_marching_tracking_callables.py
deleted file mode 100644
index 09ef0831..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/gtract_fast_marching_tracking_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in gtractFastMarchingTracking.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_fiber_tracking.yaml b/example-specs/task/nipype_internal/pydra-semtools/gtract_fiber_tracking.yaml
deleted file mode 100644
index eba31ce0..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/gtract_fiber_tracking.yaml
+++ /dev/null
@@ -1,151 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.diffusion.gtract.gtractFiberTracking' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Fiber Tracking
-# 
-#     category: Diffusion.GTRACT
-# 
-#     description: This program implements four fiber tracking methods (Free, Streamline, GraphSearch, Guided). The output of the fiber tracking is vtkPolyData (i.e. Polylines) that can be loaded into Slicer3 for visualization. The poly data can be saved in either old VTK format files (.vtk) or in the new VTK XML format (.xml). The polylines contain point data that defines the Tensor at each point along the fiber tract. This can then be used to rendered as glyphs in Slicer3 and can be used to define several scalar measures without referencing back to the anisotropy images. (1) Free tracking is a basic streamlines algorithm. This is a direct implementation of the method original proposed by Basser et al. The tracking follows the primarty eigenvector. The tracking begins with seed points in the starting region. Only those voxels above the specified anisotropy threshold in the starting region are used as seed points. Tracking terminates either as a result of maximum fiber length, low ansiotropy, or large curvature. This is a great way to explore your data. (2) The streamlines algorithm is a direct implementation of the method originally proposed by Basser et al. The tracking follows the primary eigenvector. The tracking begins with seed points in the starting region. Only those voxels above the specified anisotropy threshold in the starting region are used as seed points. Tracking terminates either by reaching the ending region or reaching some stopping criteria. Stopping criteria are specified using the following parameters: tracking threshold, curvature threshold, and max length. Only paths terminating in the ending region are kept in this method. The TEND algorithm proposed by Lazar et al. (Human Brain Mapping 18:306-321, 2003) has been instrumented. This can be enabled using the --useTend option while performing Streamlines tracking. This utilizes the entire diffusion tensor to deflect the incoming vector instead of simply following the primary eigenvector. The TEND parameters are set using the --tendF and --tendG options. (3) Graph Search tracking is the first step in the full GTRACT algorithm developed by Cheng et al. (NeuroImage 31(3): 1075-1085, 2006) for finding the tracks in a tensor image. This method was developed to generate fibers in a Tensor representation where crossing fibers occur. The graph search algorithm follows the primary eigenvector in non-ambiguous regions and utilizes branching and a graph search algorithm in ambiguous regions. Ambiguous tracking regions are defined based on two criteria: Branching Al Threshold (anisotropy values below this value and above the traching threshold) and Curvature Major Eigen (angles of the primary eigenvector direction and the current tracking direction). In regions that meet this criteria, two or three tracking paths are considered. The first is the standard primary eigenvector direction. The second is the seconadary eigenvector direction. This is based on the assumption that these regions may be prolate regions. If the Random Walk option is selected then a third direction is also considered. This direction is defined by a cone pointing from the current position to the centroid of the ending region. The interior angle of the cone is specified by the user with the Branch/Guide Angle parameter. A vector contained inside of the cone is selected at random and used as the third direction. This method can also utilize the TEND option where the primary tracking direction is that specified by the TEND method instead of the primary eigenvector. The parameter '--maximumBranchPoints' allows the tracking to have this number of branches being considered at a time. If this number of branch points is exceeded at any time, then the algorithm will revert back to a streamline algorithm until the number of branches is reduced. This allows the user to constrain the computational complexity of the algorithm. (4) The second phase of the GTRACT algorithm is Guided Tracking. This method incorporates anatomical information about the track orientation using an initial guess of the fiber track. In the originally proposed GTRACT method, this would be created from the fibers resulting from the Graph Search tracking. However, in practice this can be created using any method and could be defined manually. To create the guide fiber the program gtractCreateGuideFiber can be used. This program will load a fiber tract that has been generated and create a centerline representation of the fiber tract (i.e. a single fiber). In this method, the fiber tracking follows the primary eigenvector direction unless it deviates from the guide fiber track by a angle greater than that specified by the '--guidedCurvatureThreshold' parameter. The user must specify the guide fiber when running this program.
-# 
-#     version: 4.0.0
-# 
-#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Modules:GTRACT
-# 
-#     license: http://mri.radiology.uiowa.edu/copyright/GTRACT-Copyright.txt
-# 
-#     contributor: This tool was developed by Vincent Magnotta, Greg Harris and Yongqiang Zhao.
-# 
-#     acknowledgements: Funding for this version of the GTRACT program was provided by NIH/NINDS R01NS050568-01A2S1
-#     
-task_name: gtractFiberTracking
-nipype_name: gtractFiberTracking
-nipype_module: nipype.interfaces.semtools.diffusion.gtract
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputTensorVolume: generic/file
-    # type=file|default=<undefined>: Required (for Free, Streamline, GraphSearch, and Guided fiber tracking methods): input tensor image file name
-    inputAnisotropyVolume: generic/file
-    # type=file|default=<undefined>: Required (for Free, Streamline, GraphSearch, and Guided fiber tracking methods): input anisotropy image file name
-    inputStartingSeedsLabelMapVolume: generic/file
-    # type=file|default=<undefined>: Required (for Free, Streamline, GraphSearch, and Guided fiber tracking methods): input starting seeds LabelMap image file name
-    inputEndingSeedsLabelMapVolume: generic/file
-    # type=file|default=<undefined>: Required (for Streamline, GraphSearch, and Guided fiber tracking methods): input ending seeds LabelMap image file name
-    inputTract: generic/file
-    # type=file|default=<undefined>: Required (for Guided fiber tracking method): guide fiber in vtkPolydata file containing one tract line.
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputTract: generic/file
-    # type=file: Required (for Free, Streamline, GraphSearch, and Guided fiber tracking methods): name of output vtkPolydata file containing tract lines and the point data collected along them.
-    # type=traitcompound|default=None: Required (for Free, Streamline, GraphSearch, and Guided fiber tracking methods): name of output vtkPolydata file containing tract lines and the point data collected along them.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputTensorVolume:
-    # type=file|default=<undefined>: Required (for Free, Streamline, GraphSearch, and Guided fiber tracking methods): input tensor image file name
-    inputAnisotropyVolume:
-    # type=file|default=<undefined>: Required (for Free, Streamline, GraphSearch, and Guided fiber tracking methods): input anisotropy image file name
-    inputStartingSeedsLabelMapVolume:
-    # type=file|default=<undefined>: Required (for Free, Streamline, GraphSearch, and Guided fiber tracking methods): input starting seeds LabelMap image file name
-    startingSeedsLabel:
-    # type=int|default=0: Label value for Starting Seeds (required if Label number used to create seed point in Slicer was not 1)
-    inputEndingSeedsLabelMapVolume:
-    # type=file|default=<undefined>: Required (for Streamline, GraphSearch, and Guided fiber tracking methods): input ending seeds LabelMap image file name
-    endingSeedsLabel:
-    # type=int|default=0: Label value for Ending Seeds (required if Label number used to create seed point in Slicer was not 1)
-    inputTract:
-    # type=file|default=<undefined>: Required (for Guided fiber tracking method): guide fiber in vtkPolydata file containing one tract line.
-    outputTract:
-    # type=file: Required (for Free, Streamline, GraphSearch, and Guided fiber tracking methods): name of output vtkPolydata file containing tract lines and the point data collected along them.
-    # type=traitcompound|default=None: Required (for Free, Streamline, GraphSearch, and Guided fiber tracking methods): name of output vtkPolydata file containing tract lines and the point data collected along them.
-    writeXMLPolyDataFile:
-    # type=bool|default=False: Flag to make use of the XML format for vtkPolyData fiber tracts.
-    trackingMethod:
-    # type=enum|default='Guided'|allowed['Free','GraphSearch','Guided','Streamline']: Fiber tracking Filter Type: Guided|Free|Streamline|GraphSearch
-    guidedCurvatureThreshold:
-    # type=float|default=0.0: Guided Curvature Threshold (Degrees)
-    maximumGuideDistance:
-    # type=float|default=0.0: Maximum distance for using the guide fiber direction
-    seedThreshold:
-    # type=float|default=0.0: Anisotropy threshold for seed selection (recommended for Free fiber tracking)
-    trackingThreshold:
-    # type=float|default=0.0: Anisotropy threshold for fiber tracking (anisotropy values of the next point along the path)
-    curvatureThreshold:
-    # type=float|default=0.0: Curvature threshold in degrees (recommended for Free  fiber tracking)
-    branchingThreshold:
-    # type=float|default=0.0: Anisotropy Branching threshold (recommended for GraphSearch fiber tracking method)
-    maximumBranchPoints:
-    # type=int|default=0: Maximum branch points (recommended for GraphSearch fiber tracking method)
-    useRandomWalk:
-    # type=bool|default=False: Flag to use random walk.
-    randomSeed:
-    # type=int|default=0: Random number generator seed
-    branchingAngle:
-    # type=float|default=0.0: Branching angle in degrees (recommended for GraphSearch fiber tracking method)
-    minimumLength:
-    # type=float|default=0.0: Minimum fiber length. Helpful for filtering invalid tracts.
-    maximumLength:
-    # type=float|default=0.0: Maximum fiber length (voxels)
-    stepSize:
-    # type=float|default=0.0: Fiber tracking step size
-    useLoopDetection:
-    # type=bool|default=False: Flag to make use of loop detection.
-    useTend:
-    # type=bool|default=False: Flag to make use of Tend F and Tend G parameters.
-    tendF:
-    # type=float|default=0.0: Tend F parameter
-    tendG:
-    # type=float|default=0.0: Tend G parameter
-    numberOfThreads:
-    # type=int|default=0: Explicitly specify the maximum number of threads to use.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_fiber_tracking_callables.py b/example-specs/task/nipype_internal/pydra-semtools/gtract_fiber_tracking_callables.py
deleted file mode 100644
index 8daf2aa5..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/gtract_fiber_tracking_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in gtractFiberTracking.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_image_conformity.yaml b/example-specs/task/nipype_internal/pydra-semtools/gtract_image_conformity.yaml
deleted file mode 100644
index c9f9cfd3..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/gtract_image_conformity.yaml
+++ /dev/null
@@ -1,97 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.diffusion.gtract.gtractImageConformity' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Image Conformity
-# 
-#     category: Diffusion.GTRACT
-# 
-#     description: This program will straighten out the Direction and Origin to match the Reference Image.
-# 
-#     version: 4.0.0
-# 
-#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Modules:GTRACT
-# 
-#     license: http://mri.radiology.uiowa.edu/copyright/GTRACT-Copyright.txt
-# 
-#     contributor: This tool was developed by Vincent Magnotta and Greg Harris.
-# 
-#     acknowledgements: Funding for this version of the GTRACT program was provided by NIH/NINDS R01NS050568-01A2S1
-#     
-task_name: gtractImageConformity
-nipype_name: gtractImageConformity
-nipype_module: nipype.interfaces.semtools.diffusion.gtract
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputVolume: generic/file
-    # type=file|default=<undefined>: Required: input file containing the signed short image to reorient without resampling.
-    inputReferenceVolume: generic/file
-    # type=file|default=<undefined>: Required: input file containing the standard image to clone the characteristics of.
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputVolume: generic/file
-    # type=file: Required: name of output Nrrd or Nifti file containing the reoriented image in reference image space.
-    # type=traitcompound|default=None: Required: name of output Nrrd or Nifti file containing the reoriented image in reference image space.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputVolume:
-    # type=file|default=<undefined>: Required: input file containing the signed short image to reorient without resampling.
-    inputReferenceVolume:
-    # type=file|default=<undefined>: Required: input file containing the standard image to clone the characteristics of.
-    outputVolume:
-    # type=file: Required: name of output Nrrd or Nifti file containing the reoriented image in reference image space.
-    # type=traitcompound|default=None: Required: name of output Nrrd or Nifti file containing the reoriented image in reference image space.
-    numberOfThreads:
-    # type=int|default=0: Explicitly specify the maximum number of threads to use.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_image_conformity_callables.py b/example-specs/task/nipype_internal/pydra-semtools/gtract_image_conformity_callables.py
deleted file mode 100644
index 29f5d396..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/gtract_image_conformity_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in gtractImageConformity.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_invert_b_spline_transform.yaml b/example-specs/task/nipype_internal/pydra-semtools/gtract_invert_b_spline_transform.yaml
deleted file mode 100644
index dfad47d0..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/gtract_invert_b_spline_transform.yaml
+++ /dev/null
@@ -1,99 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.diffusion.gtract.gtractInvertBSplineTransform' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: B-Spline Transform Inversion
-# 
-#     category: Diffusion.GTRACT
-# 
-#     description: This program will invert a B-Spline transform using a thin-plate spline approximation.
-# 
-#     version: 4.0.0
-# 
-#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Modules:GTRACT
-# 
-#     license: http://mri.radiology.uiowa.edu/copyright/GTRACT-Copyright.txt
-# 
-#     contributor: This tool was developed by Vincent Magnotta and Greg Harris.
-# 
-#     acknowledgements: Funding for this version of the GTRACT program was provided by NIH/NINDS R01NS050568-01A2S1
-#     
-task_name: gtractInvertBSplineTransform
-nipype_name: gtractInvertBSplineTransform
-nipype_module: nipype.interfaces.semtools.diffusion.gtract
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputReferenceVolume: generic/file
-    # type=file|default=<undefined>: Required: input image file name to exemplify the anatomical space to interpolate over.
-    inputTransform: generic/file
-    # type=file|default=<undefined>: Required: input B-Spline transform file name
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputTransform: generic/file
-    # type=file: Required: output transform file name
-    # type=traitcompound|default=None: Required: output transform file name
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputReferenceVolume:
-    # type=file|default=<undefined>: Required: input image file name to exemplify the anatomical space to interpolate over.
-    inputTransform:
-    # type=file|default=<undefined>: Required: input B-Spline transform file name
-    outputTransform:
-    # type=file: Required: output transform file name
-    # type=traitcompound|default=None: Required: output transform file name
-    landmarkDensity:
-    # type=inputmultiobject|default=[]: Number of landmark subdivisions in all 3 directions
-    numberOfThreads:
-    # type=int|default=0: Explicitly specify the maximum number of threads to use.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_invert_b_spline_transform_callables.py b/example-specs/task/nipype_internal/pydra-semtools/gtract_invert_b_spline_transform_callables.py
deleted file mode 100644
index 466c9d5e..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/gtract_invert_b_spline_transform_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in gtractInvertBSplineTransform.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_invert_displacement_field.yaml b/example-specs/task/nipype_internal/pydra-semtools/gtract_invert_displacement_field.yaml
deleted file mode 100644
index e782acfa..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/gtract_invert_displacement_field.yaml
+++ /dev/null
@@ -1,99 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.diffusion.gtract.gtractInvertDisplacementField' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Invert Displacement Field
-# 
-#     category: Diffusion.GTRACT
-# 
-#     description: This program will invert a deformatrion field. The size of the deformation field is defined by an example image provided by the user
-# 
-#     version: 4.0.0
-# 
-#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Modules:GTRACT
-# 
-#     license: http://mri.radiology.uiowa.edu/copyright/GTRACT-Copyright.txt
-# 
-#     contributor: This tool was developed by Vincent Magnotta.
-# 
-#     acknowledgements: Funding for this version of the GTRACT program was provided by NIH/NINDS R01NS050568-01A2S1
-#     
-task_name: gtractInvertDisplacementField
-nipype_name: gtractInvertDisplacementField
-nipype_module: nipype.interfaces.semtools.diffusion.gtract
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    baseImage: generic/file
-    # type=file|default=<undefined>: Required: base image used to define the size of the inverse field
-    deformationImage: generic/file
-    # type=file|default=<undefined>: Required: Displacement field image
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputVolume: generic/file
-    # type=file: Required: Output deformation field
-    # type=traitcompound|default=None: Required: Output deformation field
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    baseImage:
-    # type=file|default=<undefined>: Required: base image used to define the size of the inverse field
-    deformationImage:
-    # type=file|default=<undefined>: Required: Displacement field image
-    outputVolume:
-    # type=file: Required: Output deformation field
-    # type=traitcompound|default=None: Required: Output deformation field
-    subsamplingFactor:
-    # type=int|default=0: Subsampling factor for the deformation field
-    numberOfThreads:
-    # type=int|default=0: Explicitly specify the maximum number of threads to use.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_invert_displacement_field_callables.py b/example-specs/task/nipype_internal/pydra-semtools/gtract_invert_displacement_field_callables.py
deleted file mode 100644
index c4dcf2e6..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/gtract_invert_displacement_field_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in gtractInvertDisplacementField.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_invert_rigid_transform.yaml b/example-specs/task/nipype_internal/pydra-semtools/gtract_invert_rigid_transform.yaml
deleted file mode 100644
index 317008ca..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/gtract_invert_rigid_transform.yaml
+++ /dev/null
@@ -1,93 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.diffusion.gtract.gtractInvertRigidTransform' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Rigid Transform Inversion
-# 
-#     category: Diffusion.GTRACT
-# 
-#     description: This program will invert a Rigid transform.
-# 
-#     version: 4.0.0
-# 
-#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Modules:GTRACT
-# 
-#     license: http://mri.radiology.uiowa.edu/copyright/GTRACT-Copyright.txt
-# 
-#     contributor: This tool was developed by Vincent Magnotta and Greg Harris.
-# 
-#     acknowledgements: Funding for this version of the GTRACT program was provided by NIH/NINDS R01NS050568-01A2S1
-#     
-task_name: gtractInvertRigidTransform
-nipype_name: gtractInvertRigidTransform
-nipype_module: nipype.interfaces.semtools.diffusion.gtract
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputTransform: generic/file
-    # type=file|default=<undefined>: Required: input rigid transform file name
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputTransform: generic/file
-    # type=file: Required: output transform file name
-    # type=traitcompound|default=None: Required: output transform file name
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputTransform:
-    # type=file|default=<undefined>: Required: input rigid transform file name
-    outputTransform:
-    # type=file: Required: output transform file name
-    # type=traitcompound|default=None: Required: output transform file name
-    numberOfThreads:
-    # type=int|default=0: Explicitly specify the maximum number of threads to use.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_invert_rigid_transform_callables.py b/example-specs/task/nipype_internal/pydra-semtools/gtract_invert_rigid_transform_callables.py
deleted file mode 100644
index e1fd18c4..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/gtract_invert_rigid_transform_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in gtractInvertRigidTransform.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_resample_anisotropy.yaml b/example-specs/task/nipype_internal/pydra-semtools/gtract_resample_anisotropy.yaml
deleted file mode 100644
index 62cd873f..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/gtract_resample_anisotropy.yaml
+++ /dev/null
@@ -1,103 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.diffusion.gtract.gtractResampleAnisotropy' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Resample Anisotropy
-# 
-#     category: Diffusion.GTRACT
-# 
-#     description: This program will resample a floating point image using either the Rigid or B-Spline transform. You may want to save the aligned B0 image after each of the anisotropy map co-registration steps with the anatomical image to check the registration quality with another tool.
-# 
-#     version: 4.0.0
-# 
-#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Modules:GTRACT
-# 
-#     license: http://mri.radiology.uiowa.edu/copyright/GTRACT-Copyright.txt
-# 
-#     contributor: This tool was developed by Vincent Magnotta and Greg Harris.
-# 
-#     acknowledgements: Funding for this version of the GTRACT program was provided by NIH/NINDS R01NS050568-01A2S1
-#     
-task_name: gtractResampleAnisotropy
-nipype_name: gtractResampleAnisotropy
-nipype_module: nipype.interfaces.semtools.diffusion.gtract
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputAnisotropyVolume: generic/file
-    # type=file|default=<undefined>: Required: input file containing the anisotropy image
-    inputAnatomicalVolume: generic/file
-    # type=file|default=<undefined>: Required: input file containing the anatomical image whose characteristics will be cloned.
-    inputTransform: generic/file
-    # type=file|default=<undefined>: Required: input Rigid OR Bspline transform file name
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputVolume: generic/file
-    # type=file: Required: name of output NRRD file containing the resampled transformed anisotropy image.
-    # type=traitcompound|default=None: Required: name of output NRRD file containing the resampled transformed anisotropy image.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputAnisotropyVolume:
-    # type=file|default=<undefined>: Required: input file containing the anisotropy image
-    inputAnatomicalVolume:
-    # type=file|default=<undefined>: Required: input file containing the anatomical image whose characteristics will be cloned.
-    inputTransform:
-    # type=file|default=<undefined>: Required: input Rigid OR Bspline transform file name
-    transformType:
-    # type=enum|default='Rigid'|allowed['B-Spline','Rigid']: Transform type: Rigid, B-Spline
-    outputVolume:
-    # type=file: Required: name of output NRRD file containing the resampled transformed anisotropy image.
-    # type=traitcompound|default=None: Required: name of output NRRD file containing the resampled transformed anisotropy image.
-    numberOfThreads:
-    # type=int|default=0: Explicitly specify the maximum number of threads to use.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_resample_anisotropy_callables.py b/example-specs/task/nipype_internal/pydra-semtools/gtract_resample_anisotropy_callables.py
deleted file mode 100644
index f19f8b2e..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/gtract_resample_anisotropy_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in gtractResampleAnisotropy.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_resample_b0.yaml b/example-specs/task/nipype_internal/pydra-semtools/gtract_resample_b0.yaml
deleted file mode 100644
index 350d74b5..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/gtract_resample_b0.yaml
+++ /dev/null
@@ -1,105 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.diffusion.gtract.gtractResampleB0' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Resample B0
-# 
-#     category: Diffusion.GTRACT
-# 
-#     description: This program will resample a signed short image using either a Rigid or B-Spline transform. The user must specify a template image that will be used to define the origin, orientation, spacing, and size of the resampled image.
-# 
-#     version: 4.0.0
-# 
-#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Modules:GTRACT
-# 
-#     license: http://mri.radiology.uiowa.edu/copyright/GTRACT-Copyright.txt
-# 
-#     contributor: This tool was developed by Vincent Magnotta and Greg Harris.
-# 
-#     acknowledgements: Funding for this version of the GTRACT program was provided by NIH/NINDS R01NS050568-01A2S1
-#     
-task_name: gtractResampleB0
-nipype_name: gtractResampleB0
-nipype_module: nipype.interfaces.semtools.diffusion.gtract
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputVolume: generic/file
-    # type=file|default=<undefined>: Required: input file containing the 4D image
-    inputAnatomicalVolume: generic/file
-    # type=file|default=<undefined>: Required: input file containing the anatomical image defining the origin, spacing and size of the resampled image (template)
-    inputTransform: generic/file
-    # type=file|default=<undefined>: Required: input Rigid OR Bspline transform file name
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputVolume: generic/file
-    # type=file: Required: name of output NRRD file containing the resampled input image.
-    # type=traitcompound|default=None: Required: name of output NRRD file containing the resampled input image.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputVolume:
-    # type=file|default=<undefined>: Required: input file containing the 4D image
-    inputAnatomicalVolume:
-    # type=file|default=<undefined>: Required: input file containing the anatomical image defining the origin, spacing and size of the resampled image (template)
-    inputTransform:
-    # type=file|default=<undefined>: Required: input Rigid OR Bspline transform file name
-    vectorIndex:
-    # type=int|default=0: Index in the diffusion weighted image set for the B0 image
-    transformType:
-    # type=enum|default='Rigid'|allowed['B-Spline','Rigid']: Transform type: Rigid, B-Spline
-    outputVolume:
-    # type=file: Required: name of output NRRD file containing the resampled input image.
-    # type=traitcompound|default=None: Required: name of output NRRD file containing the resampled input image.
-    numberOfThreads:
-    # type=int|default=0: Explicitly specify the maximum number of threads to use.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_resample_b0_callables.py b/example-specs/task/nipype_internal/pydra-semtools/gtract_resample_b0_callables.py
deleted file mode 100644
index 7789dfcd..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/gtract_resample_b0_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in gtractResampleB0.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_resample_code_image.yaml b/example-specs/task/nipype_internal/pydra-semtools/gtract_resample_code_image.yaml
deleted file mode 100644
index 5cab6097..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/gtract_resample_code_image.yaml
+++ /dev/null
@@ -1,103 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.diffusion.gtract.gtractResampleCodeImage' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Resample Code Image
-# 
-#     category: Diffusion.GTRACT
-# 
-#     description: This program will resample a short integer code image using either the Rigid or Inverse-B-Spline transform.  The reference image is the DTI tensor anisotropy image space, and the input code image is in anatomical space.
-# 
-#     version: 4.0.0
-# 
-#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Modules:GTRACT
-# 
-#     license: http://mri.radiology.uiowa.edu/copyright/GTRACT-Copyright.txt
-# 
-#     contributor: This tool was developed by Vincent Magnotta and Greg Harris.
-# 
-#     acknowledgements: Funding for this version of the GTRACT program was provided by NIH/NINDS R01NS050568-01A2S1
-#     
-task_name: gtractResampleCodeImage
-nipype_name: gtractResampleCodeImage
-nipype_module: nipype.interfaces.semtools.diffusion.gtract
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputCodeVolume: generic/file
-    # type=file|default=<undefined>: Required: input file containing the code image
-    inputReferenceVolume: generic/file
-    # type=file|default=<undefined>: Required: input file containing the standard image to clone the characteristics of.
-    inputTransform: generic/file
-    # type=file|default=<undefined>: Required: input Rigid or Inverse-B-Spline transform file name
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputVolume: generic/file
-    # type=file: Required: name of output NRRD file containing the resampled code image in acquisition space.
-    # type=traitcompound|default=None: Required: name of output NRRD file containing the resampled code image in acquisition space.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputCodeVolume:
-    # type=file|default=<undefined>: Required: input file containing the code image
-    inputReferenceVolume:
-    # type=file|default=<undefined>: Required: input file containing the standard image to clone the characteristics of.
-    inputTransform:
-    # type=file|default=<undefined>: Required: input Rigid or Inverse-B-Spline transform file name
-    transformType:
-    # type=enum|default='Rigid'|allowed['Affine','B-Spline','Inverse-B-Spline','None','Rigid']: Transform type: Rigid or Inverse-B-Spline
-    outputVolume:
-    # type=file: Required: name of output NRRD file containing the resampled code image in acquisition space.
-    # type=traitcompound|default=None: Required: name of output NRRD file containing the resampled code image in acquisition space.
-    numberOfThreads:
-    # type=int|default=0: Explicitly specify the maximum number of threads to use.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_resample_code_image_callables.py b/example-specs/task/nipype_internal/pydra-semtools/gtract_resample_code_image_callables.py
deleted file mode 100644
index 01270d55..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/gtract_resample_code_image_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in gtractResampleCodeImage.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_resample_dwi_in_place.yaml b/example-specs/task/nipype_internal/pydra-semtools/gtract_resample_dwi_in_place.yaml
deleted file mode 100644
index 82f19105..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/gtract_resample_dwi_in_place.yaml
+++ /dev/null
@@ -1,115 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.diffusion.gtract.gtractResampleDWIInPlace' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Resample DWI In Place
-# 
-#     category: Diffusion.GTRACT
-# 
-#     description: Resamples DWI image to structural image.
-# 
-#     version: 4.0.0
-# 
-#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Modules:GTRACT
-# 
-#     license: http://mri.radiology.uiowa.edu/copyright/GTRACT-Copyright.txt
-# 
-#     contributor: This tool was developed by Vincent Magnotta, Greg Harris, Hans Johnson, and Joy Matsui.
-# 
-#     acknowledgements: Funding for this version of the GTRACT program was provided by NIH/NINDS R01NS050568-01A2S1
-#     
-task_name: gtractResampleDWIInPlace
-nipype_name: gtractResampleDWIInPlace
-nipype_module: nipype.interfaces.semtools.diffusion.gtract
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputVolume: generic/file
-    # type=file|default=<undefined>: Required: input image is a 4D NRRD image.
-    referenceVolume: generic/file
-    # type=file|default=<undefined>: If provided, resample to the final space of the referenceVolume 3D data set.
-    inputTransform: generic/file
-    # type=file|default=<undefined>: Required: transform file derived from rigid registration of b0 image to reference structural image.
-    warpDWITransform: generic/file
-    # type=file|default=<undefined>: Optional: transform file to warp gradient volumes.
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputResampledB0: generic/file
-    # type=file: Convenience function for extracting the first index location (assumed to be the B0)
-    # type=traitcompound|default=None: Convenience function for extracting the first index location (assumed to be the B0)
-    outputVolume: generic/file
-    # type=file: Required: output image (NRRD file) that has been rigidly transformed into the space of the structural image and padded if image padding was changed from 0,0,0 default.
-    # type=traitcompound|default=None: Required: output image (NRRD file) that has been rigidly transformed into the space of the structural image and padded if image padding was changed from 0,0,0 default.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputVolume:
-    # type=file|default=<undefined>: Required: input image is a 4D NRRD image.
-    referenceVolume:
-    # type=file|default=<undefined>: If provided, resample to the final space of the referenceVolume 3D data set.
-    outputResampledB0:
-    # type=file: Convenience function for extracting the first index location (assumed to be the B0)
-    # type=traitcompound|default=None: Convenience function for extracting the first index location (assumed to be the B0)
-    inputTransform:
-    # type=file|default=<undefined>: Required: transform file derived from rigid registration of b0 image to reference structural image.
-    warpDWITransform:
-    # type=file|default=<undefined>: Optional: transform file to warp gradient volumes.
-    debugLevel:
-    # type=int|default=0: Display debug messages, and produce debug intermediate results.  0=OFF, 1=Minimal, 10=Maximum debugging.
-    imageOutputSize:
-    # type=inputmultiobject|default=[]: The voxel lattice for the output image, padding is added if necessary. NOTE: if 0,0,0, then the inputVolume size is used.
-    outputVolume:
-    # type=file: Required: output image (NRRD file) that has been rigidly transformed into the space of the structural image and padded if image padding was changed from 0,0,0 default.
-    # type=traitcompound|default=None: Required: output image (NRRD file) that has been rigidly transformed into the space of the structural image and padded if image padding was changed from 0,0,0 default.
-    numberOfThreads:
-    # type=int|default=0: Explicitly specify the maximum number of threads to use.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_resample_dwi_in_place_callables.py b/example-specs/task/nipype_internal/pydra-semtools/gtract_resample_dwi_in_place_callables.py
deleted file mode 100644
index 55b70f68..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/gtract_resample_dwi_in_place_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in gtractResampleDWIInPlace.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_resample_fibers.yaml b/example-specs/task/nipype_internal/pydra-semtools/gtract_resample_fibers.yaml
deleted file mode 100644
index 9ed38dbc..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/gtract_resample_fibers.yaml
+++ /dev/null
@@ -1,103 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.diffusion.gtract.gtractResampleFibers' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Resample Fibers
-# 
-#     category: Diffusion.GTRACT
-# 
-#     description: This program will resample a fiber tract with respect to a pair of deformation fields that represent the forward and reverse deformation fields.
-# 
-#     version: 4.0.0
-# 
-#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Modules:GTRACT
-# 
-#     license: http://mri.radiology.uiowa.edu/copyright/GTRACT-Copyright.txt
-# 
-#     contributor: This tool was developed by Vincent Magnotta and Greg Harris.
-# 
-#     acknowledgements: Funding for this version of the GTRACT program was provided by NIH/NINDS R01NS050568-01A2S1
-#     
-task_name: gtractResampleFibers
-nipype_name: gtractResampleFibers
-nipype_module: nipype.interfaces.semtools.diffusion.gtract
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputForwardDeformationFieldVolume: generic/file
-    # type=file|default=<undefined>: Required: input forward deformation field image file name
-    inputReverseDeformationFieldVolume: generic/file
-    # type=file|default=<undefined>: Required: input reverse deformation field image file name
-    inputTract: generic/file
-    # type=file|default=<undefined>: Required: name of input vtkPolydata file containing tract lines.
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputTract: generic/file
-    # type=file: Required: name of output vtkPolydata file containing tract lines and the point data collected along them.
-    # type=traitcompound|default=None: Required: name of output vtkPolydata file containing tract lines and the point data collected along them.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputForwardDeformationFieldVolume:
-    # type=file|default=<undefined>: Required: input forward deformation field image file name
-    inputReverseDeformationFieldVolume:
-    # type=file|default=<undefined>: Required: input reverse deformation field image file name
-    inputTract:
-    # type=file|default=<undefined>: Required: name of input vtkPolydata file containing tract lines.
-    outputTract:
-    # type=file: Required: name of output vtkPolydata file containing tract lines and the point data collected along them.
-    # type=traitcompound|default=None: Required: name of output vtkPolydata file containing tract lines and the point data collected along them.
-    writeXMLPolyDataFile:
-    # type=bool|default=False: Flag to make use of the XML format for vtkPolyData fiber tracts.
-    numberOfThreads:
-    # type=int|default=0: Explicitly specify the maximum number of threads to use.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_resample_fibers_callables.py b/example-specs/task/nipype_internal/pydra-semtools/gtract_resample_fibers_callables.py
deleted file mode 100644
index 5dd88203..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/gtract_resample_fibers_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in gtractResampleFibers.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_tensor.yaml b/example-specs/task/nipype_internal/pydra-semtools/gtract_tensor.yaml
deleted file mode 100644
index b49086ed..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/gtract_tensor.yaml
+++ /dev/null
@@ -1,113 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.diffusion.gtract.gtractTensor' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Tensor Estimation
-# 
-#     category: Diffusion.GTRACT
-# 
-#     description: This step will convert a b-value averaged diffusion tensor image to a 3x3 tensor voxel image. This step takes the diffusion tensor image data and generates a tensor representation of the data based on the signal intensity decay, b values applied, and the diffusion difrections. The apparent diffusion coefficient for a given orientation is computed on a pixel-by-pixel basis by fitting the image data (voxel intensities) to the Stejskal-Tanner equation. If at least 6 diffusion directions are used, then the diffusion tensor can be computed. This program uses itk::DiffusionTensor3DReconstructionImageFilter. The user can adjust background threshold, median filter, and isotropic resampling.
-# 
-#     version: 4.0.0
-# 
-#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Modules:GTRACT
-# 
-#     license: http://mri.radiology.uiowa.edu/copyright/GTRACT-Copyright.txt
-# 
-#     contributor: This tool was developed by Vincent Magnotta and Greg Harris.
-# 
-#     acknowledgements: Funding for this version of the GTRACT program was provided by NIH/NINDS R01NS050568-01A2S1
-#     
-task_name: gtractTensor
-nipype_name: gtractTensor
-nipype_module: nipype.interfaces.semtools.diffusion.gtract
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputVolume: generic/file
-    # type=file|default=<undefined>: Required: input image 4D NRRD image. Must contain data based on at least 6 distinct diffusion directions. The inputVolume is allowed to have multiple b0 and gradient direction images. Averaging of the b0 image is done internally in this step. Prior averaging of the DWIs is not required.
-    maskVolume: generic/file
-    # type=file|default=<undefined>: Mask Image, if maskProcessingMode is ROI
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputVolume: generic/file
-    # type=file: Required: name of output NRRD file containing the Tensor vector image
-    # type=traitcompound|default=None: Required: name of output NRRD file containing the Tensor vector image
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputVolume:
-    # type=file|default=<undefined>: Required: input image 4D NRRD image. Must contain data based on at least 6 distinct diffusion directions. The inputVolume is allowed to have multiple b0 and gradient direction images. Averaging of the b0 image is done internally in this step. Prior averaging of the DWIs is not required.
-    outputVolume:
-    # type=file: Required: name of output NRRD file containing the Tensor vector image
-    # type=traitcompound|default=None: Required: name of output NRRD file containing the Tensor vector image
-    medianFilterSize:
-    # type=inputmultiobject|default=[]: Median filter radius in all 3 directions
-    maskProcessingMode:
-    # type=enum|default='NOMASK'|allowed['NOMASK','ROI','ROIAUTO']: ROIAUTO:  mask is implicitly defined using a otsu foreground and hole filling algorithm. ROI: Uses the masks to define what parts of the image should be used for computing the transform. NOMASK: no mask used
-    maskVolume:
-    # type=file|default=<undefined>: Mask Image, if maskProcessingMode is ROI
-    backgroundSuppressingThreshold:
-    # type=int|default=0: Image threshold to suppress background. This sets a threshold used on the b0 image to remove background voxels from processing. Typically, values of 100 and 500 work well for Siemens and GE DTI data, respectively. Check your data particularly in the globus pallidus to make sure the brain tissue is not being eliminated with this threshold.
-    resampleIsotropic:
-    # type=bool|default=False: Flag to resample to isotropic voxels. Enabling this feature is recommended if fiber tracking will be performed.
-    size:
-    # type=float|default=0.0: Isotropic voxel size to resample to
-    b0Index:
-    # type=int|default=0: Index in input vector index to extract
-    applyMeasurementFrame:
-    # type=bool|default=False: Flag to apply the measurement frame to the gradient directions
-    ignoreIndex:
-    # type=inputmultiobject|default=[]: Ignore diffusion gradient index. Used to remove specific gradient directions with artifacts.
-    numberOfThreads:
-    # type=int|default=0: Explicitly specify the maximum number of threads to use.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_tensor_callables.py b/example-specs/task/nipype_internal/pydra-semtools/gtract_tensor_callables.py
deleted file mode 100644
index ea314f47..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/gtract_tensor_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in gtractTensor.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_transform_to_displacement_field.yaml b/example-specs/task/nipype_internal/pydra-semtools/gtract_transform_to_displacement_field.yaml
deleted file mode 100644
index 804b3aa4..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/gtract_transform_to_displacement_field.yaml
+++ /dev/null
@@ -1,97 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.diffusion.gtract.gtractTransformToDisplacementField' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Create Displacement Field
-# 
-#     category: Diffusion.GTRACT
-# 
-#     description: This program will compute forward deformation from the given Transform. The size of the DF is equal to MNI space
-# 
-#     version: 4.0.0
-# 
-#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Modules:GTRACT
-# 
-#     license: http://mri.radiology.uiowa.edu/copyright/GTRACT-Copyright.txt
-# 
-#     contributor: This tool was developed by Vincent Magnotta, Madhura Ingalhalikar, and Greg Harris
-# 
-#     acknowledgements: Funding for this version of the GTRACT program was provided by NIH/NINDS R01NS050568-01A2S1
-#     
-task_name: gtractTransformToDisplacementField
-nipype_name: gtractTransformToDisplacementField
-nipype_module: nipype.interfaces.semtools.diffusion.gtract
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputTransform: generic/file
-    # type=file|default=<undefined>: Input Transform File Name
-    inputReferenceVolume: generic/file
-    # type=file|default=<undefined>: Required: input image file name to exemplify the anatomical space over which to vcl_express the transform as a displacement field.
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputDeformationFieldVolume: generic/file
-    # type=file: Output deformation field
-    # type=traitcompound|default=None: Output deformation field
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputTransform:
-    # type=file|default=<undefined>: Input Transform File Name
-    inputReferenceVolume:
-    # type=file|default=<undefined>: Required: input image file name to exemplify the anatomical space over which to vcl_express the transform as a displacement field.
-    outputDeformationFieldVolume:
-    # type=file: Output deformation field
-    # type=traitcompound|default=None: Output deformation field
-    numberOfThreads:
-    # type=int|default=0: Explicitly specify the maximum number of threads to use.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/gtract_transform_to_displacement_field_callables.py b/example-specs/task/nipype_internal/pydra-semtools/gtract_transform_to_displacement_field_callables.py
deleted file mode 100644
index 5012c73d..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/gtract_transform_to_displacement_field_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in gtractTransformToDisplacementField.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/hammer_attribute_creator.yaml b/example-specs/task/nipype_internal/pydra-semtools/hammer_attribute_creator.yaml
deleted file mode 100644
index cea52a34..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/hammer_attribute_creator.yaml
+++ /dev/null
@@ -1,97 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.filtering.featuredetection.HammerAttributeCreator' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: HAMMER Feature Vectors
-# 
-#     category: Filtering.FeatureDetection
-# 
-#     description: Create the feature vectors used by HAMMER.
-# 
-#     version: 0.1.0.$Revision: 1 $(alpha)
-# 
-#     documentation-url: http:://www.na-mic.org/
-# 
-#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
-# 
-#     contributor: This was extracted from the Hammer Registration source code, and wrapped up by Hans J. Johnson.
-#     
-task_name: HammerAttributeCreator
-nipype_name: HammerAttributeCreator
-nipype_module: nipype.interfaces.semtools.filtering.featuredetection
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputGMVolume: generic/file
-    # type=file|default=<undefined>: Required: input grey matter posterior image
-    inputWMVolume: generic/file
-    # type=file|default=<undefined>: Required: input white matter posterior image
-    inputCSFVolume: generic/file
-    # type=file|default=<undefined>: Required: input CSF posterior image
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    Scale:
-    # type=int|default=0: Determine Scale of Ball
-    Strength:
-    # type=float|default=0.0: Determine Strength of Edges
-    inputGMVolume:
-    # type=file|default=<undefined>: Required: input grey matter posterior image
-    inputWMVolume:
-    # type=file|default=<undefined>: Required: input white matter posterior image
-    inputCSFVolume:
-    # type=file|default=<undefined>: Required: input CSF posterior image
-    outputVolumeBase:
-    # type=str|default='': Required: output image base name to be appended for each feature vector.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/hammer_attribute_creator_callables.py b/example-specs/task/nipype_internal/pydra-semtools/hammer_attribute_creator_callables.py
deleted file mode 100644
index c80b5d93..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/hammer_attribute_creator_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in HammerAttributeCreator.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/histogram_matching_filter.yaml b/example-specs/task/nipype_internal/pydra-semtools/histogram_matching_filter.yaml
deleted file mode 100644
index 1c8aad6b..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/histogram_matching_filter.yaml
+++ /dev/null
@@ -1,107 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.brains.utilities.HistogramMatchingFilter' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Write Out Image Intensities
-# 
-#     category: BRAINS.Utilities
-# 
-#     description: For Analysis
-# 
-#     version: 0.1
-# 
-#     contributor: University of Iowa Department of Psychiatry, http:://www.psychiatry.uiowa.edu
-#     
-task_name: HistogramMatchingFilter
-nipype_name: HistogramMatchingFilter
-nipype_module: nipype.interfaces.semtools.brains.utilities
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputVolume: generic/file
-    # type=file|default=<undefined>: The Input image to be computed for statistics
-    referenceVolume: generic/file
-    # type=file|default=<undefined>: The Input image to be computed for statistics
-    referenceBinaryVolume: generic/file
-    # type=file|default=<undefined>: referenceBinaryVolume
-    inputBinaryVolume: generic/file
-    # type=file|default=<undefined>: inputBinaryVolume
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputVolume: generic/file
-    # type=file: Output Image File Name
-    # type=traitcompound|default=None: Output Image File Name
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputVolume:
-    # type=file|default=<undefined>: The Input image to be computed for statistics
-    referenceVolume:
-    # type=file|default=<undefined>: The Input image to be computed for statistics
-    outputVolume:
-    # type=file: Output Image File Name
-    # type=traitcompound|default=None: Output Image File Name
-    referenceBinaryVolume:
-    # type=file|default=<undefined>: referenceBinaryVolume
-    inputBinaryVolume:
-    # type=file|default=<undefined>: inputBinaryVolume
-    numberOfMatchPoints:
-    # type=int|default=0:  number of histogram matching points
-    numberOfHistogramBins:
-    # type=int|default=0:  number of histogram bin
-    writeHistogram:
-    # type=str|default='':  decide if histogram data would be written with prefixe of the file name
-    histogramAlgorithm:
-    # type=enum|default='OtsuHistogramMatching'|allowed['OtsuHistogramMatching']:  histogram algrithm selection
-    verbose:
-    # type=bool|default=False:  verbose mode running for debbuging
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/histogram_matching_filter_callables.py b/example-specs/task/nipype_internal/pydra-semtools/histogram_matching_filter_callables.py
deleted file mode 100644
index ec20f360..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/histogram_matching_filter_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in HistogramMatchingFilter.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/image_region_plotter.yaml b/example-specs/task/nipype_internal/pydra-semtools/image_region_plotter.yaml
deleted file mode 100644
index b9e0a4fa..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/image_region_plotter.yaml
+++ /dev/null
@@ -1,101 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.utilities.brains.ImageRegionPlotter' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Write Out Image Intensities
-# 
-#     category: Utilities.BRAINS
-# 
-#     description: For Analysis
-# 
-#     version: 0.1
-# 
-#     contributor: University of Iowa Department of Psychiatry, http:://www.psychiatry.uiowa.edu
-#     
-task_name: ImageRegionPlotter
-nipype_name: ImageRegionPlotter
-nipype_module: nipype.interfaces.semtools.utilities.brains
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputVolume1: generic/file
-    # type=file|default=<undefined>: The Input image to be computed for statistics
-    inputVolume2: generic/file
-    # type=file|default=<undefined>: The Input image to be computed for statistics
-    inputBinaryROIVolume: generic/file
-    # type=file|default=<undefined>: The Input binary image for region of interest
-    inputLabelVolume: generic/file
-    # type=file|default=<undefined>: The Label Image
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputVolume1:
-    # type=file|default=<undefined>: The Input image to be computed for statistics
-    inputVolume2:
-    # type=file|default=<undefined>: The Input image to be computed for statistics
-    inputBinaryROIVolume:
-    # type=file|default=<undefined>: The Input binary image for region of interest
-    inputLabelVolume:
-    # type=file|default=<undefined>: The Label Image
-    numberOfHistogramBins:
-    # type=int|default=0:  the number of histogram levels
-    outputJointHistogramData:
-    # type=str|default='':  output data file name
-    useROIAUTO:
-    # type=bool|default=False:  Use ROIAUTO to compute region of interest. This cannot be used with inputLabelVolume
-    useIntensityForHistogram:
-    # type=bool|default=False:  Create Intensity Joint Histogram instead of Quantile Joint Histogram
-    verbose:
-    # type=bool|default=False:  print debugging information,       
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/image_region_plotter_callables.py b/example-specs/task/nipype_internal/pydra-semtools/image_region_plotter_callables.py
deleted file mode 100644
index bf43a254..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/image_region_plotter_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in ImageRegionPlotter.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/insert_mid_acp_cpoint.yaml b/example-specs/task/nipype_internal/pydra-semtools/insert_mid_acp_cpoint.yaml
deleted file mode 100644
index 3f2a4b96..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/insert_mid_acp_cpoint.yaml
+++ /dev/null
@@ -1,83 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.utilities.brains.insertMidACPCpoint' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: MidACPC Landmark Insertion
-# 
-#     category: Utilities.BRAINS
-# 
-#     description: This program gets a landmark fcsv file and adds a new landmark as the midpoint between AC and PC points to the output landmark fcsv file
-# 
-#     contributor: Ali Ghayoor
-#     
-task_name: insertMidACPCpoint
-nipype_name: insertMidACPCpoint
-nipype_module: nipype.interfaces.semtools.utilities.brains
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputLandmarkFile: generic/file
-    # type=file|default=<undefined>: Input landmark file (.fcsv)
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputLandmarkFile: generic/file
-    # type=file: Output landmark file (.fcsv)
-    # type=traitcompound|default=None: Output landmark file (.fcsv)
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputLandmarkFile:
-    # type=file|default=<undefined>: Input landmark file (.fcsv)
-    outputLandmarkFile:
-    # type=file: Output landmark file (.fcsv)
-    # type=traitcompound|default=None: Output landmark file (.fcsv)
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/insert_mid_acp_cpoint_callables.py b/example-specs/task/nipype_internal/pydra-semtools/insert_mid_acp_cpoint_callables.py
deleted file mode 100644
index ff32a7b5..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/insert_mid_acp_cpoint_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in insertMidACPCpoint.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/joint_histogram.yaml b/example-specs/task/nipype_internal/pydra-semtools/joint_histogram.yaml
deleted file mode 100644
index 2d1dc92f..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/joint_histogram.yaml
+++ /dev/null
@@ -1,95 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.utilities.brains.JointHistogram' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Write Out Image Intensities
-# 
-#     category: Utilities.BRAINS
-# 
-#     description: For Analysis
-# 
-#     version: 0.1
-# 
-#     contributor: University of Iowa Department of Psychiatry, http:://www.psychiatry.uiowa.edu
-#     
-task_name: JointHistogram
-nipype_name: JointHistogram
-nipype_module: nipype.interfaces.semtools.utilities.brains
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputVolumeInXAxis: generic/file
-    # type=file|default=<undefined>: The Input image to be computed for statistics
-    inputVolumeInYAxis: generic/file
-    # type=file|default=<undefined>: The Input image to be computed for statistics
-    inputMaskVolumeInXAxis: generic/file
-    # type=file|default=<undefined>: Input mask volume for inputVolumeInXAxis. Histogram will be computed just for the masked region
-    inputMaskVolumeInYAxis: generic/file
-    # type=file|default=<undefined>: Input mask volume for inputVolumeInYAxis. Histogram will be computed just for the masked region
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputVolumeInXAxis:
-    # type=file|default=<undefined>: The Input image to be computed for statistics
-    inputVolumeInYAxis:
-    # type=file|default=<undefined>: The Input image to be computed for statistics
-    inputMaskVolumeInXAxis:
-    # type=file|default=<undefined>: Input mask volume for inputVolumeInXAxis. Histogram will be computed just for the masked region
-    inputMaskVolumeInYAxis:
-    # type=file|default=<undefined>: Input mask volume for inputVolumeInYAxis. Histogram will be computed just for the masked region
-    outputJointHistogramImage:
-    # type=str|default='':  output joint histogram image file name. Histogram is usually 2D image. 
-    verbose:
-    # type=bool|default=False:  print debugging information,       
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/joint_histogram_callables.py b/example-specs/task/nipype_internal/pydra-semtools/joint_histogram_callables.py
deleted file mode 100644
index 6b7f172c..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/joint_histogram_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in JointHistogram.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/landmarks_compare.yaml b/example-specs/task/nipype_internal/pydra-semtools/landmarks_compare.yaml
deleted file mode 100644
index 3e794c08..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/landmarks_compare.yaml
+++ /dev/null
@@ -1,83 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.testing.landmarkscompare.LandmarksCompare' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Compare Fiducials
-# 
-#     category: Testing
-# 
-#     description: Compares two .fcsv or .wts text files and verifies that they are identicle.  Used for testing landmarks files.
-# 
-#     contributor: Ali Ghayoor
-#     
-task_name: LandmarksCompare
-nipype_name: LandmarksCompare
-nipype_module: nipype.interfaces.semtools.testing.landmarkscompare
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputLandmarkFile1: generic/file
-    # type=file|default=<undefined>: First input landmark file (.fcsv or .wts)
-    inputLandmarkFile2: generic/file
-    # type=file|default=<undefined>: Second input landmark file (.fcsv or .wts)
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputLandmarkFile1:
-    # type=file|default=<undefined>: First input landmark file (.fcsv or .wts)
-    inputLandmarkFile2:
-    # type=file|default=<undefined>: Second input landmark file (.fcsv or .wts)
-    tolerance:
-    # type=float|default=0.0: The maximum error (in mm) allowed in each direction of a landmark
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/landmarks_compare_callables.py b/example-specs/task/nipype_internal/pydra-semtools/landmarks_compare_callables.py
deleted file mode 100644
index e251e711..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/landmarks_compare_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in LandmarksCompare.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/landmarks_constellation_aligner.yaml b/example-specs/task/nipype_internal/pydra-semtools/landmarks_constellation_aligner.yaml
deleted file mode 100644
index e7c56858..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/landmarks_constellation_aligner.yaml
+++ /dev/null
@@ -1,83 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.utilities.brains.landmarksConstellationAligner' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: MidACPC Landmark Insertion
-# 
-#     category: Utilities.BRAINS
-# 
-#     description: This program converts the original landmark files to the acpc-aligned landmark files
-# 
-#     contributor: Ali Ghayoor
-#     
-task_name: landmarksConstellationAligner
-nipype_name: landmarksConstellationAligner
-nipype_module: nipype.interfaces.semtools.utilities.brains
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputLandmarksPaired: generic/file
-    # type=file|default=<undefined>: Input landmark file (.fcsv)
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputLandmarksPaired: generic/file
-    # type=file: Output landmark file (.fcsv)
-    # type=traitcompound|default=None: Output landmark file (.fcsv)
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputLandmarksPaired:
-    # type=file|default=<undefined>: Input landmark file (.fcsv)
-    outputLandmarksPaired:
-    # type=file: Output landmark file (.fcsv)
-    # type=traitcompound|default=None: Output landmark file (.fcsv)
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/landmarks_constellation_aligner_callables.py b/example-specs/task/nipype_internal/pydra-semtools/landmarks_constellation_aligner_callables.py
deleted file mode 100644
index 521e24ab..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/landmarks_constellation_aligner_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in landmarksConstellationAligner.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/landmarks_constellation_weights.yaml b/example-specs/task/nipype_internal/pydra-semtools/landmarks_constellation_weights.yaml
deleted file mode 100644
index ded73a63..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/landmarks_constellation_weights.yaml
+++ /dev/null
@@ -1,89 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.utilities.brains.landmarksConstellationWeights' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Generate Landmarks Weights (BRAINS)
-# 
-#     category: Utilities.BRAINS
-# 
-#     description: Train up a list of Weights for the Landmarks in BRAINSConstellationDetector
-#     
-task_name: landmarksConstellationWeights
-nipype_name: landmarksConstellationWeights
-nipype_module: nipype.interfaces.semtools.utilities.brains
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputTrainingList: generic/file
-    # type=file|default=<undefined>: ,                 Setup file, giving all parameters for training up a Weight list for landmark.,             
-    inputTemplateModel: generic/file
-    # type=file|default=<undefined>: User-specified template model.,             
-    LLSModel: generic/file
-    # type=file|default=<undefined>: Linear least squares model filename in HD5 format
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputWeightsList: generic/file
-    # type=file: ,                 The filename of a csv file which is a list of landmarks and their corresponding weights.,             
-    # type=traitcompound|default=None: ,                 The filename of a csv file which is a list of landmarks and their corresponding weights.,             
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputTrainingList:
-    # type=file|default=<undefined>: ,                 Setup file, giving all parameters for training up a Weight list for landmark.,             
-    inputTemplateModel:
-    # type=file|default=<undefined>: User-specified template model.,             
-    LLSModel:
-    # type=file|default=<undefined>: Linear least squares model filename in HD5 format
-    outputWeightsList:
-    # type=file: ,                 The filename of a csv file which is a list of landmarks and their corresponding weights.,             
-    # type=traitcompound|default=None: ,                 The filename of a csv file which is a list of landmarks and their corresponding weights.,             
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/landmarks_constellation_weights_callables.py b/example-specs/task/nipype_internal/pydra-semtools/landmarks_constellation_weights_callables.py
deleted file mode 100644
index 4fcab2e3..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/landmarks_constellation_weights_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in landmarksConstellationWeights.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/maxcurvature.yaml b/example-specs/task/nipype_internal/pydra-semtools/maxcurvature.yaml
deleted file mode 100644
index 84e0a292..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/maxcurvature.yaml
+++ /dev/null
@@ -1,99 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.diffusion.maxcurvature.maxcurvature' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: MaxCurvature-Hessian (DTIProcess)
-# 
-#     category: Diffusion
-# 
-#     description: This program computes the Hessian of the FA image (--image). We use this scalar image as a registration input when doing DTI atlas building. For most adult FA we use a sigma of 2 whereas for neonate or primate images and sigma of 1 or 1.5 is more appropriate. For really noisy images, 2.5 - 4 can be considered. The final image (--output) shows the main feature of the input image.
-# 
-#     version: 1.1.0
-# 
-#     documentation-url: http://www.slicer.org/slicerWiki/index.php/Documentation/Nightly/Extensions/DTIProcess
-# 
-#     license: Copyright (c)  Casey Goodlett. All rights reserved.
-#       See http://www.ia.unc.edu/dev/Copyright.htm for details.
-#          This software is distributed WITHOUT ANY WARRANTY; without even
-#          the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-#          PURPOSE.  See the above copyright notices for more information.
-# 
-#     contributor: Casey Goodlett
-# 
-#     acknowledgements: Hans Johnson(1,3,4); Kent Williams(1); (1=University of Iowa Department of Psychiatry, 3=University of Iowa Department of Biomedical Engineering, 4=University of Iowa Department of Electrical and Computer Engineering) provided conversions to make DTIProcess compatible with Slicer execution, and simplified the stand-alone build requirements by removing the dependencies on boost and a fortran compiler.
-#     
-task_name: maxcurvature
-nipype_name: maxcurvature
-nipype_module: nipype.interfaces.semtools.diffusion.maxcurvature
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    image: generic/file
-    # type=file|default=<undefined>: FA Image
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    output: generic/file
-    # type=file: Output File
-    # type=traitcompound|default=None: Output File
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    image:
-    # type=file|default=<undefined>: FA Image
-    output:
-    # type=file: Output File
-    # type=traitcompound|default=None: Output File
-    sigma:
-    # type=float|default=0.0: Scale of Gradients
-    verbose:
-    # type=bool|default=False: produce verbose output
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/maxcurvature_callables.py b/example-specs/task/nipype_internal/pydra-semtools/maxcurvature_callables.py
deleted file mode 100644
index be69d4a5..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/maxcurvature_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in maxcurvature.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/neighborhood_mean.yaml b/example-specs/task/nipype_internal/pydra-semtools/neighborhood_mean.yaml
deleted file mode 100644
index ad1de709..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/neighborhood_mean.yaml
+++ /dev/null
@@ -1,95 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.filtering.featuredetection.NeighborhoodMean' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Neighborhood Mean
-# 
-#     category: Filtering.FeatureDetection
-# 
-#     description: Calculates the mean, for the given neighborhood size, at each voxel of the T1, T2, and FLAIR.
-# 
-#     version: 0.1.0.$Revision: 1 $(alpha)
-# 
-#     documentation-url: http:://www.na-mic.org/
-# 
-#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
-# 
-#     contributor: This tool was developed by Mark Scully and Jeremy Bockholt.
-#     
-task_name: NeighborhoodMean
-nipype_name: NeighborhoodMean
-nipype_module: nipype.interfaces.semtools.filtering.featuredetection
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputVolume: generic/file
-    # type=file|default=<undefined>: Required: input image
-    inputMaskVolume: generic/file
-    # type=file|default=<undefined>: Required: input brain mask image
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputVolume: generic/file
-    # type=file: Required: output image
-    # type=traitcompound|default=None: Required: output image
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputVolume:
-    # type=file|default=<undefined>: Required: input image
-    inputMaskVolume:
-    # type=file|default=<undefined>: Required: input brain mask image
-    inputRadius:
-    # type=int|default=0: Required: input neighborhood radius
-    outputVolume:
-    # type=file: Required: output image
-    # type=traitcompound|default=None: Required: output image
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/neighborhood_mean_callables.py b/example-specs/task/nipype_internal/pydra-semtools/neighborhood_mean_callables.py
deleted file mode 100644
index b0bef2a5..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/neighborhood_mean_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in NeighborhoodMean.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/neighborhood_median.yaml b/example-specs/task/nipype_internal/pydra-semtools/neighborhood_median.yaml
deleted file mode 100644
index ce68050d..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/neighborhood_median.yaml
+++ /dev/null
@@ -1,95 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.filtering.featuredetection.NeighborhoodMedian' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Neighborhood Median
-# 
-#     category: Filtering.FeatureDetection
-# 
-#     description: Calculates the median, for the given neighborhood size, at each voxel of the input image.
-# 
-#     version: 0.1.0.$Revision: 1 $(alpha)
-# 
-#     documentation-url: http:://www.na-mic.org/
-# 
-#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
-# 
-#     contributor: This tool was developed by Mark Scully and Jeremy Bockholt.
-#     
-task_name: NeighborhoodMedian
-nipype_name: NeighborhoodMedian
-nipype_module: nipype.interfaces.semtools.filtering.featuredetection
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputVolume: generic/file
-    # type=file|default=<undefined>: Required: input image
-    inputMaskVolume: generic/file
-    # type=file|default=<undefined>: Required: input brain mask image
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputVolume: generic/file
-    # type=file: Required: output image
-    # type=traitcompound|default=None: Required: output image
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputVolume:
-    # type=file|default=<undefined>: Required: input image
-    inputMaskVolume:
-    # type=file|default=<undefined>: Required: input brain mask image
-    inputRadius:
-    # type=int|default=0: Required: input neighborhood radius
-    outputVolume:
-    # type=file: Required: output image
-    # type=traitcompound|default=None: Required: output image
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/neighborhood_median_callables.py b/example-specs/task/nipype_internal/pydra-semtools/neighborhood_median_callables.py
deleted file mode 100644
index 75c771e8..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/neighborhood_median_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in NeighborhoodMedian.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/scalartransform.yaml b/example-specs/task/nipype_internal/pydra-semtools/scalartransform.yaml
deleted file mode 100644
index 791f7cc2..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/scalartransform.yaml
+++ /dev/null
@@ -1,107 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.legacy.registration.scalartransform' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: ScalarTransform (DTIProcess)
-# 
-#     category: Legacy.Registration
-# 
-#     version: 1.0.0
-# 
-#     documentation-url: http://www.slicer.org/slicerWiki/index.php/Documentation/Nightly/Extensions/DTIProcess
-# 
-#     license: Copyright (c)  Casey Goodlett. All rights reserved.
-#       See http://www.ia.unc.edu/dev/Copyright.htm for details.
-#          This software is distributed WITHOUT ANY WARRANTY; without even
-#          the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-#          PURPOSE.  See the above copyright notices for more information.
-# 
-#     contributor: Casey Goodlett
-#     
-task_name: scalartransform
-nipype_name: scalartransform
-nipype_module: nipype.interfaces.semtools.legacy.registration
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    input_image: generic/file
-    # type=file|default=<undefined>: Image to transform
-    deformation: generic/file
-    # type=file|default=<undefined>: Deformation field.
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    output_image: generic/file
-    # type=file: The transformed image
-    # type=traitcompound|default=None: The transformed image
-    transformation: generic/file
-    # type=file: Output file for transformation parameters
-    # type=traitcompound|default=None: Output file for transformation parameters
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    input_image:
-    # type=file|default=<undefined>: Image to transform
-    output_image:
-    # type=file: The transformed image
-    # type=traitcompound|default=None: The transformed image
-    transformation:
-    # type=file: Output file for transformation parameters
-    # type=traitcompound|default=None: Output file for transformation parameters
-    invert:
-    # type=bool|default=False: Invert transform before applying.
-    deformation:
-    # type=file|default=<undefined>: Deformation field.
-    h_field:
-    # type=bool|default=False: The deformation is an h-field.
-    interpolation:
-    # type=enum|default='nearestneighbor'|allowed['cubic','linear','nearestneighbor']: Interpolation type (nearestneighbor, linear, cubic)
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/scalartransform_callables.py b/example-specs/task/nipype_internal/pydra-semtools/scalartransform_callables.py
deleted file mode 100644
index 4c4197fa..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/scalartransform_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in scalartransform.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/shuffle_vectors_module.yaml b/example-specs/task/nipype_internal/pydra-semtools/shuffle_vectors_module.yaml
deleted file mode 100644
index d7fffa57..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/shuffle_vectors_module.yaml
+++ /dev/null
@@ -1,89 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.utilities.brains.ShuffleVectorsModule' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: ShuffleVectors
-# 
-#     category: Utilities.BRAINS
-# 
-#     description: Automatic Segmentation using neural networks
-# 
-#     version: 1.0
-# 
-#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
-# 
-#     contributor: Hans Johnson
-#     
-task_name: ShuffleVectorsModule
-nipype_name: ShuffleVectorsModule
-nipype_module: nipype.interfaces.semtools.utilities.brains
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputVectorFileBaseName: generic/file
-    # type=file|default=<undefined>: input vector file name prefix. Usually end with .txt and header file has prost fix of .txt.hdr
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputVectorFileBaseName: generic/file
-    # type=file: output vector file name prefix. Usually end with .txt and header file has prost fix of .txt.hdr
-    # type=traitcompound|default=None: output vector file name prefix. Usually end with .txt and header file has prost fix of .txt.hdr
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputVectorFileBaseName:
-    # type=file|default=<undefined>: input vector file name prefix. Usually end with .txt and header file has prost fix of .txt.hdr
-    outputVectorFileBaseName:
-    # type=file: output vector file name prefix. Usually end with .txt and header file has prost fix of .txt.hdr
-    # type=traitcompound|default=None: output vector file name prefix. Usually end with .txt and header file has prost fix of .txt.hdr
-    resampleProportion:
-    # type=float|default=0.0: downsample size of 1 will be the same size as the input images, downsample size of 3 will throw 2/3 the vectors away.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/shuffle_vectors_module_callables.py b/example-specs/task/nipype_internal/pydra-semtools/shuffle_vectors_module_callables.py
deleted file mode 100644
index 1c56caeb..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/shuffle_vectors_module_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in ShuffleVectorsModule.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/similarity_index.yaml b/example-specs/task/nipype_internal/pydra-semtools/similarity_index.yaml
deleted file mode 100644
index db8872b5..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/similarity_index.yaml
+++ /dev/null
@@ -1,91 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.brains.segmentation.SimilarityIndex' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: BRAINSCut:SimilarityIndexComputation
-# 
-#     category: BRAINS.Segmentation
-# 
-#     description: Automatic analysis of BRAINSCut Output
-# 
-#     version: 1.0
-# 
-#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
-# 
-#     contributor: Eunyoung Regin Kim
-#     
-task_name: SimilarityIndex
-nipype_name: SimilarityIndex
-nipype_module: nipype.interfaces.semtools.brains.segmentation
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputCSVFilename: generic/file
-    # type=file|default=<undefined>: output CSV Filename
-    ANNContinuousVolume: generic/file
-    # type=file|default=<undefined>: ANN Continuous volume to be compared to the manual volume
-    inputManualVolume: generic/file
-    # type=file|default=<undefined>: input manual(reference) volume
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    outputCSVFilename:
-    # type=file|default=<undefined>: output CSV Filename
-    ANNContinuousVolume:
-    # type=file|default=<undefined>: ANN Continuous volume to be compared to the manual volume
-    inputManualVolume:
-    # type=file|default=<undefined>: input manual(reference) volume
-    thresholdInterval:
-    # type=float|default=0.0: Threshold interval to compute similarity index between zero and one
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/similarity_index_callables.py b/example-specs/task/nipype_internal/pydra-semtools/similarity_index_callables.py
deleted file mode 100644
index 64a0e7e5..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/similarity_index_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in SimilarityIndex.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/spherical_coordinate_generation.yaml b/example-specs/task/nipype_internal/pydra-semtools/spherical_coordinate_generation.yaml
deleted file mode 100644
index 46fecd20..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/spherical_coordinate_generation.yaml
+++ /dev/null
@@ -1,81 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.testing.featuredetection.SphericalCoordinateGeneration' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Spherical Coordinate Generation
-# 
-#     category: Testing.FeatureDetection
-# 
-#     description: get the atlas image as input and generates the rho, phi and theta images.
-# 
-#     version: 0.1.0.$Revision: 1 $(alpha)
-# 
-#     contributor: Ali Ghayoor
-#     
-task_name: SphericalCoordinateGeneration
-nipype_name: SphericalCoordinateGeneration
-nipype_module: nipype.interfaces.semtools.testing.featuredetection
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputAtlasImage: generic/file
-    # type=file|default=<undefined>: Input atlas image
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputAtlasImage:
-    # type=file|default=<undefined>: Input atlas image
-    outputPath:
-    # type=str|default='': Output path for rho, phi and theta images
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/spherical_coordinate_generation_callables.py b/example-specs/task/nipype_internal/pydra-semtools/spherical_coordinate_generation_callables.py
deleted file mode 100644
index f5a3e1b4..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/spherical_coordinate_generation_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in SphericalCoordinateGeneration.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/staple_analysis.yaml b/example-specs/task/nipype_internal/pydra-semtools/staple_analysis.yaml
deleted file mode 100644
index 9f13769f..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/staple_analysis.yaml
+++ /dev/null
@@ -1,91 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.filtering.featuredetection.STAPLEAnalysis' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Dilate Image
-# 
-#     category: Filtering.FeatureDetection
-# 
-#     description: Uses mathematical morphology to dilate the input images.
-# 
-#     version: 0.1.0.$Revision: 1 $(alpha)
-# 
-#     documentation-url: http:://www.na-mic.org/
-# 
-#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
-# 
-#     contributor: This tool was developed by Mark Scully and Jeremy Bockholt.
-#     
-task_name: STAPLEAnalysis
-nipype_name: STAPLEAnalysis
-nipype_module: nipype.interfaces.semtools.filtering.featuredetection
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputLabelVolume: generic/file+list-of
-    # type=inputmultiobject|default=[]: Required: input label volume
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputVolume: generic/file
-    # type=file: Required: output image
-    # type=traitcompound|default=None: Required: output image
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputDimension:
-    # type=int|default=0: Required: input image Dimension 2 or 3
-    inputLabelVolume:
-    # type=inputmultiobject|default=[]: Required: input label volume
-    outputVolume:
-    # type=file: Required: output image
-    # type=traitcompound|default=None: Required: output image
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/staple_analysis_callables.py b/example-specs/task/nipype_internal/pydra-semtools/staple_analysis_callables.py
deleted file mode 100644
index 202d8fdb..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/staple_analysis_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in STAPLEAnalysis.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/texture_from_noise_image_filter.yaml b/example-specs/task/nipype_internal/pydra-semtools/texture_from_noise_image_filter.yaml
deleted file mode 100644
index de6e4846..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/texture_from_noise_image_filter.yaml
+++ /dev/null
@@ -1,91 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.filtering.featuredetection.TextureFromNoiseImageFilter' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: TextureFromNoiseImageFilter
-# 
-#     category: Filtering.FeatureDetection
-# 
-#     description: Calculate the local noise in an image.
-# 
-#     version: 0.1.0.$Revision: 1 $(alpha)
-# 
-#     documentation-url: http:://www.na-mic.org/
-# 
-#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
-# 
-#     contributor: This tool was developed by Eunyoung Regina Kim
-#     
-task_name: TextureFromNoiseImageFilter
-nipype_name: TextureFromNoiseImageFilter
-nipype_module: nipype.interfaces.semtools.filtering.featuredetection
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputVolume: generic/file
-    # type=file|default=<undefined>: Required: input image
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputVolume: generic/file
-    # type=file: Required: output image
-    # type=traitcompound|default=None: Required: output image
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputVolume:
-    # type=file|default=<undefined>: Required: input image
-    inputRadius:
-    # type=int|default=0: Required: input neighborhood radius
-    outputVolume:
-    # type=file: Required: output image
-    # type=traitcompound|default=None: Required: output image
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/texture_from_noise_image_filter_callables.py b/example-specs/task/nipype_internal/pydra-semtools/texture_from_noise_image_filter_callables.py
deleted file mode 100644
index 00c718c6..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/texture_from_noise_image_filter_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in TextureFromNoiseImageFilter.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/texture_measure_filter.yaml b/example-specs/task/nipype_internal/pydra-semtools/texture_measure_filter.yaml
deleted file mode 100644
index 3c9bf900..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/texture_measure_filter.yaml
+++ /dev/null
@@ -1,97 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.filtering.featuredetection.TextureMeasureFilter' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Canny Level Set Image Filter
-# 
-#     category: Filtering.FeatureDetection
-# 
-#     description: The CannySegmentationLevelSet is commonly used to refine a manually generated manual mask.
-# 
-#     version: 0.3.0
-# 
-#     license: CC
-# 
-#     contributor: Regina Kim
-# 
-#     acknowledgements: This command module was derived from Insight/Examples/Segmentation/CannySegmentationLevelSetImageFilter.cxx (copyright) Insight Software Consortium.  See http://wiki.na-mic.org/Wiki/index.php/Slicer3:Execution_Model_Documentation for more detailed descriptions.
-#     
-task_name: TextureMeasureFilter
-nipype_name: TextureMeasureFilter
-nipype_module: nipype.interfaces.semtools.filtering.featuredetection
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputVolume: generic/file
-    # type=file|default=<undefined>: 
-    inputMaskVolume: generic/file
-    # type=file|default=<undefined>: 
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputFilename: generic/file
-    # type=file: 
-    # type=traitcompound|default=None: 
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputVolume:
-    # type=file|default=<undefined>: 
-    inputMaskVolume:
-    # type=file|default=<undefined>: 
-    distance:
-    # type=int|default=0: 
-    insideROIValue:
-    # type=float|default=0.0: 
-    outputFilename:
-    # type=file: 
-    # type=traitcompound|default=None: 
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/texture_measure_filter_callables.py b/example-specs/task/nipype_internal/pydra-semtools/texture_measure_filter_callables.py
deleted file mode 100644
index b2d48fa2..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/texture_measure_filter_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in TextureMeasureFilter.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/ukf_tractography.yaml b/example-specs/task/nipype_internal/pydra-semtools/ukf_tractography.yaml
deleted file mode 100644
index 3789694a..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/ukf_tractography.yaml
+++ /dev/null
@@ -1,159 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.diffusion.tractography.ukftractography.UKFTractography' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: UKF Tractography
-# 
-#     category: Diffusion.Tractography
-# 
-#     description: This module traces fibers in a DWI Volume using the multiple tensor unscented Kalman Filter methology. For more information check the documentation.
-# 
-#     version: 1.0
-# 
-#     documentation-url: http://www.nitrc.org/plugins/mwiki/index.php/ukftractography:MainPage
-# 
-#     contributor: Yogesh Rathi, Stefan Lienhard, Yinpeng Li, Martin Styner, Ipek Oguz, Yundi Shi, Christian Baumgartner, Kent Williams, Hans Johnson, Peter Savadjiev, Carl-Fredrik Westin.
-# 
-#     acknowledgements: The development of this module was supported by NIH grants R01 MH097979 (PI Rathi), R01 MH092862 (PIs Westin and Verma), U01 NS083223 (PI Westin), R01 MH074794 (PI Westin) and P41 EB015902 (PI Kikinis).
-#     
-task_name: UKFTractography
-nipype_name: UKFTractography
-nipype_module: nipype.interfaces.semtools.diffusion.tractography.ukftractography
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    dwiFile: generic/file
-    # type=file|default=<undefined>: Input DWI volume
-    seedsFile: generic/file
-    # type=file|default=<undefined>: Seeds for diffusion. If not specified, full brain tractography will be performed, and the algorithm will start from every voxel in the brain mask where the Generalized Anisotropy is bigger than 0.18
-    maskFile: generic/file
-    # type=file|default=<undefined>: Mask for diffusion tractography
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    tracts: generic/file
-    # type=file: Tracts generated, with first tensor output
-    # type=traitcompound|default=None: Tracts generated, with first tensor output
-    tractsWithSecondTensor: generic/file
-    # type=file: Tracts generated, with second tensor output (if there is one)
-    # type=traitcompound|default=None: Tracts generated, with second tensor output (if there is one)
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    dwiFile:
-    # type=file|default=<undefined>: Input DWI volume
-    seedsFile:
-    # type=file|default=<undefined>: Seeds for diffusion. If not specified, full brain tractography will be performed, and the algorithm will start from every voxel in the brain mask where the Generalized Anisotropy is bigger than 0.18
-    labels:
-    # type=inputmultiobject|default=[]: A vector of the ROI labels to be used
-    maskFile:
-    # type=file|default=<undefined>: Mask for diffusion tractography
-    tracts:
-    # type=file: Tracts generated, with first tensor output
-    # type=traitcompound|default=None: Tracts generated, with first tensor output
-    writeAsciiTracts:
-    # type=bool|default=False: Write tract file as a VTK binary data file
-    writeUncompressedTracts:
-    # type=bool|default=False: Write tract file as a VTK uncompressed data file
-    seedsPerVoxel:
-    # type=int|default=0:  Each seed generates a fiber, thus using more seeds generates more fibers. In general use 1 or 2 seeds, and for a more thorough result use 5 or 10 (depending on your machine this may take up to 2 days to run).,       
-    numTensor:
-    # type=enum|default='1'|allowed['1','2']: Number of tensors used
-    freeWater:
-    # type=bool|default=False: Adds a term for free water difusion to the model. (Note for experts: if checked, the 1T simple model is forced) 
-    recordFA:
-    # type=bool|default=False: Whether to store FA. Attaches field 'FA', and 'FA2' for 2-tensor case to fiber. 
-    recordFreeWater:
-    # type=bool|default=False: Whether to store the fraction of free water. Attaches field 'FreeWater' to fiber.
-    recordTrace:
-    # type=bool|default=False: Whether to store Trace. Attaches field 'Trace', and 'Trace2' for 2-tensor case to fiber.
-    recordTensors:
-    # type=bool|default=False: Recording the tensors enables Slicer to color the fiber bundles by FA, orientation, and so on. The fields will be called 'TensorN', where N is the tensor number. 
-    recordNMSE:
-    # type=bool|default=False: Whether to store NMSE. Attaches field 'NMSE' to fiber. 
-    recordState:
-    # type=bool|default=False: Whether to attach the states to the fiber. Will generate field 'state'.
-    recordCovariance:
-    # type=bool|default=False: Whether to store the covariance. Will generate field 'covariance' in fiber.
-    recordLength:
-    # type=float|default=0.0: Record length of tractography, in millimeters
-    minFA:
-    # type=float|default=0.0: Abort the tractography when the Fractional Anisotropy is less than this value
-    minGA:
-    # type=float|default=0.0: Abort the tractography when the Generalized Anisotropy is less than this value
-    fullTensorModel:
-    # type=bool|default=False: Whether to use the full tensor model. If unchecked, use the default simple tensor model
-    numThreads:
-    # type=int|default=0: Number of threads used during computation. Set to the number of cores on your workstation for optimal speed. If left undefined the number of cores detected will be used. 
-    stepLength:
-    # type=float|default=0.0: Step length of tractography, in millimeters
-    maxHalfFiberLength:
-    # type=float|default=0.0: The max length limit of the half fibers generated during tractography. Here the fiber is 'half' because the tractography goes in only one direction from one seed point at a time
-    seedFALimit:
-    # type=float|default=0.0: Seed points whose FA are below this value are excluded
-    Qm:
-    # type=float|default=0.0: Process noise for angles/direction
-    Ql:
-    # type=float|default=0.0: Process noise for eigenvalues
-    Qw:
-    # type=float|default=0.0: Process noise for free water weights, ignored if no free water estimation
-    Rs:
-    # type=float|default=0.0: Measurement noise
-    maxBranchingAngle:
-    # type=float|default=0.0: Maximum branching angle, in degrees. When using multiple tensors, a new branch will be created when the tensors' major directions form an angle between (minBranchingAngle, maxBranchingAngle). Branching is suppressed when this maxBranchingAngle is set to 0.0
-    minBranchingAngle:
-    # type=float|default=0.0: Minimum branching angle, in degrees. When using multiple tensors, a new branch will be created when the tensors' major directions form an angle between (minBranchingAngle, maxBranchingAngle)
-    tractsWithSecondTensor:
-    # type=file: Tracts generated, with second tensor output (if there is one)
-    # type=traitcompound|default=None: Tracts generated, with second tensor output (if there is one)
-    storeGlyphs:
-    # type=bool|default=False: Store tensors' main directions as two-point lines in a separate file named glyphs_{tracts}. When using multiple tensors, only the major tensors' main directions are stored
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/ukf_tractography_callables.py b/example-specs/task/nipype_internal/pydra-semtools/ukf_tractography_callables.py
deleted file mode 100644
index d0fe23da..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/ukf_tractography_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in UKFTractography.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/unbiased_non_local_means.yaml b/example-specs/task/nipype_internal/pydra-semtools/unbiased_non_local_means.yaml
deleted file mode 100644
index 257f42d0..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/unbiased_non_local_means.yaml
+++ /dev/null
@@ -1,107 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.filtering.denoising.UnbiasedNonLocalMeans' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Unbiased NLM for MRI
-# 
-#     category: Filtering.Denoising
-# 
-#     description: This module implements a fast version of the popular Non-Local Means filter for image denoising. This algorithm filters each pixel as a weighted average of its neighbors in a large vicinity. The weights are computed based on the similarity of each neighbor with the voxel to be denoised.
-#      In the original formulation a patch with a certain radius is centered in each of the voxels, and the Mean Squared Error between each pair of corresponding voxels is computed. In this implementation, only the mean value and gradient components are compared. This, together with an efficient memory management, can attain a speed-up of nearly 20x. Besides, the filtering is more accurate than the original with poor SNR.
-#      This code is intended for its use with MRI (or any other Rician-distributed modality): the second order moment is estimated, then we subtract twice the squared power of noise, and finally we take the square root of the result to remove the Rician bias.
-#      The original implementation of the NLM filter may be found in:
-#      A. Buades, B. Coll, J. Morel, "A review of image denoising algorithms, with a new one", Multiscale Modelling and Simulation 4(2): 490-530. 2005.
-#      The correction of the Rician bias is described in the following reference (among others):
-#      S. Aja-Fernandez, K. Krissian, "An unbiased Non-Local Means scheme for DWI filtering", in: Proceedings of the MICCAI Workshop on Computational Diffusion MRI, 2008, pp. 277-284.
-#      The whole description of this version may be found in the following paper (please, cite it if you are willing to use this software):
-#      A. Tristan-Vega, V. Garcia Perez, S. Aja-Fenandez, and C.-F. Westin, "Efficient and Robust Nonlocal Means Denoising of MR Data Based on Salient Features Matching", Computer Methods and Programs in Biomedicine. (Accepted for publication) 2011.
-# 
-#     version: 0.0.1.$Revision: 1 $(beta)
-# 
-#     documentation-url: http://www.slicer.org/slicerWiki/index.php/Modules:UnbiasedNonLocalMeans-Documentation-3.6
-# 
-#     contributor: Antonio Tristan Vega, Veronica Garcia-Perez, Santiago Aja-Fernandez, Carl-Fredrik Westin
-# 
-#     acknowledgements: Supported by grant number FMECD-2010/71131616E from the Spanish Ministry of Education/Fulbright Committee
-#     
-task_name: UnbiasedNonLocalMeans
-nipype_name: UnbiasedNonLocalMeans
-nipype_module: nipype.interfaces.semtools.filtering.denoising
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputVolume: generic/file
-    # type=file|default=<undefined>: Input MRI volume.
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputVolume: generic/file
-    # type=file: Output (filtered) MRI volume.
-    # type=traitcompound|default=None: Output (filtered) MRI volume.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    sigma:
-    # type=float|default=0.0: The root power of noise (sigma) in the complex Gaussian process the Rician comes from. If it is underestimated, the algorithm fails to remove the noise. If it is overestimated, over-blurring is likely to occur.
-    rs:
-    # type=inputmultiobject|default=[]: The algorithm search for similar voxels in a neighborhood of this radius (radii larger than 5,5,5 are very slow, and the results can be only marginally better. Small radii may fail to effectively remove the noise).
-    rc:
-    # type=inputmultiobject|default=[]: Similarity between blocks is computed as the difference between mean values and gradients. These parameters are computed fitting a hyperplane with LS inside a neighborhood of this size
-    hp:
-    # type=float|default=0.0: This parameter is related to noise; the larger the parameter, the more aggressive the filtering. Should be near 1, and only values between 0.8 and 1.2 are allowed
-    ps:
-    # type=float|default=0.0: To accelerate computations, preselection is used: if the normalized difference is above this threshold, the voxel will be discarded (non used for average)
-    inputVolume:
-    # type=file|default=<undefined>: Input MRI volume.
-    outputVolume:
-    # type=file: Output (filtered) MRI volume.
-    # type=traitcompound|default=None: Output (filtered) MRI volume.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/unbiased_non_local_means_callables.py b/example-specs/task/nipype_internal/pydra-semtools/unbiased_non_local_means_callables.py
deleted file mode 100644
index e597ef31..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/unbiased_non_local_means_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in UnbiasedNonLocalMeans.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-semtools/vbrains_demon_warp.yaml b/example-specs/task/nipype_internal/pydra-semtools/vbrains_demon_warp.yaml
deleted file mode 100644
index ef83febc..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/vbrains_demon_warp.yaml
+++ /dev/null
@@ -1,187 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.semtools.registration.specialized.VBRAINSDemonWarp' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Vector Demon Registration (BRAINS)
-# 
-#     category: Registration.Specialized
-# 
-#     description: This program finds a deformation field to warp a moving image onto a fixed image.  The images must be of the same signal kind, and contain an image of the same kind of object.  This program uses the Thirion Demons warp software in ITK, the Insight Toolkit.  Additional information is available at: http://www.nitrc.org/projects/brainsdemonwarp.
-# 
-#     version: 3.0.0
-# 
-#     documentation-url: http://www.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/BRAINSDemonWarp
-# 
-#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
-# 
-#     contributor: This tool was developed by Hans J. Johnson and Greg Harris.
-# 
-#     acknowledgements: The development of this tool was supported by funding from grants NS050568 and NS40068 from the National Institute of Neurological Disorders and Stroke and grants MH31593, MH40856, from the National Institute of Mental Health.
-#     
-task_name: VBRAINSDemonWarp
-nipype_name: VBRAINSDemonWarp
-nipype_module: nipype.interfaces.semtools.registration.specialized
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    movingVolume: generic/file+list-of
-    # type=inputmultiobject|default=[]: Required: input moving image
-    fixedVolume: generic/file+list-of
-    # type=inputmultiobject|default=[]: Required: input fixed (target) image
-    initializeWithDisplacementField: generic/file
-    # type=file|default=<undefined>: Initial deformation field vector image file name
-    initializeWithTransform: generic/file
-    # type=file|default=<undefined>: Initial Transform filename
-    fixedBinaryVolume: generic/file
-    # type=file|default=<undefined>: Mask filename for desired region of interest in the Fixed image.
-    movingBinaryVolume: generic/file
-    # type=file|default=<undefined>: Mask filename for desired region of interest in the Moving image.
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputVolume: generic/file
-    # type=file: Required: output resampled moving image (will have the same physical space as the fixedVolume).
-    # type=traitcompound|default=None: Required: output resampled moving image (will have the same physical space as the fixedVolume).
-    outputDisplacementFieldVolume: generic/file
-    # type=file: Output deformation field vector image (will have the same physical space as the fixedVolume).
-    # type=traitcompound|default=None: Output deformation field vector image (will have the same physical space as the fixedVolume).
-    outputCheckerboardVolume: generic/file
-    # type=file: Genete a checkerboard image volume between the fixedVolume and the deformed movingVolume.
-    # type=traitcompound|default=None: Genete a checkerboard image volume between the fixedVolume and the deformed movingVolume.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    movingVolume:
-    # type=inputmultiobject|default=[]: Required: input moving image
-    fixedVolume:
-    # type=inputmultiobject|default=[]: Required: input fixed (target) image
-    inputPixelType:
-    # type=enum|default='float'|allowed['float','int','short','uchar','ushort']: Input volumes will be typecast to this format: float|short|ushort|int|uchar
-    outputVolume:
-    # type=file: Required: output resampled moving image (will have the same physical space as the fixedVolume).
-    # type=traitcompound|default=None: Required: output resampled moving image (will have the same physical space as the fixedVolume).
-    outputDisplacementFieldVolume:
-    # type=file: Output deformation field vector image (will have the same physical space as the fixedVolume).
-    # type=traitcompound|default=None: Output deformation field vector image (will have the same physical space as the fixedVolume).
-    outputPixelType:
-    # type=enum|default='float'|allowed['float','int','short','uchar','ushort']: outputVolume will be typecast to this format: float|short|ushort|int|uchar
-    interpolationMode:
-    # type=enum|default='NearestNeighbor'|allowed['BSpline','Blackman','Cosine','Hamming','Lanczos','Linear','NearestNeighbor','ResampleInPlace','Welch','WindowedSinc']: Type of interpolation to be used when applying transform to moving volume.  Options are Linear, ResampleInPlace, NearestNeighbor, BSpline, or WindowedSinc
-    registrationFilterType:
-    # type=enum|default='Demons'|allowed['Demons','Diffeomorphic','FastSymmetricForces','LogDemons','SymmetricLogDemons']: Registration Filter Type: Demons|FastSymmetricForces|Diffeomorphic|LogDemons|SymmetricLogDemons
-    smoothDisplacementFieldSigma:
-    # type=float|default=0.0: A gaussian smoothing value to be applied to the deformation field at each iteration.
-    numberOfPyramidLevels:
-    # type=int|default=0: Number of image pyramid levels to use in the multi-resolution registration.
-    minimumFixedPyramid:
-    # type=inputmultiobject|default=[]: The shrink factor for the first level of the fixed image pyramid. (i.e. start at 1/16 scale, then 1/8, then 1/4, then 1/2, and finally full scale)
-    minimumMovingPyramid:
-    # type=inputmultiobject|default=[]: The shrink factor for the first level of the moving image pyramid. (i.e. start at 1/16 scale, then 1/8, then 1/4, then 1/2, and finally full scale)
-    arrayOfPyramidLevelIterations:
-    # type=inputmultiobject|default=[]: The number of iterations for each pyramid level
-    histogramMatch:
-    # type=bool|default=False: Histogram Match the input images.  This is suitable for images of the same modality that may have different absolute scales, but the same overall intensity profile.
-    numberOfHistogramBins:
-    # type=int|default=0: The number of histogram levels
-    numberOfMatchPoints:
-    # type=int|default=0: The number of match points for histrogramMatch
-    medianFilterSize:
-    # type=inputmultiobject|default=[]: Median filter radius in all 3 directions.  When images have a lot of salt and pepper noise, this step can improve the registration.
-    initializeWithDisplacementField:
-    # type=file|default=<undefined>: Initial deformation field vector image file name
-    initializeWithTransform:
-    # type=file|default=<undefined>: Initial Transform filename
-    makeBOBF:
-    # type=bool|default=False: Flag to make Brain-Only Background-Filled versions of the input and target volumes.
-    fixedBinaryVolume:
-    # type=file|default=<undefined>: Mask filename for desired region of interest in the Fixed image.
-    movingBinaryVolume:
-    # type=file|default=<undefined>: Mask filename for desired region of interest in the Moving image.
-    lowerThresholdForBOBF:
-    # type=int|default=0: Lower threshold for performing BOBF
-    upperThresholdForBOBF:
-    # type=int|default=0: Upper threshold for performing BOBF
-    backgroundFillValue:
-    # type=int|default=0: Replacement value to overwrite background when performing BOBF
-    seedForBOBF:
-    # type=inputmultiobject|default=[]: coordinates in all 3 directions for Seed when performing BOBF
-    neighborhoodForBOBF:
-    # type=inputmultiobject|default=[]: neighborhood in all 3 directions to be included when performing BOBF
-    outputDisplacementFieldPrefix:
-    # type=str|default='': Displacement field filename prefix for writing separate x, y, and z component images
-    outputCheckerboardVolume:
-    # type=file: Genete a checkerboard image volume between the fixedVolume and the deformed movingVolume.
-    # type=traitcompound|default=None: Genete a checkerboard image volume between the fixedVolume and the deformed movingVolume.
-    checkerboardPatternSubdivisions:
-    # type=inputmultiobject|default=[]: Number of Checkerboard subdivisions in all 3 directions
-    outputNormalized:
-    # type=bool|default=False: Flag to warp and write the normalized images to output.  In normalized images the image values are fit-scaled to be between 0 and the maximum storage type value.
-    outputDebug:
-    # type=bool|default=False: Flag to write debugging images after each step.
-    weightFactors:
-    # type=inputmultiobject|default=[]: Weight fatctors for each input images
-    gradient_type:
-    # type=enum|default='0'|allowed['0','1','2']: Type of gradient used for computing the demons force (0 is symmetrized, 1 is fixed image, 2 is moving image)
-    upFieldSmoothing:
-    # type=float|default=0.0: Smoothing sigma for the update field at each iteration
-    max_step_length:
-    # type=float|default=0.0: Maximum length of an update vector (0: no restriction)
-    use_vanilla_dem:
-    # type=bool|default=False: Run vanilla demons algorithm
-    gui:
-    # type=bool|default=False: Display intermediate image volumes for debugging
-    promptUser:
-    # type=bool|default=False: Prompt the user to hit enter each time an image is sent to the DebugImageViewer
-    numberOfBCHApproximationTerms:
-    # type=int|default=0: Number of terms in the BCH expansion
-    numberOfThreads:
-    # type=int|default=0: Explicitly specify the maximum number of threads to use.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-semtools/vbrains_demon_warp_callables.py b/example-specs/task/nipype_internal/pydra-semtools/vbrains_demon_warp_callables.py
deleted file mode 100644
index c1ed6ee7..00000000
--- a/example-specs/task/nipype_internal/pydra-semtools/vbrains_demon_warp_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in VBRAINSDemonWarp.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/acpc_transform.yaml b/example-specs/task/nipype_internal/pydra-slicer/acpc_transform.yaml
deleted file mode 100644
index 4b7b0aa0..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/acpc_transform.yaml
+++ /dev/null
@@ -1,93 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.slicer.registration.specialized.ACPCTransform' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: ACPC Transform
-# 
-#     category: Registration.Specialized
-# 
-#     description: <p>Calculate a transformation from two lists of fiducial points.</p><p>ACPC line is two fiducial points, one at the anterior commissure and one at the posterior commissure. The resulting transform will bring the line connecting them to horizontal to the AP axis.</p><p>The midline is a series of points defining the division between the hemispheres of the brain (the mid sagittal plane). The resulting transform will put the output volume with the mid sagittal plane lined up with the AS plane.</p><p>Use the Filtering module<b>Resample Scalar/Vector/DWI Volume</b>to apply the transformation to a volume.</p>
-# 
-#     version: 1.0
-# 
-#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/ACPCTransform
-# 
-#     license: slicer3
-# 
-#     contributor: Nicole Aucoin (SPL, BWH), Ron Kikinis (SPL, BWH)
-# 
-#     acknowledgements: This work is part of the National Alliance for Medical Image Computing (NAMIC), funded by the National Institutes of Health through the NIH Roadmap for Medical Research, Grant U54 EB005149.
-#     
-task_name: ACPCTransform
-nipype_name: ACPCTransform
-nipype_module: nipype.interfaces.slicer.registration.specialized
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputTransform: generic/file
-    # type=file: A transform filled in from the ACPC and Midline registration calculation
-    # type=traitcompound|default=None: A transform filled in from the ACPC and Midline registration calculation
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    acpc:
-    # type=inputmultiobject|default=[]: ACPC line, two fiducial points, one at the anterior commissure and one at the posterior commissure.
-    midline:
-    # type=inputmultiobject|default=[]: The midline is a series of points defining the division between the hemispheres of the brain (the mid sagittal plane).
-    outputTransform:
-    # type=file: A transform filled in from the ACPC and Midline registration calculation
-    # type=traitcompound|default=None: A transform filled in from the ACPC and Midline registration calculation
-    debugSwitch:
-    # type=bool|default=False: Click if wish to see debugging output
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/acpc_transform_callables.py b/example-specs/task/nipype_internal/pydra-slicer/acpc_transform_callables.py
deleted file mode 100644
index 2f786068..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/acpc_transform_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in ACPCTransform.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/add_scalar_volumes.yaml b/example-specs/task/nipype_internal/pydra-slicer/add_scalar_volumes.yaml
deleted file mode 100644
index ec1b6e7a..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/add_scalar_volumes.yaml
+++ /dev/null
@@ -1,95 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.slicer.filtering.arithmetic.AddScalarVolumes' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Add Scalar Volumes
-# 
-#     category: Filtering.Arithmetic
-# 
-#     description: Adds two images. Although all image types are supported on input, only signed types are produced. The two images do not have to have the same dimensions.
-# 
-#     version: 0.1.0.$Revision: 19608 $(alpha)
-# 
-#     documentation-url: http://slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/Add
-# 
-#     contributor: Bill Lorensen (GE)
-# 
-#     acknowledgements: This work is part of the National Alliance for Medical Image Computing (NAMIC), funded by the National Institutes of Health through the NIH Roadmap for Medical Research, Grant U54 EB005149.
-#     
-task_name: AddScalarVolumes
-nipype_name: AddScalarVolumes
-nipype_module: nipype.interfaces.slicer.filtering.arithmetic
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputVolume1: generic/file
-    # type=file|default=<undefined>: Input volume 1
-    inputVolume2: generic/file
-    # type=file|default=<undefined>: Input volume 2
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputVolume: generic/file
-    # type=file: Volume1 + Volume2
-    # type=traitcompound|default=None: Volume1 + Volume2
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputVolume1:
-    # type=file|default=<undefined>: Input volume 1
-    inputVolume2:
-    # type=file|default=<undefined>: Input volume 2
-    outputVolume:
-    # type=file: Volume1 + Volume2
-    # type=traitcompound|default=None: Volume1 + Volume2
-    order:
-    # type=enum|default='0'|allowed['0','1','2','3']: Interpolation order if two images are in different coordinate frames or have different sampling.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/add_scalar_volumes_callables.py b/example-specs/task/nipype_internal/pydra-slicer/add_scalar_volumes_callables.py
deleted file mode 100644
index 557644f7..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/add_scalar_volumes_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in AddScalarVolumes.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/affine_registration.yaml b/example-specs/task/nipype_internal/pydra-slicer/affine_registration.yaml
deleted file mode 100644
index 421540d9..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/affine_registration.yaml
+++ /dev/null
@@ -1,121 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.slicer.legacy.registration.AffineRegistration' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Affine Registration
-# 
-#     category: Legacy.Registration
-# 
-#     description: Registers two images together using an affine transform and mutual information. This module is often used to align images of different subjects or images of the same subject from different modalities.
-# 
-#     This module can smooth images prior to registration to mitigate noise and improve convergence. Many of the registration parameters require a working knowledge of the algorithm although the default parameters are sufficient for many registration tasks.
-# 
-# 
-# 
-#     version: 0.1.0.$Revision: 19608 $(alpha)
-# 
-#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/AffineRegistration
-# 
-#     contributor: Daniel Blezek (GE)
-# 
-#     acknowledgements: This module was developed by Daniel Blezek while at GE Research with contributions from Jim Miller.
-# 
-#     This work is part of the National Alliance for Medical Image Computing (NAMIC), funded by the National Institutes of Health through the NIH Roadmap for Medical Research, Grant U54 EB005149.
-#     
-task_name: AffineRegistration
-nipype_name: AffineRegistration
-nipype_module: nipype.interfaces.slicer.legacy.registration
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    initialtransform: generic/file
-    # type=file|default=<undefined>: Initial transform for aligning the fixed and moving image.  Maps positions in the fixed coordinate frame to positions in the moving coordinate frame. Optional.
-    FixedImageFileName: generic/file
-    # type=file|default=<undefined>: Fixed image to which to register
-    MovingImageFileName: generic/file
-    # type=file|default=<undefined>: Moving image
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputtransform: generic/file
-    # type=file: Transform calculated that aligns the fixed and moving image. Maps positions in the fixed coordinate frame to the moving coordinate frame. Optional (specify an output transform or an output volume or both).
-    # type=traitcompound|default=None: Transform calculated that aligns the fixed and moving image. Maps positions in the fixed coordinate frame to the moving coordinate frame. Optional (specify an output transform or an output volume or both).
-    resampledmovingfilename: generic/file
-    # type=file: Resampled moving image to the fixed image coordinate frame. Optional (specify an output transform or an output volume or both).
-    # type=traitcompound|default=None: Resampled moving image to the fixed image coordinate frame. Optional (specify an output transform or an output volume or both).
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    fixedsmoothingfactor:
-    # type=int|default=0: Amount of smoothing applied to fixed image prior to registration. Default is 0 (none). Range is 0-5 (unitless). Consider smoothing the input data if there is considerable amounts of noise or the noise pattern in the fixed and moving images is very different.
-    movingsmoothingfactor:
-    # type=int|default=0: Amount of smoothing applied to moving image prior to registration. Default is 0 (none). Range is 0-5 (unitless). Consider smoothing the input data if there is considerable amounts of noise or the noise pattern in the fixed and moving images is very different.
-    histogrambins:
-    # type=int|default=0: Number of histogram bins to use for Mattes Mutual Information. Reduce the number of bins if a registration fails. If the number of bins is too large, the estimated PDFs will be a field of impulses and will inhibit reliable registration estimation.
-    spatialsamples:
-    # type=int|default=0: Number of spatial samples to use in estimating Mattes Mutual Information. Larger values yield more accurate PDFs and improved registration quality.
-    iterations:
-    # type=int|default=0: Number of iterations
-    translationscale:
-    # type=float|default=0.0: Relative scale of translations to rotations, i.e. a value of 100 means 10mm = 1 degree. (Actual scale used is 1/(TranslationScale^2)). This parameter is used to 'weight' or 'standardized' the transform parameters and their effect on the registration objective function.
-    initialtransform:
-    # type=file|default=<undefined>: Initial transform for aligning the fixed and moving image.  Maps positions in the fixed coordinate frame to positions in the moving coordinate frame. Optional.
-    FixedImageFileName:
-    # type=file|default=<undefined>: Fixed image to which to register
-    MovingImageFileName:
-    # type=file|default=<undefined>: Moving image
-    outputtransform:
-    # type=file: Transform calculated that aligns the fixed and moving image. Maps positions in the fixed coordinate frame to the moving coordinate frame. Optional (specify an output transform or an output volume or both).
-    # type=traitcompound|default=None: Transform calculated that aligns the fixed and moving image. Maps positions in the fixed coordinate frame to the moving coordinate frame. Optional (specify an output transform or an output volume or both).
-    resampledmovingfilename:
-    # type=file: Resampled moving image to the fixed image coordinate frame. Optional (specify an output transform or an output volume or both).
-    # type=traitcompound|default=None: Resampled moving image to the fixed image coordinate frame. Optional (specify an output transform or an output volume or both).
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/affine_registration_callables.py b/example-specs/task/nipype_internal/pydra-slicer/affine_registration_callables.py
deleted file mode 100644
index 0a078adc..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/affine_registration_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in AffineRegistration.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/b_spline_deformable_registration.yaml b/example-specs/task/nipype_internal/pydra-slicer/b_spline_deformable_registration.yaml
deleted file mode 100644
index 6fd1a9d9..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/b_spline_deformable_registration.yaml
+++ /dev/null
@@ -1,123 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.slicer.legacy.registration.BSplineDeformableRegistration' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: BSpline Deformable Registration
-# 
-#     category: Legacy.Registration
-# 
-#     description: Registers two images together using BSpline transform and mutual information.
-# 
-#     version: 0.1.0.$Revision: 19608 $(alpha)
-# 
-#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/BSplineDeformableRegistration
-# 
-#     contributor: Bill Lorensen (GE)
-# 
-#     acknowledgements: This work is part of the National Alliance for Medical Image Computing (NAMIC), funded by the National Institutes of Health through the NIH Roadmap for Medical Research, Grant U54 EB005149.
-#     
-task_name: BSplineDeformableRegistration
-nipype_name: BSplineDeformableRegistration
-nipype_module: nipype.interfaces.slicer.legacy.registration
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    initialtransform: generic/file
-    # type=file|default=<undefined>: Initial transform for aligning the fixed and moving image. Maps positions in the fixed coordinate frame to positions in the moving coordinate frame. This transform should be an affine or rigid transform.  It is used an a bulk transform for the BSpline. Optional.
-    FixedImageFileName: generic/file
-    # type=file|default=<undefined>: Fixed image to which to register
-    MovingImageFileName: generic/file
-    # type=file|default=<undefined>: Moving image
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputtransform: generic/file
-    # type=file: Transform calculated that aligns the fixed and moving image. Maps positions from the fixed coordinate frame to the moving coordinate frame. Optional (specify an output transform or an output volume or both).
-    # type=traitcompound|default=None: Transform calculated that aligns the fixed and moving image. Maps positions from the fixed coordinate frame to the moving coordinate frame. Optional (specify an output transform or an output volume or both).
-    outputwarp: generic/file
-    # type=file: Vector field that applies an equivalent warp as the BSpline. Maps positions from the fixed coordinate frame to the moving coordinate frame. Optional.
-    # type=traitcompound|default=None: Vector field that applies an equivalent warp as the BSpline. Maps positions from the fixed coordinate frame to the moving coordinate frame. Optional.
-    resampledmovingfilename: generic/file
-    # type=file: Resampled moving image to fixed image coordinate frame. Optional (specify an output transform or an output volume or both).
-    # type=traitcompound|default=None: Resampled moving image to fixed image coordinate frame. Optional (specify an output transform or an output volume or both).
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    iterations:
-    # type=int|default=0: Number of iterations
-    gridSize:
-    # type=int|default=0: Number of grid points on interior of the fixed image. Larger grid sizes allow for finer registrations.
-    histogrambins:
-    # type=int|default=0: Number of histogram bins to use for Mattes Mutual Information. Reduce the number of bins if a deformable registration fails. If the number of bins is too large, the estimated PDFs will be a field of impulses and will inhibit reliable registration estimation.
-    spatialsamples:
-    # type=int|default=0: Number of spatial samples to use in estimating Mattes Mutual Information. Larger values yield more accurate PDFs and improved registration quality.
-    constrain:
-    # type=bool|default=False: Constrain the deformation to the amount specified in Maximum Deformation
-    maximumDeformation:
-    # type=float|default=0.0: If Constrain Deformation is checked, limit the deformation to this amount.
-    default:
-    # type=int|default=0: Default pixel value used if resampling a pixel outside of the volume.
-    initialtransform:
-    # type=file|default=<undefined>: Initial transform for aligning the fixed and moving image. Maps positions in the fixed coordinate frame to positions in the moving coordinate frame. This transform should be an affine or rigid transform.  It is used an a bulk transform for the BSpline. Optional.
-    FixedImageFileName:
-    # type=file|default=<undefined>: Fixed image to which to register
-    MovingImageFileName:
-    # type=file|default=<undefined>: Moving image
-    outputtransform:
-    # type=file: Transform calculated that aligns the fixed and moving image. Maps positions from the fixed coordinate frame to the moving coordinate frame. Optional (specify an output transform or an output volume or both).
-    # type=traitcompound|default=None: Transform calculated that aligns the fixed and moving image. Maps positions from the fixed coordinate frame to the moving coordinate frame. Optional (specify an output transform or an output volume or both).
-    outputwarp:
-    # type=file: Vector field that applies an equivalent warp as the BSpline. Maps positions from the fixed coordinate frame to the moving coordinate frame. Optional.
-    # type=traitcompound|default=None: Vector field that applies an equivalent warp as the BSpline. Maps positions from the fixed coordinate frame to the moving coordinate frame. Optional.
-    resampledmovingfilename:
-    # type=file: Resampled moving image to fixed image coordinate frame. Optional (specify an output transform or an output volume or both).
-    # type=traitcompound|default=None: Resampled moving image to fixed image coordinate frame. Optional (specify an output transform or an output volume or both).
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/b_spline_deformable_registration_callables.py b/example-specs/task/nipype_internal/pydra-slicer/b_spline_deformable_registration_callables.py
deleted file mode 100644
index dfb0e885..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/b_spline_deformable_registration_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in BSplineDeformableRegistration.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/b_spline_to_deformation_field.yaml b/example-specs/task/nipype_internal/pydra-slicer/b_spline_to_deformation_field.yaml
deleted file mode 100644
index dae97fe0..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/b_spline_to_deformation_field.yaml
+++ /dev/null
@@ -1,93 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.slicer.legacy.converters.BSplineToDeformationField' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: BSpline to deformation field
-# 
-#     category: Legacy.Converters
-# 
-#     description: Create a dense deformation field from a bspline+bulk transform.
-# 
-#     version: 0.1.0.$Revision: 2104 $(alpha)
-# 
-#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/BSplineToDeformationField
-# 
-#     contributor: Andrey Fedorov (SPL, BWH)
-# 
-#     acknowledgements: This work is funded by NIH grants R01 CA111288 and U01 CA151261.
-#     
-task_name: BSplineToDeformationField
-nipype_name: BSplineToDeformationField
-nipype_module: nipype.interfaces.slicer.legacy.converters
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    tfm: generic/file
-    # type=file|default=<undefined>: 
-    refImage: generic/file
-    # type=file|default=<undefined>: 
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    defImage: generic/file
-    # type=file: 
-    # type=traitcompound|default=None: 
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    tfm:
-    # type=file|default=<undefined>: 
-    refImage:
-    # type=file|default=<undefined>: 
-    defImage:
-    # type=file: 
-    # type=traitcompound|default=None: 
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/b_spline_to_deformation_field_callables.py b/example-specs/task/nipype_internal/pydra-slicer/b_spline_to_deformation_field_callables.py
deleted file mode 100644
index 6d8d7269..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/b_spline_to_deformation_field_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in BSplineToDeformationField.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/brains_demon_warp.yaml b/example-specs/task/nipype_internal/pydra-slicer/brains_demon_warp.yaml
deleted file mode 100644
index 2eadc746..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/brains_demon_warp.yaml
+++ /dev/null
@@ -1,188 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.slicer.registration.specialized.BRAINSDemonWarp' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Demon Registration (BRAINS)
-# 
-#     category: Registration.Specialized
-# 
-#     description:
-#         This program finds a deformation field to warp a moving image onto a fixed image.  The images must be of the same signal kind, and contain an image of the same kind of object.  This program uses the Thirion Demons warp software in ITK, the Insight Toolkit.  Additional information is available at: http://www.nitrc.org/projects/brainsdemonwarp.
-# 
-# 
-# 
-#     version: 3.0.0
-# 
-#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Modules:BRAINSDemonWarp
-# 
-#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
-# 
-#     contributor: This tool was developed by Hans J. Johnson and Greg Harris.
-# 
-#     acknowledgements: The development of this tool was supported by funding from grants NS050568 and NS40068 from the National Institute of Neurological Disorders and Stroke and grants MH31593, MH40856, from the National Institute of Mental Health.
-#     
-task_name: BRAINSDemonWarp
-nipype_name: BRAINSDemonWarp
-nipype_module: nipype.interfaces.slicer.registration.specialized
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    movingVolume: generic/file
-    # type=file|default=<undefined>: Required: input moving image
-    fixedVolume: generic/file
-    # type=file|default=<undefined>: Required: input fixed (target) image
-    initializeWithDisplacementField: generic/file
-    # type=file|default=<undefined>: Initial deformation field vector image file name
-    initializeWithTransform: generic/file
-    # type=file|default=<undefined>: Initial Transform filename
-    fixedBinaryVolume: generic/file
-    # type=file|default=<undefined>: Mask filename for desired region of interest in the Fixed image.
-    movingBinaryVolume: generic/file
-    # type=file|default=<undefined>: Mask filename for desired region of interest in the Moving image.
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputVolume: generic/file
-    # type=file: Required: output resampled moving image (will have the same physical space as the fixedVolume).
-    # type=traitcompound|default=None: Required: output resampled moving image (will have the same physical space as the fixedVolume).
-    outputDisplacementFieldVolume: generic/file
-    # type=file: Output deformation field vector image (will have the same physical space as the fixedVolume).
-    # type=traitcompound|default=None: Output deformation field vector image (will have the same physical space as the fixedVolume).
-    outputCheckerboardVolume: generic/file
-    # type=file: Genete a checkerboard image volume between the fixedVolume and the deformed movingVolume.
-    # type=traitcompound|default=None: Genete a checkerboard image volume between the fixedVolume and the deformed movingVolume.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    movingVolume:
-    # type=file|default=<undefined>: Required: input moving image
-    fixedVolume:
-    # type=file|default=<undefined>: Required: input fixed (target) image
-    inputPixelType:
-    # type=enum|default='float'|allowed['float','int','short','uchar','ushort']: Input volumes will be typecast to this format: float|short|ushort|int|uchar
-    outputVolume:
-    # type=file: Required: output resampled moving image (will have the same physical space as the fixedVolume).
-    # type=traitcompound|default=None: Required: output resampled moving image (will have the same physical space as the fixedVolume).
-    outputDisplacementFieldVolume:
-    # type=file: Output deformation field vector image (will have the same physical space as the fixedVolume).
-    # type=traitcompound|default=None: Output deformation field vector image (will have the same physical space as the fixedVolume).
-    outputPixelType:
-    # type=enum|default='float'|allowed['float','int','short','uchar','ushort']: outputVolume will be typecast to this format: float|short|ushort|int|uchar
-    interpolationMode:
-    # type=enum|default='NearestNeighbor'|allowed['BSpline','Blackman','Cosine','Hamming','Lanczos','Linear','NearestNeighbor','ResampleInPlace','Welch','WindowedSinc']: Type of interpolation to be used when applying transform to moving volume.  Options are Linear, ResampleInPlace, NearestNeighbor, BSpline, or WindowedSinc
-    registrationFilterType:
-    # type=enum|default='Demons'|allowed['Demons','Diffeomorphic','FastSymmetricForces']: Registration Filter Type: Demons|FastSymmetricForces|Diffeomorphic
-    smoothDisplacementFieldSigma:
-    # type=float|default=0.0: A gaussian smoothing value to be applied to the deformation field at each iteration.
-    numberOfPyramidLevels:
-    # type=int|default=0: Number of image pyramid levels to use in the multi-resolution registration.
-    minimumFixedPyramid:
-    # type=inputmultiobject|default=[]: The shrink factor for the first level of the fixed image pyramid. (i.e. start at 1/16 scale, then 1/8, then 1/4, then 1/2, and finally full scale)
-    minimumMovingPyramid:
-    # type=inputmultiobject|default=[]: The shrink factor for the first level of the moving image pyramid. (i.e. start at 1/16 scale, then 1/8, then 1/4, then 1/2, and finally full scale)
-    arrayOfPyramidLevelIterations:
-    # type=inputmultiobject|default=[]: The number of iterations for each pyramid level
-    histogramMatch:
-    # type=bool|default=False: Histogram Match the input images.  This is suitable for images of the same modality that may have different absolute scales, but the same overall intensity profile.
-    numberOfHistogramBins:
-    # type=int|default=0: The number of histogram levels
-    numberOfMatchPoints:
-    # type=int|default=0: The number of match points for histrogramMatch
-    medianFilterSize:
-    # type=inputmultiobject|default=[]: Median filter radius in all 3 directions.  When images have a lot of salt and pepper noise, this step can improve the registration.
-    initializeWithDisplacementField:
-    # type=file|default=<undefined>: Initial deformation field vector image file name
-    initializeWithTransform:
-    # type=file|default=<undefined>: Initial Transform filename
-    maskProcessingMode:
-    # type=enum|default='NOMASK'|allowed['BOBF','NOMASK','ROI','ROIAUTO']: What mode to use for using the masks: NOMASK|ROIAUTO|ROI|BOBF.  If ROIAUTO is chosen, then the mask is implicitly defined using a otsu foreground and hole filling algorithm. Where the Region Of Interest mode uses the masks to define what parts of the image should be used for computing the deformation field.  Brain Only Background Fill uses the masks to pre-process the input images by clipping and filling in the background with a predefined value.
-    fixedBinaryVolume:
-    # type=file|default=<undefined>: Mask filename for desired region of interest in the Fixed image.
-    movingBinaryVolume:
-    # type=file|default=<undefined>: Mask filename for desired region of interest in the Moving image.
-    lowerThresholdForBOBF:
-    # type=int|default=0: Lower threshold for performing BOBF
-    upperThresholdForBOBF:
-    # type=int|default=0: Upper threshold for performing BOBF
-    backgroundFillValue:
-    # type=int|default=0: Replacement value to overwrite background when performing BOBF
-    seedForBOBF:
-    # type=inputmultiobject|default=[]: coordinates in all 3 directions for Seed when performing BOBF
-    neighborhoodForBOBF:
-    # type=inputmultiobject|default=[]: neighborhood in all 3 directions to be included when performing BOBF
-    outputDisplacementFieldPrefix:
-    # type=str|default='': Displacement field filename prefix for writing separate x, y, and z component images
-    outputCheckerboardVolume:
-    # type=file: Genete a checkerboard image volume between the fixedVolume and the deformed movingVolume.
-    # type=traitcompound|default=None: Genete a checkerboard image volume between the fixedVolume and the deformed movingVolume.
-    checkerboardPatternSubdivisions:
-    # type=inputmultiobject|default=[]: Number of Checkerboard subdivisions in all 3 directions
-    outputNormalized:
-    # type=bool|default=False: Flag to warp and write the normalized images to output.  In normalized images the image values are fit-scaled to be between 0 and the maximum storage type value.
-    outputDebug:
-    # type=bool|default=False: Flag to write debugging images after each step.
-    gradient_type:
-    # type=enum|default='0'|allowed['0','1','2']: Type of gradient used for computing the demons force (0 is symmetrized, 1 is fixed image, 2 is moving image)
-    upFieldSmoothing:
-    # type=float|default=0.0: Smoothing sigma for the update field at each iteration
-    max_step_length:
-    # type=float|default=0.0: Maximum length of an update vector (0: no restriction)
-    use_vanilla_dem:
-    # type=bool|default=False: Run vanilla demons algorithm
-    gui:
-    # type=bool|default=False: Display intermediate image volumes for debugging
-    promptUser:
-    # type=bool|default=False: Prompt the user to hit enter each time an image is sent to the DebugImageViewer
-    numberOfBCHApproximationTerms:
-    # type=int|default=0: Number of terms in the BCH expansion
-    numberOfThreads:
-    # type=int|default=0: Explicitly specify the maximum number of threads to use.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/brains_demon_warp_callables.py b/example-specs/task/nipype_internal/pydra-slicer/brains_demon_warp_callables.py
deleted file mode 100644
index bb153f9f..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/brains_demon_warp_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in BRAINSDemonWarp.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/brains_fit.yaml b/example-specs/task/nipype_internal/pydra-slicer/brains_fit.yaml
deleted file mode 100644
index 34dd9c06..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/brains_fit.yaml
+++ /dev/null
@@ -1,241 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.slicer.registration.brainsfit.BRAINSFit' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: General Registration (BRAINS)
-# 
-#     category: Registration
-# 
-#     description: Register a three-dimensional volume to a reference volume (Mattes Mutual Information by default). Described in BRAINSFit: Mutual Information Registrations of Whole-Brain 3D Images, Using the Insight Toolkit, Johnson H.J., Harris G., Williams K., The Insight Journal, 2007. http://hdl.handle.net/1926/1291
-# 
-#     version: 3.0.0
-# 
-#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Modules:BRAINSFit
-# 
-#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
-# 
-#     contributor: Hans J. Johnson, hans-johnson -at- uiowa.edu, http://wwww.psychiatry.uiowa.edu
-# 
-#     acknowledgements: Hans Johnson(1,3,4); Kent Williams(1); Gregory Harris(1), Vincent Magnotta(1,2,3);  Andriy Fedorov(5) 1=University of Iowa Department of Psychiatry, 2=University of Iowa Department of Radiology, 3=University of Iowa Department of Biomedical Engineering, 4=University of Iowa Department of Electrical and Computer Engineering, 5=Surgical Planning Lab, Harvard
-#     
-task_name: BRAINSFit
-nipype_name: BRAINSFit
-nipype_module: nipype.interfaces.slicer.registration.brainsfit
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    fixedVolume: generic/file
-    # type=file|default=<undefined>: The fixed image for registration by mutual information optimization.
-    movingVolume: generic/file
-    # type=file|default=<undefined>: The moving image for registration by mutual information optimization.
-    initialTransform: generic/file
-    # type=file|default=<undefined>: Filename of transform used to initialize the registration.  This CAN NOT be used with either CenterOfHeadLAlign, MomentsAlign, GeometryAlign, or initialTransform file.
-    fixedBinaryVolume: generic/file
-    # type=file|default=<undefined>: Fixed Image binary mask volume, ONLY FOR MANUAL ROI mode.
-    movingBinaryVolume: generic/file
-    # type=file|default=<undefined>: Moving Image binary mask volume, ONLY FOR MANUAL ROI mode.
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    bsplineTransform: generic/file
-    # type=file: (optional) Filename to which save the estimated transform. NOTE: You must set at least one output object (either a deformed image or a transform.  NOTE: USE THIS ONLY IF THE FINAL TRANSFORM IS BSpline
-    # type=traitcompound|default=None: (optional) Filename to which save the estimated transform. NOTE: You must set at least one output object (either a deformed image or a transform.  NOTE: USE THIS ONLY IF THE FINAL TRANSFORM IS BSpline
-    linearTransform: generic/file
-    # type=file: (optional) Filename to which save the estimated transform. NOTE: You must set at least one output object (either a deformed image or a transform.  NOTE: USE THIS ONLY IF THE FINAL TRANSFORM IS ---NOT--- BSpline
-    # type=traitcompound|default=None: (optional) Filename to which save the estimated transform. NOTE: You must set at least one output object (either a deformed image or a transform.  NOTE: USE THIS ONLY IF THE FINAL TRANSFORM IS ---NOT--- BSpline
-    outputVolume: generic/file
-    # type=file: (optional) Output image for registration. NOTE: You must select either the outputTransform or the outputVolume option.
-    # type=traitcompound|default=None: (optional) Output image for registration. NOTE: You must select either the outputTransform or the outputVolume option.
-    outputFixedVolumeROI: generic/file
-    # type=file: The ROI automatically found in fixed image, ONLY FOR ROIAUTO mode.
-    # type=traitcompound|default=None: The ROI automatically found in fixed image, ONLY FOR ROIAUTO mode.
-    outputMovingVolumeROI: generic/file
-    # type=file: The ROI automatically found in moving image, ONLY FOR ROIAUTO mode.
-    # type=traitcompound|default=None: The ROI automatically found in moving image, ONLY FOR ROIAUTO mode.
-    strippedOutputTransform: generic/file
-    # type=file: File name for the rigid component of the estimated affine transform. Can be used to rigidly register the moving image to the fixed image. NOTE:  This value is overwritten if either bsplineTransform or linearTransform is set.
-    # type=traitcompound|default=None: File name for the rigid component of the estimated affine transform. Can be used to rigidly register the moving image to the fixed image. NOTE:  This value is overwritten if either bsplineTransform or linearTransform is set.
-    outputTransform: generic/file
-    # type=file: (optional) Filename to which save the (optional) estimated transform. NOTE: You must select either the outputTransform or the outputVolume option.
-    # type=traitcompound|default=None: (optional) Filename to which save the (optional) estimated transform. NOTE: You must select either the outputTransform or the outputVolume option.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    fixedVolume:
-    # type=file|default=<undefined>: The fixed image for registration by mutual information optimization.
-    movingVolume:
-    # type=file|default=<undefined>: The moving image for registration by mutual information optimization.
-    bsplineTransform:
-    # type=file: (optional) Filename to which save the estimated transform. NOTE: You must set at least one output object (either a deformed image or a transform.  NOTE: USE THIS ONLY IF THE FINAL TRANSFORM IS BSpline
-    # type=traitcompound|default=None: (optional) Filename to which save the estimated transform. NOTE: You must set at least one output object (either a deformed image or a transform.  NOTE: USE THIS ONLY IF THE FINAL TRANSFORM IS BSpline
-    linearTransform:
-    # type=file: (optional) Filename to which save the estimated transform. NOTE: You must set at least one output object (either a deformed image or a transform.  NOTE: USE THIS ONLY IF THE FINAL TRANSFORM IS ---NOT--- BSpline
-    # type=traitcompound|default=None: (optional) Filename to which save the estimated transform. NOTE: You must set at least one output object (either a deformed image or a transform.  NOTE: USE THIS ONLY IF THE FINAL TRANSFORM IS ---NOT--- BSpline
-    outputVolume:
-    # type=file: (optional) Output image for registration. NOTE: You must select either the outputTransform or the outputVolume option.
-    # type=traitcompound|default=None: (optional) Output image for registration. NOTE: You must select either the outputTransform or the outputVolume option.
-    initialTransform:
-    # type=file|default=<undefined>: Filename of transform used to initialize the registration.  This CAN NOT be used with either CenterOfHeadLAlign, MomentsAlign, GeometryAlign, or initialTransform file.
-    initializeTransformMode:
-    # type=enum|default='Off'|allowed['Off','useCenterOfHeadAlign','useCenterOfROIAlign','useGeometryAlign','useMomentsAlign']: Determine how to initialize the transform center.  GeometryAlign on assumes that the center of the voxel lattice of the images represent similar structures.  MomentsAlign assumes that the center of mass of the images represent similar structures.  useCenterOfHeadAlign attempts to use the top of head and shape of neck to drive a center of mass estimate.  Off assumes that the physical space of the images are close, and that centering in terms of the image Origins is a good starting point.  This flag is mutually exclusive with the initialTransform flag.
-    useRigid:
-    # type=bool|default=False: Perform a rigid registration as part of the sequential registration steps.  This family of options superceeds the use of transformType if any of them are set.
-    useScaleVersor3D:
-    # type=bool|default=False: Perform a ScaleVersor3D registration as part of the sequential registration steps.  This family of options superceeds the use of transformType if any of them are set.
-    useScaleSkewVersor3D:
-    # type=bool|default=False: Perform a ScaleSkewVersor3D registration as part of the sequential registration steps.  This family of options superceeds the use of transformType if any of them are set.
-    useAffine:
-    # type=bool|default=False: Perform an Affine registration as part of the sequential registration steps.  This family of options superceeds the use of transformType if any of them are set.
-    useBSpline:
-    # type=bool|default=False: Perform a BSpline registration as part of the sequential registration steps.  This family of options superceeds the use of transformType if any of them are set.
-    numberOfSamples:
-    # type=int|default=0: The number of voxels sampled for mutual information computation.  Increase this for a slower, more careful fit.  You can also limit the sampling focus with ROI masks and ROIAUTO mask generation.
-    splineGridSize:
-    # type=inputmultiobject|default=[]: The number of subdivisions of the BSpline Grid to be centered on the image space.  Each dimension must have at least 3 subdivisions for the BSpline to be correctly computed. 
-    numberOfIterations:
-    # type=inputmultiobject|default=[]: The maximum number of iterations to try before failing to converge.  Use an explicit limit like 500 or 1000 to manage risk of divergence
-    maskProcessingMode:
-    # type=enum|default='NOMASK'|allowed['NOMASK','ROI','ROIAUTO']: What mode to use for using the masks.  If ROIAUTO is chosen, then the mask is implicitly defined using a otsu foreground and hole filling algorithm. The Region Of Interest mode (choose ROI) uses the masks to define what parts of the image should be used for computing the transform.
-    fixedBinaryVolume:
-    # type=file|default=<undefined>: Fixed Image binary mask volume, ONLY FOR MANUAL ROI mode.
-    movingBinaryVolume:
-    # type=file|default=<undefined>: Moving Image binary mask volume, ONLY FOR MANUAL ROI mode.
-    outputFixedVolumeROI:
-    # type=file: The ROI automatically found in fixed image, ONLY FOR ROIAUTO mode.
-    # type=traitcompound|default=None: The ROI automatically found in fixed image, ONLY FOR ROIAUTO mode.
-    outputMovingVolumeROI:
-    # type=file: The ROI automatically found in moving image, ONLY FOR ROIAUTO mode.
-    # type=traitcompound|default=None: The ROI automatically found in moving image, ONLY FOR ROIAUTO mode.
-    outputVolumePixelType:
-    # type=enum|default='float'|allowed['float','int','short','uchar','uint','ushort']: The output image Pixel Type is the scalar datatype for representation of the Output Volume.
-    backgroundFillValue:
-    # type=float|default=0.0: Background fill value for output image.
-    maskInferiorCutOffFromCenter:
-    # type=float|default=0.0: For use with --useCenterOfHeadAlign (and --maskProcessingMode ROIAUTO): the cut-off below the image centers, in millimeters, 
-    scaleOutputValues:
-    # type=bool|default=False: If true, and the voxel values do not fit within the minimum and maximum values of the desired outputVolumePixelType, then linearly scale the min/max output image voxel values to fit within the min/max range of the outputVolumePixelType.
-    interpolationMode:
-    # type=enum|default='NearestNeighbor'|allowed['BSpline','Blackman','Cosine','Hamming','Lanczos','Linear','NearestNeighbor','ResampleInPlace','Welch','WindowedSinc']: Type of interpolation to be used when applying transform to moving volume.  Options are Linear, NearestNeighbor, BSpline, WindowedSinc, or ResampleInPlace.  The ResampleInPlace option will create an image with the same discrete voxel values and will adjust the origin and direction of the physical space interpretation.
-    minimumStepLength:
-    # type=inputmultiobject|default=[]: Each step in the optimization takes steps at least this big.  When none are possible, registration is complete.
-    translationScale:
-    # type=float|default=0.0: How much to scale up changes in position compared to unit rotational changes in radians -- decrease this to put more rotation in the search pattern.
-    reproportionScale:
-    # type=float|default=0.0: ScaleVersor3D 'Scale' compensation factor.  Increase this to put more rescaling in a ScaleVersor3D or ScaleSkewVersor3D search pattern.  1.0 works well with a translationScale of 1000.0
-    skewScale:
-    # type=float|default=0.0: ScaleSkewVersor3D Skew compensation factor.  Increase this to put more skew in a ScaleSkewVersor3D search pattern.  1.0 works well with a translationScale of 1000.0
-    maxBSplineDisplacement:
-    # type=float|default=0.0:  Sets the maximum allowed displacements in image physical coordinates for BSpline control grid along each axis.  A value of 0.0 indicates that the problem should be unbounded.  NOTE:  This only constrains the BSpline portion, and does not limit the displacement from the associated bulk transform.  This can lead to a substantial reduction in computation time in the BSpline optimizer.,       
-    histogramMatch:
-    # type=bool|default=False: Histogram Match the input images.  This is suitable for images of the same modality that may have different absolute scales, but the same overall intensity profile. Do NOT use if registering images from different modailties.
-    numberOfHistogramBins:
-    # type=int|default=0: The number of histogram levels
-    numberOfMatchPoints:
-    # type=int|default=0: the number of match points
-    strippedOutputTransform:
-    # type=file: File name for the rigid component of the estimated affine transform. Can be used to rigidly register the moving image to the fixed image. NOTE:  This value is overwritten if either bsplineTransform or linearTransform is set.
-    # type=traitcompound|default=None: File name for the rigid component of the estimated affine transform. Can be used to rigidly register the moving image to the fixed image. NOTE:  This value is overwritten if either bsplineTransform or linearTransform is set.
-    transformType:
-    # type=inputmultiobject|default=[]: Specifies a list of registration types to be used.  The valid types are, Rigid, ScaleVersor3D, ScaleSkewVersor3D, Affine, and BSpline.  Specifying more than one in a comma separated list will initialize the next stage with the previous results. If registrationClass flag is used, it overrides this parameter setting.
-    outputTransform:
-    # type=file: (optional) Filename to which save the (optional) estimated transform. NOTE: You must select either the outputTransform or the outputVolume option.
-    # type=traitcompound|default=None: (optional) Filename to which save the (optional) estimated transform. NOTE: You must select either the outputTransform or the outputVolume option.
-    fixedVolumeTimeIndex:
-    # type=int|default=0: The index in the time series for the 3D fixed image to fit, if 4-dimensional.
-    movingVolumeTimeIndex:
-    # type=int|default=0: The index in the time series for the 3D moving image to fit, if 4-dimensional.
-    medianFilterSize:
-    # type=inputmultiobject|default=[]: The radius for the optional MedianImageFilter preprocessing in all 3 directions.
-    removeIntensityOutliers:
-    # type=float|default=0.0: The half percentage to decide outliers of image intensities. The default value is zero, which means no outlier removal. If the value of 0.005 is given, the module will throw away 0.005 % of both tails, so 0.01% of intensities in total would be ignored in its statistic calculation. 
-    useCachingOfBSplineWeightsMode:
-    # type=enum|default='ON'|allowed['OFF','ON']: This is a 5x speed advantage at the expense of requiring much more memory.  Only relevant when transformType is BSpline.
-    useExplicitPDFDerivativesMode:
-    # type=enum|default='AUTO'|allowed['AUTO','OFF','ON']: Using mode AUTO means OFF for BSplineDeformableTransforms and ON for the linear transforms.  The ON alternative uses more memory to sometimes do a better job.
-    ROIAutoDilateSize:
-    # type=float|default=0.0: This flag is only relevant when using ROIAUTO mode for initializing masks.  It defines the final dilation size to capture a bit of background outside the tissue region.  At setting of 10mm has been shown to help regularize a BSpline registration type so that there is some background constraints to match the edges of the head better.
-    ROIAutoClosingSize:
-    # type=float|default=0.0: This flag is only relevant when using ROIAUTO mode for initializing masks.  It defines the hole closing size in mm.  It is rounded up to the nearest whole pixel size in each direction. The default is to use a closing size of 9mm.  For mouse data this value may need to be reset to 0.9 or smaller.
-    relaxationFactor:
-    # type=float|default=0.0: Internal debugging parameter, and should probably never be used from the command line.  This will be removed in the future.
-    maximumStepLength:
-    # type=float|default=0.0: Internal debugging parameter, and should probably never be used from the command line.  This will be removed in the future.
-    failureExitCode:
-    # type=int|default=0: If the fit fails, exit with this status code.  (It can be used to force a successfult exit status of (0) if the registration fails due to reaching the maximum number of iterations.
-    writeTransformOnFailure:
-    # type=bool|default=False: Flag to save the final transform even if the numberOfIterations are reached without convergence. (Intended for use when --failureExitCode 0 )
-    numberOfThreads:
-    # type=int|default=0: Explicitly specify the maximum number of threads to use. (default is auto-detected)
-    forceMINumberOfThreads:
-    # type=int|default=0: Force the maximum number of threads to use for non thread safe MI metric.  CAUTION: Inconsistent results my arise!
-    debugLevel:
-    # type=int|default=0: Display debug messages, and produce debug intermediate results.  0=OFF, 1=Minimal, 10=Maximum debugging.
-    costFunctionConvergenceFactor:
-    # type=float|default=0.0:  From itkLBFGSBOptimizer.h: Set/Get the CostFunctionConvergenceFactor. Algorithm terminates when the reduction in cost function is less than (factor * epsmcj) where epsmch is the machine precision. Typical values for factor: 1e+12 for low accuracy; 1e+7 for moderate accuracy and 1e+1 for extremely high accuracy.  1e+9 seems to work well.,       
-    projectedGradientTolerance:
-    # type=float|default=0.0:  From itkLBFGSBOptimizer.h: Set/Get the ProjectedGradientTolerance. Algorithm terminates when the project gradient is below the tolerance. Default lbfgsb value is 1e-5, but 1e-4 seems to work well.,       
-    gui:
-    # type=bool|default=False: Display intermediate image volumes for debugging.  NOTE:  This is not part of the standard build system, and probably does nothing on your installation.
-    promptUser:
-    # type=bool|default=False: Prompt the user to hit enter each time an image is sent to the DebugImageViewer
-    NEVER_USE_THIS_FLAG_IT_IS_OUTDATED_00:
-    # type=bool|default=False: DO NOT USE THIS FLAG
-    NEVER_USE_THIS_FLAG_IT_IS_OUTDATED_01:
-    # type=bool|default=False: DO NOT USE THIS FLAG
-    NEVER_USE_THIS_FLAG_IT_IS_OUTDATED_02:
-    # type=bool|default=False: DO NOT USE THIS FLAG
-    permitParameterVariation:
-    # type=inputmultiobject|default=[]: A bit vector to permit linear transform parameters to vary under optimization.  The vector order corresponds with transform parameters, and beyond the end ones fill in as a default.  For instance, you can choose to rotate only in x (pitch) with 1,0,0;  this is mostly for expert use in turning on and off individual degrees of freedom in rotation, translation or scaling without multiplying the number of transform representations; this trick is probably meaningless when tried with the general affine transform.
-    costMetric:
-    # type=enum|default='MMI'|allowed['MC','MMI','MSE','NC']: The cost metric to be used during fitting. Defaults to MMI. Options are MMI (Mattes Mutual Information), MSE (Mean Square Error), NC (Normalized Correlation), MC (Match Cardinality for binary images)
-    writeOutputTransformInFloat:
-    # type=bool|default=False: By default, the output registration transforms (either the output composite transform or each transform component) are written to the disk in double precision. If this flag is ON, the output transforms will be written in single (float) precision. It is especially important if the output transform is a displacement field transform, or it is a composite transform that includes several displacement fields.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/brains_fit_callables.py b/example-specs/task/nipype_internal/pydra-slicer/brains_fit_callables.py
deleted file mode 100644
index 324aacce..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/brains_fit_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in BRAINSFit.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/brains_resample.yaml b/example-specs/task/nipype_internal/pydra-slicer/brains_resample.yaml
deleted file mode 100644
index 8a2e30d6..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/brains_resample.yaml
+++ /dev/null
@@ -1,117 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.slicer.registration.brainsresample.BRAINSResample' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Resample Image (BRAINS)
-# 
-#     category: Registration
-# 
-#     description:
-#        This program resamples an image using a deformation field or a transform (BSpline, Affine, Rigid, etc.).
-# 
-# 
-#     version: 3.0.0
-# 
-#     documentation-url: http://www.slicer.org/slicerWiki/index.php/Modules:BRAINSResample
-# 
-#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
-# 
-#     contributor: This tool was developed by Vincent Magnotta, Greg Harris, and Hans Johnson.
-# 
-#     acknowledgements: The development of this tool was supported by funding from grants NS050568 and NS40068 from the National Institute of Neurological Disorders and Stroke and grants MH31593, MH40856, from the National Institute of Mental Health.
-#     
-task_name: BRAINSResample
-nipype_name: BRAINSResample
-nipype_module: nipype.interfaces.slicer.registration.brainsresample
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputVolume: generic/file
-    # type=file|default=<undefined>: Image To Warp
-    referenceVolume: generic/file
-    # type=file|default=<undefined>: Reference image used only to define the output space. If not specified, the warping is done in the same space as the image to warp.
-    deformationVolume: generic/file
-    # type=file|default=<undefined>: Displacement Field to be used to warp the image
-    warpTransform: generic/file
-    # type=file|default=<undefined>: Filename for the BRAINSFit transform used in place of the deformation field
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputVolume: generic/file
-    # type=file: Resulting deformed image
-    # type=traitcompound|default=None: Resulting deformed image
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputVolume:
-    # type=file|default=<undefined>: Image To Warp
-    referenceVolume:
-    # type=file|default=<undefined>: Reference image used only to define the output space. If not specified, the warping is done in the same space as the image to warp.
-    outputVolume:
-    # type=file: Resulting deformed image
-    # type=traitcompound|default=None: Resulting deformed image
-    pixelType:
-    # type=enum|default='float'|allowed['binary','float','int','short','uchar','uint','ushort']: Specifies the pixel type for the input/output images.  The 'binary' pixel type uses a modified algorithm whereby the image is read in as unsigned char, a signed distance map is created, signed distance map is resampled, and then a thresholded image of type unsigned char is written to disk.
-    deformationVolume:
-    # type=file|default=<undefined>: Displacement Field to be used to warp the image
-    warpTransform:
-    # type=file|default=<undefined>: Filename for the BRAINSFit transform used in place of the deformation field
-    interpolationMode:
-    # type=enum|default='NearestNeighbor'|allowed['BSpline','Blackman','Cosine','Hamming','Lanczos','Linear','NearestNeighbor','ResampleInPlace','Welch','WindowedSinc']: Type of interpolation to be used when applying transform to moving volume.  Options are Linear, ResampleInPlace, NearestNeighbor, BSpline, or WindowedSinc
-    inverseTransform:
-    # type=bool|default=False: True/False is to compute inverse of given transformation. Default is false
-    defaultValue:
-    # type=float|default=0.0: Default voxel value
-    gridSpacing:
-    # type=inputmultiobject|default=[]: Add warped grid to output image to help show the deformation that occurred with specified spacing.   A spacing of 0 in a dimension indicates that grid lines should be rendered to fall exactly (i.e. do not allow displacements off that plane).  This is useful for making a 2D image of grid lines from the 3D space 
-    numberOfThreads:
-    # type=int|default=0: Explicitly specify the maximum number of threads to use.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/brains_resample_callables.py b/example-specs/task/nipype_internal/pydra-slicer/brains_resample_callables.py
deleted file mode 100644
index e8e4b158..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/brains_resample_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in BRAINSResample.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/brainsroi_auto.yaml b/example-specs/task/nipype_internal/pydra-slicer/brainsroi_auto.yaml
deleted file mode 100644
index 51a42f79..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/brainsroi_auto.yaml
+++ /dev/null
@@ -1,108 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.slicer.segmentation.specialized.BRAINSROIAuto' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Foreground masking (BRAINS)
-# 
-#     category: Segmentation.Specialized
-# 
-#     description: This tool uses a combination of otsu thresholding and a closing operations to identify the most prominent foreground region in an image.
-# 
-# 
-#     version: 2.4.1
-# 
-#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
-# 
-#     contributor: Hans J. Johnson, hans-johnson -at- uiowa.edu, http://wwww.psychiatry.uiowa.edu
-# 
-#     acknowledgements: Hans Johnson(1,3,4); Kent Williams(1); Gregory Harris(1), Vincent Magnotta(1,2,3);  Andriy Fedorov(5), fedorov -at- bwh.harvard.edu (Slicer integration); (1=University of Iowa Department of Psychiatry, 2=University of Iowa Department of Radiology, 3=University of Iowa Department of Biomedical Engineering, 4=University of Iowa Department of Electrical and Computer Engineering, 5=Surgical Planning Lab, Harvard)
-#     
-task_name: BRAINSROIAuto
-nipype_name: BRAINSROIAuto
-nipype_module: nipype.interfaces.slicer.segmentation.specialized
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputVolume: generic/file
-    # type=file|default=<undefined>: The input image for finding the largest region filled mask.
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputROIMaskVolume: generic/file
-    # type=file: The ROI automatically found from the input image.
-    # type=traitcompound|default=None: The ROI automatically found from the input image.
-    outputClippedVolumeROI: generic/file
-    # type=file: The inputVolume clipped to the region of the brain mask.
-    # type=traitcompound|default=None: The inputVolume clipped to the region of the brain mask.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputVolume:
-    # type=file|default=<undefined>: The input image for finding the largest region filled mask.
-    outputROIMaskVolume:
-    # type=file: The ROI automatically found from the input image.
-    # type=traitcompound|default=None: The ROI automatically found from the input image.
-    outputClippedVolumeROI:
-    # type=file: The inputVolume clipped to the region of the brain mask.
-    # type=traitcompound|default=None: The inputVolume clipped to the region of the brain mask.
-    otsuPercentileThreshold:
-    # type=float|default=0.0: Parameter to the Otsu threshold algorithm.
-    thresholdCorrectionFactor:
-    # type=float|default=0.0: A factor to scale the Otsu algorithm's result threshold, in case clipping mangles the image.
-    closingSize:
-    # type=float|default=0.0: The Closing Size (in millimeters) for largest connected filled mask.  This value is divided by image spacing and rounded to the next largest voxel number.
-    ROIAutoDilateSize:
-    # type=float|default=0.0: This flag is only relevant when using ROIAUTO mode for initializing masks.  It defines the final dilation size to capture a bit of background outside the tissue region.  At setting of 10mm has been shown to help regularize a BSpline registration type so that there is some background constraints to match the edges of the head better.
-    outputVolumePixelType:
-    # type=enum|default='float'|allowed['float','int','short','uchar','uint','ushort']: The output image Pixel Type is the scalar datatype for representation of the Output Volume.
-    numberOfThreads:
-    # type=int|default=0: Explicitly specify the maximum number of threads to use.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/brainsroi_auto_callables.py b/example-specs/task/nipype_internal/pydra-slicer/brainsroi_auto_callables.py
deleted file mode 100644
index 421d7dbf..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/brainsroi_auto_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in BRAINSROIAuto.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/cast_scalar_volume.yaml b/example-specs/task/nipype_internal/pydra-slicer/cast_scalar_volume.yaml
deleted file mode 100644
index 9bab0561..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/cast_scalar_volume.yaml
+++ /dev/null
@@ -1,93 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.slicer.filtering.arithmetic.CastScalarVolume' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Cast Scalar Volume
-# 
-#     category: Filtering.Arithmetic
-# 
-#     description: Cast a volume to a given data type.
-#     Use at your own risk when casting an input volume into a lower precision type!
-#     Allows casting to the same type as the input volume.
-# 
-#     version: 0.1.0.$Revision: 2104 $(alpha)
-# 
-#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/Cast
-# 
-#     contributor: Nicole Aucoin (SPL, BWH), Ron Kikinis (SPL, BWH)
-# 
-#     acknowledgements: This work is part of the National Alliance for Medical Image Computing (NAMIC), funded by the National Institutes of Health through the NIH Roadmap for Medical Research, Grant U54 EB005149.
-#     
-task_name: CastScalarVolume
-nipype_name: CastScalarVolume
-nipype_module: nipype.interfaces.slicer.filtering.arithmetic
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    InputVolume: generic/file
-    # type=file|default=<undefined>: Input volume, the volume to cast.
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    OutputVolume: generic/file
-    # type=file: Output volume, cast to the new type.
-    # type=traitcompound|default=None: Output volume, cast to the new type.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    InputVolume:
-    # type=file|default=<undefined>: Input volume, the volume to cast.
-    OutputVolume:
-    # type=file: Output volume, cast to the new type.
-    # type=traitcompound|default=None: Output volume, cast to the new type.
-    type:
-    # type=enum|default='Char'|allowed['Char','Double','Float','Int','Short','UnsignedChar','UnsignedInt','UnsignedShort']: Type for the new output volume.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/cast_scalar_volume_callables.py b/example-specs/task/nipype_internal/pydra-slicer/cast_scalar_volume_callables.py
deleted file mode 100644
index 1c82ce5b..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/cast_scalar_volume_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in CastScalarVolume.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/checker_board_filter.yaml b/example-specs/task/nipype_internal/pydra-slicer/checker_board_filter.yaml
deleted file mode 100644
index 8792cf30..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/checker_board_filter.yaml
+++ /dev/null
@@ -1,95 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.slicer.filtering.checkerboardfilter.CheckerBoardFilter' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: CheckerBoard Filter
-# 
-#     category: Filtering
-# 
-#     description: Create a checkerboard volume of two volumes. The output volume will show the two inputs alternating according to the user supplied checkerPattern. This filter is often used to compare the results of image registration. Note that the second input is resampled to the same origin, spacing and direction before it is composed with the first input. The scalar type of the output volume will be the same as the input image scalar type.
-# 
-#     version: 0.1.0.$Revision: 19608 $(alpha)
-# 
-#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/CheckerBoard
-# 
-#     contributor: Bill Lorensen (GE)
-# 
-#     acknowledgements: This work is part of the National Alliance for Medical Image Computing (NAMIC), funded by the National Institutes of Health through the NIH Roadmap for Medical Research, Grant U54 EB005149.
-#     
-task_name: CheckerBoardFilter
-nipype_name: CheckerBoardFilter
-nipype_module: nipype.interfaces.slicer.filtering.checkerboardfilter
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputVolume1: generic/file
-    # type=file|default=<undefined>: First Input volume
-    inputVolume2: generic/file
-    # type=file|default=<undefined>: Second Input volume
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputVolume: generic/file
-    # type=file: Output filtered
-    # type=traitcompound|default=None: Output filtered
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    checkerPattern:
-    # type=inputmultiobject|default=[]: The pattern of input 1 and input 2 in the output image. The user can specify the number of checkers in each dimension. A checkerPattern of 2,2,1 means that images will alternate in every other checker in the first two dimensions. The same pattern will be used in the 3rd dimension.
-    inputVolume1:
-    # type=file|default=<undefined>: First Input volume
-    inputVolume2:
-    # type=file|default=<undefined>: Second Input volume
-    outputVolume:
-    # type=file: Output filtered
-    # type=traitcompound|default=None: Output filtered
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/checker_board_filter_callables.py b/example-specs/task/nipype_internal/pydra-slicer/checker_board_filter_callables.py
deleted file mode 100644
index d278515f..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/checker_board_filter_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in CheckerBoardFilter.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/curvature_anisotropic_diffusion.yaml b/example-specs/task/nipype_internal/pydra-slicer/curvature_anisotropic_diffusion.yaml
deleted file mode 100644
index 46e9a8f4..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/curvature_anisotropic_diffusion.yaml
+++ /dev/null
@@ -1,99 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.slicer.filtering.denoising.CurvatureAnisotropicDiffusion' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Curvature Anisotropic Diffusion
-# 
-#     category: Filtering.Denoising
-# 
-#     description: Performs anisotropic diffusion on an image using a modified curvature diffusion equation (MCDE).
-# 
-#     MCDE does not exhibit the edge enhancing properties of classic anisotropic diffusion, which can under certain conditions undergo a 'negative' diffusion, which enhances the contrast of edges.  Equations of the form of MCDE always undergo positive diffusion, with the conductance term only varying the strength of that diffusion.
-# 
-#      Qualitatively, MCDE compares well with other non-linear diffusion techniques.  It is less sensitive to contrast than classic Perona-Malik style diffusion, and preserves finer detailed structures in images.  There is a potential speed trade-off for using this function in place of Gradient Anisotropic Diffusion.  Each iteration of the solution takes roughly twice as long.  Fewer iterations, however, may be required to reach an acceptable solution.
-# 
-#     version: 0.1.0.$Revision: 19608 $(alpha)
-# 
-#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/CurvatureAnisotropicDiffusion
-# 
-#     contributor: Bill Lorensen (GE)
-# 
-#     acknowledgements: This command module was derived from Insight/Examples (copyright) Insight Software Consortium
-#     
-task_name: CurvatureAnisotropicDiffusion
-nipype_name: CurvatureAnisotropicDiffusion
-nipype_module: nipype.interfaces.slicer.filtering.denoising
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputVolume: generic/file
-    # type=file|default=<undefined>: Input volume to be filtered
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputVolume: generic/file
-    # type=file: Output filtered
-    # type=traitcompound|default=None: Output filtered
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    conductance:
-    # type=float|default=0.0: Conductance controls the sensitivity of the conductance term. As a general rule, the lower the value, the more strongly the filter preserves edges. A high value will cause diffusion (smoothing) across edges. Note that the number of iterations controls how much smoothing is done within regions bounded by edges.
-    iterations:
-    # type=int|default=0: The more iterations, the more smoothing. Each iteration takes the same amount of time. If it takes 10 seconds for one iteration, then it will take 100 seconds for 10 iterations. Note that the conductance controls how much each iteration smooths across edges.
-    timeStep:
-    # type=float|default=0.0: The time step depends on the dimensionality of the image. In Slicer the images are 3D and the default (.0625) time step will provide a stable solution.
-    inputVolume:
-    # type=file|default=<undefined>: Input volume to be filtered
-    outputVolume:
-    # type=file: Output filtered
-    # type=traitcompound|default=None: Output filtered
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/curvature_anisotropic_diffusion_callables.py b/example-specs/task/nipype_internal/pydra-slicer/curvature_anisotropic_diffusion_callables.py
deleted file mode 100644
index 20e56194..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/curvature_anisotropic_diffusion_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in CurvatureAnisotropicDiffusion.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/dicom_to_nrrd_converter.yaml b/example-specs/task/nipype_internal/pydra-slicer/dicom_to_nrrd_converter.yaml
deleted file mode 100644
index c52c6072..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/dicom_to_nrrd_converter.yaml
+++ /dev/null
@@ -1,101 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.slicer.converters.DicomToNrrdConverter' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: DICOM to NRRD Converter
-# 
-#     category: Converters
-# 
-#     description: Converts diffusion weighted MR images in dicom series into Nrrd format for analysis in Slicer. This program has been tested on only a limited subset of DTI dicom formats available from Siemens, GE, and Phillips scanners. Work in progress to support dicom multi-frame data. The program parses dicom header to extract necessary information about measurement frame, diffusion weighting directions, b-values, etc, and write out a nrrd image. For non-diffusion weighted dicom images, it loads in an entire dicom series and writes out a single dicom volume in a .nhdr/.raw pair.
-# 
-#     version: 0.2.0.$Revision: 916 $(alpha)
-# 
-#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/DicomToNrrdConverter
-# 
-#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
-# 
-#     contributor: Xiaodong Tao (GE), Vince Magnotta (UIowa), Hans Johnson (UIowa)
-# 
-#     acknowledgements: This work is part of the National Alliance for Medical Image Computing (NAMIC), funded by the National Institutes of Health through the NIH Roadmap for Medical Research, Grant U54 EB005149.  Additional support for DTI data produced on Philips scanners was contributed by Vincent Magnotta and Hans Johnson at the University of Iowa.
-#     
-task_name: DicomToNrrdConverter
-nipype_name: DicomToNrrdConverter
-nipype_module: nipype.interfaces.slicer.converters
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputDicomDirectory: generic/directory
-    # type=directory|default=<undefined>: Directory holding Dicom series
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputDirectory: generic/directory
-    # type=directory: Directory holding the output NRRD format
-    # type=traitcompound|default=None: Directory holding the output NRRD format
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputDicomDirectory:
-    # type=directory|default=<undefined>: Directory holding Dicom series
-    outputDirectory:
-    # type=directory: Directory holding the output NRRD format
-    # type=traitcompound|default=None: Directory holding the output NRRD format
-    outputVolume:
-    # type=str|default='': Output filename (.nhdr or .nrrd)
-    smallGradientThreshold:
-    # type=float|default=0.0: If a gradient magnitude is greater than 0 and less than smallGradientThreshold, then DicomToNrrdConverter will display an error message and quit, unless the useBMatrixGradientDirections option is set.
-    writeProtocolGradientsFile:
-    # type=bool|default=False: Write the protocol gradients to a file suffixed by '.txt' as they were specified in the procol by multiplying each diffusion gradient direction by the measurement frame.  This file is for debugging purposes only, the format is not fixed, and will likely change as debugging of new dicom formats is necessary.
-    useIdentityMeaseurementFrame:
-    # type=bool|default=False: Adjust all the gradients so that the measurement frame is an identity matrix.
-    useBMatrixGradientDirections:
-    # type=bool|default=False: Fill the nhdr header with the gradient directions and bvalues computed out of the BMatrix. Only changes behavior for Siemens data.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/dicom_to_nrrd_converter_callables.py b/example-specs/task/nipype_internal/pydra-slicer/dicom_to_nrrd_converter_callables.py
deleted file mode 100644
index e8c37aa6..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/dicom_to_nrrd_converter_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in DicomToNrrdConverter.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/diffusion_tensor_scalar_measurements.yaml b/example-specs/task/nipype_internal/pydra-slicer/diffusion_tensor_scalar_measurements.yaml
deleted file mode 100644
index 8572a0c9..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/diffusion_tensor_scalar_measurements.yaml
+++ /dev/null
@@ -1,91 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.slicer.diffusion.diffusion.DiffusionTensorScalarMeasurements' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Diffusion Tensor Scalar Measurements
-# 
-#     category: Diffusion.Diffusion Tensor Images
-# 
-#     description: Compute a set of different scalar measurements from a tensor field, specially oriented for Diffusion Tensors where some rotationally invariant measurements, like Fractional Anisotropy, are highly used to describe the anistropic behaviour of the tensor.
-# 
-#     version: 0.1.0.$Revision: 1892 $(alpha)
-# 
-#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/DiffusionTensorMathematics
-# 
-#     contributor: Raul San Jose (SPL, BWH)
-# 
-#     acknowledgements: LMI
-#     
-task_name: DiffusionTensorScalarMeasurements
-nipype_name: DiffusionTensorScalarMeasurements
-nipype_module: nipype.interfaces.slicer.diffusion.diffusion
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputVolume: generic/file
-    # type=file|default=<undefined>: Input DTI volume
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputScalar: generic/file
-    # type=file: Scalar volume derived from tensor
-    # type=traitcompound|default=None: Scalar volume derived from tensor
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputVolume:
-    # type=file|default=<undefined>: Input DTI volume
-    outputScalar:
-    # type=file: Scalar volume derived from tensor
-    # type=traitcompound|default=None: Scalar volume derived from tensor
-    enumeration:
-    # type=enum|default='Trace'|allowed['D11','D22','D33','Determinant','FractionalAnisotropy','LinearMeasure','MaxEigenvalue','MaxEigenvalueProjectionX','MaxEigenvalueProjectionY','MaxEigenvalueProjectionZ','MaxEigenvecX','MaxEigenvecY','MaxEigenvecZ','MidEigenvalue','MinEigenvalue','Mode','ParallelDiffusivity','PerpendicularDffusivity','PlanarMeasure','RAIMaxEigenvecX','RAIMaxEigenvecY','RAIMaxEigenvecZ','RelativeAnisotropy','SphericalMeasure','Trace']: An enumeration of strings
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/diffusion_tensor_scalar_measurements_callables.py b/example-specs/task/nipype_internal/pydra-slicer/diffusion_tensor_scalar_measurements_callables.py
deleted file mode 100644
index 4b63eb64..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/diffusion_tensor_scalar_measurements_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in DiffusionTensorScalarMeasurements.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/diffusion_weighted_volume_masking.yaml b/example-specs/task/nipype_internal/pydra-slicer/diffusion_weighted_volume_masking.yaml
deleted file mode 100644
index 63ccc379..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/diffusion_weighted_volume_masking.yaml
+++ /dev/null
@@ -1,99 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.slicer.diffusion.diffusion.DiffusionWeightedVolumeMasking' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Diffusion Weighted Volume Masking
-# 
-#     category: Diffusion.Diffusion Weighted Images
-# 
-#     description: <p>Performs a mask calculation from a diffusion weighted (DW) image.</p><p>Starting from a dw image, this module computes the baseline image averaging all the images without diffusion weighting and then applies the otsu segmentation algorithm in order to produce a mask. this mask can then be used when estimating the diffusion tensor (dt) image, not to estimate tensors all over the volume.</p>
-# 
-#     version: 0.1.0.$Revision: 1892 $(alpha)
-# 
-#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/DiffusionWeightedMasking
-# 
-#     license: slicer3
-# 
-#     contributor: Demian Wassermann (SPL, BWH)
-#     
-task_name: DiffusionWeightedVolumeMasking
-nipype_name: DiffusionWeightedVolumeMasking
-nipype_module: nipype.interfaces.slicer.diffusion.diffusion
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputVolume: generic/file
-    # type=file|default=<undefined>: Input DWI volume
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputBaseline: generic/file
-    # type=file: Estimated baseline volume
-    # type=traitcompound|default=None: Estimated baseline volume
-    thresholdMask: generic/file
-    # type=file: Otsu Threshold Mask
-    # type=traitcompound|default=None: Otsu Threshold Mask
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputVolume:
-    # type=file|default=<undefined>: Input DWI volume
-    outputBaseline:
-    # type=file: Estimated baseline volume
-    # type=traitcompound|default=None: Estimated baseline volume
-    thresholdMask:
-    # type=file: Otsu Threshold Mask
-    # type=traitcompound|default=None: Otsu Threshold Mask
-    otsuomegathreshold:
-    # type=float|default=0.0: Control the sharpness of the threshold in the Otsu computation. 0: lower threshold, 1: higher threshold
-    removeislands:
-    # type=bool|default=False: Remove Islands in Threshold Mask?
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/diffusion_weighted_volume_masking_callables.py b/example-specs/task/nipype_internal/pydra-slicer/diffusion_weighted_volume_masking_callables.py
deleted file mode 100644
index 91ba9b9a..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/diffusion_weighted_volume_masking_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in DiffusionWeightedVolumeMasking.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/dt_iexport.yaml b/example-specs/task/nipype_internal/pydra-slicer/dt_iexport.yaml
deleted file mode 100644
index dbcdd98d..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/dt_iexport.yaml
+++ /dev/null
@@ -1,89 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.slicer.diffusion.diffusion.DTIexport' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: DTIexport
-# 
-#     category: Diffusion.Diffusion Data Conversion
-# 
-#     description: Export DTI data to various file formats
-# 
-#     version: 1.0
-# 
-#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/DTIExport
-# 
-#     contributor: Sonia Pujol (SPL, BWH)
-# 
-#     acknowledgements: This work is part of the National Alliance for Medical Image Computing (NA-MIC), funded by the National Institutes of Health through the NIH Roadmap for Medical Research, Grant U54 EB005149.
-#     
-task_name: DTIexport
-nipype_name: DTIexport
-nipype_module: nipype.interfaces.slicer.diffusion.diffusion
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputTensor: generic/file
-    # type=file|default=<undefined>: Input DTI volume
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputFile: generic/file
-    # type=file: Output DTI file
-    # type=traitcompound|default=None: Output DTI file
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputTensor:
-    # type=file|default=<undefined>: Input DTI volume
-    outputFile:
-    # type=file: Output DTI file
-    # type=traitcompound|default=None: Output DTI file
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/dt_iexport_callables.py b/example-specs/task/nipype_internal/pydra-slicer/dt_iexport_callables.py
deleted file mode 100644
index c631491c..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/dt_iexport_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in DTIexport.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/dt_iimport.yaml b/example-specs/task/nipype_internal/pydra-slicer/dt_iimport.yaml
deleted file mode 100644
index 423a1ed1..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/dt_iimport.yaml
+++ /dev/null
@@ -1,91 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.slicer.diffusion.diffusion.DTIimport' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: DTIimport
-# 
-#     category: Diffusion.Diffusion Data Conversion
-# 
-#     description: Import tensor datasets from various formats, including the NifTi file format
-# 
-#     version: 1.0
-# 
-#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/DTIImport
-# 
-#     contributor: Sonia Pujol (SPL, BWH)
-# 
-#     acknowledgements: This work is part of the National Alliance for Medical Image Computing (NA-MIC), funded by the National Institutes of Health through the NIH Roadmap for Medical Research, Grant U54 EB005149.
-#     
-task_name: DTIimport
-nipype_name: DTIimport
-nipype_module: nipype.interfaces.slicer.diffusion.diffusion
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputFile: generic/file
-    # type=file|default=<undefined>: Input DTI file
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputTensor: generic/file
-    # type=file: Output DTI volume
-    # type=traitcompound|default=None: Output DTI volume
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputFile:
-    # type=file|default=<undefined>: Input DTI file
-    outputTensor:
-    # type=file: Output DTI volume
-    # type=traitcompound|default=None: Output DTI volume
-    testingmode:
-    # type=bool|default=False: Enable testing mode. Sample helix file (helix-DTI.nhdr) will be loaded into Slicer and converted in Nifti.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/dt_iimport_callables.py b/example-specs/task/nipype_internal/pydra-slicer/dt_iimport_callables.py
deleted file mode 100644
index a808a812..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/dt_iimport_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in DTIimport.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/dwi_joint_rician_lmmse_filter.yaml b/example-specs/task/nipype_internal/pydra-slicer/dwi_joint_rician_lmmse_filter.yaml
deleted file mode 100644
index 4bedb33e..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/dwi_joint_rician_lmmse_filter.yaml
+++ /dev/null
@@ -1,100 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.slicer.diffusion.diffusion.DWIJointRicianLMMSEFilter' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: DWI Joint Rician LMMSE Filter
-# 
-#     category: Diffusion.Diffusion Weighted Images
-# 
-#     description: This module reduces Rician noise (or unwanted detail) on a set of diffusion weighted images. For this, it filters the image in the mean squared error sense using a Rician noise model. The N closest gradient directions to the direction being processed are filtered together to improve the results: the noise-free signal is seen as an n-diemensional vector which has to be estimated with the LMMSE method from a set of corrupted measurements. To that end, the covariance matrix of the noise-free vector and the cross covariance between this signal and the noise have to be estimated, which is done taking into account the image formation process.
-#     The noise parameter is automatically estimated from a rough segmentation of the background of the image. In this area the signal is simply 0, so that Rician statistics reduce to Rayleigh and the noise power can be easily estimated from the mode of the histogram.
-#     A complete description of the algorithm may be found in:
-#     Antonio Tristan-Vega and Santiago Aja-Fernandez, DWI filtering using joint information for DTI and HARDI, Medical Image Analysis, Volume 14, Issue 2, Pages 205-218. 2010.
-# 
-#     version: 0.1.1.$Revision: 1 $(alpha)
-# 
-#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/JointRicianLMMSEImageFilter
-# 
-#     contributor: Antonio Tristan Vega (UVa), Santiago Aja Fernandez (UVa)
-# 
-#     acknowledgements: Partially founded by grant number TEC2007-67073/TCM from the Comision Interministerial de Ciencia y Tecnologia (Spain).
-#     
-task_name: DWIJointRicianLMMSEFilter
-nipype_name: DWIJointRicianLMMSEFilter
-nipype_module: nipype.interfaces.slicer.diffusion.diffusion
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputVolume: generic/file
-    # type=file|default=<undefined>: Input DWI volume.
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputVolume: generic/file
-    # type=file: Output DWI volume.
-    # type=traitcompound|default=None: Output DWI volume.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    re:
-    # type=inputmultiobject|default=[]: Estimation radius.
-    rf:
-    # type=inputmultiobject|default=[]: Filtering radius.
-    ng:
-    # type=int|default=0: The number of the closest gradients that are used to jointly filter a given gradient direction (0 to use all).
-    inputVolume:
-    # type=file|default=<undefined>: Input DWI volume.
-    outputVolume:
-    # type=file: Output DWI volume.
-    # type=traitcompound|default=None: Output DWI volume.
-    compressOutput:
-    # type=bool|default=False: Compress the data of the compressed file using gzip
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/dwi_joint_rician_lmmse_filter_callables.py b/example-specs/task/nipype_internal/pydra-slicer/dwi_joint_rician_lmmse_filter_callables.py
deleted file mode 100644
index 4917d0c4..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/dwi_joint_rician_lmmse_filter_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in DWIJointRicianLMMSEFilter.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/dwi_rician_lmmse_filter.yaml b/example-specs/task/nipype_internal/pydra-slicer/dwi_rician_lmmse_filter.yaml
deleted file mode 100644
index 4464e08a..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/dwi_rician_lmmse_filter.yaml
+++ /dev/null
@@ -1,112 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.slicer.diffusion.diffusion.DWIRicianLMMSEFilter' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: DWI Rician LMMSE Filter
-# 
-#     category: Diffusion.Diffusion Weighted Images
-# 
-#     description: This module reduces noise (or unwanted detail) on a set of diffusion weighted images. For this, it filters the image in the mean squared error sense using a Rician noise model. Images corresponding to each gradient direction, including baseline, are processed individually. The noise parameter is automatically estimated (noise estimation improved but slower).
-#     Note that this is a general purpose filter for MRi images. The module jointLMMSE has been specifically designed for DWI volumes and shows a better performance, so its use is recommended instead.
-#     A complete description of the algorithm in this module can be found in:
-#     S. Aja-Fernandez, M. Niethammer, M. Kubicki, M. Shenton, and C.-F. Westin. Restoration of DWI data using a Rician LMMSE estimator. IEEE Transactions on Medical Imaging, 27(10): pp. 1389-1403, Oct. 2008.
-# 
-#     version: 0.1.1.$Revision: 1 $(alpha)
-# 
-#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/RicianLMMSEImageFilter
-# 
-#     contributor: Antonio Tristan Vega (UVa), Santiago Aja Fernandez (UVa), Marc Niethammer (UNC)
-# 
-#     acknowledgements: Partially founded by grant number TEC2007-67073/TCM from the Comision Interministerial de Ciencia y Tecnologia (Spain).
-#     
-task_name: DWIRicianLMMSEFilter
-nipype_name: DWIRicianLMMSEFilter
-nipype_module: nipype.interfaces.slicer.diffusion.diffusion
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputVolume: generic/file
-    # type=file|default=<undefined>: Input DWI volume.
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputVolume: generic/file
-    # type=file: Output DWI volume.
-    # type=traitcompound|default=None: Output DWI volume.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    iter:
-    # type=int|default=0: Number of iterations for the noise removal filter.
-    re:
-    # type=inputmultiobject|default=[]: Estimation radius.
-    rf:
-    # type=inputmultiobject|default=[]: Filtering radius.
-    mnvf:
-    # type=int|default=0: Minimum number of voxels in kernel used for filtering.
-    mnve:
-    # type=int|default=0: Minimum number of voxels in kernel used for estimation.
-    minnstd:
-    # type=int|default=0: Minimum allowed noise standard deviation.
-    maxnstd:
-    # type=int|default=0: Maximum allowed noise standard deviation.
-    hrf:
-    # type=float|default=0.0: How many histogram bins per unit interval.
-    uav:
-    # type=bool|default=False: Use absolute value in case of negative square.
-    inputVolume:
-    # type=file|default=<undefined>: Input DWI volume.
-    outputVolume:
-    # type=file: Output DWI volume.
-    # type=traitcompound|default=None: Output DWI volume.
-    compressOutput:
-    # type=bool|default=False: Compress the data of the compressed file using gzip
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/dwi_rician_lmmse_filter_callables.py b/example-specs/task/nipype_internal/pydra-slicer/dwi_rician_lmmse_filter_callables.py
deleted file mode 100644
index 71aa8698..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/dwi_rician_lmmse_filter_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in DWIRicianLMMSEFilter.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/dwi_to_dti_estimation.yaml b/example-specs/task/nipype_internal/pydra-slicer/dwi_to_dti_estimation.yaml
deleted file mode 100644
index a214c9c3..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/dwi_to_dti_estimation.yaml
+++ /dev/null
@@ -1,107 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.slicer.diffusion.diffusion.DWIToDTIEstimation' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: DWI to DTI Estimation
-# 
-#     category: Diffusion.Diffusion Weighted Images
-# 
-#     description: Performs a tensor model estimation from diffusion weighted images.
-# 
-#     There are three estimation methods available: least squares, weighted least squares and non-linear estimation. The first method is the traditional method for tensor estimation and the fastest one. Weighted least squares takes into account the noise characteristics of the MRI images to weight the DWI samples used in the estimation based on its intensity magnitude. The last method is the more complex.
-# 
-#     version: 0.1.0.$Revision: 1892 $(alpha)
-# 
-#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/DiffusionTensorEstimation
-# 
-#     license: slicer3
-# 
-#     contributor: Raul San Jose (SPL, BWH)
-# 
-#     acknowledgements: This command module is based on the estimation functionality provided by the Teem library. This work is part of the National Alliance for Medical Image Computing (NAMIC), funded by the National Institutes of Health through the NIH Roadmap for Medical Research, Grant U54 EB005149.
-#     
-task_name: DWIToDTIEstimation
-nipype_name: DWIToDTIEstimation
-nipype_module: nipype.interfaces.slicer.diffusion.diffusion
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputVolume: generic/file
-    # type=file|default=<undefined>: Input DWI volume
-    mask: generic/file
-    # type=file|default=<undefined>: Mask where the tensors will be computed
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputTensor: generic/file
-    # type=file: Estimated DTI volume
-    # type=traitcompound|default=None: Estimated DTI volume
-    outputBaseline: generic/file
-    # type=file: Estimated baseline volume
-    # type=traitcompound|default=None: Estimated baseline volume
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputVolume:
-    # type=file|default=<undefined>: Input DWI volume
-    mask:
-    # type=file|default=<undefined>: Mask where the tensors will be computed
-    outputTensor:
-    # type=file: Estimated DTI volume
-    # type=traitcompound|default=None: Estimated DTI volume
-    outputBaseline:
-    # type=file: Estimated baseline volume
-    # type=traitcompound|default=None: Estimated baseline volume
-    enumeration:
-    # type=enum|default='LS'|allowed['LS','WLS']: LS: Least Squares, WLS: Weighted Least Squares
-    shiftNeg:
-    # type=bool|default=False: Shift eigenvalues so all are positive (accounts for bad tensors related to noise or acquisition error)
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/dwi_to_dti_estimation_callables.py b/example-specs/task/nipype_internal/pydra-slicer/dwi_to_dti_estimation_callables.py
deleted file mode 100644
index cfd9dc1b..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/dwi_to_dti_estimation_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in DWIToDTIEstimation.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/dwi_unbiased_non_local_means_filter.yaml b/example-specs/task/nipype_internal/pydra-slicer/dwi_unbiased_non_local_means_filter.yaml
deleted file mode 100644
index 795d0a48..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/dwi_unbiased_non_local_means_filter.yaml
+++ /dev/null
@@ -1,103 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.slicer.legacy.diffusion.denoising.DWIUnbiasedNonLocalMeansFilter' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: DWI Unbiased Non Local Means Filter
-# 
-#     category: Legacy.Diffusion.Denoising
-# 
-#     description: This module reduces noise (or unwanted detail) on a set of diffusion weighted images. For this, it filters the images using a Unbiased Non Local Means for Rician noise algorithm. It exploits not only the spatial redundancy, but the redundancy in similar gradient directions as well; it takes into account the N closest gradient directions to the direction being processed (a maximum of 5 gradient directions is allowed to keep a reasonable computational load, since we do not use neither similarity maps nor block-wise implementation).
-#     The noise parameter is automatically estimated in the same way as in the jointLMMSE module.
-#     A complete description of the algorithm may be found in:
-#     Antonio Tristan-Vega and Santiago Aja-Fernandez, DWI filtering using joint information for DTI and HARDI, Medical Image Analysis, Volume 14, Issue 2, Pages 205-218. 2010.
-#     Please, note that the execution of this filter is extremely slow, son only very conservative parameters (block size and search size as small as possible) should be used. Even so, its execution may take several hours. The advantage of this filter over joint LMMSE is its better preservation of edges and fine structures.
-# 
-#     version: 0.0.1.$Revision: 1 $(alpha)
-# 
-#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/UnbiasedNonLocalMeansFilterForDWI
-# 
-#     contributor: Antonio Tristan Vega (UVa), Santiago Aja Fernandez (UVa)
-# 
-#     acknowledgements: Partially founded by grant number TEC2007-67073/TCM from the Comision Interministerial de Ciencia y Tecnologia (Spain).
-#     
-task_name: DWIUnbiasedNonLocalMeansFilter
-nipype_name: DWIUnbiasedNonLocalMeansFilter
-nipype_module: nipype.interfaces.slicer.legacy.diffusion.denoising
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputVolume: generic/file
-    # type=file|default=<undefined>: Input DWI volume.
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputVolume: generic/file
-    # type=file: Output DWI volume.
-    # type=traitcompound|default=None: Output DWI volume.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    rs:
-    # type=inputmultiobject|default=[]: The algorithm search for similar voxels in a neighborhood of this size (larger sizes than the default one are extremely slow).
-    rc:
-    # type=inputmultiobject|default=[]: Similarity between blocks is measured using windows of this size.
-    hp:
-    # type=float|default=0.0: This parameter is related to noise; the larger the parameter, the more aggressive the filtering. Should be near 1, and only values between 0.8 and 1.2 are allowed
-    ng:
-    # type=int|default=0: The number of the closest gradients that are used to jointly filter a given gradient direction (a maximum of 5 is allowed).
-    re:
-    # type=inputmultiobject|default=[]: A neighborhood of this size is used to compute the statistics for noise estimation.
-    inputVolume:
-    # type=file|default=<undefined>: Input DWI volume.
-    outputVolume:
-    # type=file: Output DWI volume.
-    # type=traitcompound|default=None: Output DWI volume.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/dwi_unbiased_non_local_means_filter_callables.py b/example-specs/task/nipype_internal/pydra-slicer/dwi_unbiased_non_local_means_filter_callables.py
deleted file mode 100644
index 941eb97c..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/dwi_unbiased_non_local_means_filter_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in DWIUnbiasedNonLocalMeansFilter.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/em_segment_command_line.yaml b/example-specs/task/nipype_internal/pydra-slicer/em_segment_command_line.yaml
deleted file mode 100644
index 7c3f0d48..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/em_segment_command_line.yaml
+++ /dev/null
@@ -1,148 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.slicer.segmentation.specialized.EMSegmentCommandLine' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title:
-#       EMSegment Command-line
-# 
-# 
-#     category:
-#       Segmentation.Specialized
-# 
-# 
-#     description:
-#       This module is used to simplify the process of segmenting large collections of images by providing a command line interface to the EMSegment algorithm for script and batch processing.
-# 
-# 
-#     documentation-url: http://www.slicer.org/slicerWiki/index.php/Documentation/4.0/EMSegment_Command-line
-# 
-#     contributor: Sebastien Barre, Brad Davis, Kilian Pohl, Polina Golland, Yumin Yuan, Daniel Haehn
-# 
-#     acknowledgements: Many people and organizations have contributed to the funding, design, and development of the EMSegment algorithm and its various implementations.
-# 
-#     
-task_name: EMSegmentCommandLine
-nipype_name: EMSegmentCommandLine
-nipype_module: nipype.interfaces.slicer.segmentation.specialized
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    mrmlSceneFileName: generic/file
-    # type=file|default=<undefined>: Active MRML scene that contains EMSegment algorithm parameters.
-    targetVolumeFileNames: generic/file+list-of
-    # type=inputmultiobject|default=[]: File names of target volumes (to be segmented).  The number of target images must be equal to the number of target images specified in the parameter set, and these images must be spatially aligned.
-    resultStandardVolumeFileName: generic/file
-    # type=file|default=<undefined>: Used for testing.  Compare segmentation results to this image and return EXIT_FAILURE if they do not match.
-    atlasVolumeFileNames: generic/file+list-of
-    # type=inputmultiobject|default=[]: Use an alternative atlas to the one that is specified by the mrml file - note the order matters ! 
-    intermediateResultsDirectory: generic/directory
-    # type=directory|default=<undefined>: Directory where EMSegmenter will write intermediate data (e.g., aligned atlas data).
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    resultVolumeFileName: generic/file
-    # type=file: The file name that the segmentation result volume will be written to.
-    # type=traitcompound|default=None: The file name that the segmentation result volume will be written to.
-    generateEmptyMRMLSceneAndQuit: generic/file
-    # type=file: Used for testing.  Only write a scene with default mrml parameters.
-    # type=traitcompound|default=None: Used for testing.  Only write a scene with default mrml parameters.
-    resultMRMLSceneFileName: generic/file
-    # type=file: Write out the MRML scene after command line substitutions have been made.
-    # type=traitcompound|default=None: Write out the MRML scene after command line substitutions have been made.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    mrmlSceneFileName:
-    # type=file|default=<undefined>: Active MRML scene that contains EMSegment algorithm parameters.
-    resultVolumeFileName:
-    # type=file: The file name that the segmentation result volume will be written to.
-    # type=traitcompound|default=None: The file name that the segmentation result volume will be written to.
-    targetVolumeFileNames:
-    # type=inputmultiobject|default=[]: File names of target volumes (to be segmented).  The number of target images must be equal to the number of target images specified in the parameter set, and these images must be spatially aligned.
-    intermediateResultsDirectory:
-    # type=directory|default=<undefined>: Directory where EMSegmenter will write intermediate data (e.g., aligned atlas data).
-    parametersMRMLNodeName:
-    # type=str|default='': The name of the EMSegment parameters node within the active MRML scene.  Leave blank for default.
-    disableMultithreading:
-    # type=int|default=0: Disable multithreading for the EMSegmenter algorithm only! Preprocessing might still run in multi-threaded mode. -1: Do not overwrite default value. 0: Disable. 1: Enable.
-    dontUpdateIntermediateData:
-    # type=int|default=0: Disable update of intermediate results.  -1: Do not overwrite default value. 0: Disable. 1: Enable.
-    verbose:
-    # type=bool|default=False: Enable verbose output.
-    loadTargetCentered:
-    # type=bool|default=False: Read target files centered.
-    loadAtlasNonCentered:
-    # type=bool|default=False: Read atlas files non-centered.
-    taskPreProcessingSetting:
-    # type=str|default='': Specifies the different task parameter. Leave blank for default.
-    keepTempFiles:
-    # type=bool|default=False: If flag is set then at the end of command the temporary files are not removed
-    resultStandardVolumeFileName:
-    # type=file|default=<undefined>: Used for testing.  Compare segmentation results to this image and return EXIT_FAILURE if they do not match.
-    dontWriteResults:
-    # type=bool|default=False: Used for testing.  Don't actually write the resulting labelmap to disk.
-    generateEmptyMRMLSceneAndQuit:
-    # type=file: Used for testing.  Only write a scene with default mrml parameters.
-    # type=traitcompound|default=None: Used for testing.  Only write a scene with default mrml parameters.
-    resultMRMLSceneFileName:
-    # type=file: Write out the MRML scene after command line substitutions have been made.
-    # type=traitcompound|default=None: Write out the MRML scene after command line substitutions have been made.
-    disableCompression:
-    # type=bool|default=False: Don't use compression when writing result image to disk.
-    atlasVolumeFileNames:
-    # type=inputmultiobject|default=[]: Use an alternative atlas to the one that is specified by the mrml file - note the order matters ! 
-    registrationPackage:
-    # type=str|default='': specify the registration package for preprocessing (CMTK or BRAINS or PLASTIMATCH or DEMONS)
-    registrationAffineType:
-    # type=int|default=0: specify the accuracy of the affine registration. -2: Do not overwrite default, -1: Test, 0: Disable, 1: Fast, 2: Accurate
-    registrationDeformableType:
-    # type=int|default=0: specify the accuracy of the deformable registration. -2: Do not overwrite default, -1: Test, 0: Disable, 1: Fast, 2: Accurate
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/em_segment_command_line_callables.py b/example-specs/task/nipype_internal/pydra-slicer/em_segment_command_line_callables.py
deleted file mode 100644
index f1e2f079..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/em_segment_command_line_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in EMSegmentCommandLine.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/em_segment_transform_to_new_format.yaml b/example-specs/task/nipype_internal/pydra-slicer/em_segment_transform_to_new_format.yaml
deleted file mode 100644
index ab28ba10..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/em_segment_transform_to_new_format.yaml
+++ /dev/null
@@ -1,89 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.slicer.utilities.EMSegmentTransformToNewFormat' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title:
-#       Transform MRML Files to New EMSegmenter Standard
-# 
-# 
-#     category:
-#       Utilities
-# 
-# 
-#     description:
-#       Transform MRML Files to New EMSegmenter Standard
-# 
-#     
-task_name: EMSegmentTransformToNewFormat
-nipype_name: EMSegmentTransformToNewFormat
-nipype_module: nipype.interfaces.slicer.utilities
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputMRMLFileName: generic/file
-    # type=file|default=<undefined>: Active MRML scene that contains EMSegment algorithm parameters in the format before 3.6.3 - please include absolute  file name in path.
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputMRMLFileName: generic/file
-    # type=file: Write out the MRML scene after transformation to format 3.6.3 has been made. - has to be in the same directory as the input MRML file due to Slicer Core bug  - please include absolute  file name in path 
-    # type=traitcompound|default=None: Write out the MRML scene after transformation to format 3.6.3 has been made. - has to be in the same directory as the input MRML file due to Slicer Core bug  - please include absolute  file name in path 
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputMRMLFileName:
-    # type=file|default=<undefined>: Active MRML scene that contains EMSegment algorithm parameters in the format before 3.6.3 - please include absolute  file name in path.
-    outputMRMLFileName:
-    # type=file: Write out the MRML scene after transformation to format 3.6.3 has been made. - has to be in the same directory as the input MRML file due to Slicer Core bug  - please include absolute  file name in path 
-    # type=traitcompound|default=None: Write out the MRML scene after transformation to format 3.6.3 has been made. - has to be in the same directory as the input MRML file due to Slicer Core bug  - please include absolute  file name in path 
-    templateFlag:
-    # type=bool|default=False: Set to true if the transformed mrml file should be used as template file 
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/em_segment_transform_to_new_format_callables.py b/example-specs/task/nipype_internal/pydra-slicer/em_segment_transform_to_new_format_callables.py
deleted file mode 100644
index c3492774..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/em_segment_transform_to_new_format_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in EMSegmentTransformToNewFormat.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/expert_automated_registration.yaml b/example-specs/task/nipype_internal/pydra-slicer/expert_automated_registration.yaml
deleted file mode 100644
index aa857857..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/expert_automated_registration.yaml
+++ /dev/null
@@ -1,151 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.slicer.legacy.registration.ExpertAutomatedRegistration' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Expert Automated Registration
-# 
-#     category: Legacy.Registration
-# 
-#     description: Provides rigid, affine, and BSpline registration methods via a simple GUI
-# 
-#     version: 0.1.0.$Revision: 2104 $(alpha)
-# 
-#     documentation-url: http://www.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/ExpertAutomatedRegistration
-# 
-#     contributor: Stephen R Aylward (Kitware), Casey B Goodlett (Kitware)
-# 
-#     acknowledgements: This work is part of the National Alliance for Medical Image Computing (NAMIC), funded by the National Institutes of Health through the NIH Roadmap for Medical Research, Grant U54 EB005149.
-#     
-task_name: ExpertAutomatedRegistration
-nipype_name: ExpertAutomatedRegistration
-nipype_module: nipype.interfaces.slicer.legacy.registration
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    fixedImage: generic/file
-    # type=file|default=<undefined>: Image which defines the space into which the moving image is registered
-    movingImage: generic/file
-    # type=file|default=<undefined>: The transform goes from the fixed image's space into the moving image's space
-    loadTransform: generic/file
-    # type=file|default=<undefined>: Load a transform that is immediately applied to the moving image
-    fixedImageMask: generic/file
-    # type=file|default=<undefined>: Image which defines a mask for the fixed image
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    resampledImage: generic/file
-    # type=file: Registration results
-    # type=traitcompound|default=None: Registration results
-    saveTransform: generic/file
-    # type=file: Save the transform that results from registration
-    # type=traitcompound|default=None: Save the transform that results from registration
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    fixedImage:
-    # type=file|default=<undefined>: Image which defines the space into which the moving image is registered
-    movingImage:
-    # type=file|default=<undefined>: The transform goes from the fixed image's space into the moving image's space
-    resampledImage:
-    # type=file: Registration results
-    # type=traitcompound|default=None: Registration results
-    loadTransform:
-    # type=file|default=<undefined>: Load a transform that is immediately applied to the moving image
-    saveTransform:
-    # type=file: Save the transform that results from registration
-    # type=traitcompound|default=None: Save the transform that results from registration
-    initialization:
-    # type=enum|default='None'|allowed['CentersOfMass','ImageCenters','Landmarks','None','SecondMoments']: Method to prime the registration process
-    registration:
-    # type=enum|default='None'|allowed['Affine','BSpline','Initial','None','PipelineAffine','PipelineBSpline','PipelineRigid','Rigid']: Method for the registration process
-    metric:
-    # type=enum|default='MattesMI'|allowed['MattesMI','MeanSqrd','NormCorr']: Method to quantify image match
-    expectedOffset:
-    # type=float|default=0.0: Expected misalignment after initialization
-    expectedRotation:
-    # type=float|default=0.0: Expected misalignment after initialization
-    expectedScale:
-    # type=float|default=0.0: Expected misalignment after initialization
-    expectedSkew:
-    # type=float|default=0.0: Expected misalignment after initialization
-    verbosityLevel:
-    # type=enum|default='Silent'|allowed['Silent','Standard','Verbose']: Level of detail of reporting progress
-    sampleFromOverlap:
-    # type=bool|default=False: Limit metric evaluation to the fixed image region overlapped by the moving image
-    fixedImageMask:
-    # type=file|default=<undefined>: Image which defines a mask for the fixed image
-    randomNumberSeed:
-    # type=int|default=0: Seed to generate a consistent random number sequence
-    numberOfThreads:
-    # type=int|default=0: Number of CPU threads to use
-    minimizeMemory:
-    # type=bool|default=False: Reduce the amount of memory required at the cost of increased computation time
-    interpolation:
-    # type=enum|default='NearestNeighbor'|allowed['BSpline','Linear','NearestNeighbor']: Method for interpolation within the optimization process
-    fixedLandmarks:
-    # type=inputmultiobject|default=[]: Ordered list of landmarks in the fixed image
-    movingLandmarks:
-    # type=inputmultiobject|default=[]: Ordered list of landmarks in the moving image
-    rigidMaxIterations:
-    # type=int|default=0: Maximum number of rigid optimization iterations
-    rigidSamplingRatio:
-    # type=float|default=0.0: Portion of the image to use in computing the metric during rigid registration
-    affineMaxIterations:
-    # type=int|default=0: Maximum number of affine optimization iterations
-    affineSamplingRatio:
-    # type=float|default=0.0: Portion of the image to use in computing the metric during affine registration
-    bsplineMaxIterations:
-    # type=int|default=0: Maximum number of bspline optimization iterations
-    bsplineSamplingRatio:
-    # type=float|default=0.0: Portion of the image to use in computing the metric during BSpline registration
-    controlPointSpacing:
-    # type=int|default=0: Number of pixels between control points
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/expert_automated_registration_callables.py b/example-specs/task/nipype_internal/pydra-slicer/expert_automated_registration_callables.py
deleted file mode 100644
index 3c94919d..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/expert_automated_registration_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in ExpertAutomatedRegistration.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/extract_skeleton.yaml b/example-specs/task/nipype_internal/pydra-slicer/extract_skeleton.yaml
deleted file mode 100644
index 3aa15179..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/extract_skeleton.yaml
+++ /dev/null
@@ -1,97 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.slicer.filtering.extractskeleton.ExtractSkeleton' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Extract Skeleton
-# 
-#     category: Filtering
-# 
-#     description: Extract the skeleton of a binary object.  The skeleton can be limited to being a 1D curve or allowed to be a full 2D manifold.  The branches of the skeleton can be pruned so that only the maximal center skeleton is returned.
-# 
-#     version: 0.1.0.$Revision: 2104 $(alpha)
-# 
-#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/ExtractSkeleton
-# 
-#     contributor: Pierre Seroul (UNC), Martin Styner (UNC), Guido Gerig (UNC), Stephen Aylward (Kitware)
-# 
-#     acknowledgements: The original implementation of this method was provided by ETH Zurich, Image Analysis Laboratory of Profs Olaf Kuebler, Gabor Szekely and Guido Gerig.  Martin Styner at UNC, Chapel Hill made enhancements.  Wrapping for Slicer was provided by Pierre Seroul and Stephen Aylward at Kitware, Inc.
-#     
-task_name: ExtractSkeleton
-nipype_name: ExtractSkeleton
-nipype_module: nipype.interfaces.slicer.filtering.extractskeleton
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    InputImageFileName: generic/file
-    # type=file|default=<undefined>: Input image
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    OutputImageFileName: generic/file
-    # type=file: Skeleton of the input image
-    # type=traitcompound|default=None: Skeleton of the input image
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    InputImageFileName:
-    # type=file|default=<undefined>: Input image
-    OutputImageFileName:
-    # type=file: Skeleton of the input image
-    # type=traitcompound|default=None: Skeleton of the input image
-    type:
-    # type=enum|default='1D'|allowed['1D','2D']: Type of skeleton to create
-    dontPrune:
-    # type=bool|default=False: Return the full skeleton, not just the maximal skeleton
-    numPoints:
-    # type=int|default=0: Number of points used to represent the skeleton
-    pointsFile:
-    # type=str|default='': Name of the file to store the coordinates of the central (1D) skeleton points
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/extract_skeleton_callables.py b/example-specs/task/nipype_internal/pydra-slicer/extract_skeleton_callables.py
deleted file mode 100644
index 4cc88444..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/extract_skeleton_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in ExtractSkeleton.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/fiducial_registration.yaml b/example-specs/task/nipype_internal/pydra-slicer/fiducial_registration.yaml
deleted file mode 100644
index 3c2fd72f..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/fiducial_registration.yaml
+++ /dev/null
@@ -1,95 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.slicer.registration.specialized.FiducialRegistration' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Fiducial Registration
-# 
-#     category: Registration.Specialized
-# 
-#     description: Computes a rigid, similarity or affine transform from a matched list of fiducials
-# 
-#     version: 0.1.0.$Revision$
-# 
-#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/TransformFromFiducials
-# 
-#     contributor: Casey B Goodlett (Kitware), Dominik Meier (SPL, BWH)
-# 
-#     acknowledgements: This work is part of the National Alliance for Medical Image Computing (NAMIC), funded by the National Institutes of Health through the NIH Roadmap for Medical Research, Grant U54 EB005149.
-#     
-task_name: FiducialRegistration
-nipype_name: FiducialRegistration
-nipype_module: nipype.interfaces.slicer.registration.specialized
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    saveTransform: generic/file
-    # type=file: Save the transform that results from registration
-    # type=traitcompound|default=None: Save the transform that results from registration
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    fixedLandmarks:
-    # type=inputmultiobject|default=[]: Ordered list of landmarks in the fixed image
-    movingLandmarks:
-    # type=inputmultiobject|default=[]: Ordered list of landmarks in the moving image
-    saveTransform:
-    # type=file: Save the transform that results from registration
-    # type=traitcompound|default=None: Save the transform that results from registration
-    transformType:
-    # type=enum|default='Translation'|allowed['Rigid','Similarity','Translation']: Type of transform to produce
-    rms:
-    # type=float|default=0.0: Display RMS Error.
-    outputMessage:
-    # type=str|default='': Provides more information on the output
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/fiducial_registration_callables.py b/example-specs/task/nipype_internal/pydra-slicer/fiducial_registration_callables.py
deleted file mode 100644
index 403cb5cf..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/fiducial_registration_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in FiducialRegistration.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/gaussian_blur_image_filter.yaml b/example-specs/task/nipype_internal/pydra-slicer/gaussian_blur_image_filter.yaml
deleted file mode 100644
index 0c350f9a..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/gaussian_blur_image_filter.yaml
+++ /dev/null
@@ -1,91 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.slicer.filtering.denoising.GaussianBlurImageFilter' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Gaussian Blur Image Filter
-# 
-#     category: Filtering.Denoising
-# 
-#     description: Apply a gaussian blur to an image
-# 
-#     version: 0.1.0.$Revision: 1.1 $(alpha)
-# 
-#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/GaussianBlurImageFilter
-# 
-#     contributor: Julien Jomier (Kitware), Stephen Aylward (Kitware)
-# 
-#     acknowledgements: This work is part of the National Alliance for Medical Image Computing (NAMIC), funded by the National Institutes of Health through the NIH Roadmap for Medical Research, Grant U54 EB005149.
-#     
-task_name: GaussianBlurImageFilter
-nipype_name: GaussianBlurImageFilter
-nipype_module: nipype.interfaces.slicer.filtering.denoising
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputVolume: generic/file
-    # type=file|default=<undefined>: Input volume
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputVolume: generic/file
-    # type=file: Blurred Volume
-    # type=traitcompound|default=None: Blurred Volume
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    sigma:
-    # type=float|default=0.0: Sigma value in physical units (e.g., mm) of the Gaussian kernel
-    inputVolume:
-    # type=file|default=<undefined>: Input volume
-    outputVolume:
-    # type=file: Blurred Volume
-    # type=traitcompound|default=None: Blurred Volume
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/gaussian_blur_image_filter_callables.py b/example-specs/task/nipype_internal/pydra-slicer/gaussian_blur_image_filter_callables.py
deleted file mode 100644
index ef7c5d6a..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/gaussian_blur_image_filter_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in GaussianBlurImageFilter.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/gradient_anisotropic_diffusion.yaml b/example-specs/task/nipype_internal/pydra-slicer/gradient_anisotropic_diffusion.yaml
deleted file mode 100644
index 160f9573..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/gradient_anisotropic_diffusion.yaml
+++ /dev/null
@@ -1,97 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.slicer.filtering.denoising.GradientAnisotropicDiffusion' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Gradient Anisotropic Diffusion
-# 
-#     category: Filtering.Denoising
-# 
-#     description: Runs gradient anisotropic diffusion on a volume.
-# 
-#     Anisotropic diffusion methods reduce noise (or unwanted detail) in images while preserving specific image features, like edges.  For many applications, there is an assumption that light-dark transitions (edges) are interesting.  Standard isotropic diffusion methods move and blur light-dark boundaries.  Anisotropic diffusion methods are formulated to specifically preserve edges. The conductance term for this implementation is a function of the gradient magnitude of the image at each point, reducing the strength of diffusion at edges. The numerical implementation of this equation is similar to that described in the Perona-Malik paper, but uses a more robust technique for gradient magnitude estimation and has been generalized to N-dimensions.
-# 
-#     version: 0.1.0.$Revision: 19608 $(alpha)
-# 
-#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/GradientAnisotropicDiffusion
-# 
-#     contributor: Bill Lorensen (GE)
-# 
-#     acknowledgements: This command module was derived from Insight/Examples (copyright) Insight Software Consortium
-#     
-task_name: GradientAnisotropicDiffusion
-nipype_name: GradientAnisotropicDiffusion
-nipype_module: nipype.interfaces.slicer.filtering.denoising
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputVolume: generic/file
-    # type=file|default=<undefined>: Input volume to be filtered
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputVolume: generic/file
-    # type=file: Output filtered
-    # type=traitcompound|default=None: Output filtered
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    conductance:
-    # type=float|default=0.0: Conductance controls the sensitivity of the conductance term. As a general rule, the lower the value, the more strongly the filter preserves edges. A high value will cause diffusion (smoothing) across edges. Note that the number of iterations controls how much smoothing is done within regions bounded by edges.
-    iterations:
-    # type=int|default=0: The more iterations, the more smoothing. Each iteration takes the same amount of time. If it takes 10 seconds for one iteration, then it will take 100 seconds for 10 iterations. Note that the conductance controls how much each iteration smooths across edges.
-    timeStep:
-    # type=float|default=0.0: The time step depends on the dimensionality of the image. In Slicer the images are 3D and the default (.0625) time step will provide a stable solution.
-    inputVolume:
-    # type=file|default=<undefined>: Input volume to be filtered
-    outputVolume:
-    # type=file: Output filtered
-    # type=traitcompound|default=None: Output filtered
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/gradient_anisotropic_diffusion_callables.py b/example-specs/task/nipype_internal/pydra-slicer/gradient_anisotropic_diffusion_callables.py
deleted file mode 100644
index 91ce97e0..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/gradient_anisotropic_diffusion_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in GradientAnisotropicDiffusion.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/grayscale_fill_hole_image_filter.yaml b/example-specs/task/nipype_internal/pydra-slicer/grayscale_fill_hole_image_filter.yaml
deleted file mode 100644
index af1aee29..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/grayscale_fill_hole_image_filter.yaml
+++ /dev/null
@@ -1,97 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.slicer.filtering.morphology.GrayscaleFillHoleImageFilter' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Grayscale Fill Hole Image Filter
-# 
-#     category: Filtering.Morphology
-# 
-#     description: GrayscaleFillholeImageFilter fills holes in a grayscale image.  Holes are local minima in the grayscale topography that are not connected to boundaries of the image. Gray level values adjacent to a hole are extrapolated across the hole.
-# 
-#     This filter is used to smooth over local minima without affecting the values of local maxima.  If you take the difference between the output of this filter and the original image (and perhaps threshold the difference above a small value), you'll obtain a map of the local minima.
-# 
-#     This filter uses the itkGrayscaleGeodesicErodeImageFilter.  It provides its own input as the "mask" input to the geodesic erosion.  The "marker" image for the geodesic erosion is constructed such that boundary pixels match the boundary pixels of the input image and the interior pixels are set to the maximum pixel value in the input image.
-# 
-#      Geodesic morphology and the Fillhole algorithm is described in Chapter 6 of Pierre Soille's book "Morphological Image Analysis: Principles and Applications", Second Edition, Springer, 2003.
-# 
-#      A companion filter, Grayscale Grind Peak, removes peaks in grayscale images.
-# 
-#     version: 0.1.0.$Revision: 19608 $(alpha)
-# 
-#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/GrayscaleFillHoleImageFilter
-# 
-#     contributor: Bill Lorensen (GE)
-# 
-#     acknowledgements: This work is part of the National Alliance for Medical Image Computing (NAMIC), funded by the National Institutes of Health through the NIH Roadmap for Medical Research, Grant U54 EB005149.
-#     
-task_name: GrayscaleFillHoleImageFilter
-nipype_name: GrayscaleFillHoleImageFilter
-nipype_module: nipype.interfaces.slicer.filtering.morphology
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputVolume: generic/file
-    # type=file|default=<undefined>: Input volume to be filtered
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputVolume: generic/file
-    # type=file: Output filtered
-    # type=traitcompound|default=None: Output filtered
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputVolume:
-    # type=file|default=<undefined>: Input volume to be filtered
-    outputVolume:
-    # type=file: Output filtered
-    # type=traitcompound|default=None: Output filtered
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/grayscale_fill_hole_image_filter_callables.py b/example-specs/task/nipype_internal/pydra-slicer/grayscale_fill_hole_image_filter_callables.py
deleted file mode 100644
index cb4ffc92..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/grayscale_fill_hole_image_filter_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in GrayscaleFillHoleImageFilter.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/grayscale_grind_peak_image_filter.yaml b/example-specs/task/nipype_internal/pydra-slicer/grayscale_grind_peak_image_filter.yaml
deleted file mode 100644
index cf29e3cc..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/grayscale_grind_peak_image_filter.yaml
+++ /dev/null
@@ -1,99 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.slicer.filtering.morphology.GrayscaleGrindPeakImageFilter' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Grayscale Grind Peak Image Filter
-# 
-#     category: Filtering.Morphology
-# 
-#     description: GrayscaleGrindPeakImageFilter removes peaks in a grayscale image. Peaks are local maxima in the grayscale topography that are not connected to boundaries of the image. Gray level values adjacent to a peak are extrapolated through the peak.
-# 
-#     This filter is used to smooth over local maxima without affecting the values of local minima.  If you take the difference between the output of this filter and the original image (and perhaps threshold the difference above a small value), you'll obtain a map of the local maxima.
-# 
-#     This filter uses the GrayscaleGeodesicDilateImageFilter.  It provides its own input as the "mask" input to the geodesic erosion.  The "marker" image for the geodesic erosion is constructed such that boundary pixels match the boundary pixels of the input image and the interior pixels are set to the minimum pixel value in the input image.
-# 
-#     This filter is the dual to the GrayscaleFillholeImageFilter which implements the Fillhole algorithm.  Since it is a dual, it is somewhat superfluous but is provided as a convenience.
-# 
-#     Geodesic morphology and the Fillhole algorithm is described in Chapter 6 of Pierre Soille's book "Morphological Image Analysis: Principles and Applications", Second Edition, Springer, 2003.
-# 
-#     A companion filter, Grayscale Fill Hole, fills holes in grayscale images.
-# 
-#     version: 0.1.0.$Revision: 19608 $(alpha)
-# 
-#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/GrayscaleGrindPeakImageFilter
-# 
-#     contributor: Bill Lorensen (GE)
-# 
-#     acknowledgements: This work is part of the National Alliance for Medical Image Computing (NAMIC), funded by the National Institutes of Health through the NIH Roadmap for Medical Research, Grant U54 EB005149.
-#     
-task_name: GrayscaleGrindPeakImageFilter
-nipype_name: GrayscaleGrindPeakImageFilter
-nipype_module: nipype.interfaces.slicer.filtering.morphology
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputVolume: generic/file
-    # type=file|default=<undefined>: Input volume to be filtered
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputVolume: generic/file
-    # type=file: Output filtered
-    # type=traitcompound|default=None: Output filtered
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputVolume:
-    # type=file|default=<undefined>: Input volume to be filtered
-    outputVolume:
-    # type=file: Output filtered
-    # type=traitcompound|default=None: Output filtered
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/grayscale_grind_peak_image_filter_callables.py b/example-specs/task/nipype_internal/pydra-slicer/grayscale_grind_peak_image_filter_callables.py
deleted file mode 100644
index 04a704df..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/grayscale_grind_peak_image_filter_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in GrayscaleGrindPeakImageFilter.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/grayscale_model_maker.yaml b/example-specs/task/nipype_internal/pydra-slicer/grayscale_model_maker.yaml
deleted file mode 100644
index 5865c1e2..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/grayscale_model_maker.yaml
+++ /dev/null
@@ -1,103 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.slicer.surface.GrayscaleModelMaker' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Grayscale Model Maker
-# 
-#     category: Surface Models
-# 
-#     description: Create 3D surface models from grayscale data. This module uses Marching Cubes to create an isosurface at a given threshold. The resulting surface consists of triangles that separate a volume into regions below and above the threshold. The resulting surface can be smoothed and decimated. This model works on continuous data while the module Model Maker works on labeled (or discrete) data.
-# 
-#     version: 3.0
-# 
-#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/GrayscaleModelMaker
-# 
-#     license: slicer3
-# 
-#     contributor: Nicole Aucoin (SPL, BWH), Bill Lorensen (GE)
-# 
-#     acknowledgements: This work is part of the National Alliance for Medical Image Computing (NAMIC), funded by the National Institutes of Health through the NIH Roadmap for Medical Research, Grant U54 EB005149.
-#     
-task_name: GrayscaleModelMaker
-nipype_name: GrayscaleModelMaker
-nipype_module: nipype.interfaces.slicer.surface
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    InputVolume: generic/file
-    # type=file|default=<undefined>: Volume containing the input grayscale data.
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    OutputGeometry: generic/file
-    # type=file: Output that contains geometry model.
-    # type=traitcompound|default=None: Output that contains geometry model.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    InputVolume:
-    # type=file|default=<undefined>: Volume containing the input grayscale data.
-    OutputGeometry:
-    # type=file: Output that contains geometry model.
-    # type=traitcompound|default=None: Output that contains geometry model.
-    threshold:
-    # type=float|default=0.0: Grayscale threshold of isosurface. The resulting surface of triangles separates the volume into voxels that lie above (inside) and below (outside) the threshold.
-    name:
-    # type=str|default='': Name to use for this model.
-    smooth:
-    # type=int|default=0: Number of smoothing iterations. If 0, no smoothing will be done.
-    decimate:
-    # type=float|default=0.0: Target reduction during decimation, as a decimal percentage reduction in the number of polygons. If 0, no decimation will be done.
-    splitnormals:
-    # type=bool|default=False: Splitting normals is useful for visualizing sharp features. However it creates holes in surfaces which affect measurements
-    pointnormals:
-    # type=bool|default=False: Calculate the point normals? Calculated point normals make the surface appear smooth. Without point normals, the surface will appear faceted.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/grayscale_model_maker_callables.py b/example-specs/task/nipype_internal/pydra-slicer/grayscale_model_maker_callables.py
deleted file mode 100644
index 9aa1d44b..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/grayscale_model_maker_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in GrayscaleModelMaker.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/histogram_matching.yaml b/example-specs/task/nipype_internal/pydra-slicer/histogram_matching.yaml
deleted file mode 100644
index cec44df1..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/histogram_matching.yaml
+++ /dev/null
@@ -1,105 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.slicer.filtering.histogrammatching.HistogramMatching' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Histogram Matching
-# 
-#     category: Filtering
-# 
-#     description: Normalizes the grayscale values of a source image based on the grayscale values of a reference image.  This filter uses a histogram matching technique where the histograms of the two images are matched only at a specified number of quantile values.
-# 
-#     The filter was originally designed to normalize MR images of the sameMR protocol and same body part. The algorithm works best if background pixels are excluded from both the source and reference histograms.  A simple background exclusion method is to exclude all pixels whose grayscale values are smaller than the mean grayscale value. ThresholdAtMeanIntensity switches on this simple background exclusion method.
-# 
-#     Number of match points governs the number of quantile values to be matched.
-# 
-#     The filter assumes that both the source and reference are of the same type and that the input and output image type have the same number of dimension and have scalar pixel types.
-# 
-#     version: 0.1.0.$Revision: 19608 $(alpha)
-# 
-#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/HistogramMatching
-# 
-#     contributor: Bill Lorensen (GE)
-# 
-#     acknowledgements: This work is part of the National Alliance for Medical Image Computing (NAMIC), funded by the National Institutes of Health through the NIH Roadmap for Medical Research, Grant U54 EB005149.
-#     
-task_name: HistogramMatching
-nipype_name: HistogramMatching
-nipype_module: nipype.interfaces.slicer.filtering.histogrammatching
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputVolume: generic/file
-    # type=file|default=<undefined>: Input volume to be filtered
-    referenceVolume: generic/file
-    # type=file|default=<undefined>: Input volume whose histogram will be matched
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputVolume: generic/file
-    # type=file: Output volume. This is the input volume with intensities matched to the reference volume.
-    # type=traitcompound|default=None: Output volume. This is the input volume with intensities matched to the reference volume.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    numberOfHistogramLevels:
-    # type=int|default=0: The number of hisogram levels to use
-    numberOfMatchPoints:
-    # type=int|default=0: The number of match points to use
-    threshold:
-    # type=bool|default=False: If on, only pixels above the mean in each volume are thresholded.
-    inputVolume:
-    # type=file|default=<undefined>: Input volume to be filtered
-    referenceVolume:
-    # type=file|default=<undefined>: Input volume whose histogram will be matched
-    outputVolume:
-    # type=file: Output volume. This is the input volume with intensities matched to the reference volume.
-    # type=traitcompound|default=None: Output volume. This is the input volume with intensities matched to the reference volume.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/histogram_matching_callables.py b/example-specs/task/nipype_internal/pydra-slicer/histogram_matching_callables.py
deleted file mode 100644
index 253ff081..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/histogram_matching_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in HistogramMatching.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/image_label_combine.yaml b/example-specs/task/nipype_internal/pydra-slicer/image_label_combine.yaml
deleted file mode 100644
index 98bfed1f..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/image_label_combine.yaml
+++ /dev/null
@@ -1,93 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.slicer.filtering.imagelabelcombine.ImageLabelCombine' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Image Label Combine
-# 
-#     category: Filtering
-# 
-#     description: Combine two label maps into one
-# 
-#     version: 0.1.0
-# 
-#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/ImageLabelCombine
-# 
-#     contributor: Alex Yarmarkovich (SPL, BWH)
-#     
-task_name: ImageLabelCombine
-nipype_name: ImageLabelCombine
-nipype_module: nipype.interfaces.slicer.filtering.imagelabelcombine
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    InputLabelMap_A: generic/file
-    # type=file|default=<undefined>: Label map image
-    InputLabelMap_B: generic/file
-    # type=file|default=<undefined>: Label map image
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    OutputLabelMap: generic/file
-    # type=file: Resulting Label map image
-    # type=traitcompound|default=None: Resulting Label map image
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    InputLabelMap_A:
-    # type=file|default=<undefined>: Label map image
-    InputLabelMap_B:
-    # type=file|default=<undefined>: Label map image
-    OutputLabelMap:
-    # type=file: Resulting Label map image
-    # type=traitcompound|default=None: Resulting Label map image
-    first_overwrites:
-    # type=bool|default=False: Use first or second label when both are present
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/image_label_combine_callables.py b/example-specs/task/nipype_internal/pydra-slicer/image_label_combine_callables.py
deleted file mode 100644
index ea00bb0c..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/image_label_combine_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in ImageLabelCombine.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/intensity_difference_metric.yaml b/example-specs/task/nipype_internal/pydra-slicer/intensity_difference_metric.yaml
deleted file mode 100644
index da668c35..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/intensity_difference_metric.yaml
+++ /dev/null
@@ -1,112 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.slicer.quantification.changequantification.IntensityDifferenceMetric' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title:
-#       Intensity Difference Change Detection (FAST)
-# 
-# 
-#     category:
-#       Quantification.ChangeQuantification
-# 
-# 
-#     description:
-#       Quantifies the changes between two spatially aligned images based on the pixel-wise difference of image intensities.
-# 
-# 
-#     version: 0.1
-# 
-#     contributor: Andrey Fedorov
-# 
-#     acknowledgements:
-# 
-#     
-task_name: IntensityDifferenceMetric
-nipype_name: IntensityDifferenceMetric
-nipype_module: nipype.interfaces.slicer.quantification.changequantification
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    baselineVolume: generic/file
-    # type=file|default=<undefined>: Baseline volume to be compared to
-    baselineSegmentationVolume: generic/file
-    # type=file|default=<undefined>: Label volume that contains segmentation of the structure of interest in the baseline volume.
-    followupVolume: generic/file
-    # type=file|default=<undefined>: Followup volume to be compare to the baseline
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputVolume: generic/file
-    # type=file: Output volume to keep the results of change quantification.
-    # type=traitcompound|default=None: Output volume to keep the results of change quantification.
-    reportFileName: generic/file
-    # type=file: Report file name
-    # type=traitcompound|default=None: Report file name
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    sensitivityThreshold:
-    # type=float|default=0.0: This parameter should be between 0 and 1, and defines how sensitive the metric should be to the intensity changes.
-    changingBandSize:
-    # type=int|default=0: How far (in mm) from the boundary of the segmentation should the intensity changes be considered.
-    baselineVolume:
-    # type=file|default=<undefined>: Baseline volume to be compared to
-    baselineSegmentationVolume:
-    # type=file|default=<undefined>: Label volume that contains segmentation of the structure of interest in the baseline volume.
-    followupVolume:
-    # type=file|default=<undefined>: Followup volume to be compare to the baseline
-    outputVolume:
-    # type=file: Output volume to keep the results of change quantification.
-    # type=traitcompound|default=None: Output volume to keep the results of change quantification.
-    reportFileName:
-    # type=file: Report file name
-    # type=traitcompound|default=None: Report file name
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/intensity_difference_metric_callables.py b/example-specs/task/nipype_internal/pydra-slicer/intensity_difference_metric_callables.py
deleted file mode 100644
index e544585c..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/intensity_difference_metric_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in IntensityDifferenceMetric.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/label_map_smoothing.yaml b/example-specs/task/nipype_internal/pydra-slicer/label_map_smoothing.yaml
deleted file mode 100644
index d6d1b180..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/label_map_smoothing.yaml
+++ /dev/null
@@ -1,97 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.slicer.surface.LabelMapSmoothing' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Label Map Smoothing
-# 
-#     category: Surface Models
-# 
-#     description: This filter smoothes a binary label map.  With a label map as input, this filter runs an anti-alising algorithm followed by a Gaussian smoothing algorithm.  The output is a smoothed label map.
-# 
-#     version: 1.0
-# 
-#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/LabelMapSmoothing
-# 
-#     contributor: Dirk Padfield (GE), Josh Cates (Utah), Ross Whitaker (Utah)
-# 
-#     acknowledgements: This work is part of the National Alliance for Medical Image Computing (NAMIC), funded by the National Institutes of Health through the NIH Roadmap for Medical Research, Grant U54 EB005149.  This filter is based on work developed at the University of Utah, and implemented at GE Research.
-#     
-task_name: LabelMapSmoothing
-nipype_name: LabelMapSmoothing
-nipype_module: nipype.interfaces.slicer.surface
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputVolume: generic/file
-    # type=file|default=<undefined>: Input label map to smooth
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputVolume: generic/file
-    # type=file: Smoothed label map
-    # type=traitcompound|default=None: Smoothed label map
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    labelToSmooth:
-    # type=int|default=0: The label to smooth.  All others will be ignored.  If no label is selected by the user, the maximum label in the image is chosen by default.
-    numberOfIterations:
-    # type=int|default=0: The number of iterations of the level set AntiAliasing algorithm
-    maxRMSError:
-    # type=float|default=0.0: The maximum RMS error.
-    gaussianSigma:
-    # type=float|default=0.0: The standard deviation of the Gaussian kernel
-    inputVolume:
-    # type=file|default=<undefined>: Input label map to smooth
-    outputVolume:
-    # type=file: Smoothed label map
-    # type=traitcompound|default=None: Smoothed label map
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/label_map_smoothing_callables.py b/example-specs/task/nipype_internal/pydra-slicer/label_map_smoothing_callables.py
deleted file mode 100644
index e8f865e7..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/label_map_smoothing_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in LabelMapSmoothing.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/linear_registration.yaml b/example-specs/task/nipype_internal/pydra-slicer/linear_registration.yaml
deleted file mode 100644
index b3806443..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/linear_registration.yaml
+++ /dev/null
@@ -1,117 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.slicer.legacy.registration.LinearRegistration' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Linear Registration
-# 
-#     category: Legacy.Registration
-# 
-#     description: Registers two images together using a rigid transform and mutual information.
-# 
-#     version: 0.1.0.$Revision: 19608 $(alpha)
-# 
-#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/LinearRegistration
-# 
-#     contributor: Daniel Blezek (GE)
-# 
-#     acknowledgements: This work is part of the National Alliance for Medical Image Computing (NAMIC), funded by the National Institutes of Health through the NIH Roadmap for Medical Research, Grant U54 EB005149.
-#     
-task_name: LinearRegistration
-nipype_name: LinearRegistration
-nipype_module: nipype.interfaces.slicer.legacy.registration
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    initialtransform: generic/file
-    # type=file|default=<undefined>: Initial transform for aligning the fixed and moving image. Maps positions in the fixed coordinate frame to positions in the moving coordinate frame. Optional.
-    FixedImageFileName: generic/file
-    # type=file|default=<undefined>: Fixed image to which to register
-    MovingImageFileName: generic/file
-    # type=file|default=<undefined>: Moving image
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputtransform: generic/file
-    # type=file: Transform calculated that aligns the fixed and moving image. Maps positions in the fixed coordinate frame to the moving coordinate frame. Optional (specify an output transform or an output volume or both).
-    # type=traitcompound|default=None: Transform calculated that aligns the fixed and moving image. Maps positions in the fixed coordinate frame to the moving coordinate frame. Optional (specify an output transform or an output volume or both).
-    resampledmovingfilename: generic/file
-    # type=file: Resampled moving image to the fixed image coordinate frame. Optional (specify an output transform or an output volume or both).
-    # type=traitcompound|default=None: Resampled moving image to the fixed image coordinate frame. Optional (specify an output transform or an output volume or both).
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    fixedsmoothingfactor:
-    # type=int|default=0: Amount of smoothing applied to fixed image prior to registration. Default is 0 (none). Range is 0-5 (unitless). Consider smoothing the input data if there is considerable amounts of noise or the noise pattern in the fixed and moving images is very different.
-    movingsmoothingfactor:
-    # type=int|default=0: Amount of smoothing applied to moving image prior to registration. Default is 0 (none). Range is 0-5 (unitless). Consider smoothing the input data if there is considerable amounts of noise or the noise pattern in the fixed and moving images is very different.
-    histogrambins:
-    # type=int|default=0: Number of histogram bins to use for Mattes Mutual Information. Reduce the number of bins if a registration fails. If the number of bins is too large, the estimated PDFs will be a field of impulses and will inhibit reliable registration estimation.
-    spatialsamples:
-    # type=int|default=0: Number of spatial samples to use in estimating Mattes Mutual Information. Larger values yield more accurate PDFs and improved registration quality.
-    iterations:
-    # type=inputmultiobject|default=[]: Comma separated list of iterations. Must have the same number of elements as the learning rate.
-    learningrate:
-    # type=inputmultiobject|default=[]: Comma separated list of learning rates. Learning rate is a scale factor on the gradient of the registration objective function (gradient with respect to the parameters of the transformation) used to update the parameters of the transformation during optimization. Smaller values cause the optimizer to take smaller steps through the parameter space. Larger values are typically used early in the registration process to take large jumps in parameter space followed by smaller values to home in on the optimum value of the registration objective function. Default is: 0.01, 0.005, 0.0005, 0.0002. Must have the same number of elements as iterations.
-    translationscale:
-    # type=float|default=0.0: Relative scale of translations to rotations, i.e. a value of 100 means 10mm = 1 degree. (Actual scale used 1/(TranslationScale^2)). This parameter is used to 'weight' or 'standardized' the transform parameters and their effect on the registration objective function.
-    initialtransform:
-    # type=file|default=<undefined>: Initial transform for aligning the fixed and moving image. Maps positions in the fixed coordinate frame to positions in the moving coordinate frame. Optional.
-    FixedImageFileName:
-    # type=file|default=<undefined>: Fixed image to which to register
-    MovingImageFileName:
-    # type=file|default=<undefined>: Moving image
-    outputtransform:
-    # type=file: Transform calculated that aligns the fixed and moving image. Maps positions in the fixed coordinate frame to the moving coordinate frame. Optional (specify an output transform or an output volume or both).
-    # type=traitcompound|default=None: Transform calculated that aligns the fixed and moving image. Maps positions in the fixed coordinate frame to the moving coordinate frame. Optional (specify an output transform or an output volume or both).
-    resampledmovingfilename:
-    # type=file: Resampled moving image to the fixed image coordinate frame. Optional (specify an output transform or an output volume or both).
-    # type=traitcompound|default=None: Resampled moving image to the fixed image coordinate frame. Optional (specify an output transform or an output volume or both).
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/linear_registration_callables.py b/example-specs/task/nipype_internal/pydra-slicer/linear_registration_callables.py
deleted file mode 100644
index 14da31af..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/linear_registration_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in LinearRegistration.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/mask_scalar_volume.yaml b/example-specs/task/nipype_internal/pydra-slicer/mask_scalar_volume.yaml
deleted file mode 100644
index 0c41d3a3..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/mask_scalar_volume.yaml
+++ /dev/null
@@ -1,97 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.slicer.filtering.arithmetic.MaskScalarVolume' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Mask Scalar Volume
-# 
-#     category: Filtering.Arithmetic
-# 
-#     description: Masks two images. The output image is set to 0 everywhere except where the chosen label from the mask volume is present, at which point it will retain it's original values. Although all image types are supported on input, only signed types are produced. The two images do not have to have the same dimensions.
-# 
-#     version: 0.1.0.$Revision: 8595 $(alpha)
-# 
-#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/Mask
-# 
-#     contributor: Nicole Aucoin (SPL, BWH), Ron Kikinis (SPL, BWH)
-# 
-#     acknowledgements: This work is part of the National Alliance for Medical Image Computing (NAMIC), funded by the National Institutes of Health through the NIH Roadmap for Medical Research, Grant U54 EB005149.
-#     
-task_name: MaskScalarVolume
-nipype_name: MaskScalarVolume
-nipype_module: nipype.interfaces.slicer.filtering.arithmetic
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    InputVolume: generic/file
-    # type=file|default=<undefined>: Input volume to be masked
-    MaskVolume: generic/file
-    # type=file|default=<undefined>: Label volume containing the mask
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    OutputVolume: generic/file
-    # type=file: Output volume: Input Volume masked by label value from Mask Volume
-    # type=traitcompound|default=None: Output volume: Input Volume masked by label value from Mask Volume
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    InputVolume:
-    # type=file|default=<undefined>: Input volume to be masked
-    MaskVolume:
-    # type=file|default=<undefined>: Label volume containing the mask
-    OutputVolume:
-    # type=file: Output volume: Input Volume masked by label value from Mask Volume
-    # type=traitcompound|default=None: Output volume: Input Volume masked by label value from Mask Volume
-    label:
-    # type=int|default=0: Label value in the Mask Volume to use as the mask
-    replace:
-    # type=int|default=0: Value to use for the output volume outside of the mask
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/mask_scalar_volume_callables.py b/example-specs/task/nipype_internal/pydra-slicer/mask_scalar_volume_callables.py
deleted file mode 100644
index b8564e47..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/mask_scalar_volume_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in MaskScalarVolume.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/median_image_filter.yaml b/example-specs/task/nipype_internal/pydra-slicer/median_image_filter.yaml
deleted file mode 100644
index a20c20b5..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/median_image_filter.yaml
+++ /dev/null
@@ -1,91 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.slicer.filtering.denoising.MedianImageFilter' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Median Image Filter
-# 
-#     category: Filtering.Denoising
-# 
-#     description: The MedianImageFilter is commonly used as a robust approach for noise reduction. This filter is particularly efficient against "salt-and-pepper" noise. In other words, it is robust to the presence of gray-level outliers. MedianImageFilter computes the value of each output pixel as the statistical median of the neighborhood of values around the corresponding input pixel.
-# 
-#     version: 0.1.0.$Revision: 19608 $(alpha)
-# 
-#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/MedianImageFilter
-# 
-#     contributor: Bill Lorensen (GE)
-# 
-#     acknowledgements: This command module was derived from Insight/Examples/Filtering/MedianImageFilter (copyright) Insight Software Consortium
-#     
-task_name: MedianImageFilter
-nipype_name: MedianImageFilter
-nipype_module: nipype.interfaces.slicer.filtering.denoising
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputVolume: generic/file
-    # type=file|default=<undefined>: Input volume to be filtered
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputVolume: generic/file
-    # type=file: Output filtered
-    # type=traitcompound|default=None: Output filtered
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    neighborhood:
-    # type=inputmultiobject|default=[]: The size of the neighborhood in each dimension
-    inputVolume:
-    # type=file|default=<undefined>: Input volume to be filtered
-    outputVolume:
-    # type=file: Output filtered
-    # type=traitcompound|default=None: Output filtered
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/median_image_filter_callables.py b/example-specs/task/nipype_internal/pydra-slicer/median_image_filter_callables.py
deleted file mode 100644
index bcf97cf2..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/median_image_filter_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in MedianImageFilter.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/merge_models.yaml b/example-specs/task/nipype_internal/pydra-slicer/merge_models.yaml
deleted file mode 100644
index 7fe417ec..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/merge_models.yaml
+++ /dev/null
@@ -1,93 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.slicer.surface.MergeModels' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Merge Models
-# 
-#     category: Surface Models
-# 
-#     description: Merge the polydata from two input models and output a new model with the added polydata. Uses the vtkAppendPolyData filter. Works on .vtp and .vtk surface files.
-# 
-#     version: $Revision$
-# 
-#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/MergeModels
-# 
-#     contributor: Nicole Aucoin (SPL, BWH), Ron Kikinis (SPL, BWH), Daniel Haehn (SPL, BWH)
-# 
-#     acknowledgements: This work is part of the National Alliance for Medical Image Computing (NAMIC), funded by the National Institutes of Health through the NIH Roadmap for Medical Research, Grant U54 EB005149.
-#     
-task_name: MergeModels
-nipype_name: MergeModels
-nipype_module: nipype.interfaces.slicer.surface
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    Model1: generic/file
-    # type=file|default=<undefined>: Model
-    Model2: generic/file
-    # type=file|default=<undefined>: Model
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    ModelOutput: generic/file
-    # type=file: Model
-    # type=traitcompound|default=None: Model
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    Model1:
-    # type=file|default=<undefined>: Model
-    Model2:
-    # type=file|default=<undefined>: Model
-    ModelOutput:
-    # type=file: Model
-    # type=traitcompound|default=None: Model
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/merge_models_callables.py b/example-specs/task/nipype_internal/pydra-slicer/merge_models_callables.py
deleted file mode 100644
index 677ca5da..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/merge_models_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in MergeModels.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/model_maker.yaml b/example-specs/task/nipype_internal/pydra-slicer/model_maker.yaml
deleted file mode 100644
index 7732cace..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/model_maker.yaml
+++ /dev/null
@@ -1,122 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.slicer.surface.ModelMaker' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Model Maker
-# 
-#     category: Surface Models
-# 
-#     description: Create 3D surface models from segmented data.<p>Models are imported into Slicer under a model hierarchy node in a MRML scene. The model colors are set by the color table associated with the input volume (these colours will only be visible if you load the model scene file).</p><p><b>Create Multiple:</b></p><p>If you specify a list of Labels, it will over ride any start/end label settings.</p><p>If you click<i>Generate All</i>it will over ride the list of labels and any start/end label settings.</p><p><b>Model Maker Settings:</b></p><p>You can set the number of smoothing iterations, target reduction in number of polygons (decimal percentage). Use 0 and 1 if you wish no smoothing nor decimation.<br>You can set the flags to split normals or generate point normals in this pane as well.<br>You can save a copy of the models after intermediate steps (marching cubes, smoothing, and decimation if not joint smoothing, otherwise just after decimation); these models are not saved in the mrml file, turn off deleting temporary files first in the python window:<br><i>slicer.modules.modelmaker.cliModuleLogic().DeleteTemporaryFilesOff()</i></p>
-# 
-#     version: 4.1
-# 
-#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/ModelMaker
-# 
-#     license: slicer4
-# 
-#     contributor: Nicole Aucoin (SPL, BWH), Ron Kikinis (SPL, BWH), Bill Lorensen (GE)
-# 
-#     acknowledgements: This work is part of the National Alliance for Medical Image Computing (NAMIC), funded by the National Institutes of Health through the NIH Roadmap for Medical Research, Grant U54 EB005149.
-#     
-task_name: ModelMaker
-nipype_name: ModelMaker
-nipype_module: nipype.interfaces.slicer.surface
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    InputVolume: generic/file
-    # type=file|default=<undefined>: Input label map. The Input Volume drop down menu is populated with the label map volumes that are present in the scene, select one from which to generate models.
-    color: generic/file
-    # type=file|default=<undefined>: Color table to make labels to colors and objects
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    InputVolume:
-    # type=file|default=<undefined>: Input label map. The Input Volume drop down menu is populated with the label map volumes that are present in the scene, select one from which to generate models.
-    color:
-    # type=file|default=<undefined>: Color table to make labels to colors and objects
-    modelSceneFile:
-    # type=outputmultiobject: Generated models, under a model hierarchy node. Models are imported into Slicer under a model hierarchy node, and their colors are set by the color table associated with the input label map volume. The model hierarchy node must be created before running the model maker, by selecting Create New ModelHierarchy from the Models drop down menu. If you're running from the command line, a model hierarchy node in a new mrml scene will be created for you.
-    # type=traitcompound|default=[None]: Generated models, under a model hierarchy node. Models are imported into Slicer under a model hierarchy node, and their colors are set by the color table associated with the input label map volume. The model hierarchy node must be created before running the model maker, by selecting Create New ModelHierarchy from the Models drop down menu. If you're running from the command line, a model hierarchy node in a new mrml scene will be created for you.
-    name:
-    # type=str|default='': Name to use for this model. Any text entered in the entry box will be the starting string for the created model file names. The label number and the color name will also be part of the file name. If making multiple models, use this as a prefix to the label and color name.
-    generateAll:
-    # type=bool|default=False: Generate models for all labels in the input volume. select this option if you want to create all models that correspond to all values in a labelmap volume (using the Joint Smoothing option below is useful with this option). Ignores Labels, Start Label, End Label settings. Skips label 0.
-    labels:
-    # type=inputmultiobject|default=[]: A comma separated list of label values from which to make models. f you specify a list of Labels, it will override any start/end label settings. If you click Generate All Models it will override the list of labels and any start/end label settings.
-    start:
-    # type=int|default=0: If you want to specify a continuous range of labels from which to generate models, enter the lower label here. Voxel value from which to start making models. Used instead of the label list to specify a range (make sure the label list is empty or it will over ride this).
-    end:
-    # type=int|default=0: If you want to specify a continuous range of labels from which to generate models, enter the higher label here. Voxel value up to which to continue making models. Skip any values with zero voxels.
-    skipUnNamed:
-    # type=bool|default=False: Select this to not generate models from labels that do not have names defined in the color look up table associated with the input label map. If true, only models which have an entry in the color table will be generated.  If false, generate all models that exist within the label range.
-    jointsmooth:
-    # type=bool|default=False: This will ensure that all resulting models fit together smoothly, like jigsaw puzzle pieces. Otherwise the models will be smoothed independently and may overlap.
-    smooth:
-    # type=int|default=0: Here you can set the number of smoothing iterations for Laplacian smoothing, or the degree of the polynomial approximating the windowed Sinc function. Use 0 if you wish no smoothing. 
-    filtertype:
-    # type=enum|default='Sinc'|allowed['Laplacian','Sinc']: You can control the type of smoothing done on the models by selecting a filter type of either Sinc or Laplacian.
-    decimate:
-    # type=float|default=0.0: Chose the target reduction in number of polygons as a decimal percentage (between 0 and 1) of the number of polygons. Specifies the percentage of triangles to be removed. For example, 0.1 means 10% reduction and 0.9 means 90% reduction.
-    splitnormals:
-    # type=bool|default=False: Splitting normals is useful for visualizing sharp features. However it creates holes in surfaces which affects measurements.
-    pointnormals:
-    # type=bool|default=False: Turn this flag on if you wish to calculate the normal vectors for the points.
-    pad:
-    # type=bool|default=False: Pad the input volume with zero value voxels on all 6 faces in order to ensure the production of closed surfaces. Sets the origin translation and extent translation so that the models still line up with the unpadded input volume.
-    saveIntermediateModels:
-    # type=bool|default=False: You can save a copy of the models after each of the intermediate steps (marching cubes, smoothing, and decimation if not joint smoothing, otherwise just after decimation). These intermediate models are not saved in the mrml file, you have to load them manually after turning off deleting temporary files in they python console (View ->Python Interactor) using the following command slicer.modules.modelmaker.cliModuleLogic().DeleteTemporaryFilesOff().
-    debug:
-    # type=bool|default=False: turn this flag on in order to see debugging output (look in the Error Log window that is accessed via the View menu)
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/model_maker_callables.py b/example-specs/task/nipype_internal/pydra-slicer/model_maker_callables.py
deleted file mode 100644
index b5a30605..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/model_maker_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in ModelMaker.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/model_to_label_map.yaml b/example-specs/task/nipype_internal/pydra-slicer/model_to_label_map.yaml
deleted file mode 100644
index fd900a17..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/model_to_label_map.yaml
+++ /dev/null
@@ -1,95 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.slicer.surface.ModelToLabelMap' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Model To Label Map
-# 
-#     category: Surface Models
-# 
-#     description: Intersects an input model with an reference volume and produces an output label map.
-# 
-#     version: 0.1.0.$Revision: 8643 $(alpha)
-# 
-#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/PolyDataToLabelMap
-# 
-#     contributor: Nicole Aucoin (SPL, BWH), Xiaodong Tao (GE)
-# 
-#     acknowledgements: This work is part of the National Alliance for Medical Image Computing (NAMIC), funded by the National Institutes of Health through the NIH Roadmap for Medical Research, Grant U54 EB005149.
-#     
-task_name: ModelToLabelMap
-nipype_name: ModelToLabelMap
-nipype_module: nipype.interfaces.slicer.surface
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    InputVolume: generic/file
-    # type=file|default=<undefined>: Input volume
-    surface: generic/file
-    # type=file|default=<undefined>: Model
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    OutputVolume: generic/file
-    # type=file: The label volume
-    # type=traitcompound|default=None: The label volume
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    distance:
-    # type=float|default=0.0: Sample distance
-    InputVolume:
-    # type=file|default=<undefined>: Input volume
-    surface:
-    # type=file|default=<undefined>: Model
-    OutputVolume:
-    # type=file: The label volume
-    # type=traitcompound|default=None: The label volume
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/model_to_label_map_callables.py b/example-specs/task/nipype_internal/pydra-slicer/model_to_label_map_callables.py
deleted file mode 100644
index 46ed9e69..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/model_to_label_map_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in ModelToLabelMap.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/multi_resolution_affine_registration.yaml b/example-specs/task/nipype_internal/pydra-slicer/multi_resolution_affine_registration.yaml
deleted file mode 100644
index d82527b3..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/multi_resolution_affine_registration.yaml
+++ /dev/null
@@ -1,115 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.slicer.legacy.registration.MultiResolutionAffineRegistration' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Robust Multiresolution Affine Registration
-# 
-#     category: Legacy.Registration
-# 
-#     description: Provides affine registration using multiple resolution levels and decomposed affine transforms.
-# 
-#     version: 0.1.0.$Revision: 2104 $(alpha)
-# 
-#     documentation-url: http://www.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/MultiResolutionAffineRegistration
-# 
-#     contributor: Casey B Goodlett (Utah)
-# 
-#     acknowledgements: This work is part of the National Alliance for Medical Image Computing (NAMIC), funded by the National Institutes of Health through the NIH Roadmap for Medical Research, Grant U54 EB005149.
-#     
-task_name: MultiResolutionAffineRegistration
-nipype_name: MultiResolutionAffineRegistration
-nipype_module: nipype.interfaces.slicer.legacy.registration
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    fixedImage: generic/file
-    # type=file|default=<undefined>: Image which defines the space into which the moving image is registered
-    movingImage: generic/file
-    # type=file|default=<undefined>: The transform goes from the fixed image's space into the moving image's space
-    fixedImageMask: generic/file
-    # type=file|default=<undefined>: Label image which defines a mask of interest for the fixed image
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    resampledImage: generic/file
-    # type=file: Registration results
-    # type=traitcompound|default=None: Registration results
-    saveTransform: generic/file
-    # type=file: Save the output transform from the registration
-    # type=traitcompound|default=None: Save the output transform from the registration
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    fixedImage:
-    # type=file|default=<undefined>: Image which defines the space into which the moving image is registered
-    movingImage:
-    # type=file|default=<undefined>: The transform goes from the fixed image's space into the moving image's space
-    resampledImage:
-    # type=file: Registration results
-    # type=traitcompound|default=None: Registration results
-    saveTransform:
-    # type=file: Save the output transform from the registration
-    # type=traitcompound|default=None: Save the output transform from the registration
-    fixedImageMask:
-    # type=file|default=<undefined>: Label image which defines a mask of interest for the fixed image
-    fixedImageROI:
-    # type=list|default=[]: Label image which defines a ROI of interest for the fixed image
-    numIterations:
-    # type=int|default=0: Number of iterations to run at each resolution level.
-    numLineIterations:
-    # type=int|default=0: Number of iterations to run at each resolution level.
-    stepSize:
-    # type=float|default=0.0: The maximum step size of the optimizer in voxels
-    stepTolerance:
-    # type=float|default=0.0: The maximum step size of the optimizer in voxels
-    metricTolerance:
-    # type=float|default=0.0: 
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/multi_resolution_affine_registration_callables.py b/example-specs/task/nipype_internal/pydra-slicer/multi_resolution_affine_registration_callables.py
deleted file mode 100644
index 2603847f..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/multi_resolution_affine_registration_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in MultiResolutionAffineRegistration.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/multiply_scalar_volumes.yaml b/example-specs/task/nipype_internal/pydra-slicer/multiply_scalar_volumes.yaml
deleted file mode 100644
index 426b2ff0..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/multiply_scalar_volumes.yaml
+++ /dev/null
@@ -1,95 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.slicer.filtering.arithmetic.MultiplyScalarVolumes' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Multiply Scalar Volumes
-# 
-#     category: Filtering.Arithmetic
-# 
-#     description: Multiplies two images. Although all image types are supported on input, only signed types are produced. The two images do not have to have the same dimensions.
-# 
-#     version: 0.1.0.$Revision: 8595 $(alpha)
-# 
-#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/Multiply
-# 
-#     contributor: Bill Lorensen (GE)
-# 
-#     acknowledgements: This work is part of the National Alliance for Medical Image Computing (NAMIC), funded by the National Institutes of Health through the NIH Roadmap for Medical Research, Grant U54 EB005149.
-#     
-task_name: MultiplyScalarVolumes
-nipype_name: MultiplyScalarVolumes
-nipype_module: nipype.interfaces.slicer.filtering.arithmetic
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputVolume1: generic/file
-    # type=file|default=<undefined>: Input volume 1
-    inputVolume2: generic/file
-    # type=file|default=<undefined>: Input volume 2
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputVolume: generic/file
-    # type=file: Volume1 * Volume2
-    # type=traitcompound|default=None: Volume1 * Volume2
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputVolume1:
-    # type=file|default=<undefined>: Input volume 1
-    inputVolume2:
-    # type=file|default=<undefined>: Input volume 2
-    outputVolume:
-    # type=file: Volume1 * Volume2
-    # type=traitcompound|default=None: Volume1 * Volume2
-    order:
-    # type=enum|default='0'|allowed['0','1','2','3']: Interpolation order if two images are in different coordinate frames or have different sampling.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/multiply_scalar_volumes_callables.py b/example-specs/task/nipype_internal/pydra-slicer/multiply_scalar_volumes_callables.py
deleted file mode 100644
index e010f113..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/multiply_scalar_volumes_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in MultiplyScalarVolumes.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/n4itk_bias_field_correction.yaml b/example-specs/task/nipype_internal/pydra-slicer/n4itk_bias_field_correction.yaml
deleted file mode 100644
index 835806f4..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/n4itk_bias_field_correction.yaml
+++ /dev/null
@@ -1,117 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.slicer.filtering.n4itkbiasfieldcorrection.N4ITKBiasFieldCorrection' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: N4ITK MRI Bias correction
-# 
-#     category: Filtering
-# 
-#     description: Performs image bias correction using N4 algorithm. This module is based on the ITK filters contributed in the following publication:  Tustison N, Gee J "N4ITK: Nick's N3 ITK Implementation For MRI Bias Field Correction", The Insight Journal 2009 January-June, http://hdl.handle.net/10380/3053
-# 
-#     version: 9
-# 
-#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/N4ITKBiasFieldCorrection
-# 
-#     contributor: Nick Tustison (UPenn), Andrey Fedorov (SPL, BWH), Ron Kikinis (SPL, BWH)
-# 
-#     acknowledgements: The development of this module was partially supported by NIH grants R01 AA016748-01, R01 CA111288 and U01 CA151261 as well as by NA-MIC, NAC, NCIGT and the Slicer community.
-#     
-task_name: N4ITKBiasFieldCorrection
-nipype_name: N4ITKBiasFieldCorrection
-nipype_module: nipype.interfaces.slicer.filtering.n4itkbiasfieldcorrection
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputimage: generic/file
-    # type=file|default=<undefined>: Input image where you observe signal inhomegeneity
-    maskimage: generic/file
-    # type=file|default=<undefined>: Binary mask that defines the structure of your interest. NOTE: This parameter is OPTIONAL. If the mask is not specified, the module will use internally Otsu thresholding to define this mask. Better processing results can often be obtained when a meaningful mask is defined.
-    weightimage: generic/file
-    # type=file|default=<undefined>: Weight Image
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputimage: generic/file
-    # type=file: Result of processing
-    # type=traitcompound|default=None: Result of processing
-    outputbiasfield: generic/file
-    # type=file: Recovered bias field (OPTIONAL)
-    # type=traitcompound|default=None: Recovered bias field (OPTIONAL)
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputimage:
-    # type=file|default=<undefined>: Input image where you observe signal inhomegeneity
-    maskimage:
-    # type=file|default=<undefined>: Binary mask that defines the structure of your interest. NOTE: This parameter is OPTIONAL. If the mask is not specified, the module will use internally Otsu thresholding to define this mask. Better processing results can often be obtained when a meaningful mask is defined.
-    outputimage:
-    # type=file: Result of processing
-    # type=traitcompound|default=None: Result of processing
-    outputbiasfield:
-    # type=file: Recovered bias field (OPTIONAL)
-    # type=traitcompound|default=None: Recovered bias field (OPTIONAL)
-    iterations:
-    # type=inputmultiobject|default=[]: Maximum number of iterations at each level of resolution. Larger values will increase execution time, but may lead to better results.
-    convergencethreshold:
-    # type=float|default=0.0: Stopping criterion for the iterative bias estimation. Larger values will lead to smaller execution time.
-    meshresolution:
-    # type=inputmultiobject|default=[]: Resolution of the initial bspline grid defined as a sequence of three numbers. The actual resolution will be defined by adding the bspline order (default is 3) to the resolution in each dimension specified here. For example, 1,1,1 will result in a 4x4x4 grid of control points. This parameter may need to be adjusted based on your input image. In the multi-resolution N4 framework, the resolution of the bspline grid at subsequent iterations will be doubled. The number of resolutions is implicitly defined by Number of iterations parameter (the size of this list is the number of resolutions)
-    splinedistance:
-    # type=float|default=0.0: An alternative means to define the spline grid, by setting the distance between the control points. This parameter is used only if the grid resolution is not specified.
-    shrinkfactor:
-    # type=int|default=0: Defines how much the image should be upsampled before estimating the inhomogeneity field. Increase if you want to reduce the execution time. 1 corresponds to the original resolution. Larger values will significantly reduce the computation time.
-    bsplineorder:
-    # type=int|default=0: Order of B-spline used in the approximation. Larger values will lead to longer execution times, may result in overfitting and poor result.
-    weightimage:
-    # type=file|default=<undefined>: Weight Image
-    histogramsharpening:
-    # type=inputmultiobject|default=[]: A vector of up to three values. Non-zero values correspond to Bias Field Full Width at Half Maximum, Wiener filter noise, and Number of histogram bins.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/n4itk_bias_field_correction_callables.py b/example-specs/task/nipype_internal/pydra-slicer/n4itk_bias_field_correction_callables.py
deleted file mode 100644
index d1772955..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/n4itk_bias_field_correction_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in N4ITKBiasFieldCorrection.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/orient_scalar_volume.yaml b/example-specs/task/nipype_internal/pydra-slicer/orient_scalar_volume.yaml
deleted file mode 100644
index 345274c0..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/orient_scalar_volume.yaml
+++ /dev/null
@@ -1,91 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.slicer.converters.OrientScalarVolume' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Orient Scalar Volume
-# 
-#     category: Converters
-# 
-#     description: Orients an output volume. Rearranges the slices in a volume according to the selected orientation. The slices are not interpolated. They are just reordered and/or permuted. The resulting volume will cover the original volume. NOTE: since Slicer takes into account the orientation of a volume, the re-oriented volume will not show any difference from the original volume, To see the difference, save the volume and display it with a system that either ignores the orientation of the image (e.g. Paraview) or displays individual images.
-# 
-#     version: 0.1.0.$Revision: 19608 $(alpha)
-# 
-#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/OrientImage
-# 
-#     contributor: Bill Lorensen (GE)
-# 
-#     acknowledgements: This work is part of the National Alliance for Medical Image Computing (NAMIC), funded by the National Institutes of Health through the NIH Roadmap for Medical Research, Grant U54 EB005149.
-#     
-task_name: OrientScalarVolume
-nipype_name: OrientScalarVolume
-nipype_module: nipype.interfaces.slicer.converters
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputVolume1: generic/file
-    # type=file|default=<undefined>: Input volume 1
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputVolume: generic/file
-    # type=file: The oriented volume
-    # type=traitcompound|default=None: The oriented volume
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputVolume1:
-    # type=file|default=<undefined>: Input volume 1
-    outputVolume:
-    # type=file: The oriented volume
-    # type=traitcompound|default=None: The oriented volume
-    orientation:
-    # type=enum|default='Axial'|allowed['AIL','AIR','ALI','ALS','ARI','ARS','ASL','ASR','Axial','Coronal','IAL','IAR','ILA','ILP','IPL','IPR','IRA','IRP','LAI','LAS','LIA','LIP','LPI','LPS','LSA','LSP','PIL','PIR','PLI','PLS','PRI','PRS','PSL','PSR','RAI','RAS','RIA','RIP','RPI','RPS','RSA','RSP','SAL','SAR','SLA','SLP','SPL','SPR','SRA','SRP','Sagittal']: Orientation choices
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/orient_scalar_volume_callables.py b/example-specs/task/nipype_internal/pydra-slicer/orient_scalar_volume_callables.py
deleted file mode 100644
index 6fcfadb2..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/orient_scalar_volume_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in OrientScalarVolume.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/otsu_threshold_image_filter.yaml b/example-specs/task/nipype_internal/pydra-slicer/otsu_threshold_image_filter.yaml
deleted file mode 100644
index 09afdd80..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/otsu_threshold_image_filter.yaml
+++ /dev/null
@@ -1,99 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.slicer.legacy.filtering.OtsuThresholdImageFilter' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Otsu Threshold Image Filter
-# 
-#     category: Legacy.Filtering
-# 
-#     description: This filter creates a binary thresholded image that separates an image into foreground and background components. The filter calculates the optimum threshold separating those two classes so that their combined spread (intra-class variance) is minimal (see http://en.wikipedia.org/wiki/Otsu%27s_method).  Then the filter applies that threshold to the input image using the itkBinaryThresholdImageFilter. The numberOfHistogram bins can be set for the Otsu Calculator. The insideValue and outsideValue can be set for the BinaryThresholdImageFilter.  The filter produces a labeled volume.
-# 
-#     The original reference is:
-# 
-#     N.Otsu, A threshold selection method from gray level histograms, IEEE Trans.Syst.ManCybern.SMC-9,62–66 1979.
-# 
-#     version: 0.1.0.$Revision: 19608 $(alpha)
-# 
-#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/OtsuThresholdImageFilter
-# 
-#     contributor: Bill Lorensen (GE)
-# 
-#     acknowledgements: This command module was derived from Insight/Examples (copyright) Insight Software Consortium
-#     
-task_name: OtsuThresholdImageFilter
-nipype_name: OtsuThresholdImageFilter
-nipype_module: nipype.interfaces.slicer.legacy.filtering
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputVolume: generic/file
-    # type=file|default=<undefined>: Input volume to be filtered
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputVolume: generic/file
-    # type=file: Output filtered
-    # type=traitcompound|default=None: Output filtered
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    insideValue:
-    # type=int|default=0: The value assigned to pixels that are inside the computed threshold
-    outsideValue:
-    # type=int|default=0: The value assigned to pixels that are outside the computed threshold
-    numberOfBins:
-    # type=int|default=0: This is an advanced parameter. The number of bins in the histogram used to model the probability mass function of the two intensity distributions. Small numbers of bins may result in a more conservative threshold. The default should suffice for most applications. Experimentation is the only way to see the effect of varying this parameter.
-    inputVolume:
-    # type=file|default=<undefined>: Input volume to be filtered
-    outputVolume:
-    # type=file: Output filtered
-    # type=traitcompound|default=None: Output filtered
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/otsu_threshold_image_filter_callables.py b/example-specs/task/nipype_internal/pydra-slicer/otsu_threshold_image_filter_callables.py
deleted file mode 100644
index c4725667..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/otsu_threshold_image_filter_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in OtsuThresholdImageFilter.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/otsu_threshold_segmentation.yaml b/example-specs/task/nipype_internal/pydra-slicer/otsu_threshold_segmentation.yaml
deleted file mode 100644
index 87580705..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/otsu_threshold_segmentation.yaml
+++ /dev/null
@@ -1,97 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.slicer.legacy.segmentation.OtsuThresholdSegmentation' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Otsu Threshold Segmentation
-# 
-#     category: Legacy.Segmentation
-# 
-#     description: This filter creates a labeled image from a grayscale image. First, it calculates an optimal threshold that separates the image into foreground and background. This threshold separates those two classes so that their intra-class variance is minimal (see http://en.wikipedia.org/wiki/Otsu%27s_method). Then the filter runs a connected component algorithm to generate unique labels for each connected region of the foreground. Finally, the resulting image is relabeled to provide consecutive numbering.
-# 
-#     version: 1.0
-# 
-#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/OtsuThresholdSegmentation
-# 
-#     contributor: Bill Lorensen (GE)
-# 
-#     acknowledgements: This work is part of the National Alliance for Medical Image Computing (NAMIC), funded by the National Institutes of Health through the NIH Roadmap for Medical Research, Grant U54 EB005149.
-#     
-task_name: OtsuThresholdSegmentation
-nipype_name: OtsuThresholdSegmentation
-nipype_module: nipype.interfaces.slicer.legacy.segmentation
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputVolume: generic/file
-    # type=file|default=<undefined>: Input volume to be segmented
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputVolume: generic/file
-    # type=file: Output filtered
-    # type=traitcompound|default=None: Output filtered
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    brightObjects:
-    # type=bool|default=False: Segmenting bright objects on a dark background or dark objects on a bright background.
-    numberOfBins:
-    # type=int|default=0: This is an advanced parameter. The number of bins in the histogram used to model the probability mass function of the two intensity distributions. Small numbers of bins may result in a more conservative threshold. The default should suffice for most applications. Experimentation is the only way to see the effect of varying this parameter.
-    faceConnected:
-    # type=bool|default=False: This is an advanced parameter. Adjacent voxels are face connected. This affects the connected component algorithm. If this parameter is false, more regions are likely to be identified.
-    minimumObjectSize:
-    # type=int|default=0: Minimum size of object to retain. This parameter can be used to get rid of small regions in noisy images.
-    inputVolume:
-    # type=file|default=<undefined>: Input volume to be segmented
-    outputVolume:
-    # type=file: Output filtered
-    # type=traitcompound|default=None: Output filtered
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/otsu_threshold_segmentation_callables.py b/example-specs/task/nipype_internal/pydra-slicer/otsu_threshold_segmentation_callables.py
deleted file mode 100644
index 6cf5b5c5..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/otsu_threshold_segmentation_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in OtsuThresholdSegmentation.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/pet_standard_uptake_value_computation.yaml b/example-specs/task/nipype_internal/pydra-slicer/pet_standard_uptake_value_computation.yaml
deleted file mode 100644
index 2d23d0ec..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/pet_standard_uptake_value_computation.yaml
+++ /dev/null
@@ -1,111 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.slicer.quantification.petstandarduptakevaluecomputation.PETStandardUptakeValueComputation' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: PET Standard Uptake Value Computation
-# 
-#     category: Quantification
-# 
-#     description: Computes the standardized uptake value based on body weight. Takes an input PET image in DICOM and NRRD format (DICOM header must contain Radiopharmaceutical parameters). Produces a CSV file that contains patientID, studyDate, dose, labelID, suvmin, suvmax, suvmean, labelName for each volume of interest. It also displays some of the information as output strings in the GUI, the CSV file is optional in that case. The CSV file is appended to on each execution of the CLI.
-# 
-#     version: 0.1.0.$Revision: 8595 $(alpha)
-# 
-#     documentation-url: http://www.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/ComputeSUVBodyWeight
-# 
-#     contributor: Wendy Plesniak (SPL, BWH), Nicole Aucoin (SPL, BWH), Ron Kikinis (SPL, BWH)
-# 
-#     acknowledgements: This work is funded by the Harvard Catalyst, and the National Alliance for Medical Image Computing (NAMIC), funded by the National Institutes of Health through the NIH Roadmap for Medical Research, Grant U54 EB005149.
-#     
-task_name: PETStandardUptakeValueComputation
-nipype_name: PETStandardUptakeValueComputation
-nipype_module: nipype.interfaces.slicer.quantification.petstandarduptakevaluecomputation
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    petVolume: generic/file
-    # type=file|default=<undefined>: Input PET volume for SUVbw computation (must be the same volume as pointed to by the DICOM path!).
-    labelMap: generic/file
-    # type=file|default=<undefined>: Input label volume containing the volumes of interest
-    color: generic/file
-    # type=file|default=<undefined>: Color table to to map labels to colors and names
-    petDICOMPath: generic/directory
-    # type=directory|default=<undefined>: Input path to a directory containing a PET volume containing DICOM header information for SUV computation
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    csvFile: generic/file
-    # type=file: A file holding the output SUV values in comma separated lines, one per label. Optional.
-    # type=traitcompound|default=None: A file holding the output SUV values in comma separated lines, one per label. Optional.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    petDICOMPath:
-    # type=directory|default=<undefined>: Input path to a directory containing a PET volume containing DICOM header information for SUV computation
-    petVolume:
-    # type=file|default=<undefined>: Input PET volume for SUVbw computation (must be the same volume as pointed to by the DICOM path!).
-    labelMap:
-    # type=file|default=<undefined>: Input label volume containing the volumes of interest
-    color:
-    # type=file|default=<undefined>: Color table to to map labels to colors and names
-    csvFile:
-    # type=file: A file holding the output SUV values in comma separated lines, one per label. Optional.
-    # type=traitcompound|default=None: A file holding the output SUV values in comma separated lines, one per label. Optional.
-    OutputLabel:
-    # type=str|default='': List of labels for which SUV values were computed
-    OutputLabelValue:
-    # type=str|default='': List of label values for which SUV values were computed
-    SUVMax:
-    # type=str|default='': SUV max for each label
-    SUVMean:
-    # type=str|default='': SUV mean for each label
-    SUVMin:
-    # type=str|default='': SUV minimum for each label
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/pet_standard_uptake_value_computation_callables.py b/example-specs/task/nipype_internal/pydra-slicer/pet_standard_uptake_value_computation_callables.py
deleted file mode 100644
index 6246dbaf..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/pet_standard_uptake_value_computation_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in PETStandardUptakeValueComputation.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/probe_volume_with_model.yaml b/example-specs/task/nipype_internal/pydra-slicer/probe_volume_with_model.yaml
deleted file mode 100644
index a77b44c1..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/probe_volume_with_model.yaml
+++ /dev/null
@@ -1,93 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.slicer.surface.ProbeVolumeWithModel' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Probe Volume With Model
-# 
-#     category: Surface Models
-# 
-#     description: Paint a model by a volume (using vtkProbeFilter).
-# 
-#     version: 0.1.0.$Revision: 1892 $(alpha)
-# 
-#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/ProbeVolumeWithModel
-# 
-#     contributor: Lauren O'Donnell (SPL, BWH)
-# 
-#     acknowledgements: BWH, NCIGT/LMI
-#     
-task_name: ProbeVolumeWithModel
-nipype_name: ProbeVolumeWithModel
-nipype_module: nipype.interfaces.slicer.surface
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    InputVolume: generic/file
-    # type=file|default=<undefined>: Volume to use to 'paint' the model
-    InputModel: generic/file
-    # type=file|default=<undefined>: Input model
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    OutputModel: generic/file
-    # type=file: Output 'painted' model
-    # type=traitcompound|default=None: Output 'painted' model
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    InputVolume:
-    # type=file|default=<undefined>: Volume to use to 'paint' the model
-    InputModel:
-    # type=file|default=<undefined>: Input model
-    OutputModel:
-    # type=file: Output 'painted' model
-    # type=traitcompound|default=None: Output 'painted' model
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/probe_volume_with_model_callables.py b/example-specs/task/nipype_internal/pydra-slicer/probe_volume_with_model_callables.py
deleted file mode 100644
index 25e812cc..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/probe_volume_with_model_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in ProbeVolumeWithModel.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/resample_dti_volume.yaml b/example-specs/task/nipype_internal/pydra-slicer/resample_dti_volume.yaml
deleted file mode 100644
index 4e96f03a..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/resample_dti_volume.yaml
+++ /dev/null
@@ -1,143 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.slicer.diffusion.diffusion.ResampleDTIVolume' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Resample DTI Volume
-# 
-#     category: Diffusion.Diffusion Tensor Images
-# 
-#     description: Resampling an image is a very important task in image analysis. It is especially important in the frame of image registration. This module implements DT image resampling through the use of itk Transforms. The resampling is controlled by the Output Spacing. "Resampling" is performed in space coordinates, not pixel/grid coordinates. It is quite important to ensure that image spacing is properly set on the images involved. The interpolator is required since the mapping from one space to the other will often require evaluation of the intensity of the image at non-grid positions.
-# 
-#     version: 0.1
-# 
-#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/ResampleDTI
-# 
-#     contributor: Francois Budin (UNC)
-# 
-#     acknowledgements: This work is part of the National Alliance for Medical Image Computing (NAMIC), funded by the National Institutes of Health through the NIH Roadmap for Medical Research, Grant U54 EB005149. Information on the National Centers for Biomedical Computing can be obtained from http://nihroadmap.nih.gov/bioinformatics
-#     
-task_name: ResampleDTIVolume
-nipype_name: ResampleDTIVolume
-nipype_module: nipype.interfaces.slicer.diffusion.diffusion
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputVolume: generic/file
-    # type=file|default=<undefined>: Input volume to be resampled
-    Reference: generic/file
-    # type=file|default=<undefined>: Reference Volume (spacing,size,orientation,origin)
-    transformationFile: generic/file
-    # type=file|default=<undefined>: 
-    defField: generic/file
-    # type=file|default=<undefined>: File containing the deformation field (3D vector image containing vectors with 3 components)
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputVolume: generic/file
-    # type=file: Resampled Volume
-    # type=traitcompound|default=None: Resampled Volume
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputVolume:
-    # type=file|default=<undefined>: Input volume to be resampled
-    outputVolume:
-    # type=file: Resampled Volume
-    # type=traitcompound|default=None: Resampled Volume
-    Reference:
-    # type=file|default=<undefined>: Reference Volume (spacing,size,orientation,origin)
-    transformationFile:
-    # type=file|default=<undefined>: 
-    defField:
-    # type=file|default=<undefined>: File containing the deformation field (3D vector image containing vectors with 3 components)
-    hfieldtype:
-    # type=enum|default='displacement'|allowed['displacement','h-Field']: Set if the deformation field is an -Field
-    interpolation:
-    # type=enum|default='linear'|allowed['bs','linear','nn','ws']: Sampling algorithm (linear , nn (nearest neighbor), ws (WindowedSinc), bs (BSpline) )
-    correction:
-    # type=enum|default='zero'|allowed['abs','nearest','none','zero']: Correct the tensors if computed tensor is not semi-definite positive
-    transform_tensor_method:
-    # type=enum|default='PPD'|allowed['FS','PPD']: Chooses between 2 methods to transform the tensors: Finite Strain (FS), faster but less accurate, or Preservation of the Principal Direction (PPD)
-    transform_order:
-    # type=enum|default='input-to-output'|allowed['input-to-output','output-to-input']: Select in what order the transforms are read
-    notbulk:
-    # type=bool|default=False: The transform following the BSpline transform is not set as a bulk transform for the BSpline transform
-    spaceChange:
-    # type=bool|default=False: Space Orientation between transform and image is different (RAS/LPS) (warning: if the transform is a Transform Node in Slicer3, do not select)
-    rotation_point:
-    # type=list|default=[]: Center of rotation (only for rigid and affine transforms)
-    centered_transform:
-    # type=bool|default=False: Set the center of the transformation to the center of the input image (only for rigid and affine transforms)
-    image_center:
-    # type=enum|default='input'|allowed['input','output']: Image to use to center the transform (used only if 'Centered Transform' is selected)
-    Inverse_ITK_Transformation:
-    # type=bool|default=False: Inverse the transformation before applying it from output image to input image (only for rigid and affine transforms)
-    spacing:
-    # type=inputmultiobject|default=[]: Spacing along each dimension (0 means use input spacing)
-    size:
-    # type=inputmultiobject|default=[]: Size along each dimension (0 means use input size)
-    origin:
-    # type=list|default=[]: Origin of the output Image
-    direction_matrix:
-    # type=inputmultiobject|default=[]: 9 parameters of the direction matrix by rows (ijk to LPS if LPS transform, ijk to RAS if RAS transform)
-    number_of_thread:
-    # type=int|default=0: Number of thread used to compute the output image
-    default_pixel_value:
-    # type=float|default=0.0: Default pixel value for samples falling outside of the input region
-    window_function:
-    # type=enum|default='h'|allowed['b','c','h','l','w']: Window Function , h = Hamming , c = Cosine , w = Welch , l = Lanczos , b = Blackman
-    spline_order:
-    # type=int|default=0: Spline Order (Spline order may be from 0 to 5)
-    transform_matrix:
-    # type=inputmultiobject|default=[]: 12 parameters of the transform matrix by rows ( --last 3 being translation-- )
-    transform:
-    # type=enum|default='rt'|allowed['a','rt']: Transform algorithm, rt = Rigid Transform, a = Affine Transform
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/resample_dti_volume_callables.py b/example-specs/task/nipype_internal/pydra-slicer/resample_dti_volume_callables.py
deleted file mode 100644
index 6821cf16..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/resample_dti_volume_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in ResampleDTIVolume.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/resample_scalar_vector_dwi_volume.yaml b/example-specs/task/nipype_internal/pydra-slicer/resample_scalar_vector_dwi_volume.yaml
deleted file mode 100644
index f13840a1..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/resample_scalar_vector_dwi_volume.yaml
+++ /dev/null
@@ -1,143 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.slicer.filtering.resamplescalarvectordwivolume.ResampleScalarVectorDWIVolume' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Resample Scalar/Vector/DWI Volume
-# 
-#     category: Filtering
-# 
-#     description: This module implements image and vector-image resampling through  the use of itk Transforms.It can also handle diffusion weighted MRI image resampling. "Resampling" is performed in space coordinates, not pixel/grid coordinates. It is quite important to ensure that image spacing is properly set on the images involved. The interpolator is required since the mapping from one space to the other will often require evaluation of the intensity of the image at non-grid positions.
-# 
-#     Warning: To resample DWMR Images, use nrrd input and output files.
-# 
-#     Warning: Do not use to resample Diffusion Tensor Images, tensors would  not be reoriented
-# 
-#     version: 0.1
-# 
-#     documentation-url: http://www.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/ResampleScalarVectorDWIVolume
-# 
-#     contributor: Francois Budin (UNC)
-# 
-#     acknowledgements: This work is part of the National Alliance for Medical Image Computing (NAMIC), funded by the National Institutes of Health through the NIH Roadmap for Medical Research, Grant U54 EB005149. Information on the National Centers for Biomedical Computing can be obtained from http://nihroadmap.nih.gov/bioinformatics
-#     
-task_name: ResampleScalarVectorDWIVolume
-nipype_name: ResampleScalarVectorDWIVolume
-nipype_module: nipype.interfaces.slicer.filtering.resamplescalarvectordwivolume
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputVolume: generic/file
-    # type=file|default=<undefined>: Input Volume to be resampled
-    Reference: generic/file
-    # type=file|default=<undefined>: Reference Volume (spacing,size,orientation,origin)
-    transformationFile: generic/file
-    # type=file|default=<undefined>: 
-    defField: generic/file
-    # type=file|default=<undefined>: File containing the deformation field (3D vector image containing vectors with 3 components)
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputVolume: generic/file
-    # type=file: Resampled Volume
-    # type=traitcompound|default=None: Resampled Volume
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputVolume:
-    # type=file|default=<undefined>: Input Volume to be resampled
-    outputVolume:
-    # type=file: Resampled Volume
-    # type=traitcompound|default=None: Resampled Volume
-    Reference:
-    # type=file|default=<undefined>: Reference Volume (spacing,size,orientation,origin)
-    transformationFile:
-    # type=file|default=<undefined>: 
-    defField:
-    # type=file|default=<undefined>: File containing the deformation field (3D vector image containing vectors with 3 components)
-    hfieldtype:
-    # type=enum|default='displacement'|allowed['displacement','h-Field']: Set if the deformation field is an h-Field
-    interpolation:
-    # type=enum|default='linear'|allowed['bs','linear','nn','ws']: Sampling algorithm (linear or nn (nearest neighbor), ws (WindowedSinc), bs (BSpline) )
-    transform_order:
-    # type=enum|default='input-to-output'|allowed['input-to-output','output-to-input']: Select in what order the transforms are read
-    notbulk:
-    # type=bool|default=False: The transform following the BSpline transform is not set as a bulk transform for the BSpline transform
-    spaceChange:
-    # type=bool|default=False: Space Orientation between transform and image is different (RAS/LPS) (warning: if the transform is a Transform Node in Slicer3, do not select)
-    rotation_point:
-    # type=list|default=[]: Rotation Point in case of rotation around a point (otherwise useless)
-    centered_transform:
-    # type=bool|default=False: Set the center of the transformation to the center of the input image
-    image_center:
-    # type=enum|default='input'|allowed['input','output']: Image to use to center the transform (used only if 'Centered Transform' is selected)
-    Inverse_ITK_Transformation:
-    # type=bool|default=False: Inverse the transformation before applying it from output image to input image
-    spacing:
-    # type=inputmultiobject|default=[]: Spacing along each dimension (0 means use input spacing)
-    size:
-    # type=inputmultiobject|default=[]: Size along each dimension (0 means use input size)
-    origin:
-    # type=list|default=[]: Origin of the output Image
-    direction_matrix:
-    # type=inputmultiobject|default=[]: 9 parameters of the direction matrix by rows (ijk to LPS if LPS transform, ijk to RAS if RAS transform)
-    number_of_thread:
-    # type=int|default=0: Number of thread used to compute the output image
-    default_pixel_value:
-    # type=float|default=0.0: Default pixel value for samples falling outside of the input region
-    window_function:
-    # type=enum|default='h'|allowed['b','c','h','l','w']: Window Function , h = Hamming , c = Cosine , w = Welch , l = Lanczos , b = Blackman
-    spline_order:
-    # type=int|default=0: Spline Order
-    transform_matrix:
-    # type=inputmultiobject|default=[]: 12 parameters of the transform matrix by rows ( --last 3 being translation-- )
-    transform:
-    # type=enum|default='rt'|allowed['a','rt']: Transform algorithm, rt = Rigid Transform, a = Affine Transform
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/resample_scalar_vector_dwi_volume_callables.py b/example-specs/task/nipype_internal/pydra-slicer/resample_scalar_vector_dwi_volume_callables.py
deleted file mode 100644
index 3c6b487b..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/resample_scalar_vector_dwi_volume_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in ResampleScalarVectorDWIVolume.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/resample_scalar_volume.yaml b/example-specs/task/nipype_internal/pydra-slicer/resample_scalar_volume.yaml
deleted file mode 100644
index a6590101..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/resample_scalar_volume.yaml
+++ /dev/null
@@ -1,93 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.slicer.legacy.filtering.ResampleScalarVolume' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Resample Scalar Volume
-# 
-#     category: Legacy.Filtering
-# 
-#     description: Resampling an image is an important task in image analysis. It is especially important in the frame of image registration. This module implements image resampling through the use of itk Transforms. This module uses an Identity Transform. The resampling is controlled by the Output Spacing. "Resampling" is performed in space coordinates, not pixel/grid coordinates. It is quite important to ensure that image spacing is properly set on the images involved. The interpolator is required since the mapping from one space to the other will often require evaluation of the intensity of the image at non-grid positions. Several interpolators are available: linear, nearest neighbor, bspline and five flavors of sinc. The sinc interpolators, although more precise, are much slower than the linear and nearest neighbor interpolator. To resample label volumnes, nearest neighbor interpolation should be used exclusively.
-# 
-#     version: 0.1.0.$Revision: 20594 $(alpha)
-# 
-#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/ResampleVolume
-# 
-#     contributor: Bill Lorensen (GE)
-# 
-#     acknowledgements: This work is part of the National Alliance for Medical Image Computing (NAMIC), funded by the National Institutes of Health through the NIH Roadmap for Medical Research, Grant U54 EB005149.
-#     
-task_name: ResampleScalarVolume
-nipype_name: ResampleScalarVolume
-nipype_module: nipype.interfaces.slicer.legacy.filtering
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    InputVolume: generic/file
-    # type=file|default=<undefined>: Input volume to be resampled
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    OutputVolume: generic/file
-    # type=file: Resampled Volume
-    # type=traitcompound|default=None: Resampled Volume
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    spacing:
-    # type=inputmultiobject|default=[]: Spacing along each dimension (0 means use input spacing)
-    interpolation:
-    # type=enum|default='linear'|allowed['blackman','bspline','cosine','hamming','lanczos','linear','nearestNeighbor','welch']: Sampling algorithm (linear, nearest neighbor, bspline(cubic)  or windowed sinc). There are several sinc algorithms available as described in the following publication: Erik H. W. Meijering, Wiro J. Niessen, Josien P. W. Pluim, Max A. Viergever: Quantitative Comparison of Sinc-Approximating Kernels for Medical Image Interpolation. MICCAI 1999, pp. 210-217. Each window has a radius of 3;
-    InputVolume:
-    # type=file|default=<undefined>: Input volume to be resampled
-    OutputVolume:
-    # type=file: Resampled Volume
-    # type=traitcompound|default=None: Resampled Volume
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/resample_scalar_volume_callables.py b/example-specs/task/nipype_internal/pydra-slicer/resample_scalar_volume_callables.py
deleted file mode 100644
index 7615cd03..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/resample_scalar_volume_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in ResampleScalarVolume.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/rigid_registration.yaml b/example-specs/task/nipype_internal/pydra-slicer/rigid_registration.yaml
deleted file mode 100644
index d2db437c..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/rigid_registration.yaml
+++ /dev/null
@@ -1,129 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.slicer.legacy.registration.RigidRegistration' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Rigid Registration
-# 
-#     category: Legacy.Registration
-# 
-#     description: Registers two images together using a rigid transform and mutual information.
-# 
-#     This module was originally distributed as "Linear registration" but has been renamed to eliminate confusion with the "Affine registration" module.
-# 
-#     This module is often used to align images of different subjects or images of the same subject from different modalities.
-# 
-#     This module can smooth images prior to registration to mitigate noise and improve convergence. Many of the registration parameters require a working knowledge of the algorithm although the default parameters are sufficient for many registration tasks.
-# 
-# 
-# 
-#     version: 0.1.0.$Revision: 19608 $(alpha)
-# 
-#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/RigidRegistration
-# 
-#     contributor: Daniel Blezek (GE)
-# 
-#     acknowledgements: This module was developed by Daniel Blezek while at GE Research with contributions from Jim Miller.
-# 
-#     This work is part of the National Alliance for Medical Image Computing (NAMIC), funded by the National Institutes of Health through the NIH Roadmap for Medical Research, Grant U54 EB005149.
-#     
-task_name: RigidRegistration
-nipype_name: RigidRegistration
-nipype_module: nipype.interfaces.slicer.legacy.registration
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    initialtransform: generic/file
-    # type=file|default=<undefined>: Initial transform for aligning the fixed and moving image. Maps positions in the fixed coordinate frame to positions in the moving coordinate frame. Optional.
-    FixedImageFileName: generic/file
-    # type=file|default=<undefined>: Fixed image to which to register
-    MovingImageFileName: generic/file
-    # type=file|default=<undefined>: Moving image
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputtransform: generic/file
-    # type=file: Transform calculated that aligns the fixed and moving image. Maps positions in the fixed coordinate frame to the moving coordinate frame. Optional (specify an output transform or an output volume or both).
-    # type=traitcompound|default=None: Transform calculated that aligns the fixed and moving image. Maps positions in the fixed coordinate frame to the moving coordinate frame. Optional (specify an output transform or an output volume or both).
-    resampledmovingfilename: generic/file
-    # type=file: Resampled moving image to the fixed image coordinate frame. Optional (specify an output transform or an output volume or both).
-    # type=traitcompound|default=None: Resampled moving image to the fixed image coordinate frame. Optional (specify an output transform or an output volume or both).
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    fixedsmoothingfactor:
-    # type=int|default=0: Amount of smoothing applied to fixed image prior to registration. Default is 0 (none). Range is 0-5 (unitless). Consider smoothing the input data if there is considerable amounts of noise or the noise pattern in the fixed and moving images is very different.
-    movingsmoothingfactor:
-    # type=int|default=0: Amount of smoothing applied to moving image prior to registration. Default is 0 (none). Range is 0-5 (unitless). Consider smoothing the input data if there is considerable amounts of noise or the noise pattern in the fixed and moving images is very different.
-    testingmode:
-    # type=bool|default=False: Enable testing mode. Input transform will be used to construct floating image. The floating image will be ignored if passed.
-    histogrambins:
-    # type=int|default=0: Number of histogram bins to use for Mattes Mutual Information. Reduce the number of bins if a registration fails. If the number of bins is too large, the estimated PDFs will be a field of impulses and will inhibit reliable registration estimation.
-    spatialsamples:
-    # type=int|default=0: Number of spatial samples to use in estimating Mattes Mutual Information. Larger values yield more accurate PDFs and improved registration quality.
-    iterations:
-    # type=inputmultiobject|default=[]: Comma separated list of iterations. Must have the same number of elements as the learning rate.
-    learningrate:
-    # type=inputmultiobject|default=[]: Comma separated list of learning rates. Learning rate is a scale factor on the gradient of the registration objective function (gradient with respect to the parameters of the transformation) used to update the parameters of the transformation during optimization. Smaller values cause the optimizer to take smaller steps through the parameter space. Larger values are typically used early in the registration process to take large jumps in parameter space followed by smaller values to home in on the optimum value of the registration objective function. Default is: 0.01, 0.005, 0.0005, 0.0002. Must have the same number of elements as iterations.
-    translationscale:
-    # type=float|default=0.0: Relative scale of translations to rotations, i.e. a value of 100 means 10mm = 1 degree. (Actual scale used 1/(TranslationScale^2)). This parameter is used to 'weight' or 'standardized' the transform parameters and their effect on the registration objective function.
-    initialtransform:
-    # type=file|default=<undefined>: Initial transform for aligning the fixed and moving image. Maps positions in the fixed coordinate frame to positions in the moving coordinate frame. Optional.
-    FixedImageFileName:
-    # type=file|default=<undefined>: Fixed image to which to register
-    MovingImageFileName:
-    # type=file|default=<undefined>: Moving image
-    outputtransform:
-    # type=file: Transform calculated that aligns the fixed and moving image. Maps positions in the fixed coordinate frame to the moving coordinate frame. Optional (specify an output transform or an output volume or both).
-    # type=traitcompound|default=None: Transform calculated that aligns the fixed and moving image. Maps positions in the fixed coordinate frame to the moving coordinate frame. Optional (specify an output transform or an output volume or both).
-    resampledmovingfilename:
-    # type=file: Resampled moving image to the fixed image coordinate frame. Optional (specify an output transform or an output volume or both).
-    # type=traitcompound|default=None: Resampled moving image to the fixed image coordinate frame. Optional (specify an output transform or an output volume or both).
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/rigid_registration_callables.py b/example-specs/task/nipype_internal/pydra-slicer/rigid_registration_callables.py
deleted file mode 100644
index 6f0d82d1..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/rigid_registration_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in RigidRegistration.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/robust_statistics_segmenter.yaml b/example-specs/task/nipype_internal/pydra-slicer/robust_statistics_segmenter.yaml
deleted file mode 100644
index 4d6701b5..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/robust_statistics_segmenter.yaml
+++ /dev/null
@@ -1,103 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.slicer.segmentation.specialized.RobustStatisticsSegmenter' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Robust Statistics Segmenter
-# 
-#     category: Segmentation.Specialized
-# 
-#     description: Active contour segmentation using robust statistic.
-# 
-#     version: 1.0
-# 
-#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/RobustStatisticsSegmenter
-# 
-#     contributor: Yi Gao (gatech), Allen Tannenbaum (gatech), Ron Kikinis (SPL, BWH)
-# 
-#     acknowledgements: This work is part of the National Alliance for Medical Image Computing (NAMIC), funded by the National Institutes of Health
-#     
-task_name: RobustStatisticsSegmenter
-nipype_name: RobustStatisticsSegmenter
-nipype_module: nipype.interfaces.slicer.segmentation.specialized
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    originalImageFileName: generic/file
-    # type=file|default=<undefined>: Original image to be segmented
-    labelImageFileName: generic/file
-    # type=file|default=<undefined>: Label image for initialization
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    segmentedImageFileName: generic/file
-    # type=file: Segmented image
-    # type=traitcompound|default=None: Segmented image
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    expectedVolume:
-    # type=float|default=0.0: The approximate volume of the object, in mL.
-    intensityHomogeneity:
-    # type=float|default=0.0: What is the homogeneity of intensity within the object? Given constant intensity at 1.0 score and extreme fluctuating intensity at 0.
-    curvatureWeight:
-    # type=float|default=0.0: Given sphere 1.0 score and extreme rough boundary/surface 0 score, what is the expected smoothness of the object?
-    labelValue:
-    # type=int|default=0: Label value of the output image
-    maxRunningTime:
-    # type=float|default=0.0: The program will stop if this time is reached.
-    originalImageFileName:
-    # type=file|default=<undefined>: Original image to be segmented
-    labelImageFileName:
-    # type=file|default=<undefined>: Label image for initialization
-    segmentedImageFileName:
-    # type=file: Segmented image
-    # type=traitcompound|default=None: Segmented image
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/robust_statistics_segmenter_callables.py b/example-specs/task/nipype_internal/pydra-slicer/robust_statistics_segmenter_callables.py
deleted file mode 100644
index b76d8d39..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/robust_statistics_segmenter_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in RobustStatisticsSegmenter.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/simple_region_growing_segmentation.yaml b/example-specs/task/nipype_internal/pydra-slicer/simple_region_growing_segmentation.yaml
deleted file mode 100644
index d5c7aab2..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/simple_region_growing_segmentation.yaml
+++ /dev/null
@@ -1,103 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.slicer.segmentation.simpleregiongrowingsegmentation.SimpleRegionGrowingSegmentation' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Simple Region Growing Segmentation
-# 
-#     category: Segmentation
-# 
-#     description: A simple region growing segmentation algorithm based on intensity statistics. To create a list of fiducials (Seeds) for this algorithm, click on the tool bar icon of an arrow pointing to a starburst fiducial to enter the 'place a new object mode' and then use the fiducials module. This module uses the Slicer Command Line Interface (CLI) and the ITK filters CurvatureFlowImageFilter and ConfidenceConnectedImageFilter.
-# 
-#     version: 0.1.0.$Revision: 19904 $(alpha)
-# 
-#     documentation-url: http://www.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/SimpleRegionGrowingSegmentation
-# 
-#     contributor: Jim Miller (GE)
-# 
-#     acknowledgements: This command module was derived from Insight/Examples (copyright) Insight Software Consortium
-#     
-task_name: SimpleRegionGrowingSegmentation
-nipype_name: SimpleRegionGrowingSegmentation
-nipype_module: nipype.interfaces.slicer.segmentation.simpleregiongrowingsegmentation
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputVolume: generic/file
-    # type=file|default=<undefined>: Input volume to be filtered
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputVolume: generic/file
-    # type=file: Output filtered
-    # type=traitcompound|default=None: Output filtered
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    smoothingIterations:
-    # type=int|default=0: Number of smoothing iterations
-    timestep:
-    # type=float|default=0.0: Timestep for curvature flow
-    iterations:
-    # type=int|default=0: Number of iterations of region growing
-    multiplier:
-    # type=float|default=0.0: Number of standard deviations to include in intensity model
-    neighborhood:
-    # type=int|default=0: The radius of the neighborhood over which to calculate intensity model
-    labelvalue:
-    # type=int|default=0: The integer value (0-255) to use for the segmentation results. This will determine the color of the segmentation that will be generated by the Region growing algorithm
-    seed:
-    # type=inputmultiobject|default=[]: Seed point(s) for region growing
-    inputVolume:
-    # type=file|default=<undefined>: Input volume to be filtered
-    outputVolume:
-    # type=file: Output filtered
-    # type=traitcompound|default=None: Output filtered
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/simple_region_growing_segmentation_callables.py b/example-specs/task/nipype_internal/pydra-slicer/simple_region_growing_segmentation_callables.py
deleted file mode 100644
index e90f6103..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/simple_region_growing_segmentation_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in SimpleRegionGrowingSegmentation.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/subtract_scalar_volumes.yaml b/example-specs/task/nipype_internal/pydra-slicer/subtract_scalar_volumes.yaml
deleted file mode 100644
index 62b60dda..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/subtract_scalar_volumes.yaml
+++ /dev/null
@@ -1,95 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.slicer.filtering.arithmetic.SubtractScalarVolumes' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Subtract Scalar Volumes
-# 
-#     category: Filtering.Arithmetic
-# 
-#     description: Subtracts two images. Although all image types are supported on input, only signed types are produced. The two images do not have to have the same dimensions.
-# 
-#     version: 0.1.0.$Revision: 19608 $(alpha)
-# 
-#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/Subtract
-# 
-#     contributor: Bill Lorensen (GE)
-# 
-#     acknowledgements: This work is part of the National Alliance for Medical Image Computing (NAMIC), funded by the National Institutes of Health through the NIH Roadmap for Medical Research, Grant U54 EB005149.
-#     
-task_name: SubtractScalarVolumes
-nipype_name: SubtractScalarVolumes
-nipype_module: nipype.interfaces.slicer.filtering.arithmetic
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputVolume1: generic/file
-    # type=file|default=<undefined>: Input volume 1
-    inputVolume2: generic/file
-    # type=file|default=<undefined>: Input volume 2
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputVolume: generic/file
-    # type=file: Volume1 - Volume2
-    # type=traitcompound|default=None: Volume1 - Volume2
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    inputVolume1:
-    # type=file|default=<undefined>: Input volume 1
-    inputVolume2:
-    # type=file|default=<undefined>: Input volume 2
-    outputVolume:
-    # type=file: Volume1 - Volume2
-    # type=traitcompound|default=None: Volume1 - Volume2
-    order:
-    # type=enum|default='0'|allowed['0','1','2','3']: Interpolation order if two images are in different coordinate frames or have different sampling.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/subtract_scalar_volumes_callables.py b/example-specs/task/nipype_internal/pydra-slicer/subtract_scalar_volumes_callables.py
deleted file mode 100644
index 718dd062..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/subtract_scalar_volumes_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in SubtractScalarVolumes.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/threshold_scalar_volume.yaml b/example-specs/task/nipype_internal/pydra-slicer/threshold_scalar_volume.yaml
deleted file mode 100644
index 07ebd4a3..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/threshold_scalar_volume.yaml
+++ /dev/null
@@ -1,99 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.slicer.filtering.thresholdscalarvolume.ThresholdScalarVolume' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Threshold Scalar Volume
-# 
-#     category: Filtering
-# 
-#     description: <p>Threshold an image.</p><p>Set image values to a user-specified outside value if they are below, above, or between simple threshold values.</p><p>ThresholdAbove: The values greater than or equal to the threshold value are set to OutsideValue.</p><p>ThresholdBelow: The values less than or equal to the threshold value are set to OutsideValue.</p><p>ThresholdOutside: The values outside the range Lower-Upper are set to OutsideValue.</p><p>Although all image types are supported on input, only signed types are produced.</p><p>
-# 
-#     version: 0.1.0.$Revision: 2104 $(alpha)
-# 
-#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/Threshold
-# 
-#     contributor: Nicole Aucoin (SPL, BWH), Ron Kikinis (SPL, BWH)
-# 
-#     acknowledgements: This work is part of the National Alliance for Medical Image Computing (NAMIC), funded by the National Institutes of Health through the NIH Roadmap for Medical Research, Grant U54 EB005149.
-#     
-task_name: ThresholdScalarVolume
-nipype_name: ThresholdScalarVolume
-nipype_module: nipype.interfaces.slicer.filtering.thresholdscalarvolume
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    InputVolume: generic/file
-    # type=file|default=<undefined>: Input volume
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    OutputVolume: generic/file
-    # type=file: Thresholded input volume
-    # type=traitcompound|default=None: Thresholded input volume
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    InputVolume:
-    # type=file|default=<undefined>: Input volume
-    OutputVolume:
-    # type=file: Thresholded input volume
-    # type=traitcompound|default=None: Thresholded input volume
-    threshold:
-    # type=int|default=0: Threshold value
-    lower:
-    # type=int|default=0: Lower threshold value
-    upper:
-    # type=int|default=0: Upper threshold value
-    outsidevalue:
-    # type=int|default=0: Set the voxels to this value if they fall outside the threshold range
-    thresholdtype:
-    # type=enum|default='Below'|allowed['Above','Below','Outside']: What kind of threshold to perform. If Outside is selected, uses Upper and Lower values. If Below is selected, uses the ThresholdValue, if Above is selected, uses the ThresholdValue.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/threshold_scalar_volume_callables.py b/example-specs/task/nipype_internal/pydra-slicer/threshold_scalar_volume_callables.py
deleted file mode 100644
index 883d5b5e..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/threshold_scalar_volume_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in ThresholdScalarVolume.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/tractography_label_map_seeding.yaml b/example-specs/task/nipype_internal/pydra-slicer/tractography_label_map_seeding.yaml
deleted file mode 100644
index fcc9a4ed..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/tractography_label_map_seeding.yaml
+++ /dev/null
@@ -1,127 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.slicer.diffusion.diffusion.TractographyLabelMapSeeding' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Tractography Label Map Seeding
-# 
-#     category: Diffusion.Diffusion Tensor Images
-# 
-#     description: Seed tracts on a Diffusion Tensor Image (DT) from a label map
-# 
-#     version: 0.1.0.$Revision: 1892 $(alpha)
-# 
-#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/Seeding
-# 
-#     license: slicer3
-# 
-#     contributor: Raul San Jose (SPL, BWH), Demian Wassermann (SPL, BWH)
-# 
-#     acknowledgements: Laboratory of Mathematics in Imaging. This work is part of the National Alliance for Medical Image Computing (NAMIC), funded by the National Institutes of Health through the NIH Roadmap for Medical Research, Grant U54 EB005149.
-#     
-task_name: TractographyLabelMapSeeding
-nipype_name: TractographyLabelMapSeeding
-nipype_module: nipype.interfaces.slicer.diffusion.diffusion
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    InputVolume: generic/file
-    # type=file|default=<undefined>: Input DTI volume
-    inputroi: generic/file
-    # type=file|default=<undefined>: Label map with seeding ROIs
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    OutputFibers: generic/file
-    # type=file: Tractography result
-    # type=traitcompound|default=None: Tractography result
-    outputdirectory: generic/directory
-    # type=directory: Directory in which to save fiber(s)
-    # type=traitcompound|default=None: Directory in which to save fiber(s)
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    InputVolume:
-    # type=file|default=<undefined>: Input DTI volume
-    inputroi:
-    # type=file|default=<undefined>: Label map with seeding ROIs
-    OutputFibers:
-    # type=file: Tractography result
-    # type=traitcompound|default=None: Tractography result
-    useindexspace:
-    # type=bool|default=False: Seed at IJK voxel grid
-    seedspacing:
-    # type=float|default=0.0: Spacing (in mm) between seed points, only matters if use Use Index Space is off
-    randomgrid:
-    # type=bool|default=False: Enable random placing of seeds
-    clthreshold:
-    # type=float|default=0.0: Minimum Linear Measure for the seeding to start.
-    minimumlength:
-    # type=float|default=0.0: Minimum length of the fibers (in mm)
-    maximumlength:
-    # type=float|default=0.0: Maximum length of fibers (in mm)
-    stoppingmode:
-    # type=enum|default='LinearMeasure'|allowed['FractionalAnisotropy','LinearMeasure']: Tensor measurement used to stop the tractography
-    stoppingvalue:
-    # type=float|default=0.0: Tractography will stop when the stopping measurement drops below this value
-    stoppingcurvature:
-    # type=float|default=0.0: Tractography will stop if radius of curvature becomes smaller than this number units are degrees per mm
-    integrationsteplength:
-    # type=float|default=0.0: Distance between points on the same fiber in mm
-    label:
-    # type=int|default=0: Label value that defines seeding region.
-    writetofile:
-    # type=bool|default=False: Write fibers to disk or create in the scene?
-    outputdirectory:
-    # type=directory: Directory in which to save fiber(s)
-    # type=traitcompound|default=None: Directory in which to save fiber(s)
-    name:
-    # type=str|default='': Name to use for fiber files
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/tractography_label_map_seeding_callables.py b/example-specs/task/nipype_internal/pydra-slicer/tractography_label_map_seeding_callables.py
deleted file mode 100644
index 31cacc7a..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/tractography_label_map_seeding_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in TractographyLabelMapSeeding.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/vbrains_demon_warp.yaml b/example-specs/task/nipype_internal/pydra-slicer/vbrains_demon_warp.yaml
deleted file mode 100644
index 28ad182e..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/vbrains_demon_warp.yaml
+++ /dev/null
@@ -1,190 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.slicer.registration.specialized.VBRAINSDemonWarp' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Vector Demon Registration (BRAINS)
-# 
-#     category: Registration.Specialized
-# 
-#     description:
-#         This program finds a deformation field to warp a moving image onto a fixed image.  The images must be of the same signal kind, and contain an image of the same kind of object.  This program uses the Thirion Demons warp software in ITK, the Insight Toolkit.  Additional information is available at: http://www.nitrc.org/projects/brainsdemonwarp.
-# 
-# 
-# 
-#     version: 3.0.0
-# 
-#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Modules:BRAINSDemonWarp
-# 
-#     license: https://www.nitrc.org/svn/brains/BuildScripts/trunk/License.txt
-# 
-#     contributor: This tool was developed by Hans J. Johnson and Greg Harris.
-# 
-#     acknowledgements: The development of this tool was supported by funding from grants NS050568 and NS40068 from the National Institute of Neurological Disorders and Stroke and grants MH31593, MH40856, from the National Institute of Mental Health.
-#     
-task_name: VBRAINSDemonWarp
-nipype_name: VBRAINSDemonWarp
-nipype_module: nipype.interfaces.slicer.registration.specialized
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    movingVolume: generic/file+list-of
-    # type=inputmultiobject|default=[]: Required: input moving image
-    fixedVolume: generic/file+list-of
-    # type=inputmultiobject|default=[]: Required: input fixed (target) image
-    initializeWithDisplacementField: generic/file
-    # type=file|default=<undefined>: Initial deformation field vector image file name
-    initializeWithTransform: generic/file
-    # type=file|default=<undefined>: Initial Transform filename
-    fixedBinaryVolume: generic/file
-    # type=file|default=<undefined>: Mask filename for desired region of interest in the Fixed image.
-    movingBinaryVolume: generic/file
-    # type=file|default=<undefined>: Mask filename for desired region of interest in the Moving image.
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputVolume: generic/file
-    # type=file: Required: output resampled moving image (will have the same physical space as the fixedVolume).
-    # type=traitcompound|default=None: Required: output resampled moving image (will have the same physical space as the fixedVolume).
-    outputDisplacementFieldVolume: generic/file
-    # type=file: Output deformation field vector image (will have the same physical space as the fixedVolume).
-    # type=traitcompound|default=None: Output deformation field vector image (will have the same physical space as the fixedVolume).
-    outputCheckerboardVolume: generic/file
-    # type=file: Genete a checkerboard image volume between the fixedVolume and the deformed movingVolume.
-    # type=traitcompound|default=None: Genete a checkerboard image volume between the fixedVolume and the deformed movingVolume.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    movingVolume:
-    # type=inputmultiobject|default=[]: Required: input moving image
-    fixedVolume:
-    # type=inputmultiobject|default=[]: Required: input fixed (target) image
-    inputPixelType:
-    # type=enum|default='float'|allowed['float','int','short','uchar','ushort']: Input volumes will be typecast to this format: float|short|ushort|int|uchar
-    outputVolume:
-    # type=file: Required: output resampled moving image (will have the same physical space as the fixedVolume).
-    # type=traitcompound|default=None: Required: output resampled moving image (will have the same physical space as the fixedVolume).
-    outputDisplacementFieldVolume:
-    # type=file: Output deformation field vector image (will have the same physical space as the fixedVolume).
-    # type=traitcompound|default=None: Output deformation field vector image (will have the same physical space as the fixedVolume).
-    outputPixelType:
-    # type=enum|default='float'|allowed['float','int','short','uchar','ushort']: outputVolume will be typecast to this format: float|short|ushort|int|uchar
-    interpolationMode:
-    # type=enum|default='NearestNeighbor'|allowed['BSpline','Blackman','Cosine','Hamming','Lanczos','Linear','NearestNeighbor','ResampleInPlace','Welch','WindowedSinc']: Type of interpolation to be used when applying transform to moving volume.  Options are Linear, ResampleInPlace, NearestNeighbor, BSpline, or WindowedSinc
-    registrationFilterType:
-    # type=enum|default='Demons'|allowed['Demons','Diffeomorphic','FastSymmetricForces','LogDemons','SymmetricLogDemons']: Registration Filter Type: Demons|FastSymmetricForces|Diffeomorphic|LogDemons|SymmetricLogDemons
-    smoothDisplacementFieldSigma:
-    # type=float|default=0.0: A gaussian smoothing value to be applied to the deformation field at each iteration.
-    numberOfPyramidLevels:
-    # type=int|default=0: Number of image pyramid levels to use in the multi-resolution registration.
-    minimumFixedPyramid:
-    # type=inputmultiobject|default=[]: The shrink factor for the first level of the fixed image pyramid. (i.e. start at 1/16 scale, then 1/8, then 1/4, then 1/2, and finally full scale)
-    minimumMovingPyramid:
-    # type=inputmultiobject|default=[]: The shrink factor for the first level of the moving image pyramid. (i.e. start at 1/16 scale, then 1/8, then 1/4, then 1/2, and finally full scale)
-    arrayOfPyramidLevelIterations:
-    # type=inputmultiobject|default=[]: The number of iterations for each pyramid level
-    histogramMatch:
-    # type=bool|default=False: Histogram Match the input images.  This is suitable for images of the same modality that may have different absolute scales, but the same overall intensity profile.
-    numberOfHistogramBins:
-    # type=int|default=0: The number of histogram levels
-    numberOfMatchPoints:
-    # type=int|default=0: The number of match points for histrogramMatch
-    medianFilterSize:
-    # type=inputmultiobject|default=[]: Median filter radius in all 3 directions.  When images have a lot of salt and pepper noise, this step can improve the registration.
-    initializeWithDisplacementField:
-    # type=file|default=<undefined>: Initial deformation field vector image file name
-    initializeWithTransform:
-    # type=file|default=<undefined>: Initial Transform filename
-    makeBOBF:
-    # type=bool|default=False: Flag to make Brain-Only Background-Filled versions of the input and target volumes.
-    fixedBinaryVolume:
-    # type=file|default=<undefined>: Mask filename for desired region of interest in the Fixed image.
-    movingBinaryVolume:
-    # type=file|default=<undefined>: Mask filename for desired region of interest in the Moving image.
-    lowerThresholdForBOBF:
-    # type=int|default=0: Lower threshold for performing BOBF
-    upperThresholdForBOBF:
-    # type=int|default=0: Upper threshold for performing BOBF
-    backgroundFillValue:
-    # type=int|default=0: Replacement value to overwrite background when performing BOBF
-    seedForBOBF:
-    # type=inputmultiobject|default=[]: coordinates in all 3 directions for Seed when performing BOBF
-    neighborhoodForBOBF:
-    # type=inputmultiobject|default=[]: neighborhood in all 3 directions to be included when performing BOBF
-    outputDisplacementFieldPrefix:
-    # type=str|default='': Displacement field filename prefix for writing separate x, y, and z component images
-    outputCheckerboardVolume:
-    # type=file: Genete a checkerboard image volume between the fixedVolume and the deformed movingVolume.
-    # type=traitcompound|default=None: Genete a checkerboard image volume between the fixedVolume and the deformed movingVolume.
-    checkerboardPatternSubdivisions:
-    # type=inputmultiobject|default=[]: Number of Checkerboard subdivisions in all 3 directions
-    outputNormalized:
-    # type=bool|default=False: Flag to warp and write the normalized images to output.  In normalized images the image values are fit-scaled to be between 0 and the maximum storage type value.
-    outputDebug:
-    # type=bool|default=False: Flag to write debugging images after each step.
-    weightFactors:
-    # type=inputmultiobject|default=[]: Weight fatctors for each input images
-    gradient_type:
-    # type=enum|default='0'|allowed['0','1','2']: Type of gradient used for computing the demons force (0 is symmetrized, 1 is fixed image, 2 is moving image)
-    upFieldSmoothing:
-    # type=float|default=0.0: Smoothing sigma for the update field at each iteration
-    max_step_length:
-    # type=float|default=0.0: Maximum length of an update vector (0: no restriction)
-    use_vanilla_dem:
-    # type=bool|default=False: Run vanilla demons algorithm
-    gui:
-    # type=bool|default=False: Display intermediate image volumes for debugging
-    promptUser:
-    # type=bool|default=False: Prompt the user to hit enter each time an image is sent to the DebugImageViewer
-    numberOfBCHApproximationTerms:
-    # type=int|default=0: Number of terms in the BCH expansion
-    numberOfThreads:
-    # type=int|default=0: Explicitly specify the maximum number of threads to use.
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/vbrains_demon_warp_callables.py b/example-specs/task/nipype_internal/pydra-slicer/vbrains_demon_warp_callables.py
deleted file mode 100644
index c1ed6ee7..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/vbrains_demon_warp_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in VBRAINSDemonWarp.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-slicer/voting_binary_hole_filling_image_filter.yaml b/example-specs/task/nipype_internal/pydra-slicer/voting_binary_hole_filling_image_filter.yaml
deleted file mode 100644
index e052d5e6..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/voting_binary_hole_filling_image_filter.yaml
+++ /dev/null
@@ -1,97 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.slicer.filtering.votingbinaryholefillingimagefilter.VotingBinaryHoleFillingImageFilter' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# title: Voting Binary Hole Filling Image Filter
-# 
-#     category: Filtering
-# 
-#     description: Applies a voting operation in order to fill-in cavities. This can be used for smoothing contours and for filling holes in binary images. This technique is used frequently when segmenting complete organs that may have ducts or vasculature that may not have been included in the initial segmentation, e.g. lungs, kidneys, liver.
-# 
-#     version: 0.1.0.$Revision: 19608 $(alpha)
-# 
-#     documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/VotingBinaryHoleFillingImageFilter
-# 
-#     contributor: Bill Lorensen (GE)
-# 
-#     acknowledgements: This command module was derived from Insight/Examples/Filtering/VotingBinaryHoleFillingImageFilter (copyright) Insight Software Consortium
-#     
-task_name: VotingBinaryHoleFillingImageFilter
-nipype_name: VotingBinaryHoleFillingImageFilter
-nipype_module: nipype.interfaces.slicer.filtering.votingbinaryholefillingimagefilter
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    inputVolume: generic/file
-    # type=file|default=<undefined>: Input volume to be filtered
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    outputVolume: generic/file
-    # type=file: Output filtered
-    # type=traitcompound|default=None: Output filtered
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    radius:
-    # type=inputmultiobject|default=[]: The radius of a hole to be filled
-    majorityThreshold:
-    # type=int|default=0: The number of pixels over 50% that will decide whether an OFF pixel will become ON or not. For example, if the neighborhood of a pixel has 124 pixels (excluding itself), the 50% will be 62, and if you set a Majority threshold of 5, that means that the filter will require 67 or more neighbor pixels to be ON in order to switch the current OFF pixel to ON.
-    background:
-    # type=int|default=0: The value associated with the background (not object)
-    foreground:
-    # type=int|default=0: The value associated with the foreground (object)
-    inputVolume:
-    # type=file|default=<undefined>: Input volume to be filtered
-    outputVolume:
-    # type=file: Output filtered
-    # type=traitcompound|default=None: Output filtered
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-slicer/voting_binary_hole_filling_image_filter_callables.py b/example-specs/task/nipype_internal/pydra-slicer/voting_binary_hole_filling_image_filter_callables.py
deleted file mode 100644
index decc36e1..00000000
--- a/example-specs/task/nipype_internal/pydra-slicer/voting_binary_hole_filling_image_filter_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in VotingBinaryHoleFillingImageFilter.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-spm/analyze_2nii.yaml b/example-specs/task/nipype_internal/pydra-spm/analyze_2nii.yaml
deleted file mode 100644
index 1a4817be..00000000
--- a/example-specs/task/nipype_internal/pydra-spm/analyze_2nii.yaml
+++ /dev/null
@@ -1,86 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.spm.utils.Analyze2nii' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-task_name: Analyze2nii
-nipype_name: Analyze2nii
-nipype_module: nipype.interfaces.spm.utils
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    analyze_file: generic/file
-    # type=file|default=<undefined>: 
-    paths: generic/directory+list-of
-    # type=inputmultiobject: Paths to add to matlabpath
-    # type=inputmultiobject|default=[]: Paths to add to matlabpath
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    nifti_file: generic/file
-    # type=file: 
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    analyze_file:
-    # type=file|default=<undefined>: 
-    matlab_cmd:
-    # type=str: matlab command to use
-    # type=str|default='': matlab command to use
-    paths:
-    # type=inputmultiobject: Paths to add to matlabpath
-    # type=inputmultiobject|default=[]: Paths to add to matlabpath
-    mfile:
-    # type=bool: Run m-code using m-file
-    # type=bool|default=True: Run m-code using m-file
-    use_mcr:
-    # type=bool: Run m-code using SPM MCR
-    # type=bool|default=False: Run m-code using SPM MCR
-    use_v8struct:
-    # type=bool: Generate SPM8 and higher compatible jobs
-    # type=bool|default=True: Generate SPM8 and higher compatible jobs
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-spm/analyze_2nii_callables.py b/example-specs/task/nipype_internal/pydra-spm/analyze_2nii_callables.py
deleted file mode 100644
index 533b5f29..00000000
--- a/example-specs/task/nipype_internal/pydra-spm/analyze_2nii_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in Analyze2nii.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-spm/apply_deformations.yaml b/example-specs/task/nipype_internal/pydra-spm/apply_deformations.yaml
deleted file mode 100644
index 09201361..00000000
--- a/example-specs/task/nipype_internal/pydra-spm/apply_deformations.yaml
+++ /dev/null
@@ -1,84 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.spm.preprocess.ApplyDeformations' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-task_name: ApplyDeformations
-nipype_name: ApplyDeformations
-nipype_module: nipype.interfaces.spm.preprocess
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    deformation_field: generic/file
-    # type=file|default=<undefined>: 
-    paths: generic/directory+list-of
-    # type=inputmultiobject|default=[]: Paths to add to matlabpath
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_files:
-    # type=inputmultiobject|default=[]: 
-    deformation_field:
-    # type=file|default=<undefined>: 
-    reference_volume:
-    # type=imagefilespm|default=<undefined>: 
-    interp:
-    # type=range|default=0: degree of b-spline used for interpolation
-    matlab_cmd:
-    # type=str|default='': matlab command to use
-    paths:
-    # type=inputmultiobject|default=[]: Paths to add to matlabpath
-    mfile:
-    # type=bool|default=True: Run m-code using m-file
-    use_mcr:
-    # type=bool|default=False: Run m-code using SPM MCR
-    use_v8struct:
-    # type=bool|default=True: Generate SPM8 and higher compatible jobs
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-spm/apply_deformations_callables.py b/example-specs/task/nipype_internal/pydra-spm/apply_deformations_callables.py
deleted file mode 100644
index 5b50cdc2..00000000
--- a/example-specs/task/nipype_internal/pydra-spm/apply_deformations_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in ApplyDeformations.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-spm/apply_inverse_deformation.yaml b/example-specs/task/nipype_internal/pydra-spm/apply_inverse_deformation.yaml
deleted file mode 100644
index 19054119..00000000
--- a/example-specs/task/nipype_internal/pydra-spm/apply_inverse_deformation.yaml
+++ /dev/null
@@ -1,108 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.spm.utils.ApplyInverseDeformation' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Uses spm to apply inverse deformation stored in a .mat file or a
-#     deformation field to a given file
-# 
-#     Examples
-#     --------
-# 
-#     >>> import nipype.interfaces.spm.utils as spmu
-#     >>> inv = spmu.ApplyInverseDeformation()
-#     >>> inv.inputs.in_files = 'functional.nii'
-#     >>> inv.inputs.deformation = 'struct_to_func.mat'
-#     >>> inv.inputs.target = 'structural.nii'
-#     >>> inv.run() # doctest: +SKIP
-#     
-task_name: ApplyInverseDeformation
-nipype_name: ApplyInverseDeformation
-nipype_module: nipype.interfaces.spm.utils
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_files: generic/file+list-of
-    # type=inputmultiobject|default=[]: Files on which deformation is applied
-    target: generic/file
-    # type=file|default=<undefined>: File defining target space
-    deformation: generic/file
-    # type=file|default=<undefined>: SN SPM deformation file
-    deformation_field: generic/file
-    # type=file|default=<undefined>: SN SPM deformation file
-    paths: generic/directory+list-of
-    # type=inputmultiobject|default=[]: Paths to add to matlabpath
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_files:
-    # type=inputmultiobject|default=[]: Files on which deformation is applied
-    target:
-    # type=file|default=<undefined>: File defining target space
-    deformation:
-    # type=file|default=<undefined>: SN SPM deformation file
-    deformation_field:
-    # type=file|default=<undefined>: SN SPM deformation file
-    interpolation:
-    # type=range|default=0: degree of b-spline used for interpolation
-    bounding_box:
-    # type=list|default=[]: 6-element list (opt)
-    voxel_sizes:
-    # type=list|default=[]: 3-element list (opt)
-    matlab_cmd:
-    # type=str|default='': matlab command to use
-    paths:
-    # type=inputmultiobject|default=[]: Paths to add to matlabpath
-    mfile:
-    # type=bool|default=True: Run m-code using m-file
-    use_mcr:
-    # type=bool|default=False: Run m-code using SPM MCR
-    use_v8struct:
-    # type=bool|default=True: Generate SPM8 and higher compatible jobs
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-spm/apply_inverse_deformation_callables.py b/example-specs/task/nipype_internal/pydra-spm/apply_inverse_deformation_callables.py
deleted file mode 100644
index d10710f5..00000000
--- a/example-specs/task/nipype_internal/pydra-spm/apply_inverse_deformation_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in ApplyInverseDeformation.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-spm/apply_transform.yaml b/example-specs/task/nipype_internal/pydra-spm/apply_transform.yaml
deleted file mode 100644
index f6f770d9..00000000
--- a/example-specs/task/nipype_internal/pydra-spm/apply_transform.yaml
+++ /dev/null
@@ -1,102 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.spm.utils.ApplyTransform' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Uses SPM to apply transform stored in a .mat file to given file
-# 
-#     Examples
-#     --------
-# 
-#     >>> import nipype.interfaces.spm.utils as spmu
-#     >>> applymat = spmu.ApplyTransform()
-#     >>> applymat.inputs.in_file = 'functional.nii'
-#     >>> applymat.inputs.mat = 'func_to_struct.mat'
-#     >>> applymat.run() # doctest: +SKIP
-# 
-#     
-task_name: ApplyTransform
-nipype_name: ApplyTransform
-nipype_module: nipype.interfaces.spm.utils
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_file: generic/file
-    # type=file|default=<undefined>: file to apply transform to, (only updates header)
-    mat: generic/file
-    # type=file|default=<undefined>: file holding transform to apply
-    paths: generic/directory+list-of
-    # type=inputmultiobject|default=[]: Paths to add to matlabpath
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    out_file: generic/file
-    # type=file: Transformed image file
-    # type=file|default=<undefined>: output file name for transformed data
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-    out_file: out_file
-    # type=file: Transformed image file
-    # type=file|default=<undefined>: output file name for transformed data
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: file to apply transform to, (only updates header)
-    mat:
-    # type=file|default=<undefined>: file holding transform to apply
-    out_file:
-    # type=file: Transformed image file
-    # type=file|default=<undefined>: output file name for transformed data
-    matlab_cmd:
-    # type=str|default='': matlab command to use
-    paths:
-    # type=inputmultiobject|default=[]: Paths to add to matlabpath
-    mfile:
-    # type=bool|default=True: Run m-code using m-file
-    use_mcr:
-    # type=bool|default=False: Run m-code using SPM MCR
-    use_v8struct:
-    # type=bool|default=True: Generate SPM8 and higher compatible jobs
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-spm/apply_transform_callables.py b/example-specs/task/nipype_internal/pydra-spm/apply_transform_callables.py
deleted file mode 100644
index 61ab1d08..00000000
--- a/example-specs/task/nipype_internal/pydra-spm/apply_transform_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in ApplyTransform.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-spm/apply_vdm.yaml b/example-specs/task/nipype_internal/pydra-spm/apply_vdm.yaml
deleted file mode 100644
index e6f9dfce..00000000
--- a/example-specs/task/nipype_internal/pydra-spm/apply_vdm.yaml
+++ /dev/null
@@ -1,103 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.spm.preprocess.ApplyVDM' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Use the fieldmap toolbox from spm to apply the voxel displacement map (VDM) to some epi files.
-# 
-#     http://www.fil.ion.ucl.ac.uk/spm/doc/manual.pdf#page=173
-# 
-#     .. important::
-# 
-#         This interface does not deal with real/imag magnitude images nor
-#         with the two phase files case.
-# 
-#     
-task_name: ApplyVDM
-nipype_name: ApplyVDM
-nipype_module: nipype.interfaces.spm.preprocess
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    vdmfile: generic/file
-    # type=file|default=<undefined>: Voxel displacement map to use
-    paths: generic/directory+list-of
-    # type=inputmultiobject|default=[]: Paths to add to matlabpath
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    mean_image: generic/file
-    # type=file: Mean image
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_files:
-    # type=inputmultiobject|default=[]: list of filenames to apply the vdm to
-    vdmfile:
-    # type=file|default=<undefined>: Voxel displacement map to use
-    distortion_direction:
-    # type=int|default=2: phase encode direction input data have been acquired with
-    write_which:
-    # type=list|default=[2, 1]: If the first value is non-zero, reslice all images. If the second value is non-zero, reslice a mean image.
-    interpolation:
-    # type=range|default=4: degree of b-spline used for interpolation
-    write_wrap:
-    # type=list|default=[]: Check if interpolation should wrap in [x,y,z]
-    write_mask:
-    # type=bool|default=False: True/False mask time series images
-    out_prefix:
-    # type=string|default='u': fieldmap corrected output prefix
-    matlab_cmd:
-    # type=str|default='': matlab command to use
-    paths:
-    # type=inputmultiobject|default=[]: Paths to add to matlabpath
-    mfile:
-    # type=bool|default=True: Run m-code using m-file
-    use_mcr:
-    # type=bool|default=False: Run m-code using SPM MCR
-    use_v8struct:
-    # type=bool|default=True: Generate SPM8 and higher compatible jobs
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-spm/apply_vdm_callables.py b/example-specs/task/nipype_internal/pydra-spm/apply_vdm_callables.py
deleted file mode 100644
index 8ae8805c..00000000
--- a/example-specs/task/nipype_internal/pydra-spm/apply_vdm_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in ApplyVDM.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-spm/calc_coreg_affine.yaml b/example-specs/task/nipype_internal/pydra-spm/calc_coreg_affine.yaml
deleted file mode 100644
index a53be158..00000000
--- a/example-specs/task/nipype_internal/pydra-spm/calc_coreg_affine.yaml
+++ /dev/null
@@ -1,120 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.spm.utils.CalcCoregAffine' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Uses SPM (spm_coreg) to calculate the transform mapping
-#     moving to target. Saves Transform in mat (matlab binary file)
-#     Also saves inverse transform
-# 
-#     Examples
-#     --------
-# 
-#     >>> import nipype.interfaces.spm.utils as spmu
-#     >>> coreg = spmu.CalcCoregAffine(matlab_cmd='matlab-spm8')
-#     >>> coreg.inputs.target = 'structural.nii'
-#     >>> coreg.inputs.moving = 'functional.nii'
-#     >>> coreg.inputs.mat = 'func_to_struct.mat'
-#     >>> coreg.run() # doctest: +SKIP
-# 
-#     .. note::
-# 
-#      * the output file mat is saves as a matlab binary file
-#      * calculating the transforms does NOT change either input image
-#        it does not **move** the moving image, only calculates the transform
-#        that can be used to move it
-#     
-task_name: CalcCoregAffine
-nipype_name: CalcCoregAffine
-nipype_module: nipype.interfaces.spm.utils
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    target: generic/file
-    # type=file|default=<undefined>: target for generating affine transform
-    moving: generic/file
-    # type=file|default=<undefined>: volume transform can be applied to register with target
-    mat: generic/file
-    # type=file: Matlab file holding transform
-    # type=file|default=<undefined>: Filename used to store affine matrix
-    invmat: generic/file
-    # type=file: Matlab file holding inverse transform
-    # type=file|default=<undefined>: Filename used to store inverse affine matrix
-    paths: generic/directory+list-of
-    # type=inputmultiobject|default=[]: Paths to add to matlabpath
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    mat: generic/file
-    # type=file: Matlab file holding transform
-    # type=file|default=<undefined>: Filename used to store affine matrix
-    invmat: generic/file
-    # type=file: Matlab file holding inverse transform
-    # type=file|default=<undefined>: Filename used to store inverse affine matrix
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    target:
-    # type=file|default=<undefined>: target for generating affine transform
-    moving:
-    # type=file|default=<undefined>: volume transform can be applied to register with target
-    mat:
-    # type=file: Matlab file holding transform
-    # type=file|default=<undefined>: Filename used to store affine matrix
-    invmat:
-    # type=file: Matlab file holding inverse transform
-    # type=file|default=<undefined>: Filename used to store inverse affine matrix
-    matlab_cmd:
-    # type=str|default='': matlab command to use
-    paths:
-    # type=inputmultiobject|default=[]: Paths to add to matlabpath
-    mfile:
-    # type=bool|default=True: Run m-code using m-file
-    use_mcr:
-    # type=bool|default=False: Run m-code using SPM MCR
-    use_v8struct:
-    # type=bool|default=True: Generate SPM8 and higher compatible jobs
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-spm/calc_coreg_affine_callables.py b/example-specs/task/nipype_internal/pydra-spm/calc_coreg_affine_callables.py
deleted file mode 100644
index 5a37d161..00000000
--- a/example-specs/task/nipype_internal/pydra-spm/calc_coreg_affine_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in CalcCoregAffine.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-spm/coregister.yaml b/example-specs/task/nipype_internal/pydra-spm/coregister.yaml
deleted file mode 100644
index 67c35d0c..00000000
--- a/example-specs/task/nipype_internal/pydra-spm/coregister.yaml
+++ /dev/null
@@ -1,113 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.spm.preprocess.Coregister' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Use spm_coreg for estimating cross-modality rigid body alignment
-# 
-#     http://www.fil.ion.ucl.ac.uk/spm/doc/manual.pdf#page=39
-# 
-#     Examples
-#     --------
-# 
-#     >>> import nipype.interfaces.spm as spm
-#     >>> coreg = spm.Coregister()
-#     >>> coreg.inputs.target = 'functional.nii'
-#     >>> coreg.inputs.source = 'structural.nii'
-#     >>> coreg.run() # doctest: +SKIP
-# 
-#     
-task_name: Coregister
-nipype_name: Coregister
-nipype_module: nipype.interfaces.spm.preprocess
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    apply_to_files: generic/file+list-of
-    # type=inputmultiobject|default=[]: files to apply transformation to
-    paths: generic/directory+list-of
-    # type=inputmultiobject|default=[]: Paths to add to matlabpath
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    target:
-    # type=imagefilespm|default=<undefined>: reference file to register to
-    source:
-    # type=inputmultiobject|default=[]: file to register to target
-    jobtype:
-    # type=enum|default='estwrite'|allowed['estimate','estwrite','write']: one of: estimate, write, estwrite
-    apply_to_files:
-    # type=inputmultiobject|default=[]: files to apply transformation to
-    cost_function:
-    # type=enum|default='mi'|allowed['ecc','mi','ncc','nmi']: cost function, one of:                     'mi' - Mutual Information,                     'nmi' - Normalised Mutual Information,                     'ecc' - Entropy Correlation Coefficient,                     'ncc' - Normalised Cross Correlation
-    fwhm:
-    # type=list|default=[]: gaussian smoothing kernel width (mm)
-    separation:
-    # type=list|default=[]: sampling separation in mm
-    tolerance:
-    # type=list|default=[]: acceptable tolerance for each of 12 params
-    write_interp:
-    # type=range|default=0: degree of b-spline used for interpolation
-    write_wrap:
-    # type=list|default=[]: Check if interpolation should wrap in [x,y,z]
-    write_mask:
-    # type=bool|default=False: True/False mask output image
-    out_prefix:
-    # type=string|default='r': coregistered output prefix
-    matlab_cmd:
-    # type=str|default='': matlab command to use
-    paths:
-    # type=inputmultiobject|default=[]: Paths to add to matlabpath
-    mfile:
-    # type=bool|default=True: Run m-code using m-file
-    use_mcr:
-    # type=bool|default=False: Run m-code using SPM MCR
-    use_v8struct:
-    # type=bool|default=True: Generate SPM8 and higher compatible jobs
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-spm/coregister_callables.py b/example-specs/task/nipype_internal/pydra-spm/coregister_callables.py
deleted file mode 100644
index 7de5928a..00000000
--- a/example-specs/task/nipype_internal/pydra-spm/coregister_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in Coregister.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-spm/create_warped.yaml b/example-specs/task/nipype_internal/pydra-spm/create_warped.yaml
deleted file mode 100644
index 9dcd9906..00000000
--- a/example-specs/task/nipype_internal/pydra-spm/create_warped.yaml
+++ /dev/null
@@ -1,96 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.spm.preprocess.CreateWarped' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Apply a flow field estimated by DARTEL to create warped images
-# 
-#     http://www.fil.ion.ucl.ac.uk/spm/doc/manual.pdf#page=190
-# 
-#     Examples
-#     --------
-#     >>> import nipype.interfaces.spm as spm
-#     >>> create_warped = spm.CreateWarped()
-#     >>> create_warped.inputs.image_files = ['rc1s1.nii', 'rc1s2.nii']
-#     >>> create_warped.inputs.flowfield_files = ['u_rc1s1_Template.nii', 'u_rc1s2_Template.nii']
-#     >>> create_warped.run() # doctest: +SKIP
-# 
-#     
-task_name: CreateWarped
-nipype_name: CreateWarped
-nipype_module: nipype.interfaces.spm.preprocess
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    paths: generic/directory+list-of
-    # type=inputmultiobject|default=[]: Paths to add to matlabpath
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    image_files:
-    # type=inputmultiobject|default=[]: A list of files to be warped
-    flowfield_files:
-    # type=inputmultiobject|default=[]: DARTEL flow fields u_rc1*
-    iterations:
-    # type=range|default=0: The number of iterations: log2(number of time steps)
-    interp:
-    # type=range|default=0: degree of b-spline used for interpolation
-    modulate:
-    # type=bool|default=False: Modulate images
-    matlab_cmd:
-    # type=str|default='': matlab command to use
-    paths:
-    # type=inputmultiobject|default=[]: Paths to add to matlabpath
-    mfile:
-    # type=bool|default=True: Run m-code using m-file
-    use_mcr:
-    # type=bool|default=False: Run m-code using SPM MCR
-    use_v8struct:
-    # type=bool|default=True: Generate SPM8 and higher compatible jobs
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-spm/create_warped_callables.py b/example-specs/task/nipype_internal/pydra-spm/create_warped_callables.py
deleted file mode 100644
index 60c29781..00000000
--- a/example-specs/task/nipype_internal/pydra-spm/create_warped_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in CreateWarped.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-spm/dartel.yaml b/example-specs/task/nipype_internal/pydra-spm/dartel.yaml
deleted file mode 100644
index 65ef3d73..00000000
--- a/example-specs/task/nipype_internal/pydra-spm/dartel.yaml
+++ /dev/null
@@ -1,97 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.spm.preprocess.DARTEL' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Use spm DARTEL to create a template and flow fields
-# 
-#     http://www.fil.ion.ucl.ac.uk/spm/doc/manual.pdf#page=185
-# 
-#     Examples
-#     --------
-#     >>> import nipype.interfaces.spm as spm
-#     >>> dartel = spm.DARTEL()
-#     >>> dartel.inputs.image_files = [['rc1s1.nii','rc1s2.nii'],['rc2s1.nii', 'rc2s2.nii']]
-#     >>> dartel.run() # doctest: +SKIP
-# 
-#     
-task_name: DARTEL
-nipype_name: DARTEL
-nipype_module: nipype.interfaces.spm.preprocess
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    paths: generic/directory+list-of
-    # type=inputmultiobject|default=[]: Paths to add to matlabpath
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    final_template_file: generic/file
-    # type=file: final DARTEL template
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    image_files:
-    # type=list|default=[]: A list of files to be segmented
-    template_prefix:
-    # type=str|default='Template': Prefix for template
-    regularization_form:
-    # type=enum|default='Linear'|allowed['Bending','Linear','Membrane']: Form of regularization energy term
-    iteration_parameters:
-    # type=list|default=[]: List of tuples for each iteration    * Inner iterations   * Regularization parameters   * Time points for deformation model   * smoothing parameter  
-    optimization_parameters:
-    # type=tuple|default=(0.0, 1, 1): Optimization settings a tuple:    * LM regularization   * cycles of multigrid solver   * relaxation iterations  
-    matlab_cmd:
-    # type=str|default='': matlab command to use
-    paths:
-    # type=inputmultiobject|default=[]: Paths to add to matlabpath
-    mfile:
-    # type=bool|default=True: Run m-code using m-file
-    use_mcr:
-    # type=bool|default=False: Run m-code using SPM MCR
-    use_v8struct:
-    # type=bool|default=True: Generate SPM8 and higher compatible jobs
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-spm/dartel_callables.py b/example-specs/task/nipype_internal/pydra-spm/dartel_callables.py
deleted file mode 100644
index e6fe7031..00000000
--- a/example-specs/task/nipype_internal/pydra-spm/dartel_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in DARTEL.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-spm/dartel_norm_2mni.yaml b/example-specs/task/nipype_internal/pydra-spm/dartel_norm_2mni.yaml
deleted file mode 100644
index 4d0a7a36..00000000
--- a/example-specs/task/nipype_internal/pydra-spm/dartel_norm_2mni.yaml
+++ /dev/null
@@ -1,104 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.spm.preprocess.DARTELNorm2MNI' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Use spm DARTEL to normalize data to MNI space
-# 
-#     http://www.fil.ion.ucl.ac.uk/spm/doc/manual.pdf#page=188
-# 
-#     Examples
-#     --------
-#     >>> import nipype.interfaces.spm as spm
-#     >>> nm = spm.DARTELNorm2MNI()
-#     >>> nm.inputs.template_file = 'Template_6.nii'
-#     >>> nm.inputs.flowfield_files = ['u_rc1s1_Template.nii', 'u_rc1s3_Template.nii']
-#     >>> nm.inputs.apply_to_files = ['c1s1.nii', 'c1s3.nii']
-#     >>> nm.inputs.modulate = True
-#     >>> nm.run() # doctest: +SKIP
-# 
-#     
-task_name: DARTELNorm2MNI
-nipype_name: DARTELNorm2MNI
-nipype_module: nipype.interfaces.spm.preprocess
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    paths: generic/directory+list-of
-    # type=inputmultiobject|default=[]: Paths to add to matlabpath
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    normalization_parameter_file: generic/file
-    # type=file: Transform parameters to MNI space
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    template_file:
-    # type=imagefilespm|default=<undefined>: DARTEL template
-    flowfield_files:
-    # type=inputmultiobject|default=[]: DARTEL flow fields u_rc1*
-    apply_to_files:
-    # type=inputmultiobject|default=[]: Files to apply the transform to
-    voxel_size:
-    # type=tuple|default=(0.0, 0.0, 0.0): Voxel sizes for output file
-    bounding_box:
-    # type=tuple|default=(0.0, 0.0, 0.0, 0.0, 0.0, 0.0): Voxel sizes for output file
-    modulate:
-    # type=bool|default=False: Modulate out images - no modulation preserves concentrations
-    fwhm:
-    # type=traitcompound|default=None: 3-list of fwhm for each dimension
-    matlab_cmd:
-    # type=str|default='': matlab command to use
-    paths:
-    # type=inputmultiobject|default=[]: Paths to add to matlabpath
-    mfile:
-    # type=bool|default=True: Run m-code using m-file
-    use_mcr:
-    # type=bool|default=False: Run m-code using SPM MCR
-    use_v8struct:
-    # type=bool|default=True: Generate SPM8 and higher compatible jobs
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-spm/dartel_norm_2mni_callables.py b/example-specs/task/nipype_internal/pydra-spm/dartel_norm_2mni_callables.py
deleted file mode 100644
index 27ebbc54..00000000
--- a/example-specs/task/nipype_internal/pydra-spm/dartel_norm_2mni_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in DARTELNorm2MNI.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-spm/dicom_import.yaml b/example-specs/task/nipype_internal/pydra-spm/dicom_import.yaml
deleted file mode 100644
index d5f8b76c..00000000
--- a/example-specs/task/nipype_internal/pydra-spm/dicom_import.yaml
+++ /dev/null
@@ -1,95 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.spm.utils.DicomImport' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Uses spm to convert DICOM files to nii or img+hdr.
-# 
-#     Examples
-#     --------
-# 
-#     >>> import nipype.interfaces.spm.utils as spmu
-#     >>> di = spmu.DicomImport()
-#     >>> di.inputs.in_files = ['functional_1.dcm', 'functional_2.dcm']
-#     >>> di.run() # doctest: +SKIP
-#     
-task_name: DicomImport
-nipype_name: DicomImport
-nipype_module: nipype.interfaces.spm.utils
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_files: generic/file+list-of
-    # type=inputmultiobject|default=[]: dicom files to be converted
-    paths: generic/directory+list-of
-    # type=inputmultiobject|default=[]: Paths to add to matlabpath
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_files:
-    # type=inputmultiobject|default=[]: dicom files to be converted
-    output_dir_struct:
-    # type=enum|default='flat'|allowed['date_time','flat','patid','patid_date','patname','series']: directory structure for the output.
-    output_dir:
-    # type=str|default='./converted_dicom': output directory.
-    format:
-    # type=enum|default='nii'|allowed['img','nii']: output format.
-    icedims:
-    # type=bool|default=False: If image sorting fails, one can try using the additional SIEMENS ICEDims information to create unique filenames. Use this only if there would be multiple volumes with exactly the same file names.
-    matlab_cmd:
-    # type=str|default='': matlab command to use
-    paths:
-    # type=inputmultiobject|default=[]: Paths to add to matlabpath
-    mfile:
-    # type=bool|default=True: Run m-code using m-file
-    use_mcr:
-    # type=bool|default=False: Run m-code using SPM MCR
-    use_v8struct:
-    # type=bool|default=True: Generate SPM8 and higher compatible jobs
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-spm/dicom_import_callables.py b/example-specs/task/nipype_internal/pydra-spm/dicom_import_callables.py
deleted file mode 100644
index 51866005..00000000
--- a/example-specs/task/nipype_internal/pydra-spm/dicom_import_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in DicomImport.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-spm/estimate_contrast.yaml b/example-specs/task/nipype_internal/pydra-spm/estimate_contrast.yaml
deleted file mode 100644
index 7934b0f2..00000000
--- a/example-specs/task/nipype_internal/pydra-spm/estimate_contrast.yaml
+++ /dev/null
@@ -1,110 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.spm.model.EstimateContrast' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Use spm_contrasts to estimate contrasts of interest
-# 
-#     Examples
-#     --------
-#     >>> import nipype.interfaces.spm as spm
-#     >>> est = spm.EstimateContrast()
-#     >>> est.inputs.spm_mat_file = 'SPM.mat'
-#     >>> cont1 = ('Task>Baseline','T', ['Task-Odd','Task-Even'],[0.5,0.5])
-#     >>> cont2 = ('Task-Odd>Task-Even','T', ['Task-Odd','Task-Even'],[1,-1])
-#     >>> contrasts = [cont1,cont2]
-#     >>> est.inputs.contrasts = contrasts
-#     >>> est.run() # doctest: +SKIP
-# 
-#     
-task_name: EstimateContrast
-nipype_name: EstimateContrast
-nipype_module: nipype.interfaces.spm.model
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    spm_mat_file: generic/file
-    # type=file: Updated SPM mat file
-    # type=file|default=<undefined>: Absolute path to SPM.mat
-    beta_images: generic/file+list-of
-    # type=inputmultiobject|default=[]: Parameter estimates of the design matrix
-    residual_image: generic/file
-    # type=file|default=<undefined>: Mean-squared image of the residuals
-    paths: generic/directory+list-of
-    # type=inputmultiobject|default=[]: Paths to add to matlabpath
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    spm_mat_file: generic/file
-    # type=file: Updated SPM mat file
-    # type=file|default=<undefined>: Absolute path to SPM.mat
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    spm_mat_file:
-    # type=file: Updated SPM mat file
-    # type=file|default=<undefined>: Absolute path to SPM.mat
-    contrasts:
-    # type=list|default=[]: List of contrasts with each contrast being a list of the form:             [('name', 'stat', [condition list], [weight list], [session list])]             If session list is None or not provided, all sessions are used. For             F contrasts, the condition list should contain previously defined             T-contrasts.
-    beta_images:
-    # type=inputmultiobject|default=[]: Parameter estimates of the design matrix
-    residual_image:
-    # type=file|default=<undefined>: Mean-squared image of the residuals
-    use_derivs:
-    # type=bool|default=False: use derivatives for estimation
-    group_contrast:
-    # type=bool|default=False: higher level contrast
-    matlab_cmd:
-    # type=str|default='': matlab command to use
-    paths:
-    # type=inputmultiobject|default=[]: Paths to add to matlabpath
-    mfile:
-    # type=bool|default=True: Run m-code using m-file
-    use_mcr:
-    # type=bool|default=False: Run m-code using SPM MCR
-    use_v8struct:
-    # type=bool|default=True: Generate SPM8 and higher compatible jobs
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-spm/estimate_contrast_callables.py b/example-specs/task/nipype_internal/pydra-spm/estimate_contrast_callables.py
deleted file mode 100644
index 6841e094..00000000
--- a/example-specs/task/nipype_internal/pydra-spm/estimate_contrast_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in EstimateContrast.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-spm/estimate_model.yaml b/example-specs/task/nipype_internal/pydra-spm/estimate_model.yaml
deleted file mode 100644
index fdd7ad78..00000000
--- a/example-specs/task/nipype_internal/pydra-spm/estimate_model.yaml
+++ /dev/null
@@ -1,99 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.spm.model.EstimateModel' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Use spm_spm to estimate the parameters of a model
-# 
-#     http://www.fil.ion.ucl.ac.uk/spm/doc/manual.pdf#page=69
-# 
-#     Examples
-#     --------
-#     >>> est = EstimateModel()
-#     >>> est.inputs.spm_mat_file = 'SPM.mat'
-#     >>> est.inputs.estimation_method = {'Classical': 1}
-#     >>> est.run() # doctest: +SKIP
-#     
-task_name: EstimateModel
-nipype_name: EstimateModel
-nipype_module: nipype.interfaces.spm.model
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    spm_mat_file: generic/file
-    # type=file: Updated SPM mat file
-    # type=file|default=<undefined>: Absolute path to SPM.mat
-    paths: generic/directory+list-of
-    # type=inputmultiobject|default=[]: Paths to add to matlabpath
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    spm_mat_file: generic/file
-    # type=file: Updated SPM mat file
-    # type=file|default=<undefined>: Absolute path to SPM.mat
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    spm_mat_file:
-    # type=file: Updated SPM mat file
-    # type=file|default=<undefined>: Absolute path to SPM.mat
-    estimation_method:
-    # type=dict|default={}: Dictionary of either Classical: 1, Bayesian: 1, or Bayesian2: 1 (dict)
-    write_residuals:
-    # type=bool|default=False: Write individual residual images
-    flags:
-    # type=dict|default={}: Additional arguments
-    matlab_cmd:
-    # type=str|default='': matlab command to use
-    paths:
-    # type=inputmultiobject|default=[]: Paths to add to matlabpath
-    mfile:
-    # type=bool|default=True: Run m-code using m-file
-    use_mcr:
-    # type=bool|default=False: Run m-code using SPM MCR
-    use_v8struct:
-    # type=bool|default=True: Generate SPM8 and higher compatible jobs
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-spm/estimate_model_callables.py b/example-specs/task/nipype_internal/pydra-spm/estimate_model_callables.py
deleted file mode 100644
index 34d17705..00000000
--- a/example-specs/task/nipype_internal/pydra-spm/estimate_model_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in EstimateModel.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-spm/factorial_design.yaml b/example-specs/task/nipype_internal/pydra-spm/factorial_design.yaml
deleted file mode 100644
index f524698e..00000000
--- a/example-specs/task/nipype_internal/pydra-spm/factorial_design.yaml
+++ /dev/null
@@ -1,108 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.spm.model.FactorialDesign' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Base class for factorial designs
-# 
-#     http://www.fil.ion.ucl.ac.uk/spm/doc/manual.pdf#page=77
-# 
-#     
-task_name: FactorialDesign
-nipype_name: FactorialDesign
-nipype_module: nipype.interfaces.spm.model
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    explicit_mask_file: generic/file
-    # type=file|default=<undefined>: use an implicit mask file to threshold
-    spm_mat_dir: generic/directory
-    # type=directory|default=<undefined>: directory to store SPM.mat file (opt)
-    paths: generic/directory+list-of
-    # type=inputmultiobject|default=[]: Paths to add to matlabpath
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    spm_mat_file: generic/file
-    # type=file: SPM mat file
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    spm_mat_dir:
-    # type=directory|default=<undefined>: directory to store SPM.mat file (opt)
-    covariates:
-    # type=inputmultiobject|default=[]: covariate dictionary {vector, name, interaction, centering}
-    threshold_mask_none:
-    # type=bool|default=False: do not use threshold masking
-    threshold_mask_absolute:
-    # type=float|default=0.0: use an absolute threshold
-    threshold_mask_relative:
-    # type=float|default=0.0: threshold using a proportion of the global value
-    use_implicit_threshold:
-    # type=bool|default=False: use implicit mask NaNs or zeros to threshold
-    explicit_mask_file:
-    # type=file|default=<undefined>: use an implicit mask file to threshold
-    global_calc_omit:
-    # type=bool|default=False: omit global calculation
-    global_calc_mean:
-    # type=bool|default=False: use mean for global calculation
-    global_calc_values:
-    # type=list|default=[]: omit global calculation
-    no_grand_mean_scaling:
-    # type=bool|default=False: do not perform grand mean scaling
-    global_normalization:
-    # type=enum|default=1|allowed[1,2,3]: global normalization None-1, Proportional-2, ANCOVA-3
-    matlab_cmd:
-    # type=str|default='': matlab command to use
-    paths:
-    # type=inputmultiobject|default=[]: Paths to add to matlabpath
-    mfile:
-    # type=bool|default=True: Run m-code using m-file
-    use_mcr:
-    # type=bool|default=False: Run m-code using SPM MCR
-    use_v8struct:
-    # type=bool|default=True: Generate SPM8 and higher compatible jobs
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-spm/factorial_design_callables.py b/example-specs/task/nipype_internal/pydra-spm/factorial_design_callables.py
deleted file mode 100644
index 36a32703..00000000
--- a/example-specs/task/nipype_internal/pydra-spm/factorial_design_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in FactorialDesign.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-spm/field_map.yaml b/example-specs/task/nipype_internal/pydra-spm/field_map.yaml
deleted file mode 100644
index ee89ebef..00000000
--- a/example-specs/task/nipype_internal/pydra-spm/field_map.yaml
+++ /dev/null
@@ -1,157 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.spm.preprocess.FieldMap' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Use the fieldmap toolbox from spm to calculate the voxel displacement map (VDM).
-# 
-#     http://www.fil.ion.ucl.ac.uk/spm/doc/manual.pdf#page=173
-# 
-#     .. important::
-# 
-#         This interface does not deal with real/imag magnitude images nor
-#         with the two phase files case.
-# 
-#     Examples
-#     --------
-#     >>> from nipype.interfaces.spm import FieldMap
-#     >>> fm = FieldMap()
-#     >>> fm.inputs.phase_file = 'phase.nii'
-#     >>> fm.inputs.magnitude_file = 'magnitude.nii'
-#     >>> fm.inputs.echo_times = (5.19, 7.65)
-#     >>> fm.inputs.blip_direction = 1
-#     >>> fm.inputs.total_readout_time = 15.6
-#     >>> fm.inputs.epi_file = 'epi.nii'
-#     >>> fm.run() # doctest: +SKIP
-# 
-#     
-task_name: FieldMap
-nipype_name: FieldMap
-nipype_module: nipype.interfaces.spm.preprocess
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    phase_file: generic/file
-    # type=file|default=<undefined>: presubstracted phase file
-    magnitude_file: generic/file
-    # type=file|default=<undefined>: presubstracted magnitude file
-    template: generic/file
-    # type=file|default=<undefined>: template image for brain masking
-    epi_file: generic/file
-    # type=file|default=<undefined>: EPI to unwarp
-    anat_file: generic/file
-    # type=file|default=<undefined>: anatomical image for comparison
-    paths: generic/directory+list-of
-    # type=inputmultiobject|default=[]: Paths to add to matlabpath
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    vdm: generic/file
-    # type=file: voxel difference map
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    jobtype:
-    # type=enum|default='calculatevdm'|allowed['calculatevdm']: Must be 'calculatevdm'; to apply VDM, use the ApplyVDM interface.
-    phase_file:
-    # type=file|default=<undefined>: presubstracted phase file
-    magnitude_file:
-    # type=file|default=<undefined>: presubstracted magnitude file
-    echo_times:
-    # type=tuple|default=(0.0, 0.0): short and long echo times
-    maskbrain:
-    # type=bool|default=True: masking or no masking of the brain
-    blip_direction:
-    # type=enum|default=1|allowed[-1,1]: polarity of the phase-encode blips
-    total_readout_time:
-    # type=float|default=0.0: total EPI readout time
-    epifm:
-    # type=bool|default=False: epi-based field map
-    jacobian_modulation:
-    # type=bool|default=False: jacobian modulation
-    method:
-    # type=enum|default='Mark3D'|allowed['Huttonish','Mark2D','Mark3D']: One of: Mark3D, Mark2D, Huttonish
-    unwarp_fwhm:
-    # type=range|default=10: gaussian smoothing kernel width
-    pad:
-    # type=range|default=0: padding kernel width
-    ws:
-    # type=bool|default=True: weighted smoothing
-    template:
-    # type=file|default=<undefined>: template image for brain masking
-    mask_fwhm:
-    # type=range|default=5: gaussian smoothing kernel width
-    nerode:
-    # type=range|default=2: number of erosions
-    ndilate:
-    # type=range|default=4: number of erosions
-    thresh:
-    # type=float|default=0.5: threshold used to create brain mask from segmented data
-    reg:
-    # type=float|default=0.02: regularization value used in the segmentation
-    epi_file:
-    # type=file|default=<undefined>: EPI to unwarp
-    matchvdm:
-    # type=bool|default=True: match VDM to EPI
-    sessname:
-    # type=str|default='_run-': VDM filename extension
-    writeunwarped:
-    # type=bool|default=False: write unwarped EPI
-    anat_file:
-    # type=file|default=<undefined>: anatomical image for comparison
-    matchanat:
-    # type=bool|default=True: match anatomical image to EPI
-    matlab_cmd:
-    # type=str|default='': matlab command to use
-    paths:
-    # type=inputmultiobject|default=[]: Paths to add to matlabpath
-    mfile:
-    # type=bool|default=True: Run m-code using m-file
-    use_mcr:
-    # type=bool|default=False: Run m-code using SPM MCR
-    use_v8struct:
-    # type=bool|default=True: Generate SPM8 and higher compatible jobs
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-spm/field_map_callables.py b/example-specs/task/nipype_internal/pydra-spm/field_map_callables.py
deleted file mode 100644
index 501c6d08..00000000
--- a/example-specs/task/nipype_internal/pydra-spm/field_map_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in FieldMap.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-spm/level_1_design.yaml b/example-specs/task/nipype_internal/pydra-spm/level_1_design.yaml
deleted file mode 100644
index a7dd3b79..00000000
--- a/example-specs/task/nipype_internal/pydra-spm/level_1_design.yaml
+++ /dev/null
@@ -1,123 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.spm.model.Level1Design' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Generate an SPM design matrix
-# 
-#     http://www.fil.ion.ucl.ac.uk/spm/doc/manual.pdf#page=59
-# 
-#     Examples
-#     --------
-# 
-#     >>> level1design = Level1Design()
-#     >>> level1design.inputs.timing_units = 'secs'
-#     >>> level1design.inputs.interscan_interval = 2.5
-#     >>> level1design.inputs.bases = {'hrf':{'derivs': [0,0]}}
-#     >>> level1design.inputs.session_info = 'session_info.npz'
-#     >>> level1design.inputs.flags = {'mthresh': 0.4}
-#     >>> level1design.run() # doctest: +SKIP
-# 
-#     
-task_name: Level1Design
-nipype_name: Level1Design
-nipype_module: nipype.interfaces.spm.model
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    mask_image: generic/file
-    # type=file|default=<undefined>: Image  for  explicitly  masking the analysis
-    spm_mat_dir: generic/directory
-    # type=directory|default=<undefined>: directory to store SPM.mat file (opt)
-    paths: generic/directory+list-of
-    # type=inputmultiobject|default=[]: Paths to add to matlabpath
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    spm_mat_file: generic/file
-    # type=file: SPM mat file
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    spm_mat_dir:
-    # type=directory|default=<undefined>: directory to store SPM.mat file (opt)
-    timing_units:
-    # type=enum|default='secs'|allowed['scans','secs']: units for specification of onsets
-    interscan_interval:
-    # type=float|default=0.0: Interscan interval in secs
-    microtime_resolution:
-    # type=int|default=0: Number of time-bins per scan in secs (opt)
-    microtime_onset:
-    # type=float|default=0.0: The onset/time-bin in seconds for alignment (opt)
-    session_info:
-    # type=any|default=None: Session specific information generated by ``modelgen.SpecifyModel``
-    factor_info:
-    # type=list|default=[]: Factor specific information file (opt)
-    bases:
-    # type=dict|default={}: Dictionary names of the basis function to parameters:      * hrf          * derivs -- (2-element list) Model  HRF  Derivatives. No derivatives: [0,0],           Time derivatives : [1,0], Time and Dispersion derivatives: [1,1]      * fourier, fourier_han, gamma, or fir:          * length -- (int) Post-stimulus window length (in seconds)         * order -- (int) Number of basis functions  
-    volterra_expansion_order:
-    # type=enum|default=1|allowed[1,2]: Model interactions - no:1, yes:2
-    global_intensity_normalization:
-    # type=enum|default='none'|allowed['none','scaling']: Global intensity normalization - scaling or none
-    mask_image:
-    # type=file|default=<undefined>: Image  for  explicitly  masking the analysis
-    mask_threshold:
-    # type=traitcompound|default='-Inf': Thresholding for the mask
-    model_serial_correlations:
-    # type=enum|default='AR(1)'|allowed['AR(1)','FAST','none']: Model serial correlations AR(1), FAST or none. FAST is available in SPM12
-    flags:
-    # type=dict|default={}: Additional arguments to the job, e.g., a common SPM operation is to modify the default masking threshold (mthresh)
-    matlab_cmd:
-    # type=str|default='': matlab command to use
-    paths:
-    # type=inputmultiobject|default=[]: Paths to add to matlabpath
-    mfile:
-    # type=bool|default=True: Run m-code using m-file
-    use_mcr:
-    # type=bool|default=False: Run m-code using SPM MCR
-    use_v8struct:
-    # type=bool|default=True: Generate SPM8 and higher compatible jobs
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-spm/level_1_design_callables.py b/example-specs/task/nipype_internal/pydra-spm/level_1_design_callables.py
deleted file mode 100644
index 0558037d..00000000
--- a/example-specs/task/nipype_internal/pydra-spm/level_1_design_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in Level1Design.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-spm/multi_channel_new_segment.yaml b/example-specs/task/nipype_internal/pydra-spm/multi_channel_new_segment.yaml
deleted file mode 100644
index 73249c25..00000000
--- a/example-specs/task/nipype_internal/pydra-spm/multi_channel_new_segment.yaml
+++ /dev/null
@@ -1,113 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.spm.preprocess.MultiChannelNewSegment' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Use spm_preproc8 (New Segment) to separate structural images into
-#     different tissue classes. Supports multiple modalities and multichannel inputs.
-# 
-#     http://www.fil.ion.ucl.ac.uk/spm/doc/manual.pdf#page=45
-# 
-#     Examples
-#     --------
-#     >>> import nipype.interfaces.spm as spm
-#     >>> seg = spm.MultiChannelNewSegment()
-#     >>> seg.inputs.channels = [('structural.nii',(0.0001, 60, (True, True)))]
-#     >>> seg.run() # doctest: +SKIP
-# 
-#     For VBM pre-processing [http://www.fil.ion.ucl.ac.uk/~john/misc/VBMclass10.pdf],
-#     TPM.nii should be replaced by /path/to/spm8/toolbox/Seg/TPM.nii
-# 
-#     >>> seg = MultiChannelNewSegment()
-#     >>> channel1= ('T1.nii',(0.0001, 60, (True, True)))
-#     >>> channel2= ('T2.nii',(0.0001, 60, (True, True)))
-#     >>> seg.inputs.channels = [channel1, channel2]
-#     >>> tissue1 = (('TPM.nii', 1), 2, (True,True), (False, False))
-#     >>> tissue2 = (('TPM.nii', 2), 2, (True,True), (False, False))
-#     >>> tissue3 = (('TPM.nii', 3), 2, (True,False), (False, False))
-#     >>> tissue4 = (('TPM.nii', 4), 2, (False,False), (False, False))
-#     >>> tissue5 = (('TPM.nii', 5), 2, (False,False), (False, False))
-#     >>> seg.inputs.tissues = [tissue1, tissue2, tissue3, tissue4, tissue5]
-#     >>> seg.run() # doctest: +SKIP
-# 
-#     
-task_name: MultiChannelNewSegment
-nipype_name: MultiChannelNewSegment
-nipype_module: nipype.interfaces.spm.preprocess
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    paths: generic/directory+list-of
-    # type=inputmultiobject|default=[]: Paths to add to matlabpath
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    channels:
-    # type=list|default=[]: A list of tuples (one per each channel) with the following fields:             - a list of channel files (only 1rst channel files will be segmented)             - a tuple with the following channel-specific info fields:               - bias reguralisation (0-10)               - FWHM of Gaussian smoothness of bias               - which maps to save (Field, Corrected) - a tuple of two boolean values
-    tissues:
-    # type=list|default=[]: A list of tuples (one per tissue) with the following fields:             - tissue probability map (4D), 1-based index to frame             - number of gaussians             - which maps to save [Native, DARTEL] - a tuple of two boolean values             - which maps to save [Unmodulated, Modulated] - a tuple of two boolean values
-    affine_regularization:
-    # type=enum|default='mni'|allowed['eastern','mni','none','subj']: mni, eastern, subj, none 
-    warping_regularization:
-    # type=traitcompound|default=None: Warping regularization parameter(s). Accepts float or list of floats (the latter is required by SPM12)
-    sampling_distance:
-    # type=float|default=0.0: Sampling distance on data for parameter estimation
-    write_deformation_fields:
-    # type=list|default=[]: Which deformation fields to write:[Inverse, Forward]
-    matlab_cmd:
-    # type=str|default='': matlab command to use
-    paths:
-    # type=inputmultiobject|default=[]: Paths to add to matlabpath
-    mfile:
-    # type=bool|default=True: Run m-code using m-file
-    use_mcr:
-    # type=bool|default=False: Run m-code using SPM MCR
-    use_v8struct:
-    # type=bool|default=True: Generate SPM8 and higher compatible jobs
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-spm/multi_channel_new_segment_callables.py b/example-specs/task/nipype_internal/pydra-spm/multi_channel_new_segment_callables.py
deleted file mode 100644
index 83317d0f..00000000
--- a/example-specs/task/nipype_internal/pydra-spm/multi_channel_new_segment_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in MultiChannelNewSegment.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-spm/multiple_regression_design.yaml b/example-specs/task/nipype_internal/pydra-spm/multiple_regression_design.yaml
deleted file mode 100644
index 9a190646..00000000
--- a/example-specs/task/nipype_internal/pydra-spm/multiple_regression_design.yaml
+++ /dev/null
@@ -1,120 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.spm.model.MultipleRegressionDesign' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Create SPM design for multiple regression
-# 
-#     Examples
-#     --------
-# 
-#     >>> mreg = MultipleRegressionDesign()
-#     >>> mreg.inputs.in_files = ['cont1.nii','cont2.nii']
-#     >>> mreg.run() # doctest: +SKIP
-#     
-task_name: MultipleRegressionDesign
-nipype_name: MultipleRegressionDesign
-nipype_module: nipype.interfaces.spm.model
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_files: generic/file+list-of
-    # type=list|default=[]: List of files
-    explicit_mask_file: generic/file
-    # type=file|default=<undefined>: use an implicit mask file to threshold
-    spm_mat_dir: generic/directory
-    # type=directory|default=<undefined>: directory to store SPM.mat file (opt)
-    paths: generic/directory+list-of
-    # type=inputmultiobject|default=[]: Paths to add to matlabpath
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    spm_mat_file: generic/file
-    # type=file: SPM mat file
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_files:
-    # type=list|default=[]: List of files
-    include_intercept:
-    # type=bool|default=True: Include intercept in design
-    user_covariates:
-    # type=inputmultiobject|default=[]: covariate dictionary {vector, name, centering}
-    spm_mat_dir:
-    # type=directory|default=<undefined>: directory to store SPM.mat file (opt)
-    covariates:
-    # type=inputmultiobject|default=[]: covariate dictionary {vector, name, interaction, centering}
-    threshold_mask_none:
-    # type=bool|default=False: do not use threshold masking
-    threshold_mask_absolute:
-    # type=float|default=0.0: use an absolute threshold
-    threshold_mask_relative:
-    # type=float|default=0.0: threshold using a proportion of the global value
-    use_implicit_threshold:
-    # type=bool|default=False: use implicit mask NaNs or zeros to threshold
-    explicit_mask_file:
-    # type=file|default=<undefined>: use an implicit mask file to threshold
-    global_calc_omit:
-    # type=bool|default=False: omit global calculation
-    global_calc_mean:
-    # type=bool|default=False: use mean for global calculation
-    global_calc_values:
-    # type=list|default=[]: omit global calculation
-    no_grand_mean_scaling:
-    # type=bool|default=False: do not perform grand mean scaling
-    global_normalization:
-    # type=enum|default=1|allowed[1,2,3]: global normalization None-1, Proportional-2, ANCOVA-3
-    matlab_cmd:
-    # type=str|default='': matlab command to use
-    paths:
-    # type=inputmultiobject|default=[]: Paths to add to matlabpath
-    mfile:
-    # type=bool|default=True: Run m-code using m-file
-    use_mcr:
-    # type=bool|default=False: Run m-code using SPM MCR
-    use_v8struct:
-    # type=bool|default=True: Generate SPM8 and higher compatible jobs
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-spm/multiple_regression_design_callables.py b/example-specs/task/nipype_internal/pydra-spm/multiple_regression_design_callables.py
deleted file mode 100644
index 2b1e9091..00000000
--- a/example-specs/task/nipype_internal/pydra-spm/multiple_regression_design_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in MultipleRegressionDesign.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-spm/new_segment.yaml b/example-specs/task/nipype_internal/pydra-spm/new_segment.yaml
deleted file mode 100644
index b530ad62..00000000
--- a/example-specs/task/nipype_internal/pydra-spm/new_segment.yaml
+++ /dev/null
@@ -1,116 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.spm.preprocess.NewSegment' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Use spm_preproc8 (New Segment) to separate structural images into
-#     different tissue classes. Supports multiple modalities.
-# 
-#     NOTE: This interface currently supports single channel input only
-# 
-#     http://www.fil.ion.ucl.ac.uk/spm/doc/manual.pdf#page=43
-# 
-#     Examples
-#     --------
-#     >>> import nipype.interfaces.spm as spm
-#     >>> seg = spm.NewSegment()
-#     >>> seg.inputs.channel_files = 'structural.nii'
-#     >>> seg.inputs.channel_info = (0.0001, 60, (True, True))
-#     >>> seg.run() # doctest: +SKIP
-# 
-#     For VBM pre-processing [http://www.fil.ion.ucl.ac.uk/~john/misc/VBMclass10.pdf],
-#     TPM.nii should be replaced by /path/to/spm8/toolbox/Seg/TPM.nii
-# 
-#     >>> seg = NewSegment()
-#     >>> seg.inputs.channel_files = 'structural.nii'
-#     >>> tissue1 = (('TPM.nii', 1), 2, (True,True), (False, False))
-#     >>> tissue2 = (('TPM.nii', 2), 2, (True,True), (False, False))
-#     >>> tissue3 = (('TPM.nii', 3), 2, (True,False), (False, False))
-#     >>> tissue4 = (('TPM.nii', 4), 2, (False,False), (False, False))
-#     >>> tissue5 = (('TPM.nii', 5), 2, (False,False), (False, False))
-#     >>> seg.inputs.tissues = [tissue1, tissue2, tissue3, tissue4, tissue5]
-#     >>> seg.run() # doctest: +SKIP
-# 
-#     
-task_name: NewSegment
-nipype_name: NewSegment
-nipype_module: nipype.interfaces.spm.preprocess
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    paths: generic/directory+list-of
-    # type=inputmultiobject|default=[]: Paths to add to matlabpath
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    channel_files:
-    # type=inputmultiobject|default=[]: A list of files to be segmented
-    channel_info:
-    # type=tuple|default=(0.0, 0.0, (False, False)): A tuple with the following fields:             - bias reguralisation (0-10)             - FWHM of Gaussian smoothness of bias             - which maps to save (Field, Corrected) - a tuple of two boolean values
-    tissues:
-    # type=list|default=[]: A list of tuples (one per tissue) with the following fields:             - tissue probability map (4D), 1-based index to frame             - number of gaussians             - which maps to save [Native, DARTEL] - a tuple of two boolean values             - which maps to save [Unmodulated, Modulated] - a tuple of two boolean values
-    affine_regularization:
-    # type=enum|default='mni'|allowed['eastern','mni','none','subj']: mni, eastern, subj, none 
-    warping_regularization:
-    # type=traitcompound|default=None: Warping regularization parameter(s). Accepts float or list of floats (the latter is required by SPM12)
-    sampling_distance:
-    # type=float|default=0.0: Sampling distance on data for parameter estimation
-    write_deformation_fields:
-    # type=list|default=[]: Which deformation fields to write:[Inverse, Forward]
-    matlab_cmd:
-    # type=str|default='': matlab command to use
-    paths:
-    # type=inputmultiobject|default=[]: Paths to add to matlabpath
-    mfile:
-    # type=bool|default=True: Run m-code using m-file
-    use_mcr:
-    # type=bool|default=False: Run m-code using SPM MCR
-    use_v8struct:
-    # type=bool|default=True: Generate SPM8 and higher compatible jobs
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-spm/new_segment_callables.py b/example-specs/task/nipype_internal/pydra-spm/new_segment_callables.py
deleted file mode 100644
index 65a698fa..00000000
--- a/example-specs/task/nipype_internal/pydra-spm/new_segment_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in NewSegment.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-spm/normalize.yaml b/example-specs/task/nipype_internal/pydra-spm/normalize.yaml
deleted file mode 100644
index 73aa658c..00000000
--- a/example-specs/task/nipype_internal/pydra-spm/normalize.yaml
+++ /dev/null
@@ -1,131 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.spm.preprocess.Normalize' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# use spm_normalise for warping an image to a template
-# 
-#     http://www.fil.ion.ucl.ac.uk/spm/doc/manual.pdf#page=203
-# 
-#     Examples
-#     --------
-#     >>> import nipype.interfaces.spm as spm
-#     >>> norm = spm.Normalize()
-#     >>> norm.inputs.source = 'functional.nii'
-#     >>> norm.run() # doctest: +SKIP
-# 
-#     
-task_name: Normalize
-nipype_name: Normalize
-nipype_module: nipype.interfaces.spm.preprocess
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    template: generic/file
-    # type=file|default=<undefined>: template file to normalize to
-    parameter_file: generic/file
-    # type=file|default=<undefined>: normalization parameter file*_sn.mat
-    source_weight: generic/file
-    # type=file|default=<undefined>: name of weighting image for source
-    template_weight: generic/file
-    # type=file|default=<undefined>: name of weighting image for template
-    paths: generic/directory+list-of
-    # type=inputmultiobject|default=[]: Paths to add to matlabpath
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    template:
-    # type=file|default=<undefined>: template file to normalize to
-    source:
-    # type=inputmultiobject|default=[]: file to normalize to template
-    jobtype:
-    # type=enum|default='estwrite'|allowed['est','estwrite','write']: Estimate, Write or do both
-    apply_to_files:
-    # type=inputmultiobject|default=[]: files to apply transformation to
-    parameter_file:
-    # type=file|default=<undefined>: normalization parameter file*_sn.mat
-    source_weight:
-    # type=file|default=<undefined>: name of weighting image for source
-    template_weight:
-    # type=file|default=<undefined>: name of weighting image for template
-    source_image_smoothing:
-    # type=float|default=0.0: source smoothing
-    template_image_smoothing:
-    # type=float|default=0.0: template smoothing
-    affine_regularization_type:
-    # type=enum|default='mni'|allowed['mni','none','size']: mni, size, none
-    DCT_period_cutoff:
-    # type=float|default=0.0: Cutoff of for DCT bases
-    nonlinear_iterations:
-    # type=int|default=0: Number of iterations of nonlinear warping
-    nonlinear_regularization:
-    # type=float|default=0.0: the amount of the regularization for the nonlinear part of the normalization
-    write_preserve:
-    # type=bool|default=False: True/False warped images are modulated
-    write_bounding_box:
-    # type=list|default=[]: 3x2-element list of lists
-    write_voxel_sizes:
-    # type=list|default=[]: 3-element list
-    write_interp:
-    # type=range|default=0: degree of b-spline used for interpolation
-    write_wrap:
-    # type=list|default=[]: Check if interpolation should wrap in [x,y,z] - list of bools
-    out_prefix:
-    # type=string|default='w': normalized output prefix
-    matlab_cmd:
-    # type=str|default='': matlab command to use
-    paths:
-    # type=inputmultiobject|default=[]: Paths to add to matlabpath
-    mfile:
-    # type=bool|default=True: Run m-code using m-file
-    use_mcr:
-    # type=bool|default=False: Run m-code using SPM MCR
-    use_v8struct:
-    # type=bool|default=True: Generate SPM8 and higher compatible jobs
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-spm/normalize_12.yaml b/example-specs/task/nipype_internal/pydra-spm/normalize_12.yaml
deleted file mode 100644
index eb5566a3..00000000
--- a/example-specs/task/nipype_internal/pydra-spm/normalize_12.yaml
+++ /dev/null
@@ -1,122 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.spm.preprocess.Normalize12' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# uses SPM12's new Normalise routine for warping an image to a template.
-#     Spatial normalisation is now done via the segmentation routine (which was
-#     known as ``New Segment`` in SPM8). Note that the normalisation in SPM12
-#     is done towards a file containing multiple tissue probability maps, which
-#     was not the case in SPM8.
-# 
-#     http://www.fil.ion.ucl.ac.uk/spm/doc/manual.pdf#page=49
-# 
-#     Examples
-#     --------
-#     >>> import nipype.interfaces.spm as spm
-#     >>> norm12 = spm.Normalize12()
-#     >>> norm12.inputs.image_to_align = 'structural.nii'
-#     >>> norm12.inputs.apply_to_files = 'functional.nii'
-#     >>> norm12.run() # doctest: +SKIP
-# 
-#     
-task_name: Normalize12
-nipype_name: Normalize12
-nipype_module: nipype.interfaces.spm.preprocess
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    tpm: generic/file
-    # type=file|default=<undefined>: template in form of tissue probablitiy maps to normalize to
-    paths: generic/directory+list-of
-    # type=inputmultiobject|default=[]: Paths to add to matlabpath
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    image_to_align:
-    # type=imagefilespm|default=<undefined>: file to estimate normalization parameters with
-    apply_to_files:
-    # type=inputmultiobject|default=[]: files to apply transformation to
-    deformation_file:
-    # type=imagefilespm|default=<undefined>: file y_*.nii containing 3 deformation fields for the deformation in x, y and z dimension
-    jobtype:
-    # type=enum|default='estwrite'|allowed['est','estwrite','write']: Estimate, Write or do Both
-    bias_regularization:
-    # type=enum|default=0|allowed[0,0.0001,0.001,0.01,0.1,1,10,1e-05]: no(0) - extremely heavy (10)
-    bias_fwhm:
-    # type=enum|default=30|allowed['Inf',100,110,120,130,140,150,30,40,50,60,70,80,90]: FWHM of Gaussian smoothness of bias
-    tpm:
-    # type=file|default=<undefined>: template in form of tissue probablitiy maps to normalize to
-    affine_regularization_type:
-    # type=enum|default='mni'|allowed['mni','none','size']: mni, size, none
-    warping_regularization:
-    # type=list|default=[]: controls balance between parameters and data
-    smoothness:
-    # type=float|default=0.0: value (in mm) to smooth the data before normalization
-    sampling_distance:
-    # type=float|default=0.0: Sampling distance on data for parameter estimation
-    write_bounding_box:
-    # type=list|default=[]: 3x2-element list of lists representing the bounding box (in mm) to be written
-    write_voxel_sizes:
-    # type=list|default=[]: 3-element list representing the voxel sizes (in mm) of the written normalised images
-    write_interp:
-    # type=range|default=0: degree of b-spline used for interpolation
-    out_prefix:
-    # type=string|default='w': Normalized output prefix
-    matlab_cmd:
-    # type=str|default='': matlab command to use
-    paths:
-    # type=inputmultiobject|default=[]: Paths to add to matlabpath
-    mfile:
-    # type=bool|default=True: Run m-code using m-file
-    use_mcr:
-    # type=bool|default=False: Run m-code using SPM MCR
-    use_v8struct:
-    # type=bool|default=True: Generate SPM8 and higher compatible jobs
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-spm/normalize_12_callables.py b/example-specs/task/nipype_internal/pydra-spm/normalize_12_callables.py
deleted file mode 100644
index 61c69cb7..00000000
--- a/example-specs/task/nipype_internal/pydra-spm/normalize_12_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in Normalize12.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-spm/normalize_callables.py b/example-specs/task/nipype_internal/pydra-spm/normalize_callables.py
deleted file mode 100644
index 795f3328..00000000
--- a/example-specs/task/nipype_internal/pydra-spm/normalize_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in Normalize.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-spm/one_sample_t_test_design.yaml b/example-specs/task/nipype_internal/pydra-spm/one_sample_t_test_design.yaml
deleted file mode 100644
index 4045fc85..00000000
--- a/example-specs/task/nipype_internal/pydra-spm/one_sample_t_test_design.yaml
+++ /dev/null
@@ -1,116 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.spm.model.OneSampleTTestDesign' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Create SPM design for one sample t-test
-# 
-#     Examples
-#     --------
-# 
-#     >>> ttest = OneSampleTTestDesign()
-#     >>> ttest.inputs.in_files = ['cont1.nii', 'cont2.nii']
-#     >>> ttest.run() # doctest: +SKIP
-#     
-task_name: OneSampleTTestDesign
-nipype_name: OneSampleTTestDesign
-nipype_module: nipype.interfaces.spm.model
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_files: generic/file+list-of
-    # type=list|default=[]: input files
-    explicit_mask_file: generic/file
-    # type=file|default=<undefined>: use an implicit mask file to threshold
-    spm_mat_dir: generic/directory
-    # type=directory|default=<undefined>: directory to store SPM.mat file (opt)
-    paths: generic/directory+list-of
-    # type=inputmultiobject|default=[]: Paths to add to matlabpath
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    spm_mat_file: generic/file
-    # type=file: SPM mat file
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_files:
-    # type=list|default=[]: input files
-    spm_mat_dir:
-    # type=directory|default=<undefined>: directory to store SPM.mat file (opt)
-    covariates:
-    # type=inputmultiobject|default=[]: covariate dictionary {vector, name, interaction, centering}
-    threshold_mask_none:
-    # type=bool|default=False: do not use threshold masking
-    threshold_mask_absolute:
-    # type=float|default=0.0: use an absolute threshold
-    threshold_mask_relative:
-    # type=float|default=0.0: threshold using a proportion of the global value
-    use_implicit_threshold:
-    # type=bool|default=False: use implicit mask NaNs or zeros to threshold
-    explicit_mask_file:
-    # type=file|default=<undefined>: use an implicit mask file to threshold
-    global_calc_omit:
-    # type=bool|default=False: omit global calculation
-    global_calc_mean:
-    # type=bool|default=False: use mean for global calculation
-    global_calc_values:
-    # type=list|default=[]: omit global calculation
-    no_grand_mean_scaling:
-    # type=bool|default=False: do not perform grand mean scaling
-    global_normalization:
-    # type=enum|default=1|allowed[1,2,3]: global normalization None-1, Proportional-2, ANCOVA-3
-    matlab_cmd:
-    # type=str|default='': matlab command to use
-    paths:
-    # type=inputmultiobject|default=[]: Paths to add to matlabpath
-    mfile:
-    # type=bool|default=True: Run m-code using m-file
-    use_mcr:
-    # type=bool|default=False: Run m-code using SPM MCR
-    use_v8struct:
-    # type=bool|default=True: Generate SPM8 and higher compatible jobs
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-spm/one_sample_t_test_design_callables.py b/example-specs/task/nipype_internal/pydra-spm/one_sample_t_test_design_callables.py
deleted file mode 100644
index df46a0f9..00000000
--- a/example-specs/task/nipype_internal/pydra-spm/one_sample_t_test_design_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in OneSampleTTestDesign.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-spm/paired_t_test_design.yaml b/example-specs/task/nipype_internal/pydra-spm/paired_t_test_design.yaml
deleted file mode 100644
index a15f248d..00000000
--- a/example-specs/task/nipype_internal/pydra-spm/paired_t_test_design.yaml
+++ /dev/null
@@ -1,118 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.spm.model.PairedTTestDesign' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Create SPM design for paired t-test
-# 
-#     Examples
-#     --------
-# 
-#     >>> pttest = PairedTTestDesign()
-#     >>> pttest.inputs.paired_files = [['cont1.nii','cont1a.nii'],['cont2.nii','cont2a.nii']]
-#     >>> pttest.run() # doctest: +SKIP
-#     
-task_name: PairedTTestDesign
-nipype_name: PairedTTestDesign
-nipype_module: nipype.interfaces.spm.model
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    explicit_mask_file: generic/file
-    # type=file|default=<undefined>: use an implicit mask file to threshold
-    spm_mat_dir: generic/directory
-    # type=directory|default=<undefined>: directory to store SPM.mat file (opt)
-    paths: generic/directory+list-of
-    # type=inputmultiobject|default=[]: Paths to add to matlabpath
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    spm_mat_file: generic/file
-    # type=file: SPM mat file
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    paired_files:
-    # type=list|default=[]: List of paired files
-    grand_mean_scaling:
-    # type=bool|default=False: Perform grand mean scaling
-    ancova:
-    # type=bool|default=False: Specify ancova-by-factor regressors
-    spm_mat_dir:
-    # type=directory|default=<undefined>: directory to store SPM.mat file (opt)
-    covariates:
-    # type=inputmultiobject|default=[]: covariate dictionary {vector, name, interaction, centering}
-    threshold_mask_none:
-    # type=bool|default=False: do not use threshold masking
-    threshold_mask_absolute:
-    # type=float|default=0.0: use an absolute threshold
-    threshold_mask_relative:
-    # type=float|default=0.0: threshold using a proportion of the global value
-    use_implicit_threshold:
-    # type=bool|default=False: use implicit mask NaNs or zeros to threshold
-    explicit_mask_file:
-    # type=file|default=<undefined>: use an implicit mask file to threshold
-    global_calc_omit:
-    # type=bool|default=False: omit global calculation
-    global_calc_mean:
-    # type=bool|default=False: use mean for global calculation
-    global_calc_values:
-    # type=list|default=[]: omit global calculation
-    no_grand_mean_scaling:
-    # type=bool|default=False: do not perform grand mean scaling
-    global_normalization:
-    # type=enum|default=1|allowed[1,2,3]: global normalization None-1, Proportional-2, ANCOVA-3
-    matlab_cmd:
-    # type=str|default='': matlab command to use
-    paths:
-    # type=inputmultiobject|default=[]: Paths to add to matlabpath
-    mfile:
-    # type=bool|default=True: Run m-code using m-file
-    use_mcr:
-    # type=bool|default=False: Run m-code using SPM MCR
-    use_v8struct:
-    # type=bool|default=True: Generate SPM8 and higher compatible jobs
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-spm/paired_t_test_design_callables.py b/example-specs/task/nipype_internal/pydra-spm/paired_t_test_design_callables.py
deleted file mode 100644
index 28e8ee93..00000000
--- a/example-specs/task/nipype_internal/pydra-spm/paired_t_test_design_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in PairedTTestDesign.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-spm/realign.yaml b/example-specs/task/nipype_internal/pydra-spm/realign.yaml
deleted file mode 100644
index 9f585fa4..00000000
--- a/example-specs/task/nipype_internal/pydra-spm/realign.yaml
+++ /dev/null
@@ -1,119 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.spm.preprocess.Realign' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Use spm_realign for estimating within modality rigid body alignment
-# 
-#     http://www.fil.ion.ucl.ac.uk/spm/doc/manual.pdf#page=25
-# 
-#     Examples
-#     --------
-# 
-#     >>> import nipype.interfaces.spm as spm
-#     >>> realign = spm.Realign()
-#     >>> realign.inputs.in_files = 'functional.nii'
-#     >>> realign.inputs.register_to_mean = True
-#     >>> realign.run() # doctest: +SKIP
-# 
-#     
-task_name: Realign
-nipype_name: Realign
-nipype_module: nipype.interfaces.spm.preprocess
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    weight_img: generic/file
-    # type=file|default=<undefined>: filename of weighting image
-    paths: generic/directory+list-of
-    # type=inputmultiobject|default=[]: Paths to add to matlabpath
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    mean_image: generic/file
-    # type=file: Mean image file from the realignment
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_files:
-    # type=inputmultiobject|default=[]: list of filenames to realign
-    jobtype:
-    # type=enum|default='estwrite'|allowed['estimate','estwrite','write']: one of: estimate, write, estwrite
-    quality:
-    # type=range|default=0.0: 0.1 = fast, 1.0 = precise
-    fwhm:
-    # type=range|default=0.0: gaussian smoothing kernel width
-    separation:
-    # type=range|default=0.0: sampling separation in mm
-    register_to_mean:
-    # type=bool|default=False: Indicate whether realignment is done to the mean image
-    weight_img:
-    # type=file|default=<undefined>: filename of weighting image
-    interp:
-    # type=range|default=0: degree of b-spline used for interpolation
-    wrap:
-    # type=list|default=[]: Check if interpolation should wrap in [x,y,z]
-    write_which:
-    # type=list|default=[2, 1]: determines which images to reslice
-    write_interp:
-    # type=range|default=0: degree of b-spline used for interpolation
-    write_wrap:
-    # type=list|default=[]: Check if interpolation should wrap in [x,y,z]
-    write_mask:
-    # type=bool|default=False: True/False mask output image
-    out_prefix:
-    # type=string|default='r': realigned output prefix
-    matlab_cmd:
-    # type=str|default='': matlab command to use
-    paths:
-    # type=inputmultiobject|default=[]: Paths to add to matlabpath
-    mfile:
-    # type=bool|default=True: Run m-code using m-file
-    use_mcr:
-    # type=bool|default=False: Run m-code using SPM MCR
-    use_v8struct:
-    # type=bool|default=True: Generate SPM8 and higher compatible jobs
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-spm/realign_callables.py b/example-specs/task/nipype_internal/pydra-spm/realign_callables.py
deleted file mode 100644
index 8460250c..00000000
--- a/example-specs/task/nipype_internal/pydra-spm/realign_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in Realign.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-spm/realign_unwarp.yaml b/example-specs/task/nipype_internal/pydra-spm/realign_unwarp.yaml
deleted file mode 100644
index b45b80d2..00000000
--- a/example-specs/task/nipype_internal/pydra-spm/realign_unwarp.yaml
+++ /dev/null
@@ -1,145 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.spm.preprocess.RealignUnwarp' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Use spm_uw_estimate for estimating within subject registration and unwarping
-#     of time series. Function accepts only one single field map. If in_files is a
-#     list of files they will be treated as separate sessions but associated to the
-#     same fieldmap.
-# 
-#     http://www.fil.ion.ucl.ac.uk/spm/doc/manual.pdf#page=31
-# 
-#     Examples
-#     --------
-# 
-#     >>> import nipype.interfaces.spm as spm
-#     >>> realignUnwarp = spm.RealignUnwarp()
-#     >>> realignUnwarp.inputs.in_files = ['functional.nii', 'functional2.nii']
-#     >>> realignUnwarp.inputs.phase_map = 'voxeldisplacemap.vdm'
-#     >>> realignUnwarp.inputs.register_to_mean = True
-#     >>> realignUnwarp.run() # doctest: +SKIP
-# 
-#     
-task_name: RealignUnwarp
-nipype_name: RealignUnwarp
-nipype_module: nipype.interfaces.spm.preprocess
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    phase_map: generic/file
-    # type=file|default=<undefined>: Voxel displacement map to use in unwarping. Unlike SPM standard behaviour, the same map will be used for all sessions
-    weight_img: generic/file
-    # type=file|default=<undefined>: filename of weighting image
-    paths: generic/directory+list-of
-    # type=inputmultiobject|default=[]: Paths to add to matlabpath
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    mean_image: generic/file
-    # type=file: Mean image file from the realignment & unwarping
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_files:
-    # type=inputmultiobject|default=[]: list of filenames to realign and unwarp
-    phase_map:
-    # type=file|default=<undefined>: Voxel displacement map to use in unwarping. Unlike SPM standard behaviour, the same map will be used for all sessions
-    quality:
-    # type=range|default=0.0: 0.1 = fast, 1.0 = precise
-    fwhm:
-    # type=range|default=0.0: gaussian smoothing kernel width
-    separation:
-    # type=range|default=0.0: sampling separation in mm
-    register_to_mean:
-    # type=bool|default=False: Indicate whether realignment is done to the mean image
-    weight_img:
-    # type=file|default=<undefined>: filename of weighting image
-    interp:
-    # type=range|default=0: degree of b-spline used for interpolation
-    wrap:
-    # type=list|default=[]: Check if interpolation should wrap in [x,y,z]
-    est_basis_func:
-    # type=list|default=[]: Number of basis functions to use for each dimension
-    est_reg_order:
-    # type=range|default=0: This parameter determines how to balance the compromise between likelihood maximization and smoothness maximization of the estimated field.
-    est_reg_factor:
-    # type=list|default=[100000]: Regularisation factor. Default: 100000 (medium).
-    est_jacobian_deformations:
-    # type=bool|default=False: Jacobian deformations. In theory a good idea to include them,  in practice a bad idea. Default: No.
-    est_first_order_effects:
-    # type=list|default=[]: First order effects should only depend on pitch and roll, i.e. [4 5]
-    est_second_order_effects:
-    # type=list|default=[]: List of second order terms to model second derivatives of.
-    est_unwarp_fwhm:
-    # type=range|default=0.0: gaussian smoothing kernel width for unwarp
-    est_re_est_mov_par:
-    # type=bool|default=False: Re-estimate movement parameters at each unwarping iteration.
-    est_num_of_iterations:
-    # type=list|default=[5]: Number of iterations.
-    est_taylor_expansion_point:
-    # type=string|default='Average': Point in position space to perform Taylor-expansion around.
-    reslice_which:
-    # type=list|default=[2, 1]: determines which images to reslice
-    reslice_interp:
-    # type=range|default=0: degree of b-spline used for interpolation
-    reslice_wrap:
-    # type=list|default=[]: Check if interpolation should wrap in [x,y,z]
-    reslice_mask:
-    # type=bool|default=False: True/False mask output image
-    out_prefix:
-    # type=string|default='u': realigned and unwarped output prefix
-    matlab_cmd:
-    # type=str|default='': matlab command to use
-    paths:
-    # type=inputmultiobject|default=[]: Paths to add to matlabpath
-    mfile:
-    # type=bool|default=True: Run m-code using m-file
-    use_mcr:
-    # type=bool|default=False: Run m-code using SPM MCR
-    use_v8struct:
-    # type=bool|default=True: Generate SPM8 and higher compatible jobs
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-spm/realign_unwarp_callables.py b/example-specs/task/nipype_internal/pydra-spm/realign_unwarp_callables.py
deleted file mode 100644
index 98e49c21..00000000
--- a/example-specs/task/nipype_internal/pydra-spm/realign_unwarp_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in RealignUnwarp.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-spm/reslice.yaml b/example-specs/task/nipype_internal/pydra-spm/reslice.yaml
deleted file mode 100644
index 20b6a72f..00000000
--- a/example-specs/task/nipype_internal/pydra-spm/reslice.yaml
+++ /dev/null
@@ -1,93 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.spm.utils.Reslice' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# uses  spm_reslice to resample in_file into space of space_defining
-task_name: Reslice
-nipype_name: Reslice
-nipype_module: nipype.interfaces.spm.utils
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_file: generic/file
-    # type=file|default=<undefined>: file to apply transform to, (only updates header)
-    space_defining: generic/file
-    # type=file|default=<undefined>: Volume defining space to slice in_file into
-    out_file: generic/file
-    # type=file: resliced volume
-    # type=file|default=<undefined>: Optional file to save resliced volume
-    paths: generic/directory+list-of
-    # type=inputmultiobject|default=[]: Paths to add to matlabpath
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    out_file: generic/file
-    # type=file: resliced volume
-    # type=file|default=<undefined>: Optional file to save resliced volume
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: file to apply transform to, (only updates header)
-    space_defining:
-    # type=file|default=<undefined>: Volume defining space to slice in_file into
-    interp:
-    # type=range|default=0: degree of b-spline used for interpolation0 is nearest neighbor (default)
-    out_file:
-    # type=file: resliced volume
-    # type=file|default=<undefined>: Optional file to save resliced volume
-    matlab_cmd:
-    # type=str|default='': matlab command to use
-    paths:
-    # type=inputmultiobject|default=[]: Paths to add to matlabpath
-    mfile:
-    # type=bool|default=True: Run m-code using m-file
-    use_mcr:
-    # type=bool|default=False: Run m-code using SPM MCR
-    use_v8struct:
-    # type=bool|default=True: Generate SPM8 and higher compatible jobs
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-spm/reslice_callables.py b/example-specs/task/nipype_internal/pydra-spm/reslice_callables.py
deleted file mode 100644
index 7d5ac3b8..00000000
--- a/example-specs/task/nipype_internal/pydra-spm/reslice_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in Reslice.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-spm/reslice_to_reference.yaml b/example-specs/task/nipype_internal/pydra-spm/reslice_to_reference.yaml
deleted file mode 100644
index 4eaeeea5..00000000
--- a/example-specs/task/nipype_internal/pydra-spm/reslice_to_reference.yaml
+++ /dev/null
@@ -1,99 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.spm.utils.ResliceToReference' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Uses spm to reslice a volume to a target image space or to a provided
-#     voxel size and bounding box
-# 
-#     Examples
-#     --------
-# 
-#     >>> import nipype.interfaces.spm.utils as spmu
-#     >>> r2ref = spmu.ResliceToReference()
-#     >>> r2ref.inputs.in_files = 'functional.nii'
-#     >>> r2ref.inputs.target = 'structural.nii'
-#     >>> r2ref.run() # doctest: +SKIP
-#     
-task_name: ResliceToReference
-nipype_name: ResliceToReference
-nipype_module: nipype.interfaces.spm.utils
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_files: generic/file+list-of
-    # type=inputmultiobject|default=[]: Files on which deformation is applied
-    target: generic/file
-    # type=file|default=<undefined>: File defining target space
-    paths: generic/directory+list-of
-    # type=inputmultiobject|default=[]: Paths to add to matlabpath
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_files:
-    # type=inputmultiobject|default=[]: Files on which deformation is applied
-    target:
-    # type=file|default=<undefined>: File defining target space
-    interpolation:
-    # type=range|default=0: degree of b-spline used for interpolation
-    bounding_box:
-    # type=list|default=[]: 6-element list (opt)
-    voxel_sizes:
-    # type=list|default=[]: 3-element list (opt)
-    matlab_cmd:
-    # type=str|default='': matlab command to use
-    paths:
-    # type=inputmultiobject|default=[]: Paths to add to matlabpath
-    mfile:
-    # type=bool|default=True: Run m-code using m-file
-    use_mcr:
-    # type=bool|default=False: Run m-code using SPM MCR
-    use_v8struct:
-    # type=bool|default=True: Generate SPM8 and higher compatible jobs
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-spm/reslice_to_reference_callables.py b/example-specs/task/nipype_internal/pydra-spm/reslice_to_reference_callables.py
deleted file mode 100644
index 73561569..00000000
--- a/example-specs/task/nipype_internal/pydra-spm/reslice_to_reference_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in ResliceToReference.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-spm/segment.yaml b/example-specs/task/nipype_internal/pydra-spm/segment.yaml
deleted file mode 100644
index 8efbe84b..00000000
--- a/example-specs/task/nipype_internal/pydra-spm/segment.yaml
+++ /dev/null
@@ -1,146 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.spm.preprocess.Segment' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# use spm_segment to separate structural images into different
-#     tissue classes.
-# 
-#     http://www.fil.ion.ucl.ac.uk/spm/doc/manual.pdf#page=209
-# 
-#     Examples
-#     --------
-#     >>> import nipype.interfaces.spm as spm
-#     >>> seg = spm.Segment()
-#     >>> seg.inputs.data = 'structural.nii'
-#     >>> seg.run() # doctest: +SKIP
-# 
-#     
-task_name: Segment
-nipype_name: Segment
-nipype_module: nipype.interfaces.spm.preprocess
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    tissue_prob_maps: generic/file+list-of
-    # type=list|default=[]: list of gray, white & csf prob. (opt,)
-    mask_image: generic/file
-    # type=file|default=<undefined>: Binary image to restrict parameter estimation 
-    paths: generic/directory+list-of
-    # type=inputmultiobject|default=[]: Paths to add to matlabpath
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    native_gm_image: generic/file
-    # type=file: native space grey probability map
-    normalized_gm_image: generic/file
-    # type=file: normalized grey probability map
-    modulated_gm_image: generic/file
-    # type=file: modulated, normalized grey probability map
-    native_wm_image: generic/file
-    # type=file: native space white probability map
-    normalized_wm_image: generic/file
-    # type=file: normalized white probability map
-    modulated_wm_image: generic/file
-    # type=file: modulated, normalized white probability map
-    native_csf_image: generic/file
-    # type=file: native space csf probability map
-    normalized_csf_image: generic/file
-    # type=file: normalized csf probability map
-    modulated_csf_image: generic/file
-    # type=file: modulated, normalized csf probability map
-    modulated_input_image: generic/file
-    # type=file: bias-corrected version of input image
-    bias_corrected_image: generic/file
-    # type=file: bias-corrected version of input image
-    transformation_mat: generic/file
-    # type=file: Normalization transformation
-    inverse_transformation_mat: generic/file
-    # type=file: Inverse normalization info
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    data:
-    # type=inputmultiobject|default=[]: one scan per subject
-    gm_output_type:
-    # type=list|default=[]: Options to produce grey matter images: c1*.img, wc1*.img and mwc1*.img.             None: [False,False,False],             Native Space: [False,False,True],             Unmodulated Normalised: [False,True,False],             Modulated Normalised: [True,False,False],             Native + Unmodulated Normalised: [False,True,True],             Native + Modulated Normalised: [True,False,True],             Native + Modulated + Unmodulated: [True,True,True],             Modulated + Unmodulated Normalised: [True,True,False]
-    wm_output_type:
-    # type=list|default=[]:              Options to produce white matter images: c2*.img, wc2*.img and mwc2*.img.             None: [False,False,False],             Native Space: [False,False,True],             Unmodulated Normalised: [False,True,False],             Modulated Normalised: [True,False,False],             Native + Unmodulated Normalised: [False,True,True],             Native + Modulated Normalised: [True,False,True],             Native + Modulated + Unmodulated: [True,True,True],             Modulated + Unmodulated Normalised: [True,True,False]
-    csf_output_type:
-    # type=list|default=[]:              Options to produce CSF images: c3*.img, wc3*.img and mwc3*.img.             None: [False,False,False],             Native Space: [False,False,True],             Unmodulated Normalised: [False,True,False],             Modulated Normalised: [True,False,False],             Native + Unmodulated Normalised: [False,True,True],             Native + Modulated Normalised: [True,False,True],             Native + Modulated + Unmodulated: [True,True,True],             Modulated + Unmodulated Normalised: [True,True,False]
-    save_bias_corrected:
-    # type=bool|default=False: True/False produce a bias corrected image
-    clean_masks:
-    # type=enum|default='no'|allowed['light','no','thorough']: clean using estimated brain mask ('no','light','thorough')
-    tissue_prob_maps:
-    # type=list|default=[]: list of gray, white & csf prob. (opt,)
-    gaussians_per_class:
-    # type=list|default=[]: num Gaussians capture intensity distribution
-    affine_regularization:
-    # type=enum|default='mni'|allowed['','eastern','mni','none','subj']: Possible options: "mni", "eastern", "subj", "none" (no reguralisation), "" (no affine registration)
-    warping_regularization:
-    # type=float|default=0.0: Controls balance between parameters and data
-    warp_frequency_cutoff:
-    # type=float|default=0.0: Cutoff of DCT bases
-    bias_regularization:
-    # type=enum|default=0|allowed[0,0.0001,0.001,0.01,0.1,1,10,1e-05]: no(0) - extremely heavy (10)
-    bias_fwhm:
-    # type=enum|default=30|allowed['Inf',100,110,120,130,30,40,50,60,70,80,90]: FWHM of Gaussian smoothness of bias
-    sampling_distance:
-    # type=float|default=0.0: Sampling distance on data for parameter estimation
-    mask_image:
-    # type=file|default=<undefined>: Binary image to restrict parameter estimation 
-    matlab_cmd:
-    # type=str|default='': matlab command to use
-    paths:
-    # type=inputmultiobject|default=[]: Paths to add to matlabpath
-    mfile:
-    # type=bool|default=True: Run m-code using m-file
-    use_mcr:
-    # type=bool|default=False: Run m-code using SPM MCR
-    use_v8struct:
-    # type=bool|default=True: Generate SPM8 and higher compatible jobs
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-spm/segment_callables.py b/example-specs/task/nipype_internal/pydra-spm/segment_callables.py
deleted file mode 100644
index 9cb3d9e6..00000000
--- a/example-specs/task/nipype_internal/pydra-spm/segment_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in Segment.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-spm/slice_timing.yaml b/example-specs/task/nipype_internal/pydra-spm/slice_timing.yaml
deleted file mode 100644
index 625bc155..00000000
--- a/example-specs/task/nipype_internal/pydra-spm/slice_timing.yaml
+++ /dev/null
@@ -1,105 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.spm.preprocess.SliceTiming' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Use spm to perform slice timing correction.
-# 
-#     http://www.fil.ion.ucl.ac.uk/spm/doc/manual.pdf#page=19
-# 
-#     Examples
-#     --------
-# 
-#     >>> from nipype.interfaces.spm import SliceTiming
-#     >>> st = SliceTiming()
-#     >>> st.inputs.in_files = 'functional.nii'
-#     >>> st.inputs.num_slices = 32
-#     >>> st.inputs.time_repetition = 6.0
-#     >>> st.inputs.time_acquisition = 6. - 6./32.
-#     >>> st.inputs.slice_order = list(range(32,0,-1))
-#     >>> st.inputs.ref_slice = 1
-#     >>> st.run() # doctest: +SKIP
-# 
-#     
-task_name: SliceTiming
-nipype_name: SliceTiming
-nipype_module: nipype.interfaces.spm.preprocess
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    paths: generic/directory+list-of
-    # type=inputmultiobject|default=[]: Paths to add to matlabpath
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_files:
-    # type=inputmultiobject|default=[]: list of filenames to apply slice timing
-    num_slices:
-    # type=int|default=0: number of slices in a volume
-    time_repetition:
-    # type=float|default=0.0: time between volume acquisitions (start to start time)
-    time_acquisition:
-    # type=float|default=0.0: time of volume acquisition. usually calculated as TR-(TR/num_slices)
-    slice_order:
-    # type=list|default=[]: 1-based order or onset (in ms) in which slices are acquired
-    ref_slice:
-    # type=traitcompound|default=None: 1-based Number of the reference slice or reference time point if slice_order is in onsets (ms)
-    out_prefix:
-    # type=string|default='a': slicetimed output prefix
-    matlab_cmd:
-    # type=str|default='': matlab command to use
-    paths:
-    # type=inputmultiobject|default=[]: Paths to add to matlabpath
-    mfile:
-    # type=bool|default=True: Run m-code using m-file
-    use_mcr:
-    # type=bool|default=False: Run m-code using SPM MCR
-    use_v8struct:
-    # type=bool|default=True: Generate SPM8 and higher compatible jobs
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-spm/slice_timing_callables.py b/example-specs/task/nipype_internal/pydra-spm/slice_timing_callables.py
deleted file mode 100644
index 230aaf91..00000000
--- a/example-specs/task/nipype_internal/pydra-spm/slice_timing_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in SliceTiming.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-spm/smooth.yaml b/example-specs/task/nipype_internal/pydra-spm/smooth.yaml
deleted file mode 100644
index 0d7d7c28..00000000
--- a/example-specs/task/nipype_internal/pydra-spm/smooth.yaml
+++ /dev/null
@@ -1,95 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.spm.preprocess.Smooth' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Use spm_smooth for 3D Gaussian smoothing of image volumes.
-# 
-#     http://www.fil.ion.ucl.ac.uk/spm/doc/manual.pdf#page=55
-# 
-#     Examples
-#     --------
-#     >>> import nipype.interfaces.spm as spm
-#     >>> smooth = spm.Smooth()
-#     >>> smooth.inputs.in_files = 'functional.nii'
-#     >>> smooth.inputs.fwhm = [4, 4, 4]
-#     >>> smooth.run() # doctest: +SKIP
-#     
-task_name: Smooth
-nipype_name: Smooth
-nipype_module: nipype.interfaces.spm.preprocess
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    paths: generic/directory+list-of
-    # type=inputmultiobject|default=[]: Paths to add to matlabpath
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_files:
-    # type=inputmultiobject|default=[]: list of files to smooth
-    fwhm:
-    # type=traitcompound|default=None: 3-list of fwhm for each dimension
-    data_type:
-    # type=int|default=0: Data type of the output images
-    implicit_masking:
-    # type=bool|default=False: A mask implied by a particular voxel value
-    out_prefix:
-    # type=string|default='s': smoothed output prefix
-    matlab_cmd:
-    # type=str|default='': matlab command to use
-    paths:
-    # type=inputmultiobject|default=[]: Paths to add to matlabpath
-    mfile:
-    # type=bool|default=True: Run m-code using m-file
-    use_mcr:
-    # type=bool|default=False: Run m-code using SPM MCR
-    use_v8struct:
-    # type=bool|default=True: Generate SPM8 and higher compatible jobs
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-spm/smooth_callables.py b/example-specs/task/nipype_internal/pydra-spm/smooth_callables.py
deleted file mode 100644
index 5dbe8c1a..00000000
--- a/example-specs/task/nipype_internal/pydra-spm/smooth_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in Smooth.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-spm/threshold.yaml b/example-specs/task/nipype_internal/pydra-spm/threshold.yaml
deleted file mode 100644
index ec2a7c1b..00000000
--- a/example-specs/task/nipype_internal/pydra-spm/threshold.yaml
+++ /dev/null
@@ -1,117 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.spm.model.Threshold' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Topological FDR thresholding based on cluster extent/size. Smoothness is
-#     estimated from GLM residuals but is assumed to be the same for all of the
-#     voxels.
-# 
-#     Examples
-#     --------
-# 
-#     >>> thresh = Threshold()
-#     >>> thresh.inputs.spm_mat_file = 'SPM.mat'
-#     >>> thresh.inputs.stat_image = 'spmT_0001.img'
-#     >>> thresh.inputs.contrast_index = 1
-#     >>> thresh.inputs.extent_fdr_p_threshold = 0.05
-#     >>> thresh.run() # doctest: +SKIP
-#     
-task_name: Threshold
-nipype_name: Threshold
-nipype_module: nipype.interfaces.spm.model
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    spm_mat_file: generic/file
-    # type=file|default=<undefined>: absolute path to SPM.mat
-    stat_image: generic/file
-    # type=file|default=<undefined>: stat image
-    paths: generic/directory+list-of
-    # type=inputmultiobject|default=[]: Paths to add to matlabpath
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    thresholded_map: generic/file
-    # type=file: 
-    pre_topo_fdr_map: generic/file
-    # type=file: 
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    spm_mat_file:
-    # type=file|default=<undefined>: absolute path to SPM.mat
-    stat_image:
-    # type=file|default=<undefined>: stat image
-    contrast_index:
-    # type=int|default=0: which contrast in the SPM.mat to use
-    use_fwe_correction:
-    # type=bool|default=True: whether to use FWE (Bonferroni) correction for initial threshold (height_threshold_type has to be set to p-value)
-    use_vox_fdr_correction:
-    # type=bool|default=False: whether to use voxel-based FDR correction for initial threshold (height_threshold_type has to be set to q-value)
-    use_topo_fdr:
-    # type=bool|default=True: whether to use FDR over cluster extent probabilities
-    height_threshold:
-    # type=float|default=0.05: value for initial thresholding (defining clusters)
-    height_threshold_type:
-    # type=enum|default='p-value'|allowed['p-value','stat']: Is the cluster forming threshold a stat value or p-value?
-    extent_fdr_p_threshold:
-    # type=float|default=0.05: p threshold on FDR corrected cluster size probabilities
-    extent_threshold:
-    # type=int|default=0: Minimum cluster size in voxels
-    force_activation:
-    # type=bool|default=False: In case no clusters survive the topological inference step this will pick a culster with the highest sum of t-values. Use with care.
-    matlab_cmd:
-    # type=str|default='': matlab command to use
-    paths:
-    # type=inputmultiobject|default=[]: Paths to add to matlabpath
-    mfile:
-    # type=bool|default=True: Run m-code using m-file
-    use_mcr:
-    # type=bool|default=False: Run m-code using SPM MCR
-    use_v8struct:
-    # type=bool|default=True: Generate SPM8 and higher compatible jobs
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-spm/threshold_callables.py b/example-specs/task/nipype_internal/pydra-spm/threshold_callables.py
deleted file mode 100644
index a542f78f..00000000
--- a/example-specs/task/nipype_internal/pydra-spm/threshold_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in Threshold.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-spm/threshold_statistics.yaml b/example-specs/task/nipype_internal/pydra-spm/threshold_statistics.yaml
deleted file mode 100644
index 31df06bb..00000000
--- a/example-specs/task/nipype_internal/pydra-spm/threshold_statistics.yaml
+++ /dev/null
@@ -1,100 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.spm.model.ThresholdStatistics' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Given height and cluster size threshold calculate theoretical
-#     probabilities concerning false positives
-# 
-#     Examples
-#     --------
-# 
-#     >>> thresh = ThresholdStatistics()
-#     >>> thresh.inputs.spm_mat_file = 'SPM.mat'
-#     >>> thresh.inputs.stat_image = 'spmT_0001.img'
-#     >>> thresh.inputs.contrast_index = 1
-#     >>> thresh.inputs.height_threshold = 4.56
-#     >>> thresh.run() # doctest: +SKIP
-#     
-task_name: ThresholdStatistics
-nipype_name: ThresholdStatistics
-nipype_module: nipype.interfaces.spm.model
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    spm_mat_file: generic/file
-    # type=file|default=<undefined>: absolute path to SPM.mat
-    stat_image: generic/file
-    # type=file|default=<undefined>: stat image
-    paths: generic/directory+list-of
-    # type=inputmultiobject|default=[]: Paths to add to matlabpath
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    spm_mat_file:
-    # type=file|default=<undefined>: absolute path to SPM.mat
-    stat_image:
-    # type=file|default=<undefined>: stat image
-    contrast_index:
-    # type=int|default=0: which contrast in the SPM.mat to use
-    height_threshold:
-    # type=float|default=0.0: stat value for initial thresholding (defining clusters)
-    extent_threshold:
-    # type=int|default=0: Minimum cluster size in voxels
-    matlab_cmd:
-    # type=str|default='': matlab command to use
-    paths:
-    # type=inputmultiobject|default=[]: Paths to add to matlabpath
-    mfile:
-    # type=bool|default=True: Run m-code using m-file
-    use_mcr:
-    # type=bool|default=False: Run m-code using SPM MCR
-    use_v8struct:
-    # type=bool|default=True: Generate SPM8 and higher compatible jobs
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-spm/threshold_statistics_callables.py b/example-specs/task/nipype_internal/pydra-spm/threshold_statistics_callables.py
deleted file mode 100644
index 7ef3621e..00000000
--- a/example-specs/task/nipype_internal/pydra-spm/threshold_statistics_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in ThresholdStatistics.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-spm/two_sample_t_test_design.yaml b/example-specs/task/nipype_internal/pydra-spm/two_sample_t_test_design.yaml
deleted file mode 100644
index 968fa1e7..00000000
--- a/example-specs/task/nipype_internal/pydra-spm/two_sample_t_test_design.yaml
+++ /dev/null
@@ -1,125 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.spm.model.TwoSampleTTestDesign' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Create SPM design for two sample t-test
-# 
-#     Examples
-#     --------
-# 
-#     >>> ttest = TwoSampleTTestDesign()
-#     >>> ttest.inputs.group1_files = ['cont1.nii', 'cont2.nii']
-#     >>> ttest.inputs.group2_files = ['cont1a.nii', 'cont2a.nii']
-#     >>> ttest.run() # doctest: +SKIP
-#     
-task_name: TwoSampleTTestDesign
-nipype_name: TwoSampleTTestDesign
-nipype_module: nipype.interfaces.spm.model
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    group1_files: generic/file+list-of
-    # type=list|default=[]: Group 1 input files
-    group2_files: generic/file+list-of
-    # type=list|default=[]: Group 2 input files
-    explicit_mask_file: generic/file
-    # type=file|default=<undefined>: use an implicit mask file to threshold
-    spm_mat_dir: generic/directory
-    # type=directory|default=<undefined>: directory to store SPM.mat file (opt)
-    paths: generic/directory+list-of
-    # type=inputmultiobject|default=[]: Paths to add to matlabpath
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    spm_mat_file: generic/file
-    # type=file: SPM mat file
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    group1_files:
-    # type=list|default=[]: Group 1 input files
-    group2_files:
-    # type=list|default=[]: Group 2 input files
-    dependent:
-    # type=bool|default=False: Are the measurements dependent between levels
-    unequal_variance:
-    # type=bool|default=False: Are the variances equal or unequal between groups
-    spm_mat_dir:
-    # type=directory|default=<undefined>: directory to store SPM.mat file (opt)
-    covariates:
-    # type=inputmultiobject|default=[]: covariate dictionary {vector, name, interaction, centering}
-    threshold_mask_none:
-    # type=bool|default=False: do not use threshold masking
-    threshold_mask_absolute:
-    # type=float|default=0.0: use an absolute threshold
-    threshold_mask_relative:
-    # type=float|default=0.0: threshold using a proportion of the global value
-    use_implicit_threshold:
-    # type=bool|default=False: use implicit mask NaNs or zeros to threshold
-    explicit_mask_file:
-    # type=file|default=<undefined>: use an implicit mask file to threshold
-    global_calc_omit:
-    # type=bool|default=False: omit global calculation
-    global_calc_mean:
-    # type=bool|default=False: use mean for global calculation
-    global_calc_values:
-    # type=list|default=[]: omit global calculation
-    no_grand_mean_scaling:
-    # type=bool|default=False: do not perform grand mean scaling
-    global_normalization:
-    # type=enum|default=1|allowed[1,2,3]: global normalization None-1, Proportional-2, ANCOVA-3
-    matlab_cmd:
-    # type=str|default='': matlab command to use
-    paths:
-    # type=inputmultiobject|default=[]: Paths to add to matlabpath
-    mfile:
-    # type=bool|default=True: Run m-code using m-file
-    use_mcr:
-    # type=bool|default=False: Run m-code using SPM MCR
-    use_v8struct:
-    # type=bool|default=True: Generate SPM8 and higher compatible jobs
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-spm/two_sample_t_test_design_callables.py b/example-specs/task/nipype_internal/pydra-spm/two_sample_t_test_design_callables.py
deleted file mode 100644
index 844a84cb..00000000
--- a/example-specs/task/nipype_internal/pydra-spm/two_sample_t_test_design_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in TwoSampleTTestDesign.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-spm/vbm_segment.yaml b/example-specs/task/nipype_internal/pydra-spm/vbm_segment.yaml
deleted file mode 100644
index 523b4eca..00000000
--- a/example-specs/task/nipype_internal/pydra-spm/vbm_segment.yaml
+++ /dev/null
@@ -1,156 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.spm.preprocess.VBMSegment' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# Use VBM8 toolbox to separate structural images into different
-#     tissue classes.
-# 
-#     Example
-#     -------
-#     >>> import nipype.interfaces.spm as spm
-#     >>> seg = spm.VBMSegment()
-#     >>> seg.inputs.tissues = 'TPM.nii'
-#     >>> seg.inputs.dartel_template = 'Template_1_IXI550_MNI152.nii'
-#     >>> seg.inputs.bias_corrected_native = True
-#     >>> seg.inputs.gm_native = True
-#     >>> seg.inputs.wm_native = True
-#     >>> seg.inputs.csf_native = True
-#     >>> seg.inputs.pve_label_native = True
-#     >>> seg.inputs.deformation_field = (True, False)
-#     >>> seg.run() # doctest: +SKIP
-#     
-task_name: VBMSegment
-nipype_name: VBMSegment
-nipype_module: nipype.interfaces.spm.preprocess
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    paths: generic/directory+list-of
-    # type=inputmultiobject|default=[]: Paths to add to matlabpath
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_files:
-    # type=inputmultiobject|default=[]: A list of files to be segmented
-    tissues:
-    # type=imagefilespm|default=<undefined>: tissue probability map
-    gaussians_per_class:
-    # type=tuple|default=(2, 2, 2, 3, 4, 2): number of gaussians for each tissue class
-    bias_regularization:
-    # type=enum|default=0.0001|allowed[0,0.0001,0.001,0.01,0.1,1,10,1e-05]: no(0) - extremely heavy (10)
-    bias_fwhm:
-    # type=enum|default=60|allowed['Inf',100,110,120,130,30,40,50,60,70,80,90]: FWHM of Gaussian smoothness of bias
-    sampling_distance:
-    # type=float|default=3: Sampling distance on data for parameter estimation
-    warping_regularization:
-    # type=float|default=4: Controls balance between parameters and data
-    spatial_normalization:
-    # type=enum|default='high'|allowed['high','low']: 
-    dartel_template:
-    # type=imagefilespm|default=<undefined>: 
-    use_sanlm_denoising_filter:
-    # type=range|default=2: 0=No denoising, 1=denoising,2=denoising multi-threaded
-    mrf_weighting:
-    # type=float|default=0.15: 
-    cleanup_partitions:
-    # type=int|default=1: 0=None,1=light,2=thorough
-    display_results:
-    # type=bool|default=True: 
-    gm_native:
-    # type=bool|default=False: 
-    gm_normalized:
-    # type=bool|default=False: 
-    gm_modulated_normalized:
-    # type=range|default=2: 0=none,1=affine+non-linear(SPM8 default),2=non-linear only
-    gm_dartel:
-    # type=range|default=0: 0=None,1=rigid(SPM8 default),2=affine
-    wm_native:
-    # type=bool|default=False: 
-    wm_normalized:
-    # type=bool|default=False: 
-    wm_modulated_normalized:
-    # type=range|default=2: 0=none,1=affine+non-linear(SPM8 default),2=non-linear only
-    wm_dartel:
-    # type=range|default=0: 0=None,1=rigid(SPM8 default),2=affine
-    csf_native:
-    # type=bool|default=False: 
-    csf_normalized:
-    # type=bool|default=False: 
-    csf_modulated_normalized:
-    # type=range|default=2: 0=none,1=affine+non-linear(SPM8 default),2=non-linear only
-    csf_dartel:
-    # type=range|default=0: 0=None,1=rigid(SPM8 default),2=affine
-    bias_corrected_native:
-    # type=bool|default=False: 
-    bias_corrected_normalized:
-    # type=bool|default=True: 
-    bias_corrected_affine:
-    # type=bool|default=False: 
-    pve_label_native:
-    # type=bool|default=False: 
-    pve_label_normalized:
-    # type=bool|default=False: 
-    pve_label_dartel:
-    # type=range|default=0: 0=None,1=rigid(SPM8 default),2=affine
-    jacobian_determinant:
-    # type=bool|default=False: 
-    deformation_field:
-    # type=tuple|default=(0, 0): forward and inverse field
-    matlab_cmd:
-    # type=str|default='': matlab command to use
-    paths:
-    # type=inputmultiobject|default=[]: Paths to add to matlabpath
-    mfile:
-    # type=bool|default=True: Run m-code using m-file
-    use_mcr:
-    # type=bool|default=False: Run m-code using SPM MCR
-    use_v8struct:
-    # type=bool|default=True: Generate SPM8 and higher compatible jobs
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype_internal/pydra-spm/vbm_segment_callables.py b/example-specs/task/nipype_internal/pydra-spm/vbm_segment_callables.py
deleted file mode 100644
index 31b90684..00000000
--- a/example-specs/task/nipype_internal/pydra-spm/vbm_segment_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in VBMSegment.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-vista/vnifti_2_image.yaml b/example-specs/task/nipype_internal/pydra-vista/vnifti_2_image.yaml
deleted file mode 100644
index 668753b1..00000000
--- a/example-specs/task/nipype_internal/pydra-vista/vnifti_2_image.yaml
+++ /dev/null
@@ -1,127 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.vista.vista.Vnifti2Image' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Convert a nifti file into a vista file.
-# 
-#     Example
-#     -------
-#     >>> vimage = Vnifti2Image()
-#     >>> vimage.inputs.in_file = 'image.nii'
-#     >>> vimage.cmdline
-#     'vnifti2image -in image.nii -out image.v'
-#     >>> vimage.run()  # doctest: +SKIP
-# 
-#     
-task_name: Vnifti2Image
-nipype_name: Vnifti2Image
-nipype_module: nipype.interfaces.vista.vista
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_file: medimage/nifti1
-    # type=file|default=<undefined>: in file
-    attributes: generic/file
-    # type=file|default=<undefined>: attribute file
-    out_file: generic/file
-    # type=file: Output vista file
-    # type=file|default=<undefined>: output data file
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    out_file: generic/file
-    # type=file: Output vista file
-    # type=file|default=<undefined>: output data file
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: in file
-    attributes:
-    # type=file|default=<undefined>: attribute file
-    out_file:
-    # type=file: Output vista file
-    # type=file|default=<undefined>: output data file
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: in file
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests:
-- cmdline: vnifti2image -in image.nii -out image.v
-  # str - the expected cmdline output
-  inputs:
-  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
-  # If the field is of file-format type and the value is None, then the
-  # '.mock()' method of the corresponding class is used instead.
-    in_file:
-    # type=file|default=<undefined>: in file
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  directive:
-  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-vista/vnifti_2_image_callables.py b/example-specs/task/nipype_internal/pydra-vista/vnifti_2_image_callables.py
deleted file mode 100644
index ad1abcaa..00000000
--- a/example-specs/task/nipype_internal/pydra-vista/vnifti_2_image_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in Vnifti2Image.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-vista/vto_mat.yaml b/example-specs/task/nipype_internal/pydra-vista/vto_mat.yaml
deleted file mode 100644
index 2f6286e8..00000000
--- a/example-specs/task/nipype_internal/pydra-vista/vto_mat.yaml
+++ /dev/null
@@ -1,123 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.vista.vista.VtoMat' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Convert a nifti file into a vista file.
-# 
-#     Example
-#     -------
-#     >>> vimage = VtoMat()
-#     >>> vimage.inputs.in_file = 'image.v'
-#     >>> vimage.cmdline
-#     'vtomat -in image.v -out image.mat'
-#     >>> vimage.run()  # doctest: +SKIP
-# 
-#     
-task_name: VtoMat
-nipype_name: VtoMat
-nipype_module: nipype.interfaces.vista.vista
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_file: medimage-vista/v
-    # type=file|default=<undefined>: in file
-    out_file: generic/file
-    # type=file: Output mat file
-    # type=file|default=<undefined>: output mat file
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    out_file: generic/file
-    # type=file: Output mat file
-    # type=file|default=<undefined>: output mat file
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: in file
-    out_file:
-    # type=file: Output mat file
-    # type=file|default=<undefined>: output mat file
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: in file
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests:
-- cmdline: vtomat -in image.v -out image.mat
-  # str - the expected cmdline output
-  inputs:
-  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
-  # If the field is of file-format type and the value is None, then the
-  # '.mock()' method of the corresponding class is used instead.
-    in_file:
-    # type=file|default=<undefined>: in file
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  directive:
-  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-vista/vto_mat_callables.py b/example-specs/task/nipype_internal/pydra-vista/vto_mat_callables.py
deleted file mode 100644
index 3c28eba0..00000000
--- a/example-specs/task/nipype_internal/pydra-vista/vto_mat_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in VtoMat.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-workbench/cifti_smooth.yaml b/example-specs/task/nipype_internal/pydra-workbench/cifti_smooth.yaml
deleted file mode 100644
index 390ee0c8..00000000
--- a/example-specs/task/nipype_internal/pydra-workbench/cifti_smooth.yaml
+++ /dev/null
@@ -1,203 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.workbench.cifti.CiftiSmooth' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Smooth a CIFTI file
-# 
-#     The input cifti file must have a brain models mapping on the chosen
-#     dimension, columns for .dtseries, and either for .dconn.  By default,
-#     data in different structures is smoothed independently (i.e., "parcel
-#     constrained" smoothing), so volume structures that touch do not smooth
-#     across this boundary.  Specify ``merged_volume`` to ignore these
-#     boundaries. Surface smoothing uses the ``GEO_GAUSS_AREA`` smoothing method.
-# 
-#     The ``*_corrected_areas`` options are intended for when it is unavoidable
-#     to smooth on group average surfaces, it is only an approximate correction
-#     for the reduction of structure in a group average surface.  It is better
-#     to smooth the data on individuals before averaging, when feasible.
-# 
-#     The ``fix_zeros_*`` options will treat values of zero as lack of data, and
-#     not use that value when generating the smoothed values, but will fill
-#     zeros with extrapolated values.  The ROI should have a brain models
-#     mapping along columns, exactly matching the mapping of the chosen
-#     direction in the input file.  Data outside the ROI is ignored.
-# 
-#     >>> from nipype.interfaces.workbench import CiftiSmooth
-#     >>> smooth = CiftiSmooth()
-#     >>> smooth.inputs.in_file = 'sub-01_task-rest.dtseries.nii'
-#     >>> smooth.inputs.sigma_surf = 4
-#     >>> smooth.inputs.sigma_vol = 4
-#     >>> smooth.inputs.direction = 'COLUMN'
-#     >>> smooth.inputs.right_surf = 'sub-01.R.midthickness.32k_fs_LR.surf.gii'
-#     >>> smooth.inputs.left_surf = 'sub-01.L.midthickness.32k_fs_LR.surf.gii'
-#     >>> smooth.cmdline
-#     'wb_command -cifti-smoothing sub-01_task-rest.dtseries.nii 4.0 4.0 COLUMN     smoothed_sub-01_task-rest.dtseries.nii     -left-surface sub-01.L.midthickness.32k_fs_LR.surf.gii     -right-surface sub-01.R.midthickness.32k_fs_LR.surf.gii'
-#     
-task_name: CiftiSmooth
-nipype_name: CiftiSmooth
-nipype_module: nipype.interfaces.workbench.cifti
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_file: medimage/nifti1
-    # type=file|default=<undefined>: The input CIFTI file
-    out_file: generic/file
-    # type=file: output CIFTI file
-    # type=file|default=<undefined>: The output CIFTI
-    left_surf: medimage/gifti
-    # type=file|default=<undefined>: Specify the left surface to use
-    left_corrected_areas: generic/file
-    # type=file|default=<undefined>: vertex areas (as a metric) to use instead of computing them from the left surface.
-    right_surf: medimage/gifti
-    # type=file|default=<undefined>: Specify the right surface to use
-    right_corrected_areas: generic/file
-    # type=file|default=<undefined>: vertex areas (as a metric) to use instead of computing them from the right surface
-    cerebellum_surf: generic/file
-    # type=file|default=<undefined>: specify the cerebellum surface to use
-    cerebellum_corrected_areas: generic/file
-    # type=file|default=<undefined>: vertex areas (as a metric) to use instead of computing them from the cerebellum surface
-    cifti_roi: generic/file
-    # type=file|default=<undefined>: CIFTI file for ROI smoothing
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    out_file: generic/file
-    # type=file: output CIFTI file
-    # type=file|default=<undefined>: The output CIFTI
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: The input CIFTI file
-    sigma_surf:
-    # type=float|default=0.0: the sigma for the gaussian surface smoothing kernel, in mm
-    sigma_vol:
-    # type=float|default=0.0: the sigma for the gaussian volume smoothing kernel, in mm
-    direction:
-    # type=enum|default='ROW'|allowed['COLUMN','ROW']: which dimension to smooth along, ROW or COLUMN
-    out_file:
-    # type=file: output CIFTI file
-    # type=file|default=<undefined>: The output CIFTI
-    left_surf:
-    # type=file|default=<undefined>: Specify the left surface to use
-    left_corrected_areas:
-    # type=file|default=<undefined>: vertex areas (as a metric) to use instead of computing them from the left surface.
-    right_surf:
-    # type=file|default=<undefined>: Specify the right surface to use
-    right_corrected_areas:
-    # type=file|default=<undefined>: vertex areas (as a metric) to use instead of computing them from the right surface
-    cerebellum_surf:
-    # type=file|default=<undefined>: specify the cerebellum surface to use
-    cerebellum_corrected_areas:
-    # type=file|default=<undefined>: vertex areas (as a metric) to use instead of computing them from the cerebellum surface
-    cifti_roi:
-    # type=file|default=<undefined>: CIFTI file for ROI smoothing
-    fix_zeros_vol:
-    # type=bool|default=False: treat values of zero in the volume as missing data
-    fix_zeros_surf:
-    # type=bool|default=False: treat values of zero on the surface as missing data
-    merged_volume:
-    # type=bool|default=False: smooth across subcortical structure boundaries
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: The input CIFTI file
-    sigma_surf: '4'
-    # type=float|default=0.0: the sigma for the gaussian surface smoothing kernel, in mm
-    sigma_vol: '4'
-    # type=float|default=0.0: the sigma for the gaussian volume smoothing kernel, in mm
-    direction: '"COLUMN"'
-    # type=enum|default='ROW'|allowed['COLUMN','ROW']: which dimension to smooth along, ROW or COLUMN
-    right_surf:
-    # type=file|default=<undefined>: Specify the right surface to use
-    left_surf:
-    # type=file|default=<undefined>: Specify the left surface to use
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests:
-- cmdline: wb_command -cifti-smoothing sub-01_task-rest.dtseries.nii 4.0 4.0 COLUMN smoothed_sub-01_task-rest.dtseries.nii -left-surface sub-01.L.midthickness.32k_fs_LR.surf.gii -right-surface sub-01.R.midthickness.32k_fs_LR.surf.gii
-  # str - the expected cmdline output
-  inputs:
-  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
-  # If the field is of file-format type and the value is None, then the
-  # '.mock()' method of the corresponding class is used instead.
-    in_file:
-    # type=file|default=<undefined>: The input CIFTI file
-    sigma_surf: '4'
-    # type=float|default=0.0: the sigma for the gaussian surface smoothing kernel, in mm
-    sigma_vol: '4'
-    # type=float|default=0.0: the sigma for the gaussian volume smoothing kernel, in mm
-    direction: '"COLUMN"'
-    # type=enum|default='ROW'|allowed['COLUMN','ROW']: which dimension to smooth along, ROW or COLUMN
-    right_surf:
-    # type=file|default=<undefined>: Specify the right surface to use
-    left_surf:
-    # type=file|default=<undefined>: Specify the left surface to use
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  directive:
-  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-workbench/cifti_smooth_callables.py b/example-specs/task/nipype_internal/pydra-workbench/cifti_smooth_callables.py
deleted file mode 100644
index 24080d97..00000000
--- a/example-specs/task/nipype_internal/pydra-workbench/cifti_smooth_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in CiftiSmooth.yaml"""
diff --git a/example-specs/task/nipype_internal/pydra-workbench/metric_resample.yaml b/example-specs/task/nipype_internal/pydra-workbench/metric_resample.yaml
deleted file mode 100644
index 670dc849..00000000
--- a/example-specs/task/nipype_internal/pydra-workbench/metric_resample.yaml
+++ /dev/null
@@ -1,200 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.workbench.metric.MetricResample' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Resample a metric file to a different mesh
-# 
-#     Resamples a metric file, given two spherical surfaces that are in
-#     register.  If ``ADAP_BARY_AREA`` is used, exactly one of -area-surfs or
-#     ``-area-metrics`` must be specified.
-# 
-#     The ``ADAP_BARY_AREA`` method is recommended for ordinary metric data,
-#     because it should use all data while downsampling, unlike ``BARYCENTRIC``.
-#     The recommended areas option for most data is individual midthicknesses
-#     for individual data, and averaged vertex area metrics from individual
-#     midthicknesses for group average data.
-# 
-#     The ``-current-roi`` option only masks the input, the output may be slightly
-#     dilated in comparison, consider using ``-metric-mask`` on the output when
-#     using ``-current-roi``.
-# 
-#     The ``-largest option`` results in nearest vertex behavior when used with
-#     ``BARYCENTRIC``.  When resampling a binary metric, consider thresholding at
-#     0.5 after resampling rather than using ``-largest``.
-# 
-#     >>> from nipype.interfaces.workbench import MetricResample
-#     >>> metres = MetricResample()
-#     >>> metres.inputs.in_file = 'sub-01_task-rest_bold_space-fsaverage5.L.func.gii'
-#     >>> metres.inputs.method = 'ADAP_BARY_AREA'
-#     >>> metres.inputs.current_sphere = 'fsaverage5_std_sphere.L.10k_fsavg_L.surf.gii'
-#     >>> metres.inputs.new_sphere = 'fs_LR-deformed_to-fsaverage.L.sphere.32k_fs_LR.surf.gii'
-#     >>> metres.inputs.area_metrics = True
-#     >>> metres.inputs.current_area = 'fsaverage5.L.midthickness_va_avg.10k_fsavg_L.shape.gii'
-#     >>> metres.inputs.new_area = 'fs_LR.L.midthickness_va_avg.32k_fs_LR.shape.gii'
-#     >>> metres.cmdline
-#     'wb_command -metric-resample sub-01_task-rest_bold_space-fsaverage5.L.func.gii     fsaverage5_std_sphere.L.10k_fsavg_L.surf.gii     fs_LR-deformed_to-fsaverage.L.sphere.32k_fs_LR.surf.gii     ADAP_BARY_AREA fs_LR-deformed_to-fsaverage.L.sphere.32k_fs_LR.surf.out     -area-metrics fsaverage5.L.midthickness_va_avg.10k_fsavg_L.shape.gii     fs_LR.L.midthickness_va_avg.32k_fs_LR.shape.gii'
-#     
-task_name: MetricResample
-nipype_name: MetricResample
-nipype_module: nipype.interfaces.workbench.metric
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    in_file: medimage/gifti
-    # type=file|default=<undefined>: The metric file to resample
-    current_sphere: medimage/gifti
-    # type=file|default=<undefined>: A sphere surface with the mesh that the metric is currently on
-    new_sphere: medimage/gifti
-    # type=file|default=<undefined>: A sphere surface that is in register with <current-sphere> and has the desired output mesh
-    out_file: generic/file
-    # type=file: the output metric
-    # type=file|default=<undefined>: The output metric
-    current_area: medimage/gifti
-    # type=file|default=<undefined>: A relevant anatomical surface with <current-sphere> mesh OR a metric file with vertex areas for <current-sphere> mesh
-    new_area: medimage/gifti
-    # type=file|default=<undefined>: A relevant anatomical surface with <current-sphere> mesh OR a metric file with vertex areas for <current-sphere> mesh
-    roi_metric: generic/file
-    # type=file|default=<undefined>: Input roi on the current mesh used to exclude non-data vertices
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    out_file: generic/file
-    # type=file: the output metric
-    # type=file|default=<undefined>: The output metric
-    roi_file: generic/file
-    # type=file: ROI of vertices that got data from valid source vertices
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: The metric file to resample
-    current_sphere:
-    # type=file|default=<undefined>: A sphere surface with the mesh that the metric is currently on
-    new_sphere:
-    # type=file|default=<undefined>: A sphere surface that is in register with <current-sphere> and has the desired output mesh
-    method:
-    # type=enum|default='ADAP_BARY_AREA'|allowed['ADAP_BARY_AREA','BARYCENTRIC']: The method name - ADAP_BARY_AREA method is recommended for ordinary metric data, because it should use all data while downsampling, unlike BARYCENTRIC. If ADAP_BARY_AREA is used, exactly one of area_surfs or area_metrics must be specified
-    out_file:
-    # type=file: the output metric
-    # type=file|default=<undefined>: The output metric
-    area_surfs:
-    # type=bool|default=False: Specify surfaces to do vertex area correction based on
-    area_metrics:
-    # type=bool|default=False: Specify vertex area metrics to do area correction based on
-    current_area:
-    # type=file|default=<undefined>: A relevant anatomical surface with <current-sphere> mesh OR a metric file with vertex areas for <current-sphere> mesh
-    new_area:
-    # type=file|default=<undefined>: A relevant anatomical surface with <current-sphere> mesh OR a metric file with vertex areas for <current-sphere> mesh
-    roi_metric:
-    # type=file|default=<undefined>: Input roi on the current mesh used to exclude non-data vertices
-    valid_roi_out:
-    # type=bool|default=False: Output the ROI of vertices that got data from valid source vertices
-    largest:
-    # type=bool|default=False: Use only the value of the vertex with the largest weight
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    in_file:
-    # type=file|default=<undefined>: The metric file to resample
-    method: '"ADAP_BARY_AREA"'
-    # type=enum|default='ADAP_BARY_AREA'|allowed['ADAP_BARY_AREA','BARYCENTRIC']: The method name - ADAP_BARY_AREA method is recommended for ordinary metric data, because it should use all data while downsampling, unlike BARYCENTRIC. If ADAP_BARY_AREA is used, exactly one of area_surfs or area_metrics must be specified
-    current_sphere:
-    # type=file|default=<undefined>: A sphere surface with the mesh that the metric is currently on
-    new_sphere:
-    # type=file|default=<undefined>: A sphere surface that is in register with <current-sphere> and has the desired output mesh
-    area_metrics: 'True'
-    # type=bool|default=False: Specify vertex area metrics to do area correction based on
-    current_area:
-    # type=file|default=<undefined>: A relevant anatomical surface with <current-sphere> mesh OR a metric file with vertex areas for <current-sphere> mesh
-    new_area:
-    # type=file|default=<undefined>: A relevant anatomical surface with <current-sphere> mesh OR a metric file with vertex areas for <current-sphere> mesh
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests:
-- cmdline: wb_command -metric-resample sub-01_task-rest_bold_space-fsaverage5.L.func.gii fsaverage5_std_sphere.L.10k_fsavg_L.surf.gii fs_LR-deformed_to-fsaverage.L.sphere.32k_fs_LR.surf.gii ADAP_BARY_AREA fs_LR-deformed_to-fsaverage.L.sphere.32k_fs_LR.surf.out -area-metrics fsaverage5.L.midthickness_va_avg.10k_fsavg_L.shape.gii fs_LR.L.midthickness_va_avg.32k_fs_LR.shape.gii
-  # str - the expected cmdline output
-  inputs:
-  # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
-  # If the field is of file-format type and the value is None, then the
-  # '.mock()' method of the corresponding class is used instead.
-    in_file:
-    # type=file|default=<undefined>: The metric file to resample
-    method: '"ADAP_BARY_AREA"'
-    # type=enum|default='ADAP_BARY_AREA'|allowed['ADAP_BARY_AREA','BARYCENTRIC']: The method name - ADAP_BARY_AREA method is recommended for ordinary metric data, because it should use all data while downsampling, unlike BARYCENTRIC. If ADAP_BARY_AREA is used, exactly one of area_surfs or area_metrics must be specified
-    current_sphere:
-    # type=file|default=<undefined>: A sphere surface with the mesh that the metric is currently on
-    new_sphere:
-    # type=file|default=<undefined>: A sphere surface that is in register with <current-sphere> and has the desired output mesh
-    area_metrics: 'True'
-    # type=bool|default=False: Specify vertex area metrics to do area correction based on
-    current_area:
-    # type=file|default=<undefined>: A relevant anatomical surface with <current-sphere> mesh OR a metric file with vertex areas for <current-sphere> mesh
-    new_area:
-    # type=file|default=<undefined>: A relevant anatomical surface with <current-sphere> mesh OR a metric file with vertex areas for <current-sphere> mesh
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  directive:
-  # str - any doctest directive to place on the cmdline call, e.g. # doctest: +ELLIPSIS
diff --git a/example-specs/task/nipype_internal/pydra-workbench/metric_resample_callables.py b/example-specs/task/nipype_internal/pydra-workbench/metric_resample_callables.py
deleted file mode 100644
index 10b1a9fb..00000000
--- a/example-specs/task/nipype_internal/pydra-workbench/metric_resample_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in MetricResample.yaml"""
diff --git a/nipype2pydra/task/function.py b/nipype2pydra/task/function.py
index b7ab0a79..febeea51 100644
--- a/nipype2pydra/task/function.py
+++ b/nipype2pydra/task/function.py
@@ -150,14 +150,18 @@ def process_method(
         method_body = self.process_method_body(method_body, input_names, output_names)
         if self.method_returns.get(method.__name__):
             return_args = self.method_returns[method.__name__]
-            method_body = ("    " + " = ".join(return_args) + " = attrs.NOTHING\n" + method_body)
+            method_body = (
+                "    " + " = ".join(return_args) + " = attrs.NOTHING\n" + method_body
+            )
             method_lines = method_body.splitlines()
             method_body = "\n".join(method_lines[:-1])
             last_line = method_lines[-1]
             if "return" in last_line:
                 method_body += "," + ",".join(return_args)
             else:
-                method_body += "\n" + last_line + "\n    return " + ",".join(return_args)
+                method_body += (
+                    "\n" + last_line + "\n    return " + ",".join(return_args)
+                )
         return f"{pre.strip()}{', '.join(args)}{return_types}:\n{method_body}"
 
     def process_method_body(
@@ -194,11 +198,15 @@ def process_method_body(
         new_body = splits[0]
         for name, args in zip(splits[1::2], splits[2::2]):
             if self.method_returns[name]:
-                match = re.match(r".*\n *([a-zA-Z0-9\,\. ]+ *=)? *$", new_body, flags=re.MULTILINE | re.DOTALL)
+                match = re.match(
+                    r".*\n *([a-zA-Z0-9\,\. ]+ *=)? *$",
+                    new_body,
+                    flags=re.MULTILINE | re.DOTALL,
+                )
                 if match:
                     if match.group(1):
                         new_body_lines = new_body.splitlines()
-                        new_body = '\n'.join(new_body_lines[:-1])
+                        new_body = "\n".join(new_body_lines[:-1])
                         last_line = new_body_lines[-1]
                         new_body += "\n" + re.sub(
                             r"^ *([a-zA-Z0-9\,\. ]+) *= *$",
@@ -474,7 +482,7 @@ def _get_referenced(
             where the dictionary key is the names of the methods
         """
         method_body = inspect.getsource(method)
-        method_body = re.sub(r"\s*#.*", "", method_body)
+        method_body = re.sub(r"\s*#.*", "", method_body)  # Strip out comments
         ref_local_func_names = re.findall(r"(?<!self\.)(\w+)\(", method_body)
         ref_local_funcs = set(
             f
@@ -497,7 +505,9 @@ def _get_referenced(
                 )
             )
         for func in ref_local_funcs:
-            rf_inputs, rf_outputs = self._get_referenced(func, referenced_funcs, referenced_methods)
+            rf_inputs, rf_outputs = self._get_referenced(
+                func, referenced_funcs, referenced_methods
+            )
             referenced_inputs.update(rf_inputs)
             referenced_outputs.update(rf_outputs)
         for meth in ref_methods:
@@ -596,12 +606,12 @@ def split_parens_contents(snippet, brackets: bool = False):
         the text after the closing parenthesis
     """
     if brackets:
-        open = '['
-        close = ']'
+        open = "["
+        close = "]"
         pattern = r"(\[|\])"
     else:
-        open = '('
-        close = ')'
+        open = "("
+        close = ")"
         pattern = r"(\(|\))"
     splits = re.split(pattern, snippet, flags=re.MULTILINE | re.DOTALL)
     depth = 1
diff --git a/scripts/pkg_gen/afni-qwarp-only.yaml b/scripts/pkg_gen/afni-qwarp-only.yaml
new file mode 100644
index 00000000..24496784
--- /dev/null
+++ b/scripts/pkg_gen/afni-qwarp-only.yaml
@@ -0,0 +1,6 @@
+packages:
+- afni
+interfaces:
+  afni:
+  - QwarpPlusMinus
+  
\ No newline at end of file
diff --git a/scripts/pkg_gen/create_packages.py b/scripts/pkg_gen/create_packages.py
index a178c276..d572a048 100644
--- a/scripts/pkg_gen/create_packages.py
+++ b/scripts/pkg_gen/create_packages.py
@@ -7,6 +7,7 @@
 import subprocess as sp
 import shutil
 import tarfile
+import string
 from pathlib import Path
 import attrs
 from warnings import warn
@@ -34,6 +35,8 @@
 
 EXPECTED_FORMATS = [Nifti1, NiftiGz, TextFile, TextMatrix, DatFile, Xml]
 
+EXT_SPECIAL_CHARS = tuple((set(string.punctuation) - set(".-")) | set(" "))
+
 
 def ext2format_name(ext: str) -> str:
     return escape_leading_digits(ext[1:]).capitalize()
@@ -91,6 +94,7 @@ def download_tasks_template(output_path: Path):
 @click.option("--work-dir", type=click.Path(path_type=Path), default=None)
 @click.option("--task-template", type=click.Path(path_type=Path), default=None)
 @click.option("--packages-to-import", type=click.Path(path_type=Path), default=None)
+@click.option("--example-packages", type=click.Path(path_type=Path), default=None, help="Packages to save into the example-spec directory")
 @click.option(
     "--base-package",
     type=str,
@@ -103,6 +107,7 @@ def generate_packages(
     task_template: ty.Optional[Path],
     packages_to_import: ty.Optional[Path],
     base_package: str,
+    example_packages: ty.Optional[Path],
 ):
     if work_dir is None:
         work_dir = Path(tempfile.mkdtemp())
@@ -262,6 +267,8 @@ def guess_type(fspath):
                                     fspath.strip(),
                                     mode=File.ExtensionDecomposition.single,
                                 )[2]
+                                if any(c in format_ext for c in EXT_SPECIAL_CHARS):
+                                    return File  # Skip any extensions with special chars
                                 unmatched_formats.append(
                                     f"{module}.{interface}: {fspath}"
                                 )
@@ -467,6 +474,22 @@ def combine_types(type_, prev_type):
         )
         sp.check_call("git tag 0.1.0", shell=True, cwd=pkg_dir)
 
+    if example_packages:
+        with open(example_packages) as f:
+            example_pkg_names = yaml.load(f, Loader=yaml.SafeLoader)
+
+        basepkg = base_package
+        if base_package.endswith(".interfaces"):
+            basepkg = basepkg[:-len(".interfaces")]
+
+        examples_dir = Path(__file__).parent.parent.parent / "example-specs" / "task" / basepkg
+        if examples_dir.exists():
+            shutil.rmtree(examples_dir)
+        examples_dir.mkdir()
+        for example_pkg_name in example_pkg_names:
+            specs_dir = output_dir / ("pydra-" + example_pkg_name) / "nipype-auto-conv" / "specs"
+            shutil.copytree(specs_dir, examples_dir / example_pkg_name)
+
     unmatched_extensions = set(
         File.decompose_fspath(
             f.split(":")[1].strip(), mode=File.ExtensionDecomposition.single
@@ -587,6 +610,7 @@ def parse_nipype_interface(
     """Generate preamble comments at start of file with args and doc strings"""
     input_helps = {}
     file_inputs = []
+    file_outputs = []
     dir_inputs = []
     genfile_outputs = []
     multi_inputs = []
@@ -603,7 +627,10 @@ def parse_nipype_interface(
             if inpt.genfile:
                 genfile_outputs.append(inpt_name)
             elif trait_type_name == "File":
-                file_inputs.append(inpt_name)
+                if isinstance(inpt.default, str) or "out_" in inpt_name:
+                    file_outputs.append(inpt_name)
+                else:
+                    file_inputs.append(inpt_name)
             elif trait_type_name == "Directory":
                 dir_inputs.append(inpt_name)
             elif trait_type_name == "InputMultiObject":
@@ -623,7 +650,6 @@ def parse_nipype_interface(
                 else:
                     dir_inputs.append(inpt_name)
                 multi_inputs.append(inpt_name)
-    file_outputs = []
     dir_outputs = []
     output_helps = {}
     if nipype_interface.output_spec:
diff --git a/scripts/pkg_gen/example-packages.yaml b/scripts/pkg_gen/example-packages.yaml
new file mode 100644
index 00000000..865e6fd8
--- /dev/null
+++ b/scripts/pkg_gen/example-packages.yaml
@@ -0,0 +1,4 @@
+- afni
+- ants
+- freesurfer
+- fsl
diff --git a/tests/test_task.py b/tests/test_task.py
index ef2b505a..4b689b83 100644
--- a/tests/test_task.py
+++ b/tests/test_task.py
@@ -5,6 +5,7 @@
 from conftest import show_cli_trace
 from nipype2pydra.cli import task as task_cli
 from nipype2pydra.utils import add_to_sys_path, add_exc_note
+from conftest import EXAMPLE_TASKS_DIR
 
 
 logging.basicConfig(level=logging.INFO)
@@ -19,7 +20,20 @@
     "output_type",
 ]
 
+XFAIL_PACKAGES = ["camino", "cat12", "cmtk", "dcmsstack", "dipy", "spm"]
 
+
+@pytest.fixture(
+    params=[
+        str(p.relative_to(EXAMPLE_TASKS_DIR)).replace("/", "__")[:-5]
+        for p in (EXAMPLE_TASKS_DIR).glob("**/*.yaml")
+    ]
+)
+def task_spec_file(request):
+    return EXAMPLE_TASKS_DIR.joinpath(*request.param.split("__")).with_suffix(".yaml")
+
+
+@pytest.mark.xfail(condition="any(str(task_spec_file).startswith(str(EXAMPLE_TASKS_DIR / ('pydra-' + p))) for p in XFAIL_PACKAGES)")
 def test_task_conversion(task_spec_file, cli_runner, work_dir, gen_test_conftest):
 
     with open(task_spec_file) as f:

From d586e7af624216affb1402e3860fdc743304e434 Mon Sep 17 00:00:00 2001
From: Tom Close <tom.g.close@gmail.com>
Date: Wed, 6 Mar 2024 11:55:21 +1100
Subject: [PATCH 49/78] fixed up output file types

---
 .../task/nipype/afni/a_boverlap.yaml          |   3 +
 .../task/nipype/afni/afn_ito_nifti.yaml       |   3 +
 example-specs/task/nipype/afni/allineate.yaml |  28 +++-
 .../task/nipype/afni/auto_tcorrelate.yaml     |   3 +
 example-specs/task/nipype/afni/autobox.yaml   |   3 +
 example-specs/task/nipype/afni/automask.yaml  |   5 +-
 example-specs/task/nipype/afni/axialize.yaml  |   3 +
 example-specs/task/nipype/afni/bandpass.yaml  |   3 +
 .../task/nipype/afni/blur_in_mask.yaml        |   3 +
 .../task/nipype/afni/blur_to_fwhm.yaml        |   3 +
 example-specs/task/nipype/afni/bucket.yaml    |   3 +
 example-specs/task/nipype/afni/calc.yaml      |   3 +
 example-specs/task/nipype/afni/cat.yaml       |   3 +
 .../task/nipype/afni/cat_matvec.yaml          |   3 +
 .../task/nipype/afni/center_mass.yaml         |  12 +-
 .../task/nipype/afni/convert_dset.yaml        |   3 +
 example-specs/task/nipype/afni/copy.yaml      |   3 +
 .../task/nipype/afni/deconvolve.yaml          |   9 +-
 .../task/nipype/afni/degree_centrality.yaml   |   9 +-
 example-specs/task/nipype/afni/despike.yaml   |   3 +
 example-specs/task/nipype/afni/detrend.yaml   |   3 +
 example-specs/task/nipype/afni/dot.yaml       |   5 +-
 example-specs/task/nipype/afni/ecm.yaml       |   3 +
 example-specs/task/nipype/afni/edge_3.yaml    |   3 +
 example-specs/task/nipype/afni/eval.yaml      |   3 +
 example-specs/task/nipype/afni/fim.yaml       |   3 +
 example-specs/task/nipype/afni/fourier.yaml   |   3 +
 example-specs/task/nipype/afni/fwh_mx.yaml    |   9 ++
 example-specs/task/nipype/afni/hist.yaml      |   6 +
 example-specs/task/nipype/afni/lfcd.yaml      |   3 +
 .../task/nipype/afni/local_bistat.yaml        |   3 +
 example-specs/task/nipype/afni/localstat.yaml |   3 +
 example-specs/task/nipype/afni/mask_tool.yaml |   3 +
 example-specs/task/nipype/afni/maskave.yaml   |   3 +
 example-specs/task/nipype/afni/means.yaml     |   3 +
 example-specs/task/nipype/afni/merge.yaml     |   3 +
 example-specs/task/nipype/afni/net_corr.yaml  |   8 +-
 example-specs/task/nipype/afni/notes.yaml     |   3 +
 .../task/nipype/afni/nwarp_adjust.yaml        |   3 +
 .../task/nipype/afni/nwarp_apply.yaml         |   3 +
 example-specs/task/nipype/afni/nwarp_cat.yaml |   3 +
 .../task/nipype/afni/one_d_tool_py.yaml       |   5 +-
 .../task/nipype/afni/outlier_count.yaml       |   7 +-
 .../task/nipype/afni/quality_index.yaml       |   3 +
 example-specs/task/nipype/afni/qwarp.yaml     |  22 +--
 .../task/nipype/afni/qwarp_plus_minus.yaml    |  10 +-
 example-specs/task/nipype/afni/re_ho.yaml     |   3 +
 example-specs/task/nipype/afni/remlfit.yaml   |  27 ++--
 example-specs/task/nipype/afni/resample.yaml  |   3 +
 example-specs/task/nipype/afni/retroicor.yaml |   3 +
 example-specs/task/nipype/afni/roi_stats.yaml |   3 +
 .../task/nipype/afni/skull_strip.yaml         |   3 +
 example-specs/task/nipype/afni/svm_test.yaml  |   3 +
 example-specs/task/nipype/afni/svm_train.yaml |  15 +-
 .../task/nipype/afni/synthesize.yaml          |   3 +
 example-specs/task/nipype/afni/t_cat.yaml     |   3 +
 example-specs/task/nipype/afni/t_corr_1d.yaml |   3 +
 .../task/nipype/afni/t_corr_map.yaml          |  36 ++---
 .../task/nipype/afni/t_correlate.yaml         |   3 +
 example-specs/task/nipype/afni/t_norm.yaml    |   3 +
 example-specs/task/nipype/afni/t_project.yaml |   3 +
 example-specs/task/nipype/afni/t_shift.yaml   |   7 +-
 example-specs/task/nipype/afni/t_smooth.yaml  |   3 +
 example-specs/task/nipype/afni/t_stat.yaml    |   3 +
 example-specs/task/nipype/afni/to_3d.yaml     |   3 +
 example-specs/task/nipype/afni/undump.yaml    |   3 +
 example-specs/task/nipype/afni/unifize.yaml   |  11 +-
 example-specs/task/nipype/afni/volreg.yaml    |  17 +-
 example-specs/task/nipype/afni/warp.yaml      |   3 +
 example-specs/task/nipype/afni/z_cut_up.yaml  |   3 +
 example-specs/task/nipype/afni/zcat.yaml      |   3 +
 example-specs/task/nipype/afni/zeropad.yaml   |   3 +
 .../task/nipype/ants/affine_initializer.yaml  |   3 +
 example-specs/task/nipype/ants/ai.yaml        |   3 +
 example-specs/task/nipype/ants/atropos.yaml   |   4 +-
 .../task/nipype/ants/average_images.yaml      |   3 +
 .../nipype/ants/compose_multi_transform.yaml  |   6 +-
 .../nipype/ants/composite_transform_util.yaml |   9 +-
 .../task/nipype/ants/denoise_image.yaml       |   8 +-
 .../task/nipype/ants/image_math.yaml          |   6 +-
 .../task/nipype/ants/joint_fusion.yaml        |   3 +
 .../task/nipype/ants/kelly_kapowski.yaml      |   4 +-
 .../task/nipype/ants/label_geometry.yaml      |   8 +-
 .../task/nipype/ants/multiply_images.yaml     |   6 +-
 .../nipype/ants/n4_bias_field_correction.yaml |   2 +-
 .../task/nipype/ants/registration.yaml        |  10 +-
 .../ants/resample_image_by_spacing.yaml       |  14 +-
 .../task/nipype/ants/threshold_image.yaml     |  14 +-
 .../ants/warp_image_multi_transform.yaml      |   4 +-
 .../freesurfer/add_x_form_to_header.yaml      |   3 +
 .../task/nipype/freesurfer/aparc_2_aseg.yaml  |   3 +
 .../task/nipype/freesurfer/apas_2_aseg.yaml   |   3 +
 .../task/nipype/freesurfer/apply_mask.yaml    |   3 +
 .../task/nipype/freesurfer/ca_label.yaml      |   3 +
 .../task/nipype/freesurfer/ca_normalize.yaml  |   9 +-
 .../nipype/freesurfer/concatenate_lta.yaml    |   3 +
 .../nipype/freesurfer/curvature_stats.yaml    |   3 +
 .../nipype/freesurfer/edit_w_mwith_aseg.yaml  |   3 +
 .../task/nipype/freesurfer/em_register.yaml   |   3 +
 .../freesurfer/extract_main_component.yaml    |   3 +
 .../task/nipype/freesurfer/fit_ms_params.yaml |   4 +-
 .../nipype/freesurfer/fuse_segmentations.yaml |   3 +
 .../task/nipype/freesurfer/glm_fit.yaml       |   6 +-
 .../task/nipype/freesurfer/gtm_seg.yaml       |   3 +
 .../task/nipype/freesurfer/jacobian.yaml      |   3 +
 .../task/nipype/freesurfer/label_2_label.yaml |   3 +
 .../task/nipype/freesurfer/logan_ref.yaml     |   6 +-
 .../freesurfer/make_average_subject.yaml      |   4 +-
 .../freesurfer/mni_bias_correction.yaml       |   3 +
 .../nipype/freesurfer/mr_is_ca_label.yaml     |   3 +
 .../task/nipype/freesurfer/mr_is_calc.yaml    |   3 +
 .../task/nipype/freesurfer/mr_is_convert.yaml |   4 +-
 .../task/nipype/freesurfer/mr_is_inflate.yaml |   6 +
 .../task/nipype/freesurfer/mri_convert.yaml   |  10 +-
 .../task/nipype/freesurfer/mri_fill.yaml      |   9 +-
 .../nipype/freesurfer/mri_marching_cubes.yaml |   4 +-
 .../task/nipype/freesurfer/mri_pretess.yaml   |   3 +
 .../nipype/freesurfer/mri_tessellate.yaml     |   4 +-
 .../task/nipype/freesurfer/mrtm.yaml          |   6 +-
 .../task/nipype/freesurfer/mrtm2.yaml         |   6 +-
 .../task/nipype/freesurfer/ms__lda.yaml       |  20 +--
 .../task/nipype/freesurfer/normalize.yaml     |   3 +
 .../nipype/freesurfer/one_sample_t_test.yaml  |   6 +-
 .../task/nipype/freesurfer/paint.yaml         |   3 +
 .../nipype/freesurfer/parse_dicom_dir.yaml    |   3 +
 .../freesurfer/register_av_ito_talairach.yaml |   3 +
 .../freesurfer/relabel_hypointensities.yaml   |   3 +
 .../freesurfer/remove_intersection.yaml       |   3 +
 .../task/nipype/freesurfer/remove_neck.yaml   |   3 +
 .../nipype/freesurfer/robust_template.yaml    |   3 +
 .../task/nipype/freesurfer/segment_cc.yaml    |   6 +
 .../task/nipype/freesurfer/segment_wm.yaml    |   3 +
 .../freesurfer/smooth_tessellation.yaml       |  12 +-
 .../task/nipype/freesurfer/sphere.yaml        |   3 +
 .../nipype/freesurfer/spherical_average.yaml  |   4 +-
 .../freesurfer/surface_2_vol_transform.yaml   |   8 +-
 .../nipype/freesurfer/surface_snapshots.yaml  |   4 +-
 .../task/nipype/freesurfer/talairach_avi.yaml |   3 +
 .../task/nipype/freesurfer/talairach_qc.yaml  |  10 +-
 .../task/nipype/freesurfer/tkregister_2.yaml  |   3 +
 .../freesurfer/watershed_skull_strip.yaml     |   3 +
 .../task/nipype/fsl/accuracy_tester.yaml      |   2 +-
 .../task/nipype/fsl/apply_topup.yaml          |   3 +
 example-specs/task/nipype/fsl/apply_xfm.yaml  |   9 ++
 example-specs/task/nipype/fsl/b0_calc.yaml    |   3 +
 example-specs/task/nipype/fsl/classifier.yaml |   6 +-
 .../task/nipype/fsl/convert_warp.yaml         |   3 +
 example-specs/task/nipype/fsl/eddy.yaml       |  12 +-
 .../task/nipype/fsl/eddy_correct.yaml         |   8 +-
 .../task/nipype/fsl/epi_de_warp.yaml          |   4 -
 example-specs/task/nipype/fsl/epi_reg.yaml    |   6 +-
 example-specs/task/nipype/fsl/fast.yaml       |   8 +-
 .../task/nipype/fsl/feature_extractor.yaml    |   2 +-
 example-specs/task/nipype/fsl/filmgls.yaml    |   2 +-
 example-specs/task/nipype/fsl/first.yaml      |   4 +-
 example-specs/task/nipype/fsl/flirt.yaml      |   9 ++
 example-specs/task/nipype/fsl/fugue.yaml      |  26 ++--
 example-specs/task/nipype/fsl/glm.yaml        |  35 +++--
 example-specs/task/nipype/fsl/ica__aroma.yaml |   6 +-
 example-specs/task/nipype/fsl/inv_warp.yaml   |   2 +-
 .../task/nipype/fsl/make_dyadic_vectors.yaml  |   4 +-
 example-specs/task/nipype/fsl/merge.yaml      |   2 +-
 .../task/nipype/fsl/motion_outliers.yaml      |   9 ++
 .../task/nipype/fsl/prepare_fieldmap.yaml     |   3 +
 .../task/nipype/fsl/prob_track_x.yaml         |   6 +-
 .../task/nipype/fsl/prob_track_x2.yaml        |   4 +-
 example-specs/task/nipype/fsl/robust_fov.yaml |   6 +
 .../task/nipype/fsl/slice_timer.yaml          |   4 +-
 example-specs/task/nipype/fsl/smooth.yaml     |   2 +-
 example-specs/task/nipype/fsl/susan.yaml      |   4 +-
 .../task/nipype/fsl/text_2_vest.yaml          |   3 +
 example-specs/task/nipype/fsl/topup.yaml      |  25 ++-
 .../task/nipype/fsl/tract_skeleton.yaml       |   2 +-
 .../task/nipype/fsl/vest_2_text.yaml          |   3 +
 .../task/nipype/fsl/warp_points.yaml          |   3 +
 .../task/nipype/fsl/warp_points_to_std.yaml   |   3 +
 example-specs/task/nipype/fsl/warp_utils.yaml |   6 +
 nipype2pydra/task/base.py                     |   3 +
 scripts/pkg_gen/create_packages.py            | 147 ++++++++++++------
 .../pkg_gen/freesurfer-mris-convert-only.yaml |   5 +
 scripts/pkg_gen/fsl-filmgls-only.yaml         |   6 +
 tests/test_task.py                            |   5 +-
 182 files changed, 821 insertions(+), 339 deletions(-)
 create mode 100644 scripts/pkg_gen/freesurfer-mris-convert-only.yaml
 create mode 100644 scripts/pkg_gen/fsl-filmgls-only.yaml

diff --git a/example-specs/task/nipype/afni/a_boverlap.yaml b/example-specs/task/nipype/afni/a_boverlap.yaml
index 0d452646..feee2e75 100644
--- a/example-specs/task/nipype/afni/a_boverlap.yaml
+++ b/example-specs/task/nipype/afni/a_boverlap.yaml
@@ -41,6 +41,9 @@ inputs:
     # type=file|default=<undefined>: input file A
     in_file_b: medimage/nifti1
     # type=file|default=<undefined>: input file B
+    out_file: Path
+    # type=file: output file
+    # type=file|default=<undefined>: collect output to a file
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/afn_ito_nifti.yaml b/example-specs/task/nipype/afni/afn_ito_nifti.yaml
index 88cab46c..f881f485 100644
--- a/example-specs/task/nipype/afni/afn_ito_nifti.yaml
+++ b/example-specs/task/nipype/afni/afn_ito_nifti.yaml
@@ -38,6 +38,9 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage-afni/threed
     # type=file|default=<undefined>: input file to 3dAFNItoNIFTI
+    out_file: Path
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/allineate.yaml b/example-specs/task/nipype/afni/allineate.yaml
index 32481b8c..ee9d576d 100644
--- a/example-specs/task/nipype/afni/allineate.yaml
+++ b/example-specs/task/nipype/afni/allineate.yaml
@@ -59,15 +59,27 @@ inputs:
     # type=file|default=<undefined>: Read warp parameters from file and apply them to the source dataset, and produce a new dataset
     in_matrix: datascience/text-matrix
     # type=file|default=<undefined>: matrix to align input file
-    allcostx: text/text-file
-    # type=file: Compute and print ALL available cost functionals for the un-warped inputs
-    # type=file|default=<undefined>: Compute and print ALL available cost functionals for the un-warped inputsAND THEN QUIT. If you use this option none of the other expected outputs will be produced
     weight_file: generic/file
     # type=file|default=<undefined>: Set the weighting for each voxel in the base dataset; larger weights mean that voxel count more in the cost function. Must be defined on the same grid as the base dataset
     source_mask: generic/file
     # type=file|default=<undefined>: mask the input dataset
     master: generic/file
     # type=file|default=<undefined>: Write the output dataset on the same grid as this file.
+    out_file: Path
+    # type=file: output image file name
+    # type=file|default=<undefined>: output file from 3dAllineate
+    out_param_file: Path
+    # type=file: warp parameters
+    # type=file|default=<undefined>: Save the warp parameters in ASCII (.1D) format.
+    out_matrix: Path
+    # type=file: matrix to align input file
+    # type=file|default=<undefined>: Save the transformation matrix for each volume.
+    allcostx: Path
+    # type=file: Compute and print ALL available cost functionals for the un-warped inputs
+    # type=file|default=<undefined>: Compute and print ALL available cost functionals for the un-warped inputsAND THEN QUIT. If you use this option none of the other expected outputs will be produced
+    out_weight_file: Path
+    # type=file: weight volume
+    # type=file|default=<undefined>: Write the weight volume to disk as a dataset
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -84,12 +96,12 @@ outputs:
     out_file: medimage/nifti1
     # type=file: output image file name
     # type=file|default=<undefined>: output file from 3dAllineate
-    out_param_file: generic/file
-    # type=file: warp parameters
-    # type=file|default=<undefined>: Save the warp parameters in ASCII (.1D) format.
     out_matrix: generic/file
     # type=file: matrix to align input file
     # type=file|default=<undefined>: Save the transformation matrix for each volume.
+    out_param_file: generic/file
+    # type=file: warp parameters
+    # type=file|default=<undefined>: Save the warp parameters in ASCII (.1D) format.
     out_weight_file: generic/file
     # type=file: weight volume
     # type=file|default=<undefined>: Write the weight volume to disk as a dataset
@@ -267,7 +279,7 @@ tests:
     # type=file|default=<undefined>: input file to 3dAllineate
     reference:
     # type=file|default=<undefined>: file to be used as reference, the first volume will be used if not given the reference will be the first volume of in_file.
-    allcostx:
+    allcostx: '"out.allcostX.txt"'
     # type=file: Compute and print ALL available cost functionals for the un-warped inputs
     # type=file|default=<undefined>: Compute and print ALL available cost functionals for the un-warped inputsAND THEN QUIT. If you use this option none of the other expected outputs will be produced
   imports:
@@ -338,7 +350,7 @@ doctests:
     # type=file|default=<undefined>: input file to 3dAllineate
     reference:
     # type=file|default=<undefined>: file to be used as reference, the first volume will be used if not given the reference will be the first volume of in_file.
-    allcostx:
+    allcostx: '"out.allcostX.txt"'
     # type=file: Compute and print ALL available cost functionals for the un-warped inputs
     # type=file|default=<undefined>: Compute and print ALL available cost functionals for the un-warped inputsAND THEN QUIT. If you use this option none of the other expected outputs will be produced
   imports:
diff --git a/example-specs/task/nipype/afni/auto_tcorrelate.yaml b/example-specs/task/nipype/afni/auto_tcorrelate.yaml
index 7df9cee1..fce64ac6 100644
--- a/example-specs/task/nipype/afni/auto_tcorrelate.yaml
+++ b/example-specs/task/nipype/afni/auto_tcorrelate.yaml
@@ -45,6 +45,9 @@ inputs:
     # type=file|default=<undefined>: mask of voxels
     mask_source: generic/file
     # type=file|default=<undefined>: mask for source voxels
+    out_file: Path
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/autobox.yaml b/example-specs/task/nipype/afni/autobox.yaml
index 6305bae8..bedc48f1 100644
--- a/example-specs/task/nipype/afni/autobox.yaml
+++ b/example-specs/task/nipype/afni/autobox.yaml
@@ -38,6 +38,9 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/nifti1
     # type=file|default=<undefined>: input file
+    out_file: Path
+    # type=file: output file
+    # type=file|default=<undefined>: 
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/automask.yaml b/example-specs/task/nipype/afni/automask.yaml
index c04f3d8f..eb363c07 100644
--- a/example-specs/task/nipype/afni/automask.yaml
+++ b/example-specs/task/nipype/afni/automask.yaml
@@ -38,7 +38,10 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/nifti1
     # type=file|default=<undefined>: input file to 3dAutomask
-    brain_file: generic/file
+    out_file: Path
+    # type=file: mask file
+    # type=file|default=<undefined>: output image file name
+    brain_file: Path
     # type=file: brain file (skull stripped)
     # type=file|default=<undefined>: output file from 3dAutomask
   metadata:
diff --git a/example-specs/task/nipype/afni/axialize.yaml b/example-specs/task/nipype/afni/axialize.yaml
index c9bcfcb1..15d7c942 100644
--- a/example-specs/task/nipype/afni/axialize.yaml
+++ b/example-specs/task/nipype/afni/axialize.yaml
@@ -38,6 +38,9 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/nifti1
     # type=file|default=<undefined>: input file to 3daxialize
+    out_file: Path
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/bandpass.yaml b/example-specs/task/nipype/afni/bandpass.yaml
index 292e3dfd..8f3ac338 100644
--- a/example-specs/task/nipype/afni/bandpass.yaml
+++ b/example-specs/task/nipype/afni/bandpass.yaml
@@ -46,6 +46,9 @@ inputs:
     # type=inputmultiobject|default=[]: Also orthogonalize input to columns in f.1D. Multiple '-ort' options are allowed.
     orthogonalize_dset: generic/file
     # type=file|default=<undefined>: Orthogonalize each voxel to the corresponding voxel time series in dataset 'fset', which must have the same spatial and temporal grid structure as the main input dataset. At present, only one '-dsort' option is allowed.
+    out_file: Path
+    # type=file: output file
+    # type=file|default=<undefined>: output file from 3dBandpass
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/blur_in_mask.yaml b/example-specs/task/nipype/afni/blur_in_mask.yaml
index a693311e..cf1e87c2 100644
--- a/example-specs/task/nipype/afni/blur_in_mask.yaml
+++ b/example-specs/task/nipype/afni/blur_in_mask.yaml
@@ -42,6 +42,9 @@ inputs:
     # type=file|default=<undefined>: Mask dataset, if desired.  Blurring will occur only within the mask. Voxels NOT in the mask will be set to zero in the output.
     multimask: generic/file
     # type=file|default=<undefined>: Multi-mask dataset -- each distinct nonzero value in dataset will be treated as a separate mask for blurring purposes.
+    out_file: Path
+    # type=file: output file
+    # type=file|default=<undefined>: output to the file
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/blur_to_fwhm.yaml b/example-specs/task/nipype/afni/blur_to_fwhm.yaml
index 245ed880..25f6ec9d 100644
--- a/example-specs/task/nipype/afni/blur_to_fwhm.yaml
+++ b/example-specs/task/nipype/afni/blur_to_fwhm.yaml
@@ -42,6 +42,9 @@ inputs:
     # type=file|default=<undefined>: The dataset whose smoothness controls the process.
     mask: generic/file
     # type=file|default=<undefined>: Mask dataset, if desired. Voxels NOT in mask will be set to zero in output.
+    out_file: Path
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/bucket.yaml b/example-specs/task/nipype/afni/bucket.yaml
index 16b1a973..51046d36 100644
--- a/example-specs/task/nipype/afni/bucket.yaml
+++ b/example-specs/task/nipype/afni/bucket.yaml
@@ -46,6 +46,9 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    out_file: Path
+    # type=file: output file
+    # type=file|default=<undefined>: 
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/calc.yaml b/example-specs/task/nipype/afni/calc.yaml
index c861891b..1bd485b1 100644
--- a/example-specs/task/nipype/afni/calc.yaml
+++ b/example-specs/task/nipype/afni/calc.yaml
@@ -56,6 +56,9 @@ inputs:
     # type=file|default=<undefined>: operand file to 3dcalc
     other: generic/file
     # type=file|default=<undefined>: other options
+    out_file: Path
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/cat.yaml b/example-specs/task/nipype/afni/cat.yaml
index 66237964..e0bd15ca 100644
--- a/example-specs/task/nipype/afni/cat.yaml
+++ b/example-specs/task/nipype/afni/cat.yaml
@@ -40,6 +40,9 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_files: medimage-afni/oned+list-of
     # type=list|default=[]: 
+    out_file: Path
+    # type=file: output file
+    # type=file|default='catout.1d': output (concatenated) file name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/cat_matvec.yaml b/example-specs/task/nipype/afni/cat_matvec.yaml
index 95d6c31b..2e222e3c 100644
--- a/example-specs/task/nipype/afni/cat_matvec.yaml
+++ b/example-specs/task/nipype/afni/cat_matvec.yaml
@@ -35,6 +35,9 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    out_file: Path
+    # type=file: output file
+    # type=file|default=<undefined>: File to write concattenated matvecs to
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/center_mass.yaml b/example-specs/task/nipype/afni/center_mass.yaml
index 1b7f79d6..c61caa51 100644
--- a/example-specs/task/nipype/afni/center_mass.yaml
+++ b/example-specs/task/nipype/afni/center_mass.yaml
@@ -44,11 +44,11 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/nifti1
     # type=file|default=<undefined>: input file to 3dCM
-    cm_file: text/text-file
-    # type=file: file with the center of mass coordinates
-    # type=file|default=<undefined>: File to write center of mass to
     mask_file: generic/file
     # type=file|default=<undefined>: Only voxels with nonzero values in the provided mask will be averaged.
+    cm_file: Path
+    # type=file: file with the center of mass coordinates
+    # type=file|default=<undefined>: File to write center of mass to
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -88,7 +88,7 @@ tests:
     automask:
     # type=bool|default=False: Generate the mask automatically
     set_cm:
-    # type=tuple|default=(<traits.trait_types.Float object at 0x10beb75d0>, <traits.trait_types.Float object at 0x10beb76d0>, <traits.trait_types.Float object at 0x10beb7750>): After computing the center of mass, set the origin fields in the header so that the center of mass will be at (x,y,z) in DICOM coords.
+    # type=tuple|default=(<traits.trait_types.Float object at 0x10f1c4450>, <traits.trait_types.Float object at 0x10f1c4550>, <traits.trait_types.Float object at 0x10f1c45d0>): After computing the center of mass, set the origin fields in the header so that the center of mass will be at (x,y,z) in DICOM coords.
     local_ijk:
     # type=bool|default=False: Output values as (i,j,k) in local orientation
     roi_vals:
@@ -119,7 +119,7 @@ tests:
   # (if not specified, will try to choose a sensible value)
     in_file:
     # type=file|default=<undefined>: input file to 3dCM
-    cm_file:
+    cm_file: '"cm.txt"'
     # type=file: file with the center of mass coordinates
     # type=file|default=<undefined>: File to write center of mass to
     roi_vals: '[2, 10]'
@@ -148,7 +148,7 @@ doctests:
   # '.mock()' method of the corresponding class is used instead.
     in_file:
     # type=file|default=<undefined>: input file to 3dCM
-    cm_file:
+    cm_file: '"cm.txt"'
     # type=file: file with the center of mass coordinates
     # type=file|default=<undefined>: File to write center of mass to
     roi_vals: '[2, 10]'
diff --git a/example-specs/task/nipype/afni/convert_dset.yaml b/example-specs/task/nipype/afni/convert_dset.yaml
index 7250ed8e..17bd9095 100644
--- a/example-specs/task/nipype/afni/convert_dset.yaml
+++ b/example-specs/task/nipype/afni/convert_dset.yaml
@@ -38,6 +38,9 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/gifti
     # type=file|default=<undefined>: input file to ConvertDset
+    out_file: Path
+    # type=file: output file
+    # type=file|default=<undefined>: output file for ConvertDset
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/copy.yaml b/example-specs/task/nipype/afni/copy.yaml
index 74b3df0f..48e7b944 100644
--- a/example-specs/task/nipype/afni/copy.yaml
+++ b/example-specs/task/nipype/afni/copy.yaml
@@ -56,6 +56,9 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/nifti1
     # type=file|default=<undefined>: input file to 3dcopy
+    out_file: Path
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/deconvolve.yaml b/example-specs/task/nipype/afni/deconvolve.yaml
index c7413431..e0ebb18c 100644
--- a/example-specs/task/nipype/afni/deconvolve.yaml
+++ b/example-specs/task/nipype/afni/deconvolve.yaml
@@ -51,9 +51,12 @@ inputs:
     # type=file|default=<undefined>: build a mask from provided file, and use this mask for the purpose of reporting truncation-to float issues AND for computing the FDR curves. The actual results ARE not masked with this option (only with 'mask' or 'automask' options).
     censor: generic/file
     # type=file|default=<undefined>: filename of censor .1D time series. This is a file of 1s and 0s, indicating which time points are to be included (1) and which are to be excluded (0).
-    x1D: medimage-afni/oned
+    x1D: Path
     # type=file: save out X matrix
     # type=file|default=<undefined>: specify name for saved X matrix
+    out_file: Path
+    # type=file: output statistics file
+    # type=file|default=<undefined>: output statistics file
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -209,7 +212,7 @@ tests:
     out_file: '"output.nii"'
     # type=file: output statistics file
     # type=file|default=<undefined>: output statistics file
-    x1D:
+    x1D: '"output.1D"'
     # type=file: save out X matrix
     # type=file|default=<undefined>: specify name for saved X matrix
     stim_times: stim_times
@@ -247,7 +250,7 @@ doctests:
     out_file: '"output.nii"'
     # type=file: output statistics file
     # type=file|default=<undefined>: output statistics file
-    x1D:
+    x1D: '"output.1D"'
     # type=file: save out X matrix
     # type=file|default=<undefined>: specify name for saved X matrix
     stim_times: stim_times
diff --git a/example-specs/task/nipype/afni/degree_centrality.yaml b/example-specs/task/nipype/afni/degree_centrality.yaml
index d44ebefa..f744c61d 100644
--- a/example-specs/task/nipype/afni/degree_centrality.yaml
+++ b/example-specs/task/nipype/afni/degree_centrality.yaml
@@ -42,6 +42,9 @@ inputs:
     # type=file|default=<undefined>: input file to 3dDegreeCentrality
     mask: medimage/nifti1
     # type=file|default=<undefined>: mask file to mask input data
+    out_file: Path
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -55,12 +58,12 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    out_file: medimage/nifti1
-    # type=file: output file
-    # type=file|default=<undefined>: output image file name
     oned_file: generic/file
     # type=file: The text output of the similarity matrix computed after thresholding with one-dimensional and ijk voxel indices, correlations, image extents, and affine matrix.
     # type=str|default='': output filepath to text dump of correlation matrix
+    out_file: medimage/nifti1
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/afni/despike.yaml b/example-specs/task/nipype/afni/despike.yaml
index 5fdb3449..5cc7b147 100644
--- a/example-specs/task/nipype/afni/despike.yaml
+++ b/example-specs/task/nipype/afni/despike.yaml
@@ -36,6 +36,9 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/nifti1
     # type=file|default=<undefined>: input file to 3dDespike
+    out_file: Path
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/detrend.yaml b/example-specs/task/nipype/afni/detrend.yaml
index 24c2dfb9..82a275a1 100644
--- a/example-specs/task/nipype/afni/detrend.yaml
+++ b/example-specs/task/nipype/afni/detrend.yaml
@@ -39,6 +39,9 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/nifti1
     # type=file|default=<undefined>: input file to 3dDetrend
+    out_file: Path
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/dot.yaml b/example-specs/task/nipype/afni/dot.yaml
index 29087507..db686f24 100644
--- a/example-specs/task/nipype/afni/dot.yaml
+++ b/example-specs/task/nipype/afni/dot.yaml
@@ -44,6 +44,9 @@ inputs:
     # type=list|default=[]: list of input files, possibly with subbrick selectors
     mask: generic/file
     # type=file|default=<undefined>: Use this dataset as a mask
+    out_file: Path
+    # type=file: output file
+    # type=file|default=<undefined>: collect output to a file
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -79,7 +82,7 @@ tests:
     mask:
     # type=file|default=<undefined>: Use this dataset as a mask
     mrange:
-    # type=tuple|default=(<traits.trait_types.Float object at 0x10bec5dd0>, <traits.trait_types.Float object at 0x10bec5cd0>): Means to further restrict the voxels from 'mset' so thatonly those mask values within this range (inclusive) willbe used.
+    # type=tuple|default=(<traits.trait_types.Float object at 0x10f1c6d10>, <traits.trait_types.Float object at 0x10f1c6c10>): Means to further restrict the voxels from 'mset' so thatonly those mask values within this range (inclusive) willbe used.
     demean:
     # type=bool|default=False: Remove the mean from each volume prior to computing the correlation
     docor:
diff --git a/example-specs/task/nipype/afni/ecm.yaml b/example-specs/task/nipype/afni/ecm.yaml
index 02bbf953..4403999f 100644
--- a/example-specs/task/nipype/afni/ecm.yaml
+++ b/example-specs/task/nipype/afni/ecm.yaml
@@ -42,6 +42,9 @@ inputs:
     # type=file|default=<undefined>: input file to 3dECM
     mask: medimage/nifti1
     # type=file|default=<undefined>: mask file to mask input data
+    out_file: Path
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/edge_3.yaml b/example-specs/task/nipype/afni/edge_3.yaml
index 8b907650..81f33864 100644
--- a/example-specs/task/nipype/afni/edge_3.yaml
+++ b/example-specs/task/nipype/afni/edge_3.yaml
@@ -39,6 +39,9 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/nifti1
     # type=file|default=<undefined>: input file to 3dedge3
+    out_file: Path
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/eval.yaml b/example-specs/task/nipype/afni/eval.yaml
index cf9eb9ae..c863a94f 100644
--- a/example-specs/task/nipype/afni/eval.yaml
+++ b/example-specs/task/nipype/afni/eval.yaml
@@ -47,6 +47,9 @@ inputs:
     # type=file|default=<undefined>: operand file to 1deval
     other: generic/file
     # type=file|default=<undefined>: other options
+    out_file: Path
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/fim.yaml b/example-specs/task/nipype/afni/fim.yaml
index 9fa093e6..58b783e3 100644
--- a/example-specs/task/nipype/afni/fim.yaml
+++ b/example-specs/task/nipype/afni/fim.yaml
@@ -43,6 +43,9 @@ inputs:
     # type=file|default=<undefined>: input file to 3dfim+
     ideal_file: medimage-afni/oned
     # type=file|default=<undefined>: ideal time series file name
+    out_file: Path
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/fourier.yaml b/example-specs/task/nipype/afni/fourier.yaml
index 3e528631..5b7d8666 100644
--- a/example-specs/task/nipype/afni/fourier.yaml
+++ b/example-specs/task/nipype/afni/fourier.yaml
@@ -40,6 +40,9 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/nifti1
     # type=file|default=<undefined>: input file to 3dFourier
+    out_file: Path
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/fwh_mx.yaml b/example-specs/task/nipype/afni/fwh_mx.yaml
index 44584676..69a0133c 100644
--- a/example-specs/task/nipype/afni/fwh_mx.yaml
+++ b/example-specs/task/nipype/afni/fwh_mx.yaml
@@ -117,6 +117,15 @@ inputs:
     # type=file|default=<undefined>: input dataset
     mask: generic/file
     # type=file|default=<undefined>: use only voxels that are nonzero in mask
+    out_file: Path
+    # type=file: output file
+    # type=file|default=<undefined>: output file
+    out_subbricks: Path
+    # type=file: output file (subbricks)
+    # type=file|default=<undefined>: output file listing the subbricks FWHM
+    out_detrend: Path
+    # type=file: output file, detrended
+    # type=file|default=<undefined>: Save the detrended file into a dataset
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/hist.yaml b/example-specs/task/nipype/afni/hist.yaml
index f5baaf50..46a7fcd7 100644
--- a/example-specs/task/nipype/afni/hist.yaml
+++ b/example-specs/task/nipype/afni/hist.yaml
@@ -39,6 +39,12 @@ inputs:
     # type=file|default=<undefined>: input file to 3dHist
     mask: generic/file
     # type=file|default=<undefined>: matrix to align input file
+    out_file: Path
+    # type=file: output file
+    # type=file|default=<undefined>: Write histogram to niml file with this prefix
+    out_show: Path
+    # type=file: output visual histogram
+    # type=file|default=<undefined>: output image file name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/lfcd.yaml b/example-specs/task/nipype/afni/lfcd.yaml
index 2ed095e9..2ac7e333 100644
--- a/example-specs/task/nipype/afni/lfcd.yaml
+++ b/example-specs/task/nipype/afni/lfcd.yaml
@@ -41,6 +41,9 @@ inputs:
     # type=file|default=<undefined>: input file to 3dLFCD
     mask: medimage/nifti1
     # type=file|default=<undefined>: mask file to mask input data
+    out_file: Path
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/local_bistat.yaml b/example-specs/task/nipype/afni/local_bistat.yaml
index 48afc1f5..2341ed13 100644
--- a/example-specs/task/nipype/afni/local_bistat.yaml
+++ b/example-specs/task/nipype/afni/local_bistat.yaml
@@ -47,6 +47,9 @@ inputs:
     # type=file|default=<undefined>: mask image file name. Voxels NOT in the mask will not be used in the neighborhood of any voxel. Also, a voxel NOT in the mask will have its statistic(s) computed as zero (0).
     weight_file: generic/file
     # type=file|default=<undefined>: File name of an image to use as a weight.  Only applies to 'pearson' statistics.
+    out_file: Path
+    # type=file: output file
+    # type=file|default=<undefined>: Output dataset.
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/localstat.yaml b/example-specs/task/nipype/afni/localstat.yaml
index dcae292b..50f65960 100644
--- a/example-specs/task/nipype/afni/localstat.yaml
+++ b/example-specs/task/nipype/afni/localstat.yaml
@@ -44,6 +44,9 @@ inputs:
     # type=file|default=<undefined>: input dataset
     mask_file: medimage/nifti-gz
     # type=file|default=<undefined>: Mask image file name. Voxels NOT in the mask will not be used in the neighborhood of any voxel. Also, a voxel NOT in the mask will have its statistic(s) computed as zero (0) unless the parameter 'nonmask' is set to true.
+    out_file: Path
+    # type=file: output file
+    # type=file|default=<undefined>: Output dataset.
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/mask_tool.yaml b/example-specs/task/nipype/afni/mask_tool.yaml
index b827a266..a637defc 100644
--- a/example-specs/task/nipype/afni/mask_tool.yaml
+++ b/example-specs/task/nipype/afni/mask_tool.yaml
@@ -37,6 +37,9 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/nifti1+list-of
     # type=inputmultiobject|default=[]: input file or files to 3dmask_tool
+    out_file: Path
+    # type=file: mask file
+    # type=file|default=<undefined>: output image file name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/maskave.yaml b/example-specs/task/nipype/afni/maskave.yaml
index c4148462..9722dbb5 100644
--- a/example-specs/task/nipype/afni/maskave.yaml
+++ b/example-specs/task/nipype/afni/maskave.yaml
@@ -41,6 +41,9 @@ inputs:
     # type=file|default=<undefined>: input file to 3dmaskave
     mask: medimage/nifti1
     # type=file|default=<undefined>: matrix to align input file
+    out_file: Path
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/means.yaml b/example-specs/task/nipype/afni/means.yaml
index 7cad7552..094308ea 100644
--- a/example-specs/task/nipype/afni/means.yaml
+++ b/example-specs/task/nipype/afni/means.yaml
@@ -49,6 +49,9 @@ inputs:
     # type=file|default=<undefined>: input file to 3dMean
     in_file_b: medimage/nifti1
     # type=file|default=<undefined>: another input file to 3dMean
+    out_file: Path
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/merge.yaml b/example-specs/task/nipype/afni/merge.yaml
index 5b4b8605..52790c6a 100644
--- a/example-specs/task/nipype/afni/merge.yaml
+++ b/example-specs/task/nipype/afni/merge.yaml
@@ -39,6 +39,9 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_files: medimage/nifti1+list-of
     # type=inputmultiobject|default=[]: 
+    out_file: Path
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/net_corr.yaml b/example-specs/task/nipype/afni/net_corr.yaml
index 55b5f5c2..93e00dba 100644
--- a/example-specs/task/nipype/afni/net_corr.yaml
+++ b/example-specs/task/nipype/afni/net_corr.yaml
@@ -49,6 +49,8 @@ inputs:
     # type=file|default=<undefined>: can include a whole brain mask within which to calculate correlation. Otherwise, data should be masked already
     weight_ts: generic/file
     # type=file|default=<undefined>: input a 1D file WTS of weights that will be applied multiplicatively to each ROI's average time series. WTS can be a column- or row-file of values, but it must have the same length as the input time series volume. If the initial average time series was A[n] for n=0,..,(N-1) time points, then applying a set of weights W[n] of the same length from WTS would produce a new time series:  B[n] = A[n] * W[n]
+    out_file: medimage-afni/ncorr
+    # type=file|default=<undefined>: output file name part
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -62,8 +64,6 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    out_file: medimage-afni/ncorr
-    # type=file|default=<undefined>: output file name part
     out_corr_matrix: generic/file
     # type=file: output correlation matrix between ROIs written to a text file with .netcc suffix
   callables:
@@ -149,7 +149,7 @@ tests:
     # type=bool|default=False: same as above in '-ts_wb_corr', except that the maps have been Fisher transformed to Z-scores the relation: Z=atanh(r). To avoid infinities in the transform, Pearson values are effectively capped at |r| = 0.999329 (where |Z| = 4.0). Files are labelled WB_Z_ROI_001+orig, etc
     fish_z: 'True'
     # type=bool|default=False: switch to also output a matrix of Fisher Z-transform values for the corr coefs (r): Z = atanh(r) , (with Z=4 being output along matrix diagonals where r=1, as the r-to-Z conversion is ceilinged at Z = atanh(r=0.999329) = 4, which is still *quite* a high Pearson-r value
-    out_file: '"sub0.tp1.ncorr"'
+    out_file:
     # type=file|default=<undefined>: output file name part
   imports:
   # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
@@ -185,7 +185,7 @@ doctests:
     # type=bool|default=False: same as above in '-ts_wb_corr', except that the maps have been Fisher transformed to Z-scores the relation: Z=atanh(r). To avoid infinities in the transform, Pearson values are effectively capped at |r| = 0.999329 (where |Z| = 4.0). Files are labelled WB_Z_ROI_001+orig, etc
     fish_z: 'True'
     # type=bool|default=False: switch to also output a matrix of Fisher Z-transform values for the corr coefs (r): Z = atanh(r) , (with Z=4 being output along matrix diagonals where r=1, as the r-to-Z conversion is ceilinged at Z = atanh(r=0.999329) = 4, which is still *quite* a high Pearson-r value
-    out_file: '"sub0.tp1.ncorr"'
+    out_file:
     # type=file|default=<undefined>: output file name part
   imports:
   # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
diff --git a/example-specs/task/nipype/afni/notes.yaml b/example-specs/task/nipype/afni/notes.yaml
index da50e782..18d4de18 100644
--- a/example-specs/task/nipype/afni/notes.yaml
+++ b/example-specs/task/nipype/afni/notes.yaml
@@ -38,6 +38,9 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage-afni/head
     # type=file|default=<undefined>: input file to 3dNotes
+    out_file: Path
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/nwarp_adjust.yaml b/example-specs/task/nipype/afni/nwarp_adjust.yaml
index f5af9166..879c3134 100644
--- a/example-specs/task/nipype/afni/nwarp_adjust.yaml
+++ b/example-specs/task/nipype/afni/nwarp_adjust.yaml
@@ -43,6 +43,9 @@ inputs:
     # type=inputmultiobject|default=[]: List of input 3D warp datasets
     in_files: generic/file+list-of
     # type=inputmultiobject|default=[]: List of input 3D datasets to be warped by the adjusted warp datasets.  There must be exactly as many of these datasets as there are input warps.
+    out_file: Path
+    # type=file: output file
+    # type=file|default=<undefined>: Output mean dataset, only needed if in_files are also given. The output dataset will be on the common grid shared by the source datasets.
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/nwarp_apply.yaml b/example-specs/task/nipype/afni/nwarp_apply.yaml
index 212e03f4..c54c65c3 100644
--- a/example-specs/task/nipype/afni/nwarp_apply.yaml
+++ b/example-specs/task/nipype/afni/nwarp_apply.yaml
@@ -40,6 +40,9 @@ inputs:
   # passed to the field in the automatically generated unittests.
     master: generic/file
     # type=file|default=<undefined>: the name of the master dataset, which defines the output grid
+    out_file: Path
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/nwarp_cat.yaml b/example-specs/task/nipype/afni/nwarp_cat.yaml
index 68cf9ed3..0a6924fe 100644
--- a/example-specs/task/nipype/afni/nwarp_cat.yaml
+++ b/example-specs/task/nipype/afni/nwarp_cat.yaml
@@ -69,6 +69,9 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    out_file: Path
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/one_d_tool_py.yaml b/example-specs/task/nipype/afni/one_d_tool_py.yaml
index f53a53d3..7910f840 100644
--- a/example-specs/task/nipype/afni/one_d_tool_py.yaml
+++ b/example-specs/task/nipype/afni/one_d_tool_py.yaml
@@ -35,6 +35,9 @@ inputs:
     # type=file|default=<undefined>: input file to OneDTool
     show_cormat_warnings: generic/file
     # type=file|default=<undefined>: Write cormat warnings to a file
+    out_file: Path
+    # type=file: output of 1D_tool.py
+    # type=file|default=<undefined>: write the current 1D data to FILE
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -76,7 +79,7 @@ tests:
     show_censor_count:
     # type=bool|default=False: display the total number of censored TRs  Note : if input is a valid xmat.1D dataset, then the count will come from the header.  Otherwise the input is assumed to be a binary censorfile, and zeros are simply counted.
     censor_motion:
-    # type=tuple|default=(<traits.trait_types.Float object at 0x10bee9cd0>, <nipype.interfaces.base.traits_extension.File object at 0x10bee9d90>): Tuple of motion limit and outfile prefix. need to also set set_nruns -r set_run_lengths
+    # type=tuple|default=(<traits.trait_types.Float object at 0x10f1eb110>, <nipype.interfaces.base.traits_extension.File object at 0x10f1eb1d0>): Tuple of motion limit and outfile prefix. need to also set set_nruns -r set_run_lengths
     censor_prev_TR:
     # type=bool|default=False: for each censored TR, also censor previous
     show_trs_uncensored:
diff --git a/example-specs/task/nipype/afni/outlier_count.yaml b/example-specs/task/nipype/afni/outlier_count.yaml
index c2734a0d..04be0222 100644
--- a/example-specs/task/nipype/afni/outlier_count.yaml
+++ b/example-specs/task/nipype/afni/outlier_count.yaml
@@ -41,6 +41,9 @@ inputs:
     # type=file|default=<undefined>: only count voxels within the given mask
     outliers_file: generic/file
     # type=file|default=<undefined>: output image file name
+    out_file: Path
+    # type=file: capture standard output
+    # type=file|default=<undefined>: capture standard output
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -54,11 +57,11 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    out_outliers: generic/file
+    # type=file: output image file name
     out_file: generic/file
     # type=file: capture standard output
     # type=file|default=<undefined>: capture standard output
-    out_outliers: generic/file
-    # type=file: output image file name
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/afni/quality_index.yaml b/example-specs/task/nipype/afni/quality_index.yaml
index fb95678a..9680a1b7 100644
--- a/example-specs/task/nipype/afni/quality_index.yaml
+++ b/example-specs/task/nipype/afni/quality_index.yaml
@@ -42,6 +42,9 @@ inputs:
     # type=file|default=<undefined>: input dataset
     mask: generic/file
     # type=file|default=<undefined>: compute correlation only across masked voxels
+    out_file: Path
+    # type=file: file containing the captured standard output
+    # type=file|default=<undefined>: capture standard output
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/qwarp.yaml b/example-specs/task/nipype/afni/qwarp.yaml
index d8a5bd5a..658b0164 100644
--- a/example-specs/task/nipype/afni/qwarp.yaml
+++ b/example-specs/task/nipype/afni/qwarp.yaml
@@ -113,8 +113,12 @@ inputs:
     # type=file|default=<undefined>: Source image (opposite phase encoding direction than base image).
     base_file: medimage/nifti1,medimage/nifti-gz
     # type=file|default=<undefined>: Base image (opposite phase encoding direction than source image).
+    out_file: medimage/nifti-gz
+    # type=file|default=<undefined>: Sets the prefix/suffix for the output datasets.  * The source dataset is warped to match the base   and gets prefix 'ppp'. (Except if '-plusminus' is used * The final interpolation to this output dataset is   done using the 'wsinc5' method.  See the output of   3dAllineate -HELP   (in the "Modifying '-final wsinc5'" section) for   the lengthy technical details. * The 3D warp used is saved in a dataset with   prefix 'ppp_WARP' -- this dataset can be used   with 3dNwarpApply and 3dNwarpCat, for example. * To be clear, this is the warp from source dataset   coordinates to base dataset coordinates, where the   values at each base grid point are the xyz displacements   needed to move that grid point's xyz values to the   corresponding xyz values in the source dataset:   base( (x,y,z) + WARP(x,y,z) ) matches source(x,y,z)   Another way to think of this warp is that it 'pulls'   values back from source space to base space. * 3dNwarpApply would use 'ppp_WARP' to transform datasets   aligned with the source dataset to be aligned with the   base dataset.  **If you do NOT want this warp saved, use the option '-nowarp'**. (However, this warp is usually the most valuable possible output!)  * If you want to calculate and save the inverse 3D warp,   use the option '-iwarp'.  This inverse warp will then be   saved in a dataset with prefix 'ppp_WARPINV'. * This inverse warp could be used to transform data from base   space to source space, if you need to do such an operation. * You can easily compute the inverse later, say by a command like   3dNwarpCat -prefix Z_WARPINV 'INV(Z_WARP+tlrc)'   or the inverse can be computed as needed in 3dNwarpApply, like   3dNwarpApply -nwarp 'INV(Z_WARP+tlrc)' -source Dataset.nii ...  
     weight: generic/file
     # type=file|default=<undefined>: Instead of computing the weight from the base dataset,directly input the weight volume from dataset 'www'.Useful if you know what over parts of the base image youwant to emphasize or de-emphasize the matching functional.
+    out_weight_file: generic/file
+    # type=file|default=<undefined>: Write the weight volume to disk as a dataset
     emask: generic/file
     # type=file|default=<undefined>: Here, 'ee' is a dataset to specify a mask of voxelsto EXCLUDE from the analysis -- all voxels in 'ee'that are NONZERO will not be used in the alignment.The base image always automasked -- the emask isextra, to indicate voxels you definitely DON'T wantincluded in the matching process, even if they areinside the brain.
     iniwarp: medimage-afni/head+list-of
@@ -134,10 +138,6 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    out_file: medimage/nifti-gz
-    # type=file|default=<undefined>: Sets the prefix/suffix for the output datasets.  * The source dataset is warped to match the base   and gets prefix 'ppp'. (Except if '-plusminus' is used * The final interpolation to this output dataset is   done using the 'wsinc5' method.  See the output of   3dAllineate -HELP   (in the "Modifying '-final wsinc5'" section) for   the lengthy technical details. * The 3D warp used is saved in a dataset with   prefix 'ppp_WARP' -- this dataset can be used   with 3dNwarpApply and 3dNwarpCat, for example. * To be clear, this is the warp from source dataset   coordinates to base dataset coordinates, where the   values at each base grid point are the xyz displacements   needed to move that grid point's xyz values to the   corresponding xyz values in the source dataset:   base( (x,y,z) + WARP(x,y,z) ) matches source(x,y,z)   Another way to think of this warp is that it 'pulls'   values back from source space to base space. * 3dNwarpApply would use 'ppp_WARP' to transform datasets   aligned with the source dataset to be aligned with the   base dataset.  **If you do NOT want this warp saved, use the option '-nowarp'**. (However, this warp is usually the most valuable possible output!)  * If you want to calculate and save the inverse 3D warp,   use the option '-iwarp'.  This inverse warp will then be   saved in a dataset with prefix 'ppp_WARPINV'. * This inverse warp could be used to transform data from base   space to source space, if you need to do such an operation. * You can easily compute the inverse later, say by a command like   3dNwarpCat -prefix Z_WARPINV 'INV(Z_WARP+tlrc)'   or the inverse can be computed as needed in 3dNwarpApply, like   3dNwarpApply -nwarp 'INV(Z_WARP+tlrc)' -source Dataset.nii ...  
-    out_weight_file: generic/file
-    # type=file|default=<undefined>: Write the weight volume to disk as a dataset
     warped_source: generic/file
     # type=file: Warped source file. If plusminus is used, this is the undistortedsource file.
     warped_base: generic/file
@@ -190,7 +190,7 @@ tests:
     wball:
     # type=list|default=[]: "``-wball x y z r f`` Enhance automatic weight from '-useweight' by a factor of 1+f\*Gaussian(FWHM=r) centered in the base image at DICOM coordinates (x,y,z) and with radius 'r'. The goal of this option is to try and make the alignment better in a specific part of the brain. Example:  -wball 0 14 6 30 40 to emphasize the thalamic area (in MNI/Talairach space).  * The 'r' parameter must be positive! * The 'f' parameter must be between 1 and 100 (inclusive). * '-wball' does nothing if you input your own weight   with the '-weight' option. * '-wball' does change the binary weight created by   the '-noweight' option. * You can only use '-wball' once in a run of 3dQwarp.  **The effect of '-wball' is not dramatic.** The example above makes the average brain image across a collection of subjects a little sharper in the thalamic area, which might have some small value.  If you care enough about alignment to use '-wball', then you should examine the results from 3dQwarp for each subject, to see if the alignments are good enough for your purposes.
     wmask:
-    # type=tuple|default=(<nipype.interfaces.base.traits_extension.File object at 0x10bdedfd0>, <traits.trait_types.Float object at 0x10bdee010>): Similar to '-wball', but here, you provide a dataset 'ws' that indicates where to increase the weight.  * The 'ws' dataset must be on the same 3D grid as the base dataset. * 'ws' is treated as a mask -- it only matters where it   is nonzero -- otherwise, the values inside are not used. * After 'ws' comes the factor 'f' by which to increase the   automatically computed weight.  Where 'ws' is nonzero,   the weighting will be multiplied by (1+f). * As with '-wball', the factor 'f' should be between 1 and 100.  
+    # type=tuple|default=(<nipype.interfaces.base.traits_extension.File object at 0x10f0eed50>, <traits.trait_types.Float object at 0x10f0eeb10>): Similar to '-wball', but here, you provide a dataset 'ws' that indicates where to increase the weight.  * The 'ws' dataset must be on the same 3D grid as the base dataset. * 'ws' is treated as a mask -- it only matters where it   is nonzero -- otherwise, the values inside are not used. * After 'ws' comes the factor 'f' by which to increase the   automatically computed weight.  Where 'ws' is nonzero,   the weighting will be multiplied by (1+f). * As with '-wball', the factor 'f' should be between 1 and 100.  
     out_weight_file:
     # type=file|default=<undefined>: Write the weight volume to disk as a dataset
     blur:
@@ -333,7 +333,7 @@ tests:
     # type=file|default=<undefined>: Source image (opposite phase encoding direction than base image).
     base_file:
     # type=file|default=<undefined>: Base image (opposite phase encoding direction than source image).
-    out_file: '"anatSSQ.nii.gz"'
+    out_file:
     # type=file|default=<undefined>: Sets the prefix/suffix for the output datasets.  * The source dataset is warped to match the base   and gets prefix 'ppp'. (Except if '-plusminus' is used * The final interpolation to this output dataset is   done using the 'wsinc5' method.  See the output of   3dAllineate -HELP   (in the "Modifying '-final wsinc5'" section) for   the lengthy technical details. * The 3D warp used is saved in a dataset with   prefix 'ppp_WARP' -- this dataset can be used   with 3dNwarpApply and 3dNwarpCat, for example. * To be clear, this is the warp from source dataset   coordinates to base dataset coordinates, where the   values at each base grid point are the xyz displacements   needed to move that grid point's xyz values to the   corresponding xyz values in the source dataset:   base( (x,y,z) + WARP(x,y,z) ) matches source(x,y,z)   Another way to think of this warp is that it 'pulls'   values back from source space to base space. * 3dNwarpApply would use 'ppp_WARP' to transform datasets   aligned with the source dataset to be aligned with the   base dataset.  **If you do NOT want this warp saved, use the option '-nowarp'**. (However, this warp is usually the most valuable possible output!)  * If you want to calculate and save the inverse 3D warp,   use the option '-iwarp'.  This inverse warp will then be   saved in a dataset with prefix 'ppp_WARPINV'. * This inverse warp could be used to transform data from base   space to source space, if you need to do such an operation. * You can easily compute the inverse later, say by a command like   3dNwarpCat -prefix Z_WARPINV 'INV(Z_WARP+tlrc)'   or the inverse can be computed as needed in 3dNwarpApply, like   3dNwarpApply -nwarp 'INV(Z_WARP+tlrc)' -source Dataset.nii ...  
     resample: 'True'
     # type=bool|default=False: This option simply resamples the source dataset to match the base dataset grid.  You can use this if the two datasets overlap well (as seen in the AFNI GUI), but are not on the same 3D grid.  * If they don't overlap well, allineate them first * The reampling here is done with the   'wsinc5' method, which has very little blurring artifact. * If the base and source datasets ARE on the same 3D grid,   then the -resample option will be ignored. * You CAN use -resample with these 3dQwarp options:   -plusminus  -inilev  -iniwarp  -duplo  
@@ -399,7 +399,7 @@ tests:
     # type=int|default=0: The value of mm should be an odd integer.  * The default value of mm is 25. * For more accurate results than mm=25, try 19 or 13. * The smallest allowed patch size is 5. * You may want stop at a larger patch size (say 7 or 9) and use   the -Qfinal option to run that final level with quintic warps,   which might run faster and provide the same degree of warp detail. * Trying to make two different brain volumes match in fine detail   is usually a waste of time, especially in humans.  There is too   much variability in anatomy to match gyrus to gyrus accurately.   For this reason, the default minimum patch size is 25 voxels.   Using a smaller '-minpatch' might try to force the warp to   match features that do not match, and the result can be useless   image distortions -- another reason to LOOK AT THE RESULTS.  
     blur: '[0,3]'
     # type=list|default=[]: Gaussian blur the input images by 'bb' (FWHM) voxels before doing the alignment (the output dataset will not be blurred). The default is 2.345 (for no good reason).  * Optionally, you can provide 2 values for 'bb', and then   the first one is applied to the base volume, the second   to the source volume.   e.g., '-blur 0 3' to skip blurring the base image   (if the base is a blurry template, for example). * A negative blur radius means to use 3D median filtering,   rather than Gaussian blurring.  This type of filtering will   better preserve edges, which can be important in alignment. * If the base is a template volume that is already blurry,   you probably don't want to blur it again, but blurring   the source volume a little is probably a good idea, to   help the program avoid trying to match tiny features. * Note that -duplo will blur the volumes some extra   amount for the initial small-scale warping, to make   that phase of the program converge more rapidly.  
-    out_file: '"Q25"'
+    out_file:
     # type=file|default=<undefined>: Sets the prefix/suffix for the output datasets.  * The source dataset is warped to match the base   and gets prefix 'ppp'. (Except if '-plusminus' is used * The final interpolation to this output dataset is   done using the 'wsinc5' method.  See the output of   3dAllineate -HELP   (in the "Modifying '-final wsinc5'" section) for   the lengthy technical details. * The 3D warp used is saved in a dataset with   prefix 'ppp_WARP' -- this dataset can be used   with 3dNwarpApply and 3dNwarpCat, for example. * To be clear, this is the warp from source dataset   coordinates to base dataset coordinates, where the   values at each base grid point are the xyz displacements   needed to move that grid point's xyz values to the   corresponding xyz values in the source dataset:   base( (x,y,z) + WARP(x,y,z) ) matches source(x,y,z)   Another way to think of this warp is that it 'pulls'   values back from source space to base space. * 3dNwarpApply would use 'ppp_WARP' to transform datasets   aligned with the source dataset to be aligned with the   base dataset.  **If you do NOT want this warp saved, use the option '-nowarp'**. (However, this warp is usually the most valuable possible output!)  * If you want to calculate and save the inverse 3D warp,   use the option '-iwarp'.  This inverse warp will then be   saved in a dataset with prefix 'ppp_WARPINV'. * This inverse warp could be used to transform data from base   space to source space, if you need to do such an operation. * You can easily compute the inverse later, say by a command like   3dNwarpCat -prefix Z_WARPINV 'INV(Z_WARP+tlrc)'   or the inverse can be computed as needed in 3dNwarpApply, like   3dNwarpApply -nwarp 'INV(Z_WARP+tlrc)' -source Dataset.nii ...  
   imports:
   # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
@@ -425,7 +425,7 @@ tests:
     # type=file|default=<undefined>: Base image (opposite phase encoding direction than source image).
     blur: '[0,2]'
     # type=list|default=[]: Gaussian blur the input images by 'bb' (FWHM) voxels before doing the alignment (the output dataset will not be blurred). The default is 2.345 (for no good reason).  * Optionally, you can provide 2 values for 'bb', and then   the first one is applied to the base volume, the second   to the source volume.   e.g., '-blur 0 3' to skip blurring the base image   (if the base is a blurry template, for example). * A negative blur radius means to use 3D median filtering,   rather than Gaussian blurring.  This type of filtering will   better preserve edges, which can be important in alignment. * If the base is a template volume that is already blurry,   you probably don't want to blur it again, but blurring   the source volume a little is probably a good idea, to   help the program avoid trying to match tiny features. * Note that -duplo will blur the volumes some extra   amount for the initial small-scale warping, to make   that phase of the program converge more rapidly.  
-    out_file: '"Q11"'
+    out_file:
     # type=file|default=<undefined>: Sets the prefix/suffix for the output datasets.  * The source dataset is warped to match the base   and gets prefix 'ppp'. (Except if '-plusminus' is used * The final interpolation to this output dataset is   done using the 'wsinc5' method.  See the output of   3dAllineate -HELP   (in the "Modifying '-final wsinc5'" section) for   the lengthy technical details. * The 3D warp used is saved in a dataset with   prefix 'ppp_WARP' -- this dataset can be used   with 3dNwarpApply and 3dNwarpCat, for example. * To be clear, this is the warp from source dataset   coordinates to base dataset coordinates, where the   values at each base grid point are the xyz displacements   needed to move that grid point's xyz values to the   corresponding xyz values in the source dataset:   base( (x,y,z) + WARP(x,y,z) ) matches source(x,y,z)   Another way to think of this warp is that it 'pulls'   values back from source space to base space. * 3dNwarpApply would use 'ppp_WARP' to transform datasets   aligned with the source dataset to be aligned with the   base dataset.  **If you do NOT want this warp saved, use the option '-nowarp'**. (However, this warp is usually the most valuable possible output!)  * If you want to calculate and save the inverse 3D warp,   use the option '-iwarp'.  This inverse warp will then be   saved in a dataset with prefix 'ppp_WARPINV'. * This inverse warp could be used to transform data from base   space to source space, if you need to do such an operation. * You can easily compute the inverse later, say by a command like   3dNwarpCat -prefix Z_WARPINV 'INV(Z_WARP+tlrc)'   or the inverse can be computed as needed in 3dNwarpApply, like   3dNwarpApply -nwarp 'INV(Z_WARP+tlrc)' -source Dataset.nii ...  
     inilev: '7'
     # type=int|default=0: The initial refinement 'level' at which to start.  * Usually used with -iniwarp; CANNOT be used with -duplo. * The combination of -inilev and -iniwarp lets you take the   results of a previous 3dQwarp run and refine them further:   Note that the source dataset in the second run is the SAME as   in the first run.  If you don't see why this is necessary,   then you probably need to seek help from an AFNI guru.  
@@ -519,7 +519,7 @@ doctests:
     # type=file|default=<undefined>: Source image (opposite phase encoding direction than base image).
     base_file:
     # type=file|default=<undefined>: Base image (opposite phase encoding direction than source image).
-    out_file: '"anatSSQ.nii.gz"'
+    out_file:
     # type=file|default=<undefined>: Sets the prefix/suffix for the output datasets.  * The source dataset is warped to match the base   and gets prefix 'ppp'. (Except if '-plusminus' is used * The final interpolation to this output dataset is   done using the 'wsinc5' method.  See the output of   3dAllineate -HELP   (in the "Modifying '-final wsinc5'" section) for   the lengthy technical details. * The 3D warp used is saved in a dataset with   prefix 'ppp_WARP' -- this dataset can be used   with 3dNwarpApply and 3dNwarpCat, for example. * To be clear, this is the warp from source dataset   coordinates to base dataset coordinates, where the   values at each base grid point are the xyz displacements   needed to move that grid point's xyz values to the   corresponding xyz values in the source dataset:   base( (x,y,z) + WARP(x,y,z) ) matches source(x,y,z)   Another way to think of this warp is that it 'pulls'   values back from source space to base space. * 3dNwarpApply would use 'ppp_WARP' to transform datasets   aligned with the source dataset to be aligned with the   base dataset.  **If you do NOT want this warp saved, use the option '-nowarp'**. (However, this warp is usually the most valuable possible output!)  * If you want to calculate and save the inverse 3D warp,   use the option '-iwarp'.  This inverse warp will then be   saved in a dataset with prefix 'ppp_WARPINV'. * This inverse warp could be used to transform data from base   space to source space, if you need to do such an operation. * You can easily compute the inverse later, say by a command like   3dNwarpCat -prefix Z_WARPINV 'INV(Z_WARP+tlrc)'   or the inverse can be computed as needed in 3dNwarpApply, like   3dNwarpApply -nwarp 'INV(Z_WARP+tlrc)' -source Dataset.nii ...  
     resample: 'True'
     # type=bool|default=False: This option simply resamples the source dataset to match the base dataset grid.  You can use this if the two datasets overlap well (as seen in the AFNI GUI), but are not on the same 3D grid.  * If they don't overlap well, allineate them first * The reampling here is done with the   'wsinc5' method, which has very little blurring artifact. * If the base and source datasets ARE on the same 3D grid,   then the -resample option will be ignored. * You CAN use -resample with these 3dQwarp options:   -plusminus  -inilev  -iniwarp  -duplo  
@@ -571,7 +571,7 @@ doctests:
     # type=int|default=0: The value of mm should be an odd integer.  * The default value of mm is 25. * For more accurate results than mm=25, try 19 or 13. * The smallest allowed patch size is 5. * You may want stop at a larger patch size (say 7 or 9) and use   the -Qfinal option to run that final level with quintic warps,   which might run faster and provide the same degree of warp detail. * Trying to make two different brain volumes match in fine detail   is usually a waste of time, especially in humans.  There is too   much variability in anatomy to match gyrus to gyrus accurately.   For this reason, the default minimum patch size is 25 voxels.   Using a smaller '-minpatch' might try to force the warp to   match features that do not match, and the result can be useless   image distortions -- another reason to LOOK AT THE RESULTS.  
     blur: '[0,3]'
     # type=list|default=[]: Gaussian blur the input images by 'bb' (FWHM) voxels before doing the alignment (the output dataset will not be blurred). The default is 2.345 (for no good reason).  * Optionally, you can provide 2 values for 'bb', and then   the first one is applied to the base volume, the second   to the source volume.   e.g., '-blur 0 3' to skip blurring the base image   (if the base is a blurry template, for example). * A negative blur radius means to use 3D median filtering,   rather than Gaussian blurring.  This type of filtering will   better preserve edges, which can be important in alignment. * If the base is a template volume that is already blurry,   you probably don't want to blur it again, but blurring   the source volume a little is probably a good idea, to   help the program avoid trying to match tiny features. * Note that -duplo will blur the volumes some extra   amount for the initial small-scale warping, to make   that phase of the program converge more rapidly.  
-    out_file: '"Q25"'
+    out_file:
     # type=file|default=<undefined>: Sets the prefix/suffix for the output datasets.  * The source dataset is warped to match the base   and gets prefix 'ppp'. (Except if '-plusminus' is used * The final interpolation to this output dataset is   done using the 'wsinc5' method.  See the output of   3dAllineate -HELP   (in the "Modifying '-final wsinc5'" section) for   the lengthy technical details. * The 3D warp used is saved in a dataset with   prefix 'ppp_WARP' -- this dataset can be used   with 3dNwarpApply and 3dNwarpCat, for example. * To be clear, this is the warp from source dataset   coordinates to base dataset coordinates, where the   values at each base grid point are the xyz displacements   needed to move that grid point's xyz values to the   corresponding xyz values in the source dataset:   base( (x,y,z) + WARP(x,y,z) ) matches source(x,y,z)   Another way to think of this warp is that it 'pulls'   values back from source space to base space. * 3dNwarpApply would use 'ppp_WARP' to transform datasets   aligned with the source dataset to be aligned with the   base dataset.  **If you do NOT want this warp saved, use the option '-nowarp'**. (However, this warp is usually the most valuable possible output!)  * If you want to calculate and save the inverse 3D warp,   use the option '-iwarp'.  This inverse warp will then be   saved in a dataset with prefix 'ppp_WARPINV'. * This inverse warp could be used to transform data from base   space to source space, if you need to do such an operation. * You can easily compute the inverse later, say by a command like   3dNwarpCat -prefix Z_WARPINV 'INV(Z_WARP+tlrc)'   or the inverse can be computed as needed in 3dNwarpApply, like   3dNwarpApply -nwarp 'INV(Z_WARP+tlrc)' -source Dataset.nii ...  
   imports:
   # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
@@ -590,7 +590,7 @@ doctests:
     # type=file|default=<undefined>: Base image (opposite phase encoding direction than source image).
     blur: '[0,2]'
     # type=list|default=[]: Gaussian blur the input images by 'bb' (FWHM) voxels before doing the alignment (the output dataset will not be blurred). The default is 2.345 (for no good reason).  * Optionally, you can provide 2 values for 'bb', and then   the first one is applied to the base volume, the second   to the source volume.   e.g., '-blur 0 3' to skip blurring the base image   (if the base is a blurry template, for example). * A negative blur radius means to use 3D median filtering,   rather than Gaussian blurring.  This type of filtering will   better preserve edges, which can be important in alignment. * If the base is a template volume that is already blurry,   you probably don't want to blur it again, but blurring   the source volume a little is probably a good idea, to   help the program avoid trying to match tiny features. * Note that -duplo will blur the volumes some extra   amount for the initial small-scale warping, to make   that phase of the program converge more rapidly.  
-    out_file: '"Q11"'
+    out_file:
     # type=file|default=<undefined>: Sets the prefix/suffix for the output datasets.  * The source dataset is warped to match the base   and gets prefix 'ppp'. (Except if '-plusminus' is used * The final interpolation to this output dataset is   done using the 'wsinc5' method.  See the output of   3dAllineate -HELP   (in the "Modifying '-final wsinc5'" section) for   the lengthy technical details. * The 3D warp used is saved in a dataset with   prefix 'ppp_WARP' -- this dataset can be used   with 3dNwarpApply and 3dNwarpCat, for example. * To be clear, this is the warp from source dataset   coordinates to base dataset coordinates, where the   values at each base grid point are the xyz displacements   needed to move that grid point's xyz values to the   corresponding xyz values in the source dataset:   base( (x,y,z) + WARP(x,y,z) ) matches source(x,y,z)   Another way to think of this warp is that it 'pulls'   values back from source space to base space. * 3dNwarpApply would use 'ppp_WARP' to transform datasets   aligned with the source dataset to be aligned with the   base dataset.  **If you do NOT want this warp saved, use the option '-nowarp'**. (However, this warp is usually the most valuable possible output!)  * If you want to calculate and save the inverse 3D warp,   use the option '-iwarp'.  This inverse warp will then be   saved in a dataset with prefix 'ppp_WARPINV'. * This inverse warp could be used to transform data from base   space to source space, if you need to do such an operation. * You can easily compute the inverse later, say by a command like   3dNwarpCat -prefix Z_WARPINV 'INV(Z_WARP+tlrc)'   or the inverse can be computed as needed in 3dNwarpApply, like   3dNwarpApply -nwarp 'INV(Z_WARP+tlrc)' -source Dataset.nii ...  
     inilev: '7'
     # type=int|default=0: The initial refinement 'level' at which to start.  * Usually used with -iniwarp; CANNOT be used with -duplo. * The combination of -inilev and -iniwarp lets you take the   results of a previous 3dQwarp run and refine them further:   Note that the source dataset in the second run is the SAME as   in the first run.  If you don't see why this is necessary,   then you probably need to seek help from an AFNI guru.  
diff --git a/example-specs/task/nipype/afni/qwarp_plus_minus.yaml b/example-specs/task/nipype/afni/qwarp_plus_minus.yaml
index 3aaa2016..dec8b0a3 100644
--- a/example-specs/task/nipype/afni/qwarp_plus_minus.yaml
+++ b/example-specs/task/nipype/afni/qwarp_plus_minus.yaml
@@ -41,12 +41,16 @@ inputs:
   # passed to the field in the automatically generated unittests.
     source_file: generic/file
     # type=file|default=<undefined>: Source image (opposite phase encoding direction than base image)
+    out_file: generic/file
+    # type=file|default='Qwarp.nii.gz': Output file
     in_file: medimage/nifti-gz
     # type=file|default=<undefined>: Source image (opposite phase encoding direction than base image).
     base_file: medimage/nifti-gz
     # type=file|default=<undefined>: Base image (opposite phase encoding direction than source image).
     weight: generic/file
     # type=file|default=<undefined>: Instead of computing the weight from the base dataset,directly input the weight volume from dataset 'www'.Useful if you know what over parts of the base image youwant to emphasize or de-emphasize the matching functional.
+    out_weight_file: generic/file
+    # type=file|default=<undefined>: Write the weight volume to disk as a dataset
     emask: generic/file
     # type=file|default=<undefined>: Here, 'ee' is a dataset to specify a mask of voxelsto EXCLUDE from the analysis -- all voxels in 'ee'that are NONZERO will not be used in the alignment.The base image always automasked -- the emask isextra, to indicate voxels you definitely DON'T wantincluded in the matching process, even if they areinside the brain.
     iniwarp: generic/file+list-of
@@ -66,10 +70,6 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    out_file: generic/file
-    # type=file|default='Qwarp.nii.gz': Output file
-    out_weight_file: generic/file
-    # type=file|default=<undefined>: Write the weight volume to disk as a dataset
     warped_source: generic/file
     # type=file: Warped source file. If plusminus is used, this is the undistortedsource file.
     warped_base: generic/file
@@ -126,7 +126,7 @@ tests:
     wball:
     # type=list|default=[]: "``-wball x y z r f`` Enhance automatic weight from '-useweight' by a factor of 1+f\*Gaussian(FWHM=r) centered in the base image at DICOM coordinates (x,y,z) and with radius 'r'. The goal of this option is to try and make the alignment better in a specific part of the brain. Example:  -wball 0 14 6 30 40 to emphasize the thalamic area (in MNI/Talairach space).  * The 'r' parameter must be positive! * The 'f' parameter must be between 1 and 100 (inclusive). * '-wball' does nothing if you input your own weight   with the '-weight' option. * '-wball' does change the binary weight created by   the '-noweight' option. * You can only use '-wball' once in a run of 3dQwarp.  **The effect of '-wball' is not dramatic.** The example above makes the average brain image across a collection of subjects a little sharper in the thalamic area, which might have some small value.  If you care enough about alignment to use '-wball', then you should examine the results from 3dQwarp for each subject, to see if the alignments are good enough for your purposes.
     wmask:
-    # type=tuple|default=(<nipype.interfaces.base.traits_extension.File object at 0x10bdedfd0>, <traits.trait_types.Float object at 0x10bdee010>): Similar to '-wball', but here, you provide a dataset 'ws' that indicates where to increase the weight.  * The 'ws' dataset must be on the same 3D grid as the base dataset. * 'ws' is treated as a mask -- it only matters where it   is nonzero -- otherwise, the values inside are not used. * After 'ws' comes the factor 'f' by which to increase the   automatically computed weight.  Where 'ws' is nonzero,   the weighting will be multiplied by (1+f). * As with '-wball', the factor 'f' should be between 1 and 100.  
+    # type=tuple|default=(<nipype.interfaces.base.traits_extension.File object at 0x10f0eed50>, <traits.trait_types.Float object at 0x10f0eeb10>): Similar to '-wball', but here, you provide a dataset 'ws' that indicates where to increase the weight.  * The 'ws' dataset must be on the same 3D grid as the base dataset. * 'ws' is treated as a mask -- it only matters where it   is nonzero -- otherwise, the values inside are not used. * After 'ws' comes the factor 'f' by which to increase the   automatically computed weight.  Where 'ws' is nonzero,   the weighting will be multiplied by (1+f). * As with '-wball', the factor 'f' should be between 1 and 100.  
     out_weight_file:
     # type=file|default=<undefined>: Write the weight volume to disk as a dataset
     blur:
diff --git a/example-specs/task/nipype/afni/re_ho.yaml b/example-specs/task/nipype/afni/re_ho.yaml
index c9cb2b20..ca416fca 100644
--- a/example-specs/task/nipype/afni/re_ho.yaml
+++ b/example-specs/task/nipype/afni/re_ho.yaml
@@ -43,6 +43,9 @@ inputs:
     # type=file|default=<undefined>: Mask within which ReHo should be calculated voxelwise
     label_set: generic/file
     # type=file|default=<undefined>: a set of ROIs, each labelled with distinct integers. ReHo will then be calculated per ROI.
+    out_file: Path
+    # type=file: Voxelwise regional homogeneity map
+    # type=file|default=<undefined>: Output dataset.
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/remlfit.yaml b/example-specs/task/nipype/afni/remlfit.yaml
index dd13e72c..88ea46b3 100644
--- a/example-specs/task/nipype/afni/remlfit.yaml
+++ b/example-specs/task/nipype/afni/remlfit.yaml
@@ -57,40 +57,43 @@ inputs:
     # type=inputmultiobject|default=[]: similar to 'slibase', BUT each file much be in slice major order (i.e. all slice0 columns come first, then all slice1 columns, etc).
     dsort: generic/file
     # type=file|default=<undefined>: 4D dataset to be used as voxelwise baseline regressor
-    var_file: generic/file
+    out_file: Path
+    # type=file: dataset for beta + statistics from the REML estimation (if generated
+    # type=file|default=<undefined>: output dataset for beta + statistics from the REML estimation; also contains the results of any GLT analysis requested in the Deconvolve setup, similar to the 'bucket' output from Deconvolve. This dataset does NOT get the betas (or statistics) of those regressors marked as 'baseline' in the matrix file.
+    var_file: Path
     # type=file: dataset for REML variance parameters (if generated)
     # type=file|default=<undefined>: output dataset for REML variance parameters
-    rbeta_file: generic/file
+    rbeta_file: Path
     # type=file: output dataset for beta weights from the REML estimation (if generated
     # type=file|default=<undefined>: output dataset for beta weights from the REML estimation, similar to the 'cbucket' output from Deconvolve. This dataset will contain all the beta weights, for baseline and stimulus regressors alike, unless the '-nobout' option is given -- in that case, this dataset will only get the betas for the stimulus regressors.
-    glt_file: generic/file
+    glt_file: Path
     # type=file: output dataset for beta + statistics from the REML estimation, but ONLY for the GLTs added on the REMLfit command line itself via 'gltsym' (if generated)
     # type=file|default=<undefined>: output dataset for beta + statistics from the REML estimation, but ONLY for the GLTs added on the REMLfit command line itself via 'gltsym'; GLTs from Deconvolve's command line will NOT be included.
-    fitts_file: generic/file
+    fitts_file: Path
     # type=file: output dataset for REML fitted model (if generated)
     # type=file|default=<undefined>: output dataset for REML fitted model
-    errts_file: generic/file
+    errts_file: Path
     # type=file: output dataset for REML residuals = data - fitted model (if generated
     # type=file|default=<undefined>: output dataset for REML residuals = data - fitted model
-    wherr_file: generic/file
+    wherr_file: Path
     # type=file: dataset for REML residual, whitened using the estimated ARMA(1,1) correlation matrix of the noise (if generated)
     # type=file|default=<undefined>: dataset for REML residual, whitened using the estimated ARMA(1,1) correlation matrix of the noise
-    ovar: generic/file
+    ovar: Path
     # type=file: dataset for OLSQ st.dev. parameter (if generated)
     # type=file|default=<undefined>: dataset for OLSQ st.dev. parameter (kind of boring)
-    obeta: generic/file
+    obeta: Path
     # type=file: dataset for beta weights from the OLSQ estimation (if generated)
     # type=file|default=<undefined>: dataset for beta weights from the OLSQ estimation
-    obuck: generic/file
+    obuck: Path
     # type=file: dataset for beta + statistics from the OLSQ estimation (if generated)
     # type=file|default=<undefined>: dataset for beta + statistics from the OLSQ estimation
-    oglt: generic/file
+    oglt: Path
     # type=file: dataset for beta + statistics from 'gltsym' options (if generated
     # type=file|default=<undefined>: dataset for beta + statistics from 'gltsym' options
-    ofitts: generic/file
+    ofitts: Path
     # type=file: dataset for OLSQ fitted model (if generated)
     # type=file|default=<undefined>: dataset for OLSQ fitted model
-    oerrts: generic/file
+    oerrts: Path
     # type=file: dataset for OLSQ residuals = data - fitted model (if generated
     # type=file|default=<undefined>: dataset for OLSQ residuals (data - fitted model)
   metadata:
diff --git a/example-specs/task/nipype/afni/resample.yaml b/example-specs/task/nipype/afni/resample.yaml
index c7b08452..ca2abef3 100644
--- a/example-specs/task/nipype/afni/resample.yaml
+++ b/example-specs/task/nipype/afni/resample.yaml
@@ -40,6 +40,9 @@ inputs:
     # type=file|default=<undefined>: input file to 3dresample
     master: generic/file
     # type=file|default=<undefined>: align dataset grid to a reference file
+    out_file: Path
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/retroicor.yaml b/example-specs/task/nipype/afni/retroicor.yaml
index f99b9451..c5ca82cd 100644
--- a/example-specs/task/nipype/afni/retroicor.yaml
+++ b/example-specs/task/nipype/afni/retroicor.yaml
@@ -62,6 +62,9 @@ inputs:
     # type=file|default=<undefined>: Filename for 1D cardiac phase output
     respphase: generic/file
     # type=file|default=<undefined>: Filename for 1D resp phase output
+    out_file: Path
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/roi_stats.yaml b/example-specs/task/nipype/afni/roi_stats.yaml
index 81426286..b549606d 100644
--- a/example-specs/task/nipype/afni/roi_stats.yaml
+++ b/example-specs/task/nipype/afni/roi_stats.yaml
@@ -45,6 +45,9 @@ inputs:
     # type=file|default=<undefined>: input mask
     roisel: generic/file
     # type=file|default=<undefined>: Only considers ROIs denoted by values found in the specified file. Note that the order of the ROIs as specified in the file is not preserved. So an SEL.1D of '2 8 20' produces the same output as '8 20 2'
+    out_file: Path
+    # type=file: output tab-separated values file
+    # type=file|default=<undefined>: output file
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/skull_strip.yaml b/example-specs/task/nipype/afni/skull_strip.yaml
index 01320162..18848cba 100644
--- a/example-specs/task/nipype/afni/skull_strip.yaml
+++ b/example-specs/task/nipype/afni/skull_strip.yaml
@@ -39,6 +39,9 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/nifti1
     # type=file|default=<undefined>: input file to 3dSkullStrip
+    out_file: Path
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/svm_test.yaml b/example-specs/task/nipype/afni/svm_test.yaml
index 805948d3..26c362cb 100644
--- a/example-specs/task/nipype/afni/svm_test.yaml
+++ b/example-specs/task/nipype/afni/svm_test.yaml
@@ -40,6 +40,9 @@ inputs:
     # type=file|default=<undefined>: A 3D or 3D+t AFNI brik dataset to be used for testing.
     testlabels: generic/file
     # type=file|default=<undefined>: *true* class category .1D labels for the test dataset. It is used to calculate the prediction accuracy performance
+    out_file: Path
+    # type=file: output file
+    # type=file|default=<undefined>: filename for .1D prediction file(s).
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/svm_train.yaml b/example-specs/task/nipype/afni/svm_train.yaml
index 5dc2c05e..b5e85f33 100644
--- a/example-specs/task/nipype/afni/svm_train.yaml
+++ b/example-specs/task/nipype/afni/svm_train.yaml
@@ -40,18 +40,21 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: generic/file
     # type=file|default=<undefined>: A 3D+t AFNI brik dataset to be used for training.
-    model: generic/file
-    # type=file: brik containing the SVM model file name
-    # type=file|default=<undefined>: basename for the brik containing the SVM model
-    alphas: generic/file
-    # type=file: output alphas file name
-    # type=file|default=<undefined>: output alphas file name
     mask: generic/file
     # type=file|default=<undefined>: byte-format brik file used to mask voxels in the analysis
     trainlabels: generic/file
     # type=file|default=<undefined>: .1D labels corresponding to the stimulus paradigm for the training data.
     censor: generic/file
     # type=file|default=<undefined>: .1D censor file that allows the user to ignore certain samples in the training data.
+    out_file: Path
+    # type=file: sum of weighted linear support vectors file name
+    # type=file|default=<undefined>: output sum of weighted linear support vectors file name
+    model: Path
+    # type=file: brik containing the SVM model file name
+    # type=file|default=<undefined>: basename for the brik containing the SVM model
+    alphas: Path
+    # type=file: output alphas file name
+    # type=file|default=<undefined>: output alphas file name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/synthesize.yaml b/example-specs/task/nipype/afni/synthesize.yaml
index 4070e5a0..9216639b 100644
--- a/example-specs/task/nipype/afni/synthesize.yaml
+++ b/example-specs/task/nipype/afni/synthesize.yaml
@@ -42,6 +42,9 @@ inputs:
     # type=file|default=<undefined>: Read the dataset output from 3dDeconvolve via the '-cbucket' option.
     matrix: medimage-afni/oned
     # type=file|default=<undefined>: Read the matrix output from 3dDeconvolve via the '-x1D' option.
+    out_file: Path
+    # type=file: output file
+    # type=file|default=<undefined>: output dataset prefix name (default 'syn')
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/t_cat.yaml b/example-specs/task/nipype/afni/t_cat.yaml
index afd93371..64487cd3 100644
--- a/example-specs/task/nipype/afni/t_cat.yaml
+++ b/example-specs/task/nipype/afni/t_cat.yaml
@@ -41,6 +41,9 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_files: medimage/nifti1+list-of
     # type=inputmultiobject|default=[]: input file to 3dTcat
+    out_file: Path
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/t_corr_1d.yaml b/example-specs/task/nipype/afni/t_corr_1d.yaml
index 05b028e2..75770a2c 100644
--- a/example-specs/task/nipype/afni/t_corr_1d.yaml
+++ b/example-specs/task/nipype/afni/t_corr_1d.yaml
@@ -38,6 +38,9 @@ inputs:
     # type=file|default=<undefined>: 3d+time dataset input
     y_1d: medimage-afni/oned
     # type=file|default=<undefined>: 1D time series file input
+    out_file: Path
+    # type=file: output file containing correlations
+    # type=file|default=<undefined>: output filename prefix
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/t_corr_map.yaml b/example-specs/task/nipype/afni/t_corr_map.yaml
index e7694234..36c0d509 100644
--- a/example-specs/task/nipype/afni/t_corr_map.yaml
+++ b/example-specs/task/nipype/afni/t_corr_map.yaml
@@ -44,43 +44,47 @@ inputs:
     # type=file|default=<undefined>: 
     mask: medimage/nifti1
     # type=file|default=<undefined>: 
-    mean_file: generic/file
+    regress_out_timeseries: generic/file
+    # type=file|default=<undefined>: 
+    out_file: generic/file
+    # type=file|default=<undefined>: output image file name
+    mean_file: Path
     # type=file: 
     # type=file|default=<undefined>: 
-    zmean: generic/file
+    zmean: Path
     # type=file: 
     # type=file|default=<undefined>: 
-    qmean: generic/file
+    qmean: Path
     # type=file: 
     # type=file|default=<undefined>: 
-    pmean: generic/file
+    pmean: Path
     # type=file: 
     # type=file|default=<undefined>: 
-    absolute_threshold: generic/file
+    absolute_threshold: Path
     # type=file: 
     # type=file|default=<undefined>: 
-    var_absolute_threshold: generic/file
+    var_absolute_threshold: Path
     # type=file: 
     # type=file|default=<undefined>: 
-    var_absolute_threshold_normalize: generic/file
+    var_absolute_threshold_normalize: Path
     # type=file: 
     # type=file|default=<undefined>: 
-    correlation_maps: generic/file
+    correlation_maps: Path
     # type=file: 
     # type=file|default=<undefined>: 
-    correlation_maps_masked: generic/file
+    correlation_maps_masked: Path
     # type=file: 
     # type=file|default=<undefined>: 
-    average_expr: generic/file
+    average_expr: Path
     # type=file: 
     # type=file|default=<undefined>: 
-    average_expr_nonzero: generic/file
+    average_expr_nonzero: Path
     # type=file: 
     # type=file|default=<undefined>: 
-    sum_expr: generic/file
+    sum_expr: Path
     # type=file: 
     # type=file|default=<undefined>: 
-    histogram: generic/file
+    histogram: Path
     # type=file: 
     # type=file|default=<undefined>: 
   metadata:
@@ -96,10 +100,6 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    regress_out_timeseries: generic/file
-    # type=file|default=<undefined>: 
-    out_file: generic/file
-    # type=file|default=<undefined>: output image file name
     mean_file: generic/file
     # type=file: 
     # type=file|default=<undefined>: 
@@ -161,7 +161,7 @@ tests:
     polort:
     # type=int|default=0: 
     bandpass:
-    # type=tuple|default=(<traits.trait_types.Float object at 0x10bdcf490>, <traits.trait_types.Float object at 0x10bdcf650>): 
+    # type=tuple|default=(<traits.trait_types.Float object at 0x10f0d4350>, <traits.trait_types.Float object at 0x10f0d4410>): 
     regress_out_timeseries:
     # type=file|default=<undefined>: 
     blur_fwhm:
diff --git a/example-specs/task/nipype/afni/t_correlate.yaml b/example-specs/task/nipype/afni/t_correlate.yaml
index 4a3b7b60..4437ec1c 100644
--- a/example-specs/task/nipype/afni/t_correlate.yaml
+++ b/example-specs/task/nipype/afni/t_correlate.yaml
@@ -43,6 +43,9 @@ inputs:
     # type=file|default=<undefined>: input xset
     yset: medimage/nifti1
     # type=file|default=<undefined>: input yset
+    out_file: Path
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/t_norm.yaml b/example-specs/task/nipype/afni/t_norm.yaml
index 2d6ea9ff..dd7f1c58 100644
--- a/example-specs/task/nipype/afni/t_norm.yaml
+++ b/example-specs/task/nipype/afni/t_norm.yaml
@@ -39,6 +39,9 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/nifti1
     # type=file|default=<undefined>: input file to 3dTNorm
+    out_file: Path
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/t_project.yaml b/example-specs/task/nipype/afni/t_project.yaml
index b285cee3..a91a96db 100644
--- a/example-specs/task/nipype/afni/t_project.yaml
+++ b/example-specs/task/nipype/afni/t_project.yaml
@@ -60,6 +60,9 @@ inputs:
     # type=inputmultiobject|default=[]: Remove the 3D+time time series in dataset fset.  * That is, 'fset' contains a different nuisance time   series for each voxel (e.g., from AnatICOR). * Multiple -dsort options are allowed.  
     mask: generic/file
     # type=file|default=<undefined>: Only operate on voxels nonzero in the mset dataset.  * Voxels outside the mask will be filled with zeros. * If no masking option is given, then all voxels   will be processed.  
+    out_file: Path
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/t_shift.yaml b/example-specs/task/nipype/afni/t_shift.yaml
index 4f0a412e..d390bc20 100644
--- a/example-specs/task/nipype/afni/t_shift.yaml
+++ b/example-specs/task/nipype/afni/t_shift.yaml
@@ -109,6 +109,9 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/nifti1
     # type=file|default=<undefined>: input file to 3dTshift
+    out_file: Path
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -122,11 +125,11 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    timing_file: generic/file
+    # type=file: AFNI formatted timing file, if ``slice_timing`` is a list
     out_file: generic/file
     # type=file: output file
     # type=file|default=<undefined>: output image file name
-    timing_file: generic/file
-    # type=file: AFNI formatted timing file, if ``slice_timing`` is a list
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/afni/t_smooth.yaml b/example-specs/task/nipype/afni/t_smooth.yaml
index 5d5ad8d8..c3f38edd 100644
--- a/example-specs/task/nipype/afni/t_smooth.yaml
+++ b/example-specs/task/nipype/afni/t_smooth.yaml
@@ -41,6 +41,9 @@ inputs:
     # type=file|default=<undefined>: input file to 3dTSmooth
     custom: generic/file
     # type=file|default=<undefined>: odd # of coefficients must be in a single column in ASCII file
+    out_file: Path
+    # type=file: output file
+    # type=file|default=<undefined>: output file from 3dTSmooth
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/t_stat.yaml b/example-specs/task/nipype/afni/t_stat.yaml
index 4d0175d7..2ab04a44 100644
--- a/example-specs/task/nipype/afni/t_stat.yaml
+++ b/example-specs/task/nipype/afni/t_stat.yaml
@@ -40,6 +40,9 @@ inputs:
     # type=file|default=<undefined>: input file to 3dTstat
     mask: generic/file
     # type=file|default=<undefined>: mask file
+    out_file: Path
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/to_3d.yaml b/example-specs/task/nipype/afni/to_3d.yaml
index 886a9899..cefd2110 100644
--- a/example-specs/task/nipype/afni/to_3d.yaml
+++ b/example-specs/task/nipype/afni/to_3d.yaml
@@ -39,6 +39,9 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_folder: generic/directory
     # type=directory|default=<undefined>: folder with DICOM images to convert
+    out_file: Path
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/undump.yaml b/example-specs/task/nipype/afni/undump.yaml
index f8cdd960..8e43c6c5 100644
--- a/example-specs/task/nipype/afni/undump.yaml
+++ b/example-specs/task/nipype/afni/undump.yaml
@@ -57,6 +57,9 @@ inputs:
     # type=file|default=<undefined>: input file to 3dUndump, whose geometry will determinethe geometry of the output
     mask_file: generic/file
     # type=file|default=<undefined>: mask image file name. Only voxels that are nonzero in the mask can be set.
+    out_file: Path
+    # type=file: assembled file
+    # type=file|default=<undefined>: output image file name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/unifize.yaml b/example-specs/task/nipype/afni/unifize.yaml
index c6f442d8..10e9ddf1 100644
--- a/example-specs/task/nipype/afni/unifize.yaml
+++ b/example-specs/task/nipype/afni/unifize.yaml
@@ -62,7 +62,10 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/nifti1
     # type=file|default=<undefined>: input file to 3dUnifize
-    scale_file: generic/file
+    out_file: Path
+    # type=file: unifized file
+    # type=file|default=<undefined>: output image file name
+    scale_file: Path
     # type=file: scale factor file
     # type=file|default=<undefined>: output file name to save the scale factor used at each voxel 
   metadata:
@@ -78,12 +81,12 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    out_file: medimage/nifti1
-    # type=file: unifized file
-    # type=file|default=<undefined>: output image file name
     scale_file: generic/file
     # type=file: scale factor file
     # type=file|default=<undefined>: output file name to save the scale factor used at each voxel 
+    out_file: medimage/nifti1
+    # type=file: unifized file
+    # type=file|default=<undefined>: output image file name
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/afni/volreg.yaml b/example-specs/task/nipype/afni/volreg.yaml
index 8eddd28c..55e98936 100644
--- a/example-specs/task/nipype/afni/volreg.yaml
+++ b/example-specs/task/nipype/afni/volreg.yaml
@@ -55,13 +55,16 @@ inputs:
     # type=file|default=<undefined>: input file to 3dvolreg
     basefile: medimage/nifti1
     # type=file|default=<undefined>: base file for registration
-    md1d_file: generic/file
+    out_file: Path
+    # type=file: registered file
+    # type=file|default=<undefined>: output image file name
+    md1d_file: Path
     # type=file: max displacement info file
     # type=file|default=<undefined>: max displacement output file
-    oned_file: medimage-afni/oned
+    oned_file: Path
     # type=file: movement parameters info file
     # type=file|default=<undefined>: 1D movement parameters output file
-    oned_matrix_save: medimage-afni/oned
+    oned_matrix_save: Path
     # type=file: matrix transformation from base to input
     # type=file|default=<undefined>: Save the matrix transformation
   metadata:
@@ -193,10 +196,10 @@ tests:
     out_file: '"rm.epi.volreg.r1"'
     # type=file: registered file
     # type=file|default=<undefined>: output image file name
-    oned_file:
+    oned_file: '"dfile.r1.1D"'
     # type=file: movement parameters info file
     # type=file|default=<undefined>: 1D movement parameters output file
-    oned_matrix_save:
+    oned_matrix_save: '"mat.r1.tshift+orig.1D"'
     # type=file: matrix transformation from base to input
     # type=file|default=<undefined>: Save the matrix transformation
   imports:
@@ -253,10 +256,10 @@ doctests:
     out_file: '"rm.epi.volreg.r1"'
     # type=file: registered file
     # type=file|default=<undefined>: output image file name
-    oned_file:
+    oned_file: '"dfile.r1.1D"'
     # type=file: movement parameters info file
     # type=file|default=<undefined>: 1D movement parameters output file
-    oned_matrix_save:
+    oned_matrix_save: '"mat.r1.tshift+orig.1D"'
     # type=file: matrix transformation from base to input
     # type=file|default=<undefined>: Save the matrix transformation
   imports:
diff --git a/example-specs/task/nipype/afni/warp.yaml b/example-specs/task/nipype/afni/warp.yaml
index f34a52ce..569e3dd3 100644
--- a/example-specs/task/nipype/afni/warp.yaml
+++ b/example-specs/task/nipype/afni/warp.yaml
@@ -54,6 +54,9 @@ inputs:
     # type=file|default=<undefined>: Read in the oblique transformation matrix from an oblique dataset and make cardinal dataset oblique to match
     gridset: generic/file
     # type=file|default=<undefined>: copy grid of specified dataset
+    out_file: Path
+    # type=file: Warped file.
+    # type=file|default=<undefined>: output image file name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/z_cut_up.yaml b/example-specs/task/nipype/afni/z_cut_up.yaml
index 17785aac..df107055 100644
--- a/example-specs/task/nipype/afni/z_cut_up.yaml
+++ b/example-specs/task/nipype/afni/z_cut_up.yaml
@@ -38,6 +38,9 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/nifti1
     # type=file|default=<undefined>: input file to 3dZcutup
+    out_file: Path
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/zcat.yaml b/example-specs/task/nipype/afni/zcat.yaml
index 8b9f480c..eafc89ee 100644
--- a/example-specs/task/nipype/afni/zcat.yaml
+++ b/example-specs/task/nipype/afni/zcat.yaml
@@ -38,6 +38,9 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_files: medimage/nifti1+list-of
     # type=inputmultiobject|default=[]: 
+    out_file: Path
+    # type=file: output file
+    # type=file|default=<undefined>: output dataset prefix name (default 'zcat')
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/zeropad.yaml b/example-specs/task/nipype/afni/zeropad.yaml
index b103d1fe..2490c52e 100644
--- a/example-specs/task/nipype/afni/zeropad.yaml
+++ b/example-specs/task/nipype/afni/zeropad.yaml
@@ -45,6 +45,9 @@ inputs:
     # type=file|default=<undefined>: input dataset
     master: generic/file
     # type=file|default=<undefined>: match the volume described in dataset 'mset', where mset must have the same orientation and grid spacing as dataset to be padded. the goal of -master is to make the output dataset from 3dZeropad match the spatial 'extents' of mset by adding or subtracting slices as needed. You can't use -I,-S,..., or -mm with -master
+    out_file: Path
+    # type=file: output file
+    # type=file|default=<undefined>: output dataset prefix name (default 'zeropad')
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/ants/affine_initializer.yaml b/example-specs/task/nipype/ants/affine_initializer.yaml
index 2a7ee761..ede71972 100644
--- a/example-specs/task/nipype/ants/affine_initializer.yaml
+++ b/example-specs/task/nipype/ants/affine_initializer.yaml
@@ -34,6 +34,9 @@ inputs:
     # type=file|default=<undefined>: reference image
     moving_image: medimage/nifti1
     # type=file|default=<undefined>: moving image
+    out_file: Path
+    # type=file: output transform file
+    # type=file|default='transform.mat': output transform file
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/ants/ai.yaml b/example-specs/task/nipype/ants/ai.yaml
index b57fec2c..1d08a26c 100644
--- a/example-specs/task/nipype/ants/ai.yaml
+++ b/example-specs/task/nipype/ants/ai.yaml
@@ -49,6 +49,9 @@ inputs:
     # type=file|default=<undefined>: fixed mage mask
     moving_image_mask: generic/file
     # type=file|default=<undefined>: moving mage mask
+    output_transform: Path
+    # type=file: output file name
+    # type=file|default='initialization.mat': output file name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/ants/atropos.yaml b/example-specs/task/nipype/ants/atropos.yaml
index 2a95a349..f573fdb4 100644
--- a/example-specs/task/nipype/ants/atropos.yaml
+++ b/example-specs/task/nipype/ants/atropos.yaml
@@ -100,6 +100,8 @@ inputs:
     # type=inputmultiobject|default=[]: 
     mask_image: medimage/nifti1
     # type=file|default=<undefined>: 
+    out_classified_image_name: generic/file
+    # type=file|default=<undefined>: 
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -120,8 +122,6 @@ outputs:
   # to set to the `callable` attribute of output fields
   templates:
   # dict[str, str] - `output_file_template` values to be provided to output fields
-    out_classified_image_name: out_classified_image_name
-    # type=file|default=<undefined>: 
   requirements:
   # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
 tests:
diff --git a/example-specs/task/nipype/ants/average_images.yaml b/example-specs/task/nipype/ants/average_images.yaml
index b29b7f8e..ff38d027 100644
--- a/example-specs/task/nipype/ants/average_images.yaml
+++ b/example-specs/task/nipype/ants/average_images.yaml
@@ -33,6 +33,9 @@ inputs:
   # passed to the field in the automatically generated unittests.
     images: medimage/nifti1+list-of
     # type=inputmultiobject|default=[]: image to apply transformation to (generally a coregistered functional)
+    output_average_image: Path
+    # type=file: average image file
+    # type=file|default='average.nii': the name of the resulting image.
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/ants/compose_multi_transform.yaml b/example-specs/task/nipype/ants/compose_multi_transform.yaml
index 77defaa4..a28a31f0 100644
--- a/example-specs/task/nipype/ants/compose_multi_transform.yaml
+++ b/example-specs/task/nipype/ants/compose_multi_transform.yaml
@@ -33,13 +33,13 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    output_transform: generic/file
-    # type=file: Composed transform file
-    # type=file|default=<undefined>: the name of the resulting transform.
     reference_image: generic/file
     # type=file|default=<undefined>: Reference image (only necessary when output is warpfield)
     transforms: datascience/text-matrix+list-of
     # type=inputmultiobject|default=[]: transforms to average
+    output_transform: Path
+    # type=file: Composed transform file
+    # type=file|default=<undefined>: the name of the resulting transform.
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/ants/composite_transform_util.yaml b/example-specs/task/nipype/ants/composite_transform_util.yaml
index 9cd42fa1..16e204d7 100644
--- a/example-specs/task/nipype/ants/composite_transform_util.yaml
+++ b/example-specs/task/nipype/ants/composite_transform_util.yaml
@@ -47,6 +47,9 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: '[datascience/text-matrix,datascience/hdf5]+list-of'
     # type=inputmultiobject|default=[]: Input transform file(s)
+    out_file: Path
+    # type=file: Compound transformation file
+    # type=file|default=<undefined>: Output file path (only used for disassembly).
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -60,13 +63,13 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    out_file: datascience/hdf5
-    # type=file: Compound transformation file
-    # type=file|default=<undefined>: Output file path (only used for disassembly).
     affine_transform: generic/file
     # type=file: Affine transform component
     displacement_field: generic/file
     # type=file: Displacement field component
+    out_file: datascience/hdf5
+    # type=file: Compound transformation file
+    # type=file|default=<undefined>: Output file path (only used for disassembly).
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/ants/denoise_image.yaml b/example-specs/task/nipype/ants/denoise_image.yaml
index 7b88d7f0..426fbdff 100644
--- a/example-specs/task/nipype/ants/denoise_image.yaml
+++ b/example-specs/task/nipype/ants/denoise_image.yaml
@@ -46,10 +46,10 @@ inputs:
   # passed to the field in the automatically generated unittests.
     input_image: medimage/nifti1
     # type=file|default=<undefined>: A scalar image is expected as input for noise correction.
-    output_image: medimage/nifti-gz
+    output_image: Path
     # type=file: 
     # type=file|default=<undefined>: The output consists of the noise corrected version of the input image.
-    noise_image: generic/file
+    noise_image: Path
     # type=file: 
     # type=file|default=<undefined>: Filename for the estimated noise.
   metadata:
@@ -147,7 +147,7 @@ tests:
 - inputs:
   # dict[str, str] - values to provide to inputs fields in the task initialisation
   # (if not specified, will try to choose a sensible value)
-    output_image:
+    output_image: '"output_corrected_image.nii.gz"'
     # type=file: 
     # type=file|default=<undefined>: The output consists of the noise corrected version of the input image.
     noise_model: '"Rician"'
@@ -213,7 +213,7 @@ doctests:
   # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
   # If the field is of file-format type and the value is None, then the
   # '.mock()' method of the corresponding class is used instead.
-    output_image:
+    output_image: '"output_corrected_image.nii.gz"'
     # type=file: 
     # type=file|default=<undefined>: The output consists of the noise corrected version of the input image.
     noise_model: '"Rician"'
diff --git a/example-specs/task/nipype/ants/image_math.yaml b/example-specs/task/nipype/ants/image_math.yaml
index 6a287d9d..e920cc83 100644
--- a/example-specs/task/nipype/ants/image_math.yaml
+++ b/example-specs/task/nipype/ants/image_math.yaml
@@ -74,11 +74,11 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    output_image: generic/file
-    # type=file: output image file
-    # type=file|default=<undefined>: output image file
     op1: medimage/nifti1
     # type=file|default=<undefined>: first operator
+    output_image: Path
+    # type=file: output image file
+    # type=file|default=<undefined>: output image file
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/ants/joint_fusion.yaml b/example-specs/task/nipype/ants/joint_fusion.yaml
index 4f771450..c8a32ab0 100644
--- a/example-specs/task/nipype/ants/joint_fusion.yaml
+++ b/example-specs/task/nipype/ants/joint_fusion.yaml
@@ -99,6 +99,9 @@ inputs:
     # type=list|default=[]: Specify an exclusion region for the given label.
     mask_image: generic/file
     # type=file|default=<undefined>: If a mask image is specified, fusion is only performed in the mask region.
+    out_label_fusion: Path
+    # type=file: 
+    # type=file|default=<undefined>: The output label fusion image.
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/ants/kelly_kapowski.yaml b/example-specs/task/nipype/ants/kelly_kapowski.yaml
index 6a186384..a1a5ecc3 100644
--- a/example-specs/task/nipype/ants/kelly_kapowski.yaml
+++ b/example-specs/task/nipype/ants/kelly_kapowski.yaml
@@ -51,10 +51,10 @@ inputs:
     # type=file|default=<undefined>: In addition to the segmentation image, a white matter probability image can be used. If no such image is supplied, one is created using the segmentation image and a variance of 1.0 mm.
     thickness_prior_image: generic/file
     # type=file|default=<undefined>: An image containing spatially varying prior thickness values.
-    cortical_thickness: generic/file
+    cortical_thickness: Path
     # type=file: A thickness map defined in the segmented gray matter.
     # type=file|default=<undefined>: Filename for the cortical thickness.
-    warped_white_matter: generic/file
+    warped_white_matter: Path
     # type=file: A warped white matter image.
     # type=file|default=<undefined>: Filename for the warped white matter file.
   metadata:
diff --git a/example-specs/task/nipype/ants/label_geometry.yaml b/example-specs/task/nipype/ants/label_geometry.yaml
index 36aafd24..94288523 100644
--- a/example-specs/task/nipype/ants/label_geometry.yaml
+++ b/example-specs/task/nipype/ants/label_geometry.yaml
@@ -38,6 +38,8 @@ inputs:
   # passed to the field in the automatically generated unittests.
     label_image: medimage/nifti-gz
     # type=file|default=<undefined>: label image to use for extracting geometry measures
+    intensity_image: medimage/nifti-gz
+    # type=file|default='[]': Intensity image to extract values from. This is an optional input
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -51,8 +53,6 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    intensity_image: medimage/nifti-gz
-    # type=file|default='[]': Intensity image to extract values from. This is an optional input
     output_file: generic/file
     # type=file: CSV file of geometry measures
     # type=str|default='': name of output file
@@ -122,7 +122,7 @@ tests:
 - inputs:
   # dict[str, str] - values to provide to inputs fields in the task initialisation
   # (if not specified, will try to choose a sensible value)
-    intensity_image: '"ants_Warp.nii.gz"'
+    intensity_image:
     # type=file|default='[]': Intensity image to extract values from. This is an optional input
   imports:
   # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
@@ -161,7 +161,7 @@ doctests:
   # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
   # If the field is of file-format type and the value is None, then the
   # '.mock()' method of the corresponding class is used instead.
-    intensity_image: '"ants_Warp.nii.gz"'
+    intensity_image:
     # type=file|default='[]': Intensity image to extract values from. This is an optional input
   imports:
   # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
diff --git a/example-specs/task/nipype/ants/multiply_images.yaml b/example-specs/task/nipype/ants/multiply_images.yaml
index b0598214..f69faa09 100644
--- a/example-specs/task/nipype/ants/multiply_images.yaml
+++ b/example-specs/task/nipype/ants/multiply_images.yaml
@@ -33,7 +33,7 @@ inputs:
   # passed to the field in the automatically generated unittests.
     first_input: medimage/nifti1
     # type=file|default=<undefined>: image 1
-    output_product_image: medimage/nifti1
+    output_product_image: Path
     # type=file: average image file
     # type=file|default=<undefined>: Outputfname.nii.gz: the name of the resulting image.
   metadata:
@@ -102,7 +102,7 @@ tests:
     # type=file|default=<undefined>: image 1
     second_input: '0.25'
     # type=traitcompound|default=None: image 2 or multiplication weight
-    output_product_image:
+    output_product_image: '"out.nii"'
     # type=file: average image file
     # type=file|default=<undefined>: Outputfname.nii.gz: the name of the resulting image.
   imports:
@@ -133,7 +133,7 @@ doctests:
     # type=file|default=<undefined>: image 1
     second_input: '0.25'
     # type=traitcompound|default=None: image 2 or multiplication weight
-    output_product_image:
+    output_product_image: '"out.nii"'
     # type=file: average image file
     # type=file|default=<undefined>: Outputfname.nii.gz: the name of the resulting image.
   imports:
diff --git a/example-specs/task/nipype/ants/n4_bias_field_correction.yaml b/example-specs/task/nipype/ants/n4_bias_field_correction.yaml
index a85f6de1..adc8b83d 100644
--- a/example-specs/task/nipype/ants/n4_bias_field_correction.yaml
+++ b/example-specs/task/nipype/ants/n4_bias_field_correction.yaml
@@ -91,7 +91,7 @@ inputs:
     # type=file|default=<undefined>: image to specify region to perform final bias correction in
     weight_image: generic/file
     # type=file|default=<undefined>: image for relative weighting (e.g. probability map of the white matter) of voxels during the B-spline fitting. 
-    bias_image: generic/file
+    bias_image: Path
     # type=file: Estimated bias
     # type=file|default=<undefined>: Filename for the estimated bias.
   metadata:
diff --git a/example-specs/task/nipype/ants/registration.yaml b/example-specs/task/nipype/ants/registration.yaml
index e842c235..cd1ce344 100644
--- a/example-specs/task/nipype/ants/registration.yaml
+++ b/example-specs/task/nipype/ants/registration.yaml
@@ -281,13 +281,13 @@ inputs:
     # type=inputmultiobject|default=[]: Image that will be registered to the space of fixed_image. This is theimage on which the transformations will be applied to
     moving_image_mask: generic/file
     # type=file|default=<undefined>: mask used to limit metric sampling region of the moving imagein all stages
-    save_state: datascience/text-matrix
-    # type=file: The saved registration state to be restored
-    # type=file|default=<undefined>: Filename for saving the internal restorable state of the registration
     restore_state: datascience/text-matrix
     # type=file|default=<undefined>: Filename for restoring the internal restorable state of the registration
     initial_moving_transform: datascience/text-matrix+list-of
     # type=inputmultiobject|default=[]: A transform or a list of transforms that should be applied before the registration begins. Note that, when a list is given, the transformations are applied in reverse order.
+    save_state: Path
+    # type=file: The saved registration state to be restored
+    # type=file|default=<undefined>: Filename for saving the internal restorable state of the registration
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -622,7 +622,7 @@ tests:
 - inputs:
   # dict[str, str] - values to provide to inputs fields in the task initialisation
   # (if not specified, will try to choose a sensible value)
-    save_state:
+    save_state: '"trans.mat"'
     # type=file: The saved registration state to be restored
     # type=file|default=<undefined>: Filename for saving the internal restorable state of the registration
     restore_state:
@@ -963,7 +963,7 @@ doctests:
   # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
   # If the field is of file-format type and the value is None, then the
   # '.mock()' method of the corresponding class is used instead.
-    save_state:
+    save_state: '"trans.mat"'
     # type=file: The saved registration state to be restored
     # type=file|default=<undefined>: Filename for saving the internal restorable state of the registration
     restore_state:
diff --git a/example-specs/task/nipype/ants/resample_image_by_spacing.yaml b/example-specs/task/nipype/ants/resample_image_by_spacing.yaml
index 17d6c355..d509a953 100644
--- a/example-specs/task/nipype/ants/resample_image_by_spacing.yaml
+++ b/example-specs/task/nipype/ants/resample_image_by_spacing.yaml
@@ -52,7 +52,7 @@ inputs:
   # passed to the field in the automatically generated unittests.
     input_image: medimage/nifti1
     # type=file|default=<undefined>: input image file
-    output_image: medimage/nifti-gz
+    output_image: Path
     # type=file: resampled file
     # type=file|default=<undefined>: output image file
   metadata:
@@ -123,7 +123,7 @@ tests:
   # (if not specified, will try to choose a sensible value)
     input_image:
     # type=file|default=<undefined>: input image file
-    output_image:
+    output_image: '"output.nii.gz"'
     # type=file: resampled file
     # type=file|default=<undefined>: output image file
     out_spacing: (4, 4, 4)
@@ -150,7 +150,7 @@ tests:
   # (if not specified, will try to choose a sensible value)
     input_image:
     # type=file|default=<undefined>: input image file
-    output_image:
+    output_image: '"output.nii.gz"'
     # type=file: resampled file
     # type=file|default=<undefined>: output image file
     out_spacing: (4, 4, 4)
@@ -179,7 +179,7 @@ tests:
   # (if not specified, will try to choose a sensible value)
     input_image:
     # type=file|default=<undefined>: input image file
-    output_image:
+    output_image: '"output.nii.gz"'
     # type=file: resampled file
     # type=file|default=<undefined>: output image file
     out_spacing: (0.4, 0.4, 0.4)
@@ -216,7 +216,7 @@ doctests:
   # '.mock()' method of the corresponding class is used instead.
     input_image:
     # type=file|default=<undefined>: input image file
-    output_image:
+    output_image: '"output.nii.gz"'
     # type=file: resampled file
     # type=file|default=<undefined>: output image file
     out_spacing: (4, 4, 4)
@@ -236,7 +236,7 @@ doctests:
   # '.mock()' method of the corresponding class is used instead.
     input_image:
     # type=file|default=<undefined>: input image file
-    output_image:
+    output_image: '"output.nii.gz"'
     # type=file: resampled file
     # type=file|default=<undefined>: output image file
     out_spacing: (4, 4, 4)
@@ -258,7 +258,7 @@ doctests:
   # '.mock()' method of the corresponding class is used instead.
     input_image:
     # type=file|default=<undefined>: input image file
-    output_image:
+    output_image: '"output.nii.gz"'
     # type=file: resampled file
     # type=file|default=<undefined>: output image file
     out_spacing: (0.4, 0.4, 0.4)
diff --git a/example-specs/task/nipype/ants/threshold_image.yaml b/example-specs/task/nipype/ants/threshold_image.yaml
index c0d7ee1c..6fa05b67 100644
--- a/example-specs/task/nipype/ants/threshold_image.yaml
+++ b/example-specs/task/nipype/ants/threshold_image.yaml
@@ -45,11 +45,11 @@ inputs:
   # passed to the field in the automatically generated unittests.
     input_image: medimage/nifti1
     # type=file|default=<undefined>: input image file
-    output_image: medimage/nifti-gz
-    # type=file: resampled file
-    # type=file|default=<undefined>: output image file
     input_mask: generic/file
     # type=file|default=<undefined>: input mask for Otsu, Kmeans
+    output_image: Path
+    # type=file: resampled file
+    # type=file|default=<undefined>: output image file
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -126,7 +126,7 @@ tests:
   # (if not specified, will try to choose a sensible value)
     input_image:
     # type=file|default=<undefined>: input image file
-    output_image:
+    output_image: '"output.nii.gz"'
     # type=file: resampled file
     # type=file|default=<undefined>: output image file
     th_low: '0.5'
@@ -159,7 +159,7 @@ tests:
   # (if not specified, will try to choose a sensible value)
     input_image:
     # type=file|default=<undefined>: input image file
-    output_image:
+    output_image: '"output.nii.gz"'
     # type=file: resampled file
     # type=file|default=<undefined>: output image file
     mode: '"Kmeans"'
@@ -192,7 +192,7 @@ doctests:
   # '.mock()' method of the corresponding class is used instead.
     input_image:
     # type=file|default=<undefined>: input image file
-    output_image:
+    output_image: '"output.nii.gz"'
     # type=file: resampled file
     # type=file|default=<undefined>: output image file
     th_low: '0.5'
@@ -218,7 +218,7 @@ doctests:
   # '.mock()' method of the corresponding class is used instead.
     input_image:
     # type=file|default=<undefined>: input image file
-    output_image:
+    output_image: '"output.nii.gz"'
     # type=file: resampled file
     # type=file|default=<undefined>: output image file
     mode: '"Kmeans"'
diff --git a/example-specs/task/nipype/ants/warp_image_multi_transform.yaml b/example-specs/task/nipype/ants/warp_image_multi_transform.yaml
index 339bc8db..82206b42 100644
--- a/example-specs/task/nipype/ants/warp_image_multi_transform.yaml
+++ b/example-specs/task/nipype/ants/warp_image_multi_transform.yaml
@@ -43,6 +43,8 @@ inputs:
   # passed to the field in the automatically generated unittests.
     input_image: medimage/nifti1
     # type=file|default=<undefined>: image to apply transformation to (generally a coregistered functional)
+    out_postfix: generic/file
+    # type=file|default='_wimt': Postfix that is prepended to all output files (default = _wimt)
     reference_image: medimage/nifti1,medimage/nifti-gz
     # type=file|default=<undefined>: reference image space that you wish to warp INTO
     transformation_series: '[text/text-file,medimage/nifti-gz]+list-of'
@@ -60,8 +62,6 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    out_postfix: generic/file
-    # type=file|default='_wimt': Postfix that is prepended to all output files (default = _wimt)
     output_image: generic/file
     # type=file: Warped image
     # type=file|default=<undefined>: name of the output warped image
diff --git a/example-specs/task/nipype/freesurfer/add_x_form_to_header.yaml b/example-specs/task/nipype/freesurfer/add_x_form_to_header.yaml
index 5a065e54..30b93869 100644
--- a/example-specs/task/nipype/freesurfer/add_x_form_to_header.yaml
+++ b/example-specs/task/nipype/freesurfer/add_x_form_to_header.yaml
@@ -52,6 +52,9 @@ inputs:
     # type=file|default=<undefined>: xfm file
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+    out_file: Path
+    # type=file: output volume
+    # type=file|default='output.mgz': output volume
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/aparc_2_aseg.yaml b/example-specs/task/nipype/freesurfer/aparc_2_aseg.yaml
index db55ba53..875004c7 100644
--- a/example-specs/task/nipype/freesurfer/aparc_2_aseg.yaml
+++ b/example-specs/task/nipype/freesurfer/aparc_2_aseg.yaml
@@ -81,6 +81,9 @@ inputs:
     # type=file|default=<undefined>: 
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+    out_file: Path
+    # type=file: Output aseg file
+    # type=file|default=<undefined>: Full path of file to save the output segmentation in
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/apas_2_aseg.yaml b/example-specs/task/nipype/freesurfer/apas_2_aseg.yaml
index 649b5775..a7d8a753 100644
--- a/example-specs/task/nipype/freesurfer/apas_2_aseg.yaml
+++ b/example-specs/task/nipype/freesurfer/apas_2_aseg.yaml
@@ -39,6 +39,9 @@ inputs:
     # type=file|default=<undefined>: Input aparc+aseg.mgz
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+    out_file: Path
+    # type=file: Output aseg file
+    # type=file|default=<undefined>: Output aseg file
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/apply_mask.yaml b/example-specs/task/nipype/freesurfer/apply_mask.yaml
index 2f828c56..b6971532 100644
--- a/example-specs/task/nipype/freesurfer/apply_mask.yaml
+++ b/example-specs/task/nipype/freesurfer/apply_mask.yaml
@@ -38,6 +38,9 @@ inputs:
     # type=file|default=<undefined>: image defining transform target space
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+    out_file: Path
+    # type=file: masked image
+    # type=file|default=<undefined>: final image to write
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/ca_label.yaml b/example-specs/task/nipype/freesurfer/ca_label.yaml
index ee9379ef..29a44035 100644
--- a/example-specs/task/nipype/freesurfer/ca_label.yaml
+++ b/example-specs/task/nipype/freesurfer/ca_label.yaml
@@ -54,6 +54,9 @@ inputs:
     # type=file|default=<undefined>: Undocumented flag. Autorecon3 uses ../mri/aseg.presurf.mgz as input file
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+    out_file: Path
+    # type=file: Output volume from CALabel
+    # type=file|default=<undefined>: Output file for CALabel
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/ca_normalize.yaml b/example-specs/task/nipype/freesurfer/ca_normalize.yaml
index f277c3e0..3988aa00 100644
--- a/example-specs/task/nipype/freesurfer/ca_normalize.yaml
+++ b/example-specs/task/nipype/freesurfer/ca_normalize.yaml
@@ -46,13 +46,16 @@ inputs:
     # type=file|default=<undefined>: The transform file in lta format
     mask: generic/file
     # type=file|default=<undefined>: Specifies volume to use as mask
-    control_points: generic/file
-    # type=file: The output control points for Normalize
-    # type=file|default=<undefined>: File name for the output control points
     long_file: generic/file
     # type=file|default=<undefined>: undocumented flag used in longitudinal processing
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+    out_file: Path
+    # type=file: The output file for Normalize
+    # type=file|default=<undefined>: The output file for CANormalize
+    control_points: Path
+    # type=file: The output control points for Normalize
+    # type=file|default=<undefined>: File name for the output control points
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/concatenate_lta.yaml b/example-specs/task/nipype/freesurfer/concatenate_lta.yaml
index a4b9ffe0..c552a2f6 100644
--- a/example-specs/task/nipype/freesurfer/concatenate_lta.yaml
+++ b/example-specs/task/nipype/freesurfer/concatenate_lta.yaml
@@ -55,6 +55,9 @@ inputs:
     # type=file|default=<undefined>: if in_lta2 is talairach.xfm, specify template for talairach
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+    out_file: Path
+    # type=file: the combined LTA maps: src1 to dst2 = LTA2*LTA1
+    # type=file|default=<undefined>: the combined LTA maps: src1 to dst2 = LTA2*LTA1
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/curvature_stats.yaml b/example-specs/task/nipype/freesurfer/curvature_stats.yaml
index e5e87797..9f761c5a 100644
--- a/example-specs/task/nipype/freesurfer/curvature_stats.yaml
+++ b/example-specs/task/nipype/freesurfer/curvature_stats.yaml
@@ -64,6 +64,9 @@ inputs:
     # type=file|default=<undefined>: Input file for CurvatureStats
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+    out_file: Path
+    # type=file: Output curvature stats file
+    # type=file|default=<undefined>: Output curvature stats file
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/edit_w_mwith_aseg.yaml b/example-specs/task/nipype/freesurfer/edit_w_mwith_aseg.yaml
index 933009e2..9aeb7d6d 100644
--- a/example-specs/task/nipype/freesurfer/edit_w_mwith_aseg.yaml
+++ b/example-specs/task/nipype/freesurfer/edit_w_mwith_aseg.yaml
@@ -42,6 +42,9 @@ inputs:
     # type=file|default=<undefined>: Input presurf segmentation file
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+    out_file: Path
+    # type=file: Output edited WM file
+    # type=file|default=<undefined>: File to be written as output
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/em_register.yaml b/example-specs/task/nipype/freesurfer/em_register.yaml
index bcfbd6d9..fec8ccf4 100644
--- a/example-specs/task/nipype/freesurfer/em_register.yaml
+++ b/example-specs/task/nipype/freesurfer/em_register.yaml
@@ -43,6 +43,9 @@ inputs:
     # type=file|default=<undefined>: Previously computed transform
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+    out_file: Path
+    # type=file: output transform
+    # type=file|default=<undefined>: output transform
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/extract_main_component.yaml b/example-specs/task/nipype/freesurfer/extract_main_component.yaml
index 496f856b..0ad30468 100644
--- a/example-specs/task/nipype/freesurfer/extract_main_component.yaml
+++ b/example-specs/task/nipype/freesurfer/extract_main_component.yaml
@@ -32,6 +32,9 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage-freesurfer/pial
     # type=file|default=<undefined>: input surface file
+    out_file: Path
+    # type=file: surface containing main component
+    # type=file|default=<undefined>: surface containing main component
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/fit_ms_params.yaml b/example-specs/task/nipype/freesurfer/fit_ms_params.yaml
index d75002bc..d29e34df 100644
--- a/example-specs/task/nipype/freesurfer/fit_ms_params.yaml
+++ b/example-specs/task/nipype/freesurfer/fit_ms_params.yaml
@@ -35,6 +35,8 @@ inputs:
     # type=list|default=[]: list of FLASH images (must be in mgh format)
     xfm_list: generic/file+list-of
     # type=list|default=[]: list of transform files to apply to each FLASH image
+    out_dir: generic/directory
+    # type=directory|default=<undefined>: directory to store output in
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
   metadata:
@@ -61,8 +63,6 @@ outputs:
   # to set to the `callable` attribute of output fields
   templates:
   # dict[str, str] - `output_file_template` values to be provided to output fields
-    out_dir: '"flash_parameters"'
-    # type=directory|default=<undefined>: directory to store output in
   requirements:
   # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
 tests:
diff --git a/example-specs/task/nipype/freesurfer/fuse_segmentations.yaml b/example-specs/task/nipype/freesurfer/fuse_segmentations.yaml
index bcacf617..4095fa95 100644
--- a/example-specs/task/nipype/freesurfer/fuse_segmentations.yaml
+++ b/example-specs/task/nipype/freesurfer/fuse_segmentations.yaml
@@ -42,6 +42,9 @@ inputs:
     # type=inputmultiobject|default=[]: -n <filename>  - name of norm file to use (default: norm.mgs)         must include the corresponding norm file for all given timepoints         as well as for the current subject
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+    out_file: Path
+    # type=file: output fused segmentation file
+    # type=file|default=<undefined>: output fused segmentation file
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/glm_fit.yaml b/example-specs/task/nipype/freesurfer/glm_fit.yaml
index b6d67c56..4ffa4f31 100644
--- a/example-specs/task/nipype/freesurfer/glm_fit.yaml
+++ b/example-specs/task/nipype/freesurfer/glm_fit.yaml
@@ -46,15 +46,15 @@ inputs:
     # type=file|default=<undefined>: text file with dof for fixed effects analysis
     weight_file: generic/file
     # type=file|default=<undefined>: weight for each input at each voxel
-    mask_file: generic/file
-    # type=file: map of the mask used in the analysis
-    # type=file|default=<undefined>: binary mask
     label_file: generic/file
     # type=file|default=<undefined>: use label as mask, surfaces only
     sim_done_file: generic/file
     # type=file|default=<undefined>: create file when simulation finished
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+    mask_file: Path
+    # type=file: map of the mask used in the analysis
+    # type=file|default=<undefined>: binary mask
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/gtm_seg.yaml b/example-specs/task/nipype/freesurfer/gtm_seg.yaml
index 301b9c50..753e275f 100644
--- a/example-specs/task/nipype/freesurfer/gtm_seg.yaml
+++ b/example-specs/task/nipype/freesurfer/gtm_seg.yaml
@@ -32,6 +32,9 @@ inputs:
     # type=file|default=<undefined>: colortable
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+    out_file: Path
+    # type=file: GTM segmentation
+    # type=file|default='gtmseg.mgz': output volume relative to subject/mri
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/jacobian.yaml b/example-specs/task/nipype/freesurfer/jacobian.yaml
index 315bc120..461ccc48 100644
--- a/example-specs/task/nipype/freesurfer/jacobian.yaml
+++ b/example-specs/task/nipype/freesurfer/jacobian.yaml
@@ -37,6 +37,9 @@ inputs:
     # type=file|default=<undefined>: Mapped surface
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+    out_file: Path
+    # type=file: Output Jacobian of the surface mapping
+    # type=file|default=<undefined>: Output Jacobian of the surface mapping
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/label_2_label.yaml b/example-specs/task/nipype/freesurfer/label_2_label.yaml
index 24982b77..9be248c6 100644
--- a/example-specs/task/nipype/freesurfer/label_2_label.yaml
+++ b/example-specs/task/nipype/freesurfer/label_2_label.yaml
@@ -57,6 +57,9 @@ inputs:
     # type=file|default=<undefined>: Source label
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+    out_file: Path
+    # type=file: Output label
+    # type=file|default=<undefined>: Target label
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/logan_ref.yaml b/example-specs/task/nipype/freesurfer/logan_ref.yaml
index ad1168ba..6e972319 100644
--- a/example-specs/task/nipype/freesurfer/logan_ref.yaml
+++ b/example-specs/task/nipype/freesurfer/logan_ref.yaml
@@ -45,15 +45,15 @@ inputs:
     # type=file|default=<undefined>: text file with dof for fixed effects analysis
     weight_file: generic/file
     # type=file|default=<undefined>: weight for each input at each voxel
-    mask_file: generic/file
-    # type=file: map of the mask used in the analysis
-    # type=file|default=<undefined>: binary mask
     label_file: generic/file
     # type=file|default=<undefined>: use label as mask, surfaces only
     sim_done_file: generic/file
     # type=file|default=<undefined>: create file when simulation finished
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+    mask_file: Path
+    # type=file: map of the mask used in the analysis
+    # type=file|default=<undefined>: binary mask
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/make_average_subject.yaml b/example-specs/task/nipype/freesurfer/make_average_subject.yaml
index b697d7d5..9a288940 100644
--- a/example-specs/task/nipype/freesurfer/make_average_subject.yaml
+++ b/example-specs/task/nipype/freesurfer/make_average_subject.yaml
@@ -30,6 +30,8 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    out_name: generic/file
+    # type=file|default='average': name for the average subject
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
   metadata:
@@ -45,8 +47,6 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    out_name: generic/file
-    # type=file|default='average': name for the average subject
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/freesurfer/mni_bias_correction.yaml b/example-specs/task/nipype/freesurfer/mni_bias_correction.yaml
index 5fa4a1e2..664375cc 100644
--- a/example-specs/task/nipype/freesurfer/mni_bias_correction.yaml
+++ b/example-specs/task/nipype/freesurfer/mni_bias_correction.yaml
@@ -54,6 +54,9 @@ inputs:
     # type=file|default=<undefined>: tal.xfm. Use mri_make_uchar instead of conforming
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+    out_file: Path
+    # type=file: output volume
+    # type=file|default=<undefined>: output volume. Output can be any format accepted by mri_convert. If the output format is COR, then the directory must exist.
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/mr_is_ca_label.yaml b/example-specs/task/nipype/freesurfer/mr_is_ca_label.yaml
index a9f5a063..b2ded4c3 100644
--- a/example-specs/task/nipype/freesurfer/mr_is_ca_label.yaml
+++ b/example-specs/task/nipype/freesurfer/mr_is_ca_label.yaml
@@ -60,6 +60,9 @@ inputs:
     # type=file|default=<undefined>: Undocumented flag. Autorecon3 uses ../mri/aseg.presurf.mgz as input file
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+    out_file: Path
+    # type=file: Output volume from MRIsCALabel
+    # type=file|default=<undefined>: Annotated surface output file
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/mr_is_calc.yaml b/example-specs/task/nipype/freesurfer/mr_is_calc.yaml
index cdd1e863..567b9158 100644
--- a/example-specs/task/nipype/freesurfer/mr_is_calc.yaml
+++ b/example-specs/task/nipype/freesurfer/mr_is_calc.yaml
@@ -48,6 +48,9 @@ inputs:
     # type=file|default=<undefined>: Input file 2
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+    out_file: Path
+    # type=file: Output file after calculation
+    # type=file|default=<undefined>: Output file after calculation
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/mr_is_convert.yaml b/example-specs/task/nipype/freesurfer/mr_is_convert.yaml
index 56fbad14..26e4e3ea 100644
--- a/example-specs/task/nipype/freesurfer/mr_is_convert.yaml
+++ b/example-specs/task/nipype/freesurfer/mr_is_convert.yaml
@@ -45,6 +45,8 @@ inputs:
     # type=file|default=<undefined>: outfile is name of gifti file to which label stats will be written
     in_file: generic/file
     # type=file|default=<undefined>: File to read/convert
+    out_file: generic/file
+    # type=file|default=<undefined>: output filename or True to generate one
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
   metadata:
@@ -67,8 +69,6 @@ outputs:
   # to set to the `callable` attribute of output fields
   templates:
   # dict[str, str] - `output_file_template` values to be provided to output fields
-    out_file: out_file
-    # type=file|default=<undefined>: output filename or True to generate one
   requirements:
   # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
 tests:
diff --git a/example-specs/task/nipype/freesurfer/mr_is_inflate.yaml b/example-specs/task/nipype/freesurfer/mr_is_inflate.yaml
index 92f046ef..ae9a3f93 100644
--- a/example-specs/task/nipype/freesurfer/mr_is_inflate.yaml
+++ b/example-specs/task/nipype/freesurfer/mr_is_inflate.yaml
@@ -35,6 +35,12 @@ inputs:
     # type=file|default=<undefined>: Input file for MRIsInflate
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+    out_file: Path
+    # type=file: Output file for MRIsInflate
+    # type=file|default=<undefined>: Output file for MRIsInflate
+    out_sulc: Path
+    # type=file: Output sulc file
+    # type=file|default=<undefined>: Output sulc file
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/mri_convert.yaml b/example-specs/task/nipype/freesurfer/mri_convert.yaml
index b49e039d..101efcc7 100644
--- a/example-specs/task/nipype/freesurfer/mri_convert.yaml
+++ b/example-specs/task/nipype/freesurfer/mri_convert.yaml
@@ -43,6 +43,9 @@ inputs:
     # type=file|default=<undefined>: apply inverse transformation xfm file
     in_file: medimage/nifti1
     # type=file|default=<undefined>: File to read/convert
+    out_file: medimage/mgh-gz
+    # type=outputmultiobject: converted output file
+    # type=file|default=<undefined>: output filename or True to generate one
     reslice_like: generic/file
     # type=file|default=<undefined>: reslice output to match file
     in_like: generic/file
@@ -73,9 +76,6 @@ outputs:
   # to set to the `callable` attribute of output fields
   templates:
   # dict[str, str] - `output_file_template` values to be provided to output fields
-    out_file: '"outfile.mgz"'
-    # type=outputmultiobject: converted output file
-    # type=file|default=<undefined>: output filename or True to generate one
   requirements:
   # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
 tests:
@@ -275,7 +275,7 @@ tests:
   # (if not specified, will try to choose a sensible value)
     in_file:
     # type=file|default=<undefined>: File to read/convert
-    out_file: '"outfile.mgz"'
+    out_file:
     # type=outputmultiobject: converted output file
     # type=file|default=<undefined>: output filename or True to generate one
     out_type: '"mgz"'
@@ -304,7 +304,7 @@ doctests:
   # '.mock()' method of the corresponding class is used instead.
     in_file:
     # type=file|default=<undefined>: File to read/convert
-    out_file: '"outfile.mgz"'
+    out_file:
     # type=outputmultiobject: converted output file
     # type=file|default=<undefined>: output filename or True to generate one
     out_type: '"mgz"'
diff --git a/example-specs/task/nipype/freesurfer/mri_fill.yaml b/example-specs/task/nipype/freesurfer/mri_fill.yaml
index 894b22c7..78ea995e 100644
--- a/example-specs/task/nipype/freesurfer/mri_fill.yaml
+++ b/example-specs/task/nipype/freesurfer/mri_fill.yaml
@@ -38,11 +38,14 @@ inputs:
     # type=file|default=<undefined>: Input segmentation file for MRIFill
     transform: generic/file
     # type=file|default=<undefined>: Input transform file for MRIFill
-    log_file: generic/file
-    # type=file: Output log file from MRIFill
-    # type=file|default=<undefined>: Output log file for MRIFill
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+    out_file: Path
+    # type=file: Output file from MRIFill
+    # type=file|default=<undefined>: Output filled volume file name for MRIFill
+    log_file: Path
+    # type=file: Output log file from MRIFill
+    # type=file|default=<undefined>: Output log file for MRIFill
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/mri_marching_cubes.yaml b/example-specs/task/nipype/freesurfer/mri_marching_cubes.yaml
index bf3254cd..cff8645b 100644
--- a/example-specs/task/nipype/freesurfer/mri_marching_cubes.yaml
+++ b/example-specs/task/nipype/freesurfer/mri_marching_cubes.yaml
@@ -34,6 +34,8 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: generic/file
     # type=file|default=<undefined>: Input volume to tessellate voxels from.
+    out_file: generic/file
+    # type=file|default=<undefined>: output filename or True to generate one
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
   metadata:
@@ -56,8 +58,6 @@ outputs:
   # to set to the `callable` attribute of output fields
   templates:
   # dict[str, str] - `output_file_template` values to be provided to output fields
-    out_file: out_file
-    # type=file|default=<undefined>: output filename or True to generate one
   requirements:
   # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
 tests:
diff --git a/example-specs/task/nipype/freesurfer/mri_pretess.yaml b/example-specs/task/nipype/freesurfer/mri_pretess.yaml
index 92a73eee..24e34e60 100644
--- a/example-specs/task/nipype/freesurfer/mri_pretess.yaml
+++ b/example-specs/task/nipype/freesurfer/mri_pretess.yaml
@@ -44,6 +44,9 @@ inputs:
     # type=file|default=<undefined>: the normalized, brain-extracted T1w image. Usually norm.mgz
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+    out_file: Path
+    # type=file: output file after mri_pretess
+    # type=file|default=<undefined>: the output file after mri_pretess.
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/mri_tessellate.yaml b/example-specs/task/nipype/freesurfer/mri_tessellate.yaml
index a2376d9c..a1720f1e 100644
--- a/example-specs/task/nipype/freesurfer/mri_tessellate.yaml
+++ b/example-specs/task/nipype/freesurfer/mri_tessellate.yaml
@@ -34,6 +34,8 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: generic/file
     # type=file|default=<undefined>: Input volume to tessellate voxels from.
+    out_file: generic/file
+    # type=file|default=<undefined>: output filename or True to generate one
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
   metadata:
@@ -56,8 +58,6 @@ outputs:
   # to set to the `callable` attribute of output fields
   templates:
   # dict[str, str] - `output_file_template` values to be provided to output fields
-    out_file: out_file
-    # type=file|default=<undefined>: output filename or True to generate one
   requirements:
   # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
 tests:
diff --git a/example-specs/task/nipype/freesurfer/mrtm.yaml b/example-specs/task/nipype/freesurfer/mrtm.yaml
index d91bf54b..acb22a4d 100644
--- a/example-specs/task/nipype/freesurfer/mrtm.yaml
+++ b/example-specs/task/nipype/freesurfer/mrtm.yaml
@@ -46,15 +46,15 @@ inputs:
     # type=file|default=<undefined>: text file with dof for fixed effects analysis
     weight_file: generic/file
     # type=file|default=<undefined>: weight for each input at each voxel
-    mask_file: generic/file
-    # type=file: map of the mask used in the analysis
-    # type=file|default=<undefined>: binary mask
     label_file: generic/file
     # type=file|default=<undefined>: use label as mask, surfaces only
     sim_done_file: generic/file
     # type=file|default=<undefined>: create file when simulation finished
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+    mask_file: Path
+    # type=file: map of the mask used in the analysis
+    # type=file|default=<undefined>: binary mask
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/mrtm2.yaml b/example-specs/task/nipype/freesurfer/mrtm2.yaml
index ccd6baab..86072201 100644
--- a/example-specs/task/nipype/freesurfer/mrtm2.yaml
+++ b/example-specs/task/nipype/freesurfer/mrtm2.yaml
@@ -45,15 +45,15 @@ inputs:
     # type=file|default=<undefined>: text file with dof for fixed effects analysis
     weight_file: generic/file
     # type=file|default=<undefined>: weight for each input at each voxel
-    mask_file: generic/file
-    # type=file: map of the mask used in the analysis
-    # type=file|default=<undefined>: binary mask
     label_file: generic/file
     # type=file|default=<undefined>: use label as mask, surfaces only
     sim_done_file: generic/file
     # type=file|default=<undefined>: create file when simulation finished
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+    mask_file: Path
+    # type=file: map of the mask used in the analysis
+    # type=file|default=<undefined>: binary mask
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/ms__lda.yaml b/example-specs/task/nipype/freesurfer/ms__lda.yaml
index ef1e17ad..f1b1ecd4 100644
--- a/example-specs/task/nipype/freesurfer/ms__lda.yaml
+++ b/example-specs/task/nipype/freesurfer/ms__lda.yaml
@@ -31,12 +31,6 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    weight_file: text/text-file
-    # type=file: 
-    # type=file|default=<undefined>: filename for the LDA weights (input or output)
-    vol_synth_file: medimage/mgh-gz
-    # type=file: 
-    # type=file|default=<undefined>: filename for the synthesized output volume
     label_file: medimage/mgh-gz
     # type=file|default=<undefined>: filename of the label volume
     mask_file: generic/file
@@ -45,6 +39,12 @@ inputs:
     # type=inputmultiobject|default=[]: list of input FLASH images
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+    weight_file: Path
+    # type=file: 
+    # type=file|default=<undefined>: filename for the LDA weights (input or output)
+    vol_synth_file: Path
+    # type=file: 
+    # type=file|default=<undefined>: filename for the synthesized output volume
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -123,12 +123,12 @@ tests:
     # type=list|default=[]: pair of class labels to optimize
     label_file:
     # type=file|default=<undefined>: filename of the label volume
-    weight_file:
+    weight_file: '"weights.txt"'
     # type=file: 
     # type=file|default=<undefined>: filename for the LDA weights (input or output)
     shift: zero_value
     # type=int|default=0: shift all values equal to the given value to zero
-    vol_synth_file:
+    vol_synth_file: '"synth_out.mgz"'
     # type=file: 
     # type=file|default=<undefined>: filename for the synthesized output volume
     conform: 'True'
@@ -163,12 +163,12 @@ doctests:
     # type=list|default=[]: pair of class labels to optimize
     label_file:
     # type=file|default=<undefined>: filename of the label volume
-    weight_file:
+    weight_file: '"weights.txt"'
     # type=file: 
     # type=file|default=<undefined>: filename for the LDA weights (input or output)
     shift: zero_value
     # type=int|default=0: shift all values equal to the given value to zero
-    vol_synth_file:
+    vol_synth_file: '"synth_out.mgz"'
     # type=file: 
     # type=file|default=<undefined>: filename for the synthesized output volume
     conform: 'True'
diff --git a/example-specs/task/nipype/freesurfer/normalize.yaml b/example-specs/task/nipype/freesurfer/normalize.yaml
index b08139a8..190a68ad 100644
--- a/example-specs/task/nipype/freesurfer/normalize.yaml
+++ b/example-specs/task/nipype/freesurfer/normalize.yaml
@@ -43,6 +43,9 @@ inputs:
     # type=file|default=<undefined>: Transform file from the header of the input file
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+    out_file: Path
+    # type=file: The output file for Normalize
+    # type=file|default=<undefined>: The output file for Normalize
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/one_sample_t_test.yaml b/example-specs/task/nipype/freesurfer/one_sample_t_test.yaml
index 18ac4a8a..43ab0797 100644
--- a/example-specs/task/nipype/freesurfer/one_sample_t_test.yaml
+++ b/example-specs/task/nipype/freesurfer/one_sample_t_test.yaml
@@ -36,15 +36,15 @@ inputs:
     # type=file|default=<undefined>: text file with dof for fixed effects analysis
     weight_file: generic/file
     # type=file|default=<undefined>: weight for each input at each voxel
-    mask_file: generic/file
-    # type=file: map of the mask used in the analysis
-    # type=file|default=<undefined>: binary mask
     label_file: generic/file
     # type=file|default=<undefined>: use label as mask, surfaces only
     sim_done_file: generic/file
     # type=file|default=<undefined>: create file when simulation finished
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+    mask_file: Path
+    # type=file: map of the mask used in the analysis
+    # type=file|default=<undefined>: binary mask
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/paint.yaml b/example-specs/task/nipype/freesurfer/paint.yaml
index 0184ca1f..a5ff15a5 100644
--- a/example-specs/task/nipype/freesurfer/paint.yaml
+++ b/example-specs/task/nipype/freesurfer/paint.yaml
@@ -43,6 +43,9 @@ inputs:
     # type=file|default=<undefined>: Template file
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+    out_file: Path
+    # type=file: File containing a surface-worth of per-vertex values, saved in 'curvature' format.
+    # type=file|default=<undefined>: File containing a surface-worth of per-vertex values, saved in 'curvature' format.
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/parse_dicom_dir.yaml b/example-specs/task/nipype/freesurfer/parse_dicom_dir.yaml
index 00c593a7..cf652ef6 100644
--- a/example-specs/task/nipype/freesurfer/parse_dicom_dir.yaml
+++ b/example-specs/task/nipype/freesurfer/parse_dicom_dir.yaml
@@ -37,6 +37,9 @@ inputs:
     # type=directory|default=<undefined>: path to siemens dicom directory
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+    dicom_info_file: Path
+    # type=file: text file containing dicom information
+    # type=file|default='dicominfo.txt': file to which results are written
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/register_av_ito_talairach.yaml b/example-specs/task/nipype/freesurfer/register_av_ito_talairach.yaml
index b24e9878..c82866b6 100644
--- a/example-specs/task/nipype/freesurfer/register_av_ito_talairach.yaml
+++ b/example-specs/task/nipype/freesurfer/register_av_ito_talairach.yaml
@@ -52,6 +52,9 @@ inputs:
     # type=file|default=<undefined>: The vox2vox file
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+    out_file: Path
+    # type=file: The output file for RegisterAVItoTalairach
+    # type=file|default='talairach.auto.xfm': The transform output
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/relabel_hypointensities.yaml b/example-specs/task/nipype/freesurfer/relabel_hypointensities.yaml
index 5eefca06..0f7bca76 100644
--- a/example-specs/task/nipype/freesurfer/relabel_hypointensities.yaml
+++ b/example-specs/task/nipype/freesurfer/relabel_hypointensities.yaml
@@ -43,6 +43,9 @@ inputs:
     # type=directory|default='.': Directory containing lh.white and rh.white
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+    out_file: Path
+    # type=file: Output aseg file
+    # type=file|default=<undefined>: Output aseg file
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/remove_intersection.yaml b/example-specs/task/nipype/freesurfer/remove_intersection.yaml
index cf7102bc..086bbaf5 100644
--- a/example-specs/task/nipype/freesurfer/remove_intersection.yaml
+++ b/example-specs/task/nipype/freesurfer/remove_intersection.yaml
@@ -34,6 +34,9 @@ inputs:
     # type=file|default=<undefined>: Input file for RemoveIntersection
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+    out_file: Path
+    # type=file: Output file for RemoveIntersection
+    # type=file|default=<undefined>: Output file for RemoveIntersection
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/remove_neck.yaml b/example-specs/task/nipype/freesurfer/remove_neck.yaml
index 71797446..1ee1c5e9 100644
--- a/example-specs/task/nipype/freesurfer/remove_neck.yaml
+++ b/example-specs/task/nipype/freesurfer/remove_neck.yaml
@@ -41,6 +41,9 @@ inputs:
     # type=file|default=<undefined>: Input template file for RemoveNeck
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+    out_file: Path
+    # type=file: Output file with neck removed
+    # type=file|default=<undefined>: Output file for RemoveNeck
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/robust_template.yaml b/example-specs/task/nipype/freesurfer/robust_template.yaml
index ddd4e0cf..dad1fa46 100644
--- a/example-specs/task/nipype/freesurfer/robust_template.yaml
+++ b/example-specs/task/nipype/freesurfer/robust_template.yaml
@@ -65,6 +65,9 @@ inputs:
     # type=inputmultiobject|default=[]: use initial intensity scales
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+    out_file: Path
+    # type=file: output template volume (final mean/median image)
+    # type=file|default='mri_robust_template_out.mgz': output template volume (final mean/median image)
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/segment_cc.yaml b/example-specs/task/nipype/freesurfer/segment_cc.yaml
index 79ba3f6b..7dfa967d 100644
--- a/example-specs/task/nipype/freesurfer/segment_cc.yaml
+++ b/example-specs/task/nipype/freesurfer/segment_cc.yaml
@@ -46,6 +46,12 @@ inputs:
     # type=file|default=<undefined>: Required undocumented input {subject}/mri/norm.mgz
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+    out_file: Path
+    # type=file: Output segmentation uncluding corpus collosum
+    # type=file|default=<undefined>: Filename to write aseg including CC
+    out_rotation: Path
+    # type=file: Output lta rotation file
+    # type=file|default=<undefined>: Global filepath for writing rotation lta
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/segment_wm.yaml b/example-specs/task/nipype/freesurfer/segment_wm.yaml
index 4878172d..9e11d1ae 100644
--- a/example-specs/task/nipype/freesurfer/segment_wm.yaml
+++ b/example-specs/task/nipype/freesurfer/segment_wm.yaml
@@ -38,6 +38,9 @@ inputs:
     # type=file|default=<undefined>: Input file for SegmentWM
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+    out_file: Path
+    # type=file: Output white matter segmentation
+    # type=file|default=<undefined>: File to be written as output for SegmentWM
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/smooth_tessellation.yaml b/example-specs/task/nipype/freesurfer/smooth_tessellation.yaml
index 2763de80..74b19c87 100644
--- a/example-specs/task/nipype/freesurfer/smooth_tessellation.yaml
+++ b/example-specs/task/nipype/freesurfer/smooth_tessellation.yaml
@@ -37,6 +37,12 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: generic/file
     # type=file|default=<undefined>: Input volume to tessellate voxels from.
+    out_file: generic/file
+    # type=file|default=<undefined>: output filename or True to generate one
+    out_curvature_file: generic/file
+    # type=file|default=<undefined>: Write curvature to ``?h.curvname`` (default "curv")
+    out_area_file: generic/file
+    # type=file|default=<undefined>: Write area to ``?h.areaname`` (default "area")
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
   metadata:
@@ -52,10 +58,6 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    out_curvature_file: generic/file
-    # type=file|default=<undefined>: Write curvature to ``?h.curvname`` (default "curv")
-    out_area_file: generic/file
-    # type=file|default=<undefined>: Write area to ``?h.areaname`` (default "area")
     surface: generic/file
     # type=file: Smoothed surface file.
   callables:
@@ -63,8 +65,6 @@ outputs:
   # to set to the `callable` attribute of output fields
   templates:
   # dict[str, str] - `output_file_template` values to be provided to output fields
-    out_file: out_file
-    # type=file|default=<undefined>: output filename or True to generate one
   requirements:
   # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
 tests:
diff --git a/example-specs/task/nipype/freesurfer/sphere.yaml b/example-specs/task/nipype/freesurfer/sphere.yaml
index e1644dc1..2e74f39c 100644
--- a/example-specs/task/nipype/freesurfer/sphere.yaml
+++ b/example-specs/task/nipype/freesurfer/sphere.yaml
@@ -36,6 +36,9 @@ inputs:
     # type=file|default=<undefined>: Input surface required when -q flag is not selected
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+    out_file: Path
+    # type=file: Output file for Sphere
+    # type=file|default=<undefined>: Output file for Sphere
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/spherical_average.yaml b/example-specs/task/nipype/freesurfer/spherical_average.yaml
index f5b28b69..3eb78b29 100644
--- a/example-specs/task/nipype/freesurfer/spherical_average.yaml
+++ b/example-specs/task/nipype/freesurfer/spherical_average.yaml
@@ -43,6 +43,8 @@ inputs:
     # type=file|default=<undefined>: Input surface file
     in_orig: generic/file
     # type=file|default=<undefined>: Original surface filename
+    in_average: generic/directory
+    # type=directory|default=<undefined>: Average subject
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
   metadata:
@@ -69,8 +71,6 @@ outputs:
     out_file: '"test.out"'
     # type=file: Output label
     # type=file|default=<undefined>: Output filename
-    in_average: '"."'
-    # type=directory|default=<undefined>: Average subject
   requirements:
   # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
 tests:
diff --git a/example-specs/task/nipype/freesurfer/surface_2_vol_transform.yaml b/example-specs/task/nipype/freesurfer/surface_2_vol_transform.yaml
index af2d956a..22f69301 100644
--- a/example-specs/task/nipype/freesurfer/surface_2_vol_transform.yaml
+++ b/example-specs/task/nipype/freesurfer/surface_2_vol_transform.yaml
@@ -38,14 +38,14 @@ inputs:
   # passed to the field in the automatically generated unittests.
     source_file: medimage/mgh-gz
     # type=file|default=<undefined>: This is the source of the surface values
-    transformed_file: generic/file
-    # type=file: Path to output file if used normally
-    # type=file|default=<undefined>: Output volume
     reg_file: datascience/text-matrix
     # type=file|default=<undefined>: tkRAS-to-tkRAS matrix   (tkregister2 format)
     template_file: medimage/nifti-gz
     # type=file|default=<undefined>: Output template volume
-    vertexvol_file: generic/file
+    transformed_file: Path
+    # type=file: Path to output file if used normally
+    # type=file|default=<undefined>: Output volume
+    vertexvol_file: Path
     # type=file: vertex map volume path id. Optional
     # type=file|default=<undefined>: Path name of the vertex output volume, which is the same as output volume except that the value of each voxel is the vertex-id that is mapped to that voxel.
   metadata:
diff --git a/example-specs/task/nipype/freesurfer/surface_snapshots.yaml b/example-specs/task/nipype/freesurfer/surface_snapshots.yaml
index 1f2e4a0e..c670699b 100644
--- a/example-specs/task/nipype/freesurfer/surface_snapshots.yaml
+++ b/example-specs/task/nipype/freesurfer/surface_snapshots.yaml
@@ -56,6 +56,8 @@ inputs:
     # type=file|default=<undefined>: load colortable file
     patch_file: generic/file
     # type=file|default=<undefined>: load a patch
+    tcl_script: generic/file
+    # type=file|default=<undefined>: override default screenshot script
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
   metadata:
@@ -76,8 +78,6 @@ outputs:
   # to set to the `callable` attribute of output fields
   templates:
   # dict[str, str] - `output_file_template` values to be provided to output fields
-    tcl_script: tcl_script
-    # type=file|default=<undefined>: override default screenshot script
   requirements:
   # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
 tests:
diff --git a/example-specs/task/nipype/freesurfer/talairach_avi.yaml b/example-specs/task/nipype/freesurfer/talairach_avi.yaml
index b1a5d280..c156ba0f 100644
--- a/example-specs/task/nipype/freesurfer/talairach_avi.yaml
+++ b/example-specs/task/nipype/freesurfer/talairach_avi.yaml
@@ -42,6 +42,9 @@ inputs:
     # type=file|default=<undefined>: input volume
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+    out_file: Path
+    # type=file: The output transform for TalairachAVI
+    # type=file|default=<undefined>: output xfm file
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/talairach_qc.yaml b/example-specs/task/nipype/freesurfer/talairach_qc.yaml
index fa4f395e..8cdcfaac 100644
--- a/example-specs/task/nipype/freesurfer/talairach_qc.yaml
+++ b/example-specs/task/nipype/freesurfer/talairach_qc.yaml
@@ -29,11 +29,11 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    log_file: text/text-file
-    # type=file: The output log
-    # type=file|default=<undefined>: The log file for TalairachQC
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+    log_file: Path
+    # type=file: The output log
+    # type=file|default=<undefined>: The log file for TalairachQC
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -88,7 +88,7 @@ tests:
 - inputs:
   # dict[str, str] - values to provide to inputs fields in the task initialisation
   # (if not specified, will try to choose a sensible value)
-    log_file:
+    log_file: '"dirs.txt"'
     # type=file: The output log
     # type=file|default=<undefined>: The log file for TalairachQC
   imports:
@@ -113,7 +113,7 @@ doctests:
   # dict[str, str] - name-value pairs for inputs to be provided to the doctest.
   # If the field is of file-format type and the value is None, then the
   # '.mock()' method of the corresponding class is used instead.
-    log_file:
+    log_file: '"dirs.txt"'
     # type=file: The output log
     # type=file|default=<undefined>: The log file for TalairachQC
   imports:
diff --git a/example-specs/task/nipype/freesurfer/tkregister_2.yaml b/example-specs/task/nipype/freesurfer/tkregister_2.yaml
index d8d85f33..62ac0bf2 100644
--- a/example-specs/task/nipype/freesurfer/tkregister_2.yaml
+++ b/example-specs/task/nipype/freesurfer/tkregister_2.yaml
@@ -61,6 +61,9 @@ inputs:
     # type=file|default=<undefined>: use a matrix in MNI coordinates as initial registration
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+    reg_file: Path
+    # type=file: freesurfer-style registration file
+    # type=file|default='register.dat': freesurfer-style registration file
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/watershed_skull_strip.yaml b/example-specs/task/nipype/freesurfer/watershed_skull_strip.yaml
index 66ad18d4..3ee70b4a 100644
--- a/example-specs/task/nipype/freesurfer/watershed_skull_strip.yaml
+++ b/example-specs/task/nipype/freesurfer/watershed_skull_strip.yaml
@@ -51,6 +51,9 @@ inputs:
     # type=file|default=<undefined>: undocumented
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+    out_file: Path
+    # type=file: skull stripped brain volume
+    # type=file|default='brainmask.auto.mgz': output volume
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/accuracy_tester.yaml b/example-specs/task/nipype/fsl/accuracy_tester.yaml
index e0308e11..d8f3f009 100644
--- a/example-specs/task/nipype/fsl/accuracy_tester.yaml
+++ b/example-specs/task/nipype/fsl/accuracy_tester.yaml
@@ -27,7 +27,7 @@ inputs:
     # type=file|default=<undefined>: trained-weights file
     mel_icas: generic/directory+list-of
     # type=inputmultiobject|default=[]: Melodic output directories
-    output_directory: generic/directory
+    output_directory: Path
     # type=directory: Path to folder in which to store the results of the accuracy test.
     # type=directory|default=<undefined>: Path to folder in which to store the results of the accuracy test.
   metadata:
diff --git a/example-specs/task/nipype/fsl/apply_topup.yaml b/example-specs/task/nipype/fsl/apply_topup.yaml
index 2a5ae1e0..de80b370 100644
--- a/example-specs/task/nipype/fsl/apply_topup.yaml
+++ b/example-specs/task/nipype/fsl/apply_topup.yaml
@@ -51,6 +51,9 @@ inputs:
     # type=file|default=<undefined>: topup file containing the field coefficients
     in_topup_movpar: text/text-file
     # type=file|default=<undefined>: topup movpar.txt file
+    out_corrected: Path
+    # type=file: name of 4D image file with unwarped images
+    # type=file|default=<undefined>: output (warped) image
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/apply_xfm.yaml b/example-specs/task/nipype/fsl/apply_xfm.yaml
index 2b2880a4..905f0b89 100644
--- a/example-specs/task/nipype/fsl/apply_xfm.yaml
+++ b/example-specs/task/nipype/fsl/apply_xfm.yaml
@@ -61,6 +61,15 @@ inputs:
     # type=file|default=<undefined>: fieldmap image in rads/s - must be already registered to the reference image
     fieldmapmask: generic/file
     # type=file|default=<undefined>: mask for fieldmap image
+    out_file: Path
+    # type=file: path/name of registered file (if generated)
+    # type=file|default=<undefined>: registered output file
+    out_matrix_file: Path
+    # type=file: path/name of calculated affine transform (if generated)
+    # type=file|default=<undefined>: output affine matrix in 4x4 asciii format
+    out_log: Path
+    # type=file: path/name of output log (if generated)
+    # type=file|default=<undefined>: output log
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/b0_calc.yaml b/example-specs/task/nipype/fsl/b0_calc.yaml
index 2508aaa4..6235b9cd 100644
--- a/example-specs/task/nipype/fsl/b0_calc.yaml
+++ b/example-specs/task/nipype/fsl/b0_calc.yaml
@@ -39,6 +39,9 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/nifti1
     # type=file|default=<undefined>: filename of input image (usually a tissue/air segmentation)
+    out_file: Path
+    # type=file: filename of B0 output volume
+    # type=file|default=<undefined>: filename of B0 output volume
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/classifier.yaml b/example-specs/task/nipype/fsl/classifier.yaml
index b9e589b7..9a80ff57 100644
--- a/example-specs/task/nipype/fsl/classifier.yaml
+++ b/example-specs/task/nipype/fsl/classifier.yaml
@@ -24,11 +24,11 @@ inputs:
   # passed to the field in the automatically generated unittests.
     trained_wts_file: generic/file
     # type=file|default=<undefined>: trained-weights file
-    artifacts_list_file: generic/file
-    # type=file: Text file listing which ICs are artifacts; can be the output from classification or can be created manually
-    # type=file|default=<undefined>: Text file listing which ICs are artifacts; can be the output from classification or can be created manually
     mel_ica: generic/directory
     # type=directory|default=<undefined>: Melodic output directory or directories
+    artifacts_list_file: Path
+    # type=file: Text file listing which ICs are artifacts; can be the output from classification or can be created manually
+    # type=file|default=<undefined>: Text file listing which ICs are artifacts; can be the output from classification or can be created manually
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/convert_warp.yaml b/example-specs/task/nipype/fsl/convert_warp.yaml
index 2f9f22b0..9243823c 100644
--- a/example-specs/task/nipype/fsl/convert_warp.yaml
+++ b/example-specs/task/nipype/fsl/convert_warp.yaml
@@ -52,6 +52,9 @@ inputs:
     # type=file|default=<undefined>: Name of file containing an affine transform (applied last). It could e.g. be an affine transform that maps the MNI152-space into a better approximation to the Talairach-space (if indeed there is one).
     shift_in_file: generic/file
     # type=file|default=<undefined>: Name of file containing a "shiftmap", a non-linear transform with displacements only in one direction (applied first, before premat). This would typically be a fieldmap that has been pre-processed using fugue that maps a subjects functional (EPI) data onto an undistorted space (i.e. a space that corresponds to his/her true anatomy).
+    out_file: Path
+    # type=file: Name of output file, containing the warp as field or coefficients.
+    # type=file|default=<undefined>: Name of output file, containing warps that are the combination of all those given as arguments. The format of this will be a field-file (rather than spline coefficients) with any affine components included.
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/eddy.yaml b/example-specs/task/nipype/fsl/eddy.yaml
index b54bdabf..ffe16f1e 100644
--- a/example-specs/task/nipype/fsl/eddy.yaml
+++ b/example-specs/task/nipype/fsl/eddy.yaml
@@ -80,6 +80,10 @@ inputs:
     # type=file|default=<undefined>: Non-topup derived fieldmap scaled in Hz
     field_mat: generic/file
     # type=file|default=<undefined>: Matrix specifying the relative positions of the fieldmap, --field, and the first volume of the input file, --imain
+    slice_order: text/text-file
+    # type=file|default='': Name of text file completely specifying slice/group acquisition
+    json: generic/file
+    # type=file|default='': Name of .json text file with information about slice timing
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -93,10 +97,6 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    slice_order: text/text-file
-    # type=file|default='': Name of text file completely specifying slice/group acquisition
-    json: generic/file
-    # type=file|default='': Name of .json text file with information about slice timing
     out_corrected: generic/file
     # type=file: 4D image file containing all the corrected volumes
     out_parameter: generic/file
@@ -306,7 +306,7 @@ tests:
     # type=int|default=0: Regularisation weight for slice-to-vol movement (reasonable range 1-10)
     slice2vol_interp: '"trilinear"'
     # type=enum|default='trilinear'|allowed['spline','trilinear']: Slice-to-vol interpolation model for estimation step
-    slice_order: '"epi_slspec.txt"'
+    slice_order:
     # type=file|default='': Name of text file completely specifying slice/group acquisition
   imports:
   # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
@@ -366,7 +366,7 @@ doctests:
     # type=int|default=0: Regularisation weight for slice-to-vol movement (reasonable range 1-10)
     slice2vol_interp: '"trilinear"'
     # type=enum|default='trilinear'|allowed['spline','trilinear']: Slice-to-vol interpolation model for estimation step
-    slice_order: '"epi_slspec.txt"'
+    slice_order:
     # type=file|default='': Name of text file completely specifying slice/group acquisition
   imports:
   # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
diff --git a/example-specs/task/nipype/fsl/eddy_correct.yaml b/example-specs/task/nipype/fsl/eddy_correct.yaml
index a95169a4..4b48aa5d 100644
--- a/example-specs/task/nipype/fsl/eddy_correct.yaml
+++ b/example-specs/task/nipype/fsl/eddy_correct.yaml
@@ -36,6 +36,8 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/nifti1
     # type=file|default=<undefined>: 4D input file
+    out_file: medimage/nifti1
+    # type=file|default=<undefined>: 4D output file
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -49,8 +51,6 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    out_file: medimage/nifti1
-    # type=file|default=<undefined>: 4D output file
     eddy_corrected: generic/file
     # type=file: path/name of 4D eddy corrected output file
   callables:
@@ -96,7 +96,7 @@ tests:
   # (if not specified, will try to choose a sensible value)
     in_file:
     # type=file|default=<undefined>: 4D input file
-    out_file: '"diffusion_edc.nii"'
+    out_file:
     # type=file|default=<undefined>: 4D output file
     ref_num: '0'
     # type=int|default=0: reference number
@@ -124,7 +124,7 @@ doctests:
   # '.mock()' method of the corresponding class is used instead.
     in_file:
     # type=file|default=<undefined>: 4D input file
-    out_file: '"diffusion_edc.nii"'
+    out_file:
     # type=file|default=<undefined>: 4D output file
     ref_num: '0'
     # type=int|default=0: reference number
diff --git a/example-specs/task/nipype/fsl/epi_de_warp.yaml b/example-specs/task/nipype/fsl/epi_de_warp.yaml
index 22536184..b1e2d567 100644
--- a/example-specs/task/nipype/fsl/epi_de_warp.yaml
+++ b/example-specs/task/nipype/fsl/epi_de_warp.yaml
@@ -76,13 +76,9 @@ outputs:
   # to set to the `callable` attribute of output fields
   templates:
   # dict[str, str] - `output_file_template` values to be provided to output fields
-    vsm: vsm
-    # type=string|default='': voxel shift map
     exfdw: exfdw
     # type=file: dewarped functional volume example
     # type=string|default='': dewarped example func volume
-    tmpdir: tmpdir
-    # type=string|default='': tmpdir
   requirements:
   # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
 tests:
diff --git a/example-specs/task/nipype/fsl/epi_reg.yaml b/example-specs/task/nipype/fsl/epi_reg.yaml
index cede9c09..42b75360 100644
--- a/example-specs/task/nipype/fsl/epi_reg.yaml
+++ b/example-specs/task/nipype/fsl/epi_reg.yaml
@@ -55,11 +55,11 @@ inputs:
     # type=file|default=<undefined>: fieldmap magnitude image - wholehead
     fmapmagbrain: medimage/nifti1
     # type=file|default=<undefined>: fieldmap magnitude image - brain extracted
-    wmseg: generic/file
-    # type=file: white matter segmentation used in flirt bbr
-    # type=file|default=<undefined>: white matter segmentation of T1 image, has to be named                  like the t1brain and end on _wmseg
     weight_image: generic/file
     # type=file|default=<undefined>: weighting image (in T1 space)
+    wmseg: Path
+    # type=file: white matter segmentation used in flirt bbr
+    # type=file|default=<undefined>: white matter segmentation of T1 image, has to be named                  like the t1brain and end on _wmseg
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/fast.yaml b/example-specs/task/nipype/fsl/fast.yaml
index 94f22f14..49871bee 100644
--- a/example-specs/task/nipype/fsl/fast.yaml
+++ b/example-specs/task/nipype/fsl/fast.yaml
@@ -37,6 +37,8 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_files: medimage/nifti1+list-of
     # type=inputmultiobject|default=[]: image, or multi-channel set of images, to be segmented
+    out_basename: generic/file
+    # type=file|default=<undefined>: base name of output files
     init_transform: generic/file
     # type=file|default=<undefined>: <standard2input.mat> initialise using priors
     other_priors: generic/file+list-of
@@ -56,8 +58,6 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    out_basename: generic/file
-    # type=file|default=<undefined>: base name of output files
     tissue_class_map: generic/file
     # type=file: path/name of binary segmented volume file one val for each class  _seg
     mixeltype: generic/file
@@ -146,7 +146,7 @@ tests:
   # (if not specified, will try to choose a sensible value)
     in_files:
     # type=inputmultiobject|default=[]: image, or multi-channel set of images, to be segmented
-    out_basename: '"fast_"'
+    out_basename:
     # type=file|default=<undefined>: base name of output files
   imports:
   # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
@@ -172,7 +172,7 @@ doctests:
   # '.mock()' method of the corresponding class is used instead.
     in_files:
     # type=inputmultiobject|default=[]: image, or multi-channel set of images, to be segmented
-    out_basename: '"fast_"'
+    out_basename:
     # type=file|default=<undefined>: base name of output files
   imports:
   # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
diff --git a/example-specs/task/nipype/fsl/feature_extractor.yaml b/example-specs/task/nipype/fsl/feature_extractor.yaml
index ec458c37..a3d2221d 100644
--- a/example-specs/task/nipype/fsl/feature_extractor.yaml
+++ b/example-specs/task/nipype/fsl/feature_extractor.yaml
@@ -22,7 +22,7 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    mel_ica: generic/directory
+    mel_ica: Path
     # type=directory: Melodic output directory or directories
     # type=directory|default=<undefined>: Melodic output directory or directories
   metadata:
diff --git a/example-specs/task/nipype/fsl/filmgls.yaml b/example-specs/task/nipype/fsl/filmgls.yaml
index 39df0730..b578ddae 100644
--- a/example-specs/task/nipype/fsl/filmgls.yaml
+++ b/example-specs/task/nipype/fsl/filmgls.yaml
@@ -55,7 +55,7 @@ inputs:
     # type=file|default=<undefined>: input data file
     design_file: generic/file
     # type=file|default=<undefined>: design matrix file
-    results_dir: generic/directory
+    results_dir: Path
     # type=directory: directory storing model estimation output
     # type=directory|default='results': directory to store results in
   metadata:
diff --git a/example-specs/task/nipype/fsl/first.yaml b/example-specs/task/nipype/fsl/first.yaml
index add51779..1863f910 100644
--- a/example-specs/task/nipype/fsl/first.yaml
+++ b/example-specs/task/nipype/fsl/first.yaml
@@ -35,6 +35,8 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: generic/file
     # type=file|default=<undefined>: input data file
+    out_file: generic/file
+    # type=file|default='segmented': output data file
     affine_file: generic/file
     # type=file|default=<undefined>: Affine matrix to use (e.g. img2std.mat) (does not re-run registration)
   metadata:
@@ -50,8 +52,6 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    out_file: generic/file
-    # type=file|default='segmented': output data file
     original_segmentations: generic/file
     # type=file: 3D image file containing the segmented regions as integer values. Uses CMA labelling
     segmentation_file: generic/file
diff --git a/example-specs/task/nipype/fsl/flirt.yaml b/example-specs/task/nipype/fsl/flirt.yaml
index b4a786f8..73b0de1b 100644
--- a/example-specs/task/nipype/fsl/flirt.yaml
+++ b/example-specs/task/nipype/fsl/flirt.yaml
@@ -62,6 +62,15 @@ inputs:
     # type=file|default=<undefined>: fieldmap image in rads/s - must be already registered to the reference image
     fieldmapmask: generic/file
     # type=file|default=<undefined>: mask for fieldmap image
+    out_file: Path
+    # type=file: path/name of registered file (if generated)
+    # type=file|default=<undefined>: registered output file
+    out_matrix_file: Path
+    # type=file: path/name of calculated affine transform (if generated)
+    # type=file|default=<undefined>: output affine matrix in 4x4 asciii format
+    out_log: Path
+    # type=file: path/name of output log (if generated)
+    # type=file|default=<undefined>: output log
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/fugue.yaml b/example-specs/task/nipype/fsl/fugue.yaml
index e62cfc15..6f064553 100644
--- a/example-specs/task/nipype/fsl/fugue.yaml
+++ b/example-specs/task/nipype/fsl/fugue.yaml
@@ -90,14 +90,20 @@ inputs:
     # type=file|default=<undefined>: filename for input phase image
     fmap_in_file: generic/file
     # type=file|default=<undefined>: filename for loading fieldmap (rad/s)
-    unwarped_file: generic/file
+    mask_file: medimage/nifti1
+    # type=file|default=<undefined>: filename for loading valid mask
+    unwarped_file: Path
     # type=file: unwarped file
     # type=file|default=<undefined>: apply unwarping and save as filename
-    warped_file: generic/file
+    warped_file: Path
     # type=file: forward warped file
     # type=file|default=<undefined>: apply forward warping and save as filename
-    mask_file: medimage/nifti1
-    # type=file|default=<undefined>: filename for loading valid mask
+    shift_out_file: Path
+    # type=file: voxel shift map file
+    # type=file|default=<undefined>: filename for saving pixel shift volume
+    fmap_out_file: Path
+    # type=file: fieldmap file
+    # type=file|default=<undefined>: filename for saving fieldmap (rad/s)
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -111,18 +117,18 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    shift_out_file: generic/file
-    # type=file: voxel shift map file
-    # type=file|default=<undefined>: filename for saving pixel shift volume
-    fmap_out_file: generic/file
-    # type=file: fieldmap file
-    # type=file|default=<undefined>: filename for saving fieldmap (rad/s)
     unwarped_file: generic/file
     # type=file: unwarped file
     # type=file|default=<undefined>: apply unwarping and save as filename
     warped_file: generic/file
     # type=file: forward warped file
     # type=file|default=<undefined>: apply forward warping and save as filename
+    shift_out_file: generic/file
+    # type=file: voxel shift map file
+    # type=file|default=<undefined>: filename for saving pixel shift volume
+    fmap_out_file: generic/file
+    # type=file: fieldmap file
+    # type=file|default=<undefined>: filename for saving fieldmap (rad/s)
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/fsl/glm.yaml b/example-specs/task/nipype/fsl/glm.yaml
index f0f9afcd..ef2da8f4 100644
--- a/example-specs/task/nipype/fsl/glm.yaml
+++ b/example-specs/task/nipype/fsl/glm.yaml
@@ -38,22 +38,6 @@ inputs:
     # type=file|default=<undefined>: matrix of t-statics contrasts
     mask: generic/file
     # type=file|default=<undefined>: mask image file name if input is image
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    out_file: generic/file
-    # type=file: file name of GLM parameters (if generated)
-    # type=file|default=<undefined>: filename for GLM parameter estimates (GLM betas)
     out_cope: generic/file
     # type=outputmultiobject: output file name for COPEs (either as text file or image)
     # type=file|default=<undefined>: output file name for COPE (either as txt or image
@@ -77,6 +61,25 @@ outputs:
     # type=file|default=<undefined>: output file name for pre-processed data
     out_vnscales_name: generic/file
     # type=file|default=<undefined>: output file name for scaling factors for variance normalisation
+    out_file: Path
+    # type=file: file name of GLM parameters (if generated)
+    # type=file|default=<undefined>: filename for GLM parameter estimates (GLM betas)
+  metadata:
+  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
+outputs:
+  omit:
+  # list[str] - fields to omit from the Pydra interface
+  rename:
+  # dict[str, str] - fields to rename in the Pydra interface
+  types:
+  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
+  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
+  # from the nipype interface, but you may want to be more specific, particularly
+  # for file types, where specifying the format also specifies the file that will be
+  # passed to the field in the automatically generated unittests.
+    out_file: generic/file
+    # type=file: file name of GLM parameters (if generated)
+    # type=file|default=<undefined>: filename for GLM parameter estimates (GLM betas)
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/fsl/ica__aroma.yaml b/example-specs/task/nipype/fsl/ica__aroma.yaml
index 701aad11..d3768262 100644
--- a/example-specs/task/nipype/fsl/ica__aroma.yaml
+++ b/example-specs/task/nipype/fsl/ica__aroma.yaml
@@ -58,11 +58,11 @@ inputs:
     # type=file|default=<undefined>: motion parameters file
     feat_dir: generic/directory
     # type=directory|default=<undefined>: If a feat directory exists and temporal filtering has not been run yet, ICA_AROMA can use the files in this directory.
-    out_dir: generic/directory
-    # type=directory: directory contains (in addition to the denoised files): melodic.ica + classified_motion_components + classification_overview + feature_scores + melodic_ic_mni)
-    # type=directory|default='out': output directory
     melodic_dir: generic/directory
     # type=directory|default=<undefined>: path to MELODIC directory if MELODIC has already been run
+    out_dir: Path
+    # type=directory: directory contains (in addition to the denoised files): melodic.ica + classified_motion_components + classification_overview + feature_scores + melodic_ic_mni)
+    # type=directory|default='out': output directory
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/inv_warp.yaml b/example-specs/task/nipype/fsl/inv_warp.yaml
index b9237569..203b81e4 100644
--- a/example-specs/task/nipype/fsl/inv_warp.yaml
+++ b/example-specs/task/nipype/fsl/inv_warp.yaml
@@ -41,7 +41,7 @@ inputs:
     # type=file|default=<undefined>: Name of file containing warp-coefficients/fields. This would typically be the output from the --cout switch of fnirt (but can also use fields, like the output from --fout).
     reference: medimage/nifti1
     # type=file|default=<undefined>: Name of a file in target space. Note that the target space is now different from the target space that was used to create the --warp file. It would typically be the file that was specified with the --in argument when running fnirt.
-    inverse_warp: generic/file
+    inverse_warp: Path
     # type=file: Name of output file, containing warps that are the "reverse" of those in --warp.
     # type=file|default=<undefined>: Name of output file, containing warps that are the "reverse" of those in --warp. This will be a field-file (rather than a file of spline coefficients), and it will have any affine component included as part of the displacements.
   metadata:
diff --git a/example-specs/task/nipype/fsl/make_dyadic_vectors.yaml b/example-specs/task/nipype/fsl/make_dyadic_vectors.yaml
index ba2e7dd0..633027e9 100644
--- a/example-specs/task/nipype/fsl/make_dyadic_vectors.yaml
+++ b/example-specs/task/nipype/fsl/make_dyadic_vectors.yaml
@@ -27,6 +27,8 @@ inputs:
     # type=file|default=<undefined>: 
     mask: generic/file
     # type=file|default=<undefined>: 
+    output: generic/file
+    # type=file|default='dyads': 
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -40,8 +42,6 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    output: generic/file
-    # type=file|default='dyads': 
     dyads: generic/file
     # type=file: 
     dispersion: generic/file
diff --git a/example-specs/task/nipype/fsl/merge.yaml b/example-specs/task/nipype/fsl/merge.yaml
index 8fb0c1c5..d1605f0d 100644
--- a/example-specs/task/nipype/fsl/merge.yaml
+++ b/example-specs/task/nipype/fsl/merge.yaml
@@ -46,7 +46,7 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_files: medimage/nifti1+list-of
     # type=list|default=[]: 
-    merged_file: generic/file
+    merged_file: Path
     # type=file: 
     # type=file|default=<undefined>: 
   metadata:
diff --git a/example-specs/task/nipype/fsl/motion_outliers.yaml b/example-specs/task/nipype/fsl/motion_outliers.yaml
index 78856c98..bf066ddd 100644
--- a/example-specs/task/nipype/fsl/motion_outliers.yaml
+++ b/example-specs/task/nipype/fsl/motion_outliers.yaml
@@ -34,6 +34,15 @@ inputs:
     # type=file|default=<undefined>: unfiltered 4D image
     mask: generic/file
     # type=file|default=<undefined>: mask image for calculating metric
+    out_file: Path
+    # type=file: 
+    # type=file|default=<undefined>: output outlier file name
+    out_metric_values: Path
+    # type=file: 
+    # type=file|default=<undefined>: output metric values (DVARS etc.) file name
+    out_metric_plot: Path
+    # type=file: 
+    # type=file|default=<undefined>: output metric values plot (DVARS etc.) file name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/prepare_fieldmap.yaml b/example-specs/task/nipype/fsl/prepare_fieldmap.yaml
index f4ddde19..f2dba5ea 100644
--- a/example-specs/task/nipype/fsl/prepare_fieldmap.yaml
+++ b/example-specs/task/nipype/fsl/prepare_fieldmap.yaml
@@ -45,6 +45,9 @@ inputs:
     # type=file|default=<undefined>: Phase difference map, in SIEMENS format range from 0-4096 or 0-8192)
     in_magnitude: medimage/nifti1
     # type=file|default=<undefined>: Magnitude difference map, brain extracted
+    out_fieldmap: Path
+    # type=file: output name for prepared fieldmap
+    # type=file|default=<undefined>: output name for prepared fieldmap
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/prob_track_x.yaml b/example-specs/task/nipype/fsl/prob_track_x.yaml
index 458ec845..12061afb 100644
--- a/example-specs/task/nipype/fsl/prob_track_x.yaml
+++ b/example-specs/task/nipype/fsl/prob_track_x.yaml
@@ -56,6 +56,8 @@ inputs:
     # type=file|default=<undefined>: transformation matrix taking seed space to DTI space (either FLIRT matrix or FNIRT warp_field) - default is identity
     inv_xfm: generic/file
     # type=file|default=<undefined>: transformation matrix taking DTI space to seed space (compulsory when using a warp_field for seeds_to_dti)
+    out_dir: generic/directory
+    # type=directory|default=<undefined>: directory to put the final volumes in
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -78,10 +80,6 @@ outputs:
   # to set to the `callable` attribute of output fields
   templates:
   # dict[str, str] - `output_file_template` values to be provided to output fields
-    mode: '"seedmask"'
-    # type=enum|default='simple'|allowed['seedmask','simple','two_mask_symm']: options: simple (single seed voxel), seedmask (mask of seed voxels), twomask_symm (two bet binary masks)
-    out_dir: '"."'
-    # type=directory|default=<undefined>: directory to put the final volumes in
   requirements:
   # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
 tests:
diff --git a/example-specs/task/nipype/fsl/prob_track_x2.yaml b/example-specs/task/nipype/fsl/prob_track_x2.yaml
index 149443cd..a8ab37b0 100644
--- a/example-specs/task/nipype/fsl/prob_track_x2.yaml
+++ b/example-specs/task/nipype/fsl/prob_track_x2.yaml
@@ -71,6 +71,8 @@ inputs:
     # type=file|default=<undefined>: transformation matrix taking seed space to DTI space (either FLIRT matrix or FNIRT warp_field) - default is identity
     inv_xfm: generic/file
     # type=file|default=<undefined>: transformation matrix taking DTI space to seed space (compulsory when using a warp_field for seeds_to_dti)
+    out_dir: generic/directory
+    # type=directory|default=<undefined>: directory to put the final volumes in
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -103,8 +105,6 @@ outputs:
   # to set to the `callable` attribute of output fields
   templates:
   # dict[str, str] - `output_file_template` values to be provided to output fields
-    out_dir: '"."'
-    # type=directory|default=<undefined>: directory to put the final volumes in
   requirements:
   # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
 tests:
diff --git a/example-specs/task/nipype/fsl/robust_fov.yaml b/example-specs/task/nipype/fsl/robust_fov.yaml
index e3130f56..79154107 100644
--- a/example-specs/task/nipype/fsl/robust_fov.yaml
+++ b/example-specs/task/nipype/fsl/robust_fov.yaml
@@ -26,6 +26,12 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: generic/file
     # type=file|default=<undefined>: input filename
+    out_roi: Path
+    # type=file: ROI volume output name
+    # type=file|default=<undefined>: ROI volume output name
+    out_transform: Path
+    # type=file: Transformation matrix in_file to out_roi output name
+    # type=file|default=<undefined>: Transformation matrix in_file to out_roi output name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/slice_timer.yaml b/example-specs/task/nipype/fsl/slice_timer.yaml
index c45cd37b..e6e5e9d6 100644
--- a/example-specs/task/nipype/fsl/slice_timer.yaml
+++ b/example-specs/task/nipype/fsl/slice_timer.yaml
@@ -33,6 +33,8 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: generic/file
     # type=file|default=<undefined>: filename of input timeseries
+    out_file: generic/file
+    # type=file|default=<undefined>: filename of output timeseries
     custom_timings: generic/file
     # type=file|default=<undefined>: slice timings, in fractions of TR, range 0:1 (default is 0.5 = no shift)
     custom_order: generic/file
@@ -57,8 +59,6 @@ outputs:
   # to set to the `callable` attribute of output fields
   templates:
   # dict[str, str] - `output_file_template` values to be provided to output fields
-    out_file: out_file
-    # type=file|default=<undefined>: filename of output timeseries
   requirements:
   # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
 tests:
diff --git a/example-specs/task/nipype/fsl/smooth.yaml b/example-specs/task/nipype/fsl/smooth.yaml
index 3e389292..fec86574 100644
--- a/example-specs/task/nipype/fsl/smooth.yaml
+++ b/example-specs/task/nipype/fsl/smooth.yaml
@@ -57,7 +57,7 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/nifti1
     # type=file|default=<undefined>: 
-    smoothed_file: generic/file
+    smoothed_file: Path
     # type=file: 
     # type=file|default=<undefined>: 
   metadata:
diff --git a/example-specs/task/nipype/fsl/susan.yaml b/example-specs/task/nipype/fsl/susan.yaml
index aafe0dae..7013db52 100644
--- a/example-specs/task/nipype/fsl/susan.yaml
+++ b/example-specs/task/nipype/fsl/susan.yaml
@@ -39,6 +39,8 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: generic/file
     # type=file|default=<undefined>: filename of input timeseries
+    out_file: generic/file
+    # type=file|default=<undefined>: output file name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -59,8 +61,6 @@ outputs:
   # to set to the `callable` attribute of output fields
   templates:
   # dict[str, str] - `output_file_template` values to be provided to output fields
-    out_file: out_file
-    # type=file|default=<undefined>: output file name
   requirements:
   # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
 tests:
diff --git a/example-specs/task/nipype/fsl/text_2_vest.yaml b/example-specs/task/nipype/fsl/text_2_vest.yaml
index 47e7ad77..b608dfa3 100644
--- a/example-specs/task/nipype/fsl/text_2_vest.yaml
+++ b/example-specs/task/nipype/fsl/text_2_vest.yaml
@@ -35,6 +35,9 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: text/text-file
     # type=file|default=<undefined>: plain text file representing your design, contrast, or f-test matrix
+    out_file: Path
+    # type=file: matrix data in the format used by FSL tools
+    # type=file|default=<undefined>: file name to store matrix data in the format used by FSL tools (e.g., design.mat, design.con design.fts)
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/topup.yaml b/example-specs/task/nipype/fsl/topup.yaml
index ae2d5391..45d28f0d 100644
--- a/example-specs/task/nipype/fsl/topup.yaml
+++ b/example-specs/task/nipype/fsl/topup.yaml
@@ -45,6 +45,17 @@ inputs:
     # type=file|default=<undefined>: name of 4D file with images
     encoding_file: text/text-file
     # type=file|default=<undefined>: name of text file with PE directions/times
+    out_base: generic/file
+    # type=file|default=<undefined>: base-name of output files (spline coefficients (Hz) and movement parameters)
+    out_field: Path
+    # type=file: name of image file with field (Hz)
+    # type=file|default=<undefined>: name of image file with field (Hz)
+    out_corrected: Path
+    # type=file: name of 4D image file with unwarped images
+    # type=file|default=<undefined>: name of 4D image file with unwarped images
+    out_logfile: Path
+    # type=file: name of log-file
+    # type=file|default=<undefined>: name of log-file
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -58,8 +69,12 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    out_base: generic/file
-    # type=file|default=<undefined>: base-name of output files (spline coefficients (Hz) and movement parameters)
+    out_fieldcoef: generic/file
+    # type=file: file containing the field coefficients
+    out_movpar: generic/file
+    # type=file: movpar.txt output file
+    out_enc_file: generic/file
+    # type=file: encoding directions file output for applytopup
     out_field: generic/file
     # type=file: name of image file with field (Hz)
     # type=file|default=<undefined>: name of image file with field (Hz)
@@ -69,12 +84,6 @@ outputs:
     out_logfile: generic/file
     # type=file: name of log-file
     # type=file|default=<undefined>: name of log-file
-    out_fieldcoef: generic/file
-    # type=file: file containing the field coefficients
-    out_movpar: generic/file
-    # type=file: movpar.txt output file
-    out_enc_file: generic/file
-    # type=file: encoding directions file output for applytopup
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/fsl/tract_skeleton.yaml b/example-specs/task/nipype/fsl/tract_skeleton.yaml
index 599fe46e..70e49e2e 100644
--- a/example-specs/task/nipype/fsl/tract_skeleton.yaml
+++ b/example-specs/task/nipype/fsl/tract_skeleton.yaml
@@ -54,7 +54,7 @@ inputs:
     # type=file|default=<undefined>: 4D non-FA data to project onto skeleton
     alt_skeleton: generic/file
     # type=file|default=<undefined>: alternate skeleton to use
-    projected_data: generic/file
+    projected_data: Path
     # type=file: input data projected onto skeleton
     # type=file|default=<undefined>: input data projected onto skeleton
   metadata:
diff --git a/example-specs/task/nipype/fsl/vest_2_text.yaml b/example-specs/task/nipype/fsl/vest_2_text.yaml
index 9028f77c..4b696f1a 100644
--- a/example-specs/task/nipype/fsl/vest_2_text.yaml
+++ b/example-specs/task/nipype/fsl/vest_2_text.yaml
@@ -34,6 +34,9 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: datascience/text-matrix
     # type=file|default=<undefined>: matrix data stored in the format used by FSL tools
+    out_file: Path
+    # type=file: plain text representation of FSL matrix
+    # type=file|default='design.txt': file name to store text output from matrix
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/warp_points.yaml b/example-specs/task/nipype/fsl/warp_points.yaml
index dd7e73f1..d4b565f6 100644
--- a/example-specs/task/nipype/fsl/warp_points.yaml
+++ b/example-specs/task/nipype/fsl/warp_points.yaml
@@ -51,6 +51,9 @@ inputs:
     # type=file|default=<undefined>: filename of affine transform (e.g. source2dest.mat)
     warp_file: medimage/nifti1
     # type=file|default=<undefined>: filename of warpfield (e.g. intermediate2dest_warp.nii.gz)
+    out_file: Path
+    # type=file: Name of output file, containing the warp as field or coefficients.
+    # type=file|default=<undefined>: output file name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/warp_points_to_std.yaml b/example-specs/task/nipype/fsl/warp_points_to_std.yaml
index d7808b21..22df79cc 100644
--- a/example-specs/task/nipype/fsl/warp_points_to_std.yaml
+++ b/example-specs/task/nipype/fsl/warp_points_to_std.yaml
@@ -55,6 +55,9 @@ inputs:
     # type=file|default=<undefined>: filename of affine transform (e.g. source2dest.mat)
     warp_file: medimage/nifti1
     # type=file|default=<undefined>: filename of warpfield (e.g. intermediate2dest_warp.nii.gz)
+    out_file: Path
+    # type=file: Name of output file, containing the warp as field or coefficients.
+    # type=file|default=<undefined>: output file name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/warp_utils.yaml b/example-specs/task/nipype/fsl/warp_utils.yaml
index f9369aaa..1009f3c4 100644
--- a/example-specs/task/nipype/fsl/warp_utils.yaml
+++ b/example-specs/task/nipype/fsl/warp_utils.yaml
@@ -43,6 +43,12 @@ inputs:
     # type=file|default=<undefined>: Name of file containing warp-coefficients/fields. This would typically be the output from the --cout switch of fnirt (but can also use fields, like the output from --fout).
     reference: medimage/nifti1
     # type=file|default=<undefined>: Name of a file in target space. Note that the target space is now different from the target space that was used to create the --warp file. It would typically be the file that was specified with the --in argument when running fnirt.
+    out_file: Path
+    # type=file: Name of output file, containing the warp as field or coefficients.
+    # type=file|default=<undefined>: Name of output file. The format of the output depends on what other parameters are set. The default format is a (4D) field-file. If the --outformat is set to spline the format will be a (4D) file of spline coefficients.
+    out_jacobian: Path
+    # type=file: Name of output file, containing the map of the determinant of the Jacobian
+    # type=file|default=<undefined>: Specifies that a (3D) file of Jacobian determinants corresponding to --in should be produced and written to filename.
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/nipype2pydra/task/base.py b/nipype2pydra/task/base.py
index 7ff49cee..354bc9d4 100644
--- a/nipype2pydra/task/base.py
+++ b/nipype2pydra/task/base.py
@@ -459,6 +459,9 @@ def add_nonstd_types(tp):
         for f in input_fields:
             add_nonstd_types(f[1])
 
+        for f in output_fields:
+            add_nonstd_types(f[1])
+
         output_file = (
             Path(package_root)
             .joinpath(*self.output_module.split("."))
diff --git a/scripts/pkg_gen/create_packages.py b/scripts/pkg_gen/create_packages.py
index d572a048..0fc75e76 100644
--- a/scripts/pkg_gen/create_packages.py
+++ b/scripts/pkg_gen/create_packages.py
@@ -2,6 +2,7 @@
 import typing as ty
 import tempfile
 import re
+import inspect
 from importlib import import_module
 from copy import copy
 import subprocess as sp
@@ -94,7 +95,12 @@ def download_tasks_template(output_path: Path):
 @click.option("--work-dir", type=click.Path(path_type=Path), default=None)
 @click.option("--task-template", type=click.Path(path_type=Path), default=None)
 @click.option("--packages-to-import", type=click.Path(path_type=Path), default=None)
-@click.option("--example-packages", type=click.Path(path_type=Path), default=None, help="Packages to save into the example-spec directory")
+@click.option(
+    "--example-packages",
+    type=click.Path(path_type=Path),
+    default=None,
+    help="Packages to save into the example-spec directory",
+)
 @click.option(
     "--base-package",
     type=str,
@@ -171,11 +177,13 @@ def generate_packages(
                     input_helps,
                     output_helps,
                     file_inputs,
+                    path_inputs,
                     file_outputs,
-                    genfile_outputs,
+                    template_outputs,
                     multi_inputs,
                     dir_inputs,
                     dir_outputs,
+                    callables,
                 ) = parse_nipype_interface(nipype_interface)
 
                 # Create "stubs" for each of the available fields
@@ -204,6 +212,7 @@ def fields_stub(name, category_class, values=None):
 
                 input_types = {i: File for i in file_inputs}
                 input_types.update({i: Directory for i in dir_inputs})
+                input_types.update({i: Path for i in path_inputs})
                 output_types = {o: File for o in file_outputs}
                 output_types.update({o: Directory for o in dir_outputs})
                 output_templates = {}
@@ -268,7 +277,9 @@ def guess_type(fspath):
                                     mode=File.ExtensionDecomposition.single,
                                 )[2]
                                 if any(c in format_ext for c in EXT_SPECIAL_CHARS):
-                                    return File  # Skip any extensions with special chars
+                                    return (
+                                        File  # Skip any extensions with special chars
+                                    )
                                 unmatched_formats.append(
                                     f"{module}.{interface}: {fspath}"
                                 )
@@ -325,7 +336,7 @@ def combine_types(type_, prev_type):
                                 output_types[name] = combine_types(
                                     guessed_type, output_types[name]
                                 )
-                            if name in genfile_outputs:
+                            if name in template_outputs:
                                 output_templates[name] = val
 
                         tests.append(
@@ -350,7 +361,7 @@ def combine_types(type_, prev_type):
                         has_doctests.add(f"{module.replace('/', '.')}.{interface}")
 
                 # Add default template names for fields not explicitly listed in doctests
-                for outpt in genfile_outputs:
+                for outpt in template_outputs:
                     if outpt not in output_templates:
                         try:
                             frmt = output_types[outpt]
@@ -369,6 +380,13 @@ def combine_types(type_, prev_type):
                     for n, t in input_types.items()
                 }
 
+                non_mime = [Path]
+
+                def type2str(tp):
+                    if tp in non_mime:
+                        return tp.__name__
+                    return fileformats.core.utils.to_mime(tp, official=False)
+
                 spec_stub = {
                     "task_name": interface,
                     "nipype_name": interface,
@@ -376,22 +394,15 @@ def combine_types(type_, prev_type):
                     "inputs": fields_stub(
                         "inputs",
                         InputsConverter,
-                        {
-                            "types": {
-                                n: fileformats.core.utils.to_mime(t, official=False)
-                                for n, t in input_types.items()
-                            }
-                        },
+                        {"types": {n: type2str(t) for n, t in input_types.items()}},
                     ),
                     "outputs": fields_stub(
                         "outputs",
                         OutputsConverter,
                         {
-                            "types": {
-                                n: fileformats.core.utils.to_mime(t, official=False)
-                                for n, t in output_types.items()
-                            },
+                            "types": {n: type2str(t) for n, t in output_types.items()},
                             "templates": output_templates,
+                            "callables": {n: f"{n}_callable" for n in callables},
                         },
                     ),
                     "tests": tests,
@@ -443,6 +454,17 @@ def combine_types(type_, prev_type):
                     f.write(
                         f'"""Module to put any functions that are referred to in {interface}.yaml"""\n'
                     )
+                    if callables:
+                        f.write(
+                            "\n"
+                            + convert_gen_filename_to_func(nipype_interface)
+                            + "\n\n"
+                        )
+                        for name, val in callables.items():
+                            f.write(
+                                f"def {name}_callable(output_dir, inputs, stdout, stderr):\n"
+                                f'return _gen_filename("{name}", inputs)\n\n'
+                            )
 
         with open(
             pkg_dir
@@ -480,14 +502,21 @@ def combine_types(type_, prev_type):
 
         basepkg = base_package
         if base_package.endswith(".interfaces"):
-            basepkg = basepkg[:-len(".interfaces")]
+            basepkg = basepkg[: -len(".interfaces")]
 
-        examples_dir = Path(__file__).parent.parent.parent / "example-specs" / "task" / basepkg
+        examples_dir = (
+            Path(__file__).parent.parent.parent / "example-specs" / "task" / basepkg
+        )
         if examples_dir.exists():
             shutil.rmtree(examples_dir)
         examples_dir.mkdir()
         for example_pkg_name in example_pkg_names:
-            specs_dir = output_dir / ("pydra-" + example_pkg_name) / "nipype-auto-conv" / "specs"
+            specs_dir = (
+                output_dir
+                / ("pydra-" + example_pkg_name)
+                / "nipype-auto-conv"
+                / "specs"
+            )
             shutil.copytree(specs_dir, examples_dir / example_pkg_name)
 
     unmatched_extensions = set(
@@ -543,7 +572,9 @@ def copy_ignore(_, names):
     with open(pkg_dir / "pyproject.toml") as f:
         pyproject_toml = f.read()
     pyproject_toml = pyproject_toml.replace("README.md", "README.rst")
-    pyproject_toml = pyproject_toml.replace("test = [\n", "test = [\n    \"nipype2pydra\",\n")
+    pyproject_toml = pyproject_toml.replace(
+        "test = [\n", 'test = [\n    "nipype2pydra",\n'
+    )
     with open(pkg_dir / "pyproject.toml", "w") as f:
         f.write(pyproject_toml)
 
@@ -606,14 +637,32 @@ def parse_nipype_interface(
     ty.List[str],
     ty.List[str],
     ty.List[str],
+    ty.List[str],
+    ty.List[str],
 ]:
     """Generate preamble comments at start of file with args and doc strings"""
     input_helps = {}
     file_inputs = []
     file_outputs = []
     dir_inputs = []
-    genfile_outputs = []
+    path_inputs = []
+    template_outputs = []
     multi_inputs = []
+    dir_outputs = []
+    output_helps = {}
+    callables = []
+    if nipype_interface.output_spec:
+        for outpt_name, outpt in nipype_interface.output_spec().traits().items():
+            if outpt_name in ("trait_added", "trait_modified"):
+                continue
+            outpt_desc = outpt.desc.replace("\n", " ") if outpt.desc else ""
+            output_helps[outpt_name] = (
+                f"type={type(outpt.trait_type).__name__.lower()}: {outpt_desc}"
+            )
+            if type(outpt.trait_type).__name__ == "File":
+                file_outputs.append(outpt_name)
+            elif type(outpt.trait_type).__name__ == "Directory":
+                dir_outputs.append(outpt_name)
     if nipype_interface.input_spec:
         for inpt_name, inpt in nipype_interface.input_spec().traits().items():
             if inpt_name in ("trait_added", "trait_modified"):
@@ -624,46 +673,36 @@ def parse_nipype_interface(
                 inpt_mdata += f"|allowed[{','.join(sorted(repr(v) for v in inpt.trait_type.values))}]"
             input_helps[inpt_name] = f"{inpt_mdata}: {inpt_desc}"
             trait_type_name = type(inpt.trait_type).__name__
-            if inpt.genfile:
-                genfile_outputs.append(inpt_name)
-            elif trait_type_name == "File":
-                if isinstance(inpt.default, str) or "out_" in inpt_name:
-                    file_outputs.append(inpt_name)
-                else:
-                    file_inputs.append(inpt_name)
-            elif trait_type_name == "Directory":
+            if inpt.genfile and inpt_name in (file_outputs + dir_outputs):
+                template_outputs.append(inpt_name)
+            elif trait_type_name == "File" and inpt_name not in file_outputs:
+                file_inputs.append(inpt_name)
+            elif trait_type_name == "Directory" and inpt_name not in dir_outputs:
                 dir_inputs.append(inpt_name)
             elif trait_type_name == "InputMultiObject":
-                inner_trait_type_name = type(inpt.trait_type.item_trait.trait_type).__name__
+                inner_trait_type_name = type(
+                    inpt.trait_type.item_trait.trait_type
+                ).__name__
                 if inner_trait_type_name == "Directory":
                     dir_inputs.append(inpt_name)
                 elif inner_trait_type_name == "File":
                     file_inputs.append(inpt_name)
                 multi_inputs.append(inpt_name)
-            elif (
-                type(inpt.trait_type).__name__ == "List"
-                and type(inpt.trait_type.inner_traits()[0].handler).__name__ in ("File", "Directory")
-            ):
-                item_type_name = type(inpt.trait_type.inner_traits()[0].handler).__name__
+            elif type(inpt.trait_type).__name__ == "List" and type(
+                inpt.trait_type.inner_traits()[0].handler
+            ).__name__ in ("File", "Directory"):
+                item_type_name = type(
+                    inpt.trait_type.inner_traits()[0].handler
+                ).__name__
                 if item_type_name == "File":
                     file_inputs.append(inpt_name)
                 else:
                     dir_inputs.append(inpt_name)
                 multi_inputs.append(inpt_name)
-    dir_outputs = []
-    output_helps = {}
-    if nipype_interface.output_spec:
-        for outpt_name, outpt in nipype_interface.output_spec().traits().items():
-            if outpt_name in ("trait_added", "trait_modified"):
-                continue
-            outpt_desc = outpt.desc.replace("\n", " ") if outpt.desc else ""
-            output_helps[
-                outpt_name
-            ] = f"type={type(outpt.trait_type).__name__.lower()}: {outpt_desc}"
-            if type(outpt.trait_type).__name__ == "File":
-                file_outputs.append(outpt_name)
-            elif type(outpt.trait_type).__name__ == "Directory":
-                dir_outputs.append(outpt_name)
+            elif trait_type_name in ("File", "Directory"):
+                path_inputs.append(inpt_name)
+            elif inpt.genfile:
+                callables.append(inpt_name)
     doc_string = nipype_interface.__doc__ if nipype_interface.__doc__ else ""
     doc_string = doc_string.replace("\n", "\n# ")
     # Create a preamble at the top of the specificaiton explaining what to do
@@ -682,11 +721,13 @@ def parse_nipype_interface(
         input_helps,
         output_helps,
         file_inputs,
+        path_inputs,
         file_outputs,
-        genfile_outputs,
+        template_outputs,
         multi_inputs,
         dir_inputs,
         dir_outputs,
+        callables,
     )
 
 
@@ -818,6 +859,14 @@ def gen_sample_{frmt.lower()}_data({frmt.lower()}: {frmt}, dest_dir: Path, seed:
     return code_str
 
 
+def convert_gen_filename_to_func(nipype_interface) -> ty.Tuple[str, str]:
+    src = inspect.getsource(nipype_interface._gen_filename)
+    body = "\n" + src.split("\n", 1)[1]
+    body = body.replace("self.inputs", "inputs")
+    body = body.replace("\n        ", "\n    ")
+    return "def _gen_filename(name, inputs):" + body
+
+
 if __name__ == "__main__":
     import sys
 
diff --git a/scripts/pkg_gen/freesurfer-mris-convert-only.yaml b/scripts/pkg_gen/freesurfer-mris-convert-only.yaml
new file mode 100644
index 00000000..70261003
--- /dev/null
+++ b/scripts/pkg_gen/freesurfer-mris-convert-only.yaml
@@ -0,0 +1,5 @@
+packages:
+- freesurfer
+interfaces:
+  freesurfer:
+  - MRIsConvert
\ No newline at end of file
diff --git a/scripts/pkg_gen/fsl-filmgls-only.yaml b/scripts/pkg_gen/fsl-filmgls-only.yaml
new file mode 100644
index 00000000..6aca6a26
--- /dev/null
+++ b/scripts/pkg_gen/fsl-filmgls-only.yaml
@@ -0,0 +1,6 @@
+packages:
+- fsl
+interfaces:
+  fsl:
+  - FILMGLS
+  
\ No newline at end of file
diff --git a/tests/test_task.py b/tests/test_task.py
index 4b689b83..948d2cc6 100644
--- a/tests/test_task.py
+++ b/tests/test_task.py
@@ -25,15 +25,14 @@
 
 @pytest.fixture(
     params=[
-        str(p.relative_to(EXAMPLE_TASKS_DIR)).replace("/", "__")[:-5]
+        str(p.relative_to(EXAMPLE_TASKS_DIR)).replace("/", "-")[:-5]
         for p in (EXAMPLE_TASKS_DIR).glob("**/*.yaml")
     ]
 )
 def task_spec_file(request):
-    return EXAMPLE_TASKS_DIR.joinpath(*request.param.split("__")).with_suffix(".yaml")
+    return EXAMPLE_TASKS_DIR.joinpath(*request.param.split("-")).with_suffix(".yaml")
 
 
-@pytest.mark.xfail(condition="any(str(task_spec_file).startswith(str(EXAMPLE_TASKS_DIR / ('pydra-' + p))) for p in XFAIL_PACKAGES)")
 def test_task_conversion(task_spec_file, cli_runner, work_dir, gen_test_conftest):
 
     with open(task_spec_file) as f:

From 776e46e42ad81bd3745f9321b476dcb229a66919 Mon Sep 17 00:00:00 2001
From: Tom Close <tom.g.close@gmail.com>
Date: Wed, 6 Mar 2024 21:53:47 +1100
Subject: [PATCH 50/78] implemented callables porting

---
 .../task/nipype/afni/center_mass.yaml         |   2 +-
 example-specs/task/nipype/afni/dot.yaml       |   2 +-
 .../task/nipype/afni/one_d_tool_py.yaml       |   2 +-
 example-specs/task/nipype/afni/qwarp.yaml     |   2 +-
 .../task/nipype/afni/qwarp_plus_minus.yaml    |   2 +-
 .../task/nipype/afni/t_corr_map.yaml          |   2 +-
 .../task/nipype/fsl/epi_de_warp.yaml          |   4 +
 .../task/nipype/fsl/epi_de_warp_callables.py  | 201 +++++++++++
 .../task/nipype/fsl/prob_track_x.yaml         |   2 +
 .../task/nipype/fsl/prob_track_x_callables.py |  16 +
 nipype2pydra/task/function.py                 | 312 ++----------------
 nipype2pydra/utils.py                         | 306 ++++++++++++++++-
 scripts/pkg_gen/create_packages.py            | 149 +++++++--
 scripts/pkg_gen/fsl-filmgls-only.yaml         |   2 +-
 14 files changed, 688 insertions(+), 316 deletions(-)

diff --git a/example-specs/task/nipype/afni/center_mass.yaml b/example-specs/task/nipype/afni/center_mass.yaml
index c61caa51..ebc25f65 100644
--- a/example-specs/task/nipype/afni/center_mass.yaml
+++ b/example-specs/task/nipype/afni/center_mass.yaml
@@ -88,7 +88,7 @@ tests:
     automask:
     # type=bool|default=False: Generate the mask automatically
     set_cm:
-    # type=tuple|default=(<traits.trait_types.Float object at 0x10f1c4450>, <traits.trait_types.Float object at 0x10f1c4550>, <traits.trait_types.Float object at 0x10f1c45d0>): After computing the center of mass, set the origin fields in the header so that the center of mass will be at (x,y,z) in DICOM coords.
+    # type=tuple|default=(<traits.trait_types.Float object at 0x112056650>, <traits.trait_types.Float object at 0x112056750>, <traits.trait_types.Float object at 0x1120567d0>): After computing the center of mass, set the origin fields in the header so that the center of mass will be at (x,y,z) in DICOM coords.
     local_ijk:
     # type=bool|default=False: Output values as (i,j,k) in local orientation
     roi_vals:
diff --git a/example-specs/task/nipype/afni/dot.yaml b/example-specs/task/nipype/afni/dot.yaml
index db686f24..51a571a4 100644
--- a/example-specs/task/nipype/afni/dot.yaml
+++ b/example-specs/task/nipype/afni/dot.yaml
@@ -82,7 +82,7 @@ tests:
     mask:
     # type=file|default=<undefined>: Use this dataset as a mask
     mrange:
-    # type=tuple|default=(<traits.trait_types.Float object at 0x10f1c6d10>, <traits.trait_types.Float object at 0x10f1c6c10>): Means to further restrict the voxels from 'mset' so thatonly those mask values within this range (inclusive) willbe used.
+    # type=tuple|default=(<traits.trait_types.Float object at 0x112060e50>, <traits.trait_types.Float object at 0x112060d50>): Means to further restrict the voxels from 'mset' so thatonly those mask values within this range (inclusive) willbe used.
     demean:
     # type=bool|default=False: Remove the mean from each volume prior to computing the correlation
     docor:
diff --git a/example-specs/task/nipype/afni/one_d_tool_py.yaml b/example-specs/task/nipype/afni/one_d_tool_py.yaml
index 7910f840..4f6c26ae 100644
--- a/example-specs/task/nipype/afni/one_d_tool_py.yaml
+++ b/example-specs/task/nipype/afni/one_d_tool_py.yaml
@@ -79,7 +79,7 @@ tests:
     show_censor_count:
     # type=bool|default=False: display the total number of censored TRs  Note : if input is a valid xmat.1D dataset, then the count will come from the header.  Otherwise the input is assumed to be a binary censorfile, and zeros are simply counted.
     censor_motion:
-    # type=tuple|default=(<traits.trait_types.Float object at 0x10f1eb110>, <nipype.interfaces.base.traits_extension.File object at 0x10f1eb1d0>): Tuple of motion limit and outfile prefix. need to also set set_nruns -r set_run_lengths
+    # type=tuple|default=(<traits.trait_types.Float object at 0x11208d110>, <nipype.interfaces.base.traits_extension.File object at 0x11208d1d0>): Tuple of motion limit and outfile prefix. need to also set set_nruns -r set_run_lengths
     censor_prev_TR:
     # type=bool|default=False: for each censored TR, also censor previous
     show_trs_uncensored:
diff --git a/example-specs/task/nipype/afni/qwarp.yaml b/example-specs/task/nipype/afni/qwarp.yaml
index 658b0164..a5d4e9f4 100644
--- a/example-specs/task/nipype/afni/qwarp.yaml
+++ b/example-specs/task/nipype/afni/qwarp.yaml
@@ -190,7 +190,7 @@ tests:
     wball:
     # type=list|default=[]: "``-wball x y z r f`` Enhance automatic weight from '-useweight' by a factor of 1+f\*Gaussian(FWHM=r) centered in the base image at DICOM coordinates (x,y,z) and with radius 'r'. The goal of this option is to try and make the alignment better in a specific part of the brain. Example:  -wball 0 14 6 30 40 to emphasize the thalamic area (in MNI/Talairach space).  * The 'r' parameter must be positive! * The 'f' parameter must be between 1 and 100 (inclusive). * '-wball' does nothing if you input your own weight   with the '-weight' option. * '-wball' does change the binary weight created by   the '-noweight' option. * You can only use '-wball' once in a run of 3dQwarp.  **The effect of '-wball' is not dramatic.** The example above makes the average brain image across a collection of subjects a little sharper in the thalamic area, which might have some small value.  If you care enough about alignment to use '-wball', then you should examine the results from 3dQwarp for each subject, to see if the alignments are good enough for your purposes.
     wmask:
-    # type=tuple|default=(<nipype.interfaces.base.traits_extension.File object at 0x10f0eed50>, <traits.trait_types.Float object at 0x10f0eeb10>): Similar to '-wball', but here, you provide a dataset 'ws' that indicates where to increase the weight.  * The 'ws' dataset must be on the same 3D grid as the base dataset. * 'ws' is treated as a mask -- it only matters where it   is nonzero -- otherwise, the values inside are not used. * After 'ws' comes the factor 'f' by which to increase the   automatically computed weight.  Where 'ws' is nonzero,   the weighting will be multiplied by (1+f). * As with '-wball', the factor 'f' should be between 1 and 100.  
+    # type=tuple|default=(<nipype.interfaces.base.traits_extension.File object at 0x111f91150>, <traits.trait_types.Float object at 0x111f91310>): Similar to '-wball', but here, you provide a dataset 'ws' that indicates where to increase the weight.  * The 'ws' dataset must be on the same 3D grid as the base dataset. * 'ws' is treated as a mask -- it only matters where it   is nonzero -- otherwise, the values inside are not used. * After 'ws' comes the factor 'f' by which to increase the   automatically computed weight.  Where 'ws' is nonzero,   the weighting will be multiplied by (1+f). * As with '-wball', the factor 'f' should be between 1 and 100.  
     out_weight_file:
     # type=file|default=<undefined>: Write the weight volume to disk as a dataset
     blur:
diff --git a/example-specs/task/nipype/afni/qwarp_plus_minus.yaml b/example-specs/task/nipype/afni/qwarp_plus_minus.yaml
index dec8b0a3..7de9641c 100644
--- a/example-specs/task/nipype/afni/qwarp_plus_minus.yaml
+++ b/example-specs/task/nipype/afni/qwarp_plus_minus.yaml
@@ -126,7 +126,7 @@ tests:
     wball:
     # type=list|default=[]: "``-wball x y z r f`` Enhance automatic weight from '-useweight' by a factor of 1+f\*Gaussian(FWHM=r) centered in the base image at DICOM coordinates (x,y,z) and with radius 'r'. The goal of this option is to try and make the alignment better in a specific part of the brain. Example:  -wball 0 14 6 30 40 to emphasize the thalamic area (in MNI/Talairach space).  * The 'r' parameter must be positive! * The 'f' parameter must be between 1 and 100 (inclusive). * '-wball' does nothing if you input your own weight   with the '-weight' option. * '-wball' does change the binary weight created by   the '-noweight' option. * You can only use '-wball' once in a run of 3dQwarp.  **The effect of '-wball' is not dramatic.** The example above makes the average brain image across a collection of subjects a little sharper in the thalamic area, which might have some small value.  If you care enough about alignment to use '-wball', then you should examine the results from 3dQwarp for each subject, to see if the alignments are good enough for your purposes.
     wmask:
-    # type=tuple|default=(<nipype.interfaces.base.traits_extension.File object at 0x10f0eed50>, <traits.trait_types.Float object at 0x10f0eeb10>): Similar to '-wball', but here, you provide a dataset 'ws' that indicates where to increase the weight.  * The 'ws' dataset must be on the same 3D grid as the base dataset. * 'ws' is treated as a mask -- it only matters where it   is nonzero -- otherwise, the values inside are not used. * After 'ws' comes the factor 'f' by which to increase the   automatically computed weight.  Where 'ws' is nonzero,   the weighting will be multiplied by (1+f). * As with '-wball', the factor 'f' should be between 1 and 100.  
+    # type=tuple|default=(<nipype.interfaces.base.traits_extension.File object at 0x111f91150>, <traits.trait_types.Float object at 0x111f91310>): Similar to '-wball', but here, you provide a dataset 'ws' that indicates where to increase the weight.  * The 'ws' dataset must be on the same 3D grid as the base dataset. * 'ws' is treated as a mask -- it only matters where it   is nonzero -- otherwise, the values inside are not used. * After 'ws' comes the factor 'f' by which to increase the   automatically computed weight.  Where 'ws' is nonzero,   the weighting will be multiplied by (1+f). * As with '-wball', the factor 'f' should be between 1 and 100.  
     out_weight_file:
     # type=file|default=<undefined>: Write the weight volume to disk as a dataset
     blur:
diff --git a/example-specs/task/nipype/afni/t_corr_map.yaml b/example-specs/task/nipype/afni/t_corr_map.yaml
index 36c0d509..114b2193 100644
--- a/example-specs/task/nipype/afni/t_corr_map.yaml
+++ b/example-specs/task/nipype/afni/t_corr_map.yaml
@@ -161,7 +161,7 @@ tests:
     polort:
     # type=int|default=0: 
     bandpass:
-    # type=tuple|default=(<traits.trait_types.Float object at 0x10f0d4350>, <traits.trait_types.Float object at 0x10f0d4410>): 
+    # type=tuple|default=(<traits.trait_types.Float object at 0x111f72f50>, <traits.trait_types.Float object at 0x111f72fd0>): 
     regress_out_timeseries:
     # type=file|default=<undefined>: 
     blur_fwhm:
diff --git a/example-specs/task/nipype/fsl/epi_de_warp.yaml b/example-specs/task/nipype/fsl/epi_de_warp.yaml
index b1e2d567..398c0cfd 100644
--- a/example-specs/task/nipype/fsl/epi_de_warp.yaml
+++ b/example-specs/task/nipype/fsl/epi_de_warp.yaml
@@ -74,6 +74,10 @@ outputs:
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
+    vsm: vsm_callable
+    # type=string|default='': voxel shift map
+    tmpdir: tmpdir_callable
+    # type=string|default='': tmpdir
   templates:
   # dict[str, str] - `output_file_template` values to be provided to output fields
     exfdw: exfdw
diff --git a/example-specs/task/nipype/fsl/epi_de_warp_callables.py b/example-specs/task/nipype/fsl/epi_de_warp_callables.py
index 33f2aea8..7c342436 100644
--- a/example-specs/task/nipype/fsl/epi_de_warp_callables.py
+++ b/example-specs/task/nipype/fsl/epi_de_warp_callables.py
@@ -1 +1,202 @@
 """Module to put any functions that are referred to in EPIDeWarp.yaml"""
+import os.path as op
+import os
+from pathlib import Path
+import attrs
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "exfdw":
+        if inputs.exf_file is not attrs.NOTHING:
+            return _gen_fname(
+                inputs.exf_file,
+                suffix="_exfdw",
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+        else:
+            return _gen_fname(
+                "exfdw",
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    if name == "epidw":
+        if inputs.epi_file is not attrs.NOTHING:
+            return _gen_fname(
+                inputs.epi_file,
+                suffix="_epidw",
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    if name == "vsm":
+        return _gen_fname(
+            "vsm", inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )
+    if name == "tmpdir":
+        return os.path.join(output_dir, "temp")
+    return None
+
+
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
+
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
+
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
+
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "epidewarp.fsl"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import Undefined
+    >>> fname_presuffix(fname, 'pre', 'post', Undefined) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for isdefined: bool(Undefined) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def vsm_callable(output_dir, inputs, stdout, stderr):
+    return _gen_filename(
+        "vsm", output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+
+
+def tmpdir_callable(output_dir, inputs, stdout, stderr):
+    return _gen_filename(
+        "tmpdir", output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
diff --git a/example-specs/task/nipype/fsl/prob_track_x.yaml b/example-specs/task/nipype/fsl/prob_track_x.yaml
index 12061afb..68275ce1 100644
--- a/example-specs/task/nipype/fsl/prob_track_x.yaml
+++ b/example-specs/task/nipype/fsl/prob_track_x.yaml
@@ -78,6 +78,8 @@ outputs:
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
+    mode: mode_callable
+    # type=enum|default='simple'|allowed['seedmask','simple','two_mask_symm']: options: simple (single seed voxel), seedmask (mask of seed voxels), twomask_symm (two bet binary masks)
   templates:
   # dict[str, str] - `output_file_template` values to be provided to output fields
   requirements:
diff --git a/example-specs/task/nipype/fsl/prob_track_x_callables.py b/example-specs/task/nipype/fsl/prob_track_x_callables.py
index 9bac8685..0d8c4ce7 100644
--- a/example-specs/task/nipype/fsl/prob_track_x_callables.py
+++ b/example-specs/task/nipype/fsl/prob_track_x_callables.py
@@ -1 +1,17 @@
 """Module to put any functions that are referred to in ProbTrackX.yaml"""
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_dir":
+        return output_dir
+    elif name == "mode":
+        if isinstance(inputs.seed, list) and isinstance(inputs.seed[0], list):
+            return "simple"
+        else:
+            return "seedmask"
+
+
+def mode_callable(output_dir, inputs, stdout, stderr):
+    return _gen_filename(
+        "mode", output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
diff --git a/nipype2pydra/task/function.py b/nipype2pydra/task/function.py
index febeea51..852ca386 100644
--- a/nipype2pydra/task/function.py
+++ b/nipype2pydra/task/function.py
@@ -4,9 +4,16 @@
 from operator import attrgetter, itemgetter
 from functools import cached_property
 import itertools
-from importlib import import_module
 import attrs
 from .base import BaseTaskConverter
+from ..utils import (
+    split_parens_contents,
+    UsedSymbols,
+    get_local_functions,
+    get_local_constants,
+    cleanup_function_body,
+    insert_args_in_signature,
+)
 
 
 @attrs.define(slots=False)
@@ -50,19 +57,18 @@ def types_to_names(spec_fields):
         method_body += lo_src
         method_body = self.process_method_body(method_body, input_names, output_names)
 
-        (other_imports, funcs_to_include, used_local_functions, used_constants) = (
-            self.get_imports_and_functions_to_include(
-                [method_body]
-                + [
-                    inspect.getsource(f)
-                    for f in itertools.chain(
-                        self.referenced_local_functions, self.referenced_methods
-                    )
-                ]
-            )
+        used = UsedSymbols.find(
+            self.nipype_module,
+            [method_body]
+            + [
+                inspect.getsource(f)
+                for f in itertools.chain(
+                    self.referenced_local_functions, self.referenced_methods
+                )
+            ],
         )
 
-        spec_str = "\n".join(f"{n} = {d}" for n, d in used_constants)
+        spec_str = "\n".join(f"{n} = {d}" for n, d in used.constants)
 
         # Create the spec string
         spec_str += "\n\n" + self.function_callables()
@@ -101,14 +107,14 @@ def types_to_names(spec_fields):
 
         spec_str += "\n\n# Functions defined locally in the original module\n\n"
 
-        for func in sorted(used_local_functions, key=attrgetter("__name__")):
-            spec_str += "\n\n" + self.process_function_body(
-                inspect.getsource(func), input_names
+        for func in sorted(used.local_functions, key=attrgetter("__name__")):
+            spec_str += "\n\n" + cleanup_function_body(
+                inspect.getsource(func)
             )
 
         spec_str += "\n\n# Functions defined in neighbouring modules that have been included inline instead of imported\n\n"
 
-        for func_name, func in sorted(funcs_to_include, key=itemgetter(0)):
+        for func_name, func in sorted(used.funcs_to_include, key=itemgetter(0)):
             func_src = inspect.getsource(func)
             func_src = re.sub(
                 r"^(def|class) (\w+)(?=\()",
@@ -116,13 +122,13 @@ def types_to_names(spec_fields):
                 func_src,
                 flags=re.MULTILINE,
             )
-            spec_str += "\n\n" + self.process_function_body(func_src, input_names)
+            spec_str += "\n\n" + cleanup_function_body(func_src)
 
         imports = self.construct_imports(
             nonstd_types,
             spec_str,
             include_task=False,
-            base=base_imports + list(other_imports) + list(additional_imports),
+            base=base_imports + list(used.imports) + list(additional_imports),
         )
         spec_str = "\n".join(imports) + "\n\n" + spec_str
 
@@ -197,6 +203,8 @@ def process_method_body(
         splits = method_re.split(method_body)
         new_body = splits[0]
         for name, args in zip(splits[1::2], splits[2::2]):
+            # Assign additional return values (which were previously saved to member
+            # attributes) to new variables from the method call
             if self.method_returns[name]:
                 match = re.match(
                     r".*\n *([a-zA-Z0-9\,\. ]+ *=)? *$",
@@ -223,7 +231,9 @@ def process_method_body(
                         "directly. Need to replace the method call with a variable and "
                         "assign the return value to it on a previous line"
                     )
-            new_body += name + self.insert_args_in_signature(
+            # Insert additional arguments to the method call (which were previously
+            # accessed via member attributes)
+            new_body += name + insert_args_in_signature(
                 args, [f"{a}={a}" for a in self.method_args[name]]
             )
         method_body = new_body
@@ -232,186 +242,7 @@ def process_method_body(
         method_body = re.sub(
             r"self\.(\w+ *)(?==)", r"\1", method_body, flags=re.MULTILINE | re.DOTALL
         )
-        return self.process_function_body(method_body, input_names=input_names)
-
-    def process_function_body(
-        self, function_body: str, input_names: ty.List[str]
-    ) -> str:
-        """Replace self.inputs.<name> with <name> in the function body and add args to the
-        function signature
-
-        Parameters
-        ----------
-        function_body: str
-            The source code of the function to process
-        input_names: list[str]
-            The names of the inputs to the function
-
-        Returns
-        -------
-        function_body: str
-            The processed source code
-        """
-        # Detect the indentation of the source code in src and reduce it to 4 spaces
-        indents = re.findall(r"^\s+", function_body, flags=re.MULTILINE)
-        min_indent = min(len(i) for i in indents if i)
-        indent_reduction = min_indent - 4
-        function_body = re.sub(
-            r"^" + " " * indent_reduction, "", function_body, flags=re.MULTILINE
-        )
-        # Other misc replacements
-        function_body = function_body.replace("LOGGER.", "logger.")
-        function_body = re.sub(
-            r"not isdefined\((\w+)\)", r"\1 is attrs.NOTHING", function_body
-        )
-        function_body = re.sub(
-            r"isdefined\((\w+)\)", r"\1 is not attrs.NOTHING", function_body
-        )
-        return function_body
-
-    def get_imports_and_functions_to_include(
-        self,
-        function_bodies: ty.List[str],
-        source_code: str = None,
-        local_functions: ty.List[ty.Callable] = None,
-        local_constants: ty.List[ty.Tuple[str, str]] = None,
-    ) -> ty.Tuple[ty.List[str], ty.List[ty.Tuple[str, ty.Any]]]:
-        """Get the imports required for the function body
-
-        Parameters
-        ----------
-        function_bodies: list[str]
-            the source of all functions that need to be checked for used imports
-        source_code: str, optional
-            the source code containing the relevant import statements, by default the
-            source file containing the interface to be converted
-        local_functions: list[callable], optional
-            local functions defined in the source code, by default the functions in the
-            same file as the interface
-        local_constants: list[tuple[str, str]], optional
-            local constants defined in the source code with their definitions,
-            by default the functions in the same file as the interface
-
-        Returns
-        -------
-        used_imports : list[str]
-            the import statements that need to be included in the converted file
-        external_functions: list[tuple[str, Any]]
-            list of objects (e.g. classes, functions and variables) that are defined
-            in neighbouring modules that need to be included in the converted file
-            (as opposed of just imported from independent packages) along with the name
-            that they were imported as and therefore should be named as in the converted
-            module
-        """
-        if source_code is None:
-            source_code = self.source_code
-        if local_functions is None:
-            local_functions = self.local_functions
-        if local_constants is None:
-            local_constants = self.local_constants
-        imports = []
-        block = ""
-        for line in source_code.split("\n"):
-            if line.startswith("from") or line.startswith("import"):
-                if "(" in line:
-                    block = line
-                else:
-                    imports.append(line)
-            if ")" in line and block:
-                imports.append(block + line)
-                block = ""
-        # extract imported symbols from import statements
-        used_symbols = set()
-        for function_body in function_bodies:
-            # Strip comments from function body
-            function_body = re.sub(r"\s*#.*", "", function_body)
-            used_symbols.update(re.findall(r"(\w+)", function_body))
-        used_imports = set()
-        used_local_functions = set()
-        used_constants = set()
-        # Keep looping through local function source until all local functions and constants
-        # are added to the used symbols
-        new_symbols = True
-        while new_symbols:
-            new_symbols = False
-            for local_func in local_functions:
-                if (
-                    local_func.__name__ in used_symbols
-                    and local_func not in used_local_functions
-                ):
-                    used_local_functions.add(local_func)
-                    func_body = inspect.getsource(local_func)
-                    func_body = re.sub(r"\s*#.*", "", func_body)
-                    local_func_symbols = re.findall(r"(\w+)", func_body)
-                    used_symbols.update(local_func_symbols)
-                    new_symbols = True
-            for const_name, const_def in local_constants:
-                if (
-                    const_name in used_symbols
-                    and (const_name, const_def) not in used_constants
-                ):
-                    if const_name == "LOGGER":
-                        continue
-                    used_constants.add((const_name, const_def))
-                    const_def_symbols = re.findall(r"(\w+)", const_def)
-                    used_symbols.update(const_def_symbols)
-                    new_symbols = True
-        # functions to copy from a relative or nipype module into the output module
-        external_functions = set()
-        for stmt in imports:
-            stmt = stmt.replace("\n", "")
-            stmt = stmt.replace("(", "")
-            stmt = stmt.replace(")", "")
-            base_stmt, symbol_str = stmt.split("import ")
-            symbol_parts = re.split(r" *, *", symbol_str)
-            split_parts = [re.split(r" +as +", p) for p in symbol_parts]
-            used_parts = [p for p in split_parts if p[-1] in used_symbols]
-            if used_parts:
-                required_stmt = (
-                    base_stmt
-                    + "import "
-                    + ", ".join(" as ".join(p) for p in used_parts)
-                )
-                match = re.match(r"from ([\w\.]+)", base_stmt)
-                import_mod = match.group(1) if match else ""
-                if import_mod.startswith(".") or import_mod.startswith("nipype."):
-                    if import_mod.startswith("."):
-                        match = re.match(r"(\.*)(.*)", import_mod)
-                        mod_parts = self.nipype_module.__name__.split(".")
-                        nparents = len(match.group(1))
-                        if nparents:
-                            mod_parts = mod_parts[:-nparents]
-                        mod_name = ".".join(mod_parts) + "." + match.group(2)
-                    elif import_mod.startswith("nipype."):
-                        mod_name = import_mod
-                    else:
-                        assert False
-                    mod = import_module(mod_name)
-                    mod_func_bodies = []
-                    for used_part in used_parts:
-                        func = getattr(mod, used_part[0])
-                        external_functions.add((used_part[-1], func))
-                        mod_func_bodies.append(inspect.getsource(func))
-                    # Recursively include neighbouring objects imported in the module
-                    (
-                        mod_used_imports,
-                        mod_external_funcs,
-                        mod_local_funcs,
-                        mod_constants,
-                    ) = self.get_imports_and_functions_to_include(
-                        function_bodies=mod_func_bodies,
-                        source_code=inspect.getsource(mod),
-                        local_functions=get_local_functions(mod),
-                        local_constants=get_local_constants(mod),
-                    )
-                    used_imports.update(mod_used_imports)
-                    external_functions.update(mod_external_funcs)
-                    external_functions.update((f.__name__, f) for f in mod_local_funcs)
-                    used_constants.update(mod_constants)
-                else:
-                    used_imports.add(required_stmt)
-
-        return used_imports, external_functions, used_local_functions, used_constants
+        return cleanup_function_body(method_body)
 
     @property
     def referenced_local_functions(self):
@@ -570,86 +401,3 @@ def local_function_names(self):
         ("hostname", "platform.node()", "import platform"),
         ("platform", "platform.platform()", "import platform"),
     )
-
-    @classmethod
-    def insert_args_in_signature(cls, snippet: str, new_args: ty.Iterable[str]) -> str:
-        """Insert the arguments into the function signature"""
-        # Split out the argstring from the rest of the code snippet
-        pre, argstr, post = split_parens_contents(snippet)
-        if argstr:
-            args = re.split(r" *, *", argstr)
-            if "runtime" in args:
-                args.remove("runtime")
-        else:
-            args = []
-        return pre + ", ".join(args + new_args) + post
-
-
-def split_parens_contents(snippet, brackets: bool = False):
-    """Splits the code snippet at the first opening parenthesis into a 3-tuple
-    consisting of the pre-paren text, the contents of the parens and the post-paren
-
-    Parameters
-    ----------
-    snippet: str
-        the code snippet to split
-    brackets: bool, optional
-        whether to split at brackets instead of parens, by default False
-
-    Returns
-    -------
-    pre: str
-        the text before the opening parenthesis
-    contents: str
-        the contents of the parens
-    post: str
-        the text after the closing parenthesis
-    """
-    if brackets:
-        open = "["
-        close = "]"
-        pattern = r"(\[|\])"
-    else:
-        open = "("
-        close = ")"
-        pattern = r"(\(|\))"
-    splits = re.split(pattern, snippet, flags=re.MULTILINE | re.DOTALL)
-    depth = 1
-    pre = "".join(splits[:2])
-    contents = ""
-    for i, s in enumerate(splits[2:], start=2):
-        if s == open:
-            depth += 1
-        else:
-            if s == close:
-                depth -= 1
-                if depth == 0:
-                    return pre, contents, "".join(splits[i:])
-            contents += s
-    raise ValueError(f"No matching parenthesis found in '{snippet}'")
-
-
-def get_local_functions(mod):
-    """Get the functions defined in the same file as the interface"""
-    functions = []
-    for attr_name in dir(mod):
-        attr = getattr(mod, attr_name)
-        if inspect.isfunction(attr) and attr.__module__ == mod.__name__:
-            functions.append(attr)
-    return functions
-
-
-def get_local_constants(mod):
-    source_code = inspect.getsource(mod)
-    parts = re.split(r"^(\w+) *= *", source_code, flags=re.MULTILINE)
-    local_vars = []
-    for attr_name, following in zip(parts[1::2], parts[2::2]):
-        if "(" in following.splitlines()[0]:
-            pre, args, _ = split_parens_contents(following)
-            local_vars.append((attr_name, pre + re.sub(r"\n *", "", args) + ")"))
-        elif "[" in following.splitlines()[0]:
-            pre, args, _ = split_parens_contents(following, brackets=True)
-            local_vars.append((attr_name, pre + re.sub(r"\n *", "", args) + "]"))
-        else:
-            local_vars.append((attr_name, following.splitlines()[0]))
-    return local_vars
diff --git a/nipype2pydra/utils.py b/nipype2pydra/utils.py
index 4f957a8e..d6b0b0d3 100644
--- a/nipype2pydra/utils.py
+++ b/nipype2pydra/utils.py
@@ -2,9 +2,11 @@
 import typing as ty
 from types import ModuleType
 import sys
+import re
 import os
 import inspect
 from contextlib import contextmanager
+import attrs
 from pathlib import Path
 from fileformats.core import FileSet
 
@@ -17,7 +19,7 @@
 
 
 def load_class_or_func(location_str):
-    module_str, name = location_str.split(':')
+    module_str, name = location_str.split(":")
     module = import_module(module_str)
     return getattr(module, name)
 
@@ -74,9 +76,7 @@ def add_to_sys_path(path: Path):
 
 def is_fileset(tp: type):
     return (
-        inspect.isclass(tp)
-        and type(tp) is not GenericAlias
-        and issubclass(tp, FileSet)
+        inspect.isclass(tp) and type(tp) is not GenericAlias and issubclass(tp, FileSet)
     )
 
 
@@ -96,7 +96,10 @@ def to_snake_case(name: str) -> str:
             and (char.isupper() or char.isdigit())
             and (
                 not (name[i - 1].isupper() or name[i - 1].isdigit())
-                or ((i + 1) < len(name) and (name[i + 1].islower() or name[i + 1].islower()))
+                or (
+                    (i + 1) < len(name)
+                    and (name[i + 1].islower() or name[i + 1].islower())
+                )
             )
         ):
             snake_str += "_"
@@ -127,4 +130,295 @@ def add_exc_note(e, note):
         e.add_note(note)
     else:
         e.args = (e.args[0] + "\n" + note,)
-    return e
\ No newline at end of file
+    return e
+
+
+def split_parens_contents(snippet, brackets: bool = False):
+    """Splits the code snippet at the first opening parenthesis into a 3-tuple
+    consisting of the pre-paren text, the contents of the parens and the post-paren
+
+    Parameters
+    ----------
+    snippet: str
+        the code snippet to split
+    brackets: bool, optional
+        whether to split at brackets instead of parens, by default False
+
+    Returns
+    -------
+    pre: str
+        the text before the opening parenthesis
+    contents: str
+        the contents of the parens
+    post: str
+        the text after the closing parenthesis
+    """
+    if brackets:
+        open = "["
+        close = "]"
+        pattern = r"(\[|\])"
+    else:
+        open = "("
+        close = ")"
+        pattern = r"(\(|\))"
+    splits = re.split(pattern, snippet, flags=re.MULTILINE | re.DOTALL)
+    depth = 1
+    pre = "".join(splits[:2])
+    contents = ""
+    for i, s in enumerate(splits[2:], start=2):
+        if s == open:
+            depth += 1
+        else:
+            if s == close:
+                depth -= 1
+                if depth == 0:
+                    return pre, contents, "".join(splits[i:])
+            contents += s
+    raise ValueError(f"No matching parenthesis found in '{snippet}'")
+
+
+@attrs.define
+class UsedSymbols:
+    """
+    A class to hold the used symbols in a module
+
+    Parameters
+    -------
+    used_imports : list[str]
+        the import statements that need to be included in the converted file
+    funcs_to_include: list[tuple[str, callable]]
+        list of objects (e.g. classes, functions and variables) that are defined
+        in neighbouring modules that need to be included in the converted file
+        (as opposed of just imported from independent packages) along with the name
+        that they were imported as and therefore should be named as in the converted
+        module
+    used_local_functions: set[callable]
+        locally-defined functions used in the function bodies, or nested functions thereof
+    used_constants: set[tuple[str, str]]
+        constants used in the function bodies, or nested functions thereof, tuples consist
+        of the constant name and its definition
+    """
+
+    imports: ty.Set[str] = attrs.field(factory=set)
+    funcs_to_include: ty.Set[ty.Tuple[str, ty.Callable]] = attrs.field(factory=set)
+    local_functions: ty.Set[ty.Callable] = attrs.field(factory=set)
+    constants: ty.Set[ty.Tuple[str, str]] = attrs.field(factory=set)
+
+    def update(self, other: "UsedSymbols"):
+        self.imports.update(other.imports)
+        self.funcs_to_include.update(other.funcs_to_include)
+        self.funcs_to_include.update((f.__name__, f) for f in other.local_functions)
+        self.constants.update(other.constants)
+
+    @classmethod
+    def find(
+        cls,
+        module,
+        function_bodies: ty.List[str],
+    ) -> "UsedSymbols":
+        """Get the imports required for the function body
+
+        Parameters
+        ----------
+        module: ModuleType
+            the module containing the functions to be converted
+        function_bodies: list[str]
+            the source of all functions that need to be checked for used imports
+
+        Returns
+        -------
+        UsedSymbols
+            a class containing the used symbols in the module
+        """
+        used = cls()
+        imports = ["import attrs"]  # attrs is included in imports in case we reference attrs.NOTHING
+        block = ""
+        source_code = inspect.getsource(module)
+        local_functions = get_local_functions(module)
+        local_constants = get_local_constants(module)
+        for line in source_code.split("\n"):
+            if line.startswith("from") or line.startswith("import"):
+                if "(" in line:
+                    block = line
+                else:
+                    imports.append(line)
+            if ")" in line and block:
+                imports.append(block + line)
+                block = ""
+        # extract imported symbols from import statements
+        used_symbols = set()
+        for function_body in function_bodies:
+            # Strip comments from function body
+            function_body = re.sub(r"\s*#.*", "", function_body)
+            used_symbols.update(re.findall(r"\b(\w+)\b", function_body))
+        used_symbols -= set(cls.SYMBOLS_TO_IGNORE)
+        # Keep looping through local function source until all local functions and constants
+        # are added to the used symbols
+        new_symbols = True
+        while new_symbols:
+            new_symbols = False
+            for local_func in local_functions:
+                if (
+                    local_func.__name__ in used_symbols
+                    and local_func not in used.local_functions
+                ):
+                    used.local_functions.add(local_func)
+                    func_body = inspect.getsource(local_func)
+                    func_body = re.sub(r"\s*#.*", "", func_body)
+                    local_func_symbols = re.findall(r"\b(\w+)\b", func_body)
+                    used_symbols.update(local_func_symbols)
+                    new_symbols = True
+            for const_name, const_def in local_constants:
+                if (
+                    const_name in used_symbols
+                    and (const_name, const_def) not in used.constants
+                ):
+                    used.constants.add((const_name, const_def))
+                    const_def_symbols = re.findall(r"\b(\w+)\b", const_def)
+                    used_symbols.update(const_def_symbols)
+                    new_symbols = True
+        # functions to copy from a relative or nipype module into the output module
+        for stmt in imports:
+            stmt = stmt.replace("\n", "")
+            stmt = stmt.replace("(", "")
+            stmt = stmt.replace(")", "")
+            base_stmt, symbol_str = stmt.split("import ")
+            symbol_parts = re.split(r" *, *", symbol_str)
+            split_parts = [re.split(r" +as +", p) for p in symbol_parts]
+            used_parts = [p for p in split_parts if p[-1] in used_symbols]
+            if used_parts:
+                required_stmt = (
+                    base_stmt
+                    + "import "
+                    + ", ".join(" as ".join(p) for p in used_parts)
+                )
+                match = re.match(r"from ([\w\.]+)", base_stmt)
+                import_mod = match.group(1) if match else ""
+                if import_mod.startswith(".") or import_mod.startswith("nipype."):
+                    if import_mod.startswith("."):
+                        match = re.match(r"(\.*)(.*)", import_mod)
+                        mod_parts = module.__name__.split(".")
+                        nparents = len(match.group(1))
+                        if nparents:
+                            mod_parts = mod_parts[:-nparents]
+                        mod_name = ".".join(mod_parts)
+                        if match.group(2):
+                            mod_name += "." + match.group(2)
+                    elif import_mod.startswith("nipype."):
+                        mod_name = import_mod
+                    else:
+                        assert False
+                    mod = import_module(mod_name)
+                    mod_func_bodies = []
+                    for used_part in used_parts:
+                        func = getattr(mod, used_part[0])
+                        if inspect.isfunction(func):
+                            used.funcs_to_include.add((used_part[-1], func))
+                            mod_func_bodies.append(inspect.getsource(func))
+                    # Recursively include neighbouring objects imported in the module
+                    used_in_mod = cls.find(
+                        mod,
+                        function_bodies=mod_func_bodies,
+                    )
+                    used.update(used_in_mod)
+                else:
+                    used.imports.add(required_stmt)
+        return used
+
+    SYMBOLS_TO_IGNORE = ["isdefined", "LOGGER"]
+
+
+def get_local_functions(mod):
+    """Get the functions defined in the module"""
+    functions = []
+    for attr_name in dir(mod):
+        attr = getattr(mod, attr_name)
+        if inspect.isfunction(attr) and attr.__module__ == mod.__name__:
+            functions.append(attr)
+    return functions
+
+
+def get_local_constants(mod):
+    """
+    Get the constants defined in the module
+    """
+    source_code = inspect.getsource(mod)
+    parts = re.split(r"^(\w+) *= *", source_code, flags=re.MULTILINE)
+    local_vars = []
+    for attr_name, following in zip(parts[1::2], parts[2::2]):
+        if "(" in following.splitlines()[0]:
+            pre, args, _ = split_parens_contents(following)
+            local_vars.append((attr_name, pre + re.sub(r"\n *", "", args) + ")"))
+        elif "[" in following.splitlines()[0]:
+            pre, args, _ = split_parens_contents(following, brackets=True)
+            local_vars.append((attr_name, pre + re.sub(r"\n *", "", args) + "]"))
+        else:
+            local_vars.append((attr_name, following.splitlines()[0]))
+    return local_vars
+
+
+def cleanup_function_body(
+    function_body: str, with_signature: bool = False
+) -> str:
+    """Ensure 4-space indentation, replace LOGGER with logger, and replace isdefined
+    with the attrs.NOTHING constant
+
+    Parameters
+    ----------
+    function_body: str
+        The source code of the function to process
+    with_signature: bool, optional
+        whether the function signature is included in the source code, by default False
+
+    Returns
+    -------
+    function_body: str
+        The processed source code
+    """
+    # Detect the indentation of the source code in src and reduce it to 4 spaces
+    indents = re.findall(r"^ *(?=[^\n])", function_body, flags=re.MULTILINE)
+    min_indent = min(len(i) for i in indents) if indents else 0
+    indent_reduction = min_indent - (0 if with_signature else 4)
+    assert indent_reduction >= 0, (
+        "Indentation reduction cannot be negative, probably need to set "
+        "'with_signature' to True"
+    )
+    if indent_reduction:
+        function_body = re.sub(
+            r"^" + " " * indent_reduction, "", function_body, flags=re.MULTILINE
+        )
+    # Other misc replacements
+    function_body = function_body.replace("LOGGER.", "logger.")
+    function_body = re.sub(
+        r"not isdefined\(([a-zA-Z0-9\_\.]+)\)", r"\1 is attrs.NOTHING", function_body, flags=re.MULTILINE
+    )
+    function_body = re.sub(
+        r"isdefined\(([a-zA-Z0-9\_\.]+)\)", r"\1 is not attrs.NOTHING", function_body, flags=re.MULTILINE
+    )
+    return function_body
+
+
+def insert_args_in_signature(snippet: str, new_args: ty.Iterable[str]) -> str:
+    """Insert the arguments into a function signature
+
+    Parameters
+    ----------
+    snippet: str
+        the function signature to modify
+    new_args: list[str]
+        the arguments to insert into the signature
+
+    Returns
+    -------
+    str
+        the modified function signature
+    """
+    # Split out the argstring from the rest of the code snippet
+    pre, argstr, post = split_parens_contents(snippet)
+    if argstr:
+        args = re.split(r" *, *", argstr)
+        if "runtime" in args:
+            args.remove("runtime")
+    else:
+        args = []
+    return pre + ", ".join(args + new_args) + post
diff --git a/scripts/pkg_gen/create_packages.py b/scripts/pkg_gen/create_packages.py
index 0fc75e76..5652ab2a 100644
--- a/scripts/pkg_gen/create_packages.py
+++ b/scripts/pkg_gen/create_packages.py
@@ -15,6 +15,7 @@
 import requests
 import click
 import yaml
+import black.parsing
 import fileformats.core.utils
 import fileformats.core.mixin
 from fileformats.generic import File, Directory
@@ -29,7 +30,13 @@
     TestGenerator,
     DocTestGenerator,
 )
-from nipype2pydra.utils import to_snake_case
+from nipype2pydra.utils import (
+    to_snake_case,
+    UsedSymbols,
+    split_parens_contents,
+    cleanup_function_body,
+    insert_args_in_signature,
+)
 
 
 RESOURCES_DIR = Path(__file__).parent / "resources"
@@ -450,21 +457,31 @@ def type2str(tp):
 
                 with open(spec_dir / (spec_name + ".yaml"), "w") as f:
                     f.write(preamble + yaml_str)
-                with open(callables_fspath, "w") as f:
-                    f.write(
-                        f'"""Module to put any functions that are referred to in {interface}.yaml"""\n'
-                    )
-                    if callables:
-                        f.write(
-                            "\n"
-                            + convert_gen_filename_to_func(nipype_interface)
-                            + "\n\n"
+                callables_str = (
+                    f'"""Module to put any functions that are referred to in '
+                    f'{interface}.yaml"""\n\n'
+                )
+                if callables:
+                    funcs, imports, consts = get_gen_filename_to_funcs(nipype_interface)
+                    callables_str += "\n".join(imports) + "\n\n"
+                    for const in consts:
+                        callables_str += f"{const[0]} = {const[1]}\n" + "\n\n"
+                    callables_str += "\n\n".join(funcs) + "\n\n"
+                    for name in callables:
+                        callables_str += (
+                            f"def {name}_callable(output_dir, inputs, stdout, stderr):\n"
+                            f'    return _gen_filename("{name}", output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr)\n\n'
                         )
-                        for name, val in callables.items():
-                            f.write(
-                                f"def {name}_callable(output_dir, inputs, stdout, stderr):\n"
-                                f'return _gen_filename("{name}", inputs)\n\n'
-                            )
+                    try:
+                        callables_str = black.format_file_contents(
+                            callables_str, fast=False, mode=black.FileMode()
+                        )
+                    except black.parsing.InvalidInput as e:
+                        raise RuntimeError(
+                            f"Black could not parse generated code: {e}\n\n{callables_str}"
+                        )
+                with open(callables_fspath, "w") as f:
+                    f.write(callables_str)
 
         with open(
             pkg_dir
@@ -859,12 +876,102 @@ def gen_sample_{frmt.lower()}_data({frmt.lower()}: {frmt}, dest_dir: Path, seed:
     return code_str
 
 
-def convert_gen_filename_to_func(nipype_interface) -> ty.Tuple[str, str]:
-    src = inspect.getsource(nipype_interface._gen_filename)
-    body = "\n" + src.split("\n", 1)[1]
-    body = body.replace("self.inputs", "inputs")
-    body = body.replace("\n        ", "\n    ")
-    return "def _gen_filename(name, inputs):" + body
+def get_gen_filename_to_funcs(
+    nipype_interface,
+) -> ty.Tuple[ty.List[str], ty.Set[str], ty.Set[ty.Tuple[str, str]]]:
+    """
+    Convert the _gen_filename method of a nipype interface into a function that can be
+    imported and used by the auto-convert scripts
+
+    Parameters
+    ----------
+    nipype_interface : type
+        the nipype interface to convert
+
+    Returns
+    -------
+    list[str]
+        the source code of functions to be added to the callables
+    set[str]
+        the imports required for the function
+    set[tuple[str, str]]
+        the external constants required by the function, as (name, value) tuples
+    """
+
+    IMPLICIT_ARGS = ["inputs", "stdout", "stderr", "output_dir"]
+
+    def find_nested_methods(method: ty.Callable) -> ty.List[str]:
+        all_nested = set()
+        for match in re.findall(r"self\.(\w+)\(", inspect.getsource(method)):
+            nested = getattr(nipype_interface, match)
+            all_nested.add(nested)
+            all_nested.update(find_nested_methods(nested))
+        return all_nested
+
+    def process_method(method: ty.Callable) -> str:
+        src = inspect.getsource(method)
+        prefix, args_str, body = split_parens_contents(src)
+        body = insert_args_in_method_calls(body, [f"{a}={a}" for a in IMPLICIT_ARGS])
+        body = body.replace("self.cmd", f'"{nipype_interface._cmd}"')
+        body = body.replace("self.", "")
+        body = re.sub(r"\w+runtime\.(stdout|stderr)", r"\1", body)
+        body = body.replace("os.getcwd()", "output_dir")
+        # drop 'self' from the args and add the implicit callable args
+        args = args_str.split(",")[1:]
+        arg_names = [a.split("=")[0].split(":")[0] for a in args]
+        for implicit in IMPLICIT_ARGS:
+            if implicit not in arg_names:
+                args.append(f"{implicit}=None")
+        src = prefix + ", ".join(args) + body
+        src = cleanup_function_body(src, with_signature=True)
+        return src
+
+    def insert_args_in_method_calls(src: str, args: ty.List[ty.Tuple[str, str]]) -> str:
+        """Insert additional arguments into the method calls
+
+        Parameters
+        ----------
+        body : str
+            the body of th
+        args : list[tuple[str, str]]
+            the arguments to insert into the method calls
+        """
+        # Split the src code into chunks delimited by calls to methods (i.e. 'self.<method>(.*)')
+        method_re = re.compile(r"self\.(\w+)(?=\()", flags=re.MULTILINE | re.DOTALL)
+        splits = method_re.split(src)
+        new_src = splits[0]
+        # Iterate through these chunks and add the additional args to the method calls
+        # using insert_args_in_signature function
+        for name, sig in zip(splits[1::2], splits[2::2]):
+            new_src += name + insert_args_in_signature(sig, args)
+        return new_src
+
+    func_srcs = [
+        process_method(m)
+        for m in (
+            [nipype_interface._gen_filename]
+            + list(find_nested_methods(nipype_interface._gen_filename))
+        )
+    ]
+
+    mod = import_module(nipype_interface.__module__)
+    used = UsedSymbols.find(mod, func_srcs)
+    for func in used.local_functions:
+        func_srcs.append(cleanup_function_body(inspect.getsource(func), with_signature=True))
+    for new_func_name, func in used.funcs_to_include:
+        func_src = inspect.getsource(func)
+        match = re.match(
+            r" *(def|class) *" + func.__name__ + r"(?=\()(.*)$",
+            func_src,
+            re.DOTALL | re.MULTILINE,
+        )
+        func_src = match.group(1) + " " + new_func_name + match.group(2)
+        func_srcs.append(cleanup_function_body(func_src, with_signature=True))
+    return (
+        func_srcs,
+        used.imports,
+        used.constants,
+    )
 
 
 if __name__ == "__main__":
diff --git a/scripts/pkg_gen/fsl-filmgls-only.yaml b/scripts/pkg_gen/fsl-filmgls-only.yaml
index 6aca6a26..73eb8b2a 100644
--- a/scripts/pkg_gen/fsl-filmgls-only.yaml
+++ b/scripts/pkg_gen/fsl-filmgls-only.yaml
@@ -2,5 +2,5 @@ packages:
 - fsl
 interfaces:
   fsl:
-  - FILMGLS
+  - EPIDeWarp
   
\ No newline at end of file

From 9de519ce469303cf85e3df9d23cc9723974fb68a Mon Sep 17 00:00:00 2001
From: Tom Close <tom.g.close@gmail.com>
Date: Thu, 7 Mar 2024 09:06:50 +1100
Subject: [PATCH 51/78] explicitly mark output files as type path, generate
 more callables

---
 .../task/nipype/afni/center_mass.yaml         |   2 +-
 example-specs/task/nipype/afni/dot.yaml       |   2 +-
 .../task/nipype/afni/one_d_tool_py.yaml       |   2 +-
 example-specs/task/nipype/afni/qwarp.yaml     |   2 +-
 .../task/nipype/afni/qwarp_plus_minus.yaml    |   2 +-
 .../task/nipype/afni/t_cat_sub_brick.yaml     |   3 +
 .../task/nipype/afni/t_corr_map.yaml          |   2 +-
 example-specs/task/nipype/ants/atropos.yaml   |   4 +-
 .../task/nipype/ants/atropos_callables.py     |  72 ++++++++++
 .../ants/warp_image_multi_transform.yaml      |   3 +
 .../freesurfer/apply_vol_transform.yaml       |   3 +
 .../task/nipype/freesurfer/bb_register.yaml   |   3 +
 .../task/nipype/freesurfer/binarize.yaml      |   3 +
 .../task/nipype/freesurfer/ca_register.yaml   |   3 +
 .../task/nipype/freesurfer/concatenate.yaml   |   3 +
 .../task/nipype/freesurfer/fit_ms_params.yaml |   6 +-
 .../freesurfer/fit_ms_params_callables.py     |  12 ++
 .../task/nipype/freesurfer/label_2_vol.yaml   |   3 +
 .../task/nipype/freesurfer/mr_is_combine.yaml |   3 +
 .../task/nipype/freesurfer/mr_is_convert.yaml |   6 +-
 .../freesurfer/mr_is_convert_callables.py     |  90 +++++++++++++
 .../task/nipype/freesurfer/mri_convert.yaml   |  13 +-
 .../freesurfer/mri_convert_callables.py       | 124 ++++++++++++++++++
 .../nipype/freesurfer/mri_marching_cubes.yaml |   6 +-
 .../mri_marching_cubes_callables.py           |  77 +++++++++++
 .../nipype/freesurfer/mri_tessellate.yaml     |   6 +-
 .../freesurfer/mri_tessellate_callables.py    |  76 +++++++++++
 .../task/nipype/freesurfer/mris_preproc.yaml  |   3 +
 .../freesurfer/mris_preproc_recon_all.yaml    |   3 +
 .../nipype/freesurfer/parcellation_stats.yaml |   6 +
 .../task/nipype/freesurfer/recon_all.yaml     |   3 +
 .../task/nipype/freesurfer/register.yaml      |   3 +
 .../task/nipype/freesurfer/resample.yaml      |   3 +
 .../nipype/freesurfer/sample_to_surface.yaml  |   3 +
 .../task/nipype/freesurfer/seg_stats.yaml     |   3 +
 .../freesurfer/seg_stats_recon_all.yaml       |   3 +
 .../task/nipype/freesurfer/smooth.yaml        |   3 +
 .../freesurfer/smooth_tessellation.yaml       |   6 +-
 .../smooth_tessellation_callables.py          |  77 +++++++++++
 .../nipype/freesurfer/spherical_average.yaml  |   9 +-
 .../freesurfer/spherical_average_callables.py |  58 ++++++++
 .../nipype/freesurfer/surface_smooth.yaml     |   3 +
 .../nipype/freesurfer/surface_snapshots.yaml  |   6 +-
 .../freesurfer/surface_snapshots_callables.py |  12 ++
 .../nipype/freesurfer/surface_transform.yaml  |   3 +
 .../nipype/freesurfer/synthesize_flash.yaml   |   3 +
 example-specs/task/nipype/fsl/apply_mask.yaml |   3 +
 example-specs/task/nipype/fsl/apply_warp.yaml |   3 +
 example-specs/task/nipype/fsl/ar1_image.yaml  |   3 +
 example-specs/task/nipype/fsl/bet.yaml        |   3 +
 .../task/nipype/fsl/binary_maths.yaml         |   3 +
 .../task/nipype/fsl/change_data_type.yaml     |   3 +
 example-specs/task/nipype/fsl/complex.yaml    |  15 +++
 .../task/nipype/fsl/convert_xfm.yaml          |   3 +
 .../task/nipype/fsl/dilate_image.yaml         |   3 +
 .../task/nipype/fsl/distance_map.yaml         |   3 +
 .../task/nipype/fsl/dual_regression.yaml      |   3 +
 .../task/nipype/fsl/epi_de_warp_callables.py  | 101 +++++++-------
 .../task/nipype/fsl/erode_image.yaml          |   3 +
 .../task/nipype/fsl/extract_roi.yaml          |   3 +
 .../task/nipype/fsl/filter_regressor.yaml     |   3 +
 .../task/nipype/fsl/find_the_biggest.yaml     |   3 +
 example-specs/task/nipype/fsl/fnirt.yaml      |   6 +
 .../task/nipype/fsl/image_maths.yaml          |   3 +
 .../task/nipype/fsl/image_meants.yaml         |   3 +
 .../task/nipype/fsl/isotropic_smooth.yaml     |   3 +
 .../task/nipype/fsl/maths_command.yaml        |   3 +
 example-specs/task/nipype/fsl/max_image.yaml  |   3 +
 example-specs/task/nipype/fsl/maxn_image.yaml |   3 +
 example-specs/task/nipype/fsl/mcflirt.yaml    |   3 +
 example-specs/task/nipype/fsl/mean_image.yaml |   3 +
 .../task/nipype/fsl/median_image.yaml         |   3 +
 example-specs/task/nipype/fsl/melodic.yaml    |   3 +
 example-specs/task/nipype/fsl/min_image.yaml  |   3 +
 .../task/nipype/fsl/multi_image_maths.yaml    |   3 +
 example-specs/task/nipype/fsl/overlay.yaml    |   3 +
 .../task/nipype/fsl/percentile_image.yaml     |   3 +
 .../task/nipype/fsl/plot_motion_params.yaml   |   3 +
 .../task/nipype/fsl/plot_time_series.yaml     |   3 +
 .../task/nipype/fsl/power_spectrum.yaml       |   3 +
 example-specs/task/nipype/fsl/prelude.yaml    |   3 +
 .../task/nipype/fsl/prob_track_x.yaml         |   4 +-
 .../task/nipype/fsl/prob_track_x2.yaml        |   4 +-
 .../nipype/fsl/prob_track_x2_callables.py     |  16 +++
 .../task/nipype/fsl/prob_track_x_callables.py |  18 ++-
 .../task/nipype/fsl/reorient_2_std.yaml       |   3 +
 example-specs/task/nipype/fsl/sig_loss.yaml   |   3 +
 .../task/nipype/fsl/slice_timer.yaml          |   6 +-
 .../task/nipype/fsl/slice_timer_callables.py  | 105 +++++++++++++++
 example-specs/task/nipype/fsl/slicer.yaml     |   3 +
 .../task/nipype/fsl/spatial_filter.yaml       |   3 +
 example-specs/task/nipype/fsl/std_image.yaml  |   3 +
 example-specs/task/nipype/fsl/susan.yaml      |   4 +-
 .../task/nipype/fsl/susan_callables.py        | 105 +++++++++++++++
 .../task/nipype/fsl/swap_dimensions.yaml      |   3 +
 .../task/nipype/fsl/temporal_filter.yaml      |   3 +
 example-specs/task/nipype/fsl/threshold.yaml  |   3 +
 .../task/nipype/fsl/unary_maths.yaml          |   3 +
 example-specs/task/nipype/fsl/vec_reg.yaml    |   3 +
 scripts/pkg_gen/create_packages.py            |  83 ++++++++----
 100 files changed, 1223 insertions(+), 111 deletions(-)

diff --git a/example-specs/task/nipype/afni/center_mass.yaml b/example-specs/task/nipype/afni/center_mass.yaml
index ebc25f65..84cead7a 100644
--- a/example-specs/task/nipype/afni/center_mass.yaml
+++ b/example-specs/task/nipype/afni/center_mass.yaml
@@ -88,7 +88,7 @@ tests:
     automask:
     # type=bool|default=False: Generate the mask automatically
     set_cm:
-    # type=tuple|default=(<traits.trait_types.Float object at 0x112056650>, <traits.trait_types.Float object at 0x112056750>, <traits.trait_types.Float object at 0x1120567d0>): After computing the center of mass, set the origin fields in the header so that the center of mass will be at (x,y,z) in DICOM coords.
+    # type=tuple|default=(<traits.trait_types.Float object at 0x1080a8c90>, <traits.trait_types.Float object at 0x1080a8d90>, <traits.trait_types.Float object at 0x1080a8e10>): After computing the center of mass, set the origin fields in the header so that the center of mass will be at (x,y,z) in DICOM coords.
     local_ijk:
     # type=bool|default=False: Output values as (i,j,k) in local orientation
     roi_vals:
diff --git a/example-specs/task/nipype/afni/dot.yaml b/example-specs/task/nipype/afni/dot.yaml
index 51a571a4..0e652a6b 100644
--- a/example-specs/task/nipype/afni/dot.yaml
+++ b/example-specs/task/nipype/afni/dot.yaml
@@ -82,7 +82,7 @@ tests:
     mask:
     # type=file|default=<undefined>: Use this dataset as a mask
     mrange:
-    # type=tuple|default=(<traits.trait_types.Float object at 0x112060e50>, <traits.trait_types.Float object at 0x112060d50>): Means to further restrict the voxels from 'mset' so thatonly those mask values within this range (inclusive) willbe used.
+    # type=tuple|default=(<traits.trait_types.Float object at 0x1080ab410>, <traits.trait_types.Float object at 0x1080ab310>): Means to further restrict the voxels from 'mset' so thatonly those mask values within this range (inclusive) willbe used.
     demean:
     # type=bool|default=False: Remove the mean from each volume prior to computing the correlation
     docor:
diff --git a/example-specs/task/nipype/afni/one_d_tool_py.yaml b/example-specs/task/nipype/afni/one_d_tool_py.yaml
index 4f6c26ae..0028d6ba 100644
--- a/example-specs/task/nipype/afni/one_d_tool_py.yaml
+++ b/example-specs/task/nipype/afni/one_d_tool_py.yaml
@@ -79,7 +79,7 @@ tests:
     show_censor_count:
     # type=bool|default=False: display the total number of censored TRs  Note : if input is a valid xmat.1D dataset, then the count will come from the header.  Otherwise the input is assumed to be a binary censorfile, and zeros are simply counted.
     censor_motion:
-    # type=tuple|default=(<traits.trait_types.Float object at 0x11208d110>, <nipype.interfaces.base.traits_extension.File object at 0x11208d1d0>): Tuple of motion limit and outfile prefix. need to also set set_nruns -r set_run_lengths
+    # type=tuple|default=(<traits.trait_types.Float object at 0x1080d3510>, <nipype.interfaces.base.traits_extension.File object at 0x1080d35d0>): Tuple of motion limit and outfile prefix. need to also set set_nruns -r set_run_lengths
     censor_prev_TR:
     # type=bool|default=False: for each censored TR, also censor previous
     show_trs_uncensored:
diff --git a/example-specs/task/nipype/afni/qwarp.yaml b/example-specs/task/nipype/afni/qwarp.yaml
index a5d4e9f4..d53446be 100644
--- a/example-specs/task/nipype/afni/qwarp.yaml
+++ b/example-specs/task/nipype/afni/qwarp.yaml
@@ -190,7 +190,7 @@ tests:
     wball:
     # type=list|default=[]: "``-wball x y z r f`` Enhance automatic weight from '-useweight' by a factor of 1+f\*Gaussian(FWHM=r) centered in the base image at DICOM coordinates (x,y,z) and with radius 'r'. The goal of this option is to try and make the alignment better in a specific part of the brain. Example:  -wball 0 14 6 30 40 to emphasize the thalamic area (in MNI/Talairach space).  * The 'r' parameter must be positive! * The 'f' parameter must be between 1 and 100 (inclusive). * '-wball' does nothing if you input your own weight   with the '-weight' option. * '-wball' does change the binary weight created by   the '-noweight' option. * You can only use '-wball' once in a run of 3dQwarp.  **The effect of '-wball' is not dramatic.** The example above makes the average brain image across a collection of subjects a little sharper in the thalamic area, which might have some small value.  If you care enough about alignment to use '-wball', then you should examine the results from 3dQwarp for each subject, to see if the alignments are good enough for your purposes.
     wmask:
-    # type=tuple|default=(<nipype.interfaces.base.traits_extension.File object at 0x111f91150>, <traits.trait_types.Float object at 0x111f91310>): Similar to '-wball', but here, you provide a dataset 'ws' that indicates where to increase the weight.  * The 'ws' dataset must be on the same 3D grid as the base dataset. * 'ws' is treated as a mask -- it only matters where it   is nonzero -- otherwise, the values inside are not used. * After 'ws' comes the factor 'f' by which to increase the   automatically computed weight.  Where 'ws' is nonzero,   the weighting will be multiplied by (1+f). * As with '-wball', the factor 'f' should be between 1 and 100.  
+    # type=tuple|default=(<nipype.interfaces.base.traits_extension.File object at 0x107fd7b50>, <traits.trait_types.Float object at 0x107fd7d10>): Similar to '-wball', but here, you provide a dataset 'ws' that indicates where to increase the weight.  * The 'ws' dataset must be on the same 3D grid as the base dataset. * 'ws' is treated as a mask -- it only matters where it   is nonzero -- otherwise, the values inside are not used. * After 'ws' comes the factor 'f' by which to increase the   automatically computed weight.  Where 'ws' is nonzero,   the weighting will be multiplied by (1+f). * As with '-wball', the factor 'f' should be between 1 and 100.  
     out_weight_file:
     # type=file|default=<undefined>: Write the weight volume to disk as a dataset
     blur:
diff --git a/example-specs/task/nipype/afni/qwarp_plus_minus.yaml b/example-specs/task/nipype/afni/qwarp_plus_minus.yaml
index 7de9641c..3d0e5218 100644
--- a/example-specs/task/nipype/afni/qwarp_plus_minus.yaml
+++ b/example-specs/task/nipype/afni/qwarp_plus_minus.yaml
@@ -126,7 +126,7 @@ tests:
     wball:
     # type=list|default=[]: "``-wball x y z r f`` Enhance automatic weight from '-useweight' by a factor of 1+f\*Gaussian(FWHM=r) centered in the base image at DICOM coordinates (x,y,z) and with radius 'r'. The goal of this option is to try and make the alignment better in a specific part of the brain. Example:  -wball 0 14 6 30 40 to emphasize the thalamic area (in MNI/Talairach space).  * The 'r' parameter must be positive! * The 'f' parameter must be between 1 and 100 (inclusive). * '-wball' does nothing if you input your own weight   with the '-weight' option. * '-wball' does change the binary weight created by   the '-noweight' option. * You can only use '-wball' once in a run of 3dQwarp.  **The effect of '-wball' is not dramatic.** The example above makes the average brain image across a collection of subjects a little sharper in the thalamic area, which might have some small value.  If you care enough about alignment to use '-wball', then you should examine the results from 3dQwarp for each subject, to see if the alignments are good enough for your purposes.
     wmask:
-    # type=tuple|default=(<nipype.interfaces.base.traits_extension.File object at 0x111f91150>, <traits.trait_types.Float object at 0x111f91310>): Similar to '-wball', but here, you provide a dataset 'ws' that indicates where to increase the weight.  * The 'ws' dataset must be on the same 3D grid as the base dataset. * 'ws' is treated as a mask -- it only matters where it   is nonzero -- otherwise, the values inside are not used. * After 'ws' comes the factor 'f' by which to increase the   automatically computed weight.  Where 'ws' is nonzero,   the weighting will be multiplied by (1+f). * As with '-wball', the factor 'f' should be between 1 and 100.  
+    # type=tuple|default=(<nipype.interfaces.base.traits_extension.File object at 0x107fd7b50>, <traits.trait_types.Float object at 0x107fd7d10>): Similar to '-wball', but here, you provide a dataset 'ws' that indicates where to increase the weight.  * The 'ws' dataset must be on the same 3D grid as the base dataset. * 'ws' is treated as a mask -- it only matters where it   is nonzero -- otherwise, the values inside are not used. * After 'ws' comes the factor 'f' by which to increase the   automatically computed weight.  Where 'ws' is nonzero,   the weighting will be multiplied by (1+f). * As with '-wball', the factor 'f' should be between 1 and 100.  
     out_weight_file:
     # type=file|default=<undefined>: Write the weight volume to disk as a dataset
     blur:
diff --git a/example-specs/task/nipype/afni/t_cat_sub_brick.yaml b/example-specs/task/nipype/afni/t_cat_sub_brick.yaml
index 2da55a99..4ab0216b 100644
--- a/example-specs/task/nipype/afni/t_cat_sub_brick.yaml
+++ b/example-specs/task/nipype/afni/t_cat_sub_brick.yaml
@@ -37,6 +37,9 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    out_file: Path
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/t_corr_map.yaml b/example-specs/task/nipype/afni/t_corr_map.yaml
index 114b2193..f8f72ef4 100644
--- a/example-specs/task/nipype/afni/t_corr_map.yaml
+++ b/example-specs/task/nipype/afni/t_corr_map.yaml
@@ -161,7 +161,7 @@ tests:
     polort:
     # type=int|default=0: 
     bandpass:
-    # type=tuple|default=(<traits.trait_types.Float object at 0x111f72f50>, <traits.trait_types.Float object at 0x111f72fd0>): 
+    # type=tuple|default=(<traits.trait_types.Float object at 0x107f6fc90>, <traits.trait_types.Float object at 0x107f6e810>): 
     regress_out_timeseries:
     # type=file|default=<undefined>: 
     blur_fwhm:
diff --git a/example-specs/task/nipype/ants/atropos.yaml b/example-specs/task/nipype/ants/atropos.yaml
index f573fdb4..a7665fee 100644
--- a/example-specs/task/nipype/ants/atropos.yaml
+++ b/example-specs/task/nipype/ants/atropos.yaml
@@ -100,7 +100,7 @@ inputs:
     # type=inputmultiobject|default=[]: 
     mask_image: medimage/nifti1
     # type=file|default=<undefined>: 
-    out_classified_image_name: generic/file
+    out_classified_image_name: Path
     # type=file|default=<undefined>: 
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
@@ -120,6 +120,8 @@ outputs:
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
+    out_classified_image_name: out_classified_image_name_callable
+    # type=file|default=<undefined>: 
   templates:
   # dict[str, str] - `output_file_template` values to be provided to output fields
   requirements:
diff --git a/example-specs/task/nipype/ants/atropos_callables.py b/example-specs/task/nipype/ants/atropos_callables.py
index 93f87cd6..53553f2e 100644
--- a/example-specs/task/nipype/ants/atropos_callables.py
+++ b/example-specs/task/nipype/ants/atropos_callables.py
@@ -1 +1,73 @@
 """Module to put any functions that are referred to in Atropos.yaml"""
+
+import os.path as op
+import attrs
+
+
+def out_classified_image_name_callable(output_dir, inputs, stdout, stderr):
+    return _gen_filename(
+        "out_classified_image_name",
+        output_dir=output_dir,
+        inputs=inputs,
+        stdout=stdout,
+        stderr=stderr,
+    )
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_classified_image_name":
+        output = inputs.out_classified_image_name
+        if output is attrs.NOTHING:
+            _, name, ext = split_filename(inputs.intensity_images[0])
+            output = name + "_labeled" + ext
+        return output
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
diff --git a/example-specs/task/nipype/ants/warp_image_multi_transform.yaml b/example-specs/task/nipype/ants/warp_image_multi_transform.yaml
index 82206b42..e0e64984 100644
--- a/example-specs/task/nipype/ants/warp_image_multi_transform.yaml
+++ b/example-specs/task/nipype/ants/warp_image_multi_transform.yaml
@@ -49,6 +49,9 @@ inputs:
     # type=file|default=<undefined>: reference image space that you wish to warp INTO
     transformation_series: '[text/text-file,medimage/nifti-gz]+list-of'
     # type=inputmultiobject|default=[]: transformation file(s) to be applied
+    output_image: Path
+    # type=file: Warped image
+    # type=file|default=<undefined>: name of the output warped image
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/apply_vol_transform.yaml b/example-specs/task/nipype/freesurfer/apply_vol_transform.yaml
index 2e560829..37d36c4b 100644
--- a/example-specs/task/nipype/freesurfer/apply_vol_transform.yaml
+++ b/example-specs/task/nipype/freesurfer/apply_vol_transform.yaml
@@ -52,6 +52,9 @@ inputs:
     # type=file|default=<undefined>: This is the morph to be applied to the volume. Unless the morph is in mri/transforms (eg.: for talairach.m3z computed by reconall), you will need to specify the full path to this morph and use the --noDefM3zPath flag.
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+    transformed_file: Path
+    # type=file: Path to output file if used normally
+    # type=file|default=<undefined>: Output volume
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/bb_register.yaml b/example-specs/task/nipype/freesurfer/bb_register.yaml
index 7c1097a9..e3f4acc9 100644
--- a/example-specs/task/nipype/freesurfer/bb_register.yaml
+++ b/example-specs/task/nipype/freesurfer/bb_register.yaml
@@ -42,6 +42,9 @@ inputs:
     # type=file|default=<undefined>: Intermediate image, e.g. in case of partial FOV
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+    out_reg_file: Path
+    # type=file: Output registration file
+    # type=file|default=<undefined>: output registration file
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/binarize.yaml b/example-specs/task/nipype/freesurfer/binarize.yaml
index 00051fd3..f48c24c3 100644
--- a/example-specs/task/nipype/freesurfer/binarize.yaml
+++ b/example-specs/task/nipype/freesurfer/binarize.yaml
@@ -36,6 +36,9 @@ inputs:
     # type=file|default=<undefined>: must be within mask
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+    binary_file: Path
+    # type=file: binarized output volume
+    # type=file|default=<undefined>: binary output volume
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/ca_register.yaml b/example-specs/task/nipype/freesurfer/ca_register.yaml
index 7548fa0d..7147a9b2 100644
--- a/example-specs/task/nipype/freesurfer/ca_register.yaml
+++ b/example-specs/task/nipype/freesurfer/ca_register.yaml
@@ -48,6 +48,9 @@ inputs:
     # type=inputmultiobject|default=[]: undocumented flag used in longitudinal processing
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+    out_file: Path
+    # type=file: The output file for CARegister
+    # type=file|default=<undefined>: The output volume for CARegister
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/concatenate.yaml b/example-specs/task/nipype/freesurfer/concatenate.yaml
index bc54d2f4..5009f570 100644
--- a/example-specs/task/nipype/freesurfer/concatenate.yaml
+++ b/example-specs/task/nipype/freesurfer/concatenate.yaml
@@ -42,6 +42,9 @@ inputs:
     # type=file|default=<undefined>: Mask input with a volume
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+    concatenated_file: Path
+    # type=file: Path/name of the output volume
+    # type=file|default=<undefined>: Output volume
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/fit_ms_params.yaml b/example-specs/task/nipype/freesurfer/fit_ms_params.yaml
index d29e34df..1f89856c 100644
--- a/example-specs/task/nipype/freesurfer/fit_ms_params.yaml
+++ b/example-specs/task/nipype/freesurfer/fit_ms_params.yaml
@@ -35,10 +35,10 @@ inputs:
     # type=list|default=[]: list of FLASH images (must be in mgh format)
     xfm_list: generic/file+list-of
     # type=list|default=[]: list of transform files to apply to each FLASH image
-    out_dir: generic/directory
-    # type=directory|default=<undefined>: directory to store output in
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+    out_dir: Path
+    # type=directory|default=<undefined>: directory to store output in
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -61,6 +61,8 @@ outputs:
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
+    out_dir: out_dir_callable
+    # type=directory|default=<undefined>: directory to store output in
   templates:
   # dict[str, str] - `output_file_template` values to be provided to output fields
   requirements:
diff --git a/example-specs/task/nipype/freesurfer/fit_ms_params_callables.py b/example-specs/task/nipype/freesurfer/fit_ms_params_callables.py
index c37da7ee..6319b185 100644
--- a/example-specs/task/nipype/freesurfer/fit_ms_params_callables.py
+++ b/example-specs/task/nipype/freesurfer/fit_ms_params_callables.py
@@ -1 +1,13 @@
 """Module to put any functions that are referred to in FitMSParams.yaml"""
+
+
+def out_dir_callable(output_dir, inputs, stdout, stderr):
+    return _gen_filename(
+        "out_dir", output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_dir":
+        return output_dir
+    return None
diff --git a/example-specs/task/nipype/freesurfer/label_2_vol.yaml b/example-specs/task/nipype/freesurfer/label_2_vol.yaml
index 7a45d61f..e7ce0b18 100644
--- a/example-specs/task/nipype/freesurfer/label_2_vol.yaml
+++ b/example-specs/task/nipype/freesurfer/label_2_vol.yaml
@@ -46,6 +46,9 @@ inputs:
     # type=file|default=<undefined>: map the label stats field into the vol
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+    vol_label_file: Path
+    # type=file: output volume
+    # type=file|default=<undefined>: output volume
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/mr_is_combine.yaml b/example-specs/task/nipype/freesurfer/mr_is_combine.yaml
index 4cd7516c..57db2ac6 100644
--- a/example-specs/task/nipype/freesurfer/mr_is_combine.yaml
+++ b/example-specs/task/nipype/freesurfer/mr_is_combine.yaml
@@ -47,6 +47,9 @@ inputs:
     # type=list|default=[]: Two surfaces to be combined.
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+    out_file: Path
+    # type=file: Output filename. Combined surfaces from in_files.
+    # type=file|default=<undefined>: Output filename. Combined surfaces from in_files.
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/mr_is_convert.yaml b/example-specs/task/nipype/freesurfer/mr_is_convert.yaml
index 26e4e3ea..c6fb52ce 100644
--- a/example-specs/task/nipype/freesurfer/mr_is_convert.yaml
+++ b/example-specs/task/nipype/freesurfer/mr_is_convert.yaml
@@ -45,10 +45,10 @@ inputs:
     # type=file|default=<undefined>: outfile is name of gifti file to which label stats will be written
     in_file: generic/file
     # type=file|default=<undefined>: File to read/convert
-    out_file: generic/file
-    # type=file|default=<undefined>: output filename or True to generate one
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+    out_file: Path
+    # type=file|default=<undefined>: output filename or True to generate one
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -67,6 +67,8 @@ outputs:
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
+    out_file: out_file_callable
+    # type=file|default=<undefined>: output filename or True to generate one
   templates:
   # dict[str, str] - `output_file_template` values to be provided to output fields
   requirements:
diff --git a/example-specs/task/nipype/freesurfer/mr_is_convert_callables.py b/example-specs/task/nipype/freesurfer/mr_is_convert_callables.py
index 9d8dbbe5..d185fca0 100644
--- a/example-specs/task/nipype/freesurfer/mr_is_convert_callables.py
+++ b/example-specs/task/nipype/freesurfer/mr_is_convert_callables.py
@@ -1 +1,91 @@
 """Module to put any functions that are referred to in MRIsConvert.yaml"""
+
+import os.path as op
+import os
+import attrs
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    return _gen_filename(
+        "out_file", output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return os.path.abspath(
+            _gen_outfilename(
+                inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+        )
+    else:
+        return None
+
+
+def _gen_outfilename(inputs=None, stdout=None, stderr=None, output_dir=None):
+    if inputs.out_file is not attrs.NOTHING:
+        return inputs.out_file
+    elif inputs.annot_file is not attrs.NOTHING:
+        _, name, ext = split_filename(inputs.annot_file)
+    elif inputs.parcstats_file is not attrs.NOTHING:
+        _, name, ext = split_filename(inputs.parcstats_file)
+    elif inputs.label_file is not attrs.NOTHING:
+        _, name, ext = split_filename(inputs.label_file)
+    elif inputs.scalarcurv_file is not attrs.NOTHING:
+        _, name, ext = split_filename(inputs.scalarcurv_file)
+    elif inputs.functional_file is not attrs.NOTHING:
+        _, name, ext = split_filename(inputs.functional_file)
+    elif inputs.in_file is not attrs.NOTHING:
+        _, name, ext = split_filename(inputs.in_file)
+
+    return name + ext + "_converted." + inputs.out_datatype
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
diff --git a/example-specs/task/nipype/freesurfer/mri_convert.yaml b/example-specs/task/nipype/freesurfer/mri_convert.yaml
index 101efcc7..71333c7d 100644
--- a/example-specs/task/nipype/freesurfer/mri_convert.yaml
+++ b/example-specs/task/nipype/freesurfer/mri_convert.yaml
@@ -43,9 +43,6 @@ inputs:
     # type=file|default=<undefined>: apply inverse transformation xfm file
     in_file: medimage/nifti1
     # type=file|default=<undefined>: File to read/convert
-    out_file: medimage/mgh-gz
-    # type=outputmultiobject: converted output file
-    # type=file|default=<undefined>: output filename or True to generate one
     reslice_like: generic/file
     # type=file|default=<undefined>: reslice output to match file
     in_like: generic/file
@@ -58,6 +55,9 @@ inputs:
     # type=file|default=<undefined>: list of DICOM files for conversion
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+    out_file: Path
+    # type=outputmultiobject: converted output file
+    # type=file|default=<undefined>: output filename or True to generate one
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -74,6 +74,9 @@ outputs:
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
+    out_file: out_file_callable
+    # type=outputmultiobject: converted output file
+    # type=file|default=<undefined>: output filename or True to generate one
   templates:
   # dict[str, str] - `output_file_template` values to be provided to output fields
   requirements:
@@ -275,7 +278,7 @@ tests:
   # (if not specified, will try to choose a sensible value)
     in_file:
     # type=file|default=<undefined>: File to read/convert
-    out_file:
+    out_file: '"outfile.mgz"'
     # type=outputmultiobject: converted output file
     # type=file|default=<undefined>: output filename or True to generate one
     out_type: '"mgz"'
@@ -304,7 +307,7 @@ doctests:
   # '.mock()' method of the corresponding class is used instead.
     in_file:
     # type=file|default=<undefined>: File to read/convert
-    out_file:
+    out_file: '"outfile.mgz"'
     # type=outputmultiobject: converted output file
     # type=file|default=<undefined>: output filename or True to generate one
     out_type: '"mgz"'
diff --git a/example-specs/task/nipype/freesurfer/mri_convert_callables.py b/example-specs/task/nipype/freesurfer/mri_convert_callables.py
index 178c87a0..70cdd1b7 100644
--- a/example-specs/task/nipype/freesurfer/mri_convert_callables.py
+++ b/example-specs/task/nipype/freesurfer/mri_convert_callables.py
@@ -1 +1,125 @@
 """Module to put any functions that are referred to in MRIConvert.yaml"""
+
+import os.path as op
+import os
+from pathlib import Path
+import attrs
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    return _gen_filename(
+        "out_file", output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _get_outfilename(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )
+    return None
+
+
+def _get_outfilename(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outfile = inputs.out_file
+    if outfile is attrs.NOTHING:
+        if inputs.out_type is not attrs.NOTHING:
+            suffix = "_out." + filemap[inputs.out_type]
+        else:
+            suffix = "_out.nii.gz"
+        outfile = fname_presuffix(
+            inputs.in_file, newpath=output_dir, suffix=suffix, use_ext=False
+        )
+    return os.path.abspath(outfile)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import Undefined
+    >>> fname_presuffix(fname, 'pre', 'post', Undefined) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for isdefined: bool(Undefined) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
diff --git a/example-specs/task/nipype/freesurfer/mri_marching_cubes.yaml b/example-specs/task/nipype/freesurfer/mri_marching_cubes.yaml
index cff8645b..f0ce9ac5 100644
--- a/example-specs/task/nipype/freesurfer/mri_marching_cubes.yaml
+++ b/example-specs/task/nipype/freesurfer/mri_marching_cubes.yaml
@@ -34,10 +34,10 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: generic/file
     # type=file|default=<undefined>: Input volume to tessellate voxels from.
-    out_file: generic/file
-    # type=file|default=<undefined>: output filename or True to generate one
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+    out_file: Path
+    # type=file|default=<undefined>: output filename or True to generate one
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -56,6 +56,8 @@ outputs:
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
+    out_file: out_file_callable
+    # type=file|default=<undefined>: output filename or True to generate one
   templates:
   # dict[str, str] - `output_file_template` values to be provided to output fields
   requirements:
diff --git a/example-specs/task/nipype/freesurfer/mri_marching_cubes_callables.py b/example-specs/task/nipype/freesurfer/mri_marching_cubes_callables.py
index e598b7c1..d72c9c86 100644
--- a/example-specs/task/nipype/freesurfer/mri_marching_cubes_callables.py
+++ b/example-specs/task/nipype/freesurfer/mri_marching_cubes_callables.py
@@ -1 +1,78 @@
 """Module to put any functions that are referred to in MRIMarchingCubes.yaml"""
+
+import os.path as op
+import os
+import attrs
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    return _gen_filename(
+        "out_file", output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _gen_outfilename(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )
+    else:
+        return None
+
+
+def _gen_outfilename(inputs=None, stdout=None, stderr=None, output_dir=None):
+    if inputs.out_file is not attrs.NOTHING:
+        return os.path.abspath(inputs.out_file)
+    else:
+        _, name, ext = split_filename(inputs.in_file)
+        return os.path.abspath(name + ext + "_" + str(inputs.label_value))
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
diff --git a/example-specs/task/nipype/freesurfer/mri_tessellate.yaml b/example-specs/task/nipype/freesurfer/mri_tessellate.yaml
index a1720f1e..b600ce19 100644
--- a/example-specs/task/nipype/freesurfer/mri_tessellate.yaml
+++ b/example-specs/task/nipype/freesurfer/mri_tessellate.yaml
@@ -34,10 +34,10 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: generic/file
     # type=file|default=<undefined>: Input volume to tessellate voxels from.
-    out_file: generic/file
-    # type=file|default=<undefined>: output filename or True to generate one
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+    out_file: Path
+    # type=file|default=<undefined>: output filename or True to generate one
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -56,6 +56,8 @@ outputs:
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
+    out_file: out_file_callable
+    # type=file|default=<undefined>: output filename or True to generate one
   templates:
   # dict[str, str] - `output_file_template` values to be provided to output fields
   requirements:
diff --git a/example-specs/task/nipype/freesurfer/mri_tessellate_callables.py b/example-specs/task/nipype/freesurfer/mri_tessellate_callables.py
index f72b6b64..d7c68fb4 100644
--- a/example-specs/task/nipype/freesurfer/mri_tessellate_callables.py
+++ b/example-specs/task/nipype/freesurfer/mri_tessellate_callables.py
@@ -1 +1,77 @@
 """Module to put any functions that are referred to in MRITessellate.yaml"""
+
+import os.path as op
+import attrs
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    return _gen_filename(
+        "out_file", output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _gen_outfilename(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )
+    else:
+        return None
+
+
+def _gen_outfilename(inputs=None, stdout=None, stderr=None, output_dir=None):
+    if inputs.out_file is not attrs.NOTHING:
+        return inputs.out_file
+    else:
+        _, name, ext = split_filename(inputs.in_file)
+        return name + ext + "_" + str(inputs.label_value)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
diff --git a/example-specs/task/nipype/freesurfer/mris_preproc.yaml b/example-specs/task/nipype/freesurfer/mris_preproc.yaml
index 29cb0a1b..f8c57e1d 100644
--- a/example-specs/task/nipype/freesurfer/mris_preproc.yaml
+++ b/example-specs/task/nipype/freesurfer/mris_preproc.yaml
@@ -41,6 +41,9 @@ inputs:
     # type=inputmultiobject|default=[]: file alternative to surfmeas, still requires list of subjects
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+    out_file: Path
+    # type=file: preprocessed output file
+    # type=file|default=<undefined>: output filename
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/mris_preproc_recon_all.yaml b/example-specs/task/nipype/freesurfer/mris_preproc_recon_all.yaml
index 5d64bb62..4e249c3d 100644
--- a/example-specs/task/nipype/freesurfer/mris_preproc_recon_all.yaml
+++ b/example-specs/task/nipype/freesurfer/mris_preproc_recon_all.yaml
@@ -46,6 +46,9 @@ inputs:
     # type=file|default=<undefined>: file specifying subjects separated by white space
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+    out_file: Path
+    # type=file: preprocessed output file
+    # type=file|default=<undefined>: output filename
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/parcellation_stats.yaml b/example-specs/task/nipype/freesurfer/parcellation_stats.yaml
index a67d5dc4..2bd2b51f 100644
--- a/example-specs/task/nipype/freesurfer/parcellation_stats.yaml
+++ b/example-specs/task/nipype/freesurfer/parcellation_stats.yaml
@@ -75,6 +75,12 @@ inputs:
     # type=file|default=<undefined>: limit calculations to specified label
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+    out_table: Path
+    # type=file: Table output to tablefile
+    # type=file|default=<undefined>: Table output to tablefile
+    out_color: Path
+    # type=file: Output annotation files's colortable to text file
+    # type=file|default=<undefined>: Output annotation files's colortable to text file
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/recon_all.yaml b/example-specs/task/nipype/freesurfer/recon_all.yaml
index 7a1deafd..26b0c107 100644
--- a/example-specs/task/nipype/freesurfer/recon_all.yaml
+++ b/example-specs/task/nipype/freesurfer/recon_all.yaml
@@ -80,6 +80,9 @@ inputs:
     # type=file|default=<undefined>: Convert FLAIR image to orig directory
     expert: generic/file
     # type=file|default=<undefined>: Set parameters using expert file
+    subjects_dir: Path
+    # type=directory: Freesurfer subjects directory.
+    # type=directory|default=<undefined>: path to subjects directory
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/register.yaml b/example-specs/task/nipype/freesurfer/register.yaml
index 54e1af54..8e4e3880 100644
--- a/example-specs/task/nipype/freesurfer/register.yaml
+++ b/example-specs/task/nipype/freesurfer/register.yaml
@@ -44,6 +44,9 @@ inputs:
     # type=file|default=<undefined>: Undocumented input file ${SUBJECTS_DIR}/surf/{hemisphere}.smoothwm 
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+    out_file: Path
+    # type=file: Output surface file to capture registration
+    # type=file|default=<undefined>: Output surface file to capture registration
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/resample.yaml b/example-specs/task/nipype/freesurfer/resample.yaml
index 52180997..abbd0489 100644
--- a/example-specs/task/nipype/freesurfer/resample.yaml
+++ b/example-specs/task/nipype/freesurfer/resample.yaml
@@ -37,6 +37,9 @@ inputs:
     # type=file|default=<undefined>: file to resample
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+    resampled_file: Path
+    # type=file: output filename
+    # type=file|default=<undefined>: output filename
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/sample_to_surface.yaml b/example-specs/task/nipype/freesurfer/sample_to_surface.yaml
index 1a4a1290..ba0676ce 100644
--- a/example-specs/task/nipype/freesurfer/sample_to_surface.yaml
+++ b/example-specs/task/nipype/freesurfer/sample_to_surface.yaml
@@ -58,6 +58,9 @@ inputs:
     # type=file|default=<undefined>: label file to mask output with
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+    out_file: Path
+    # type=file: surface file
+    # type=file|default=<undefined>: surface file to write
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/seg_stats.yaml b/example-specs/task/nipype/freesurfer/seg_stats.yaml
index 5015d0be..69e6c2e1 100644
--- a/example-specs/task/nipype/freesurfer/seg_stats.yaml
+++ b/example-specs/task/nipype/freesurfer/seg_stats.yaml
@@ -52,6 +52,9 @@ inputs:
     # type=file|default=<undefined>: Undocumented input norm.mgz file
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+    summary_file: Path
+    # type=file: Segmentation summary statistics table
+    # type=file|default=<undefined>: Segmentation stats summary table file
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/seg_stats_recon_all.yaml b/example-specs/task/nipype/freesurfer/seg_stats_recon_all.yaml
index 0c69f5d6..327abb73 100644
--- a/example-specs/task/nipype/freesurfer/seg_stats_recon_all.yaml
+++ b/example-specs/task/nipype/freesurfer/seg_stats_recon_all.yaml
@@ -94,6 +94,9 @@ inputs:
     # type=file|default=<undefined>: Undocumented input norm.mgz file
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+    summary_file: Path
+    # type=file: Segmentation summary statistics table
+    # type=file|default=<undefined>: Segmentation stats summary table file
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/smooth.yaml b/example-specs/task/nipype/freesurfer/smooth.yaml
index 4dd8d6da..f32520a3 100644
--- a/example-specs/task/nipype/freesurfer/smooth.yaml
+++ b/example-specs/task/nipype/freesurfer/smooth.yaml
@@ -45,6 +45,9 @@ inputs:
     # type=file|default=<undefined>: registers volume to surface anatomical 
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+    smoothed_file: Path
+    # type=file: smoothed input volume
+    # type=file|default=<undefined>: output volume
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/smooth_tessellation.yaml b/example-specs/task/nipype/freesurfer/smooth_tessellation.yaml
index 74b19c87..3ad97d1a 100644
--- a/example-specs/task/nipype/freesurfer/smooth_tessellation.yaml
+++ b/example-specs/task/nipype/freesurfer/smooth_tessellation.yaml
@@ -37,14 +37,14 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: generic/file
     # type=file|default=<undefined>: Input volume to tessellate voxels from.
-    out_file: generic/file
-    # type=file|default=<undefined>: output filename or True to generate one
     out_curvature_file: generic/file
     # type=file|default=<undefined>: Write curvature to ``?h.curvname`` (default "curv")
     out_area_file: generic/file
     # type=file|default=<undefined>: Write area to ``?h.areaname`` (default "area")
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+    out_file: Path
+    # type=file|default=<undefined>: output filename or True to generate one
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -63,6 +63,8 @@ outputs:
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
+    out_file: out_file_callable
+    # type=file|default=<undefined>: output filename or True to generate one
   templates:
   # dict[str, str] - `output_file_template` values to be provided to output fields
   requirements:
diff --git a/example-specs/task/nipype/freesurfer/smooth_tessellation_callables.py b/example-specs/task/nipype/freesurfer/smooth_tessellation_callables.py
index fba09942..bf64a0ec 100644
--- a/example-specs/task/nipype/freesurfer/smooth_tessellation_callables.py
+++ b/example-specs/task/nipype/freesurfer/smooth_tessellation_callables.py
@@ -1 +1,78 @@
 """Module to put any functions that are referred to in SmoothTessellation.yaml"""
+
+import os.path as op
+import os
+import attrs
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    return _gen_filename(
+        "out_file", output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _gen_outfilename(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )
+    else:
+        return None
+
+
+def _gen_outfilename(inputs=None, stdout=None, stderr=None, output_dir=None):
+    if inputs.out_file is not attrs.NOTHING:
+        return os.path.abspath(inputs.out_file)
+    else:
+        _, name, ext = split_filename(inputs.in_file)
+        return os.path.abspath(name + "_smoothed" + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
diff --git a/example-specs/task/nipype/freesurfer/spherical_average.yaml b/example-specs/task/nipype/freesurfer/spherical_average.yaml
index 3eb78b29..07d2ed9c 100644
--- a/example-specs/task/nipype/freesurfer/spherical_average.yaml
+++ b/example-specs/task/nipype/freesurfer/spherical_average.yaml
@@ -43,10 +43,13 @@ inputs:
     # type=file|default=<undefined>: Input surface file
     in_orig: generic/file
     # type=file|default=<undefined>: Original surface filename
-    in_average: generic/directory
-    # type=directory|default=<undefined>: Average subject
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+    out_file: Path
+    # type=file: Output label
+    # type=file|default=<undefined>: Output filename
+    in_average: Path
+    # type=directory|default=<undefined>: Average subject
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -66,6 +69,8 @@ outputs:
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
+    in_average: in_average_callable
+    # type=directory|default=<undefined>: Average subject
   templates:
   # dict[str, str] - `output_file_template` values to be provided to output fields
     out_file: '"test.out"'
diff --git a/example-specs/task/nipype/freesurfer/spherical_average_callables.py b/example-specs/task/nipype/freesurfer/spherical_average_callables.py
index c5d3dc57..1ec52618 100644
--- a/example-specs/task/nipype/freesurfer/spherical_average_callables.py
+++ b/example-specs/task/nipype/freesurfer/spherical_average_callables.py
@@ -1 +1,59 @@
 """Module to put any functions that are referred to in SphericalAverage.yaml"""
+
+import os
+import attrs
+
+
+def in_average_callable(output_dir, inputs, stdout, stderr):
+    return _gen_filename(
+        "in_average", output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "in_average":
+        avg_subject = str(inputs.hemisphere) + ".EC_average"
+        avg_directory = os.path.join(inputs.subjects_dir, avg_subject)
+        if not os.path.isdir(avg_directory):
+            fs_home = os.path.abspath(os.environ.get("FREESURFER_HOME"))
+        return avg_subject
+    elif name == "out_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )[name]
+    else:
+        return None
+
+
+class SphericalAverageOutputSpec(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    out_file = File(exists=False, desc="Output label")
+
+
+def _outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    """Returns a bunch containing output fields for the class"""
+    outputs = None
+    if output_spec:
+        outputs = output_spec(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )
+
+    return outputs
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = _outputs(
+        inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+    ).get()
+    if inputs.out_file is not attrs.NOTHING:
+        outputs["out_file"] = os.path.abspath(inputs.out_file)
+    else:
+        out_dir = os.path.join(inputs.subjects_dir, inputs.subject_id, "label")
+        if inputs.in_average is not attrs.NOTHING:
+            basename = os.path.basename(inputs.in_average)
+            basename = basename.replace("_", "_exvivo_") + ".label"
+        else:
+            basename = str(inputs.hemisphere) + ".EC_exvivo_average.label"
+        outputs["out_file"] = os.path.join(out_dir, basename)
+    return outputs
diff --git a/example-specs/task/nipype/freesurfer/surface_smooth.yaml b/example-specs/task/nipype/freesurfer/surface_smooth.yaml
index 105f061a..cacaf523 100644
--- a/example-specs/task/nipype/freesurfer/surface_smooth.yaml
+++ b/example-specs/task/nipype/freesurfer/surface_smooth.yaml
@@ -49,6 +49,9 @@ inputs:
     # type=file|default=<undefined>: source surface file
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+    out_file: Path
+    # type=file: smoothed surface file
+    # type=file|default=<undefined>: surface file to write
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/surface_snapshots.yaml b/example-specs/task/nipype/freesurfer/surface_snapshots.yaml
index c670699b..221caf9a 100644
--- a/example-specs/task/nipype/freesurfer/surface_snapshots.yaml
+++ b/example-specs/task/nipype/freesurfer/surface_snapshots.yaml
@@ -56,10 +56,10 @@ inputs:
     # type=file|default=<undefined>: load colortable file
     patch_file: generic/file
     # type=file|default=<undefined>: load a patch
-    tcl_script: generic/file
-    # type=file|default=<undefined>: override default screenshot script
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+    tcl_script: Path
+    # type=file|default=<undefined>: override default screenshot script
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -76,6 +76,8 @@ outputs:
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
+    tcl_script: tcl_script_callable
+    # type=file|default=<undefined>: override default screenshot script
   templates:
   # dict[str, str] - `output_file_template` values to be provided to output fields
   requirements:
diff --git a/example-specs/task/nipype/freesurfer/surface_snapshots_callables.py b/example-specs/task/nipype/freesurfer/surface_snapshots_callables.py
index 98b507ff..5b155865 100644
--- a/example-specs/task/nipype/freesurfer/surface_snapshots_callables.py
+++ b/example-specs/task/nipype/freesurfer/surface_snapshots_callables.py
@@ -1 +1,13 @@
 """Module to put any functions that are referred to in SurfaceSnapshots.yaml"""
+
+
+def tcl_script_callable(output_dir, inputs, stdout, stderr):
+    return _gen_filename(
+        "tcl_script", output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "tcl_script":
+        return "snapshots.tcl"
+    return None
diff --git a/example-specs/task/nipype/freesurfer/surface_transform.yaml b/example-specs/task/nipype/freesurfer/surface_transform.yaml
index 400aabe7..cd77d625 100644
--- a/example-specs/task/nipype/freesurfer/surface_transform.yaml
+++ b/example-specs/task/nipype/freesurfer/surface_transform.yaml
@@ -43,6 +43,9 @@ inputs:
     # type=file|default=<undefined>: surface annotation file
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+    out_file: Path
+    # type=file: transformed surface file
+    # type=file|default=<undefined>: surface file to write
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/synthesize_flash.yaml b/example-specs/task/nipype/freesurfer/synthesize_flash.yaml
index 51481eb5..05f34e38 100644
--- a/example-specs/task/nipype/freesurfer/synthesize_flash.yaml
+++ b/example-specs/task/nipype/freesurfer/synthesize_flash.yaml
@@ -38,6 +38,9 @@ inputs:
     # type=file|default=<undefined>: image of proton density values
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+    out_file: Path
+    # type=file: synthesized FLASH acquisition
+    # type=file|default=<undefined>: image to write
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/apply_mask.yaml b/example-specs/task/nipype/fsl/apply_mask.yaml
index 4f478bea..cdb099ca 100644
--- a/example-specs/task/nipype/fsl/apply_mask.yaml
+++ b/example-specs/task/nipype/fsl/apply_mask.yaml
@@ -24,6 +24,9 @@ inputs:
     # type=file|default=<undefined>: binary image defining mask space
     in_file: generic/file
     # type=file|default=<undefined>: image to operate on
+    out_file: Path
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/apply_warp.yaml b/example-specs/task/nipype/fsl/apply_warp.yaml
index 70b833ed..3c9a6277 100644
--- a/example-specs/task/nipype/fsl/apply_warp.yaml
+++ b/example-specs/task/nipype/fsl/apply_warp.yaml
@@ -45,6 +45,9 @@ inputs:
     # type=file|default=<undefined>: filename for post-transform (affine matrix)
     mask_file: generic/file
     # type=file|default=<undefined>: filename for mask image (in reference space)
+    out_file: Path
+    # type=file: Warped output file
+    # type=file|default=<undefined>: output filename
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/ar1_image.yaml b/example-specs/task/nipype/fsl/ar1_image.yaml
index b6ca33d6..7bea654f 100644
--- a/example-specs/task/nipype/fsl/ar1_image.yaml
+++ b/example-specs/task/nipype/fsl/ar1_image.yaml
@@ -25,6 +25,9 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: generic/file
     # type=file|default=<undefined>: image to operate on
+    out_file: Path
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/bet.yaml b/example-specs/task/nipype/fsl/bet.yaml
index 2ed11121..363f19c0 100644
--- a/example-specs/task/nipype/fsl/bet.yaml
+++ b/example-specs/task/nipype/fsl/bet.yaml
@@ -40,6 +40,9 @@ inputs:
     # type=file|default=<undefined>: input file to skull strip
     t2_guided: generic/file
     # type=file|default=<undefined>: as with creating surfaces, when also feeding in non-brain-extracted T2 (includes registrations)
+    out_file: Path
+    # type=file: path/name of skullstripped file (if generated)
+    # type=file|default=<undefined>: name of output skull stripped image
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/binary_maths.yaml b/example-specs/task/nipype/fsl/binary_maths.yaml
index 2cb6b816..292bcb03 100644
--- a/example-specs/task/nipype/fsl/binary_maths.yaml
+++ b/example-specs/task/nipype/fsl/binary_maths.yaml
@@ -27,6 +27,9 @@ inputs:
     # type=file|default=<undefined>: second image to perform operation with
     in_file: generic/file
     # type=file|default=<undefined>: image to operate on
+    out_file: Path
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/change_data_type.yaml b/example-specs/task/nipype/fsl/change_data_type.yaml
index 3ba3191c..924e49cf 100644
--- a/example-specs/task/nipype/fsl/change_data_type.yaml
+++ b/example-specs/task/nipype/fsl/change_data_type.yaml
@@ -22,6 +22,9 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: generic/file
     # type=file|default=<undefined>: image to operate on
+    out_file: Path
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/complex.yaml b/example-specs/task/nipype/fsl/complex.yaml
index 36e57c1c..097f99e3 100644
--- a/example-specs/task/nipype/fsl/complex.yaml
+++ b/example-specs/task/nipype/fsl/complex.yaml
@@ -43,6 +43,21 @@ inputs:
     # type=file|default=<undefined>: 
     phase_in_file: generic/file
     # type=file|default=<undefined>: 
+    complex_out_file: Path
+    # type=file: 
+    # type=file|default=<undefined>: 
+    magnitude_out_file: Path
+    # type=file: 
+    # type=file|default=<undefined>: 
+    phase_out_file: Path
+    # type=file: 
+    # type=file|default=<undefined>: 
+    real_out_file: Path
+    # type=file: 
+    # type=file|default=<undefined>: 
+    imaginary_out_file: Path
+    # type=file: 
+    # type=file|default=<undefined>: 
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/convert_xfm.yaml b/example-specs/task/nipype/fsl/convert_xfm.yaml
index b6019cf1..7e83f4ad 100644
--- a/example-specs/task/nipype/fsl/convert_xfm.yaml
+++ b/example-specs/task/nipype/fsl/convert_xfm.yaml
@@ -38,6 +38,9 @@ inputs:
     # type=file|default=<undefined>: input transformation matrix
     in_file2: generic/file
     # type=file|default=<undefined>: second input matrix (for use with fix_scale_skew or concat_xfm)
+    out_file: Path
+    # type=file: output transformation matrix
+    # type=file|default=<undefined>: final transformation matrix
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/dilate_image.yaml b/example-specs/task/nipype/fsl/dilate_image.yaml
index 89d3ecc7..c22fed3e 100644
--- a/example-specs/task/nipype/fsl/dilate_image.yaml
+++ b/example-specs/task/nipype/fsl/dilate_image.yaml
@@ -24,6 +24,9 @@ inputs:
     # type=file|default=<undefined>: use external file for kernel
     in_file: generic/file
     # type=file|default=<undefined>: image to operate on
+    out_file: Path
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/distance_map.yaml b/example-specs/task/nipype/fsl/distance_map.yaml
index f774eb47..be2e5104 100644
--- a/example-specs/task/nipype/fsl/distance_map.yaml
+++ b/example-specs/task/nipype/fsl/distance_map.yaml
@@ -35,6 +35,9 @@ inputs:
     # type=file|default=<undefined>: image to calculate distance values for
     mask_file: generic/file
     # type=file|default=<undefined>: binary mask to constrain calculations
+    distance_map: Path
+    # type=file: value is distance to nearest nonzero voxels
+    # type=file|default=<undefined>: distance map to write
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/dual_regression.yaml b/example-specs/task/nipype/fsl/dual_regression.yaml
index d51819f7..912d74e4 100644
--- a/example-specs/task/nipype/fsl/dual_regression.yaml
+++ b/example-specs/task/nipype/fsl/dual_regression.yaml
@@ -44,6 +44,9 @@ inputs:
     # type=file|default=<undefined>: Design matrix for final cross-subject modelling with randomise
     con_file: generic/file
     # type=file|default=<undefined>: Design contrasts for final cross-subject modelling with randomise
+    out_dir: Path
+    # type=directory: 
+    # type=directory|default='output': This directory will be created to hold all output and logfiles
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/epi_de_warp_callables.py b/example-specs/task/nipype/fsl/epi_de_warp_callables.py
index 7c342436..ebb58d7f 100644
--- a/example-specs/task/nipype/fsl/epi_de_warp_callables.py
+++ b/example-specs/task/nipype/fsl/epi_de_warp_callables.py
@@ -1,10 +1,23 @@
 """Module to put any functions that are referred to in EPIDeWarp.yaml"""
+
 import os.path as op
 import os
 from pathlib import Path
 import attrs
 
 
+def vsm_callable(output_dir, inputs, stdout, stderr):
+    return _gen_filename(
+        "vsm", output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+
+
+def tmpdir_callable(output_dir, inputs, stdout, stderr):
+    return _gen_filename(
+        "tmpdir", output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+
+
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "exfdw":
         if inputs.exf_file is not attrs.NOTHING:
@@ -98,48 +111,6 @@ def _gen_fname(
     return fname
 
 
-def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
-    """Manipulates path and name of input filename
-
-    Parameters
-    ----------
-    fname : string
-        A filename (may or may not include path)
-    prefix : string
-        Characters to prepend to the filename
-    suffix : string
-        Characters to append to the filename
-    newpath : string
-        Path to replace the path of the input fname
-    use_ext : boolean
-        If True (default), appends the extension of the original file
-        to the output name.
-
-    Returns
-    -------
-    Absolute path of the modified filename
-
-    >>> from nipype.utils.filemanip import fname_presuffix
-    >>> fname = 'foo.nii.gz'
-    >>> fname_presuffix(fname,'pre','post','/tmp')
-    '/tmp/prefoopost.nii.gz'
-
-    >>> from nipype.interfaces.base import Undefined
-    >>> fname_presuffix(fname, 'pre', 'post', Undefined) == \
-            fname_presuffix(fname, 'pre', 'post')
-    True
-
-    """
-    pth, fname, ext = split_filename(fname)
-    if not use_ext:
-        ext = ""
-
-    # No need for isdefined: bool(Undefined) evaluates to False
-    if newpath:
-        pth = op.abspath(newpath)
-    return op.join(pth, prefix + fname + suffix + ext)
-
-
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -190,13 +161,43 @@ def split_filename(fname):
     return pth, fname, ext
 
 
-def vsm_callable(output_dir, inputs, stdout, stderr):
-    return _gen_filename(
-        "vsm", output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
-    )
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
 
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
 
-def tmpdir_callable(output_dir, inputs, stdout, stderr):
-    return _gen_filename(
-        "tmpdir", output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
-    )
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import Undefined
+    >>> fname_presuffix(fname, 'pre', 'post', Undefined) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for isdefined: bool(Undefined) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
diff --git a/example-specs/task/nipype/fsl/erode_image.yaml b/example-specs/task/nipype/fsl/erode_image.yaml
index 821cfac2..2c5e065b 100644
--- a/example-specs/task/nipype/fsl/erode_image.yaml
+++ b/example-specs/task/nipype/fsl/erode_image.yaml
@@ -24,6 +24,9 @@ inputs:
     # type=file|default=<undefined>: use external file for kernel
     in_file: generic/file
     # type=file|default=<undefined>: image to operate on
+    out_file: Path
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/extract_roi.yaml b/example-specs/task/nipype/fsl/extract_roi.yaml
index 1e3c7445..c7e9a156 100644
--- a/example-specs/task/nipype/fsl/extract_roi.yaml
+++ b/example-specs/task/nipype/fsl/extract_roi.yaml
@@ -45,6 +45,9 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: generic/file
     # type=file|default=<undefined>: input file
+    roi_file: Path
+    # type=file: 
+    # type=file|default=<undefined>: output file
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/filter_regressor.yaml b/example-specs/task/nipype/fsl/filter_regressor.yaml
index 9603d623..b60feaaf 100644
--- a/example-specs/task/nipype/fsl/filter_regressor.yaml
+++ b/example-specs/task/nipype/fsl/filter_regressor.yaml
@@ -29,6 +29,9 @@ inputs:
     # type=file|default=<undefined>: name of the matrix with time courses (e.g. GLM design or MELODIC mixing matrix)
     mask: generic/file
     # type=file|default=<undefined>: mask image file name
+    out_file: Path
+    # type=file: output file name for the filtered data
+    # type=file|default=<undefined>: output file name for the filtered data
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/find_the_biggest.yaml b/example-specs/task/nipype/fsl/find_the_biggest.yaml
index 00b6711d..eff63541 100644
--- a/example-specs/task/nipype/fsl/find_the_biggest.yaml
+++ b/example-specs/task/nipype/fsl/find_the_biggest.yaml
@@ -37,6 +37,9 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_files: generic/file+list-of
     # type=list|default=[]: a list of input volumes or a singleMatrixFile
+    out_file: Path
+    # type=file: output file indexed in order of input files
+    # type=file|default=<undefined>: file with the resulting segmentation
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/fnirt.yaml b/example-specs/task/nipype/fsl/fnirt.yaml
index 98d44563..2e7db1ec 100644
--- a/example-specs/task/nipype/fsl/fnirt.yaml
+++ b/example-specs/task/nipype/fsl/fnirt.yaml
@@ -63,6 +63,12 @@ inputs:
     # type=file|default=<undefined>: name of file with mask in reference space
     inmask_file: generic/file
     # type=file|default=<undefined>: name of file with mask in input image space
+    warped_file: Path
+    # type=file: warped image
+    # type=file|default=<undefined>: name of output image
+    log_file: Path
+    # type=file: Name of log-file
+    # type=file|default=<undefined>: Name of log-file
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/image_maths.yaml b/example-specs/task/nipype/fsl/image_maths.yaml
index 82119d18..c5652f77 100644
--- a/example-specs/task/nipype/fsl/image_maths.yaml
+++ b/example-specs/task/nipype/fsl/image_maths.yaml
@@ -41,6 +41,9 @@ inputs:
     # type=file|default=<undefined>: 
     mask_file: generic/file
     # type=file|default=<undefined>: use (following image>0) to mask current image
+    out_file: Path
+    # type=file: 
+    # type=file|default=<undefined>: 
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/image_meants.yaml b/example-specs/task/nipype/fsl/image_meants.yaml
index d9cfe2fb..0939da7b 100644
--- a/example-specs/task/nipype/fsl/image_meants.yaml
+++ b/example-specs/task/nipype/fsl/image_meants.yaml
@@ -28,6 +28,9 @@ inputs:
     # type=file|default=<undefined>: input file for computing the average timeseries
     mask: generic/file
     # type=file|default=<undefined>: input 3D mask
+    out_file: Path
+    # type=file: path/name of output text matrix
+    # type=file|default=<undefined>: name of output text matrix
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/isotropic_smooth.yaml b/example-specs/task/nipype/fsl/isotropic_smooth.yaml
index df735550..053bb995 100644
--- a/example-specs/task/nipype/fsl/isotropic_smooth.yaml
+++ b/example-specs/task/nipype/fsl/isotropic_smooth.yaml
@@ -22,6 +22,9 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: generic/file
     # type=file|default=<undefined>: image to operate on
+    out_file: Path
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/maths_command.yaml b/example-specs/task/nipype/fsl/maths_command.yaml
index c9bbe5bc..7c2814c2 100644
--- a/example-specs/task/nipype/fsl/maths_command.yaml
+++ b/example-specs/task/nipype/fsl/maths_command.yaml
@@ -22,6 +22,9 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: generic/file
     # type=file|default=<undefined>: image to operate on
+    out_file: Path
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/max_image.yaml b/example-specs/task/nipype/fsl/max_image.yaml
index 7be290f7..9d80c01d 100644
--- a/example-specs/task/nipype/fsl/max_image.yaml
+++ b/example-specs/task/nipype/fsl/max_image.yaml
@@ -33,6 +33,9 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/nifti1
     # type=file|default=<undefined>: image to operate on
+    out_file: Path
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/maxn_image.yaml b/example-specs/task/nipype/fsl/maxn_image.yaml
index 2794e7de..4c742711 100644
--- a/example-specs/task/nipype/fsl/maxn_image.yaml
+++ b/example-specs/task/nipype/fsl/maxn_image.yaml
@@ -25,6 +25,9 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: generic/file
     # type=file|default=<undefined>: image to operate on
+    out_file: Path
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/mcflirt.yaml b/example-specs/task/nipype/fsl/mcflirt.yaml
index 27a2ad64..4dfd6b10 100644
--- a/example-specs/task/nipype/fsl/mcflirt.yaml
+++ b/example-specs/task/nipype/fsl/mcflirt.yaml
@@ -42,6 +42,9 @@ inputs:
     # type=file|default=<undefined>: initial transformation matrix
     ref_file: generic/file
     # type=file|default=<undefined>: target image for motion correction
+    out_file: Path
+    # type=file: motion-corrected timeseries
+    # type=file|default=<undefined>: file to write
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/mean_image.yaml b/example-specs/task/nipype/fsl/mean_image.yaml
index 9f080763..c4fcaae9 100644
--- a/example-specs/task/nipype/fsl/mean_image.yaml
+++ b/example-specs/task/nipype/fsl/mean_image.yaml
@@ -22,6 +22,9 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: generic/file
     # type=file|default=<undefined>: image to operate on
+    out_file: Path
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/median_image.yaml b/example-specs/task/nipype/fsl/median_image.yaml
index 35181867..30bc3891 100644
--- a/example-specs/task/nipype/fsl/median_image.yaml
+++ b/example-specs/task/nipype/fsl/median_image.yaml
@@ -22,6 +22,9 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: generic/file
     # type=file|default=<undefined>: image to operate on
+    out_file: Path
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/melodic.yaml b/example-specs/task/nipype/fsl/melodic.yaml
index 9363b3fc..d0ed11f2 100644
--- a/example-specs/task/nipype/fsl/melodic.yaml
+++ b/example-specs/task/nipype/fsl/melodic.yaml
@@ -64,6 +64,9 @@ inputs:
     # type=file|default=<undefined>: design matrix across subject-domain
     s_con: medimage-fsl/con
     # type=file|default=<undefined>: t-contrast matrix across subject-domain
+    out_dir: Path
+    # type=directory: 
+    # type=directory|default=<undefined>: output directory name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/min_image.yaml b/example-specs/task/nipype/fsl/min_image.yaml
index 001cd4f9..30fad4dd 100644
--- a/example-specs/task/nipype/fsl/min_image.yaml
+++ b/example-specs/task/nipype/fsl/min_image.yaml
@@ -22,6 +22,9 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: generic/file
     # type=file|default=<undefined>: image to operate on
+    out_file: Path
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/multi_image_maths.yaml b/example-specs/task/nipype/fsl/multi_image_maths.yaml
index 35b56119..c269eb56 100644
--- a/example-specs/task/nipype/fsl/multi_image_maths.yaml
+++ b/example-specs/task/nipype/fsl/multi_image_maths.yaml
@@ -37,6 +37,9 @@ inputs:
     # type=inputmultiobject|default=[]: list of file names to plug into op string
     in_file: medimage/nifti1
     # type=file|default=<undefined>: image to operate on
+    out_file: Path
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/overlay.yaml b/example-specs/task/nipype/fsl/overlay.yaml
index 5b5781a1..0efc1d8c 100644
--- a/example-specs/task/nipype/fsl/overlay.yaml
+++ b/example-specs/task/nipype/fsl/overlay.yaml
@@ -43,6 +43,9 @@ inputs:
     # type=file|default=<undefined>: statistical image to overlay in color
     stat_image2: generic/file
     # type=file|default=<undefined>: second statistical image to overlay in color
+    out_file: Path
+    # type=file: combined image volume
+    # type=file|default=<undefined>: combined image volume
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/percentile_image.yaml b/example-specs/task/nipype/fsl/percentile_image.yaml
index bcd4ba6a..5f0cf9e7 100644
--- a/example-specs/task/nipype/fsl/percentile_image.yaml
+++ b/example-specs/task/nipype/fsl/percentile_image.yaml
@@ -34,6 +34,9 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/nifti1
     # type=file|default=<undefined>: image to operate on
+    out_file: Path
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/plot_motion_params.yaml b/example-specs/task/nipype/fsl/plot_motion_params.yaml
index ecce3340..232d0ecb 100644
--- a/example-specs/task/nipype/fsl/plot_motion_params.yaml
+++ b/example-specs/task/nipype/fsl/plot_motion_params.yaml
@@ -45,6 +45,9 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    out_file: Path
+    # type=file: image to write
+    # type=file|default=<undefined>: image to write
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/plot_time_series.yaml b/example-specs/task/nipype/fsl/plot_time_series.yaml
index b5898404..a577325b 100644
--- a/example-specs/task/nipype/fsl/plot_time_series.yaml
+++ b/example-specs/task/nipype/fsl/plot_time_series.yaml
@@ -35,6 +35,9 @@ inputs:
   # passed to the field in the automatically generated unittests.
     legend_file: generic/file
     # type=file|default=<undefined>: legend file
+    out_file: Path
+    # type=file: image to write
+    # type=file|default=<undefined>: image to write
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/power_spectrum.yaml b/example-specs/task/nipype/fsl/power_spectrum.yaml
index a51287c0..71c0bbf6 100644
--- a/example-specs/task/nipype/fsl/power_spectrum.yaml
+++ b/example-specs/task/nipype/fsl/power_spectrum.yaml
@@ -33,6 +33,9 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: generic/file
     # type=file|default=<undefined>: input 4D file to estimate the power spectrum
+    out_file: Path
+    # type=file: path/name of the output 4D power spectrum file
+    # type=file|default=<undefined>: name of output 4D file for power spectrum
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/prelude.yaml b/example-specs/task/nipype/fsl/prelude.yaml
index 6e4160ed..30691325 100644
--- a/example-specs/task/nipype/fsl/prelude.yaml
+++ b/example-specs/task/nipype/fsl/prelude.yaml
@@ -41,6 +41,9 @@ inputs:
     # type=file|default=<undefined>: saving the raw phase output
     label_file: generic/file
     # type=file|default=<undefined>: saving the area labels output
+    unwrapped_phase_file: Path
+    # type=file: unwrapped phase file
+    # type=file|default=<undefined>: file containing unwrapepd phase
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/prob_track_x.yaml b/example-specs/task/nipype/fsl/prob_track_x.yaml
index 68275ce1..eec7b1ca 100644
--- a/example-specs/task/nipype/fsl/prob_track_x.yaml
+++ b/example-specs/task/nipype/fsl/prob_track_x.yaml
@@ -56,7 +56,7 @@ inputs:
     # type=file|default=<undefined>: transformation matrix taking seed space to DTI space (either FLIRT matrix or FNIRT warp_field) - default is identity
     inv_xfm: generic/file
     # type=file|default=<undefined>: transformation matrix taking DTI space to seed space (compulsory when using a warp_field for seeds_to_dti)
-    out_dir: generic/directory
+    out_dir: Path
     # type=directory|default=<undefined>: directory to put the final volumes in
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
@@ -80,6 +80,8 @@ outputs:
   # to set to the `callable` attribute of output fields
     mode: mode_callable
     # type=enum|default='simple'|allowed['seedmask','simple','two_mask_symm']: options: simple (single seed voxel), seedmask (mask of seed voxels), twomask_symm (two bet binary masks)
+    out_dir: out_dir_callable
+    # type=directory|default=<undefined>: directory to put the final volumes in
   templates:
   # dict[str, str] - `output_file_template` values to be provided to output fields
   requirements:
diff --git a/example-specs/task/nipype/fsl/prob_track_x2.yaml b/example-specs/task/nipype/fsl/prob_track_x2.yaml
index a8ab37b0..6050d2ac 100644
--- a/example-specs/task/nipype/fsl/prob_track_x2.yaml
+++ b/example-specs/task/nipype/fsl/prob_track_x2.yaml
@@ -71,7 +71,7 @@ inputs:
     # type=file|default=<undefined>: transformation matrix taking seed space to DTI space (either FLIRT matrix or FNIRT warp_field) - default is identity
     inv_xfm: generic/file
     # type=file|default=<undefined>: transformation matrix taking DTI space to seed space (compulsory when using a warp_field for seeds_to_dti)
-    out_dir: generic/directory
+    out_dir: Path
     # type=directory|default=<undefined>: directory to put the final volumes in
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
@@ -103,6 +103,8 @@ outputs:
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
+    out_dir: out_dir_callable
+    # type=directory|default=<undefined>: directory to put the final volumes in
   templates:
   # dict[str, str] - `output_file_template` values to be provided to output fields
   requirements:
diff --git a/example-specs/task/nipype/fsl/prob_track_x2_callables.py b/example-specs/task/nipype/fsl/prob_track_x2_callables.py
index bf9e220b..ff73ff30 100644
--- a/example-specs/task/nipype/fsl/prob_track_x2_callables.py
+++ b/example-specs/task/nipype/fsl/prob_track_x2_callables.py
@@ -1 +1,17 @@
 """Module to put any functions that are referred to in ProbTrackX2.yaml"""
+
+
+def out_dir_callable(output_dir, inputs, stdout, stderr):
+    return _gen_filename(
+        "out_dir", output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_dir":
+        return output_dir
+    elif name == "mode":
+        if isinstance(inputs.seed, list) and isinstance(inputs.seed[0], list):
+            return "simple"
+        else:
+            return "seedmask"
diff --git a/example-specs/task/nipype/fsl/prob_track_x_callables.py b/example-specs/task/nipype/fsl/prob_track_x_callables.py
index 0d8c4ce7..74e67313 100644
--- a/example-specs/task/nipype/fsl/prob_track_x_callables.py
+++ b/example-specs/task/nipype/fsl/prob_track_x_callables.py
@@ -1,6 +1,18 @@
 """Module to put any functions that are referred to in ProbTrackX.yaml"""
 
 
+def mode_callable(output_dir, inputs, stdout, stderr):
+    return _gen_filename(
+        "mode", output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+
+
+def out_dir_callable(output_dir, inputs, stdout, stderr):
+    return _gen_filename(
+        "out_dir", output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+
+
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "out_dir":
         return output_dir
@@ -9,9 +21,3 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
             return "simple"
         else:
             return "seedmask"
-
-
-def mode_callable(output_dir, inputs, stdout, stderr):
-    return _gen_filename(
-        "mode", output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
-    )
diff --git a/example-specs/task/nipype/fsl/reorient_2_std.yaml b/example-specs/task/nipype/fsl/reorient_2_std.yaml
index f8f0e820..eb684efb 100644
--- a/example-specs/task/nipype/fsl/reorient_2_std.yaml
+++ b/example-specs/task/nipype/fsl/reorient_2_std.yaml
@@ -34,6 +34,9 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: generic/file
     # type=file|default=<undefined>: 
+    out_file: Path
+    # type=file: 
+    # type=file|default=<undefined>: 
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/sig_loss.yaml b/example-specs/task/nipype/fsl/sig_loss.yaml
index 509b6b29..c83bc2f5 100644
--- a/example-specs/task/nipype/fsl/sig_loss.yaml
+++ b/example-specs/task/nipype/fsl/sig_loss.yaml
@@ -35,6 +35,9 @@ inputs:
     # type=file|default=<undefined>: b0 fieldmap file
     mask_file: generic/file
     # type=file|default=<undefined>: brain mask file
+    out_file: Path
+    # type=file: signal loss estimate file
+    # type=file|default=<undefined>: output signal loss estimate file
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/slice_timer.yaml b/example-specs/task/nipype/fsl/slice_timer.yaml
index e6e5e9d6..3ec864b5 100644
--- a/example-specs/task/nipype/fsl/slice_timer.yaml
+++ b/example-specs/task/nipype/fsl/slice_timer.yaml
@@ -33,12 +33,12 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: generic/file
     # type=file|default=<undefined>: filename of input timeseries
-    out_file: generic/file
-    # type=file|default=<undefined>: filename of output timeseries
     custom_timings: generic/file
     # type=file|default=<undefined>: slice timings, in fractions of TR, range 0:1 (default is 0.5 = no shift)
     custom_order: generic/file
     # type=file|default=<undefined>: filename of single-column custom interleave order file (first slice is referred to as 1 not 0)
+    out_file: Path
+    # type=file|default=<undefined>: filename of output timeseries
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -57,6 +57,8 @@ outputs:
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
+    out_file: out_file_callable
+    # type=file|default=<undefined>: filename of output timeseries
   templates:
   # dict[str, str] - `output_file_template` values to be provided to output fields
   requirements:
diff --git a/example-specs/task/nipype/fsl/slice_timer_callables.py b/example-specs/task/nipype/fsl/slice_timer_callables.py
index ecae1562..a06afc6a 100644
--- a/example-specs/task/nipype/fsl/slice_timer_callables.py
+++ b/example-specs/task/nipype/fsl/slice_timer_callables.py
@@ -1 +1,106 @@
 """Module to put any functions that are referred to in SliceTimer.yaml"""
+
+import os
+import attrs
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    return _gen_filename(
+        "out_file", output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )["slice_time_corrected_file"]
+    return None
+
+
+class SliceTimerOutputSpec(inputs=None, stdout=None, stderr=None, output_dir=None):
+    slice_time_corrected_file = File(exists=True, desc="slice time corrected file")
+
+
+def _outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    """Returns a bunch containing output fields for the class"""
+    outputs = None
+    if output_spec:
+        outputs = output_spec(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )
+
+    return outputs
+
+
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
+
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
+
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
+
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "slicetimer"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = _outputs(
+        inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+    ).get()
+    out_file = inputs.out_file
+    if out_file is attrs.NOTHING:
+        out_file = _gen_fname(
+            inputs.in_file,
+            suffix="_st",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    outputs["slice_time_corrected_file"] = os.path.abspath(out_file)
+    return outputs
diff --git a/example-specs/task/nipype/fsl/slicer.yaml b/example-specs/task/nipype/fsl/slicer.yaml
index e60a1317..9fdb7625 100644
--- a/example-specs/task/nipype/fsl/slicer.yaml
+++ b/example-specs/task/nipype/fsl/slicer.yaml
@@ -41,6 +41,9 @@ inputs:
     # type=file|default=<undefined>: volume to display edge overlay for (useful for checking registration
     colour_map: generic/file
     # type=file|default=<undefined>: use different colour map from that stored in nifti header
+    out_file: Path
+    # type=file: picture to write
+    # type=file|default=<undefined>: picture to write
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/spatial_filter.yaml b/example-specs/task/nipype/fsl/spatial_filter.yaml
index d7bccd78..3bcc8127 100644
--- a/example-specs/task/nipype/fsl/spatial_filter.yaml
+++ b/example-specs/task/nipype/fsl/spatial_filter.yaml
@@ -24,6 +24,9 @@ inputs:
     # type=file|default=<undefined>: use external file for kernel
     in_file: generic/file
     # type=file|default=<undefined>: image to operate on
+    out_file: Path
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/std_image.yaml b/example-specs/task/nipype/fsl/std_image.yaml
index d8b88ade..c2bd0928 100644
--- a/example-specs/task/nipype/fsl/std_image.yaml
+++ b/example-specs/task/nipype/fsl/std_image.yaml
@@ -24,6 +24,9 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: generic/file
     # type=file|default=<undefined>: image to operate on
+    out_file: Path
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/susan.yaml b/example-specs/task/nipype/fsl/susan.yaml
index 7013db52..cf6d21a9 100644
--- a/example-specs/task/nipype/fsl/susan.yaml
+++ b/example-specs/task/nipype/fsl/susan.yaml
@@ -39,7 +39,7 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: generic/file
     # type=file|default=<undefined>: filename of input timeseries
-    out_file: generic/file
+    out_file: Path
     # type=file|default=<undefined>: output file name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
@@ -59,6 +59,8 @@ outputs:
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
+    out_file: out_file_callable
+    # type=file|default=<undefined>: output file name
   templates:
   # dict[str, str] - `output_file_template` values to be provided to output fields
   requirements:
diff --git a/example-specs/task/nipype/fsl/susan_callables.py b/example-specs/task/nipype/fsl/susan_callables.py
index 505eade0..13c530c0 100644
--- a/example-specs/task/nipype/fsl/susan_callables.py
+++ b/example-specs/task/nipype/fsl/susan_callables.py
@@ -1 +1,106 @@
 """Module to put any functions that are referred to in SUSAN.yaml"""
+
+import os
+import attrs
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    return _gen_filename(
+        "out_file", output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )["smoothed_file"]
+    return None
+
+
+def _outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    """Returns a bunch containing output fields for the class"""
+    outputs = None
+    if output_spec:
+        outputs = output_spec(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )
+
+    return outputs
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = _outputs(
+        inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+    ).get()
+    out_file = inputs.out_file
+    if out_file is attrs.NOTHING:
+        out_file = _gen_fname(
+            inputs.in_file,
+            suffix="_smooth",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    outputs["smoothed_file"] = os.path.abspath(out_file)
+    return outputs
+
+
+class SUSANOutputSpec(inputs=None, stdout=None, stderr=None, output_dir=None):
+    smoothed_file = File(exists=True, desc="smoothed output file")
+
+
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
+
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
+
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
+
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "susan"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
diff --git a/example-specs/task/nipype/fsl/swap_dimensions.yaml b/example-specs/task/nipype/fsl/swap_dimensions.yaml
index c2cc15c7..a6c6572f 100644
--- a/example-specs/task/nipype/fsl/swap_dimensions.yaml
+++ b/example-specs/task/nipype/fsl/swap_dimensions.yaml
@@ -29,6 +29,9 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: generic/file
     # type=file|default=<undefined>: input image
+    out_file: Path
+    # type=file: image with new dimensions
+    # type=file|default=<undefined>: image to write
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/temporal_filter.yaml b/example-specs/task/nipype/fsl/temporal_filter.yaml
index b961e7d8..84311577 100644
--- a/example-specs/task/nipype/fsl/temporal_filter.yaml
+++ b/example-specs/task/nipype/fsl/temporal_filter.yaml
@@ -25,6 +25,9 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: generic/file
     # type=file|default=<undefined>: image to operate on
+    out_file: Path
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/threshold.yaml b/example-specs/task/nipype/fsl/threshold.yaml
index 3efba32c..ebb81daf 100644
--- a/example-specs/task/nipype/fsl/threshold.yaml
+++ b/example-specs/task/nipype/fsl/threshold.yaml
@@ -22,6 +22,9 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: generic/file
     # type=file|default=<undefined>: image to operate on
+    out_file: Path
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/unary_maths.yaml b/example-specs/task/nipype/fsl/unary_maths.yaml
index 28d9d3ef..8df0c997 100644
--- a/example-specs/task/nipype/fsl/unary_maths.yaml
+++ b/example-specs/task/nipype/fsl/unary_maths.yaml
@@ -22,6 +22,9 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: generic/file
     # type=file|default=<undefined>: image to operate on
+    out_file: Path
+    # type=file: image written after calculations
+    # type=file|default=<undefined>: image to write
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/vec_reg.yaml b/example-specs/task/nipype/fsl/vec_reg.yaml
index f5f60af1..ec6ae088 100644
--- a/example-specs/task/nipype/fsl/vec_reg.yaml
+++ b/example-specs/task/nipype/fsl/vec_reg.yaml
@@ -48,6 +48,9 @@ inputs:
     # type=file|default=<undefined>: brain mask in input space
     ref_mask: generic/file
     # type=file|default=<undefined>: brain mask in output space (useful for speed up of nonlinear reg)
+    out_file: Path
+    # type=file: path/name of filename for the registered vector or tensor field
+    # type=file|default=<undefined>: filename for output registered vector or tensor field
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/scripts/pkg_gen/create_packages.py b/scripts/pkg_gen/create_packages.py
index 5652ab2a..a00e3025 100644
--- a/scripts/pkg_gen/create_packages.py
+++ b/scripts/pkg_gen/create_packages.py
@@ -102,6 +102,7 @@ def download_tasks_template(output_path: Path):
 @click.option("--work-dir", type=click.Path(path_type=Path), default=None)
 @click.option("--task-template", type=click.Path(path_type=Path), default=None)
 @click.option("--packages-to-import", type=click.Path(path_type=Path), default=None)
+@click.option("--single-interface", type=str, nargs=2, default=None)
 @click.option(
     "--example-packages",
     type=click.Path(path_type=Path),
@@ -119,9 +120,11 @@ def generate_packages(
     work_dir: ty.Optional[Path],
     task_template: ty.Optional[Path],
     packages_to_import: ty.Optional[Path],
+    single_interface: ty.Optional[ty.Tuple[str]],
     base_package: str,
     example_packages: ty.Optional[Path],
 ):
+
     if work_dir is None:
         work_dir = Path(tempfile.mkdtemp())
 
@@ -133,13 +136,25 @@ def generate_packages(
             tar.extractall(path=extract_dir)
         task_template = extract_dir / next(extract_dir.iterdir())
 
-    if packages_to_import is None:
-        packages_to_import = (
-            Path(__file__).parent.parent.parent / "nipype-interfaces-to-import.yaml"
-        )
+    if single_interface:
+        to_import = {
+            "packages": [single_interface[0]],
+            "interfaces": {
+                single_interface[0]: [single_interface[1]],
+            }
+        }
+        if packages_to_import:
+            raise ValueError(
+                "Cannot specify both --single-package and --packages-to-import"
+            )
+    else:
+        if packages_to_import is None:
+            packages_to_import = (
+                Path(__file__).parent.parent.parent / "nipype-interfaces-to-import.yaml"
+            )
 
-    with open(packages_to_import) as f:
-        to_import = yaml.load(f, Loader=yaml.SafeLoader)
+        with open(packages_to_import) as f:
+            to_import = yaml.load(f, Loader=yaml.SafeLoader)
 
     # Wipe output dir
     if output_dir.exists():
@@ -458,28 +473,33 @@ def type2str(tp):
                 with open(spec_dir / (spec_name + ".yaml"), "w") as f:
                     f.write(preamble + yaml_str)
                 callables_str = (
-                    f'"""Module to put any functions that are referred to in '
-                    f'{interface}.yaml"""\n\n'
+                    f'"""Module to put any functions that are referred to in the "callables"'
+                    f' section of {interface}.yaml"""\n\n'
                 )
                 if callables:
+                    # Convert the "_gen_filename" method into a function with any referenced
+                    # methods, functions and constants included in the module
                     funcs, imports, consts = get_gen_filename_to_funcs(nipype_interface)
                     callables_str += "\n".join(imports) + "\n\n"
-                    for const in consts:
-                        callables_str += f"{const[0]} = {const[1]}\n" + "\n\n"
-                    callables_str += "\n\n".join(funcs) + "\n\n"
+                    # Create separate callable function for each callable field, which
+                    # reference the magic "_gen_filename" method
                     for name in callables:
                         callables_str += (
                             f"def {name}_callable(output_dir, inputs, stdout, stderr):\n"
                             f'    return _gen_filename("{name}", output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr)\n\n'
                         )
-                    try:
-                        callables_str = black.format_file_contents(
-                            callables_str, fast=False, mode=black.FileMode()
-                        )
-                    except black.parsing.InvalidInput as e:
-                        raise RuntimeError(
-                            f"Black could not parse generated code: {e}\n\n{callables_str}"
-                        )
+                    for const in consts:
+                        callables_str += f"{const[0]} = {const[1]}\n" + "\n\n"
+                    callables_str += "\n\n".join(funcs) + "\n\n"
+                # Format the generated code with black
+                try:
+                    callables_str = black.format_file_contents(
+                        callables_str, fast=False, mode=black.FileMode()
+                    )
+                except black.parsing.InvalidInput as e:
+                    raise RuntimeError(
+                        f"Black could not parse generated code: {e}\n\n{callables_str}"
+                    )
                 with open(callables_fspath, "w") as f:
                     f.write(callables_str)
 
@@ -690,8 +710,13 @@ def parse_nipype_interface(
                 inpt_mdata += f"|allowed[{','.join(sorted(repr(v) for v in inpt.trait_type.values))}]"
             input_helps[inpt_name] = f"{inpt_mdata}: {inpt_desc}"
             trait_type_name = type(inpt.trait_type).__name__
-            if inpt.genfile and inpt_name in (file_outputs + dir_outputs):
-                template_outputs.append(inpt_name)
+            if inpt.genfile:
+                if trait_type_name in ("File", "Directory"):
+                    path_inputs.append(inpt_name)
+                if inpt_name in (file_outputs + dir_outputs):
+                    template_outputs.append(inpt_name)
+                else:
+                    callables.append(inpt_name)
             elif trait_type_name == "File" and inpt_name not in file_outputs:
                 file_inputs.append(inpt_name)
             elif trait_type_name == "Directory" and inpt_name not in dir_outputs:
@@ -718,8 +743,6 @@ def parse_nipype_interface(
                 multi_inputs.append(inpt_name)
             elif trait_type_name in ("File", "Directory"):
                 path_inputs.append(inpt_name)
-            elif inpt.genfile:
-                callables.append(inpt_name)
     doc_string = nipype_interface.__doc__ if nipype_interface.__doc__ else ""
     doc_string = doc_string.replace("\n", "\n# ")
     # Create a preamble at the top of the specificaiton explaining what to do
@@ -898,6 +921,16 @@ def get_gen_filename_to_funcs(
         the external constants required by the function, as (name, value) tuples
     """
 
+    if not hasattr(nipype_interface, "_gen_filename"):
+        func_src = f"""
+def _gen_filename(field, inputs, output_dir, stdout, stderr):
+    raise NotImplementedError(
+        "Could not find '_gen_filename' method in {nipype_interface.__module__}.{nipype_interface.__name__}"
+    )
+"""
+        warn(f"Could not find '_gen_filename' method in {nipype_interface}")
+        return [func_src], set(), set()
+
     IMPLICIT_ARGS = ["inputs", "stdout", "stderr", "output_dir"]
 
     def find_nested_methods(method: ty.Callable) -> ty.List[str]:
@@ -957,7 +990,9 @@ def insert_args_in_method_calls(src: str, args: ty.List[ty.Tuple[str, str]]) ->
     mod = import_module(nipype_interface.__module__)
     used = UsedSymbols.find(mod, func_srcs)
     for func in used.local_functions:
-        func_srcs.append(cleanup_function_body(inspect.getsource(func), with_signature=True))
+        func_srcs.append(
+            cleanup_function_body(inspect.getsource(func), with_signature=True)
+        )
     for new_func_name, func in used.funcs_to_include:
         func_src = inspect.getsource(func)
         match = re.match(

From 697a872b5b5089d93f6bff406db726974a03ad24 Mon Sep 17 00:00:00 2001
From: Tom Close <tom.g.close@gmail.com>
Date: Thu, 7 Mar 2024 15:52:10 +1100
Subject: [PATCH 52/78] moved pkg-gen into new command

---
 nipype2pydra/cli/__init__.py                  |  1 +
 nipype2pydra/cli/base.py                      |  9 ++
 .../specs}/afni-qwarp-only.yaml               |  0
 .../specs}/example-packages.yaml              |  0
 .../specs}/fastsurfer-only.yaml               |  0
 .../specs}/freesurfer-mris-convert-only.yaml  |  0
 .../specs}/freesurfer-only.yaml               |  0
 .../specs}/fsl-filmgls-only.yaml              |  0
 .../pkg-gen-resources/specs}/fsl-only.yaml    |  0
 .../cli/pkg-gen-resources/specs}/mriqc.yaml   |  0
 .../specs/nipype-interfaces-to-import.yaml    |  1 -
 .../cli/pkg-gen-resources/specs}/qsiprep.yaml |  0
 .../pkg-gen-resources/templates}/README.rst   |  0
 .../templates}/gh_workflows/ci-cd.yaml        |  0
 .../nipype-auto-convert-requirements.txt      |  0
 .../templates}/nipype-auto-convert.py         |  0
 .../pkg-gen-resources/templates}/pkg_init.py  |  0
 .../cli/pkg_gen.py                            | 19 ++--
 nipype2pydra/{cli.py => cli/task.py}          | 38 ++++++--
 nipype2pydra/task/base.py                     |  9 +-
 nipype2pydra/utils.py                         |  2 +-
 port_smriprep.py                              | 89 -------------------
 pyproject.toml                                |  1 +
 scripts/pkg_gen/requirements.txt              |  3 -
 scripts/port_interface.py                     | 21 -----
 tests/test_task.py                            |  2 +
 26 files changed, 56 insertions(+), 139 deletions(-)
 create mode 100644 nipype2pydra/cli/__init__.py
 create mode 100644 nipype2pydra/cli/base.py
 rename {scripts/pkg_gen => nipype2pydra/cli/pkg-gen-resources/specs}/afni-qwarp-only.yaml (100%)
 rename {scripts/pkg_gen => nipype2pydra/cli/pkg-gen-resources/specs}/example-packages.yaml (100%)
 rename {scripts/pkg_gen => nipype2pydra/cli/pkg-gen-resources/specs}/fastsurfer-only.yaml (100%)
 rename {scripts/pkg_gen => nipype2pydra/cli/pkg-gen-resources/specs}/freesurfer-mris-convert-only.yaml (100%)
 rename {scripts/pkg_gen => nipype2pydra/cli/pkg-gen-resources/specs}/freesurfer-only.yaml (100%)
 rename {scripts/pkg_gen => nipype2pydra/cli/pkg-gen-resources/specs}/fsl-filmgls-only.yaml (100%)
 rename {scripts/pkg_gen => nipype2pydra/cli/pkg-gen-resources/specs}/fsl-only.yaml (100%)
 rename {scripts/pkg_gen => nipype2pydra/cli/pkg-gen-resources/specs}/mriqc.yaml (100%)
 rename nipype-interfaces-to-import.yaml => nipype2pydra/cli/pkg-gen-resources/specs/nipype-interfaces-to-import.yaml (99%)
 rename {scripts/pkg_gen => nipype2pydra/cli/pkg-gen-resources/specs}/qsiprep.yaml (100%)
 rename {scripts/pkg_gen/resources => nipype2pydra/cli/pkg-gen-resources/templates}/README.rst (100%)
 rename {scripts/pkg_gen/resources => nipype2pydra/cli/pkg-gen-resources/templates}/gh_workflows/ci-cd.yaml (100%)
 rename {scripts/pkg_gen/resources => nipype2pydra/cli/pkg-gen-resources/templates}/nipype-auto-convert-requirements.txt (100%)
 rename {scripts/pkg_gen/resources => nipype2pydra/cli/pkg-gen-resources/templates}/nipype-auto-convert.py (100%)
 rename {scripts/pkg_gen/resources => nipype2pydra/cli/pkg-gen-resources/templates}/pkg_init.py (100%)
 rename scripts/pkg_gen/create_packages.py => nipype2pydra/cli/pkg_gen.py (98%)
 rename nipype2pydra/{cli.py => cli/task.py} (59%)
 delete mode 100644 port_smriprep.py
 delete mode 100644 scripts/pkg_gen/requirements.txt
 delete mode 100644 scripts/port_interface.py

diff --git a/nipype2pydra/cli/__init__.py b/nipype2pydra/cli/__init__.py
new file mode 100644
index 00000000..5efd591c
--- /dev/null
+++ b/nipype2pydra/cli/__init__.py
@@ -0,0 +1 @@
+from .base import cli
diff --git a/nipype2pydra/cli/base.py b/nipype2pydra/cli/base.py
new file mode 100644
index 00000000..7f558ba8
--- /dev/null
+++ b/nipype2pydra/cli/base.py
@@ -0,0 +1,9 @@
+import click
+from nipype2pydra import __version__
+
+
+# Define the base CLI entrypoint
+@click.group()
+@click.version_option(version=__version__)
+def cli():
+    pass
diff --git a/scripts/pkg_gen/afni-qwarp-only.yaml b/nipype2pydra/cli/pkg-gen-resources/specs/afni-qwarp-only.yaml
similarity index 100%
rename from scripts/pkg_gen/afni-qwarp-only.yaml
rename to nipype2pydra/cli/pkg-gen-resources/specs/afni-qwarp-only.yaml
diff --git a/scripts/pkg_gen/example-packages.yaml b/nipype2pydra/cli/pkg-gen-resources/specs/example-packages.yaml
similarity index 100%
rename from scripts/pkg_gen/example-packages.yaml
rename to nipype2pydra/cli/pkg-gen-resources/specs/example-packages.yaml
diff --git a/scripts/pkg_gen/fastsurfer-only.yaml b/nipype2pydra/cli/pkg-gen-resources/specs/fastsurfer-only.yaml
similarity index 100%
rename from scripts/pkg_gen/fastsurfer-only.yaml
rename to nipype2pydra/cli/pkg-gen-resources/specs/fastsurfer-only.yaml
diff --git a/scripts/pkg_gen/freesurfer-mris-convert-only.yaml b/nipype2pydra/cli/pkg-gen-resources/specs/freesurfer-mris-convert-only.yaml
similarity index 100%
rename from scripts/pkg_gen/freesurfer-mris-convert-only.yaml
rename to nipype2pydra/cli/pkg-gen-resources/specs/freesurfer-mris-convert-only.yaml
diff --git a/scripts/pkg_gen/freesurfer-only.yaml b/nipype2pydra/cli/pkg-gen-resources/specs/freesurfer-only.yaml
similarity index 100%
rename from scripts/pkg_gen/freesurfer-only.yaml
rename to nipype2pydra/cli/pkg-gen-resources/specs/freesurfer-only.yaml
diff --git a/scripts/pkg_gen/fsl-filmgls-only.yaml b/nipype2pydra/cli/pkg-gen-resources/specs/fsl-filmgls-only.yaml
similarity index 100%
rename from scripts/pkg_gen/fsl-filmgls-only.yaml
rename to nipype2pydra/cli/pkg-gen-resources/specs/fsl-filmgls-only.yaml
diff --git a/scripts/pkg_gen/fsl-only.yaml b/nipype2pydra/cli/pkg-gen-resources/specs/fsl-only.yaml
similarity index 100%
rename from scripts/pkg_gen/fsl-only.yaml
rename to nipype2pydra/cli/pkg-gen-resources/specs/fsl-only.yaml
diff --git a/scripts/pkg_gen/mriqc.yaml b/nipype2pydra/cli/pkg-gen-resources/specs/mriqc.yaml
similarity index 100%
rename from scripts/pkg_gen/mriqc.yaml
rename to nipype2pydra/cli/pkg-gen-resources/specs/mriqc.yaml
diff --git a/nipype-interfaces-to-import.yaml b/nipype2pydra/cli/pkg-gen-resources/specs/nipype-interfaces-to-import.yaml
similarity index 99%
rename from nipype-interfaces-to-import.yaml
rename to nipype2pydra/cli/pkg-gen-resources/specs/nipype-interfaces-to-import.yaml
index dc22011b..f9ba6221 100644
--- a/nipype-interfaces-to-import.yaml
+++ b/nipype2pydra/cli/pkg-gen-resources/specs/nipype-interfaces-to-import.yaml
@@ -418,7 +418,6 @@ interfaces:
   - ICA_AROMA
   fsl/dti:
   - DTIFit
-  - FSLXCommand
   - BEDPOSTX5
   - XFibres5
   - ProbTrackX
diff --git a/scripts/pkg_gen/qsiprep.yaml b/nipype2pydra/cli/pkg-gen-resources/specs/qsiprep.yaml
similarity index 100%
rename from scripts/pkg_gen/qsiprep.yaml
rename to nipype2pydra/cli/pkg-gen-resources/specs/qsiprep.yaml
diff --git a/scripts/pkg_gen/resources/README.rst b/nipype2pydra/cli/pkg-gen-resources/templates/README.rst
similarity index 100%
rename from scripts/pkg_gen/resources/README.rst
rename to nipype2pydra/cli/pkg-gen-resources/templates/README.rst
diff --git a/scripts/pkg_gen/resources/gh_workflows/ci-cd.yaml b/nipype2pydra/cli/pkg-gen-resources/templates/gh_workflows/ci-cd.yaml
similarity index 100%
rename from scripts/pkg_gen/resources/gh_workflows/ci-cd.yaml
rename to nipype2pydra/cli/pkg-gen-resources/templates/gh_workflows/ci-cd.yaml
diff --git a/scripts/pkg_gen/resources/nipype-auto-convert-requirements.txt b/nipype2pydra/cli/pkg-gen-resources/templates/nipype-auto-convert-requirements.txt
similarity index 100%
rename from scripts/pkg_gen/resources/nipype-auto-convert-requirements.txt
rename to nipype2pydra/cli/pkg-gen-resources/templates/nipype-auto-convert-requirements.txt
diff --git a/scripts/pkg_gen/resources/nipype-auto-convert.py b/nipype2pydra/cli/pkg-gen-resources/templates/nipype-auto-convert.py
similarity index 100%
rename from scripts/pkg_gen/resources/nipype-auto-convert.py
rename to nipype2pydra/cli/pkg-gen-resources/templates/nipype-auto-convert.py
diff --git a/scripts/pkg_gen/resources/pkg_init.py b/nipype2pydra/cli/pkg-gen-resources/templates/pkg_init.py
similarity index 100%
rename from scripts/pkg_gen/resources/pkg_init.py
rename to nipype2pydra/cli/pkg-gen-resources/templates/pkg_init.py
diff --git a/scripts/pkg_gen/create_packages.py b/nipype2pydra/cli/pkg_gen.py
similarity index 98%
rename from scripts/pkg_gen/create_packages.py
rename to nipype2pydra/cli/pkg_gen.py
index a00e3025..4b1b4fa6 100644
--- a/scripts/pkg_gen/create_packages.py
+++ b/nipype2pydra/cli/pkg_gen.py
@@ -37,9 +37,10 @@
     cleanup_function_body,
     insert_args_in_signature,
 )
+from nipype2pydra.cli.base import cli
 
 
-RESOURCES_DIR = Path(__file__).parent / "resources"
+TEMPLATES_DIR = Path(__file__).parent / "pkg-gen-resources" / "templates"
 
 EXPECTED_FORMATS = [Nifti1, NiftiGz, TextFile, TextMatrix, DatFile, Xml]
 
@@ -97,7 +98,7 @@ def download_tasks_template(output_path: Path):
         )
 
 
-@click.command(help="Generates stub pydra packages for all nipype interfaces to import")
+@cli.command("pkg-gen", help="Generates stub pydra packages for all nipype interfaces to import")
 @click.argument("output_dir", type=click.Path(path_type=Path))
 @click.option("--work-dir", type=click.Path(path_type=Path), default=None)
 @click.option("--task-template", type=click.Path(path_type=Path), default=None)
@@ -115,7 +116,7 @@ def download_tasks_template(output_path: Path):
     default="nipype.interfaces",
     help=("the base package which the sub-packages are relative to"),
 )
-def generate_packages(
+def pkg_gen(
     output_dir: Path,
     work_dir: ty.Optional[Path],
     task_template: ty.Optional[Path],
@@ -588,10 +589,10 @@ def copy_ignore(_, names):
     auto_conv_dir = pkg_dir / "nipype-auto-conv"
     specs_dir = auto_conv_dir / "specs"
     specs_dir.mkdir(parents=True)
-    shutil.copy(RESOURCES_DIR / "nipype-auto-convert.py", auto_conv_dir / "generate")
+    shutil.copy(TEMPLATES_DIR / "nipype-auto-convert.py", auto_conv_dir / "generate")
     os.chmod(auto_conv_dir / "generate", 0o755)  # make executable
     shutil.copy(
-        RESOURCES_DIR / "nipype-auto-convert-requirements.txt",
+        TEMPLATES_DIR / "nipype-auto-convert-requirements.txt",
         auto_conv_dir / "requirements.txt",
     )
 
@@ -599,13 +600,13 @@ def copy_ignore(_, names):
     gh_workflows_dir = pkg_dir / ".github" / "workflows"
     gh_workflows_dir.mkdir(parents=True, exist_ok=True)
     shutil.copy(
-        RESOURCES_DIR / "gh_workflows" / "ci-cd.yaml",
+        TEMPLATES_DIR / "gh_workflows" / "ci-cd.yaml",
         gh_workflows_dir / "ci-cd.yaml",
     )
 
     # Add modified README
     os.unlink(pkg_dir / "README.md")
-    shutil.copy(RESOURCES_DIR / "README.rst", pkg_dir / "README.rst")
+    shutil.copy(TEMPLATES_DIR / "README.rst", pkg_dir / "README.rst")
     with open(pkg_dir / "pyproject.toml") as f:
         pyproject_toml = f.read()
     pyproject_toml = pyproject_toml.replace("README.md", "README.rst")
@@ -648,7 +649,7 @@ def copy_ignore(_, names):
 
     # Add in modified __init__.py
     shutil.copy(
-        RESOURCES_DIR / "pkg_init.py", pkg_dir / "pydra" / "tasks" / pkg / "__init__.py"
+        TEMPLATES_DIR / "pkg_init.py", pkg_dir / "pydra" / "tasks" / pkg / "__init__.py"
     )
 
     # Replace "CHANGEME" string with pkg name
@@ -1012,4 +1013,4 @@ def insert_args_in_method_calls(src: str, args: ty.List[ty.Tuple[str, str]]) ->
 if __name__ == "__main__":
     import sys
 
-    generate_packages(sys.argv[1:])
+    pkg_gen(sys.argv[1:])
diff --git a/nipype2pydra/cli.py b/nipype2pydra/cli/task.py
similarity index 59%
rename from nipype2pydra/cli.py
rename to nipype2pydra/cli/task.py
index 39fd406f..ecf55f46 100644
--- a/nipype2pydra/cli.py
+++ b/nipype2pydra/cli/task.py
@@ -1,15 +1,8 @@
 from pathlib import Path
 import click
 import yaml
-from nipype2pydra import __version__
 import nipype2pydra.task
-
-
-# Define the base CLI entrypoint
-@click.group()
-@click.version_option(version=__version__)
-def cli():
-    pass
+from .base import cli
 
 
 @cli.command(
@@ -28,7 +21,7 @@ def cli():
 @click.option(
     "-c",
     "--callables",
-    type=click.File(),
+    type=click.Path(path_type=Path, exists=True, dir_okay=False, resolve_path=True),
     default=None,
     help="a Python file containing callable functions required in the command interface",
 )
@@ -47,7 +40,34 @@ def task(yaml_spec, package_root, callables, output_module):
 
     spec = yaml.safe_load(yaml_spec)
 
+    if callables is None:
+        callables_default = yaml_spec.parent / (yaml_spec.stem + "_callables.py")
+        if callables_default.exists():
+            callables = callables_default
+
     converter = nipype2pydra.task.get_converter(
         output_module=output_module, callables_module=callables, **spec
     )
     converter.generate(package_root)
+
+
+if __name__ == "__main__":
+    import sys
+    from pathlib import Path
+    import nipype2pydra.utils
+
+    outputs_path = Path(__file__).parent.parent / "outputs" / "testing"
+
+    outputs_path.mkdir(parents=True, exist_ok=True)
+
+    spec_file = sys.argv[1]
+    with open(spec_file) as f:
+        spec = yaml.load(f, Loader=yaml.SafeLoader)
+
+    converter = nipype2pydra.task.get_converter(
+        output_module=spec["nipype_module"].split("interfaces.")[-1]
+        + ".auto."
+        + nipype2pydra.utils.to_snake_case(spec["task_name"]),
+        **spec,
+    )
+    converter.generate(outputs_path)
diff --git a/nipype2pydra/task/base.py b/nipype2pydra/task/base.py
index 354bc9d4..ab460ef8 100644
--- a/nipype2pydra/task/base.py
+++ b/nipype2pydra/task/base.py
@@ -396,7 +396,7 @@ class BaseTaskConverter(metaclass=ABCMeta):
         converter=from_dict_to_outputs,
     )
     callables_module: ModuleType = attrs.field(
-        converter=import_module_from_path, default=None
+        converter=import_module_from_path, default=None,
     )
     tests: ty.List[TestGenerator] = attrs.field(  # type: ignore
         factory=list, converter=from_list_to_tests
@@ -632,12 +632,9 @@ def pydra_fld_output(self, field, name):
     def function_callables(self):
         if not self.outputs.callables:
             return ""
-        python_functions_spec = (
-            Path(os.path.dirname(__file__)) / "../specs/callables.py"
-        )
-        if not python_functions_spec.exists():
+        if not self.callables_module:
             raise Exception(
-                "specs/callables.py file is needed if output_callables in the spec files"
+                "callables module must be provided if output_callables are set in the spec file"
             )
         fun_str = ""
         fun_names = list(set(self.outputs.callables.values()))
diff --git a/nipype2pydra/utils.py b/nipype2pydra/utils.py
index d6b0b0d3..fb8e4b08 100644
--- a/nipype2pydra/utils.py
+++ b/nipype2pydra/utils.py
@@ -231,7 +231,7 @@ def find(
             a class containing the used symbols in the module
         """
         used = cls()
-        imports = ["import attrs"]  # attrs is included in imports in case we reference attrs.NOTHING
+        imports = ["import attrs", "from fileformats.generic import File, Directory"]  # attrs is included in imports in case we reference attrs.NOTHING
         block = ""
         source_code = inspect.getsource(module)
         local_functions = get_local_functions(module)
diff --git a/port_smriprep.py b/port_smriprep.py
deleted file mode 100644
index 304f9a3f..00000000
--- a/port_smriprep.py
+++ /dev/null
@@ -1,89 +0,0 @@
-import json
-from collections import defaultdict
-import click
-from bids import BIDSLayout
-from nipype.interfaces.base import isdefined
-from niworkflows.utils.spaces import SpatialReferences, Reference
-from smriprep.workflows.base import init_single_subject_wf
-
-
-@click.command("Print out auto-generated port of Nipype to Pydra")
-@click.argument("out-file")
-@click.argument("bids-dataset")
-def port(out_file, bids_dataset):
-
-    wf = build_workflow(bids_dataset)
-
-    connections = defaultdict(dict)
-
-    for edge, props in wf._graph.edges.items():
-        src_node = edge[0].name
-        dest_node = edge[1].name
-        for node_conn in props['connect']:
-            src_field = node_conn[1]
-            dest_field = node_conn[0]
-            if src_field.startswith('def'):
-                print(f"Not sure how to deal with {src_field} in {src_node} to "
-                      f"{dest_node}.{dest_field}")
-                continue
-            else:
-                src_field = src_field.split('.')[-1]
-            connections[dest_node][dest_field] = f"{src_node}.lzout.{src_field}"
-
-    out_text = ""
-    for node_name in wf.list_node_names():
-        node = wf.get_node(node_name)
-
-        interface_type = type(node.interface)
-
-        task_type = interface_type.__module__ + "." + interface_type.__name__
-        node_args = ""
-        for arg in node.inputs.visible_traits():
-            val = getattr(node.inputs, arg)  # Enclose strings in quotes
-            if isdefined(val):
-                try:
-                    val = json.dumps(val)
-                except TypeError:
-                    pass
-                if isinstance(val, str) and '\n' in val:
-                    val = '"""' + val + '""""'
-                node_args += f",\n        {arg}={val}"
-
-        for arg, val in connections[node.name].items():
-            node_args += f",\n        {arg}={val}"
-
-        out_text += f"""
-    wf.add({task_type}(
-        name="{node.name}"{node_args}
-    )"""
-
-    with open(out_file, "w") as f:
-        f.write(out_text)
-
-
-def build_workflow(bids_dataset):
-
-    wf = init_single_subject_wf(
-        debug=False,
-        freesurfer=True,
-        fast_track=False,
-        hires=True,
-        layout=BIDSLayout(bids_dataset),
-        longitudinal=False,
-        low_mem=False,
-        name="single_subject_wf",
-        omp_nthreads=1,
-        output_dir=".",
-        skull_strip_fixed_seed=False,
-        skull_strip_mode="force",
-        skull_strip_template=Reference("OASIS30ANTs"),
-        spaces=SpatialReferences(spaces=["MNI152NLin2009cAsym", "fsaverage5"]),
-        subject_id="test",
-        bids_filters=None,
-    )
-
-    return wf
-
-
-if __name__ == "__main__":
-    port()
diff --git a/pyproject.toml b/pyproject.toml
index e7aa1fe6..d8c278fe 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -16,6 +16,7 @@ dependencies = [
     "fileformats >=0.8",
     "fileformats-medimage >=0.4",
     "fileformats-datascience",
+    "requests>=2.31.0",
     "traits",
 ]
 license = {file = "LICENSE"}
diff --git a/scripts/pkg_gen/requirements.txt b/scripts/pkg_gen/requirements.txt
deleted file mode 100644
index 008daa34..00000000
--- a/scripts/pkg_gen/requirements.txt
+++ /dev/null
@@ -1,3 +0,0 @@
-PyYaml >= 1.4.0
-click >= 8.1.3
-requests >= 2.31.0
diff --git a/scripts/port_interface.py b/scripts/port_interface.py
deleted file mode 100644
index f65ddc3b..00000000
--- a/scripts/port_interface.py
+++ /dev/null
@@ -1,21 +0,0 @@
-import sys
-import yaml
-from pathlib import Path
-import nipype2pydra.task
-import nipype2pydra.utils
-
-outputs_path = Path(__file__).parent.parent / "outputs" / "testing"
-
-outputs_path.mkdir(parents=True, exist_ok=True)
-
-spec_file = sys.argv[1]
-with open(spec_file) as f:
-    spec = yaml.load(f, Loader=yaml.SafeLoader)
-
-converter = nipype2pydra.task.get_converter(
-    output_module=spec["nipype_module"].split("interfaces.")[-1]
-    + ".auto."
-    + nipype2pydra.utils.to_snake_case(spec["task_name"]),
-    **spec,
-)
-converter.generate(outputs_path)
diff --git a/tests/test_task.py b/tests/test_task.py
index 948d2cc6..f3aa186d 100644
--- a/tests/test_task.py
+++ b/tests/test_task.py
@@ -50,6 +50,8 @@ def test_task_conversion(task_spec_file, cli_runner, work_dir, gen_test_conftest
             str(pkg_root),
             "--output-module",
             output_module_path,
+            "--callables",
+            str(task_spec_file.parent / (task_spec_file.stem + "_callables.py")),
         ],
     )
 

From 86a90b7753527bbb095025bc33ad6f063a2664c0 Mon Sep 17 00:00:00 2001
From: Tom Close <tom.g.close@gmail.com>
Date: Thu, 7 Mar 2024 17:40:30 +1100
Subject: [PATCH 53/78] brought pkg-gen command inside package instead of
 scripts dir

---
 nipype2pydra/cli/pkg_gen.py                   | 858 +-----------------
 nipype2pydra/pkg_gen/__init__.py              | 848 +++++++++++++++++
 .../resources}/specs/afni-qwarp-only.yaml     |   0
 .../resources}/specs/example-packages.yaml    |   0
 .../resources}/specs/fastsurfer-only.yaml     |   0
 .../specs/freesurfer-mris-convert-only.yaml   |   0
 .../resources}/specs/freesurfer-only.yaml     |   0
 .../resources}/specs/fsl-filmgls-only.yaml    |   0
 .../resources}/specs/fsl-only.yaml            |   0
 .../resources}/specs/mriqc.yaml               |   0
 .../specs/nipype-interfaces-to-import.yaml    |   0
 .../resources}/specs/qsiprep.yaml             |   0
 .../resources}/templates/README.rst           |   0
 .../templates/gh_workflows/ci-cd.yaml         |   0
 .../nipype-auto-convert-requirements.txt      |   0
 .../templates/nipype-auto-convert.py          |   0
 .../resources}/templates/pkg_init.py          |   0
 17 files changed, 876 insertions(+), 830 deletions(-)
 create mode 100644 nipype2pydra/pkg_gen/__init__.py
 rename nipype2pydra/{cli/pkg-gen-resources => pkg_gen/resources}/specs/afni-qwarp-only.yaml (100%)
 rename nipype2pydra/{cli/pkg-gen-resources => pkg_gen/resources}/specs/example-packages.yaml (100%)
 rename nipype2pydra/{cli/pkg-gen-resources => pkg_gen/resources}/specs/fastsurfer-only.yaml (100%)
 rename nipype2pydra/{cli/pkg-gen-resources => pkg_gen/resources}/specs/freesurfer-mris-convert-only.yaml (100%)
 rename nipype2pydra/{cli/pkg-gen-resources => pkg_gen/resources}/specs/freesurfer-only.yaml (100%)
 rename nipype2pydra/{cli/pkg-gen-resources => pkg_gen/resources}/specs/fsl-filmgls-only.yaml (100%)
 rename nipype2pydra/{cli/pkg-gen-resources => pkg_gen/resources}/specs/fsl-only.yaml (100%)
 rename nipype2pydra/{cli/pkg-gen-resources => pkg_gen/resources}/specs/mriqc.yaml (100%)
 rename nipype2pydra/{cli/pkg-gen-resources => pkg_gen/resources}/specs/nipype-interfaces-to-import.yaml (100%)
 rename nipype2pydra/{cli/pkg-gen-resources => pkg_gen/resources}/specs/qsiprep.yaml (100%)
 rename nipype2pydra/{cli/pkg-gen-resources => pkg_gen/resources}/templates/README.rst (100%)
 rename nipype2pydra/{cli/pkg-gen-resources => pkg_gen/resources}/templates/gh_workflows/ci-cd.yaml (100%)
 rename nipype2pydra/{cli/pkg-gen-resources => pkg_gen/resources}/templates/nipype-auto-convert-requirements.txt (100%)
 rename nipype2pydra/{cli/pkg-gen-resources => pkg_gen/resources}/templates/nipype-auto-convert.py (100%)
 rename nipype2pydra/{cli/pkg-gen-resources => pkg_gen/resources}/templates/pkg_init.py (100%)

diff --git a/nipype2pydra/cli/pkg_gen.py b/nipype2pydra/cli/pkg_gen.py
index 4b1b4fa6..16dfd954 100644
--- a/nipype2pydra/cli/pkg_gen.py
+++ b/nipype2pydra/cli/pkg_gen.py
@@ -1,104 +1,30 @@
-import os
 import typing as ty
 import tempfile
-import re
-import inspect
 from importlib import import_module
-from copy import copy
 import subprocess as sp
 import shutil
 import tarfile
-import string
 from pathlib import Path
-import attrs
-from warnings import warn
-import requests
 import click
 import yaml
-import black.parsing
-import fileformats.core.utils
-import fileformats.core.mixin
-from fileformats.generic import File, Directory
-from fileformats.medimage import Nifti1, NiftiGz, Bval, Bvec
-from fileformats.application import Dicom, Xml
-from fileformats.text import TextFile
-from fileformats.datascience import TextMatrix, DatFile
+from fileformats.generic import File
 import nipype.interfaces.base.core
-from nipype2pydra.task import (
-    InputsConverter,
-    OutputsConverter,
-    TestGenerator,
-    DocTestGenerator,
-)
 from nipype2pydra.utils import (
     to_snake_case,
-    UsedSymbols,
-    split_parens_contents,
-    cleanup_function_body,
-    insert_args_in_signature,
+)
+from nipype2pydra.pkg_gen import (
+    download_tasks_template,
+    initialise_task_repo,
+    NipypeInterface,
+    gen_fileformats_module,
+    gen_fileformats_extras_module,
 )
 from nipype2pydra.cli.base import cli
 
 
-TEMPLATES_DIR = Path(__file__).parent / "pkg-gen-resources" / "templates"
-
-EXPECTED_FORMATS = [Nifti1, NiftiGz, TextFile, TextMatrix, DatFile, Xml]
-
-EXT_SPECIAL_CHARS = tuple((set(string.punctuation) - set(".-")) | set(" "))
-
-
-def ext2format_name(ext: str) -> str:
-    return escape_leading_digits(ext[1:]).capitalize()
-
-
-def escape_leading_digits(name: str) -> str:
-    for k, v in ESCAPE_DIGITS.items():
-        if name.startswith(k):
-            name = v + name[1:]
-            return name
-    return name
-
-
-ESCAPE_DIGITS = {
-    "1": "one",
-    "2": "two",
-    "3": "three",
-    "4": "four",
-    "5": "five",
-    "6": "six",
-    "7": "seven",
-    "8": "eight",
-    "9": "nine",
-}
-
-
-def download_tasks_template(output_path: Path):
-    """Downloads the latest pydra-template to the output path"""
-
-    release_url = (
-        "https://api.github.com/repos/nipype/pydra-tasks-template/releases/latest"
-    )
-    headers = {"Accept": "application/vnd.github.v3+json", "User-Agent": "nipype2pydra"}
-
-    response = requests.get(release_url, headers=headers)
-    if response.status_code != 200:
-        raise RuntimeError(f"Did not find release at '{release_url}'")
-    data = response.json()
-    tarball_url = data["tarball_url"]
-
-    response = requests.get(tarball_url)
-
-    if response.status_code == 200:
-        # Save the response content to a file
-        with open(output_path, "wb") as f:
-            f.write(response.content)
-    else:
-        raise RuntimeError(
-            f"Could not download the pydra-tasks template at {release_url}"
-        )
-
-
-@cli.command("pkg-gen", help="Generates stub pydra packages for all nipype interfaces to import")
+@cli.command(
+    "pkg-gen", help="Generates stub pydra packages for all nipype interfaces to import"
+)
 @click.argument("output_dir", type=click.Path(path_type=Path))
 @click.option("--work-dir", type=click.Path(path_type=Path), default=None)
 @click.option("--task-template", type=click.Path(path_type=Path), default=None)
@@ -142,7 +68,7 @@ def pkg_gen(
             "packages": [single_interface[0]],
             "interfaces": {
                 single_interface[0]: [single_interface[1]],
-            }
+            },
         }
         if packages_to_import:
             raise ValueError(
@@ -181,12 +107,10 @@ def pkg_gen(
 
             # Loop through all interfaces in module
             for interface in interfaces:
-                spec_name = to_snake_case(interface)
-                callables_fspath = spec_dir / f"{spec_name}_callables.py"
-                spec_stub = {}
 
                 # Import interface from module
-                nipype_module_str = base_package + "." + ".".join(module.split("/"))
+                module_str = ".".join(module.split("/"))
+                nipype_module_str = base_package + "." + module_str
                 nipype_module = import_module(nipype_module_str)
                 nipype_interface = getattr(nipype_module, interface)
                 if not issubclass(
@@ -195,314 +119,24 @@ def pkg_gen(
                     not_interfaces.append(f"{module}.{interface}")
                     continue
 
-                (
-                    preamble,
-                    input_helps,
-                    output_helps,
-                    file_inputs,
-                    path_inputs,
-                    file_outputs,
-                    template_outputs,
-                    multi_inputs,
-                    dir_inputs,
-                    dir_outputs,
-                    callables,
-                ) = parse_nipype_interface(nipype_interface)
-
-                # Create "stubs" for each of the available fields
-                def fields_stub(name, category_class, values=None):
-                    """Used, in conjunction with some find/replaces after dumping, to
-                    insert comments into the YAML file"""
-                    dct = {}
-                    for field in attrs.fields(category_class):
-                        field_name = f"{name}.{field.name}"
-                        try:
-                            val = values[field.name]
-                        except (KeyError, TypeError):
-                            val = (
-                                field.default
-                                if (
-                                    field.default != attrs.NOTHING
-                                    and not isinstance(field.default, attrs.Factory)
-                                )
-                                else None
-                            )
-                        else:
-                            if isinstance(val, ty.Iterable) and not val:
-                                val = None
-                        dct[field_name] = val
-                    return dct
-
-                input_types = {i: File for i in file_inputs}
-                input_types.update({i: Directory for i in dir_inputs})
-                input_types.update({i: Path for i in path_inputs})
-                output_types = {o: File for o in file_outputs}
-                output_types.update({o: Directory for o in dir_outputs})
-                output_templates = {}
+                parsed = NipypeInterface.parse(nipype_interface, pkg, base_package)
 
-                # Attempt to parse doctest to pull out sensible defaults for input/output
-                # values
-                doc_str = nipype_interface.__doc__ if nipype_interface.__doc__ else ""
-                doc_str = re.sub(r"\n\s+\.\.\.\s+", "", doc_str)
-                prev_block = ""
-                doctest_blocks = []
-                for para in doc_str.split("\n\n"):
-                    if "cmdline" in para:
-                        doctest_blocks.append(prev_block + "\n" + para)
-                        prev_block = ""
-                    elif ">>>" in para:
-                        prev_block += "\n" + para
-
-                doctests: ty.List[DocTestGenerator] = []
-                tests: ty.List[TestGenerator] = [
-                    fields_stub(
-                        "test",
-                        TestGenerator,
-                        {"inputs": {i: None for i in input_helps}, "imports": None},
-                    )
-                ]
-
-                for doctest_str in doctest_blocks:
-                    if ">>>" in doctest_str:
-                        try:
-                            cmdline, inpts, directive, imports = extract_doctest_inputs(
-                                doctest_str, interface
-                            )
-                        except ValueError:
-                            intf_name = f"{module.replace('/', '.')}.{interface}"
-                            warn(
-                                f"Could not parse doctest for {intf_name}:\n{doctest_str}"
-                            )
-                            continue
-
-                        def guess_type(fspath):
-                            try:
-                                fspath = re.search(
-                                    r"""['"]([^'"]*)['"]""", fspath
-                                ).group(1)
-                            except AttributeError:
-                                return File
-                            possible_formats = []
-                            for frmt in fileformats.core.FileSet.all_formats:
-                                if not frmt.ext or None in frmt.alternate_exts:
-                                    continue
-                                if frmt.matching_exts(fspath):
-                                    possible_formats.append(frmt)
-                            if not possible_formats:
-                                if fspath.endswith(".dcm"):
-                                    return Dicom
-                                if fspath == "bvals":
-                                    return Bval
-                                if fspath == "bvecs":
-                                    return Bvec
-                                format_ext = File.decompose_fspath(
-                                    fspath.strip(),
-                                    mode=File.ExtensionDecomposition.single,
-                                )[2]
-                                if any(c in format_ext for c in EXT_SPECIAL_CHARS):
-                                    return (
-                                        File  # Skip any extensions with special chars
-                                    )
-                                unmatched_formats.append(
-                                    f"{module}.{interface}: {fspath}"
-                                )
-                                if format_ext:
-                                    pkg_formats.add(format_ext)
-                                    return f"fileformats.medimage_{pkg}.{ext2format_name(format_ext)}"
-                                return File
-
-                            for expected in EXPECTED_FORMATS:
-                                if expected in possible_formats:
-                                    return expected
-                            if len(possible_formats) > 1:
-                                non_adjacent = [
-                                    f
-                                    for f in possible_formats
-                                    if not issubclass(
-                                        f, fileformats.core.mixin.WithAdjacentFiles
-                                    )
-                                ]
-                                if non_adjacent:
-                                    possible_formats = non_adjacent
-                            if len(possible_formats) > 1:
-                                possible_formats = sorted(
-                                    possible_formats, key=lambda f: f.__name__
-                                )
-                                ambiguous_formats.append(possible_formats)
-                            return possible_formats[0]
-
-                        def combine_types(type_, prev_type):
-                            if type_ is File:
-                                return prev_type
-                            if prev_type is not File:
-                                if ty.get_origin(prev_type) is ty.Union:
-                                    prev_types = ty.get_args(prev_type)
-                                else:
-                                    prev_types = [prev_type]
-                                return ty.Union.__getitem__(
-                                    (type_,) + tuple(prev_types)
-                                )
-                            return type_
-
-                        test_inpts: ty.Dict[str, ty.Optional[ty.Type]] = {}
-                        for name, val in inpts.items():
-                            if name in file_inputs and name != "flags":
-                                guessed_type = guess_type(val)
-                                input_types[name] = combine_types(
-                                    guessed_type, input_types[name]
-                                )
-                                test_inpts[name] = None
-                            else:
-                                test_inpts[name] = val
-                            if name in file_outputs:
-                                guessed_type = guess_type(val)
-                                output_types[name] = combine_types(
-                                    guessed_type, output_types[name]
-                                )
-                            if name in template_outputs:
-                                output_templates[name] = val
-
-                        tests.append(
-                            fields_stub(
-                                "test",
-                                TestGenerator,
-                                {"inputs": test_inpts, "imports": imports},
-                            )
-                        )
-                        doctests.append(
-                            fields_stub(
-                                "doctest",
-                                DocTestGenerator,
-                                {
-                                    "cmdline": cmdline,
-                                    "inputs": copy(test_inpts),
-                                    "imports": imports,
-                                    "directive": directive,
-                                },
-                            )
-                        )
-                        has_doctests.add(f"{module.replace('/', '.')}.{interface}")
-
-                # Add default template names for fields not explicitly listed in doctests
-                for outpt in template_outputs:
-                    if outpt not in output_templates:
-                        try:
-                            frmt = output_types[outpt]
-                        except KeyError:
-                            ext = ""
-                        else:
-                            if getattr(frmt, "_name", None) == "Union":
-                                ext = ty.get_args(frmt)[0].strext
-                            else:
-                                ext = frmt.strext
-                        output_templates[outpt] = outpt + ext
-
-                # convert to multi-input types to lists
-                input_types = {
-                    n: ty.List[t] if n in multi_inputs else t
-                    for n, t in input_types.items()
-                }
-
-                non_mime = [Path]
-
-                def type2str(tp):
-                    if tp in non_mime:
-                        return tp.__name__
-                    return fileformats.core.utils.to_mime(tp, official=False)
+                spec_name = to_snake_case(interface)
+                yaml_spec = (
+                    parsed.generate_yaml_spec()
+                )
+                unmatched_formats.extend(parsed.unmatched_formats)
+                ambiguous_formats.extend(parsed.ambiguous_formats)
+                pkg_formats.update(parsed.pkg_formats)
+                if parsed.has_doctests:
+                    has_doctests.add(f"{module_str}.{interface}")
+                with open(spec_dir / (spec_name + ".yaml"), "w") as f:
+                    f.write(yaml_spec)
 
-                spec_stub = {
-                    "task_name": interface,
-                    "nipype_name": interface,
-                    "nipype_module": nipype_module_str,
-                    "inputs": fields_stub(
-                        "inputs",
-                        InputsConverter,
-                        {"types": {n: type2str(t) for n, t in input_types.items()}},
-                    ),
-                    "outputs": fields_stub(
-                        "outputs",
-                        OutputsConverter,
-                        {
-                            "types": {n: type2str(t) for n, t in output_types.items()},
-                            "templates": output_templates,
-                            "callables": {n: f"{n}_callable" for n in callables},
-                        },
-                    ),
-                    "tests": tests,
-                    "doctests": doctests,
-                }
-                yaml_str = yaml.dump(spec_stub, indent=2, sort_keys=False, width=4096)
-                # Strip explicit nulls from dumped YAML
-                yaml_str = yaml_str.replace(" null", "")
-                # Inject comments into dumped YAML
-                for category_name, category_class in [
-                    ("inputs", InputsConverter),
-                    ("outputs", OutputsConverter),
-                    ("test", TestGenerator),
-                    ("doctest", DocTestGenerator),
-                ]:
-                    for field in attrs.fields(category_class):
-                        tp = field.type
-                        if tp.__module__ == "builtins":
-                            tp_name = tp.__name__
-                        else:
-                            tp_name = str(tp).lower().replace("typing.", "")
-                        comment = f"  # {tp_name} - " + field.metadata["help"].replace(
-                            "\n                ", "\n  # "
-                        )
-                        yaml_str = re.sub(
-                            f" {category_name}.{field.name}:" + r"(.*)",
-                            f" {field.name}:" + r"\1" + f"\n{comment}",
-                            yaml_str,
-                        )
-                # Add comments to input and output fields, with their type and description
-                for inpt, desc in input_helps.items():
-                    yaml_str = re.sub(
-                        f"    ({inpt}):(.*)",
-                        r"    \1:\2\n    # ##PLACEHOLDER##",
-                        yaml_str,
-                    )
-                    yaml_str = yaml_str.replace("##PLACEHOLDER##", desc)
-                for outpt, desc in output_helps.items():
-                    yaml_str = re.sub(
-                        f"    ({outpt}):(.*)",
-                        r"    \1:\2\n    # ##PLACEHOLDER##",
-                        yaml_str,
-                    )
-                    yaml_str = yaml_str.replace("##PLACEHOLDER##", desc)
+                callables_fspath = spec_dir / f"{spec_name}_callables.py"
 
-                with open(spec_dir / (spec_name + ".yaml"), "w") as f:
-                    f.write(preamble + yaml_str)
-                callables_str = (
-                    f'"""Module to put any functions that are referred to in the "callables"'
-                    f' section of {interface}.yaml"""\n\n'
-                )
-                if callables:
-                    # Convert the "_gen_filename" method into a function with any referenced
-                    # methods, functions and constants included in the module
-                    funcs, imports, consts = get_gen_filename_to_funcs(nipype_interface)
-                    callables_str += "\n".join(imports) + "\n\n"
-                    # Create separate callable function for each callable field, which
-                    # reference the magic "_gen_filename" method
-                    for name in callables:
-                        callables_str += (
-                            f"def {name}_callable(output_dir, inputs, stdout, stderr):\n"
-                            f'    return _gen_filename("{name}", output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr)\n\n'
-                        )
-                    for const in consts:
-                        callables_str += f"{const[0]} = {const[1]}\n" + "\n\n"
-                    callables_str += "\n\n".join(funcs) + "\n\n"
-                # Format the generated code with black
-                try:
-                    callables_str = black.format_file_contents(
-                        callables_str, fast=False, mode=black.FileMode()
-                    )
-                except black.parsing.InvalidInput as e:
-                    raise RuntimeError(
-                        f"Black could not parse generated code: {e}\n\n{callables_str}"
-                    )
                 with open(callables_fspath, "w") as f:
-                    f.write(callables_str)
+                    f.write(parsed.generate_callables(nipype_interface))
 
         with open(
             pkg_dir
@@ -574,442 +208,6 @@ def type2str(tp):
     print("\n".join(sorted(has_doctests)))
 
 
-def initialise_task_repo(output_dir, task_template: Path, pkg: str) -> Path:
-    """Copy the task template to the output directory and customise it for the given
-    package name and return the created package directory"""
-
-    pkg_dir = output_dir / f"pydra-{pkg}"
-
-    def copy_ignore(_, names):
-        return [n for n in names if n in (".git", "__pycache__", ".pytest_cache")]
-
-    shutil.copytree(task_template, pkg_dir, ignore=copy_ignore)
-
-    # Setup script to auto-convert nipype interfaces
-    auto_conv_dir = pkg_dir / "nipype-auto-conv"
-    specs_dir = auto_conv_dir / "specs"
-    specs_dir.mkdir(parents=True)
-    shutil.copy(TEMPLATES_DIR / "nipype-auto-convert.py", auto_conv_dir / "generate")
-    os.chmod(auto_conv_dir / "generate", 0o755)  # make executable
-    shutil.copy(
-        TEMPLATES_DIR / "nipype-auto-convert-requirements.txt",
-        auto_conv_dir / "requirements.txt",
-    )
-
-    # Setup GitHub workflows
-    gh_workflows_dir = pkg_dir / ".github" / "workflows"
-    gh_workflows_dir.mkdir(parents=True, exist_ok=True)
-    shutil.copy(
-        TEMPLATES_DIR / "gh_workflows" / "ci-cd.yaml",
-        gh_workflows_dir / "ci-cd.yaml",
-    )
-
-    # Add modified README
-    os.unlink(pkg_dir / "README.md")
-    shutil.copy(TEMPLATES_DIR / "README.rst", pkg_dir / "README.rst")
-    with open(pkg_dir / "pyproject.toml") as f:
-        pyproject_toml = f.read()
-    pyproject_toml = pyproject_toml.replace("README.md", "README.rst")
-    pyproject_toml = pyproject_toml.replace(
-        "test = [\n", 'test = [\n    "nipype2pydra",\n'
-    )
-    with open(pkg_dir / "pyproject.toml", "w") as f:
-        f.write(pyproject_toml)
-
-    # Add "pydra.tasks.<pkg>.auto to gitignore"
-    with open(pkg_dir / ".gitignore", "a") as f:
-        f.write(f"\n/pydra/tasks/{pkg}/auto" f"\n/pydra/tasks/{pkg}/_version.py\n")
-
-    # rename tasks directory
-    (pkg_dir / "pydra" / "tasks" / "CHANGEME").rename(pkg_dir / "pydra" / "tasks" / pkg)
-    (
-        pkg_dir
-        / "related-packages"
-        / "fileformats"
-        / "fileformats"
-        / "medimage_CHANGEME"
-    ).rename(
-        pkg_dir / "related-packages" / "fileformats" / "fileformats" / f"medimage_{pkg}"
-    )
-    (
-        pkg_dir
-        / "related-packages"
-        / "fileformats-extras"
-        / "fileformats"
-        / "extras"
-        / "medimage_CHANGEME"
-    ).rename(
-        pkg_dir
-        / "related-packages"
-        / "fileformats-extras"
-        / "fileformats"
-        / "extras"
-        / f"medimage_{pkg}"
-    )
-
-    # Add in modified __init__.py
-    shutil.copy(
-        TEMPLATES_DIR / "pkg_init.py", pkg_dir / "pydra" / "tasks" / pkg / "__init__.py"
-    )
-
-    # Replace "CHANGEME" string with pkg name
-    for fspath in pkg_dir.glob("**/*"):
-        if fspath.is_dir():
-            continue
-        with open(fspath) as f:
-            contents = f.read()
-        contents = re.sub(r"(?<![0-9a-zA-Z])CHANGEME(?![0-9a-zA-Z])", pkg, contents)
-        with open(fspath, "w") as f:
-            f.write(contents)
-
-    return pkg_dir
-
-
-def parse_nipype_interface(
-    nipype_interface,
-) -> ty.Tuple[
-    str,
-    ty.Dict[str, str],
-    ty.Dict[str, str],
-    ty.List[str],
-    ty.List[str],
-    ty.List[str],
-    ty.List[str],
-    ty.List[str],
-    ty.List[str],
-]:
-    """Generate preamble comments at start of file with args and doc strings"""
-    input_helps = {}
-    file_inputs = []
-    file_outputs = []
-    dir_inputs = []
-    path_inputs = []
-    template_outputs = []
-    multi_inputs = []
-    dir_outputs = []
-    output_helps = {}
-    callables = []
-    if nipype_interface.output_spec:
-        for outpt_name, outpt in nipype_interface.output_spec().traits().items():
-            if outpt_name in ("trait_added", "trait_modified"):
-                continue
-            outpt_desc = outpt.desc.replace("\n", " ") if outpt.desc else ""
-            output_helps[outpt_name] = (
-                f"type={type(outpt.trait_type).__name__.lower()}: {outpt_desc}"
-            )
-            if type(outpt.trait_type).__name__ == "File":
-                file_outputs.append(outpt_name)
-            elif type(outpt.trait_type).__name__ == "Directory":
-                dir_outputs.append(outpt_name)
-    if nipype_interface.input_spec:
-        for inpt_name, inpt in nipype_interface.input_spec().traits().items():
-            if inpt_name in ("trait_added", "trait_modified"):
-                continue
-            inpt_desc = inpt.desc.replace("\n", " ") if inpt.desc else ""
-            inpt_mdata = f"type={type(inpt.trait_type).__name__.lower()}|default={inpt.default!r}"
-            if isinstance(inpt.trait_type, nipype.interfaces.base.core.traits.Enum):
-                inpt_mdata += f"|allowed[{','.join(sorted(repr(v) for v in inpt.trait_type.values))}]"
-            input_helps[inpt_name] = f"{inpt_mdata}: {inpt_desc}"
-            trait_type_name = type(inpt.trait_type).__name__
-            if inpt.genfile:
-                if trait_type_name in ("File", "Directory"):
-                    path_inputs.append(inpt_name)
-                if inpt_name in (file_outputs + dir_outputs):
-                    template_outputs.append(inpt_name)
-                else:
-                    callables.append(inpt_name)
-            elif trait_type_name == "File" and inpt_name not in file_outputs:
-                file_inputs.append(inpt_name)
-            elif trait_type_name == "Directory" and inpt_name not in dir_outputs:
-                dir_inputs.append(inpt_name)
-            elif trait_type_name == "InputMultiObject":
-                inner_trait_type_name = type(
-                    inpt.trait_type.item_trait.trait_type
-                ).__name__
-                if inner_trait_type_name == "Directory":
-                    dir_inputs.append(inpt_name)
-                elif inner_trait_type_name == "File":
-                    file_inputs.append(inpt_name)
-                multi_inputs.append(inpt_name)
-            elif type(inpt.trait_type).__name__ == "List" and type(
-                inpt.trait_type.inner_traits()[0].handler
-            ).__name__ in ("File", "Directory"):
-                item_type_name = type(
-                    inpt.trait_type.inner_traits()[0].handler
-                ).__name__
-                if item_type_name == "File":
-                    file_inputs.append(inpt_name)
-                else:
-                    dir_inputs.append(inpt_name)
-                multi_inputs.append(inpt_name)
-            elif trait_type_name in ("File", "Directory"):
-                path_inputs.append(inpt_name)
-    doc_string = nipype_interface.__doc__ if nipype_interface.__doc__ else ""
-    doc_string = doc_string.replace("\n", "\n# ")
-    # Create a preamble at the top of the specificaiton explaining what to do
-    preamble = (
-        f"""# This file is used to manually specify the semi-automatic conversion of
-        # '{nipype_interface.__module__.replace('/', '.')}.{nipype_interface.__name__}' from Nipype to Pydra.
-        #
-        # Please fill-in/edit the fields below where appropriate
-        #
-        # Docs
-        # ----
-        # {doc_string}\n"""
-    ).replace("        #", "#")
-    return (
-        preamble,
-        input_helps,
-        output_helps,
-        file_inputs,
-        path_inputs,
-        file_outputs,
-        template_outputs,
-        multi_inputs,
-        dir_inputs,
-        dir_outputs,
-        callables,
-    )
-
-
-def extract_doctest_inputs(
-    doctest: str, interface: str
-) -> ty.Tuple[
-    ty.Optional[str], ty.Dict[str, ty.Any], ty.Optional[str], ty.List[ty.Dict[str, str]]
-]:
-    """Extract the inputs passed to tasks in the doctests of Nipype interfaces
-
-    Parameters
-    ----------
-    doctest : str
-        the doc string of the interface
-    interface : str
-        the name of the interface
-
-    Returns
-    -------
-    cmdline : str
-        the expected cmdline
-    inputs : dict[str, ty.Any]
-        the inputs passed to the task
-    directive : str
-        any doctest directives found after the cmdline, e.g. ELLIPSIS"""
-    match = re.search(
-        r"""^\s+>>> (?:.*)\.cmdline(\s*# doctest: .*)?\n\s*('|")(.*)(?:'|")?\s*.*(?!>>>)\2""",
-        doctest,
-        flags=re.MULTILINE | re.DOTALL,
-    )
-    if match:
-        cmdline = match.group(3)
-        cmdline = re.sub(r"\s+", " ", cmdline)
-        cmdline = cmdline.replace("'", '"') if '"' not in cmdline else cmdline
-        directive = match.group(2)
-        if directive == '"' or directive == "'":
-            directive = None
-    else:
-        cmdline = directive = None
-    doctest_inpts = {
-        n: v.replace("'", '"') if '"' not in v else v
-        for n, v in re.findall(
-            r"""\s+>>> (?:\w+)\.inputs\.(\w+) ?= ?(.*)\n""",
-            doctest,
-        )
-    }
-    match = re.search(
-        interface + r"""\(([^\)]+)\)(\n|  ?#|\.cmdline)""",
-        doctest,
-    )
-    if match is not None:
-        arg_str = match.group(1) + ", "
-        doctest_inpts.update(
-            {
-                n: v.replace("'", '"') if '"' not in v else v
-                for n, v in re.findall(r"(\w+) *= *([^=]+), *", arg_str)
-            }
-        )
-    imports = []
-    for ln in doctest.splitlines():
-        if re.match(r".*>>>.*(?<!\w)import(?!\w)", ln):
-            match = re.match(r".*>>> import (.*)$", ln)
-            if match:
-                for mod in match.group(1).split(","):
-                    imports.append({"module": mod.strip()})
-            else:
-                match = re.match(r".*>>> from ([\w\.]+) import (.*)", ln)
-                if not match:
-                    raise ValueError(f"Could not parse import statement: {ln}")
-                module = match.group(1)
-                if "nipype.interfaces" in module:
-                    continue
-                for atr in match.group(2).split(","):
-                    match = re.match(r"(\w+) as ((\w+))", atr)
-                    if match:
-                        name = match.group(1)
-                        alias = match.group(2)
-                    else:
-                        name = atr
-                        alias = None
-                    imports.append(
-                        {
-                            "module": module,
-                            "name": name,
-                            "alias": alias,
-                        }
-                    )
-    if not doctest_inpts:
-        raise ValueError(f"Could not parse doctest:\n{doctest}")
-
-    if not directive or directive == "''" or directive == '""':
-        directive = None
-
-    return cmdline, doctest_inpts, directive, imports
-
-
-def gen_fileformats_module(pkg_formats: ty.Set[str]):
-    code_str = "from fileformats.generic import File"
-    for ext in pkg_formats:
-        frmt = ext2format_name(ext)
-        code_str += f"""
-
-class {frmt}(File):
-    ext = "{ext}"
-    binary = True
-"""
-    return code_str
-
-
-def gen_fileformats_extras_module(pkg: str, pkg_formats: ty.Set[str]):
-    code_str = """from pathlib import Path
-import typing as ty
-from random import Random
-from fileformats.core import FileSet
-"""
-    code_str += f"from fileformats.medimage_{pkg} import (\n"
-    for ext in pkg_formats:
-        frmt = ext2format_name(ext)
-        code_str += f"    {frmt},\n"
-    code_str += ")\n\n"
-    for ext in pkg_formats:
-        frmt = ext2format_name(ext)
-        code_str += f"""
-
-@FileSet.generate_sample_data.register
-def gen_sample_{frmt.lower()}_data({frmt.lower()}: {frmt}, dest_dir: Path, seed: ty.Union[int, Random] = 0, stem: ty.Optional[str] = None) -> ty.Iterable[Path]:
-    raise NotImplementedError
-"""
-    return code_str
-
-
-def get_gen_filename_to_funcs(
-    nipype_interface,
-) -> ty.Tuple[ty.List[str], ty.Set[str], ty.Set[ty.Tuple[str, str]]]:
-    """
-    Convert the _gen_filename method of a nipype interface into a function that can be
-    imported and used by the auto-convert scripts
-
-    Parameters
-    ----------
-    nipype_interface : type
-        the nipype interface to convert
-
-    Returns
-    -------
-    list[str]
-        the source code of functions to be added to the callables
-    set[str]
-        the imports required for the function
-    set[tuple[str, str]]
-        the external constants required by the function, as (name, value) tuples
-    """
-
-    if not hasattr(nipype_interface, "_gen_filename"):
-        func_src = f"""
-def _gen_filename(field, inputs, output_dir, stdout, stderr):
-    raise NotImplementedError(
-        "Could not find '_gen_filename' method in {nipype_interface.__module__}.{nipype_interface.__name__}"
-    )
-"""
-        warn(f"Could not find '_gen_filename' method in {nipype_interface}")
-        return [func_src], set(), set()
-
-    IMPLICIT_ARGS = ["inputs", "stdout", "stderr", "output_dir"]
-
-    def find_nested_methods(method: ty.Callable) -> ty.List[str]:
-        all_nested = set()
-        for match in re.findall(r"self\.(\w+)\(", inspect.getsource(method)):
-            nested = getattr(nipype_interface, match)
-            all_nested.add(nested)
-            all_nested.update(find_nested_methods(nested))
-        return all_nested
-
-    def process_method(method: ty.Callable) -> str:
-        src = inspect.getsource(method)
-        prefix, args_str, body = split_parens_contents(src)
-        body = insert_args_in_method_calls(body, [f"{a}={a}" for a in IMPLICIT_ARGS])
-        body = body.replace("self.cmd", f'"{nipype_interface._cmd}"')
-        body = body.replace("self.", "")
-        body = re.sub(r"\w+runtime\.(stdout|stderr)", r"\1", body)
-        body = body.replace("os.getcwd()", "output_dir")
-        # drop 'self' from the args and add the implicit callable args
-        args = args_str.split(",")[1:]
-        arg_names = [a.split("=")[0].split(":")[0] for a in args]
-        for implicit in IMPLICIT_ARGS:
-            if implicit not in arg_names:
-                args.append(f"{implicit}=None")
-        src = prefix + ", ".join(args) + body
-        src = cleanup_function_body(src, with_signature=True)
-        return src
-
-    def insert_args_in_method_calls(src: str, args: ty.List[ty.Tuple[str, str]]) -> str:
-        """Insert additional arguments into the method calls
-
-        Parameters
-        ----------
-        body : str
-            the body of th
-        args : list[tuple[str, str]]
-            the arguments to insert into the method calls
-        """
-        # Split the src code into chunks delimited by calls to methods (i.e. 'self.<method>(.*)')
-        method_re = re.compile(r"self\.(\w+)(?=\()", flags=re.MULTILINE | re.DOTALL)
-        splits = method_re.split(src)
-        new_src = splits[0]
-        # Iterate through these chunks and add the additional args to the method calls
-        # using insert_args_in_signature function
-        for name, sig in zip(splits[1::2], splits[2::2]):
-            new_src += name + insert_args_in_signature(sig, args)
-        return new_src
-
-    func_srcs = [
-        process_method(m)
-        for m in (
-            [nipype_interface._gen_filename]
-            + list(find_nested_methods(nipype_interface._gen_filename))
-        )
-    ]
-
-    mod = import_module(nipype_interface.__module__)
-    used = UsedSymbols.find(mod, func_srcs)
-    for func in used.local_functions:
-        func_srcs.append(
-            cleanup_function_body(inspect.getsource(func), with_signature=True)
-        )
-    for new_func_name, func in used.funcs_to_include:
-        func_src = inspect.getsource(func)
-        match = re.match(
-            r" *(def|class) *" + func.__name__ + r"(?=\()(.*)$",
-            func_src,
-            re.DOTALL | re.MULTILINE,
-        )
-        func_src = match.group(1) + " " + new_func_name + match.group(2)
-        func_srcs.append(cleanup_function_body(func_src, with_signature=True))
-    return (
-        func_srcs,
-        used.imports,
-        used.constants,
-    )
-
-
 if __name__ == "__main__":
     import sys
 
diff --git a/nipype2pydra/pkg_gen/__init__.py b/nipype2pydra/pkg_gen/__init__.py
new file mode 100644
index 00000000..87d70968
--- /dev/null
+++ b/nipype2pydra/pkg_gen/__init__.py
@@ -0,0 +1,848 @@
+import os
+import typing as ty
+import re
+import inspect
+from importlib import import_module
+from copy import copy
+import shutil
+import string
+from pathlib import Path
+import attrs
+from warnings import warn
+import requests
+import yaml
+import black.parsing
+import fileformats.core.utils
+import fileformats.core.mixin
+from fileformats.generic import File, Directory
+from fileformats.medimage import Nifti1, NiftiGz, Bval, Bvec
+from fileformats.application import Dicom, Xml
+from fileformats.text import TextFile
+from fileformats.datascience import TextMatrix, DatFile
+import nipype.interfaces.base.core
+from nipype2pydra.task import (
+    InputsConverter,
+    OutputsConverter,
+    TestGenerator,
+    DocTestGenerator,
+)
+from nipype2pydra.utils import (
+    UsedSymbols,
+    split_parens_contents,
+    cleanup_function_body,
+    insert_args_in_signature,
+)
+
+
+TEMPLATES_DIR = Path(__file__).parent.parent / "pkg_gen" / "resources" / "templates"
+
+EXPECTED_FORMATS = [Nifti1, NiftiGz, TextFile, TextMatrix, DatFile, Xml]
+
+EXT_SPECIAL_CHARS = tuple((set(string.punctuation) - set(".-")) | set(" "))
+
+
+def ext2format_name(ext: str) -> str:
+    return escape_leading_digits(ext[1:]).capitalize()
+
+
+def escape_leading_digits(name: str) -> str:
+    for k, v in ESCAPE_DIGITS.items():
+        if name.startswith(k):
+            name = v + name[1:]
+            return name
+    return name
+
+
+ESCAPE_DIGITS = {
+    "1": "one",
+    "2": "two",
+    "3": "three",
+    "4": "four",
+    "5": "five",
+    "6": "six",
+    "7": "seven",
+    "8": "eight",
+    "9": "nine",
+}
+
+
+@attrs.define
+class NipypeInterface:
+    """A class to hold the parsed structure of a Nipype interface"""
+
+    name: str
+    doc_str: str
+    module: str
+    pkg: str
+    base_package: str
+    preamble: str = attrs.field()
+    input_helps: ty.Dict[str, str] = attrs.field()
+    output_helps: ty.Dict[str, str] = attrs.field()
+    file_inputs: ty.Dict[str, str] = attrs.field()
+    path_inputs: ty.List[str] = attrs.field()
+    file_outputs: ty.List[str] = attrs.field()
+    template_outputs: ty.List[str] = attrs.field()
+    multi_inputs: ty.List[str] = attrs.field()
+    dir_inputs: ty.List[str] = attrs.field()
+    dir_outputs: ty.List[str] = attrs.field()
+    callables: ty.List[str] = attrs.field()
+
+    unmatched_formats: ty.List[str] = attrs.field(factory=list)
+    ambiguous_formats: ty.List[str] = attrs.field(factory=list)
+    pkg_formats: ty.Set[str] = attrs.field(factory=set)
+    has_doctests: bool = False
+
+    @classmethod
+    def parse(
+        cls, nipype_interface: type, pkg: str, base_package: str
+    ) -> "NipypeInterface":
+        """Generate preamble comments at start of file with args and doc strings"""
+        input_helps = {}
+        file_inputs = []
+        file_outputs = []
+        dir_inputs = []
+        path_inputs = []
+        template_outputs = []
+        multi_inputs = []
+        dir_outputs = []
+        output_helps = {}
+        callables = []
+        if nipype_interface.output_spec:
+            for outpt_name, outpt in nipype_interface.output_spec().traits().items():
+                if outpt_name in ("trait_added", "trait_modified"):
+                    continue
+                outpt_desc = outpt.desc.replace("\n", " ") if outpt.desc else ""
+                output_helps[outpt_name] = (
+                    f"type={type(outpt.trait_type).__name__.lower()}: {outpt_desc}"
+                )
+                if type(outpt.trait_type).__name__ == "File":
+                    file_outputs.append(outpt_name)
+                elif type(outpt.trait_type).__name__ == "Directory":
+                    dir_outputs.append(outpt_name)
+        if nipype_interface.input_spec:
+            for inpt_name, inpt in nipype_interface.input_spec().traits().items():
+                if inpt_name in ("trait_added", "trait_modified"):
+                    continue
+                inpt_desc = inpt.desc.replace("\n", " ") if inpt.desc else ""
+                inpt_mdata = f"type={type(inpt.trait_type).__name__.lower()}|default={inpt.default!r}"
+                if isinstance(inpt.trait_type, nipype.interfaces.base.core.traits.Enum):
+                    inpt_mdata += f"|allowed[{','.join(sorted(repr(v) for v in inpt.trait_type.values))}]"
+                input_helps[inpt_name] = f"{inpt_mdata}: {inpt_desc}"
+                trait_type_name = type(inpt.trait_type).__name__
+                if inpt.genfile:
+                    if trait_type_name in ("File", "Directory"):
+                        path_inputs.append(inpt_name)
+                    if inpt_name in (file_outputs + dir_outputs):
+                        template_outputs.append(inpt_name)
+                    else:
+                        callables.append(inpt_name)
+                elif trait_type_name == "File" and inpt_name not in file_outputs:
+                    file_inputs.append(inpt_name)
+                elif trait_type_name == "Directory" and inpt_name not in dir_outputs:
+                    dir_inputs.append(inpt_name)
+                elif trait_type_name == "InputMultiObject":
+                    inner_trait_type_name = type(
+                        inpt.trait_type.item_trait.trait_type
+                    ).__name__
+                    if inner_trait_type_name == "Directory":
+                        dir_inputs.append(inpt_name)
+                    elif inner_trait_type_name == "File":
+                        file_inputs.append(inpt_name)
+                    multi_inputs.append(inpt_name)
+                elif type(inpt.trait_type).__name__ == "List" and type(
+                    inpt.trait_type.inner_traits()[0].handler
+                ).__name__ in ("File", "Directory"):
+                    item_type_name = type(
+                        inpt.trait_type.inner_traits()[0].handler
+                    ).__name__
+                    if item_type_name == "File":
+                        file_inputs.append(inpt_name)
+                    else:
+                        dir_inputs.append(inpt_name)
+                    multi_inputs.append(inpt_name)
+                elif trait_type_name in ("File", "Directory"):
+                    path_inputs.append(inpt_name)
+        doc_string = nipype_interface.__doc__ if nipype_interface.__doc__ else ""
+        doc_string = doc_string.replace("\n", "\n# ")
+        # Create a preamble at the top of the specificaiton explaining what to do
+        preamble = (
+            f"""# This file is used to manually specify the semi-automatic conversion of
+            # '{nipype_interface.__module__.replace('/', '.')}.{nipype_interface.__name__}' from Nipype to Pydra.
+            #
+            # Please fill-in/edit the fields below where appropriate
+            #
+            # Docs
+            # ----
+            # {doc_string}\n"""
+        ).replace("        #", "#")
+        return cls(
+            name=nipype_interface.__name__,
+            doc_str=nipype_interface.__doc__ if nipype_interface.__doc__ else "",
+            module=nipype_interface.__module__[len(base_package) + 1 :],
+            pkg=pkg,
+            base_package=base_package,
+            preamble=preamble,
+            input_helps=input_helps,
+            output_helps=output_helps,
+            file_inputs=file_inputs,
+            path_inputs=path_inputs,
+            file_outputs=file_outputs,
+            template_outputs=template_outputs,
+            multi_inputs=multi_inputs,
+            dir_inputs=dir_inputs,
+            dir_outputs=dir_outputs,
+            callables=callables,
+        )
+
+    def generate_yaml_spec(self) -> str:
+        """Convert the NipypeInterface to a YAML string"""
+
+        input_types = {i: File for i in self.file_inputs}
+        input_types.update({i: Directory for i in self.dir_inputs})
+        input_types.update({i: Path for i in self.path_inputs})
+        output_types = {o: File for o in self.file_outputs}
+        output_types.update({o: Directory for o in self.dir_outputs})
+        output_templates = {}
+
+        # Attempt to parse doctest to pull out sensible defaults for input/output
+        # values
+        stripped_doc_str = re.sub(r"\n\s+\.\.\.\s+", "", self.doc_str)
+        prev_block = ""
+        doctest_blocks = []
+        for para in stripped_doc_str.split("\n\n"):
+            if "cmdline" in para:
+                doctest_blocks.append(prev_block + "\n" + para)
+                prev_block = ""
+            elif ">>>" in para:
+                prev_block += "\n" + para
+
+        # Add default template names for fields not explicitly listed in doctests
+        for outpt in self.template_outputs:
+            if outpt not in output_templates:
+                try:
+                    frmt = output_types[outpt]
+                except KeyError:
+                    ext = ""
+                else:
+                    if getattr(frmt, "_name", None) == "Union":
+                        ext = ty.get_args(frmt)[0].strext
+                    else:
+                        ext = frmt.strext
+                output_templates[outpt] = outpt + ext
+
+        # convert to multi-input types to lists
+        input_types = {
+            n: ty.List[t] if n in self.multi_inputs else t
+            for n, t in input_types.items()
+        }
+
+        non_mime = [Path]
+
+        def type2str(tp):
+            if tp in non_mime:
+                return tp.__name__
+            return fileformats.core.utils.to_mime(tp, official=False)
+
+        tests, doctests = self._gen_tests(
+            doctest_blocks, input_types, output_types, output_templates
+        )
+
+        spec_stub = {
+            "task_name": self.name,
+            "nipype_name": self.name,
+            "nipype_module": self.base_package + "." + self.module,
+            "inputs": self._fields_stub(
+                "inputs",
+                InputsConverter,
+                {"types": {n: type2str(t) for n, t in input_types.items()}},
+            ),
+            "outputs": self._fields_stub(
+                "outputs",
+                OutputsConverter,
+                {
+                    "types": {n: type2str(t) for n, t in output_types.items()},
+                    "templates": output_templates,
+                    "callables": {n: f"{n}_callable" for n in self.callables},
+                },
+            ),
+            "tests": tests,
+            "doctests": doctests,
+        }
+        yaml_str = yaml.dump(spec_stub, indent=2, sort_keys=False, width=4096)
+        # Strip explicit nulls from dumped YAML
+        yaml_str = yaml_str.replace(" null", "")
+        # Inject comments into dumped YAML
+        for category_name, category_class in [
+            ("inputs", InputsConverter),
+            ("outputs", OutputsConverter),
+            ("test", TestGenerator),
+            ("doctest", DocTestGenerator),
+        ]:
+            for field in attrs.fields(category_class):
+                tp = field.type
+                if tp.__module__ == "builtins":
+                    tp_name = tp.__name__
+                else:
+                    tp_name = str(tp).lower().replace("typing.", "")
+                comment = f"  # {tp_name} - " + field.metadata["help"].replace(
+                    "\n                ", "\n  # "
+                )
+                yaml_str = re.sub(
+                    f" {category_name}.{field.name}:" + r"(.*)",
+                    f" {field.name}:" + r"\1" + f"\n{comment}",
+                    yaml_str,
+                )
+        # Add comments to input and output fields, with their type and description
+        for inpt, desc in self.input_helps.items():
+            yaml_str = re.sub(
+                f"    ({inpt}):(.*)",
+                r"    \1:\2\n    # ##PLACEHOLDER##",
+                yaml_str,
+            )
+            yaml_str = yaml_str.replace("##PLACEHOLDER##", desc)
+        for outpt, desc in self.output_helps.items():
+            yaml_str = re.sub(
+                f"    ({outpt}):(.*)",
+                r"    \1:\2\n    # ##PLACEHOLDER##",
+                yaml_str,
+            )
+            yaml_str = yaml_str.replace("##PLACEHOLDER##", desc)
+        return self.preamble + yaml_str
+
+    def generate_callables(self, nipype_interface) -> str:
+        callables_str = (
+            f'"""Module to put any functions that are referred to in the "callables"'
+            f' section of {self.name}.yaml"""\n\n'
+        )
+        if self.callables:
+            # Convert the "_gen_filename" method into a function with any referenced
+            # methods, functions and constants included in the module
+            funcs, imports, consts = get_gen_filename_to_funcs(nipype_interface)
+            callables_str += "\n".join(imports) + "\n\n"
+            # Create separate callable function for each callable field, which
+            # reference the magic "_gen_filename" method
+            for name in self.callables:
+                callables_str += (
+                    f"def {name}_callable(output_dir, inputs, stdout, stderr):\n"
+                    f'    return _gen_filename("{name}", output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr)\n\n'
+                )
+            for const in consts:
+                callables_str += f"{const[0]} = {const[1]}\n" + "\n\n"
+            callables_str += "\n\n".join(funcs) + "\n\n"
+        # Format the generated code with black
+        try:
+            callables_str = black.format_file_contents(
+                callables_str, fast=False, mode=black.FileMode()
+            )
+        except black.parsing.InvalidInput as e:
+            raise RuntimeError(
+                f"Black could not parse generated code: {e}\n\n{callables_str}"
+            )
+        return callables_str
+
+    def _gen_tests(
+        self, doctest_blocks, input_types, output_types, output_templates
+    ) -> ty.Tuple[ty.List[TestGenerator], ty.List[DocTestGenerator]]:
+
+        doctests: ty.List[DocTestGenerator] = []
+        tests: ty.List[TestGenerator] = [
+            self._fields_stub(
+                "test",
+                TestGenerator,
+                {"inputs": {i: None for i in self.input_helps}, "imports": None},
+            )
+        ]
+
+        for doctest_str in doctest_blocks:
+            if ">>>" in doctest_str:
+                try:
+                    cmdline, inpts, directive, imports = extract_doctest_inputs(
+                        doctest_str, self.name
+                    )
+                except ValueError:
+                    intf_name = f"{self.module}.{self.name}"
+                    warn(f"Could not parse doctest for {intf_name}:\n{doctest_str}")
+                    continue
+
+                def guess_type(fspath):
+                    try:
+                        fspath = re.search(r"""['"]([^'"]*)['"]""", fspath).group(1)
+                    except AttributeError:
+                        return File
+                    possible_formats = []
+                    for frmt in fileformats.core.FileSet.all_formats:
+                        if not frmt.ext or None in frmt.alternate_exts:
+                            continue
+                        if frmt.matching_exts(fspath):
+                            possible_formats.append(frmt)
+                    if not possible_formats:
+                        if fspath.endswith(".dcm"):
+                            return Dicom
+                        if fspath == "bvals":
+                            return Bval
+                        if fspath == "bvecs":
+                            return Bvec
+                        format_ext = File.decompose_fspath(
+                            fspath.strip(),
+                            mode=File.ExtensionDecomposition.single,
+                        )[2]
+                        if any(c in format_ext for c in EXT_SPECIAL_CHARS):
+                            return File  # Skip any extensions with special chars
+                        self.unmatched_formats.append(
+                            f"{self.module}.{self.name}: {fspath}"
+                        )
+                        if format_ext:
+                            self.pkg_formats.add(format_ext)
+                            return f"fileformats.medimage_{self.pkg}.{ext2format_name(format_ext)}"
+                        return File
+
+                    for expected in EXPECTED_FORMATS:
+                        if expected in possible_formats:
+                            return expected
+                    if len(possible_formats) > 1:
+                        non_adjacent = [
+                            f
+                            for f in possible_formats
+                            if not issubclass(
+                                f, fileformats.core.mixin.WithAdjacentFiles
+                            )
+                        ]
+                        if non_adjacent:
+                            possible_formats = non_adjacent
+                    if len(possible_formats) > 1:
+                        possible_formats = sorted(
+                            possible_formats, key=lambda f: f.__name__
+                        )
+                        self.ambiguous_formats.append(possible_formats)
+                    return possible_formats[0]
+
+                def combine_types(type_, prev_type):
+                    if type_ is File:
+                        return prev_type
+                    if prev_type is not File:
+                        if ty.get_origin(prev_type) is ty.Union:
+                            prev_types = ty.get_args(prev_type)
+                        else:
+                            prev_types = [prev_type]
+                        return ty.Union.__getitem__((type_,) + tuple(prev_types))
+                    return type_
+
+                test_inpts: ty.Dict[str, ty.Optional[ty.Type]] = {}
+                for name, val in inpts.items():
+                    if name in self.file_inputs and name != "flags":
+                        guessed_type = guess_type(val)
+                        input_types[name] = combine_types(
+                            guessed_type, input_types[name]
+                        )
+                        test_inpts[name] = None
+                    else:
+                        test_inpts[name] = val
+                    if name in self.file_outputs:
+                        guessed_type = guess_type(val)
+                        output_types[name] = combine_types(
+                            guessed_type, output_types[name]
+                        )
+                    if name in self.template_outputs:
+                        output_templates[name] = val
+
+                tests.append(
+                    self._fields_stub(
+                        "test",
+                        TestGenerator,
+                        {"inputs": test_inpts, "imports": imports},
+                    )
+                )
+                doctests.append(
+                    self._fields_stub(
+                        "doctest",
+                        DocTestGenerator,
+                        {
+                            "cmdline": cmdline,
+                            "inputs": copy(test_inpts),
+                            "imports": imports,
+                            "directive": directive,
+                        },
+                    )
+                )
+                self.has_doctests = True
+        return tests, doctests
+
+    # Create "stubs" for each of the available fields
+    @classmethod
+    def _fields_stub(cls, name, category_class, values=None):
+        """Used, in conjunction with some find/replaces after dumping, to
+        insert comments into the YAML file"""
+        dct = {}
+        for field in attrs.fields(category_class):
+            field_name = f"{name}.{field.name}"
+            try:
+                val = values[field.name]
+            except (KeyError, TypeError):
+                val = (
+                    field.default
+                    if (
+                        field.default != attrs.NOTHING
+                        and not isinstance(field.default, attrs.Factory)
+                    )
+                    else None
+                )
+            else:
+                if isinstance(val, ty.Iterable) and not val:
+                    val = None
+            dct[field_name] = val
+        return dct
+
+
+def download_tasks_template(output_path: Path):
+    """Downloads the latest pydra-template to the output path"""
+
+    release_url = (
+        "https://api.github.com/repos/nipype/pydra-tasks-template/releases/latest"
+    )
+    headers = {"Accept": "application/vnd.github.v3+json", "User-Agent": "nipype2pydra"}
+
+    response = requests.get(release_url, headers=headers)
+    if response.status_code != 200:
+        raise RuntimeError(f"Did not find release at '{release_url}'")
+    data = response.json()
+    tarball_url = data["tarball_url"]
+
+    response = requests.get(tarball_url)
+
+    if response.status_code == 200:
+        # Save the response content to a file
+        with open(output_path, "wb") as f:
+            f.write(response.content)
+    else:
+        raise RuntimeError(
+            f"Could not download the pydra-tasks template at {release_url}"
+        )
+
+
+def initialise_task_repo(output_dir, task_template: Path, pkg: str) -> Path:
+    """Copy the task template to the output directory and customise it for the given
+    package name and return the created package directory"""
+
+    pkg_dir = output_dir / f"pydra-{pkg}"
+
+    def copy_ignore(_, names):
+        return [n for n in names if n in (".git", "__pycache__", ".pytest_cache")]
+
+    shutil.copytree(task_template, pkg_dir, ignore=copy_ignore)
+
+    # Setup script to auto-convert nipype interfaces
+    auto_conv_dir = pkg_dir / "nipype-auto-conv"
+    specs_dir = auto_conv_dir / "specs"
+    specs_dir.mkdir(parents=True)
+    shutil.copy(TEMPLATES_DIR / "nipype-auto-convert.py", auto_conv_dir / "generate")
+    os.chmod(auto_conv_dir / "generate", 0o755)  # make executable
+    shutil.copy(
+        TEMPLATES_DIR / "nipype-auto-convert-requirements.txt",
+        auto_conv_dir / "requirements.txt",
+    )
+
+    # Setup GitHub workflows
+    gh_workflows_dir = pkg_dir / ".github" / "workflows"
+    gh_workflows_dir.mkdir(parents=True, exist_ok=True)
+    shutil.copy(
+        TEMPLATES_DIR / "gh_workflows" / "ci-cd.yaml",
+        gh_workflows_dir / "ci-cd.yaml",
+    )
+
+    # Add modified README
+    os.unlink(pkg_dir / "README.md")
+    shutil.copy(TEMPLATES_DIR / "README.rst", pkg_dir / "README.rst")
+    with open(pkg_dir / "pyproject.toml") as f:
+        pyproject_toml = f.read()
+    pyproject_toml = pyproject_toml.replace("README.md", "README.rst")
+    pyproject_toml = pyproject_toml.replace(
+        "test = [\n", 'test = [\n    "nipype2pydra",\n'
+    )
+    with open(pkg_dir / "pyproject.toml", "w") as f:
+        f.write(pyproject_toml)
+
+    # Add "pydra.tasks.<pkg>.auto to gitignore"
+    with open(pkg_dir / ".gitignore", "a") as f:
+        f.write(f"\n/pydra/tasks/{pkg}/auto" f"\n/pydra/tasks/{pkg}/_version.py\n")
+
+    # rename tasks directory
+    (pkg_dir / "pydra" / "tasks" / "CHANGEME").rename(pkg_dir / "pydra" / "tasks" / pkg)
+    (
+        pkg_dir
+        / "related-packages"
+        / "fileformats"
+        / "fileformats"
+        / "medimage_CHANGEME"
+    ).rename(
+        pkg_dir / "related-packages" / "fileformats" / "fileformats" / f"medimage_{pkg}"
+    )
+    (
+        pkg_dir
+        / "related-packages"
+        / "fileformats-extras"
+        / "fileformats"
+        / "extras"
+        / "medimage_CHANGEME"
+    ).rename(
+        pkg_dir
+        / "related-packages"
+        / "fileformats-extras"
+        / "fileformats"
+        / "extras"
+        / f"medimage_{pkg}"
+    )
+
+    # Add in modified __init__.py
+    shutil.copy(
+        TEMPLATES_DIR / "pkg_init.py", pkg_dir / "pydra" / "tasks" / pkg / "__init__.py"
+    )
+
+    # Replace "CHANGEME" string with pkg name
+    for fspath in pkg_dir.glob("**/*"):
+        if fspath.is_dir():
+            continue
+        with open(fspath) as f:
+            contents = f.read()
+        contents = re.sub(r"(?<![0-9a-zA-Z])CHANGEME(?![0-9a-zA-Z])", pkg, contents)
+        with open(fspath, "w") as f:
+            f.write(contents)
+
+    return pkg_dir
+
+
+def extract_doctest_inputs(
+    doctest: str, interface: str
+) -> ty.Tuple[
+    ty.Optional[str], ty.Dict[str, ty.Any], ty.Optional[str], ty.List[ty.Dict[str, str]]
+]:
+    """Extract the inputs passed to tasks in the doctests of Nipype interfaces
+
+    Parameters
+    ----------
+    doctest : str
+        the doc string of the interface
+    interface : str
+        the name of the interface
+
+    Returns
+    -------
+    cmdline : str
+        the expected cmdline
+    inputs : dict[str, ty.Any]
+        the inputs passed to the task
+    directive : str
+        any doctest directives found after the cmdline, e.g. ELLIPSIS"""
+    match = re.search(
+        r"""^\s+>>> (?:.*)\.cmdline(\s*# doctest: .*)?\n\s*('|")(.*)(?:'|")?\s*.*(?!>>>)\2""",
+        doctest,
+        flags=re.MULTILINE | re.DOTALL,
+    )
+    if match:
+        cmdline = match.group(3)
+        cmdline = re.sub(r"\s+", " ", cmdline)
+        cmdline = cmdline.replace("'", '"') if '"' not in cmdline else cmdline
+        directive = match.group(2)
+        if directive == '"' or directive == "'":
+            directive = None
+    else:
+        cmdline = directive = None
+    doctest_inpts = {
+        n: v.replace("'", '"') if '"' not in v else v
+        for n, v in re.findall(
+            r"""\s+>>> (?:\w+)\.inputs\.(\w+) ?= ?(.*)\n""",
+            doctest,
+        )
+    }
+    match = re.search(
+        interface + r"""\(([^\)]+)\)(\n|  ?#|\.cmdline)""",
+        doctest,
+    )
+    if match is not None:
+        arg_str = match.group(1) + ", "
+        doctest_inpts.update(
+            {
+                n: v.replace("'", '"') if '"' not in v else v
+                for n, v in re.findall(r"(\w+) *= *([^=]+), *", arg_str)
+            }
+        )
+    imports = []
+    for ln in doctest.splitlines():
+        if re.match(r".*>>>.*(?<!\w)import(?!\w)", ln):
+            match = re.match(r".*>>> import (.*)$", ln)
+            if match:
+                for mod in match.group(1).split(","):
+                    imports.append({"module": mod.strip()})
+            else:
+                match = re.match(r".*>>> from ([\w\.]+) import (.*)", ln)
+                if not match:
+                    raise ValueError(f"Could not parse import statement: {ln}")
+                module = match.group(1)
+                if "nipype.interfaces" in module:
+                    continue
+                for atr in match.group(2).split(","):
+                    match = re.match(r"(\w+) as ((\w+))", atr)
+                    if match:
+                        name = match.group(1)
+                        alias = match.group(2)
+                    else:
+                        name = atr
+                        alias = None
+                    imports.append(
+                        {
+                            "module": module,
+                            "name": name,
+                            "alias": alias,
+                        }
+                    )
+    if not doctest_inpts:
+        raise ValueError(f"Could not parse doctest:\n{doctest}")
+
+    if not directive or directive == "''" or directive == '""':
+        directive = None
+
+    return cmdline, doctest_inpts, directive, imports
+
+
+def gen_fileformats_module(pkg_formats: ty.Set[str]):
+    code_str = "from fileformats.generic import File"
+    for ext in pkg_formats:
+        frmt = ext2format_name(ext)
+        code_str += f"""
+
+class {frmt}(File):
+    ext = "{ext}"
+    binary = True
+"""
+    return code_str
+
+
+def gen_fileformats_extras_module(pkg: str, pkg_formats: ty.Set[str]):
+    code_str = """from pathlib import Path
+import typing as ty
+from random import Random
+from fileformats.core import FileSet
+"""
+    code_str += f"from fileformats.medimage_{pkg} import (\n"
+    for ext in pkg_formats:
+        frmt = ext2format_name(ext)
+        code_str += f"    {frmt},\n"
+    code_str += ")\n\n"
+    for ext in pkg_formats:
+        frmt = ext2format_name(ext)
+        code_str += f"""
+
+@FileSet.generate_sample_data.register
+def gen_sample_{frmt.lower()}_data({frmt.lower()}: {frmt}, dest_dir: Path, seed: ty.Union[int, Random] = 0, stem: ty.Optional[str] = None) -> ty.Iterable[Path]:
+    raise NotImplementedError
+"""
+    return code_str
+
+
+def get_gen_filename_to_funcs(
+    nipype_interface,
+) -> ty.Tuple[ty.List[str], ty.Set[str], ty.Set[ty.Tuple[str, str]]]:
+    """
+    Convert the _gen_filename method of a nipype interface into a function that can be
+    imported and used by the auto-convert scripts
+
+    Parameters
+    ----------
+    nipype_interface : type
+        the nipype interface to convert
+
+    Returns
+    -------
+    list[str]
+        the source code of functions to be added to the callables
+    set[str]
+        the imports required for the function
+    set[tuple[str, str]]
+        the external constants required by the function, as (name, value) tuples
+    """
+
+    if not hasattr(nipype_interface, "_gen_filename"):
+        func_src = f"""
+def _gen_filename(field, inputs, output_dir, stdout, stderr):
+    raise NotImplementedError(
+        "Could not find '_gen_filename' method in {nipype_interface.__module__}.{nipype_interface.__name__}"
+    )
+"""
+        warn(f"Could not find '_gen_filename' method in {nipype_interface}")
+        return [func_src], set(), set()
+
+    IMPLICIT_ARGS = ["inputs", "stdout", "stderr", "output_dir"]
+
+    def find_nested_methods(method: ty.Callable) -> ty.List[str]:
+        all_nested = set()
+        for match in re.findall(r"self\.(\w+)\(", inspect.getsource(method)):
+            nested = getattr(nipype_interface, match)
+            all_nested.add(nested)
+            all_nested.update(find_nested_methods(nested))
+        return all_nested
+
+    def process_method(method: ty.Callable) -> str:
+        src = inspect.getsource(method)
+        prefix, args_str, body = split_parens_contents(src)
+        body = insert_args_in_method_calls(body, [f"{a}={a}" for a in IMPLICIT_ARGS])
+        body = body.replace("self.cmd", f'"{nipype_interface._cmd}"')
+        body = body.replace("self.", "")
+        body = re.sub(r"\w+runtime\.(stdout|stderr)", r"\1", body)
+        body = body.replace("os.getcwd()", "output_dir")
+        # drop 'self' from the args and add the implicit callable args
+        args = args_str.split(",")[1:]
+        arg_names = [a.split("=")[0].split(":")[0] for a in args]
+        for implicit in IMPLICIT_ARGS:
+            if implicit not in arg_names:
+                args.append(f"{implicit}=None")
+        src = prefix + ", ".join(args) + body
+        src = cleanup_function_body(src, with_signature=True)
+        return src
+
+    def insert_args_in_method_calls(src: str, args: ty.List[ty.Tuple[str, str]]) -> str:
+        """Insert additional arguments into the method calls
+
+        Parameters
+        ----------
+        body : str
+            the body of th
+        args : list[tuple[str, str]]
+            the arguments to insert into the method calls
+        """
+        # Split the src code into chunks delimited by calls to methods (i.e. 'self.<method>(.*)')
+        method_re = re.compile(r"self\.(\w+)(?=\()", flags=re.MULTILINE | re.DOTALL)
+        splits = method_re.split(src)
+        new_src = splits[0]
+        # Iterate through these chunks and add the additional args to the method calls
+        # using insert_args_in_signature function
+        for name, sig in zip(splits[1::2], splits[2::2]):
+            new_src += name + insert_args_in_signature(sig, args)
+        return new_src
+
+    func_srcs = [
+        process_method(m)
+        for m in (
+            [nipype_interface._gen_filename]
+            + list(find_nested_methods(nipype_interface._gen_filename))
+        )
+    ]
+
+    mod = import_module(nipype_interface.__module__)
+    used = UsedSymbols.find(mod, func_srcs)
+    for func in used.local_functions:
+        func_srcs.append(
+            cleanup_function_body(inspect.getsource(func), with_signature=True)
+        )
+    for new_func_name, func in used.funcs_to_include:
+        func_src = inspect.getsource(func)
+        match = re.match(
+            r" *(def|class) *" + func.__name__ + r"(?=\()(.*)$",
+            func_src,
+            re.DOTALL | re.MULTILINE,
+        )
+        func_src = match.group(1) + " " + new_func_name + match.group(2)
+        func_srcs.append(cleanup_function_body(func_src, with_signature=True))
+    return (
+        func_srcs,
+        used.imports,
+        used.constants,
+    )
diff --git a/nipype2pydra/cli/pkg-gen-resources/specs/afni-qwarp-only.yaml b/nipype2pydra/pkg_gen/resources/specs/afni-qwarp-only.yaml
similarity index 100%
rename from nipype2pydra/cli/pkg-gen-resources/specs/afni-qwarp-only.yaml
rename to nipype2pydra/pkg_gen/resources/specs/afni-qwarp-only.yaml
diff --git a/nipype2pydra/cli/pkg-gen-resources/specs/example-packages.yaml b/nipype2pydra/pkg_gen/resources/specs/example-packages.yaml
similarity index 100%
rename from nipype2pydra/cli/pkg-gen-resources/specs/example-packages.yaml
rename to nipype2pydra/pkg_gen/resources/specs/example-packages.yaml
diff --git a/nipype2pydra/cli/pkg-gen-resources/specs/fastsurfer-only.yaml b/nipype2pydra/pkg_gen/resources/specs/fastsurfer-only.yaml
similarity index 100%
rename from nipype2pydra/cli/pkg-gen-resources/specs/fastsurfer-only.yaml
rename to nipype2pydra/pkg_gen/resources/specs/fastsurfer-only.yaml
diff --git a/nipype2pydra/cli/pkg-gen-resources/specs/freesurfer-mris-convert-only.yaml b/nipype2pydra/pkg_gen/resources/specs/freesurfer-mris-convert-only.yaml
similarity index 100%
rename from nipype2pydra/cli/pkg-gen-resources/specs/freesurfer-mris-convert-only.yaml
rename to nipype2pydra/pkg_gen/resources/specs/freesurfer-mris-convert-only.yaml
diff --git a/nipype2pydra/cli/pkg-gen-resources/specs/freesurfer-only.yaml b/nipype2pydra/pkg_gen/resources/specs/freesurfer-only.yaml
similarity index 100%
rename from nipype2pydra/cli/pkg-gen-resources/specs/freesurfer-only.yaml
rename to nipype2pydra/pkg_gen/resources/specs/freesurfer-only.yaml
diff --git a/nipype2pydra/cli/pkg-gen-resources/specs/fsl-filmgls-only.yaml b/nipype2pydra/pkg_gen/resources/specs/fsl-filmgls-only.yaml
similarity index 100%
rename from nipype2pydra/cli/pkg-gen-resources/specs/fsl-filmgls-only.yaml
rename to nipype2pydra/pkg_gen/resources/specs/fsl-filmgls-only.yaml
diff --git a/nipype2pydra/cli/pkg-gen-resources/specs/fsl-only.yaml b/nipype2pydra/pkg_gen/resources/specs/fsl-only.yaml
similarity index 100%
rename from nipype2pydra/cli/pkg-gen-resources/specs/fsl-only.yaml
rename to nipype2pydra/pkg_gen/resources/specs/fsl-only.yaml
diff --git a/nipype2pydra/cli/pkg-gen-resources/specs/mriqc.yaml b/nipype2pydra/pkg_gen/resources/specs/mriqc.yaml
similarity index 100%
rename from nipype2pydra/cli/pkg-gen-resources/specs/mriqc.yaml
rename to nipype2pydra/pkg_gen/resources/specs/mriqc.yaml
diff --git a/nipype2pydra/cli/pkg-gen-resources/specs/nipype-interfaces-to-import.yaml b/nipype2pydra/pkg_gen/resources/specs/nipype-interfaces-to-import.yaml
similarity index 100%
rename from nipype2pydra/cli/pkg-gen-resources/specs/nipype-interfaces-to-import.yaml
rename to nipype2pydra/pkg_gen/resources/specs/nipype-interfaces-to-import.yaml
diff --git a/nipype2pydra/cli/pkg-gen-resources/specs/qsiprep.yaml b/nipype2pydra/pkg_gen/resources/specs/qsiprep.yaml
similarity index 100%
rename from nipype2pydra/cli/pkg-gen-resources/specs/qsiprep.yaml
rename to nipype2pydra/pkg_gen/resources/specs/qsiprep.yaml
diff --git a/nipype2pydra/cli/pkg-gen-resources/templates/README.rst b/nipype2pydra/pkg_gen/resources/templates/README.rst
similarity index 100%
rename from nipype2pydra/cli/pkg-gen-resources/templates/README.rst
rename to nipype2pydra/pkg_gen/resources/templates/README.rst
diff --git a/nipype2pydra/cli/pkg-gen-resources/templates/gh_workflows/ci-cd.yaml b/nipype2pydra/pkg_gen/resources/templates/gh_workflows/ci-cd.yaml
similarity index 100%
rename from nipype2pydra/cli/pkg-gen-resources/templates/gh_workflows/ci-cd.yaml
rename to nipype2pydra/pkg_gen/resources/templates/gh_workflows/ci-cd.yaml
diff --git a/nipype2pydra/cli/pkg-gen-resources/templates/nipype-auto-convert-requirements.txt b/nipype2pydra/pkg_gen/resources/templates/nipype-auto-convert-requirements.txt
similarity index 100%
rename from nipype2pydra/cli/pkg-gen-resources/templates/nipype-auto-convert-requirements.txt
rename to nipype2pydra/pkg_gen/resources/templates/nipype-auto-convert-requirements.txt
diff --git a/nipype2pydra/cli/pkg-gen-resources/templates/nipype-auto-convert.py b/nipype2pydra/pkg_gen/resources/templates/nipype-auto-convert.py
similarity index 100%
rename from nipype2pydra/cli/pkg-gen-resources/templates/nipype-auto-convert.py
rename to nipype2pydra/pkg_gen/resources/templates/nipype-auto-convert.py
diff --git a/nipype2pydra/cli/pkg-gen-resources/templates/pkg_init.py b/nipype2pydra/pkg_gen/resources/templates/pkg_init.py
similarity index 100%
rename from nipype2pydra/cli/pkg-gen-resources/templates/pkg_init.py
rename to nipype2pydra/pkg_gen/resources/templates/pkg_init.py

From f4f383ce50947a95843bf12e2f24362362fb065a Mon Sep 17 00:00:00 2001
From: Tom Close <tom.g.close@gmail.com>
Date: Thu, 7 Mar 2024 20:12:00 +1100
Subject: [PATCH 54/78] debugged type guessing from docstring

---
 nipype2pydra/pkg_gen/__init__.py | 149 +++++++++++++++++++------------
 1 file changed, 91 insertions(+), 58 deletions(-)

diff --git a/nipype2pydra/pkg_gen/__init__.py b/nipype2pydra/pkg_gen/__init__.py
index 87d70968..107d35fa 100644
--- a/nipype2pydra/pkg_gen/__init__.py
+++ b/nipype2pydra/pkg_gen/__init__.py
@@ -10,6 +10,7 @@
 import attrs
 from warnings import warn
 import requests
+from operator import itemgetter
 import yaml
 import black.parsing
 import fileformats.core.utils
@@ -80,6 +81,7 @@ class NipypeInterface:
     output_helps: ty.Dict[str, str] = attrs.field()
     file_inputs: ty.Dict[str, str] = attrs.field()
     path_inputs: ty.List[str] = attrs.field()
+    str_inputs: ty.List[str] = attrs.field()
     file_outputs: ty.List[str] = attrs.field()
     template_outputs: ty.List[str] = attrs.field()
     multi_inputs: ty.List[str] = attrs.field()
@@ -102,66 +104,79 @@ def parse(
         file_outputs = []
         dir_inputs = []
         path_inputs = []
+        str_inputs = []
         template_outputs = []
         multi_inputs = []
         dir_outputs = []
         output_helps = {}
         callables = []
-        if nipype_interface.output_spec:
-            for outpt_name, outpt in nipype_interface.output_spec().traits().items():
-                if outpt_name in ("trait_added", "trait_modified"):
-                    continue
-                outpt_desc = outpt.desc.replace("\n", " ") if outpt.desc else ""
-                output_helps[outpt_name] = (
-                    f"type={type(outpt.trait_type).__name__.lower()}: {outpt_desc}"
-                )
-                if type(outpt.trait_type).__name__ == "File":
-                    file_outputs.append(outpt_name)
-                elif type(outpt.trait_type).__name__ == "Directory":
-                    dir_outputs.append(outpt_name)
-        if nipype_interface.input_spec:
-            for inpt_name, inpt in nipype_interface.input_spec().traits().items():
-                if inpt_name in ("trait_added", "trait_modified"):
-                    continue
-                inpt_desc = inpt.desc.replace("\n", " ") if inpt.desc else ""
-                inpt_mdata = f"type={type(inpt.trait_type).__name__.lower()}|default={inpt.default!r}"
-                if isinstance(inpt.trait_type, nipype.interfaces.base.core.traits.Enum):
-                    inpt_mdata += f"|allowed[{','.join(sorted(repr(v) for v in inpt.trait_type.values))}]"
-                input_helps[inpt_name] = f"{inpt_mdata}: {inpt_desc}"
-                trait_type_name = type(inpt.trait_type).__name__
-                if inpt.genfile:
-                    if trait_type_name in ("File", "Directory"):
-                        path_inputs.append(inpt_name)
-                    if inpt_name in (file_outputs + dir_outputs):
-                        template_outputs.append(inpt_name)
+        # Parse output types and descriptions
+        for outpt_name, outpt in nipype_interface.output_spec().traits().items():
+            if outpt_name in ("trait_added", "trait_modified"):
+                continue
+            outpt_desc = outpt.desc.replace("\n", " ") if outpt.desc else ""
+            output_helps[outpt_name] = (
+                f"type={type(outpt.trait_type).__name__.lower()}: {outpt_desc}"
+            )
+            if type(outpt.trait_type).__name__ == "File":
+                file_outputs.append(outpt_name)
+            elif type(outpt.trait_type).__name__ == "Directory":
+                dir_outputs.append(outpt_name)
+        # Parse input types, descriptions and metadata
+        for inpt_name, inpt in nipype_interface.input_spec().traits().items():
+            if inpt_name in ("trait_added", "trait_modified"):
+                continue
+            inpt_desc = inpt.desc.replace("\n", " ") if inpt.desc else ""
+            inpt_mdata = f"type={type(inpt.trait_type).__name__.lower()}|default={inpt.default!r}"
+            if isinstance(inpt.trait_type, nipype.interfaces.base.core.traits.Enum):
+                inpt_mdata += f"|allowed[{','.join(sorted(repr(v) for v in inpt.trait_type.values))}]"
+            input_helps[inpt_name] = f"{inpt_mdata}: {inpt_desc}"
+            trait_type_name = type(inpt.trait_type).__name__
+            if inpt.genfile:
+                if trait_type_name in ("File", "Directory"):
+                    path_inputs.append(inpt_name)
+                if inpt_name in (file_outputs + dir_outputs):
+                    template_outputs.append(inpt_name)
+                else:
+                    callables.append(inpt_name)
+            elif trait_type_name == "File" and inpt_name not in file_outputs:
+                # override logic if it is named as an output
+                if (
+                    inpt_name.startswith("out_")
+                    or inpt_name.startswith("output_")
+                    or inpt_name.endswith("_out")
+                    or inpt_name.endswith("_output")
+                ):
+                    if "fix" in inpt_name:
+                        str_inputs.append(inpt_name)
                     else:
-                        callables.append(inpt_name)
-                elif trait_type_name == "File" and inpt_name not in file_outputs:
+                        path_inputs.append(inpt_name)
+                else:
                     file_inputs.append(inpt_name)
-                elif trait_type_name == "Directory" and inpt_name not in dir_outputs:
+            elif trait_type_name == "Directory" and inpt_name not in dir_outputs:
+                dir_inputs.append(inpt_name)
+            elif trait_type_name == "InputMultiObject":
+                inner_trait_type_name = type(
+                    inpt.trait_type.item_trait.trait_type
+                ).__name__
+                if inner_trait_type_name == "Directory":
                     dir_inputs.append(inpt_name)
-                elif trait_type_name == "InputMultiObject":
-                    inner_trait_type_name = type(
-                        inpt.trait_type.item_trait.trait_type
-                    ).__name__
-                    if inner_trait_type_name == "Directory":
-                        dir_inputs.append(inpt_name)
-                    elif inner_trait_type_name == "File":
-                        file_inputs.append(inpt_name)
-                    multi_inputs.append(inpt_name)
-                elif type(inpt.trait_type).__name__ == "List" and type(
+                elif inner_trait_type_name == "File":
+                    file_inputs.append(inpt_name)
+                multi_inputs.append(inpt_name)
+            elif type(inpt.trait_type).__name__ == "List" and type(
+                inpt.trait_type.inner_traits()[0].handler
+            ).__name__ in ("File", "Directory"):
+                item_type_name = type(
                     inpt.trait_type.inner_traits()[0].handler
-                ).__name__ in ("File", "Directory"):
-                    item_type_name = type(
-                        inpt.trait_type.inner_traits()[0].handler
-                    ).__name__
-                    if item_type_name == "File":
-                        file_inputs.append(inpt_name)
-                    else:
-                        dir_inputs.append(inpt_name)
-                    multi_inputs.append(inpt_name)
-                elif trait_type_name in ("File", "Directory"):
-                    path_inputs.append(inpt_name)
+                ).__name__
+                if item_type_name == "File":
+                    file_inputs.append(inpt_name)
+                else:
+                    dir_inputs.append(inpt_name)
+                multi_inputs.append(inpt_name)
+            elif trait_type_name in ("File", "Directory"):
+                path_inputs.append(inpt_name)
         doc_string = nipype_interface.__doc__ if nipype_interface.__doc__ else ""
         doc_string = doc_string.replace("\n", "\n# ")
         # Create a preamble at the top of the specificaiton explaining what to do
@@ -186,6 +201,7 @@ def parse(
             output_helps=output_helps,
             file_inputs=file_inputs,
             path_inputs=path_inputs,
+            str_inputs=str_inputs,
             file_outputs=file_outputs,
             template_outputs=template_outputs,
             multi_inputs=multi_inputs,
@@ -200,6 +216,7 @@ def generate_yaml_spec(self) -> str:
         input_types = {i: File for i in self.file_inputs}
         input_types.update({i: Directory for i in self.dir_inputs})
         input_types.update({i: Path for i in self.path_inputs})
+        input_types.update({i: str for i in self.str_inputs})
         output_types = {o: File for o in self.file_outputs}
         output_types.update({o: Directory for o in self.dir_outputs})
         output_templates = {}
@@ -236,7 +253,7 @@ def generate_yaml_spec(self) -> str:
             for n, t in input_types.items()
         }
 
-        non_mime = [Path]
+        non_mime = [Path, str]
 
         def type2str(tp):
             if tp in non_mime:
@@ -247,6 +264,11 @@ def type2str(tp):
             doctest_blocks, input_types, output_types, output_templates
         )
 
+        # sort dictionaries by key
+        input_types = dict(sorted(input_types.items(), key=itemgetter(0)))
+        output_types = dict(sorted(output_types.items(), key=itemgetter(0)))
+        output_templates = dict(sorted(output_templates.items(), key=itemgetter(0)))
+
         spec_stub = {
             "task_name": self.name,
             "nipype_name": self.name,
@@ -262,7 +284,7 @@ def type2str(tp):
                 {
                     "types": {n: type2str(t) for n, t in output_types.items()},
                     "templates": output_templates,
-                    "callables": {n: f"{n}_callable" for n in self.callables},
+                    "callables": {n: f"{n}_callable" for n in sorted(self.callables)},
                 },
             ),
             "tests": tests,
@@ -417,15 +439,26 @@ def guess_type(fspath):
                     return possible_formats[0]
 
                 def combine_types(type_, prev_type):
-                    if type_ is File:
-                        return prev_type
-                    if prev_type is not File:
+                    as_list = False
+                    if ty.get_origin(prev_type) is list:
+                        as_list = True
+                        prev_type = ty.get_args(prev_type)[0]
+                    if ty.get_origin(type_) is list:
+                        as_list = True
+                        type_ = ty.get_args(type_)[0]
+                    if issubclass(type_, prev_type):
+                        combined = type_
+                    elif issubclass(prev_type, type_):
+                        combined = prev_type
+                    else:
                         if ty.get_origin(prev_type) is ty.Union:
                             prev_types = ty.get_args(prev_type)
                         else:
                             prev_types = [prev_type]
-                        return ty.Union.__getitem__((type_,) + tuple(prev_types))
-                    return type_
+                        combined = ty.Union.__getitem__((type_,) + tuple(prev_types))
+                    if as_list:
+                        combined = ty.List.__getitem__(combined)
+                    return combined
 
                 test_inpts: ty.Dict[str, ty.Optional[ty.Type]] = {}
                 for name, val in inpts.items():

From 23aec591677988fab7d22a48d3088f9d75a19a43 Mon Sep 17 00:00:00 2001
From: Tom Close <tom.g.close@gmail.com>
Date: Fri, 8 Mar 2024 13:01:22 +1100
Subject: [PATCH 55/78] sort example spec file fields for consistent order

---
 .../task/nipype/afni/a_boverlap_callables.py  |   2 +-
 .../nipype/afni/afn_ito_nifti_callables.py    |   2 +-
 .../task/nipype/afni/align_epi_anat_py.yaml   |  20 +--
 .../afni/align_epi_anat_py_callables.py       |   2 +-
 example-specs/task/nipype/afni/allineate.yaml |  34 ++--
 .../task/nipype/afni/allineate_callables.py   |   2 +-
 .../nipype/afni/auto_tcorrelate_callables.py  |   2 +-
 .../task/nipype/afni/auto_tlrc_callables.py   |   2 +-
 .../task/nipype/afni/autobox_callables.py     |   2 +-
 example-specs/task/nipype/afni/automask.yaml  |  12 +-
 .../task/nipype/afni/automask_callables.py    |   2 +-
 .../task/nipype/afni/axialize_callables.py    |   2 +-
 example-specs/task/nipype/afni/bandpass.yaml  |   4 +-
 .../task/nipype/afni/bandpass_callables.py    |   2 +-
 .../nipype/afni/blur_in_mask_callables.py     |   2 +-
 .../task/nipype/afni/blur_to_fwhm.yaml        |   4 +-
 .../nipype/afni/blur_to_fwhm_callables.py     |   2 +-
 .../task/nipype/afni/brick_stat_callables.py  |   2 +-
 .../task/nipype/afni/bucket_callables.py      |   2 +-
 .../task/nipype/afni/calc_callables.py        |   2 +-
 .../task/nipype/afni/cat_callables.py         |   2 +-
 .../task/nipype/afni/cat_matvec_callables.py  |   2 +-
 .../task/nipype/afni/center_mass.yaml         |  12 +-
 .../task/nipype/afni/center_mass_callables.py |   2 +-
 .../task/nipype/afni/clip_level.yaml          |   4 +-
 .../task/nipype/afni/clip_level_callables.py  |   2 +-
 .../nipype/afni/convert_dset_callables.py     |   2 +-
 .../task/nipype/afni/copy_callables.py        |   2 +-
 .../task/nipype/afni/deconvolve.yaml          |  20 +--
 .../task/nipype/afni/deconvolve_callables.py  |   2 +-
 .../afni/degree_centrality_callables.py       |   2 +-
 .../task/nipype/afni/despike_callables.py     |   2 +-
 .../task/nipype/afni/detrend_callables.py     |   2 +-
 example-specs/task/nipype/afni/dot.yaml       |   2 +-
 .../task/nipype/afni/dot_callables.py         |   2 +-
 .../task/nipype/afni/ecm_callables.py         |   2 +-
 .../task/nipype/afni/edge_3_callables.py      |   2 +-
 .../task/nipype/afni/eval_callables.py        |   2 +-
 example-specs/task/nipype/afni/fim.yaml       |   4 +-
 .../task/nipype/afni/fim_callables.py         |   2 +-
 .../task/nipype/afni/fourier_callables.py     |   2 +-
 example-specs/task/nipype/afni/fwh_mx.yaml    |  16 +-
 .../task/nipype/afni/fwh_mx_callables.py      |   2 +-
 .../task/nipype/afni/gcor_callables.py        |   2 +-
 .../task/nipype/afni/hist_callables.py        |   2 +-
 .../task/nipype/afni/lfcd_callables.py        |   2 +-
 .../task/nipype/afni/local_bistat.yaml        |   4 +-
 .../nipype/afni/local_bistat_callables.py     |   2 +-
 .../task/nipype/afni/localstat_callables.py   |   2 +-
 .../task/nipype/afni/mask_tool_callables.py   |   2 +-
 .../task/nipype/afni/maskave_callables.py     |   2 +-
 .../task/nipype/afni/means_callables.py       |   2 +-
 .../task/nipype/afni/merge_callables.py       |   2 +-
 example-specs/task/nipype/afni/net_corr.yaml  |   8 +-
 .../task/nipype/afni/net_corr_callables.py    |   2 +-
 .../task/nipype/afni/notes_callables.py       |   2 +-
 .../task/nipype/afni/nwarp_adjust.yaml        |   4 +-
 .../nipype/afni/nwarp_adjust_callables.py     |   2 +-
 .../task/nipype/afni/nwarp_apply_callables.py |   2 +-
 .../task/nipype/afni/nwarp_cat_callables.py   |   2 +-
 .../task/nipype/afni/one_d_tool_py.yaml       |   6 +-
 .../nipype/afni/one_d_tool_py_callables.py    |   2 +-
 .../task/nipype/afni/outlier_count.yaml       |   8 +-
 .../nipype/afni/outlier_count_callables.py    |   2 +-
 .../nipype/afni/quality_index_callables.py    |   2 +-
 example-specs/task/nipype/afni/qwarp.yaml     |  48 +++---
 .../task/nipype/afni/qwarp_callables.py       |   2 +-
 .../task/nipype/afni/qwarp_plus_minus.yaml    |  38 ++---
 .../nipype/afni/qwarp_plus_minus_callables.py |   2 +-
 example-specs/task/nipype/afni/re_ho.yaml     |   4 +-
 .../task/nipype/afni/re_ho_callables.py       |   2 +-
 example-specs/task/nipype/afni/refit.yaml     |   4 +-
 .../task/nipype/afni/refit_callables.py       |   2 +-
 example-specs/task/nipype/afni/remlfit.yaml   | 132 +++++++--------
 .../task/nipype/afni/remlfit_callables.py     |   2 +-
 .../task/nipype/afni/resample_callables.py    |   2 +-
 example-specs/task/nipype/afni/retroicor.yaml |  12 +-
 .../task/nipype/afni/retroicor_callables.py   |   2 +-
 example-specs/task/nipype/afni/roi_stats.yaml |   4 +-
 .../task/nipype/afni/roi_stats_callables.py   |   2 +-
 .../task/nipype/afni/seg_callables.py         |   2 +-
 .../task/nipype/afni/skull_strip_callables.py |   2 +-
 example-specs/task/nipype/afni/svm_test.yaml  |   4 +-
 .../task/nipype/afni/svm_test_callables.py    |   2 +-
 example-specs/task/nipype/afni/svm_train.yaml |  32 ++--
 .../task/nipype/afni/svm_train_callables.py   |   2 +-
 .../task/nipype/afni/synthesize_callables.py  |   2 +-
 .../task/nipype/afni/t_cat_callables.py       |   2 +-
 .../nipype/afni/t_cat_sub_brick_callables.py  |   2 +-
 example-specs/task/nipype/afni/t_corr_1d.yaml |   6 +-
 .../task/nipype/afni/t_corr_1d_callables.py   |   2 +-
 .../task/nipype/afni/t_corr_map.yaml          |  74 ++++-----
 .../task/nipype/afni/t_corr_map_callables.py  |   2 +-
 .../task/nipype/afni/t_correlate.yaml         |   6 +-
 .../task/nipype/afni/t_correlate_callables.py |   2 +-
 .../task/nipype/afni/t_norm_callables.py      |   2 +-
 example-specs/task/nipype/afni/t_project.yaml |   8 +-
 .../task/nipype/afni/t_project_callables.py   |   2 +-
 example-specs/task/nipype/afni/t_shift.yaml   |   4 +-
 .../task/nipype/afni/t_shift_callables.py     |   2 +-
 example-specs/task/nipype/afni/t_smooth.yaml  |   4 +-
 .../task/nipype/afni/t_smooth_callables.py    |   2 +-
 .../task/nipype/afni/t_stat_callables.py      |   2 +-
 .../task/nipype/afni/to_3d_callables.py       |   2 +-
 .../task/nipype/afni/undump_callables.py      |   2 +-
 example-specs/task/nipype/afni/unifize.yaml   |   6 +-
 .../task/nipype/afni/unifize_callables.py     |   2 +-
 example-specs/task/nipype/afni/volreg.yaml    |  16 +-
 .../task/nipype/afni/volreg_callables.py      |   2 +-
 example-specs/task/nipype/afni/warp.yaml      |   4 +-
 .../task/nipype/afni/warp_callables.py        |   2 +-
 .../task/nipype/afni/z_cut_up_callables.py    |   2 +-
 .../task/nipype/afni/zcat_callables.py        |   2 +-
 .../task/nipype/afni/zeropad_callables.py     |   2 +-
 .../ants/affine_initializer_callables.py      |   2 +-
 example-specs/task/nipype/ants/ai.yaml        |   4 +-
 .../task/nipype/ants/ai_callables.py          |   2 +-
 example-specs/task/nipype/ants/ants.yaml      |   4 +-
 .../task/nipype/ants/ants_callables.py        |   2 +-
 .../task/nipype/ants/ants_introduction.yaml   |  12 +-
 .../ants/ants_introduction_callables.py       |   2 +-
 .../nipype/ants/apply_transforms_callables.py |   2 +-
 .../apply_transforms_to_points_callables.py   |   2 +-
 .../task/nipype/ants/atropos_callables.py     |   4 +-
 .../nipype/ants/average_affine_transform.yaml |   6 +-
 .../average_affine_transform_callables.py     |   2 +-
 .../nipype/ants/average_images_callables.py   |   2 +-
 .../task/nipype/ants/brain_extraction.yaml    |   8 +-
 .../nipype/ants/brain_extraction_callables.py |   2 +-
 .../ants/buildtemplateparallel_callables.py   |   2 +-
 .../nipype/ants/compose_multi_transform.yaml  |   6 +-
 .../ants/compose_multi_transform_callables.py |   2 +-
 .../composite_transform_util_callables.py     |   2 +-
 .../convert_scalar_image_to_rgb_callables.py  |   2 +-
 .../task/nipype/ants/cortical_thickness.yaml  |  36 ++--
 .../ants/cortical_thickness_callables.py      |   2 +-
 ...te_jacobian_determinant_image_callables.py |   2 +-
 .../task/nipype/ants/create_tiled_mosaic.yaml |   4 +-
 .../ants/create_tiled_mosaic_callables.py     |   2 +-
 .../task/nipype/ants/denoise_image.yaml       |  12 +-
 .../nipype/ants/denoise_image_callables.py    |   2 +-
 .../task/nipype/ants/gen_warp_fields.yaml     |  12 +-
 .../nipype/ants/gen_warp_fields_callables.py  |   2 +-
 .../task/nipype/ants/image_math_callables.py  |   2 +-
 .../nipype/ants/joint_fusion_callables.py     |   2 +-
 .../task/nipype/ants/kelly_kapowski.yaml      |  14 +-
 .../nipype/ants/kelly_kapowski_callables.py   |   2 +-
 .../task/nipype/ants/label_geometry.yaml      |   4 +-
 .../nipype/ants/label_geometry_callables.py   |   2 +-
 .../task/nipype/ants/laplacian_thickness.yaml |   4 +-
 .../ants/laplacian_thickness_callables.py     |   2 +-
 .../nipype/ants/measure_image_similarity.yaml |   4 +-
 .../measure_image_similarity_callables.py     |   2 +-
 .../nipype/ants/multiply_images_callables.py  |   2 +-
 .../nipype/ants/n4_bias_field_correction.yaml |  12 +-
 .../n4_bias_field_correction_callables.py     |   2 +-
 .../task/nipype/ants/registration.yaml        |   8 +-
 .../nipype/ants/registration_callables.py     |   2 +-
 .../nipype/ants/registration_syn_quick.yaml   |  12 +-
 .../ants/registration_syn_quick_callables.py  |   2 +-
 .../resample_image_by_spacing_callables.py    |   2 +-
 .../nipype/ants/threshold_image_callables.py  |   2 +-
 .../ants/warp_image_multi_transform.yaml      |   8 +-
 .../warp_image_multi_transform_callables.py   |   2 +-
 ..._series_image_multi_transform_callables.py |   2 +-
 .../freesurfer/add_x_form_to_header.yaml      |   8 +-
 .../add_x_form_to_header_callables.py         |   2 +-
 .../task/nipype/freesurfer/aparc_2_aseg.yaml  |  38 ++---
 .../freesurfer/aparc_2_aseg_callables.py      |   2 +-
 .../task/nipype/freesurfer/apas_2_aseg.yaml   |   4 +-
 .../freesurfer/apas_2_aseg_callables.py       |   2 +-
 .../task/nipype/freesurfer/apply_mask.yaml    |  10 +-
 .../nipype/freesurfer/apply_mask_callables.py |   2 +-
 .../freesurfer/apply_vol_transform.yaml       |  20 +--
 .../apply_vol_transform_callables.py          |   2 +-
 .../task/nipype/freesurfer/bb_register.yaml   |  24 +--
 .../freesurfer/bb_register_callables.py       |   2 +-
 .../task/nipype/freesurfer/binarize.yaml      |  10 +-
 .../nipype/freesurfer/binarize_callables.py   |   2 +-
 .../task/nipype/freesurfer/ca_label.yaml      |  16 +-
 .../nipype/freesurfer/ca_label_callables.py   |   2 +-
 .../task/nipype/freesurfer/ca_normalize.yaml  |  28 ++--
 .../freesurfer/ca_normalize_callables.py      |   2 +-
 .../task/nipype/freesurfer/ca_register.yaml   |  16 +-
 .../freesurfer/ca_register_callables.py       |   2 +-
 .../check_talairach_alignment_callables.py    |   2 +-
 .../task/nipype/freesurfer/concatenate.yaml   |  10 +-
 .../freesurfer/concatenate_callables.py       |   2 +-
 .../nipype/freesurfer/concatenate_lta.yaml    |  10 +-
 .../freesurfer/concatenate_lta_callables.py   |   2 +-
 .../task/nipype/freesurfer/contrast.yaml      |  12 +-
 .../nipype/freesurfer/contrast_callables.py   |   2 +-
 .../task/nipype/freesurfer/curvature.yaml     |   4 +-
 .../nipype/freesurfer/curvature_callables.py  |   2 +-
 .../nipype/freesurfer/curvature_stats.yaml    |   8 +-
 .../freesurfer/curvature_stats_callables.py   |   2 +-
 .../task/nipype/freesurfer/dicom_convert.yaml |   8 +-
 .../freesurfer/dicom_convert_callables.py     |   2 +-
 .../nipype/freesurfer/edit_w_mwith_aseg.yaml  |  10 +-
 .../freesurfer/edit_w_mwith_aseg_callables.py |   2 +-
 .../task/nipype/freesurfer/em_register.yaml   |  12 +-
 .../freesurfer/em_register_callables.py       |   2 +-
 .../freesurfer/euler_number_callables.py      |   2 +-
 .../extract_main_component_callables.py       |   2 +-
 .../task/nipype/freesurfer/fit_ms_params.yaml |  12 +-
 .../freesurfer/fit_ms_params_callables.py     |   2 +-
 .../task/nipype/freesurfer/fix_topology.yaml  |   8 +-
 .../freesurfer/fix_topology_callables.py      |   2 +-
 .../nipype/freesurfer/fuse_segmentations.yaml |   8 +-
 .../fuse_segmentations_callables.py           |   2 +-
 .../task/nipype/freesurfer/glm_fit.yaml       |  64 +++----
 .../nipype/freesurfer/glm_fit_callables.py    |   2 +-
 .../task/nipype/freesurfer/gtm_seg.yaml       |   4 +-
 .../nipype/freesurfer/gtm_seg_callables.py    |   2 +-
 .../task/nipype/freesurfer/gtmpvc.yaml        |  66 ++++----
 .../nipype/freesurfer/gtmpvc_callables.py     |   2 +-
 .../nipype/freesurfer/image_info_callables.py |   2 +-
 .../task/nipype/freesurfer/jacobian.yaml      |   8 +-
 .../nipype/freesurfer/jacobian_callables.py   |   2 +-
 .../task/nipype/freesurfer/label_2_annot.yaml |   4 +-
 .../freesurfer/label_2_annot_callables.py     |   2 +-
 .../task/nipype/freesurfer/label_2_label.yaml |  18 +-
 .../freesurfer/label_2_label_callables.py     |   2 +-
 .../task/nipype/freesurfer/label_2_vol.yaml   |  20 +--
 .../freesurfer/label_2_vol_callables.py       |   2 +-
 .../task/nipype/freesurfer/logan_ref.yaml     |  64 +++----
 .../nipype/freesurfer/logan_ref_callables.py  |   2 +-
 .../task/nipype/freesurfer/lta_convert.yaml   |  20 +--
 .../freesurfer/lta_convert_callables.py       |   2 +-
 .../freesurfer/make_average_subject.yaml      |   2 +-
 .../make_average_subject_callables.py         |   2 +-
 .../task/nipype/freesurfer/make_surfaces.yaml |  32 ++--
 .../freesurfer/make_surfaces_callables.py     |   2 +-
 .../freesurfer/mni_bias_correction.yaml       |   8 +-
 .../mni_bias_correction_callables.py          |   2 +-
 .../task/nipype/freesurfer/mp_rto_mni305.yaml |   4 +-
 .../freesurfer/mp_rto_mni305_callables.py     |   2 +-
 .../nipype/freesurfer/mr_is_ca_label.yaml     |  16 +-
 .../freesurfer/mr_is_ca_label_callables.py    |   2 +-
 .../task/nipype/freesurfer/mr_is_calc.yaml    |   4 +-
 .../nipype/freesurfer/mr_is_calc_callables.py |   2 +-
 .../task/nipype/freesurfer/mr_is_combine.yaml |   4 +-
 .../freesurfer/mr_is_combine_callables.py     |   2 +-
 .../task/nipype/freesurfer/mr_is_convert.yaml |  20 +--
 .../freesurfer/mr_is_convert_callables.py     |   4 +-
 .../freesurfer/mr_is_expand_callables.py      |   2 +-
 .../task/nipype/freesurfer/mr_is_inflate.yaml |   4 +-
 .../freesurfer/mr_is_inflate_callables.py     |   2 +-
 .../task/nipype/freesurfer/mri_convert.yaml   |  26 +--
 .../freesurfer/mri_convert_callables.py       |   6 +-
 .../task/nipype/freesurfer/mri_coreg.yaml     |  10 +-
 .../nipype/freesurfer/mri_coreg_callables.py  |   2 +-
 .../task/nipype/freesurfer/mri_fill.yaml      |  22 +--
 .../nipype/freesurfer/mri_fill_callables.py   |   2 +-
 .../nipype/freesurfer/mri_marching_cubes.yaml |   4 +-
 .../mri_marching_cubes_callables.py           |   4 +-
 .../task/nipype/freesurfer/mri_pretess.yaml   |   4 +-
 .../freesurfer/mri_pretess_callables.py       |   2 +-
 .../nipype/freesurfer/mri_tessellate.yaml     |   4 +-
 .../freesurfer/mri_tessellate_callables.py    |   4 +-
 .../task/nipype/freesurfer/mris_preproc.yaml  |  10 +-
 .../freesurfer/mris_preproc_callables.py      |   2 +-
 .../freesurfer/mris_preproc_recon_all.yaml    |  18 +-
 .../mris_preproc_recon_all_callables.py       |   2 +-
 .../task/nipype/freesurfer/mrtm.yaml          |  64 +++----
 .../task/nipype/freesurfer/mrtm2.yaml         |  64 +++----
 .../task/nipype/freesurfer/mrtm2_callables.py |   2 +-
 .../task/nipype/freesurfer/mrtm_callables.py  |   2 +-
 .../task/nipype/freesurfer/ms__lda.yaml       |  16 +-
 .../nipype/freesurfer/ms__lda_callables.py    |   2 +-
 .../task/nipype/freesurfer/normalize.yaml     |  10 +-
 .../nipype/freesurfer/normalize_callables.py  |   2 +-
 .../nipype/freesurfer/one_sample_t_test.yaml  |  64 +++----
 .../freesurfer/one_sample_t_test_callables.py |   2 +-
 .../task/nipype/freesurfer/paint.yaml         |   8 +-
 .../task/nipype/freesurfer/paint_callables.py |   2 +-
 .../nipype/freesurfer/parcellation_stats.yaml |  62 +++----
 .../parcellation_stats_callables.py           |   2 +-
 .../nipype/freesurfer/parse_dicom_dir.yaml    |   4 +-
 .../freesurfer/parse_dicom_dir_callables.py   |   2 +-
 .../task/nipype/freesurfer/recon_all.yaml     |  10 +-
 .../nipype/freesurfer/recon_all_callables.py  |   2 +-
 .../task/nipype/freesurfer/register.yaml      |  16 +-
 .../freesurfer/register_av_ito_talairach.yaml |  14 +-
 .../register_av_ito_talairach_callables.py    |   2 +-
 .../nipype/freesurfer/register_callables.py   |   2 +-
 .../freesurfer/relabel_hypointensities.yaml   |  14 +-
 .../relabel_hypointensities_callables.py      |   2 +-
 .../freesurfer/remove_intersection.yaml       |   4 +-
 .../remove_intersection_callables.py          |   2 +-
 .../task/nipype/freesurfer/remove_neck.yaml   |  12 +-
 .../freesurfer/remove_neck_callables.py       |   2 +-
 .../task/nipype/freesurfer/resample.yaml      |   4 +-
 .../nipype/freesurfer/resample_callables.py   |   2 +-
 .../nipype/freesurfer/robust_register.yaml    |  38 ++---
 .../freesurfer/robust_register_callables.py   |   2 +-
 .../nipype/freesurfer/robust_template.yaml    |   8 +-
 .../freesurfer/robust_template_callables.py   |   2 +-
 .../nipype/freesurfer/sample_to_surface.yaml  |  20 +--
 .../freesurfer/sample_to_surface_callables.py |   2 +-
 .../task/nipype/freesurfer/seg_stats.yaml     |  32 ++--
 .../nipype/freesurfer/seg_stats_callables.py  |   2 +-
 .../freesurfer/seg_stats_recon_all.yaml       |  68 ++++----
 .../seg_stats_recon_all_callables.py          |   2 +-
 .../task/nipype/freesurfer/segment_cc.yaml    |   4 +-
 .../nipype/freesurfer/segment_cc_callables.py |   2 +-
 .../task/nipype/freesurfer/segment_wm.yaml    |   4 +-
 .../nipype/freesurfer/segment_wm_callables.py |   2 +-
 .../task/nipype/freesurfer/smooth.yaml        |   4 +-
 .../nipype/freesurfer/smooth_callables.py     |   2 +-
 .../freesurfer/smooth_tessellation.yaml       |  10 +-
 .../smooth_tessellation_callables.py          |   4 +-
 .../task/nipype/freesurfer/sphere.yaml        |   4 +-
 .../nipype/freesurfer/sphere_callables.py     |   2 +-
 .../nipype/freesurfer/spherical_average.yaml  |  12 +-
 .../freesurfer/spherical_average_callables.py |  17 +-
 .../freesurfer/surface_2_vol_transform.yaml   |   4 +-
 .../surface_2_vol_transform_callables.py      |   2 +-
 .../nipype/freesurfer/surface_smooth.yaml     |   4 +-
 .../freesurfer/surface_smooth_callables.py    |   2 +-
 .../nipype/freesurfer/surface_snapshots.yaml  |  12 +-
 .../freesurfer/surface_snapshots_callables.py |   2 +-
 .../nipype/freesurfer/surface_transform.yaml  |  10 +-
 .../freesurfer/surface_transform_callables.py |   2 +-
 .../nipype/freesurfer/synthesize_flash.yaml   |  10 +-
 .../freesurfer/synthesize_flash_callables.py  |   2 +-
 .../task/nipype/freesurfer/talairach_avi.yaml |   4 +-
 .../freesurfer/talairach_avi_callables.py     |   2 +-
 .../task/nipype/freesurfer/talairach_qc.yaml  |   4 +-
 .../freesurfer/talairach_qc_callables.py      |   2 +-
 .../task/nipype/freesurfer/tkregister_2.yaml  |  22 +--
 .../freesurfer/tkregister_2_callables.py      |   2 +-
 .../nipype/freesurfer/unpack_sdicom_dir.yaml  |  12 +-
 .../freesurfer/unpack_sdicom_dir_callables.py |   2 +-
 .../task/nipype/freesurfer/volume_mask.yaml   |  16 +-
 .../freesurfer/volume_mask_callables.py       |   2 +-
 .../freesurfer/watershed_skull_strip.yaml     |  12 +-
 .../watershed_skull_strip_callables.py        |   2 +-
 .../task/nipype/fsl/accuracy_tester.yaml      |   4 +-
 .../nipype/fsl/accuracy_tester_callables.py   |   2 +-
 example-specs/task/nipype/fsl/apply_mask.yaml |   4 +-
 .../task/nipype/fsl/apply_mask_callables.py   |   2 +-
 .../task/nipype/fsl/apply_topup.yaml          |   4 +-
 .../task/nipype/fsl/apply_topup_callables.py  |   2 +-
 example-specs/task/nipype/fsl/apply_warp.yaml |  16 +-
 .../task/nipype/fsl/apply_warp_callables.py   |   2 +-
 example-specs/task/nipype/fsl/apply_xfm.yaml  |  44 ++---
 .../task/nipype/fsl/apply_xfm_callables.py    |   2 +-
 .../task/nipype/fsl/ar1_image_callables.py    |   2 +-
 .../task/nipype/fsl/av_scale_callables.py     |   2 +-
 .../task/nipype/fsl/b0_calc_callables.py      |   2 +-
 example-specs/task/nipype/fsl/bedpostx5.yaml  |  16 +-
 .../task/nipype/fsl/bedpostx5_callables.py    |   2 +-
 example-specs/task/nipype/fsl/bet.yaml        |  32 ++--
 .../task/nipype/fsl/bet_callables.py          |   2 +-
 .../task/nipype/fsl/binary_maths.yaml         |   4 +-
 .../task/nipype/fsl/binary_maths_callables.py |   2 +-
 .../nipype/fsl/change_data_type_callables.py  |   2 +-
 example-specs/task/nipype/fsl/classifier.yaml |   8 +-
 .../task/nipype/fsl/classifier_callables.py   |   2 +-
 .../task/nipype/fsl/cleaner_callables.py      |   2 +-
 example-specs/task/nipype/fsl/cluster.yaml    |  16 +-
 .../task/nipype/fsl/cluster_callables.py      |   2 +-
 example-specs/task/nipype/fsl/complex.yaml    |  34 ++--
 .../task/nipype/fsl/complex_callables.py      |   2 +-
 .../task/nipype/fsl/contrast_mgr.yaml         |  12 +-
 .../task/nipype/fsl/contrast_mgr_callables.py |   2 +-
 .../task/nipype/fsl/convert_warp.yaml         |  22 +--
 .../task/nipype/fsl/convert_warp_callables.py |   2 +-
 .../task/nipype/fsl/convert_xfm_callables.py  |   2 +-
 example-specs/task/nipype/fsl/copy_geom.yaml  |   4 +-
 .../task/nipype/fsl/copy_geom_callables.py    |   2 +-
 .../task/nipype/fsl/dilate_image.yaml         |   4 +-
 .../task/nipype/fsl/dilate_image_callables.py |   2 +-
 .../task/nipype/fsl/distance_map.yaml         |   6 +-
 .../task/nipype/fsl/distance_map_callables.py |   2 +-
 example-specs/task/nipype/fsl/dti_fit.yaml    |  32 ++--
 .../task/nipype/fsl/dti_fit_callables.py      |   2 +-
 .../task/nipype/fsl/dual_regression.yaml      |  12 +-
 .../nipype/fsl/dual_regression_callables.py   |   2 +-
 example-specs/task/nipype/fsl/eddy.yaml       |  68 ++++----
 .../task/nipype/fsl/eddy_callables.py         |   2 +-
 .../task/nipype/fsl/eddy_correct.yaml         |   6 +-
 .../task/nipype/fsl/eddy_correct_callables.py |   2 +-
 example-specs/task/nipype/fsl/eddy_quad.yaml  |  20 +--
 .../task/nipype/fsl/eddy_quad_callables.py    |   2 +-
 .../task/nipype/fsl/epi_de_warp.yaml          |  22 +--
 .../task/nipype/fsl/epi_de_warp_callables.py  |   6 +-
 example-specs/task/nipype/fsl/epi_reg.yaml    |  38 ++---
 .../task/nipype/fsl/epi_reg_callables.py      |   2 +-
 .../task/nipype/fsl/erode_image.yaml          |   4 +-
 .../task/nipype/fsl/erode_image_callables.py  |   2 +-
 .../task/nipype/fsl/extract_roi_callables.py  |   2 +-
 example-specs/task/nipype/fsl/fast.yaml       |  16 +-
 .../task/nipype/fsl/fast_callables.py         |   2 +-
 .../task/nipype/fsl/feat_callables.py         |   2 +-
 example-specs/task/nipype/fsl/feat_model.yaml |  12 +-
 .../task/nipype/fsl/feat_model_callables.py   |   2 +-
 .../nipype/fsl/feature_extractor_callables.py |   2 +-
 example-specs/task/nipype/fsl/filmgls.yaml    |  24 +--
 .../task/nipype/fsl/filmgls_callables.py      |   2 +-
 .../task/nipype/fsl/filter_regressor.yaml     |   4 +-
 .../nipype/fsl/filter_regressor_callables.py  |   2 +-
 .../nipype/fsl/find_the_biggest_callables.py  |   2 +-
 example-specs/task/nipype/fsl/first.yaml      |   6 +-
 .../task/nipype/fsl/first_callables.py        |   2 +-
 example-specs/task/nipype/fsl/flameo.yaml     |  20 +--
 .../task/nipype/fsl/flameo_callables.py       |   2 +-
 example-specs/task/nipype/fsl/flirt.yaml      |  44 ++---
 .../task/nipype/fsl/flirt_callables.py        |   2 +-
 example-specs/task/nipype/fsl/fnirt.yaml      |  46 +++---
 .../task/nipype/fsl/fnirt_callables.py        |   2 +-
 .../task/nipype/fsl/fslx_command.yaml         | 132 ---------------
 .../task/nipype/fsl/fslx_command_callables.py |   1 -
 example-specs/task/nipype/fsl/fugue.yaml      |  36 ++--
 .../task/nipype/fsl/fugue_callables.py        |   2 +-
 example-specs/task/nipype/fsl/glm.yaml        |  46 +++---
 .../task/nipype/fsl/glm_callables.py          |   2 +-
 example-specs/task/nipype/fsl/ica__aroma.yaml |  12 +-
 .../task/nipype/fsl/ica__aroma_callables.py   |   2 +-
 .../task/nipype/fsl/image_maths_callables.py  |   2 +-
 .../task/nipype/fsl/image_meants_callables.py |   2 +-
 .../task/nipype/fsl/image_stats.yaml          |   4 +-
 .../task/nipype/fsl/image_stats_callables.py  |   2 +-
 example-specs/task/nipype/fsl/inv_warp.yaml   |   8 +-
 .../task/nipype/fsl/inv_warp_callables.py     |   2 +-
 .../nipype/fsl/isotropic_smooth_callables.py  |   2 +-
 example-specs/task/nipype/fsl/l2_model.yaml   |   4 +-
 .../task/nipype/fsl/l2_model_callables.py     |   2 +-
 .../nipype/fsl/level_1_design_callables.py    |   2 +-
 .../task/nipype/fsl/make_dyadic_vectors.yaml  |  12 +-
 .../fsl/make_dyadic_vectors_callables.py      |   2 +-
 .../nipype/fsl/maths_command_callables.py     |   2 +-
 .../task/nipype/fsl/max_image_callables.py    |   2 +-
 .../task/nipype/fsl/maxn_image_callables.py   |   2 +-
 example-specs/task/nipype/fsl/mcflirt.yaml    |  16 +-
 .../task/nipype/fsl/mcflirt_callables.py      |   2 +-
 .../task/nipype/fsl/mean_image_callables.py   |   2 +-
 .../task/nipype/fsl/median_image_callables.py |   2 +-
 example-specs/task/nipype/fsl/melodic.yaml    |  26 +--
 .../task/nipype/fsl/melodic_callables.py      |   2 +-
 .../task/nipype/fsl/merge_callables.py        |   2 +-
 .../task/nipype/fsl/min_image_callables.py    |   2 +-
 .../task/nipype/fsl/motion_outliers.yaml      |  12 +-
 .../nipype/fsl/motion_outliers_callables.py   |   2 +-
 .../task/nipype/fsl/multi_image_maths.yaml    |   4 +-
 .../nipype/fsl/multi_image_maths_callables.py |   2 +-
 .../nipype/fsl/multiple_regress_design.yaml   |   4 +-
 .../fsl/multiple_regress_design_callables.py  |   2 +-
 example-specs/task/nipype/fsl/overlay.yaml    |   6 +-
 .../task/nipype/fsl/overlay_callables.py      |   2 +-
 .../nipype/fsl/percentile_image_callables.py  |   2 +-
 .../fsl/plot_motion_params_callables.py       |   2 +-
 .../nipype/fsl/plot_time_series_callables.py  |   2 +-
 .../nipype/fsl/power_spectrum_callables.py    |   2 +-
 example-specs/task/nipype/fsl/prelude.yaml    |  12 +-
 .../task/nipype/fsl/prelude_callables.py      |   2 +-
 .../task/nipype/fsl/prepare_fieldmap.yaml     |   4 +-
 .../nipype/fsl/prepare_fieldmap_callables.py  |   2 +-
 .../task/nipype/fsl/prob_track_x.yaml         |  32 ++--
 .../task/nipype/fsl/prob_track_x2.yaml        |  56 +++----
 .../nipype/fsl/prob_track_x2_callables.py     |   2 +-
 .../task/nipype/fsl/prob_track_x_callables.py |   2 +-
 .../task/nipype/fsl/proj_thresh_callables.py  |   2 +-
 example-specs/task/nipype/fsl/randomise.yaml  |   8 +-
 .../task/nipype/fsl/randomise_callables.py    |   2 +-
 .../nipype/fsl/reorient_2_std_callables.py    |   2 +-
 .../task/nipype/fsl/robust_fov_callables.py   |   2 +-
 .../task/nipype/fsl/sig_loss_callables.py     |   2 +-
 .../task/nipype/fsl/slice_callables.py        |   2 +-
 .../task/nipype/fsl/slice_timer.yaml          |   8 +-
 .../task/nipype/fsl/slice_timer_callables.py  |  45 ++---
 example-specs/task/nipype/fsl/slicer.yaml     |   8 +-
 .../task/nipype/fsl/slicer_callables.py       |   2 +-
 example-specs/task/nipype/fsl/smm.yaml        |   7 +-
 .../task/nipype/fsl/smm_callables.py          |   2 +-
 .../task/nipype/fsl/smooth_callables.py       |   2 +-
 .../nipype/fsl/smooth_estimate_callables.py   |   2 +-
 .../task/nipype/fsl/spatial_filter.yaml       |   4 +-
 .../nipype/fsl/spatial_filter_callables.py    |   2 +-
 .../task/nipype/fsl/split_callables.py        |   2 +-
 .../task/nipype/fsl/std_image_callables.py    |   2 +-
 .../task/nipype/fsl/susan_callables.py        |  13 +-
 .../nipype/fsl/swap_dimensions_callables.py   |   2 +-
 .../nipype/fsl/temporal_filter_callables.py   |   2 +-
 .../task/nipype/fsl/text_2_vest_callables.py  |   2 +-
 .../task/nipype/fsl/threshold_callables.py    |   2 +-
 example-specs/task/nipype/fsl/topup.yaml      |  26 +--
 .../task/nipype/fsl/topup_callables.py        |   2 +-
 .../task/nipype/fsl/tract_skeleton.yaml       |  16 +-
 .../nipype/fsl/tract_skeleton_callables.py    |   2 +-
 .../task/nipype/fsl/training_callables.py     |   2 +-
 .../fsl/training_set_creator_callables.py     |   2 +-
 .../task/nipype/fsl/unary_maths_callables.py  |   2 +-
 example-specs/task/nipype/fsl/vec_reg.yaml    |  22 +--
 .../task/nipype/fsl/vec_reg_callables.py      |   2 +-
 .../task/nipype/fsl/vest_2_text_callables.py  |   2 +-
 .../task/nipype/fsl/warp_points.yaml          |  12 +-
 .../task/nipype/fsl/warp_points_callables.py  |   2 +-
 .../task/nipype/fsl/warp_points_from_std.yaml |   8 +-
 .../fsl/warp_points_from_std_callables.py     |   2 +-
 .../task/nipype/fsl/warp_points_to_std.yaml   |  16 +-
 .../fsl/warp_points_to_std_callables.py       |   2 +-
 example-specs/task/nipype/fsl/warp_utils.yaml |   4 +-
 .../task/nipype/fsl/warp_utils_callables.py   |   2 +-
 example-specs/task/nipype/fsl/x_fibres_5.yaml |  20 +--
 .../task/nipype/fsl/x_fibres_5_callables.py   |   2 +-
 nipype2pydra/cli/pkg_gen.py                   |  21 +--
 nipype2pydra/cli/task.py                      |   1 +
 nipype2pydra/pkg_gen/__init__.py              | 156 ++++++++----------
 nipype2pydra/task/base.py                     |  10 +-
 nipype2pydra/task/function.py                 |   5 +-
 nipype2pydra/utils.py                         |  10 +-
 tests/test_task.py                            |  25 +--
 514 files changed, 2065 insertions(+), 2208 deletions(-)
 delete mode 100644 example-specs/task/nipype/fsl/fslx_command.yaml
 delete mode 100644 example-specs/task/nipype/fsl/fslx_command_callables.py

diff --git a/example-specs/task/nipype/afni/a_boverlap_callables.py b/example-specs/task/nipype/afni/a_boverlap_callables.py
index d93ad85b..225b2f40 100644
--- a/example-specs/task/nipype/afni/a_boverlap_callables.py
+++ b/example-specs/task/nipype/afni/a_boverlap_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in ABoverlap.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of ABoverlap.yaml"""
diff --git a/example-specs/task/nipype/afni/afn_ito_nifti_callables.py b/example-specs/task/nipype/afni/afn_ito_nifti_callables.py
index b9cccca4..9bcbc388 100644
--- a/example-specs/task/nipype/afni/afn_ito_nifti_callables.py
+++ b/example-specs/task/nipype/afni/afn_ito_nifti_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in AFNItoNIFTI.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of AFNItoNIFTI.yaml"""
diff --git a/example-specs/task/nipype/afni/align_epi_anat_py.yaml b/example-specs/task/nipype/afni/align_epi_anat_py.yaml
index 73884358..e6fd8200 100644
--- a/example-specs/task/nipype/afni/align_epi_anat_py.yaml
+++ b/example-specs/task/nipype/afni/align_epi_anat_py.yaml
@@ -70,10 +70,10 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    in_file: medimage/nifti1
-    # type=file|default=<undefined>: EPI dataset to align
     anat: medimage/nifti1
     # type=file|default=<undefined>: name of structural dataset
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: EPI dataset to align
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -87,22 +87,22 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    anat_al_mat: generic/file
+    # type=file: matrix to align anatomy to the EPI
     anat_al_orig: generic/file
     # type=file: A version of the anatomy that is aligned to the EPI
+    epi_al_mat: generic/file
+    # type=file: matrix to align EPI to anatomy
     epi_al_orig: generic/file
     # type=file: A version of the EPI dataset aligned to the anatomy
+    epi_al_tlrc_mat: generic/file
+    # type=file: matrix to volume register and align epito anatomy and put into standard space
+    epi_reg_al_mat: generic/file
+    # type=file: matrix to volume register and align epi to anatomy
     epi_tlrc_al: generic/file
     # type=file: A version of the EPI dataset aligned to a standard template
-    anat_al_mat: generic/file
-    # type=file: matrix to align anatomy to the EPI
-    epi_al_mat: generic/file
-    # type=file: matrix to align EPI to anatomy
     epi_vr_al_mat: generic/file
     # type=file: matrix to volume register EPI
-    epi_reg_al_mat: generic/file
-    # type=file: matrix to volume register and align epi to anatomy
-    epi_al_tlrc_mat: generic/file
-    # type=file: matrix to volume register and align epito anatomy and put into standard space
     epi_vr_motion: generic/file
     # type=file: motion parameters from EPI time-seriesregistration (tsh included in name if slicetiming correction is also included).
     skullstrip: generic/file
diff --git a/example-specs/task/nipype/afni/align_epi_anat_py_callables.py b/example-specs/task/nipype/afni/align_epi_anat_py_callables.py
index 0a532bcc..f997535d 100644
--- a/example-specs/task/nipype/afni/align_epi_anat_py_callables.py
+++ b/example-specs/task/nipype/afni/align_epi_anat_py_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in AlignEpiAnatPy.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of AlignEpiAnatPy.yaml"""
diff --git a/example-specs/task/nipype/afni/allineate.yaml b/example-specs/task/nipype/afni/allineate.yaml
index ee9d576d..f53cd86e 100644
--- a/example-specs/task/nipype/afni/allineate.yaml
+++ b/example-specs/task/nipype/afni/allineate.yaml
@@ -51,35 +51,35 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    allcostx: Path
+    # type=file: Compute and print ALL available cost functionals for the un-warped inputs
+    # type=file|default=<undefined>: Compute and print ALL available cost functionals for the un-warped inputsAND THEN QUIT. If you use this option none of the other expected outputs will be produced
     in_file: medimage/nifti1
     # type=file|default=<undefined>: input file to 3dAllineate
-    reference: medimage/nifti1
-    # type=file|default=<undefined>: file to be used as reference, the first volume will be used if not given the reference will be the first volume of in_file.
-    in_param_file: generic/file
-    # type=file|default=<undefined>: Read warp parameters from file and apply them to the source dataset, and produce a new dataset
     in_matrix: datascience/text-matrix
     # type=file|default=<undefined>: matrix to align input file
-    weight_file: generic/file
-    # type=file|default=<undefined>: Set the weighting for each voxel in the base dataset; larger weights mean that voxel count more in the cost function. Must be defined on the same grid as the base dataset
-    source_mask: generic/file
-    # type=file|default=<undefined>: mask the input dataset
+    in_param_file: generic/file
+    # type=file|default=<undefined>: Read warp parameters from file and apply them to the source dataset, and produce a new dataset
     master: generic/file
     # type=file|default=<undefined>: Write the output dataset on the same grid as this file.
     out_file: Path
     # type=file: output image file name
     # type=file|default=<undefined>: output file from 3dAllineate
-    out_param_file: Path
-    # type=file: warp parameters
-    # type=file|default=<undefined>: Save the warp parameters in ASCII (.1D) format.
     out_matrix: Path
     # type=file: matrix to align input file
     # type=file|default=<undefined>: Save the transformation matrix for each volume.
-    allcostx: Path
-    # type=file: Compute and print ALL available cost functionals for the un-warped inputs
-    # type=file|default=<undefined>: Compute and print ALL available cost functionals for the un-warped inputsAND THEN QUIT. If you use this option none of the other expected outputs will be produced
+    out_param_file: Path
+    # type=file: warp parameters
+    # type=file|default=<undefined>: Save the warp parameters in ASCII (.1D) format.
     out_weight_file: Path
     # type=file: weight volume
     # type=file|default=<undefined>: Write the weight volume to disk as a dataset
+    reference: medimage/nifti1
+    # type=file|default=<undefined>: file to be used as reference, the first volume will be used if not given the reference will be the first volume of in_file.
+    source_mask: generic/file
+    # type=file|default=<undefined>: mask the input dataset
+    weight_file: generic/file
+    # type=file|default=<undefined>: Set the weighting for each voxel in the base dataset; larger weights mean that voxel count more in the cost function. Must be defined on the same grid as the base dataset
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -93,6 +93,9 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    allcostx: text/text-file
+    # type=file: Compute and print ALL available cost functionals for the un-warped inputs
+    # type=file|default=<undefined>: Compute and print ALL available cost functionals for the un-warped inputsAND THEN QUIT. If you use this option none of the other expected outputs will be produced
     out_file: medimage/nifti1
     # type=file: output image file name
     # type=file|default=<undefined>: output file from 3dAllineate
@@ -105,9 +108,6 @@ outputs:
     out_weight_file: generic/file
     # type=file: weight volume
     # type=file|default=<undefined>: Write the weight volume to disk as a dataset
-    allcostx: text/text-file
-    # type=file: Compute and print ALL available cost functionals for the un-warped inputs
-    # type=file|default=<undefined>: Compute and print ALL available cost functionals for the un-warped inputsAND THEN QUIT. If you use this option none of the other expected outputs will be produced
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/afni/allineate_callables.py b/example-specs/task/nipype/afni/allineate_callables.py
index ef04a59b..53f30a05 100644
--- a/example-specs/task/nipype/afni/allineate_callables.py
+++ b/example-specs/task/nipype/afni/allineate_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in Allineate.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of Allineate.yaml"""
diff --git a/example-specs/task/nipype/afni/auto_tcorrelate_callables.py b/example-specs/task/nipype/afni/auto_tcorrelate_callables.py
index 2ab2ba4e..334fc735 100644
--- a/example-specs/task/nipype/afni/auto_tcorrelate_callables.py
+++ b/example-specs/task/nipype/afni/auto_tcorrelate_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in AutoTcorrelate.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of AutoTcorrelate.yaml"""
diff --git a/example-specs/task/nipype/afni/auto_tlrc_callables.py b/example-specs/task/nipype/afni/auto_tlrc_callables.py
index 873f7172..14ed8753 100644
--- a/example-specs/task/nipype/afni/auto_tlrc_callables.py
+++ b/example-specs/task/nipype/afni/auto_tlrc_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in AutoTLRC.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of AutoTLRC.yaml"""
diff --git a/example-specs/task/nipype/afni/autobox_callables.py b/example-specs/task/nipype/afni/autobox_callables.py
index f24b937c..49efa990 100644
--- a/example-specs/task/nipype/afni/autobox_callables.py
+++ b/example-specs/task/nipype/afni/autobox_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in Autobox.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of Autobox.yaml"""
diff --git a/example-specs/task/nipype/afni/automask.yaml b/example-specs/task/nipype/afni/automask.yaml
index eb363c07..fa692b23 100644
--- a/example-specs/task/nipype/afni/automask.yaml
+++ b/example-specs/task/nipype/afni/automask.yaml
@@ -36,14 +36,14 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    brain_file: Path
+    # type=file: brain file (skull stripped)
+    # type=file|default=<undefined>: output file from 3dAutomask
     in_file: medimage/nifti1
     # type=file|default=<undefined>: input file to 3dAutomask
     out_file: Path
     # type=file: mask file
     # type=file|default=<undefined>: output image file name
-    brain_file: Path
-    # type=file: brain file (skull stripped)
-    # type=file|default=<undefined>: output file from 3dAutomask
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -57,12 +57,12 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    out_file: generic/file
-    # type=file: mask file
-    # type=file|default=<undefined>: output image file name
     brain_file: generic/file
     # type=file: brain file (skull stripped)
     # type=file|default=<undefined>: output file from 3dAutomask
+    out_file: generic/file
+    # type=file: mask file
+    # type=file|default=<undefined>: output image file name
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/afni/automask_callables.py b/example-specs/task/nipype/afni/automask_callables.py
index a19deb68..f5e22de6 100644
--- a/example-specs/task/nipype/afni/automask_callables.py
+++ b/example-specs/task/nipype/afni/automask_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in Automask.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of Automask.yaml"""
diff --git a/example-specs/task/nipype/afni/axialize_callables.py b/example-specs/task/nipype/afni/axialize_callables.py
index 368125b2..35318fb6 100644
--- a/example-specs/task/nipype/afni/axialize_callables.py
+++ b/example-specs/task/nipype/afni/axialize_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in Axialize.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of Axialize.yaml"""
diff --git a/example-specs/task/nipype/afni/bandpass.yaml b/example-specs/task/nipype/afni/bandpass.yaml
index 8f3ac338..af0d857c 100644
--- a/example-specs/task/nipype/afni/bandpass.yaml
+++ b/example-specs/task/nipype/afni/bandpass.yaml
@@ -42,10 +42,10 @@ inputs:
     # type=file|default=<undefined>: input file to 3dBandpass
     mask: generic/file
     # type=file|default=<undefined>: mask file
-    orthogonalize_file: generic/file+list-of
-    # type=inputmultiobject|default=[]: Also orthogonalize input to columns in f.1D. Multiple '-ort' options are allowed.
     orthogonalize_dset: generic/file
     # type=file|default=<undefined>: Orthogonalize each voxel to the corresponding voxel time series in dataset 'fset', which must have the same spatial and temporal grid structure as the main input dataset. At present, only one '-dsort' option is allowed.
+    orthogonalize_file: generic/file+list-of
+    # type=inputmultiobject|default=[]: Also orthogonalize input to columns in f.1D. Multiple '-ort' options are allowed.
     out_file: Path
     # type=file: output file
     # type=file|default=<undefined>: output file from 3dBandpass
diff --git a/example-specs/task/nipype/afni/bandpass_callables.py b/example-specs/task/nipype/afni/bandpass_callables.py
index 232d1740..e3a526d7 100644
--- a/example-specs/task/nipype/afni/bandpass_callables.py
+++ b/example-specs/task/nipype/afni/bandpass_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in Bandpass.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of Bandpass.yaml"""
diff --git a/example-specs/task/nipype/afni/blur_in_mask_callables.py b/example-specs/task/nipype/afni/blur_in_mask_callables.py
index 7872f88f..43afcd15 100644
--- a/example-specs/task/nipype/afni/blur_in_mask_callables.py
+++ b/example-specs/task/nipype/afni/blur_in_mask_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in BlurInMask.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of BlurInMask.yaml"""
diff --git a/example-specs/task/nipype/afni/blur_to_fwhm.yaml b/example-specs/task/nipype/afni/blur_to_fwhm.yaml
index 25f6ec9d..f47d34af 100644
--- a/example-specs/task/nipype/afni/blur_to_fwhm.yaml
+++ b/example-specs/task/nipype/afni/blur_to_fwhm.yaml
@@ -36,10 +36,10 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    in_file: medimage/nifti1
-    # type=file|default=<undefined>: The dataset that will be smoothed
     blurmaster: generic/file
     # type=file|default=<undefined>: The dataset whose smoothness controls the process.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: The dataset that will be smoothed
     mask: generic/file
     # type=file|default=<undefined>: Mask dataset, if desired. Voxels NOT in mask will be set to zero in output.
     out_file: Path
diff --git a/example-specs/task/nipype/afni/blur_to_fwhm_callables.py b/example-specs/task/nipype/afni/blur_to_fwhm_callables.py
index cc29ac1b..a83767d7 100644
--- a/example-specs/task/nipype/afni/blur_to_fwhm_callables.py
+++ b/example-specs/task/nipype/afni/blur_to_fwhm_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in BlurToFWHM.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of BlurToFWHM.yaml"""
diff --git a/example-specs/task/nipype/afni/brick_stat_callables.py b/example-specs/task/nipype/afni/brick_stat_callables.py
index 91c3ac98..f2f4b2eb 100644
--- a/example-specs/task/nipype/afni/brick_stat_callables.py
+++ b/example-specs/task/nipype/afni/brick_stat_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in BrickStat.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of BrickStat.yaml"""
diff --git a/example-specs/task/nipype/afni/bucket_callables.py b/example-specs/task/nipype/afni/bucket_callables.py
index d394d4d3..c41ffcd8 100644
--- a/example-specs/task/nipype/afni/bucket_callables.py
+++ b/example-specs/task/nipype/afni/bucket_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in Bucket.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of Bucket.yaml"""
diff --git a/example-specs/task/nipype/afni/calc_callables.py b/example-specs/task/nipype/afni/calc_callables.py
index e7ff3fa7..7570d10b 100644
--- a/example-specs/task/nipype/afni/calc_callables.py
+++ b/example-specs/task/nipype/afni/calc_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in Calc.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of Calc.yaml"""
diff --git a/example-specs/task/nipype/afni/cat_callables.py b/example-specs/task/nipype/afni/cat_callables.py
index 6a4e9a64..8935f1f3 100644
--- a/example-specs/task/nipype/afni/cat_callables.py
+++ b/example-specs/task/nipype/afni/cat_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in Cat.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of Cat.yaml"""
diff --git a/example-specs/task/nipype/afni/cat_matvec_callables.py b/example-specs/task/nipype/afni/cat_matvec_callables.py
index 455c4f69..f16b22bb 100644
--- a/example-specs/task/nipype/afni/cat_matvec_callables.py
+++ b/example-specs/task/nipype/afni/cat_matvec_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in CatMatvec.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of CatMatvec.yaml"""
diff --git a/example-specs/task/nipype/afni/center_mass.yaml b/example-specs/task/nipype/afni/center_mass.yaml
index 84cead7a..b0546b98 100644
--- a/example-specs/task/nipype/afni/center_mass.yaml
+++ b/example-specs/task/nipype/afni/center_mass.yaml
@@ -42,13 +42,13 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    cm_file: Path
+    # type=file: file with the center of mass coordinates
+    # type=file|default=<undefined>: File to write center of mass to
     in_file: medimage/nifti1
     # type=file|default=<undefined>: input file to 3dCM
     mask_file: generic/file
     # type=file|default=<undefined>: Only voxels with nonzero values in the provided mask will be averaged.
-    cm_file: Path
-    # type=file: file with the center of mass coordinates
-    # type=file|default=<undefined>: File to write center of mass to
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -62,11 +62,11 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    out_file: generic/file
-    # type=file: output file
     cm_file: text/text-file
     # type=file: file with the center of mass coordinates
     # type=file|default=<undefined>: File to write center of mass to
+    out_file: generic/file
+    # type=file: output file
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
@@ -88,7 +88,7 @@ tests:
     automask:
     # type=bool|default=False: Generate the mask automatically
     set_cm:
-    # type=tuple|default=(<traits.trait_types.Float object at 0x1080a8c90>, <traits.trait_types.Float object at 0x1080a8d90>, <traits.trait_types.Float object at 0x1080a8e10>): After computing the center of mass, set the origin fields in the header so that the center of mass will be at (x,y,z) in DICOM coords.
+    # type=tuple|default=(<traits.trait_types.Float object at 0x10ffdfcd0>, <traits.trait_types.Float object at 0x10ffdfdd0>, <traits.trait_types.Float object at 0x10ffdfe50>): After computing the center of mass, set the origin fields in the header so that the center of mass will be at (x,y,z) in DICOM coords.
     local_ijk:
     # type=bool|default=False: Output values as (i,j,k) in local orientation
     roi_vals:
diff --git a/example-specs/task/nipype/afni/center_mass_callables.py b/example-specs/task/nipype/afni/center_mass_callables.py
index 6b6f0e54..4bfd0a6c 100644
--- a/example-specs/task/nipype/afni/center_mass_callables.py
+++ b/example-specs/task/nipype/afni/center_mass_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in CenterMass.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of CenterMass.yaml"""
diff --git a/example-specs/task/nipype/afni/clip_level.yaml b/example-specs/task/nipype/afni/clip_level.yaml
index 93ddaceb..f540c7bd 100644
--- a/example-specs/task/nipype/afni/clip_level.yaml
+++ b/example-specs/task/nipype/afni/clip_level.yaml
@@ -35,10 +35,10 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    in_file: medimage/nifti1
-    # type=file|default=<undefined>: input file to 3dClipLevel
     grad: generic/file
     # type=file|default=<undefined>: Also compute a 'gradual' clip level as a function of voxel position, and output that to a dataset.
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: input file to 3dClipLevel
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/clip_level_callables.py b/example-specs/task/nipype/afni/clip_level_callables.py
index a6b60fcd..b091fa95 100644
--- a/example-specs/task/nipype/afni/clip_level_callables.py
+++ b/example-specs/task/nipype/afni/clip_level_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in ClipLevel.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of ClipLevel.yaml"""
diff --git a/example-specs/task/nipype/afni/convert_dset_callables.py b/example-specs/task/nipype/afni/convert_dset_callables.py
index 8cd28c71..df195b27 100644
--- a/example-specs/task/nipype/afni/convert_dset_callables.py
+++ b/example-specs/task/nipype/afni/convert_dset_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in ConvertDset.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of ConvertDset.yaml"""
diff --git a/example-specs/task/nipype/afni/copy_callables.py b/example-specs/task/nipype/afni/copy_callables.py
index df0aabd9..720b743f 100644
--- a/example-specs/task/nipype/afni/copy_callables.py
+++ b/example-specs/task/nipype/afni/copy_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in Copy.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of Copy.yaml"""
diff --git a/example-specs/task/nipype/afni/deconvolve.yaml b/example-specs/task/nipype/afni/deconvolve.yaml
index e0ebb18c..35693fcc 100644
--- a/example-specs/task/nipype/afni/deconvolve.yaml
+++ b/example-specs/task/nipype/afni/deconvolve.yaml
@@ -41,22 +41,22 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    STATmask: generic/file
+    # type=file|default=<undefined>: build a mask from provided file, and use this mask for the purpose of reporting truncation-to float issues AND for computing the FDR curves. The actual results ARE not masked with this option (only with 'mask' or 'automask' options).
+    censor: generic/file
+    # type=file|default=<undefined>: filename of censor .1D time series. This is a file of 1s and 0s, indicating which time points are to be included (1) and which are to be excluded (0).
     in_files: medimage/nifti1+list-of
     # type=inputmultiobject|default=[]: filenames of 3D+time input datasets. More than one filename can be given and the datasets will be auto-catenated in time. You can input a 1D time series file here, but the time axis should run along the ROW direction, not the COLUMN direction as in the 'input1D' option.
     input1D: generic/file
     # type=file|default=<undefined>: filename of single (fMRI) .1D time series where time runs down the column.
     mask: generic/file
     # type=file|default=<undefined>: filename of 3D mask dataset; only data time series from within the mask will be analyzed; results for voxels outside the mask will be set to zero.
-    STATmask: generic/file
-    # type=file|default=<undefined>: build a mask from provided file, and use this mask for the purpose of reporting truncation-to float issues AND for computing the FDR curves. The actual results ARE not masked with this option (only with 'mask' or 'automask' options).
-    censor: generic/file
-    # type=file|default=<undefined>: filename of censor .1D time series. This is a file of 1s and 0s, indicating which time points are to be included (1) and which are to be excluded (0).
-    x1D: Path
-    # type=file: save out X matrix
-    # type=file|default=<undefined>: specify name for saved X matrix
     out_file: Path
     # type=file: output statistics file
     # type=file|default=<undefined>: output statistics file
+    x1D: Path
+    # type=file: save out X matrix
+    # type=file|default=<undefined>: specify name for saved X matrix
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -70,6 +70,9 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    cbucket: generic/file
+    # type=file: output regression coefficients file (if generated)
+    # type=str|default='': Name for dataset in which to save the regression coefficients (no statistics). This dataset will be used in a -xrestore run [not yet implemented] instead of the bucket dataset, if possible.
     out_file: medimage/nifti1
     # type=file: output statistics file
     # type=file|default=<undefined>: output statistics file
@@ -78,9 +81,6 @@ outputs:
     x1D: medimage-afni/oned
     # type=file: save out X matrix
     # type=file|default=<undefined>: specify name for saved X matrix
-    cbucket: generic/file
-    # type=file: output regression coefficients file (if generated)
-    # type=str|default='': Name for dataset in which to save the regression coefficients (no statistics). This dataset will be used in a -xrestore run [not yet implemented] instead of the bucket dataset, if possible.
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/afni/deconvolve_callables.py b/example-specs/task/nipype/afni/deconvolve_callables.py
index 7c50d913..97883751 100644
--- a/example-specs/task/nipype/afni/deconvolve_callables.py
+++ b/example-specs/task/nipype/afni/deconvolve_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in Deconvolve.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of Deconvolve.yaml"""
diff --git a/example-specs/task/nipype/afni/degree_centrality_callables.py b/example-specs/task/nipype/afni/degree_centrality_callables.py
index a13ac89d..57fb37a5 100644
--- a/example-specs/task/nipype/afni/degree_centrality_callables.py
+++ b/example-specs/task/nipype/afni/degree_centrality_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in DegreeCentrality.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of DegreeCentrality.yaml"""
diff --git a/example-specs/task/nipype/afni/despike_callables.py b/example-specs/task/nipype/afni/despike_callables.py
index 59a29b61..fd379b60 100644
--- a/example-specs/task/nipype/afni/despike_callables.py
+++ b/example-specs/task/nipype/afni/despike_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in Despike.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of Despike.yaml"""
diff --git a/example-specs/task/nipype/afni/detrend_callables.py b/example-specs/task/nipype/afni/detrend_callables.py
index cae6cbf3..02c8f7b6 100644
--- a/example-specs/task/nipype/afni/detrend_callables.py
+++ b/example-specs/task/nipype/afni/detrend_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in Detrend.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of Detrend.yaml"""
diff --git a/example-specs/task/nipype/afni/dot.yaml b/example-specs/task/nipype/afni/dot.yaml
index 0e652a6b..ee7ae529 100644
--- a/example-specs/task/nipype/afni/dot.yaml
+++ b/example-specs/task/nipype/afni/dot.yaml
@@ -82,7 +82,7 @@ tests:
     mask:
     # type=file|default=<undefined>: Use this dataset as a mask
     mrange:
-    # type=tuple|default=(<traits.trait_types.Float object at 0x1080ab410>, <traits.trait_types.Float object at 0x1080ab310>): Means to further restrict the voxels from 'mset' so thatonly those mask values within this range (inclusive) willbe used.
+    # type=tuple|default=(<traits.trait_types.Float object at 0x10ffe6310>, <traits.trait_types.Float object at 0x10ffe6210>): Means to further restrict the voxels from 'mset' so thatonly those mask values within this range (inclusive) willbe used.
     demean:
     # type=bool|default=False: Remove the mean from each volume prior to computing the correlation
     docor:
diff --git a/example-specs/task/nipype/afni/dot_callables.py b/example-specs/task/nipype/afni/dot_callables.py
index 1ecb48b1..b8c951c5 100644
--- a/example-specs/task/nipype/afni/dot_callables.py
+++ b/example-specs/task/nipype/afni/dot_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in Dot.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of Dot.yaml"""
diff --git a/example-specs/task/nipype/afni/ecm_callables.py b/example-specs/task/nipype/afni/ecm_callables.py
index 55c619b1..62727561 100644
--- a/example-specs/task/nipype/afni/ecm_callables.py
+++ b/example-specs/task/nipype/afni/ecm_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in ECM.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of ECM.yaml"""
diff --git a/example-specs/task/nipype/afni/edge_3_callables.py b/example-specs/task/nipype/afni/edge_3_callables.py
index 7836b475..c481dd24 100644
--- a/example-specs/task/nipype/afni/edge_3_callables.py
+++ b/example-specs/task/nipype/afni/edge_3_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in Edge3.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of Edge3.yaml"""
diff --git a/example-specs/task/nipype/afni/eval_callables.py b/example-specs/task/nipype/afni/eval_callables.py
index 8bae81cc..829884d8 100644
--- a/example-specs/task/nipype/afni/eval_callables.py
+++ b/example-specs/task/nipype/afni/eval_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in Eval.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of Eval.yaml"""
diff --git a/example-specs/task/nipype/afni/fim.yaml b/example-specs/task/nipype/afni/fim.yaml
index 58b783e3..7f517923 100644
--- a/example-specs/task/nipype/afni/fim.yaml
+++ b/example-specs/task/nipype/afni/fim.yaml
@@ -39,10 +39,10 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    in_file: medimage/nifti1
-    # type=file|default=<undefined>: input file to 3dfim+
     ideal_file: medimage-afni/oned
     # type=file|default=<undefined>: ideal time series file name
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: input file to 3dfim+
     out_file: Path
     # type=file: output file
     # type=file|default=<undefined>: output image file name
diff --git a/example-specs/task/nipype/afni/fim_callables.py b/example-specs/task/nipype/afni/fim_callables.py
index e01594a5..860b82c8 100644
--- a/example-specs/task/nipype/afni/fim_callables.py
+++ b/example-specs/task/nipype/afni/fim_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in Fim.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of Fim.yaml"""
diff --git a/example-specs/task/nipype/afni/fourier_callables.py b/example-specs/task/nipype/afni/fourier_callables.py
index fef4f76e..fada4d06 100644
--- a/example-specs/task/nipype/afni/fourier_callables.py
+++ b/example-specs/task/nipype/afni/fourier_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in Fourier.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of Fourier.yaml"""
diff --git a/example-specs/task/nipype/afni/fwh_mx.yaml b/example-specs/task/nipype/afni/fwh_mx.yaml
index 69a0133c..0538e6a3 100644
--- a/example-specs/task/nipype/afni/fwh_mx.yaml
+++ b/example-specs/task/nipype/afni/fwh_mx.yaml
@@ -117,15 +117,15 @@ inputs:
     # type=file|default=<undefined>: input dataset
     mask: generic/file
     # type=file|default=<undefined>: use only voxels that are nonzero in mask
+    out_detrend: Path
+    # type=file: output file, detrended
+    # type=file|default=<undefined>: Save the detrended file into a dataset
     out_file: Path
     # type=file: output file
     # type=file|default=<undefined>: output file
     out_subbricks: Path
     # type=file: output file (subbricks)
     # type=file|default=<undefined>: output file listing the subbricks FWHM
-    out_detrend: Path
-    # type=file: output file, detrended
-    # type=file|default=<undefined>: Save the detrended file into a dataset
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -139,17 +139,17 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    out_acf: generic/file
+    # type=file: output acf file
+    out_detrend: generic/file
+    # type=file: output file, detrended
+    # type=file|default=<undefined>: Save the detrended file into a dataset
     out_file: generic/file
     # type=file: output file
     # type=file|default=<undefined>: output file
     out_subbricks: generic/file
     # type=file: output file (subbricks)
     # type=file|default=<undefined>: output file listing the subbricks FWHM
-    out_detrend: generic/file
-    # type=file: output file, detrended
-    # type=file|default=<undefined>: Save the detrended file into a dataset
-    out_acf: generic/file
-    # type=file: output acf file
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/afni/fwh_mx_callables.py b/example-specs/task/nipype/afni/fwh_mx_callables.py
index 4714fc62..cadbc73d 100644
--- a/example-specs/task/nipype/afni/fwh_mx_callables.py
+++ b/example-specs/task/nipype/afni/fwh_mx_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in FWHMx.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of FWHMx.yaml"""
diff --git a/example-specs/task/nipype/afni/gcor_callables.py b/example-specs/task/nipype/afni/gcor_callables.py
index d268a028..1e1b5923 100644
--- a/example-specs/task/nipype/afni/gcor_callables.py
+++ b/example-specs/task/nipype/afni/gcor_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in GCOR.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of GCOR.yaml"""
diff --git a/example-specs/task/nipype/afni/hist_callables.py b/example-specs/task/nipype/afni/hist_callables.py
index f6578ac1..56635a9c 100644
--- a/example-specs/task/nipype/afni/hist_callables.py
+++ b/example-specs/task/nipype/afni/hist_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in Hist.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of Hist.yaml"""
diff --git a/example-specs/task/nipype/afni/lfcd_callables.py b/example-specs/task/nipype/afni/lfcd_callables.py
index 96a6755d..39f71693 100644
--- a/example-specs/task/nipype/afni/lfcd_callables.py
+++ b/example-specs/task/nipype/afni/lfcd_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in LFCD.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of LFCD.yaml"""
diff --git a/example-specs/task/nipype/afni/local_bistat.yaml b/example-specs/task/nipype/afni/local_bistat.yaml
index 2341ed13..c8bb4c78 100644
--- a/example-specs/task/nipype/afni/local_bistat.yaml
+++ b/example-specs/task/nipype/afni/local_bistat.yaml
@@ -45,11 +45,11 @@ inputs:
     # type=file|default=<undefined>: Filename of the second image
     mask_file: generic/file
     # type=file|default=<undefined>: mask image file name. Voxels NOT in the mask will not be used in the neighborhood of any voxel. Also, a voxel NOT in the mask will have its statistic(s) computed as zero (0).
-    weight_file: generic/file
-    # type=file|default=<undefined>: File name of an image to use as a weight.  Only applies to 'pearson' statistics.
     out_file: Path
     # type=file: output file
     # type=file|default=<undefined>: Output dataset.
+    weight_file: generic/file
+    # type=file|default=<undefined>: File name of an image to use as a weight.  Only applies to 'pearson' statistics.
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/local_bistat_callables.py b/example-specs/task/nipype/afni/local_bistat_callables.py
index c94b1bab..32c1bc96 100644
--- a/example-specs/task/nipype/afni/local_bistat_callables.py
+++ b/example-specs/task/nipype/afni/local_bistat_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in LocalBistat.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of LocalBistat.yaml"""
diff --git a/example-specs/task/nipype/afni/localstat_callables.py b/example-specs/task/nipype/afni/localstat_callables.py
index b625977e..2704455b 100644
--- a/example-specs/task/nipype/afni/localstat_callables.py
+++ b/example-specs/task/nipype/afni/localstat_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in Localstat.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of Localstat.yaml"""
diff --git a/example-specs/task/nipype/afni/mask_tool_callables.py b/example-specs/task/nipype/afni/mask_tool_callables.py
index 788061ff..0962c849 100644
--- a/example-specs/task/nipype/afni/mask_tool_callables.py
+++ b/example-specs/task/nipype/afni/mask_tool_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in MaskTool.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of MaskTool.yaml"""
diff --git a/example-specs/task/nipype/afni/maskave_callables.py b/example-specs/task/nipype/afni/maskave_callables.py
index bfb2eb35..1f013994 100644
--- a/example-specs/task/nipype/afni/maskave_callables.py
+++ b/example-specs/task/nipype/afni/maskave_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in Maskave.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of Maskave.yaml"""
diff --git a/example-specs/task/nipype/afni/means_callables.py b/example-specs/task/nipype/afni/means_callables.py
index 4e09bd79..ece13969 100644
--- a/example-specs/task/nipype/afni/means_callables.py
+++ b/example-specs/task/nipype/afni/means_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in Means.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of Means.yaml"""
diff --git a/example-specs/task/nipype/afni/merge_callables.py b/example-specs/task/nipype/afni/merge_callables.py
index 1950a89d..a64071b1 100644
--- a/example-specs/task/nipype/afni/merge_callables.py
+++ b/example-specs/task/nipype/afni/merge_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in Merge.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of Merge.yaml"""
diff --git a/example-specs/task/nipype/afni/net_corr.yaml b/example-specs/task/nipype/afni/net_corr.yaml
index 93e00dba..39f3e3c5 100644
--- a/example-specs/task/nipype/afni/net_corr.yaml
+++ b/example-specs/task/nipype/afni/net_corr.yaml
@@ -47,10 +47,10 @@ inputs:
     # type=file|default=<undefined>: input set of ROIs, each labelled with distinct integers
     mask: medimage/nifti1
     # type=file|default=<undefined>: can include a whole brain mask within which to calculate correlation. Otherwise, data should be masked already
+    out_file: Path
+    # type=file|default=<undefined>: output file name part
     weight_ts: generic/file
     # type=file|default=<undefined>: input a 1D file WTS of weights that will be applied multiplicatively to each ROI's average time series. WTS can be a column- or row-file of values, but it must have the same length as the input time series volume. If the initial average time series was A[n] for n=0,..,(N-1) time points, then applying a set of weights W[n] of the same length from WTS would produce a new time series:  B[n] = A[n] * W[n]
-    out_file: medimage-afni/ncorr
-    # type=file|default=<undefined>: output file name part
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -149,7 +149,7 @@ tests:
     # type=bool|default=False: same as above in '-ts_wb_corr', except that the maps have been Fisher transformed to Z-scores the relation: Z=atanh(r). To avoid infinities in the transform, Pearson values are effectively capped at |r| = 0.999329 (where |Z| = 4.0). Files are labelled WB_Z_ROI_001+orig, etc
     fish_z: 'True'
     # type=bool|default=False: switch to also output a matrix of Fisher Z-transform values for the corr coefs (r): Z = atanh(r) , (with Z=4 being output along matrix diagonals where r=1, as the r-to-Z conversion is ceilinged at Z = atanh(r=0.999329) = 4, which is still *quite* a high Pearson-r value
-    out_file:
+    out_file: '"sub0.tp1.ncorr"'
     # type=file|default=<undefined>: output file name part
   imports:
   # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
@@ -185,7 +185,7 @@ doctests:
     # type=bool|default=False: same as above in '-ts_wb_corr', except that the maps have been Fisher transformed to Z-scores the relation: Z=atanh(r). To avoid infinities in the transform, Pearson values are effectively capped at |r| = 0.999329 (where |Z| = 4.0). Files are labelled WB_Z_ROI_001+orig, etc
     fish_z: 'True'
     # type=bool|default=False: switch to also output a matrix of Fisher Z-transform values for the corr coefs (r): Z = atanh(r) , (with Z=4 being output along matrix diagonals where r=1, as the r-to-Z conversion is ceilinged at Z = atanh(r=0.999329) = 4, which is still *quite* a high Pearson-r value
-    out_file:
+    out_file: '"sub0.tp1.ncorr"'
     # type=file|default=<undefined>: output file name part
   imports:
   # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
diff --git a/example-specs/task/nipype/afni/net_corr_callables.py b/example-specs/task/nipype/afni/net_corr_callables.py
index 7202de6d..dd2cc65d 100644
--- a/example-specs/task/nipype/afni/net_corr_callables.py
+++ b/example-specs/task/nipype/afni/net_corr_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in NetCorr.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of NetCorr.yaml"""
diff --git a/example-specs/task/nipype/afni/notes_callables.py b/example-specs/task/nipype/afni/notes_callables.py
index 1735c99c..7b329c55 100644
--- a/example-specs/task/nipype/afni/notes_callables.py
+++ b/example-specs/task/nipype/afni/notes_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in Notes.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of Notes.yaml"""
diff --git a/example-specs/task/nipype/afni/nwarp_adjust.yaml b/example-specs/task/nipype/afni/nwarp_adjust.yaml
index 879c3134..e87d1cfd 100644
--- a/example-specs/task/nipype/afni/nwarp_adjust.yaml
+++ b/example-specs/task/nipype/afni/nwarp_adjust.yaml
@@ -39,13 +39,13 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    warps: medimage/nifti-gz+list-of
-    # type=inputmultiobject|default=[]: List of input 3D warp datasets
     in_files: generic/file+list-of
     # type=inputmultiobject|default=[]: List of input 3D datasets to be warped by the adjusted warp datasets.  There must be exactly as many of these datasets as there are input warps.
     out_file: Path
     # type=file: output file
     # type=file|default=<undefined>: Output mean dataset, only needed if in_files are also given. The output dataset will be on the common grid shared by the source datasets.
+    warps: medimage/nifti-gz+list-of
+    # type=inputmultiobject|default=[]: List of input 3D warp datasets
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/nwarp_adjust_callables.py b/example-specs/task/nipype/afni/nwarp_adjust_callables.py
index 7d24d4c1..675694c9 100644
--- a/example-specs/task/nipype/afni/nwarp_adjust_callables.py
+++ b/example-specs/task/nipype/afni/nwarp_adjust_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in NwarpAdjust.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of NwarpAdjust.yaml"""
diff --git a/example-specs/task/nipype/afni/nwarp_apply_callables.py b/example-specs/task/nipype/afni/nwarp_apply_callables.py
index 79d1bed8..bbc3ac4e 100644
--- a/example-specs/task/nipype/afni/nwarp_apply_callables.py
+++ b/example-specs/task/nipype/afni/nwarp_apply_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in NwarpApply.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of NwarpApply.yaml"""
diff --git a/example-specs/task/nipype/afni/nwarp_cat_callables.py b/example-specs/task/nipype/afni/nwarp_cat_callables.py
index fb01a71b..91922f70 100644
--- a/example-specs/task/nipype/afni/nwarp_cat_callables.py
+++ b/example-specs/task/nipype/afni/nwarp_cat_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in NwarpCat.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of NwarpCat.yaml"""
diff --git a/example-specs/task/nipype/afni/one_d_tool_py.yaml b/example-specs/task/nipype/afni/one_d_tool_py.yaml
index 0028d6ba..fdb3e8d8 100644
--- a/example-specs/task/nipype/afni/one_d_tool_py.yaml
+++ b/example-specs/task/nipype/afni/one_d_tool_py.yaml
@@ -33,11 +33,11 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage-afni/oned
     # type=file|default=<undefined>: input file to OneDTool
-    show_cormat_warnings: generic/file
-    # type=file|default=<undefined>: Write cormat warnings to a file
     out_file: Path
     # type=file: output of 1D_tool.py
     # type=file|default=<undefined>: write the current 1D data to FILE
+    show_cormat_warnings: generic/file
+    # type=file|default=<undefined>: Write cormat warnings to a file
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -79,7 +79,7 @@ tests:
     show_censor_count:
     # type=bool|default=False: display the total number of censored TRs  Note : if input is a valid xmat.1D dataset, then the count will come from the header.  Otherwise the input is assumed to be a binary censorfile, and zeros are simply counted.
     censor_motion:
-    # type=tuple|default=(<traits.trait_types.Float object at 0x1080d3510>, <nipype.interfaces.base.traits_extension.File object at 0x1080d35d0>): Tuple of motion limit and outfile prefix. need to also set set_nruns -r set_run_lengths
+    # type=tuple|default=(<traits.trait_types.Float object at 0x11411a010>, <nipype.interfaces.base.traits_extension.File object at 0x11411a0d0>): Tuple of motion limit and outfile prefix. need to also set set_nruns -r set_run_lengths
     censor_prev_TR:
     # type=bool|default=False: for each censored TR, also censor previous
     show_trs_uncensored:
diff --git a/example-specs/task/nipype/afni/one_d_tool_py_callables.py b/example-specs/task/nipype/afni/one_d_tool_py_callables.py
index 979a9988..bc7bdd70 100644
--- a/example-specs/task/nipype/afni/one_d_tool_py_callables.py
+++ b/example-specs/task/nipype/afni/one_d_tool_py_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in OneDToolPy.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of OneDToolPy.yaml"""
diff --git a/example-specs/task/nipype/afni/outlier_count.yaml b/example-specs/task/nipype/afni/outlier_count.yaml
index 04be0222..274067c2 100644
--- a/example-specs/task/nipype/afni/outlier_count.yaml
+++ b/example-specs/task/nipype/afni/outlier_count.yaml
@@ -39,11 +39,11 @@ inputs:
     # type=file|default=<undefined>: input dataset
     mask: generic/file
     # type=file|default=<undefined>: only count voxels within the given mask
-    outliers_file: generic/file
-    # type=file|default=<undefined>: output image file name
     out_file: Path
     # type=file: capture standard output
     # type=file|default=<undefined>: capture standard output
+    outliers_file: generic/file
+    # type=file|default=<undefined>: output image file name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -57,11 +57,11 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    out_outliers: generic/file
-    # type=file: output image file name
     out_file: generic/file
     # type=file: capture standard output
     # type=file|default=<undefined>: capture standard output
+    out_outliers: generic/file
+    # type=file: output image file name
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/afni/outlier_count_callables.py b/example-specs/task/nipype/afni/outlier_count_callables.py
index 48231b09..60baa917 100644
--- a/example-specs/task/nipype/afni/outlier_count_callables.py
+++ b/example-specs/task/nipype/afni/outlier_count_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in OutlierCount.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of OutlierCount.yaml"""
diff --git a/example-specs/task/nipype/afni/quality_index_callables.py b/example-specs/task/nipype/afni/quality_index_callables.py
index dc347515..dc24d8ac 100644
--- a/example-specs/task/nipype/afni/quality_index_callables.py
+++ b/example-specs/task/nipype/afni/quality_index_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in QualityIndex.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of QualityIndex.yaml"""
diff --git a/example-specs/task/nipype/afni/qwarp.yaml b/example-specs/task/nipype/afni/qwarp.yaml
index d53446be..698dfef9 100644
--- a/example-specs/task/nipype/afni/qwarp.yaml
+++ b/example-specs/task/nipype/afni/qwarp.yaml
@@ -109,22 +109,22 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    in_file: medimage/nifti1,medimage/nifti-gz
-    # type=file|default=<undefined>: Source image (opposite phase encoding direction than base image).
-    base_file: medimage/nifti1,medimage/nifti-gz
+    base_file: medimage/nifti1
     # type=file|default=<undefined>: Base image (opposite phase encoding direction than source image).
-    out_file: medimage/nifti-gz
-    # type=file|default=<undefined>: Sets the prefix/suffix for the output datasets.  * The source dataset is warped to match the base   and gets prefix 'ppp'. (Except if '-plusminus' is used * The final interpolation to this output dataset is   done using the 'wsinc5' method.  See the output of   3dAllineate -HELP   (in the "Modifying '-final wsinc5'" section) for   the lengthy technical details. * The 3D warp used is saved in a dataset with   prefix 'ppp_WARP' -- this dataset can be used   with 3dNwarpApply and 3dNwarpCat, for example. * To be clear, this is the warp from source dataset   coordinates to base dataset coordinates, where the   values at each base grid point are the xyz displacements   needed to move that grid point's xyz values to the   corresponding xyz values in the source dataset:   base( (x,y,z) + WARP(x,y,z) ) matches source(x,y,z)   Another way to think of this warp is that it 'pulls'   values back from source space to base space. * 3dNwarpApply would use 'ppp_WARP' to transform datasets   aligned with the source dataset to be aligned with the   base dataset.  **If you do NOT want this warp saved, use the option '-nowarp'**. (However, this warp is usually the most valuable possible output!)  * If you want to calculate and save the inverse 3D warp,   use the option '-iwarp'.  This inverse warp will then be   saved in a dataset with prefix 'ppp_WARPINV'. * This inverse warp could be used to transform data from base   space to source space, if you need to do such an operation. * You can easily compute the inverse later, say by a command like   3dNwarpCat -prefix Z_WARPINV 'INV(Z_WARP+tlrc)'   or the inverse can be computed as needed in 3dNwarpApply, like   3dNwarpApply -nwarp 'INV(Z_WARP+tlrc)' -source Dataset.nii ...  
-    weight: generic/file
-    # type=file|default=<undefined>: Instead of computing the weight from the base dataset,directly input the weight volume from dataset 'www'.Useful if you know what over parts of the base image youwant to emphasize or de-emphasize the matching functional.
-    out_weight_file: generic/file
-    # type=file|default=<undefined>: Write the weight volume to disk as a dataset
     emask: generic/file
     # type=file|default=<undefined>: Here, 'ee' is a dataset to specify a mask of voxelsto EXCLUDE from the analysis -- all voxels in 'ee'that are NONZERO will not be used in the alignment.The base image always automasked -- the emask isextra, to indicate voxels you definitely DON'T wantincluded in the matching process, even if they areinside the brain.
-    iniwarp: medimage-afni/head+list-of
-    # type=list|default=[]: A dataset with an initial nonlinear warp to use.  * If this option is not used, the initial warp is the identity. * You can specify a catenation of warps (in quotes) here, as in   program 3dNwarpApply. * As a special case, if you just input an affine matrix in a .1D   file, that will work also -- it is treated as giving the initial   warp via the string "IDENT(base_dataset) matrix_file.aff12.1D". * You CANNOT use this option with -duplo !! * -iniwarp is usually used with -inilev to re-start 3dQwarp from   a previous stopping point.  
     gridlist: generic/file
     # type=file|default=<undefined>: This option provides an alternate way to specify the patch grid sizes used in the warp optimization process. 'gl' is a 1D file with a list of patches to use -- in most cases, you will want to use it in the following form: ``-gridlist '1D: 0 151 101 75 51'``  * Here, a 0 patch size means the global domain. Patch sizes   otherwise should be odd integers >= 5. * If you use the '0' patch size again after the first position,   you will actually get an iteration at the size of the   default patch level 1, where the patch sizes are 75% of   the volume dimension.  There is no way to force the program   to literally repeat the sui generis step of lev=0.  
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: Source image (opposite phase encoding direction than base image).
+    iniwarp: medimage-afni/head+list-of
+    # type=list|default=[]: A dataset with an initial nonlinear warp to use.  * If this option is not used, the initial warp is the identity. * You can specify a catenation of warps (in quotes) here, as in   program 3dNwarpApply. * As a special case, if you just input an affine matrix in a .1D   file, that will work also -- it is treated as giving the initial   warp via the string "IDENT(base_dataset) matrix_file.aff12.1D". * You CANNOT use this option with -duplo !! * -iniwarp is usually used with -inilev to re-start 3dQwarp from   a previous stopping point.  
+    out_file: Path
+    # type=file|default=<undefined>: Sets the prefix/suffix for the output datasets.  * The source dataset is warped to match the base   and gets prefix 'ppp'. (Except if '-plusminus' is used * The final interpolation to this output dataset is   done using the 'wsinc5' method.  See the output of   3dAllineate -HELP   (in the "Modifying '-final wsinc5'" section) for   the lengthy technical details. * The 3D warp used is saved in a dataset with   prefix 'ppp_WARP' -- this dataset can be used   with 3dNwarpApply and 3dNwarpCat, for example. * To be clear, this is the warp from source dataset   coordinates to base dataset coordinates, where the   values at each base grid point are the xyz displacements   needed to move that grid point's xyz values to the   corresponding xyz values in the source dataset:   base( (x,y,z) + WARP(x,y,z) ) matches source(x,y,z)   Another way to think of this warp is that it 'pulls'   values back from source space to base space. * 3dNwarpApply would use 'ppp_WARP' to transform datasets   aligned with the source dataset to be aligned with the   base dataset.  **If you do NOT want this warp saved, use the option '-nowarp'**. (However, this warp is usually the most valuable possible output!)  * If you want to calculate and save the inverse 3D warp,   use the option '-iwarp'.  This inverse warp will then be   saved in a dataset with prefix 'ppp_WARPINV'. * This inverse warp could be used to transform data from base   space to source space, if you need to do such an operation. * You can easily compute the inverse later, say by a command like   3dNwarpCat -prefix Z_WARPINV 'INV(Z_WARP+tlrc)'   or the inverse can be computed as needed in 3dNwarpApply, like   3dNwarpApply -nwarp 'INV(Z_WARP+tlrc)' -source Dataset.nii ...  
+    out_weight_file: Path
+    # type=file|default=<undefined>: Write the weight volume to disk as a dataset
+    weight: generic/file
+    # type=file|default=<undefined>: Instead of computing the weight from the base dataset,directly input the weight volume from dataset 'www'.Useful if you know what over parts of the base image youwant to emphasize or de-emphasize the matching functional.
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -138,14 +138,14 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    warped_source: generic/file
-    # type=file: Warped source file. If plusminus is used, this is the undistortedsource file.
-    warped_base: generic/file
-    # type=file: Undistorted base file.
-    source_warp: generic/file
-    # type=file: Displacement in mm for the source image.If plusminus is used this is the field suceptibility correctionwarp (in 'mm') for source image.
     base_warp: generic/file
     # type=file: Displacement in mm for the base image.If plus minus is used, this is the field suceptibility correctionwarp (in 'mm') for base image. This is only output if plusminusor iwarp options are passed
+    source_warp: generic/file
+    # type=file: Displacement in mm for the source image.If plusminus is used this is the field suceptibility correctionwarp (in 'mm') for source image.
+    warped_base: generic/file
+    # type=file: Undistorted base file.
+    warped_source: generic/file
+    # type=file: Warped source file. If plusminus is used, this is the undistortedsource file.
     weights: generic/file
     # type=file: Auto-computed weight volume.
   callables:
@@ -190,7 +190,7 @@ tests:
     wball:
     # type=list|default=[]: "``-wball x y z r f`` Enhance automatic weight from '-useweight' by a factor of 1+f\*Gaussian(FWHM=r) centered in the base image at DICOM coordinates (x,y,z) and with radius 'r'. The goal of this option is to try and make the alignment better in a specific part of the brain. Example:  -wball 0 14 6 30 40 to emphasize the thalamic area (in MNI/Talairach space).  * The 'r' parameter must be positive! * The 'f' parameter must be between 1 and 100 (inclusive). * '-wball' does nothing if you input your own weight   with the '-weight' option. * '-wball' does change the binary weight created by   the '-noweight' option. * You can only use '-wball' once in a run of 3dQwarp.  **The effect of '-wball' is not dramatic.** The example above makes the average brain image across a collection of subjects a little sharper in the thalamic area, which might have some small value.  If you care enough about alignment to use '-wball', then you should examine the results from 3dQwarp for each subject, to see if the alignments are good enough for your purposes.
     wmask:
-    # type=tuple|default=(<nipype.interfaces.base.traits_extension.File object at 0x107fd7b50>, <traits.trait_types.Float object at 0x107fd7d10>): Similar to '-wball', but here, you provide a dataset 'ws' that indicates where to increase the weight.  * The 'ws' dataset must be on the same 3D grid as the base dataset. * 'ws' is treated as a mask -- it only matters where it   is nonzero -- otherwise, the values inside are not used. * After 'ws' comes the factor 'f' by which to increase the   automatically computed weight.  Where 'ws' is nonzero,   the weighting will be multiplied by (1+f). * As with '-wball', the factor 'f' should be between 1 and 100.  
+    # type=tuple|default=(<nipype.interfaces.base.traits_extension.File object at 0x10ff13890>, <traits.trait_types.Float object at 0x10ff13910>): Similar to '-wball', but here, you provide a dataset 'ws' that indicates where to increase the weight.  * The 'ws' dataset must be on the same 3D grid as the base dataset. * 'ws' is treated as a mask -- it only matters where it   is nonzero -- otherwise, the values inside are not used. * After 'ws' comes the factor 'f' by which to increase the   automatically computed weight.  Where 'ws' is nonzero,   the weighting will be multiplied by (1+f). * As with '-wball', the factor 'f' should be between 1 and 100.  
     out_weight_file:
     # type=file|default=<undefined>: Write the weight volume to disk as a dataset
     blur:
@@ -333,7 +333,7 @@ tests:
     # type=file|default=<undefined>: Source image (opposite phase encoding direction than base image).
     base_file:
     # type=file|default=<undefined>: Base image (opposite phase encoding direction than source image).
-    out_file:
+    out_file: '"anatSSQ.nii.gz"'
     # type=file|default=<undefined>: Sets the prefix/suffix for the output datasets.  * The source dataset is warped to match the base   and gets prefix 'ppp'. (Except if '-plusminus' is used * The final interpolation to this output dataset is   done using the 'wsinc5' method.  See the output of   3dAllineate -HELP   (in the "Modifying '-final wsinc5'" section) for   the lengthy technical details. * The 3D warp used is saved in a dataset with   prefix 'ppp_WARP' -- this dataset can be used   with 3dNwarpApply and 3dNwarpCat, for example. * To be clear, this is the warp from source dataset   coordinates to base dataset coordinates, where the   values at each base grid point are the xyz displacements   needed to move that grid point's xyz values to the   corresponding xyz values in the source dataset:   base( (x,y,z) + WARP(x,y,z) ) matches source(x,y,z)   Another way to think of this warp is that it 'pulls'   values back from source space to base space. * 3dNwarpApply would use 'ppp_WARP' to transform datasets   aligned with the source dataset to be aligned with the   base dataset.  **If you do NOT want this warp saved, use the option '-nowarp'**. (However, this warp is usually the most valuable possible output!)  * If you want to calculate and save the inverse 3D warp,   use the option '-iwarp'.  This inverse warp will then be   saved in a dataset with prefix 'ppp_WARPINV'. * This inverse warp could be used to transform data from base   space to source space, if you need to do such an operation. * You can easily compute the inverse later, say by a command like   3dNwarpCat -prefix Z_WARPINV 'INV(Z_WARP+tlrc)'   or the inverse can be computed as needed in 3dNwarpApply, like   3dNwarpApply -nwarp 'INV(Z_WARP+tlrc)' -source Dataset.nii ...  
     resample: 'True'
     # type=bool|default=False: This option simply resamples the source dataset to match the base dataset grid.  You can use this if the two datasets overlap well (as seen in the AFNI GUI), but are not on the same 3D grid.  * If they don't overlap well, allineate them first * The reampling here is done with the   'wsinc5' method, which has very little blurring artifact. * If the base and source datasets ARE on the same 3D grid,   then the -resample option will be ignored. * You CAN use -resample with these 3dQwarp options:   -plusminus  -inilev  -iniwarp  -duplo  
@@ -399,7 +399,7 @@ tests:
     # type=int|default=0: The value of mm should be an odd integer.  * The default value of mm is 25. * For more accurate results than mm=25, try 19 or 13. * The smallest allowed patch size is 5. * You may want stop at a larger patch size (say 7 or 9) and use   the -Qfinal option to run that final level with quintic warps,   which might run faster and provide the same degree of warp detail. * Trying to make two different brain volumes match in fine detail   is usually a waste of time, especially in humans.  There is too   much variability in anatomy to match gyrus to gyrus accurately.   For this reason, the default minimum patch size is 25 voxels.   Using a smaller '-minpatch' might try to force the warp to   match features that do not match, and the result can be useless   image distortions -- another reason to LOOK AT THE RESULTS.  
     blur: '[0,3]'
     # type=list|default=[]: Gaussian blur the input images by 'bb' (FWHM) voxels before doing the alignment (the output dataset will not be blurred). The default is 2.345 (for no good reason).  * Optionally, you can provide 2 values for 'bb', and then   the first one is applied to the base volume, the second   to the source volume.   e.g., '-blur 0 3' to skip blurring the base image   (if the base is a blurry template, for example). * A negative blur radius means to use 3D median filtering,   rather than Gaussian blurring.  This type of filtering will   better preserve edges, which can be important in alignment. * If the base is a template volume that is already blurry,   you probably don't want to blur it again, but blurring   the source volume a little is probably a good idea, to   help the program avoid trying to match tiny features. * Note that -duplo will blur the volumes some extra   amount for the initial small-scale warping, to make   that phase of the program converge more rapidly.  
-    out_file:
+    out_file: '"Q25"'
     # type=file|default=<undefined>: Sets the prefix/suffix for the output datasets.  * The source dataset is warped to match the base   and gets prefix 'ppp'. (Except if '-plusminus' is used * The final interpolation to this output dataset is   done using the 'wsinc5' method.  See the output of   3dAllineate -HELP   (in the "Modifying '-final wsinc5'" section) for   the lengthy technical details. * The 3D warp used is saved in a dataset with   prefix 'ppp_WARP' -- this dataset can be used   with 3dNwarpApply and 3dNwarpCat, for example. * To be clear, this is the warp from source dataset   coordinates to base dataset coordinates, where the   values at each base grid point are the xyz displacements   needed to move that grid point's xyz values to the   corresponding xyz values in the source dataset:   base( (x,y,z) + WARP(x,y,z) ) matches source(x,y,z)   Another way to think of this warp is that it 'pulls'   values back from source space to base space. * 3dNwarpApply would use 'ppp_WARP' to transform datasets   aligned with the source dataset to be aligned with the   base dataset.  **If you do NOT want this warp saved, use the option '-nowarp'**. (However, this warp is usually the most valuable possible output!)  * If you want to calculate and save the inverse 3D warp,   use the option '-iwarp'.  This inverse warp will then be   saved in a dataset with prefix 'ppp_WARPINV'. * This inverse warp could be used to transform data from base   space to source space, if you need to do such an operation. * You can easily compute the inverse later, say by a command like   3dNwarpCat -prefix Z_WARPINV 'INV(Z_WARP+tlrc)'   or the inverse can be computed as needed in 3dNwarpApply, like   3dNwarpApply -nwarp 'INV(Z_WARP+tlrc)' -source Dataset.nii ...  
   imports:
   # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
@@ -425,7 +425,7 @@ tests:
     # type=file|default=<undefined>: Base image (opposite phase encoding direction than source image).
     blur: '[0,2]'
     # type=list|default=[]: Gaussian blur the input images by 'bb' (FWHM) voxels before doing the alignment (the output dataset will not be blurred). The default is 2.345 (for no good reason).  * Optionally, you can provide 2 values for 'bb', and then   the first one is applied to the base volume, the second   to the source volume.   e.g., '-blur 0 3' to skip blurring the base image   (if the base is a blurry template, for example). * A negative blur radius means to use 3D median filtering,   rather than Gaussian blurring.  This type of filtering will   better preserve edges, which can be important in alignment. * If the base is a template volume that is already blurry,   you probably don't want to blur it again, but blurring   the source volume a little is probably a good idea, to   help the program avoid trying to match tiny features. * Note that -duplo will blur the volumes some extra   amount for the initial small-scale warping, to make   that phase of the program converge more rapidly.  
-    out_file:
+    out_file: '"Q11"'
     # type=file|default=<undefined>: Sets the prefix/suffix for the output datasets.  * The source dataset is warped to match the base   and gets prefix 'ppp'. (Except if '-plusminus' is used * The final interpolation to this output dataset is   done using the 'wsinc5' method.  See the output of   3dAllineate -HELP   (in the "Modifying '-final wsinc5'" section) for   the lengthy technical details. * The 3D warp used is saved in a dataset with   prefix 'ppp_WARP' -- this dataset can be used   with 3dNwarpApply and 3dNwarpCat, for example. * To be clear, this is the warp from source dataset   coordinates to base dataset coordinates, where the   values at each base grid point are the xyz displacements   needed to move that grid point's xyz values to the   corresponding xyz values in the source dataset:   base( (x,y,z) + WARP(x,y,z) ) matches source(x,y,z)   Another way to think of this warp is that it 'pulls'   values back from source space to base space. * 3dNwarpApply would use 'ppp_WARP' to transform datasets   aligned with the source dataset to be aligned with the   base dataset.  **If you do NOT want this warp saved, use the option '-nowarp'**. (However, this warp is usually the most valuable possible output!)  * If you want to calculate and save the inverse 3D warp,   use the option '-iwarp'.  This inverse warp will then be   saved in a dataset with prefix 'ppp_WARPINV'. * This inverse warp could be used to transform data from base   space to source space, if you need to do such an operation. * You can easily compute the inverse later, say by a command like   3dNwarpCat -prefix Z_WARPINV 'INV(Z_WARP+tlrc)'   or the inverse can be computed as needed in 3dNwarpApply, like   3dNwarpApply -nwarp 'INV(Z_WARP+tlrc)' -source Dataset.nii ...  
     inilev: '7'
     # type=int|default=0: The initial refinement 'level' at which to start.  * Usually used with -iniwarp; CANNOT be used with -duplo. * The combination of -inilev and -iniwarp lets you take the   results of a previous 3dQwarp run and refine them further:   Note that the source dataset in the second run is the SAME as   in the first run.  If you don't see why this is necessary,   then you probably need to seek help from an AFNI guru.  
@@ -519,7 +519,7 @@ doctests:
     # type=file|default=<undefined>: Source image (opposite phase encoding direction than base image).
     base_file:
     # type=file|default=<undefined>: Base image (opposite phase encoding direction than source image).
-    out_file:
+    out_file: '"anatSSQ.nii.gz"'
     # type=file|default=<undefined>: Sets the prefix/suffix for the output datasets.  * The source dataset is warped to match the base   and gets prefix 'ppp'. (Except if '-plusminus' is used * The final interpolation to this output dataset is   done using the 'wsinc5' method.  See the output of   3dAllineate -HELP   (in the "Modifying '-final wsinc5'" section) for   the lengthy technical details. * The 3D warp used is saved in a dataset with   prefix 'ppp_WARP' -- this dataset can be used   with 3dNwarpApply and 3dNwarpCat, for example. * To be clear, this is the warp from source dataset   coordinates to base dataset coordinates, where the   values at each base grid point are the xyz displacements   needed to move that grid point's xyz values to the   corresponding xyz values in the source dataset:   base( (x,y,z) + WARP(x,y,z) ) matches source(x,y,z)   Another way to think of this warp is that it 'pulls'   values back from source space to base space. * 3dNwarpApply would use 'ppp_WARP' to transform datasets   aligned with the source dataset to be aligned with the   base dataset.  **If you do NOT want this warp saved, use the option '-nowarp'**. (However, this warp is usually the most valuable possible output!)  * If you want to calculate and save the inverse 3D warp,   use the option '-iwarp'.  This inverse warp will then be   saved in a dataset with prefix 'ppp_WARPINV'. * This inverse warp could be used to transform data from base   space to source space, if you need to do such an operation. * You can easily compute the inverse later, say by a command like   3dNwarpCat -prefix Z_WARPINV 'INV(Z_WARP+tlrc)'   or the inverse can be computed as needed in 3dNwarpApply, like   3dNwarpApply -nwarp 'INV(Z_WARP+tlrc)' -source Dataset.nii ...  
     resample: 'True'
     # type=bool|default=False: This option simply resamples the source dataset to match the base dataset grid.  You can use this if the two datasets overlap well (as seen in the AFNI GUI), but are not on the same 3D grid.  * If they don't overlap well, allineate them first * The reampling here is done with the   'wsinc5' method, which has very little blurring artifact. * If the base and source datasets ARE on the same 3D grid,   then the -resample option will be ignored. * You CAN use -resample with these 3dQwarp options:   -plusminus  -inilev  -iniwarp  -duplo  
@@ -571,7 +571,7 @@ doctests:
     # type=int|default=0: The value of mm should be an odd integer.  * The default value of mm is 25. * For more accurate results than mm=25, try 19 or 13. * The smallest allowed patch size is 5. * You may want stop at a larger patch size (say 7 or 9) and use   the -Qfinal option to run that final level with quintic warps,   which might run faster and provide the same degree of warp detail. * Trying to make two different brain volumes match in fine detail   is usually a waste of time, especially in humans.  There is too   much variability in anatomy to match gyrus to gyrus accurately.   For this reason, the default minimum patch size is 25 voxels.   Using a smaller '-minpatch' might try to force the warp to   match features that do not match, and the result can be useless   image distortions -- another reason to LOOK AT THE RESULTS.  
     blur: '[0,3]'
     # type=list|default=[]: Gaussian blur the input images by 'bb' (FWHM) voxels before doing the alignment (the output dataset will not be blurred). The default is 2.345 (for no good reason).  * Optionally, you can provide 2 values for 'bb', and then   the first one is applied to the base volume, the second   to the source volume.   e.g., '-blur 0 3' to skip blurring the base image   (if the base is a blurry template, for example). * A negative blur radius means to use 3D median filtering,   rather than Gaussian blurring.  This type of filtering will   better preserve edges, which can be important in alignment. * If the base is a template volume that is already blurry,   you probably don't want to blur it again, but blurring   the source volume a little is probably a good idea, to   help the program avoid trying to match tiny features. * Note that -duplo will blur the volumes some extra   amount for the initial small-scale warping, to make   that phase of the program converge more rapidly.  
-    out_file:
+    out_file: '"Q25"'
     # type=file|default=<undefined>: Sets the prefix/suffix for the output datasets.  * The source dataset is warped to match the base   and gets prefix 'ppp'. (Except if '-plusminus' is used * The final interpolation to this output dataset is   done using the 'wsinc5' method.  See the output of   3dAllineate -HELP   (in the "Modifying '-final wsinc5'" section) for   the lengthy technical details. * The 3D warp used is saved in a dataset with   prefix 'ppp_WARP' -- this dataset can be used   with 3dNwarpApply and 3dNwarpCat, for example. * To be clear, this is the warp from source dataset   coordinates to base dataset coordinates, where the   values at each base grid point are the xyz displacements   needed to move that grid point's xyz values to the   corresponding xyz values in the source dataset:   base( (x,y,z) + WARP(x,y,z) ) matches source(x,y,z)   Another way to think of this warp is that it 'pulls'   values back from source space to base space. * 3dNwarpApply would use 'ppp_WARP' to transform datasets   aligned with the source dataset to be aligned with the   base dataset.  **If you do NOT want this warp saved, use the option '-nowarp'**. (However, this warp is usually the most valuable possible output!)  * If you want to calculate and save the inverse 3D warp,   use the option '-iwarp'.  This inverse warp will then be   saved in a dataset with prefix 'ppp_WARPINV'. * This inverse warp could be used to transform data from base   space to source space, if you need to do such an operation. * You can easily compute the inverse later, say by a command like   3dNwarpCat -prefix Z_WARPINV 'INV(Z_WARP+tlrc)'   or the inverse can be computed as needed in 3dNwarpApply, like   3dNwarpApply -nwarp 'INV(Z_WARP+tlrc)' -source Dataset.nii ...  
   imports:
   # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
@@ -590,7 +590,7 @@ doctests:
     # type=file|default=<undefined>: Base image (opposite phase encoding direction than source image).
     blur: '[0,2]'
     # type=list|default=[]: Gaussian blur the input images by 'bb' (FWHM) voxels before doing the alignment (the output dataset will not be blurred). The default is 2.345 (for no good reason).  * Optionally, you can provide 2 values for 'bb', and then   the first one is applied to the base volume, the second   to the source volume.   e.g., '-blur 0 3' to skip blurring the base image   (if the base is a blurry template, for example). * A negative blur radius means to use 3D median filtering,   rather than Gaussian blurring.  This type of filtering will   better preserve edges, which can be important in alignment. * If the base is a template volume that is already blurry,   you probably don't want to blur it again, but blurring   the source volume a little is probably a good idea, to   help the program avoid trying to match tiny features. * Note that -duplo will blur the volumes some extra   amount for the initial small-scale warping, to make   that phase of the program converge more rapidly.  
-    out_file:
+    out_file: '"Q11"'
     # type=file|default=<undefined>: Sets the prefix/suffix for the output datasets.  * The source dataset is warped to match the base   and gets prefix 'ppp'. (Except if '-plusminus' is used * The final interpolation to this output dataset is   done using the 'wsinc5' method.  See the output of   3dAllineate -HELP   (in the "Modifying '-final wsinc5'" section) for   the lengthy technical details. * The 3D warp used is saved in a dataset with   prefix 'ppp_WARP' -- this dataset can be used   with 3dNwarpApply and 3dNwarpCat, for example. * To be clear, this is the warp from source dataset   coordinates to base dataset coordinates, where the   values at each base grid point are the xyz displacements   needed to move that grid point's xyz values to the   corresponding xyz values in the source dataset:   base( (x,y,z) + WARP(x,y,z) ) matches source(x,y,z)   Another way to think of this warp is that it 'pulls'   values back from source space to base space. * 3dNwarpApply would use 'ppp_WARP' to transform datasets   aligned with the source dataset to be aligned with the   base dataset.  **If you do NOT want this warp saved, use the option '-nowarp'**. (However, this warp is usually the most valuable possible output!)  * If you want to calculate and save the inverse 3D warp,   use the option '-iwarp'.  This inverse warp will then be   saved in a dataset with prefix 'ppp_WARPINV'. * This inverse warp could be used to transform data from base   space to source space, if you need to do such an operation. * You can easily compute the inverse later, say by a command like   3dNwarpCat -prefix Z_WARPINV 'INV(Z_WARP+tlrc)'   or the inverse can be computed as needed in 3dNwarpApply, like   3dNwarpApply -nwarp 'INV(Z_WARP+tlrc)' -source Dataset.nii ...  
     inilev: '7'
     # type=int|default=0: The initial refinement 'level' at which to start.  * Usually used with -iniwarp; CANNOT be used with -duplo. * The combination of -inilev and -iniwarp lets you take the   results of a previous 3dQwarp run and refine them further:   Note that the source dataset in the second run is the SAME as   in the first run.  If you don't see why this is necessary,   then you probably need to seek help from an AFNI guru.  
diff --git a/example-specs/task/nipype/afni/qwarp_callables.py b/example-specs/task/nipype/afni/qwarp_callables.py
index b40e3b58..81de4ef3 100644
--- a/example-specs/task/nipype/afni/qwarp_callables.py
+++ b/example-specs/task/nipype/afni/qwarp_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in Qwarp.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of Qwarp.yaml"""
diff --git a/example-specs/task/nipype/afni/qwarp_plus_minus.yaml b/example-specs/task/nipype/afni/qwarp_plus_minus.yaml
index 3d0e5218..bdce11bf 100644
--- a/example-specs/task/nipype/afni/qwarp_plus_minus.yaml
+++ b/example-specs/task/nipype/afni/qwarp_plus_minus.yaml
@@ -39,24 +39,24 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    source_file: generic/file
-    # type=file|default=<undefined>: Source image (opposite phase encoding direction than base image)
-    out_file: generic/file
-    # type=file|default='Qwarp.nii.gz': Output file
-    in_file: medimage/nifti-gz
-    # type=file|default=<undefined>: Source image (opposite phase encoding direction than base image).
     base_file: medimage/nifti-gz
     # type=file|default=<undefined>: Base image (opposite phase encoding direction than source image).
-    weight: generic/file
-    # type=file|default=<undefined>: Instead of computing the weight from the base dataset,directly input the weight volume from dataset 'www'.Useful if you know what over parts of the base image youwant to emphasize or de-emphasize the matching functional.
-    out_weight_file: generic/file
-    # type=file|default=<undefined>: Write the weight volume to disk as a dataset
     emask: generic/file
     # type=file|default=<undefined>: Here, 'ee' is a dataset to specify a mask of voxelsto EXCLUDE from the analysis -- all voxels in 'ee'that are NONZERO will not be used in the alignment.The base image always automasked -- the emask isextra, to indicate voxels you definitely DON'T wantincluded in the matching process, even if they areinside the brain.
-    iniwarp: generic/file+list-of
-    # type=list|default=[]: A dataset with an initial nonlinear warp to use.  * If this option is not used, the initial warp is the identity. * You can specify a catenation of warps (in quotes) here, as in   program 3dNwarpApply. * As a special case, if you just input an affine matrix in a .1D   file, that will work also -- it is treated as giving the initial   warp via the string "IDENT(base_dataset) matrix_file.aff12.1D". * You CANNOT use this option with -duplo !! * -iniwarp is usually used with -inilev to re-start 3dQwarp from   a previous stopping point.  
     gridlist: generic/file
     # type=file|default=<undefined>: This option provides an alternate way to specify the patch grid sizes used in the warp optimization process. 'gl' is a 1D file with a list of patches to use -- in most cases, you will want to use it in the following form: ``-gridlist '1D: 0 151 101 75 51'``  * Here, a 0 patch size means the global domain. Patch sizes   otherwise should be odd integers >= 5. * If you use the '0' patch size again after the first position,   you will actually get an iteration at the size of the   default patch level 1, where the patch sizes are 75% of   the volume dimension.  There is no way to force the program   to literally repeat the sui generis step of lev=0.  
+    in_file: medimage/nifti-gz
+    # type=file|default=<undefined>: Source image (opposite phase encoding direction than base image).
+    iniwarp: generic/file+list-of
+    # type=list|default=[]: A dataset with an initial nonlinear warp to use.  * If this option is not used, the initial warp is the identity. * You can specify a catenation of warps (in quotes) here, as in   program 3dNwarpApply. * As a special case, if you just input an affine matrix in a .1D   file, that will work also -- it is treated as giving the initial   warp via the string "IDENT(base_dataset) matrix_file.aff12.1D". * You CANNOT use this option with -duplo !! * -iniwarp is usually used with -inilev to re-start 3dQwarp from   a previous stopping point.  
+    out_file: Path
+    # type=file|default='Qwarp.nii.gz': Output file
+    out_weight_file: Path
+    # type=file|default=<undefined>: Write the weight volume to disk as a dataset
+    source_file: generic/file
+    # type=file|default=<undefined>: Source image (opposite phase encoding direction than base image)
+    weight: generic/file
+    # type=file|default=<undefined>: Instead of computing the weight from the base dataset,directly input the weight volume from dataset 'www'.Useful if you know what over parts of the base image youwant to emphasize or de-emphasize the matching functional.
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -70,14 +70,14 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    warped_source: generic/file
-    # type=file: Warped source file. If plusminus is used, this is the undistortedsource file.
-    warped_base: generic/file
-    # type=file: Undistorted base file.
-    source_warp: generic/file
-    # type=file: Displacement in mm for the source image.If plusminus is used this is the field suceptibility correctionwarp (in 'mm') for source image.
     base_warp: generic/file
     # type=file: Displacement in mm for the base image.If plus minus is used, this is the field suceptibility correctionwarp (in 'mm') for base image. This is only output if plusminusor iwarp options are passed
+    source_warp: generic/file
+    # type=file: Displacement in mm for the source image.If plusminus is used this is the field suceptibility correctionwarp (in 'mm') for source image.
+    warped_base: generic/file
+    # type=file: Undistorted base file.
+    warped_source: generic/file
+    # type=file: Warped source file. If plusminus is used, this is the undistortedsource file.
     weights: generic/file
     # type=file: Auto-computed weight volume.
   callables:
@@ -126,7 +126,7 @@ tests:
     wball:
     # type=list|default=[]: "``-wball x y z r f`` Enhance automatic weight from '-useweight' by a factor of 1+f\*Gaussian(FWHM=r) centered in the base image at DICOM coordinates (x,y,z) and with radius 'r'. The goal of this option is to try and make the alignment better in a specific part of the brain. Example:  -wball 0 14 6 30 40 to emphasize the thalamic area (in MNI/Talairach space).  * The 'r' parameter must be positive! * The 'f' parameter must be between 1 and 100 (inclusive). * '-wball' does nothing if you input your own weight   with the '-weight' option. * '-wball' does change the binary weight created by   the '-noweight' option. * You can only use '-wball' once in a run of 3dQwarp.  **The effect of '-wball' is not dramatic.** The example above makes the average brain image across a collection of subjects a little sharper in the thalamic area, which might have some small value.  If you care enough about alignment to use '-wball', then you should examine the results from 3dQwarp for each subject, to see if the alignments are good enough for your purposes.
     wmask:
-    # type=tuple|default=(<nipype.interfaces.base.traits_extension.File object at 0x107fd7b50>, <traits.trait_types.Float object at 0x107fd7d10>): Similar to '-wball', but here, you provide a dataset 'ws' that indicates where to increase the weight.  * The 'ws' dataset must be on the same 3D grid as the base dataset. * 'ws' is treated as a mask -- it only matters where it   is nonzero -- otherwise, the values inside are not used. * After 'ws' comes the factor 'f' by which to increase the   automatically computed weight.  Where 'ws' is nonzero,   the weighting will be multiplied by (1+f). * As with '-wball', the factor 'f' should be between 1 and 100.  
+    # type=tuple|default=(<nipype.interfaces.base.traits_extension.File object at 0x10ff13890>, <traits.trait_types.Float object at 0x10ff13910>): Similar to '-wball', but here, you provide a dataset 'ws' that indicates where to increase the weight.  * The 'ws' dataset must be on the same 3D grid as the base dataset. * 'ws' is treated as a mask -- it only matters where it   is nonzero -- otherwise, the values inside are not used. * After 'ws' comes the factor 'f' by which to increase the   automatically computed weight.  Where 'ws' is nonzero,   the weighting will be multiplied by (1+f). * As with '-wball', the factor 'f' should be between 1 and 100.  
     out_weight_file:
     # type=file|default=<undefined>: Write the weight volume to disk as a dataset
     blur:
diff --git a/example-specs/task/nipype/afni/qwarp_plus_minus_callables.py b/example-specs/task/nipype/afni/qwarp_plus_minus_callables.py
index 4b6c49d2..fc193c60 100644
--- a/example-specs/task/nipype/afni/qwarp_plus_minus_callables.py
+++ b/example-specs/task/nipype/afni/qwarp_plus_minus_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in QwarpPlusMinus.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of QwarpPlusMinus.yaml"""
diff --git a/example-specs/task/nipype/afni/re_ho.yaml b/example-specs/task/nipype/afni/re_ho.yaml
index ca416fca..4987f290 100644
--- a/example-specs/task/nipype/afni/re_ho.yaml
+++ b/example-specs/task/nipype/afni/re_ho.yaml
@@ -39,10 +39,10 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/nifti1
     # type=file|default=<undefined>: input dataset
-    mask_file: generic/file
-    # type=file|default=<undefined>: Mask within which ReHo should be calculated voxelwise
     label_set: generic/file
     # type=file|default=<undefined>: a set of ROIs, each labelled with distinct integers. ReHo will then be calculated per ROI.
+    mask_file: generic/file
+    # type=file|default=<undefined>: Mask within which ReHo should be calculated voxelwise
     out_file: Path
     # type=file: Voxelwise regional homogeneity map
     # type=file|default=<undefined>: Output dataset.
diff --git a/example-specs/task/nipype/afni/re_ho_callables.py b/example-specs/task/nipype/afni/re_ho_callables.py
index 576ca23a..b64e6a6c 100644
--- a/example-specs/task/nipype/afni/re_ho_callables.py
+++ b/example-specs/task/nipype/afni/re_ho_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in ReHo.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of ReHo.yaml"""
diff --git a/example-specs/task/nipype/afni/refit.yaml b/example-specs/task/nipype/afni/refit.yaml
index f1a8aa44..05b14b34 100644
--- a/example-specs/task/nipype/afni/refit.yaml
+++ b/example-specs/task/nipype/afni/refit.yaml
@@ -42,10 +42,10 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    in_file: medimage/nifti1
-    # type=file|default=<undefined>: input file to 3drefit
     duporigin_file: generic/file
     # type=file|default=<undefined>: Copies the xorigin, yorigin, and zorigin values from the header of the given dataset
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: input file to 3drefit
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/refit_callables.py b/example-specs/task/nipype/afni/refit_callables.py
index 6c854dfa..7ec47a2c 100644
--- a/example-specs/task/nipype/afni/refit_callables.py
+++ b/example-specs/task/nipype/afni/refit_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in Refit.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of Refit.yaml"""
diff --git a/example-specs/task/nipype/afni/remlfit.yaml b/example-specs/task/nipype/afni/remlfit.yaml
index 88ea46b3..7ee246f7 100644
--- a/example-specs/task/nipype/afni/remlfit.yaml
+++ b/example-specs/task/nipype/afni/remlfit.yaml
@@ -39,63 +39,63 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    in_files: medimage/nifti1+list-of
-    # type=inputmultiobject|default=[]: Read time series dataset
-    matrix: medimage-afni/oned
-    # type=file|default=<undefined>: the design matrix file, which should have been output from Deconvolve via the 'x1D' option
-    matim: generic/file
-    # type=file|default=<undefined>: read a standard file as the matrix. You can use only Col as a name in GLTs with these nonstandard matrix input methods, since the other names come from the 'matrix' file. These mutually exclusive options are ignored if 'matrix' is used.
-    mask: generic/file
-    # type=file|default=<undefined>: filename of 3D mask dataset; only data time series from within the mask will be analyzed; results for voxels outside the mask will be set to zero.
     STATmask: generic/file
     # type=file|default=<undefined>: filename of 3D mask dataset to be used for the purpose of reporting truncation-to float issues AND for computing the FDR curves. The actual results ARE not masked with this option (only with 'mask' or 'automask' options).
     addbase: generic/file+list-of
     # type=inputmultiobject|default=[]: file(s) to add baseline model columns to the matrix with this option. Each column in the specified file(s) will be appended to the matrix. File(s) must have at least as many rows as the matrix does.
-    slibase: generic/file+list-of
-    # type=inputmultiobject|default=[]: similar to 'addbase' in concept, BUT each specified file must have an integer multiple of the number of slices in the input dataset(s); then, separate regression matrices are generated for each slice, with the first column of the file appended to the matrix for the first slice of the dataset, the second column of the file appended to the matrix for the first slice of the dataset, and so on. Intended to help model physiological noise in FMRI, or other effects you want to regress out that might change significantly in the inter-slice time intervals. This will slow the program down, and make it use a lot more memory (to hold all the matrix stuff).
-    slibase_sm: generic/file+list-of
-    # type=inputmultiobject|default=[]: similar to 'slibase', BUT each file much be in slice major order (i.e. all slice0 columns come first, then all slice1 columns, etc).
     dsort: generic/file
     # type=file|default=<undefined>: 4D dataset to be used as voxelwise baseline regressor
-    out_file: Path
-    # type=file: dataset for beta + statistics from the REML estimation (if generated
-    # type=file|default=<undefined>: output dataset for beta + statistics from the REML estimation; also contains the results of any GLT analysis requested in the Deconvolve setup, similar to the 'bucket' output from Deconvolve. This dataset does NOT get the betas (or statistics) of those regressors marked as 'baseline' in the matrix file.
-    var_file: Path
-    # type=file: dataset for REML variance parameters (if generated)
-    # type=file|default=<undefined>: output dataset for REML variance parameters
-    rbeta_file: Path
-    # type=file: output dataset for beta weights from the REML estimation (if generated
-    # type=file|default=<undefined>: output dataset for beta weights from the REML estimation, similar to the 'cbucket' output from Deconvolve. This dataset will contain all the beta weights, for baseline and stimulus regressors alike, unless the '-nobout' option is given -- in that case, this dataset will only get the betas for the stimulus regressors.
-    glt_file: Path
-    # type=file: output dataset for beta + statistics from the REML estimation, but ONLY for the GLTs added on the REMLfit command line itself via 'gltsym' (if generated)
-    # type=file|default=<undefined>: output dataset for beta + statistics from the REML estimation, but ONLY for the GLTs added on the REMLfit command line itself via 'gltsym'; GLTs from Deconvolve's command line will NOT be included.
-    fitts_file: Path
-    # type=file: output dataset for REML fitted model (if generated)
-    # type=file|default=<undefined>: output dataset for REML fitted model
     errts_file: Path
     # type=file: output dataset for REML residuals = data - fitted model (if generated
     # type=file|default=<undefined>: output dataset for REML residuals = data - fitted model
-    wherr_file: Path
-    # type=file: dataset for REML residual, whitened using the estimated ARMA(1,1) correlation matrix of the noise (if generated)
-    # type=file|default=<undefined>: dataset for REML residual, whitened using the estimated ARMA(1,1) correlation matrix of the noise
-    ovar: Path
-    # type=file: dataset for OLSQ st.dev. parameter (if generated)
-    # type=file|default=<undefined>: dataset for OLSQ st.dev. parameter (kind of boring)
+    fitts_file: Path
+    # type=file: output dataset for REML fitted model (if generated)
+    # type=file|default=<undefined>: output dataset for REML fitted model
+    glt_file: Path
+    # type=file: output dataset for beta + statistics from the REML estimation, but ONLY for the GLTs added on the REMLfit command line itself via 'gltsym' (if generated)
+    # type=file|default=<undefined>: output dataset for beta + statistics from the REML estimation, but ONLY for the GLTs added on the REMLfit command line itself via 'gltsym'; GLTs from Deconvolve's command line will NOT be included.
+    in_files: medimage/nifti1+list-of
+    # type=inputmultiobject|default=[]: Read time series dataset
+    mask: generic/file
+    # type=file|default=<undefined>: filename of 3D mask dataset; only data time series from within the mask will be analyzed; results for voxels outside the mask will be set to zero.
+    matim: generic/file
+    # type=file|default=<undefined>: read a standard file as the matrix. You can use only Col as a name in GLTs with these nonstandard matrix input methods, since the other names come from the 'matrix' file. These mutually exclusive options are ignored if 'matrix' is used.
+    matrix: medimage-afni/oned
+    # type=file|default=<undefined>: the design matrix file, which should have been output from Deconvolve via the 'x1D' option
     obeta: Path
     # type=file: dataset for beta weights from the OLSQ estimation (if generated)
     # type=file|default=<undefined>: dataset for beta weights from the OLSQ estimation
     obuck: Path
     # type=file: dataset for beta + statistics from the OLSQ estimation (if generated)
     # type=file|default=<undefined>: dataset for beta + statistics from the OLSQ estimation
-    oglt: Path
-    # type=file: dataset for beta + statistics from 'gltsym' options (if generated
-    # type=file|default=<undefined>: dataset for beta + statistics from 'gltsym' options
-    ofitts: Path
-    # type=file: dataset for OLSQ fitted model (if generated)
-    # type=file|default=<undefined>: dataset for OLSQ fitted model
     oerrts: Path
     # type=file: dataset for OLSQ residuals = data - fitted model (if generated
     # type=file|default=<undefined>: dataset for OLSQ residuals (data - fitted model)
+    ofitts: Path
+    # type=file: dataset for OLSQ fitted model (if generated)
+    # type=file|default=<undefined>: dataset for OLSQ fitted model
+    oglt: Path
+    # type=file: dataset for beta + statistics from 'gltsym' options (if generated
+    # type=file|default=<undefined>: dataset for beta + statistics from 'gltsym' options
+    out_file: Path
+    # type=file: dataset for beta + statistics from the REML estimation (if generated
+    # type=file|default=<undefined>: output dataset for beta + statistics from the REML estimation; also contains the results of any GLT analysis requested in the Deconvolve setup, similar to the 'bucket' output from Deconvolve. This dataset does NOT get the betas (or statistics) of those regressors marked as 'baseline' in the matrix file.
+    ovar: Path
+    # type=file: dataset for OLSQ st.dev. parameter (if generated)
+    # type=file|default=<undefined>: dataset for OLSQ st.dev. parameter (kind of boring)
+    rbeta_file: Path
+    # type=file: output dataset for beta weights from the REML estimation (if generated
+    # type=file|default=<undefined>: output dataset for beta weights from the REML estimation, similar to the 'cbucket' output from Deconvolve. This dataset will contain all the beta weights, for baseline and stimulus regressors alike, unless the '-nobout' option is given -- in that case, this dataset will only get the betas for the stimulus regressors.
+    slibase: generic/file+list-of
+    # type=inputmultiobject|default=[]: similar to 'addbase' in concept, BUT each specified file must have an integer multiple of the number of slices in the input dataset(s); then, separate regression matrices are generated for each slice, with the first column of the file appended to the matrix for the first slice of the dataset, the second column of the file appended to the matrix for the first slice of the dataset, and so on. Intended to help model physiological noise in FMRI, or other effects you want to regress out that might change significantly in the inter-slice time intervals. This will slow the program down, and make it use a lot more memory (to hold all the matrix stuff).
+    slibase_sm: generic/file+list-of
+    # type=inputmultiobject|default=[]: similar to 'slibase', BUT each file much be in slice major order (i.e. all slice0 columns come first, then all slice1 columns, etc).
+    var_file: Path
+    # type=file: dataset for REML variance parameters (if generated)
+    # type=file|default=<undefined>: output dataset for REML variance parameters
+    wherr_file: Path
+    # type=file: dataset for REML residual, whitened using the estimated ARMA(1,1) correlation matrix of the noise (if generated)
+    # type=file|default=<undefined>: dataset for REML residual, whitened using the estimated ARMA(1,1) correlation matrix of the noise
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -109,45 +109,45 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    out_file: medimage/nifti1
-    # type=file: dataset for beta + statistics from the REML estimation (if generated
-    # type=file|default=<undefined>: output dataset for beta + statistics from the REML estimation; also contains the results of any GLT analysis requested in the Deconvolve setup, similar to the 'bucket' output from Deconvolve. This dataset does NOT get the betas (or statistics) of those regressors marked as 'baseline' in the matrix file.
-    var_file: generic/file
-    # type=file: dataset for REML variance parameters (if generated)
-    # type=file|default=<undefined>: output dataset for REML variance parameters
-    rbeta_file: generic/file
-    # type=file: output dataset for beta weights from the REML estimation (if generated
-    # type=file|default=<undefined>: output dataset for beta weights from the REML estimation, similar to the 'cbucket' output from Deconvolve. This dataset will contain all the beta weights, for baseline and stimulus regressors alike, unless the '-nobout' option is given -- in that case, this dataset will only get the betas for the stimulus regressors.
-    glt_file: generic/file
-    # type=file: output dataset for beta + statistics from the REML estimation, but ONLY for the GLTs added on the REMLfit command line itself via 'gltsym' (if generated)
-    # type=file|default=<undefined>: output dataset for beta + statistics from the REML estimation, but ONLY for the GLTs added on the REMLfit command line itself via 'gltsym'; GLTs from Deconvolve's command line will NOT be included.
-    fitts_file: generic/file
-    # type=file: output dataset for REML fitted model (if generated)
-    # type=file|default=<undefined>: output dataset for REML fitted model
     errts_file: generic/file
     # type=file: output dataset for REML residuals = data - fitted model (if generated
     # type=file|default=<undefined>: output dataset for REML residuals = data - fitted model
-    wherr_file: generic/file
-    # type=file: dataset for REML residual, whitened using the estimated ARMA(1,1) correlation matrix of the noise (if generated)
-    # type=file|default=<undefined>: dataset for REML residual, whitened using the estimated ARMA(1,1) correlation matrix of the noise
-    ovar: generic/file
-    # type=file: dataset for OLSQ st.dev. parameter (if generated)
-    # type=file|default=<undefined>: dataset for OLSQ st.dev. parameter (kind of boring)
+    fitts_file: generic/file
+    # type=file: output dataset for REML fitted model (if generated)
+    # type=file|default=<undefined>: output dataset for REML fitted model
+    glt_file: generic/file
+    # type=file: output dataset for beta + statistics from the REML estimation, but ONLY for the GLTs added on the REMLfit command line itself via 'gltsym' (if generated)
+    # type=file|default=<undefined>: output dataset for beta + statistics from the REML estimation, but ONLY for the GLTs added on the REMLfit command line itself via 'gltsym'; GLTs from Deconvolve's command line will NOT be included.
     obeta: generic/file
     # type=file: dataset for beta weights from the OLSQ estimation (if generated)
     # type=file|default=<undefined>: dataset for beta weights from the OLSQ estimation
     obuck: generic/file
     # type=file: dataset for beta + statistics from the OLSQ estimation (if generated)
     # type=file|default=<undefined>: dataset for beta + statistics from the OLSQ estimation
-    oglt: generic/file
-    # type=file: dataset for beta + statistics from 'gltsym' options (if generated
-    # type=file|default=<undefined>: dataset for beta + statistics from 'gltsym' options
-    ofitts: generic/file
-    # type=file: dataset for OLSQ fitted model (if generated)
-    # type=file|default=<undefined>: dataset for OLSQ fitted model
     oerrts: generic/file
     # type=file: dataset for OLSQ residuals = data - fitted model (if generated
     # type=file|default=<undefined>: dataset for OLSQ residuals (data - fitted model)
+    ofitts: generic/file
+    # type=file: dataset for OLSQ fitted model (if generated)
+    # type=file|default=<undefined>: dataset for OLSQ fitted model
+    oglt: generic/file
+    # type=file: dataset for beta + statistics from 'gltsym' options (if generated
+    # type=file|default=<undefined>: dataset for beta + statistics from 'gltsym' options
+    out_file: medimage/nifti1
+    # type=file: dataset for beta + statistics from the REML estimation (if generated
+    # type=file|default=<undefined>: output dataset for beta + statistics from the REML estimation; also contains the results of any GLT analysis requested in the Deconvolve setup, similar to the 'bucket' output from Deconvolve. This dataset does NOT get the betas (or statistics) of those regressors marked as 'baseline' in the matrix file.
+    ovar: generic/file
+    # type=file: dataset for OLSQ st.dev. parameter (if generated)
+    # type=file|default=<undefined>: dataset for OLSQ st.dev. parameter (kind of boring)
+    rbeta_file: generic/file
+    # type=file: output dataset for beta weights from the REML estimation (if generated
+    # type=file|default=<undefined>: output dataset for beta weights from the REML estimation, similar to the 'cbucket' output from Deconvolve. This dataset will contain all the beta weights, for baseline and stimulus regressors alike, unless the '-nobout' option is given -- in that case, this dataset will only get the betas for the stimulus regressors.
+    var_file: generic/file
+    # type=file: dataset for REML variance parameters (if generated)
+    # type=file|default=<undefined>: output dataset for REML variance parameters
+    wherr_file: generic/file
+    # type=file: dataset for REML residual, whitened using the estimated ARMA(1,1) correlation matrix of the noise (if generated)
+    # type=file|default=<undefined>: dataset for REML residual, whitened using the estimated ARMA(1,1) correlation matrix of the noise
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/afni/remlfit_callables.py b/example-specs/task/nipype/afni/remlfit_callables.py
index 7dedf957..9a3d9922 100644
--- a/example-specs/task/nipype/afni/remlfit_callables.py
+++ b/example-specs/task/nipype/afni/remlfit_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in Remlfit.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of Remlfit.yaml"""
diff --git a/example-specs/task/nipype/afni/resample_callables.py b/example-specs/task/nipype/afni/resample_callables.py
index 1e012806..d6f33aaa 100644
--- a/example-specs/task/nipype/afni/resample_callables.py
+++ b/example-specs/task/nipype/afni/resample_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in Resample.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of Resample.yaml"""
diff --git a/example-specs/task/nipype/afni/retroicor.yaml b/example-specs/task/nipype/afni/retroicor.yaml
index c5ca82cd..8a054165 100644
--- a/example-specs/task/nipype/afni/retroicor.yaml
+++ b/example-specs/task/nipype/afni/retroicor.yaml
@@ -52,19 +52,19 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    in_file: medimage/nifti1
-    # type=file|default=<undefined>: input file to 3dretroicor
     card: medimage-afni/oned
     # type=file|default=<undefined>: 1D cardiac data file for cardiac correction
-    resp: medimage-afni/oned
-    # type=file|default=<undefined>: 1D respiratory waveform data for correction
     cardphase: generic/file
     # type=file|default=<undefined>: Filename for 1D cardiac phase output
-    respphase: generic/file
-    # type=file|default=<undefined>: Filename for 1D resp phase output
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: input file to 3dretroicor
     out_file: Path
     # type=file: output file
     # type=file|default=<undefined>: output image file name
+    resp: medimage-afni/oned
+    # type=file|default=<undefined>: 1D respiratory waveform data for correction
+    respphase: generic/file
+    # type=file|default=<undefined>: Filename for 1D resp phase output
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/retroicor_callables.py b/example-specs/task/nipype/afni/retroicor_callables.py
index 1b4f7ade..83eb5eea 100644
--- a/example-specs/task/nipype/afni/retroicor_callables.py
+++ b/example-specs/task/nipype/afni/retroicor_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in Retroicor.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of Retroicor.yaml"""
diff --git a/example-specs/task/nipype/afni/roi_stats.yaml b/example-specs/task/nipype/afni/roi_stats.yaml
index b549606d..6f02ac8a 100644
--- a/example-specs/task/nipype/afni/roi_stats.yaml
+++ b/example-specs/task/nipype/afni/roi_stats.yaml
@@ -43,11 +43,11 @@ inputs:
     # type=file|default=<undefined>: input mask
     mask_file: medimage/nifti-gz
     # type=file|default=<undefined>: input mask
-    roisel: generic/file
-    # type=file|default=<undefined>: Only considers ROIs denoted by values found in the specified file. Note that the order of the ROIs as specified in the file is not preserved. So an SEL.1D of '2 8 20' produces the same output as '8 20 2'
     out_file: Path
     # type=file: output tab-separated values file
     # type=file|default=<undefined>: output file
+    roisel: generic/file
+    # type=file|default=<undefined>: Only considers ROIs denoted by values found in the specified file. Note that the order of the ROIs as specified in the file is not preserved. So an SEL.1D of '2 8 20' produces the same output as '8 20 2'
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/roi_stats_callables.py b/example-specs/task/nipype/afni/roi_stats_callables.py
index 47f34117..3b987779 100644
--- a/example-specs/task/nipype/afni/roi_stats_callables.py
+++ b/example-specs/task/nipype/afni/roi_stats_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in ROIStats.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of ROIStats.yaml"""
diff --git a/example-specs/task/nipype/afni/seg_callables.py b/example-specs/task/nipype/afni/seg_callables.py
index 38eafb08..3c61b4ea 100644
--- a/example-specs/task/nipype/afni/seg_callables.py
+++ b/example-specs/task/nipype/afni/seg_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in Seg.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of Seg.yaml"""
diff --git a/example-specs/task/nipype/afni/skull_strip_callables.py b/example-specs/task/nipype/afni/skull_strip_callables.py
index 500e8987..ffbf4801 100644
--- a/example-specs/task/nipype/afni/skull_strip_callables.py
+++ b/example-specs/task/nipype/afni/skull_strip_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in SkullStrip.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of SkullStrip.yaml"""
diff --git a/example-specs/task/nipype/afni/svm_test.yaml b/example-specs/task/nipype/afni/svm_test.yaml
index 26c362cb..9e6c11b4 100644
--- a/example-specs/task/nipype/afni/svm_test.yaml
+++ b/example-specs/task/nipype/afni/svm_test.yaml
@@ -38,11 +38,11 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: generic/file
     # type=file|default=<undefined>: A 3D or 3D+t AFNI brik dataset to be used for testing.
-    testlabels: generic/file
-    # type=file|default=<undefined>: *true* class category .1D labels for the test dataset. It is used to calculate the prediction accuracy performance
     out_file: Path
     # type=file: output file
     # type=file|default=<undefined>: filename for .1D prediction file(s).
+    testlabels: generic/file
+    # type=file|default=<undefined>: *true* class category .1D labels for the test dataset. It is used to calculate the prediction accuracy performance
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/svm_test_callables.py b/example-specs/task/nipype/afni/svm_test_callables.py
index 5189ca36..1a9d6ae5 100644
--- a/example-specs/task/nipype/afni/svm_test_callables.py
+++ b/example-specs/task/nipype/afni/svm_test_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in SVMTest.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of SVMTest.yaml"""
diff --git a/example-specs/task/nipype/afni/svm_train.yaml b/example-specs/task/nipype/afni/svm_train.yaml
index b5e85f33..791f713c 100644
--- a/example-specs/task/nipype/afni/svm_train.yaml
+++ b/example-specs/task/nipype/afni/svm_train.yaml
@@ -38,23 +38,23 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    alphas: Path
+    # type=file: output alphas file name
+    # type=file|default=<undefined>: output alphas file name
+    censor: generic/file
+    # type=file|default=<undefined>: .1D censor file that allows the user to ignore certain samples in the training data.
     in_file: generic/file
     # type=file|default=<undefined>: A 3D+t AFNI brik dataset to be used for training.
     mask: generic/file
     # type=file|default=<undefined>: byte-format brik file used to mask voxels in the analysis
-    trainlabels: generic/file
-    # type=file|default=<undefined>: .1D labels corresponding to the stimulus paradigm for the training data.
-    censor: generic/file
-    # type=file|default=<undefined>: .1D censor file that allows the user to ignore certain samples in the training data.
-    out_file: Path
-    # type=file: sum of weighted linear support vectors file name
-    # type=file|default=<undefined>: output sum of weighted linear support vectors file name
     model: Path
     # type=file: brik containing the SVM model file name
     # type=file|default=<undefined>: basename for the brik containing the SVM model
-    alphas: Path
-    # type=file: output alphas file name
-    # type=file|default=<undefined>: output alphas file name
+    out_file: Path
+    # type=file: sum of weighted linear support vectors file name
+    # type=file|default=<undefined>: output sum of weighted linear support vectors file name
+    trainlabels: generic/file
+    # type=file|default=<undefined>: .1D labels corresponding to the stimulus paradigm for the training data.
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -68,15 +68,15 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    out_file: generic/file
-    # type=file: sum of weighted linear support vectors file name
-    # type=file|default=<undefined>: output sum of weighted linear support vectors file name
-    model: generic/file
-    # type=file: brik containing the SVM model file name
-    # type=file|default=<undefined>: basename for the brik containing the SVM model
     alphas: generic/file
     # type=file: output alphas file name
     # type=file|default=<undefined>: output alphas file name
+    model: generic/file
+    # type=file: brik containing the SVM model file name
+    # type=file|default=<undefined>: basename for the brik containing the SVM model
+    out_file: generic/file
+    # type=file: sum of weighted linear support vectors file name
+    # type=file|default=<undefined>: output sum of weighted linear support vectors file name
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/afni/svm_train_callables.py b/example-specs/task/nipype/afni/svm_train_callables.py
index d84f0913..3ee35f3f 100644
--- a/example-specs/task/nipype/afni/svm_train_callables.py
+++ b/example-specs/task/nipype/afni/svm_train_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in SVMTrain.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of SVMTrain.yaml"""
diff --git a/example-specs/task/nipype/afni/synthesize_callables.py b/example-specs/task/nipype/afni/synthesize_callables.py
index 208f458b..585387ab 100644
--- a/example-specs/task/nipype/afni/synthesize_callables.py
+++ b/example-specs/task/nipype/afni/synthesize_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in Synthesize.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of Synthesize.yaml"""
diff --git a/example-specs/task/nipype/afni/t_cat_callables.py b/example-specs/task/nipype/afni/t_cat_callables.py
index 73663106..b1e4956f 100644
--- a/example-specs/task/nipype/afni/t_cat_callables.py
+++ b/example-specs/task/nipype/afni/t_cat_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in TCat.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of TCat.yaml"""
diff --git a/example-specs/task/nipype/afni/t_cat_sub_brick_callables.py b/example-specs/task/nipype/afni/t_cat_sub_brick_callables.py
index 3554ec89..5abad487 100644
--- a/example-specs/task/nipype/afni/t_cat_sub_brick_callables.py
+++ b/example-specs/task/nipype/afni/t_cat_sub_brick_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in TCatSubBrick.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of TCatSubBrick.yaml"""
diff --git a/example-specs/task/nipype/afni/t_corr_1d.yaml b/example-specs/task/nipype/afni/t_corr_1d.yaml
index 75770a2c..75192bbc 100644
--- a/example-specs/task/nipype/afni/t_corr_1d.yaml
+++ b/example-specs/task/nipype/afni/t_corr_1d.yaml
@@ -34,13 +34,13 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    out_file: Path
+    # type=file: output file containing correlations
+    # type=file|default=<undefined>: output filename prefix
     xset: medimage/nifti1
     # type=file|default=<undefined>: 3d+time dataset input
     y_1d: medimage-afni/oned
     # type=file|default=<undefined>: 1D time series file input
-    out_file: Path
-    # type=file: output file containing correlations
-    # type=file|default=<undefined>: output filename prefix
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/t_corr_1d_callables.py b/example-specs/task/nipype/afni/t_corr_1d_callables.py
index 5e0e5652..9a0d0b90 100644
--- a/example-specs/task/nipype/afni/t_corr_1d_callables.py
+++ b/example-specs/task/nipype/afni/t_corr_1d_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in TCorr1D.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of TCorr1D.yaml"""
diff --git a/example-specs/task/nipype/afni/t_corr_map.yaml b/example-specs/task/nipype/afni/t_corr_map.yaml
index f8f72ef4..8745dc45 100644
--- a/example-specs/task/nipype/afni/t_corr_map.yaml
+++ b/example-specs/task/nipype/afni/t_corr_map.yaml
@@ -38,53 +38,53 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    in_file: medimage/nifti1
-    # type=file|default=<undefined>: 
-    seeds: generic/file
-    # type=file|default=<undefined>: 
-    mask: medimage/nifti1
-    # type=file|default=<undefined>: 
-    regress_out_timeseries: generic/file
-    # type=file|default=<undefined>: 
-    out_file: generic/file
-    # type=file|default=<undefined>: output image file name
-    mean_file: Path
+    absolute_threshold: Path
     # type=file: 
     # type=file|default=<undefined>: 
-    zmean: Path
+    average_expr: Path
     # type=file: 
     # type=file|default=<undefined>: 
-    qmean: Path
+    average_expr_nonzero: Path
     # type=file: 
     # type=file|default=<undefined>: 
-    pmean: Path
+    correlation_maps: Path
     # type=file: 
     # type=file|default=<undefined>: 
-    absolute_threshold: Path
+    correlation_maps_masked: Path
     # type=file: 
     # type=file|default=<undefined>: 
-    var_absolute_threshold: Path
+    histogram: Path
     # type=file: 
     # type=file|default=<undefined>: 
-    var_absolute_threshold_normalize: Path
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: 
+    mask: medimage/nifti1
+    # type=file|default=<undefined>: 
+    mean_file: Path
     # type=file: 
     # type=file|default=<undefined>: 
-    correlation_maps: Path
+    out_file: Path
+    # type=file|default=<undefined>: output image file name
+    pmean: Path
     # type=file: 
     # type=file|default=<undefined>: 
-    correlation_maps_masked: Path
+    qmean: Path
     # type=file: 
     # type=file|default=<undefined>: 
-    average_expr: Path
+    regress_out_timeseries: generic/file
+    # type=file|default=<undefined>: 
+    seeds: generic/file
+    # type=file|default=<undefined>: 
+    sum_expr: Path
     # type=file: 
     # type=file|default=<undefined>: 
-    average_expr_nonzero: Path
+    var_absolute_threshold: Path
     # type=file: 
     # type=file|default=<undefined>: 
-    sum_expr: Path
+    var_absolute_threshold_normalize: Path
     # type=file: 
     # type=file|default=<undefined>: 
-    histogram: Path
+    zmean: Path
     # type=file: 
     # type=file|default=<undefined>: 
   metadata:
@@ -100,43 +100,43 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    mean_file: generic/file
+    absolute_threshold: generic/file
     # type=file: 
     # type=file|default=<undefined>: 
-    zmean: generic/file
+    average_expr: generic/file
     # type=file: 
     # type=file|default=<undefined>: 
-    qmean: generic/file
+    average_expr_nonzero: generic/file
     # type=file: 
     # type=file|default=<undefined>: 
-    pmean: generic/file
+    correlation_maps: generic/file
     # type=file: 
     # type=file|default=<undefined>: 
-    absolute_threshold: generic/file
+    correlation_maps_masked: generic/file
     # type=file: 
     # type=file|default=<undefined>: 
-    var_absolute_threshold: generic/file
+    histogram: generic/file
     # type=file: 
     # type=file|default=<undefined>: 
-    var_absolute_threshold_normalize: generic/file
+    mean_file: generic/file
     # type=file: 
     # type=file|default=<undefined>: 
-    correlation_maps: generic/file
+    pmean: generic/file
     # type=file: 
     # type=file|default=<undefined>: 
-    correlation_maps_masked: generic/file
+    qmean: generic/file
     # type=file: 
     # type=file|default=<undefined>: 
-    average_expr: generic/file
+    sum_expr: generic/file
     # type=file: 
     # type=file|default=<undefined>: 
-    average_expr_nonzero: generic/file
+    var_absolute_threshold: generic/file
     # type=file: 
     # type=file|default=<undefined>: 
-    sum_expr: generic/file
+    var_absolute_threshold_normalize: generic/file
     # type=file: 
     # type=file|default=<undefined>: 
-    histogram: generic/file
+    zmean: generic/file
     # type=file: 
     # type=file|default=<undefined>: 
   callables:
@@ -161,7 +161,7 @@ tests:
     polort:
     # type=int|default=0: 
     bandpass:
-    # type=tuple|default=(<traits.trait_types.Float object at 0x107f6fc90>, <traits.trait_types.Float object at 0x107f6e810>): 
+    # type=tuple|default=(<traits.trait_types.Float object at 0x10fefcb90>, <traits.trait_types.Float object at 0x10fefcc50>): 
     regress_out_timeseries:
     # type=file|default=<undefined>: 
     blur_fwhm:
diff --git a/example-specs/task/nipype/afni/t_corr_map_callables.py b/example-specs/task/nipype/afni/t_corr_map_callables.py
index 3e042bc6..ad59b583 100644
--- a/example-specs/task/nipype/afni/t_corr_map_callables.py
+++ b/example-specs/task/nipype/afni/t_corr_map_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in TCorrMap.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of TCorrMap.yaml"""
diff --git a/example-specs/task/nipype/afni/t_correlate.yaml b/example-specs/task/nipype/afni/t_correlate.yaml
index 4437ec1c..5e658494 100644
--- a/example-specs/task/nipype/afni/t_correlate.yaml
+++ b/example-specs/task/nipype/afni/t_correlate.yaml
@@ -39,13 +39,13 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    out_file: Path
+    # type=file: output file
+    # type=file|default=<undefined>: output image file name
     xset: medimage/nifti1
     # type=file|default=<undefined>: input xset
     yset: medimage/nifti1
     # type=file|default=<undefined>: input yset
-    out_file: Path
-    # type=file: output file
-    # type=file|default=<undefined>: output image file name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/t_correlate_callables.py b/example-specs/task/nipype/afni/t_correlate_callables.py
index 32a0c5ef..666c5b1f 100644
--- a/example-specs/task/nipype/afni/t_correlate_callables.py
+++ b/example-specs/task/nipype/afni/t_correlate_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in TCorrelate.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of TCorrelate.yaml"""
diff --git a/example-specs/task/nipype/afni/t_norm_callables.py b/example-specs/task/nipype/afni/t_norm_callables.py
index 83ce70d6..c23dd2fe 100644
--- a/example-specs/task/nipype/afni/t_norm_callables.py
+++ b/example-specs/task/nipype/afni/t_norm_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in TNorm.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of TNorm.yaml"""
diff --git a/example-specs/task/nipype/afni/t_project.yaml b/example-specs/task/nipype/afni/t_project.yaml
index a91a96db..4b42ccef 100644
--- a/example-specs/task/nipype/afni/t_project.yaml
+++ b/example-specs/task/nipype/afni/t_project.yaml
@@ -48,18 +48,18 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    in_file: medimage/nifti1
-    # type=file|default=<undefined>: input file to 3dTproject
     censor: generic/file
     # type=file|default=<undefined>: Filename of censor .1D time series. This is a file of 1s and 0s, indicating which time points are to be included (1) and which are to be excluded (0).
     concat: generic/file
     # type=file|default=<undefined>: The catenation file, as in 3dDeconvolve, containing the TR indexes of the start points for each contiguous run within the input dataset (the first entry should be 0).  * Also as in 3dDeconvolve, if the input dataset is   automatically catenated from a collection of datasets,   then the run start indexes are determined directly,   and '-concat' is not needed (and will be ignored). * Each run must have at least 9 time points AFTER   censoring, or the program will not work! * The only use made of this input is in setting up   the bandpass/stopband regressors. * '-ort' and '-dsort' regressors run through all time   points, as read in.  If you want separate projections   in each run, then you must either break these ort files   into appropriate components, OR you must run 3dTproject   for each run separately, using the appropriate pieces   from the ort files via the ``{...}`` selector for the   1D files and the ``[...]`` selector for the datasets.  
-    ort: generic/file
-    # type=file|default=<undefined>: Remove each column in file. Each column will have its mean removed.
     dsort: generic/file+list-of
     # type=inputmultiobject|default=[]: Remove the 3D+time time series in dataset fset.  * That is, 'fset' contains a different nuisance time   series for each voxel (e.g., from AnatICOR). * Multiple -dsort options are allowed.  
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: input file to 3dTproject
     mask: generic/file
     # type=file|default=<undefined>: Only operate on voxels nonzero in the mset dataset.  * Voxels outside the mask will be filled with zeros. * If no masking option is given, then all voxels   will be processed.  
+    ort: generic/file
+    # type=file|default=<undefined>: Remove each column in file. Each column will have its mean removed.
     out_file: Path
     # type=file: output file
     # type=file|default=<undefined>: output image file name
diff --git a/example-specs/task/nipype/afni/t_project_callables.py b/example-specs/task/nipype/afni/t_project_callables.py
index c6350838..7f0383d4 100644
--- a/example-specs/task/nipype/afni/t_project_callables.py
+++ b/example-specs/task/nipype/afni/t_project_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in TProject.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of TProject.yaml"""
diff --git a/example-specs/task/nipype/afni/t_shift.yaml b/example-specs/task/nipype/afni/t_shift.yaml
index d390bc20..3c25526a 100644
--- a/example-specs/task/nipype/afni/t_shift.yaml
+++ b/example-specs/task/nipype/afni/t_shift.yaml
@@ -125,11 +125,11 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    timing_file: generic/file
-    # type=file: AFNI formatted timing file, if ``slice_timing`` is a list
     out_file: generic/file
     # type=file: output file
     # type=file|default=<undefined>: output image file name
+    timing_file: generic/file
+    # type=file: AFNI formatted timing file, if ``slice_timing`` is a list
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/afni/t_shift_callables.py b/example-specs/task/nipype/afni/t_shift_callables.py
index 0746bd0d..9272e6ef 100644
--- a/example-specs/task/nipype/afni/t_shift_callables.py
+++ b/example-specs/task/nipype/afni/t_shift_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in TShift.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of TShift.yaml"""
diff --git a/example-specs/task/nipype/afni/t_smooth.yaml b/example-specs/task/nipype/afni/t_smooth.yaml
index c3f38edd..90e586ed 100644
--- a/example-specs/task/nipype/afni/t_smooth.yaml
+++ b/example-specs/task/nipype/afni/t_smooth.yaml
@@ -37,10 +37,10 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    in_file: medimage/nifti1
-    # type=file|default=<undefined>: input file to 3dTSmooth
     custom: generic/file
     # type=file|default=<undefined>: odd # of coefficients must be in a single column in ASCII file
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: input file to 3dTSmooth
     out_file: Path
     # type=file: output file
     # type=file|default=<undefined>: output file from 3dTSmooth
diff --git a/example-specs/task/nipype/afni/t_smooth_callables.py b/example-specs/task/nipype/afni/t_smooth_callables.py
index 25307116..e27dc268 100644
--- a/example-specs/task/nipype/afni/t_smooth_callables.py
+++ b/example-specs/task/nipype/afni/t_smooth_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in TSmooth.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of TSmooth.yaml"""
diff --git a/example-specs/task/nipype/afni/t_stat_callables.py b/example-specs/task/nipype/afni/t_stat_callables.py
index dde13485..03658302 100644
--- a/example-specs/task/nipype/afni/t_stat_callables.py
+++ b/example-specs/task/nipype/afni/t_stat_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in TStat.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of TStat.yaml"""
diff --git a/example-specs/task/nipype/afni/to_3d_callables.py b/example-specs/task/nipype/afni/to_3d_callables.py
index bf28f929..b03a6700 100644
--- a/example-specs/task/nipype/afni/to_3d_callables.py
+++ b/example-specs/task/nipype/afni/to_3d_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in To3D.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of To3D.yaml"""
diff --git a/example-specs/task/nipype/afni/undump_callables.py b/example-specs/task/nipype/afni/undump_callables.py
index 22257d09..d549409b 100644
--- a/example-specs/task/nipype/afni/undump_callables.py
+++ b/example-specs/task/nipype/afni/undump_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in Undump.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of Undump.yaml"""
diff --git a/example-specs/task/nipype/afni/unifize.yaml b/example-specs/task/nipype/afni/unifize.yaml
index 10e9ddf1..cbb34b07 100644
--- a/example-specs/task/nipype/afni/unifize.yaml
+++ b/example-specs/task/nipype/afni/unifize.yaml
@@ -81,12 +81,12 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    scale_file: generic/file
-    # type=file: scale factor file
-    # type=file|default=<undefined>: output file name to save the scale factor used at each voxel 
     out_file: medimage/nifti1
     # type=file: unifized file
     # type=file|default=<undefined>: output image file name
+    scale_file: generic/file
+    # type=file: scale factor file
+    # type=file|default=<undefined>: output file name to save the scale factor used at each voxel 
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/afni/unifize_callables.py b/example-specs/task/nipype/afni/unifize_callables.py
index 0e048ad5..fccd5af3 100644
--- a/example-specs/task/nipype/afni/unifize_callables.py
+++ b/example-specs/task/nipype/afni/unifize_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in Unifize.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of Unifize.yaml"""
diff --git a/example-specs/task/nipype/afni/volreg.yaml b/example-specs/task/nipype/afni/volreg.yaml
index 55e98936..23d34552 100644
--- a/example-specs/task/nipype/afni/volreg.yaml
+++ b/example-specs/task/nipype/afni/volreg.yaml
@@ -51,13 +51,10 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    in_file: medimage/nifti1
-    # type=file|default=<undefined>: input file to 3dvolreg
     basefile: medimage/nifti1
     # type=file|default=<undefined>: base file for registration
-    out_file: Path
-    # type=file: registered file
-    # type=file|default=<undefined>: output image file name
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: input file to 3dvolreg
     md1d_file: Path
     # type=file: max displacement info file
     # type=file|default=<undefined>: max displacement output file
@@ -67,6 +64,9 @@ inputs:
     oned_matrix_save: Path
     # type=file: matrix transformation from base to input
     # type=file|default=<undefined>: Save the matrix transformation
+    out_file: Path
+    # type=file: registered file
+    # type=file|default=<undefined>: output image file name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -80,9 +80,6 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    out_file: medimage-afni/r1
-    # type=file: registered file
-    # type=file|default=<undefined>: output image file name
     md1d_file: generic/file
     # type=file: max displacement info file
     # type=file|default=<undefined>: max displacement output file
@@ -92,6 +89,9 @@ outputs:
     oned_matrix_save: medimage-afni/oned
     # type=file: matrix transformation from base to input
     # type=file|default=<undefined>: Save the matrix transformation
+    out_file: medimage-afni/r1
+    # type=file: registered file
+    # type=file|default=<undefined>: output image file name
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/afni/volreg_callables.py b/example-specs/task/nipype/afni/volreg_callables.py
index 48ce6b3d..0ca457b4 100644
--- a/example-specs/task/nipype/afni/volreg_callables.py
+++ b/example-specs/task/nipype/afni/volreg_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in Volreg.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of Volreg.yaml"""
diff --git a/example-specs/task/nipype/afni/warp.yaml b/example-specs/task/nipype/afni/warp.yaml
index 569e3dd3..8a799785 100644
--- a/example-specs/task/nipype/afni/warp.yaml
+++ b/example-specs/task/nipype/afni/warp.yaml
@@ -46,14 +46,14 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    gridset: generic/file
+    # type=file|default=<undefined>: copy grid of specified dataset
     in_file: medimage/nifti1
     # type=file|default=<undefined>: input file to 3dWarp
     matparent: generic/file
     # type=file|default=<undefined>: apply transformation from 3dWarpDrive
     oblique_parent: generic/file
     # type=file|default=<undefined>: Read in the oblique transformation matrix from an oblique dataset and make cardinal dataset oblique to match
-    gridset: generic/file
-    # type=file|default=<undefined>: copy grid of specified dataset
     out_file: Path
     # type=file: Warped file.
     # type=file|default=<undefined>: output image file name
diff --git a/example-specs/task/nipype/afni/warp_callables.py b/example-specs/task/nipype/afni/warp_callables.py
index 8001b9c4..56e75cc8 100644
--- a/example-specs/task/nipype/afni/warp_callables.py
+++ b/example-specs/task/nipype/afni/warp_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in Warp.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of Warp.yaml"""
diff --git a/example-specs/task/nipype/afni/z_cut_up_callables.py b/example-specs/task/nipype/afni/z_cut_up_callables.py
index 970f55ba..5e6f7ecc 100644
--- a/example-specs/task/nipype/afni/z_cut_up_callables.py
+++ b/example-specs/task/nipype/afni/z_cut_up_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in ZCutUp.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of ZCutUp.yaml"""
diff --git a/example-specs/task/nipype/afni/zcat_callables.py b/example-specs/task/nipype/afni/zcat_callables.py
index 19dc1a13..3c00bd17 100644
--- a/example-specs/task/nipype/afni/zcat_callables.py
+++ b/example-specs/task/nipype/afni/zcat_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in Zcat.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of Zcat.yaml"""
diff --git a/example-specs/task/nipype/afni/zeropad_callables.py b/example-specs/task/nipype/afni/zeropad_callables.py
index 15a323c9..14e582d6 100644
--- a/example-specs/task/nipype/afni/zeropad_callables.py
+++ b/example-specs/task/nipype/afni/zeropad_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in Zeropad.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of Zeropad.yaml"""
diff --git a/example-specs/task/nipype/ants/affine_initializer_callables.py b/example-specs/task/nipype/ants/affine_initializer_callables.py
index 47d5ce0a..e438336f 100644
--- a/example-specs/task/nipype/ants/affine_initializer_callables.py
+++ b/example-specs/task/nipype/ants/affine_initializer_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in AffineInitializer.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of AffineInitializer.yaml"""
diff --git a/example-specs/task/nipype/ants/ai.yaml b/example-specs/task/nipype/ants/ai.yaml
index 1d08a26c..60714fe8 100644
--- a/example-specs/task/nipype/ants/ai.yaml
+++ b/example-specs/task/nipype/ants/ai.yaml
@@ -43,10 +43,10 @@ inputs:
   # passed to the field in the automatically generated unittests.
     fixed_image: generic/file
     # type=file|default=<undefined>: Image to which the moving_image should be transformed
-    moving_image: generic/file
-    # type=file|default=<undefined>: Image that will be transformed to fixed_image
     fixed_image_mask: generic/file
     # type=file|default=<undefined>: fixed mage mask
+    moving_image: generic/file
+    # type=file|default=<undefined>: Image that will be transformed to fixed_image
     moving_image_mask: generic/file
     # type=file|default=<undefined>: moving mage mask
     output_transform: Path
diff --git a/example-specs/task/nipype/ants/ai_callables.py b/example-specs/task/nipype/ants/ai_callables.py
index dafef828..84c22ddd 100644
--- a/example-specs/task/nipype/ants/ai_callables.py
+++ b/example-specs/task/nipype/ants/ai_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in AI.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of AI.yaml"""
diff --git a/example-specs/task/nipype/ants/ants.yaml b/example-specs/task/nipype/ants/ants.yaml
index a7c9f6ad..e22f2cc4 100644
--- a/example-specs/task/nipype/ants/ants.yaml
+++ b/example-specs/task/nipype/ants/ants.yaml
@@ -65,14 +65,14 @@ outputs:
   # passed to the field in the automatically generated unittests.
     affine_transform: generic/file
     # type=file: Affine transform file
-    warp_transform: generic/file
-    # type=file: Warping deformation field
     inverse_warp_transform: generic/file
     # type=file: Inverse warping deformation field
     metaheader: generic/file
     # type=file: VTK metaheader .mhd file
     metaheader_raw: generic/file
     # type=file: VTK metaheader .raw file
+    warp_transform: generic/file
+    # type=file: Warping deformation field
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/ants/ants_callables.py b/example-specs/task/nipype/ants/ants_callables.py
index dc14cf02..2245171d 100644
--- a/example-specs/task/nipype/ants/ants_callables.py
+++ b/example-specs/task/nipype/ants/ants_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in ANTS.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of ANTS.yaml"""
diff --git a/example-specs/task/nipype/ants/ants_introduction.yaml b/example-specs/task/nipype/ants/ants_introduction.yaml
index b119bbbe..6ba47ad7 100644
--- a/example-specs/task/nipype/ants/ants_introduction.yaml
+++ b/example-specs/task/nipype/ants/ants_introduction.yaml
@@ -33,10 +33,10 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    reference_image: medimage/nifti1
-    # type=file|default=<undefined>: template file to warp to
     input_image: medimage/nifti1
     # type=file|default=<undefined>: input image to warp to template
+    reference_image: medimage/nifti1
+    # type=file|default=<undefined>: template file to warp to
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -52,14 +52,14 @@ outputs:
   # passed to the field in the automatically generated unittests.
     affine_transformation: generic/file
     # type=file: affine (prefix_Affine.txt)
-    warp_field: generic/file
-    # type=file: warp field (prefix_Warp.nii)
-    inverse_warp_field: generic/file
-    # type=file: inverse warp field (prefix_InverseWarp.nii)
     input_file: generic/file
     # type=file: input image (prefix_repaired.nii)
+    inverse_warp_field: generic/file
+    # type=file: inverse warp field (prefix_InverseWarp.nii)
     output_file: generic/file
     # type=file: output image (prefix_deformed.nii)
+    warp_field: generic/file
+    # type=file: warp field (prefix_Warp.nii)
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/ants/ants_introduction_callables.py b/example-specs/task/nipype/ants/ants_introduction_callables.py
index d6e4f62c..74ee5c8f 100644
--- a/example-specs/task/nipype/ants/ants_introduction_callables.py
+++ b/example-specs/task/nipype/ants/ants_introduction_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in antsIntroduction.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of antsIntroduction.yaml"""
diff --git a/example-specs/task/nipype/ants/apply_transforms_callables.py b/example-specs/task/nipype/ants/apply_transforms_callables.py
index eaafa83e..dd38b019 100644
--- a/example-specs/task/nipype/ants/apply_transforms_callables.py
+++ b/example-specs/task/nipype/ants/apply_transforms_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in ApplyTransforms.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of ApplyTransforms.yaml"""
diff --git a/example-specs/task/nipype/ants/apply_transforms_to_points_callables.py b/example-specs/task/nipype/ants/apply_transforms_to_points_callables.py
index de371e76..dc9684a9 100644
--- a/example-specs/task/nipype/ants/apply_transforms_to_points_callables.py
+++ b/example-specs/task/nipype/ants/apply_transforms_to_points_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in ApplyTransformsToPoints.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of ApplyTransformsToPoints.yaml"""
diff --git a/example-specs/task/nipype/ants/atropos_callables.py b/example-specs/task/nipype/ants/atropos_callables.py
index 53553f2e..d0d4d45c 100644
--- a/example-specs/task/nipype/ants/atropos_callables.py
+++ b/example-specs/task/nipype/ants/atropos_callables.py
@@ -1,7 +1,7 @@
-"""Module to put any functions that are referred to in Atropos.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of Atropos.yaml"""
 
-import os.path as op
 import attrs
+import os.path as op
 
 
 def out_classified_image_name_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/ants/average_affine_transform.yaml b/example-specs/task/nipype/ants/average_affine_transform.yaml
index 57d00c5d..62946e20 100644
--- a/example-specs/task/nipype/ants/average_affine_transform.yaml
+++ b/example-specs/task/nipype/ants/average_affine_transform.yaml
@@ -31,7 +31,7 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    output_affine_transform: datascience/text-matrix
+    output_affine_transform: Path
     # type=file|default=<undefined>: Outputfname.txt: the name of the resulting transform.
     transforms: datascience/text-matrix+list-of
     # type=inputmultiobject|default=[]: transforms to average
@@ -95,7 +95,7 @@ tests:
     # type=enum|default=3|allowed[2,3]: image dimension (2 or 3)
     transforms:
     # type=inputmultiobject|default=[]: transforms to average
-    output_affine_transform:
+    output_affine_transform: '"MYtemplatewarp.mat"'
     # type=file|default=<undefined>: Outputfname.txt: the name of the resulting transform.
   imports:
   # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
@@ -123,7 +123,7 @@ doctests:
     # type=enum|default=3|allowed[2,3]: image dimension (2 or 3)
     transforms:
     # type=inputmultiobject|default=[]: transforms to average
-    output_affine_transform:
+    output_affine_transform: '"MYtemplatewarp.mat"'
     # type=file|default=<undefined>: Outputfname.txt: the name of the resulting transform.
   imports:
   # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
diff --git a/example-specs/task/nipype/ants/average_affine_transform_callables.py b/example-specs/task/nipype/ants/average_affine_transform_callables.py
index 5ee02575..f0714454 100644
--- a/example-specs/task/nipype/ants/average_affine_transform_callables.py
+++ b/example-specs/task/nipype/ants/average_affine_transform_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in AverageAffineTransform.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of AverageAffineTransform.yaml"""
diff --git a/example-specs/task/nipype/ants/average_images_callables.py b/example-specs/task/nipype/ants/average_images_callables.py
index 8d6e9a0f..95359fbf 100644
--- a/example-specs/task/nipype/ants/average_images_callables.py
+++ b/example-specs/task/nipype/ants/average_images_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in AverageImages.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of AverageImages.yaml"""
diff --git a/example-specs/task/nipype/ants/brain_extraction.yaml b/example-specs/task/nipype/ants/brain_extraction.yaml
index 0cec473b..32752462 100644
--- a/example-specs/task/nipype/ants/brain_extraction.yaml
+++ b/example-specs/task/nipype/ants/brain_extraction.yaml
@@ -37,10 +37,10 @@ inputs:
   # passed to the field in the automatically generated unittests.
     anatomical_image: medimage/nifti-gz
     # type=file|default=<undefined>: Structural image, typically T1.  If more than one anatomical image is specified, subsequently specified images are used during the segmentation process.  However, only the first image is used in the registration of priors. Our suggestion would be to specify the T1 as the first image. Anatomical template created using e.g. LPBA40 data set with buildtemplateparallel.sh in ANTs.
-    brain_template: medimage/nifti-gz
-    # type=file|default=<undefined>: Anatomical template created using e.g. LPBA40 data set with buildtemplateparallel.sh in ANTs.
     brain_probability_mask: medimage/nifti-gz
     # type=file|default=<undefined>: Brain probability mask created using e.g. LPBA40 data set which have brain masks defined, and warped to anatomical template and averaged resulting in a probability image.
+    brain_template: medimage/nifti-gz
+    # type=file|default=<undefined>: Anatomical template created using e.g. LPBA40 data set with buildtemplateparallel.sh in ANTs.
     extraction_registration_mask: generic/file
     # type=file|default=<undefined>: Mask (defined in the template space) used during registration for brain extraction. To limit the metric computation to a specific region.
   metadata:
@@ -56,8 +56,6 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    BrainExtractionMask: generic/file
-    # type=file: brain extraction mask
     BrainExtractionBrain: generic/file
     # type=file: brain extraction image
     BrainExtractionCSF: generic/file
@@ -72,6 +70,8 @@ outputs:
     # type=file: 
     BrainExtractionLaplacian: generic/file
     # type=file: 
+    BrainExtractionMask: generic/file
+    # type=file: brain extraction mask
     BrainExtractionPrior0GenericAffine: generic/file
     # type=file: 
     BrainExtractionPrior1InverseWarp: generic/file
diff --git a/example-specs/task/nipype/ants/brain_extraction_callables.py b/example-specs/task/nipype/ants/brain_extraction_callables.py
index 88a7a0b8..d2dfd412 100644
--- a/example-specs/task/nipype/ants/brain_extraction_callables.py
+++ b/example-specs/task/nipype/ants/brain_extraction_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in BrainExtraction.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of BrainExtraction.yaml"""
diff --git a/example-specs/task/nipype/ants/buildtemplateparallel_callables.py b/example-specs/task/nipype/ants/buildtemplateparallel_callables.py
index 7ba280c9..f1425283 100644
--- a/example-specs/task/nipype/ants/buildtemplateparallel_callables.py
+++ b/example-specs/task/nipype/ants/buildtemplateparallel_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in buildtemplateparallel.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of buildtemplateparallel.yaml"""
diff --git a/example-specs/task/nipype/ants/compose_multi_transform.yaml b/example-specs/task/nipype/ants/compose_multi_transform.yaml
index a28a31f0..6bc5c609 100644
--- a/example-specs/task/nipype/ants/compose_multi_transform.yaml
+++ b/example-specs/task/nipype/ants/compose_multi_transform.yaml
@@ -33,13 +33,13 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    output_transform: Path
+    # type=file: Composed transform file
+    # type=file|default=<undefined>: the name of the resulting transform.
     reference_image: generic/file
     # type=file|default=<undefined>: Reference image (only necessary when output is warpfield)
     transforms: datascience/text-matrix+list-of
     # type=inputmultiobject|default=[]: transforms to average
-    output_transform: Path
-    # type=file: Composed transform file
-    # type=file|default=<undefined>: the name of the resulting transform.
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/ants/compose_multi_transform_callables.py b/example-specs/task/nipype/ants/compose_multi_transform_callables.py
index 88052b58..c9410a1f 100644
--- a/example-specs/task/nipype/ants/compose_multi_transform_callables.py
+++ b/example-specs/task/nipype/ants/compose_multi_transform_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in ComposeMultiTransform.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of ComposeMultiTransform.yaml"""
diff --git a/example-specs/task/nipype/ants/composite_transform_util_callables.py b/example-specs/task/nipype/ants/composite_transform_util_callables.py
index 4983be4f..f8ae9933 100644
--- a/example-specs/task/nipype/ants/composite_transform_util_callables.py
+++ b/example-specs/task/nipype/ants/composite_transform_util_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in CompositeTransformUtil.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of CompositeTransformUtil.yaml"""
diff --git a/example-specs/task/nipype/ants/convert_scalar_image_to_rgb_callables.py b/example-specs/task/nipype/ants/convert_scalar_image_to_rgb_callables.py
index f4c78361..e06a95d3 100644
--- a/example-specs/task/nipype/ants/convert_scalar_image_to_rgb_callables.py
+++ b/example-specs/task/nipype/ants/convert_scalar_image_to_rgb_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in ConvertScalarImageToRGB.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of ConvertScalarImageToRGB.yaml"""
diff --git a/example-specs/task/nipype/ants/cortical_thickness.yaml b/example-specs/task/nipype/ants/cortical_thickness.yaml
index 4718a3ac..dc23839e 100644
--- a/example-specs/task/nipype/ants/cortical_thickness.yaml
+++ b/example-specs/task/nipype/ants/cortical_thickness.yaml
@@ -41,18 +41,18 @@ inputs:
   # passed to the field in the automatically generated unittests.
     anatomical_image: medimage/nifti-gz
     # type=file|default=<undefined>: Structural *intensity* image, typically T1. If more than one anatomical image is specified, subsequently specified images are used during the segmentation process. However, only the first image is used in the registration of priors. Our suggestion would be to specify the T1 as the first image.
-    brain_template: medimage/nifti-gz
-    # type=file|default=<undefined>: Anatomical *intensity* template (possibly created using a population data set with buildtemplateparallel.sh in ANTs). This template is  *not* skull-stripped.
     brain_probability_mask: medimage/nifti-gz
     # type=file|default=<undefined>: brain probability mask in template space
+    brain_template: medimage/nifti-gz
+    # type=file|default=<undefined>: Anatomical *intensity* template (possibly created using a population data set with buildtemplateparallel.sh in ANTs). This template is  *not* skull-stripped.
+    cortical_label_image: generic/file
+    # type=file|default=<undefined>: Cortical ROI labels to use as a prior for ATITH.
+    extraction_registration_mask: generic/file
+    # type=file|default=<undefined>: Mask (defined in the template space) used during registration for brain extraction.
     segmentation_priors: medimage/nifti-gz+list-of
     # type=inputmultiobject|default=[]: 
     t1_registration_template: medimage/nifti-gz
     # type=file|default=<undefined>: Anatomical *intensity* template (assumed to be skull-stripped). A common case would be where this would be the same template as specified in the -e option which is not skull stripped.
-    extraction_registration_mask: generic/file
-    # type=file|default=<undefined>: Mask (defined in the template space) used during registration for brain extraction.
-    cortical_label_image: generic/file
-    # type=file|default=<undefined>: Cortical ROI labels to use as a prior for ATITH.
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -68,28 +68,28 @@ outputs:
   # passed to the field in the automatically generated unittests.
     BrainExtractionMask: generic/file
     # type=file: brain extraction mask
-    ExtractedBrainN4: generic/file
-    # type=file: extracted brain from N4 image
     BrainSegmentation: generic/file
     # type=file: brain segmentation image
     BrainSegmentationN4: generic/file
     # type=file: N4 corrected image
+    BrainVolumes: generic/file
+    # type=file: Brain volumes as text
     CorticalThickness: generic/file
     # type=file: cortical thickness file
-    TemplateToSubject1GenericAffine: generic/file
-    # type=file: Template to subject affine
-    TemplateToSubject0Warp: generic/file
-    # type=file: Template to subject warp
-    SubjectToTemplate1Warp: generic/file
-    # type=file: Template to subject inverse warp
+    CorticalThicknessNormedToTemplate: generic/file
+    # type=file: Normalized cortical thickness
+    ExtractedBrainN4: generic/file
+    # type=file: extracted brain from N4 image
     SubjectToTemplate0GenericAffine: generic/file
     # type=file: Template to subject inverse affine
+    SubjectToTemplate1Warp: generic/file
+    # type=file: Template to subject inverse warp
     SubjectToTemplateLogJacobian: generic/file
     # type=file: Template to subject log jacobian
-    CorticalThicknessNormedToTemplate: generic/file
-    # type=file: Normalized cortical thickness
-    BrainVolumes: generic/file
-    # type=file: Brain volumes as text
+    TemplateToSubject0Warp: generic/file
+    # type=file: Template to subject warp
+    TemplateToSubject1GenericAffine: generic/file
+    # type=file: Template to subject affine
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/ants/cortical_thickness_callables.py b/example-specs/task/nipype/ants/cortical_thickness_callables.py
index 847ddf0c..058413a9 100644
--- a/example-specs/task/nipype/ants/cortical_thickness_callables.py
+++ b/example-specs/task/nipype/ants/cortical_thickness_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in CorticalThickness.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of CorticalThickness.yaml"""
diff --git a/example-specs/task/nipype/ants/create_jacobian_determinant_image_callables.py b/example-specs/task/nipype/ants/create_jacobian_determinant_image_callables.py
index ed5d9270..79119041 100644
--- a/example-specs/task/nipype/ants/create_jacobian_determinant_image_callables.py
+++ b/example-specs/task/nipype/ants/create_jacobian_determinant_image_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in CreateJacobianDeterminantImage.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of CreateJacobianDeterminantImage.yaml"""
diff --git a/example-specs/task/nipype/ants/create_tiled_mosaic.yaml b/example-specs/task/nipype/ants/create_tiled_mosaic.yaml
index dcb374c7..9a319fe3 100644
--- a/example-specs/task/nipype/ants/create_tiled_mosaic.yaml
+++ b/example-specs/task/nipype/ants/create_tiled_mosaic.yaml
@@ -42,10 +42,10 @@ inputs:
   # passed to the field in the automatically generated unittests.
     input_image: medimage/nifti-gz
     # type=file|default=<undefined>: Main input is a 3-D grayscale image.
-    rgb_image: medimage/nifti-gz
-    # type=file|default=<undefined>: An optional Rgb image can be added as an overlay.It must have the same imagegeometry as the input grayscale image.
     mask_image: medimage/nifti-gz
     # type=file|default=<undefined>: Specifies the ROI of the RGB voxels used.
+    rgb_image: medimage/nifti-gz
+    # type=file|default=<undefined>: An optional Rgb image can be added as an overlay.It must have the same imagegeometry as the input grayscale image.
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/ants/create_tiled_mosaic_callables.py b/example-specs/task/nipype/ants/create_tiled_mosaic_callables.py
index b65faa69..0deb50b6 100644
--- a/example-specs/task/nipype/ants/create_tiled_mosaic_callables.py
+++ b/example-specs/task/nipype/ants/create_tiled_mosaic_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in CreateTiledMosaic.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of CreateTiledMosaic.yaml"""
diff --git a/example-specs/task/nipype/ants/denoise_image.yaml b/example-specs/task/nipype/ants/denoise_image.yaml
index 426fbdff..01e51e78 100644
--- a/example-specs/task/nipype/ants/denoise_image.yaml
+++ b/example-specs/task/nipype/ants/denoise_image.yaml
@@ -46,12 +46,12 @@ inputs:
   # passed to the field in the automatically generated unittests.
     input_image: medimage/nifti1
     # type=file|default=<undefined>: A scalar image is expected as input for noise correction.
-    output_image: Path
-    # type=file: 
-    # type=file|default=<undefined>: The output consists of the noise corrected version of the input image.
     noise_image: Path
     # type=file: 
     # type=file|default=<undefined>: Filename for the estimated noise.
+    output_image: Path
+    # type=file: 
+    # type=file|default=<undefined>: The output consists of the noise corrected version of the input image.
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -65,12 +65,12 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    output_image: medimage/nifti-gz
-    # type=file: 
-    # type=file|default=<undefined>: The output consists of the noise corrected version of the input image.
     noise_image: generic/file
     # type=file: 
     # type=file|default=<undefined>: Filename for the estimated noise.
+    output_image: medimage/nifti-gz
+    # type=file: 
+    # type=file|default=<undefined>: The output consists of the noise corrected version of the input image.
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/ants/denoise_image_callables.py b/example-specs/task/nipype/ants/denoise_image_callables.py
index 1f1bd275..771da693 100644
--- a/example-specs/task/nipype/ants/denoise_image_callables.py
+++ b/example-specs/task/nipype/ants/denoise_image_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in DenoiseImage.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of DenoiseImage.yaml"""
diff --git a/example-specs/task/nipype/ants/gen_warp_fields.yaml b/example-specs/task/nipype/ants/gen_warp_fields.yaml
index 0d4540ce..52e68aff 100644
--- a/example-specs/task/nipype/ants/gen_warp_fields.yaml
+++ b/example-specs/task/nipype/ants/gen_warp_fields.yaml
@@ -20,10 +20,10 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    reference_image: generic/file
-    # type=file|default=<undefined>: template file to warp to
     input_image: generic/file
     # type=file|default=<undefined>: input image to warp to template
+    reference_image: generic/file
+    # type=file|default=<undefined>: template file to warp to
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -39,14 +39,14 @@ outputs:
   # passed to the field in the automatically generated unittests.
     affine_transformation: generic/file
     # type=file: affine (prefix_Affine.txt)
-    warp_field: generic/file
-    # type=file: warp field (prefix_Warp.nii)
-    inverse_warp_field: generic/file
-    # type=file: inverse warp field (prefix_InverseWarp.nii)
     input_file: generic/file
     # type=file: input image (prefix_repaired.nii)
+    inverse_warp_field: generic/file
+    # type=file: inverse warp field (prefix_InverseWarp.nii)
     output_file: generic/file
     # type=file: output image (prefix_deformed.nii)
+    warp_field: generic/file
+    # type=file: warp field (prefix_Warp.nii)
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/ants/gen_warp_fields_callables.py b/example-specs/task/nipype/ants/gen_warp_fields_callables.py
index f08cf2cf..83591d3b 100644
--- a/example-specs/task/nipype/ants/gen_warp_fields_callables.py
+++ b/example-specs/task/nipype/ants/gen_warp_fields_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in GenWarpFields.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of GenWarpFields.yaml"""
diff --git a/example-specs/task/nipype/ants/image_math_callables.py b/example-specs/task/nipype/ants/image_math_callables.py
index 49800dde..ae493e18 100644
--- a/example-specs/task/nipype/ants/image_math_callables.py
+++ b/example-specs/task/nipype/ants/image_math_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in ImageMath.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of ImageMath.yaml"""
diff --git a/example-specs/task/nipype/ants/joint_fusion_callables.py b/example-specs/task/nipype/ants/joint_fusion_callables.py
index f0bf25d3..9b345a81 100644
--- a/example-specs/task/nipype/ants/joint_fusion_callables.py
+++ b/example-specs/task/nipype/ants/joint_fusion_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in JointFusion.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of JointFusion.yaml"""
diff --git a/example-specs/task/nipype/ants/kelly_kapowski.yaml b/example-specs/task/nipype/ants/kelly_kapowski.yaml
index a1a5ecc3..d53e6c20 100644
--- a/example-specs/task/nipype/ants/kelly_kapowski.yaml
+++ b/example-specs/task/nipype/ants/kelly_kapowski.yaml
@@ -43,20 +43,20 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    segmentation_image: medimage/nifti-gz
-    # type=file|default=<undefined>: A segmentation image must be supplied labeling the gray and white matters. Default values = 2 and 3, respectively.
+    cortical_thickness: Path
+    # type=file: A thickness map defined in the segmented gray matter.
+    # type=file|default=<undefined>: Filename for the cortical thickness.
     gray_matter_prob_image: generic/file
     # type=file|default=<undefined>: In addition to the segmentation image, a gray matter probability image can be used. If no such image is supplied, one is created using the segmentation image and a variance of 1.0 mm.
-    white_matter_prob_image: generic/file
-    # type=file|default=<undefined>: In addition to the segmentation image, a white matter probability image can be used. If no such image is supplied, one is created using the segmentation image and a variance of 1.0 mm.
+    segmentation_image: medimage/nifti-gz
+    # type=file|default=<undefined>: A segmentation image must be supplied labeling the gray and white matters. Default values = 2 and 3, respectively.
     thickness_prior_image: generic/file
     # type=file|default=<undefined>: An image containing spatially varying prior thickness values.
-    cortical_thickness: Path
-    # type=file: A thickness map defined in the segmented gray matter.
-    # type=file|default=<undefined>: Filename for the cortical thickness.
     warped_white_matter: Path
     # type=file: A warped white matter image.
     # type=file|default=<undefined>: Filename for the warped white matter file.
+    white_matter_prob_image: generic/file
+    # type=file|default=<undefined>: In addition to the segmentation image, a white matter probability image can be used. If no such image is supplied, one is created using the segmentation image and a variance of 1.0 mm.
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/ants/kelly_kapowski_callables.py b/example-specs/task/nipype/ants/kelly_kapowski_callables.py
index 9073c2b9..ef06c0ee 100644
--- a/example-specs/task/nipype/ants/kelly_kapowski_callables.py
+++ b/example-specs/task/nipype/ants/kelly_kapowski_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in KellyKapowski.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of KellyKapowski.yaml"""
diff --git a/example-specs/task/nipype/ants/label_geometry.yaml b/example-specs/task/nipype/ants/label_geometry.yaml
index 94288523..b4c4c262 100644
--- a/example-specs/task/nipype/ants/label_geometry.yaml
+++ b/example-specs/task/nipype/ants/label_geometry.yaml
@@ -36,10 +36,10 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    label_image: medimage/nifti-gz
-    # type=file|default=<undefined>: label image to use for extracting geometry measures
     intensity_image: medimage/nifti-gz
     # type=file|default='[]': Intensity image to extract values from. This is an optional input
+    label_image: medimage/nifti-gz
+    # type=file|default=<undefined>: label image to use for extracting geometry measures
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/ants/label_geometry_callables.py b/example-specs/task/nipype/ants/label_geometry_callables.py
index 2ec8a91a..9fd98ea1 100644
--- a/example-specs/task/nipype/ants/label_geometry_callables.py
+++ b/example-specs/task/nipype/ants/label_geometry_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in LabelGeometry.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of LabelGeometry.yaml"""
diff --git a/example-specs/task/nipype/ants/laplacian_thickness.yaml b/example-specs/task/nipype/ants/laplacian_thickness.yaml
index b5fda038..f39981fe 100644
--- a/example-specs/task/nipype/ants/laplacian_thickness.yaml
+++ b/example-specs/task/nipype/ants/laplacian_thickness.yaml
@@ -36,10 +36,10 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    input_wm: medimage/nifti-gz
-    # type=file|default=<undefined>: white matter segmentation image
     input_gm: medimage/nifti-gz
     # type=file|default=<undefined>: gray matter segmentation image
+    input_wm: medimage/nifti-gz
+    # type=file|default=<undefined>: white matter segmentation image
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/ants/laplacian_thickness_callables.py b/example-specs/task/nipype/ants/laplacian_thickness_callables.py
index c361c6b2..e853d05c 100644
--- a/example-specs/task/nipype/ants/laplacian_thickness_callables.py
+++ b/example-specs/task/nipype/ants/laplacian_thickness_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in LaplacianThickness.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of LaplacianThickness.yaml"""
diff --git a/example-specs/task/nipype/ants/measure_image_similarity.yaml b/example-specs/task/nipype/ants/measure_image_similarity.yaml
index 373cae28..2294a99b 100644
--- a/example-specs/task/nipype/ants/measure_image_similarity.yaml
+++ b/example-specs/task/nipype/ants/measure_image_similarity.yaml
@@ -42,10 +42,10 @@ inputs:
   # passed to the field in the automatically generated unittests.
     fixed_image: medimage/nifti1
     # type=file|default=<undefined>: Image to which the moving image is warped
-    moving_image: medimage/nifti1
-    # type=file|default=<undefined>: Image to apply transformation to (generally a coregistered functional)
     fixed_image_mask: medimage/nifti1
     # type=file|default=<undefined>: mask used to limit metric sampling region of the fixed image
+    moving_image: medimage/nifti1
+    # type=file|default=<undefined>: Image to apply transformation to (generally a coregistered functional)
     moving_image_mask: medimage/nifti-gz
     # type=file|default=<undefined>: mask used to limit metric sampling region of the moving image
   metadata:
diff --git a/example-specs/task/nipype/ants/measure_image_similarity_callables.py b/example-specs/task/nipype/ants/measure_image_similarity_callables.py
index 7379ba2f..df6075c2 100644
--- a/example-specs/task/nipype/ants/measure_image_similarity_callables.py
+++ b/example-specs/task/nipype/ants/measure_image_similarity_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in MeasureImageSimilarity.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of MeasureImageSimilarity.yaml"""
diff --git a/example-specs/task/nipype/ants/multiply_images_callables.py b/example-specs/task/nipype/ants/multiply_images_callables.py
index 47cb95b1..fdc71011 100644
--- a/example-specs/task/nipype/ants/multiply_images_callables.py
+++ b/example-specs/task/nipype/ants/multiply_images_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in MultiplyImages.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of MultiplyImages.yaml"""
diff --git a/example-specs/task/nipype/ants/n4_bias_field_correction.yaml b/example-specs/task/nipype/ants/n4_bias_field_correction.yaml
index adc8b83d..a644a06d 100644
--- a/example-specs/task/nipype/ants/n4_bias_field_correction.yaml
+++ b/example-specs/task/nipype/ants/n4_bias_field_correction.yaml
@@ -85,15 +85,15 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    bias_image: Path
+    # type=file: Estimated bias
+    # type=file|default=<undefined>: Filename for the estimated bias.
     input_image: medimage/nifti1
     # type=file|default=<undefined>: input for bias correction. Negative values or values close to zero should be processed prior to correction
     mask_image: generic/file
     # type=file|default=<undefined>: image to specify region to perform final bias correction in
     weight_image: generic/file
     # type=file|default=<undefined>: image for relative weighting (e.g. probability map of the white matter) of voxels during the B-spline fitting. 
-    bias_image: Path
-    # type=file: Estimated bias
-    # type=file|default=<undefined>: Filename for the estimated bias.
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -107,12 +107,12 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    output_image: generic/file
-    # type=file: Warped image
-    # type=str|default='': output file name
     bias_image: generic/file
     # type=file: Estimated bias
     # type=file|default=<undefined>: Filename for the estimated bias.
+    output_image: generic/file
+    # type=file: Warped image
+    # type=str|default='': output file name
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/ants/n4_bias_field_correction_callables.py b/example-specs/task/nipype/ants/n4_bias_field_correction_callables.py
index 7c58464f..28e01a34 100644
--- a/example-specs/task/nipype/ants/n4_bias_field_correction_callables.py
+++ b/example-specs/task/nipype/ants/n4_bias_field_correction_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in N4BiasFieldCorrection.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of N4BiasFieldCorrection.yaml"""
diff --git a/example-specs/task/nipype/ants/registration.yaml b/example-specs/task/nipype/ants/registration.yaml
index cd1ce344..f95b6999 100644
--- a/example-specs/task/nipype/ants/registration.yaml
+++ b/example-specs/task/nipype/ants/registration.yaml
@@ -277,14 +277,14 @@ inputs:
     # type=inputmultiobject|default=[]: Image to which the moving_image should be transformed(usually a structural image)
     fixed_image_mask: generic/file
     # type=file|default=<undefined>: Mask used to limit metric sampling region of the fixed imagein all stages
+    initial_moving_transform: datascience/text-matrix+list-of
+    # type=inputmultiobject|default=[]: A transform or a list of transforms that should be applied before the registration begins. Note that, when a list is given, the transformations are applied in reverse order.
     moving_image: medimage/nifti1+list-of
     # type=inputmultiobject|default=[]: Image that will be registered to the space of fixed_image. This is theimage on which the transformations will be applied to
     moving_image_mask: generic/file
     # type=file|default=<undefined>: mask used to limit metric sampling region of the moving imagein all stages
     restore_state: datascience/text-matrix
     # type=file|default=<undefined>: Filename for restoring the internal restorable state of the registration
-    initial_moving_transform: datascience/text-matrix+list-of
-    # type=inputmultiobject|default=[]: A transform or a list of transforms that should be applied before the registration begins. Note that, when a list is given, the transformations are applied in reverse order.
     save_state: Path
     # type=file: The saved registration state to be restored
     # type=file|default=<undefined>: Filename for saving the internal restorable state of the registration
@@ -305,13 +305,13 @@ outputs:
     # type=file: Composite transform file
     inverse_composite_transform: generic/file
     # type=file: Inverse composite transform file
-    warped_image: generic/file
-    # type=file: Outputs warped image
     inverse_warped_image: generic/file
     # type=file: Outputs the inverse of the warped image
     save_state: datascience/text-matrix
     # type=file: The saved registration state to be restored
     # type=file|default=<undefined>: Filename for saving the internal restorable state of the registration
+    warped_image: generic/file
+    # type=file: Outputs warped image
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/ants/registration_callables.py b/example-specs/task/nipype/ants/registration_callables.py
index 5191c22f..c815d4c4 100644
--- a/example-specs/task/nipype/ants/registration_callables.py
+++ b/example-specs/task/nipype/ants/registration_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in Registration.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of Registration.yaml"""
diff --git a/example-specs/task/nipype/ants/registration_syn_quick.yaml b/example-specs/task/nipype/ants/registration_syn_quick.yaml
index d481a172..543ee7ff 100644
--- a/example-specs/task/nipype/ants/registration_syn_quick.yaml
+++ b/example-specs/task/nipype/ants/registration_syn_quick.yaml
@@ -64,16 +64,16 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    warped_image: generic/file
-    # type=file: Warped image
-    inverse_warped_image: generic/file
-    # type=file: Inverse warped image
-    out_matrix: generic/file
-    # type=file: Affine matrix
     forward_warp_field: generic/file
     # type=file: Forward warp field
     inverse_warp_field: generic/file
     # type=file: Inverse warp field
+    inverse_warped_image: generic/file
+    # type=file: Inverse warped image
+    out_matrix: generic/file
+    # type=file: Affine matrix
+    warped_image: generic/file
+    # type=file: Warped image
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/ants/registration_syn_quick_callables.py b/example-specs/task/nipype/ants/registration_syn_quick_callables.py
index d009c67f..6de253a7 100644
--- a/example-specs/task/nipype/ants/registration_syn_quick_callables.py
+++ b/example-specs/task/nipype/ants/registration_syn_quick_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in RegistrationSynQuick.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of RegistrationSynQuick.yaml"""
diff --git a/example-specs/task/nipype/ants/resample_image_by_spacing_callables.py b/example-specs/task/nipype/ants/resample_image_by_spacing_callables.py
index e84e078e..ef1c5ab6 100644
--- a/example-specs/task/nipype/ants/resample_image_by_spacing_callables.py
+++ b/example-specs/task/nipype/ants/resample_image_by_spacing_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in ResampleImageBySpacing.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of ResampleImageBySpacing.yaml"""
diff --git a/example-specs/task/nipype/ants/threshold_image_callables.py b/example-specs/task/nipype/ants/threshold_image_callables.py
index 91e21ef3..25fa00ba 100644
--- a/example-specs/task/nipype/ants/threshold_image_callables.py
+++ b/example-specs/task/nipype/ants/threshold_image_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in ThresholdImage.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of ThresholdImage.yaml"""
diff --git a/example-specs/task/nipype/ants/warp_image_multi_transform.yaml b/example-specs/task/nipype/ants/warp_image_multi_transform.yaml
index e0e64984..0f296f77 100644
--- a/example-specs/task/nipype/ants/warp_image_multi_transform.yaml
+++ b/example-specs/task/nipype/ants/warp_image_multi_transform.yaml
@@ -43,15 +43,15 @@ inputs:
   # passed to the field in the automatically generated unittests.
     input_image: medimage/nifti1
     # type=file|default=<undefined>: image to apply transformation to (generally a coregistered functional)
-    out_postfix: generic/file
+    out_postfix: str
     # type=file|default='_wimt': Postfix that is prepended to all output files (default = _wimt)
+    output_image: Path
+    # type=file: Warped image
+    # type=file|default=<undefined>: name of the output warped image
     reference_image: medimage/nifti1,medimage/nifti-gz
     # type=file|default=<undefined>: reference image space that you wish to warp INTO
     transformation_series: '[text/text-file,medimage/nifti-gz]+list-of'
     # type=inputmultiobject|default=[]: transformation file(s) to be applied
-    output_image: Path
-    # type=file: Warped image
-    # type=file|default=<undefined>: name of the output warped image
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/ants/warp_image_multi_transform_callables.py b/example-specs/task/nipype/ants/warp_image_multi_transform_callables.py
index 6982677a..6a7febac 100644
--- a/example-specs/task/nipype/ants/warp_image_multi_transform_callables.py
+++ b/example-specs/task/nipype/ants/warp_image_multi_transform_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in WarpImageMultiTransform.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of WarpImageMultiTransform.yaml"""
diff --git a/example-specs/task/nipype/ants/warp_time_series_image_multi_transform_callables.py b/example-specs/task/nipype/ants/warp_time_series_image_multi_transform_callables.py
index 7eef52d6..e944a608 100644
--- a/example-specs/task/nipype/ants/warp_time_series_image_multi_transform_callables.py
+++ b/example-specs/task/nipype/ants/warp_time_series_image_multi_transform_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in WarpTimeSeriesImageMultiTransform.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of WarpTimeSeriesImageMultiTransform.yaml"""
diff --git a/example-specs/task/nipype/freesurfer/add_x_form_to_header.yaml b/example-specs/task/nipype/freesurfer/add_x_form_to_header.yaml
index 30b93869..81505624 100644
--- a/example-specs/task/nipype/freesurfer/add_x_form_to_header.yaml
+++ b/example-specs/task/nipype/freesurfer/add_x_form_to_header.yaml
@@ -48,13 +48,13 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/mgh-gz
     # type=file|default=<undefined>: input volume
-    transform: datascience/text-matrix
-    # type=file|default=<undefined>: xfm file
-    subjects_dir: generic/directory
-    # type=directory|default=<undefined>: subjects directory
     out_file: Path
     # type=file: output volume
     # type=file|default='output.mgz': output volume
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+    transform: datascience/text-matrix
+    # type=file|default=<undefined>: xfm file
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/add_x_form_to_header_callables.py b/example-specs/task/nipype/freesurfer/add_x_form_to_header_callables.py
index 360e8b9d..e9a18b75 100644
--- a/example-specs/task/nipype/freesurfer/add_x_form_to_header_callables.py
+++ b/example-specs/task/nipype/freesurfer/add_x_form_to_header_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in AddXFormToHeader.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of AddXFormToHeader.yaml"""
diff --git a/example-specs/task/nipype/freesurfer/aparc_2_aseg.yaml b/example-specs/task/nipype/freesurfer/aparc_2_aseg.yaml
index 875004c7..ecb97d38 100644
--- a/example-specs/task/nipype/freesurfer/aparc_2_aseg.yaml
+++ b/example-specs/task/nipype/freesurfer/aparc_2_aseg.yaml
@@ -55,35 +55,35 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    lh_white: medimage-freesurfer/pial
-    # type=file|default=<undefined>: Input file must be <subject_id>/surf/lh.white
-    rh_white: medimage-freesurfer/pial
-    # type=file|default=<undefined>: Input file must be <subject_id>/surf/rh.white
+    aseg: generic/file
+    # type=file|default=<undefined>: Input aseg file
+    ctxseg: generic/file
+    # type=file|default=<undefined>: 
+    filled: generic/file
+    # type=file|default=<undefined>: Implicit input filled file. Only required with FS v5.3.
+    lh_annotation: medimage-freesurfer/pial
+    # type=file|default=<undefined>: Input file must be <subject_id>/label/lh.aparc.annot
     lh_pial: medimage-freesurfer/pial
     # type=file|default=<undefined>: Input file must be <subject_id>/surf/lh.pial
-    rh_pial: medimage-freesurfer/pial
-    # type=file|default=<undefined>: Input file must be <subject_id>/surf/rh.pial
     lh_ribbon: medimage/mgh-gz
     # type=file|default=<undefined>: Input file must be <subject_id>/mri/lh.ribbon.mgz
+    lh_white: medimage-freesurfer/pial
+    # type=file|default=<undefined>: Input file must be <subject_id>/surf/lh.white
+    out_file: Path
+    # type=file: Output aseg file
+    # type=file|default=<undefined>: Full path of file to save the output segmentation in
+    rh_annotation: medimage-freesurfer/pial
+    # type=file|default=<undefined>: Input file must be <subject_id>/label/rh.aparc.annot
+    rh_pial: medimage-freesurfer/pial
+    # type=file|default=<undefined>: Input file must be <subject_id>/surf/rh.pial
     rh_ribbon: medimage/mgh-gz
     # type=file|default=<undefined>: Input file must be <subject_id>/mri/rh.ribbon.mgz
+    rh_white: medimage-freesurfer/pial
+    # type=file|default=<undefined>: Input file must be <subject_id>/surf/rh.white
     ribbon: medimage/mgh-gz
     # type=file|default=<undefined>: Input file must be <subject_id>/mri/ribbon.mgz
-    lh_annotation: medimage-freesurfer/pial
-    # type=file|default=<undefined>: Input file must be <subject_id>/label/lh.aparc.annot
-    rh_annotation: medimage-freesurfer/pial
-    # type=file|default=<undefined>: Input file must be <subject_id>/label/rh.aparc.annot
-    filled: generic/file
-    # type=file|default=<undefined>: Implicit input filled file. Only required with FS v5.3.
-    aseg: generic/file
-    # type=file|default=<undefined>: Input aseg file
-    ctxseg: generic/file
-    # type=file|default=<undefined>: 
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
-    out_file: Path
-    # type=file: Output aseg file
-    # type=file|default=<undefined>: Full path of file to save the output segmentation in
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/aparc_2_aseg_callables.py b/example-specs/task/nipype/freesurfer/aparc_2_aseg_callables.py
index d9a21915..d73de6af 100644
--- a/example-specs/task/nipype/freesurfer/aparc_2_aseg_callables.py
+++ b/example-specs/task/nipype/freesurfer/aparc_2_aseg_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in Aparc2Aseg.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of Aparc2Aseg.yaml"""
diff --git a/example-specs/task/nipype/freesurfer/apas_2_aseg.yaml b/example-specs/task/nipype/freesurfer/apas_2_aseg.yaml
index a7d8a753..c247750e 100644
--- a/example-specs/task/nipype/freesurfer/apas_2_aseg.yaml
+++ b/example-specs/task/nipype/freesurfer/apas_2_aseg.yaml
@@ -37,11 +37,11 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/mgh-gz
     # type=file|default=<undefined>: Input aparc+aseg.mgz
-    subjects_dir: generic/directory
-    # type=directory|default=<undefined>: subjects directory
     out_file: Path
     # type=file: Output aseg file
     # type=file|default=<undefined>: Output aseg file
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/apas_2_aseg_callables.py b/example-specs/task/nipype/freesurfer/apas_2_aseg_callables.py
index 79f67377..80244c3e 100644
--- a/example-specs/task/nipype/freesurfer/apas_2_aseg_callables.py
+++ b/example-specs/task/nipype/freesurfer/apas_2_aseg_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in Apas2Aseg.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of Apas2Aseg.yaml"""
diff --git a/example-specs/task/nipype/freesurfer/apply_mask.yaml b/example-specs/task/nipype/freesurfer/apply_mask.yaml
index b6971532..7d633987 100644
--- a/example-specs/task/nipype/freesurfer/apply_mask.yaml
+++ b/example-specs/task/nipype/freesurfer/apply_mask.yaml
@@ -30,17 +30,17 @@ inputs:
     # type=file|default=<undefined>: input image (will be masked)
     mask_file: generic/file
     # type=file|default=<undefined>: image defining mask space
+    out_file: Path
+    # type=file: masked image
+    # type=file|default=<undefined>: final image to write
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
     xfm_file: generic/file
     # type=file|default=<undefined>: LTA-format transformation matrix to align mask with input
     xfm_source: generic/file
     # type=file|default=<undefined>: image defining transform source space
     xfm_target: generic/file
     # type=file|default=<undefined>: image defining transform target space
-    subjects_dir: generic/directory
-    # type=directory|default=<undefined>: subjects directory
-    out_file: Path
-    # type=file: masked image
-    # type=file|default=<undefined>: final image to write
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/apply_mask_callables.py b/example-specs/task/nipype/freesurfer/apply_mask_callables.py
index ce0e94d9..411af901 100644
--- a/example-specs/task/nipype/freesurfer/apply_mask_callables.py
+++ b/example-specs/task/nipype/freesurfer/apply_mask_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in ApplyMask.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of ApplyMask.yaml"""
diff --git a/example-specs/task/nipype/freesurfer/apply_vol_transform.yaml b/example-specs/task/nipype/freesurfer/apply_vol_transform.yaml
index 37d36c4b..2142b743 100644
--- a/example-specs/task/nipype/freesurfer/apply_vol_transform.yaml
+++ b/example-specs/task/nipype/freesurfer/apply_vol_transform.yaml
@@ -34,27 +34,27 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    source_file: medimage/nifti1
-    # type=file|default=<undefined>: Input volume you wish to transform
-    target_file: generic/file
-    # type=file|default=<undefined>: Output template volume
-    reg_file: datascience/dat-file
-    # type=file|default=<undefined>: tkRAS-to-tkRAS matrix   (tkregister2 format)
+    fsl_reg_file: generic/file
+    # type=file|default=<undefined>: fslRAS-to-fslRAS matrix (FSL format)
     lta_file: generic/file
     # type=file|default=<undefined>: Linear Transform Array file
     lta_inv_file: generic/file
     # type=file|default=<undefined>: LTA, invert
-    fsl_reg_file: generic/file
-    # type=file|default=<undefined>: fslRAS-to-fslRAS matrix (FSL format)
-    xfm_reg_file: generic/file
-    # type=file|default=<undefined>: ScannerRAS-to-ScannerRAS matrix (MNI format)
     m3z_file: generic/file
     # type=file|default=<undefined>: This is the morph to be applied to the volume. Unless the morph is in mri/transforms (eg.: for talairach.m3z computed by reconall), you will need to specify the full path to this morph and use the --noDefM3zPath flag.
+    reg_file: datascience/dat-file
+    # type=file|default=<undefined>: tkRAS-to-tkRAS matrix   (tkregister2 format)
+    source_file: medimage/nifti1
+    # type=file|default=<undefined>: Input volume you wish to transform
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+    target_file: generic/file
+    # type=file|default=<undefined>: Output template volume
     transformed_file: Path
     # type=file: Path to output file if used normally
     # type=file|default=<undefined>: Output volume
+    xfm_reg_file: generic/file
+    # type=file|default=<undefined>: ScannerRAS-to-ScannerRAS matrix (MNI format)
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/apply_vol_transform_callables.py b/example-specs/task/nipype/freesurfer/apply_vol_transform_callables.py
index 34929ae3..a14c8eb1 100644
--- a/example-specs/task/nipype/freesurfer/apply_vol_transform_callables.py
+++ b/example-specs/task/nipype/freesurfer/apply_vol_transform_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in ApplyVolTransform.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of ApplyVolTransform.yaml"""
diff --git a/example-specs/task/nipype/freesurfer/bb_register.yaml b/example-specs/task/nipype/freesurfer/bb_register.yaml
index e3f4acc9..993f37eb 100644
--- a/example-specs/task/nipype/freesurfer/bb_register.yaml
+++ b/example-specs/task/nipype/freesurfer/bb_register.yaml
@@ -36,15 +36,15 @@ inputs:
   # passed to the field in the automatically generated unittests.
     init_reg_file: generic/file
     # type=file|default=<undefined>: existing registration file
-    source_file: medimage/nifti1
-    # type=file|default=<undefined>: source file to be registered
     intermediate_file: generic/file
     # type=file|default=<undefined>: Intermediate image, e.g. in case of partial FOV
-    subjects_dir: generic/directory
-    # type=directory|default=<undefined>: subjects directory
     out_reg_file: Path
     # type=file: Output registration file
     # type=file|default=<undefined>: output registration file
+    source_file: medimage/nifti1
+    # type=file|default=<undefined>: source file to be registered
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -58,20 +58,20 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    out_reg_file: generic/file
-    # type=file: Output registration file
-    # type=file|default=<undefined>: output registration file
+    init_cost_file: generic/file
+    # type=file: Output initial registration cost file
+    # type=traitcompound|default=None: output initial registration cost file
+    min_cost_file: generic/file
+    # type=file: Output registration minimum cost file
     out_fsl_file: generic/file
     # type=file: Output FLIRT-style registration file
     # type=traitcompound|default=None: write the transformation matrix in FSL FLIRT format
     out_lta_file: generic/file
     # type=file: Output LTA-style registration file
     # type=traitcompound|default=None: write the transformation matrix in LTA format
-    min_cost_file: generic/file
-    # type=file: Output registration minimum cost file
-    init_cost_file: generic/file
-    # type=file: Output initial registration cost file
-    # type=traitcompound|default=None: output initial registration cost file
+    out_reg_file: generic/file
+    # type=file: Output registration file
+    # type=file|default=<undefined>: output registration file
     registered_file: generic/file
     # type=file: Registered and resampled source file
     # type=traitcompound|default=None: output warped sourcefile either True or filename
diff --git a/example-specs/task/nipype/freesurfer/bb_register_callables.py b/example-specs/task/nipype/freesurfer/bb_register_callables.py
index fcc6350a..b022ad47 100644
--- a/example-specs/task/nipype/freesurfer/bb_register_callables.py
+++ b/example-specs/task/nipype/freesurfer/bb_register_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in BBRegister.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of BBRegister.yaml"""
diff --git a/example-specs/task/nipype/freesurfer/binarize.yaml b/example-specs/task/nipype/freesurfer/binarize.yaml
index f48c24c3..dd8358b1 100644
--- a/example-specs/task/nipype/freesurfer/binarize.yaml
+++ b/example-specs/task/nipype/freesurfer/binarize.yaml
@@ -28,17 +28,17 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    binary_file: Path
+    # type=file: binarized output volume
+    # type=file|default=<undefined>: binary output volume
     in_file: medimage/nifti1
     # type=file|default=<undefined>: input volume
-    merge_file: generic/file
-    # type=file|default=<undefined>: merge with mergevol
     mask_file: generic/file
     # type=file|default=<undefined>: must be within mask
+    merge_file: generic/file
+    # type=file|default=<undefined>: merge with mergevol
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
-    binary_file: Path
-    # type=file: binarized output volume
-    # type=file|default=<undefined>: binary output volume
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/binarize_callables.py b/example-specs/task/nipype/freesurfer/binarize_callables.py
index c4023215..01354d75 100644
--- a/example-specs/task/nipype/freesurfer/binarize_callables.py
+++ b/example-specs/task/nipype/freesurfer/binarize_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in Binarize.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of Binarize.yaml"""
diff --git a/example-specs/task/nipype/freesurfer/ca_label.yaml b/example-specs/task/nipype/freesurfer/ca_label.yaml
index 29a44035..01a9f92a 100644
--- a/example-specs/task/nipype/freesurfer/ca_label.yaml
+++ b/example-specs/task/nipype/freesurfer/ca_label.yaml
@@ -38,25 +38,25 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    aseg: generic/file
+    # type=file|default=<undefined>: Undocumented flag. Autorecon3 uses ../mri/aseg.presurf.mgz as input file
     in_file: medimage/mgh-gz
     # type=file|default=<undefined>: Input volume for CALabel
-    transform: datascience/text-matrix
-    # type=file|default=<undefined>: Input transform for CALabel
-    template: medimage/nifti1
-    # type=file|default=<undefined>: Input template for CALabel
     in_vol: generic/file
     # type=file|default=<undefined>: set input volume
     intensities: generic/file
     # type=file|default=<undefined>: input label intensities file(used in longitudinal processing)
     label: generic/file
     # type=file|default=<undefined>: Undocumented flag. Autorecon3 uses ../label/{hemisphere}.cortex.label as input file
-    aseg: generic/file
-    # type=file|default=<undefined>: Undocumented flag. Autorecon3 uses ../mri/aseg.presurf.mgz as input file
-    subjects_dir: generic/directory
-    # type=directory|default=<undefined>: subjects directory
     out_file: Path
     # type=file: Output volume from CALabel
     # type=file|default=<undefined>: Output file for CALabel
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+    template: medimage/nifti1
+    # type=file|default=<undefined>: Input template for CALabel
+    transform: datascience/text-matrix
+    # type=file|default=<undefined>: Input transform for CALabel
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/ca_label_callables.py b/example-specs/task/nipype/freesurfer/ca_label_callables.py
index 9461dd05..60c89013 100644
--- a/example-specs/task/nipype/freesurfer/ca_label_callables.py
+++ b/example-specs/task/nipype/freesurfer/ca_label_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in CALabel.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of CALabel.yaml"""
diff --git a/example-specs/task/nipype/freesurfer/ca_normalize.yaml b/example-specs/task/nipype/freesurfer/ca_normalize.yaml
index 3988aa00..b39d54da 100644
--- a/example-specs/task/nipype/freesurfer/ca_normalize.yaml
+++ b/example-specs/task/nipype/freesurfer/ca_normalize.yaml
@@ -38,24 +38,24 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    in_file: medimage/mgh-gz
-    # type=file|default=<undefined>: The input file for CANormalize
     atlas: medimage/nifti-gz
     # type=file|default=<undefined>: The atlas file in gca format
-    transform: datascience/text-matrix
-    # type=file|default=<undefined>: The transform file in lta format
-    mask: generic/file
-    # type=file|default=<undefined>: Specifies volume to use as mask
+    control_points: Path
+    # type=file: The output control points for Normalize
+    # type=file|default=<undefined>: File name for the output control points
+    in_file: medimage/mgh-gz
+    # type=file|default=<undefined>: The input file for CANormalize
     long_file: generic/file
     # type=file|default=<undefined>: undocumented flag used in longitudinal processing
-    subjects_dir: generic/directory
-    # type=directory|default=<undefined>: subjects directory
+    mask: generic/file
+    # type=file|default=<undefined>: Specifies volume to use as mask
     out_file: Path
     # type=file: The output file for Normalize
     # type=file|default=<undefined>: The output file for CANormalize
-    control_points: Path
-    # type=file: The output control points for Normalize
-    # type=file|default=<undefined>: File name for the output control points
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+    transform: datascience/text-matrix
+    # type=file|default=<undefined>: The transform file in lta format
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -69,12 +69,12 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    out_file: generic/file
-    # type=file: The output file for Normalize
-    # type=file|default=<undefined>: The output file for CANormalize
     control_points: generic/file
     # type=file: The output control points for Normalize
     # type=file|default=<undefined>: File name for the output control points
+    out_file: generic/file
+    # type=file: The output file for Normalize
+    # type=file|default=<undefined>: The output file for CANormalize
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/freesurfer/ca_normalize_callables.py b/example-specs/task/nipype/freesurfer/ca_normalize_callables.py
index 74c8f9a0..c74a5710 100644
--- a/example-specs/task/nipype/freesurfer/ca_normalize_callables.py
+++ b/example-specs/task/nipype/freesurfer/ca_normalize_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in CANormalize.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of CANormalize.yaml"""
diff --git a/example-specs/task/nipype/freesurfer/ca_register.yaml b/example-specs/task/nipype/freesurfer/ca_register.yaml
index 7147a9b2..3b979e28 100644
--- a/example-specs/task/nipype/freesurfer/ca_register.yaml
+++ b/example-specs/task/nipype/freesurfer/ca_register.yaml
@@ -38,19 +38,19 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/mgh-gz
     # type=file|default=<undefined>: The input volume for CARegister
-    template: generic/file
-    # type=file|default=<undefined>: The template file in gca format
-    mask: generic/file
-    # type=file|default=<undefined>: Specifies volume to use as mask
-    transform: generic/file
-    # type=file|default=<undefined>: Specifies transform in lta format
     l_files: generic/file+list-of
     # type=inputmultiobject|default=[]: undocumented flag used in longitudinal processing
-    subjects_dir: generic/directory
-    # type=directory|default=<undefined>: subjects directory
+    mask: generic/file
+    # type=file|default=<undefined>: Specifies volume to use as mask
     out_file: Path
     # type=file: The output file for CARegister
     # type=file|default=<undefined>: The output volume for CARegister
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+    template: generic/file
+    # type=file|default=<undefined>: The template file in gca format
+    transform: generic/file
+    # type=file|default=<undefined>: Specifies transform in lta format
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/ca_register_callables.py b/example-specs/task/nipype/freesurfer/ca_register_callables.py
index cebb0f07..1e79583d 100644
--- a/example-specs/task/nipype/freesurfer/ca_register_callables.py
+++ b/example-specs/task/nipype/freesurfer/ca_register_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in CARegister.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of CARegister.yaml"""
diff --git a/example-specs/task/nipype/freesurfer/check_talairach_alignment_callables.py b/example-specs/task/nipype/freesurfer/check_talairach_alignment_callables.py
index 31369920..159abe65 100644
--- a/example-specs/task/nipype/freesurfer/check_talairach_alignment_callables.py
+++ b/example-specs/task/nipype/freesurfer/check_talairach_alignment_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in CheckTalairachAlignment.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of CheckTalairachAlignment.yaml"""
diff --git a/example-specs/task/nipype/freesurfer/concatenate.yaml b/example-specs/task/nipype/freesurfer/concatenate.yaml
index 5009f570..efb3f8a6 100644
--- a/example-specs/task/nipype/freesurfer/concatenate.yaml
+++ b/example-specs/task/nipype/freesurfer/concatenate.yaml
@@ -34,17 +34,17 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    concatenated_file: Path
+    # type=file: Path/name of the output volume
+    # type=file|default=<undefined>: Output volume
     in_files: medimage/nifti1+list-of
     # type=inputmultiobject|default=[]: Individual volumes to be concatenated
-    multiply_matrix_file: generic/file
-    # type=file|default=<undefined>: Multiply input by an ascii matrix in file
     mask_file: generic/file
     # type=file|default=<undefined>: Mask input with a volume
+    multiply_matrix_file: generic/file
+    # type=file|default=<undefined>: Multiply input by an ascii matrix in file
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
-    concatenated_file: Path
-    # type=file: Path/name of the output volume
-    # type=file|default=<undefined>: Output volume
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/concatenate_callables.py b/example-specs/task/nipype/freesurfer/concatenate_callables.py
index 98afd0f7..2eb26502 100644
--- a/example-specs/task/nipype/freesurfer/concatenate_callables.py
+++ b/example-specs/task/nipype/freesurfer/concatenate_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in Concatenate.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of Concatenate.yaml"""
diff --git a/example-specs/task/nipype/freesurfer/concatenate_lta.yaml b/example-specs/task/nipype/freesurfer/concatenate_lta.yaml
index c552a2f6..974f0a6f 100644
--- a/example-specs/task/nipype/freesurfer/concatenate_lta.yaml
+++ b/example-specs/task/nipype/freesurfer/concatenate_lta.yaml
@@ -49,15 +49,15 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_lta1: medimage-freesurfer/lta
     # type=file|default=<undefined>: maps some src1 to dst1
+    out_file: Path
+    # type=file: the combined LTA maps: src1 to dst2 = LTA2*LTA1
+    # type=file|default=<undefined>: the combined LTA maps: src1 to dst2 = LTA2*LTA1
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
     tal_source_file: generic/file
     # type=file|default=<undefined>: if in_lta2 is talairach.xfm, specify source for talairach
     tal_template_file: generic/file
     # type=file|default=<undefined>: if in_lta2 is talairach.xfm, specify template for talairach
-    subjects_dir: generic/directory
-    # type=directory|default=<undefined>: subjects directory
-    out_file: Path
-    # type=file: the combined LTA maps: src1 to dst2 = LTA2*LTA1
-    # type=file|default=<undefined>: the combined LTA maps: src1 to dst2 = LTA2*LTA1
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/concatenate_lta_callables.py b/example-specs/task/nipype/freesurfer/concatenate_lta_callables.py
index b772b7d0..534cd698 100644
--- a/example-specs/task/nipype/freesurfer/concatenate_lta_callables.py
+++ b/example-specs/task/nipype/freesurfer/concatenate_lta_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in ConcatenateLTA.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of ConcatenateLTA.yaml"""
diff --git a/example-specs/task/nipype/freesurfer/contrast.yaml b/example-specs/task/nipype/freesurfer/contrast.yaml
index 0e8efa7f..3a863cdc 100644
--- a/example-specs/task/nipype/freesurfer/contrast.yaml
+++ b/example-specs/task/nipype/freesurfer/contrast.yaml
@@ -37,10 +37,6 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    thickness: medimage-freesurfer/thickness
-    # type=file|default=<undefined>: Input file must be <subject_id>/surf/?h.thickness
-    white: medimage-freesurfer/white
-    # type=file|default=<undefined>: Input file must be <subject_id>/surf/<hemisphere>.white
     annotation: medimage-freesurfer/annot
     # type=file|default=<undefined>: Input annotation file must be <subject_id>/label/<hemisphere>.aparc.annot
     cortex: medimage-freesurfer/label
@@ -51,6 +47,10 @@ inputs:
     # type=file|default=<undefined>: Implicit input file mri/rawavg.mgz
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+    thickness: medimage-freesurfer/thickness
+    # type=file|default=<undefined>: Input file must be <subject_id>/surf/?h.thickness
+    white: medimage-freesurfer/white
+    # type=file|default=<undefined>: Input file must be <subject_id>/surf/<hemisphere>.white
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -66,10 +66,10 @@ outputs:
   # passed to the field in the automatically generated unittests.
     out_contrast: generic/file
     # type=file: Output contrast file from Contrast
-    out_stats: generic/file
-    # type=file: Output stats file from Contrast
     out_log: generic/file
     # type=file: Output log from Contrast
+    out_stats: generic/file
+    # type=file: Output stats file from Contrast
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/freesurfer/contrast_callables.py b/example-specs/task/nipype/freesurfer/contrast_callables.py
index 926d9117..cab5f447 100644
--- a/example-specs/task/nipype/freesurfer/contrast_callables.py
+++ b/example-specs/task/nipype/freesurfer/contrast_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in Contrast.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of Contrast.yaml"""
diff --git a/example-specs/task/nipype/freesurfer/curvature.yaml b/example-specs/task/nipype/freesurfer/curvature.yaml
index 7f71b624..d1724e42 100644
--- a/example-specs/task/nipype/freesurfer/curvature.yaml
+++ b/example-specs/task/nipype/freesurfer/curvature.yaml
@@ -50,10 +50,10 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    out_mean: generic/file
-    # type=file: Mean curvature output file
     out_gauss: generic/file
     # type=file: Gaussian curvature output file
+    out_mean: generic/file
+    # type=file: Mean curvature output file
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/freesurfer/curvature_callables.py b/example-specs/task/nipype/freesurfer/curvature_callables.py
index a74cd397..9b95a834 100644
--- a/example-specs/task/nipype/freesurfer/curvature_callables.py
+++ b/example-specs/task/nipype/freesurfer/curvature_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in Curvature.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of Curvature.yaml"""
diff --git a/example-specs/task/nipype/freesurfer/curvature_stats.yaml b/example-specs/task/nipype/freesurfer/curvature_stats.yaml
index 9f761c5a..03352fb8 100644
--- a/example-specs/task/nipype/freesurfer/curvature_stats.yaml
+++ b/example-specs/task/nipype/freesurfer/curvature_stats.yaml
@@ -56,17 +56,17 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    surface: medimage-freesurfer/pial
-    # type=file|default=<undefined>: Specify surface file for CurvatureStats
     curvfile1: medimage-freesurfer/pial
     # type=file|default=<undefined>: Input file for CurvatureStats
     curvfile2: medimage-freesurfer/pial
     # type=file|default=<undefined>: Input file for CurvatureStats
-    subjects_dir: generic/directory
-    # type=directory|default=<undefined>: subjects directory
     out_file: Path
     # type=file: Output curvature stats file
     # type=file|default=<undefined>: Output curvature stats file
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+    surface: medimage-freesurfer/pial
+    # type=file|default=<undefined>: Specify surface file for CurvatureStats
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/curvature_stats_callables.py b/example-specs/task/nipype/freesurfer/curvature_stats_callables.py
index 3f5ae512..9e579e65 100644
--- a/example-specs/task/nipype/freesurfer/curvature_stats_callables.py
+++ b/example-specs/task/nipype/freesurfer/curvature_stats_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in CurvatureStats.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of CurvatureStats.yaml"""
diff --git a/example-specs/task/nipype/freesurfer/dicom_convert.yaml b/example-specs/task/nipype/freesurfer/dicom_convert.yaml
index 9eef2fab..d2b9371f 100644
--- a/example-specs/task/nipype/freesurfer/dicom_convert.yaml
+++ b/example-specs/task/nipype/freesurfer/dicom_convert.yaml
@@ -30,12 +30,12 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    dicom_info: generic/file
-    # type=file|default=<undefined>: File containing summary information from mri_parse_sdcmdir
-    dicom_dir: generic/directory
-    # type=directory|default=<undefined>: dicom directory from which to convert dicom files
     base_output_dir: generic/directory
     # type=directory|default=<undefined>: directory in which subject directories are created
+    dicom_dir: generic/directory
+    # type=directory|default=<undefined>: dicom directory from which to convert dicom files
+    dicom_info: generic/file
+    # type=file|default=<undefined>: File containing summary information from mri_parse_sdcmdir
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
   metadata:
diff --git a/example-specs/task/nipype/freesurfer/dicom_convert_callables.py b/example-specs/task/nipype/freesurfer/dicom_convert_callables.py
index 3cc0c305..8cd6f466 100644
--- a/example-specs/task/nipype/freesurfer/dicom_convert_callables.py
+++ b/example-specs/task/nipype/freesurfer/dicom_convert_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in DICOMConvert.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of DICOMConvert.yaml"""
diff --git a/example-specs/task/nipype/freesurfer/edit_w_mwith_aseg.yaml b/example-specs/task/nipype/freesurfer/edit_w_mwith_aseg.yaml
index 9aeb7d6d..7bdc14b8 100644
--- a/example-specs/task/nipype/freesurfer/edit_w_mwith_aseg.yaml
+++ b/example-specs/task/nipype/freesurfer/edit_w_mwith_aseg.yaml
@@ -34,17 +34,17 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    in_file: medimage/mgh-gz
-    # type=file|default=<undefined>: Input white matter segmentation file
     brain_file: medimage/mgh-gz
     # type=file|default=<undefined>: Input brain/T1 file
+    in_file: medimage/mgh-gz
+    # type=file|default=<undefined>: Input white matter segmentation file
+    out_file: Path
+    # type=file: Output edited WM file
+    # type=file|default=<undefined>: File to be written as output
     seg_file: medimage/mgh-gz
     # type=file|default=<undefined>: Input presurf segmentation file
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
-    out_file: Path
-    # type=file: Output edited WM file
-    # type=file|default=<undefined>: File to be written as output
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/edit_w_mwith_aseg_callables.py b/example-specs/task/nipype/freesurfer/edit_w_mwith_aseg_callables.py
index 4d2c53dc..a0c459f0 100644
--- a/example-specs/task/nipype/freesurfer/edit_w_mwith_aseg_callables.py
+++ b/example-specs/task/nipype/freesurfer/edit_w_mwith_aseg_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in EditWMwithAseg.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of EditWMwithAseg.yaml"""
diff --git a/example-specs/task/nipype/freesurfer/em_register.yaml b/example-specs/task/nipype/freesurfer/em_register.yaml
index fec8ccf4..db7a38c5 100644
--- a/example-specs/task/nipype/freesurfer/em_register.yaml
+++ b/example-specs/task/nipype/freesurfer/em_register.yaml
@@ -35,17 +35,17 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/mgh-gz
     # type=file|default=<undefined>: in brain volume
-    template: medimage/mgh-gz
-    # type=file|default=<undefined>: template gca
     mask: generic/file
     # type=file|default=<undefined>: use volume as a mask
-    transform: generic/file
-    # type=file|default=<undefined>: Previously computed transform
-    subjects_dir: generic/directory
-    # type=directory|default=<undefined>: subjects directory
     out_file: Path
     # type=file: output transform
     # type=file|default=<undefined>: output transform
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+    template: medimage/mgh-gz
+    # type=file|default=<undefined>: template gca
+    transform: generic/file
+    # type=file|default=<undefined>: Previously computed transform
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/em_register_callables.py b/example-specs/task/nipype/freesurfer/em_register_callables.py
index 2e390538..bc3efc0f 100644
--- a/example-specs/task/nipype/freesurfer/em_register_callables.py
+++ b/example-specs/task/nipype/freesurfer/em_register_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in EMRegister.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of EMRegister.yaml"""
diff --git a/example-specs/task/nipype/freesurfer/euler_number_callables.py b/example-specs/task/nipype/freesurfer/euler_number_callables.py
index 3759b891..2e9a493e 100644
--- a/example-specs/task/nipype/freesurfer/euler_number_callables.py
+++ b/example-specs/task/nipype/freesurfer/euler_number_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in EulerNumber.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of EulerNumber.yaml"""
diff --git a/example-specs/task/nipype/freesurfer/extract_main_component_callables.py b/example-specs/task/nipype/freesurfer/extract_main_component_callables.py
index 6f7c2d5e..b73a2742 100644
--- a/example-specs/task/nipype/freesurfer/extract_main_component_callables.py
+++ b/example-specs/task/nipype/freesurfer/extract_main_component_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in ExtractMainComponent.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of ExtractMainComponent.yaml"""
diff --git a/example-specs/task/nipype/freesurfer/fit_ms_params.yaml b/example-specs/task/nipype/freesurfer/fit_ms_params.yaml
index 1f89856c..6a8bea02 100644
--- a/example-specs/task/nipype/freesurfer/fit_ms_params.yaml
+++ b/example-specs/task/nipype/freesurfer/fit_ms_params.yaml
@@ -33,12 +33,12 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_files: medimage/mgh-gz+list-of
     # type=list|default=[]: list of FLASH images (must be in mgh format)
-    xfm_list: generic/file+list-of
-    # type=list|default=[]: list of transform files to apply to each FLASH image
-    subjects_dir: generic/directory
-    # type=directory|default=<undefined>: subjects directory
     out_dir: Path
     # type=directory|default=<undefined>: directory to store output in
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+    xfm_list: generic/file+list-of
+    # type=list|default=[]: list of transform files to apply to each FLASH image
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -52,10 +52,10 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    t1_image: generic/file
-    # type=file: image of estimated T1 relaxation values
     pd_image: generic/file
     # type=file: image of estimated proton density values
+    t1_image: generic/file
+    # type=file: image of estimated T1 relaxation values
     t2star_image: generic/file
     # type=file: image of estimated T2* values
   callables:
diff --git a/example-specs/task/nipype/freesurfer/fit_ms_params_callables.py b/example-specs/task/nipype/freesurfer/fit_ms_params_callables.py
index 6319b185..1387479e 100644
--- a/example-specs/task/nipype/freesurfer/fit_ms_params_callables.py
+++ b/example-specs/task/nipype/freesurfer/fit_ms_params_callables.py
@@ -1,4 +1,4 @@
-"""Module to put any functions that are referred to in FitMSParams.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of FitMSParams.yaml"""
 
 
 def out_dir_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/freesurfer/fix_topology.yaml b/example-specs/task/nipype/freesurfer/fix_topology.yaml
index 63d4a86e..4c164714 100644
--- a/example-specs/task/nipype/freesurfer/fix_topology.yaml
+++ b/example-specs/task/nipype/freesurfer/fix_topology.yaml
@@ -38,12 +38,12 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    in_orig: medimage-freesurfer/orig
-    # type=file|default=<undefined>: Undocumented input file <hemisphere>.orig
-    in_inflated: medimage-freesurfer/inflated
-    # type=file|default=<undefined>: Undocumented input file <hemisphere>.inflated
     in_brain: generic/file
     # type=file|default=<undefined>: Implicit input brain.mgz
+    in_inflated: medimage-freesurfer/inflated
+    # type=file|default=<undefined>: Undocumented input file <hemisphere>.inflated
+    in_orig: medimage-freesurfer/orig
+    # type=file|default=<undefined>: Undocumented input file <hemisphere>.orig
     in_wm: generic/file
     # type=file|default=<undefined>: Implicit input wm.mgz
     sphere: medimage-freesurfer/nofix
diff --git a/example-specs/task/nipype/freesurfer/fix_topology_callables.py b/example-specs/task/nipype/freesurfer/fix_topology_callables.py
index 96440301..06798671 100644
--- a/example-specs/task/nipype/freesurfer/fix_topology_callables.py
+++ b/example-specs/task/nipype/freesurfer/fix_topology_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in FixTopology.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of FixTopology.yaml"""
diff --git a/example-specs/task/nipype/freesurfer/fuse_segmentations.yaml b/example-specs/task/nipype/freesurfer/fuse_segmentations.yaml
index 4095fa95..6d98f0b4 100644
--- a/example-specs/task/nipype/freesurfer/fuse_segmentations.yaml
+++ b/example-specs/task/nipype/freesurfer/fuse_segmentations.yaml
@@ -34,17 +34,17 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    in_norms: medimage/mgh-gz+list-of
+    # type=inputmultiobject|default=[]: -n <filename>  - name of norm file to use (default: norm.mgs)         must include the corresponding norm file for all given timepoints         as well as for the current subject
     in_segmentations: medimage/mgh-gz+list-of
     # type=inputmultiobject|default=[]: name of aseg file to use (default: aseg.mgz)         must include the aseg files for all the given timepoints
     in_segmentations_noCC: medimage/mgh-gz+list-of
     # type=inputmultiobject|default=[]: name of aseg file w/o CC labels (default: aseg.auto_noCCseg.mgz)         must include the corresponding file for all the given timepoints
-    in_norms: medimage/mgh-gz+list-of
-    # type=inputmultiobject|default=[]: -n <filename>  - name of norm file to use (default: norm.mgs)         must include the corresponding norm file for all given timepoints         as well as for the current subject
-    subjects_dir: generic/directory
-    # type=directory|default=<undefined>: subjects directory
     out_file: Path
     # type=file: output fused segmentation file
     # type=file|default=<undefined>: output fused segmentation file
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/fuse_segmentations_callables.py b/example-specs/task/nipype/freesurfer/fuse_segmentations_callables.py
index fda17fb0..d76154ac 100644
--- a/example-specs/task/nipype/freesurfer/fuse_segmentations_callables.py
+++ b/example-specs/task/nipype/freesurfer/fuse_segmentations_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in FuseSegmentations.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of FuseSegmentations.yaml"""
diff --git a/example-specs/task/nipype/freesurfer/glm_fit.yaml b/example-specs/task/nipype/freesurfer/glm_fit.yaml
index 4ffa4f31..7a0e1622 100644
--- a/example-specs/task/nipype/freesurfer/glm_fit.yaml
+++ b/example-specs/task/nipype/freesurfer/glm_fit.yaml
@@ -30,31 +30,31 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    in_file: medimage/nifti1
-    # type=file|default=<undefined>: input 4D file
-    design: generic/file
-    # type=file|default=<undefined>: design matrix file
     contrast: generic/file+list-of
     # type=inputmultiobject|default=[]: contrast file
-    per_voxel_reg: generic/file+list-of
-    # type=inputmultiobject|default=[]: per-voxel regressors
-    weighted_ls: generic/file
-    # type=file|default=<undefined>: weighted least squares
-    fixed_fx_var: generic/file
-    # type=file|default=<undefined>: for fixed effects analysis
+    design: generic/file
+    # type=file|default=<undefined>: design matrix file
     fixed_fx_dof_file: generic/file
     # type=file|default=<undefined>: text file with dof for fixed effects analysis
-    weight_file: generic/file
-    # type=file|default=<undefined>: weight for each input at each voxel
+    fixed_fx_var: generic/file
+    # type=file|default=<undefined>: for fixed effects analysis
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: input 4D file
     label_file: generic/file
     # type=file|default=<undefined>: use label as mask, surfaces only
+    mask_file: Path
+    # type=file: map of the mask used in the analysis
+    # type=file|default=<undefined>: binary mask
+    per_voxel_reg: generic/file+list-of
+    # type=inputmultiobject|default=[]: per-voxel regressors
     sim_done_file: generic/file
     # type=file|default=<undefined>: create file when simulation finished
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
-    mask_file: Path
-    # type=file: map of the mask used in the analysis
-    # type=file|default=<undefined>: binary mask
+    weight_file: generic/file
+    # type=file|default=<undefined>: weight for each input at each voxel
+    weighted_ls: generic/file
+    # type=file|default=<undefined>: weighted least squares
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -70,36 +70,36 @@ outputs:
   # passed to the field in the automatically generated unittests.
     beta_file: generic/file
     # type=file: map of regression coefficients
+    bp_file: generic/file
+    # type=file: Binding potential estimates
+    dof_file: generic/file
+    # type=file: text file with effective degrees-of-freedom for the analysis
     error_file: generic/file
     # type=file: map of residual error
-    error_var_file: generic/file
-    # type=file: map of residual error variance
     error_stddev_file: generic/file
     # type=file: map of residual error standard deviation
+    error_var_file: generic/file
+    # type=file: map of residual error variance
     estimate_file: generic/file
     # type=file: map of the estimated Y values
+    frame_eigenvectors: generic/file
+    # type=file: matrix of frame eigenvectors from residual PCA
+    fwhm_file: generic/file
+    # type=file: text file with estimated smoothness
+    glm_dir: generic/directory
+    # type=directory: output directory
+    # type=str|default='': save outputs to dir
+    k2p_file: generic/file
+    # type=file: estimate of k2p parameter
     mask_file: generic/file
     # type=file: map of the mask used in the analysis
     # type=file|default=<undefined>: binary mask
-    fwhm_file: generic/file
-    # type=file: text file with estimated smoothness
-    dof_file: generic/file
-    # type=file: text file with effective degrees-of-freedom for the analysis
-    spatial_eigenvectors: generic/file
-    # type=file: map of spatial eigenvectors from residual PCA
-    frame_eigenvectors: generic/file
-    # type=file: matrix of frame eigenvectors from residual PCA
     singular_values: generic/file
     # type=file: matrix singular values from residual PCA
+    spatial_eigenvectors: generic/file
+    # type=file: map of spatial eigenvectors from residual PCA
     svd_stats_file: generic/file
     # type=file: text file summarizing the residual PCA
-    k2p_file: generic/file
-    # type=file: estimate of k2p parameter
-    bp_file: generic/file
-    # type=file: Binding potential estimates
-    glm_dir: generic/directory
-    # type=directory: output directory
-    # type=str|default='': save outputs to dir
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/freesurfer/glm_fit_callables.py b/example-specs/task/nipype/freesurfer/glm_fit_callables.py
index a9012e2b..df81d5b9 100644
--- a/example-specs/task/nipype/freesurfer/glm_fit_callables.py
+++ b/example-specs/task/nipype/freesurfer/glm_fit_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in GLMFit.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of GLMFit.yaml"""
diff --git a/example-specs/task/nipype/freesurfer/gtm_seg.yaml b/example-specs/task/nipype/freesurfer/gtm_seg.yaml
index 753e275f..e5b68fc0 100644
--- a/example-specs/task/nipype/freesurfer/gtm_seg.yaml
+++ b/example-specs/task/nipype/freesurfer/gtm_seg.yaml
@@ -30,11 +30,11 @@ inputs:
   # passed to the field in the automatically generated unittests.
     colortable: generic/file
     # type=file|default=<undefined>: colortable
-    subjects_dir: generic/directory
-    # type=directory|default=<undefined>: subjects directory
     out_file: Path
     # type=file: GTM segmentation
     # type=file|default='gtmseg.mgz': output volume relative to subject/mri
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/gtm_seg_callables.py b/example-specs/task/nipype/freesurfer/gtm_seg_callables.py
index ec594dae..adf8196e 100644
--- a/example-specs/task/nipype/freesurfer/gtm_seg_callables.py
+++ b/example-specs/task/nipype/freesurfer/gtm_seg_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in GTMSeg.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of GTMSeg.yaml"""
diff --git a/example-specs/task/nipype/freesurfer/gtmpvc.yaml b/example-specs/task/nipype/freesurfer/gtmpvc.yaml
index cb68a4bf..5b32ebc6 100644
--- a/example-specs/task/nipype/freesurfer/gtmpvc.yaml
+++ b/example-specs/task/nipype/freesurfer/gtmpvc.yaml
@@ -47,18 +47,18 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    color_table_file: generic/file
+    # type=file|default=<undefined>: color table file with seg id names
+    contrast: generic/file+list-of
+    # type=inputmultiobject|default=[]: contrast file
     in_file: medimage/nifti-gz
     # type=file|default=<undefined>: input volume - source data to pvc
-    segmentation: medimage/mgh-gz
-    # type=file|default=<undefined>: segfile : anatomical segmentation to define regions for GTM
-    reg_file: medimage-freesurfer/lta
-    # type=file|default=<undefined>: LTA registration file that maps PET to anatomical
     mask_file: generic/file
     # type=file|default=<undefined>: ignore areas outside of the mask (in input vol space)
-    contrast: generic/file+list-of
-    # type=inputmultiobject|default=[]: contrast file
-    color_table_file: generic/file
-    # type=file|default=<undefined>: color table file with seg id names
+    reg_file: medimage-freesurfer/lta
+    # type=file|default=<undefined>: LTA registration file that maps PET to anatomical
+    segmentation: medimage/mgh-gz
+    # type=file|default=<undefined>: segfile : anatomical segmentation to define regions for GTM
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
   metadata:
@@ -74,50 +74,50 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    ref_file: generic/file
-    # type=file: Reference TAC in .dat
-    hb_nifti: generic/file
-    # type=file: High-binding TAC in nifti
-    hb_dat: generic/file
-    # type=file: High-binding TAC in .dat
-    nopvc_file: generic/file
-    # type=file: TACs for all regions with no PVC
     gtm_file: generic/file
     # type=file: TACs for all regions with GTM PVC
     gtm_stats: generic/file
     # type=file: Statistics for the GTM PVC
+    hb_dat: generic/file
+    # type=file: High-binding TAC in .dat
+    hb_nifti: generic/file
+    # type=file: High-binding TAC in nifti
     input_file: generic/file
     # type=file: 4D PET file in native volume space
-    reg_pet2anat: generic/file
-    # type=file: Registration file to go from PET to anat
-    reg_anat2pet: generic/file
-    # type=file: Registration file to go from anat to PET
-    reg_rbvpet2anat: generic/file
-    # type=file: Registration file to go from RBV corrected PET to anat
-    reg_anat2rbvpet: generic/file
-    # type=file: Registration file to go from anat to RBV corrected PET
     mgx_ctxgm: generic/file
     # type=file: Cortical GM voxel-wise values corrected using the extended Muller-Gartner method
-    mgx_subctxgm: generic/file
-    # type=file: Subcortical GM voxel-wise values corrected using the extended Muller-Gartner method
     mgx_gm: generic/file
     # type=file: All GM voxel-wise values corrected using the extended Muller-Gartner method
+    mgx_subctxgm: generic/file
+    # type=file: Subcortical GM voxel-wise values corrected using the extended Muller-Gartner method
+    nopvc_file: generic/file
+    # type=file: TACs for all regions with no PVC
+    opt_params: generic/file
+    # type=file: Optimal parameter estimates for the FWHM using adaptive GTM
+    pvc_dir: generic/directory
+    # type=directory: output directory
+    # type=str|default='': save outputs to dir
     rbv: generic/file
     # type=file: All GM voxel-wise values corrected using the RBV method
     # type=bool|default=False: perform Region-based Voxelwise (RBV) PVC
-    opt_params: generic/file
-    # type=file: Optimal parameter estimates for the FWHM using adaptive GTM
-    yhat0: generic/file
-    # type=file: 4D PET file of signal estimate (yhat) after PVC (unsmoothed)
+    ref_file: generic/file
+    # type=file: Reference TAC in .dat
+    reg_anat2pet: generic/file
+    # type=file: Registration file to go from anat to PET
+    reg_anat2rbvpet: generic/file
+    # type=file: Registration file to go from anat to RBV corrected PET
+    reg_pet2anat: generic/file
+    # type=file: Registration file to go from PET to anat
+    reg_rbvpet2anat: generic/file
+    # type=file: Registration file to go from RBV corrected PET to anat
     yhat: generic/file
     # type=file: 4D PET file of signal estimate (yhat) after PVC (smoothed with PSF)
+    yhat0: generic/file
+    # type=file: 4D PET file of signal estimate (yhat) after PVC (unsmoothed)
     yhat_full_fov: generic/file
     # type=file: 4D PET file with full FOV of signal estimate (yhat) after PVC (smoothed with PSF)
     yhat_with_noise: generic/file
     # type=file: 4D PET file with full FOV of signal estimate (yhat) with noise after PVC (smoothed with PSF)
-    pvc_dir: generic/directory
-    # type=directory: output directory
-    # type=str|default='': save outputs to dir
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/freesurfer/gtmpvc_callables.py b/example-specs/task/nipype/freesurfer/gtmpvc_callables.py
index 80701ac4..8741b758 100644
--- a/example-specs/task/nipype/freesurfer/gtmpvc_callables.py
+++ b/example-specs/task/nipype/freesurfer/gtmpvc_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in GTMPVC.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of GTMPVC.yaml"""
diff --git a/example-specs/task/nipype/freesurfer/image_info_callables.py b/example-specs/task/nipype/freesurfer/image_info_callables.py
index d6754e7f..baa0543b 100644
--- a/example-specs/task/nipype/freesurfer/image_info_callables.py
+++ b/example-specs/task/nipype/freesurfer/image_info_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in ImageInfo.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of ImageInfo.yaml"""
diff --git a/example-specs/task/nipype/freesurfer/jacobian.yaml b/example-specs/task/nipype/freesurfer/jacobian.yaml
index 461ccc48..495a1b0b 100644
--- a/example-specs/task/nipype/freesurfer/jacobian.yaml
+++ b/example-specs/task/nipype/freesurfer/jacobian.yaml
@@ -31,15 +31,15 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    in_origsurf: medimage-freesurfer/pial
-    # type=file|default=<undefined>: Original surface
     in_mappedsurf: medimage-freesurfer/pial
     # type=file|default=<undefined>: Mapped surface
-    subjects_dir: generic/directory
-    # type=directory|default=<undefined>: subjects directory
+    in_origsurf: medimage-freesurfer/pial
+    # type=file|default=<undefined>: Original surface
     out_file: Path
     # type=file: Output Jacobian of the surface mapping
     # type=file|default=<undefined>: Output Jacobian of the surface mapping
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/jacobian_callables.py b/example-specs/task/nipype/freesurfer/jacobian_callables.py
index 4d7ccd46..513e3766 100644
--- a/example-specs/task/nipype/freesurfer/jacobian_callables.py
+++ b/example-specs/task/nipype/freesurfer/jacobian_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in Jacobian.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of Jacobian.yaml"""
diff --git a/example-specs/task/nipype/freesurfer/label_2_annot.yaml b/example-specs/task/nipype/freesurfer/label_2_annot.yaml
index bf08fff8..07da90e7 100644
--- a/example-specs/task/nipype/freesurfer/label_2_annot.yaml
+++ b/example-specs/task/nipype/freesurfer/label_2_annot.yaml
@@ -34,10 +34,10 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    orig: medimage-freesurfer/pial
-    # type=file|default=<undefined>: implicit {hemisphere}.orig
     color_table: generic/file
     # type=file|default=<undefined>: File that defines the structure names, their indices, and their color
+    orig: medimage-freesurfer/pial
+    # type=file|default=<undefined>: implicit {hemisphere}.orig
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
   metadata:
diff --git a/example-specs/task/nipype/freesurfer/label_2_annot_callables.py b/example-specs/task/nipype/freesurfer/label_2_annot_callables.py
index ddbd52ea..404675fc 100644
--- a/example-specs/task/nipype/freesurfer/label_2_annot_callables.py
+++ b/example-specs/task/nipype/freesurfer/label_2_annot_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in Label2Annot.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of Label2Annot.yaml"""
diff --git a/example-specs/task/nipype/freesurfer/label_2_label.yaml b/example-specs/task/nipype/freesurfer/label_2_label.yaml
index 9be248c6..18289854 100644
--- a/example-specs/task/nipype/freesurfer/label_2_label.yaml
+++ b/example-specs/task/nipype/freesurfer/label_2_label.yaml
@@ -45,21 +45,21 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    sphere_reg: medimage-freesurfer/pial
-    # type=file|default=<undefined>: Implicit input <hemisphere>.sphere.reg
-    white: medimage-freesurfer/pial
-    # type=file|default=<undefined>: Implicit input <hemisphere>.white
+    out_file: Path
+    # type=file: Output label
+    # type=file|default=<undefined>: Target label
+    source_label: model/stl
+    # type=file|default=<undefined>: Source label
     source_sphere_reg: medimage-freesurfer/pial
     # type=file|default=<undefined>: Implicit input <hemisphere>.sphere.reg
     source_white: medimage-freesurfer/pial
     # type=file|default=<undefined>: Implicit input <hemisphere>.white
-    source_label: model/stl
-    # type=file|default=<undefined>: Source label
+    sphere_reg: medimage-freesurfer/pial
+    # type=file|default=<undefined>: Implicit input <hemisphere>.sphere.reg
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
-    out_file: Path
-    # type=file: Output label
-    # type=file|default=<undefined>: Target label
+    white: medimage-freesurfer/pial
+    # type=file|default=<undefined>: Implicit input <hemisphere>.white
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/label_2_label_callables.py b/example-specs/task/nipype/freesurfer/label_2_label_callables.py
index c00417f0..f00cdebe 100644
--- a/example-specs/task/nipype/freesurfer/label_2_label_callables.py
+++ b/example-specs/task/nipype/freesurfer/label_2_label_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in Label2Label.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of Label2Label.yaml"""
diff --git a/example-specs/task/nipype/freesurfer/label_2_vol.yaml b/example-specs/task/nipype/freesurfer/label_2_vol.yaml
index e7ce0b18..792e9bf0 100644
--- a/example-specs/task/nipype/freesurfer/label_2_vol.yaml
+++ b/example-specs/task/nipype/freesurfer/label_2_vol.yaml
@@ -28,24 +28,24 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    label_file: medimage-freesurfer/label+list-of
-    # type=inputmultiobject|default=[]: list of label files
     annot_file: generic/file
     # type=file|default=<undefined>: surface annotation file
-    seg_file: generic/file
-    # type=file|default=<undefined>: segmentation file
-    template_file: medimage/nifti1
-    # type=file|default=<undefined>: output template volume
-    reg_file: datascience/dat-file
-    # type=file|default=<undefined>: tkregister style matrix VolXYZ = R*LabelXYZ
-    reg_header: generic/file
-    # type=file|default=<undefined>: label template volume
+    label_file: medimage-freesurfer/label+list-of
+    # type=inputmultiobject|default=[]: list of label files
     label_hit_file: generic/file
     # type=file|default=<undefined>: file with each frame is nhits for a label
     map_label_stat: generic/file
     # type=file|default=<undefined>: map the label stats field into the vol
+    reg_file: datascience/dat-file
+    # type=file|default=<undefined>: tkregister style matrix VolXYZ = R*LabelXYZ
+    reg_header: generic/file
+    # type=file|default=<undefined>: label template volume
+    seg_file: generic/file
+    # type=file|default=<undefined>: segmentation file
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+    template_file: medimage/nifti1
+    # type=file|default=<undefined>: output template volume
     vol_label_file: Path
     # type=file: output volume
     # type=file|default=<undefined>: output volume
diff --git a/example-specs/task/nipype/freesurfer/label_2_vol_callables.py b/example-specs/task/nipype/freesurfer/label_2_vol_callables.py
index a6f32381..1f5bf397 100644
--- a/example-specs/task/nipype/freesurfer/label_2_vol_callables.py
+++ b/example-specs/task/nipype/freesurfer/label_2_vol_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in Label2Vol.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of Label2Vol.yaml"""
diff --git a/example-specs/task/nipype/freesurfer/logan_ref.yaml b/example-specs/task/nipype/freesurfer/logan_ref.yaml
index 6e972319..05219af1 100644
--- a/example-specs/task/nipype/freesurfer/logan_ref.yaml
+++ b/example-specs/task/nipype/freesurfer/logan_ref.yaml
@@ -29,31 +29,31 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    in_file: medimage/nifti1
-    # type=file|default=<undefined>: input 4D file
-    design: generic/file
-    # type=file|default=<undefined>: design matrix file
     contrast: generic/file+list-of
     # type=inputmultiobject|default=[]: contrast file
-    per_voxel_reg: generic/file+list-of
-    # type=inputmultiobject|default=[]: per-voxel regressors
-    weighted_ls: generic/file
-    # type=file|default=<undefined>: weighted least squares
-    fixed_fx_var: generic/file
-    # type=file|default=<undefined>: for fixed effects analysis
+    design: generic/file
+    # type=file|default=<undefined>: design matrix file
     fixed_fx_dof_file: generic/file
     # type=file|default=<undefined>: text file with dof for fixed effects analysis
-    weight_file: generic/file
-    # type=file|default=<undefined>: weight for each input at each voxel
+    fixed_fx_var: generic/file
+    # type=file|default=<undefined>: for fixed effects analysis
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: input 4D file
     label_file: generic/file
     # type=file|default=<undefined>: use label as mask, surfaces only
+    mask_file: Path
+    # type=file: map of the mask used in the analysis
+    # type=file|default=<undefined>: binary mask
+    per_voxel_reg: generic/file+list-of
+    # type=inputmultiobject|default=[]: per-voxel regressors
     sim_done_file: generic/file
     # type=file|default=<undefined>: create file when simulation finished
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
-    mask_file: Path
-    # type=file: map of the mask used in the analysis
-    # type=file|default=<undefined>: binary mask
+    weight_file: generic/file
+    # type=file|default=<undefined>: weight for each input at each voxel
+    weighted_ls: generic/file
+    # type=file|default=<undefined>: weighted least squares
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -69,36 +69,36 @@ outputs:
   # passed to the field in the automatically generated unittests.
     beta_file: generic/file
     # type=file: map of regression coefficients
+    bp_file: generic/file
+    # type=file: Binding potential estimates
+    dof_file: generic/file
+    # type=file: text file with effective degrees-of-freedom for the analysis
     error_file: generic/file
     # type=file: map of residual error
-    error_var_file: generic/file
-    # type=file: map of residual error variance
     error_stddev_file: generic/file
     # type=file: map of residual error standard deviation
+    error_var_file: generic/file
+    # type=file: map of residual error variance
     estimate_file: generic/file
     # type=file: map of the estimated Y values
+    frame_eigenvectors: generic/file
+    # type=file: matrix of frame eigenvectors from residual PCA
+    fwhm_file: generic/file
+    # type=file: text file with estimated smoothness
+    glm_dir: generic/directory
+    # type=directory: output directory
+    # type=str|default='': save outputs to dir
+    k2p_file: generic/file
+    # type=file: estimate of k2p parameter
     mask_file: generic/file
     # type=file: map of the mask used in the analysis
     # type=file|default=<undefined>: binary mask
-    fwhm_file: generic/file
-    # type=file: text file with estimated smoothness
-    dof_file: generic/file
-    # type=file: text file with effective degrees-of-freedom for the analysis
-    spatial_eigenvectors: generic/file
-    # type=file: map of spatial eigenvectors from residual PCA
-    frame_eigenvectors: generic/file
-    # type=file: matrix of frame eigenvectors from residual PCA
     singular_values: generic/file
     # type=file: matrix singular values from residual PCA
+    spatial_eigenvectors: generic/file
+    # type=file: map of spatial eigenvectors from residual PCA
     svd_stats_file: generic/file
     # type=file: text file summarizing the residual PCA
-    k2p_file: generic/file
-    # type=file: estimate of k2p parameter
-    bp_file: generic/file
-    # type=file: Binding potential estimates
-    glm_dir: generic/directory
-    # type=directory: output directory
-    # type=str|default='': save outputs to dir
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/freesurfer/logan_ref_callables.py b/example-specs/task/nipype/freesurfer/logan_ref_callables.py
index 92e5a6b4..f7878b7a 100644
--- a/example-specs/task/nipype/freesurfer/logan_ref_callables.py
+++ b/example-specs/task/nipype/freesurfer/logan_ref_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in LoganRef.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of LoganRef.yaml"""
diff --git a/example-specs/task/nipype/freesurfer/lta_convert.yaml b/example-specs/task/nipype/freesurfer/lta_convert.yaml
index 434de8a7..2735f875 100644
--- a/example-specs/task/nipype/freesurfer/lta_convert.yaml
+++ b/example-specs/task/nipype/freesurfer/lta_convert.yaml
@@ -28,14 +28,14 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_fsl: generic/file
     # type=file|default=<undefined>: input transform of FSL type
+    in_itk: generic/file
+    # type=file|default=<undefined>: input transform of ITK type
     in_mni: generic/file
     # type=file|default=<undefined>: input transform of MNI/XFM type
-    in_reg: generic/file
-    # type=file|default=<undefined>: input transform of TK REG type (deprecated format)
     in_niftyreg: generic/file
     # type=file|default=<undefined>: input transform of Nifty Reg type (inverse RAS2RAS)
-    in_itk: generic/file
-    # type=file|default=<undefined>: input transform of ITK type
+    in_reg: generic/file
+    # type=file|default=<undefined>: input transform of TK REG type (deprecated format)
     source_file: generic/file
     # type=file|default=<undefined>: 
     target_file: generic/file
@@ -53,21 +53,21 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    out_lta: generic/file
-    # type=file: output linear transform (LTA Freesurfer format)
-    # type=traitcompound|default=None: output linear transform (LTA Freesurfer format)
     out_fsl: generic/file
     # type=file: output transform in FSL format
     # type=traitcompound|default=None: output transform in FSL format
+    out_itk: generic/file
+    # type=file: output transform in ITK format
+    # type=traitcompound|default=None: output transform in ITK format
+    out_lta: generic/file
+    # type=file: output linear transform (LTA Freesurfer format)
+    # type=traitcompound|default=None: output linear transform (LTA Freesurfer format)
     out_mni: generic/file
     # type=file: output transform in MNI/XFM format
     # type=traitcompound|default=None: output transform in MNI/XFM format
     out_reg: generic/file
     # type=file: output transform in reg dat format
     # type=traitcompound|default=None: output transform in reg dat format
-    out_itk: generic/file
-    # type=file: output transform in ITK format
-    # type=traitcompound|default=None: output transform in ITK format
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/freesurfer/lta_convert_callables.py b/example-specs/task/nipype/freesurfer/lta_convert_callables.py
index efc3a184..a8761ea3 100644
--- a/example-specs/task/nipype/freesurfer/lta_convert_callables.py
+++ b/example-specs/task/nipype/freesurfer/lta_convert_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in LTAConvert.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of LTAConvert.yaml"""
diff --git a/example-specs/task/nipype/freesurfer/make_average_subject.yaml b/example-specs/task/nipype/freesurfer/make_average_subject.yaml
index 9a288940..52738e25 100644
--- a/example-specs/task/nipype/freesurfer/make_average_subject.yaml
+++ b/example-specs/task/nipype/freesurfer/make_average_subject.yaml
@@ -30,7 +30,7 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    out_name: generic/file
+    out_name: Path
     # type=file|default='average': name for the average subject
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
diff --git a/example-specs/task/nipype/freesurfer/make_average_subject_callables.py b/example-specs/task/nipype/freesurfer/make_average_subject_callables.py
index 4d855d5a..71a755c2 100644
--- a/example-specs/task/nipype/freesurfer/make_average_subject_callables.py
+++ b/example-specs/task/nipype/freesurfer/make_average_subject_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in MakeAverageSubject.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of MakeAverageSubject.yaml"""
diff --git a/example-specs/task/nipype/freesurfer/make_surfaces.yaml b/example-specs/task/nipype/freesurfer/make_surfaces.yaml
index a6ae5f06..f59aeb08 100644
--- a/example-specs/task/nipype/freesurfer/make_surfaces.yaml
+++ b/example-specs/task/nipype/freesurfer/make_surfaces.yaml
@@ -41,24 +41,24 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    in_orig: medimage-freesurfer/pial
-    # type=file|default=<undefined>: Implicit input file <hemisphere>.orig
-    in_wm: medimage/mgh-gz
-    # type=file|default=<undefined>: Implicit input file wm.mgz
+    in_T1: medimage/mgh-gz
+    # type=file|default=<undefined>: Input brain or T1 file
+    in_aseg: generic/file
+    # type=file|default=<undefined>: Input segmentation file
     in_filled: medimage/mgh-gz
     # type=file|default=<undefined>: Implicit input file filled.mgz
-    in_white: generic/file
-    # type=file|default=<undefined>: Implicit input that is sometimes used
     in_label: medimage/nifti1
     # type=file|default=<undefined>: Implicit input label/<hemisphere>.aparc.annot
-    orig_white: generic/file
-    # type=file|default=<undefined>: Specify a white surface to start with
+    in_orig: medimage-freesurfer/pial
+    # type=file|default=<undefined>: Implicit input file <hemisphere>.orig
+    in_white: generic/file
+    # type=file|default=<undefined>: Implicit input that is sometimes used
+    in_wm: medimage/mgh-gz
+    # type=file|default=<undefined>: Implicit input file wm.mgz
     orig_pial: medimage-freesurfer/pial
     # type=file|default=<undefined>: Specify a pial surface to start with
-    in_aseg: generic/file
-    # type=file|default=<undefined>: Input segmentation file
-    in_T1: medimage/mgh-gz
-    # type=file|default=<undefined>: Input brain or T1 file
+    orig_white: generic/file
+    # type=file|default=<undefined>: Specify a white surface to start with
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
   metadata:
@@ -74,18 +74,18 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    out_white: generic/file
-    # type=file: Output white matter hemisphere surface
-    out_curv: generic/file
-    # type=file: Output curv file for MakeSurfaces
     out_area: generic/file
     # type=file: Output area file for MakeSurfaces
     out_cortex: generic/file
     # type=file: Output cortex file for MakeSurfaces
+    out_curv: generic/file
+    # type=file: Output curv file for MakeSurfaces
     out_pial: generic/file
     # type=file: Output pial surface for MakeSurfaces
     out_thickness: generic/file
     # type=file: Output thickness file for MakeSurfaces
+    out_white: generic/file
+    # type=file: Output white matter hemisphere surface
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/freesurfer/make_surfaces_callables.py b/example-specs/task/nipype/freesurfer/make_surfaces_callables.py
index 93ac50c0..ecddf133 100644
--- a/example-specs/task/nipype/freesurfer/make_surfaces_callables.py
+++ b/example-specs/task/nipype/freesurfer/make_surfaces_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in MakeSurfaces.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of MakeSurfaces.yaml"""
diff --git a/example-specs/task/nipype/freesurfer/mni_bias_correction.yaml b/example-specs/task/nipype/freesurfer/mni_bias_correction.yaml
index 664375cc..8b626ba6 100644
--- a/example-specs/task/nipype/freesurfer/mni_bias_correction.yaml
+++ b/example-specs/task/nipype/freesurfer/mni_bias_correction.yaml
@@ -50,13 +50,13 @@ inputs:
     # type=file|default=<undefined>: input volume. Input can be any format accepted by mri_convert.
     mask: generic/file
     # type=file|default=<undefined>: brainmask volume. Input can be any format accepted by mri_convert.
-    transform: generic/file
-    # type=file|default=<undefined>: tal.xfm. Use mri_make_uchar instead of conforming
-    subjects_dir: generic/directory
-    # type=directory|default=<undefined>: subjects directory
     out_file: Path
     # type=file: output volume
     # type=file|default=<undefined>: output volume. Output can be any format accepted by mri_convert. If the output format is COR, then the directory must exist.
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+    transform: generic/file
+    # type=file|default=<undefined>: tal.xfm. Use mri_make_uchar instead of conforming
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/mni_bias_correction_callables.py b/example-specs/task/nipype/freesurfer/mni_bias_correction_callables.py
index 536a2bea..ed299b8c 100644
--- a/example-specs/task/nipype/freesurfer/mni_bias_correction_callables.py
+++ b/example-specs/task/nipype/freesurfer/mni_bias_correction_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in MNIBiasCorrection.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of MNIBiasCorrection.yaml"""
diff --git a/example-specs/task/nipype/freesurfer/mp_rto_mni305.yaml b/example-specs/task/nipype/freesurfer/mp_rto_mni305.yaml
index a633c468..13b24260 100644
--- a/example-specs/task/nipype/freesurfer/mp_rto_mni305.yaml
+++ b/example-specs/task/nipype/freesurfer/mp_rto_mni305.yaml
@@ -59,10 +59,10 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    out_file: generic/file
-    # type=file: The output file '<in_file>_to_<target>_t4_vox2vox.txt'
     log_file: generic/file
     # type=file: The output log
+    out_file: generic/file
+    # type=file: The output file '<in_file>_to_<target>_t4_vox2vox.txt'
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/freesurfer/mp_rto_mni305_callables.py b/example-specs/task/nipype/freesurfer/mp_rto_mni305_callables.py
index c172ac42..f180eb22 100644
--- a/example-specs/task/nipype/freesurfer/mp_rto_mni305_callables.py
+++ b/example-specs/task/nipype/freesurfer/mp_rto_mni305_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in MPRtoMNI305.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of MPRtoMNI305.yaml"""
diff --git a/example-specs/task/nipype/freesurfer/mr_is_ca_label.yaml b/example-specs/task/nipype/freesurfer/mr_is_ca_label.yaml
index b2ded4c3..9b0930e4 100644
--- a/example-specs/task/nipype/freesurfer/mr_is_ca_label.yaml
+++ b/example-specs/task/nipype/freesurfer/mr_is_ca_label.yaml
@@ -44,25 +44,25 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    aseg: generic/file
+    # type=file|default=<undefined>: Undocumented flag. Autorecon3 uses ../mri/aseg.presurf.mgz as input file
     canonsurf: medimage-freesurfer/pial
     # type=file|default=<undefined>: Input canonical surface file
     classifier: medimage/nifti1
     # type=file|default=<undefined>: Classifier array input file
-    smoothwm: medimage-freesurfer/pial
-    # type=file|default=<undefined>: implicit input {hemisphere}.smoothwm
     curv: medimage-freesurfer/pial
     # type=file|default=<undefined>: implicit input {hemisphere}.curv
-    sulc: medimage-freesurfer/pial
-    # type=file|default=<undefined>: implicit input {hemisphere}.sulc
     label: generic/file
     # type=file|default=<undefined>: Undocumented flag. Autorecon3 uses ../label/{hemisphere}.cortex.label as input file
-    aseg: generic/file
-    # type=file|default=<undefined>: Undocumented flag. Autorecon3 uses ../mri/aseg.presurf.mgz as input file
-    subjects_dir: generic/directory
-    # type=directory|default=<undefined>: subjects directory
     out_file: Path
     # type=file: Output volume from MRIsCALabel
     # type=file|default=<undefined>: Annotated surface output file
+    smoothwm: medimage-freesurfer/pial
+    # type=file|default=<undefined>: implicit input {hemisphere}.smoothwm
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+    sulc: medimage-freesurfer/pial
+    # type=file|default=<undefined>: implicit input {hemisphere}.sulc
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/mr_is_ca_label_callables.py b/example-specs/task/nipype/freesurfer/mr_is_ca_label_callables.py
index 9e48dc34..aacca75c 100644
--- a/example-specs/task/nipype/freesurfer/mr_is_ca_label_callables.py
+++ b/example-specs/task/nipype/freesurfer/mr_is_ca_label_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in MRIsCALabel.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of MRIsCALabel.yaml"""
diff --git a/example-specs/task/nipype/freesurfer/mr_is_calc.yaml b/example-specs/task/nipype/freesurfer/mr_is_calc.yaml
index 567b9158..f3c7ec97 100644
--- a/example-specs/task/nipype/freesurfer/mr_is_calc.yaml
+++ b/example-specs/task/nipype/freesurfer/mr_is_calc.yaml
@@ -46,11 +46,11 @@ inputs:
     # type=file|default=<undefined>: Input file 1
     in_file2: medimage-freesurfer/pial
     # type=file|default=<undefined>: Input file 2
-    subjects_dir: generic/directory
-    # type=directory|default=<undefined>: subjects directory
     out_file: Path
     # type=file: Output file after calculation
     # type=file|default=<undefined>: Output file after calculation
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/mr_is_calc_callables.py b/example-specs/task/nipype/freesurfer/mr_is_calc_callables.py
index c062d99b..58765cbe 100644
--- a/example-specs/task/nipype/freesurfer/mr_is_calc_callables.py
+++ b/example-specs/task/nipype/freesurfer/mr_is_calc_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in MRIsCalc.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of MRIsCalc.yaml"""
diff --git a/example-specs/task/nipype/freesurfer/mr_is_combine.yaml b/example-specs/task/nipype/freesurfer/mr_is_combine.yaml
index 57db2ac6..ee0e71a6 100644
--- a/example-specs/task/nipype/freesurfer/mr_is_combine.yaml
+++ b/example-specs/task/nipype/freesurfer/mr_is_combine.yaml
@@ -45,11 +45,11 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_files: medimage-freesurfer/pial+list-of
     # type=list|default=[]: Two surfaces to be combined.
-    subjects_dir: generic/directory
-    # type=directory|default=<undefined>: subjects directory
     out_file: Path
     # type=file: Output filename. Combined surfaces from in_files.
     # type=file|default=<undefined>: Output filename. Combined surfaces from in_files.
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/mr_is_combine_callables.py b/example-specs/task/nipype/freesurfer/mr_is_combine_callables.py
index 67ed156f..c6b6d55a 100644
--- a/example-specs/task/nipype/freesurfer/mr_is_combine_callables.py
+++ b/example-specs/task/nipype/freesurfer/mr_is_combine_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in MRIsCombine.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of MRIsCombine.yaml"""
diff --git a/example-specs/task/nipype/freesurfer/mr_is_convert.yaml b/example-specs/task/nipype/freesurfer/mr_is_convert.yaml
index c6fb52ce..d7038b32 100644
--- a/example-specs/task/nipype/freesurfer/mr_is_convert.yaml
+++ b/example-specs/task/nipype/freesurfer/mr_is_convert.yaml
@@ -33,22 +33,22 @@ inputs:
   # passed to the field in the automatically generated unittests.
     annot_file: generic/file
     # type=file|default=<undefined>: input is annotation or gifti label data
-    parcstats_file: generic/file
-    # type=file|default=<undefined>: infile is name of text file containing label/val pairs
-    label_file: generic/file
-    # type=file|default=<undefined>: infile is .label file, label is name of this label
-    scalarcurv_file: generic/file
-    # type=file|default=<undefined>: input is scalar curv overlay file (must still specify surface)
     functional_file: generic/file
     # type=file|default=<undefined>: input is functional time-series or other multi-frame data (must specify surface)
-    labelstats_outfile: generic/file
-    # type=file|default=<undefined>: outfile is name of gifti file to which label stats will be written
     in_file: generic/file
     # type=file|default=<undefined>: File to read/convert
-    subjects_dir: generic/directory
-    # type=directory|default=<undefined>: subjects directory
+    label_file: generic/file
+    # type=file|default=<undefined>: infile is .label file, label is name of this label
+    labelstats_outfile: generic/file
+    # type=file|default=<undefined>: outfile is name of gifti file to which label stats will be written
     out_file: Path
     # type=file|default=<undefined>: output filename or True to generate one
+    parcstats_file: generic/file
+    # type=file|default=<undefined>: infile is name of text file containing label/val pairs
+    scalarcurv_file: generic/file
+    # type=file|default=<undefined>: input is scalar curv overlay file (must still specify surface)
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/mr_is_convert_callables.py b/example-specs/task/nipype/freesurfer/mr_is_convert_callables.py
index d185fca0..747f6050 100644
--- a/example-specs/task/nipype/freesurfer/mr_is_convert_callables.py
+++ b/example-specs/task/nipype/freesurfer/mr_is_convert_callables.py
@@ -1,8 +1,8 @@
-"""Module to put any functions that are referred to in MRIsConvert.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of MRIsConvert.yaml"""
 
+import attrs
 import os.path as op
 import os
-import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/freesurfer/mr_is_expand_callables.py b/example-specs/task/nipype/freesurfer/mr_is_expand_callables.py
index 82577871..3581af2c 100644
--- a/example-specs/task/nipype/freesurfer/mr_is_expand_callables.py
+++ b/example-specs/task/nipype/freesurfer/mr_is_expand_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in MRIsExpand.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of MRIsExpand.yaml"""
diff --git a/example-specs/task/nipype/freesurfer/mr_is_inflate.yaml b/example-specs/task/nipype/freesurfer/mr_is_inflate.yaml
index ae9a3f93..3bcbb4c3 100644
--- a/example-specs/task/nipype/freesurfer/mr_is_inflate.yaml
+++ b/example-specs/task/nipype/freesurfer/mr_is_inflate.yaml
@@ -33,14 +33,14 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage-freesurfer/pial
     # type=file|default=<undefined>: Input file for MRIsInflate
-    subjects_dir: generic/directory
-    # type=directory|default=<undefined>: subjects directory
     out_file: Path
     # type=file: Output file for MRIsInflate
     # type=file|default=<undefined>: Output file for MRIsInflate
     out_sulc: Path
     # type=file: Output sulc file
     # type=file|default=<undefined>: Output sulc file
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/mr_is_inflate_callables.py b/example-specs/task/nipype/freesurfer/mr_is_inflate_callables.py
index def395d3..76ee3f78 100644
--- a/example-specs/task/nipype/freesurfer/mr_is_inflate_callables.py
+++ b/example-specs/task/nipype/freesurfer/mr_is_inflate_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in MRIsInflate.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of MRIsInflate.yaml"""
diff --git a/example-specs/task/nipype/freesurfer/mri_convert.yaml b/example-specs/task/nipype/freesurfer/mri_convert.yaml
index 71333c7d..026942bb 100644
--- a/example-specs/task/nipype/freesurfer/mri_convert.yaml
+++ b/example-specs/task/nipype/freesurfer/mri_convert.yaml
@@ -35,29 +35,29 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    autoalign_matrix: generic/file
-    # type=file|default=<undefined>: text file with autoalign matrix
-    apply_transform: generic/file
-    # type=file|default=<undefined>: apply xfm file
     apply_inv_transform: generic/file
     # type=file|default=<undefined>: apply inverse transformation xfm file
+    apply_transform: generic/file
+    # type=file|default=<undefined>: apply xfm file
+    autoalign_matrix: generic/file
+    # type=file|default=<undefined>: text file with autoalign matrix
+    color_file: generic/file
+    # type=file|default=<undefined>: color file
     in_file: medimage/nifti1
     # type=file|default=<undefined>: File to read/convert
-    reslice_like: generic/file
-    # type=file|default=<undefined>: reslice output to match file
     in_like: generic/file
     # type=file|default=<undefined>: input looks like
-    color_file: generic/file
-    # type=file|default=<undefined>: color file
-    status_file: generic/file
-    # type=file|default=<undefined>: status file for DICOM conversion
+    out_file: Path
+    # type=outputmultiobject: converted output file
+    # type=file|default=<undefined>: output filename or True to generate one
+    reslice_like: generic/file
+    # type=file|default=<undefined>: reslice output to match file
     sdcm_list: generic/file
     # type=file|default=<undefined>: list of DICOM files for conversion
+    status_file: generic/file
+    # type=file|default=<undefined>: status file for DICOM conversion
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
-    out_file: Path
-    # type=outputmultiobject: converted output file
-    # type=file|default=<undefined>: output filename or True to generate one
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/mri_convert_callables.py b/example-specs/task/nipype/freesurfer/mri_convert_callables.py
index 70cdd1b7..e5e88940 100644
--- a/example-specs/task/nipype/freesurfer/mri_convert_callables.py
+++ b/example-specs/task/nipype/freesurfer/mri_convert_callables.py
@@ -1,9 +1,9 @@
-"""Module to put any functions that are referred to in MRIConvert.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of MRIConvert.yaml"""
 
-import os.path as op
-import os
 from pathlib import Path
 import attrs
+import os.path as op
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/freesurfer/mri_coreg.yaml b/example-specs/task/nipype/freesurfer/mri_coreg.yaml
index ae1fc16d..9abcc938 100644
--- a/example-specs/task/nipype/freesurfer/mri_coreg.yaml
+++ b/example-specs/task/nipype/freesurfer/mri_coreg.yaml
@@ -53,10 +53,10 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    source_file: medimage/nifti1
-    # type=file|default=<undefined>: source file to be registered
     reference_file: medimage/nifti1
     # type=file|default=<undefined>: reference (target) file
+    source_file: medimage/nifti1
+    # type=file|default=<undefined>: source file to be registered
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: FreeSurfer SUBJECTS_DIR
   metadata:
@@ -72,15 +72,15 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    out_reg_file: generic/file
-    # type=file: output registration file
-    # type=traitcompound|default=None: output registration file (REG format)
     out_lta_file: generic/file
     # type=file: output LTA-style registration file
     # type=traitcompound|default=True: output registration file (LTA format)
     out_params_file: generic/file
     # type=file: output parameters file
     # type=traitcompound|default=None: output parameters file
+    out_reg_file: generic/file
+    # type=file: output registration file
+    # type=traitcompound|default=None: output registration file (REG format)
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/freesurfer/mri_coreg_callables.py b/example-specs/task/nipype/freesurfer/mri_coreg_callables.py
index c570b237..8b951039 100644
--- a/example-specs/task/nipype/freesurfer/mri_coreg_callables.py
+++ b/example-specs/task/nipype/freesurfer/mri_coreg_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in MRICoreg.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of MRICoreg.yaml"""
diff --git a/example-specs/task/nipype/freesurfer/mri_fill.yaml b/example-specs/task/nipype/freesurfer/mri_fill.yaml
index 78ea995e..0cb8f88b 100644
--- a/example-specs/task/nipype/freesurfer/mri_fill.yaml
+++ b/example-specs/task/nipype/freesurfer/mri_fill.yaml
@@ -34,18 +34,18 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/mgh-gz
     # type=file|default=<undefined>: Input white matter file
+    log_file: Path
+    # type=file: Output log file from MRIFill
+    # type=file|default=<undefined>: Output log file for MRIFill
+    out_file: Path
+    # type=file: Output file from MRIFill
+    # type=file|default=<undefined>: Output filled volume file name for MRIFill
     segmentation: generic/file
     # type=file|default=<undefined>: Input segmentation file for MRIFill
-    transform: generic/file
-    # type=file|default=<undefined>: Input transform file for MRIFill
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
-    out_file: Path
-    # type=file: Output file from MRIFill
-    # type=file|default=<undefined>: Output filled volume file name for MRIFill
-    log_file: Path
-    # type=file: Output log file from MRIFill
-    # type=file|default=<undefined>: Output log file for MRIFill
+    transform: generic/file
+    # type=file|default=<undefined>: Input transform file for MRIFill
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -59,12 +59,12 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    out_file: medimage/mgh-gz
-    # type=file: Output file from MRIFill
-    # type=file|default=<undefined>: Output filled volume file name for MRIFill
     log_file: generic/file
     # type=file: Output log file from MRIFill
     # type=file|default=<undefined>: Output log file for MRIFill
+    out_file: medimage/mgh-gz
+    # type=file: Output file from MRIFill
+    # type=file|default=<undefined>: Output filled volume file name for MRIFill
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/freesurfer/mri_fill_callables.py b/example-specs/task/nipype/freesurfer/mri_fill_callables.py
index 82ff297c..6dc1c03b 100644
--- a/example-specs/task/nipype/freesurfer/mri_fill_callables.py
+++ b/example-specs/task/nipype/freesurfer/mri_fill_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in MRIFill.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of MRIFill.yaml"""
diff --git a/example-specs/task/nipype/freesurfer/mri_marching_cubes.yaml b/example-specs/task/nipype/freesurfer/mri_marching_cubes.yaml
index f0ce9ac5..40d9bd47 100644
--- a/example-specs/task/nipype/freesurfer/mri_marching_cubes.yaml
+++ b/example-specs/task/nipype/freesurfer/mri_marching_cubes.yaml
@@ -34,10 +34,10 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: generic/file
     # type=file|default=<undefined>: Input volume to tessellate voxels from.
-    subjects_dir: generic/directory
-    # type=directory|default=<undefined>: subjects directory
     out_file: Path
     # type=file|default=<undefined>: output filename or True to generate one
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/mri_marching_cubes_callables.py b/example-specs/task/nipype/freesurfer/mri_marching_cubes_callables.py
index d72c9c86..b5677d6a 100644
--- a/example-specs/task/nipype/freesurfer/mri_marching_cubes_callables.py
+++ b/example-specs/task/nipype/freesurfer/mri_marching_cubes_callables.py
@@ -1,8 +1,8 @@
-"""Module to put any functions that are referred to in MRIMarchingCubes.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of MRIMarchingCubes.yaml"""
 
+import attrs
 import os.path as op
 import os
-import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/freesurfer/mri_pretess.yaml b/example-specs/task/nipype/freesurfer/mri_pretess.yaml
index 24e34e60..f34b20a5 100644
--- a/example-specs/task/nipype/freesurfer/mri_pretess.yaml
+++ b/example-specs/task/nipype/freesurfer/mri_pretess.yaml
@@ -42,11 +42,11 @@ inputs:
     # type=file|default=<undefined>: filled volume, usually wm.mgz
     in_norm: medimage/mgh-gz
     # type=file|default=<undefined>: the normalized, brain-extracted T1w image. Usually norm.mgz
-    subjects_dir: generic/directory
-    # type=directory|default=<undefined>: subjects directory
     out_file: Path
     # type=file: output file after mri_pretess
     # type=file|default=<undefined>: the output file after mri_pretess.
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/mri_pretess_callables.py b/example-specs/task/nipype/freesurfer/mri_pretess_callables.py
index 9b47ea27..d1e58dd9 100644
--- a/example-specs/task/nipype/freesurfer/mri_pretess_callables.py
+++ b/example-specs/task/nipype/freesurfer/mri_pretess_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in MRIPretess.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of MRIPretess.yaml"""
diff --git a/example-specs/task/nipype/freesurfer/mri_tessellate.yaml b/example-specs/task/nipype/freesurfer/mri_tessellate.yaml
index b600ce19..b516a7f2 100644
--- a/example-specs/task/nipype/freesurfer/mri_tessellate.yaml
+++ b/example-specs/task/nipype/freesurfer/mri_tessellate.yaml
@@ -34,10 +34,10 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: generic/file
     # type=file|default=<undefined>: Input volume to tessellate voxels from.
-    subjects_dir: generic/directory
-    # type=directory|default=<undefined>: subjects directory
     out_file: Path
     # type=file|default=<undefined>: output filename or True to generate one
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/mri_tessellate_callables.py b/example-specs/task/nipype/freesurfer/mri_tessellate_callables.py
index d7c68fb4..6a660f7e 100644
--- a/example-specs/task/nipype/freesurfer/mri_tessellate_callables.py
+++ b/example-specs/task/nipype/freesurfer/mri_tessellate_callables.py
@@ -1,7 +1,7 @@
-"""Module to put any functions that are referred to in MRITessellate.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of MRITessellate.yaml"""
 
-import os.path as op
 import attrs
+import os.path as op
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/freesurfer/mris_preproc.yaml b/example-specs/task/nipype/freesurfer/mris_preproc.yaml
index f8c57e1d..fb7afc3a 100644
--- a/example-specs/task/nipype/freesurfer/mris_preproc.yaml
+++ b/example-specs/task/nipype/freesurfer/mris_preproc.yaml
@@ -35,15 +35,15 @@ inputs:
   # passed to the field in the automatically generated unittests.
     fsgd_file: generic/file
     # type=file|default=<undefined>: specify subjects using fsgd file
+    out_file: Path
+    # type=file: preprocessed output file
+    # type=file|default=<undefined>: output filename
     subject_file: generic/file
     # type=file|default=<undefined>: file specifying subjects separated by white space
-    surf_measure_file: generic/file+list-of
-    # type=inputmultiobject|default=[]: file alternative to surfmeas, still requires list of subjects
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
-    out_file: Path
-    # type=file: preprocessed output file
-    # type=file|default=<undefined>: output filename
+    surf_measure_file: generic/file+list-of
+    # type=inputmultiobject|default=[]: file alternative to surfmeas, still requires list of subjects
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/mris_preproc_callables.py b/example-specs/task/nipype/freesurfer/mris_preproc_callables.py
index 8e72acc6..cf78adf6 100644
--- a/example-specs/task/nipype/freesurfer/mris_preproc_callables.py
+++ b/example-specs/task/nipype/freesurfer/mris_preproc_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in MRISPreproc.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of MRISPreproc.yaml"""
diff --git a/example-specs/task/nipype/freesurfer/mris_preproc_recon_all.yaml b/example-specs/task/nipype/freesurfer/mris_preproc_recon_all.yaml
index 4e249c3d..dd26feb3 100644
--- a/example-specs/task/nipype/freesurfer/mris_preproc_recon_all.yaml
+++ b/example-specs/task/nipype/freesurfer/mris_preproc_recon_all.yaml
@@ -32,23 +32,23 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    surf_measure_file: generic/file
-    # type=file|default=<undefined>: file necessary for surfmeas
-    surfreg_files: generic/file+list-of
-    # type=inputmultiobject|default=[]: lh and rh input surface registration files
+    fsgd_file: generic/file
+    # type=file|default=<undefined>: specify subjects using fsgd file
     lh_surfreg_target: generic/file
     # type=file|default=<undefined>: Implicit target surface registration file
+    out_file: Path
+    # type=file: preprocessed output file
+    # type=file|default=<undefined>: output filename
     rh_surfreg_target: generic/file
     # type=file|default=<undefined>: Implicit target surface registration file
-    fsgd_file: generic/file
-    # type=file|default=<undefined>: specify subjects using fsgd file
     subject_file: generic/file
     # type=file|default=<undefined>: file specifying subjects separated by white space
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
-    out_file: Path
-    # type=file: preprocessed output file
-    # type=file|default=<undefined>: output filename
+    surf_measure_file: generic/file
+    # type=file|default=<undefined>: file necessary for surfmeas
+    surfreg_files: generic/file+list-of
+    # type=inputmultiobject|default=[]: lh and rh input surface registration files
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/mris_preproc_recon_all_callables.py b/example-specs/task/nipype/freesurfer/mris_preproc_recon_all_callables.py
index 08da982d..430e1ee9 100644
--- a/example-specs/task/nipype/freesurfer/mris_preproc_recon_all_callables.py
+++ b/example-specs/task/nipype/freesurfer/mris_preproc_recon_all_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in MRISPreprocReconAll.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of MRISPreprocReconAll.yaml"""
diff --git a/example-specs/task/nipype/freesurfer/mrtm.yaml b/example-specs/task/nipype/freesurfer/mrtm.yaml
index acb22a4d..a8a3b4d0 100644
--- a/example-specs/task/nipype/freesurfer/mrtm.yaml
+++ b/example-specs/task/nipype/freesurfer/mrtm.yaml
@@ -30,31 +30,31 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    in_file: medimage/nifti1
-    # type=file|default=<undefined>: input 4D file
-    design: generic/file
-    # type=file|default=<undefined>: design matrix file
     contrast: generic/file+list-of
     # type=inputmultiobject|default=[]: contrast file
-    per_voxel_reg: generic/file+list-of
-    # type=inputmultiobject|default=[]: per-voxel regressors
-    weighted_ls: generic/file
-    # type=file|default=<undefined>: weighted least squares
-    fixed_fx_var: generic/file
-    # type=file|default=<undefined>: for fixed effects analysis
+    design: generic/file
+    # type=file|default=<undefined>: design matrix file
     fixed_fx_dof_file: generic/file
     # type=file|default=<undefined>: text file with dof for fixed effects analysis
-    weight_file: generic/file
-    # type=file|default=<undefined>: weight for each input at each voxel
+    fixed_fx_var: generic/file
+    # type=file|default=<undefined>: for fixed effects analysis
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: input 4D file
     label_file: generic/file
     # type=file|default=<undefined>: use label as mask, surfaces only
+    mask_file: Path
+    # type=file: map of the mask used in the analysis
+    # type=file|default=<undefined>: binary mask
+    per_voxel_reg: generic/file+list-of
+    # type=inputmultiobject|default=[]: per-voxel regressors
     sim_done_file: generic/file
     # type=file|default=<undefined>: create file when simulation finished
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
-    mask_file: Path
-    # type=file: map of the mask used in the analysis
-    # type=file|default=<undefined>: binary mask
+    weight_file: generic/file
+    # type=file|default=<undefined>: weight for each input at each voxel
+    weighted_ls: generic/file
+    # type=file|default=<undefined>: weighted least squares
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -70,36 +70,36 @@ outputs:
   # passed to the field in the automatically generated unittests.
     beta_file: generic/file
     # type=file: map of regression coefficients
+    bp_file: generic/file
+    # type=file: Binding potential estimates
+    dof_file: generic/file
+    # type=file: text file with effective degrees-of-freedom for the analysis
     error_file: generic/file
     # type=file: map of residual error
-    error_var_file: generic/file
-    # type=file: map of residual error variance
     error_stddev_file: generic/file
     # type=file: map of residual error standard deviation
+    error_var_file: generic/file
+    # type=file: map of residual error variance
     estimate_file: generic/file
     # type=file: map of the estimated Y values
+    frame_eigenvectors: generic/file
+    # type=file: matrix of frame eigenvectors from residual PCA
+    fwhm_file: generic/file
+    # type=file: text file with estimated smoothness
+    glm_dir: generic/directory
+    # type=directory: output directory
+    # type=str|default='': save outputs to dir
+    k2p_file: generic/file
+    # type=file: estimate of k2p parameter
     mask_file: generic/file
     # type=file: map of the mask used in the analysis
     # type=file|default=<undefined>: binary mask
-    fwhm_file: generic/file
-    # type=file: text file with estimated smoothness
-    dof_file: generic/file
-    # type=file: text file with effective degrees-of-freedom for the analysis
-    spatial_eigenvectors: generic/file
-    # type=file: map of spatial eigenvectors from residual PCA
-    frame_eigenvectors: generic/file
-    # type=file: matrix of frame eigenvectors from residual PCA
     singular_values: generic/file
     # type=file: matrix singular values from residual PCA
+    spatial_eigenvectors: generic/file
+    # type=file: map of spatial eigenvectors from residual PCA
     svd_stats_file: generic/file
     # type=file: text file summarizing the residual PCA
-    k2p_file: generic/file
-    # type=file: estimate of k2p parameter
-    bp_file: generic/file
-    # type=file: Binding potential estimates
-    glm_dir: generic/directory
-    # type=directory: output directory
-    # type=str|default='': save outputs to dir
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/freesurfer/mrtm2.yaml b/example-specs/task/nipype/freesurfer/mrtm2.yaml
index 86072201..1e84f44f 100644
--- a/example-specs/task/nipype/freesurfer/mrtm2.yaml
+++ b/example-specs/task/nipype/freesurfer/mrtm2.yaml
@@ -29,31 +29,31 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    in_file: medimage/nifti1
-    # type=file|default=<undefined>: input 4D file
-    design: generic/file
-    # type=file|default=<undefined>: design matrix file
     contrast: generic/file+list-of
     # type=inputmultiobject|default=[]: contrast file
-    per_voxel_reg: generic/file+list-of
-    # type=inputmultiobject|default=[]: per-voxel regressors
-    weighted_ls: generic/file
-    # type=file|default=<undefined>: weighted least squares
-    fixed_fx_var: generic/file
-    # type=file|default=<undefined>: for fixed effects analysis
+    design: generic/file
+    # type=file|default=<undefined>: design matrix file
     fixed_fx_dof_file: generic/file
     # type=file|default=<undefined>: text file with dof for fixed effects analysis
-    weight_file: generic/file
-    # type=file|default=<undefined>: weight for each input at each voxel
+    fixed_fx_var: generic/file
+    # type=file|default=<undefined>: for fixed effects analysis
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: input 4D file
     label_file: generic/file
     # type=file|default=<undefined>: use label as mask, surfaces only
+    mask_file: Path
+    # type=file: map of the mask used in the analysis
+    # type=file|default=<undefined>: binary mask
+    per_voxel_reg: generic/file+list-of
+    # type=inputmultiobject|default=[]: per-voxel regressors
     sim_done_file: generic/file
     # type=file|default=<undefined>: create file when simulation finished
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
-    mask_file: Path
-    # type=file: map of the mask used in the analysis
-    # type=file|default=<undefined>: binary mask
+    weight_file: generic/file
+    # type=file|default=<undefined>: weight for each input at each voxel
+    weighted_ls: generic/file
+    # type=file|default=<undefined>: weighted least squares
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -69,36 +69,36 @@ outputs:
   # passed to the field in the automatically generated unittests.
     beta_file: generic/file
     # type=file: map of regression coefficients
+    bp_file: generic/file
+    # type=file: Binding potential estimates
+    dof_file: generic/file
+    # type=file: text file with effective degrees-of-freedom for the analysis
     error_file: generic/file
     # type=file: map of residual error
-    error_var_file: generic/file
-    # type=file: map of residual error variance
     error_stddev_file: generic/file
     # type=file: map of residual error standard deviation
+    error_var_file: generic/file
+    # type=file: map of residual error variance
     estimate_file: generic/file
     # type=file: map of the estimated Y values
+    frame_eigenvectors: generic/file
+    # type=file: matrix of frame eigenvectors from residual PCA
+    fwhm_file: generic/file
+    # type=file: text file with estimated smoothness
+    glm_dir: generic/directory
+    # type=directory: output directory
+    # type=str|default='': save outputs to dir
+    k2p_file: generic/file
+    # type=file: estimate of k2p parameter
     mask_file: generic/file
     # type=file: map of the mask used in the analysis
     # type=file|default=<undefined>: binary mask
-    fwhm_file: generic/file
-    # type=file: text file with estimated smoothness
-    dof_file: generic/file
-    # type=file: text file with effective degrees-of-freedom for the analysis
-    spatial_eigenvectors: generic/file
-    # type=file: map of spatial eigenvectors from residual PCA
-    frame_eigenvectors: generic/file
-    # type=file: matrix of frame eigenvectors from residual PCA
     singular_values: generic/file
     # type=file: matrix singular values from residual PCA
+    spatial_eigenvectors: generic/file
+    # type=file: map of spatial eigenvectors from residual PCA
     svd_stats_file: generic/file
     # type=file: text file summarizing the residual PCA
-    k2p_file: generic/file
-    # type=file: estimate of k2p parameter
-    bp_file: generic/file
-    # type=file: Binding potential estimates
-    glm_dir: generic/directory
-    # type=directory: output directory
-    # type=str|default='': save outputs to dir
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/freesurfer/mrtm2_callables.py b/example-specs/task/nipype/freesurfer/mrtm2_callables.py
index 20fb1266..929db38f 100644
--- a/example-specs/task/nipype/freesurfer/mrtm2_callables.py
+++ b/example-specs/task/nipype/freesurfer/mrtm2_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in MRTM2.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of MRTM2.yaml"""
diff --git a/example-specs/task/nipype/freesurfer/mrtm_callables.py b/example-specs/task/nipype/freesurfer/mrtm_callables.py
index 13bca71e..190f5610 100644
--- a/example-specs/task/nipype/freesurfer/mrtm_callables.py
+++ b/example-specs/task/nipype/freesurfer/mrtm_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in MRTM.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of MRTM.yaml"""
diff --git a/example-specs/task/nipype/freesurfer/ms__lda.yaml b/example-specs/task/nipype/freesurfer/ms__lda.yaml
index f1b1ecd4..5848ae13 100644
--- a/example-specs/task/nipype/freesurfer/ms__lda.yaml
+++ b/example-specs/task/nipype/freesurfer/ms__lda.yaml
@@ -31,20 +31,20 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    images: medimage/mgh-gz+list-of
+    # type=inputmultiobject|default=[]: list of input FLASH images
     label_file: medimage/mgh-gz
     # type=file|default=<undefined>: filename of the label volume
     mask_file: generic/file
     # type=file|default=<undefined>: filename of the brain mask volume
-    images: medimage/mgh-gz+list-of
-    # type=inputmultiobject|default=[]: list of input FLASH images
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
-    weight_file: Path
-    # type=file: 
-    # type=file|default=<undefined>: filename for the LDA weights (input or output)
     vol_synth_file: Path
     # type=file: 
     # type=file|default=<undefined>: filename for the synthesized output volume
+    weight_file: Path
+    # type=file: 
+    # type=file|default=<undefined>: filename for the LDA weights (input or output)
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -58,12 +58,12 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    weight_file: text/text-file
-    # type=file: 
-    # type=file|default=<undefined>: filename for the LDA weights (input or output)
     vol_synth_file: medimage/mgh-gz
     # type=file: 
     # type=file|default=<undefined>: filename for the synthesized output volume
+    weight_file: text/text-file
+    # type=file: 
+    # type=file|default=<undefined>: filename for the LDA weights (input or output)
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/freesurfer/ms__lda_callables.py b/example-specs/task/nipype/freesurfer/ms__lda_callables.py
index 22230ee1..ae275a53 100644
--- a/example-specs/task/nipype/freesurfer/ms__lda_callables.py
+++ b/example-specs/task/nipype/freesurfer/ms__lda_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in MS_LDA.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of MS_LDA.yaml"""
diff --git a/example-specs/task/nipype/freesurfer/normalize.yaml b/example-specs/task/nipype/freesurfer/normalize.yaml
index 190a68ad..ca908368 100644
--- a/example-specs/task/nipype/freesurfer/normalize.yaml
+++ b/example-specs/task/nipype/freesurfer/normalize.yaml
@@ -37,15 +37,15 @@ inputs:
     # type=file|default=<undefined>: The input file for Normalize
     mask: generic/file
     # type=file|default=<undefined>: The input mask file for Normalize
+    out_file: Path
+    # type=file: The output file for Normalize
+    # type=file|default=<undefined>: The output file for Normalize
     segmentation: generic/file
     # type=file|default=<undefined>: The input segmentation for Normalize
-    transform: generic/file
-    # type=file|default=<undefined>: Transform file from the header of the input file
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
-    out_file: Path
-    # type=file: The output file for Normalize
-    # type=file|default=<undefined>: The output file for Normalize
+    transform: generic/file
+    # type=file|default=<undefined>: Transform file from the header of the input file
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/normalize_callables.py b/example-specs/task/nipype/freesurfer/normalize_callables.py
index 795f3328..38d7c349 100644
--- a/example-specs/task/nipype/freesurfer/normalize_callables.py
+++ b/example-specs/task/nipype/freesurfer/normalize_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in Normalize.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of Normalize.yaml"""
diff --git a/example-specs/task/nipype/freesurfer/one_sample_t_test.yaml b/example-specs/task/nipype/freesurfer/one_sample_t_test.yaml
index 43ab0797..e313b817 100644
--- a/example-specs/task/nipype/freesurfer/one_sample_t_test.yaml
+++ b/example-specs/task/nipype/freesurfer/one_sample_t_test.yaml
@@ -20,31 +20,31 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    in_file: generic/file
-    # type=file|default=<undefined>: input 4D file
-    design: generic/file
-    # type=file|default=<undefined>: design matrix file
     contrast: generic/file+list-of
     # type=inputmultiobject|default=[]: contrast file
-    per_voxel_reg: generic/file+list-of
-    # type=inputmultiobject|default=[]: per-voxel regressors
-    weighted_ls: generic/file
-    # type=file|default=<undefined>: weighted least squares
-    fixed_fx_var: generic/file
-    # type=file|default=<undefined>: for fixed effects analysis
+    design: generic/file
+    # type=file|default=<undefined>: design matrix file
     fixed_fx_dof_file: generic/file
     # type=file|default=<undefined>: text file with dof for fixed effects analysis
-    weight_file: generic/file
-    # type=file|default=<undefined>: weight for each input at each voxel
+    fixed_fx_var: generic/file
+    # type=file|default=<undefined>: for fixed effects analysis
+    in_file: generic/file
+    # type=file|default=<undefined>: input 4D file
     label_file: generic/file
     # type=file|default=<undefined>: use label as mask, surfaces only
+    mask_file: Path
+    # type=file: map of the mask used in the analysis
+    # type=file|default=<undefined>: binary mask
+    per_voxel_reg: generic/file+list-of
+    # type=inputmultiobject|default=[]: per-voxel regressors
     sim_done_file: generic/file
     # type=file|default=<undefined>: create file when simulation finished
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
-    mask_file: Path
-    # type=file: map of the mask used in the analysis
-    # type=file|default=<undefined>: binary mask
+    weight_file: generic/file
+    # type=file|default=<undefined>: weight for each input at each voxel
+    weighted_ls: generic/file
+    # type=file|default=<undefined>: weighted least squares
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -60,36 +60,36 @@ outputs:
   # passed to the field in the automatically generated unittests.
     beta_file: generic/file
     # type=file: map of regression coefficients
+    bp_file: generic/file
+    # type=file: Binding potential estimates
+    dof_file: generic/file
+    # type=file: text file with effective degrees-of-freedom for the analysis
     error_file: generic/file
     # type=file: map of residual error
-    error_var_file: generic/file
-    # type=file: map of residual error variance
     error_stddev_file: generic/file
     # type=file: map of residual error standard deviation
+    error_var_file: generic/file
+    # type=file: map of residual error variance
     estimate_file: generic/file
     # type=file: map of the estimated Y values
+    frame_eigenvectors: generic/file
+    # type=file: matrix of frame eigenvectors from residual PCA
+    fwhm_file: generic/file
+    # type=file: text file with estimated smoothness
+    glm_dir: generic/directory
+    # type=directory: output directory
+    # type=str|default='': save outputs to dir
+    k2p_file: generic/file
+    # type=file: estimate of k2p parameter
     mask_file: generic/file
     # type=file: map of the mask used in the analysis
     # type=file|default=<undefined>: binary mask
-    fwhm_file: generic/file
-    # type=file: text file with estimated smoothness
-    dof_file: generic/file
-    # type=file: text file with effective degrees-of-freedom for the analysis
-    spatial_eigenvectors: generic/file
-    # type=file: map of spatial eigenvectors from residual PCA
-    frame_eigenvectors: generic/file
-    # type=file: matrix of frame eigenvectors from residual PCA
     singular_values: generic/file
     # type=file: matrix singular values from residual PCA
+    spatial_eigenvectors: generic/file
+    # type=file: map of spatial eigenvectors from residual PCA
     svd_stats_file: generic/file
     # type=file: text file summarizing the residual PCA
-    k2p_file: generic/file
-    # type=file: estimate of k2p parameter
-    bp_file: generic/file
-    # type=file: Binding potential estimates
-    glm_dir: generic/directory
-    # type=directory: output directory
-    # type=str|default='': save outputs to dir
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/freesurfer/one_sample_t_test_callables.py b/example-specs/task/nipype/freesurfer/one_sample_t_test_callables.py
index 327ad259..3c8dc1c7 100644
--- a/example-specs/task/nipype/freesurfer/one_sample_t_test_callables.py
+++ b/example-specs/task/nipype/freesurfer/one_sample_t_test_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in OneSampleTTest.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of OneSampleTTest.yaml"""
diff --git a/example-specs/task/nipype/freesurfer/paint.yaml b/example-specs/task/nipype/freesurfer/paint.yaml
index a5ff15a5..ab9c160a 100644
--- a/example-specs/task/nipype/freesurfer/paint.yaml
+++ b/example-specs/task/nipype/freesurfer/paint.yaml
@@ -39,13 +39,13 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_surf: medimage-freesurfer/pial
     # type=file|default=<undefined>: Surface file with grid (vertices) onto which the template data is to be sampled or 'painted'
-    template: medimage/mgh-gz
-    # type=file|default=<undefined>: Template file
-    subjects_dir: generic/directory
-    # type=directory|default=<undefined>: subjects directory
     out_file: Path
     # type=file: File containing a surface-worth of per-vertex values, saved in 'curvature' format.
     # type=file|default=<undefined>: File containing a surface-worth of per-vertex values, saved in 'curvature' format.
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+    template: medimage/mgh-gz
+    # type=file|default=<undefined>: Template file
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/paint_callables.py b/example-specs/task/nipype/freesurfer/paint_callables.py
index 93cce06e..f836bd38 100644
--- a/example-specs/task/nipype/freesurfer/paint_callables.py
+++ b/example-specs/task/nipype/freesurfer/paint_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in Paint.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of Paint.yaml"""
diff --git a/example-specs/task/nipype/freesurfer/parcellation_stats.yaml b/example-specs/task/nipype/freesurfer/parcellation_stats.yaml
index 2bd2b51f..327ff2cc 100644
--- a/example-specs/task/nipype/freesurfer/parcellation_stats.yaml
+++ b/example-specs/task/nipype/freesurfer/parcellation_stats.yaml
@@ -45,42 +45,42 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    wm: medimage/mgh-gz
-    # type=file|default=<undefined>: Input file must be <subject_id>/mri/wm.mgz
-    lh_white: medimage-freesurfer/white
-    # type=file|default=<undefined>: Input file must be <subject_id>/surf/lh.white
-    rh_white: medimage-freesurfer/white
-    # type=file|default=<undefined>: Input file must be <subject_id>/surf/rh.white
-    lh_pial: medimage-freesurfer/pial
-    # type=file|default=<undefined>: Input file must be <subject_id>/surf/lh.pial
-    rh_pial: medimage-freesurfer/pial
-    # type=file|default=<undefined>: Input file must be <subject_id>/surf/rh.pial
-    transform: medimage-freesurfer/xfm
-    # type=file|default=<undefined>: Input file must be <subject_id>/mri/transforms/talairach.xfm
-    thickness: medimage-freesurfer/thickness
-    # type=file|default=<undefined>: Input file must be <subject_id>/surf/?h.thickness
-    brainmask: medimage/mgh-gz
-    # type=file|default=<undefined>: Input file must be <subject_id>/mri/brainmask.mgz
     aseg: medimage/mgh-gz
     # type=file|default=<undefined>: Input file must be <subject_id>/mri/aseg.presurf.mgz
-    ribbon: medimage/mgh-gz
-    # type=file|default=<undefined>: Input file must be <subject_id>/mri/ribbon.mgz
+    brainmask: medimage/mgh-gz
+    # type=file|default=<undefined>: Input file must be <subject_id>/mri/brainmask.mgz
     cortex_label: generic/file
     # type=file|default=<undefined>: implicit input file {hemi}.cortex.label
-    in_cortex: generic/file
-    # type=file|default=<undefined>: Input cortex label
     in_annotation: generic/file
     # type=file|default=<undefined>: compute properties for each label in the annotation file separately
+    in_cortex: generic/file
+    # type=file|default=<undefined>: Input cortex label
     in_label: generic/file
     # type=file|default=<undefined>: limit calculations to specified label
-    subjects_dir: generic/directory
-    # type=directory|default=<undefined>: subjects directory
-    out_table: Path
-    # type=file: Table output to tablefile
-    # type=file|default=<undefined>: Table output to tablefile
+    lh_pial: medimage-freesurfer/pial
+    # type=file|default=<undefined>: Input file must be <subject_id>/surf/lh.pial
+    lh_white: medimage-freesurfer/white
+    # type=file|default=<undefined>: Input file must be <subject_id>/surf/lh.white
     out_color: Path
     # type=file: Output annotation files's colortable to text file
     # type=file|default=<undefined>: Output annotation files's colortable to text file
+    out_table: Path
+    # type=file: Table output to tablefile
+    # type=file|default=<undefined>: Table output to tablefile
+    rh_pial: medimage-freesurfer/pial
+    # type=file|default=<undefined>: Input file must be <subject_id>/surf/rh.pial
+    rh_white: medimage-freesurfer/white
+    # type=file|default=<undefined>: Input file must be <subject_id>/surf/rh.white
+    ribbon: medimage/mgh-gz
+    # type=file|default=<undefined>: Input file must be <subject_id>/mri/ribbon.mgz
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+    thickness: medimage-freesurfer/thickness
+    # type=file|default=<undefined>: Input file must be <subject_id>/surf/?h.thickness
+    transform: medimage-freesurfer/xfm
+    # type=file|default=<undefined>: Input file must be <subject_id>/mri/transforms/talairach.xfm
+    wm: medimage/mgh-gz
+    # type=file|default=<undefined>: Input file must be <subject_id>/mri/wm.mgz
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -94,23 +94,23 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    out_table: medimage-freesurfer/stats
-    # type=file: Table output to tablefile
-    # type=file|default=<undefined>: Table output to tablefile
     out_color: medimage-freesurfer/ctab
     # type=file: Output annotation files's colortable to text file
     # type=file|default=<undefined>: Output annotation files's colortable to text file
+    out_table: medimage-freesurfer/stats
+    # type=file: Table output to tablefile
+    # type=file|default=<undefined>: Table output to tablefile
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
   templates:
   # dict[str, str] - `output_file_template` values to be provided to output fields
-    out_table: '"lh.test.stats"'
-    # type=file: Table output to tablefile
-    # type=file|default=<undefined>: Table output to tablefile
     out_color: '"test.ctab"'
     # type=file: Output annotation files's colortable to text file
     # type=file|default=<undefined>: Output annotation files's colortable to text file
+    out_table: '"lh.test.stats"'
+    # type=file: Table output to tablefile
+    # type=file|default=<undefined>: Table output to tablefile
   requirements:
   # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
 tests:
diff --git a/example-specs/task/nipype/freesurfer/parcellation_stats_callables.py b/example-specs/task/nipype/freesurfer/parcellation_stats_callables.py
index af32d119..d20ea541 100644
--- a/example-specs/task/nipype/freesurfer/parcellation_stats_callables.py
+++ b/example-specs/task/nipype/freesurfer/parcellation_stats_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in ParcellationStats.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of ParcellationStats.yaml"""
diff --git a/example-specs/task/nipype/freesurfer/parse_dicom_dir.yaml b/example-specs/task/nipype/freesurfer/parse_dicom_dir.yaml
index cf652ef6..306e22e1 100644
--- a/example-specs/task/nipype/freesurfer/parse_dicom_dir.yaml
+++ b/example-specs/task/nipype/freesurfer/parse_dicom_dir.yaml
@@ -35,11 +35,11 @@ inputs:
   # passed to the field in the automatically generated unittests.
     dicom_dir: generic/directory
     # type=directory|default=<undefined>: path to siemens dicom directory
-    subjects_dir: generic/directory
-    # type=directory|default=<undefined>: subjects directory
     dicom_info_file: Path
     # type=file: text file containing dicom information
     # type=file|default='dicominfo.txt': file to which results are written
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/parse_dicom_dir_callables.py b/example-specs/task/nipype/freesurfer/parse_dicom_dir_callables.py
index dfe9a498..65467f64 100644
--- a/example-specs/task/nipype/freesurfer/parse_dicom_dir_callables.py
+++ b/example-specs/task/nipype/freesurfer/parse_dicom_dir_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in ParseDICOMDir.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of ParseDICOMDir.yaml"""
diff --git a/example-specs/task/nipype/freesurfer/recon_all.yaml b/example-specs/task/nipype/freesurfer/recon_all.yaml
index 26b0c107..af49e9cc 100644
--- a/example-specs/task/nipype/freesurfer/recon_all.yaml
+++ b/example-specs/task/nipype/freesurfer/recon_all.yaml
@@ -72,12 +72,12 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    FLAIR_file: generic/file
+    # type=file|default=<undefined>: Convert FLAIR image to orig directory
     T1_files: medimage/nifti1+list-of
     # type=inputmultiobject|default=[]: name of T1 file to process
     T2_file: generic/file
     # type=file|default=<undefined>: Convert T2 image to orig directory
-    FLAIR_file: generic/file
-    # type=file|default=<undefined>: Convert FLAIR image to orig directory
     expert: generic/file
     # type=file|default=<undefined>: Set parameters using expert file
     subjects_dir: Path
@@ -114,13 +114,13 @@ outputs:
     # type=file: Base image conformed to Freesurfer space
     rawavg: generic/file
     # type=file: Volume formed by averaging input images
+    subjects_dir: generic/directory
+    # type=directory: Freesurfer subjects directory.
+    # type=directory|default=<undefined>: path to subjects directory
     wm: generic/file
     # type=file: Segmented white-matter volume
     wmparc: generic/file
     # type=file: Aparc parcellation projected into subcortical white matter
-    subjects_dir: generic/directory
-    # type=directory: Freesurfer subjects directory.
-    # type=directory|default=<undefined>: path to subjects directory
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/freesurfer/recon_all_callables.py b/example-specs/task/nipype/freesurfer/recon_all_callables.py
index f2ff9955..a67a91e3 100644
--- a/example-specs/task/nipype/freesurfer/recon_all_callables.py
+++ b/example-specs/task/nipype/freesurfer/recon_all_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in ReconAll.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of ReconAll.yaml"""
diff --git a/example-specs/task/nipype/freesurfer/register.yaml b/example-specs/task/nipype/freesurfer/register.yaml
index 8e4e3880..5ceda4f7 100644
--- a/example-specs/task/nipype/freesurfer/register.yaml
+++ b/example-specs/task/nipype/freesurfer/register.yaml
@@ -34,19 +34,19 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    in_surf: medimage-freesurfer/pial
-    # type=file|default=<undefined>: Surface to register, often {hemi}.sphere
-    target: medimage/mgh-gz
-    # type=file|default=<undefined>: The data to register to. In normal recon-all usage, this is a template file for average surface.
-    in_sulc: medimage-freesurfer/pial
-    # type=file|default=<undefined>: Undocumented mandatory input file ${SUBJECTS_DIR}/surf/{hemisphere}.sulc 
     in_smoothwm: medimage-freesurfer/pial
     # type=file|default=<undefined>: Undocumented input file ${SUBJECTS_DIR}/surf/{hemisphere}.smoothwm 
-    subjects_dir: generic/directory
-    # type=directory|default=<undefined>: subjects directory
+    in_sulc: medimage-freesurfer/pial
+    # type=file|default=<undefined>: Undocumented mandatory input file ${SUBJECTS_DIR}/surf/{hemisphere}.sulc 
+    in_surf: medimage-freesurfer/pial
+    # type=file|default=<undefined>: Surface to register, often {hemi}.sphere
     out_file: Path
     # type=file: Output surface file to capture registration
     # type=file|default=<undefined>: Output surface file to capture registration
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+    target: medimage/mgh-gz
+    # type=file|default=<undefined>: The data to register to. In normal recon-all usage, this is a template file for average surface.
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/register_av_ito_talairach.yaml b/example-specs/task/nipype/freesurfer/register_av_ito_talairach.yaml
index c82866b6..15c2d982 100644
--- a/example-specs/task/nipype/freesurfer/register_av_ito_talairach.yaml
+++ b/example-specs/task/nipype/freesurfer/register_av_ito_talairach.yaml
@@ -46,15 +46,15 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/mgh-gz
     # type=file|default=<undefined>: The input file
+    out_file: Path
+    # type=file: The output file for RegisterAVItoTalairach
+    # type=file|default='talairach.auto.xfm': The transform output
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
     target: medimage/mgh-gz
     # type=file|default=<undefined>: The target file
     vox2vox: text/text-file
     # type=file|default=<undefined>: The vox2vox file
-    subjects_dir: generic/directory
-    # type=directory|default=<undefined>: subjects directory
-    out_file: Path
-    # type=file: The output file for RegisterAVItoTalairach
-    # type=file|default='talairach.auto.xfm': The transform output
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -68,11 +68,11 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    log_file: generic/file
+    # type=file: The output log
     out_file: generic/file
     # type=file: The output file for RegisterAVItoTalairach
     # type=file|default='talairach.auto.xfm': The transform output
-    log_file: generic/file
-    # type=file: The output log
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/freesurfer/register_av_ito_talairach_callables.py b/example-specs/task/nipype/freesurfer/register_av_ito_talairach_callables.py
index a968a895..72e18eb6 100644
--- a/example-specs/task/nipype/freesurfer/register_av_ito_talairach_callables.py
+++ b/example-specs/task/nipype/freesurfer/register_av_ito_talairach_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in RegisterAVItoTalairach.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of RegisterAVItoTalairach.yaml"""
diff --git a/example-specs/task/nipype/freesurfer/register_callables.py b/example-specs/task/nipype/freesurfer/register_callables.py
index 8dc066af..5acaa15e 100644
--- a/example-specs/task/nipype/freesurfer/register_callables.py
+++ b/example-specs/task/nipype/freesurfer/register_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in Register.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of Register.yaml"""
diff --git a/example-specs/task/nipype/freesurfer/relabel_hypointensities.yaml b/example-specs/task/nipype/freesurfer/relabel_hypointensities.yaml
index 0f7bca76..c3fef856 100644
--- a/example-specs/task/nipype/freesurfer/relabel_hypointensities.yaml
+++ b/example-specs/task/nipype/freesurfer/relabel_hypointensities.yaml
@@ -33,19 +33,19 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    aseg: medimage/mgh-gz
+    # type=file|default=<undefined>: Input aseg file
     lh_white: medimage-freesurfer/pial
     # type=file|default=<undefined>: Implicit input file must be lh.white
+    out_file: Path
+    # type=file: Output aseg file
+    # type=file|default=<undefined>: Output aseg file
     rh_white: medimage-freesurfer/pial
     # type=file|default=<undefined>: Implicit input file must be rh.white
-    aseg: medimage/mgh-gz
-    # type=file|default=<undefined>: Input aseg file
-    surf_directory: generic/directory
-    # type=directory|default='.': Directory containing lh.white and rh.white
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
-    out_file: Path
-    # type=file: Output aseg file
-    # type=file|default=<undefined>: Output aseg file
+    surf_directory: generic/directory
+    # type=directory|default='.': Directory containing lh.white and rh.white
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/relabel_hypointensities_callables.py b/example-specs/task/nipype/freesurfer/relabel_hypointensities_callables.py
index 5f614cc2..1d61dce8 100644
--- a/example-specs/task/nipype/freesurfer/relabel_hypointensities_callables.py
+++ b/example-specs/task/nipype/freesurfer/relabel_hypointensities_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in RelabelHypointensities.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of RelabelHypointensities.yaml"""
diff --git a/example-specs/task/nipype/freesurfer/remove_intersection.yaml b/example-specs/task/nipype/freesurfer/remove_intersection.yaml
index 086bbaf5..a0760ca5 100644
--- a/example-specs/task/nipype/freesurfer/remove_intersection.yaml
+++ b/example-specs/task/nipype/freesurfer/remove_intersection.yaml
@@ -32,11 +32,11 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage-freesurfer/pial
     # type=file|default=<undefined>: Input file for RemoveIntersection
-    subjects_dir: generic/directory
-    # type=directory|default=<undefined>: subjects directory
     out_file: Path
     # type=file: Output file for RemoveIntersection
     # type=file|default=<undefined>: Output file for RemoveIntersection
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/remove_intersection_callables.py b/example-specs/task/nipype/freesurfer/remove_intersection_callables.py
index 63d3b957..50dc2b82 100644
--- a/example-specs/task/nipype/freesurfer/remove_intersection_callables.py
+++ b/example-specs/task/nipype/freesurfer/remove_intersection_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in RemoveIntersection.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of RemoveIntersection.yaml"""
diff --git a/example-specs/task/nipype/freesurfer/remove_neck.yaml b/example-specs/task/nipype/freesurfer/remove_neck.yaml
index 1ee1c5e9..28708b7f 100644
--- a/example-specs/task/nipype/freesurfer/remove_neck.yaml
+++ b/example-specs/task/nipype/freesurfer/remove_neck.yaml
@@ -35,15 +35,15 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/mgh-gz
     # type=file|default=<undefined>: Input file for RemoveNeck
-    transform: datascience/text-matrix
-    # type=file|default=<undefined>: Input transform file for RemoveNeck
-    template: datascience/text-matrix
-    # type=file|default=<undefined>: Input template file for RemoveNeck
-    subjects_dir: generic/directory
-    # type=directory|default=<undefined>: subjects directory
     out_file: Path
     # type=file: Output file with neck removed
     # type=file|default=<undefined>: Output file for RemoveNeck
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+    template: datascience/text-matrix
+    # type=file|default=<undefined>: Input template file for RemoveNeck
+    transform: datascience/text-matrix
+    # type=file|default=<undefined>: Input transform file for RemoveNeck
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/remove_neck_callables.py b/example-specs/task/nipype/freesurfer/remove_neck_callables.py
index 899991aa..4ea5176e 100644
--- a/example-specs/task/nipype/freesurfer/remove_neck_callables.py
+++ b/example-specs/task/nipype/freesurfer/remove_neck_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in RemoveNeck.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of RemoveNeck.yaml"""
diff --git a/example-specs/task/nipype/freesurfer/resample.yaml b/example-specs/task/nipype/freesurfer/resample.yaml
index abbd0489..4976c93c 100644
--- a/example-specs/task/nipype/freesurfer/resample.yaml
+++ b/example-specs/task/nipype/freesurfer/resample.yaml
@@ -35,11 +35,11 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/nifti1
     # type=file|default=<undefined>: file to resample
-    subjects_dir: generic/directory
-    # type=directory|default=<undefined>: subjects directory
     resampled_file: Path
     # type=file: output filename
     # type=file|default=<undefined>: output filename
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/resample_callables.py b/example-specs/task/nipype/freesurfer/resample_callables.py
index 1e012806..d6f33aaa 100644
--- a/example-specs/task/nipype/freesurfer/resample_callables.py
+++ b/example-specs/task/nipype/freesurfer/resample_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in Resample.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of Resample.yaml"""
diff --git a/example-specs/task/nipype/freesurfer/robust_register.yaml b/example-specs/task/nipype/freesurfer/robust_register.yaml
index 9b7637dc..2e68f678 100644
--- a/example-specs/task/nipype/freesurfer/robust_register.yaml
+++ b/example-specs/task/nipype/freesurfer/robust_register.yaml
@@ -39,18 +39,18 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    source_file: medimage/nifti1
-    # type=file|default=<undefined>: volume to be registered
-    target_file: medimage/nifti1
-    # type=file|default=<undefined>: target volume for the registration
     in_xfm_file: generic/file
     # type=file|default=<undefined>: use initial transform on source
     mask_source: generic/file
     # type=file|default=<undefined>: image to mask source volume with
     mask_target: generic/file
     # type=file|default=<undefined>: image to mask target volume with
+    source_file: medimage/nifti1
+    # type=file|default=<undefined>: volume to be registered
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+    target_file: medimage/nifti1
+    # type=file|default=<undefined>: target volume for the registration
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -64,30 +64,30 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    out_reg_file: generic/file
-    # type=file: output registration file
-    # type=traitcompound|default=True: registration file; either True or filename
-    registered_file: generic/file
-    # type=file: output image with registration applied
-    # type=traitcompound|default=None: registered image; either True or filename
-    weights_file: generic/file
-    # type=file: image of weights used
-    # type=traitcompound|default=None: weights image to write; either True or filename
     half_source: generic/file
     # type=file: source image mapped to halfway space
     # type=traitcompound|default=None: write source volume mapped to halfway space
-    half_targ: generic/file
-    # type=file: target image mapped to halfway space
-    # type=traitcompound|default=None: write target volume mapped to halfway space
-    half_weights: generic/file
-    # type=file: weights image mapped to halfway space
-    # type=traitcompound|default=None: write weights volume mapped to halfway space
     half_source_xfm: generic/file
     # type=file: transform file to map source image to halfway space
     # type=traitcompound|default=None: write transform from source to halfway space
+    half_targ: generic/file
+    # type=file: target image mapped to halfway space
+    # type=traitcompound|default=None: write target volume mapped to halfway space
     half_targ_xfm: generic/file
     # type=file: transform file to map target image to halfway space
     # type=traitcompound|default=None: write transform from target to halfway space
+    half_weights: generic/file
+    # type=file: weights image mapped to halfway space
+    # type=traitcompound|default=None: write weights volume mapped to halfway space
+    out_reg_file: generic/file
+    # type=file: output registration file
+    # type=traitcompound|default=True: registration file; either True or filename
+    registered_file: generic/file
+    # type=file: output image with registration applied
+    # type=traitcompound|default=None: registered image; either True or filename
+    weights_file: generic/file
+    # type=file: image of weights used
+    # type=traitcompound|default=None: weights image to write; either True or filename
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/freesurfer/robust_register_callables.py b/example-specs/task/nipype/freesurfer/robust_register_callables.py
index c9447444..d8f48bf5 100644
--- a/example-specs/task/nipype/freesurfer/robust_register_callables.py
+++ b/example-specs/task/nipype/freesurfer/robust_register_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in RobustRegister.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of RobustRegister.yaml"""
diff --git a/example-specs/task/nipype/freesurfer/robust_template.yaml b/example-specs/task/nipype/freesurfer/robust_template.yaml
index dad1fa46..2944a5e2 100644
--- a/example-specs/task/nipype/freesurfer/robust_template.yaml
+++ b/example-specs/task/nipype/freesurfer/robust_template.yaml
@@ -59,15 +59,15 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_files: medimage/nifti1+list-of
     # type=inputmultiobject|default=[]: input movable volumes to be aligned to common mean/median template
-    initial_transforms: generic/file+list-of
-    # type=inputmultiobject|default=[]: use initial transforms (lta) on source
     in_intensity_scales: generic/file+list-of
     # type=inputmultiobject|default=[]: use initial intensity scales
-    subjects_dir: generic/directory
-    # type=directory|default=<undefined>: subjects directory
+    initial_transforms: generic/file+list-of
+    # type=inputmultiobject|default=[]: use initial transforms (lta) on source
     out_file: Path
     # type=file: output template volume (final mean/median image)
     # type=file|default='mri_robust_template_out.mgz': output template volume (final mean/median image)
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/robust_template_callables.py b/example-specs/task/nipype/freesurfer/robust_template_callables.py
index 4991aa92..1aa8753c 100644
--- a/example-specs/task/nipype/freesurfer/robust_template_callables.py
+++ b/example-specs/task/nipype/freesurfer/robust_template_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in RobustTemplate.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of RobustTemplate.yaml"""
diff --git a/example-specs/task/nipype/freesurfer/sample_to_surface.yaml b/example-specs/task/nipype/freesurfer/sample_to_surface.yaml
index ba0676ce..41dbc3d0 100644
--- a/example-specs/task/nipype/freesurfer/sample_to_surface.yaml
+++ b/example-specs/task/nipype/freesurfer/sample_to_surface.yaml
@@ -48,19 +48,19 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    source_file: medimage/nifti-gz
-    # type=file|default=<undefined>: volume to sample values from
+    mask_label: generic/file
+    # type=file|default=<undefined>: label file to mask output with
+    out_file: Path
+    # type=file: surface file
+    # type=file|default=<undefined>: surface file to write
     reference_file: generic/file
     # type=file|default=<undefined>: reference volume (default is orig.mgz)
     reg_file: datascience/dat-file
     # type=file|default=<undefined>: source-to-reference registration file
-    mask_label: generic/file
-    # type=file|default=<undefined>: label file to mask output with
+    source_file: medimage/nifti-gz
+    # type=file|default=<undefined>: volume to sample values from
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
-    out_file: Path
-    # type=file: surface file
-    # type=file|default=<undefined>: surface file to write
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -74,12 +74,12 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    out_file: generic/file
-    # type=file: surface file
-    # type=file|default=<undefined>: surface file to write
     hits_file: generic/file
     # type=file: image with number of hits at each voxel
     # type=traitcompound|default=None: save image with number of hits at each voxel
+    out_file: generic/file
+    # type=file: surface file
+    # type=file|default=<undefined>: surface file to write
     vox_file: generic/file
     # type=file: text file with the number of voxels intersecting the surface
     # type=traitcompound|default=None: text file with the number of voxels intersecting the surface
diff --git a/example-specs/task/nipype/freesurfer/sample_to_surface_callables.py b/example-specs/task/nipype/freesurfer/sample_to_surface_callables.py
index 540762f7..a675706f 100644
--- a/example-specs/task/nipype/freesurfer/sample_to_surface_callables.py
+++ b/example-specs/task/nipype/freesurfer/sample_to_surface_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in SampleToSurface.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of SampleToSurface.yaml"""
diff --git a/example-specs/task/nipype/freesurfer/seg_stats.yaml b/example-specs/task/nipype/freesurfer/seg_stats.yaml
index 69e6c2e1..072d3f8f 100644
--- a/example-specs/task/nipype/freesurfer/seg_stats.yaml
+++ b/example-specs/task/nipype/freesurfer/seg_stats.yaml
@@ -34,22 +34,22 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    segmentation_file: generic/file
-    # type=file|default=<undefined>: segmentation volume path
-    partial_volume_file: generic/file
-    # type=file|default=<undefined>: Compensate for partial voluming
-    in_file: medimage/nifti1
-    # type=file|default=<undefined>: Use the segmentation to report stats on this volume
+    brainmask_file: generic/file
+    # type=file|default=<undefined>: Load brain mask and compute the volume of the brain as the non-zero voxels in this volume
     color_table_file: generic/file
     # type=file|default=<undefined>: color table file with seg id names
     gca_color_table: generic/file
     # type=file|default=<undefined>: get color table from GCA (CMA)
-    mask_file: generic/file
-    # type=file|default=<undefined>: Mask volume (same size as seg
-    brainmask_file: generic/file
-    # type=file|default=<undefined>: Load brain mask and compute the volume of the brain as the non-zero voxels in this volume
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: Use the segmentation to report stats on this volume
     in_intensity: generic/file
     # type=file|default=<undefined>: Undocumented input norm.mgz file
+    mask_file: generic/file
+    # type=file|default=<undefined>: Mask volume (same size as seg
+    partial_volume_file: generic/file
+    # type=file|default=<undefined>: Compensate for partial voluming
+    segmentation_file: generic/file
+    # type=file|default=<undefined>: segmentation volume path
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
     summary_file: Path
@@ -68,18 +68,18 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    summary_file: medimage-freesurfer/stats
-    # type=file: Segmentation summary statistics table
-    # type=file|default=<undefined>: Segmentation stats summary table file
-    avgwf_txt_file: text/text-file
-    # type=file: Text file with functional statistics averaged over segs
-    # type=traitcompound|default=None: Save average waveform into file (bool or filename)
     avgwf_file: generic/file
     # type=file: Volume with functional statistics averaged over segs
     # type=traitcompound|default=None: Save as binary volume (bool or filename)
+    avgwf_txt_file: text/text-file
+    # type=file: Text file with functional statistics averaged over segs
+    # type=traitcompound|default=None: Save average waveform into file (bool or filename)
     sf_avg_file: generic/file
     # type=file: Text file with func statistics averaged over segs and framss
     # type=traitcompound|default=None: Save mean across space and time
+    summary_file: medimage-freesurfer/stats
+    # type=file: Segmentation summary statistics table
+    # type=file|default=<undefined>: Segmentation stats summary table file
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/freesurfer/seg_stats_callables.py b/example-specs/task/nipype/freesurfer/seg_stats_callables.py
index 3bb4af02..5ee4b4e0 100644
--- a/example-specs/task/nipype/freesurfer/seg_stats_callables.py
+++ b/example-specs/task/nipype/freesurfer/seg_stats_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in SegStats.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of SegStats.yaml"""
diff --git a/example-specs/task/nipype/freesurfer/seg_stats_recon_all.yaml b/example-specs/task/nipype/freesurfer/seg_stats_recon_all.yaml
index 327abb73..a21e3add 100644
--- a/example-specs/task/nipype/freesurfer/seg_stats_recon_all.yaml
+++ b/example-specs/task/nipype/freesurfer/seg_stats_recon_all.yaml
@@ -56,47 +56,47 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    ribbon: medimage/mgh-gz
-    # type=file|default=<undefined>: Input file mri/ribbon.mgz
-    presurf_seg: medimage/mgh-gz
-    # type=file|default=<undefined>: Input segmentation volume
-    transform: datascience/text-matrix
-    # type=file|default=<undefined>: Input transform file
-    lh_orig_nofix: medimage-freesurfer/pial
-    # type=file|default=<undefined>: Input lh.orig.nofix
-    rh_orig_nofix: medimage-freesurfer/pial
-    # type=file|default=<undefined>: Input rh.orig.nofix
-    lh_white: medimage-freesurfer/pial
-    # type=file|default=<undefined>: Input file must be <subject_id>/surf/lh.white
-    rh_white: medimage-freesurfer/pial
-    # type=file|default=<undefined>: Input file must be <subject_id>/surf/rh.white
-    lh_pial: medimage-freesurfer/pial
-    # type=file|default=<undefined>: Input file must be <subject_id>/surf/lh.pial
-    rh_pial: medimage-freesurfer/pial
-    # type=file|default=<undefined>: Input file must be <subject_id>/surf/rh.pial
     aseg: generic/file
     # type=file|default=<undefined>: Mandatory implicit input in 5.3
-    segmentation_file: generic/file
-    # type=file|default=<undefined>: segmentation volume path
-    partial_volume_file: generic/file
-    # type=file|default=<undefined>: Compensate for partial voluming
-    in_file: generic/file
-    # type=file|default=<undefined>: Use the segmentation to report stats on this volume
+    brainmask_file: generic/file
+    # type=file|default=<undefined>: Load brain mask and compute the volume of the brain as the non-zero voxels in this volume
     color_table_file: generic/file
     # type=file|default=<undefined>: color table file with seg id names
     gca_color_table: generic/file
     # type=file|default=<undefined>: get color table from GCA (CMA)
-    mask_file: generic/file
-    # type=file|default=<undefined>: Mask volume (same size as seg
-    brainmask_file: generic/file
-    # type=file|default=<undefined>: Load brain mask and compute the volume of the brain as the non-zero voxels in this volume
+    in_file: generic/file
+    # type=file|default=<undefined>: Use the segmentation to report stats on this volume
     in_intensity: generic/file
     # type=file|default=<undefined>: Undocumented input norm.mgz file
+    lh_orig_nofix: medimage-freesurfer/pial
+    # type=file|default=<undefined>: Input lh.orig.nofix
+    lh_pial: medimage-freesurfer/pial
+    # type=file|default=<undefined>: Input file must be <subject_id>/surf/lh.pial
+    lh_white: medimage-freesurfer/pial
+    # type=file|default=<undefined>: Input file must be <subject_id>/surf/lh.white
+    mask_file: generic/file
+    # type=file|default=<undefined>: Mask volume (same size as seg
+    partial_volume_file: generic/file
+    # type=file|default=<undefined>: Compensate for partial voluming
+    presurf_seg: medimage/mgh-gz
+    # type=file|default=<undefined>: Input segmentation volume
+    rh_orig_nofix: medimage-freesurfer/pial
+    # type=file|default=<undefined>: Input rh.orig.nofix
+    rh_pial: medimage-freesurfer/pial
+    # type=file|default=<undefined>: Input file must be <subject_id>/surf/rh.pial
+    rh_white: medimage-freesurfer/pial
+    # type=file|default=<undefined>: Input file must be <subject_id>/surf/rh.white
+    ribbon: medimage/mgh-gz
+    # type=file|default=<undefined>: Input file mri/ribbon.mgz
+    segmentation_file: generic/file
+    # type=file|default=<undefined>: segmentation volume path
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
     summary_file: Path
     # type=file: Segmentation summary statistics table
     # type=file|default=<undefined>: Segmentation stats summary table file
+    transform: datascience/text-matrix
+    # type=file|default=<undefined>: Input transform file
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -110,18 +110,18 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    summary_file: medimage-freesurfer/stats
-    # type=file: Segmentation summary statistics table
-    # type=file|default=<undefined>: Segmentation stats summary table file
-    avgwf_txt_file: text/text-file
-    # type=file: Text file with functional statistics averaged over segs
-    # type=traitcompound|default=None: Save average waveform into file (bool or filename)
     avgwf_file: generic/file
     # type=file: Volume with functional statistics averaged over segs
     # type=traitcompound|default=None: Save as binary volume (bool or filename)
+    avgwf_txt_file: text/text-file
+    # type=file: Text file with functional statistics averaged over segs
+    # type=traitcompound|default=None: Save average waveform into file (bool or filename)
     sf_avg_file: generic/file
     # type=file: Text file with func statistics averaged over segs and framss
     # type=traitcompound|default=None: Save mean across space and time
+    summary_file: medimage-freesurfer/stats
+    # type=file: Segmentation summary statistics table
+    # type=file|default=<undefined>: Segmentation stats summary table file
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/freesurfer/seg_stats_recon_all_callables.py b/example-specs/task/nipype/freesurfer/seg_stats_recon_all_callables.py
index 7c5925a0..17259997 100644
--- a/example-specs/task/nipype/freesurfer/seg_stats_recon_all_callables.py
+++ b/example-specs/task/nipype/freesurfer/seg_stats_recon_all_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in SegStatsReconAll.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of SegStatsReconAll.yaml"""
diff --git a/example-specs/task/nipype/freesurfer/segment_cc.yaml b/example-specs/task/nipype/freesurfer/segment_cc.yaml
index 7dfa967d..32da9287 100644
--- a/example-specs/task/nipype/freesurfer/segment_cc.yaml
+++ b/example-specs/task/nipype/freesurfer/segment_cc.yaml
@@ -44,14 +44,14 @@ inputs:
     # type=file|default=<undefined>: Input aseg file to read from subjects directory
     in_norm: medimage/mgh-gz
     # type=file|default=<undefined>: Required undocumented input {subject}/mri/norm.mgz
-    subjects_dir: generic/directory
-    # type=directory|default=<undefined>: subjects directory
     out_file: Path
     # type=file: Output segmentation uncluding corpus collosum
     # type=file|default=<undefined>: Filename to write aseg including CC
     out_rotation: Path
     # type=file: Output lta rotation file
     # type=file|default=<undefined>: Global filepath for writing rotation lta
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/segment_cc_callables.py b/example-specs/task/nipype/freesurfer/segment_cc_callables.py
index e5ed1b47..cc2bd0d6 100644
--- a/example-specs/task/nipype/freesurfer/segment_cc_callables.py
+++ b/example-specs/task/nipype/freesurfer/segment_cc_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in SegmentCC.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of SegmentCC.yaml"""
diff --git a/example-specs/task/nipype/freesurfer/segment_wm.yaml b/example-specs/task/nipype/freesurfer/segment_wm.yaml
index 9e11d1ae..92c294a5 100644
--- a/example-specs/task/nipype/freesurfer/segment_wm.yaml
+++ b/example-specs/task/nipype/freesurfer/segment_wm.yaml
@@ -36,11 +36,11 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/mgh-gz
     # type=file|default=<undefined>: Input file for SegmentWM
-    subjects_dir: generic/directory
-    # type=directory|default=<undefined>: subjects directory
     out_file: Path
     # type=file: Output white matter segmentation
     # type=file|default=<undefined>: File to be written as output for SegmentWM
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/segment_wm_callables.py b/example-specs/task/nipype/freesurfer/segment_wm_callables.py
index 8ab02a19..7c13fcb5 100644
--- a/example-specs/task/nipype/freesurfer/segment_wm_callables.py
+++ b/example-specs/task/nipype/freesurfer/segment_wm_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in SegmentWM.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of SegmentWM.yaml"""
diff --git a/example-specs/task/nipype/freesurfer/smooth.yaml b/example-specs/task/nipype/freesurfer/smooth.yaml
index f32520a3..bf4a54a1 100644
--- a/example-specs/task/nipype/freesurfer/smooth.yaml
+++ b/example-specs/task/nipype/freesurfer/smooth.yaml
@@ -43,11 +43,11 @@ inputs:
     # type=file|default=<undefined>: source volume
     reg_file: datascience/dat-file
     # type=file|default=<undefined>: registers volume to surface anatomical 
-    subjects_dir: generic/directory
-    # type=directory|default=<undefined>: subjects directory
     smoothed_file: Path
     # type=file: smoothed input volume
     # type=file|default=<undefined>: output volume
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/smooth_callables.py b/example-specs/task/nipype/freesurfer/smooth_callables.py
index 5dbe8c1a..277b109d 100644
--- a/example-specs/task/nipype/freesurfer/smooth_callables.py
+++ b/example-specs/task/nipype/freesurfer/smooth_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in Smooth.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of Smooth.yaml"""
diff --git a/example-specs/task/nipype/freesurfer/smooth_tessellation.yaml b/example-specs/task/nipype/freesurfer/smooth_tessellation.yaml
index 3ad97d1a..3aca79a1 100644
--- a/example-specs/task/nipype/freesurfer/smooth_tessellation.yaml
+++ b/example-specs/task/nipype/freesurfer/smooth_tessellation.yaml
@@ -37,14 +37,14 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: generic/file
     # type=file|default=<undefined>: Input volume to tessellate voxels from.
-    out_curvature_file: generic/file
-    # type=file|default=<undefined>: Write curvature to ``?h.curvname`` (default "curv")
-    out_area_file: generic/file
+    out_area_file: Path
     # type=file|default=<undefined>: Write area to ``?h.areaname`` (default "area")
-    subjects_dir: generic/directory
-    # type=directory|default=<undefined>: subjects directory
+    out_curvature_file: Path
+    # type=file|default=<undefined>: Write curvature to ``?h.curvname`` (default "curv")
     out_file: Path
     # type=file|default=<undefined>: output filename or True to generate one
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/smooth_tessellation_callables.py b/example-specs/task/nipype/freesurfer/smooth_tessellation_callables.py
index bf64a0ec..3ecc8bfe 100644
--- a/example-specs/task/nipype/freesurfer/smooth_tessellation_callables.py
+++ b/example-specs/task/nipype/freesurfer/smooth_tessellation_callables.py
@@ -1,8 +1,8 @@
-"""Module to put any functions that are referred to in SmoothTessellation.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of SmoothTessellation.yaml"""
 
+import attrs
 import os.path as op
 import os
-import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/freesurfer/sphere.yaml b/example-specs/task/nipype/freesurfer/sphere.yaml
index 2e74f39c..128ca016 100644
--- a/example-specs/task/nipype/freesurfer/sphere.yaml
+++ b/example-specs/task/nipype/freesurfer/sphere.yaml
@@ -34,11 +34,11 @@ inputs:
     # type=file|default=<undefined>: Input file for Sphere
     in_smoothwm: generic/file
     # type=file|default=<undefined>: Input surface required when -q flag is not selected
-    subjects_dir: generic/directory
-    # type=directory|default=<undefined>: subjects directory
     out_file: Path
     # type=file: Output file for Sphere
     # type=file|default=<undefined>: Output file for Sphere
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/sphere_callables.py b/example-specs/task/nipype/freesurfer/sphere_callables.py
index ab4fc1b8..0d813120 100644
--- a/example-specs/task/nipype/freesurfer/sphere_callables.py
+++ b/example-specs/task/nipype/freesurfer/sphere_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in Sphere.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of Sphere.yaml"""
diff --git a/example-specs/task/nipype/freesurfer/spherical_average.yaml b/example-specs/task/nipype/freesurfer/spherical_average.yaml
index 07d2ed9c..04a8406e 100644
--- a/example-specs/task/nipype/freesurfer/spherical_average.yaml
+++ b/example-specs/task/nipype/freesurfer/spherical_average.yaml
@@ -39,17 +39,17 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    in_surf: medimage-freesurfer/pial
-    # type=file|default=<undefined>: Input surface file
+    in_average: Path
+    # type=directory|default=<undefined>: Average subject
     in_orig: generic/file
     # type=file|default=<undefined>: Original surface filename
-    subjects_dir: generic/directory
-    # type=directory|default=<undefined>: subjects directory
+    in_surf: medimage-freesurfer/pial
+    # type=file|default=<undefined>: Input surface file
     out_file: Path
     # type=file: Output label
     # type=file|default=<undefined>: Output filename
-    in_average: Path
-    # type=directory|default=<undefined>: Average subject
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/spherical_average_callables.py b/example-specs/task/nipype/freesurfer/spherical_average_callables.py
index 1ec52618..5cffc775 100644
--- a/example-specs/task/nipype/freesurfer/spherical_average_callables.py
+++ b/example-specs/task/nipype/freesurfer/spherical_average_callables.py
@@ -1,7 +1,8 @@
-"""Module to put any functions that are referred to in SphericalAverage.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of SphericalAverage.yaml"""
 
-import os
 import attrs
+from fileformats.generic import File
+import os
 
 
 def in_average_callable(output_dir, inputs, stdout, stderr):
@@ -25,12 +26,6 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
         return None
 
 
-class SphericalAverageOutputSpec(
-    inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    out_file = File(exists=False, desc="Output label")
-
-
 def _outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     """Returns a bunch containing output fields for the class"""
     outputs = None
@@ -42,6 +37,12 @@ def _outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     return outputs
 
 
+class SphericalAverageOutputSpec(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    out_file = File(exists=False, desc="Output label")
+
+
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = _outputs(
         inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
diff --git a/example-specs/task/nipype/freesurfer/surface_2_vol_transform.yaml b/example-specs/task/nipype/freesurfer/surface_2_vol_transform.yaml
index 22f69301..e8b18003 100644
--- a/example-specs/task/nipype/freesurfer/surface_2_vol_transform.yaml
+++ b/example-specs/task/nipype/freesurfer/surface_2_vol_transform.yaml
@@ -36,10 +36,10 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    source_file: medimage/mgh-gz
-    # type=file|default=<undefined>: This is the source of the surface values
     reg_file: datascience/text-matrix
     # type=file|default=<undefined>: tkRAS-to-tkRAS matrix   (tkregister2 format)
+    source_file: medimage/mgh-gz
+    # type=file|default=<undefined>: This is the source of the surface values
     template_file: medimage/nifti-gz
     # type=file|default=<undefined>: Output template volume
     transformed_file: Path
diff --git a/example-specs/task/nipype/freesurfer/surface_2_vol_transform_callables.py b/example-specs/task/nipype/freesurfer/surface_2_vol_transform_callables.py
index 41aa3120..331967de 100644
--- a/example-specs/task/nipype/freesurfer/surface_2_vol_transform_callables.py
+++ b/example-specs/task/nipype/freesurfer/surface_2_vol_transform_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in Surface2VolTransform.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of Surface2VolTransform.yaml"""
diff --git a/example-specs/task/nipype/freesurfer/surface_smooth.yaml b/example-specs/task/nipype/freesurfer/surface_smooth.yaml
index cacaf523..35eed358 100644
--- a/example-specs/task/nipype/freesurfer/surface_smooth.yaml
+++ b/example-specs/task/nipype/freesurfer/surface_smooth.yaml
@@ -47,11 +47,11 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/mgh-gz
     # type=file|default=<undefined>: source surface file
-    subjects_dir: generic/directory
-    # type=directory|default=<undefined>: subjects directory
     out_file: Path
     # type=file: smoothed surface file
     # type=file|default=<undefined>: surface file to write
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/surface_smooth_callables.py b/example-specs/task/nipype/freesurfer/surface_smooth_callables.py
index ab914fe7..63295d6d 100644
--- a/example-specs/task/nipype/freesurfer/surface_smooth_callables.py
+++ b/example-specs/task/nipype/freesurfer/surface_smooth_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in SurfaceSmooth.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of SurfaceSmooth.yaml"""
diff --git a/example-specs/task/nipype/freesurfer/surface_snapshots.yaml b/example-specs/task/nipype/freesurfer/surface_snapshots.yaml
index 221caf9a..88b38e2d 100644
--- a/example-specs/task/nipype/freesurfer/surface_snapshots.yaml
+++ b/example-specs/task/nipype/freesurfer/surface_snapshots.yaml
@@ -44,16 +44,16 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    overlay: generic/file
-    # type=file|default=<undefined>: load an overlay volume/surface
-    overlay_reg: generic/file
-    # type=file|default=<undefined>: registration matrix file to register overlay to surface
     annot_file: generic/file
     # type=file|default=<undefined>: path to annotation file to display
-    label_file: generic/file
-    # type=file|default=<undefined>: path to label file to display
     colortable: generic/file
     # type=file|default=<undefined>: load colortable file
+    label_file: generic/file
+    # type=file|default=<undefined>: path to label file to display
+    overlay: generic/file
+    # type=file|default=<undefined>: load an overlay volume/surface
+    overlay_reg: generic/file
+    # type=file|default=<undefined>: registration matrix file to register overlay to surface
     patch_file: generic/file
     # type=file|default=<undefined>: load a patch
     subjects_dir: generic/directory
diff --git a/example-specs/task/nipype/freesurfer/surface_snapshots_callables.py b/example-specs/task/nipype/freesurfer/surface_snapshots_callables.py
index 5b155865..d331f34b 100644
--- a/example-specs/task/nipype/freesurfer/surface_snapshots_callables.py
+++ b/example-specs/task/nipype/freesurfer/surface_snapshots_callables.py
@@ -1,4 +1,4 @@
-"""Module to put any functions that are referred to in SurfaceSnapshots.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of SurfaceSnapshots.yaml"""
 
 
 def tcl_script_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/freesurfer/surface_transform.yaml b/example-specs/task/nipype/freesurfer/surface_transform.yaml
index cd77d625..deb32790 100644
--- a/example-specs/task/nipype/freesurfer/surface_transform.yaml
+++ b/example-specs/task/nipype/freesurfer/surface_transform.yaml
@@ -37,15 +37,15 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    source_file: generic/file
-    # type=file|default=<undefined>: surface file with source values
+    out_file: Path
+    # type=file: transformed surface file
+    # type=file|default=<undefined>: surface file to write
     source_annot_file: generic/file
     # type=file|default=<undefined>: surface annotation file
+    source_file: generic/file
+    # type=file|default=<undefined>: surface file with source values
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
-    out_file: Path
-    # type=file: transformed surface file
-    # type=file|default=<undefined>: surface file to write
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/surface_transform_callables.py b/example-specs/task/nipype/freesurfer/surface_transform_callables.py
index 4ef7bf87..bc0bb94c 100644
--- a/example-specs/task/nipype/freesurfer/surface_transform_callables.py
+++ b/example-specs/task/nipype/freesurfer/surface_transform_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in SurfaceTransform.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of SurfaceTransform.yaml"""
diff --git a/example-specs/task/nipype/freesurfer/synthesize_flash.yaml b/example-specs/task/nipype/freesurfer/synthesize_flash.yaml
index 05f34e38..38e5bc97 100644
--- a/example-specs/task/nipype/freesurfer/synthesize_flash.yaml
+++ b/example-specs/task/nipype/freesurfer/synthesize_flash.yaml
@@ -32,15 +32,15 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    t1_image: medimage/mgh-gz
-    # type=file|default=<undefined>: image of T1 values
+    out_file: Path
+    # type=file: synthesized FLASH acquisition
+    # type=file|default=<undefined>: image to write
     pd_image: medimage/mgh-gz
     # type=file|default=<undefined>: image of proton density values
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
-    out_file: Path
-    # type=file: synthesized FLASH acquisition
-    # type=file|default=<undefined>: image to write
+    t1_image: medimage/mgh-gz
+    # type=file|default=<undefined>: image of T1 values
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/synthesize_flash_callables.py b/example-specs/task/nipype/freesurfer/synthesize_flash_callables.py
index 57e2ba5e..3d8b5898 100644
--- a/example-specs/task/nipype/freesurfer/synthesize_flash_callables.py
+++ b/example-specs/task/nipype/freesurfer/synthesize_flash_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in SynthesizeFLASH.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of SynthesizeFLASH.yaml"""
diff --git a/example-specs/task/nipype/freesurfer/talairach_avi.yaml b/example-specs/task/nipype/freesurfer/talairach_avi.yaml
index c156ba0f..4a09eef7 100644
--- a/example-specs/task/nipype/freesurfer/talairach_avi.yaml
+++ b/example-specs/task/nipype/freesurfer/talairach_avi.yaml
@@ -40,11 +40,11 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/mgh-gz
     # type=file|default=<undefined>: input volume
-    subjects_dir: generic/directory
-    # type=directory|default=<undefined>: subjects directory
     out_file: Path
     # type=file: The output transform for TalairachAVI
     # type=file|default=<undefined>: output xfm file
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/talairach_avi_callables.py b/example-specs/task/nipype/freesurfer/talairach_avi_callables.py
index 64c41b67..ba6cd07a 100644
--- a/example-specs/task/nipype/freesurfer/talairach_avi_callables.py
+++ b/example-specs/task/nipype/freesurfer/talairach_avi_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in TalairachAVI.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of TalairachAVI.yaml"""
diff --git a/example-specs/task/nipype/freesurfer/talairach_qc.yaml b/example-specs/task/nipype/freesurfer/talairach_qc.yaml
index 8cdcfaac..611eb0a9 100644
--- a/example-specs/task/nipype/freesurfer/talairach_qc.yaml
+++ b/example-specs/task/nipype/freesurfer/talairach_qc.yaml
@@ -29,11 +29,11 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    subjects_dir: generic/directory
-    # type=directory|default=<undefined>: subjects directory
     log_file: Path
     # type=file: The output log
     # type=file|default=<undefined>: The log file for TalairachQC
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/talairach_qc_callables.py b/example-specs/task/nipype/freesurfer/talairach_qc_callables.py
index 0790363f..d172a503 100644
--- a/example-specs/task/nipype/freesurfer/talairach_qc_callables.py
+++ b/example-specs/task/nipype/freesurfer/talairach_qc_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in TalairachQC.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of TalairachQC.yaml"""
diff --git a/example-specs/task/nipype/freesurfer/tkregister_2.yaml b/example-specs/task/nipype/freesurfer/tkregister_2.yaml
index 62ac0bf2..0e511783 100644
--- a/example-specs/task/nipype/freesurfer/tkregister_2.yaml
+++ b/example-specs/task/nipype/freesurfer/tkregister_2.yaml
@@ -49,21 +49,21 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    target_image: medimage/nifti1
-    # type=file|default=<undefined>: target volume
-    moving_image: medimage/nifti1,medimage/mgh-gz
-    # type=file|default=<undefined>: moving volume
     fsl_in_matrix: datascience/text-matrix
     # type=file|default=<undefined>: fsl-style registration input matrix
-    xfm: generic/file
-    # type=file|default=<undefined>: use a matrix in MNI coordinates as initial registration
     lta_in: generic/file
     # type=file|default=<undefined>: use a matrix in MNI coordinates as initial registration
-    subjects_dir: generic/directory
-    # type=directory|default=<undefined>: subjects directory
+    moving_image: medimage/nifti1,medimage/mgh-gz
+    # type=file|default=<undefined>: moving volume
     reg_file: Path
     # type=file: freesurfer-style registration file
     # type=file|default='register.dat': freesurfer-style registration file
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+    target_image: medimage/nifti1
+    # type=file|default=<undefined>: target volume
+    xfm: generic/file
+    # type=file|default=<undefined>: use a matrix in MNI coordinates as initial registration
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -77,13 +77,13 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    reg_file: datascience/dat-file
-    # type=file: freesurfer-style registration file
-    # type=file|default='register.dat': freesurfer-style registration file
     fsl_file: generic/file
     # type=file: FSL-style registration file
     lta_file: generic/file
     # type=file: LTA-style registration file
+    reg_file: datascience/dat-file
+    # type=file: freesurfer-style registration file
+    # type=file|default='register.dat': freesurfer-style registration file
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/freesurfer/tkregister_2_callables.py b/example-specs/task/nipype/freesurfer/tkregister_2_callables.py
index 01df9072..e34e8b6f 100644
--- a/example-specs/task/nipype/freesurfer/tkregister_2_callables.py
+++ b/example-specs/task/nipype/freesurfer/tkregister_2_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in Tkregister2.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of Tkregister2.yaml"""
diff --git a/example-specs/task/nipype/freesurfer/unpack_sdicom_dir.yaml b/example-specs/task/nipype/freesurfer/unpack_sdicom_dir.yaml
index c207a431..1f6e69f5 100644
--- a/example-specs/task/nipype/freesurfer/unpack_sdicom_dir.yaml
+++ b/example-specs/task/nipype/freesurfer/unpack_sdicom_dir.yaml
@@ -38,16 +38,16 @@ inputs:
   # passed to the field in the automatically generated unittests.
     config: generic/file
     # type=file|default=<undefined>: specify unpacking rules in file
-    seq_config: generic/file
-    # type=file|default=<undefined>: specify unpacking rules based on sequence
-    scan_only: generic/file
-    # type=file|default=<undefined>: only scan the directory and put result in file
     log_file: generic/file
     # type=file|default=<undefined>: explicitly set log file
-    source_dir: generic/directory
-    # type=directory|default=<undefined>: directory with the DICOM files
     output_dir: generic/directory
     # type=directory|default=<undefined>: top directory into which the files will be unpacked
+    scan_only: generic/file
+    # type=file|default=<undefined>: only scan the directory and put result in file
+    seq_config: generic/file
+    # type=file|default=<undefined>: specify unpacking rules based on sequence
+    source_dir: generic/directory
+    # type=directory|default=<undefined>: directory with the DICOM files
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
   metadata:
diff --git a/example-specs/task/nipype/freesurfer/unpack_sdicom_dir_callables.py b/example-specs/task/nipype/freesurfer/unpack_sdicom_dir_callables.py
index 05e705bd..486de40a 100644
--- a/example-specs/task/nipype/freesurfer/unpack_sdicom_dir_callables.py
+++ b/example-specs/task/nipype/freesurfer/unpack_sdicom_dir_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in UnpackSDICOMDir.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of UnpackSDICOMDir.yaml"""
diff --git a/example-specs/task/nipype/freesurfer/volume_mask.yaml b/example-specs/task/nipype/freesurfer/volume_mask.yaml
index ef034b89..53297484 100644
--- a/example-specs/task/nipype/freesurfer/volume_mask.yaml
+++ b/example-specs/task/nipype/freesurfer/volume_mask.yaml
@@ -45,18 +45,18 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    aseg: generic/file
+    # type=file|default=<undefined>: Implicit aseg.mgz segmentation. Specify a different aseg by using the 'in_aseg' input.
+    in_aseg: generic/file
+    # type=file|default=<undefined>: Input aseg file for VolumeMask
     lh_pial: medimage-freesurfer/pial
     # type=file|default=<undefined>: Implicit input left pial surface
-    rh_pial: medimage-freesurfer/pial
-    # type=file|default=<undefined>: Implicit input right pial surface
     lh_white: medimage-freesurfer/pial
     # type=file|default=<undefined>: Implicit input left white matter surface
+    rh_pial: medimage-freesurfer/pial
+    # type=file|default=<undefined>: Implicit input right pial surface
     rh_white: medimage-freesurfer/pial
     # type=file|default=<undefined>: Implicit input right white matter surface
-    aseg: generic/file
-    # type=file|default=<undefined>: Implicit aseg.mgz segmentation. Specify a different aseg by using the 'in_aseg' input.
-    in_aseg: generic/file
-    # type=file|default=<undefined>: Input aseg file for VolumeMask
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
   metadata:
@@ -72,10 +72,10 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    out_ribbon: generic/file
-    # type=file: Output cortical ribbon mask
     lh_ribbon: generic/file
     # type=file: Output left cortical ribbon mask
+    out_ribbon: generic/file
+    # type=file: Output cortical ribbon mask
     rh_ribbon: generic/file
     # type=file: Output right cortical ribbon mask
   callables:
diff --git a/example-specs/task/nipype/freesurfer/volume_mask_callables.py b/example-specs/task/nipype/freesurfer/volume_mask_callables.py
index fa5442aa..027c538a 100644
--- a/example-specs/task/nipype/freesurfer/volume_mask_callables.py
+++ b/example-specs/task/nipype/freesurfer/volume_mask_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in VolumeMask.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of VolumeMask.yaml"""
diff --git a/example-specs/task/nipype/freesurfer/watershed_skull_strip.yaml b/example-specs/task/nipype/freesurfer/watershed_skull_strip.yaml
index 3ee70b4a..76b9a9f7 100644
--- a/example-specs/task/nipype/freesurfer/watershed_skull_strip.yaml
+++ b/example-specs/task/nipype/freesurfer/watershed_skull_strip.yaml
@@ -43,17 +43,17 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    in_file: medimage/mgh-gz
-    # type=file|default=<undefined>: input volume
     brain_atlas: generic/file
     # type=file|default=<undefined>: 
-    transform: medimage-freesurfer/lta
-    # type=file|default=<undefined>: undocumented
-    subjects_dir: generic/directory
-    # type=directory|default=<undefined>: subjects directory
+    in_file: medimage/mgh-gz
+    # type=file|default=<undefined>: input volume
     out_file: Path
     # type=file: skull stripped brain volume
     # type=file|default='brainmask.auto.mgz': output volume
+    subjects_dir: generic/directory
+    # type=directory|default=<undefined>: subjects directory
+    transform: medimage-freesurfer/lta
+    # type=file|default=<undefined>: undocumented
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/watershed_skull_strip_callables.py b/example-specs/task/nipype/freesurfer/watershed_skull_strip_callables.py
index e6780434..3501134e 100644
--- a/example-specs/task/nipype/freesurfer/watershed_skull_strip_callables.py
+++ b/example-specs/task/nipype/freesurfer/watershed_skull_strip_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in WatershedSkullStrip.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of WatershedSkullStrip.yaml"""
diff --git a/example-specs/task/nipype/fsl/accuracy_tester.yaml b/example-specs/task/nipype/fsl/accuracy_tester.yaml
index d8f3f009..571881d0 100644
--- a/example-specs/task/nipype/fsl/accuracy_tester.yaml
+++ b/example-specs/task/nipype/fsl/accuracy_tester.yaml
@@ -23,13 +23,13 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    trained_wts_file: generic/file
-    # type=file|default=<undefined>: trained-weights file
     mel_icas: generic/directory+list-of
     # type=inputmultiobject|default=[]: Melodic output directories
     output_directory: Path
     # type=directory: Path to folder in which to store the results of the accuracy test.
     # type=directory|default=<undefined>: Path to folder in which to store the results of the accuracy test.
+    trained_wts_file: generic/file
+    # type=file|default=<undefined>: trained-weights file
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/accuracy_tester_callables.py b/example-specs/task/nipype/fsl/accuracy_tester_callables.py
index 5c3eb007..c69be900 100644
--- a/example-specs/task/nipype/fsl/accuracy_tester_callables.py
+++ b/example-specs/task/nipype/fsl/accuracy_tester_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in AccuracyTester.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of AccuracyTester.yaml"""
diff --git a/example-specs/task/nipype/fsl/apply_mask.yaml b/example-specs/task/nipype/fsl/apply_mask.yaml
index cdb099ca..d2a24be6 100644
--- a/example-specs/task/nipype/fsl/apply_mask.yaml
+++ b/example-specs/task/nipype/fsl/apply_mask.yaml
@@ -20,10 +20,10 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    mask_file: generic/file
-    # type=file|default=<undefined>: binary image defining mask space
     in_file: generic/file
     # type=file|default=<undefined>: image to operate on
+    mask_file: generic/file
+    # type=file|default=<undefined>: binary image defining mask space
     out_file: Path
     # type=file: image written after calculations
     # type=file|default=<undefined>: image to write
diff --git a/example-specs/task/nipype/fsl/apply_mask_callables.py b/example-specs/task/nipype/fsl/apply_mask_callables.py
index ce0e94d9..411af901 100644
--- a/example-specs/task/nipype/fsl/apply_mask_callables.py
+++ b/example-specs/task/nipype/fsl/apply_mask_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in ApplyMask.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of ApplyMask.yaml"""
diff --git a/example-specs/task/nipype/fsl/apply_topup.yaml b/example-specs/task/nipype/fsl/apply_topup.yaml
index de80b370..0addbf7a 100644
--- a/example-specs/task/nipype/fsl/apply_topup.yaml
+++ b/example-specs/task/nipype/fsl/apply_topup.yaml
@@ -43,10 +43,10 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    in_files: medimage/nifti1+list-of
-    # type=inputmultiobject|default=[]: name of file with images
     encoding_file: text/text-file
     # type=file|default=<undefined>: name of text file with PE directions/times
+    in_files: medimage/nifti1+list-of
+    # type=inputmultiobject|default=[]: name of file with images
     in_topup_fieldcoef: medimage/nifti-gz
     # type=file|default=<undefined>: topup file containing the field coefficients
     in_topup_movpar: text/text-file
diff --git a/example-specs/task/nipype/fsl/apply_topup_callables.py b/example-specs/task/nipype/fsl/apply_topup_callables.py
index 62f411a9..f16621a9 100644
--- a/example-specs/task/nipype/fsl/apply_topup_callables.py
+++ b/example-specs/task/nipype/fsl/apply_topup_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in ApplyTOPUP.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of ApplyTOPUP.yaml"""
diff --git a/example-specs/task/nipype/fsl/apply_warp.yaml b/example-specs/task/nipype/fsl/apply_warp.yaml
index 3c9a6277..d722faef 100644
--- a/example-specs/task/nipype/fsl/apply_warp.yaml
+++ b/example-specs/task/nipype/fsl/apply_warp.yaml
@@ -33,21 +33,21 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    in_file: generic/file
-    # type=file|default=<undefined>: image to be warped
-    ref_file: generic/file
-    # type=file|default=<undefined>: reference image
     field_file: generic/file
     # type=file|default=<undefined>: file containing warp field
-    premat: generic/file
-    # type=file|default=<undefined>: filename for pre-transform (affine matrix)
-    postmat: generic/file
-    # type=file|default=<undefined>: filename for post-transform (affine matrix)
+    in_file: generic/file
+    # type=file|default=<undefined>: image to be warped
     mask_file: generic/file
     # type=file|default=<undefined>: filename for mask image (in reference space)
     out_file: Path
     # type=file: Warped output file
     # type=file|default=<undefined>: output filename
+    postmat: generic/file
+    # type=file|default=<undefined>: filename for post-transform (affine matrix)
+    premat: generic/file
+    # type=file|default=<undefined>: filename for pre-transform (affine matrix)
+    ref_file: generic/file
+    # type=file|default=<undefined>: reference image
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/apply_warp_callables.py b/example-specs/task/nipype/fsl/apply_warp_callables.py
index 827cf9f6..d4827d57 100644
--- a/example-specs/task/nipype/fsl/apply_warp_callables.py
+++ b/example-specs/task/nipype/fsl/apply_warp_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in ApplyWarp.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of ApplyWarp.yaml"""
diff --git a/example-specs/task/nipype/fsl/apply_xfm.yaml b/example-specs/task/nipype/fsl/apply_xfm.yaml
index 905f0b89..21c8788f 100644
--- a/example-specs/task/nipype/fsl/apply_xfm.yaml
+++ b/example-specs/task/nipype/fsl/apply_xfm.yaml
@@ -39,37 +39,37 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    fieldmap: generic/file
+    # type=file|default=<undefined>: fieldmap image in rads/s - must be already registered to the reference image
+    fieldmapmask: generic/file
+    # type=file|default=<undefined>: mask for fieldmap image
     in_file: generic/file
     # type=file|default=<undefined>: input file
-    reference: generic/file
-    # type=file|default=<undefined>: reference file
     in_matrix_file: generic/file
     # type=file|default=<undefined>: input 4x4 affine matrix
-    schedule: generic/file
-    # type=file|default=<undefined>: replaces default schedule
-    ref_weight: generic/file
-    # type=file|default=<undefined>: File for reference weighting volume
     in_weight: generic/file
     # type=file|default=<undefined>: File for input weighting volume
-    wm_seg: generic/file
-    # type=file|default=<undefined>: white matter segmentation volume needed by BBR cost function
-    wmcoords: generic/file
-    # type=file|default=<undefined>: white matter boundary coordinates for BBR cost function
-    wmnorms: generic/file
-    # type=file|default=<undefined>: white matter boundary normals for BBR cost function
-    fieldmap: generic/file
-    # type=file|default=<undefined>: fieldmap image in rads/s - must be already registered to the reference image
-    fieldmapmask: generic/file
-    # type=file|default=<undefined>: mask for fieldmap image
     out_file: Path
     # type=file: path/name of registered file (if generated)
     # type=file|default=<undefined>: registered output file
-    out_matrix_file: Path
-    # type=file: path/name of calculated affine transform (if generated)
-    # type=file|default=<undefined>: output affine matrix in 4x4 asciii format
     out_log: Path
     # type=file: path/name of output log (if generated)
     # type=file|default=<undefined>: output log
+    out_matrix_file: Path
+    # type=file: path/name of calculated affine transform (if generated)
+    # type=file|default=<undefined>: output affine matrix in 4x4 asciii format
+    ref_weight: generic/file
+    # type=file|default=<undefined>: File for reference weighting volume
+    reference: generic/file
+    # type=file|default=<undefined>: reference file
+    schedule: generic/file
+    # type=file|default=<undefined>: replaces default schedule
+    wm_seg: generic/file
+    # type=file|default=<undefined>: white matter segmentation volume needed by BBR cost function
+    wmcoords: generic/file
+    # type=file|default=<undefined>: white matter boundary coordinates for BBR cost function
+    wmnorms: generic/file
+    # type=file|default=<undefined>: white matter boundary normals for BBR cost function
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -86,12 +86,12 @@ outputs:
     out_file: generic/file
     # type=file: path/name of registered file (if generated)
     # type=file|default=<undefined>: registered output file
-    out_matrix_file: generic/file
-    # type=file: path/name of calculated affine transform (if generated)
-    # type=file|default=<undefined>: output affine matrix in 4x4 asciii format
     out_log: generic/file
     # type=file: path/name of output log (if generated)
     # type=file|default=<undefined>: output log
+    out_matrix_file: generic/file
+    # type=file: path/name of calculated affine transform (if generated)
+    # type=file|default=<undefined>: output affine matrix in 4x4 asciii format
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/fsl/apply_xfm_callables.py b/example-specs/task/nipype/fsl/apply_xfm_callables.py
index 3b6054b3..1dce24c5 100644
--- a/example-specs/task/nipype/fsl/apply_xfm_callables.py
+++ b/example-specs/task/nipype/fsl/apply_xfm_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in ApplyXFM.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of ApplyXFM.yaml"""
diff --git a/example-specs/task/nipype/fsl/ar1_image_callables.py b/example-specs/task/nipype/fsl/ar1_image_callables.py
index 7bd81558..25964e2e 100644
--- a/example-specs/task/nipype/fsl/ar1_image_callables.py
+++ b/example-specs/task/nipype/fsl/ar1_image_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in AR1Image.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of AR1Image.yaml"""
diff --git a/example-specs/task/nipype/fsl/av_scale_callables.py b/example-specs/task/nipype/fsl/av_scale_callables.py
index 236bd307..6a1d0bde 100644
--- a/example-specs/task/nipype/fsl/av_scale_callables.py
+++ b/example-specs/task/nipype/fsl/av_scale_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in AvScale.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of AvScale.yaml"""
diff --git a/example-specs/task/nipype/fsl/b0_calc_callables.py b/example-specs/task/nipype/fsl/b0_calc_callables.py
index 4c30d1fc..95f757d4 100644
--- a/example-specs/task/nipype/fsl/b0_calc_callables.py
+++ b/example-specs/task/nipype/fsl/b0_calc_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in B0Calc.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of B0Calc.yaml"""
diff --git a/example-specs/task/nipype/fsl/bedpostx5.yaml b/example-specs/task/nipype/fsl/bedpostx5.yaml
index d22f95a3..0d6f6e48 100644
--- a/example-specs/task/nipype/fsl/bedpostx5.yaml
+++ b/example-specs/task/nipype/fsl/bedpostx5.yaml
@@ -43,18 +43,18 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    dwi: medimage/nifti1
-    # type=file|default=<undefined>: diffusion weighted image data file
-    mask: medimage/nifti1
-    # type=file|default=<undefined>: bet binary mask file
-    bvecs: medimage/bvec
-    # type=file|default=<undefined>: b vectors file
     bvals: medimage/bval
     # type=file|default=<undefined>: b values file
+    bvecs: medimage/bvec
+    # type=file|default=<undefined>: b vectors file
+    dwi: medimage/nifti1
+    # type=file|default=<undefined>: diffusion weighted image data file
     grad_dev: generic/file
     # type=file|default=<undefined>: grad_dev file, if gradnonlin, -g is True
     logdir: generic/directory
     # type=directory|default=<undefined>: 
+    mask: medimage/nifti1
+    # type=file|default=<undefined>: bet binary mask file
     out_dir: generic/directory
     # type=directory|default='bedpostx': output directory
   metadata:
@@ -70,10 +70,10 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    mean_dsamples: generic/file
-    # type=file: Mean of distribution on diffusivity d
     mean_S0samples: generic/file
     # type=file: Mean of distribution on T2wbaseline signal intensity S0
+    mean_dsamples: generic/file
+    # type=file: Mean of distribution on diffusivity d
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/fsl/bedpostx5_callables.py b/example-specs/task/nipype/fsl/bedpostx5_callables.py
index 3f67f67b..f03ac323 100644
--- a/example-specs/task/nipype/fsl/bedpostx5_callables.py
+++ b/example-specs/task/nipype/fsl/bedpostx5_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in BEDPOSTX5.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of BEDPOSTX5.yaml"""
diff --git a/example-specs/task/nipype/fsl/bet.yaml b/example-specs/task/nipype/fsl/bet.yaml
index 363f19c0..35b58d5d 100644
--- a/example-specs/task/nipype/fsl/bet.yaml
+++ b/example-specs/task/nipype/fsl/bet.yaml
@@ -38,11 +38,11 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/nifti1
     # type=file|default=<undefined>: input file to skull strip
-    t2_guided: generic/file
-    # type=file|default=<undefined>: as with creating surfaces, when also feeding in non-brain-extracted T2 (includes registrations)
     out_file: Path
     # type=file: path/name of skullstripped file (if generated)
     # type=file|default=<undefined>: name of output skull stripped image
+    t2_guided: generic/file
+    # type=file|default=<undefined>: as with creating surfaces, when also feeding in non-brain-extracted T2 (includes registrations)
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -56,31 +56,31 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    inskull_mask_file: generic/file
+    # type=file: path/name of inskull mask (if generated)
+    inskull_mesh_file: generic/file
+    # type=file: path/name of inskull mesh outline (if generated)
+    mask_file: generic/file
+    # type=file: path/name of binary brain mask (if generated)
+    meshfile: generic/file
+    # type=file: path/name of vtk mesh file (if generated)
     out_file: medimage/nifti1
     # type=file: path/name of skullstripped file (if generated)
     # type=file|default=<undefined>: name of output skull stripped image
-    mask_file: generic/file
-    # type=file: path/name of binary brain mask (if generated)
     outline_file: generic/file
     # type=file: path/name of outline file (if generated)
-    meshfile: generic/file
-    # type=file: path/name of vtk mesh file (if generated)
-    inskull_mask_file: generic/file
-    # type=file: path/name of inskull mask (if generated)
-    inskull_mesh_file: generic/file
-    # type=file: path/name of inskull mesh outline (if generated)
-    outskull_mask_file: generic/file
-    # type=file: path/name of outskull mask (if generated)
-    outskull_mesh_file: generic/file
-    # type=file: path/name of outskull mesh outline (if generated)
     outskin_mask_file: generic/file
     # type=file: path/name of outskin mask (if generated)
     outskin_mesh_file: generic/file
     # type=file: path/name of outskin mesh outline (if generated)
-    skull_mask_file: generic/file
-    # type=file: path/name of skull mask (if generated)
+    outskull_mask_file: generic/file
+    # type=file: path/name of outskull mask (if generated)
+    outskull_mesh_file: generic/file
+    # type=file: path/name of outskull mesh outline (if generated)
     skull_file: generic/file
     # type=file: path/name of skull file (if generated)
+    skull_mask_file: generic/file
+    # type=file: path/name of skull mask (if generated)
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/fsl/bet_callables.py b/example-specs/task/nipype/fsl/bet_callables.py
index 8b4d7f59..6b806f68 100644
--- a/example-specs/task/nipype/fsl/bet_callables.py
+++ b/example-specs/task/nipype/fsl/bet_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in BET.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of BET.yaml"""
diff --git a/example-specs/task/nipype/fsl/binary_maths.yaml b/example-specs/task/nipype/fsl/binary_maths.yaml
index 292bcb03..c496039e 100644
--- a/example-specs/task/nipype/fsl/binary_maths.yaml
+++ b/example-specs/task/nipype/fsl/binary_maths.yaml
@@ -23,10 +23,10 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    operand_file: generic/file
-    # type=file|default=<undefined>: second image to perform operation with
     in_file: generic/file
     # type=file|default=<undefined>: image to operate on
+    operand_file: generic/file
+    # type=file|default=<undefined>: second image to perform operation with
     out_file: Path
     # type=file: image written after calculations
     # type=file|default=<undefined>: image to write
diff --git a/example-specs/task/nipype/fsl/binary_maths_callables.py b/example-specs/task/nipype/fsl/binary_maths_callables.py
index 68e6b721..2bfff1ee 100644
--- a/example-specs/task/nipype/fsl/binary_maths_callables.py
+++ b/example-specs/task/nipype/fsl/binary_maths_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in BinaryMaths.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of BinaryMaths.yaml"""
diff --git a/example-specs/task/nipype/fsl/change_data_type_callables.py b/example-specs/task/nipype/fsl/change_data_type_callables.py
index 2eb33677..85403873 100644
--- a/example-specs/task/nipype/fsl/change_data_type_callables.py
+++ b/example-specs/task/nipype/fsl/change_data_type_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in ChangeDataType.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of ChangeDataType.yaml"""
diff --git a/example-specs/task/nipype/fsl/classifier.yaml b/example-specs/task/nipype/fsl/classifier.yaml
index 9a80ff57..25920b74 100644
--- a/example-specs/task/nipype/fsl/classifier.yaml
+++ b/example-specs/task/nipype/fsl/classifier.yaml
@@ -22,13 +22,13 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    trained_wts_file: generic/file
-    # type=file|default=<undefined>: trained-weights file
-    mel_ica: generic/directory
-    # type=directory|default=<undefined>: Melodic output directory or directories
     artifacts_list_file: Path
     # type=file: Text file listing which ICs are artifacts; can be the output from classification or can be created manually
     # type=file|default=<undefined>: Text file listing which ICs are artifacts; can be the output from classification or can be created manually
+    mel_ica: generic/directory
+    # type=directory|default=<undefined>: Melodic output directory or directories
+    trained_wts_file: generic/file
+    # type=file|default=<undefined>: trained-weights file
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/classifier_callables.py b/example-specs/task/nipype/fsl/classifier_callables.py
index 4f49e90a..fa0d814f 100644
--- a/example-specs/task/nipype/fsl/classifier_callables.py
+++ b/example-specs/task/nipype/fsl/classifier_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in Classifier.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of Classifier.yaml"""
diff --git a/example-specs/task/nipype/fsl/cleaner_callables.py b/example-specs/task/nipype/fsl/cleaner_callables.py
index 625e2aff..3e7367f3 100644
--- a/example-specs/task/nipype/fsl/cleaner_callables.py
+++ b/example-specs/task/nipype/fsl/cleaner_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in Cleaner.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of Cleaner.yaml"""
diff --git a/example-specs/task/nipype/fsl/cluster.yaml b/example-specs/task/nipype/fsl/cluster.yaml
index 75f69e45..8fa634dd 100644
--- a/example-specs/task/nipype/fsl/cluster.yaml
+++ b/example-specs/task/nipype/fsl/cluster.yaml
@@ -33,16 +33,16 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    in_file: medimage/nifti-gz
-    # type=file|default=<undefined>: input volume
     cope_file: generic/file
     # type=file|default=<undefined>: cope volume
-    xfm_file: generic/file
-    # type=file|default=<undefined>: filename for Linear: input->standard-space transform. Non-linear: input->highres transform
+    in_file: medimage/nifti-gz
+    # type=file|default=<undefined>: input volume
     std_space_file: generic/file
     # type=file|default=<undefined>: filename for standard-space volume
     warpfield_file: generic/file
     # type=file|default=<undefined>: file contining warpfield
+    xfm_file: generic/file
+    # type=file|default=<undefined>: filename for Linear: input->standard-space transform. Non-linear: input->highres transform
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -58,20 +58,20 @@ outputs:
   # passed to the field in the automatically generated unittests.
     index_file: generic/file
     # type=file: output of cluster index (in size order)
-    threshold_file: generic/file
-    # type=file: thresholded image
     localmax_txt_file: generic/file
     # type=file: local maxima text file
     localmax_vol_file: generic/file
     # type=file: output of local maxima volume
-    size_file: generic/file
-    # type=file: filename for output of size image
     max_file: generic/file
     # type=file: filename for output of max image
     mean_file: generic/file
     # type=file: filename for output of mean image
     pval_file: generic/file
     # type=file: filename for image output of log pvals
+    size_file: generic/file
+    # type=file: filename for output of size image
+    threshold_file: generic/file
+    # type=file: thresholded image
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/fsl/cluster_callables.py b/example-specs/task/nipype/fsl/cluster_callables.py
index bca8cdec..c189bff1 100644
--- a/example-specs/task/nipype/fsl/cluster_callables.py
+++ b/example-specs/task/nipype/fsl/cluster_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in Cluster.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of Cluster.yaml"""
diff --git a/example-specs/task/nipype/fsl/complex.yaml b/example-specs/task/nipype/fsl/complex.yaml
index 097f99e3..0a239a53 100644
--- a/example-specs/task/nipype/fsl/complex.yaml
+++ b/example-specs/task/nipype/fsl/complex.yaml
@@ -35,27 +35,27 @@ inputs:
     # type=file|default=<undefined>: 
     complex_in_file2: generic/file
     # type=file|default=<undefined>: 
-    real_in_file: generic/file
+    complex_out_file: Path
+    # type=file: 
     # type=file|default=<undefined>: 
     imaginary_in_file: generic/file
     # type=file|default=<undefined>: 
-    magnitude_in_file: generic/file
-    # type=file|default=<undefined>: 
-    phase_in_file: generic/file
-    # type=file|default=<undefined>: 
-    complex_out_file: Path
+    imaginary_out_file: Path
     # type=file: 
     # type=file|default=<undefined>: 
+    magnitude_in_file: generic/file
+    # type=file|default=<undefined>: 
     magnitude_out_file: Path
     # type=file: 
     # type=file|default=<undefined>: 
+    phase_in_file: generic/file
+    # type=file|default=<undefined>: 
     phase_out_file: Path
     # type=file: 
     # type=file|default=<undefined>: 
-    real_out_file: Path
-    # type=file: 
+    real_in_file: generic/file
     # type=file|default=<undefined>: 
-    imaginary_out_file: Path
+    real_out_file: Path
     # type=file: 
     # type=file|default=<undefined>: 
   metadata:
@@ -71,19 +71,19 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    magnitude_out_file: generic/file
+    complex_out_file: generic/file
     # type=file: 
     # type=file|default=<undefined>: 
-    phase_out_file: generic/file
+    imaginary_out_file: generic/file
     # type=file: 
     # type=file|default=<undefined>: 
-    real_out_file: generic/file
+    magnitude_out_file: generic/file
     # type=file: 
     # type=file|default=<undefined>: 
-    imaginary_out_file: generic/file
+    phase_out_file: generic/file
     # type=file: 
     # type=file|default=<undefined>: 
-    complex_out_file: generic/file
+    real_out_file: generic/file
     # type=file: 
     # type=file|default=<undefined>: 
   callables:
@@ -94,6 +94,9 @@ outputs:
     complex_out_file: complex_out_file
     # type=file: 
     # type=file|default=<undefined>: 
+    imaginary_out_file: imaginary_out_file
+    # type=file: 
+    # type=file|default=<undefined>: 
     magnitude_out_file: magnitude_out_file
     # type=file: 
     # type=file|default=<undefined>: 
@@ -103,9 +106,6 @@ outputs:
     real_out_file: real_out_file
     # type=file: 
     # type=file|default=<undefined>: 
-    imaginary_out_file: imaginary_out_file
-    # type=file: 
-    # type=file|default=<undefined>: 
   requirements:
   # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
 tests:
diff --git a/example-specs/task/nipype/fsl/complex_callables.py b/example-specs/task/nipype/fsl/complex_callables.py
index 566f01d0..93bb00f0 100644
--- a/example-specs/task/nipype/fsl/complex_callables.py
+++ b/example-specs/task/nipype/fsl/complex_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in Complex.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of Complex.yaml"""
diff --git a/example-specs/task/nipype/fsl/contrast_mgr.yaml b/example-specs/task/nipype/fsl/contrast_mgr.yaml
index c344fd2f..76c7d1f0 100644
--- a/example-specs/task/nipype/fsl/contrast_mgr.yaml
+++ b/example-specs/task/nipype/fsl/contrast_mgr.yaml
@@ -25,18 +25,18 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    tcon_file: generic/file
-    # type=file|default=<undefined>: contrast file containing T-contrasts
-    fcon_file: generic/file
-    # type=file|default=<undefined>: contrast file containing F-contrasts
-    param_estimates: generic/file+list-of
-    # type=inputmultiobject|default=[]: Parameter estimates for each column of the design matrix
     corrections: generic/file
     # type=file|default=<undefined>: statistical corrections used within FILM modelling
     dof_file: generic/file
     # type=file|default=<undefined>: degrees of freedom
+    fcon_file: generic/file
+    # type=file|default=<undefined>: contrast file containing F-contrasts
+    param_estimates: generic/file+list-of
+    # type=inputmultiobject|default=[]: Parameter estimates for each column of the design matrix
     sigmasquareds: generic/file
     # type=file|default=<undefined>: summary of residuals, See Woolrich, et. al., 2001
+    tcon_file: generic/file
+    # type=file|default=<undefined>: contrast file containing T-contrasts
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/contrast_mgr_callables.py b/example-specs/task/nipype/fsl/contrast_mgr_callables.py
index ff62f092..f42e6470 100644
--- a/example-specs/task/nipype/fsl/contrast_mgr_callables.py
+++ b/example-specs/task/nipype/fsl/contrast_mgr_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in ContrastMgr.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of ContrastMgr.yaml"""
diff --git a/example-specs/task/nipype/fsl/convert_warp.yaml b/example-specs/task/nipype/fsl/convert_warp.yaml
index 9243823c..31c0eeb6 100644
--- a/example-specs/task/nipype/fsl/convert_warp.yaml
+++ b/example-specs/task/nipype/fsl/convert_warp.yaml
@@ -38,23 +38,23 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    reference: medimage/nifti1
-    # type=file|default=<undefined>: Name of a file in target space of the full transform.
-    premat: generic/file
-    # type=file|default=<undefined>: filename for pre-transform (affine matrix)
-    warp1: medimage/nifti1
-    # type=file|default=<undefined>: Name of file containing initial warp-fields/coefficients (follows premat). This could e.g. be a fnirt-transform from a subjects structural scan to an average of a group of subjects.
     midmat: generic/file
     # type=file|default=<undefined>: Name of file containing mid-warp-affine transform
-    warp2: generic/file
-    # type=file|default=<undefined>: Name of file containing secondary warp-fields/coefficients (after warp1/midmat but before postmat). This could e.g. be a fnirt-transform from the average of a group of subjects to some standard space (e.g. MNI152).
+    out_file: Path
+    # type=file: Name of output file, containing the warp as field or coefficients.
+    # type=file|default=<undefined>: Name of output file, containing warps that are the combination of all those given as arguments. The format of this will be a field-file (rather than spline coefficients) with any affine components included.
     postmat: generic/file
     # type=file|default=<undefined>: Name of file containing an affine transform (applied last). It could e.g. be an affine transform that maps the MNI152-space into a better approximation to the Talairach-space (if indeed there is one).
+    premat: generic/file
+    # type=file|default=<undefined>: filename for pre-transform (affine matrix)
+    reference: medimage/nifti1
+    # type=file|default=<undefined>: Name of a file in target space of the full transform.
     shift_in_file: generic/file
     # type=file|default=<undefined>: Name of file containing a "shiftmap", a non-linear transform with displacements only in one direction (applied first, before premat). This would typically be a fieldmap that has been pre-processed using fugue that maps a subjects functional (EPI) data onto an undistorted space (i.e. a space that corresponds to his/her true anatomy).
-    out_file: Path
-    # type=file: Name of output file, containing the warp as field or coefficients.
-    # type=file|default=<undefined>: Name of output file, containing warps that are the combination of all those given as arguments. The format of this will be a field-file (rather than spline coefficients) with any affine components included.
+    warp1: medimage/nifti1
+    # type=file|default=<undefined>: Name of file containing initial warp-fields/coefficients (follows premat). This could e.g. be a fnirt-transform from a subjects structural scan to an average of a group of subjects.
+    warp2: generic/file
+    # type=file|default=<undefined>: Name of file containing secondary warp-fields/coefficients (after warp1/midmat but before postmat). This could e.g. be a fnirt-transform from the average of a group of subjects to some standard space (e.g. MNI152).
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/convert_warp_callables.py b/example-specs/task/nipype/fsl/convert_warp_callables.py
index b6a046c7..09e19634 100644
--- a/example-specs/task/nipype/fsl/convert_warp_callables.py
+++ b/example-specs/task/nipype/fsl/convert_warp_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in ConvertWarp.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of ConvertWarp.yaml"""
diff --git a/example-specs/task/nipype/fsl/convert_xfm_callables.py b/example-specs/task/nipype/fsl/convert_xfm_callables.py
index c81ca182..c4ba5ac2 100644
--- a/example-specs/task/nipype/fsl/convert_xfm_callables.py
+++ b/example-specs/task/nipype/fsl/convert_xfm_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in ConvertXFM.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of ConvertXFM.yaml"""
diff --git a/example-specs/task/nipype/fsl/copy_geom.yaml b/example-specs/task/nipype/fsl/copy_geom.yaml
index 44d5cf9f..c6e16e1b 100644
--- a/example-specs/task/nipype/fsl/copy_geom.yaml
+++ b/example-specs/task/nipype/fsl/copy_geom.yaml
@@ -27,10 +27,10 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    in_file: generic/file
-    # type=file|default=<undefined>: source image
     dest_file: generic/file
     # type=file|default=<undefined>: destination image
+    in_file: generic/file
+    # type=file|default=<undefined>: source image
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/copy_geom_callables.py b/example-specs/task/nipype/fsl/copy_geom_callables.py
index 384cdef4..b1b163c5 100644
--- a/example-specs/task/nipype/fsl/copy_geom_callables.py
+++ b/example-specs/task/nipype/fsl/copy_geom_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in CopyGeom.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of CopyGeom.yaml"""
diff --git a/example-specs/task/nipype/fsl/dilate_image.yaml b/example-specs/task/nipype/fsl/dilate_image.yaml
index c22fed3e..dafbfb82 100644
--- a/example-specs/task/nipype/fsl/dilate_image.yaml
+++ b/example-specs/task/nipype/fsl/dilate_image.yaml
@@ -20,10 +20,10 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    kernel_file: generic/file
-    # type=file|default=<undefined>: use external file for kernel
     in_file: generic/file
     # type=file|default=<undefined>: image to operate on
+    kernel_file: generic/file
+    # type=file|default=<undefined>: use external file for kernel
     out_file: Path
     # type=file: image written after calculations
     # type=file|default=<undefined>: image to write
diff --git a/example-specs/task/nipype/fsl/dilate_image_callables.py b/example-specs/task/nipype/fsl/dilate_image_callables.py
index a27b1b06..5a40faf7 100644
--- a/example-specs/task/nipype/fsl/dilate_image_callables.py
+++ b/example-specs/task/nipype/fsl/dilate_image_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in DilateImage.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of DilateImage.yaml"""
diff --git a/example-specs/task/nipype/fsl/distance_map.yaml b/example-specs/task/nipype/fsl/distance_map.yaml
index be2e5104..2bced5c8 100644
--- a/example-specs/task/nipype/fsl/distance_map.yaml
+++ b/example-specs/task/nipype/fsl/distance_map.yaml
@@ -31,13 +31,13 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    distance_map: Path
+    # type=file: value is distance to nearest nonzero voxels
+    # type=file|default=<undefined>: distance map to write
     in_file: generic/file
     # type=file|default=<undefined>: image to calculate distance values for
     mask_file: generic/file
     # type=file|default=<undefined>: binary mask to constrain calculations
-    distance_map: Path
-    # type=file: value is distance to nearest nonzero voxels
-    # type=file|default=<undefined>: distance map to write
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/distance_map_callables.py b/example-specs/task/nipype/fsl/distance_map_callables.py
index e8ef0b5f..25cceb09 100644
--- a/example-specs/task/nipype/fsl/distance_map_callables.py
+++ b/example-specs/task/nipype/fsl/distance_map_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in DistanceMap.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of DistanceMap.yaml"""
diff --git a/example-specs/task/nipype/fsl/dti_fit.yaml b/example-specs/task/nipype/fsl/dti_fit.yaml
index 93b9163d..cd97a22e 100644
--- a/example-specs/task/nipype/fsl/dti_fit.yaml
+++ b/example-specs/task/nipype/fsl/dti_fit.yaml
@@ -36,18 +36,18 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    dwi: medimage/nifti1
-    # type=file|default=<undefined>: diffusion weighted image data file
-    mask: medimage/nifti1
-    # type=file|default=<undefined>: bet binary mask file
-    bvecs: medimage/bvec
-    # type=file|default=<undefined>: b vectors file
     bvals: medimage/bval
     # type=file|default=<undefined>: b values file
+    bvecs: medimage/bvec
+    # type=file|default=<undefined>: b vectors file
     cni: generic/file
     # type=file|default=<undefined>: input counfound regressors
+    dwi: medimage/nifti1
+    # type=file|default=<undefined>: diffusion weighted image data file
     gradnonlin: generic/file
     # type=file|default=<undefined>: gradient non linearities
+    mask: medimage/nifti1
+    # type=file|default=<undefined>: bet binary mask file
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -61,12 +61,8 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    V1: generic/file
-    # type=file: path/name of file with the 1st eigenvector
-    V2: generic/file
-    # type=file: path/name of file with the 2nd eigenvector
-    V3: generic/file
-    # type=file: path/name of file with the 3rd eigenvector
+    FA: generic/file
+    # type=file: path/name of file with the fractional anisotropy
     L1: generic/file
     # type=file: path/name of file with the 1st eigenvalue
     L2: generic/file
@@ -75,17 +71,21 @@ outputs:
     # type=file: path/name of file with the 3rd eigenvalue
     MD: generic/file
     # type=file: path/name of file with the mean diffusivity
-    FA: generic/file
-    # type=file: path/name of file with the fractional anisotropy
     MO: generic/file
     # type=file: path/name of file with the mode of anisotropy
     S0: generic/file
     # type=file: path/name of file with the raw T2 signal with no diffusion weighting
-    tensor: generic/file
-    # type=file: path/name of file with the 4D tensor volume
+    V1: generic/file
+    # type=file: path/name of file with the 1st eigenvector
+    V2: generic/file
+    # type=file: path/name of file with the 2nd eigenvector
+    V3: generic/file
+    # type=file: path/name of file with the 3rd eigenvector
     sse: generic/file
     # type=file: path/name of file with the summed squared error
     # type=bool|default=False: output sum of squared errors
+    tensor: generic/file
+    # type=file: path/name of file with the 4D tensor volume
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/fsl/dti_fit_callables.py b/example-specs/task/nipype/fsl/dti_fit_callables.py
index 5d71e93e..2cbb4e91 100644
--- a/example-specs/task/nipype/fsl/dti_fit_callables.py
+++ b/example-specs/task/nipype/fsl/dti_fit_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in DTIFit.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of DTIFit.yaml"""
diff --git a/example-specs/task/nipype/fsl/dual_regression.yaml b/example-specs/task/nipype/fsl/dual_regression.yaml
index 912d74e4..ab6d490b 100644
--- a/example-specs/task/nipype/fsl/dual_regression.yaml
+++ b/example-specs/task/nipype/fsl/dual_regression.yaml
@@ -36,14 +36,14 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    in_files: medimage/nifti1+list-of
-    # type=inputmultiobject|default=[]: List all subjects' preprocessed, standard-space 4D datasets
-    group_IC_maps_4D: medimage/nifti1
-    # type=file|default=<undefined>: 4D image containing spatial IC maps (melodic_IC) from the whole-group ICA analysis
-    design_file: generic/file
-    # type=file|default=<undefined>: Design matrix for final cross-subject modelling with randomise
     con_file: generic/file
     # type=file|default=<undefined>: Design contrasts for final cross-subject modelling with randomise
+    design_file: generic/file
+    # type=file|default=<undefined>: Design matrix for final cross-subject modelling with randomise
+    group_IC_maps_4D: medimage/nifti1
+    # type=file|default=<undefined>: 4D image containing spatial IC maps (melodic_IC) from the whole-group ICA analysis
+    in_files: medimage/nifti1+list-of
+    # type=inputmultiobject|default=[]: List all subjects' preprocessed, standard-space 4D datasets
     out_dir: Path
     # type=directory: 
     # type=directory|default='output': This directory will be created to hold all output and logfiles
diff --git a/example-specs/task/nipype/fsl/dual_regression_callables.py b/example-specs/task/nipype/fsl/dual_regression_callables.py
index 1e6cc354..6c58bd05 100644
--- a/example-specs/task/nipype/fsl/dual_regression_callables.py
+++ b/example-specs/task/nipype/fsl/dual_regression_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in DualRegression.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of DualRegression.yaml"""
diff --git a/example-specs/task/nipype/fsl/eddy.yaml b/example-specs/task/nipype/fsl/eddy.yaml
index ffe16f1e..ed6f5f73 100644
--- a/example-specs/task/nipype/fsl/eddy.yaml
+++ b/example-specs/task/nipype/fsl/eddy.yaml
@@ -58,32 +58,32 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    in_file: medimage/nifti1
-    # type=file|default=<undefined>: File containing all the images to estimate distortions for
-    in_mask: generic/file
-    # type=file|default=<undefined>: Mask to indicate brain
-    in_index: text/text-file
-    # type=file|default=<undefined>: File containing indices for all volumes in --imain into --acqp and --topup
+    field: generic/file
+    # type=file|default=<undefined>: Non-topup derived fieldmap scaled in Hz
+    field_mat: generic/file
+    # type=file|default=<undefined>: Matrix specifying the relative positions of the fieldmap, --field, and the first volume of the input file, --imain
     in_acqp: generic/file
     # type=file|default=<undefined>: File containing acquisition parameters
-    in_bvec: generic/file
-    # type=file|default=<undefined>: File containing the b-vectors for all volumes in --imain
     in_bval: generic/file
     # type=file|default=<undefined>: File containing the b-values for all volumes in --imain
-    session: generic/file
-    # type=file|default=<undefined>: File containing session indices for all volumes in --imain
+    in_bvec: generic/file
+    # type=file|default=<undefined>: File containing the b-vectors for all volumes in --imain
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: File containing all the images to estimate distortions for
+    in_index: text/text-file
+    # type=file|default=<undefined>: File containing indices for all volumes in --imain into --acqp and --topup
+    in_mask: generic/file
+    # type=file|default=<undefined>: Mask to indicate brain
     in_topup_fieldcoef: generic/file
     # type=file|default=<undefined>: Topup results file containing the field coefficients
     in_topup_movpar: generic/file
     # type=file|default=<undefined>: Topup results file containing the movement parameters (movpar.txt)
-    field: generic/file
-    # type=file|default=<undefined>: Non-topup derived fieldmap scaled in Hz
-    field_mat: generic/file
-    # type=file|default=<undefined>: Matrix specifying the relative positions of the fieldmap, --field, and the first volume of the input file, --imain
-    slice_order: text/text-file
-    # type=file|default='': Name of text file completely specifying slice/group acquisition
     json: generic/file
     # type=file|default='': Name of .json text file with information about slice timing
+    session: generic/file
+    # type=file|default=<undefined>: File containing session indices for all volumes in --imain
+    slice_order: text/text-file
+    # type=file|default='': Name of text file completely specifying slice/group acquisition
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -97,36 +97,36 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    out_cnr_maps: generic/file
+    # type=file: path/name of file with the cnr_maps
     out_corrected: generic/file
     # type=file: 4D image file containing all the corrected volumes
-    out_parameter: generic/file
-    # type=file: Text file with parameters defining the field and movement for each scan
-    out_rotated_bvecs: generic/file
-    # type=file: File containing rotated b-values for all volumes
+    out_movement_over_time: generic/file
+    # type=file: Text file containing translations (mm) and rotations (radians) for each excitation
     out_movement_rms: generic/file
     # type=file: Summary of the 'total movement' in each volume
-    out_restricted_movement_rms: generic/file
-    # type=file: Summary of the 'total movement' in each volume disregarding translation in the PE direction
-    out_shell_alignment_parameters: generic/file
-    # type=file: Text file containing rigid body movement parameters between the different shells as estimated by a post-hoc mutual information based registration
-    out_shell_pe_translation_parameters: generic/file
-    # type=file: Text file containing translation along the PE-direction between the different shells as estimated by a post-hoc mutual information based registration
+    out_outlier_free: generic/file
+    # type=file: 4D image file not corrected for susceptibility or eddy-current distortions or subject movement but with outlier slices replaced
     out_outlier_map: generic/file
     # type=file: Matrix where rows represent volumes and columns represent slices. "0" indicates that scan-slice is not an outlier and "1" indicates that it is
-    out_outlier_n_stdev_map: generic/file
-    # type=file: Matrix where rows represent volumes and columns represent slices. Values indicate number of standard deviations off the mean difference between observation and prediction is
     out_outlier_n_sqr_stdev_map: generic/file
     # type=file: Matrix where rows represent volumes and columns represent slices. Values indicate number of standard deivations off the square root of the mean squared difference between observation and prediction is
+    out_outlier_n_stdev_map: generic/file
+    # type=file: Matrix where rows represent volumes and columns represent slices. Values indicate number of standard deviations off the mean difference between observation and prediction is
     out_outlier_report: generic/file
     # type=file: Text file with a plain language report on what outlier slices eddy has found
-    out_outlier_free: generic/file
-    # type=file: 4D image file not corrected for susceptibility or eddy-current distortions or subject movement but with outlier slices replaced
-    out_movement_over_time: generic/file
-    # type=file: Text file containing translations (mm) and rotations (radians) for each excitation
-    out_cnr_maps: generic/file
-    # type=file: path/name of file with the cnr_maps
+    out_parameter: generic/file
+    # type=file: Text file with parameters defining the field and movement for each scan
     out_residuals: generic/file
     # type=file: path/name of file with the residuals
+    out_restricted_movement_rms: generic/file
+    # type=file: Summary of the 'total movement' in each volume disregarding translation in the PE direction
+    out_rotated_bvecs: generic/file
+    # type=file: File containing rotated b-values for all volumes
+    out_shell_alignment_parameters: generic/file
+    # type=file: Text file containing rigid body movement parameters between the different shells as estimated by a post-hoc mutual information based registration
+    out_shell_pe_translation_parameters: generic/file
+    # type=file: Text file containing translation along the PE-direction between the different shells as estimated by a post-hoc mutual information based registration
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/fsl/eddy_callables.py b/example-specs/task/nipype/fsl/eddy_callables.py
index 8b90e546..d52a039a 100644
--- a/example-specs/task/nipype/fsl/eddy_callables.py
+++ b/example-specs/task/nipype/fsl/eddy_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in Eddy.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of Eddy.yaml"""
diff --git a/example-specs/task/nipype/fsl/eddy_correct.yaml b/example-specs/task/nipype/fsl/eddy_correct.yaml
index 4b48aa5d..8afb9f66 100644
--- a/example-specs/task/nipype/fsl/eddy_correct.yaml
+++ b/example-specs/task/nipype/fsl/eddy_correct.yaml
@@ -36,7 +36,7 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/nifti1
     # type=file|default=<undefined>: 4D input file
-    out_file: medimage/nifti1
+    out_file: Path
     # type=file|default=<undefined>: 4D output file
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
@@ -96,7 +96,7 @@ tests:
   # (if not specified, will try to choose a sensible value)
     in_file:
     # type=file|default=<undefined>: 4D input file
-    out_file:
+    out_file: '"diffusion_edc.nii"'
     # type=file|default=<undefined>: 4D output file
     ref_num: '0'
     # type=int|default=0: reference number
@@ -124,7 +124,7 @@ doctests:
   # '.mock()' method of the corresponding class is used instead.
     in_file:
     # type=file|default=<undefined>: 4D input file
-    out_file:
+    out_file: '"diffusion_edc.nii"'
     # type=file|default=<undefined>: 4D output file
     ref_num: '0'
     # type=int|default=0: reference number
diff --git a/example-specs/task/nipype/fsl/eddy_correct_callables.py b/example-specs/task/nipype/fsl/eddy_correct_callables.py
index dfb3b961..746a59a5 100644
--- a/example-specs/task/nipype/fsl/eddy_correct_callables.py
+++ b/example-specs/task/nipype/fsl/eddy_correct_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in EddyCorrect.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of EddyCorrect.yaml"""
diff --git a/example-specs/task/nipype/fsl/eddy_quad.yaml b/example-specs/task/nipype/fsl/eddy_quad.yaml
index 1da8a64e..354ed2ca 100644
--- a/example-specs/task/nipype/fsl/eddy_quad.yaml
+++ b/example-specs/task/nipype/fsl/eddy_quad.yaml
@@ -43,18 +43,18 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    idx_file: generic/file
-    # type=file|default=<undefined>: File containing indices for all volumes into acquisition parameters
-    param_file: text/text-file
-    # type=file|default=<undefined>: File containing acquisition parameters
-    mask_file: generic/file
-    # type=file|default=<undefined>: Binary mask file
     bval_file: generic/file
     # type=file|default=<undefined>: b-values file
     bvec_file: generic/file
     # type=file|default=<undefined>: b-vectors file - only used when <base_name>.eddy_residuals file is present
     field: generic/file
     # type=file|default=<undefined>: TOPUP estimated field (in Hz)
+    idx_file: generic/file
+    # type=file|default=<undefined>: File containing indices for all volumes into acquisition parameters
+    mask_file: generic/file
+    # type=file|default=<undefined>: Binary mask file
+    param_file: text/text-file
+    # type=file|default=<undefined>: File containing acquisition parameters
     slice_spec: generic/file
     # type=file|default=<undefined>: Text file specifying slice/group acquisition
   metadata:
@@ -70,16 +70,16 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    clean_volumes: generic/file
+    # type=file: Text file containing a list of clean volumes, based on the eddy squared residuals. To generate a version of the pre-processed dataset without outlier volumes, use: `fslselectvols -i <eddy_corrected_data> -o eddy_corrected_data_clean --vols=vols_no_outliers.txt`
     qc_json: generic/file
     # type=file: Single subject database containing quality metrics and data info.
     qc_pdf: generic/file
     # type=file: Single subject QC report.
-    vdm_png: generic/file
-    # type=file: Image showing mid-sagittal, -coronal and -axial slices of the voxel displacement map. Generated when using the -f option.
     residuals: generic/file
     # type=file: Text file containing the volume-wise mask-averaged squared residuals. Generated when residual maps are available.
-    clean_volumes: generic/file
-    # type=file: Text file containing a list of clean volumes, based on the eddy squared residuals. To generate a version of the pre-processed dataset without outlier volumes, use: `fslselectvols -i <eddy_corrected_data> -o eddy_corrected_data_clean --vols=vols_no_outliers.txt`
+    vdm_png: generic/file
+    # type=file: Image showing mid-sagittal, -coronal and -axial slices of the voxel displacement map. Generated when using the -f option.
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/fsl/eddy_quad_callables.py b/example-specs/task/nipype/fsl/eddy_quad_callables.py
index 1720ae13..2fb7e400 100644
--- a/example-specs/task/nipype/fsl/eddy_quad_callables.py
+++ b/example-specs/task/nipype/fsl/eddy_quad_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in EddyQuad.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of EddyQuad.yaml"""
diff --git a/example-specs/task/nipype/fsl/epi_de_warp.yaml b/example-specs/task/nipype/fsl/epi_de_warp.yaml
index 398c0cfd..f91e8ef4 100644
--- a/example-specs/task/nipype/fsl/epi_de_warp.yaml
+++ b/example-specs/task/nipype/fsl/epi_de_warp.yaml
@@ -41,14 +41,14 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    mag_file: medimage/nifti1
-    # type=file|default=<undefined>: Magnitude file
     dph_file: medimage/nifti1
     # type=file|default=<undefined>: Phase file assumed to be scaled from 0 to 4095
-    exf_file: generic/file
-    # type=file|default=<undefined>: example func volume (or use epi)
     epi_file: medimage/nifti1
     # type=file|default=<undefined>: EPI volume to unwarp
+    exf_file: generic/file
+    # type=file|default=<undefined>: example func volume (or use epi)
+    mag_file: medimage/nifti1
+    # type=file|default=<undefined>: Magnitude file
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -62,22 +62,22 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    exf_mask: generic/file
+    # type=file: Mask from example functional volume
+    exfdw: generic/file
+    # type=file: dewarped functional volume example
+    # type=string|default='': dewarped example func volume
     unwarped_file: generic/file
     # type=file: unwarped epi file
     vsm_file: generic/file
     # type=file: voxel shift map
-    exfdw: generic/file
-    # type=file: dewarped functional volume example
-    # type=string|default='': dewarped example func volume
-    exf_mask: generic/file
-    # type=file: Mask from example functional volume
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
-    vsm: vsm_callable
-    # type=string|default='': voxel shift map
     tmpdir: tmpdir_callable
     # type=string|default='': tmpdir
+    vsm: vsm_callable
+    # type=string|default='': voxel shift map
   templates:
   # dict[str, str] - `output_file_template` values to be provided to output fields
     exfdw: exfdw
diff --git a/example-specs/task/nipype/fsl/epi_de_warp_callables.py b/example-specs/task/nipype/fsl/epi_de_warp_callables.py
index ebb58d7f..48652261 100644
--- a/example-specs/task/nipype/fsl/epi_de_warp_callables.py
+++ b/example-specs/task/nipype/fsl/epi_de_warp_callables.py
@@ -1,9 +1,9 @@
-"""Module to put any functions that are referred to in EPIDeWarp.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of EPIDeWarp.yaml"""
 
-import os.path as op
-import os
 from pathlib import Path
 import attrs
+import os.path as op
+import os
 
 
 def vsm_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/fsl/epi_reg.yaml b/example-specs/task/nipype/fsl/epi_reg.yaml
index 42b75360..3e81104e 100644
--- a/example-specs/task/nipype/fsl/epi_reg.yaml
+++ b/example-specs/task/nipype/fsl/epi_reg.yaml
@@ -45,16 +45,16 @@ inputs:
   # passed to the field in the automatically generated unittests.
     epi: medimage/nifti1
     # type=file|default=<undefined>: EPI image
-    t1_head: medimage/nifti1
-    # type=file|default=<undefined>: wholehead T1 image
-    t1_brain: medimage/nifti1
-    # type=file|default=<undefined>: brain extracted T1 image
     fmap: medimage/nifti1
     # type=file|default=<undefined>: fieldmap image (in rad/s)
     fmapmag: medimage/nifti1
     # type=file|default=<undefined>: fieldmap magnitude image - wholehead
     fmapmagbrain: medimage/nifti1
     # type=file|default=<undefined>: fieldmap magnitude image - brain extracted
+    t1_brain: medimage/nifti1
+    # type=file|default=<undefined>: brain extracted T1 image
+    t1_head: medimage/nifti1
+    # type=file|default=<undefined>: wholehead T1 image
     weight_image: generic/file
     # type=file|default=<undefined>: weighting image (in T1 space)
     wmseg: Path
@@ -73,35 +73,35 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    out_file: generic/file
-    # type=file: unwarped and coregistered epi input
-    out_1vol: generic/file
-    # type=file: unwarped and coregistered single volume
-    fmap2str_mat: generic/file
-    # type=file: rigid fieldmap-to-structural transform
+    epi2str_inv: generic/file
+    # type=file: rigid structural-to-epi transform
+    epi2str_mat: generic/file
+    # type=file: rigid epi-to-structural transform
     fmap2epi_mat: generic/file
     # type=file: rigid fieldmap-to-epi transform
+    fmap2str_mat: generic/file
+    # type=file: rigid fieldmap-to-structural transform
     fmap_epi: generic/file
     # type=file: fieldmap in epi space
     fmap_str: generic/file
     # type=file: fieldmap in structural space
     fmapmag_str: generic/file
     # type=file: fieldmap magnitude image in structural space
-    epi2str_inv: generic/file
-    # type=file: rigid structural-to-epi transform
-    epi2str_mat: generic/file
-    # type=file: rigid epi-to-structural transform
-    shiftmap: generic/file
-    # type=file: shiftmap in epi space
     fullwarp: generic/file
     # type=file: warpfield to unwarp epi and transform into                     structural space
-    wmseg: generic/file
-    # type=file: white matter segmentation used in flirt bbr
-    # type=file|default=<undefined>: white matter segmentation of T1 image, has to be named                  like the t1brain and end on _wmseg
+    out_1vol: generic/file
+    # type=file: unwarped and coregistered single volume
+    out_file: generic/file
+    # type=file: unwarped and coregistered epi input
     seg: generic/file
     # type=file: white matter, gray matter, csf segmentation
+    shiftmap: generic/file
+    # type=file: shiftmap in epi space
     wmedge: generic/file
     # type=file: white matter edges for visualization
+    wmseg: generic/file
+    # type=file: white matter segmentation used in flirt bbr
+    # type=file|default=<undefined>: white matter segmentation of T1 image, has to be named                  like the t1brain and end on _wmseg
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/fsl/epi_reg_callables.py b/example-specs/task/nipype/fsl/epi_reg_callables.py
index 06d672a6..f595e74a 100644
--- a/example-specs/task/nipype/fsl/epi_reg_callables.py
+++ b/example-specs/task/nipype/fsl/epi_reg_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in EpiReg.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of EpiReg.yaml"""
diff --git a/example-specs/task/nipype/fsl/erode_image.yaml b/example-specs/task/nipype/fsl/erode_image.yaml
index 2c5e065b..943984c4 100644
--- a/example-specs/task/nipype/fsl/erode_image.yaml
+++ b/example-specs/task/nipype/fsl/erode_image.yaml
@@ -20,10 +20,10 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    kernel_file: generic/file
-    # type=file|default=<undefined>: use external file for kernel
     in_file: generic/file
     # type=file|default=<undefined>: image to operate on
+    kernel_file: generic/file
+    # type=file|default=<undefined>: use external file for kernel
     out_file: Path
     # type=file: image written after calculations
     # type=file|default=<undefined>: image to write
diff --git a/example-specs/task/nipype/fsl/erode_image_callables.py b/example-specs/task/nipype/fsl/erode_image_callables.py
index 545fa4d7..9cbdb4b7 100644
--- a/example-specs/task/nipype/fsl/erode_image_callables.py
+++ b/example-specs/task/nipype/fsl/erode_image_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in ErodeImage.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of ErodeImage.yaml"""
diff --git a/example-specs/task/nipype/fsl/extract_roi_callables.py b/example-specs/task/nipype/fsl/extract_roi_callables.py
index 9292403e..4fef61a5 100644
--- a/example-specs/task/nipype/fsl/extract_roi_callables.py
+++ b/example-specs/task/nipype/fsl/extract_roi_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in ExtractROI.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of ExtractROI.yaml"""
diff --git a/example-specs/task/nipype/fsl/fast.yaml b/example-specs/task/nipype/fsl/fast.yaml
index 49871bee..5cf2f7bf 100644
--- a/example-specs/task/nipype/fsl/fast.yaml
+++ b/example-specs/task/nipype/fsl/fast.yaml
@@ -37,14 +37,14 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_files: medimage/nifti1+list-of
     # type=inputmultiobject|default=[]: image, or multi-channel set of images, to be segmented
-    out_basename: generic/file
-    # type=file|default=<undefined>: base name of output files
     init_transform: generic/file
     # type=file|default=<undefined>: <standard2input.mat> initialise using priors
-    other_priors: generic/file+list-of
-    # type=inputmultiobject|default=[]: alternative prior images
     manual_seg: generic/file
     # type=file|default=<undefined>: Filename containing intensities
+    other_priors: generic/file+list-of
+    # type=inputmultiobject|default=[]: alternative prior images
+    out_basename: Path
+    # type=file|default=<undefined>: base name of output files
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -58,12 +58,12 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    tissue_class_map: generic/file
-    # type=file: path/name of binary segmented volume file one val for each class  _seg
     mixeltype: generic/file
     # type=file: path/name of mixeltype volume file _mixeltype
     partial_volume_map: generic/file
     # type=file: path/name of partial volume file _pveseg
+    tissue_class_map: generic/file
+    # type=file: path/name of binary segmented volume file one val for each class  _seg
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
@@ -146,7 +146,7 @@ tests:
   # (if not specified, will try to choose a sensible value)
     in_files:
     # type=inputmultiobject|default=[]: image, or multi-channel set of images, to be segmented
-    out_basename:
+    out_basename: '"fast_"'
     # type=file|default=<undefined>: base name of output files
   imports:
   # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
@@ -172,7 +172,7 @@ doctests:
   # '.mock()' method of the corresponding class is used instead.
     in_files:
     # type=inputmultiobject|default=[]: image, or multi-channel set of images, to be segmented
-    out_basename:
+    out_basename: '"fast_"'
     # type=file|default=<undefined>: base name of output files
   imports:
   # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
diff --git a/example-specs/task/nipype/fsl/fast_callables.py b/example-specs/task/nipype/fsl/fast_callables.py
index 4e29548b..3ba8f036 100644
--- a/example-specs/task/nipype/fsl/fast_callables.py
+++ b/example-specs/task/nipype/fsl/fast_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in FAST.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of FAST.yaml"""
diff --git a/example-specs/task/nipype/fsl/feat_callables.py b/example-specs/task/nipype/fsl/feat_callables.py
index ac5b32f2..cc49a4c8 100644
--- a/example-specs/task/nipype/fsl/feat_callables.py
+++ b/example-specs/task/nipype/fsl/feat_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in FEAT.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of FEAT.yaml"""
diff --git a/example-specs/task/nipype/fsl/feat_model.yaml b/example-specs/task/nipype/fsl/feat_model.yaml
index 6b7fe8bc..27c52acb 100644
--- a/example-specs/task/nipype/fsl/feat_model.yaml
+++ b/example-specs/task/nipype/fsl/feat_model.yaml
@@ -20,10 +20,10 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    fsf_file: generic/file
-    # type=file|default=<undefined>: File specifying the feat design spec file
     ev_files: generic/file+list-of
     # type=list|default=[]: Event spec files generated by level1design
+    fsf_file: generic/file
+    # type=file|default=<undefined>: File specifying the feat design spec file
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -37,14 +37,14 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    con_file: generic/file
+    # type=file: Contrast file containing contrast vectors
+    design_cov: generic/file
+    # type=file: Graphical representation of design covariance
     design_file: generic/file
     # type=file: Mat file containing ascii matrix for design
     design_image: generic/file
     # type=file: Graphical representation of design matrix
-    design_cov: generic/file
-    # type=file: Graphical representation of design covariance
-    con_file: generic/file
-    # type=file: Contrast file containing contrast vectors
     fcon_file: generic/file
     # type=file: Contrast file containing contrast vectors
   callables:
diff --git a/example-specs/task/nipype/fsl/feat_model_callables.py b/example-specs/task/nipype/fsl/feat_model_callables.py
index ddb4019f..4ce6666d 100644
--- a/example-specs/task/nipype/fsl/feat_model_callables.py
+++ b/example-specs/task/nipype/fsl/feat_model_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in FEATModel.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of FEATModel.yaml"""
diff --git a/example-specs/task/nipype/fsl/feature_extractor_callables.py b/example-specs/task/nipype/fsl/feature_extractor_callables.py
index 1bcc7da7..cf383991 100644
--- a/example-specs/task/nipype/fsl/feature_extractor_callables.py
+++ b/example-specs/task/nipype/fsl/feature_extractor_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in FeatureExtractor.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of FeatureExtractor.yaml"""
diff --git a/example-specs/task/nipype/fsl/filmgls.yaml b/example-specs/task/nipype/fsl/filmgls.yaml
index b578ddae..ba632896 100644
--- a/example-specs/task/nipype/fsl/filmgls.yaml
+++ b/example-specs/task/nipype/fsl/filmgls.yaml
@@ -45,19 +45,19 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    tcon_file: generic/file
-    # type=file|default=<undefined>: contrast file containing T-contrasts
+    design_file: generic/file
+    # type=file|default=<undefined>: design matrix file
     fcon_file: generic/file
     # type=file|default=<undefined>: contrast file containing F-contrasts
-    surface: generic/file
-    # type=file|default=<undefined>: input surface for autocorr smoothing in surface-based analyses
     in_file: generic/file
     # type=file|default=<undefined>: input data file
-    design_file: generic/file
-    # type=file|default=<undefined>: design matrix file
     results_dir: Path
     # type=directory: directory storing model estimation output
     # type=directory|default='results': directory to store results in
+    surface: generic/file
+    # type=file|default=<undefined>: input surface for autocorr smoothing in surface-based analyses
+    tcon_file: generic/file
+    # type=file|default=<undefined>: contrast file containing T-contrasts
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -71,19 +71,19 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    residual4d: generic/file
-    # type=file: Model fit residual mean-squared error for each time point
     dof_file: generic/file
     # type=file: degrees of freedom
-    sigmasquareds: generic/file
-    # type=file: summary of residuals, See Woolrich, et. al., 2001
-    thresholdac: generic/file
-    # type=file: The FILM autocorrelation parameters
     logfile: generic/file
     # type=file: FILM run logfile
+    residual4d: generic/file
+    # type=file: Model fit residual mean-squared error for each time point
     results_dir: generic/directory
     # type=directory: directory storing model estimation output
     # type=directory|default='results': directory to store results in
+    sigmasquareds: generic/file
+    # type=file: summary of residuals, See Woolrich, et. al., 2001
+    thresholdac: generic/file
+    # type=file: The FILM autocorrelation parameters
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/fsl/filmgls_callables.py b/example-specs/task/nipype/fsl/filmgls_callables.py
index 2911e6a5..5ba862af 100644
--- a/example-specs/task/nipype/fsl/filmgls_callables.py
+++ b/example-specs/task/nipype/fsl/filmgls_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in FILMGLS.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of FILMGLS.yaml"""
diff --git a/example-specs/task/nipype/fsl/filter_regressor.yaml b/example-specs/task/nipype/fsl/filter_regressor.yaml
index b60feaaf..5ff3d9a5 100644
--- a/example-specs/task/nipype/fsl/filter_regressor.yaml
+++ b/example-specs/task/nipype/fsl/filter_regressor.yaml
@@ -23,10 +23,10 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    in_file: generic/file
-    # type=file|default=<undefined>: input file name (4D image)
     design_file: generic/file
     # type=file|default=<undefined>: name of the matrix with time courses (e.g. GLM design or MELODIC mixing matrix)
+    in_file: generic/file
+    # type=file|default=<undefined>: input file name (4D image)
     mask: generic/file
     # type=file|default=<undefined>: mask image file name
     out_file: Path
diff --git a/example-specs/task/nipype/fsl/filter_regressor_callables.py b/example-specs/task/nipype/fsl/filter_regressor_callables.py
index 9e1cd026..53d67339 100644
--- a/example-specs/task/nipype/fsl/filter_regressor_callables.py
+++ b/example-specs/task/nipype/fsl/filter_regressor_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in FilterRegressor.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of FilterRegressor.yaml"""
diff --git a/example-specs/task/nipype/fsl/find_the_biggest_callables.py b/example-specs/task/nipype/fsl/find_the_biggest_callables.py
index a666e9d9..ac9adbb5 100644
--- a/example-specs/task/nipype/fsl/find_the_biggest_callables.py
+++ b/example-specs/task/nipype/fsl/find_the_biggest_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in FindTheBiggest.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of FindTheBiggest.yaml"""
diff --git a/example-specs/task/nipype/fsl/first.yaml b/example-specs/task/nipype/fsl/first.yaml
index 1863f910..329292f8 100644
--- a/example-specs/task/nipype/fsl/first.yaml
+++ b/example-specs/task/nipype/fsl/first.yaml
@@ -33,12 +33,12 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    affine_file: generic/file
+    # type=file|default=<undefined>: Affine matrix to use (e.g. img2std.mat) (does not re-run registration)
     in_file: generic/file
     # type=file|default=<undefined>: input data file
-    out_file: generic/file
+    out_file: Path
     # type=file|default='segmented': output data file
-    affine_file: generic/file
-    # type=file|default=<undefined>: Affine matrix to use (e.g. img2std.mat) (does not re-run registration)
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/first_callables.py b/example-specs/task/nipype/fsl/first_callables.py
index 08786d5a..d1e94f42 100644
--- a/example-specs/task/nipype/fsl/first_callables.py
+++ b/example-specs/task/nipype/fsl/first_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in FIRST.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of FIRST.yaml"""
diff --git a/example-specs/task/nipype/fsl/flameo.yaml b/example-specs/task/nipype/fsl/flameo.yaml
index d9edd358..71a90216 100644
--- a/example-specs/task/nipype/fsl/flameo.yaml
+++ b/example-specs/task/nipype/fsl/flameo.yaml
@@ -41,22 +41,22 @@ inputs:
   # passed to the field in the automatically generated unittests.
     cope_file: medimage/nifti-gz
     # type=file|default=<undefined>: cope regressor data file
-    var_cope_file: medimage/nifti-gz
-    # type=file|default=<undefined>: varcope weightings data file
-    dof_var_cope_file: generic/file
-    # type=file|default=<undefined>: dof data file for varcope data
-    mask_file: medimage/nifti1
-    # type=file|default=<undefined>: mask file
+    cov_split_file: datascience/text-matrix
+    # type=file|default=<undefined>: ascii matrix specifying the groups the covariance is split into
     design_file: datascience/text-matrix
     # type=file|default=<undefined>: design matrix file
-    t_con_file: medimage-fsl/con
-    # type=file|default=<undefined>: ascii matrix specifying t-contrasts
+    dof_var_cope_file: generic/file
+    # type=file|default=<undefined>: dof data file for varcope data
     f_con_file: generic/file
     # type=file|default=<undefined>: ascii matrix specifying f-contrasts
-    cov_split_file: datascience/text-matrix
-    # type=file|default=<undefined>: ascii matrix specifying the groups the covariance is split into
     log_dir: generic/directory
     # type=directory|default='stats': 
+    mask_file: medimage/nifti1
+    # type=file|default=<undefined>: mask file
+    t_con_file: medimage-fsl/con
+    # type=file|default=<undefined>: ascii matrix specifying t-contrasts
+    var_cope_file: medimage/nifti-gz
+    # type=file|default=<undefined>: varcope weightings data file
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/flameo_callables.py b/example-specs/task/nipype/fsl/flameo_callables.py
index d01dd85b..f6edf1f8 100644
--- a/example-specs/task/nipype/fsl/flameo_callables.py
+++ b/example-specs/task/nipype/fsl/flameo_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in FLAMEO.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of FLAMEO.yaml"""
diff --git a/example-specs/task/nipype/fsl/flirt.yaml b/example-specs/task/nipype/fsl/flirt.yaml
index 73b0de1b..6d677c87 100644
--- a/example-specs/task/nipype/fsl/flirt.yaml
+++ b/example-specs/task/nipype/fsl/flirt.yaml
@@ -40,37 +40,37 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    fieldmap: generic/file
+    # type=file|default=<undefined>: fieldmap image in rads/s - must be already registered to the reference image
+    fieldmapmask: generic/file
+    # type=file|default=<undefined>: mask for fieldmap image
     in_file: medimage/nifti1
     # type=file|default=<undefined>: input file
-    reference: medimage/nifti1
-    # type=file|default=<undefined>: reference file
     in_matrix_file: generic/file
     # type=file|default=<undefined>: input 4x4 affine matrix
-    schedule: generic/file
-    # type=file|default=<undefined>: replaces default schedule
-    ref_weight: generic/file
-    # type=file|default=<undefined>: File for reference weighting volume
     in_weight: generic/file
     # type=file|default=<undefined>: File for input weighting volume
-    wm_seg: generic/file
-    # type=file|default=<undefined>: white matter segmentation volume needed by BBR cost function
-    wmcoords: generic/file
-    # type=file|default=<undefined>: white matter boundary coordinates for BBR cost function
-    wmnorms: generic/file
-    # type=file|default=<undefined>: white matter boundary normals for BBR cost function
-    fieldmap: generic/file
-    # type=file|default=<undefined>: fieldmap image in rads/s - must be already registered to the reference image
-    fieldmapmask: generic/file
-    # type=file|default=<undefined>: mask for fieldmap image
     out_file: Path
     # type=file: path/name of registered file (if generated)
     # type=file|default=<undefined>: registered output file
-    out_matrix_file: Path
-    # type=file: path/name of calculated affine transform (if generated)
-    # type=file|default=<undefined>: output affine matrix in 4x4 asciii format
     out_log: Path
     # type=file: path/name of output log (if generated)
     # type=file|default=<undefined>: output log
+    out_matrix_file: Path
+    # type=file: path/name of calculated affine transform (if generated)
+    # type=file|default=<undefined>: output affine matrix in 4x4 asciii format
+    ref_weight: generic/file
+    # type=file|default=<undefined>: File for reference weighting volume
+    reference: medimage/nifti1
+    # type=file|default=<undefined>: reference file
+    schedule: generic/file
+    # type=file|default=<undefined>: replaces default schedule
+    wm_seg: generic/file
+    # type=file|default=<undefined>: white matter segmentation volume needed by BBR cost function
+    wmcoords: generic/file
+    # type=file|default=<undefined>: white matter boundary coordinates for BBR cost function
+    wmnorms: generic/file
+    # type=file|default=<undefined>: white matter boundary normals for BBR cost function
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -87,12 +87,12 @@ outputs:
     out_file: generic/file
     # type=file: path/name of registered file (if generated)
     # type=file|default=<undefined>: registered output file
-    out_matrix_file: generic/file
-    # type=file: path/name of calculated affine transform (if generated)
-    # type=file|default=<undefined>: output affine matrix in 4x4 asciii format
     out_log: generic/file
     # type=file: path/name of output log (if generated)
     # type=file|default=<undefined>: output log
+    out_matrix_file: generic/file
+    # type=file: path/name of calculated affine transform (if generated)
+    # type=file|default=<undefined>: output affine matrix in 4x4 asciii format
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/fsl/flirt_callables.py b/example-specs/task/nipype/fsl/flirt_callables.py
index 1b4f6bd0..81dbf4aa 100644
--- a/example-specs/task/nipype/fsl/flirt_callables.py
+++ b/example-specs/task/nipype/fsl/flirt_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in FLIRT.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of FLIRT.yaml"""
diff --git a/example-specs/task/nipype/fsl/fnirt.yaml b/example-specs/task/nipype/fsl/fnirt.yaml
index 2e7db1ec..94efb952 100644
--- a/example-specs/task/nipype/fsl/fnirt.yaml
+++ b/example-specs/task/nipype/fsl/fnirt.yaml
@@ -49,26 +49,26 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    ref_file: generic/file
-    # type=file|default=<undefined>: name of reference image
-    in_file: generic/file
-    # type=file|default=<undefined>: name of input image
     affine_file: generic/file
     # type=file|default=<undefined>: name of file containing affine transform
-    inwarp_file: generic/file
-    # type=file|default=<undefined>: name of file containing initial non-linear warps
+    in_file: generic/file
+    # type=file|default=<undefined>: name of input image
     in_intensitymap_file: generic/file+list-of
     # type=list|default=[]: name of file/files containing initial intensity mapping usually generated by previous fnirt run
-    refmask_file: generic/file
-    # type=file|default=<undefined>: name of file with mask in reference space
     inmask_file: generic/file
     # type=file|default=<undefined>: name of file with mask in input image space
-    warped_file: Path
-    # type=file: warped image
-    # type=file|default=<undefined>: name of output image
+    inwarp_file: generic/file
+    # type=file|default=<undefined>: name of file containing initial non-linear warps
     log_file: Path
     # type=file: Name of log-file
     # type=file|default=<undefined>: Name of log-file
+    ref_file: generic/file
+    # type=file|default=<undefined>: name of reference image
+    refmask_file: generic/file
+    # type=file|default=<undefined>: name of file with mask in reference space
+    warped_file: Path
+    # type=file: warped image
+    # type=file|default=<undefined>: name of output image
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -82,35 +82,35 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    fieldcoeff_file: generic/file
-    # type=file: file with field coefficients
-    # type=traitcompound|default=None: name of output file with field coefficients or true
-    warped_file: generic/file
-    # type=file: warped image
-    # type=file|default=<undefined>: name of output image
     field_file: generic/file
     # type=file: file with warp field
     # type=traitcompound|default=None: name of output file with field or true
+    fieldcoeff_file: generic/file
+    # type=file: file with field coefficients
+    # type=traitcompound|default=None: name of output file with field coefficients or true
     jacobian_file: generic/file
     # type=file: file containing Jacobian of the field
     # type=traitcompound|default=None: name of file for writing out the Jacobian of the field (for diagnostic or VBM purposes)
-    modulatedref_file: generic/file
-    # type=file: file containing intensity modulated --ref
-    # type=traitcompound|default=None: name of file for writing out intensity modulated --ref (for diagnostic purposes)
     log_file: generic/file
     # type=file: Name of log-file
     # type=file|default=<undefined>: Name of log-file
+    modulatedref_file: generic/file
+    # type=file: file containing intensity modulated --ref
+    # type=traitcompound|default=None: name of file for writing out intensity modulated --ref (for diagnostic purposes)
+    warped_file: generic/file
+    # type=file: warped image
+    # type=file|default=<undefined>: name of output image
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
   templates:
   # dict[str, str] - `output_file_template` values to be provided to output fields
-    warped_file: warped_file
-    # type=file: warped image
-    # type=file|default=<undefined>: name of output image
     log_file: log_file
     # type=file: Name of log-file
     # type=file|default=<undefined>: Name of log-file
+    warped_file: warped_file
+    # type=file: warped image
+    # type=file|default=<undefined>: name of output image
   requirements:
   # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
 tests:
diff --git a/example-specs/task/nipype/fsl/fnirt_callables.py b/example-specs/task/nipype/fsl/fnirt_callables.py
index 6739d9d4..e48495e3 100644
--- a/example-specs/task/nipype/fsl/fnirt_callables.py
+++ b/example-specs/task/nipype/fsl/fnirt_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in FNIRT.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of FNIRT.yaml"""
diff --git a/example-specs/task/nipype/fsl/fslx_command.yaml b/example-specs/task/nipype/fsl/fslx_command.yaml
deleted file mode 100644
index d4a94a91..00000000
--- a/example-specs/task/nipype/fsl/fslx_command.yaml
+++ /dev/null
@@ -1,132 +0,0 @@
-# This file is used to manually specify the semi-automatic conversion of
-# 'nipype.interfaces.fsl.dti.FSLXCommand' from Nipype to Pydra.
-#
-# Please fill-in/edit the fields below where appropriate
-#
-# Docs
-# ----
-# 
-#     Base support for ``xfibres`` and ``bedpostx``
-#     
-task_name: FSLXCommand
-nipype_name: FSLXCommand
-nipype_module: nipype.interfaces.fsl.dti
-inputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    dwi: generic/file
-    # type=file|default=<undefined>: diffusion weighted image data file
-    mask: generic/file
-    # type=file|default=<undefined>: brain binary mask file (i.e. from BET)
-    bvecs: generic/file
-    # type=file|default=<undefined>: b vectors file
-    bvals: generic/file
-    # type=file|default=<undefined>: b values file
-    logdir: generic/directory
-    # type=directory|default='.': 
-  metadata:
-  # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
-outputs:
-  omit:
-  # list[str] - fields to omit from the Pydra interface
-  rename:
-  # dict[str, str] - fields to rename in the Pydra interface
-  types:
-  # dict[str, type] - override inferred types (use "mime-like" string for file-format types,
-  # e.g. 'medimage/nifti-gz'). For most fields the type will be correctly inferred
-  # from the nipype interface, but you may want to be more specific, particularly
-  # for file types, where specifying the format also specifies the file that will be
-  # passed to the field in the automatically generated unittests.
-    mean_dsamples: generic/file
-    # type=file: Mean of distribution on diffusivity d
-    mean_S0samples: generic/file
-    # type=file: Mean of distribution on T2wbaseline signal intensity S0
-    mean_tausamples: generic/file
-    # type=file: Mean of distribution on tau samples (only with rician noise)
-  callables:
-  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
-  # to set to the `callable` attribute of output fields
-  templates:
-  # dict[str, str] - `output_file_template` values to be provided to output fields
-  requirements:
-  # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
-tests:
-- inputs:
-  # dict[str, str] - values to provide to inputs fields in the task initialisation
-  # (if not specified, will try to choose a sensible value)
-    dwi:
-    # type=file|default=<undefined>: diffusion weighted image data file
-    mask:
-    # type=file|default=<undefined>: brain binary mask file (i.e. from BET)
-    bvecs:
-    # type=file|default=<undefined>: b vectors file
-    bvals:
-    # type=file|default=<undefined>: b values file
-    logdir:
-    # type=directory|default='.': 
-    n_fibres:
-    # type=range|default=2: Maximum number of fibres to fit in each voxel
-    model:
-    # type=enum|default=1|allowed[1,2,3]: use monoexponential (1, default, required for single-shell) or multiexponential (2, multi-shell) model
-    fudge:
-    # type=int|default=0: ARD fudge factor
-    n_jumps:
-    # type=int|default=5000: Num of jumps to be made by MCMC
-    burn_in:
-    # type=range|default=0: Total num of jumps at start of MCMC to be discarded
-    burn_in_no_ard:
-    # type=range|default=0: num of burnin jumps before the ard is imposed
-    sample_every:
-    # type=range|default=1: Num of jumps for each sample (MCMC)
-    update_proposal_every:
-    # type=range|default=40: Num of jumps for each update to the proposal density std (MCMC)
-    seed:
-    # type=int|default=0: seed for pseudo random number generator
-    no_ard:
-    # type=bool|default=False: Turn ARD off on all fibres
-    all_ard:
-    # type=bool|default=False: Turn ARD on on all fibres
-    no_spat:
-    # type=bool|default=False: Initialise with tensor, not spatially
-    non_linear:
-    # type=bool|default=False: Initialise with nonlinear fitting
-    cnlinear:
-    # type=bool|default=False: Initialise with constrained nonlinear fitting
-    rician:
-    # type=bool|default=False: use Rician noise modeling
-    f0_noard:
-    # type=bool|default=False: Noise floor model: add to the model an unattenuated signal compartment f0
-    f0_ard:
-    # type=bool|default=False: Noise floor model: add to the model an unattenuated signal compartment f0
-    force_dir:
-    # type=bool|default=True: use the actual directory name given (do not add + to make a new directory)
-    output_type:
-    # type=enum|default='NIFTI'|allowed['NIFTI','NIFTI_GZ','NIFTI_PAIR','NIFTI_PAIR_GZ']: FSL output type
-    args:
-    # type=str|default='': Additional parameters to the command
-    environ:
-    # type=dict|default={}: Environment variables
-  imports:
-  # list[nipype2pydra.task.base.importstatement] - list import statements required by the test, with each list item
-  # consisting of 'module', 'name', and optionally 'alias' keys
-  expected_outputs:
-  # dict[str, str] - expected values for selected outputs, noting that tests will typically
-  # be terminated before they complete for time-saving reasons, and therefore
-  # these values will be ignored, when running in CI
-  timeout: 10
-  # int - the value to set for the timeout in the generated test, 
-  # after which the test will be considered to have been initialised 
-  # successfully. Set to 0 to disable the timeout (warning, this could
-  # lead to the unittests taking a very long time to complete)
-  xfail: true
-  # bool - whether the unittest is expected to fail or not. Set to false
-  # when you are satisfied with the edits you have made to this file
-doctests: []
diff --git a/example-specs/task/nipype/fsl/fslx_command_callables.py b/example-specs/task/nipype/fsl/fslx_command_callables.py
deleted file mode 100644
index 048758af..00000000
--- a/example-specs/task/nipype/fsl/fslx_command_callables.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Module to put any functions that are referred to in FSLXCommand.yaml"""
diff --git a/example-specs/task/nipype/fsl/fugue.yaml b/example-specs/task/nipype/fsl/fugue.yaml
index 6f064553..ca21c208 100644
--- a/example-specs/task/nipype/fsl/fugue.yaml
+++ b/example-specs/task/nipype/fsl/fugue.yaml
@@ -82,28 +82,28 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    in_file: medimage/nifti1
-    # type=file|default=<undefined>: filename of input volume
-    shift_in_file: medimage/nifti1
-    # type=file|default=<undefined>: filename for reading pixel shift volume
-    phasemap_in_file: medimage/nifti1
-    # type=file|default=<undefined>: filename for input phase image
     fmap_in_file: generic/file
     # type=file|default=<undefined>: filename for loading fieldmap (rad/s)
+    fmap_out_file: Path
+    # type=file: fieldmap file
+    # type=file|default=<undefined>: filename for saving fieldmap (rad/s)
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: filename of input volume
     mask_file: medimage/nifti1
     # type=file|default=<undefined>: filename for loading valid mask
+    phasemap_in_file: medimage/nifti1
+    # type=file|default=<undefined>: filename for input phase image
+    shift_in_file: medimage/nifti1
+    # type=file|default=<undefined>: filename for reading pixel shift volume
+    shift_out_file: Path
+    # type=file: voxel shift map file
+    # type=file|default=<undefined>: filename for saving pixel shift volume
     unwarped_file: Path
     # type=file: unwarped file
     # type=file|default=<undefined>: apply unwarping and save as filename
     warped_file: Path
     # type=file: forward warped file
     # type=file|default=<undefined>: apply forward warping and save as filename
-    shift_out_file: Path
-    # type=file: voxel shift map file
-    # type=file|default=<undefined>: filename for saving pixel shift volume
-    fmap_out_file: Path
-    # type=file: fieldmap file
-    # type=file|default=<undefined>: filename for saving fieldmap (rad/s)
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -117,18 +117,18 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    fmap_out_file: generic/file
+    # type=file: fieldmap file
+    # type=file|default=<undefined>: filename for saving fieldmap (rad/s)
+    shift_out_file: generic/file
+    # type=file: voxel shift map file
+    # type=file|default=<undefined>: filename for saving pixel shift volume
     unwarped_file: generic/file
     # type=file: unwarped file
     # type=file|default=<undefined>: apply unwarping and save as filename
     warped_file: generic/file
     # type=file: forward warped file
     # type=file|default=<undefined>: apply forward warping and save as filename
-    shift_out_file: generic/file
-    # type=file: voxel shift map file
-    # type=file|default=<undefined>: filename for saving pixel shift volume
-    fmap_out_file: generic/file
-    # type=file: fieldmap file
-    # type=file|default=<undefined>: filename for saving fieldmap (rad/s)
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/fsl/fugue_callables.py b/example-specs/task/nipype/fsl/fugue_callables.py
index 3d58eb5d..142154ca 100644
--- a/example-specs/task/nipype/fsl/fugue_callables.py
+++ b/example-specs/task/nipype/fsl/fugue_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in FUGUE.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of FUGUE.yaml"""
diff --git a/example-specs/task/nipype/fsl/glm.yaml b/example-specs/task/nipype/fsl/glm.yaml
index ef2da8f4..0e402987 100644
--- a/example-specs/task/nipype/fsl/glm.yaml
+++ b/example-specs/task/nipype/fsl/glm.yaml
@@ -30,40 +30,40 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    in_file: medimage/nifti1
-    # type=file|default=<undefined>: input file name (text matrix or 3D/4D image file)
-    design: medimage/nifti1
-    # type=file|default=<undefined>: file name of the GLM design matrix (text time courses for temporal regression or an image file for spatial regression)
     contrasts: generic/file
     # type=file|default=<undefined>: matrix of t-statics contrasts
+    design: medimage/nifti1
+    # type=file|default=<undefined>: file name of the GLM design matrix (text time courses for temporal regression or an image file for spatial regression)
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: input file name (text matrix or 3D/4D image file)
     mask: generic/file
     # type=file|default=<undefined>: mask image file name if input is image
-    out_cope: generic/file
+    out_cope: Path
     # type=outputmultiobject: output file name for COPEs (either as text file or image)
     # type=file|default=<undefined>: output file name for COPE (either as txt or image
-    out_z_name: generic/file
-    # type=file|default=<undefined>: output file name for Z-stats (either as txt or image
-    out_t_name: generic/file
-    # type=file|default=<undefined>: output file name for t-stats (either as txt or image
-    out_p_name: generic/file
-    # type=file|default=<undefined>: output file name for p-values of Z-stats (either as text file or image)
-    out_f_name: generic/file
+    out_data_name: Path
+    # type=file|default=<undefined>: output file name for pre-processed data
+    out_f_name: Path
     # type=file|default=<undefined>: output file name for F-value of full model fit
-    out_pf_name: generic/file
+    out_file: Path
+    # type=file: file name of GLM parameters (if generated)
+    # type=file|default=<undefined>: filename for GLM parameter estimates (GLM betas)
+    out_p_name: Path
+    # type=file|default=<undefined>: output file name for p-values of Z-stats (either as text file or image)
+    out_pf_name: Path
     # type=file|default=<undefined>: output file name for p-value for full model fit
-    out_res_name: generic/file
+    out_res_name: Path
     # type=file|default=<undefined>: output file name for residuals
-    out_varcb_name: generic/file
-    # type=file|default=<undefined>: output file name for variance of COPEs
-    out_sigsq_name: generic/file
+    out_sigsq_name: Path
     # type=file|default=<undefined>: output file name for residual noise variance sigma-square
-    out_data_name: generic/file
-    # type=file|default=<undefined>: output file name for pre-processed data
-    out_vnscales_name: generic/file
+    out_t_name: Path
+    # type=file|default=<undefined>: output file name for t-stats (either as txt or image
+    out_varcb_name: Path
+    # type=file|default=<undefined>: output file name for variance of COPEs
+    out_vnscales_name: Path
     # type=file|default=<undefined>: output file name for scaling factors for variance normalisation
-    out_file: Path
-    # type=file: file name of GLM parameters (if generated)
-    # type=file|default=<undefined>: filename for GLM parameter estimates (GLM betas)
+    out_z_name: Path
+    # type=file|default=<undefined>: output file name for Z-stats (either as txt or image
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/glm_callables.py b/example-specs/task/nipype/fsl/glm_callables.py
index e54bc448..c1050522 100644
--- a/example-specs/task/nipype/fsl/glm_callables.py
+++ b/example-specs/task/nipype/fsl/glm_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in GLM.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of GLM.yaml"""
diff --git a/example-specs/task/nipype/fsl/ica__aroma.yaml b/example-specs/task/nipype/fsl/ica__aroma.yaml
index d3768262..d6b80bc6 100644
--- a/example-specs/task/nipype/fsl/ica__aroma.yaml
+++ b/example-specs/task/nipype/fsl/ica__aroma.yaml
@@ -46,20 +46,20 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    feat_dir: generic/directory
+    # type=directory|default=<undefined>: If a feat directory exists and temporal filtering has not been run yet, ICA_AROMA can use the files in this directory.
+    fnirt_warp_file: medimage/nifti1
+    # type=file|default=<undefined>: File name of the warp-file describing the non-linear registration (e.g. FSL FNIRT) of the structural data to MNI152 space (.nii.gz)
     in_file: medimage/nifti1
     # type=file|default=<undefined>: volume to be denoised
     mask: medimage/nifti-gz
     # type=file|default=<undefined>: path/name volume mask
     mat_file: datascience/text-matrix
     # type=file|default=<undefined>: path/name of the mat-file describing the affine registration (e.g. FSL FLIRT) of the functional data to structural space (.mat file)
-    fnirt_warp_file: medimage/nifti1
-    # type=file|default=<undefined>: File name of the warp-file describing the non-linear registration (e.g. FSL FNIRT) of the structural data to MNI152 space (.nii.gz)
-    motion_parameters: text/text-file
-    # type=file|default=<undefined>: motion parameters file
-    feat_dir: generic/directory
-    # type=directory|default=<undefined>: If a feat directory exists and temporal filtering has not been run yet, ICA_AROMA can use the files in this directory.
     melodic_dir: generic/directory
     # type=directory|default=<undefined>: path to MELODIC directory if MELODIC has already been run
+    motion_parameters: text/text-file
+    # type=file|default=<undefined>: motion parameters file
     out_dir: Path
     # type=directory: directory contains (in addition to the denoised files): melodic.ica + classified_motion_components + classification_overview + feature_scores + melodic_ic_mni)
     # type=directory|default='out': output directory
diff --git a/example-specs/task/nipype/fsl/ica__aroma_callables.py b/example-specs/task/nipype/fsl/ica__aroma_callables.py
index ebc5c582..76cdd5ab 100644
--- a/example-specs/task/nipype/fsl/ica__aroma_callables.py
+++ b/example-specs/task/nipype/fsl/ica__aroma_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in ICA_AROMA.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of ICA_AROMA.yaml"""
diff --git a/example-specs/task/nipype/fsl/image_maths_callables.py b/example-specs/task/nipype/fsl/image_maths_callables.py
index af88ca1a..831ceab4 100644
--- a/example-specs/task/nipype/fsl/image_maths_callables.py
+++ b/example-specs/task/nipype/fsl/image_maths_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in ImageMaths.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of ImageMaths.yaml"""
diff --git a/example-specs/task/nipype/fsl/image_meants_callables.py b/example-specs/task/nipype/fsl/image_meants_callables.py
index 0e60de8e..5132ce61 100644
--- a/example-specs/task/nipype/fsl/image_meants_callables.py
+++ b/example-specs/task/nipype/fsl/image_meants_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in ImageMeants.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of ImageMeants.yaml"""
diff --git a/example-specs/task/nipype/fsl/image_stats.yaml b/example-specs/task/nipype/fsl/image_stats.yaml
index 5e6da27c..748e5eb9 100644
--- a/example-specs/task/nipype/fsl/image_stats.yaml
+++ b/example-specs/task/nipype/fsl/image_stats.yaml
@@ -37,10 +37,10 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: generic/file
     # type=file|default=<undefined>: input file to generate stats of
-    mask_file: generic/file
-    # type=file|default=<undefined>: mask file used for option -k %s
     index_mask_file: generic/file
     # type=file|default=<undefined>: generate separate n submasks from indexMask, for indexvalues 1..n where n is the maximum index value in indexMask, and generate statistics for each submask
+    mask_file: generic/file
+    # type=file|default=<undefined>: mask file used for option -k %s
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/image_stats_callables.py b/example-specs/task/nipype/fsl/image_stats_callables.py
index 1a145967..ed9ee2e9 100644
--- a/example-specs/task/nipype/fsl/image_stats_callables.py
+++ b/example-specs/task/nipype/fsl/image_stats_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in ImageStats.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of ImageStats.yaml"""
diff --git a/example-specs/task/nipype/fsl/inv_warp.yaml b/example-specs/task/nipype/fsl/inv_warp.yaml
index 203b81e4..134c7541 100644
--- a/example-specs/task/nipype/fsl/inv_warp.yaml
+++ b/example-specs/task/nipype/fsl/inv_warp.yaml
@@ -37,13 +37,13 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    warp: medimage/nifti1
-    # type=file|default=<undefined>: Name of file containing warp-coefficients/fields. This would typically be the output from the --cout switch of fnirt (but can also use fields, like the output from --fout).
-    reference: medimage/nifti1
-    # type=file|default=<undefined>: Name of a file in target space. Note that the target space is now different from the target space that was used to create the --warp file. It would typically be the file that was specified with the --in argument when running fnirt.
     inverse_warp: Path
     # type=file: Name of output file, containing warps that are the "reverse" of those in --warp.
     # type=file|default=<undefined>: Name of output file, containing warps that are the "reverse" of those in --warp. This will be a field-file (rather than a file of spline coefficients), and it will have any affine component included as part of the displacements.
+    reference: medimage/nifti1
+    # type=file|default=<undefined>: Name of a file in target space. Note that the target space is now different from the target space that was used to create the --warp file. It would typically be the file that was specified with the --in argument when running fnirt.
+    warp: medimage/nifti1
+    # type=file|default=<undefined>: Name of file containing warp-coefficients/fields. This would typically be the output from the --cout switch of fnirt (but can also use fields, like the output from --fout).
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/inv_warp_callables.py b/example-specs/task/nipype/fsl/inv_warp_callables.py
index 3df23d87..88c75fd3 100644
--- a/example-specs/task/nipype/fsl/inv_warp_callables.py
+++ b/example-specs/task/nipype/fsl/inv_warp_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in InvWarp.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of InvWarp.yaml"""
diff --git a/example-specs/task/nipype/fsl/isotropic_smooth_callables.py b/example-specs/task/nipype/fsl/isotropic_smooth_callables.py
index cb3b0b01..b5f489b7 100644
--- a/example-specs/task/nipype/fsl/isotropic_smooth_callables.py
+++ b/example-specs/task/nipype/fsl/isotropic_smooth_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in IsotropicSmooth.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of IsotropicSmooth.yaml"""
diff --git a/example-specs/task/nipype/fsl/l2_model.yaml b/example-specs/task/nipype/fsl/l2_model.yaml
index 9122537c..6276feef 100644
--- a/example-specs/task/nipype/fsl/l2_model.yaml
+++ b/example-specs/task/nipype/fsl/l2_model.yaml
@@ -41,12 +41,12 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    design_mat: generic/file
-    # type=file: design matrix file
     design_con: generic/file
     # type=file: design contrast file
     design_grp: generic/file
     # type=file: design group file
+    design_mat: generic/file
+    # type=file: design matrix file
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/fsl/l2_model_callables.py b/example-specs/task/nipype/fsl/l2_model_callables.py
index 05b7a8ce..abebe77c 100644
--- a/example-specs/task/nipype/fsl/l2_model_callables.py
+++ b/example-specs/task/nipype/fsl/l2_model_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in L2Model.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of L2Model.yaml"""
diff --git a/example-specs/task/nipype/fsl/level_1_design_callables.py b/example-specs/task/nipype/fsl/level_1_design_callables.py
index 0558037d..936f279e 100644
--- a/example-specs/task/nipype/fsl/level_1_design_callables.py
+++ b/example-specs/task/nipype/fsl/level_1_design_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in Level1Design.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of Level1Design.yaml"""
diff --git a/example-specs/task/nipype/fsl/make_dyadic_vectors.yaml b/example-specs/task/nipype/fsl/make_dyadic_vectors.yaml
index 633027e9..264c87df 100644
--- a/example-specs/task/nipype/fsl/make_dyadic_vectors.yaml
+++ b/example-specs/task/nipype/fsl/make_dyadic_vectors.yaml
@@ -21,14 +21,14 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    theta_vol: generic/file
-    # type=file|default=<undefined>: 
-    phi_vol: generic/file
-    # type=file|default=<undefined>: 
     mask: generic/file
     # type=file|default=<undefined>: 
     output: generic/file
     # type=file|default='dyads': 
+    phi_vol: generic/file
+    # type=file|default=<undefined>: 
+    theta_vol: generic/file
+    # type=file|default=<undefined>: 
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -42,10 +42,10 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    dyads: generic/file
-    # type=file: 
     dispersion: generic/file
     # type=file: 
+    dyads: generic/file
+    # type=file: 
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/fsl/make_dyadic_vectors_callables.py b/example-specs/task/nipype/fsl/make_dyadic_vectors_callables.py
index 3864dbd7..8e6285b5 100644
--- a/example-specs/task/nipype/fsl/make_dyadic_vectors_callables.py
+++ b/example-specs/task/nipype/fsl/make_dyadic_vectors_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in MakeDyadicVectors.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of MakeDyadicVectors.yaml"""
diff --git a/example-specs/task/nipype/fsl/maths_command_callables.py b/example-specs/task/nipype/fsl/maths_command_callables.py
index 84e0f131..a952571f 100644
--- a/example-specs/task/nipype/fsl/maths_command_callables.py
+++ b/example-specs/task/nipype/fsl/maths_command_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in MathsCommand.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of MathsCommand.yaml"""
diff --git a/example-specs/task/nipype/fsl/max_image_callables.py b/example-specs/task/nipype/fsl/max_image_callables.py
index 940bd9a0..2c2f6c1c 100644
--- a/example-specs/task/nipype/fsl/max_image_callables.py
+++ b/example-specs/task/nipype/fsl/max_image_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in MaxImage.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of MaxImage.yaml"""
diff --git a/example-specs/task/nipype/fsl/maxn_image_callables.py b/example-specs/task/nipype/fsl/maxn_image_callables.py
index 31eb42f2..3c27500d 100644
--- a/example-specs/task/nipype/fsl/maxn_image_callables.py
+++ b/example-specs/task/nipype/fsl/maxn_image_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in MaxnImage.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of MaxnImage.yaml"""
diff --git a/example-specs/task/nipype/fsl/mcflirt.yaml b/example-specs/task/nipype/fsl/mcflirt.yaml
index 4dfd6b10..6f578245 100644
--- a/example-specs/task/nipype/fsl/mcflirt.yaml
+++ b/example-specs/task/nipype/fsl/mcflirt.yaml
@@ -40,11 +40,11 @@ inputs:
     # type=file|default=<undefined>: timeseries to motion-correct
     init: generic/file
     # type=file|default=<undefined>: initial transformation matrix
-    ref_file: generic/file
-    # type=file|default=<undefined>: target image for motion correction
     out_file: Path
     # type=file: motion-corrected timeseries
     # type=file|default=<undefined>: file to write
+    ref_file: generic/file
+    # type=file|default=<undefined>: target image for motion correction
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -58,17 +58,17 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    mean_img: generic/file
+    # type=file: mean timeseries image (if mean_vol=True)
     out_file: medimage/nifti1
     # type=file: motion-corrected timeseries
     # type=file|default=<undefined>: file to write
-    variance_img: generic/file
-    # type=file: variance image
-    std_img: generic/file
-    # type=file: standard deviation image
-    mean_img: generic/file
-    # type=file: mean timeseries image (if mean_vol=True)
     par_file: generic/file
     # type=file: text-file with motion parameters
+    std_img: generic/file
+    # type=file: standard deviation image
+    variance_img: generic/file
+    # type=file: variance image
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/fsl/mcflirt_callables.py b/example-specs/task/nipype/fsl/mcflirt_callables.py
index 7fb6bc8c..d8aee9f1 100644
--- a/example-specs/task/nipype/fsl/mcflirt_callables.py
+++ b/example-specs/task/nipype/fsl/mcflirt_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in MCFLIRT.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of MCFLIRT.yaml"""
diff --git a/example-specs/task/nipype/fsl/mean_image_callables.py b/example-specs/task/nipype/fsl/mean_image_callables.py
index 1d3333ca..bc7a08f8 100644
--- a/example-specs/task/nipype/fsl/mean_image_callables.py
+++ b/example-specs/task/nipype/fsl/mean_image_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in MeanImage.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of MeanImage.yaml"""
diff --git a/example-specs/task/nipype/fsl/median_image_callables.py b/example-specs/task/nipype/fsl/median_image_callables.py
index d4df040b..492c6bf4 100644
--- a/example-specs/task/nipype/fsl/median_image_callables.py
+++ b/example-specs/task/nipype/fsl/median_image_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in MedianImage.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of MedianImage.yaml"""
diff --git a/example-specs/task/nipype/fsl/melodic.yaml b/example-specs/task/nipype/fsl/melodic.yaml
index d0ed11f2..5917e209 100644
--- a/example-specs/task/nipype/fsl/melodic.yaml
+++ b/example-specs/task/nipype/fsl/melodic.yaml
@@ -44,29 +44,29 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    ICs: generic/file
+    # type=file|default=<undefined>: filename of the IC components file for mixture modelling
+    bg_image: generic/file
+    # type=file|default=<undefined>: specify background image for report (default: mean image)
     in_files: medimage/nifti1+list-of
     # type=inputmultiobject|default=[]: input file names (either single file name or a list)
     mask: generic/file
     # type=file|default=<undefined>: file name of mask for thresholding
-    ICs: generic/file
-    # type=file|default=<undefined>: filename of the IC components file for mixture modelling
     mix: generic/file
     # type=file|default=<undefined>: mixing matrix for mixture modelling / filtering
+    out_dir: Path
+    # type=directory: 
+    # type=directory|default=<undefined>: output directory name
+    s_con: medimage-fsl/con
+    # type=file|default=<undefined>: t-contrast matrix across subject-domain
+    s_des: datascience/text-matrix
+    # type=file|default=<undefined>: design matrix across subject-domain
     smode: generic/file
     # type=file|default=<undefined>: matrix of session modes for report generation
-    bg_image: generic/file
-    # type=file|default=<undefined>: specify background image for report (default: mean image)
-    t_des: datascience/text-matrix
-    # type=file|default=<undefined>: design matrix across time-domain
     t_con: medimage-fsl/con
     # type=file|default=<undefined>: t-contrast matrix across time-domain
-    s_des: datascience/text-matrix
-    # type=file|default=<undefined>: design matrix across subject-domain
-    s_con: medimage-fsl/con
-    # type=file|default=<undefined>: t-contrast matrix across subject-domain
-    out_dir: Path
-    # type=directory: 
-    # type=directory|default=<undefined>: output directory name
+    t_des: datascience/text-matrix
+    # type=file|default=<undefined>: design matrix across time-domain
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/melodic_callables.py b/example-specs/task/nipype/fsl/melodic_callables.py
index b6075b9a..65e696fa 100644
--- a/example-specs/task/nipype/fsl/melodic_callables.py
+++ b/example-specs/task/nipype/fsl/melodic_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in MELODIC.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of MELODIC.yaml"""
diff --git a/example-specs/task/nipype/fsl/merge_callables.py b/example-specs/task/nipype/fsl/merge_callables.py
index 1950a89d..a64071b1 100644
--- a/example-specs/task/nipype/fsl/merge_callables.py
+++ b/example-specs/task/nipype/fsl/merge_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in Merge.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of Merge.yaml"""
diff --git a/example-specs/task/nipype/fsl/min_image_callables.py b/example-specs/task/nipype/fsl/min_image_callables.py
index be3a24b8..e01f3541 100644
--- a/example-specs/task/nipype/fsl/min_image_callables.py
+++ b/example-specs/task/nipype/fsl/min_image_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in MinImage.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of MinImage.yaml"""
diff --git a/example-specs/task/nipype/fsl/motion_outliers.yaml b/example-specs/task/nipype/fsl/motion_outliers.yaml
index bf066ddd..7d98d27f 100644
--- a/example-specs/task/nipype/fsl/motion_outliers.yaml
+++ b/example-specs/task/nipype/fsl/motion_outliers.yaml
@@ -37,12 +37,12 @@ inputs:
     out_file: Path
     # type=file: 
     # type=file|default=<undefined>: output outlier file name
-    out_metric_values: Path
-    # type=file: 
-    # type=file|default=<undefined>: output metric values (DVARS etc.) file name
     out_metric_plot: Path
     # type=file: 
     # type=file|default=<undefined>: output metric values plot (DVARS etc.) file name
+    out_metric_values: Path
+    # type=file: 
+    # type=file|default=<undefined>: output metric values (DVARS etc.) file name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -59,12 +59,12 @@ outputs:
     out_file: generic/file
     # type=file: 
     # type=file|default=<undefined>: output outlier file name
-    out_metric_values: generic/file
-    # type=file: 
-    # type=file|default=<undefined>: output metric values (DVARS etc.) file name
     out_metric_plot: generic/file
     # type=file: 
     # type=file|default=<undefined>: output metric values plot (DVARS etc.) file name
+    out_metric_values: generic/file
+    # type=file: 
+    # type=file|default=<undefined>: output metric values (DVARS etc.) file name
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/fsl/motion_outliers_callables.py b/example-specs/task/nipype/fsl/motion_outliers_callables.py
index 811e8192..00364833 100644
--- a/example-specs/task/nipype/fsl/motion_outliers_callables.py
+++ b/example-specs/task/nipype/fsl/motion_outliers_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in MotionOutliers.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of MotionOutliers.yaml"""
diff --git a/example-specs/task/nipype/fsl/multi_image_maths.yaml b/example-specs/task/nipype/fsl/multi_image_maths.yaml
index c269eb56..e3228269 100644
--- a/example-specs/task/nipype/fsl/multi_image_maths.yaml
+++ b/example-specs/task/nipype/fsl/multi_image_maths.yaml
@@ -33,10 +33,10 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    operand_files: medimage/nifti1+list-of
-    # type=inputmultiobject|default=[]: list of file names to plug into op string
     in_file: medimage/nifti1
     # type=file|default=<undefined>: image to operate on
+    operand_files: medimage/nifti1+list-of
+    # type=inputmultiobject|default=[]: list of file names to plug into op string
     out_file: Path
     # type=file: image written after calculations
     # type=file|default=<undefined>: image to write
diff --git a/example-specs/task/nipype/fsl/multi_image_maths_callables.py b/example-specs/task/nipype/fsl/multi_image_maths_callables.py
index af619ea5..df382bdc 100644
--- a/example-specs/task/nipype/fsl/multi_image_maths_callables.py
+++ b/example-specs/task/nipype/fsl/multi_image_maths_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in MultiImageMaths.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of MultiImageMaths.yaml"""
diff --git a/example-specs/task/nipype/fsl/multiple_regress_design.yaml b/example-specs/task/nipype/fsl/multiple_regress_design.yaml
index 499caa02..58c3bf16 100644
--- a/example-specs/task/nipype/fsl/multiple_regress_design.yaml
+++ b/example-specs/task/nipype/fsl/multiple_regress_design.yaml
@@ -51,14 +51,14 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    design_mat: generic/file
-    # type=file: design matrix file
     design_con: generic/file
     # type=file: design t-contrast file
     design_fts: generic/file
     # type=file: design f-contrast file
     design_grp: generic/file
     # type=file: design group file
+    design_mat: generic/file
+    # type=file: design matrix file
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/fsl/multiple_regress_design_callables.py b/example-specs/task/nipype/fsl/multiple_regress_design_callables.py
index d429231c..d862eb2a 100644
--- a/example-specs/task/nipype/fsl/multiple_regress_design_callables.py
+++ b/example-specs/task/nipype/fsl/multiple_regress_design_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in MultipleRegressDesign.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of MultipleRegressDesign.yaml"""
diff --git a/example-specs/task/nipype/fsl/overlay.yaml b/example-specs/task/nipype/fsl/overlay.yaml
index 0efc1d8c..c73bc36c 100644
--- a/example-specs/task/nipype/fsl/overlay.yaml
+++ b/example-specs/task/nipype/fsl/overlay.yaml
@@ -39,13 +39,13 @@ inputs:
   # passed to the field in the automatically generated unittests.
     background_image: generic/file
     # type=file|default=<undefined>: image to use as background
+    out_file: Path
+    # type=file: combined image volume
+    # type=file|default=<undefined>: combined image volume
     stat_image: generic/file
     # type=file|default=<undefined>: statistical image to overlay in color
     stat_image2: generic/file
     # type=file|default=<undefined>: second statistical image to overlay in color
-    out_file: Path
-    # type=file: combined image volume
-    # type=file|default=<undefined>: combined image volume
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/overlay_callables.py b/example-specs/task/nipype/fsl/overlay_callables.py
index dc826681..a6094ad6 100644
--- a/example-specs/task/nipype/fsl/overlay_callables.py
+++ b/example-specs/task/nipype/fsl/overlay_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in Overlay.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of Overlay.yaml"""
diff --git a/example-specs/task/nipype/fsl/percentile_image_callables.py b/example-specs/task/nipype/fsl/percentile_image_callables.py
index 3ab3b262..54f2d358 100644
--- a/example-specs/task/nipype/fsl/percentile_image_callables.py
+++ b/example-specs/task/nipype/fsl/percentile_image_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in PercentileImage.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of PercentileImage.yaml"""
diff --git a/example-specs/task/nipype/fsl/plot_motion_params_callables.py b/example-specs/task/nipype/fsl/plot_motion_params_callables.py
index cb9a47a0..8f0266b7 100644
--- a/example-specs/task/nipype/fsl/plot_motion_params_callables.py
+++ b/example-specs/task/nipype/fsl/plot_motion_params_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in PlotMotionParams.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of PlotMotionParams.yaml"""
diff --git a/example-specs/task/nipype/fsl/plot_time_series_callables.py b/example-specs/task/nipype/fsl/plot_time_series_callables.py
index a741da77..ebbcab6f 100644
--- a/example-specs/task/nipype/fsl/plot_time_series_callables.py
+++ b/example-specs/task/nipype/fsl/plot_time_series_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in PlotTimeSeries.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of PlotTimeSeries.yaml"""
diff --git a/example-specs/task/nipype/fsl/power_spectrum_callables.py b/example-specs/task/nipype/fsl/power_spectrum_callables.py
index 99730853..d6dc3fd3 100644
--- a/example-specs/task/nipype/fsl/power_spectrum_callables.py
+++ b/example-specs/task/nipype/fsl/power_spectrum_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in PowerSpectrum.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of PowerSpectrum.yaml"""
diff --git a/example-specs/task/nipype/fsl/prelude.yaml b/example-specs/task/nipype/fsl/prelude.yaml
index 30691325..cbe0d2ca 100644
--- a/example-specs/task/nipype/fsl/prelude.yaml
+++ b/example-specs/task/nipype/fsl/prelude.yaml
@@ -29,18 +29,18 @@ inputs:
   # passed to the field in the automatically generated unittests.
     complex_phase_file: generic/file
     # type=file|default=<undefined>: complex phase input volume
+    label_file: generic/file
+    # type=file|default=<undefined>: saving the area labels output
     magnitude_file: generic/file
     # type=file|default=<undefined>: file containing magnitude image
-    phase_file: generic/file
-    # type=file|default=<undefined>: raw phase file
     mask_file: generic/file
     # type=file|default=<undefined>: filename of mask input volume
-    savemask_file: generic/file
-    # type=file|default=<undefined>: saving the mask volume
+    phase_file: generic/file
+    # type=file|default=<undefined>: raw phase file
     rawphase_file: generic/file
     # type=file|default=<undefined>: saving the raw phase output
-    label_file: generic/file
-    # type=file|default=<undefined>: saving the area labels output
+    savemask_file: generic/file
+    # type=file|default=<undefined>: saving the mask volume
     unwrapped_phase_file: Path
     # type=file: unwrapped phase file
     # type=file|default=<undefined>: file containing unwrapepd phase
diff --git a/example-specs/task/nipype/fsl/prelude_callables.py b/example-specs/task/nipype/fsl/prelude_callables.py
index af11ab91..aad67925 100644
--- a/example-specs/task/nipype/fsl/prelude_callables.py
+++ b/example-specs/task/nipype/fsl/prelude_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in PRELUDE.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of PRELUDE.yaml"""
diff --git a/example-specs/task/nipype/fsl/prepare_fieldmap.yaml b/example-specs/task/nipype/fsl/prepare_fieldmap.yaml
index f2dba5ea..0cb04343 100644
--- a/example-specs/task/nipype/fsl/prepare_fieldmap.yaml
+++ b/example-specs/task/nipype/fsl/prepare_fieldmap.yaml
@@ -41,10 +41,10 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    in_phase: medimage/nifti1
-    # type=file|default=<undefined>: Phase difference map, in SIEMENS format range from 0-4096 or 0-8192)
     in_magnitude: medimage/nifti1
     # type=file|default=<undefined>: Magnitude difference map, brain extracted
+    in_phase: medimage/nifti1
+    # type=file|default=<undefined>: Phase difference map, in SIEMENS format range from 0-4096 or 0-8192)
     out_fieldmap: Path
     # type=file: output name for prepared fieldmap
     # type=file|default=<undefined>: output name for prepared fieldmap
diff --git a/example-specs/task/nipype/fsl/prepare_fieldmap_callables.py b/example-specs/task/nipype/fsl/prepare_fieldmap_callables.py
index 55273d74..8d4cf635 100644
--- a/example-specs/task/nipype/fsl/prepare_fieldmap_callables.py
+++ b/example-specs/task/nipype/fsl/prepare_fieldmap_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in PrepareFieldmap.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of PrepareFieldmap.yaml"""
diff --git a/example-specs/task/nipype/fsl/prob_track_x.yaml b/example-specs/task/nipype/fsl/prob_track_x.yaml
index eec7b1ca..44aa3bf9 100644
--- a/example-specs/task/nipype/fsl/prob_track_x.yaml
+++ b/example-specs/task/nipype/fsl/prob_track_x.yaml
@@ -30,34 +30,34 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    avoid_mp: generic/file
+    # type=file|default=<undefined>: reject pathways passing through locations given by this mask
+    fsamples: medimage/nifti1+list-of
+    # type=inputmultiobject|default=[]: 
+    inv_xfm: generic/file
+    # type=file|default=<undefined>: transformation matrix taking DTI space to seed space (compulsory when using a warp_field for seeds_to_dti)
+    mask: medimage/nifti1
+    # type=file|default=<undefined>: bet binary mask file in diffusion space
     mask2: generic/file
     # type=file|default=<undefined>: second bet binary mask (in diffusion space) in twomask_symm mode
     mesh: generic/file
     # type=file|default=<undefined>: Freesurfer-type surface descriptor (in ascii format)
-    thsamples: medimage/nifti1+list-of
-    # type=inputmultiobject|default=[]: 
+    out_dir: Path
+    # type=directory|default=<undefined>: directory to put the final volumes in
     phsamples: medimage/nifti1+list-of
     # type=inputmultiobject|default=[]: 
-    fsamples: medimage/nifti1+list-of
-    # type=inputmultiobject|default=[]: 
-    mask: medimage/nifti1
-    # type=file|default=<undefined>: bet binary mask file in diffusion space
-    target_masks: medimage/nifti1+list-of
-    # type=inputmultiobject|default=[]: list of target masks - required for seeds_to_targets classification
-    waypoints: generic/file
-    # type=file|default=<undefined>: waypoint mask or ascii list of waypoint masks - only keep paths going through ALL the masks
     seed_ref: generic/file
     # type=file|default=<undefined>: reference vol to define seed space in simple mode - diffusion space assumed if absent
-    avoid_mp: generic/file
-    # type=file|default=<undefined>: reject pathways passing through locations given by this mask
     stop_mask: generic/file
     # type=file|default=<undefined>: stop tracking at locations given by this mask file
+    target_masks: medimage/nifti1+list-of
+    # type=inputmultiobject|default=[]: list of target masks - required for seeds_to_targets classification
+    thsamples: medimage/nifti1+list-of
+    # type=inputmultiobject|default=[]: 
+    waypoints: generic/file
+    # type=file|default=<undefined>: waypoint mask or ascii list of waypoint masks - only keep paths going through ALL the masks
     xfm: datascience/text-matrix
     # type=file|default=<undefined>: transformation matrix taking seed space to DTI space (either FLIRT matrix or FNIRT warp_field) - default is identity
-    inv_xfm: generic/file
-    # type=file|default=<undefined>: transformation matrix taking DTI space to seed space (compulsory when using a warp_field for seeds_to_dti)
-    out_dir: Path
-    # type=directory|default=<undefined>: directory to put the final volumes in
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/prob_track_x2.yaml b/example-specs/task/nipype/fsl/prob_track_x2.yaml
index 6050d2ac..6f2e7056 100644
--- a/example-specs/task/nipype/fsl/prob_track_x2.yaml
+++ b/example-specs/task/nipype/fsl/prob_track_x2.yaml
@@ -37,42 +37,42 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    avoid_mp: generic/file
+    # type=file|default=<undefined>: reject pathways passing through locations given by this mask
+    colmask4: generic/file
+    # type=file|default=<undefined>: Mask for columns of matrix4 (default=seed mask)
     fopd: generic/file
     # type=file|default=<undefined>: Other mask for binning tract distribution
+    fsamples: medimage/nifti-gz+list-of
+    # type=inputmultiobject|default=[]: 
+    inv_xfm: generic/file
+    # type=file|default=<undefined>: transformation matrix taking DTI space to seed space (compulsory when using a warp_field for seeds_to_dti)
+    lrtarget3: generic/file
+    # type=file|default=<undefined>: Column-space mask used for Nxn connectivity matrix
+    mask: medimage/nifti-gz
+    # type=file|default=<undefined>: bet binary mask file in diffusion space
+    out_dir: Path
+    # type=directory|default=<undefined>: directory to put the final volumes in
+    phsamples: medimage/nifti-gz+list-of
+    # type=inputmultiobject|default=[]: 
+    seed_ref: generic/file
+    # type=file|default=<undefined>: reference vol to define seed space in simple mode - diffusion space assumed if absent
+    stop_mask: generic/file
+    # type=file|default=<undefined>: stop tracking at locations given by this mask file
     target2: generic/file
     # type=file|default=<undefined>: Low resolution binary brain mask for storing connectivity distribution in matrix2 mode
     target3: generic/file
     # type=file|default=<undefined>: Mask used for NxN connectivity matrix (or Nxn if lrtarget3 is set)
-    lrtarget3: generic/file
-    # type=file|default=<undefined>: Column-space mask used for Nxn connectivity matrix
-    colmask4: generic/file
-    # type=file|default=<undefined>: Mask for columns of matrix4 (default=seed mask)
     target4: generic/file
     # type=file|default=<undefined>: Brain mask in DTI space
-    thsamples: medimage/nifti-gz+list-of
-    # type=inputmultiobject|default=[]: 
-    phsamples: medimage/nifti-gz+list-of
-    # type=inputmultiobject|default=[]: 
-    fsamples: medimage/nifti-gz+list-of
-    # type=inputmultiobject|default=[]: 
-    mask: medimage/nifti-gz
-    # type=file|default=<undefined>: bet binary mask file in diffusion space
     target_masks: generic/file+list-of
     # type=inputmultiobject|default=[]: list of target masks - required for seeds_to_targets classification
+    thsamples: medimage/nifti-gz+list-of
+    # type=inputmultiobject|default=[]: 
     waypoints: generic/file
     # type=file|default=<undefined>: waypoint mask or ascii list of waypoint masks - only keep paths going through ALL the masks
-    seed_ref: generic/file
-    # type=file|default=<undefined>: reference vol to define seed space in simple mode - diffusion space assumed if absent
-    avoid_mp: generic/file
-    # type=file|default=<undefined>: reject pathways passing through locations given by this mask
-    stop_mask: generic/file
-    # type=file|default=<undefined>: stop tracking at locations given by this mask file
     xfm: generic/file
     # type=file|default=<undefined>: transformation matrix taking seed space to DTI space (either FLIRT matrix or FNIRT warp_field) - default is identity
-    inv_xfm: generic/file
-    # type=file|default=<undefined>: transformation matrix taking DTI space to seed space (compulsory when using a warp_field for seeds_to_dti)
-    out_dir: Path
-    # type=directory|default=<undefined>: directory to put the final volumes in
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -86,18 +86,18 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    network_matrix: generic/file
-    # type=file: the network matrix generated by --omatrix1 option
-    matrix1_dot: generic/file
-    # type=file: Output matrix1.dot - SeedToSeed Connectivity
+    log: generic/file
+    # type=file: path/name of a text record of the command that was run
     lookup_tractspace: generic/file
     # type=file: lookup_tractspace generated by --omatrix2 option
+    matrix1_dot: generic/file
+    # type=file: Output matrix1.dot - SeedToSeed Connectivity
     matrix2_dot: generic/file
     # type=file: Output matrix2.dot - SeedToLowResMask
     matrix3_dot: generic/file
     # type=file: Output matrix3 - NxN connectivity matrix
-    log: generic/file
-    # type=file: path/name of a text record of the command that was run
+    network_matrix: generic/file
+    # type=file: the network matrix generated by --omatrix1 option
     way_total: generic/file
     # type=file: path/name of a text file containing a single number corresponding to the total number of generated tracts that have not been rejected by inclusion/exclusion mask criteria
   callables:
diff --git a/example-specs/task/nipype/fsl/prob_track_x2_callables.py b/example-specs/task/nipype/fsl/prob_track_x2_callables.py
index ff73ff30..13bf6955 100644
--- a/example-specs/task/nipype/fsl/prob_track_x2_callables.py
+++ b/example-specs/task/nipype/fsl/prob_track_x2_callables.py
@@ -1,4 +1,4 @@
-"""Module to put any functions that are referred to in ProbTrackX2.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of ProbTrackX2.yaml"""
 
 
 def out_dir_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/fsl/prob_track_x_callables.py b/example-specs/task/nipype/fsl/prob_track_x_callables.py
index 74e67313..1d6d62b8 100644
--- a/example-specs/task/nipype/fsl/prob_track_x_callables.py
+++ b/example-specs/task/nipype/fsl/prob_track_x_callables.py
@@ -1,4 +1,4 @@
-"""Module to put any functions that are referred to in ProbTrackX.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of ProbTrackX.yaml"""
 
 
 def mode_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/fsl/proj_thresh_callables.py b/example-specs/task/nipype/fsl/proj_thresh_callables.py
index 30899258..dd6e1c7b 100644
--- a/example-specs/task/nipype/fsl/proj_thresh_callables.py
+++ b/example-specs/task/nipype/fsl/proj_thresh_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in ProjThresh.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of ProjThresh.yaml"""
diff --git a/example-specs/task/nipype/fsl/randomise.yaml b/example-specs/task/nipype/fsl/randomise.yaml
index f4bc08b3..c692d1d4 100644
--- a/example-specs/task/nipype/fsl/randomise.yaml
+++ b/example-specs/task/nipype/fsl/randomise.yaml
@@ -31,16 +31,16 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    in_file: medimage/nifti1
-    # type=file|default=<undefined>: 4D input file
     design_mat: datascience/text-matrix
     # type=file|default=<undefined>: design matrix file
-    tcon: medimage-fsl/con
-    # type=file|default=<undefined>: t contrasts file
     fcon: generic/file
     # type=file|default=<undefined>: f contrasts file
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: 4D input file
     mask: medimage/nifti1
     # type=file|default=<undefined>: mask image
+    tcon: medimage-fsl/con
+    # type=file|default=<undefined>: t contrasts file
     x_block_labels: generic/file
     # type=file|default=<undefined>: exchangeability block labels file
   metadata:
diff --git a/example-specs/task/nipype/fsl/randomise_callables.py b/example-specs/task/nipype/fsl/randomise_callables.py
index 3f63d057..dad09814 100644
--- a/example-specs/task/nipype/fsl/randomise_callables.py
+++ b/example-specs/task/nipype/fsl/randomise_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in Randomise.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of Randomise.yaml"""
diff --git a/example-specs/task/nipype/fsl/reorient_2_std_callables.py b/example-specs/task/nipype/fsl/reorient_2_std_callables.py
index 7e424ba6..c2c600d6 100644
--- a/example-specs/task/nipype/fsl/reorient_2_std_callables.py
+++ b/example-specs/task/nipype/fsl/reorient_2_std_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in Reorient2Std.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of Reorient2Std.yaml"""
diff --git a/example-specs/task/nipype/fsl/robust_fov_callables.py b/example-specs/task/nipype/fsl/robust_fov_callables.py
index 4b540c7e..a37d6861 100644
--- a/example-specs/task/nipype/fsl/robust_fov_callables.py
+++ b/example-specs/task/nipype/fsl/robust_fov_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in RobustFOV.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of RobustFOV.yaml"""
diff --git a/example-specs/task/nipype/fsl/sig_loss_callables.py b/example-specs/task/nipype/fsl/sig_loss_callables.py
index 05400d7b..0e195a9f 100644
--- a/example-specs/task/nipype/fsl/sig_loss_callables.py
+++ b/example-specs/task/nipype/fsl/sig_loss_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in SigLoss.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of SigLoss.yaml"""
diff --git a/example-specs/task/nipype/fsl/slice_callables.py b/example-specs/task/nipype/fsl/slice_callables.py
index d53846ee..005d7999 100644
--- a/example-specs/task/nipype/fsl/slice_callables.py
+++ b/example-specs/task/nipype/fsl/slice_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in Slice.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of Slice.yaml"""
diff --git a/example-specs/task/nipype/fsl/slice_timer.yaml b/example-specs/task/nipype/fsl/slice_timer.yaml
index 3ec864b5..c3d317f4 100644
--- a/example-specs/task/nipype/fsl/slice_timer.yaml
+++ b/example-specs/task/nipype/fsl/slice_timer.yaml
@@ -31,12 +31,12 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    in_file: generic/file
-    # type=file|default=<undefined>: filename of input timeseries
-    custom_timings: generic/file
-    # type=file|default=<undefined>: slice timings, in fractions of TR, range 0:1 (default is 0.5 = no shift)
     custom_order: generic/file
     # type=file|default=<undefined>: filename of single-column custom interleave order file (first slice is referred to as 1 not 0)
+    custom_timings: generic/file
+    # type=file|default=<undefined>: slice timings, in fractions of TR, range 0:1 (default is 0.5 = no shift)
+    in_file: generic/file
+    # type=file|default=<undefined>: filename of input timeseries
     out_file: Path
     # type=file|default=<undefined>: filename of output timeseries
   metadata:
diff --git a/example-specs/task/nipype/fsl/slice_timer_callables.py b/example-specs/task/nipype/fsl/slice_timer_callables.py
index a06afc6a..7fe139bc 100644
--- a/example-specs/task/nipype/fsl/slice_timer_callables.py
+++ b/example-specs/task/nipype/fsl/slice_timer_callables.py
@@ -1,7 +1,8 @@
-"""Module to put any functions that are referred to in SliceTimer.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of SliceTimer.yaml"""
 
-import os
 import attrs
+from fileformats.generic import File
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -18,10 +19,6 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     return None
 
 
-class SliceTimerOutputSpec(inputs=None, stdout=None, stderr=None, output_dir=None):
-    slice_time_corrected_file = File(exists=True, desc="slice time corrected file")
-
-
 def _outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     """Returns a bunch containing output fields for the class"""
     outputs = None
@@ -33,6 +30,24 @@ def _outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     return outputs
 
 
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = _outputs(
+        inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+    ).get()
+    out_file = inputs.out_file
+    if out_file is attrs.NOTHING:
+        out_file = _gen_fname(
+            inputs.in_file,
+            suffix="_st",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    outputs["slice_time_corrected_file"] = os.path.abspath(out_file)
+    return outputs
+
+
 def _gen_fname(
     basename,
     cwd=None,
@@ -88,19 +103,5 @@ def _gen_fname(
     return fname
 
 
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = _outputs(
-        inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-    ).get()
-    out_file = inputs.out_file
-    if out_file is attrs.NOTHING:
-        out_file = _gen_fname(
-            inputs.in_file,
-            suffix="_st",
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-    outputs["slice_time_corrected_file"] = os.path.abspath(out_file)
-    return outputs
+class SliceTimerOutputSpec(inputs=None, stdout=None, stderr=None, output_dir=None):
+    slice_time_corrected_file = File(exists=True, desc="slice time corrected file")
diff --git a/example-specs/task/nipype/fsl/slicer.yaml b/example-specs/task/nipype/fsl/slicer.yaml
index 9fdb7625..8d211f5c 100644
--- a/example-specs/task/nipype/fsl/slicer.yaml
+++ b/example-specs/task/nipype/fsl/slicer.yaml
@@ -35,12 +35,12 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    in_file: generic/file
-    # type=file|default=<undefined>: input volume
-    image_edges: generic/file
-    # type=file|default=<undefined>: volume to display edge overlay for (useful for checking registration
     colour_map: generic/file
     # type=file|default=<undefined>: use different colour map from that stored in nifti header
+    image_edges: generic/file
+    # type=file|default=<undefined>: volume to display edge overlay for (useful for checking registration
+    in_file: generic/file
+    # type=file|default=<undefined>: input volume
     out_file: Path
     # type=file: picture to write
     # type=file|default=<undefined>: picture to write
diff --git a/example-specs/task/nipype/fsl/slicer_callables.py b/example-specs/task/nipype/fsl/slicer_callables.py
index 88b43163..c50250bb 100644
--- a/example-specs/task/nipype/fsl/slicer_callables.py
+++ b/example-specs/task/nipype/fsl/slicer_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in Slicer.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of Slicer.yaml"""
diff --git a/example-specs/task/nipype/fsl/smm.yaml b/example-specs/task/nipype/fsl/smm.yaml
index 0b723345..34aa637c 100644
--- a/example-specs/task/nipype/fsl/smm.yaml
+++ b/example-specs/task/nipype/fsl/smm.yaml
@@ -25,10 +25,10 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    spatial_data_file: generic/file
-    # type=file|default=<undefined>: statistics spatial map
     mask: generic/file
     # type=file|default=<undefined>: mask file
+    spatial_data_file: generic/file
+    # type=file|default=<undefined>: statistics spatial map
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -42,11 +42,12 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-   _p_map: generic/file
     activation_p_map: generic/file
     # type=file: 
     deactivation_p_map: generic/file
     # type=file: 
+    null_p_map: generic/file
+    # type=file: 
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/fsl/smm_callables.py b/example-specs/task/nipype/fsl/smm_callables.py
index a6c27295..6368393a 100644
--- a/example-specs/task/nipype/fsl/smm_callables.py
+++ b/example-specs/task/nipype/fsl/smm_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in SMM.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of SMM.yaml"""
diff --git a/example-specs/task/nipype/fsl/smooth_callables.py b/example-specs/task/nipype/fsl/smooth_callables.py
index 5dbe8c1a..277b109d 100644
--- a/example-specs/task/nipype/fsl/smooth_callables.py
+++ b/example-specs/task/nipype/fsl/smooth_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in Smooth.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of Smooth.yaml"""
diff --git a/example-specs/task/nipype/fsl/smooth_estimate_callables.py b/example-specs/task/nipype/fsl/smooth_estimate_callables.py
index bac9d457..a2168bae 100644
--- a/example-specs/task/nipype/fsl/smooth_estimate_callables.py
+++ b/example-specs/task/nipype/fsl/smooth_estimate_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in SmoothEstimate.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of SmoothEstimate.yaml"""
diff --git a/example-specs/task/nipype/fsl/spatial_filter.yaml b/example-specs/task/nipype/fsl/spatial_filter.yaml
index 3bcc8127..2caa4035 100644
--- a/example-specs/task/nipype/fsl/spatial_filter.yaml
+++ b/example-specs/task/nipype/fsl/spatial_filter.yaml
@@ -20,10 +20,10 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    kernel_file: generic/file
-    # type=file|default=<undefined>: use external file for kernel
     in_file: generic/file
     # type=file|default=<undefined>: image to operate on
+    kernel_file: generic/file
+    # type=file|default=<undefined>: use external file for kernel
     out_file: Path
     # type=file: image written after calculations
     # type=file|default=<undefined>: image to write
diff --git a/example-specs/task/nipype/fsl/spatial_filter_callables.py b/example-specs/task/nipype/fsl/spatial_filter_callables.py
index 3a39375c..99a68b98 100644
--- a/example-specs/task/nipype/fsl/spatial_filter_callables.py
+++ b/example-specs/task/nipype/fsl/spatial_filter_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in SpatialFilter.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of SpatialFilter.yaml"""
diff --git a/example-specs/task/nipype/fsl/split_callables.py b/example-specs/task/nipype/fsl/split_callables.py
index bdbf3d70..ea00acce 100644
--- a/example-specs/task/nipype/fsl/split_callables.py
+++ b/example-specs/task/nipype/fsl/split_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in Split.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of Split.yaml"""
diff --git a/example-specs/task/nipype/fsl/std_image_callables.py b/example-specs/task/nipype/fsl/std_image_callables.py
index 4670a791..8dabe984 100644
--- a/example-specs/task/nipype/fsl/std_image_callables.py
+++ b/example-specs/task/nipype/fsl/std_image_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in StdImage.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of StdImage.yaml"""
diff --git a/example-specs/task/nipype/fsl/susan_callables.py b/example-specs/task/nipype/fsl/susan_callables.py
index 13c530c0..45dc9cc0 100644
--- a/example-specs/task/nipype/fsl/susan_callables.py
+++ b/example-specs/task/nipype/fsl/susan_callables.py
@@ -1,7 +1,8 @@
-"""Module to put any functions that are referred to in SUSAN.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of SUSAN.yaml"""
 
-import os
 import attrs
+from fileformats.generic import File
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -47,10 +48,6 @@ def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     return outputs
 
 
-class SUSANOutputSpec(inputs=None, stdout=None, stderr=None, output_dir=None):
-    smoothed_file = File(exists=True, desc="smoothed output file")
-
-
 def _gen_fname(
     basename,
     cwd=None,
@@ -104,3 +101,7 @@ def _gen_fname(
         suffix = ""
     fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
     return fname
+
+
+class SUSANOutputSpec(inputs=None, stdout=None, stderr=None, output_dir=None):
+    smoothed_file = File(exists=True, desc="smoothed output file")
diff --git a/example-specs/task/nipype/fsl/swap_dimensions_callables.py b/example-specs/task/nipype/fsl/swap_dimensions_callables.py
index 74ec8eca..da4e9b2c 100644
--- a/example-specs/task/nipype/fsl/swap_dimensions_callables.py
+++ b/example-specs/task/nipype/fsl/swap_dimensions_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in SwapDimensions.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of SwapDimensions.yaml"""
diff --git a/example-specs/task/nipype/fsl/temporal_filter_callables.py b/example-specs/task/nipype/fsl/temporal_filter_callables.py
index 3ec888f9..aceb51d3 100644
--- a/example-specs/task/nipype/fsl/temporal_filter_callables.py
+++ b/example-specs/task/nipype/fsl/temporal_filter_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in TemporalFilter.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of TemporalFilter.yaml"""
diff --git a/example-specs/task/nipype/fsl/text_2_vest_callables.py b/example-specs/task/nipype/fsl/text_2_vest_callables.py
index 1fdad810..3f719aa1 100644
--- a/example-specs/task/nipype/fsl/text_2_vest_callables.py
+++ b/example-specs/task/nipype/fsl/text_2_vest_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in Text2Vest.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of Text2Vest.yaml"""
diff --git a/example-specs/task/nipype/fsl/threshold_callables.py b/example-specs/task/nipype/fsl/threshold_callables.py
index a542f78f..f5f33571 100644
--- a/example-specs/task/nipype/fsl/threshold_callables.py
+++ b/example-specs/task/nipype/fsl/threshold_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in Threshold.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of Threshold.yaml"""
diff --git a/example-specs/task/nipype/fsl/topup.yaml b/example-specs/task/nipype/fsl/topup.yaml
index 45d28f0d..b02c52ee 100644
--- a/example-specs/task/nipype/fsl/topup.yaml
+++ b/example-specs/task/nipype/fsl/topup.yaml
@@ -41,18 +41,18 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    in_file: medimage/nifti1
-    # type=file|default=<undefined>: name of 4D file with images
     encoding_file: text/text-file
     # type=file|default=<undefined>: name of text file with PE directions/times
-    out_base: generic/file
+    in_file: medimage/nifti1
+    # type=file|default=<undefined>: name of 4D file with images
+    out_base: Path
     # type=file|default=<undefined>: base-name of output files (spline coefficients (Hz) and movement parameters)
-    out_field: Path
-    # type=file: name of image file with field (Hz)
-    # type=file|default=<undefined>: name of image file with field (Hz)
     out_corrected: Path
     # type=file: name of 4D image file with unwarped images
     # type=file|default=<undefined>: name of 4D image file with unwarped images
+    out_field: Path
+    # type=file: name of image file with field (Hz)
+    # type=file|default=<undefined>: name of image file with field (Hz)
     out_logfile: Path
     # type=file: name of log-file
     # type=file|default=<undefined>: name of log-file
@@ -69,21 +69,21 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    out_fieldcoef: generic/file
-    # type=file: file containing the field coefficients
-    out_movpar: generic/file
-    # type=file: movpar.txt output file
+    out_corrected: generic/file
+    # type=file: name of 4D image file with unwarped images
+    # type=file|default=<undefined>: name of 4D image file with unwarped images
     out_enc_file: generic/file
     # type=file: encoding directions file output for applytopup
     out_field: generic/file
     # type=file: name of image file with field (Hz)
     # type=file|default=<undefined>: name of image file with field (Hz)
-    out_corrected: generic/file
-    # type=file: name of 4D image file with unwarped images
-    # type=file|default=<undefined>: name of 4D image file with unwarped images
+    out_fieldcoef: generic/file
+    # type=file: file containing the field coefficients
     out_logfile: generic/file
     # type=file: name of log-file
     # type=file|default=<undefined>: name of log-file
+    out_movpar: generic/file
+    # type=file: movpar.txt output file
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/fsl/topup_callables.py b/example-specs/task/nipype/fsl/topup_callables.py
index 3069076b..eec1880d 100644
--- a/example-specs/task/nipype/fsl/topup_callables.py
+++ b/example-specs/task/nipype/fsl/topup_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in TOPUP.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of TOPUP.yaml"""
diff --git a/example-specs/task/nipype/fsl/tract_skeleton.yaml b/example-specs/task/nipype/fsl/tract_skeleton.yaml
index 70e49e2e..271adccf 100644
--- a/example-specs/task/nipype/fsl/tract_skeleton.yaml
+++ b/example-specs/task/nipype/fsl/tract_skeleton.yaml
@@ -42,21 +42,21 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    in_file: generic/file
-    # type=file|default=<undefined>: input image (typically mean FA volume)
-    distance_map: generic/file
-    # type=file|default=<undefined>: distance map image
-    search_mask_file: generic/file
-    # type=file|default=<undefined>: mask in which to use alternate search rule
-    data_file: generic/file
-    # type=file|default=<undefined>: 4D data to project onto skeleton (usually FA)
     alt_data_file: generic/file
     # type=file|default=<undefined>: 4D non-FA data to project onto skeleton
     alt_skeleton: generic/file
     # type=file|default=<undefined>: alternate skeleton to use
+    data_file: generic/file
+    # type=file|default=<undefined>: 4D data to project onto skeleton (usually FA)
+    distance_map: generic/file
+    # type=file|default=<undefined>: distance map image
+    in_file: generic/file
+    # type=file|default=<undefined>: input image (typically mean FA volume)
     projected_data: Path
     # type=file: input data projected onto skeleton
     # type=file|default=<undefined>: input data projected onto skeleton
+    search_mask_file: generic/file
+    # type=file|default=<undefined>: mask in which to use alternate search rule
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/tract_skeleton_callables.py b/example-specs/task/nipype/fsl/tract_skeleton_callables.py
index 92b6fc48..dd8ab045 100644
--- a/example-specs/task/nipype/fsl/tract_skeleton_callables.py
+++ b/example-specs/task/nipype/fsl/tract_skeleton_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in TractSkeleton.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of TractSkeleton.yaml"""
diff --git a/example-specs/task/nipype/fsl/training_callables.py b/example-specs/task/nipype/fsl/training_callables.py
index 7be534ea..36362c92 100644
--- a/example-specs/task/nipype/fsl/training_callables.py
+++ b/example-specs/task/nipype/fsl/training_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in Training.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of Training.yaml"""
diff --git a/example-specs/task/nipype/fsl/training_set_creator_callables.py b/example-specs/task/nipype/fsl/training_set_creator_callables.py
index b5853094..f750b5c1 100644
--- a/example-specs/task/nipype/fsl/training_set_creator_callables.py
+++ b/example-specs/task/nipype/fsl/training_set_creator_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in TrainingSetCreator.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of TrainingSetCreator.yaml"""
diff --git a/example-specs/task/nipype/fsl/unary_maths_callables.py b/example-specs/task/nipype/fsl/unary_maths_callables.py
index ae1ae260..b2b7ec0a 100644
--- a/example-specs/task/nipype/fsl/unary_maths_callables.py
+++ b/example-specs/task/nipype/fsl/unary_maths_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in UnaryMaths.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of UnaryMaths.yaml"""
diff --git a/example-specs/task/nipype/fsl/vec_reg.yaml b/example-specs/task/nipype/fsl/vec_reg.yaml
index ec6ae088..fc61d08e 100644
--- a/example-specs/task/nipype/fsl/vec_reg.yaml
+++ b/example-specs/task/nipype/fsl/vec_reg.yaml
@@ -32,25 +32,25 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    affine_mat: datascience/text-matrix
+    # type=file|default=<undefined>: filename for affine transformation matrix
     in_file: medimage/nifti1
     # type=file|default=<undefined>: filename for input vector or tensor field
+    mask: generic/file
+    # type=file|default=<undefined>: brain mask in input space
+    out_file: Path
+    # type=file: path/name of filename for the registered vector or tensor field
+    # type=file|default=<undefined>: filename for output registered vector or tensor field
+    ref_mask: generic/file
+    # type=file|default=<undefined>: brain mask in output space (useful for speed up of nonlinear reg)
     ref_vol: medimage/nifti1
     # type=file|default=<undefined>: filename for reference (target) volume
-    affine_mat: datascience/text-matrix
-    # type=file|default=<undefined>: filename for affine transformation matrix
-    warp_field: generic/file
-    # type=file|default=<undefined>: filename for 4D warp field for nonlinear registration
     rotation_mat: generic/file
     # type=file|default=<undefined>: filename for secondary affine matrix if set, this will be used for the rotation of the vector/tensor field
     rotation_warp: generic/file
     # type=file|default=<undefined>: filename for secondary warp field if set, this will be used for the rotation of the vector/tensor field
-    mask: generic/file
-    # type=file|default=<undefined>: brain mask in input space
-    ref_mask: generic/file
-    # type=file|default=<undefined>: brain mask in output space (useful for speed up of nonlinear reg)
-    out_file: Path
-    # type=file: path/name of filename for the registered vector or tensor field
-    # type=file|default=<undefined>: filename for output registered vector or tensor field
+    warp_field: generic/file
+    # type=file|default=<undefined>: filename for 4D warp field for nonlinear registration
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/vec_reg_callables.py b/example-specs/task/nipype/fsl/vec_reg_callables.py
index e1d8453d..0ae08a62 100644
--- a/example-specs/task/nipype/fsl/vec_reg_callables.py
+++ b/example-specs/task/nipype/fsl/vec_reg_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in VecReg.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of VecReg.yaml"""
diff --git a/example-specs/task/nipype/fsl/vest_2_text_callables.py b/example-specs/task/nipype/fsl/vest_2_text_callables.py
index 905b2264..aaa2d8d1 100644
--- a/example-specs/task/nipype/fsl/vest_2_text_callables.py
+++ b/example-specs/task/nipype/fsl/vest_2_text_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in Vest2Text.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of Vest2Text.yaml"""
diff --git a/example-specs/task/nipype/fsl/warp_points.yaml b/example-specs/task/nipype/fsl/warp_points.yaml
index d4b565f6..740df315 100644
--- a/example-specs/task/nipype/fsl/warp_points.yaml
+++ b/example-specs/task/nipype/fsl/warp_points.yaml
@@ -41,19 +41,19 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    src_file: medimage/nifti1
-    # type=file|default=<undefined>: filename of source image
     dest_file: medimage/nifti1
     # type=file|default=<undefined>: filename of destination image
     in_coords: text/text-file
     # type=file|default=<undefined>: filename of file containing coordinates
-    xfm_file: generic/file
-    # type=file|default=<undefined>: filename of affine transform (e.g. source2dest.mat)
-    warp_file: medimage/nifti1
-    # type=file|default=<undefined>: filename of warpfield (e.g. intermediate2dest_warp.nii.gz)
     out_file: Path
     # type=file: Name of output file, containing the warp as field or coefficients.
     # type=file|default=<undefined>: output file name
+    src_file: medimage/nifti1
+    # type=file|default=<undefined>: filename of source image
+    warp_file: medimage/nifti1
+    # type=file|default=<undefined>: filename of warpfield (e.g. intermediate2dest_warp.nii.gz)
+    xfm_file: generic/file
+    # type=file|default=<undefined>: filename of affine transform (e.g. source2dest.mat)
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/warp_points_callables.py b/example-specs/task/nipype/fsl/warp_points_callables.py
index b868a2c6..49f2e25e 100644
--- a/example-specs/task/nipype/fsl/warp_points_callables.py
+++ b/example-specs/task/nipype/fsl/warp_points_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in WarpPoints.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of WarpPoints.yaml"""
diff --git a/example-specs/task/nipype/fsl/warp_points_from_std.yaml b/example-specs/task/nipype/fsl/warp_points_from_std.yaml
index aaffa6bc..4737ba00 100644
--- a/example-specs/task/nipype/fsl/warp_points_from_std.yaml
+++ b/example-specs/task/nipype/fsl/warp_points_from_std.yaml
@@ -43,14 +43,14 @@ inputs:
   # passed to the field in the automatically generated unittests.
     img_file: medimage/nifti1
     # type=file|default=<undefined>: filename of a destination image
-    std_file: medimage/nifti1
-    # type=file|default=<undefined>: filename of the image in standard space
     in_coords: text/text-file
     # type=file|default=<undefined>: filename of file containing coordinates
-    xfm_file: generic/file
-    # type=file|default=<undefined>: filename of affine transform (e.g. source2dest.mat)
+    std_file: medimage/nifti1
+    # type=file|default=<undefined>: filename of the image in standard space
     warp_file: medimage/nifti1
     # type=file|default=<undefined>: filename of warpfield (e.g. intermediate2dest_warp.nii.gz)
+    xfm_file: generic/file
+    # type=file|default=<undefined>: filename of affine transform (e.g. source2dest.mat)
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/warp_points_from_std_callables.py b/example-specs/task/nipype/fsl/warp_points_from_std_callables.py
index e587abf1..e5b9aebe 100644
--- a/example-specs/task/nipype/fsl/warp_points_from_std_callables.py
+++ b/example-specs/task/nipype/fsl/warp_points_from_std_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in WarpPointsFromStd.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of WarpPointsFromStd.yaml"""
diff --git a/example-specs/task/nipype/fsl/warp_points_to_std.yaml b/example-specs/task/nipype/fsl/warp_points_to_std.yaml
index 22df79cc..c0a108dd 100644
--- a/example-specs/task/nipype/fsl/warp_points_to_std.yaml
+++ b/example-specs/task/nipype/fsl/warp_points_to_std.yaml
@@ -45,19 +45,19 @@ inputs:
   # passed to the field in the automatically generated unittests.
     img_file: medimage/nifti1
     # type=file|default=<undefined>: filename of input image
-    std_file: medimage/nifti1
-    # type=file|default=<undefined>: filename of destination image
-    premat_file: generic/file
-    # type=file|default=<undefined>: filename of pre-warp affine transform (e.g. example_func2highres.mat)
     in_coords: text/text-file
     # type=file|default=<undefined>: filename of file containing coordinates
-    xfm_file: generic/file
-    # type=file|default=<undefined>: filename of affine transform (e.g. source2dest.mat)
-    warp_file: medimage/nifti1
-    # type=file|default=<undefined>: filename of warpfield (e.g. intermediate2dest_warp.nii.gz)
     out_file: Path
     # type=file: Name of output file, containing the warp as field or coefficients.
     # type=file|default=<undefined>: output file name
+    premat_file: generic/file
+    # type=file|default=<undefined>: filename of pre-warp affine transform (e.g. example_func2highres.mat)
+    std_file: medimage/nifti1
+    # type=file|default=<undefined>: filename of destination image
+    warp_file: medimage/nifti1
+    # type=file|default=<undefined>: filename of warpfield (e.g. intermediate2dest_warp.nii.gz)
+    xfm_file: generic/file
+    # type=file|default=<undefined>: filename of affine transform (e.g. source2dest.mat)
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/warp_points_to_std_callables.py b/example-specs/task/nipype/fsl/warp_points_to_std_callables.py
index 3c706519..390b14dc 100644
--- a/example-specs/task/nipype/fsl/warp_points_to_std_callables.py
+++ b/example-specs/task/nipype/fsl/warp_points_to_std_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in WarpPointsToStd.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of WarpPointsToStd.yaml"""
diff --git a/example-specs/task/nipype/fsl/warp_utils.yaml b/example-specs/task/nipype/fsl/warp_utils.yaml
index 1009f3c4..a3cc43da 100644
--- a/example-specs/task/nipype/fsl/warp_utils.yaml
+++ b/example-specs/task/nipype/fsl/warp_utils.yaml
@@ -41,14 +41,14 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/nifti1
     # type=file|default=<undefined>: Name of file containing warp-coefficients/fields. This would typically be the output from the --cout switch of fnirt (but can also use fields, like the output from --fout).
-    reference: medimage/nifti1
-    # type=file|default=<undefined>: Name of a file in target space. Note that the target space is now different from the target space that was used to create the --warp file. It would typically be the file that was specified with the --in argument when running fnirt.
     out_file: Path
     # type=file: Name of output file, containing the warp as field or coefficients.
     # type=file|default=<undefined>: Name of output file. The format of the output depends on what other parameters are set. The default format is a (4D) field-file. If the --outformat is set to spline the format will be a (4D) file of spline coefficients.
     out_jacobian: Path
     # type=file: Name of output file, containing the map of the determinant of the Jacobian
     # type=file|default=<undefined>: Specifies that a (3D) file of Jacobian determinants corresponding to --in should be produced and written to filename.
+    reference: medimage/nifti1
+    # type=file|default=<undefined>: Name of a file in target space. Note that the target space is now different from the target space that was used to create the --warp file. It would typically be the file that was specified with the --in argument when running fnirt.
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/warp_utils_callables.py b/example-specs/task/nipype/fsl/warp_utils_callables.py
index f8cee64c..1f873334 100644
--- a/example-specs/task/nipype/fsl/warp_utils_callables.py
+++ b/example-specs/task/nipype/fsl/warp_utils_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in WarpUtils.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of WarpUtils.yaml"""
diff --git a/example-specs/task/nipype/fsl/x_fibres_5.yaml b/example-specs/task/nipype/fsl/x_fibres_5.yaml
index 7236d371..2764ee56 100644
--- a/example-specs/task/nipype/fsl/x_fibres_5.yaml
+++ b/example-specs/task/nipype/fsl/x_fibres_5.yaml
@@ -23,18 +23,18 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    gradnonlin: generic/file
-    # type=file|default=<undefined>: gradient file corresponding to slice
-    dwi: generic/file
-    # type=file|default=<undefined>: diffusion weighted image data file
-    mask: generic/file
-    # type=file|default=<undefined>: brain binary mask file (i.e. from BET)
-    bvecs: generic/file
-    # type=file|default=<undefined>: b vectors file
     bvals: generic/file
     # type=file|default=<undefined>: b values file
+    bvecs: generic/file
+    # type=file|default=<undefined>: b vectors file
+    dwi: generic/file
+    # type=file|default=<undefined>: diffusion weighted image data file
+    gradnonlin: generic/file
+    # type=file|default=<undefined>: gradient file corresponding to slice
     logdir: generic/directory
     # type=directory|default='.': 
+    mask: generic/file
+    # type=file|default=<undefined>: brain binary mask file (i.e. from BET)
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -48,10 +48,10 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
-    mean_dsamples: generic/file
-    # type=file: Mean of distribution on diffusivity d
     mean_S0samples: generic/file
     # type=file: Mean of distribution on T2wbaseline signal intensity S0
+    mean_dsamples: generic/file
+    # type=file: Mean of distribution on diffusivity d
     mean_tausamples: generic/file
     # type=file: Mean of distribution on tau samples (only with rician noise)
   callables:
diff --git a/example-specs/task/nipype/fsl/x_fibres_5_callables.py b/example-specs/task/nipype/fsl/x_fibres_5_callables.py
index 0f22a32c..b2469497 100644
--- a/example-specs/task/nipype/fsl/x_fibres_5_callables.py
+++ b/example-specs/task/nipype/fsl/x_fibres_5_callables.py
@@ -1 +1 @@
-"""Module to put any functions that are referred to in XFibres5.yaml"""
+"""Module to put any functions that are referred to in the "callables" section of XFibres5.yaml"""
diff --git a/nipype2pydra/cli/pkg_gen.py b/nipype2pydra/cli/pkg_gen.py
index 16dfd954..fa516892 100644
--- a/nipype2pydra/cli/pkg_gen.py
+++ b/nipype2pydra/cli/pkg_gen.py
@@ -22,13 +22,18 @@
 from nipype2pydra.cli.base import cli
 
 
+DEFAULT_INTERFACE_SPEC = (
+    Path(__file__).parent.parent / "pkg_gen" / "resources" / "specs" / "nipype-interfaces-to-import.yaml"
+)
+
+
 @cli.command(
     "pkg-gen", help="Generates stub pydra packages for all nipype interfaces to import"
 )
 @click.argument("output_dir", type=click.Path(path_type=Path))
 @click.option("--work-dir", type=click.Path(path_type=Path), default=None)
 @click.option("--task-template", type=click.Path(path_type=Path), default=None)
-@click.option("--packages-to-import", type=click.Path(path_type=Path), default=None)
+@click.option("--packages-to-import", type=click.Path(path_type=Path), default=DEFAULT_INTERFACE_SPEC)
 @click.option("--single-interface", type=str, nargs=2, default=None)
 @click.option(
     "--example-packages",
@@ -70,16 +75,7 @@ def pkg_gen(
                 single_interface[0]: [single_interface[1]],
             },
         }
-        if packages_to_import:
-            raise ValueError(
-                "Cannot specify both --single-package and --packages-to-import"
-            )
     else:
-        if packages_to_import is None:
-            packages_to_import = (
-                Path(__file__).parent.parent.parent / "nipype-interfaces-to-import.yaml"
-            )
-
         with open(packages_to_import) as f:
             to_import = yaml.load(f, Loader=yaml.SafeLoader)
 
@@ -168,7 +164,7 @@ def pkg_gen(
         )
         sp.check_call("git tag 0.1.0", shell=True, cwd=pkg_dir)
 
-    if example_packages:
+    if example_packages and not single_interface:
         with open(example_packages) as f:
             example_pkg_names = yaml.load(f, Loader=yaml.SafeLoader)
 
@@ -189,7 +185,8 @@ def pkg_gen(
                 / "nipype-auto-conv"
                 / "specs"
             )
-            shutil.copytree(specs_dir, examples_dir / example_pkg_name)
+            dest_dir = examples_dir / example_pkg_name
+            shutil.copytree(specs_dir, dest_dir)
 
     unmatched_extensions = set(
         File.decompose_fspath(
diff --git a/nipype2pydra/cli/task.py b/nipype2pydra/cli/task.py
index ecf55f46..20224b50 100644
--- a/nipype2pydra/cli/task.py
+++ b/nipype2pydra/cli/task.py
@@ -6,6 +6,7 @@
 
 
 @cli.command(
+    name="task",
     help="""Port Nipype task interface code to Pydra
 
 YAML_SPEC is a YAML file which defines interfaces to be imported along with an
diff --git a/nipype2pydra/pkg_gen/__init__.py b/nipype2pydra/pkg_gen/__init__.py
index 107d35fa..69e50c75 100644
--- a/nipype2pydra/pkg_gen/__init__.py
+++ b/nipype2pydra/pkg_gen/__init__.py
@@ -77,17 +77,17 @@ class NipypeInterface:
     pkg: str
     base_package: str
     preamble: str = attrs.field()
-    input_helps: ty.Dict[str, str] = attrs.field()
-    output_helps: ty.Dict[str, str] = attrs.field()
-    file_inputs: ty.Dict[str, str] = attrs.field()
-    path_inputs: ty.List[str] = attrs.field()
-    str_inputs: ty.List[str] = attrs.field()
-    file_outputs: ty.List[str] = attrs.field()
-    template_outputs: ty.List[str] = attrs.field()
-    multi_inputs: ty.List[str] = attrs.field()
-    dir_inputs: ty.List[str] = attrs.field()
-    dir_outputs: ty.List[str] = attrs.field()
-    callables: ty.List[str] = attrs.field()
+    input_helps: ty.Dict[str, str] = attrs.field(factory=dict)
+    output_helps: ty.Dict[str, str] = attrs.field(factory=dict)
+    file_inputs: ty.List[str] = attrs.field(factory=list)
+    path_inputs: ty.List[str] = attrs.field(factory=list)
+    str_inputs: ty.List[str] = attrs.field(factory=list)
+    file_outputs: ty.List[str] = attrs.field(factory=list)
+    template_outputs: ty.List[str] = attrs.field(factory=list)
+    multi_inputs: ty.List[str] = attrs.field(factory=list)
+    dir_inputs: ty.List[str] = attrs.field(factory=list)
+    dir_outputs: ty.List[str] = attrs.field(factory=list)
+    callables: ty.List[str] = attrs.field(factory=list)
 
     unmatched_formats: ty.List[str] = attrs.field(factory=list)
     ambiguous_formats: ty.List[str] = attrs.field(factory=list)
@@ -99,29 +99,42 @@ def parse(
         cls, nipype_interface: type, pkg: str, base_package: str
     ) -> "NipypeInterface":
         """Generate preamble comments at start of file with args and doc strings"""
-        input_helps = {}
-        file_inputs = []
-        file_outputs = []
-        dir_inputs = []
-        path_inputs = []
-        str_inputs = []
-        template_outputs = []
-        multi_inputs = []
-        dir_outputs = []
-        output_helps = {}
-        callables = []
+
+        doc_string = nipype_interface.__doc__ if nipype_interface.__doc__ else ""
+        doc_string = doc_string.replace("\n", "\n# ")
+        # Create a preamble at the top of the specificaiton explaining what to do
+        preamble = (
+            f"""# This file is used to manually specify the semi-automatic conversion of
+# '{nipype_interface.__module__.replace('/', '.')}.{nipype_interface.__name__}' from Nipype to Pydra.
+#
+# Please fill-in/edit the fields below where appropriate
+#
+# Docs
+# ----
+# {doc_string}\n"""
+        ).replace("        #", "#")
+        
+        parsed = cls(
+            name=nipype_interface.__name__,
+            doc_str=nipype_interface.__doc__ if nipype_interface.__doc__ else "",
+            module=nipype_interface.__module__[len(base_package) + 1 :],
+            pkg=pkg,
+            base_package=base_package,
+            preamble=preamble,
+        )
         # Parse output types and descriptions
-        for outpt_name, outpt in nipype_interface.output_spec().traits().items():
-            if outpt_name in ("trait_added", "trait_modified"):
-                continue
-            outpt_desc = outpt.desc.replace("\n", " ") if outpt.desc else ""
-            output_helps[outpt_name] = (
-                f"type={type(outpt.trait_type).__name__.lower()}: {outpt_desc}"
-            )
-            if type(outpt.trait_type).__name__ == "File":
-                file_outputs.append(outpt_name)
-            elif type(outpt.trait_type).__name__ == "Directory":
-                dir_outputs.append(outpt_name)
+        if nipype_interface.output_spec:
+            for outpt_name, outpt in nipype_interface.output_spec().traits().items():
+                if outpt_name in ("trait_added", "trait_modified"):
+                    continue
+                outpt_desc = outpt.desc.replace("\n", " ") if outpt.desc else ""
+                parsed.output_helps[outpt_name] = (
+                    f"type={type(outpt.trait_type).__name__.lower()}: {outpt_desc}"
+                )
+                if type(outpt.trait_type).__name__ == "File":
+                    parsed.file_outputs.append(outpt_name)
+                elif type(outpt.trait_type).__name__ == "Directory":
+                    parsed.dir_outputs.append(outpt_name)
         # Parse input types, descriptions and metadata
         for inpt_name, inpt in nipype_interface.input_spec().traits().items():
             if inpt_name in ("trait_added", "trait_modified"):
@@ -130,16 +143,16 @@ def parse(
             inpt_mdata = f"type={type(inpt.trait_type).__name__.lower()}|default={inpt.default!r}"
             if isinstance(inpt.trait_type, nipype.interfaces.base.core.traits.Enum):
                 inpt_mdata += f"|allowed[{','.join(sorted(repr(v) for v in inpt.trait_type.values))}]"
-            input_helps[inpt_name] = f"{inpt_mdata}: {inpt_desc}"
+            parsed.input_helps[inpt_name] = f"{inpt_mdata}: {inpt_desc}"
             trait_type_name = type(inpt.trait_type).__name__
             if inpt.genfile:
                 if trait_type_name in ("File", "Directory"):
-                    path_inputs.append(inpt_name)
-                if inpt_name in (file_outputs + dir_outputs):
-                    template_outputs.append(inpt_name)
+                    parsed.path_inputs.append(inpt_name)
+                if inpt_name in (parsed.file_outputs + parsed.dir_outputs):
+                    parsed.template_outputs.append(inpt_name)
                 else:
-                    callables.append(inpt_name)
-            elif trait_type_name == "File" and inpt_name not in file_outputs:
+                    parsed.callables.append(inpt_name)
+            elif trait_type_name == "File" and inpt_name not in parsed.file_outputs:
                 # override logic if it is named as an output
                 if (
                     inpt_name.startswith("out_")
@@ -148,22 +161,22 @@ def parse(
                     or inpt_name.endswith("_output")
                 ):
                     if "fix" in inpt_name:
-                        str_inputs.append(inpt_name)
+                        parsed.str_inputs.append(inpt_name)
                     else:
-                        path_inputs.append(inpt_name)
+                        parsed.path_inputs.append(inpt_name)
                 else:
-                    file_inputs.append(inpt_name)
-            elif trait_type_name == "Directory" and inpt_name not in dir_outputs:
-                dir_inputs.append(inpt_name)
+                    parsed.file_inputs.append(inpt_name)
+            elif trait_type_name == "Directory" and inpt_name not in parsed.dir_outputs:
+                parsed.dir_inputs.append(inpt_name)
             elif trait_type_name == "InputMultiObject":
                 inner_trait_type_name = type(
                     inpt.trait_type.item_trait.trait_type
                 ).__name__
                 if inner_trait_type_name == "Directory":
-                    dir_inputs.append(inpt_name)
+                    parsed.dir_inputs.append(inpt_name)
                 elif inner_trait_type_name == "File":
-                    file_inputs.append(inpt_name)
-                multi_inputs.append(inpt_name)
+                    parsed.file_inputs.append(inpt_name)
+                parsed.multi_inputs.append(inpt_name)
             elif type(inpt.trait_type).__name__ == "List" and type(
                 inpt.trait_type.inner_traits()[0].handler
             ).__name__ in ("File", "Directory"):
@@ -171,44 +184,13 @@ def parse(
                     inpt.trait_type.inner_traits()[0].handler
                 ).__name__
                 if item_type_name == "File":
-                    file_inputs.append(inpt_name)
+                    parsed.file_inputs.append(inpt_name)
                 else:
-                    dir_inputs.append(inpt_name)
-                multi_inputs.append(inpt_name)
+                    parsed.dir_inputs.append(inpt_name)
+                parsed.multi_inputs.append(inpt_name)
             elif trait_type_name in ("File", "Directory"):
-                path_inputs.append(inpt_name)
-        doc_string = nipype_interface.__doc__ if nipype_interface.__doc__ else ""
-        doc_string = doc_string.replace("\n", "\n# ")
-        # Create a preamble at the top of the specificaiton explaining what to do
-        preamble = (
-            f"""# This file is used to manually specify the semi-automatic conversion of
-            # '{nipype_interface.__module__.replace('/', '.')}.{nipype_interface.__name__}' from Nipype to Pydra.
-            #
-            # Please fill-in/edit the fields below where appropriate
-            #
-            # Docs
-            # ----
-            # {doc_string}\n"""
-        ).replace("        #", "#")
-        return cls(
-            name=nipype_interface.__name__,
-            doc_str=nipype_interface.__doc__ if nipype_interface.__doc__ else "",
-            module=nipype_interface.__module__[len(base_package) + 1 :],
-            pkg=pkg,
-            base_package=base_package,
-            preamble=preamble,
-            input_helps=input_helps,
-            output_helps=output_helps,
-            file_inputs=file_inputs,
-            path_inputs=path_inputs,
-            str_inputs=str_inputs,
-            file_outputs=file_outputs,
-            template_outputs=template_outputs,
-            multi_inputs=multi_inputs,
-            dir_inputs=dir_inputs,
-            dir_outputs=dir_outputs,
-            callables=callables,
-        )
+                parsed.path_inputs.append(inpt_name)
+        return parsed
 
     def generate_yaml_spec(self) -> str:
         """Convert the NipypeInterface to a YAML string"""
@@ -292,7 +274,7 @@ def type2str(tp):
         }
         yaml_str = yaml.dump(spec_stub, indent=2, sort_keys=False, width=4096)
         # Strip explicit nulls from dumped YAML
-        yaml_str = yaml_str.replace(" null", "")
+        yaml_str = re.sub(r": null$", ":", yaml_str, flags=re.MULTILINE)
         # Inject comments into dumped YAML
         for category_name, category_class in [
             ("inputs", InputsConverter),
@@ -828,7 +810,7 @@ def process_method(method: ty.Callable) -> str:
             if implicit not in arg_names:
                 args.append(f"{implicit}=None")
         src = prefix + ", ".join(args) + body
-        src = cleanup_function_body(src, with_signature=True)
+        src = cleanup_function_body(src)
         return src
 
     def insert_args_in_method_calls(src: str, args: ty.List[ty.Tuple[str, str]]) -> str:
@@ -863,7 +845,7 @@ def insert_args_in_method_calls(src: str, args: ty.List[ty.Tuple[str, str]]) ->
     used = UsedSymbols.find(mod, func_srcs)
     for func in used.local_functions:
         func_srcs.append(
-            cleanup_function_body(inspect.getsource(func), with_signature=True)
+            cleanup_function_body(inspect.getsource(func))
         )
     for new_func_name, func in used.funcs_to_include:
         func_src = inspect.getsource(func)
@@ -873,7 +855,7 @@ def insert_args_in_method_calls(src: str, args: ty.List[ty.Tuple[str, str]]) ->
             re.DOTALL | re.MULTILINE,
         )
         func_src = match.group(1) + " " + new_func_name + match.group(2)
-        func_srcs.append(cleanup_function_body(func_src, with_signature=True))
+        func_srcs.append(cleanup_function_body(func_src))
     return (
         func_srcs,
         used.imports,
diff --git a/nipype2pydra/task/base.py b/nipype2pydra/task/base.py
index ab460ef8..7fa44c53 100644
--- a/nipype2pydra/task/base.py
+++ b/nipype2pydra/task/base.py
@@ -717,11 +717,11 @@ def write_task(self, filename, input_fields, nonstd_types, output_fields):
             spec_str, fast=False, mode=black.FileMode()
         )
 
-        # FIXME: bit of a hack, should make sure that multi-input/output objects
-        #        are referenced properly without this substitution
-        spec_str = re.sub(
-            r"(?<!specs\.|mport )Multi(Input|Output)", r"specs.Multi\1", spec_str
-        )
+        # # FIXME: bit of a hack, should make sure that multi-input/output objects
+        # #        are referenced properly without this substitution
+        # spec_str = re.sub(
+        #     r"(?<!specs\.|mport )Multi(Input|Output)", r"specs.Multi\1", spec_str
+        # )
 
         with open(filename, "w") as f:
             f.write(spec_str)
diff --git a/nipype2pydra/task/function.py b/nipype2pydra/task/function.py
index 852ca386..a502cf00 100644
--- a/nipype2pydra/task/function.py
+++ b/nipype2pydra/task/function.py
@@ -18,6 +18,7 @@
 
 @attrs.define(slots=False)
 class FunctionTaskConverter(BaseTaskConverter):
+
     def generate_task_str(self, filename, input_fields, nonstd_types, output_fields):
         """writing pydra task to the dile based on the input and output spec"""
 
@@ -144,7 +145,7 @@ def process_method(
     ):
         src = inspect.getsource(method)
         pre, argstr, post = split_parens_contents(src)
-        args = re.split(r" *, *", argstr)
+        args = re.split(r"\s*,\s*", argstr.strip())
         args.remove("self")
         if "runtime" in args:
             args.remove("runtime")
@@ -191,6 +192,8 @@ def process_method_body(
             not unrecognised_outputs
         ), f"Found the following unrecognised outputs {unrecognised_outputs}"
         method_body = output_re.sub(r"\1", method_body)
+        # Strip initialisation of outputs
+        method_body = re.sub(r"outputs = self.output_spec().*", r"outputs = {}", method_body)
         # Add args to the function signature of method calls
         method_re = re.compile(r"self\.(\w+)(?=\()", flags=re.MULTILINE | re.DOTALL)
         method_names = [m.__name__ for m in self.referenced_methods]
diff --git a/nipype2pydra/utils.py b/nipype2pydra/utils.py
index fb8e4b08..ffa79968 100644
--- a/nipype2pydra/utils.py
+++ b/nipype2pydra/utils.py
@@ -357,9 +357,7 @@ def get_local_constants(mod):
     return local_vars
 
 
-def cleanup_function_body(
-    function_body: str, with_signature: bool = False
-) -> str:
+def cleanup_function_body(function_body: str) -> str:
     """Ensure 4-space indentation, replace LOGGER with logger, and replace isdefined
     with the attrs.NOTHING constant
 
@@ -375,8 +373,12 @@ def cleanup_function_body(
     function_body: str
         The processed source code
     """
+    if re.match(r"\s*(def|class)\s+", function_body):
+        with_signature = True
+    else:
+        with_signature = False
     # Detect the indentation of the source code in src and reduce it to 4 spaces
-    indents = re.findall(r"^ *(?=[^\n])", function_body, flags=re.MULTILINE)
+    indents = re.findall(r"^( *)[^\s].*\n", function_body, flags=re.MULTILINE)
     min_indent = min(len(i) for i in indents) if indents else 0
     indent_reduction = min_indent - (0 if with_signature else 4)
     assert indent_reduction >= 0, (
diff --git a/tests/test_task.py b/tests/test_task.py
index f3aa186d..a224810c 100644
--- a/tests/test_task.py
+++ b/tests/test_task.py
@@ -3,7 +3,7 @@
 import pytest
 import logging
 from conftest import show_cli_trace
-from nipype2pydra.cli import task as task_cli
+from nipype2pydra.cli.task import task as task_cli
 from nipype2pydra.utils import add_to_sys_path, add_exc_note
 from conftest import EXAMPLE_TASKS_DIR
 
@@ -81,18 +81,19 @@ def test_task_conversion(task_spec_file, cli_runner, work_dir, gen_test_conftest
         )
     )
 
-    nipype_output_names = nipype_interface.output_spec().all_trait_names()
-    outputs_omit = task_spec["outputs"]["omit"] if task_spec["outputs"]["omit"] else []
-
-    assert sorted(f[0] for f in pydra_task().output_spec.fields if not f[0].startswith("_")) == sorted(
-        n
-        for n in nipype_output_names
-        if not (
-            n in INBUILT_NIPYPE_TRAIT_NAMES
-            or n in outputs_omit
-            or (n.endswith("_items") and n[: -len("_items")] in nipype_output_names)
+    if nipype_interface.output_spec:
+        nipype_output_names = nipype_interface.output_spec().all_trait_names()
+        outputs_omit = task_spec["outputs"]["omit"] if task_spec["outputs"]["omit"] else []
+
+        assert sorted(f[0] for f in pydra_task().output_spec.fields if not f[0].startswith("_")) == sorted(
+            n
+            for n in nipype_output_names
+            if not (
+                n in INBUILT_NIPYPE_TRAIT_NAMES
+                or n in outputs_omit
+                or (n.endswith("_items") and n[: -len("_items")] in nipype_output_names)
+            )
         )
-    )
 
     # tests_fspath = pkg_root.joinpath(*output_module_path.split(".")).parent / "tests"
 

From 0147531faf7def7d75ed3ecd63488c0446ada415 Mon Sep 17 00:00:00 2001
From: Tom Close <tom.g.close@gmail.com>
Date: Fri, 8 Mar 2024 23:52:24 +1100
Subject: [PATCH 56/78] chasing down nested includes

---
 nipype2pydra/pkg_gen/__init__.py | 108 ++++++++++++++++++++-----------
 nipype2pydra/task/base.py        |   4 +-
 nipype2pydra/task/function.py    |  12 +++-
 nipype2pydra/utils.py            |  58 ++++++++++++++---
 4 files changed, 135 insertions(+), 47 deletions(-)

diff --git a/nipype2pydra/pkg_gen/__init__.py b/nipype2pydra/pkg_gen/__init__.py
index 69e50c75..31d5df6f 100644
--- a/nipype2pydra/pkg_gen/__init__.py
+++ b/nipype2pydra/pkg_gen/__init__.py
@@ -4,6 +4,7 @@
 import inspect
 from importlib import import_module
 from copy import copy
+from collections import defaultdict
 import shutil
 import string
 from pathlib import Path
@@ -321,14 +322,22 @@ def generate_callables(self, nipype_interface) -> str:
         if self.callables:
             # Convert the "_gen_filename" method into a function with any referenced
             # methods, functions and constants included in the module
-            funcs, imports, consts = get_gen_filename_to_funcs(nipype_interface)
+            funcs, imports, consts = get_callable_sources(nipype_interface)
             callables_str += "\n".join(imports) + "\n\n"
             # Create separate callable function for each callable field, which
             # reference the magic "_gen_filename" method
-            for name in self.callables:
+            for inpt_name, inpt in nipype_interface.input_spec().traits().items():
+                if inpt.genfile:
+                    callables_str += (
+                        f"def {inpt_name}_default(inputs):\n"
+                        f'    return _gen_filename("{inpt_name}", inputs=inputs)\n\n'
+                    )
+            
+            for output_name in self.callables:
                 callables_str += (
-                    f"def {name}_callable(output_dir, inputs, stdout, stderr):\n"
-                    f'    return _gen_filename("{name}", output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr)\n\n'
+                    f"def {output_name}_callable(output_dir, inputs, stdout, stderr):\n"
+                    '    outputs = _list_outputs(output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr)\n'
+                    '    return outputs["' + output_name + '"]\n\n'
                 )
             for const in consts:
                 callables_str += f"{const[0]} = {const[1]}\n" + "\n\n"
@@ -753,7 +762,7 @@ def gen_sample_{frmt.lower()}_data({frmt.lower()}: {frmt}, dest_dir: Path, seed:
     return code_str
 
 
-def get_gen_filename_to_funcs(
+def get_callable_sources(
     nipype_interface,
 ) -> ty.Tuple[ty.List[str], ty.Set[str], ty.Set[ty.Tuple[str, str]]]:
     """
@@ -787,16 +796,22 @@ def _gen_filename(field, inputs, output_dir, stdout, stderr):
 
     IMPLICIT_ARGS = ["inputs", "stdout", "stderr", "output_dir"]
 
-    def find_nested_methods(method: ty.Callable) -> ty.List[str]:
-        all_nested = set()
-        for match in re.findall(r"self\.(\w+)\(", inspect.getsource(method)):
-            nested = getattr(nipype_interface, match)
-            all_nested.add(nested)
-            all_nested.update(find_nested_methods(nested))
+    def find_nested_methods(methods: ty.List[ty.Callable]) -> ty.List[str]:
+        all_nested = set(methods)
+        for method in methods:
+            for match in re.findall(r"self\.(\w+)\(", inspect.getsource(method)):
+                if match in ("output_spec", "_outputs"):
+                    continue
+                nested = getattr(nipype_interface, match)
+                if nested not in all_nested:
+                    all_nested.add(nested)
+                    all_nested.update(find_nested_methods([nested]))
         return all_nested
 
     def process_method(method: ty.Callable) -> str:
         src = inspect.getsource(method)
+        src = src.replace("if self.output_spec:", "if True:")
+        src = re.sub(r"outputs = self\.(output_spec|_outputs)\(\).*$", r"outputs = {}", src, flags=re.MULTILINE)        
         prefix, args_str, body = split_parens_contents(src)
         body = insert_args_in_method_calls(body, [f"{a}={a}" for a in IMPLICIT_ARGS])
         body = body.replace("self.cmd", f'"{nipype_interface._cmd}"')
@@ -833,31 +848,50 @@ def insert_args_in_method_calls(src: str, args: ty.List[ty.Tuple[str, str]]) ->
             new_src += name + insert_args_in_signature(sig, args)
         return new_src
 
-    func_srcs = [
-        process_method(m)
-        for m in (
-            [nipype_interface._gen_filename]
-            + list(find_nested_methods(nipype_interface._gen_filename))
-        )
-    ]
-
-    mod = import_module(nipype_interface.__module__)
-    used = UsedSymbols.find(mod, func_srcs)
-    for func in used.local_functions:
-        func_srcs.append(
-            cleanup_function_body(inspect.getsource(func))
-        )
-    for new_func_name, func in used.funcs_to_include:
-        func_src = inspect.getsource(func)
-        match = re.match(
-            r" *(def|class) *" + func.__name__ + r"(?=\()(.*)$",
-            func_src,
-            re.DOTALL | re.MULTILINE,
-        )
-        func_src = match.group(1) + " " + new_func_name + match.group(2)
-        func_srcs.append(cleanup_function_body(func_src))
+    methods_to_process = [nipype_interface._list_outputs]
+    if hasattr(nipype_interface, "_gen_filename"):
+        methods_to_process.append(nipype_interface._gen_filename)
+    
+    func_srcs = defaultdict(list)
+    for method in find_nested_methods(methods_to_process):
+        func_srcs[method.__module__].append(process_method(method))
+    all_funcs = []
+    all_imports = set()
+    all_constants = set()
+    for mod_name, funcs in func_srcs.items():
+        mod = import_module(mod_name)
+        used = UsedSymbols.find(mod, funcs)
+        all_funcs.extend(funcs)
+        for func in used.local_functions:
+            all_funcs.append(
+                cleanup_function_body(inspect.getsource(func))
+            )
+        for klass in used.local_classes:
+            all_funcs.append(
+                cleanup_function_body(inspect.getsource(klass))
+            )            
+        for new_func_name, func in used.funcs_to_include:
+            func_src = inspect.getsource(func)
+            match = re.match(
+                r" *def *" + func.__name__ + r"(?=\()(.*)$",
+                func_src,
+                re.DOTALL | re.MULTILINE,
+            )
+            func_src = "def " + new_func_name + match.group(1)
+            all_funcs.append(cleanup_function_body(func_src))
+        for new_klass_name, klass in used.classes_to_include:
+            klass_src = inspect.getsource(klass)
+            match = re.match(
+                r" *class *" + klass.__name__ + r"(?=\()(.*)$",
+                klass_src,
+                re.DOTALL | re.MULTILINE,
+            )
+            klass_src = "class " + new_klass_name + match.group(1)
+            all_funcs.append(cleanup_function_body(klass_src))            
+        all_imports.update(used.imports)
+        all_constants.update(used.constants)
     return (
-        func_srcs,
-        used.imports,
-        used.constants,
+        reversed(all_funcs),  # Ensure base classes are defined first
+        all_imports,
+        all_constants,
     )
diff --git a/nipype2pydra/task/base.py b/nipype2pydra/task/base.py
index 7fa44c53..1266e6aa 100644
--- a/nipype2pydra/task/base.py
+++ b/nipype2pydra/task/base.py
@@ -762,8 +762,10 @@ def add_import(stmt):
 
         if re.match(r".*(?<!\w)ty\.", spec_str, flags=re.MULTILINE | re.DOTALL):
             add_import("import typing as ty")
-        if re.match(r".*(?<!\w)Path(?!\w)", spec_str, flags=re.MULTILINE | re.DOTALL):
+        if re.match(r".*\bPath\b", spec_str, flags=re.MULTILINE | re.DOTALL):
             add_import("from pathlib import Path")
+        if re.match(r".*\blogging\b", spec_str, flags=re.MULTILINE | re.DOTALL):
+            add_import("import logging")
         for test in self.tests:
             for stmt in test.imports:
                 if "nipype" in stmt.module:
diff --git a/nipype2pydra/task/function.py b/nipype2pydra/task/function.py
index a502cf00..6f740bb1 100644
--- a/nipype2pydra/task/function.py
+++ b/nipype2pydra/task/function.py
@@ -118,13 +118,23 @@ def types_to_names(spec_fields):
         for func_name, func in sorted(used.funcs_to_include, key=itemgetter(0)):
             func_src = inspect.getsource(func)
             func_src = re.sub(
-                r"^(def|class) (\w+)(?=\()",
+                r"^(def) (\w+)(?=\()",
                 r"\1 " + func_name,
                 func_src,
                 flags=re.MULTILINE,
             )
             spec_str += "\n\n" + cleanup_function_body(func_src)
 
+        for klass_name, klass in sorted(used.classes_to_include, key=itemgetter(0)):
+            klass_src = inspect.getsource(klass)
+            klass_src = re.sub(
+                r"^(class) (\w+)(?=\()",
+                r"\1 " + klass_name,
+                klass_src,
+                flags=re.MULTILINE,
+            )
+            spec_str += "\n\n" + cleanup_function_body(klass_src)
+
         imports = self.construct_imports(
             nonstd_types,
             spec_str,
diff --git a/nipype2pydra/utils.py b/nipype2pydra/utils.py
index ffa79968..f8ce4822 100644
--- a/nipype2pydra/utils.py
+++ b/nipype2pydra/utils.py
@@ -201,7 +201,9 @@ class UsedSymbols:
 
     imports: ty.Set[str] = attrs.field(factory=set)
     funcs_to_include: ty.Set[ty.Tuple[str, ty.Callable]] = attrs.field(factory=set)
+    classes_to_include: ty.List[ty.Tuple[str, ty.Callable]] = attrs.field(factory=set)
     local_functions: ty.Set[ty.Callable] = attrs.field(factory=set)
+    local_classes: ty.List[type] = attrs.field(factory=list)
     constants: ty.Set[ty.Tuple[str, str]] = attrs.field(factory=set)
 
     def update(self, other: "UsedSymbols"):
@@ -231,11 +233,15 @@ def find(
             a class containing the used symbols in the module
         """
         used = cls()
-        imports = ["import attrs", "from fileformats.generic import File, Directory"]  # attrs is included in imports in case we reference attrs.NOTHING
+        imports = [
+            "import attrs",
+            "from fileformats.generic import File, Directory",
+        ]  # attrs is included in imports in case we reference attrs.NOTHING
         block = ""
         source_code = inspect.getsource(module)
         local_functions = get_local_functions(module)
         local_constants = get_local_constants(module)
+        local_classes = get_local_classes(module)
         for line in source_code.split("\n"):
             if line.startswith("from") or line.startswith("import"):
                 if "(" in line:
@@ -268,6 +274,22 @@ def find(
                     local_func_symbols = re.findall(r"\b(\w+)\b", func_body)
                     used_symbols.update(local_func_symbols)
                     new_symbols = True
+            for local_class in local_classes:
+                if (
+                    local_class.__name__ in used_symbols
+                    and local_class not in used.local_classes
+                ):
+                    used.local_classes.append(local_class)
+                    class_body = inspect.getsource(local_class)
+                    bases = [
+                        b.strip()
+                        for b in split_parens_contents(class_body)[1].split(",")
+                    ]
+                    used_symbols.update(bases)
+                    class_body = re.sub(r"\s*#.*", "", class_body)
+                    local_class_symbols = re.findall(r"\b(\w+)\b", class_body)
+                    used_symbols.update(local_class_symbols)
+                    new_symbols = True
             for const_name, const_def in local_constants:
                 if (
                     const_name in used_symbols
@@ -311,10 +333,14 @@ def find(
                     mod = import_module(mod_name)
                     mod_func_bodies = []
                     for used_part in used_parts:
-                        func = getattr(mod, used_part[0])
-                        if inspect.isfunction(func):
-                            used.funcs_to_include.add((used_part[-1], func))
-                            mod_func_bodies.append(inspect.getsource(func))
+                        atr = getattr(mod, used_part[0])
+                        if inspect.isfunction(atr):
+                            used.funcs_to_include.add((used_part[-1], atr))
+                            mod_func_bodies.append(inspect.getsource(atr))
+                        elif inspect.isclass(atr):
+                            used.classes_to_include.add((used_part[-1], atr))
+                            class_body = split_parens_contents(inspect.getsource(atr))[2].split("\n", 1)[1]
+                            mod_func_bodies.append(class_body)
                     # Recursively include neighbouring objects imported in the module
                     used_in_mod = cls.find(
                         mod,
@@ -338,6 +364,16 @@ def get_local_functions(mod):
     return functions
 
 
+def get_local_classes(mod):
+    """Get the functions defined in the module"""
+    classes = []
+    for attr_name in dir(mod):
+        attr = getattr(mod, attr_name)
+        if inspect.isclass(attr) and attr.__module__ == mod.__name__:
+            classes.append(attr)
+    return classes
+
+
 def get_local_constants(mod):
     """
     Get the constants defined in the module
@@ -390,12 +426,18 @@ def cleanup_function_body(function_body: str) -> str:
             r"^" + " " * indent_reduction, "", function_body, flags=re.MULTILINE
         )
     # Other misc replacements
-    function_body = function_body.replace("LOGGER.", "logger.")
+    # function_body = function_body.replace("LOGGER.", "logger.")
     function_body = re.sub(
-        r"not isdefined\(([a-zA-Z0-9\_\.]+)\)", r"\1 is attrs.NOTHING", function_body, flags=re.MULTILINE
+        r"not isdefined\(([a-zA-Z0-9\_\.]+)\)",
+        r"\1 is attrs.NOTHING",
+        function_body,
+        flags=re.MULTILINE,
     )
     function_body = re.sub(
-        r"isdefined\(([a-zA-Z0-9\_\.]+)\)", r"\1 is not attrs.NOTHING", function_body, flags=re.MULTILINE
+        r"isdefined\(([a-zA-Z0-9\_\.]+)\)",
+        r"\1 is not attrs.NOTHING",
+        function_body,
+        flags=re.MULTILINE,
     )
     return function_body
 

From 69711ea4005f9a74fc3a6094b1141e5fda622c81 Mon Sep 17 00:00:00 2001
From: Tom Close <tom.g.close@gmail.com>
Date: Sat, 9 Mar 2024 00:28:33 +1100
Subject: [PATCH 57/78] sorted out issue with loggers being dropped

---
 nipype2pydra/utils.py | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/nipype2pydra/utils.py b/nipype2pydra/utils.py
index f8ce4822..d20499d3 100644
--- a/nipype2pydra/utils.py
+++ b/nipype2pydra/utils.py
@@ -236,6 +236,8 @@ def find(
         imports = [
             "import attrs",
             "from fileformats.generic import File, Directory",
+            "import logging",
+            "from logging import getLogger",
         ]  # attrs is included in imports in case we reference attrs.NOTHING
         block = ""
         source_code = inspect.getsource(module)
@@ -351,7 +353,7 @@ def find(
                     used.imports.add(required_stmt)
         return used
 
-    SYMBOLS_TO_IGNORE = ["isdefined", "LOGGER"]
+    SYMBOLS_TO_IGNORE = ["isdefined"]
 
 
 def get_local_functions(mod):
@@ -394,7 +396,7 @@ def get_local_constants(mod):
 
 
 def cleanup_function_body(function_body: str) -> str:
-    """Ensure 4-space indentation, replace LOGGER with logger, and replace isdefined
+    """Ensure 4-space indentation and replace isdefined
     with the attrs.NOTHING constant
 
     Parameters

From c9503f6aaa7d5a2be54a48f7b8b10efaf0bde8db Mon Sep 17 00:00:00 2001
From: Tom Close <tom.g.close@gmail.com>
Date: Mon, 11 Mar 2024 13:40:47 +1100
Subject: [PATCH 58/78] beefed up split_parens_contents to handle nested
 functions and quotest

---
 nipype2pydra/exceptions.py                    |   3 +
 nipype2pydra/pkg_gen/__init__.py              |  14 ++-
 nipype2pydra/task/function.py                 |   4 +-
 .../task/tests}/test_task.py                  |   0
 nipype2pydra/tests/test_utils.py              |  61 ++++++++++
 nipype2pydra/utils.py                         | 112 +++++++++++-------
 6 files changed, 148 insertions(+), 46 deletions(-)
 create mode 100644 nipype2pydra/exceptions.py
 rename {tests => nipype2pydra/task/tests}/test_task.py (100%)
 create mode 100644 nipype2pydra/tests/test_utils.py

diff --git a/nipype2pydra/exceptions.py b/nipype2pydra/exceptions.py
new file mode 100644
index 00000000..d7b6704e
--- /dev/null
+++ b/nipype2pydra/exceptions.py
@@ -0,0 +1,3 @@
+
+class UnmatchedParensException(Exception):
+    pass
diff --git a/nipype2pydra/pkg_gen/__init__.py b/nipype2pydra/pkg_gen/__init__.py
index 31d5df6f..8092ff1b 100644
--- a/nipype2pydra/pkg_gen/__init__.py
+++ b/nipype2pydra/pkg_gen/__init__.py
@@ -812,14 +812,14 @@ def process_method(method: ty.Callable) -> str:
         src = inspect.getsource(method)
         src = src.replace("if self.output_spec:", "if True:")
         src = re.sub(r"outputs = self\.(output_spec|_outputs)\(\).*$", r"outputs = {}", src, flags=re.MULTILINE)        
-        prefix, args_str, body = split_parens_contents(src)
+        prefix, args, body = split_parens_contents(src)
         body = insert_args_in_method_calls(body, [f"{a}={a}" for a in IMPLICIT_ARGS])
         body = body.replace("self.cmd", f'"{nipype_interface._cmd}"')
         body = body.replace("self.", "")
         body = re.sub(r"\w+runtime\.(stdout|stderr)", r"\1", body)
         body = body.replace("os.getcwd()", "output_dir")
         # drop 'self' from the args and add the implicit callable args
-        args = args_str.split(",")[1:]
+        args = args[1:]
         arg_names = [a.split("=")[0].split(":")[0] for a in args]
         for implicit in IMPLICIT_ARGS:
             if implicit not in arg_names:
@@ -844,8 +844,14 @@ def insert_args_in_method_calls(src: str, args: ty.List[ty.Tuple[str, str]]) ->
         new_src = splits[0]
         # Iterate through these chunks and add the additional args to the method calls
         # using insert_args_in_signature function
-        for name, sig in zip(splits[1::2], splits[2::2]):
-            new_src += name + insert_args_in_signature(sig, args)
+        sig = ""
+        for name, next_part in zip(splits[1::2], splits[2::2]):
+            if next_part.count("(") > next_part.count(")"):
+                sig += name + next_part
+            else:
+                sig += next_part
+                new_src += name + insert_args_in_signature(sig, args)
+                sig = ""
         return new_src
 
     methods_to_process = [nipype_interface._list_outputs]
diff --git a/nipype2pydra/task/function.py b/nipype2pydra/task/function.py
index 6f740bb1..10e28693 100644
--- a/nipype2pydra/task/function.py
+++ b/nipype2pydra/task/function.py
@@ -24,6 +24,7 @@ def generate_task_str(self, filename, input_fields, nonstd_types, output_fields)
 
         base_imports = [
             "import pydra.mark",
+            "import logging",
             "from logging import getLogger",
             "import attrs",
         ]
@@ -154,8 +155,7 @@ def process_method(
         method_returns: ty.Dict[str, ty.List[str]] = None,
     ):
         src = inspect.getsource(method)
-        pre, argstr, post = split_parens_contents(src)
-        args = re.split(r"\s*,\s*", argstr.strip())
+        pre, args, post = split_parens_contents(src)
         args.remove("self")
         if "runtime" in args:
             args.remove("runtime")
diff --git a/tests/test_task.py b/nipype2pydra/task/tests/test_task.py
similarity index 100%
rename from tests/test_task.py
rename to nipype2pydra/task/tests/test_task.py
diff --git a/nipype2pydra/tests/test_utils.py b/nipype2pydra/tests/test_utils.py
new file mode 100644
index 00000000..3f265236
--- /dev/null
+++ b/nipype2pydra/tests/test_utils.py
@@ -0,0 +1,61 @@
+from nipype2pydra.utils import split_parens_contents
+
+
+def test_split_parens_contents1():
+    assert split_parens_contents(
+        "def foo(a, b, c):\n    return a",
+    ) == ("def foo(", ["a", "b", "c"], "):\n    return a")
+
+
+def test_split_parens_contents2():
+    assert split_parens_contents(
+        "foo(a, 'b, c')",
+    ) == ("foo(", ["a", "'b, c'"], ")")
+
+
+def test_split_parens_contents2a():
+    assert split_parens_contents(
+        'foo(a, "b, c")',
+    ) == ("foo(", ["a", '"b, c"'], ")")
+
+
+def test_split_parens_contents2b():
+    assert split_parens_contents(
+        "foo(a, 'b, \"c')"
+    ) == ("foo(", ["a", "'b, \"c'"], ")")
+
+
+def test_split_parens_contents3():
+    assert split_parens_contents(
+        "foo(a, bar(b, c))",
+    ) == ("foo(", ["a", "bar(b, c)"], ")")
+
+
+def test_split_parens_contents3a():
+    assert split_parens_contents(
+        "foo(a, bar[b, c])",
+    ) == ("foo(", ["a", "bar[b, c]"], ")")
+
+
+def test_split_parens_contents3b():
+    assert split_parens_contents(
+        "foo(a, bar([b, c]))",
+    ) == ("foo(", ["a", "bar([b, c])"], ")")
+
+
+def test_split_parens_contents5():
+    assert split_parens_contents(
+        "foo(a, '\"b\"', c)",
+    ) == ("foo(", ["a", "'\"b\"'", "c"], ")")
+
+
+def test_split_parens_contents6():
+    assert split_parens_contents(
+        r"foo(a, '\'b\'', c)",
+    ) == ("foo(", ["a", r"'\'b\''", "c"], ")")
+
+
+def test_split_parens_contents6a():
+    assert split_parens_contents(
+        r"foo(a, '\'b\', c')",
+    ) == ("foo(", ["a", r"'\'b\', c'"], ")")
diff --git a/nipype2pydra/utils.py b/nipype2pydra/utils.py
index d20499d3..bbd926a2 100644
--- a/nipype2pydra/utils.py
+++ b/nipype2pydra/utils.py
@@ -9,6 +9,7 @@
 import attrs
 from pathlib import Path
 from fileformats.core import FileSet
+from .exceptions import UnmatchedParensException
 
 try:
     from typing import GenericAlias
@@ -133,7 +134,7 @@ def add_exc_note(e, note):
     return e
 
 
-def split_parens_contents(snippet, brackets: bool = False):
+def split_parens_contents(snippet, brackets: bool = False, delimiter=","):
     """Splits the code snippet at the first opening parenthesis into a 3-tuple
     consisting of the pre-paren text, the contents of the parens and the post-paren
 
@@ -143,38 +144,74 @@ def split_parens_contents(snippet, brackets: bool = False):
         the code snippet to split
     brackets: bool, optional
         whether to split at brackets instead of parens, by default False
+    delimiter: str, optional
+        an optional delimiter to split the contents of the parens by, by default None
+        means that they aren't split
 
     Returns
     -------
     pre: str
         the text before the opening parenthesis
-    contents: str
+    contents: str or list[str]
         the contents of the parens
     post: str
         the text after the closing parenthesis
     """
-    if brackets:
-        open = "["
-        close = "]"
-        pattern = r"(\[|\])"
-    else:
-        open = "("
-        close = ")"
-        pattern = r"(\(|\))"
-    splits = re.split(pattern, snippet, flags=re.MULTILINE | re.DOTALL)
-    depth = 1
+    splits = re.split(
+        r"(\(|\)|\[|\]|'|\"|\\\(|\\\)|\\\[|\\\]|\\'|\\\")",
+        snippet,
+        flags=re.MULTILINE | re.DOTALL,
+    )
     pre = "".join(splits[:2])
-    contents = ""
+    contents = []
+    next_item = ""
+    first = splits[1]  # which bracket/parens type was opened initially (and signifies)
+    matching = {")": "(", "]": "["}
+    open = ["(", "["]
+    close = [")", "]"]
+    depth = {p: 0 for p in open}
+    depth[first] += 1  # Open the first bracket/parens type
+    inquote = None
     for i, s in enumerate(splits[2:], start=2):
-        if s == open:
-            depth += 1
+        if not s:
+            continue
+        if s[0] == "\\":
+            next_item += s
+            continue
+        if s in ["'", '"']:
+            if inquote is None:
+                inquote = s
+            elif inquote == s:
+                inquote = None
+            next_item += s
+            continue
+        if inquote:
+            next_item += s
+            continue
+        if s in open:
+            depth[s] += 1
+            next_item += s
         else:
-            if s == close:
-                depth -= 1
-                if depth == 0:
+            if s in close:
+                matching_open = matching[s]
+                depth[matching_open] -= 1
+                if matching_open == first and depth[matching_open] == 0:
+                    if next_item:
+                        contents.append(next_item)
                     return pre, contents, "".join(splits[i:])
-            contents += s
-    raise ValueError(f"No matching parenthesis found in '{snippet}'")
+            if depth[first] == 1 and all(
+                d == 0 for b, d in depth.items() if b != first
+            ):
+                parts = [p.strip() for p in s.split(delimiter)]
+                if parts:
+                    contents.append((next_item + parts[0]).strip())
+                    contents.extend(parts[1:-1])
+                    next_item = parts[-1] if len(parts) > 1 else ""
+                else:
+                    next_item = ""
+            else:
+                next_item += s
+    raise UnmatchedParensException(f"Unmatched parenthesis found in '{snippet}'")
 
 
 @attrs.define
@@ -237,7 +274,6 @@ def find(
             "import attrs",
             "from fileformats.generic import File, Directory",
             "import logging",
-            "from logging import getLogger",
         ]  # attrs is included in imports in case we reference attrs.NOTHING
         block = ""
         source_code = inspect.getsource(module)
@@ -259,7 +295,6 @@ def find(
             # Strip comments from function body
             function_body = re.sub(r"\s*#.*", "", function_body)
             used_symbols.update(re.findall(r"\b(\w+)\b", function_body))
-        used_symbols -= set(cls.SYMBOLS_TO_IGNORE)
         # Keep looping through local function source until all local functions and constants
         # are added to the used symbols
         new_symbols = True
@@ -283,10 +318,7 @@ def find(
                 ):
                     used.local_classes.append(local_class)
                     class_body = inspect.getsource(local_class)
-                    bases = [
-                        b.strip()
-                        for b in split_parens_contents(class_body)[1].split(",")
-                    ]
+                    bases = split_parens_contents(class_body)[1]
                     used_symbols.update(bases)
                     class_body = re.sub(r"\s*#.*", "", class_body)
                     local_class_symbols = re.findall(r"\b(\w+)\b", class_body)
@@ -301,6 +333,7 @@ def find(
                     const_def_symbols = re.findall(r"\b(\w+)\b", const_def)
                     used_symbols.update(const_def_symbols)
                     new_symbols = True
+        used_symbols -= set(cls.SYMBOLS_TO_IGNORE)
         # functions to copy from a relative or nipype module into the output module
         for stmt in imports:
             stmt = stmt.replace("\n", "")
@@ -323,6 +356,8 @@ def find(
                         match = re.match(r"(\.*)(.*)", import_mod)
                         mod_parts = module.__name__.split(".")
                         nparents = len(match.group(1))
+                        if Path(module.__file__).stem == "__init__":
+                            nparents -= 1
                         if nparents:
                             mod_parts = mod_parts[:-nparents]
                         mod_name = ".".join(mod_parts)
@@ -341,7 +376,9 @@ def find(
                             mod_func_bodies.append(inspect.getsource(atr))
                         elif inspect.isclass(atr):
                             used.classes_to_include.add((used_part[-1], atr))
-                            class_body = split_parens_contents(inspect.getsource(atr))[2].split("\n", 1)[1]
+                            class_body = split_parens_contents(inspect.getsource(atr))[
+                                2
+                            ].split("\n", 1)[1]
                             mod_func_bodies.append(class_body)
                     # Recursively include neighbouring objects imported in the module
                     used_in_mod = cls.find(
@@ -384,12 +421,11 @@ def get_local_constants(mod):
     parts = re.split(r"^(\w+) *= *", source_code, flags=re.MULTILINE)
     local_vars = []
     for attr_name, following in zip(parts[1::2], parts[2::2]):
-        if "(" in following.splitlines()[0]:
-            pre, args, _ = split_parens_contents(following)
-            local_vars.append((attr_name, pre + re.sub(r"\n *", "", args) + ")"))
-        elif "[" in following.splitlines()[0]:
-            pre, args, _ = split_parens_contents(following, brackets=True)
-            local_vars.append((attr_name, pre + re.sub(r"\n *", "", args) + "]"))
+        if "(" in following or "[" in following:
+            pre, args, post = split_parens_contents(following)
+            local_vars.append(
+                (attr_name, pre + re.sub(r"\n *", "", ", ".join(args)) + post[0])
+            )
         else:
             local_vars.append((attr_name, following.splitlines()[0]))
     return local_vars
@@ -460,11 +496,7 @@ def insert_args_in_signature(snippet: str, new_args: ty.Iterable[str]) -> str:
         the modified function signature
     """
     # Split out the argstring from the rest of the code snippet
-    pre, argstr, post = split_parens_contents(snippet)
-    if argstr:
-        args = re.split(r" *, *", argstr)
-        if "runtime" in args:
-            args.remove("runtime")
-    else:
-        args = []
+    pre, args, post = split_parens_contents(snippet)
+    if "runtime" in args:
+        args.remove("runtime")
     return pre + ", ".join(args + new_args) + post

From 44e73e9dce8755dd6fa343b168bbac953545d78d Mon Sep 17 00:00:00 2001
From: Tom Close <tom.g.close@gmail.com>
Date: Mon, 11 Mar 2024 17:45:13 +1100
Subject: [PATCH 59/78] regenerated example specs with the latest version of
 the package generator script

---
 .../task/nipype/afni/center_mass.yaml         |    2 +-
 example-specs/task/nipype/afni/dot.yaml       |    2 +-
 .../task/nipype/afni/one_d_tool_py.yaml       |    2 +-
 example-specs/task/nipype/afni/qwarp.yaml     |    2 +-
 .../task/nipype/afni/qwarp_plus_minus.yaml    |    2 +-
 .../task/nipype/afni/t_corr_map.yaml          |    2 +-
 .../task/nipype/ants/atropos_callables.py     |   52 +-
 .../freesurfer/fit_ms_params_callables.py     |   30 +-
 .../freesurfer/mr_is_convert_callables.py     |   81 +-
 .../freesurfer/mri_convert_callables.py       |  166 ++-
 .../mri_marching_cubes_callables.py           |   53 +-
 .../freesurfer/mri_tessellate_callables.py    |   54 +-
 .../smooth_tessellation_callables.py          |   53 +-
 .../freesurfer/spherical_average_callables.py |   35 +-
 .../freesurfer/surface_snapshots_callables.py |  173 ++-
 .../task/nipype/fsl/epi_de_warp_callables.py  |  360 +++--
 .../nipype/fsl/prob_track_x2_callables.py     | 1168 ++++++++++++++++-
 .../task/nipype/fsl/prob_track_x_callables.py |  375 +++++-
 .../task/nipype/fsl/slice_timer_callables.py  |  257 +++-
 .../task/nipype/fsl/susan_callables.py        |  257 +++-
 nipype2pydra/pkg_gen/__init__.py              |   17 +-
 nipype2pydra/task/tests/test_task.py          |  157 ++-
 nipype2pydra/tests/test_utils.py              |   30 +-
 nipype2pydra/utils.py                         |   27 +-
 24 files changed, 2962 insertions(+), 395 deletions(-)

diff --git a/example-specs/task/nipype/afni/center_mass.yaml b/example-specs/task/nipype/afni/center_mass.yaml
index b0546b98..3d1d972a 100644
--- a/example-specs/task/nipype/afni/center_mass.yaml
+++ b/example-specs/task/nipype/afni/center_mass.yaml
@@ -88,7 +88,7 @@ tests:
     automask:
     # type=bool|default=False: Generate the mask automatically
     set_cm:
-    # type=tuple|default=(<traits.trait_types.Float object at 0x10ffdfcd0>, <traits.trait_types.Float object at 0x10ffdfdd0>, <traits.trait_types.Float object at 0x10ffdfe50>): After computing the center of mass, set the origin fields in the header so that the center of mass will be at (x,y,z) in DICOM coords.
+    # type=tuple|default=(<traits.trait_types.Float object at 0x10b05c8d0>, <traits.trait_types.Float object at 0x10b05c9d0>, <traits.trait_types.Float object at 0x10b05ca50>): After computing the center of mass, set the origin fields in the header so that the center of mass will be at (x,y,z) in DICOM coords.
     local_ijk:
     # type=bool|default=False: Output values as (i,j,k) in local orientation
     roi_vals:
diff --git a/example-specs/task/nipype/afni/dot.yaml b/example-specs/task/nipype/afni/dot.yaml
index ee7ae529..47a6197e 100644
--- a/example-specs/task/nipype/afni/dot.yaml
+++ b/example-specs/task/nipype/afni/dot.yaml
@@ -82,7 +82,7 @@ tests:
     mask:
     # type=file|default=<undefined>: Use this dataset as a mask
     mrange:
-    # type=tuple|default=(<traits.trait_types.Float object at 0x10ffe6310>, <traits.trait_types.Float object at 0x10ffe6210>): Means to further restrict the voxels from 'mset' so thatonly those mask values within this range (inclusive) willbe used.
+    # type=tuple|default=(<traits.trait_types.Float object at 0x10b05f210>, <traits.trait_types.Float object at 0x10b05f110>): Means to further restrict the voxels from 'mset' so thatonly those mask values within this range (inclusive) willbe used.
     demean:
     # type=bool|default=False: Remove the mean from each volume prior to computing the correlation
     docor:
diff --git a/example-specs/task/nipype/afni/one_d_tool_py.yaml b/example-specs/task/nipype/afni/one_d_tool_py.yaml
index fdb3e8d8..4abd6ee1 100644
--- a/example-specs/task/nipype/afni/one_d_tool_py.yaml
+++ b/example-specs/task/nipype/afni/one_d_tool_py.yaml
@@ -79,7 +79,7 @@ tests:
     show_censor_count:
     # type=bool|default=False: display the total number of censored TRs  Note : if input is a valid xmat.1D dataset, then the count will come from the header.  Otherwise the input is assumed to be a binary censorfile, and zeros are simply counted.
     censor_motion:
-    # type=tuple|default=(<traits.trait_types.Float object at 0x11411a010>, <nipype.interfaces.base.traits_extension.File object at 0x11411a0d0>): Tuple of motion limit and outfile prefix. need to also set set_nruns -r set_run_lengths
+    # type=tuple|default=(<traits.trait_types.Float object at 0x10b08b5d0>, <nipype.interfaces.base.traits_extension.File object at 0x10b08b690>): Tuple of motion limit and outfile prefix. need to also set set_nruns -r set_run_lengths
     censor_prev_TR:
     # type=bool|default=False: for each censored TR, also censor previous
     show_trs_uncensored:
diff --git a/example-specs/task/nipype/afni/qwarp.yaml b/example-specs/task/nipype/afni/qwarp.yaml
index 698dfef9..08bf4cea 100644
--- a/example-specs/task/nipype/afni/qwarp.yaml
+++ b/example-specs/task/nipype/afni/qwarp.yaml
@@ -190,7 +190,7 @@ tests:
     wball:
     # type=list|default=[]: "``-wball x y z r f`` Enhance automatic weight from '-useweight' by a factor of 1+f\*Gaussian(FWHM=r) centered in the base image at DICOM coordinates (x,y,z) and with radius 'r'. The goal of this option is to try and make the alignment better in a specific part of the brain. Example:  -wball 0 14 6 30 40 to emphasize the thalamic area (in MNI/Talairach space).  * The 'r' parameter must be positive! * The 'f' parameter must be between 1 and 100 (inclusive). * '-wball' does nothing if you input your own weight   with the '-weight' option. * '-wball' does change the binary weight created by   the '-noweight' option. * You can only use '-wball' once in a run of 3dQwarp.  **The effect of '-wball' is not dramatic.** The example above makes the average brain image across a collection of subjects a little sharper in the thalamic area, which might have some small value.  If you care enough about alignment to use '-wball', then you should examine the results from 3dQwarp for each subject, to see if the alignments are good enough for your purposes.
     wmask:
-    # type=tuple|default=(<nipype.interfaces.base.traits_extension.File object at 0x10ff13890>, <traits.trait_types.Float object at 0x10ff13910>): Similar to '-wball', but here, you provide a dataset 'ws' that indicates where to increase the weight.  * The 'ws' dataset must be on the same 3D grid as the base dataset. * 'ws' is treated as a mask -- it only matters where it   is nonzero -- otherwise, the values inside are not used. * After 'ws' comes the factor 'f' by which to increase the   automatically computed weight.  Where 'ws' is nonzero,   the weighting will be multiplied by (1+f). * As with '-wball', the factor 'f' should be between 1 and 100.  
+    # type=tuple|default=(<nipype.interfaces.base.traits_extension.File object at 0x10af7cbd0>, <traits.trait_types.Float object at 0x10af7c890>): Similar to '-wball', but here, you provide a dataset 'ws' that indicates where to increase the weight.  * The 'ws' dataset must be on the same 3D grid as the base dataset. * 'ws' is treated as a mask -- it only matters where it   is nonzero -- otherwise, the values inside are not used. * After 'ws' comes the factor 'f' by which to increase the   automatically computed weight.  Where 'ws' is nonzero,   the weighting will be multiplied by (1+f). * As with '-wball', the factor 'f' should be between 1 and 100.  
     out_weight_file:
     # type=file|default=<undefined>: Write the weight volume to disk as a dataset
     blur:
diff --git a/example-specs/task/nipype/afni/qwarp_plus_minus.yaml b/example-specs/task/nipype/afni/qwarp_plus_minus.yaml
index bdce11bf..f4a6b24a 100644
--- a/example-specs/task/nipype/afni/qwarp_plus_minus.yaml
+++ b/example-specs/task/nipype/afni/qwarp_plus_minus.yaml
@@ -126,7 +126,7 @@ tests:
     wball:
     # type=list|default=[]: "``-wball x y z r f`` Enhance automatic weight from '-useweight' by a factor of 1+f\*Gaussian(FWHM=r) centered in the base image at DICOM coordinates (x,y,z) and with radius 'r'. The goal of this option is to try and make the alignment better in a specific part of the brain. Example:  -wball 0 14 6 30 40 to emphasize the thalamic area (in MNI/Talairach space).  * The 'r' parameter must be positive! * The 'f' parameter must be between 1 and 100 (inclusive). * '-wball' does nothing if you input your own weight   with the '-weight' option. * '-wball' does change the binary weight created by   the '-noweight' option. * You can only use '-wball' once in a run of 3dQwarp.  **The effect of '-wball' is not dramatic.** The example above makes the average brain image across a collection of subjects a little sharper in the thalamic area, which might have some small value.  If you care enough about alignment to use '-wball', then you should examine the results from 3dQwarp for each subject, to see if the alignments are good enough for your purposes.
     wmask:
-    # type=tuple|default=(<nipype.interfaces.base.traits_extension.File object at 0x10ff13890>, <traits.trait_types.Float object at 0x10ff13910>): Similar to '-wball', but here, you provide a dataset 'ws' that indicates where to increase the weight.  * The 'ws' dataset must be on the same 3D grid as the base dataset. * 'ws' is treated as a mask -- it only matters where it   is nonzero -- otherwise, the values inside are not used. * After 'ws' comes the factor 'f' by which to increase the   automatically computed weight.  Where 'ws' is nonzero,   the weighting will be multiplied by (1+f). * As with '-wball', the factor 'f' should be between 1 and 100.  
+    # type=tuple|default=(<nipype.interfaces.base.traits_extension.File object at 0x10af7cbd0>, <traits.trait_types.Float object at 0x10af7c890>): Similar to '-wball', but here, you provide a dataset 'ws' that indicates where to increase the weight.  * The 'ws' dataset must be on the same 3D grid as the base dataset. * 'ws' is treated as a mask -- it only matters where it   is nonzero -- otherwise, the values inside are not used. * After 'ws' comes the factor 'f' by which to increase the   automatically computed weight.  Where 'ws' is nonzero,   the weighting will be multiplied by (1+f). * As with '-wball', the factor 'f' should be between 1 and 100.  
     out_weight_file:
     # type=file|default=<undefined>: Write the weight volume to disk as a dataset
     blur:
diff --git a/example-specs/task/nipype/afni/t_corr_map.yaml b/example-specs/task/nipype/afni/t_corr_map.yaml
index 8745dc45..3a4988a3 100644
--- a/example-specs/task/nipype/afni/t_corr_map.yaml
+++ b/example-specs/task/nipype/afni/t_corr_map.yaml
@@ -161,7 +161,7 @@ tests:
     polort:
     # type=int|default=0: 
     bandpass:
-    # type=tuple|default=(<traits.trait_types.Float object at 0x10fefcb90>, <traits.trait_types.Float object at 0x10fefcc50>): 
+    # type=tuple|default=(<traits.trait_types.Float object at 0x10af6e590>, <traits.trait_types.Float object at 0x10af6e650>): 
     regress_out_timeseries:
     # type=file|default=<undefined>: 
     blur_fwhm:
diff --git a/example-specs/task/nipype/ants/atropos_callables.py b/example-specs/task/nipype/ants/atropos_callables.py
index d0d4d45c..f8a0d92b 100644
--- a/example-specs/task/nipype/ants/atropos_callables.py
+++ b/example-specs/task/nipype/ants/atropos_callables.py
@@ -1,26 +1,19 @@
 """Module to put any functions that are referred to in the "callables" section of Atropos.yaml"""
 
 import attrs
+import os
 import os.path as op
 
 
-def out_classified_image_name_callable(output_dir, inputs, stdout, stderr):
-    return _gen_filename(
-        "out_classified_image_name",
-        output_dir=output_dir,
-        inputs=inputs,
-        stdout=stdout,
-        stderr=stderr,
-    )
+def out_classified_image_name_default(inputs):
+    return _gen_filename("out_classified_image_name", inputs=inputs)
 
 
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "out_classified_image_name":
-        output = inputs.out_classified_image_name
-        if output is attrs.NOTHING:
-            _, name, ext = split_filename(inputs.intensity_images[0])
-            output = name + "_labeled" + ext
-        return output
+def out_classified_image_name_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_classified_image_name"]
 
 
 def split_filename(fname):
@@ -71,3 +64,32 @@ def split_filename(fname):
         fname, ext = op.splitext(fname)
 
     return pth, fname, ext
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["classified_image"] = os.path.abspath(
+        _gen_filename(
+            "out_classified_image_name",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    )
+    if inputs.save_posteriors is not attrs.NOTHING and inputs.save_posteriors:
+        outputs["posteriors"] = []
+        for i in range(inputs.number_of_tissue_classes):
+            outputs["posteriors"].append(
+                os.path.abspath(inputs.output_posteriors_name_template % (i + 1))
+            )
+    return outputs
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_classified_image_name":
+        output = inputs.out_classified_image_name
+        if output is attrs.NOTHING:
+            _, name, ext = split_filename(inputs.intensity_images[0])
+            output = name + "_labeled" + ext
+        return output
diff --git a/example-specs/task/nipype/freesurfer/fit_ms_params_callables.py b/example-specs/task/nipype/freesurfer/fit_ms_params_callables.py
index 1387479e..d150f96d 100644
--- a/example-specs/task/nipype/freesurfer/fit_ms_params_callables.py
+++ b/example-specs/task/nipype/freesurfer/fit_ms_params_callables.py
@@ -1,13 +1,39 @@
 """Module to put any functions that are referred to in the "callables" section of FitMSParams.yaml"""
 
+import attrs
+import os
+
+
+def out_dir_default(inputs):
+    return _gen_filename("out_dir", inputs=inputs)
+
 
 def out_dir_callable(output_dir, inputs, stdout, stderr):
-    return _gen_filename(
-        "out_dir", output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
+    return outputs["out_dir"]
 
 
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "out_dir":
         return output_dir
     return None
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    if inputs.out_dir is attrs.NOTHING:
+        out_dir = _gen_filename(
+            "out_dir",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    else:
+        out_dir = inputs.out_dir
+    outputs["t1_image"] = os.path.join(out_dir, "T1.mgz")
+    outputs["pd_image"] = os.path.join(out_dir, "PD.mgz")
+    outputs["t2star_image"] = os.path.join(out_dir, "T2star.mgz")
+    return outputs
diff --git a/example-specs/task/nipype/freesurfer/mr_is_convert_callables.py b/example-specs/task/nipype/freesurfer/mr_is_convert_callables.py
index 747f6050..b23a1f21 100644
--- a/example-specs/task/nipype/freesurfer/mr_is_convert_callables.py
+++ b/example-specs/task/nipype/freesurfer/mr_is_convert_callables.py
@@ -1,44 +1,19 @@
 """Module to put any functions that are referred to in the "callables" section of MRIsConvert.yaml"""
 
 import attrs
-import os.path as op
 import os
+import os.path as op
 
 
-def out_file_callable(output_dir, inputs, stdout, stderr):
-    return _gen_filename(
-        "out_file", output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
-    )
-
+def out_file_default(inputs):
+    return _gen_filename("out_file", inputs=inputs)
 
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "out_file":
-        return os.path.abspath(
-            _gen_outfilename(
-                inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-            )
-        )
-    else:
-        return None
-
-
-def _gen_outfilename(inputs=None, stdout=None, stderr=None, output_dir=None):
-    if inputs.out_file is not attrs.NOTHING:
-        return inputs.out_file
-    elif inputs.annot_file is not attrs.NOTHING:
-        _, name, ext = split_filename(inputs.annot_file)
-    elif inputs.parcstats_file is not attrs.NOTHING:
-        _, name, ext = split_filename(inputs.parcstats_file)
-    elif inputs.label_file is not attrs.NOTHING:
-        _, name, ext = split_filename(inputs.label_file)
-    elif inputs.scalarcurv_file is not attrs.NOTHING:
-        _, name, ext = split_filename(inputs.scalarcurv_file)
-    elif inputs.functional_file is not attrs.NOTHING:
-        _, name, ext = split_filename(inputs.functional_file)
-    elif inputs.in_file is not attrs.NOTHING:
-        _, name, ext = split_filename(inputs.in_file)
 
-    return name + ext + "_converted." + inputs.out_datatype
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
 
 
 def split_filename(fname):
@@ -89,3 +64,43 @@ def split_filename(fname):
         fname, ext = op.splitext(fname)
 
     return pth, fname, ext
+
+
+def _gen_outfilename(inputs=None, stdout=None, stderr=None, output_dir=None):
+    if inputs.out_file is not attrs.NOTHING:
+        return inputs.out_file
+    elif inputs.annot_file is not attrs.NOTHING:
+        _, name, ext = split_filename(inputs.annot_file)
+    elif inputs.parcstats_file is not attrs.NOTHING:
+        _, name, ext = split_filename(inputs.parcstats_file)
+    elif inputs.label_file is not attrs.NOTHING:
+        _, name, ext = split_filename(inputs.label_file)
+    elif inputs.scalarcurv_file is not attrs.NOTHING:
+        _, name, ext = split_filename(inputs.scalarcurv_file)
+    elif inputs.functional_file is not attrs.NOTHING:
+        _, name, ext = split_filename(inputs.functional_file)
+    elif inputs.in_file is not attrs.NOTHING:
+        _, name, ext = split_filename(inputs.in_file)
+
+    return name + ext + "_converted." + inputs.out_datatype
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return os.path.abspath(
+            _gen_outfilename(
+                inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+        )
+    else:
+        return None
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["converted"] = os.path.abspath(
+        _gen_outfilename(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )
+    )
+    return outputs
diff --git a/example-specs/task/nipype/freesurfer/mri_convert_callables.py b/example-specs/task/nipype/freesurfer/mri_convert_callables.py
index e5e88940..9b81ca1e 100644
--- a/example-specs/task/nipype/freesurfer/mri_convert_callables.py
+++ b/example-specs/task/nipype/freesurfer/mri_convert_callables.py
@@ -1,36 +1,63 @@
 """Module to put any functions that are referred to in the "callables" section of MRIConvert.yaml"""
 
-from pathlib import Path
 import attrs
-import os.path as op
 import os
+from nibabel import load
+import os.path as op
+from pathlib import Path
+
+
+def out_file_default(inputs):
+    return _gen_filename("out_file", inputs=inputs)
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
-    return _gen_filename(
-        "out_file", output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
+    return outputs["out_file"]
 
 
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "out_file":
-        return _get_outfilename(
-            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-        )
-    return None
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
 
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
 
-def _get_outfilename(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outfile = inputs.out_file
-    if outfile is attrs.NOTHING:
-        if inputs.out_type is not attrs.NOTHING:
-            suffix = "_out." + filemap[inputs.out_type]
-        else:
-            suffix = "_out.nii.gz"
-        outfile = fname_presuffix(
-            inputs.in_file, newpath=output_dir, suffix=suffix, use_ext=False
-        )
-    return os.path.abspath(outfile)
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import Undefined
+    >>> fname_presuffix(fname, 'pre', 'post', Undefined) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for isdefined: bool(Undefined) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
 
 
 def split_filename(fname):
@@ -83,43 +110,68 @@ def split_filename(fname):
     return pth, fname, ext
 
 
-def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
-    """Manipulates path and name of input filename
-
-    Parameters
-    ----------
-    fname : string
-        A filename (may or may not include path)
-    prefix : string
-        Characters to prepend to the filename
-    suffix : string
-        Characters to append to the filename
-    newpath : string
-        Path to replace the path of the input fname
-    use_ext : boolean
-        If True (default), appends the extension of the original file
-        to the output name.
-
-    Returns
-    -------
-    Absolute path of the modified filename
+def _get_outfilename(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outfile = inputs.out_file
+    if outfile is attrs.NOTHING:
+        if inputs.out_type is not attrs.NOTHING:
+            suffix = "_out." + filemap[inputs.out_type]
+        else:
+            suffix = "_out.nii.gz"
+        outfile = fname_presuffix(
+            inputs.in_file, newpath=output_dir, suffix=suffix, use_ext=False
+        )
+    return os.path.abspath(outfile)
 
-    >>> from nipype.utils.filemanip import fname_presuffix
-    >>> fname = 'foo.nii.gz'
-    >>> fname_presuffix(fname,'pre','post','/tmp')
-    '/tmp/prefoopost.nii.gz'
 
-    >>> from nipype.interfaces.base import Undefined
-    >>> fname_presuffix(fname, 'pre', 'post', Undefined) == \
-            fname_presuffix(fname, 'pre', 'post')
-    True
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _get_outfilename(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )
+    return None
 
-    """
-    pth, fname, ext = split_filename(fname)
-    if not use_ext:
-        ext = ""
 
-    # No need for isdefined: bool(Undefined) evaluates to False
-    if newpath:
-        pth = op.abspath(newpath)
-    return op.join(pth, prefix + fname + suffix + ext)
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outfile = _get_outfilename(
+        inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+    )
+    if inputs.split is not attrs.NOTHING and inputs.split:
+        size = load(inputs.in_file).shape
+        if len(size) == 3:
+            tp = 1
+        else:
+            tp = size[-1]
+        if outfile.endswith(".mgz"):
+            stem = outfile.split(".mgz")[0]
+            ext = ".mgz"
+        elif outfile.endswith(".nii.gz"):
+            stem = outfile.split(".nii.gz")[0]
+            ext = ".nii.gz"
+        else:
+            stem = ".".join(outfile.split(".")[:-1])
+            ext = "." + outfile.split(".")[-1]
+        outfile = []
+        for idx in range(0, tp):
+            outfile.append(stem + "%04d" % idx + ext)
+    if inputs.out_type is not attrs.NOTHING:
+        if inputs.out_type in ["spm", "analyze"]:
+            # generate all outputs
+            size = load(inputs.in_file).shape
+            if len(size) == 3:
+                tp = 1
+            else:
+                tp = size[-1]
+                # have to take care of all the frame manipulations
+                raise Exception(
+                    "Not taking frame manipulations into account- please warn the developers"
+                )
+            outfiles = []
+            outfile = _get_outfilename(
+                inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            for i in range(tp):
+                outfiles.append(fname_presuffix(outfile, suffix="%03d" % (i + 1)))
+            outfile = outfiles
+    outputs["out_file"] = outfile
+    return outputs
diff --git a/example-specs/task/nipype/freesurfer/mri_marching_cubes_callables.py b/example-specs/task/nipype/freesurfer/mri_marching_cubes_callables.py
index b5677d6a..336c63b9 100644
--- a/example-specs/task/nipype/freesurfer/mri_marching_cubes_callables.py
+++ b/example-specs/task/nipype/freesurfer/mri_marching_cubes_callables.py
@@ -1,31 +1,19 @@
 """Module to put any functions that are referred to in the "callables" section of MRIMarchingCubes.yaml"""
 
 import attrs
-import os.path as op
 import os
+import os.path as op
 
 
-def out_file_callable(output_dir, inputs, stdout, stderr):
-    return _gen_filename(
-        "out_file", output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
-    )
+def out_file_default(inputs):
+    return _gen_filename("out_file", inputs=inputs)
 
 
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "out_file":
-        return _gen_outfilename(
-            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-        )
-    else:
-        return None
-
-
-def _gen_outfilename(inputs=None, stdout=None, stderr=None, output_dir=None):
-    if inputs.out_file is not attrs.NOTHING:
-        return os.path.abspath(inputs.out_file)
-    else:
-        _, name, ext = split_filename(inputs.in_file)
-        return os.path.abspath(name + ext + "_" + str(inputs.label_value))
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
 
 
 def split_filename(fname):
@@ -76,3 +64,28 @@ def split_filename(fname):
         fname, ext = op.splitext(fname)
 
     return pth, fname, ext
+
+
+def _gen_outfilename(inputs=None, stdout=None, stderr=None, output_dir=None):
+    if inputs.out_file is not attrs.NOTHING:
+        return os.path.abspath(inputs.out_file)
+    else:
+        _, name, ext = split_filename(inputs.in_file)
+        return os.path.abspath(name + ext + "_" + str(inputs.label_value))
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _gen_outfilename(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )
+    else:
+        return None
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["surface"] = _gen_outfilename(
+        inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+    )
+    return outputs
diff --git a/example-specs/task/nipype/freesurfer/mri_tessellate_callables.py b/example-specs/task/nipype/freesurfer/mri_tessellate_callables.py
index 6a660f7e..de06ab0a 100644
--- a/example-specs/task/nipype/freesurfer/mri_tessellate_callables.py
+++ b/example-specs/task/nipype/freesurfer/mri_tessellate_callables.py
@@ -1,30 +1,19 @@
 """Module to put any functions that are referred to in the "callables" section of MRITessellate.yaml"""
 
 import attrs
+import os
 import os.path as op
 
 
-def out_file_callable(output_dir, inputs, stdout, stderr):
-    return _gen_filename(
-        "out_file", output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
-    )
-
-
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "out_file":
-        return _gen_outfilename(
-            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-        )
-    else:
-        return None
+def out_file_default(inputs):
+    return _gen_filename("out_file", inputs=inputs)
 
 
-def _gen_outfilename(inputs=None, stdout=None, stderr=None, output_dir=None):
-    if inputs.out_file is not attrs.NOTHING:
-        return inputs.out_file
-    else:
-        _, name, ext = split_filename(inputs.in_file)
-        return name + ext + "_" + str(inputs.label_value)
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
 
 
 def split_filename(fname):
@@ -75,3 +64,30 @@ def split_filename(fname):
         fname, ext = op.splitext(fname)
 
     return pth, fname, ext
+
+
+def _gen_outfilename(inputs=None, stdout=None, stderr=None, output_dir=None):
+    if inputs.out_file is not attrs.NOTHING:
+        return inputs.out_file
+    else:
+        _, name, ext = split_filename(inputs.in_file)
+        return name + ext + "_" + str(inputs.label_value)
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _gen_outfilename(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )
+    else:
+        return None
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["surface"] = os.path.abspath(
+        _gen_outfilename(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )
+    )
+    return outputs
diff --git a/example-specs/task/nipype/freesurfer/smooth_tessellation_callables.py b/example-specs/task/nipype/freesurfer/smooth_tessellation_callables.py
index 3ecc8bfe..739dd25b 100644
--- a/example-specs/task/nipype/freesurfer/smooth_tessellation_callables.py
+++ b/example-specs/task/nipype/freesurfer/smooth_tessellation_callables.py
@@ -1,31 +1,19 @@
 """Module to put any functions that are referred to in the "callables" section of SmoothTessellation.yaml"""
 
 import attrs
-import os.path as op
 import os
+import os.path as op
 
 
-def out_file_callable(output_dir, inputs, stdout, stderr):
-    return _gen_filename(
-        "out_file", output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
-    )
+def out_file_default(inputs):
+    return _gen_filename("out_file", inputs=inputs)
 
 
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "out_file":
-        return _gen_outfilename(
-            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-        )
-    else:
-        return None
-
-
-def _gen_outfilename(inputs=None, stdout=None, stderr=None, output_dir=None):
-    if inputs.out_file is not attrs.NOTHING:
-        return os.path.abspath(inputs.out_file)
-    else:
-        _, name, ext = split_filename(inputs.in_file)
-        return os.path.abspath(name + "_smoothed" + ext)
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
 
 
 def split_filename(fname):
@@ -76,3 +64,28 @@ def split_filename(fname):
         fname, ext = op.splitext(fname)
 
     return pth, fname, ext
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _gen_outfilename(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )
+    else:
+        return None
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["surface"] = _gen_outfilename(
+        inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+    )
+    return outputs
+
+
+def _gen_outfilename(inputs=None, stdout=None, stderr=None, output_dir=None):
+    if inputs.out_file is not attrs.NOTHING:
+        return os.path.abspath(inputs.out_file)
+    else:
+        _, name, ext = split_filename(inputs.in_file)
+        return os.path.abspath(name + "_smoothed" + ext)
diff --git a/example-specs/task/nipype/freesurfer/spherical_average_callables.py b/example-specs/task/nipype/freesurfer/spherical_average_callables.py
index 5cffc775..2eeafdc4 100644
--- a/example-specs/task/nipype/freesurfer/spherical_average_callables.py
+++ b/example-specs/task/nipype/freesurfer/spherical_average_callables.py
@@ -1,14 +1,22 @@
 """Module to put any functions that are referred to in the "callables" section of SphericalAverage.yaml"""
 
 import attrs
-from fileformats.generic import File
 import os
 
 
+def out_file_default(inputs):
+    return _gen_filename("out_file", inputs=inputs)
+
+
+def in_average_default(inputs):
+    return _gen_filename("in_average", inputs=inputs)
+
+
 def in_average_callable(output_dir, inputs, stdout, stderr):
-    return _gen_filename(
-        "in_average", output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
+    return outputs["in_average"]
 
 
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
@@ -26,27 +34,8 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
         return None
 
 
-def _outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    """Returns a bunch containing output fields for the class"""
-    outputs = None
-    if output_spec:
-        outputs = output_spec(
-            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-        )
-
-    return outputs
-
-
-class SphericalAverageOutputSpec(
-    inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    out_file = File(exists=False, desc="Output label")
-
-
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = _outputs(
-        inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-    ).get()
+    outputs = {}
     if inputs.out_file is not attrs.NOTHING:
         outputs["out_file"] = os.path.abspath(inputs.out_file)
     else:
diff --git a/example-specs/task/nipype/freesurfer/surface_snapshots_callables.py b/example-specs/task/nipype/freesurfer/surface_snapshots_callables.py
index d331f34b..848d740c 100644
--- a/example-specs/task/nipype/freesurfer/surface_snapshots_callables.py
+++ b/example-specs/task/nipype/freesurfer/surface_snapshots_callables.py
@@ -1,13 +1,182 @@
 """Module to put any functions that are referred to in the "callables" section of SurfaceSnapshots.yaml"""
 
+import attrs
+import os.path as op
+from pathlib import Path
+
+
+def tcl_script_default(inputs):
+    return _gen_filename("tcl_script", inputs=inputs)
+
 
 def tcl_script_callable(output_dir, inputs, stdout, stderr):
-    return _gen_filename(
-        "tcl_script", output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
+    return outputs["tcl_script"]
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import Undefined
+    >>> fname_presuffix(fname, 'pre', 'post', Undefined) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for isdefined: bool(Undefined) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _gen_fname(
+    basename,
+    fname=None,
+    cwd=None,
+    suffix="_fs",
+    use_ext=True,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Define a generic mapping for a single outfile
+
+    The filename is potentially autogenerated by suffixing inputs.infile
+
+    Parameters
+    ----------
+    basename : string (required)
+        filename to base the new filename on
+    fname : string
+        if not None, just use this fname
+    cwd : string
+        prefix paths with cwd, otherwise output_dir
+    suffix : string
+        default suffix
+    """
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "tksurfer"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=use_ext, newpath=cwd)
+    return fname
 
 
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "tcl_script":
         return "snapshots.tcl"
     return None
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    if inputs.screenshot_stem is attrs.NOTHING:
+        stem = "%s_%s_%s" % (
+            inputs.subject_id,
+            inputs.hemi,
+            inputs.surface,
+        )
+    else:
+        stem = inputs.screenshot_stem
+        stem_args = inputs.stem_template_args
+        if stem_args is not attrs.NOTHING:
+            args = tuple([getattr(inputs, arg) for arg in stem_args])
+            stem = stem % args
+    snapshots = ["%s-lat.tif", "%s-med.tif", "%s-dor.tif", "%s-ven.tif"]
+    if inputs.six_images:
+        snapshots.extend(["%s-pos.tif", "%s-ant.tif"])
+    snapshots = [
+        _gen_fname(
+            f % stem,
+            suffix="",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+        for f in snapshots
+    ]
+    outputs["snapshots"] = snapshots
+    return outputs
diff --git a/example-specs/task/nipype/fsl/epi_de_warp_callables.py b/example-specs/task/nipype/fsl/epi_de_warp_callables.py
index 48652261..41d6b2b8 100644
--- a/example-specs/task/nipype/fsl/epi_de_warp_callables.py
+++ b/example-specs/task/nipype/fsl/epi_de_warp_callables.py
@@ -1,21 +1,92 @@
 """Module to put any functions that are referred to in the "callables" section of EPIDeWarp.yaml"""
 
-from pathlib import Path
+from glob import glob
 import attrs
-import os.path as op
 import os
+import os.path as op
+from pathlib import Path
+import logging
+
+
+def vsm_default(inputs):
+    return _gen_filename("vsm", inputs=inputs)
+
+
+def exfdw_default(inputs):
+    return _gen_filename("exfdw", inputs=inputs)
+
+
+def tmpdir_default(inputs):
+    return _gen_filename("tmpdir", inputs=inputs)
 
 
 def vsm_callable(output_dir, inputs, stdout, stderr):
-    return _gen_filename(
-        "vsm", output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
+    return outputs["vsm"]
 
 
 def tmpdir_callable(output_dir, inputs, stdout, stderr):
-    return _gen_filename(
-        "tmpdir", output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
+    return outputs["tmpdir"]
+
+
+IFLOGGER = logging.getLogger("nipype.interface")
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    if inputs.exfdw is attrs.NOTHING:
+        outputs["exfdw"] = _gen_filename(
+            "exfdw", inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )
+    else:
+        outputs["exfdw"] = inputs.exfdw
+    if inputs.epi_file is not attrs.NOTHING:
+        if inputs.epidw is not attrs.NOTHING:
+            outputs["unwarped_file"] = inputs.epidw
+        else:
+            outputs["unwarped_file"] = _gen_filename(
+                "epidw",
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    if inputs.vsm is attrs.NOTHING:
+        outputs["vsm_file"] = _gen_filename(
+            "vsm", inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )
+    else:
+        outputs["vsm_file"] = _gen_fname(
+            inputs.vsm,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    if inputs.tmpdir is attrs.NOTHING:
+        outputs["exf_mask"] = _gen_fname(
+            cwd=_gen_filename("tmpdir"),
+            basename="maskexf",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    else:
+        outputs["exf_mask"] = _gen_fname(
+            cwd=inputs.tmpdir,
+            basename="maskexf",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    return outputs
 
 
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
@@ -56,59 +127,83 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     return None
 
 
-def _gen_fname(
-    basename,
-    cwd=None,
-    suffix=None,
-    change_ext=True,
-    ext=None,
-    inputs=None,
-    stdout=None,
-    stderr=None,
-    output_dir=None,
-):
-    """Generate a filename based on the given parameters.
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
 
-    The filename will take the form: cwd/basename<suffix><ext>.
-    If change_ext is True, it will use the extensions specified in
-    <instance>inputs.output_type.
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
 
     Parameters
     ----------
-    basename : str
-        Filename to base the new filename on.
-    cwd : str
-        Path to prefix to the new filename. (default is output_dir)
-    suffix : str
-        Suffix to add to the `basename`.  (defaults is '' )
-    change_ext : bool
-        Flag to change the filename extension to the FSL output type.
-        (default True)
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
 
     Returns
     -------
-    fname : str
-        New filename based on given parameters.
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import Undefined
+    >>> fname_presuffix(fname, 'pre', 'post', Undefined) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
 
     """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
 
-    if basename == "":
-        msg = "Unable to generate filename for command %s. " % "epidewarp.fsl"
-        msg += "basename is not set!"
-        raise ValueError(msg)
-    if cwd is None:
-        cwd = output_dir
-    if ext is None:
-        ext = Info.output_type_to_ext(inputs.output_type)
-    if change_ext:
-        if suffix:
-            suffix = "".join((suffix, ext))
-        else:
-            suffix = ext
-    if suffix is None:
-        suffix = ""
-    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
-    return fname
+    # No need for isdefined: bool(Undefined) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
 
 
 def split_filename(fname):
@@ -161,43 +256,148 @@ def split_filename(fname):
     return pth, fname, ext
 
 
-def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
-    """Manipulates path and name of input filename
+class Info(PackageInfo):
+    """
+    Handle FSL ``output_type`` and version information.
+
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
+
+    """
+
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
+
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
+
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
+
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
+
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
+
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
+
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
+
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
+
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
+
+        Returns a list of standard images if called without arguments.
+
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
+
+
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
+
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
 
     Parameters
     ----------
-    fname : string
-        A filename (may or may not include path)
-    prefix : string
-        Characters to prepend to the filename
-    suffix : string
-        Characters to append to the filename
-    newpath : string
-        Path to replace the path of the input fname
-    use_ext : boolean
-        If True (default), appends the extension of the original file
-        to the output name.
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
 
     Returns
     -------
-    Absolute path of the modified filename
-
-    >>> from nipype.utils.filemanip import fname_presuffix
-    >>> fname = 'foo.nii.gz'
-    >>> fname_presuffix(fname,'pre','post','/tmp')
-    '/tmp/prefoopost.nii.gz'
-
-    >>> from nipype.interfaces.base import Undefined
-    >>> fname_presuffix(fname, 'pre', 'post', Undefined) == \
-            fname_presuffix(fname, 'pre', 'post')
-    True
+    fname : str
+        New filename based on given parameters.
 
     """
-    pth, fname, ext = split_filename(fname)
-    if not use_ext:
-        ext = ""
 
-    # No need for isdefined: bool(Undefined) evaluates to False
-    if newpath:
-        pth = op.abspath(newpath)
-    return op.join(pth, prefix + fname + suffix + ext)
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "epidewarp.fsl"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
diff --git a/example-specs/task/nipype/fsl/prob_track_x2_callables.py b/example-specs/task/nipype/fsl/prob_track_x2_callables.py
index 13bf6955..23601cb9 100644
--- a/example-specs/task/nipype/fsl/prob_track_x2_callables.py
+++ b/example-specs/task/nipype/fsl/prob_track_x2_callables.py
@@ -1,10 +1,1141 @@
 """Module to put any functions that are referred to in the "callables" section of ProbTrackX2.yaml"""
 
+import warnings
+import re
+from hashlib import md5
+import shutil
+import os
+from pathlib import Path
+from fileformats.generic import File, Directory
+from glob import glob
+import os.path as op
+import logging
+import hashlib
+import attrs
+import subprocess as sp
+import simplejson as json
+from fileformats.generic import File
+import posixpath
+
+
+def out_dir_default(inputs):
+    return _gen_filename("out_dir", inputs=inputs)
+
 
 def out_dir_callable(output_dir, inputs, stdout, stderr):
-    return _gen_filename(
-        "out_dir", output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_dir"]
+
+
+related_filetype_sets = [(".hdr", ".img", ".mat"), (".nii", ".mat"), (".BRIK", ".HEAD")]
+
+
+_cifs_table = _generate_cifs_table()
+
+
+fmlogger = logging.getLogger("nipype.utils")
+
+
+IFLOGGER = logging.getLogger("nipype.interface")
+
+
+class FSLCommandInputSpec(CommandLineInputSpec):
+    """
+    Base Input Specification for all FSL Commands
+
+    All command support specifying FSLOUTPUTTYPE dynamically
+    via output_type.
+
+    Example
+    -------
+    fsl.ExtractRoi(tmin=42, tsize=1, output_type='NIFTI')
+    """
+
+    output_type = traits.Enum("NIFTI", list(Info.ftypes.keys()), desc="FSL output type")
+
+
+class FSLCommand(CommandLine):
+    """Base support for FSL commands."""
+
+    input_spec = FSLCommandInputSpec
+    _output_type = None
+
+    _references = [
+        {
+            "entry": BibTeX(
+                "@article{JenkinsonBeckmannBehrensWoolrichSmith2012,"
+                "author={M. Jenkinson, C.F. Beckmann, T.E. Behrens, "
+                "M.W. Woolrich, and S.M. Smith},"
+                "title={FSL},"
+                "journal={NeuroImage},"
+                "volume={62},"
+                "pages={782-790},"
+                "year={2012},"
+                "}"
+            ),
+            "tags": ["implementation"],
+        }
+    ]
+
+    def __init__(self, **inputs):
+        super(FSLCommand, self).__init__(**inputs)
+        self.inputs.on_trait_change(self._output_update, "output_type")
+
+        if self._output_type is None:
+            self._output_type = Info.output_type()
+
+        if self.inputs.output_type is attrs.NOTHING:
+            self.inputs.output_type = self._output_type
+        else:
+            self._output_update()
+
+    def _output_update(self):
+        self._output_type = self.inputs.output_type
+        self.inputs.environ.update({"FSLOUTPUTTYPE": self.inputs.output_type})
+
+    @classmethod
+    def set_default_output_type(cls, output_type):
+        """Set the default output type for FSL classes.
+
+        This method is used to set the default output type for all fSL
+        subclasses.  However, setting this will not update the output
+        type for any existing instances.  For these, assign the
+        <instance>.inputs.output_type.
+        """
+
+        if output_type in Info.ftypes:
+            cls._output_type = output_type
+        else:
+            raise AttributeError("Invalid FSL output_type: %s" % output_type)
+
+    @property
+    def version(self):
+        return Info.version()
+
+    def _gen_fname(self, basename, cwd=None, suffix=None, change_ext=True, ext=None):
+        """Generate a filename based on the given parameters.
+
+        The filename will take the form: cwd/basename<suffix><ext>.
+        If change_ext is True, it will use the extensions specified in
+        <instance>inputs.output_type.
+
+        Parameters
+        ----------
+        basename : str
+            Filename to base the new filename on.
+        cwd : str
+            Path to prefix to the new filename. (default is os.getcwd())
+        suffix : str
+            Suffix to add to the `basename`.  (defaults is '' )
+        change_ext : bool
+            Flag to change the filename extension to the FSL output type.
+            (default True)
+
+        Returns
+        -------
+        fname : str
+            New filename based on given parameters.
+
+        """
+
+        if basename == "":
+            msg = "Unable to generate filename for command %s. " % self.cmd
+            msg += "basename is not set!"
+            raise ValueError(msg)
+        if cwd is None:
+            cwd = os.getcwd()
+        if ext is None:
+            ext = Info.output_type_to_ext(self.inputs.output_type)
+        if change_ext:
+            if suffix:
+                suffix = "".join((suffix, ext))
+            else:
+                suffix = ext
+        if suffix is None:
+            suffix = ""
+        fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+        return fname
+
+    def _overload_extension(self, value, name=None):
+        return value + Info.output_type_to_ext(self.inputs.output_type)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def on_cifs(fname):
+    """
+    Checks whether a file path is on a CIFS filesystem mounted in a POSIX
+    host (i.e., has the ``mount`` command).
+
+    On Windows, Docker mounts host directories into containers through CIFS
+    shares, which has support for Minshall+French symlinks, or text files that
+    the CIFS driver exposes to the OS as symlinks.
+    We have found that under concurrent access to the filesystem, this feature
+    can result in failures to create or read recently-created symlinks,
+    leading to inconsistent behavior and ``FileNotFoundError``.
+
+    This check is written to support disabling symlinks on CIFS shares.
+
+    """
+    # Only the first match (most recent parent) counts
+    for fspath, fstype in _cifs_table:
+        if fname.startswith(fspath):
+            return fstype == "cifs"
+    return False
+
+
+def BibTeX(*args, **kwargs):
+    """Perform no good and no bad"""
+    pass
+
+
+def _donothing_func(*args, **kwargs):
+    """Perform no good and no bad"""
+    pass
+
+
+def which(cmd, env=None, pathext=None):
+    """
+    Return the path to an executable which would be run if the given
+    cmd was called. If no cmd would be called, return ``None``.
+
+    Code for Python < 3.3 is based on a code snippet from
+    http://orip.org/2009/08/python-checking-if-executable-exists-in.html
+
+    """
+
+    if pathext is None:
+        pathext = os.getenv("PATHEXT", "").split(os.pathsep)
+        pathext.insert(0, "")
+
+    path = os.getenv("PATH", os.defpath)
+    if env and "PATH" in env:
+        path = env.get("PATH")
+
+    for ext in pathext:
+        filename = shutil.which(cmd + ext, path=path)
+        if filename:
+            return filename
+    return None
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import Undefined
+    >>> fname_presuffix(fname, 'pre', 'post', Undefined) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for isdefined: bool(Undefined) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def copyfile(
+    originalfile,
+    newfile,
+    copy=False,
+    create_new=False,
+    hashmethod=None,
+    use_hardlink=False,
+    copy_related_files=True,
+):
+    """Copy or link ``originalfile`` to ``newfile``.
+
+    If ``use_hardlink`` is True, and the file can be hard-linked, then a
+    link is created, instead of copying the file.
+
+    If a hard link is not created and ``copy`` is False, then a symbolic
+    link is created.
+
+    Parameters
+    ----------
+    originalfile : str
+        full path to original file
+    newfile : str
+        full path to new file
+    copy : Bool
+        specifies whether to copy or symlink files
+        (default=False) but only for POSIX systems
+    use_hardlink : Bool
+        specifies whether to hard-link files, when able
+        (Default=False), taking precedence over copy
+    copy_related_files : Bool
+        specifies whether to also operate on related files, as defined in
+        ``related_filetype_sets``
+
+    Returns
+    -------
+    None
+
+    """
+    newhash = None
+    orighash = None
+    fmlogger.debug(newfile)
+
+    if create_new:
+        while op.exists(newfile):
+            base, fname, ext = split_filename(newfile)
+            s = re.search("_c[0-9]{4,4}$", fname)
+            i = 0
+            if s:
+                i = int(s.group()[2:]) + 1
+                fname = fname[:-6] + "_c%04d" % i
+            else:
+                fname += "_c%04d" % i
+            newfile = base + os.sep + fname + ext
+
+    if hashmethod is None:
+        hashmethod = config.get("execution", "hash_method").lower()
+
+    # Don't try creating symlinks on CIFS
+    if copy is False and on_cifs(newfile):
+        copy = True
+
+    # Existing file
+    # -------------
+    # Options:
+    #   symlink
+    #       to regular file originalfile            (keep if symlinking)
+    #       to same dest as symlink originalfile    (keep if symlinking)
+    #       to other file                           (unlink)
+    #   regular file
+    #       hard link to originalfile               (keep)
+    #       copy of file (same hash)                (keep)
+    #       different file (diff hash)              (unlink)
+    keep = False
+    if op.lexists(newfile):
+        if op.islink(newfile):
+            if all(
+                (
+                    os.readlink(newfile) == op.realpath(originalfile),
+                    not use_hardlink,
+                    not copy,
+                )
+            ):
+                keep = True
+        elif posixpath.samefile(newfile, originalfile):
+            keep = True
+        else:
+            if hashmethod == "timestamp":
+                hashfn = hash_timestamp
+            elif hashmethod == "content":
+                hashfn = hash_infile
+            else:
+                raise AttributeError("Unknown hash method found:", hashmethod)
+            newhash = hashfn(newfile)
+            fmlogger.debug(
+                "File: %s already exists,%s, copy:%d", newfile, newhash, copy
+            )
+            orighash = hashfn(originalfile)
+            keep = newhash == orighash
+        if keep:
+            fmlogger.debug(
+                "File: %s already exists, not overwriting, copy:%d", newfile, copy
+            )
+        else:
+            os.unlink(newfile)
+
+    # New file
+    # --------
+    # use_hardlink & can_hardlink => hardlink
+    # ~hardlink & ~copy & can_symlink => symlink
+    # ~hardlink & ~symlink => copy
+    if not keep and use_hardlink:
+        try:
+            fmlogger.debug("Linking File: %s->%s", newfile, originalfile)
+            # Use realpath to avoid hardlinking symlinks
+            os.link(op.realpath(originalfile), newfile)
+        except OSError:
+            use_hardlink = False  # Disable hardlink for associated files
+        else:
+            keep = True
+
+    if not keep and not copy and os.name == "posix":
+        try:
+            fmlogger.debug("Symlinking File: %s->%s", newfile, originalfile)
+            os.symlink(originalfile, newfile)
+        except OSError:
+            copy = True  # Disable symlink for associated files
+        else:
+            keep = True
+
+    if not keep:
+        try:
+            fmlogger.debug("Copying File: %s->%s", newfile, originalfile)
+            shutil.copyfile(originalfile, newfile)
+        except shutil.Error as e:
+            fmlogger.warning(str(e))
+
+    # Associated files
+    if copy_related_files:
+        related_file_pairs = (
+            get_related_files(f, include_this_file=False)
+            for f in (originalfile, newfile)
+        )
+        for alt_ofile, alt_nfile in zip(*related_file_pairs):
+            if op.exists(alt_ofile):
+                copyfile(
+                    alt_ofile,
+                    alt_nfile,
+                    copy,
+                    hashmethod=hashmethod,
+                    use_hardlink=use_hardlink,
+                    copy_related_files=False,
+                )
+
+    return newfile
+
+
+def _parse_mount_table(exit_code, output):
+    """Parses the output of ``mount`` to produce (path, fs_type) pairs
+
+    Separated from _generate_cifs_table to enable testing logic with real
+    outputs
+    """
+    # Not POSIX
+    if exit_code != 0:
+        return []
+
+    # Linux mount example:  sysfs on /sys type sysfs (rw,nosuid,nodev,noexec)
+    #                          <PATH>^^^^      ^^^^^<FSTYPE>
+    # OSX mount example:    /dev/disk2 on / (hfs, local, journaled)
+    #                               <PATH>^  ^^^<FSTYPE>
+    pattern = re.compile(r".*? on (/.*?) (?:type |\()([^\s,\)]+)")
+
+    # Keep line and match for error reporting (match == None on failure)
+    # Ignore empty lines
+    matches = [(l, pattern.match(l)) for l in output.strip().splitlines() if l]
+
+    # (path, fstype) tuples, sorted by path length (longest first)
+    mount_info = sorted(
+        (match.groups() for _, match in matches if match is not None),
+        key=lambda x: len(x[0]),
+        reverse=True,
     )
+    cifs_paths = [path for path, fstype in mount_info if fstype.lower() == "cifs"]
+
+    # Report failures as warnings
+    for line, match in matches:
+        if match is None:
+            fmlogger.debug("Cannot parse mount line: '%s'", line)
+
+    return [
+        mount
+        for mount in mount_info
+        if any(mount[0].startswith(path) for path in cifs_paths)
+    ]
+
+
+def hash_timestamp(afile):
+    """Computes md5 hash of the timestamp of a file"""
+    md5hex = None
+    if op.isfile(afile):
+        md5obj = md5()
+        stat = os.stat(afile)
+        md5obj.update(str(stat.st_size).encode())
+        md5obj.update(str(stat.st_mtime).encode())
+        md5hex = md5obj.hexdigest()
+    return md5hex
+
+
+def _generate_cifs_table():
+    """Construct a reverse-length-ordered list of mount points that
+    fall under a CIFS mount.
+
+    This precomputation allows efficient checking for whether a given path
+    would be on a CIFS filesystem.
+
+    On systems without a ``mount`` command, or with no CIFS mounts, returns an
+    empty list.
+    """
+    exit_code, output = sp.getstatusoutput("mount")
+    return _parse_mount_table(exit_code, output)
+
+
+def hash_infile(afile, chunk_len=8192, crypto=hashlib.md5, raise_notfound=False):
+    """
+    Computes hash of a file using 'crypto' module
+
+    >>> hash_infile('smri_ants_registration_settings.json')
+    'f225785dfb0db9032aa5a0e4f2c730ad'
+
+    >>> hash_infile('surf01.vtk')
+    'fdf1cf359b4e346034372cdeb58f9a88'
+
+    >>> hash_infile('spminfo')
+    '0dc55e3888c98a182dab179b976dfffc'
+
+    >>> hash_infile('fsl_motion_outliers_fd.txt')
+    'defd1812c22405b1ee4431aac5bbdd73'
+
+
+    """
+    if not op.isfile(afile):
+        if raise_notfound:
+            raise RuntimeError('File "%s" not found.' % afile)
+        return None
+
+    crypto_obj = crypto()
+    with open(afile, "rb") as fp:
+        while True:
+            data = fp.read(chunk_len)
+            if not data:
+                break
+            crypto_obj.update(data)
+    return crypto_obj.hexdigest()
+
+
+def get_related_files(filename, include_this_file=True):
+    """Returns a list of related files, as defined in
+    ``related_filetype_sets``, for a filename. (e.g., Nifti-Pair, Analyze (SPM)
+    and AFNI files).
+
+    Parameters
+    ----------
+    filename : str
+        File name to find related filetypes of.
+    include_this_file : bool
+        If true, output includes the input filename.
+    """
+    related_files = []
+    path, name, this_type = split_filename(filename)
+    for type_set in related_filetype_sets:
+        if this_type in type_set:
+            for related_type in type_set:
+                if include_this_file or related_type != this_type:
+                    related_files.append(op.join(path, name + related_type))
+    if not len(related_files):
+        related_files = [filename]
+    return related_files
+
+
+class ProbTrackXInputSpec(ProbTrackXBaseInputSpec):
+    mode = traits.Enum(
+        "simple",
+        "two_mask_symm",
+        "seedmask",
+        desc=(
+            "options: simple (single seed voxel), seedmask "
+            "(mask of seed voxels), twomask_symm (two bet "
+            "binary masks)"
+        ),
+        argstr="--mode=%s",
+        genfile=True,
+    )
+    mask2 = File(
+        exists=True,
+        desc=("second bet binary mask (in diffusion space) in " "twomask_symm mode"),
+        argstr="--mask2=%s",
+    )
+    mesh = File(
+        exists=True,
+        desc="Freesurfer-type surface descriptor (in ascii format)",
+        argstr="--mesh=%s",
+    )
+
+
+class ProbTrackX(FSLCommand):
+    """ Use FSL  probtrackx for tractography on bedpostx results
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces import fsl
+    >>> pbx = fsl.ProbTrackX(samples_base_name='merged', mask='mask.nii', \
+    seed='MASK_average_thal_right.nii', mode='seedmask', \
+    xfm='trans.mat', n_samples=3, n_steps=10, force_dir=True, opd=True, \
+    os2t=True, target_masks = ['targets_MASK1.nii', 'targets_MASK2.nii'], \
+    thsamples='merged_thsamples.nii', fsamples='merged_fsamples.nii', \
+    phsamples='merged_phsamples.nii', out_dir='.')
+    >>> pbx.cmdline
+    'probtrackx --forcedir -m mask.nii --mode=seedmask --nsamples=3 --nsteps=10 --opd --os2t --dir=. --samples=merged --seed=MASK_average_thal_right.nii --targetmasks=targets.txt --xfm=trans.mat'
+
+    """
+
+    _cmd = "probtrackx"
+    input_spec = ProbTrackXInputSpec
+    output_spec = ProbTrackXOutputSpec
+
+    def __init__(self, **inputs):
+        warnings.warn(
+            ("Deprecated: Please use create_bedpostx_pipeline " "instead"),
+            DeprecationWarning,
+        )
+        return super(ProbTrackX, self).__init__(**inputs)
+
+    def _run_interface(self, runtime):
+        for i in range(1, len(self.inputs.thsamples) + 1):
+            _, _, ext = split_filename(self.inputs.thsamples[i - 1])
+            copyfile(
+                self.inputs.thsamples[i - 1],
+                self.inputs.samples_base_name + "_th%dsamples" % i + ext,
+                copy=False,
+            )
+            _, _, ext = split_filename(self.inputs.thsamples[i - 1])
+            copyfile(
+                self.inputs.phsamples[i - 1],
+                self.inputs.samples_base_name + "_ph%dsamples" % i + ext,
+                copy=False,
+            )
+            _, _, ext = split_filename(self.inputs.thsamples[i - 1])
+            copyfile(
+                self.inputs.fsamples[i - 1],
+                self.inputs.samples_base_name + "_f%dsamples" % i + ext,
+                copy=False,
+            )
+
+        if self.inputs.target_masks is not attrs.NOTHING:
+            f = open("targets.txt", "w")
+            for target in self.inputs.target_masks:
+                f.write("%s\n" % target)
+            f.close()
+        if isinstance(self.inputs.seed, list):
+            f = open("seeds.txt", "w")
+            for seed in self.inputs.seed:
+                if isinstance(seed, list):
+                    f.write("%s\n" % (" ".join([str(s) for s in seed])))
+                else:
+                    f.write("%s\n" % seed)
+            f.close()
+
+        runtime = super(ProbTrackX, self)._run_interface(runtime)
+        if runtime.stderr:
+            self.raise_exception(runtime)
+        return runtime
+
+    def _format_arg(self, name, spec, value):
+        if name == "target_masks" and value is not attrs.NOTHING:
+            fname = "targets.txt"
+            return super(ProbTrackX, self)._format_arg(name, spec, [fname])
+        elif name == "seed" and isinstance(value, list):
+            fname = "seeds.txt"
+            return super(ProbTrackX, self)._format_arg(name, spec, fname)
+        else:
+            return super(ProbTrackX, self)._format_arg(name, spec, value)
+
+    def _list_outputs(self):
+        outputs = self.output_spec().get()
+        if self.inputs.out_dir is attrs.NOTHING:
+            out_dir = self._gen_filename("out_dir")
+        else:
+            out_dir = self.inputs.out_dir
+
+        outputs["log"] = os.path.abspath(os.path.join(out_dir, "probtrackx.log"))
+        # outputs['way_total'] = os.path.abspath(os.path.join(out_dir,
+        #                                                    'waytotal'))
+        if isdefined(self.inputs.opd is True):
+            if isinstance(self.inputs.seed, list) and isinstance(
+                self.inputs.seed[0], list
+            ):
+                outputs["fdt_paths"] = []
+                for seed in self.inputs.seed:
+                    outputs["fdt_paths"].append(
+                        os.path.abspath(
+                            self._gen_fname(
+                                ("fdt_paths_%s" % ("_".join([str(s) for s in seed]))),
+                                cwd=out_dir,
+                                suffix="",
+                            )
+                        )
+                    )
+            else:
+                outputs["fdt_paths"] = os.path.abspath(
+                    self._gen_fname("fdt_paths", cwd=out_dir, suffix="")
+                )
+
+        # handle seeds-to-target output files
+        if self.inputs.target_masks is not attrs.NOTHING:
+            outputs["targets"] = []
+            for target in self.inputs.target_masks:
+                outputs["targets"].append(
+                    os.path.abspath(
+                        self._gen_fname(
+                            "seeds_to_" + os.path.split(target)[1],
+                            cwd=out_dir,
+                            suffix="",
+                        )
+                    )
+                )
+        if self.inputs.verbose is not attrs.NOTHING and self.inputs.verbose == 2:
+            outputs["particle_files"] = [
+                os.path.abspath(os.path.join(out_dir, "particle%d" % i))
+                for i in range(self.inputs.n_samples)
+            ]
+        return outputs
+
+    def _gen_filename(self, name):
+        if name == "out_dir":
+            return os.getcwd()
+        elif name == "mode":
+            if isinstance(self.inputs.seed, list) and isinstance(
+                self.inputs.seed[0], list
+            ):
+                return "simple"
+            else:
+                return "seedmask"
+
+
+class ProbTrackXOutputSpec(TraitedSpec):
+    log = File(
+        exists=True, desc="path/name of a text record of the command that was run"
+    )
+    fdt_paths = OutputMultiPath(
+        File(exists=True),
+        desc=(
+            "path/name of a 3D image file "
+            "containing the output connectivity "
+            "distribution to the seed mask"
+        ),
+    )
+    way_total = File(
+        exists=True,
+        desc=(
+            "path/name of a text file containing a single "
+            "number corresponding to the total number of "
+            "generated tracts that have not been rejected by "
+            "inclusion/exclusion mask criteria"
+        ),
+    )
+    targets = traits.List(
+        File(exists=True), desc=("a list with all generated seeds_to_target " "files")
+    )
+    particle_files = traits.List(
+        File(exists=True),
+        desc=(
+            "Files describing all of the tract "
+            "samples. Generated only if verbose is "
+            "set to 2"
+        ),
+    )
+
+
+class ProbTrackXBaseInputSpec(FSLCommandInputSpec):
+    thsamples = InputMultiPath(File(exists=True), mandatory=True)
+    phsamples = InputMultiPath(File(exists=True), mandatory=True)
+    fsamples = InputMultiPath(File(exists=True), mandatory=True)
+    samples_base_name = traits.Str(
+        "merged",
+        desc=("the rootname/base_name for samples " "files"),
+        argstr="--samples=%s",
+        usedefault=True,
+    )
+    mask = File(
+        exists=True,
+        desc="bet binary mask file in diffusion space",
+        argstr="-m %s",
+        mandatory=True,
+    )
+    seed = traits.Either(
+        File(exists=True),
+        traits.List(File(exists=True)),
+        traits.List(traits.List(traits.Int(), minlen=3, maxlen=3)),
+        desc=("seed volume(s), or voxel(s) or freesurfer " "label file"),
+        argstr="--seed=%s",
+        mandatory=True,
+    )
+    target_masks = InputMultiPath(
+        File(exits=True),
+        desc=("list of target masks - required for " "seeds_to_targets classification"),
+        argstr="--targetmasks=%s",
+    )
+    waypoints = File(
+        exists=True,
+        desc=(
+            "waypoint mask or ascii list of waypoint masks - "
+            "only keep paths going through ALL the masks"
+        ),
+        argstr="--waypoints=%s",
+    )
+    network = traits.Bool(
+        desc=(
+            "activate network mode - only keep paths "
+            "going through at least one seed mask "
+            "(required if multiple seed masks)"
+        ),
+        argstr="--network",
+    )
+    seed_ref = File(
+        exists=True,
+        desc=(
+            "reference vol to define seed space in simple mode "
+            "- diffusion space assumed if absent"
+        ),
+        argstr="--seedref=%s",
+    )
+    out_dir = Directory(
+        exists=True,
+        argstr="--dir=%s",
+        desc="directory to put the final volumes in",
+        genfile=True,
+    )
+    force_dir = traits.Bool(
+        True,
+        desc=(
+            "use the actual directory name given - i.e. "
+            "do not add + to make a new directory"
+        ),
+        argstr="--forcedir",
+        usedefault=True,
+    )
+    opd = traits.Bool(
+        True, desc="outputs path distributions", argstr="--opd", usedefault=True
+    )
+    correct_path_distribution = traits.Bool(
+        desc=("correct path distribution " "for the length of the " "pathways"),
+        argstr="--pd",
+    )
+    os2t = traits.Bool(desc="Outputs seeds to targets", argstr="--os2t")
+    # paths_file = File('nipype_fdtpaths', usedefault=True, argstr='--out=%s',
+    #                 desc='produces an output file (default is fdt_paths)')
+    avoid_mp = File(
+        exists=True,
+        desc=("reject pathways passing through locations given by " "this mask"),
+        argstr="--avoid=%s",
+    )
+    stop_mask = File(
+        exists=True,
+        argstr="--stop=%s",
+        desc="stop tracking at locations given by this mask file",
+    )
+    xfm = File(
+        exists=True,
+        argstr="--xfm=%s",
+        desc=(
+            "transformation matrix taking seed space to DTI space "
+            "(either FLIRT matrix or FNIRT warp_field) - default is "
+            "identity"
+        ),
+    )
+    inv_xfm = File(
+        argstr="--invxfm=%s",
+        desc=(
+            "transformation matrix taking DTI space to seed "
+            "space (compulsory when using a warp_field for "
+            "seeds_to_dti)"
+        ),
+    )
+    n_samples = traits.Int(
+        5000,
+        argstr="--nsamples=%d",
+        desc="number of samples - default=5000",
+        usedefault=True,
+    )
+    n_steps = traits.Int(
+        argstr="--nsteps=%d", desc="number of steps per sample - default=2000"
+    )
+    dist_thresh = traits.Float(
+        argstr="--distthresh=%.3f",
+        desc=("discards samples shorter than this " "threshold (in mm - default=0)"),
+    )
+    c_thresh = traits.Float(
+        argstr="--cthr=%.3f", desc="curvature threshold - default=0.2"
+    )
+    sample_random_points = traits.Bool(
+        argstr="--sampvox", desc=("sample random points within " "seed voxels")
+    )
+    step_length = traits.Float(
+        argstr="--steplength=%.3f", desc="step_length in mm - default=0.5"
+    )
+    loop_check = traits.Bool(
+        argstr="--loopcheck",
+        desc=(
+            "perform loop_checks on paths - slower, "
+            "but allows lower curvature threshold"
+        ),
+    )
+    use_anisotropy = traits.Bool(
+        argstr="--usef", desc="use anisotropy to constrain tracking"
+    )
+    rand_fib = traits.Enum(
+        0,
+        1,
+        2,
+        3,
+        argstr="--randfib=%d",
+        desc=(
+            "options: 0 - default, 1 - to randomly "
+            "sample initial fibres (with f > fibthresh), "
+            "2 - to sample in proportion fibres (with "
+            "f>fibthresh) to f, 3 - to sample ALL "
+            "populations at random (even if "
+            "f<fibthresh)"
+        ),
+    )
+    fibst = traits.Int(
+        argstr="--fibst=%d",
+        desc=(
+            "force a starting fibre for tracking - "
+            "default=1, i.e. first fibre orientation. Only "
+            "works if randfib==0"
+        ),
+    )
+    mod_euler = traits.Bool(argstr="--modeuler", desc="use modified euler streamlining")
+    random_seed = traits.Bool(argstr="--rseed", desc="random seed")
+    s2tastext = traits.Bool(
+        argstr="--s2tastext",
+        desc=(
+            "output seed-to-target counts as a text "
+            "file (useful when seeding from a mesh)"
+        ),
+    )
+    verbose = traits.Enum(
+        0,
+        1,
+        2,
+        desc=("Verbose level, [0-2]. Level 2 is required to " "output particle files."),
+        argstr="--verbose=%d",
+    )
+
+
+class ProbTrackX2OutputSpec(ProbTrackXOutputSpec):
+    network_matrix = File(
+        exists=True, desc=("the network matrix generated by --omatrix1 " "option")
+    )
+    matrix1_dot = File(exists=True, desc="Output matrix1.dot - SeedToSeed Connectivity")
+    lookup_tractspace = File(
+        exists=True, desc=("lookup_tractspace generated by " "--omatrix2 option")
+    )
+    matrix2_dot = File(exists=True, desc="Output matrix2.dot - SeedToLowResMask")
+    matrix3_dot = File(exists=True, desc="Output matrix3 - NxN connectivity matrix")
+
+
+class ProbTrackX2InputSpec(ProbTrackXBaseInputSpec):
+    simple = traits.Bool(
+        desc=(
+            "rack from a list of voxels (seed must be a " "ASCII list of coordinates)"
+        ),
+        argstr="--simple",
+    )
+    fopd = File(
+        exists=True,
+        desc="Other mask for binning tract distribution",
+        argstr="--fopd=%s",
+    )
+    waycond = traits.Enum(
+        "OR",
+        "AND",
+        argstr="--waycond=%s",
+        desc=('Waypoint condition. Either "AND" (default) ' 'or "OR"'),
+    )
+    wayorder = traits.Bool(
+        desc=(
+            "Reject streamlines that do not hit "
+            "waypoints in given order. Only valid if "
+            "waycond=AND"
+        ),
+        argstr="--wayorder",
+    )
+    onewaycondition = traits.Bool(
+        desc=("Apply waypoint conditions to each " "half tract separately"),
+        argstr="--onewaycondition",
+    )
+    omatrix1 = traits.Bool(
+        desc="Output matrix1 - SeedToSeed Connectivity", argstr="--omatrix1"
+    )
+    distthresh1 = traits.Float(
+        argstr="--distthresh1=%.3f",
+        desc=(
+            "Discards samples (in matrix1) shorter "
+            "than this threshold (in mm - "
+            "default=0)"
+        ),
+    )
+    omatrix2 = traits.Bool(
+        desc="Output matrix2 - SeedToLowResMask",
+        argstr="--omatrix2",
+        requires=["target2"],
+    )
+    target2 = File(
+        exists=True,
+        desc=(
+            "Low resolution binary brain mask for storing "
+            "connectivity distribution in matrix2 mode"
+        ),
+        argstr="--target2=%s",
+    )
+    omatrix3 = traits.Bool(
+        desc="Output matrix3 (NxN connectivity matrix)",
+        argstr="--omatrix3",
+        requires=["target3", "lrtarget3"],
+    )
+    target3 = File(
+        exists=True,
+        desc=("Mask used for NxN connectivity matrix (or Nxn if " "lrtarget3 is set)"),
+        argstr="--target3=%s",
+    )
+    lrtarget3 = File(
+        exists=True,
+        desc="Column-space mask used for Nxn connectivity matrix",
+        argstr="--lrtarget3=%s",
+    )
+    distthresh3 = traits.Float(
+        argstr="--distthresh3=%.3f",
+        desc=(
+            "Discards samples (in matrix3) shorter "
+            "than this threshold (in mm - "
+            "default=0)"
+        ),
+    )
+    omatrix4 = traits.Bool(
+        desc=("Output matrix4 - DtiMaskToSeed (special " "Oxford Sparse Format)"),
+        argstr="--omatrix4",
+    )
+    colmask4 = File(
+        exists=True,
+        desc="Mask for columns of matrix4 (default=seed mask)",
+        argstr="--colmask4=%s",
+    )
+    target4 = File(exists=True, desc="Brain mask in DTI space", argstr="--target4=%s")
+    meshspace = traits.Enum(
+        "caret",
+        "freesurfer",
+        "first",
+        "vox",
+        argstr="--meshspace=%s",
+        desc=(
+            'Mesh reference space - either "caret" '
+            '(default) or "freesurfer" or "first" or '
+            '"vox"'
+        ),
+    )
+
+
+class ProbTrackX2(ProbTrackX):
+    """Use FSL  probtrackx2 for tractography on bedpostx results
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces import fsl
+    >>> pbx2 = fsl.ProbTrackX2()
+    >>> pbx2.inputs.seed = 'seed_source.nii.gz'
+    >>> pbx2.inputs.thsamples = 'merged_th1samples.nii.gz'
+    >>> pbx2.inputs.fsamples = 'merged_f1samples.nii.gz'
+    >>> pbx2.inputs.phsamples = 'merged_ph1samples.nii.gz'
+    >>> pbx2.inputs.mask = 'nodif_brain_mask.nii.gz'
+    >>> pbx2.inputs.out_dir = '.'
+    >>> pbx2.inputs.n_samples = 3
+    >>> pbx2.inputs.n_steps = 10
+    >>> pbx2.cmdline
+    'probtrackx2 --forcedir -m nodif_brain_mask.nii.gz --nsamples=3 --nsteps=10 --opd --dir=. --samples=merged --seed=seed_source.nii.gz'
+    """
+
+    _cmd = "probtrackx2"
+    input_spec = ProbTrackX2InputSpec
+    output_spec = ProbTrackX2OutputSpec
+
+    def _list_outputs(self):
+        outputs = super(ProbTrackX2, self)._list_outputs()
+
+        if self.inputs.out_dir is attrs.NOTHING:
+            out_dir = os.getcwd()
+        else:
+            out_dir = self.inputs.out_dir
+
+        outputs["way_total"] = os.path.abspath(os.path.join(out_dir, "waytotal"))
+
+        if self.inputs.omatrix1 is not attrs.NOTHING:
+            outputs["network_matrix"] = os.path.abspath(
+                os.path.join(out_dir, "matrix_seeds_to_all_targets")
+            )
+            outputs["matrix1_dot"] = os.path.abspath(
+                os.path.join(out_dir, "fdt_matrix1.dot")
+            )
+
+        if self.inputs.omatrix2 is not attrs.NOTHING:
+            outputs["lookup_tractspace"] = os.path.abspath(
+                os.path.join(out_dir, "lookup_tractspace_fdt_matrix2.nii.gz")
+            )
+            outputs["matrix2_dot"] = os.path.abspath(
+                os.path.join(out_dir, "fdt_matrix2.dot")
+            )
+
+        if self.inputs.omatrix3 is not attrs.NOTHING:
+            outputs["matrix3_dot"] = os.path.abspath(
+                os.path.join(out_dir, "fdt_matrix3.dot")
+            )
+        return outputs
 
 
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
@@ -15,3 +1146,36 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
             return "simple"
         else:
             return "seedmask"
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = super(ProbTrackX2, self)._list_outputs()
+
+    if inputs.out_dir is attrs.NOTHING:
+        out_dir = output_dir
+    else:
+        out_dir = inputs.out_dir
+
+    outputs["way_total"] = os.path.abspath(os.path.join(out_dir, "waytotal"))
+
+    if inputs.omatrix1 is not attrs.NOTHING:
+        outputs["network_matrix"] = os.path.abspath(
+            os.path.join(out_dir, "matrix_seeds_to_all_targets")
+        )
+        outputs["matrix1_dot"] = os.path.abspath(
+            os.path.join(out_dir, "fdt_matrix1.dot")
+        )
+
+    if inputs.omatrix2 is not attrs.NOTHING:
+        outputs["lookup_tractspace"] = os.path.abspath(
+            os.path.join(out_dir, "lookup_tractspace_fdt_matrix2.nii.gz")
+        )
+        outputs["matrix2_dot"] = os.path.abspath(
+            os.path.join(out_dir, "fdt_matrix2.dot")
+        )
+
+    if inputs.omatrix3 is not attrs.NOTHING:
+        outputs["matrix3_dot"] = os.path.abspath(
+            os.path.join(out_dir, "fdt_matrix3.dot")
+        )
+    return outputs
diff --git a/example-specs/task/nipype/fsl/prob_track_x_callables.py b/example-specs/task/nipype/fsl/prob_track_x_callables.py
index 1d6d62b8..19e8b343 100644
--- a/example-specs/task/nipype/fsl/prob_track_x_callables.py
+++ b/example-specs/task/nipype/fsl/prob_track_x_callables.py
@@ -1,16 +1,36 @@
 """Module to put any functions that are referred to in the "callables" section of ProbTrackX.yaml"""
 
+from glob import glob
+import attrs
+import os
+import os.path as op
+from pathlib import Path
+import logging
+
+
+def mode_default(inputs):
+    return _gen_filename("mode", inputs=inputs)
+
+
+def out_dir_default(inputs):
+    return _gen_filename("out_dir", inputs=inputs)
+
 
 def mode_callable(output_dir, inputs, stdout, stderr):
-    return _gen_filename(
-        "mode", output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
+    return outputs["mode"]
 
 
 def out_dir_callable(output_dir, inputs, stdout, stderr):
-    return _gen_filename(
-        "out_dir", output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
+    return outputs["out_dir"]
+
+
+IFLOGGER = logging.getLogger("nipype.interface")
 
 
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
@@ -21,3 +41,350 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
             return "simple"
         else:
             return "seedmask"
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    if inputs.out_dir is attrs.NOTHING:
+        out_dir = _gen_filename(
+            "out_dir",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    else:
+        out_dir = inputs.out_dir
+
+    outputs["log"] = os.path.abspath(os.path.join(out_dir, "probtrackx.log"))
+    # outputs['way_total'] = os.path.abspath(os.path.join(out_dir,
+    #                                                    'waytotal'))
+    if isdefined(inputs.opd is True):
+        if isinstance(inputs.seed, list) and isinstance(inputs.seed[0], list):
+            outputs["fdt_paths"] = []
+            for seed in inputs.seed:
+                outputs["fdt_paths"].append(
+                    os.path.abspath(
+                        _gen_fname(
+                            ("fdt_paths_%s" % ("_".join([str(s) for s in seed]))),
+                            cwd=out_dir,
+                            suffix="",
+                            inputs=inputs,
+                            stdout=stdout,
+                            stderr=stderr,
+                            output_dir=output_dir,
+                        )
+                    )
+                )
+        else:
+            outputs["fdt_paths"] = os.path.abspath(
+                _gen_fname(
+                    "fdt_paths",
+                    cwd=out_dir,
+                    suffix="",
+                    inputs=inputs,
+                    stdout=stdout,
+                    stderr=stderr,
+                    output_dir=output_dir,
+                )
+            )
+
+    # handle seeds-to-target output files
+    if inputs.target_masks is not attrs.NOTHING:
+        outputs["targets"] = []
+        for target in inputs.target_masks:
+            outputs["targets"].append(
+                os.path.abspath(
+                    _gen_fname(
+                        "seeds_to_" + os.path.split(target)[1],
+                        cwd=out_dir,
+                        suffix="",
+                        inputs=inputs,
+                        stdout=stdout,
+                        stderr=stderr,
+                        output_dir=output_dir,
+                    )
+                )
+            )
+    if inputs.verbose is not attrs.NOTHING and inputs.verbose == 2:
+        outputs["particle_files"] = [
+            os.path.abspath(os.path.join(out_dir, "particle%d" % i))
+            for i in range(inputs.n_samples)
+        ]
+    return outputs
+
+
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import Undefined
+    >>> fname_presuffix(fname, 'pre', 'post', Undefined) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for isdefined: bool(Undefined) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """
+    Handle FSL ``output_type`` and version information.
+
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
+
+    """
+
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
+
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
+
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
+
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
+
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
+
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
+
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
+
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
+
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
+
+        Returns a list of standard images if called without arguments.
+
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
+
+
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
+
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
+
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
+
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "probtrackx"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
diff --git a/example-specs/task/nipype/fsl/slice_timer_callables.py b/example-specs/task/nipype/fsl/slice_timer_callables.py
index 7fe139bc..80734620 100644
--- a/example-specs/task/nipype/fsl/slice_timer_callables.py
+++ b/example-specs/task/nipype/fsl/slice_timer_callables.py
@@ -1,14 +1,25 @@
 """Module to put any functions that are referred to in the "callables" section of SliceTimer.yaml"""
 
+from glob import glob
 import attrs
-from fileformats.generic import File
 import os
+import os.path as op
+from pathlib import Path
+import logging
+
+
+def out_file_default(inputs):
+    return _gen_filename("out_file", inputs=inputs)
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
-    return _gen_filename(
-        "out_file", output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
+    return outputs["out_file"]
+
+
+IFLOGGER = logging.getLogger("nipype.interface")
 
 
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
@@ -19,21 +30,8 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     return None
 
 
-def _outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    """Returns a bunch containing output fields for the class"""
-    outputs = None
-    if output_spec:
-        outputs = output_spec(
-            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-        )
-
-    return outputs
-
-
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = _outputs(
-        inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-    ).get()
+    outputs = {}
     out_file = inputs.out_file
     if out_file is attrs.NOTHING:
         out_file = _gen_fname(
@@ -48,6 +46,227 @@ def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     return outputs
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import Undefined
+    >>> fname_presuffix(fname, 'pre', 'post', Undefined) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for isdefined: bool(Undefined) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """
+    Handle FSL ``output_type`` and version information.
+
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
+
+    """
+
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
+
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
+
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
+
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
+
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
+
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
+
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
+
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
+
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
+
+        Returns a list of standard images if called without arguments.
+
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
+
+
 def _gen_fname(
     basename,
     cwd=None,
@@ -101,7 +320,3 @@ def _gen_fname(
         suffix = ""
     fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
     return fname
-
-
-class SliceTimerOutputSpec(inputs=None, stdout=None, stderr=None, output_dir=None):
-    slice_time_corrected_file = File(exists=True, desc="slice time corrected file")
diff --git a/example-specs/task/nipype/fsl/susan_callables.py b/example-specs/task/nipype/fsl/susan_callables.py
index 45dc9cc0..fdfecf82 100644
--- a/example-specs/task/nipype/fsl/susan_callables.py
+++ b/example-specs/task/nipype/fsl/susan_callables.py
@@ -1,14 +1,25 @@
 """Module to put any functions that are referred to in the "callables" section of SUSAN.yaml"""
 
+from glob import glob
 import attrs
-from fileformats.generic import File
 import os
+import os.path as op
+from pathlib import Path
+import logging
+
+
+def out_file_default(inputs):
+    return _gen_filename("out_file", inputs=inputs)
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
-    return _gen_filename(
-        "out_file", output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
+    return outputs["out_file"]
+
+
+IFLOGGER = logging.getLogger("nipype.interface")
 
 
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
@@ -19,21 +30,8 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     return None
 
 
-def _outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    """Returns a bunch containing output fields for the class"""
-    outputs = None
-    if output_spec:
-        outputs = output_spec(
-            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-        )
-
-    return outputs
-
-
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = _outputs(
-        inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-    ).get()
+    outputs = {}
     out_file = inputs.out_file
     if out_file is attrs.NOTHING:
         out_file = _gen_fname(
@@ -48,6 +46,227 @@ def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     return outputs
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import Undefined
+    >>> fname_presuffix(fname, 'pre', 'post', Undefined) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for isdefined: bool(Undefined) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """
+    Handle FSL ``output_type`` and version information.
+
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
+
+    """
+
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
+
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
+
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
+
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
+
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
+
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
+
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
+
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
+
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
+
+        Returns a list of standard images if called without arguments.
+
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
+
+
 def _gen_fname(
     basename,
     cwd=None,
@@ -101,7 +320,3 @@ def _gen_fname(
         suffix = ""
     fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
     return fname
-
-
-class SUSANOutputSpec(inputs=None, stdout=None, stderr=None, output_dir=None):
-    smoothed_file = File(exists=True, desc="smoothed output file")
diff --git a/nipype2pydra/pkg_gen/__init__.py b/nipype2pydra/pkg_gen/__init__.py
index 8092ff1b..8882ce75 100644
--- a/nipype2pydra/pkg_gen/__init__.py
+++ b/nipype2pydra/pkg_gen/__init__.py
@@ -34,6 +34,7 @@
     cleanup_function_body,
     insert_args_in_signature,
 )
+from nipype2pydra.exceptions import UnmatchedParensException
 
 
 TEMPLATES_DIR = Path(__file__).parent.parent / "pkg_gen" / "resources" / "templates"
@@ -845,12 +846,24 @@ def insert_args_in_method_calls(src: str, args: ty.List[ty.Tuple[str, str]]) ->
         # Iterate through these chunks and add the additional args to the method calls
         # using insert_args_in_signature function
         sig = ""
+        outer_name = None
         for name, next_part in zip(splits[1::2], splits[2::2]):
-            if next_part.count("(") > next_part.count(")"):
+            if outer_name:
                 sig += name + next_part
             else:
                 sig += next_part
-                new_src += name + insert_args_in_signature(sig, args)
+            try:
+                new_sig = insert_args_in_signature(sig, args)
+            except UnmatchedParensException:
+                sig = next_part
+                outer_name = name
+            else:
+                if outer_name:
+                    new_sig = insert_args_in_method_calls(new_sig, args)
+                    new_src += outer_name + new_sig
+                    outer_name = None
+                else:
+                    new_src += name + new_sig
                 sig = ""
         return new_src
 
diff --git a/nipype2pydra/task/tests/test_task.py b/nipype2pydra/task/tests/test_task.py
index a224810c..59f4795b 100644
--- a/nipype2pydra/task/tests/test_task.py
+++ b/nipype2pydra/task/tests/test_task.py
@@ -3,6 +3,7 @@
 import pytest
 import logging
 from conftest import show_cli_trace
+from traceback import format_exc
 from nipype2pydra.cli.task import task as task_cli
 from nipype2pydra.utils import add_to_sys_path, add_exc_note
 from conftest import EXAMPLE_TASKS_DIR
@@ -20,7 +21,19 @@
     "output_type",
 ]
 
-XFAIL_PACKAGES = ["camino", "cat12", "cmtk", "dcmsstack", "dipy", "spm"]
+XFAIL_INTERFACES = [
+    "fsl-prob_track_x2",
+    "fsl-flameo",
+    "fsl-make_dyadic_vectors",
+    "fsl-dual_regression",
+]
+
+XFAIL_INTERFACES_IN_COMBINED = [
+    "freesurfer-smooth",
+    "freesurfer-apply_mask",
+    "afni-merge",
+    "afni-resample",
+]
 
 
 @pytest.fixture(
@@ -35,71 +48,99 @@ def task_spec_file(request):
 
 def test_task_conversion(task_spec_file, cli_runner, work_dir, gen_test_conftest):
 
-    with open(task_spec_file) as f:
-        task_spec = yaml.safe_load(f)
-    pkg_root = work_dir / "src"
-    pkg_root.mkdir()
-    # shutil.copyfile(gen_test_conftest, pkg_root / "conftest.py")
-
-    output_module_path = f"nipype2pydratest.{task_spec_file.stem.lower()}"
-
-    result = cli_runner(
-        task_cli,
-        args=[
-            str(task_spec_file),
-            str(pkg_root),
-            "--output-module",
-            output_module_path,
-            "--callables",
-            str(task_spec_file.parent / (task_spec_file.stem + "_callables.py")),
-        ],
-    )
-
-    assert result.exit_code == 0, show_cli_trace(result)
-
-    with add_to_sys_path(pkg_root):
-        try:
-            pydra_module = import_module(output_module_path)
-        except Exception as e:
-            add_exc_note(e, f"Attempting to import {task_spec['task_name']} from '{output_module_path}'")
-            raise e
-    pydra_task = getattr(pydra_module, task_spec["task_name"])
-    nipype_interface = getattr(
-        import_module(task_spec["nipype_module"]), task_spec["nipype_name"]
-    )
-
-    nipype_input_names = nipype_interface.input_spec().all_trait_names()
-    inputs_omit = task_spec["inputs"]["omit"] if task_spec["inputs"]["omit"] else []
-
-    assert sorted(f[0] for f in pydra_task().input_spec.fields if not f[0].startswith("_")) == sorted(
-        n
-        for n in nipype_input_names
-        if not (
-            n in INBUILT_NIPYPE_TRAIT_NAMES
-            or n in inputs_omit
-            or (n.endswith("_items") and n[: -len("_items")] in nipype_input_names)
+    try:
+        with open(task_spec_file) as f:
+            task_spec = yaml.safe_load(f)
+        pkg_root = work_dir / "src"
+        pkg_root.mkdir()
+        # shutil.copyfile(gen_test_conftest, pkg_root / "conftest.py")
+
+        output_module_path = f"nipype2pydratest.{task_spec_file.stem.lower()}"
+
+        result = cli_runner(
+            task_cli,
+            args=[
+                str(task_spec_file),
+                str(pkg_root),
+                "--output-module",
+                output_module_path,
+                "--callables",
+                str(task_spec_file.parent / (task_spec_file.stem + "_callables.py")),
+            ],
         )
-    )
 
-    if nipype_interface.output_spec:
-        nipype_output_names = nipype_interface.output_spec().all_trait_names()
-        outputs_omit = task_spec["outputs"]["omit"] if task_spec["outputs"]["omit"] else []
+        assert result.exit_code == 0, show_cli_trace(result)
+
+        with add_to_sys_path(pkg_root):
+            try:
+                pydra_module = import_module(output_module_path)
+            except Exception as e:
+                add_exc_note(
+                    e,
+                    f"Attempting to import {task_spec['task_name']} from '{output_module_path}'",
+                )
+                raise e
+        pydra_task = getattr(pydra_module, task_spec["task_name"])
+        nipype_interface = getattr(
+            import_module(task_spec["nipype_module"]), task_spec["nipype_name"]
+        )
 
-        assert sorted(f[0] for f in pydra_task().output_spec.fields if not f[0].startswith("_")) == sorted(
+        nipype_input_names = nipype_interface.input_spec().all_trait_names()
+        inputs_omit = task_spec["inputs"]["omit"] if task_spec["inputs"]["omit"] else []
+
+        assert sorted(
+            f[0] for f in pydra_task().input_spec.fields if not f[0].startswith("_")
+        ) == sorted(
             n
-            for n in nipype_output_names
+            for n in nipype_input_names
             if not (
                 n in INBUILT_NIPYPE_TRAIT_NAMES
-                or n in outputs_omit
-                or (n.endswith("_items") and n[: -len("_items")] in nipype_output_names)
+                or n in inputs_omit
+                or (n.endswith("_items") and n[: -len("_items")] in nipype_input_names)
             )
         )
 
-    # tests_fspath = pkg_root.joinpath(*output_module_path.split(".")).parent / "tests"
+        if nipype_interface.output_spec:
+            nipype_output_names = nipype_interface.output_spec().all_trait_names()
+            outputs_omit = (
+                task_spec["outputs"]["omit"] if task_spec["outputs"]["omit"] else []
+            )
 
-    # # logging.info("Running generated tests for %s", output_module_path)
-    # # # Run generated pytests
-    # # with add_to_sys_path(pkg_root):
-    # #     result = pytest.main([str(tests_fspath)])
+            assert sorted(
+                f[0]
+                for f in pydra_task().output_spec.fields
+                if not f[0].startswith("_")
+            ) == sorted(
+                n
+                for n in nipype_output_names
+                if not (
+                    n in INBUILT_NIPYPE_TRAIT_NAMES
+                    or n in outputs_omit
+                    or (
+                        n.endswith("_items")
+                        and n[: -len("_items")] in nipype_output_names
+                    )
+                )
+            )
 
-    # assert result.value == 0
+        # tests_fspath = pkg_root.joinpath(*output_module_path.split(".")).parent / "tests"
+
+        # # logging.info("Running generated tests for %s", output_module_path)
+        # # # Run generated pytests
+        # # with add_to_sys_path(pkg_root):
+        # #     result = pytest.main([str(tests_fspath)])
+
+        # assert result.value == 0
+    except Exception:
+        task_name = task_spec_file.parent.name + "-" + task_spec_file.stem
+        if task_name in XFAIL_INTERFACES or task_name in XFAIL_INTERFACES_IN_COMBINED:
+            msg = f"Test for '{task_name}' is expected to fail:\n{format_exc()}"
+            if task_name in XFAIL_INTERFACES_IN_COMBINED:
+                msg += (
+                    "\nNote that it isn't expected to fail when you run it separately, "
+                    "not sure why the interfaces are getting mixed up between tests but "
+                    "looks like it comes from another interface"
+                )
+            pytest.xfail(msg)
+        else:
+            raise
diff --git a/nipype2pydra/tests/test_utils.py b/nipype2pydra/tests/test_utils.py
index 3f265236..10225eda 100644
--- a/nipype2pydra/tests/test_utils.py
+++ b/nipype2pydra/tests/test_utils.py
@@ -20,9 +20,7 @@ def test_split_parens_contents2a():
 
 
 def test_split_parens_contents2b():
-    assert split_parens_contents(
-        "foo(a, 'b, \"c')"
-    ) == ("foo(", ["a", "'b, \"c'"], ")")
+    assert split_parens_contents("foo(a, 'b, \"c')") == ("foo(", ["a", "'b, \"c'"], ")")
 
 
 def test_split_parens_contents3():
@@ -59,3 +57,29 @@ def test_split_parens_contents6a():
     assert split_parens_contents(
         r"foo(a, '\'b\', c')",
     ) == ("foo(", ["a", r"'\'b\', c'"], ")")
+
+
+def test_split_parens_contents7():
+    assert split_parens_contents(
+        '"""Module explanation"""\ndef foo(a, b, c)',
+    ) == ('"""Module explanation"""\ndef foo(', ["a", "b", "c"], ")")
+
+
+def test_split_parens_contents8():
+    assert split_parens_contents(
+        """related_filetype_sets = [(".hdr", ".img", ".mat"), (".nii", ".mat"), (".BRIK", ".HEAD")]""",
+    ) == (
+        "related_filetype_sets = [",
+        ['(".hdr", ".img", ".mat")', '(".nii", ".mat")', '(".BRIK", ".HEAD")'],
+        "]",
+    )
+
+
+def test_split_parens_contents9():
+    assert split_parens_contents(
+        'foo(cwd=bar("tmpdir"), basename="maskexf")'
+    ) == (
+        "foo(",
+        ['cwd=bar("tmpdir")', 'basename="maskexf"'],
+        ")",
+    )
diff --git a/nipype2pydra/utils.py b/nipype2pydra/utils.py
index bbd926a2..1dd16399 100644
--- a/nipype2pydra/utils.py
+++ b/nipype2pydra/utils.py
@@ -162,23 +162,28 @@ def split_parens_contents(snippet, brackets: bool = False, delimiter=","):
         snippet,
         flags=re.MULTILINE | re.DOTALL,
     )
+    quote_types = ["'", '"']
     pre = "".join(splits[:2])
     contents = []
-    next_item = ""
-    first = splits[1]  # which bracket/parens type was opened initially (and signifies)
     matching = {")": "(", "]": "["}
     open = ["(", "["]
     close = [")", "]"]
     depth = {p: 0 for p in open}
-    depth[first] += 1  # Open the first bracket/parens type
-    inquote = None
+    next_item = ""
+    if splits[1] in quote_types:
+        first = None  # which bracket/parens type was opened initially (and signifies)
+        inquote = splits[1]
+    else:
+        first = splits[1]
+        depth[first] += 1  # Open the first bracket/parens type
+        inquote = None
     for i, s in enumerate(splits[2:], start=2):
         if not s:
             continue
         if s[0] == "\\":
             next_item += s
             continue
-        if s in ["'", '"']:
+        if s in quote_types:
             if inquote is None:
                 inquote = s
             elif inquote == s:
@@ -191,6 +196,10 @@ def split_parens_contents(snippet, brackets: bool = False, delimiter=","):
         if s in open:
             depth[s] += 1
             next_item += s
+            if first is None:
+                first = s
+                pre += next_item
+                next_item = ""
         else:
             if s in close:
                 matching_open = matching[s]
@@ -199,12 +208,15 @@ def split_parens_contents(snippet, brackets: bool = False, delimiter=","):
                     if next_item:
                         contents.append(next_item)
                     return pre, contents, "".join(splits[i:])
-            if depth[first] == 1 and all(
+            if first and depth[first] == 1 and delimiter in s and all(
                 d == 0 for b, d in depth.items() if b != first
             ):
                 parts = [p.strip() for p in s.split(delimiter)]
                 if parts:
-                    contents.append((next_item + parts[0]).strip())
+                    next_item += parts[0]
+                    next_item = next_item.strip()
+                    if next_item:
+                        contents.append(next_item)
                     contents.extend(parts[1:-1])
                     next_item = parts[-1] if len(parts) > 1 else ""
                 else:
@@ -418,6 +430,7 @@ def get_local_constants(mod):
     Get the constants defined in the module
     """
     source_code = inspect.getsource(mod)
+    source_code = source_code.replace("\\\n", " ")
     parts = re.split(r"^(\w+) *= *", source_code, flags=re.MULTILINE)
     local_vars = []
     for attr_name, following in zip(parts[1::2], parts[2::2]):

From 14dbbacfea8018c83d7b632b05235f6e482ecf13 Mon Sep 17 00:00:00 2001
From: Tom Close <tom.g.close@gmail.com>
Date: Wed, 13 Mar 2024 07:36:11 +1100
Subject: [PATCH 60/78] debugging pkg gen

---
 .../task/nipype/afni/a_boverlap_callables.py  |  350 +++++
 .../nipype/afni/afn_ito_nifti_callables.py    |  325 +++++
 .../afni/align_epi_anat_py_callables.py       |  420 ++++++
 .../task/nipype/afni/allineate_callables.py   |  550 +++++++
 .../nipype/afni/auto_tcorrelate_callables.py  |  319 +++++
 .../task/nipype/afni/auto_tlrc_callables.py   |  260 ++++
 example-specs/task/nipype/afni/autobox.yaml   |   12 +
 .../task/nipype/afni/autobox_callables.py     |  392 +++++
 .../task/nipype/afni/automask_callables.py    |  357 +++++
 .../task/nipype/afni/axialize_callables.py    |  350 +++++
 .../task/nipype/afni/bandpass_callables.py    |  350 +++++
 .../nipype/afni/blur_in_mask_callables.py     |  350 +++++
 .../nipype/afni/blur_to_fwhm_callables.py     |  350 +++++
 .../task/nipype/afni/brick_stat.yaml          |    2 +
 .../task/nipype/afni/brick_stat_callables.py  |  186 +++
 .../task/nipype/afni/bucket_callables.py      |  350 +++++
 .../task/nipype/afni/calc_callables.py        |  350 +++++
 .../task/nipype/afni/cat_callables.py         |  350 +++++
 .../task/nipype/afni/cat_matvec_callables.py  |  350 +++++
 .../task/nipype/afni/center_mass.yaml         |    2 +-
 .../task/nipype/afni/center_mass_callables.py |  212 +++
 .../task/nipype/afni/clip_level.yaml          |    2 +
 .../task/nipype/afni/clip_level_callables.py  |  186 +++
 .../nipype/afni/convert_dset_callables.py     |   19 +
 .../task/nipype/afni/copy_callables.py        |  350 +++++
 .../task/nipype/afni/deconvolve_callables.py  |  307 ++++
 .../afni/degree_centrality_callables.py       |  353 +++++
 .../task/nipype/afni/despike_callables.py     |  350 +++++
 .../task/nipype/afni/detrend_callables.py     |  350 +++++
 example-specs/task/nipype/afni/dot.yaml       |    2 +-
 .../task/nipype/afni/dot_callables.py         |  350 +++++
 .../task/nipype/afni/ecm_callables.py         |  350 +++++
 .../task/nipype/afni/edge_3_callables.py      |  350 +++++
 .../task/nipype/afni/eval_callables.py        |  350 +++++
 .../task/nipype/afni/fim_callables.py         |  350 +++++
 .../task/nipype/afni/fourier_callables.py     |  350 +++++
 example-specs/task/nipype/afni/fwh_mx.yaml    |    4 +
 .../task/nipype/afni/fwh_mx_callables.py      |  255 ++++
 example-specs/task/nipype/afni/gcor.yaml      |    2 +
 .../task/nipype/afni/gcor_callables.py        |   15 +
 .../task/nipype/afni/hist_callables.py        |  203 +++
 .../task/nipype/afni/lfcd_callables.py        |  350 +++++
 .../nipype/afni/local_bistat_callables.py     |  350 +++++
 .../task/nipype/afni/localstat_callables.py   |  350 +++++
 .../task/nipype/afni/mask_tool_callables.py   |  350 +++++
 .../task/nipype/afni/maskave_callables.py     |  350 +++++
 .../task/nipype/afni/means_callables.py       |  350 +++++
 .../task/nipype/afni/merge_callables.py       |  350 +++++
 example-specs/task/nipype/afni/net_corr.yaml  |    2 +
 .../task/nipype/afni/net_corr_callables.py    |  281 ++++
 .../task/nipype/afni/notes_callables.py       |   19 +
 .../nipype/afni/nwarp_adjust_callables.py     |   30 +
 .../task/nipype/afni/nwarp_apply_callables.py |  186 +++
 .../task/nipype/afni/nwarp_cat_callables.py   |  271 ++++
 .../task/nipype/afni/one_d_tool_py.yaml       |    2 +-
 .../nipype/afni/one_d_tool_py_callables.py    |   28 +
 .../nipype/afni/outlier_count_callables.py    |   28 +
 .../nipype/afni/quality_index_callables.py    |  186 +++
 example-specs/task/nipype/afni/qwarp.yaml     |    2 +-
 .../task/nipype/afni/qwarp_callables.py       |  455 ++++++
 .../task/nipype/afni/qwarp_plus_minus.yaml    |    2 +-
 .../nipype/afni/qwarp_plus_minus_callables.py |  455 ++++++
 .../task/nipype/afni/re_ho_callables.py       |  202 +++
 .../task/nipype/afni/refit_callables.py       |   19 +
 .../task/nipype/afni/remlfit_callables.py     |  108 ++
 .../task/nipype/afni/resample_callables.py    |  350 +++++
 .../task/nipype/afni/retroicor_callables.py   |  350 +++++
 .../task/nipype/afni/roi_stats_callables.py   |  186 +++
 .../task/nipype/afni/seg_callables.py         |  186 +++
 .../task/nipype/afni/skull_strip_callables.py |  350 +++++
 .../task/nipype/afni/svm_test_callables.py    |  350 +++++
 .../task/nipype/afni/svm_train_callables.py   |  364 +++++
 .../task/nipype/afni/synthesize_callables.py  |   24 +
 .../task/nipype/afni/t_cat_callables.py       |  350 +++++
 .../nipype/afni/t_cat_sub_brick_callables.py  |  458 ++++++
 .../task/nipype/afni/t_corr_1d_callables.py   |  350 +++++
 .../task/nipype/afni/t_corr_map.yaml          |    2 +-
 .../task/nipype/afni/t_corr_map_callables.py  |  434 ++++++
 .../task/nipype/afni/t_correlate_callables.py |  350 +++++
 .../task/nipype/afni/t_norm_callables.py      |  350 +++++
 .../task/nipype/afni/t_project_callables.py   |  350 +++++
 .../task/nipype/afni/t_shift_callables.py     |  354 +++++
 .../task/nipype/afni/t_smooth_callables.py    |  350 +++++
 .../task/nipype/afni/t_stat_callables.py      |  350 +++++
 .../task/nipype/afni/to_3d_callables.py       |  350 +++++
 .../task/nipype/afni/undump_callables.py      |  350 +++++
 .../task/nipype/afni/unifize_callables.py     |  357 +++++
 .../task/nipype/afni/volreg_callables.py      |  371 +++++
 .../task/nipype/afni/warp_callables.py        |  446 ++++++
 .../task/nipype/afni/z_cut_up_callables.py    |  350 +++++
 .../task/nipype/afni/zcat_callables.py        |  350 +++++
 .../task/nipype/afni/zeropad_callables.py     |  350 +++++
 .../ants/affine_initializer_callables.py      |   17 +
 .../task/nipype/ants/ai_callables.py          |   15 +
 .../task/nipype/ants/ants_callables.py        |   57 +
 .../ants/ants_introduction_callables.py       |   71 +
 .../nipype/ants/apply_transforms_callables.py |   89 ++
 .../apply_transforms_to_points_callables.py   |  186 +++
 example-specs/task/nipype/ants/atropos.yaml   |    2 +
 .../task/nipype/ants/atropos_callables.py     |   33 +-
 .../average_affine_transform_callables.py     |   19 +
 .../nipype/ants/average_images_callables.py   |   19 +
 .../nipype/ants/brain_extraction_callables.py |  221 +++
 .../nipype/ants/buildtemplateparallel.yaml    |    4 +
 .../ants/buildtemplateparallel_callables.py   |  114 ++
 .../ants/compose_multi_transform_callables.py |  186 +++
 .../composite_transform_util_callables.py     |   41 +
 .../convert_scalar_image_to_rgb_callables.py  |   19 +
 .../task/nipype/ants/cortical_thickness.yaml  |    2 +
 .../ants/cortical_thickness_callables.py      |  158 ++
 ...te_jacobian_determinant_image_callables.py |   19 +
 .../ants/create_tiled_mosaic_callables.py     |   19 +
 .../nipype/ants/denoise_image_callables.py    |  193 +++
 .../nipype/ants/gen_warp_fields_callables.py  |   71 +
 .../task/nipype/ants/image_math_callables.py  |  186 +++
 .../task/nipype/ants/joint_fusion.yaml        |    6 +
 .../nipype/ants/joint_fusion_callables.py     |   57 +
 .../nipype/ants/kelly_kapowski_callables.py   |  255 ++++
 .../nipype/ants/label_geometry_callables.py   |  186 +++
 .../ants/laplacian_thickness_callables.py     |  186 +++
 .../nipype/ants/measure_image_similarity.yaml |    2 +
 .../measure_image_similarity_callables.py     |  186 +++
 .../nipype/ants/multiply_images_callables.py  |   19 +
 .../n4_bias_field_correction_callables.py     |  202 +++
 .../task/nipype/ants/registration.yaml        |   10 +
 .../nipype/ants/registration_callables.py     |  313 ++++
 .../ants/registration_syn_quick_callables.py  |   54 +
 .../resample_image_by_spacing_callables.py    |  186 +++
 .../nipype/ants/threshold_image_callables.py  |  186 +++
 .../warp_image_multi_transform_callables.py   |   89 ++
 ..._series_image_multi_transform_callables.py |   73 +
 .../add_x_form_to_header_callables.py         |   19 +
 .../freesurfer/aparc_2_aseg_callables.py      |   19 +
 .../freesurfer/apas_2_aseg_callables.py       |   19 +
 .../nipype/freesurfer/apply_mask_callables.py |  186 +++
 .../apply_vol_transform_callables.py          |  137 ++
 .../freesurfer/bb_register_callables.py       |  199 +++
 .../nipype/freesurfer/binarize_callables.py   |  153 ++
 .../nipype/freesurfer/ca_label_callables.py   |   19 +
 .../freesurfer/ca_normalize_callables.py      |   27 +
 .../freesurfer/ca_register_callables.py       |   23 +
 .../check_talairach_alignment_callables.py    |   17 +
 .../freesurfer/concatenate_callables.py       |   32 +
 .../freesurfer/concatenate_lta_callables.py   |  186 +++
 .../nipype/freesurfer/contrast_callables.py   |   40 +
 .../nipype/freesurfer/curvature_callables.py  |   31 +
 .../freesurfer/curvature_stats_callables.py   |   19 +
 .../freesurfer/dicom_convert_callables.py     |  178 +++
 .../freesurfer/edit_w_mwith_aseg_callables.py |   19 +
 .../freesurfer/em_register_callables.py       |   19 +
 .../task/nipype/freesurfer/euler_number.yaml  |    4 +
 .../freesurfer/euler_number_callables.py      |   25 +
 .../extract_main_component_callables.py       |  186 +++
 .../freesurfer/fit_ms_params_callables.py     |   20 +-
 .../freesurfer/fix_topology_callables.py      |   19 +
 .../fuse_segmentations_callables.py           |   19 +
 .../nipype/freesurfer/glm_fit_callables.py    |  260 ++++
 .../nipype/freesurfer/gtm_seg_callables.py    |   24 +
 .../nipype/freesurfer/gtmpvc_callables.py     |  202 +++
 .../task/nipype/freesurfer/image_info.yaml    |   20 +
 .../nipype/freesurfer/image_info_callables.py |  256 ++++
 .../nipype/freesurfer/jacobian_callables.py   |   19 +
 .../freesurfer/label_2_annot_callables.py     |   24 +
 .../freesurfer/label_2_label_callables.py     |   24 +
 .../freesurfer/label_2_vol_callables.py       |  134 ++
 .../nipype/freesurfer/logan_ref_callables.py  |  260 ++++
 .../freesurfer/lta_convert_callables.py       |   58 +
 .../freesurfer/make_average_subject.yaml      |    2 +
 .../make_average_subject_callables.py         |   17 +
 .../freesurfer/make_surfaces_callables.py     |   79 +
 .../mni_bias_correction_callables.py          |  186 +++
 .../freesurfer/mp_rto_mni305_callables.py     |  104 ++
 .../freesurfer/mr_is_ca_label_callables.py    |   22 +
 .../nipype/freesurfer/mr_is_calc_callables.py |   19 +
 .../freesurfer/mr_is_combine_callables.py     |   31 +
 .../freesurfer/mr_is_convert_callables.py     |    6 +-
 .../freesurfer/mr_is_expand_callables.py      |   45 +
 .../freesurfer/mr_is_inflate_callables.py     |   29 +
 .../task/nipype/freesurfer/mri_convert.yaml   |    9 +-
 .../freesurfer/mri_convert_callables.py       |   13 +-
 .../nipype/freesurfer/mri_coreg_callables.py  |   52 +
 .../nipype/freesurfer/mri_fill_callables.py   |   29 +
 .../mri_marching_cubes_callables.py           |    6 +-
 .../freesurfer/mri_pretess_callables.py       |  186 +++
 .../freesurfer/mri_tessellate_callables.py    |    6 +-
 .../freesurfer/mris_preproc_callables.py      |   33 +
 .../mris_preproc_recon_all_callables.py       |   33 +
 .../task/nipype/freesurfer/mrtm2_callables.py |  260 ++++
 .../task/nipype/freesurfer/mrtm_callables.py  |  260 ++++
 .../nipype/freesurfer/ms__lda_callables.py    |   32 +
 .../nipype/freesurfer/normalize_callables.py  |   19 +
 .../freesurfer/one_sample_t_test_callables.py |  260 ++++
 .../task/nipype/freesurfer/paint_callables.py |   19 +
 .../parcellation_stats_callables.py           |   87 ++
 .../freesurfer/parse_dicom_dir_callables.py   |   21 +
 .../task/nipype/freesurfer/recon_all.yaml     |   55 +
 .../nipype/freesurfer/recon_all_callables.py  |  319 +++++
 .../register_av_ito_talairach_callables.py    |   26 +
 .../nipype/freesurfer/register_callables.py   |   31 +
 .../relabel_hypointensities_callables.py      |   19 +
 .../remove_intersection_callables.py          |   19 +
 .../freesurfer/remove_neck_callables.py       |   19 +
 .../nipype/freesurfer/resample_callables.py   |  132 ++
 .../freesurfer/robust_register_callables.py   |  184 +++
 .../nipype/freesurfer/robust_template.yaml    |    6 +
 .../freesurfer/robust_template_callables.py   |   46 +
 .../freesurfer/sample_to_surface_callables.py |  204 +++
 .../nipype/freesurfer/seg_stats_callables.py  |  165 +++
 .../seg_stats_recon_all_callables.py          |  165 +++
 .../nipype/freesurfer/segment_cc_callables.py |   27 +
 .../nipype/freesurfer/segment_wm_callables.py |   19 +
 .../nipype/freesurfer/smooth_callables.py     |  166 +++
 .../smooth_tessellation_callables.py          |   22 +-
 .../nipype/freesurfer/sphere_callables.py     |   19 +
 .../freesurfer/spherical_average_callables.py |    6 +-
 .../surface_2_vol_transform_callables.py      |  193 +++
 .../freesurfer/surface_smooth_callables.py    |  129 ++
 .../nipype/freesurfer/surface_snapshots.yaml  |    2 +
 .../freesurfer/surface_snapshots_callables.py |   11 +-
 .../freesurfer/surface_transform_callables.py |  185 +++
 .../freesurfer/synthesize_flash_callables.py  |  166 +++
 .../freesurfer/talairach_avi_callables.py     |   38 +
 .../freesurfer/talairach_qc_callables.py      |   19 +
 .../freesurfer/tkregister_2_callables.py      |  147 ++
 .../freesurfer/unpack_sdicom_dir_callables.py |  178 +++
 .../freesurfer/volume_mask_callables.py       |   37 +
 .../watershed_skull_strip_callables.py        |   19 +
 .../nipype/fsl/accuracy_tester_callables.py   |   24 +
 .../task/nipype/fsl/apply_mask_callables.py   |  283 ++++
 .../task/nipype/fsl/apply_topup_callables.py  |  282 ++++
 .../task/nipype/fsl/apply_warp_callables.py   |  283 ++++
 .../task/nipype/fsl/apply_xfm_callables.py    |  296 ++++
 .../task/nipype/fsl/ar1_image_callables.py    |  283 ++++
 example-specs/task/nipype/fsl/av_scale.yaml   |    6 +
 .../task/nipype/fsl/av_scale_callables.py     |   78 +
 .../task/nipype/fsl/b0_calc_callables.py      |  282 ++++
 example-specs/task/nipype/fsl/bedpostx5.yaml  |   16 +
 .../task/nipype/fsl/bedpostx5_callables.py    |  435 ++++++
 .../task/nipype/fsl/bet_callables.py          |  477 +++++++
 .../task/nipype/fsl/binary_maths_callables.py |  283 ++++
 .../nipype/fsl/change_data_type_callables.py  |  283 ++++
 .../task/nipype/fsl/classifier_callables.py   |   38 +
 .../task/nipype/fsl/cleaner_callables.py      |   38 +
 .../task/nipype/fsl/cluster_callables.py      |  333 +++++
 .../task/nipype/fsl/complex_callables.py      |  417 ++++++
 .../task/nipype/fsl/contrast_mgr.yaml         |   14 +
 .../task/nipype/fsl/contrast_mgr_callables.py |  421 ++++++
 .../task/nipype/fsl/convert_warp_callables.py |  282 ++++
 .../task/nipype/fsl/convert_xfm_callables.py  |  141 ++
 .../task/nipype/fsl/copy_geom_callables.py    |  282 ++++
 .../task/nipype/fsl/dilate_image_callables.py |  283 ++++
 .../task/nipype/fsl/distance_map_callables.py |  141 ++
 .../task/nipype/fsl/dti_fit_callables.py      |  361 +++++
 .../nipype/fsl/dual_regression_callables.py   |   34 +
 .../task/nipype/fsl/eddy_callables.py         |  182 +++
 .../task/nipype/fsl/eddy_correct_callables.py |  282 ++++
 example-specs/task/nipype/fsl/eddy_quad.yaml  |    6 +
 .../task/nipype/fsl/eddy_quad_callables.py    |  107 ++
 .../task/nipype/fsl/epi_de_warp_callables.py  |  244 ++--
 .../task/nipype/fsl/epi_reg_callables.py      |  144 ++
 .../task/nipype/fsl/erode_image_callables.py  |  283 ++++
 .../task/nipype/fsl/extract_roi_callables.py  |  299 ++++
 example-specs/task/nipype/fsl/fast.yaml       |   11 +
 .../task/nipype/fsl/fast_callables.py         |  500 +++++++
 .../task/nipype/fsl/feat_callables.py         |   39 +
 .../task/nipype/fsl/feat_model_callables.py   |  160 +++
 .../nipype/fsl/feature_extractor_callables.py |   17 +
 example-specs/task/nipype/fsl/filmgls.yaml    |   14 +
 .../task/nipype/fsl/filmgls_callables.py      |  526 +++++++
 .../nipype/fsl/filter_regressor_callables.py  |  283 ++++
 .../nipype/fsl/find_the_biggest_callables.py  |  284 ++++
 example-specs/task/nipype/fsl/first.yaml      |    4 +
 .../task/nipype/fsl/first_callables.py        |  181 +++
 example-specs/task/nipype/fsl/flameo.yaml     |   22 +
 .../task/nipype/fsl/flameo_callables.py       |  163 +++
 .../task/nipype/fsl/flirt_callables.py        |  296 ++++
 example-specs/task/nipype/fsl/fnirt.yaml      |    3 +
 .../task/nipype/fsl/fnirt_callables.py        |  778 ++++++++++
 .../task/nipype/fsl/fugue_callables.py        |  303 ++++
 example-specs/task/nipype/fsl/glm.yaml        |   23 +
 .../task/nipype/fsl/glm_callables.py          |  400 ++++++
 .../task/nipype/fsl/ica__aroma_callables.py   |   43 +
 .../task/nipype/fsl/image_maths_callables.py  |  286 ++++
 .../task/nipype/fsl/image_meants_callables.py |  285 ++++
 .../task/nipype/fsl/image_stats.yaml          |    2 +
 .../task/nipype/fsl/image_stats_callables.py  |  282 ++++
 .../task/nipype/fsl/inv_warp_callables.py     |  282 ++++
 .../nipype/fsl/isotropic_smooth_callables.py  |  283 ++++
 .../task/nipype/fsl/l2_model_callables.py     |   27 +
 .../task/nipype/fsl/level_1_design.yaml       |    2 +
 .../nipype/fsl/level_1_design_callables.py    |   20 +
 .../fsl/make_dyadic_vectors_callables.py      |  286 ++++
 .../nipype/fsl/maths_command_callables.py     |  283 ++++
 .../task/nipype/fsl/max_image_callables.py    |  283 ++++
 .../task/nipype/fsl/maxn_image_callables.py   |  283 ++++
 example-specs/task/nipype/fsl/mcflirt.yaml    |    4 +
 .../task/nipype/fsl/mcflirt_callables.py      |  418 ++++++
 .../task/nipype/fsl/mean_image_callables.py   |  283 ++++
 .../task/nipype/fsl/median_image_callables.py |  283 ++++
 .../task/nipype/fsl/melodic_callables.py      |   43 +
 .../task/nipype/fsl/merge_callables.py        |  282 ++++
 .../task/nipype/fsl/min_image_callables.py    |  283 ++++
 .../nipype/fsl/motion_outliers_callables.py   |  296 ++++
 .../nipype/fsl/multi_image_maths_callables.py |  283 ++++
 .../fsl/multiple_regress_design_callables.py  |   34 +
 .../task/nipype/fsl/overlay_callables.py      |  343 +++++
 .../nipype/fsl/percentile_image_callables.py  |  283 ++++
 .../fsl/plot_motion_params_callables.py       |  129 ++
 .../nipype/fsl/plot_time_series_callables.py  |  287 ++++
 .../nipype/fsl/power_spectrum_callables.py    |  291 ++++
 .../task/nipype/fsl/prelude_callables.py      |  293 ++++
 .../nipype/fsl/prepare_fieldmap_callables.py  |   17 +
 .../task/nipype/fsl/prob_track_x.yaml         |    6 +
 .../task/nipype/fsl/prob_track_x2.yaml        |    6 +
 .../nipype/fsl/prob_track_x2_callables.py     | 1266 ++++-------------
 .../task/nipype/fsl/prob_track_x_callables.py |  229 ++-
 .../task/nipype/fsl/proj_thresh.yaml          |    2 +
 .../task/nipype/fsl/proj_thresh_callables.py  |  277 ++++
 example-specs/task/nipype/fsl/randomise.yaml  |   12 +
 .../task/nipype/fsl/randomise_callables.py    |  363 +++++
 .../nipype/fsl/reorient_2_std_callables.py    |  287 ++++
 .../task/nipype/fsl/robust_fov_callables.py   |  289 ++++
 .../task/nipype/fsl/sig_loss_callables.py     |  282 ++++
 example-specs/task/nipype/fsl/slice.yaml      |    2 +
 .../task/nipype/fsl/slice_callables.py        |  137 ++
 .../task/nipype/fsl/slice_timer_callables.py  |  100 +-
 .../task/nipype/fsl/slicer_callables.py       |  283 ++++
 .../task/nipype/fsl/smm_callables.py          |  306 ++++
 .../task/nipype/fsl/smooth_callables.py       |  282 ++++
 .../task/nipype/fsl/smooth_estimate.yaml      |    6 +
 .../nipype/fsl/smooth_estimate_callables.py   |  296 ++++
 .../nipype/fsl/spatial_filter_callables.py    |  283 ++++
 example-specs/task/nipype/fsl/split.yaml      |    2 +
 .../task/nipype/fsl/split_callables.py        |   40 +
 .../task/nipype/fsl/std_image_callables.py    |  283 ++++
 .../task/nipype/fsl/susan_callables.py        |  100 +-
 .../nipype/fsl/swap_dimensions_callables.py   |  283 ++++
 .../nipype/fsl/temporal_filter_callables.py   |  283 ++++
 .../task/nipype/fsl/text_2_vest_callables.py  |  282 ++++
 .../task/nipype/fsl/threshold_callables.py    |  283 ++++
 example-specs/task/nipype/fsl/topup.yaml      |    6 +
 .../task/nipype/fsl/topup_callables.py        |  603 ++++++++
 .../nipype/fsl/tract_skeleton_callables.py    |  135 ++
 .../task/nipype/fsl/training_callables.py     |   25 +
 .../task/nipype/fsl/training_set_creator.yaml |    2 +
 .../fsl/training_set_creator_callables.py     |   13 +
 .../task/nipype/fsl/unary_maths_callables.py  |  290 ++++
 .../task/nipype/fsl/vec_reg_callables.py      |  286 ++++
 .../task/nipype/fsl/vest_2_text_callables.py  |  282 ++++
 .../task/nipype/fsl/warp_points_callables.py  |  187 +++
 .../fsl/warp_points_from_std_callables.py     |   19 +
 .../fsl/warp_points_to_std_callables.py       |  187 +++
 .../task/nipype/fsl/warp_utils_callables.py   |  289 ++++
 example-specs/task/nipype/fsl/x_fibres_5.yaml |   10 +
 .../task/nipype/fsl/x_fibres_5_callables.py   |  400 ++++++
 nipype2pydra/pkg_gen/__init__.py              |  188 ++-
 nipype2pydra/task/base.py                     |    9 +-
 nipype2pydra/task/tests/test_task.py          |   11 +-
 nipype2pydra/utils.py                         |  199 ++-
 359 files changed, 61446 insertions(+), 1592 deletions(-)

diff --git a/example-specs/task/nipype/afni/a_boverlap_callables.py b/example-specs/task/nipype/afni/a_boverlap_callables.py
index 225b2f40..fd07d144 100644
--- a/example-specs/task/nipype/afni/a_boverlap_callables.py
+++ b/example-specs/task/nipype/afni/a_boverlap_callables.py
@@ -1 +1,351 @@
 """Module to put any functions that are referred to in the "callables" section of ABoverlap.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def nipype_interfaces_afni__AFNICommandBase___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """Handle afni output type and version information."""
+
+    __outputtype = "AFNI"
+    ftypes = {"NIFTI": ".nii", "AFNI": "", "NIFTI_GZ": ".nii.gz"}
+    version_cmd = "afni --version"
+
+    @staticmethod
+    def parse_version(raw_info):
+        """Check and parse AFNI's version."""
+        version_stamp = raw_info.split("\n")[0].split("Version ")[1]
+        if version_stamp.startswith("AFNI"):
+            version_stamp = version_stamp.split("AFNI_")[1]
+        elif version_stamp.startswith("Debian"):
+            version_stamp = version_stamp.split("Debian-")[1].split("~")[0]
+        else:
+            return None
+
+        version = LooseVersion(version_stamp.replace("_", ".")).version[:3]
+        if version[0] < 1000:
+            version[0] = version[0] + 2000
+        return tuple(version)
+
+    @classmethod
+    def output_type_to_ext(cls, outputtype):
+        """
+        Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        outputtype : {'NIFTI', 'NIFTI_GZ', 'AFNI'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+
+        """
+        try:
+            return cls.ftypes[outputtype]
+        except KeyError as e:
+            msg = "Invalid AFNIOUTPUTTYPE: ", outputtype
+            raise KeyError(msg) from e
+
+    @classmethod
+    def outputtype(cls):
+        """
+        Set default output filetype.
+
+        AFNI has no environment variables, Output filetypes get set in command line calls
+        Nipype uses ``AFNI`` as default
+
+
+        Returns
+        -------
+        None
+
+        """
+        return "AFNI"
+
+    @staticmethod
+    def standard_image(img_name):
+        """
+        Grab an image from the standard location.
+
+        Could be made more fancy to allow for more relocatability
+
+        """
+        clout = CommandLine(
+            "which afni",
+            ignore_exception=True,
+            resource_monitor=False,
+            terminal_output="allatonce",
+        ).run()
+        if clout.runtime.returncode != 0:
+            return None
+
+        out = clout.runtime.stdout
+        basedir = os.path.split(out)[0]
+        return os.path.join(basedir, img_name)
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
diff --git a/example-specs/task/nipype/afni/afn_ito_nifti_callables.py b/example-specs/task/nipype/afni/afn_ito_nifti_callables.py
index 9bcbc388..178875c1 100644
--- a/example-specs/task/nipype/afni/afn_ito_nifti_callables.py
+++ b/example-specs/task/nipype/afni/afn_ito_nifti_callables.py
@@ -1 +1,326 @@
 """Module to put any functions that are referred to in the "callables" section of AFNItoNIFTI.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def nipype_interfaces_afni__AFNICommand___gen_filename(
+    name, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    raise NotImplementedError
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def nipype_interfaces_afni__AFNICommandBase___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, ext = split_filename(value)
+    if ext.lower() not in [".nii", ".nii.gz", ".1d", ".1D"]:
+        ext += ".nii"
+    return os.path.join(path, base + ext)
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    return os.path.abspath(nipype_interfaces_afni__AFNICommand___gen_filename(name))
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
diff --git a/example-specs/task/nipype/afni/align_epi_anat_py_callables.py b/example-specs/task/nipype/afni/align_epi_anat_py_callables.py
index f997535d..5c90be59 100644
--- a/example-specs/task/nipype/afni/align_epi_anat_py_callables.py
+++ b/example-specs/task/nipype/afni/align_epi_anat_py_callables.py
@@ -1 +1,421 @@
 """Module to put any functions that are referred to in the "callables" section of AlignEpiAnatPy.yaml"""
+
+import os
+import os.path as op
+
+
+def anat_al_orig_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["anat_al_orig"]
+
+
+def epi_al_orig_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["epi_al_orig"]
+
+
+def epi_tlrc_al_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["epi_tlrc_al"]
+
+
+def anat_al_mat_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["anat_al_mat"]
+
+
+def epi_al_mat_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["epi_al_mat"]
+
+
+def epi_vr_al_mat_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["epi_vr_al_mat"]
+
+
+def epi_reg_al_mat_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["epi_reg_al_mat"]
+
+
+def epi_al_tlrc_mat_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["epi_al_tlrc_mat"]
+
+
+def epi_vr_motion_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["epi_vr_motion"]
+
+
+def skullstrip_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["skullstrip"]
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """Handle afni output type and version information."""
+
+    __outputtype = "AFNI"
+    ftypes = {"NIFTI": ".nii", "AFNI": "", "NIFTI_GZ": ".nii.gz"}
+    version_cmd = "afni --version"
+
+    @staticmethod
+    def parse_version(raw_info):
+        """Check and parse AFNI's version."""
+        version_stamp = raw_info.split("\n")[0].split("Version ")[1]
+        if version_stamp.startswith("AFNI"):
+            version_stamp = version_stamp.split("AFNI_")[1]
+        elif version_stamp.startswith("Debian"):
+            version_stamp = version_stamp.split("Debian-")[1].split("~")[0]
+        else:
+            return None
+
+        version = LooseVersion(version_stamp.replace("_", ".")).version[:3]
+        if version[0] < 1000:
+            version[0] = version[0] + 2000
+        return tuple(version)
+
+    @classmethod
+    def output_type_to_ext(cls, outputtype):
+        """
+        Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        outputtype : {'NIFTI', 'NIFTI_GZ', 'AFNI'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+
+        """
+        try:
+            return cls.ftypes[outputtype]
+        except KeyError as e:
+            msg = "Invalid AFNIOUTPUTTYPE: ", outputtype
+            raise KeyError(msg) from e
+
+    @classmethod
+    def outputtype(cls):
+        """
+        Set default output filetype.
+
+        AFNI has no environment variables, Output filetypes get set in command line calls
+        Nipype uses ``AFNI`` as default
+
+
+        Returns
+        -------
+        None
+
+        """
+        return "AFNI"
+
+    @staticmethod
+    def standard_image(img_name):
+        """
+        Grab an image from the standard location.
+
+        Could be made more fancy to allow for more relocatability
+
+        """
+        clout = CommandLine(
+            "which afni",
+            ignore_exception=True,
+            resource_monitor=False,
+            terminal_output="allatonce",
+        ).run()
+        if clout.runtime.returncode != 0:
+            return None
+
+        out = clout.runtime.stdout
+        basedir = os.path.split(out)[0]
+        return os.path.join(basedir, img_name)
+
+
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """
+    Generate a filename based on the given parameters.
+
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
+
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
+
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+    if not basename:
+        msg = "Unable to generate filename for command %s. " % "align_epi_anat.py"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.outputtype)
+    if change_ext:
+        suffix = "".join((suffix, ext)) if suffix else ext
+
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    anat_prefix = _gen_fname(
+        inputs.anat, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+    )
+    epi_prefix = _gen_fname(
+        inputs.in_file,
+        inputs=inputs,
+        stdout=stdout,
+        stderr=stderr,
+        output_dir=output_dir,
+    )
+    if "+" in anat_prefix:
+        anat_prefix = "".join(anat_prefix.split("+")[:-1])
+    if "+" in epi_prefix:
+        epi_prefix = "".join(epi_prefix.split("+")[:-1])
+    outputtype = inputs.outputtype
+    if outputtype == "AFNI":
+        ext = ".HEAD"
+    else:
+        ext = Info.output_type_to_ext(outputtype)
+    matext = ".1D"
+    suffix = inputs.suffix
+    if inputs.anat2epi:
+        outputs["anat_al_orig"] = _gen_fname(
+            anat_prefix,
+            suffix=suffix + "+orig",
+            ext=ext,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+        outputs["anat_al_mat"] = _gen_fname(
+            anat_prefix,
+            suffix=suffix + "_mat.aff12",
+            ext=matext,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    if inputs.epi2anat:
+        outputs["epi_al_orig"] = _gen_fname(
+            epi_prefix,
+            suffix=suffix + "+orig",
+            ext=ext,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+        outputs["epi_al_mat"] = _gen_fname(
+            epi_prefix,
+            suffix=suffix + "_mat.aff12",
+            ext=matext,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    if inputs.volreg == "on":
+        outputs["epi_vr_al_mat"] = _gen_fname(
+            epi_prefix,
+            suffix="_vr" + suffix + "_mat.aff12",
+            ext=matext,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+        if inputs.tshift == "on":
+            outputs["epi_vr_motion"] = _gen_fname(
+                epi_prefix,
+                suffix="tsh_vr_motion",
+                ext=matext,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+        elif inputs.tshift == "off":
+            outputs["epi_vr_motion"] = _gen_fname(
+                epi_prefix,
+                suffix="vr_motion",
+                ext=matext,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    if inputs.volreg == "on" and inputs.epi2anat:
+        outputs["epi_reg_al_mat"] = _gen_fname(
+            epi_prefix,
+            suffix="_reg" + suffix + "_mat.aff12",
+            ext=matext,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    if inputs.save_skullstrip:
+        outputs.skullstrip = _gen_fname(
+            anat_prefix,
+            suffix="_ns" + "+orig",
+            ext=ext,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    return outputs
diff --git a/example-specs/task/nipype/afni/allineate_callables.py b/example-specs/task/nipype/afni/allineate_callables.py
index 53f30a05..b28448db 100644
--- a/example-specs/task/nipype/afni/allineate_callables.py
+++ b/example-specs/task/nipype/afni/allineate_callables.py
@@ -1 +1,551 @@
 """Module to put any functions that are referred to in the "callables" section of Allineate.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+def out_matrix_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_matrix"]
+
+
+def out_param_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_param_file"]
+
+
+def out_weight_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_weight_file"]
+
+
+def allcostx_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["allcostx"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """Handle afni output type and version information."""
+
+    __outputtype = "AFNI"
+    ftypes = {"NIFTI": ".nii", "AFNI": "", "NIFTI_GZ": ".nii.gz"}
+    version_cmd = "afni --version"
+
+    @staticmethod
+    def parse_version(raw_info):
+        """Check and parse AFNI's version."""
+        version_stamp = raw_info.split("\n")[0].split("Version ")[1]
+        if version_stamp.startswith("AFNI"):
+            version_stamp = version_stamp.split("AFNI_")[1]
+        elif version_stamp.startswith("Debian"):
+            version_stamp = version_stamp.split("Debian-")[1].split("~")[0]
+        else:
+            return None
+
+        version = LooseVersion(version_stamp.replace("_", ".")).version[:3]
+        if version[0] < 1000:
+            version[0] = version[0] + 2000
+        return tuple(version)
+
+    @classmethod
+    def output_type_to_ext(cls, outputtype):
+        """
+        Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        outputtype : {'NIFTI', 'NIFTI_GZ', 'AFNI'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+
+        """
+        try:
+            return cls.ftypes[outputtype]
+        except KeyError as e:
+            msg = "Invalid AFNIOUTPUTTYPE: ", outputtype
+            raise KeyError(msg) from e
+
+    @classmethod
+    def outputtype(cls):
+        """
+        Set default output filetype.
+
+        AFNI has no environment variables, Output filetypes get set in command line calls
+        Nipype uses ``AFNI`` as default
+
+
+        Returns
+        -------
+        None
+
+        """
+        return "AFNI"
+
+    @staticmethod
+    def standard_image(img_name):
+        """
+        Grab an image from the standard location.
+
+        Could be made more fancy to allow for more relocatability
+
+        """
+        clout = CommandLine(
+            "which afni",
+            ignore_exception=True,
+            resource_monitor=False,
+            terminal_output="allatonce",
+        ).run()
+        if clout.runtime.returncode != 0:
+            return None
+
+        out = clout.runtime.stdout
+        basedir = os.path.split(out)[0]
+        return os.path.join(basedir, img_name)
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """
+    Generate a filename based on the given parameters.
+
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
+
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
+
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+    if not basename:
+        msg = "Unable to generate filename for command %s. " % "3dAllineate"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.outputtype)
+    if change_ext:
+        suffix = "".join((suffix, ext)) if suffix else ext
+
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def nipype_interfaces_afni__AFNICommandBase___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+
+    if inputs.out_weight_file:
+        outputs["out_weight_file"] = op.abspath(inputs.out_weight_file)
+
+    if inputs.out_matrix:
+        ext = split_filename(inputs.out_matrix)[-1]
+        if ext.lower() not in [".1d", ".1D"]:
+            outputs["out_matrix"] = _gen_fname(
+                inputs.out_matrix,
+                suffix=".aff12.1D",
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+        else:
+            outputs["out_matrix"] = op.abspath(inputs.out_matrix)
+
+    if inputs.out_param_file:
+        ext = split_filename(inputs.out_param_file)[-1]
+        if ext.lower() not in [".1d", ".1D"]:
+            outputs["out_param_file"] = _gen_fname(
+                inputs.out_param_file,
+                suffix=".param.1D",
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+        else:
+            outputs["out_param_file"] = op.abspath(inputs.out_param_file)
+
+    if inputs.allcostx:
+        outputs["allcostX"] = os.path.abspath(inputs.allcostx)
+    return outputs
diff --git a/example-specs/task/nipype/afni/auto_tcorrelate_callables.py b/example-specs/task/nipype/afni/auto_tcorrelate_callables.py
index 334fc735..cc1abafc 100644
--- a/example-specs/task/nipype/afni/auto_tcorrelate_callables.py
+++ b/example-specs/task/nipype/afni/auto_tcorrelate_callables.py
@@ -1 +1,320 @@
 """Module to put any functions that are referred to in the "callables" section of AutoTcorrelate.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, ext = split_filename(value)
+    if ext.lower() not in [".1d", ".1D", ".nii.gz", ".nii"]:
+        ext = ext + ".1D"
+    return os.path.join(path, base + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def nipype_interfaces_afni__AFNICommandBase___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
diff --git a/example-specs/task/nipype/afni/auto_tlrc_callables.py b/example-specs/task/nipype/afni/auto_tlrc_callables.py
index 14ed8753..a308d53d 100644
--- a/example-specs/task/nipype/afni/auto_tlrc_callables.py
+++ b/example-specs/task/nipype/afni/auto_tlrc_callables.py
@@ -1 +1,261 @@
 """Module to put any functions that are referred to in the "callables" section of AutoTLRC.yaml"""
+
+import os
+import os.path as op
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """Handle afni output type and version information."""
+
+    __outputtype = "AFNI"
+    ftypes = {"NIFTI": ".nii", "AFNI": "", "NIFTI_GZ": ".nii.gz"}
+    version_cmd = "afni --version"
+
+    @staticmethod
+    def parse_version(raw_info):
+        """Check and parse AFNI's version."""
+        version_stamp = raw_info.split("\n")[0].split("Version ")[1]
+        if version_stamp.startswith("AFNI"):
+            version_stamp = version_stamp.split("AFNI_")[1]
+        elif version_stamp.startswith("Debian"):
+            version_stamp = version_stamp.split("Debian-")[1].split("~")[0]
+        else:
+            return None
+
+        version = LooseVersion(version_stamp.replace("_", ".")).version[:3]
+        if version[0] < 1000:
+            version[0] = version[0] + 2000
+        return tuple(version)
+
+    @classmethod
+    def output_type_to_ext(cls, outputtype):
+        """
+        Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        outputtype : {'NIFTI', 'NIFTI_GZ', 'AFNI'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+
+        """
+        try:
+            return cls.ftypes[outputtype]
+        except KeyError as e:
+            msg = "Invalid AFNIOUTPUTTYPE: ", outputtype
+            raise KeyError(msg) from e
+
+    @classmethod
+    def outputtype(cls):
+        """
+        Set default output filetype.
+
+        AFNI has no environment variables, Output filetypes get set in command line calls
+        Nipype uses ``AFNI`` as default
+
+
+        Returns
+        -------
+        None
+
+        """
+        return "AFNI"
+
+    @staticmethod
+    def standard_image(img_name):
+        """
+        Grab an image from the standard location.
+
+        Could be made more fancy to allow for more relocatability
+
+        """
+        clout = CommandLine(
+            "which afni",
+            ignore_exception=True,
+            resource_monitor=False,
+            terminal_output="allatonce",
+        ).run()
+        if clout.runtime.returncode != 0:
+            return None
+
+        out = clout.runtime.stdout
+        basedir = os.path.split(out)[0]
+        return os.path.join(basedir, img_name)
+
+
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """
+    Generate a filename based on the given parameters.
+
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
+
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
+
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+    if not basename:
+        msg = "Unable to generate filename for command %s. " % "@auto_tlrc"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.outputtype)
+    if change_ext:
+        suffix = "".join((suffix, ext)) if suffix else ext
+
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    ext = ".HEAD"
+    outputs["out_file"] = os.path.abspath(
+        _gen_fname(
+            inputs.in_file,
+            suffix="+tlrc",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+        + ext
+    )
+    return outputs
diff --git a/example-specs/task/nipype/afni/autobox.yaml b/example-specs/task/nipype/afni/autobox.yaml
index bedc48f1..5393082e 100644
--- a/example-specs/task/nipype/afni/autobox.yaml
+++ b/example-specs/task/nipype/afni/autobox.yaml
@@ -60,6 +60,18 @@ outputs:
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
+    x_max: x_max_callable
+    # type=int: 
+    x_min: x_min_callable
+    # type=int: 
+    y_max: y_max_callable
+    # type=int: 
+    y_min: y_min_callable
+    # type=int: 
+    z_max: z_max_callable
+    # type=int: 
+    z_min: z_min_callable
+    # type=int: 
   templates:
   # dict[str, str] - `output_file_template` values to be provided to output fields
   requirements:
diff --git a/example-specs/task/nipype/afni/autobox_callables.py b/example-specs/task/nipype/afni/autobox_callables.py
index 49efa990..c698a6c1 100644
--- a/example-specs/task/nipype/afni/autobox_callables.py
+++ b/example-specs/task/nipype/afni/autobox_callables.py
@@ -1 +1,393 @@
 """Module to put any functions that are referred to in the "callables" section of Autobox.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+
+
+def x_min_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["x_min"]
+
+
+def x_max_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["x_max"]
+
+
+def y_min_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["y_min"]
+
+
+def y_max_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["y_max"]
+
+
+def z_min_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["z_min"]
+
+
+def z_max_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["z_max"]
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def nipype_interfaces_afni__AFNICommandBase___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """Handle afni output type and version information."""
+
+    __outputtype = "AFNI"
+    ftypes = {"NIFTI": ".nii", "AFNI": "", "NIFTI_GZ": ".nii.gz"}
+    version_cmd = "afni --version"
+
+    @staticmethod
+    def parse_version(raw_info):
+        """Check and parse AFNI's version."""
+        version_stamp = raw_info.split("\n")[0].split("Version ")[1]
+        if version_stamp.startswith("AFNI"):
+            version_stamp = version_stamp.split("AFNI_")[1]
+        elif version_stamp.startswith("Debian"):
+            version_stamp = version_stamp.split("Debian-")[1].split("~")[0]
+        else:
+            return None
+
+        version = LooseVersion(version_stamp.replace("_", ".")).version[:3]
+        if version[0] < 1000:
+            version[0] = version[0] + 2000
+        return tuple(version)
+
+    @classmethod
+    def output_type_to_ext(cls, outputtype):
+        """
+        Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        outputtype : {'NIFTI', 'NIFTI_GZ', 'AFNI'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+
+        """
+        try:
+            return cls.ftypes[outputtype]
+        except KeyError as e:
+            msg = "Invalid AFNIOUTPUTTYPE: ", outputtype
+            raise KeyError(msg) from e
+
+    @classmethod
+    def outputtype(cls):
+        """
+        Set default output filetype.
+
+        AFNI has no environment variables, Output filetypes get set in command line calls
+        Nipype uses ``AFNI`` as default
+
+
+        Returns
+        -------
+        None
+
+        """
+        return "AFNI"
+
+    @staticmethod
+    def standard_image(img_name):
+        """
+        Grab an image from the standard location.
+
+        Could be made more fancy to allow for more relocatability
+
+        """
+        clout = CommandLine(
+            "which afni",
+            ignore_exception=True,
+            resource_monitor=False,
+            terminal_output="allatonce",
+        ).run()
+        if clout.runtime.returncode != 0:
+            return None
+
+        out = clout.runtime.stdout
+        basedir = os.path.split(out)[0]
+        return os.path.join(basedir, img_name)
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
diff --git a/example-specs/task/nipype/afni/automask_callables.py b/example-specs/task/nipype/afni/automask_callables.py
index f5e22de6..130f59a5 100644
--- a/example-specs/task/nipype/afni/automask_callables.py
+++ b/example-specs/task/nipype/afni/automask_callables.py
@@ -1 +1,358 @@
 """Module to put any functions that are referred to in the "callables" section of Automask.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+def brain_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["brain_file"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def nipype_interfaces_afni__AFNICommandBase___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """Handle afni output type and version information."""
+
+    __outputtype = "AFNI"
+    ftypes = {"NIFTI": ".nii", "AFNI": "", "NIFTI_GZ": ".nii.gz"}
+    version_cmd = "afni --version"
+
+    @staticmethod
+    def parse_version(raw_info):
+        """Check and parse AFNI's version."""
+        version_stamp = raw_info.split("\n")[0].split("Version ")[1]
+        if version_stamp.startswith("AFNI"):
+            version_stamp = version_stamp.split("AFNI_")[1]
+        elif version_stamp.startswith("Debian"):
+            version_stamp = version_stamp.split("Debian-")[1].split("~")[0]
+        else:
+            return None
+
+        version = LooseVersion(version_stamp.replace("_", ".")).version[:3]
+        if version[0] < 1000:
+            version[0] = version[0] + 2000
+        return tuple(version)
+
+    @classmethod
+    def output_type_to_ext(cls, outputtype):
+        """
+        Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        outputtype : {'NIFTI', 'NIFTI_GZ', 'AFNI'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+
+        """
+        try:
+            return cls.ftypes[outputtype]
+        except KeyError as e:
+            msg = "Invalid AFNIOUTPUTTYPE: ", outputtype
+            raise KeyError(msg) from e
+
+    @classmethod
+    def outputtype(cls):
+        """
+        Set default output filetype.
+
+        AFNI has no environment variables, Output filetypes get set in command line calls
+        Nipype uses ``AFNI`` as default
+
+
+        Returns
+        -------
+        None
+
+        """
+        return "AFNI"
+
+    @staticmethod
+    def standard_image(img_name):
+        """
+        Grab an image from the standard location.
+
+        Could be made more fancy to allow for more relocatability
+
+        """
+        clout = CommandLine(
+            "which afni",
+            ignore_exception=True,
+            resource_monitor=False,
+            terminal_output="allatonce",
+        ).run()
+        if clout.runtime.returncode != 0:
+            return None
+
+        out = clout.runtime.stdout
+        basedir = os.path.split(out)[0]
+        return os.path.join(basedir, img_name)
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
diff --git a/example-specs/task/nipype/afni/axialize_callables.py b/example-specs/task/nipype/afni/axialize_callables.py
index 35318fb6..10eb0039 100644
--- a/example-specs/task/nipype/afni/axialize_callables.py
+++ b/example-specs/task/nipype/afni/axialize_callables.py
@@ -1 +1,351 @@
 """Module to put any functions that are referred to in the "callables" section of Axialize.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def nipype_interfaces_afni__AFNICommandBase___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """Handle afni output type and version information."""
+
+    __outputtype = "AFNI"
+    ftypes = {"NIFTI": ".nii", "AFNI": "", "NIFTI_GZ": ".nii.gz"}
+    version_cmd = "afni --version"
+
+    @staticmethod
+    def parse_version(raw_info):
+        """Check and parse AFNI's version."""
+        version_stamp = raw_info.split("\n")[0].split("Version ")[1]
+        if version_stamp.startswith("AFNI"):
+            version_stamp = version_stamp.split("AFNI_")[1]
+        elif version_stamp.startswith("Debian"):
+            version_stamp = version_stamp.split("Debian-")[1].split("~")[0]
+        else:
+            return None
+
+        version = LooseVersion(version_stamp.replace("_", ".")).version[:3]
+        if version[0] < 1000:
+            version[0] = version[0] + 2000
+        return tuple(version)
+
+    @classmethod
+    def output_type_to_ext(cls, outputtype):
+        """
+        Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        outputtype : {'NIFTI', 'NIFTI_GZ', 'AFNI'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+
+        """
+        try:
+            return cls.ftypes[outputtype]
+        except KeyError as e:
+            msg = "Invalid AFNIOUTPUTTYPE: ", outputtype
+            raise KeyError(msg) from e
+
+    @classmethod
+    def outputtype(cls):
+        """
+        Set default output filetype.
+
+        AFNI has no environment variables, Output filetypes get set in command line calls
+        Nipype uses ``AFNI`` as default
+
+
+        Returns
+        -------
+        None
+
+        """
+        return "AFNI"
+
+    @staticmethod
+    def standard_image(img_name):
+        """
+        Grab an image from the standard location.
+
+        Could be made more fancy to allow for more relocatability
+
+        """
+        clout = CommandLine(
+            "which afni",
+            ignore_exception=True,
+            resource_monitor=False,
+            terminal_output="allatonce",
+        ).run()
+        if clout.runtime.returncode != 0:
+            return None
+
+        out = clout.runtime.stdout
+        basedir = os.path.split(out)[0]
+        return os.path.join(basedir, img_name)
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
diff --git a/example-specs/task/nipype/afni/bandpass_callables.py b/example-specs/task/nipype/afni/bandpass_callables.py
index e3a526d7..c66e3d13 100644
--- a/example-specs/task/nipype/afni/bandpass_callables.py
+++ b/example-specs/task/nipype/afni/bandpass_callables.py
@@ -1 +1,351 @@
 """Module to put any functions that are referred to in the "callables" section of Bandpass.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def nipype_interfaces_afni__AFNICommandBase___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """Handle afni output type and version information."""
+
+    __outputtype = "AFNI"
+    ftypes = {"NIFTI": ".nii", "AFNI": "", "NIFTI_GZ": ".nii.gz"}
+    version_cmd = "afni --version"
+
+    @staticmethod
+    def parse_version(raw_info):
+        """Check and parse AFNI's version."""
+        version_stamp = raw_info.split("\n")[0].split("Version ")[1]
+        if version_stamp.startswith("AFNI"):
+            version_stamp = version_stamp.split("AFNI_")[1]
+        elif version_stamp.startswith("Debian"):
+            version_stamp = version_stamp.split("Debian-")[1].split("~")[0]
+        else:
+            return None
+
+        version = LooseVersion(version_stamp.replace("_", ".")).version[:3]
+        if version[0] < 1000:
+            version[0] = version[0] + 2000
+        return tuple(version)
+
+    @classmethod
+    def output_type_to_ext(cls, outputtype):
+        """
+        Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        outputtype : {'NIFTI', 'NIFTI_GZ', 'AFNI'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+
+        """
+        try:
+            return cls.ftypes[outputtype]
+        except KeyError as e:
+            msg = "Invalid AFNIOUTPUTTYPE: ", outputtype
+            raise KeyError(msg) from e
+
+    @classmethod
+    def outputtype(cls):
+        """
+        Set default output filetype.
+
+        AFNI has no environment variables, Output filetypes get set in command line calls
+        Nipype uses ``AFNI`` as default
+
+
+        Returns
+        -------
+        None
+
+        """
+        return "AFNI"
+
+    @staticmethod
+    def standard_image(img_name):
+        """
+        Grab an image from the standard location.
+
+        Could be made more fancy to allow for more relocatability
+
+        """
+        clout = CommandLine(
+            "which afni",
+            ignore_exception=True,
+            resource_monitor=False,
+            terminal_output="allatonce",
+        ).run()
+        if clout.runtime.returncode != 0:
+            return None
+
+        out = clout.runtime.stdout
+        basedir = os.path.split(out)[0]
+        return os.path.join(basedir, img_name)
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
diff --git a/example-specs/task/nipype/afni/blur_in_mask_callables.py b/example-specs/task/nipype/afni/blur_in_mask_callables.py
index 43afcd15..a08927eb 100644
--- a/example-specs/task/nipype/afni/blur_in_mask_callables.py
+++ b/example-specs/task/nipype/afni/blur_in_mask_callables.py
@@ -1 +1,351 @@
 """Module to put any functions that are referred to in the "callables" section of BlurInMask.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def nipype_interfaces_afni__AFNICommandBase___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """Handle afni output type and version information."""
+
+    __outputtype = "AFNI"
+    ftypes = {"NIFTI": ".nii", "AFNI": "", "NIFTI_GZ": ".nii.gz"}
+    version_cmd = "afni --version"
+
+    @staticmethod
+    def parse_version(raw_info):
+        """Check and parse AFNI's version."""
+        version_stamp = raw_info.split("\n")[0].split("Version ")[1]
+        if version_stamp.startswith("AFNI"):
+            version_stamp = version_stamp.split("AFNI_")[1]
+        elif version_stamp.startswith("Debian"):
+            version_stamp = version_stamp.split("Debian-")[1].split("~")[0]
+        else:
+            return None
+
+        version = LooseVersion(version_stamp.replace("_", ".")).version[:3]
+        if version[0] < 1000:
+            version[0] = version[0] + 2000
+        return tuple(version)
+
+    @classmethod
+    def output_type_to_ext(cls, outputtype):
+        """
+        Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        outputtype : {'NIFTI', 'NIFTI_GZ', 'AFNI'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+
+        """
+        try:
+            return cls.ftypes[outputtype]
+        except KeyError as e:
+            msg = "Invalid AFNIOUTPUTTYPE: ", outputtype
+            raise KeyError(msg) from e
+
+    @classmethod
+    def outputtype(cls):
+        """
+        Set default output filetype.
+
+        AFNI has no environment variables, Output filetypes get set in command line calls
+        Nipype uses ``AFNI`` as default
+
+
+        Returns
+        -------
+        None
+
+        """
+        return "AFNI"
+
+    @staticmethod
+    def standard_image(img_name):
+        """
+        Grab an image from the standard location.
+
+        Could be made more fancy to allow for more relocatability
+
+        """
+        clout = CommandLine(
+            "which afni",
+            ignore_exception=True,
+            resource_monitor=False,
+            terminal_output="allatonce",
+        ).run()
+        if clout.runtime.returncode != 0:
+            return None
+
+        out = clout.runtime.stdout
+        basedir = os.path.split(out)[0]
+        return os.path.join(basedir, img_name)
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
diff --git a/example-specs/task/nipype/afni/blur_to_fwhm_callables.py b/example-specs/task/nipype/afni/blur_to_fwhm_callables.py
index a83767d7..a3b3e2dc 100644
--- a/example-specs/task/nipype/afni/blur_to_fwhm_callables.py
+++ b/example-specs/task/nipype/afni/blur_to_fwhm_callables.py
@@ -1 +1,351 @@
 """Module to put any functions that are referred to in the "callables" section of BlurToFWHM.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def nipype_interfaces_afni__AFNICommandBase___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """Handle afni output type and version information."""
+
+    __outputtype = "AFNI"
+    ftypes = {"NIFTI": ".nii", "AFNI": "", "NIFTI_GZ": ".nii.gz"}
+    version_cmd = "afni --version"
+
+    @staticmethod
+    def parse_version(raw_info):
+        """Check and parse AFNI's version."""
+        version_stamp = raw_info.split("\n")[0].split("Version ")[1]
+        if version_stamp.startswith("AFNI"):
+            version_stamp = version_stamp.split("AFNI_")[1]
+        elif version_stamp.startswith("Debian"):
+            version_stamp = version_stamp.split("Debian-")[1].split("~")[0]
+        else:
+            return None
+
+        version = LooseVersion(version_stamp.replace("_", ".")).version[:3]
+        if version[0] < 1000:
+            version[0] = version[0] + 2000
+        return tuple(version)
+
+    @classmethod
+    def output_type_to_ext(cls, outputtype):
+        """
+        Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        outputtype : {'NIFTI', 'NIFTI_GZ', 'AFNI'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+
+        """
+        try:
+            return cls.ftypes[outputtype]
+        except KeyError as e:
+            msg = "Invalid AFNIOUTPUTTYPE: ", outputtype
+            raise KeyError(msg) from e
+
+    @classmethod
+    def outputtype(cls):
+        """
+        Set default output filetype.
+
+        AFNI has no environment variables, Output filetypes get set in command line calls
+        Nipype uses ``AFNI`` as default
+
+
+        Returns
+        -------
+        None
+
+        """
+        return "AFNI"
+
+    @staticmethod
+    def standard_image(img_name):
+        """
+        Grab an image from the standard location.
+
+        Could be made more fancy to allow for more relocatability
+
+        """
+        clout = CommandLine(
+            "which afni",
+            ignore_exception=True,
+            resource_monitor=False,
+            terminal_output="allatonce",
+        ).run()
+        if clout.runtime.returncode != 0:
+            return None
+
+        out = clout.runtime.stdout
+        basedir = os.path.split(out)[0]
+        return os.path.join(basedir, img_name)
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
diff --git a/example-specs/task/nipype/afni/brick_stat.yaml b/example-specs/task/nipype/afni/brick_stat.yaml
index bbf57a2c..6675ed50 100644
--- a/example-specs/task/nipype/afni/brick_stat.yaml
+++ b/example-specs/task/nipype/afni/brick_stat.yaml
@@ -57,6 +57,8 @@ outputs:
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
+    min_val: min_val_callable
+    # type=float: output
   templates:
   # dict[str, str] - `output_file_template` values to be provided to output fields
   requirements:
diff --git a/example-specs/task/nipype/afni/brick_stat_callables.py b/example-specs/task/nipype/afni/brick_stat_callables.py
index f2f4b2eb..68498b74 100644
--- a/example-specs/task/nipype/afni/brick_stat_callables.py
+++ b/example-specs/task/nipype/afni/brick_stat_callables.py
@@ -1 +1,187 @@
 """Module to put any functions that are referred to in the "callables" section of BrickStat.yaml"""
+
+import os
+import os.path as op
+import attrs
+import logging
+
+
+def min_val_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["min_val"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
diff --git a/example-specs/task/nipype/afni/bucket_callables.py b/example-specs/task/nipype/afni/bucket_callables.py
index c41ffcd8..cd06e4a0 100644
--- a/example-specs/task/nipype/afni/bucket_callables.py
+++ b/example-specs/task/nipype/afni/bucket_callables.py
@@ -1 +1,351 @@
 """Module to put any functions that are referred to in the "callables" section of Bucket.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def nipype_interfaces_afni__AFNICommandBase___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """Handle afni output type and version information."""
+
+    __outputtype = "AFNI"
+    ftypes = {"NIFTI": ".nii", "AFNI": "", "NIFTI_GZ": ".nii.gz"}
+    version_cmd = "afni --version"
+
+    @staticmethod
+    def parse_version(raw_info):
+        """Check and parse AFNI's version."""
+        version_stamp = raw_info.split("\n")[0].split("Version ")[1]
+        if version_stamp.startswith("AFNI"):
+            version_stamp = version_stamp.split("AFNI_")[1]
+        elif version_stamp.startswith("Debian"):
+            version_stamp = version_stamp.split("Debian-")[1].split("~")[0]
+        else:
+            return None
+
+        version = LooseVersion(version_stamp.replace("_", ".")).version[:3]
+        if version[0] < 1000:
+            version[0] = version[0] + 2000
+        return tuple(version)
+
+    @classmethod
+    def output_type_to_ext(cls, outputtype):
+        """
+        Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        outputtype : {'NIFTI', 'NIFTI_GZ', 'AFNI'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+
+        """
+        try:
+            return cls.ftypes[outputtype]
+        except KeyError as e:
+            msg = "Invalid AFNIOUTPUTTYPE: ", outputtype
+            raise KeyError(msg) from e
+
+    @classmethod
+    def outputtype(cls):
+        """
+        Set default output filetype.
+
+        AFNI has no environment variables, Output filetypes get set in command line calls
+        Nipype uses ``AFNI`` as default
+
+
+        Returns
+        -------
+        None
+
+        """
+        return "AFNI"
+
+    @staticmethod
+    def standard_image(img_name):
+        """
+        Grab an image from the standard location.
+
+        Could be made more fancy to allow for more relocatability
+
+        """
+        clout = CommandLine(
+            "which afni",
+            ignore_exception=True,
+            resource_monitor=False,
+            terminal_output="allatonce",
+        ).run()
+        if clout.runtime.returncode != 0:
+            return None
+
+        out = clout.runtime.stdout
+        basedir = os.path.split(out)[0]
+        return os.path.join(basedir, img_name)
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
diff --git a/example-specs/task/nipype/afni/calc_callables.py b/example-specs/task/nipype/afni/calc_callables.py
index 7570d10b..6ef9e409 100644
--- a/example-specs/task/nipype/afni/calc_callables.py
+++ b/example-specs/task/nipype/afni/calc_callables.py
@@ -1 +1,351 @@
 """Module to put any functions that are referred to in the "callables" section of Calc.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def nipype_interfaces_afni__AFNICommandBase___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """Handle afni output type and version information."""
+
+    __outputtype = "AFNI"
+    ftypes = {"NIFTI": ".nii", "AFNI": "", "NIFTI_GZ": ".nii.gz"}
+    version_cmd = "afni --version"
+
+    @staticmethod
+    def parse_version(raw_info):
+        """Check and parse AFNI's version."""
+        version_stamp = raw_info.split("\n")[0].split("Version ")[1]
+        if version_stamp.startswith("AFNI"):
+            version_stamp = version_stamp.split("AFNI_")[1]
+        elif version_stamp.startswith("Debian"):
+            version_stamp = version_stamp.split("Debian-")[1].split("~")[0]
+        else:
+            return None
+
+        version = LooseVersion(version_stamp.replace("_", ".")).version[:3]
+        if version[0] < 1000:
+            version[0] = version[0] + 2000
+        return tuple(version)
+
+    @classmethod
+    def output_type_to_ext(cls, outputtype):
+        """
+        Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        outputtype : {'NIFTI', 'NIFTI_GZ', 'AFNI'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+
+        """
+        try:
+            return cls.ftypes[outputtype]
+        except KeyError as e:
+            msg = "Invalid AFNIOUTPUTTYPE: ", outputtype
+            raise KeyError(msg) from e
+
+    @classmethod
+    def outputtype(cls):
+        """
+        Set default output filetype.
+
+        AFNI has no environment variables, Output filetypes get set in command line calls
+        Nipype uses ``AFNI`` as default
+
+
+        Returns
+        -------
+        None
+
+        """
+        return "AFNI"
+
+    @staticmethod
+    def standard_image(img_name):
+        """
+        Grab an image from the standard location.
+
+        Could be made more fancy to allow for more relocatability
+
+        """
+        clout = CommandLine(
+            "which afni",
+            ignore_exception=True,
+            resource_monitor=False,
+            terminal_output="allatonce",
+        ).run()
+        if clout.runtime.returncode != 0:
+            return None
+
+        out = clout.runtime.stdout
+        basedir = os.path.split(out)[0]
+        return os.path.join(basedir, img_name)
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
diff --git a/example-specs/task/nipype/afni/cat_callables.py b/example-specs/task/nipype/afni/cat_callables.py
index 8935f1f3..e2691aac 100644
--- a/example-specs/task/nipype/afni/cat_callables.py
+++ b/example-specs/task/nipype/afni/cat_callables.py
@@ -1 +1,351 @@
 """Module to put any functions that are referred to in the "callables" section of Cat.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def nipype_interfaces_afni__AFNICommandBase___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """Handle afni output type and version information."""
+
+    __outputtype = "AFNI"
+    ftypes = {"NIFTI": ".nii", "AFNI": "", "NIFTI_GZ": ".nii.gz"}
+    version_cmd = "afni --version"
+
+    @staticmethod
+    def parse_version(raw_info):
+        """Check and parse AFNI's version."""
+        version_stamp = raw_info.split("\n")[0].split("Version ")[1]
+        if version_stamp.startswith("AFNI"):
+            version_stamp = version_stamp.split("AFNI_")[1]
+        elif version_stamp.startswith("Debian"):
+            version_stamp = version_stamp.split("Debian-")[1].split("~")[0]
+        else:
+            return None
+
+        version = LooseVersion(version_stamp.replace("_", ".")).version[:3]
+        if version[0] < 1000:
+            version[0] = version[0] + 2000
+        return tuple(version)
+
+    @classmethod
+    def output_type_to_ext(cls, outputtype):
+        """
+        Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        outputtype : {'NIFTI', 'NIFTI_GZ', 'AFNI'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+
+        """
+        try:
+            return cls.ftypes[outputtype]
+        except KeyError as e:
+            msg = "Invalid AFNIOUTPUTTYPE: ", outputtype
+            raise KeyError(msg) from e
+
+    @classmethod
+    def outputtype(cls):
+        """
+        Set default output filetype.
+
+        AFNI has no environment variables, Output filetypes get set in command line calls
+        Nipype uses ``AFNI`` as default
+
+
+        Returns
+        -------
+        None
+
+        """
+        return "AFNI"
+
+    @staticmethod
+    def standard_image(img_name):
+        """
+        Grab an image from the standard location.
+
+        Could be made more fancy to allow for more relocatability
+
+        """
+        clout = CommandLine(
+            "which afni",
+            ignore_exception=True,
+            resource_monitor=False,
+            terminal_output="allatonce",
+        ).run()
+        if clout.runtime.returncode != 0:
+            return None
+
+        out = clout.runtime.stdout
+        basedir = os.path.split(out)[0]
+        return os.path.join(basedir, img_name)
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
diff --git a/example-specs/task/nipype/afni/cat_matvec_callables.py b/example-specs/task/nipype/afni/cat_matvec_callables.py
index f16b22bb..176000e6 100644
--- a/example-specs/task/nipype/afni/cat_matvec_callables.py
+++ b/example-specs/task/nipype/afni/cat_matvec_callables.py
@@ -1 +1,351 @@
 """Module to put any functions that are referred to in the "callables" section of CatMatvec.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def nipype_interfaces_afni__AFNICommandBase___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """Handle afni output type and version information."""
+
+    __outputtype = "AFNI"
+    ftypes = {"NIFTI": ".nii", "AFNI": "", "NIFTI_GZ": ".nii.gz"}
+    version_cmd = "afni --version"
+
+    @staticmethod
+    def parse_version(raw_info):
+        """Check and parse AFNI's version."""
+        version_stamp = raw_info.split("\n")[0].split("Version ")[1]
+        if version_stamp.startswith("AFNI"):
+            version_stamp = version_stamp.split("AFNI_")[1]
+        elif version_stamp.startswith("Debian"):
+            version_stamp = version_stamp.split("Debian-")[1].split("~")[0]
+        else:
+            return None
+
+        version = LooseVersion(version_stamp.replace("_", ".")).version[:3]
+        if version[0] < 1000:
+            version[0] = version[0] + 2000
+        return tuple(version)
+
+    @classmethod
+    def output_type_to_ext(cls, outputtype):
+        """
+        Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        outputtype : {'NIFTI', 'NIFTI_GZ', 'AFNI'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+
+        """
+        try:
+            return cls.ftypes[outputtype]
+        except KeyError as e:
+            msg = "Invalid AFNIOUTPUTTYPE: ", outputtype
+            raise KeyError(msg) from e
+
+    @classmethod
+    def outputtype(cls):
+        """
+        Set default output filetype.
+
+        AFNI has no environment variables, Output filetypes get set in command line calls
+        Nipype uses ``AFNI`` as default
+
+
+        Returns
+        -------
+        None
+
+        """
+        return "AFNI"
+
+    @staticmethod
+    def standard_image(img_name):
+        """
+        Grab an image from the standard location.
+
+        Could be made more fancy to allow for more relocatability
+
+        """
+        clout = CommandLine(
+            "which afni",
+            ignore_exception=True,
+            resource_monitor=False,
+            terminal_output="allatonce",
+        ).run()
+        if clout.runtime.returncode != 0:
+            return None
+
+        out = clout.runtime.stdout
+        basedir = os.path.split(out)[0]
+        return os.path.join(basedir, img_name)
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
diff --git a/example-specs/task/nipype/afni/center_mass.yaml b/example-specs/task/nipype/afni/center_mass.yaml
index 3d1d972a..a6a758cb 100644
--- a/example-specs/task/nipype/afni/center_mass.yaml
+++ b/example-specs/task/nipype/afni/center_mass.yaml
@@ -88,7 +88,7 @@ tests:
     automask:
     # type=bool|default=False: Generate the mask automatically
     set_cm:
-    # type=tuple|default=(<traits.trait_types.Float object at 0x10b05c8d0>, <traits.trait_types.Float object at 0x10b05c9d0>, <traits.trait_types.Float object at 0x10b05ca50>): After computing the center of mass, set the origin fields in the header so that the center of mass will be at (x,y,z) in DICOM coords.
+    # type=tuple|default=(<traits.trait_types.Float object at 0x10aa84810>, <traits.trait_types.Float object at 0x10aa84910>, <traits.trait_types.Float object at 0x10aa84990>): After computing the center of mass, set the origin fields in the header so that the center of mass will be at (x,y,z) in DICOM coords.
     local_ijk:
     # type=bool|default=False: Output values as (i,j,k) in local orientation
     roi_vals:
diff --git a/example-specs/task/nipype/afni/center_mass_callables.py b/example-specs/task/nipype/afni/center_mass_callables.py
index 4bfd0a6c..fc522168 100644
--- a/example-specs/task/nipype/afni/center_mass_callables.py
+++ b/example-specs/task/nipype/afni/center_mass_callables.py
@@ -1 +1,213 @@
 """Module to put any functions that are referred to in the "callables" section of CenterMass.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+import numpy as np
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+def cm_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["cm_file"]
+
+
+def cm_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["cm"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def nipype_interfaces_afni__AFNICommandBase___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    outputs["out_file"] = os.path.abspath(inputs.in_file)
+    outputs["cm_file"] = os.path.abspath(inputs.cm_file)
+    sout = np.loadtxt(outputs["cm_file"], ndmin=2)
+    outputs["cm"] = [tuple(s) for s in sout]
+    return outputs
diff --git a/example-specs/task/nipype/afni/clip_level.yaml b/example-specs/task/nipype/afni/clip_level.yaml
index f540c7bd..10e029a0 100644
--- a/example-specs/task/nipype/afni/clip_level.yaml
+++ b/example-specs/task/nipype/afni/clip_level.yaml
@@ -55,6 +55,8 @@ outputs:
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
+    clip_val: clip_val_callable
+    # type=float: output
   templates:
   # dict[str, str] - `output_file_template` values to be provided to output fields
   requirements:
diff --git a/example-specs/task/nipype/afni/clip_level_callables.py b/example-specs/task/nipype/afni/clip_level_callables.py
index b091fa95..7b7e5c35 100644
--- a/example-specs/task/nipype/afni/clip_level_callables.py
+++ b/example-specs/task/nipype/afni/clip_level_callables.py
@@ -1 +1,187 @@
 """Module to put any functions that are referred to in the "callables" section of ClipLevel.yaml"""
+
+import os
+import os.path as op
+import attrs
+import logging
+
+
+def clip_val_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["clip_val"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
diff --git a/example-specs/task/nipype/afni/convert_dset_callables.py b/example-specs/task/nipype/afni/convert_dset_callables.py
index df195b27..7b83b67a 100644
--- a/example-specs/task/nipype/afni/convert_dset_callables.py
+++ b/example-specs/task/nipype/afni/convert_dset_callables.py
@@ -1 +1,20 @@
 """Module to put any functions that are referred to in the "callables" section of ConvertDset.yaml"""
+
+import os.path as op
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = op.abspath(inputs.out_file)
+    return outputs
diff --git a/example-specs/task/nipype/afni/copy_callables.py b/example-specs/task/nipype/afni/copy_callables.py
index 720b743f..28aa757c 100644
--- a/example-specs/task/nipype/afni/copy_callables.py
+++ b/example-specs/task/nipype/afni/copy_callables.py
@@ -1 +1,351 @@
 """Module to put any functions that are referred to in the "callables" section of Copy.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def nipype_interfaces_afni__AFNICommandBase___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """Handle afni output type and version information."""
+
+    __outputtype = "AFNI"
+    ftypes = {"NIFTI": ".nii", "AFNI": "", "NIFTI_GZ": ".nii.gz"}
+    version_cmd = "afni --version"
+
+    @staticmethod
+    def parse_version(raw_info):
+        """Check and parse AFNI's version."""
+        version_stamp = raw_info.split("\n")[0].split("Version ")[1]
+        if version_stamp.startswith("AFNI"):
+            version_stamp = version_stamp.split("AFNI_")[1]
+        elif version_stamp.startswith("Debian"):
+            version_stamp = version_stamp.split("Debian-")[1].split("~")[0]
+        else:
+            return None
+
+        version = LooseVersion(version_stamp.replace("_", ".")).version[:3]
+        if version[0] < 1000:
+            version[0] = version[0] + 2000
+        return tuple(version)
+
+    @classmethod
+    def output_type_to_ext(cls, outputtype):
+        """
+        Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        outputtype : {'NIFTI', 'NIFTI_GZ', 'AFNI'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+
+        """
+        try:
+            return cls.ftypes[outputtype]
+        except KeyError as e:
+            msg = "Invalid AFNIOUTPUTTYPE: ", outputtype
+            raise KeyError(msg) from e
+
+    @classmethod
+    def outputtype(cls):
+        """
+        Set default output filetype.
+
+        AFNI has no environment variables, Output filetypes get set in command line calls
+        Nipype uses ``AFNI`` as default
+
+
+        Returns
+        -------
+        None
+
+        """
+        return "AFNI"
+
+    @staticmethod
+    def standard_image(img_name):
+        """
+        Grab an image from the standard location.
+
+        Could be made more fancy to allow for more relocatability
+
+        """
+        clout = CommandLine(
+            "which afni",
+            ignore_exception=True,
+            resource_monitor=False,
+            terminal_output="allatonce",
+        ).run()
+        if clout.runtime.returncode != 0:
+            return None
+
+        out = clout.runtime.stdout
+        basedir = os.path.split(out)[0]
+        return os.path.join(basedir, img_name)
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
diff --git a/example-specs/task/nipype/afni/deconvolve_callables.py b/example-specs/task/nipype/afni/deconvolve_callables.py
index 97883751..71fca94c 100644
--- a/example-specs/task/nipype/afni/deconvolve_callables.py
+++ b/example-specs/task/nipype/afni/deconvolve_callables.py
@@ -1 +1,308 @@
 """Module to put any functions that are referred to in the "callables" section of Deconvolve.yaml"""
+
+import os
+import attrs
+import os.path as op
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+def reml_script_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["reml_script"]
+
+
+def x1D_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["x1D"]
+
+
+def cbucket_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["cbucket"]
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """Handle afni output type and version information."""
+
+    __outputtype = "AFNI"
+    ftypes = {"NIFTI": ".nii", "AFNI": "", "NIFTI_GZ": ".nii.gz"}
+    version_cmd = "afni --version"
+
+    @staticmethod
+    def parse_version(raw_info):
+        """Check and parse AFNI's version."""
+        version_stamp = raw_info.split("\n")[0].split("Version ")[1]
+        if version_stamp.startswith("AFNI"):
+            version_stamp = version_stamp.split("AFNI_")[1]
+        elif version_stamp.startswith("Debian"):
+            version_stamp = version_stamp.split("Debian-")[1].split("~")[0]
+        else:
+            return None
+
+        version = LooseVersion(version_stamp.replace("_", ".")).version[:3]
+        if version[0] < 1000:
+            version[0] = version[0] + 2000
+        return tuple(version)
+
+    @classmethod
+    def output_type_to_ext(cls, outputtype):
+        """
+        Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        outputtype : {'NIFTI', 'NIFTI_GZ', 'AFNI'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+
+        """
+        try:
+            return cls.ftypes[outputtype]
+        except KeyError as e:
+            msg = "Invalid AFNIOUTPUTTYPE: ", outputtype
+            raise KeyError(msg) from e
+
+    @classmethod
+    def outputtype(cls):
+        """
+        Set default output filetype.
+
+        AFNI has no environment variables, Output filetypes get set in command line calls
+        Nipype uses ``AFNI`` as default
+
+
+        Returns
+        -------
+        None
+
+        """
+        return "AFNI"
+
+    @staticmethod
+    def standard_image(img_name):
+        """
+        Grab an image from the standard location.
+
+        Could be made more fancy to allow for more relocatability
+
+        """
+        clout = CommandLine(
+            "which afni",
+            ignore_exception=True,
+            resource_monitor=False,
+            terminal_output="allatonce",
+        ).run()
+        if clout.runtime.returncode != 0:
+            return None
+
+        out = clout.runtime.stdout
+        basedir = os.path.split(out)[0]
+        return os.path.join(basedir, img_name)
+
+
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """
+    Generate a filename based on the given parameters.
+
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
+
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
+
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+    if not basename:
+        msg = "Unable to generate filename for command %s. " % "3dDeconvolve"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.outputtype)
+    if change_ext:
+        suffix = "".join((suffix, ext)) if suffix else ext
+
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+
+    _gen_fname_opts = {}
+    _gen_fname_opts["basename"] = inputs.out_file
+    _gen_fname_opts["cwd"] = output_dir
+
+    if inputs.x1D is not attrs.NOTHING:
+        if not inputs.x1D.endswith(".xmat.1D"):
+            outputs["x1D"] = os.path.abspath(inputs.x1D + ".xmat.1D")
+        else:
+            outputs["x1D"] = os.path.abspath(inputs.x1D)
+    else:
+        outputs["x1D"] = _gen_fname(
+            suffix=".xmat.1D",
+            **_gen_fname_opts,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir
+        )
+
+    if inputs.cbucket is not attrs.NOTHING:
+        outputs["cbucket"] = os.path.abspath(inputs.cbucket)
+
+    outputs["reml_script"] = _gen_fname(
+        suffix=".REML_cmd",
+        **_gen_fname_opts,
+        inputs=inputs,
+        stdout=stdout,
+        stderr=stderr,
+        output_dir=output_dir
+    )
+    # remove out_file from outputs if x1d_stop set to True
+    if inputs.x1D_stop:
+        del outputs["out_file"], outputs["cbucket"]
+    else:
+        outputs["out_file"] = os.path.abspath(inputs.out_file)
+
+    return outputs
diff --git a/example-specs/task/nipype/afni/degree_centrality_callables.py b/example-specs/task/nipype/afni/degree_centrality_callables.py
index 57fb37a5..777a981e 100644
--- a/example-specs/task/nipype/afni/degree_centrality_callables.py
+++ b/example-specs/task/nipype/afni/degree_centrality_callables.py
@@ -1 +1,354 @@
 """Module to put any functions that are referred to in the "callables" section of DegreeCentrality.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+
+
+def oned_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["oned_file"]
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """Handle afni output type and version information."""
+
+    __outputtype = "AFNI"
+    ftypes = {"NIFTI": ".nii", "AFNI": "", "NIFTI_GZ": ".nii.gz"}
+    version_cmd = "afni --version"
+
+    @staticmethod
+    def parse_version(raw_info):
+        """Check and parse AFNI's version."""
+        version_stamp = raw_info.split("\n")[0].split("Version ")[1]
+        if version_stamp.startswith("AFNI"):
+            version_stamp = version_stamp.split("AFNI_")[1]
+        elif version_stamp.startswith("Debian"):
+            version_stamp = version_stamp.split("Debian-")[1].split("~")[0]
+        else:
+            return None
+
+        version = LooseVersion(version_stamp.replace("_", ".")).version[:3]
+        if version[0] < 1000:
+            version[0] = version[0] + 2000
+        return tuple(version)
+
+    @classmethod
+    def output_type_to_ext(cls, outputtype):
+        """
+        Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        outputtype : {'NIFTI', 'NIFTI_GZ', 'AFNI'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+
+        """
+        try:
+            return cls.ftypes[outputtype]
+        except KeyError as e:
+            msg = "Invalid AFNIOUTPUTTYPE: ", outputtype
+            raise KeyError(msg) from e
+
+    @classmethod
+    def outputtype(cls):
+        """
+        Set default output filetype.
+
+        AFNI has no environment variables, Output filetypes get set in command line calls
+        Nipype uses ``AFNI`` as default
+
+
+        Returns
+        -------
+        None
+
+        """
+        return "AFNI"
+
+    @staticmethod
+    def standard_image(img_name):
+        """
+        Grab an image from the standard location.
+
+        Could be made more fancy to allow for more relocatability
+
+        """
+        clout = CommandLine(
+            "which afni",
+            ignore_exception=True,
+            resource_monitor=False,
+            terminal_output="allatonce",
+        ).run()
+        if clout.runtime.returncode != 0:
+            return None
+
+        out = clout.runtime.stdout
+        basedir = os.path.split(out)[0]
+        return os.path.join(basedir, img_name)
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def nipype_interfaces_afni__AFNICommandBase___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    # Update outputs dictionary if oned file is defined
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    if inputs.oned_file:
+        outputs["oned_file"] = os.path.abspath(inputs.oned_file)
+
+    return outputs
diff --git a/example-specs/task/nipype/afni/despike_callables.py b/example-specs/task/nipype/afni/despike_callables.py
index fd379b60..6f9d8f0e 100644
--- a/example-specs/task/nipype/afni/despike_callables.py
+++ b/example-specs/task/nipype/afni/despike_callables.py
@@ -1 +1,351 @@
 """Module to put any functions that are referred to in the "callables" section of Despike.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def nipype_interfaces_afni__AFNICommandBase___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """Handle afni output type and version information."""
+
+    __outputtype = "AFNI"
+    ftypes = {"NIFTI": ".nii", "AFNI": "", "NIFTI_GZ": ".nii.gz"}
+    version_cmd = "afni --version"
+
+    @staticmethod
+    def parse_version(raw_info):
+        """Check and parse AFNI's version."""
+        version_stamp = raw_info.split("\n")[0].split("Version ")[1]
+        if version_stamp.startswith("AFNI"):
+            version_stamp = version_stamp.split("AFNI_")[1]
+        elif version_stamp.startswith("Debian"):
+            version_stamp = version_stamp.split("Debian-")[1].split("~")[0]
+        else:
+            return None
+
+        version = LooseVersion(version_stamp.replace("_", ".")).version[:3]
+        if version[0] < 1000:
+            version[0] = version[0] + 2000
+        return tuple(version)
+
+    @classmethod
+    def output_type_to_ext(cls, outputtype):
+        """
+        Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        outputtype : {'NIFTI', 'NIFTI_GZ', 'AFNI'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+
+        """
+        try:
+            return cls.ftypes[outputtype]
+        except KeyError as e:
+            msg = "Invalid AFNIOUTPUTTYPE: ", outputtype
+            raise KeyError(msg) from e
+
+    @classmethod
+    def outputtype(cls):
+        """
+        Set default output filetype.
+
+        AFNI has no environment variables, Output filetypes get set in command line calls
+        Nipype uses ``AFNI`` as default
+
+
+        Returns
+        -------
+        None
+
+        """
+        return "AFNI"
+
+    @staticmethod
+    def standard_image(img_name):
+        """
+        Grab an image from the standard location.
+
+        Could be made more fancy to allow for more relocatability
+
+        """
+        clout = CommandLine(
+            "which afni",
+            ignore_exception=True,
+            resource_monitor=False,
+            terminal_output="allatonce",
+        ).run()
+        if clout.runtime.returncode != 0:
+            return None
+
+        out = clout.runtime.stdout
+        basedir = os.path.split(out)[0]
+        return os.path.join(basedir, img_name)
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
diff --git a/example-specs/task/nipype/afni/detrend_callables.py b/example-specs/task/nipype/afni/detrend_callables.py
index 02c8f7b6..c53f0fb8 100644
--- a/example-specs/task/nipype/afni/detrend_callables.py
+++ b/example-specs/task/nipype/afni/detrend_callables.py
@@ -1 +1,351 @@
 """Module to put any functions that are referred to in the "callables" section of Detrend.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def nipype_interfaces_afni__AFNICommandBase___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """Handle afni output type and version information."""
+
+    __outputtype = "AFNI"
+    ftypes = {"NIFTI": ".nii", "AFNI": "", "NIFTI_GZ": ".nii.gz"}
+    version_cmd = "afni --version"
+
+    @staticmethod
+    def parse_version(raw_info):
+        """Check and parse AFNI's version."""
+        version_stamp = raw_info.split("\n")[0].split("Version ")[1]
+        if version_stamp.startswith("AFNI"):
+            version_stamp = version_stamp.split("AFNI_")[1]
+        elif version_stamp.startswith("Debian"):
+            version_stamp = version_stamp.split("Debian-")[1].split("~")[0]
+        else:
+            return None
+
+        version = LooseVersion(version_stamp.replace("_", ".")).version[:3]
+        if version[0] < 1000:
+            version[0] = version[0] + 2000
+        return tuple(version)
+
+    @classmethod
+    def output_type_to_ext(cls, outputtype):
+        """
+        Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        outputtype : {'NIFTI', 'NIFTI_GZ', 'AFNI'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+
+        """
+        try:
+            return cls.ftypes[outputtype]
+        except KeyError as e:
+            msg = "Invalid AFNIOUTPUTTYPE: ", outputtype
+            raise KeyError(msg) from e
+
+    @classmethod
+    def outputtype(cls):
+        """
+        Set default output filetype.
+
+        AFNI has no environment variables, Output filetypes get set in command line calls
+        Nipype uses ``AFNI`` as default
+
+
+        Returns
+        -------
+        None
+
+        """
+        return "AFNI"
+
+    @staticmethod
+    def standard_image(img_name):
+        """
+        Grab an image from the standard location.
+
+        Could be made more fancy to allow for more relocatability
+
+        """
+        clout = CommandLine(
+            "which afni",
+            ignore_exception=True,
+            resource_monitor=False,
+            terminal_output="allatonce",
+        ).run()
+        if clout.runtime.returncode != 0:
+            return None
+
+        out = clout.runtime.stdout
+        basedir = os.path.split(out)[0]
+        return os.path.join(basedir, img_name)
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
diff --git a/example-specs/task/nipype/afni/dot.yaml b/example-specs/task/nipype/afni/dot.yaml
index 47a6197e..13328318 100644
--- a/example-specs/task/nipype/afni/dot.yaml
+++ b/example-specs/task/nipype/afni/dot.yaml
@@ -82,7 +82,7 @@ tests:
     mask:
     # type=file|default=<undefined>: Use this dataset as a mask
     mrange:
-    # type=tuple|default=(<traits.trait_types.Float object at 0x10b05f210>, <traits.trait_types.Float object at 0x10b05f110>): Means to further restrict the voxels from 'mset' so thatonly those mask values within this range (inclusive) willbe used.
+    # type=tuple|default=(<traits.trait_types.Float object at 0x10aa87250>, <traits.trait_types.Float object at 0x10aa87150>): Means to further restrict the voxels from 'mset' so thatonly those mask values within this range (inclusive) willbe used.
     demean:
     # type=bool|default=False: Remove the mean from each volume prior to computing the correlation
     docor:
diff --git a/example-specs/task/nipype/afni/dot_callables.py b/example-specs/task/nipype/afni/dot_callables.py
index b8c951c5..fcc3f28d 100644
--- a/example-specs/task/nipype/afni/dot_callables.py
+++ b/example-specs/task/nipype/afni/dot_callables.py
@@ -1 +1,351 @@
 """Module to put any functions that are referred to in the "callables" section of Dot.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def nipype_interfaces_afni__AFNICommandBase___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """Handle afni output type and version information."""
+
+    __outputtype = "AFNI"
+    ftypes = {"NIFTI": ".nii", "AFNI": "", "NIFTI_GZ": ".nii.gz"}
+    version_cmd = "afni --version"
+
+    @staticmethod
+    def parse_version(raw_info):
+        """Check and parse AFNI's version."""
+        version_stamp = raw_info.split("\n")[0].split("Version ")[1]
+        if version_stamp.startswith("AFNI"):
+            version_stamp = version_stamp.split("AFNI_")[1]
+        elif version_stamp.startswith("Debian"):
+            version_stamp = version_stamp.split("Debian-")[1].split("~")[0]
+        else:
+            return None
+
+        version = LooseVersion(version_stamp.replace("_", ".")).version[:3]
+        if version[0] < 1000:
+            version[0] = version[0] + 2000
+        return tuple(version)
+
+    @classmethod
+    def output_type_to_ext(cls, outputtype):
+        """
+        Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        outputtype : {'NIFTI', 'NIFTI_GZ', 'AFNI'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+
+        """
+        try:
+            return cls.ftypes[outputtype]
+        except KeyError as e:
+            msg = "Invalid AFNIOUTPUTTYPE: ", outputtype
+            raise KeyError(msg) from e
+
+    @classmethod
+    def outputtype(cls):
+        """
+        Set default output filetype.
+
+        AFNI has no environment variables, Output filetypes get set in command line calls
+        Nipype uses ``AFNI`` as default
+
+
+        Returns
+        -------
+        None
+
+        """
+        return "AFNI"
+
+    @staticmethod
+    def standard_image(img_name):
+        """
+        Grab an image from the standard location.
+
+        Could be made more fancy to allow for more relocatability
+
+        """
+        clout = CommandLine(
+            "which afni",
+            ignore_exception=True,
+            resource_monitor=False,
+            terminal_output="allatonce",
+        ).run()
+        if clout.runtime.returncode != 0:
+            return None
+
+        out = clout.runtime.stdout
+        basedir = os.path.split(out)[0]
+        return os.path.join(basedir, img_name)
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
diff --git a/example-specs/task/nipype/afni/ecm_callables.py b/example-specs/task/nipype/afni/ecm_callables.py
index 62727561..a7306533 100644
--- a/example-specs/task/nipype/afni/ecm_callables.py
+++ b/example-specs/task/nipype/afni/ecm_callables.py
@@ -1 +1,351 @@
 """Module to put any functions that are referred to in the "callables" section of ECM.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def nipype_interfaces_afni__AFNICommandBase___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """Handle afni output type and version information."""
+
+    __outputtype = "AFNI"
+    ftypes = {"NIFTI": ".nii", "AFNI": "", "NIFTI_GZ": ".nii.gz"}
+    version_cmd = "afni --version"
+
+    @staticmethod
+    def parse_version(raw_info):
+        """Check and parse AFNI's version."""
+        version_stamp = raw_info.split("\n")[0].split("Version ")[1]
+        if version_stamp.startswith("AFNI"):
+            version_stamp = version_stamp.split("AFNI_")[1]
+        elif version_stamp.startswith("Debian"):
+            version_stamp = version_stamp.split("Debian-")[1].split("~")[0]
+        else:
+            return None
+
+        version = LooseVersion(version_stamp.replace("_", ".")).version[:3]
+        if version[0] < 1000:
+            version[0] = version[0] + 2000
+        return tuple(version)
+
+    @classmethod
+    def output_type_to_ext(cls, outputtype):
+        """
+        Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        outputtype : {'NIFTI', 'NIFTI_GZ', 'AFNI'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+
+        """
+        try:
+            return cls.ftypes[outputtype]
+        except KeyError as e:
+            msg = "Invalid AFNIOUTPUTTYPE: ", outputtype
+            raise KeyError(msg) from e
+
+    @classmethod
+    def outputtype(cls):
+        """
+        Set default output filetype.
+
+        AFNI has no environment variables, Output filetypes get set in command line calls
+        Nipype uses ``AFNI`` as default
+
+
+        Returns
+        -------
+        None
+
+        """
+        return "AFNI"
+
+    @staticmethod
+    def standard_image(img_name):
+        """
+        Grab an image from the standard location.
+
+        Could be made more fancy to allow for more relocatability
+
+        """
+        clout = CommandLine(
+            "which afni",
+            ignore_exception=True,
+            resource_monitor=False,
+            terminal_output="allatonce",
+        ).run()
+        if clout.runtime.returncode != 0:
+            return None
+
+        out = clout.runtime.stdout
+        basedir = os.path.split(out)[0]
+        return os.path.join(basedir, img_name)
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
diff --git a/example-specs/task/nipype/afni/edge_3_callables.py b/example-specs/task/nipype/afni/edge_3_callables.py
index c481dd24..510c8ca7 100644
--- a/example-specs/task/nipype/afni/edge_3_callables.py
+++ b/example-specs/task/nipype/afni/edge_3_callables.py
@@ -1 +1,351 @@
 """Module to put any functions that are referred to in the "callables" section of Edge3.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def nipype_interfaces_afni__AFNICommandBase___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """Handle afni output type and version information."""
+
+    __outputtype = "AFNI"
+    ftypes = {"NIFTI": ".nii", "AFNI": "", "NIFTI_GZ": ".nii.gz"}
+    version_cmd = "afni --version"
+
+    @staticmethod
+    def parse_version(raw_info):
+        """Check and parse AFNI's version."""
+        version_stamp = raw_info.split("\n")[0].split("Version ")[1]
+        if version_stamp.startswith("AFNI"):
+            version_stamp = version_stamp.split("AFNI_")[1]
+        elif version_stamp.startswith("Debian"):
+            version_stamp = version_stamp.split("Debian-")[1].split("~")[0]
+        else:
+            return None
+
+        version = LooseVersion(version_stamp.replace("_", ".")).version[:3]
+        if version[0] < 1000:
+            version[0] = version[0] + 2000
+        return tuple(version)
+
+    @classmethod
+    def output_type_to_ext(cls, outputtype):
+        """
+        Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        outputtype : {'NIFTI', 'NIFTI_GZ', 'AFNI'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+
+        """
+        try:
+            return cls.ftypes[outputtype]
+        except KeyError as e:
+            msg = "Invalid AFNIOUTPUTTYPE: ", outputtype
+            raise KeyError(msg) from e
+
+    @classmethod
+    def outputtype(cls):
+        """
+        Set default output filetype.
+
+        AFNI has no environment variables, Output filetypes get set in command line calls
+        Nipype uses ``AFNI`` as default
+
+
+        Returns
+        -------
+        None
+
+        """
+        return "AFNI"
+
+    @staticmethod
+    def standard_image(img_name):
+        """
+        Grab an image from the standard location.
+
+        Could be made more fancy to allow for more relocatability
+
+        """
+        clout = CommandLine(
+            "which afni",
+            ignore_exception=True,
+            resource_monitor=False,
+            terminal_output="allatonce",
+        ).run()
+        if clout.runtime.returncode != 0:
+            return None
+
+        out = clout.runtime.stdout
+        basedir = os.path.split(out)[0]
+        return os.path.join(basedir, img_name)
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
diff --git a/example-specs/task/nipype/afni/eval_callables.py b/example-specs/task/nipype/afni/eval_callables.py
index 829884d8..2ab11fb1 100644
--- a/example-specs/task/nipype/afni/eval_callables.py
+++ b/example-specs/task/nipype/afni/eval_callables.py
@@ -1 +1,351 @@
 """Module to put any functions that are referred to in the "callables" section of Eval.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def nipype_interfaces_afni__AFNICommandBase___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """Handle afni output type and version information."""
+
+    __outputtype = "AFNI"
+    ftypes = {"NIFTI": ".nii", "AFNI": "", "NIFTI_GZ": ".nii.gz"}
+    version_cmd = "afni --version"
+
+    @staticmethod
+    def parse_version(raw_info):
+        """Check and parse AFNI's version."""
+        version_stamp = raw_info.split("\n")[0].split("Version ")[1]
+        if version_stamp.startswith("AFNI"):
+            version_stamp = version_stamp.split("AFNI_")[1]
+        elif version_stamp.startswith("Debian"):
+            version_stamp = version_stamp.split("Debian-")[1].split("~")[0]
+        else:
+            return None
+
+        version = LooseVersion(version_stamp.replace("_", ".")).version[:3]
+        if version[0] < 1000:
+            version[0] = version[0] + 2000
+        return tuple(version)
+
+    @classmethod
+    def output_type_to_ext(cls, outputtype):
+        """
+        Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        outputtype : {'NIFTI', 'NIFTI_GZ', 'AFNI'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+
+        """
+        try:
+            return cls.ftypes[outputtype]
+        except KeyError as e:
+            msg = "Invalid AFNIOUTPUTTYPE: ", outputtype
+            raise KeyError(msg) from e
+
+    @classmethod
+    def outputtype(cls):
+        """
+        Set default output filetype.
+
+        AFNI has no environment variables, Output filetypes get set in command line calls
+        Nipype uses ``AFNI`` as default
+
+
+        Returns
+        -------
+        None
+
+        """
+        return "AFNI"
+
+    @staticmethod
+    def standard_image(img_name):
+        """
+        Grab an image from the standard location.
+
+        Could be made more fancy to allow for more relocatability
+
+        """
+        clout = CommandLine(
+            "which afni",
+            ignore_exception=True,
+            resource_monitor=False,
+            terminal_output="allatonce",
+        ).run()
+        if clout.runtime.returncode != 0:
+            return None
+
+        out = clout.runtime.stdout
+        basedir = os.path.split(out)[0]
+        return os.path.join(basedir, img_name)
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
diff --git a/example-specs/task/nipype/afni/fim_callables.py b/example-specs/task/nipype/afni/fim_callables.py
index 860b82c8..4b4428c8 100644
--- a/example-specs/task/nipype/afni/fim_callables.py
+++ b/example-specs/task/nipype/afni/fim_callables.py
@@ -1 +1,351 @@
 """Module to put any functions that are referred to in the "callables" section of Fim.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def nipype_interfaces_afni__AFNICommandBase___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """Handle afni output type and version information."""
+
+    __outputtype = "AFNI"
+    ftypes = {"NIFTI": ".nii", "AFNI": "", "NIFTI_GZ": ".nii.gz"}
+    version_cmd = "afni --version"
+
+    @staticmethod
+    def parse_version(raw_info):
+        """Check and parse AFNI's version."""
+        version_stamp = raw_info.split("\n")[0].split("Version ")[1]
+        if version_stamp.startswith("AFNI"):
+            version_stamp = version_stamp.split("AFNI_")[1]
+        elif version_stamp.startswith("Debian"):
+            version_stamp = version_stamp.split("Debian-")[1].split("~")[0]
+        else:
+            return None
+
+        version = LooseVersion(version_stamp.replace("_", ".")).version[:3]
+        if version[0] < 1000:
+            version[0] = version[0] + 2000
+        return tuple(version)
+
+    @classmethod
+    def output_type_to_ext(cls, outputtype):
+        """
+        Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        outputtype : {'NIFTI', 'NIFTI_GZ', 'AFNI'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+
+        """
+        try:
+            return cls.ftypes[outputtype]
+        except KeyError as e:
+            msg = "Invalid AFNIOUTPUTTYPE: ", outputtype
+            raise KeyError(msg) from e
+
+    @classmethod
+    def outputtype(cls):
+        """
+        Set default output filetype.
+
+        AFNI has no environment variables, Output filetypes get set in command line calls
+        Nipype uses ``AFNI`` as default
+
+
+        Returns
+        -------
+        None
+
+        """
+        return "AFNI"
+
+    @staticmethod
+    def standard_image(img_name):
+        """
+        Grab an image from the standard location.
+
+        Could be made more fancy to allow for more relocatability
+
+        """
+        clout = CommandLine(
+            "which afni",
+            ignore_exception=True,
+            resource_monitor=False,
+            terminal_output="allatonce",
+        ).run()
+        if clout.runtime.returncode != 0:
+            return None
+
+        out = clout.runtime.stdout
+        basedir = os.path.split(out)[0]
+        return os.path.join(basedir, img_name)
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
diff --git a/example-specs/task/nipype/afni/fourier_callables.py b/example-specs/task/nipype/afni/fourier_callables.py
index fada4d06..65f79bfa 100644
--- a/example-specs/task/nipype/afni/fourier_callables.py
+++ b/example-specs/task/nipype/afni/fourier_callables.py
@@ -1 +1,351 @@
 """Module to put any functions that are referred to in the "callables" section of Fourier.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def nipype_interfaces_afni__AFNICommandBase___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """Handle afni output type and version information."""
+
+    __outputtype = "AFNI"
+    ftypes = {"NIFTI": ".nii", "AFNI": "", "NIFTI_GZ": ".nii.gz"}
+    version_cmd = "afni --version"
+
+    @staticmethod
+    def parse_version(raw_info):
+        """Check and parse AFNI's version."""
+        version_stamp = raw_info.split("\n")[0].split("Version ")[1]
+        if version_stamp.startswith("AFNI"):
+            version_stamp = version_stamp.split("AFNI_")[1]
+        elif version_stamp.startswith("Debian"):
+            version_stamp = version_stamp.split("Debian-")[1].split("~")[0]
+        else:
+            return None
+
+        version = LooseVersion(version_stamp.replace("_", ".")).version[:3]
+        if version[0] < 1000:
+            version[0] = version[0] + 2000
+        return tuple(version)
+
+    @classmethod
+    def output_type_to_ext(cls, outputtype):
+        """
+        Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        outputtype : {'NIFTI', 'NIFTI_GZ', 'AFNI'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+
+        """
+        try:
+            return cls.ftypes[outputtype]
+        except KeyError as e:
+            msg = "Invalid AFNIOUTPUTTYPE: ", outputtype
+            raise KeyError(msg) from e
+
+    @classmethod
+    def outputtype(cls):
+        """
+        Set default output filetype.
+
+        AFNI has no environment variables, Output filetypes get set in command line calls
+        Nipype uses ``AFNI`` as default
+
+
+        Returns
+        -------
+        None
+
+        """
+        return "AFNI"
+
+    @staticmethod
+    def standard_image(img_name):
+        """
+        Grab an image from the standard location.
+
+        Could be made more fancy to allow for more relocatability
+
+        """
+        clout = CommandLine(
+            "which afni",
+            ignore_exception=True,
+            resource_monitor=False,
+            terminal_output="allatonce",
+        ).run()
+        if clout.runtime.returncode != 0:
+            return None
+
+        out = clout.runtime.stdout
+        basedir = os.path.split(out)[0]
+        return os.path.join(basedir, img_name)
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
diff --git a/example-specs/task/nipype/afni/fwh_mx.yaml b/example-specs/task/nipype/afni/fwh_mx.yaml
index 0538e6a3..453cbdd4 100644
--- a/example-specs/task/nipype/afni/fwh_mx.yaml
+++ b/example-specs/task/nipype/afni/fwh_mx.yaml
@@ -153,6 +153,10 @@ outputs:
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
+    acf_param: acf_param_callable
+    # type=traitcompound: fitted ACF model parameters
+    fwhm: fwhm_callable
+    # type=traitcompound: FWHM along each axis
   templates:
   # dict[str, str] - `output_file_template` values to be provided to output fields
   requirements:
diff --git a/example-specs/task/nipype/afni/fwh_mx_callables.py b/example-specs/task/nipype/afni/fwh_mx_callables.py
index cadbc73d..77ac2f3b 100644
--- a/example-specs/task/nipype/afni/fwh_mx_callables.py
+++ b/example-specs/task/nipype/afni/fwh_mx_callables.py
@@ -1 +1,256 @@
 """Module to put any functions that are referred to in the "callables" section of FWHMx.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+import numpy as np
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+def out_subbricks_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_subbricks"]
+
+
+def out_detrend_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_detrend"]
+
+
+def fwhm_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["fwhm"]
+
+
+def acf_param_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["acf_param"]
+
+
+def out_acf_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_acf"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def nipype_interfaces_afni__AFNICommandBase___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+
+    if inputs.detrend:
+        fname, ext = op.splitext(inputs.in_file)
+        if ".gz" in ext:
+            _, ext2 = op.splitext(fname)
+            ext = ext2 + ext
+        outputs["out_detrend"] += ext
+    else:
+        outputs["out_detrend"] = attrs.NOTHING
+
+    sout = np.loadtxt(outputs["out_file"])
+
+    # handle newer versions of AFNI
+    if sout.size == 8:
+        outputs["fwhm"] = tuple(sout[0, :])
+    else:
+        outputs["fwhm"] = tuple(sout)
+
+    if _acf:
+        assert sout.size == 8, "Wrong number of elements in %s" % str(sout)
+        outputs["acf_param"] = tuple(sout[1])
+
+        outputs["out_acf"] = op.abspath("3dFWHMx.1D")
+        if isinstance(inputs.acf, (str, bytes)):
+            outputs["out_acf"] = op.abspath(inputs.acf)
+
+    return outputs
diff --git a/example-specs/task/nipype/afni/gcor.yaml b/example-specs/task/nipype/afni/gcor.yaml
index 66760420..41c739aa 100644
--- a/example-specs/task/nipype/afni/gcor.yaml
+++ b/example-specs/task/nipype/afni/gcor.yaml
@@ -58,6 +58,8 @@ outputs:
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
+    out: out_callable
+    # type=float: global correlation value
   templates:
   # dict[str, str] - `output_file_template` values to be provided to output fields
   requirements:
diff --git a/example-specs/task/nipype/afni/gcor_callables.py b/example-specs/task/nipype/afni/gcor_callables.py
index 1e1b5923..a44c6a53 100644
--- a/example-specs/task/nipype/afni/gcor_callables.py
+++ b/example-specs/task/nipype/afni/gcor_callables.py
@@ -1 +1,16 @@
 """Module to put any functions that are referred to in the "callables" section of GCOR.yaml"""
+
+
+def out_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    return {"out": getattr(self, "_gcor")}
diff --git a/example-specs/task/nipype/afni/hist_callables.py b/example-specs/task/nipype/afni/hist_callables.py
index 56635a9c..4ed98612 100644
--- a/example-specs/task/nipype/afni/hist_callables.py
+++ b/example-specs/task/nipype/afni/hist_callables.py
@@ -1 +1,204 @@
 """Module to put any functions that are referred to in the "callables" section of Hist.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+def out_show_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_show"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def nipype_interfaces_afni__AFNICommandBase___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    outputs["out_file"] += ".niml.hist"
+    if not inputs.showhist:
+        outputs["out_show"] = attrs.NOTHING
+    return outputs
diff --git a/example-specs/task/nipype/afni/lfcd_callables.py b/example-specs/task/nipype/afni/lfcd_callables.py
index 39f71693..aa9268d5 100644
--- a/example-specs/task/nipype/afni/lfcd_callables.py
+++ b/example-specs/task/nipype/afni/lfcd_callables.py
@@ -1 +1,351 @@
 """Module to put any functions that are referred to in the "callables" section of LFCD.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def nipype_interfaces_afni__AFNICommandBase___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """Handle afni output type and version information."""
+
+    __outputtype = "AFNI"
+    ftypes = {"NIFTI": ".nii", "AFNI": "", "NIFTI_GZ": ".nii.gz"}
+    version_cmd = "afni --version"
+
+    @staticmethod
+    def parse_version(raw_info):
+        """Check and parse AFNI's version."""
+        version_stamp = raw_info.split("\n")[0].split("Version ")[1]
+        if version_stamp.startswith("AFNI"):
+            version_stamp = version_stamp.split("AFNI_")[1]
+        elif version_stamp.startswith("Debian"):
+            version_stamp = version_stamp.split("Debian-")[1].split("~")[0]
+        else:
+            return None
+
+        version = LooseVersion(version_stamp.replace("_", ".")).version[:3]
+        if version[0] < 1000:
+            version[0] = version[0] + 2000
+        return tuple(version)
+
+    @classmethod
+    def output_type_to_ext(cls, outputtype):
+        """
+        Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        outputtype : {'NIFTI', 'NIFTI_GZ', 'AFNI'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+
+        """
+        try:
+            return cls.ftypes[outputtype]
+        except KeyError as e:
+            msg = "Invalid AFNIOUTPUTTYPE: ", outputtype
+            raise KeyError(msg) from e
+
+    @classmethod
+    def outputtype(cls):
+        """
+        Set default output filetype.
+
+        AFNI has no environment variables, Output filetypes get set in command line calls
+        Nipype uses ``AFNI`` as default
+
+
+        Returns
+        -------
+        None
+
+        """
+        return "AFNI"
+
+    @staticmethod
+    def standard_image(img_name):
+        """
+        Grab an image from the standard location.
+
+        Could be made more fancy to allow for more relocatability
+
+        """
+        clout = CommandLine(
+            "which afni",
+            ignore_exception=True,
+            resource_monitor=False,
+            terminal_output="allatonce",
+        ).run()
+        if clout.runtime.returncode != 0:
+            return None
+
+        out = clout.runtime.stdout
+        basedir = os.path.split(out)[0]
+        return os.path.join(basedir, img_name)
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
diff --git a/example-specs/task/nipype/afni/local_bistat_callables.py b/example-specs/task/nipype/afni/local_bistat_callables.py
index 32c1bc96..11ff92c6 100644
--- a/example-specs/task/nipype/afni/local_bistat_callables.py
+++ b/example-specs/task/nipype/afni/local_bistat_callables.py
@@ -1 +1,351 @@
 """Module to put any functions that are referred to in the "callables" section of LocalBistat.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def nipype_interfaces_afni__AFNICommandBase___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """Handle afni output type and version information."""
+
+    __outputtype = "AFNI"
+    ftypes = {"NIFTI": ".nii", "AFNI": "", "NIFTI_GZ": ".nii.gz"}
+    version_cmd = "afni --version"
+
+    @staticmethod
+    def parse_version(raw_info):
+        """Check and parse AFNI's version."""
+        version_stamp = raw_info.split("\n")[0].split("Version ")[1]
+        if version_stamp.startswith("AFNI"):
+            version_stamp = version_stamp.split("AFNI_")[1]
+        elif version_stamp.startswith("Debian"):
+            version_stamp = version_stamp.split("Debian-")[1].split("~")[0]
+        else:
+            return None
+
+        version = LooseVersion(version_stamp.replace("_", ".")).version[:3]
+        if version[0] < 1000:
+            version[0] = version[0] + 2000
+        return tuple(version)
+
+    @classmethod
+    def output_type_to_ext(cls, outputtype):
+        """
+        Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        outputtype : {'NIFTI', 'NIFTI_GZ', 'AFNI'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+
+        """
+        try:
+            return cls.ftypes[outputtype]
+        except KeyError as e:
+            msg = "Invalid AFNIOUTPUTTYPE: ", outputtype
+            raise KeyError(msg) from e
+
+    @classmethod
+    def outputtype(cls):
+        """
+        Set default output filetype.
+
+        AFNI has no environment variables, Output filetypes get set in command line calls
+        Nipype uses ``AFNI`` as default
+
+
+        Returns
+        -------
+        None
+
+        """
+        return "AFNI"
+
+    @staticmethod
+    def standard_image(img_name):
+        """
+        Grab an image from the standard location.
+
+        Could be made more fancy to allow for more relocatability
+
+        """
+        clout = CommandLine(
+            "which afni",
+            ignore_exception=True,
+            resource_monitor=False,
+            terminal_output="allatonce",
+        ).run()
+        if clout.runtime.returncode != 0:
+            return None
+
+        out = clout.runtime.stdout
+        basedir = os.path.split(out)[0]
+        return os.path.join(basedir, img_name)
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
diff --git a/example-specs/task/nipype/afni/localstat_callables.py b/example-specs/task/nipype/afni/localstat_callables.py
index 2704455b..88c27a86 100644
--- a/example-specs/task/nipype/afni/localstat_callables.py
+++ b/example-specs/task/nipype/afni/localstat_callables.py
@@ -1 +1,351 @@
 """Module to put any functions that are referred to in the "callables" section of Localstat.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def nipype_interfaces_afni__AFNICommandBase___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """Handle afni output type and version information."""
+
+    __outputtype = "AFNI"
+    ftypes = {"NIFTI": ".nii", "AFNI": "", "NIFTI_GZ": ".nii.gz"}
+    version_cmd = "afni --version"
+
+    @staticmethod
+    def parse_version(raw_info):
+        """Check and parse AFNI's version."""
+        version_stamp = raw_info.split("\n")[0].split("Version ")[1]
+        if version_stamp.startswith("AFNI"):
+            version_stamp = version_stamp.split("AFNI_")[1]
+        elif version_stamp.startswith("Debian"):
+            version_stamp = version_stamp.split("Debian-")[1].split("~")[0]
+        else:
+            return None
+
+        version = LooseVersion(version_stamp.replace("_", ".")).version[:3]
+        if version[0] < 1000:
+            version[0] = version[0] + 2000
+        return tuple(version)
+
+    @classmethod
+    def output_type_to_ext(cls, outputtype):
+        """
+        Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        outputtype : {'NIFTI', 'NIFTI_GZ', 'AFNI'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+
+        """
+        try:
+            return cls.ftypes[outputtype]
+        except KeyError as e:
+            msg = "Invalid AFNIOUTPUTTYPE: ", outputtype
+            raise KeyError(msg) from e
+
+    @classmethod
+    def outputtype(cls):
+        """
+        Set default output filetype.
+
+        AFNI has no environment variables, Output filetypes get set in command line calls
+        Nipype uses ``AFNI`` as default
+
+
+        Returns
+        -------
+        None
+
+        """
+        return "AFNI"
+
+    @staticmethod
+    def standard_image(img_name):
+        """
+        Grab an image from the standard location.
+
+        Could be made more fancy to allow for more relocatability
+
+        """
+        clout = CommandLine(
+            "which afni",
+            ignore_exception=True,
+            resource_monitor=False,
+            terminal_output="allatonce",
+        ).run()
+        if clout.runtime.returncode != 0:
+            return None
+
+        out = clout.runtime.stdout
+        basedir = os.path.split(out)[0]
+        return os.path.join(basedir, img_name)
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
diff --git a/example-specs/task/nipype/afni/mask_tool_callables.py b/example-specs/task/nipype/afni/mask_tool_callables.py
index 0962c849..6825ec7a 100644
--- a/example-specs/task/nipype/afni/mask_tool_callables.py
+++ b/example-specs/task/nipype/afni/mask_tool_callables.py
@@ -1 +1,351 @@
 """Module to put any functions that are referred to in the "callables" section of MaskTool.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def nipype_interfaces_afni__AFNICommandBase___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """Handle afni output type and version information."""
+
+    __outputtype = "AFNI"
+    ftypes = {"NIFTI": ".nii", "AFNI": "", "NIFTI_GZ": ".nii.gz"}
+    version_cmd = "afni --version"
+
+    @staticmethod
+    def parse_version(raw_info):
+        """Check and parse AFNI's version."""
+        version_stamp = raw_info.split("\n")[0].split("Version ")[1]
+        if version_stamp.startswith("AFNI"):
+            version_stamp = version_stamp.split("AFNI_")[1]
+        elif version_stamp.startswith("Debian"):
+            version_stamp = version_stamp.split("Debian-")[1].split("~")[0]
+        else:
+            return None
+
+        version = LooseVersion(version_stamp.replace("_", ".")).version[:3]
+        if version[0] < 1000:
+            version[0] = version[0] + 2000
+        return tuple(version)
+
+    @classmethod
+    def output_type_to_ext(cls, outputtype):
+        """
+        Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        outputtype : {'NIFTI', 'NIFTI_GZ', 'AFNI'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+
+        """
+        try:
+            return cls.ftypes[outputtype]
+        except KeyError as e:
+            msg = "Invalid AFNIOUTPUTTYPE: ", outputtype
+            raise KeyError(msg) from e
+
+    @classmethod
+    def outputtype(cls):
+        """
+        Set default output filetype.
+
+        AFNI has no environment variables, Output filetypes get set in command line calls
+        Nipype uses ``AFNI`` as default
+
+
+        Returns
+        -------
+        None
+
+        """
+        return "AFNI"
+
+    @staticmethod
+    def standard_image(img_name):
+        """
+        Grab an image from the standard location.
+
+        Could be made more fancy to allow for more relocatability
+
+        """
+        clout = CommandLine(
+            "which afni",
+            ignore_exception=True,
+            resource_monitor=False,
+            terminal_output="allatonce",
+        ).run()
+        if clout.runtime.returncode != 0:
+            return None
+
+        out = clout.runtime.stdout
+        basedir = os.path.split(out)[0]
+        return os.path.join(basedir, img_name)
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
diff --git a/example-specs/task/nipype/afni/maskave_callables.py b/example-specs/task/nipype/afni/maskave_callables.py
index 1f013994..847d55fc 100644
--- a/example-specs/task/nipype/afni/maskave_callables.py
+++ b/example-specs/task/nipype/afni/maskave_callables.py
@@ -1 +1,351 @@
 """Module to put any functions that are referred to in the "callables" section of Maskave.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def nipype_interfaces_afni__AFNICommandBase___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """Handle afni output type and version information."""
+
+    __outputtype = "AFNI"
+    ftypes = {"NIFTI": ".nii", "AFNI": "", "NIFTI_GZ": ".nii.gz"}
+    version_cmd = "afni --version"
+
+    @staticmethod
+    def parse_version(raw_info):
+        """Check and parse AFNI's version."""
+        version_stamp = raw_info.split("\n")[0].split("Version ")[1]
+        if version_stamp.startswith("AFNI"):
+            version_stamp = version_stamp.split("AFNI_")[1]
+        elif version_stamp.startswith("Debian"):
+            version_stamp = version_stamp.split("Debian-")[1].split("~")[0]
+        else:
+            return None
+
+        version = LooseVersion(version_stamp.replace("_", ".")).version[:3]
+        if version[0] < 1000:
+            version[0] = version[0] + 2000
+        return tuple(version)
+
+    @classmethod
+    def output_type_to_ext(cls, outputtype):
+        """
+        Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        outputtype : {'NIFTI', 'NIFTI_GZ', 'AFNI'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+
+        """
+        try:
+            return cls.ftypes[outputtype]
+        except KeyError as e:
+            msg = "Invalid AFNIOUTPUTTYPE: ", outputtype
+            raise KeyError(msg) from e
+
+    @classmethod
+    def outputtype(cls):
+        """
+        Set default output filetype.
+
+        AFNI has no environment variables, Output filetypes get set in command line calls
+        Nipype uses ``AFNI`` as default
+
+
+        Returns
+        -------
+        None
+
+        """
+        return "AFNI"
+
+    @staticmethod
+    def standard_image(img_name):
+        """
+        Grab an image from the standard location.
+
+        Could be made more fancy to allow for more relocatability
+
+        """
+        clout = CommandLine(
+            "which afni",
+            ignore_exception=True,
+            resource_monitor=False,
+            terminal_output="allatonce",
+        ).run()
+        if clout.runtime.returncode != 0:
+            return None
+
+        out = clout.runtime.stdout
+        basedir = os.path.split(out)[0]
+        return os.path.join(basedir, img_name)
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
diff --git a/example-specs/task/nipype/afni/means_callables.py b/example-specs/task/nipype/afni/means_callables.py
index ece13969..7ffb1b73 100644
--- a/example-specs/task/nipype/afni/means_callables.py
+++ b/example-specs/task/nipype/afni/means_callables.py
@@ -1 +1,351 @@
 """Module to put any functions that are referred to in the "callables" section of Means.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def nipype_interfaces_afni__AFNICommandBase___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """Handle afni output type and version information."""
+
+    __outputtype = "AFNI"
+    ftypes = {"NIFTI": ".nii", "AFNI": "", "NIFTI_GZ": ".nii.gz"}
+    version_cmd = "afni --version"
+
+    @staticmethod
+    def parse_version(raw_info):
+        """Check and parse AFNI's version."""
+        version_stamp = raw_info.split("\n")[0].split("Version ")[1]
+        if version_stamp.startswith("AFNI"):
+            version_stamp = version_stamp.split("AFNI_")[1]
+        elif version_stamp.startswith("Debian"):
+            version_stamp = version_stamp.split("Debian-")[1].split("~")[0]
+        else:
+            return None
+
+        version = LooseVersion(version_stamp.replace("_", ".")).version[:3]
+        if version[0] < 1000:
+            version[0] = version[0] + 2000
+        return tuple(version)
+
+    @classmethod
+    def output_type_to_ext(cls, outputtype):
+        """
+        Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        outputtype : {'NIFTI', 'NIFTI_GZ', 'AFNI'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+
+        """
+        try:
+            return cls.ftypes[outputtype]
+        except KeyError as e:
+            msg = "Invalid AFNIOUTPUTTYPE: ", outputtype
+            raise KeyError(msg) from e
+
+    @classmethod
+    def outputtype(cls):
+        """
+        Set default output filetype.
+
+        AFNI has no environment variables, Output filetypes get set in command line calls
+        Nipype uses ``AFNI`` as default
+
+
+        Returns
+        -------
+        None
+
+        """
+        return "AFNI"
+
+    @staticmethod
+    def standard_image(img_name):
+        """
+        Grab an image from the standard location.
+
+        Could be made more fancy to allow for more relocatability
+
+        """
+        clout = CommandLine(
+            "which afni",
+            ignore_exception=True,
+            resource_monitor=False,
+            terminal_output="allatonce",
+        ).run()
+        if clout.runtime.returncode != 0:
+            return None
+
+        out = clout.runtime.stdout
+        basedir = os.path.split(out)[0]
+        return os.path.join(basedir, img_name)
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
diff --git a/example-specs/task/nipype/afni/merge_callables.py b/example-specs/task/nipype/afni/merge_callables.py
index a64071b1..25ce8640 100644
--- a/example-specs/task/nipype/afni/merge_callables.py
+++ b/example-specs/task/nipype/afni/merge_callables.py
@@ -1 +1,351 @@
 """Module to put any functions that are referred to in the "callables" section of Merge.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def nipype_interfaces_afni__AFNICommandBase___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """Handle afni output type and version information."""
+
+    __outputtype = "AFNI"
+    ftypes = {"NIFTI": ".nii", "AFNI": "", "NIFTI_GZ": ".nii.gz"}
+    version_cmd = "afni --version"
+
+    @staticmethod
+    def parse_version(raw_info):
+        """Check and parse AFNI's version."""
+        version_stamp = raw_info.split("\n")[0].split("Version ")[1]
+        if version_stamp.startswith("AFNI"):
+            version_stamp = version_stamp.split("AFNI_")[1]
+        elif version_stamp.startswith("Debian"):
+            version_stamp = version_stamp.split("Debian-")[1].split("~")[0]
+        else:
+            return None
+
+        version = LooseVersion(version_stamp.replace("_", ".")).version[:3]
+        if version[0] < 1000:
+            version[0] = version[0] + 2000
+        return tuple(version)
+
+    @classmethod
+    def output_type_to_ext(cls, outputtype):
+        """
+        Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        outputtype : {'NIFTI', 'NIFTI_GZ', 'AFNI'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+
+        """
+        try:
+            return cls.ftypes[outputtype]
+        except KeyError as e:
+            msg = "Invalid AFNIOUTPUTTYPE: ", outputtype
+            raise KeyError(msg) from e
+
+    @classmethod
+    def outputtype(cls):
+        """
+        Set default output filetype.
+
+        AFNI has no environment variables, Output filetypes get set in command line calls
+        Nipype uses ``AFNI`` as default
+
+
+        Returns
+        -------
+        None
+
+        """
+        return "AFNI"
+
+    @staticmethod
+    def standard_image(img_name):
+        """
+        Grab an image from the standard location.
+
+        Could be made more fancy to allow for more relocatability
+
+        """
+        clout = CommandLine(
+            "which afni",
+            ignore_exception=True,
+            resource_monitor=False,
+            terminal_output="allatonce",
+        ).run()
+        if clout.runtime.returncode != 0:
+            return None
+
+        out = clout.runtime.stdout
+        basedir = os.path.split(out)[0]
+        return os.path.join(basedir, img_name)
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
diff --git a/example-specs/task/nipype/afni/net_corr.yaml b/example-specs/task/nipype/afni/net_corr.yaml
index 39f3e3c5..6779ad53 100644
--- a/example-specs/task/nipype/afni/net_corr.yaml
+++ b/example-specs/task/nipype/afni/net_corr.yaml
@@ -64,6 +64,8 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    out_corr_maps: generic/file+list-of
+    # type=list: output correlation maps in Pearson and/or Z-scores
     out_corr_matrix: generic/file
     # type=file: output correlation matrix between ROIs written to a text file with .netcc suffix
   callables:
diff --git a/example-specs/task/nipype/afni/net_corr_callables.py b/example-specs/task/nipype/afni/net_corr_callables.py
index dd2cc65d..3b96db11 100644
--- a/example-specs/task/nipype/afni/net_corr_callables.py
+++ b/example-specs/task/nipype/afni/net_corr_callables.py
@@ -1 +1,282 @@
 """Module to put any functions that are referred to in the "callables" section of NetCorr.yaml"""
+
+import os
+import attrs
+import os.path as op
+
+
+def out_corr_matrix_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_corr_matrix"]
+
+
+def out_corr_maps_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_corr_maps"]
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """Handle afni output type and version information."""
+
+    __outputtype = "AFNI"
+    ftypes = {"NIFTI": ".nii", "AFNI": "", "NIFTI_GZ": ".nii.gz"}
+    version_cmd = "afni --version"
+
+    @staticmethod
+    def parse_version(raw_info):
+        """Check and parse AFNI's version."""
+        version_stamp = raw_info.split("\n")[0].split("Version ")[1]
+        if version_stamp.startswith("AFNI"):
+            version_stamp = version_stamp.split("AFNI_")[1]
+        elif version_stamp.startswith("Debian"):
+            version_stamp = version_stamp.split("Debian-")[1].split("~")[0]
+        else:
+            return None
+
+        version = LooseVersion(version_stamp.replace("_", ".")).version[:3]
+        if version[0] < 1000:
+            version[0] = version[0] + 2000
+        return tuple(version)
+
+    @classmethod
+    def output_type_to_ext(cls, outputtype):
+        """
+        Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        outputtype : {'NIFTI', 'NIFTI_GZ', 'AFNI'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+
+        """
+        try:
+            return cls.ftypes[outputtype]
+        except KeyError as e:
+            msg = "Invalid AFNIOUTPUTTYPE: ", outputtype
+            raise KeyError(msg) from e
+
+    @classmethod
+    def outputtype(cls):
+        """
+        Set default output filetype.
+
+        AFNI has no environment variables, Output filetypes get set in command line calls
+        Nipype uses ``AFNI`` as default
+
+
+        Returns
+        -------
+        None
+
+        """
+        return "AFNI"
+
+    @staticmethod
+    def standard_image(img_name):
+        """
+        Grab an image from the standard location.
+
+        Could be made more fancy to allow for more relocatability
+
+        """
+        clout = CommandLine(
+            "which afni",
+            ignore_exception=True,
+            resource_monitor=False,
+            terminal_output="allatonce",
+        ).run()
+        if clout.runtime.returncode != 0:
+            return None
+
+        out = clout.runtime.stdout
+        basedir = os.path.split(out)[0]
+        return os.path.join(basedir, img_name)
+
+
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """
+    Generate a filename based on the given parameters.
+
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
+
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
+
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+    if not basename:
+        msg = "Unable to generate filename for command %s. " % "3dNetCorr"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.outputtype)
+    if change_ext:
+        suffix = "".join((suffix, ext)) if suffix else ext
+
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    import glob
+
+    outputs = {}
+
+    if inputs.out_file is attrs.NOTHING:
+        prefix = _gen_fname(
+            inputs.in_file,
+            suffix="_netcorr",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    else:
+        prefix = inputs.out_file
+
+    # All outputs should be in the same directory as the prefix
+    odir = os.path.dirname(os.path.abspath(prefix))
+    outputs["out_corr_matrix"] = glob.glob(os.path.join(odir, "*.netcc"))[0]
+
+    if (inputs.ts_wb_corr is not attrs.NOTHING) or (
+        inputs.ts_Z_corr is not attrs.NOTHING
+    ):
+        corrdir = os.path.join(odir, prefix + "_000_INDIV")
+        outputs["out_corr_maps"] = glob.glob(os.path.join(corrdir, "*.nii.gz"))
+
+    return outputs
diff --git a/example-specs/task/nipype/afni/notes_callables.py b/example-specs/task/nipype/afni/notes_callables.py
index 7b329c55..c8d03bfd 100644
--- a/example-specs/task/nipype/afni/notes_callables.py
+++ b/example-specs/task/nipype/afni/notes_callables.py
@@ -1 +1,20 @@
 """Module to put any functions that are referred to in the "callables" section of Notes.yaml"""
+
+import os
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = os.path.abspath(inputs.in_file)
+    return outputs
diff --git a/example-specs/task/nipype/afni/nwarp_adjust_callables.py b/example-specs/task/nipype/afni/nwarp_adjust_callables.py
index 675694c9..c26ca491 100644
--- a/example-specs/task/nipype/afni/nwarp_adjust_callables.py
+++ b/example-specs/task/nipype/afni/nwarp_adjust_callables.py
@@ -1 +1,31 @@
 """Module to put any functions that are referred to in the "callables" section of NwarpAdjust.yaml"""
+
+import os
+import os.path as op
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+
+    if inputs.in_files:
+        if inputs.out_file:
+            outputs["out_file"] = os.path.abspath(inputs.out_file)
+        else:
+            basename = os.path.basename(inputs.in_files[0])
+            basename_noext, ext = op.splitext(basename)
+            if ".gz" in ext:
+                basename_noext, ext2 = op.splitext(basename_noext)
+                ext = ext2 + ext
+            outputs["out_file"] = os.path.abspath(basename_noext + "_NwarpAdjust" + ext)
+    return outputs
diff --git a/example-specs/task/nipype/afni/nwarp_apply_callables.py b/example-specs/task/nipype/afni/nwarp_apply_callables.py
index bbc3ac4e..7f1a7d63 100644
--- a/example-specs/task/nipype/afni/nwarp_apply_callables.py
+++ b/example-specs/task/nipype/afni/nwarp_apply_callables.py
@@ -1 +1,187 @@
 """Module to put any functions that are referred to in the "callables" section of NwarpApply.yaml"""
+
+import os
+import os.path as op
+import attrs
+import logging
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
diff --git a/example-specs/task/nipype/afni/nwarp_cat_callables.py b/example-specs/task/nipype/afni/nwarp_cat_callables.py
index 91922f70..42487caa 100644
--- a/example-specs/task/nipype/afni/nwarp_cat_callables.py
+++ b/example-specs/task/nipype/afni/nwarp_cat_callables.py
@@ -1 +1,272 @@
 """Module to put any functions that are referred to in the "callables" section of NwarpCat.yaml"""
+
+import os
+import attrs
+import os.path as op
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """Handle afni output type and version information."""
+
+    __outputtype = "AFNI"
+    ftypes = {"NIFTI": ".nii", "AFNI": "", "NIFTI_GZ": ".nii.gz"}
+    version_cmd = "afni --version"
+
+    @staticmethod
+    def parse_version(raw_info):
+        """Check and parse AFNI's version."""
+        version_stamp = raw_info.split("\n")[0].split("Version ")[1]
+        if version_stamp.startswith("AFNI"):
+            version_stamp = version_stamp.split("AFNI_")[1]
+        elif version_stamp.startswith("Debian"):
+            version_stamp = version_stamp.split("Debian-")[1].split("~")[0]
+        else:
+            return None
+
+        version = LooseVersion(version_stamp.replace("_", ".")).version[:3]
+        if version[0] < 1000:
+            version[0] = version[0] + 2000
+        return tuple(version)
+
+    @classmethod
+    def output_type_to_ext(cls, outputtype):
+        """
+        Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        outputtype : {'NIFTI', 'NIFTI_GZ', 'AFNI'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+
+        """
+        try:
+            return cls.ftypes[outputtype]
+        except KeyError as e:
+            msg = "Invalid AFNIOUTPUTTYPE: ", outputtype
+            raise KeyError(msg) from e
+
+    @classmethod
+    def outputtype(cls):
+        """
+        Set default output filetype.
+
+        AFNI has no environment variables, Output filetypes get set in command line calls
+        Nipype uses ``AFNI`` as default
+
+
+        Returns
+        -------
+        None
+
+        """
+        return "AFNI"
+
+    @staticmethod
+    def standard_image(img_name):
+        """
+        Grab an image from the standard location.
+
+        Could be made more fancy to allow for more relocatability
+
+        """
+        clout = CommandLine(
+            "which afni",
+            ignore_exception=True,
+            resource_monitor=False,
+            terminal_output="allatonce",
+        ).run()
+        if clout.runtime.returncode != 0:
+            return None
+
+        out = clout.runtime.stdout
+        basedir = os.path.split(out)[0]
+        return os.path.join(basedir, img_name)
+
+
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """
+    Generate a filename based on the given parameters.
+
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
+
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
+
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+    if not basename:
+        msg = "Unable to generate filename for command %s. " % "3dNwarpCat"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.outputtype)
+    if change_ext:
+        suffix = "".join((suffix, ext)) if suffix else ext
+
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _gen_fname(
+            inputs.in_files[0][0],
+            suffix="_NwarpCat",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    if inputs.out_file is not attrs.NOTHING:
+        outputs["out_file"] = os.path.abspath(inputs.out_file)
+    else:
+        outputs["out_file"] = os.path.abspath(
+            _gen_fname(
+                inputs.in_files[0],
+                suffix="_NwarpCat+tlrc",
+                ext=".HEAD",
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+        )
+    return outputs
diff --git a/example-specs/task/nipype/afni/one_d_tool_py.yaml b/example-specs/task/nipype/afni/one_d_tool_py.yaml
index 4abd6ee1..06e44a7f 100644
--- a/example-specs/task/nipype/afni/one_d_tool_py.yaml
+++ b/example-specs/task/nipype/afni/one_d_tool_py.yaml
@@ -79,7 +79,7 @@ tests:
     show_censor_count:
     # type=bool|default=False: display the total number of censored TRs  Note : if input is a valid xmat.1D dataset, then the count will come from the header.  Otherwise the input is assumed to be a binary censorfile, and zeros are simply counted.
     censor_motion:
-    # type=tuple|default=(<traits.trait_types.Float object at 0x10b08b5d0>, <nipype.interfaces.base.traits_extension.File object at 0x10b08b690>): Tuple of motion limit and outfile prefix. need to also set set_nruns -r set_run_lengths
+    # type=tuple|default=(<traits.trait_types.Float object at 0x10aaaf210>, <nipype.interfaces.base.traits_extension.File object at 0x10aaaf2d0>): Tuple of motion limit and outfile prefix. need to also set set_nruns -r set_run_lengths
     censor_prev_TR:
     # type=bool|default=False: for each censored TR, also censor previous
     show_trs_uncensored:
diff --git a/example-specs/task/nipype/afni/one_d_tool_py_callables.py b/example-specs/task/nipype/afni/one_d_tool_py_callables.py
index bc7bdd70..111b687e 100644
--- a/example-specs/task/nipype/afni/one_d_tool_py_callables.py
+++ b/example-specs/task/nipype/afni/one_d_tool_py_callables.py
@@ -1 +1,29 @@
 """Module to put any functions that are referred to in the "callables" section of OneDToolPy.yaml"""
+
+import os
+import attrs
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+
+    if inputs.out_file is not attrs.NOTHING:
+        outputs["out_file"] = os.path.join(output_dir, inputs.out_file)
+    if inputs.show_cormat_warnings is not attrs.NOTHING:
+        outputs["out_file"] = os.path.join(output_dir, inputs.show_cormat_warnings)
+    if inputs.censor_motion is not attrs.NOTHING:
+        outputs["out_file"] = os.path.join(
+            output_dir, inputs.censor_motion[1] + "_censor.1D"
+        )
+    return outputs
diff --git a/example-specs/task/nipype/afni/outlier_count_callables.py b/example-specs/task/nipype/afni/outlier_count_callables.py
index 60baa917..7f671a86 100644
--- a/example-specs/task/nipype/afni/outlier_count_callables.py
+++ b/example-specs/task/nipype/afni/outlier_count_callables.py
@@ -1 +1,29 @@
 """Module to put any functions that are referred to in the "callables" section of OutlierCount.yaml"""
+
+import os.path as op
+
+
+def out_outliers_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_outliers"]
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = op.abspath(inputs.out_file)
+    if inputs.save_outliers:
+        outputs["out_outliers"] = op.abspath(inputs.outliers_file)
+    return outputs
diff --git a/example-specs/task/nipype/afni/quality_index_callables.py b/example-specs/task/nipype/afni/quality_index_callables.py
index dc24d8ac..2a263807 100644
--- a/example-specs/task/nipype/afni/quality_index_callables.py
+++ b/example-specs/task/nipype/afni/quality_index_callables.py
@@ -1 +1,187 @@
 """Module to put any functions that are referred to in the "callables" section of QualityIndex.yaml"""
+
+import os
+import os.path as op
+import attrs
+import logging
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
diff --git a/example-specs/task/nipype/afni/qwarp.yaml b/example-specs/task/nipype/afni/qwarp.yaml
index 08bf4cea..6a2e179d 100644
--- a/example-specs/task/nipype/afni/qwarp.yaml
+++ b/example-specs/task/nipype/afni/qwarp.yaml
@@ -190,7 +190,7 @@ tests:
     wball:
     # type=list|default=[]: "``-wball x y z r f`` Enhance automatic weight from '-useweight' by a factor of 1+f\*Gaussian(FWHM=r) centered in the base image at DICOM coordinates (x,y,z) and with radius 'r'. The goal of this option is to try and make the alignment better in a specific part of the brain. Example:  -wball 0 14 6 30 40 to emphasize the thalamic area (in MNI/Talairach space).  * The 'r' parameter must be positive! * The 'f' parameter must be between 1 and 100 (inclusive). * '-wball' does nothing if you input your own weight   with the '-weight' option. * '-wball' does change the binary weight created by   the '-noweight' option. * You can only use '-wball' once in a run of 3dQwarp.  **The effect of '-wball' is not dramatic.** The example above makes the average brain image across a collection of subjects a little sharper in the thalamic area, which might have some small value.  If you care enough about alignment to use '-wball', then you should examine the results from 3dQwarp for each subject, to see if the alignments are good enough for your purposes.
     wmask:
-    # type=tuple|default=(<nipype.interfaces.base.traits_extension.File object at 0x10af7cbd0>, <traits.trait_types.Float object at 0x10af7c890>): Similar to '-wball', but here, you provide a dataset 'ws' that indicates where to increase the weight.  * The 'ws' dataset must be on the same 3D grid as the base dataset. * 'ws' is treated as a mask -- it only matters where it   is nonzero -- otherwise, the values inside are not used. * After 'ws' comes the factor 'f' by which to increase the   automatically computed weight.  Where 'ws' is nonzero,   the weighting will be multiplied by (1+f). * As with '-wball', the factor 'f' should be between 1 and 100.  
+    # type=tuple|default=(<nipype.interfaces.base.traits_extension.File object at 0x10a9b4410>, <traits.trait_types.Float object at 0x10a9b4490>): Similar to '-wball', but here, you provide a dataset 'ws' that indicates where to increase the weight.  * The 'ws' dataset must be on the same 3D grid as the base dataset. * 'ws' is treated as a mask -- it only matters where it   is nonzero -- otherwise, the values inside are not used. * After 'ws' comes the factor 'f' by which to increase the   automatically computed weight.  Where 'ws' is nonzero,   the weighting will be multiplied by (1+f). * As with '-wball', the factor 'f' should be between 1 and 100.  
     out_weight_file:
     # type=file|default=<undefined>: Write the weight volume to disk as a dataset
     blur:
diff --git a/example-specs/task/nipype/afni/qwarp_callables.py b/example-specs/task/nipype/afni/qwarp_callables.py
index 81de4ef3..f4493348 100644
--- a/example-specs/task/nipype/afni/qwarp_callables.py
+++ b/example-specs/task/nipype/afni/qwarp_callables.py
@@ -1 +1,456 @@
 """Module to put any functions that are referred to in the "callables" section of Qwarp.yaml"""
+
+import os
+import attrs
+import os.path as op
+
+
+def warped_source_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["warped_source"]
+
+
+def warped_base_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["warped_base"]
+
+
+def source_warp_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["source_warp"]
+
+
+def base_warp_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["base_warp"]
+
+
+def weights_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["weights"]
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """Handle afni output type and version information."""
+
+    __outputtype = "AFNI"
+    ftypes = {"NIFTI": ".nii", "AFNI": "", "NIFTI_GZ": ".nii.gz"}
+    version_cmd = "afni --version"
+
+    @staticmethod
+    def parse_version(raw_info):
+        """Check and parse AFNI's version."""
+        version_stamp = raw_info.split("\n")[0].split("Version ")[1]
+        if version_stamp.startswith("AFNI"):
+            version_stamp = version_stamp.split("AFNI_")[1]
+        elif version_stamp.startswith("Debian"):
+            version_stamp = version_stamp.split("Debian-")[1].split("~")[0]
+        else:
+            return None
+
+        version = LooseVersion(version_stamp.replace("_", ".")).version[:3]
+        if version[0] < 1000:
+            version[0] = version[0] + 2000
+        return tuple(version)
+
+    @classmethod
+    def output_type_to_ext(cls, outputtype):
+        """
+        Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        outputtype : {'NIFTI', 'NIFTI_GZ', 'AFNI'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+
+        """
+        try:
+            return cls.ftypes[outputtype]
+        except KeyError as e:
+            msg = "Invalid AFNIOUTPUTTYPE: ", outputtype
+            raise KeyError(msg) from e
+
+    @classmethod
+    def outputtype(cls):
+        """
+        Set default output filetype.
+
+        AFNI has no environment variables, Output filetypes get set in command line calls
+        Nipype uses ``AFNI`` as default
+
+
+        Returns
+        -------
+        None
+
+        """
+        return "AFNI"
+
+    @staticmethod
+    def standard_image(img_name):
+        """
+        Grab an image from the standard location.
+
+        Could be made more fancy to allow for more relocatability
+
+        """
+        clout = CommandLine(
+            "which afni",
+            ignore_exception=True,
+            resource_monitor=False,
+            terminal_output="allatonce",
+        ).run()
+        if clout.runtime.returncode != 0:
+            return None
+
+        out = clout.runtime.stdout
+        basedir = os.path.split(out)[0]
+        return os.path.join(basedir, img_name)
+
+
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """
+    Generate a filename based on the given parameters.
+
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
+
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
+
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+    if not basename:
+        msg = "Unable to generate filename for command %s. " % "3dQwarp"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.outputtype)
+    if change_ext:
+        suffix = "".join((suffix, ext)) if suffix else ext
+
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _gen_fname(
+            inputs.in_file,
+            suffix="_QW",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+
+    if inputs.out_file is attrs.NOTHING:
+        prefix = _gen_fname(
+            inputs.in_file,
+            suffix="_QW",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+        outputtype = inputs.outputtype
+        if outputtype == "AFNI":
+            ext = ".HEAD"
+            suffix = "+tlrc"
+        else:
+            ext = Info.output_type_to_ext(outputtype)
+            suffix = ""
+    else:
+        prefix = inputs.out_file
+        ext_ind = max([prefix.lower().rfind(".nii.gz"), prefix.lower().rfind(".nii")])
+        if ext_ind == -1:
+            ext = ".HEAD"
+            suffix = "+tlrc"
+        else:
+            ext = prefix[ext_ind:]
+            suffix = ""
+
+    # All outputs should be in the same directory as the prefix
+    out_dir = os.path.dirname(os.path.abspath(prefix))
+
+    outputs["warped_source"] = (
+        fname_presuffix(prefix, suffix=suffix, use_ext=False, newpath=out_dir) + ext
+    )
+    if not inputs.nowarp:
+        outputs["source_warp"] = (
+            fname_presuffix(
+                prefix, suffix="_WARP" + suffix, use_ext=False, newpath=out_dir
+            )
+            + ext
+        )
+    if inputs.iwarp:
+        outputs["base_warp"] = (
+            fname_presuffix(
+                prefix, suffix="_WARPINV" + suffix, use_ext=False, newpath=out_dir
+            )
+            + ext
+        )
+    if inputs.out_weight_file is not attrs.NOTHING:
+        outputs["weights"] = os.path.abspath(inputs.out_weight_file)
+
+    if inputs.plusminus:
+        outputs["warped_source"] = (
+            fname_presuffix(
+                prefix, suffix="_PLUS" + suffix, use_ext=False, newpath=out_dir
+            )
+            + ext
+        )
+        outputs["warped_base"] = (
+            fname_presuffix(
+                prefix, suffix="_MINUS" + suffix, use_ext=False, newpath=out_dir
+            )
+            + ext
+        )
+        outputs["source_warp"] = (
+            fname_presuffix(
+                prefix, suffix="_PLUS_WARP" + suffix, use_ext=False, newpath=out_dir
+            )
+            + ext
+        )
+        outputs["base_warp"] = (
+            fname_presuffix(
+                prefix,
+                suffix="_MINUS_WARP" + suffix,
+                use_ext=False,
+                newpath=out_dir,
+            )
+            + ext
+        )
+    return outputs
diff --git a/example-specs/task/nipype/afni/qwarp_plus_minus.yaml b/example-specs/task/nipype/afni/qwarp_plus_minus.yaml
index f4a6b24a..a6fe983a 100644
--- a/example-specs/task/nipype/afni/qwarp_plus_minus.yaml
+++ b/example-specs/task/nipype/afni/qwarp_plus_minus.yaml
@@ -126,7 +126,7 @@ tests:
     wball:
     # type=list|default=[]: "``-wball x y z r f`` Enhance automatic weight from '-useweight' by a factor of 1+f\*Gaussian(FWHM=r) centered in the base image at DICOM coordinates (x,y,z) and with radius 'r'. The goal of this option is to try and make the alignment better in a specific part of the brain. Example:  -wball 0 14 6 30 40 to emphasize the thalamic area (in MNI/Talairach space).  * The 'r' parameter must be positive! * The 'f' parameter must be between 1 and 100 (inclusive). * '-wball' does nothing if you input your own weight   with the '-weight' option. * '-wball' does change the binary weight created by   the '-noweight' option. * You can only use '-wball' once in a run of 3dQwarp.  **The effect of '-wball' is not dramatic.** The example above makes the average brain image across a collection of subjects a little sharper in the thalamic area, which might have some small value.  If you care enough about alignment to use '-wball', then you should examine the results from 3dQwarp for each subject, to see if the alignments are good enough for your purposes.
     wmask:
-    # type=tuple|default=(<nipype.interfaces.base.traits_extension.File object at 0x10af7cbd0>, <traits.trait_types.Float object at 0x10af7c890>): Similar to '-wball', but here, you provide a dataset 'ws' that indicates where to increase the weight.  * The 'ws' dataset must be on the same 3D grid as the base dataset. * 'ws' is treated as a mask -- it only matters where it   is nonzero -- otherwise, the values inside are not used. * After 'ws' comes the factor 'f' by which to increase the   automatically computed weight.  Where 'ws' is nonzero,   the weighting will be multiplied by (1+f). * As with '-wball', the factor 'f' should be between 1 and 100.  
+    # type=tuple|default=(<nipype.interfaces.base.traits_extension.File object at 0x10a9b4410>, <traits.trait_types.Float object at 0x10a9b4490>): Similar to '-wball', but here, you provide a dataset 'ws' that indicates where to increase the weight.  * The 'ws' dataset must be on the same 3D grid as the base dataset. * 'ws' is treated as a mask -- it only matters where it   is nonzero -- otherwise, the values inside are not used. * After 'ws' comes the factor 'f' by which to increase the   automatically computed weight.  Where 'ws' is nonzero,   the weighting will be multiplied by (1+f). * As with '-wball', the factor 'f' should be between 1 and 100.  
     out_weight_file:
     # type=file|default=<undefined>: Write the weight volume to disk as a dataset
     blur:
diff --git a/example-specs/task/nipype/afni/qwarp_plus_minus_callables.py b/example-specs/task/nipype/afni/qwarp_plus_minus_callables.py
index fc193c60..30d2ae9c 100644
--- a/example-specs/task/nipype/afni/qwarp_plus_minus_callables.py
+++ b/example-specs/task/nipype/afni/qwarp_plus_minus_callables.py
@@ -1 +1,456 @@
 """Module to put any functions that are referred to in the "callables" section of QwarpPlusMinus.yaml"""
+
+import os
+import attrs
+import os.path as op
+
+
+def warped_source_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["warped_source"]
+
+
+def warped_base_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["warped_base"]
+
+
+def source_warp_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["source_warp"]
+
+
+def base_warp_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["base_warp"]
+
+
+def weights_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["weights"]
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """Handle afni output type and version information."""
+
+    __outputtype = "AFNI"
+    ftypes = {"NIFTI": ".nii", "AFNI": "", "NIFTI_GZ": ".nii.gz"}
+    version_cmd = "afni --version"
+
+    @staticmethod
+    def parse_version(raw_info):
+        """Check and parse AFNI's version."""
+        version_stamp = raw_info.split("\n")[0].split("Version ")[1]
+        if version_stamp.startswith("AFNI"):
+            version_stamp = version_stamp.split("AFNI_")[1]
+        elif version_stamp.startswith("Debian"):
+            version_stamp = version_stamp.split("Debian-")[1].split("~")[0]
+        else:
+            return None
+
+        version = LooseVersion(version_stamp.replace("_", ".")).version[:3]
+        if version[0] < 1000:
+            version[0] = version[0] + 2000
+        return tuple(version)
+
+    @classmethod
+    def output_type_to_ext(cls, outputtype):
+        """
+        Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        outputtype : {'NIFTI', 'NIFTI_GZ', 'AFNI'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+
+        """
+        try:
+            return cls.ftypes[outputtype]
+        except KeyError as e:
+            msg = "Invalid AFNIOUTPUTTYPE: ", outputtype
+            raise KeyError(msg) from e
+
+    @classmethod
+    def outputtype(cls):
+        """
+        Set default output filetype.
+
+        AFNI has no environment variables, Output filetypes get set in command line calls
+        Nipype uses ``AFNI`` as default
+
+
+        Returns
+        -------
+        None
+
+        """
+        return "AFNI"
+
+    @staticmethod
+    def standard_image(img_name):
+        """
+        Grab an image from the standard location.
+
+        Could be made more fancy to allow for more relocatability
+
+        """
+        clout = CommandLine(
+            "which afni",
+            ignore_exception=True,
+            resource_monitor=False,
+            terminal_output="allatonce",
+        ).run()
+        if clout.runtime.returncode != 0:
+            return None
+
+        out = clout.runtime.stdout
+        basedir = os.path.split(out)[0]
+        return os.path.join(basedir, img_name)
+
+
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """
+    Generate a filename based on the given parameters.
+
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
+
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
+
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+    if not basename:
+        msg = "Unable to generate filename for command %s. " % "3dQwarp"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.outputtype)
+    if change_ext:
+        suffix = "".join((suffix, ext)) if suffix else ext
+
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _gen_fname(
+            inputs.in_file,
+            suffix="_QW",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+
+    if inputs.out_file is attrs.NOTHING:
+        prefix = _gen_fname(
+            inputs.in_file,
+            suffix="_QW",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+        outputtype = inputs.outputtype
+        if outputtype == "AFNI":
+            ext = ".HEAD"
+            suffix = "+tlrc"
+        else:
+            ext = Info.output_type_to_ext(outputtype)
+            suffix = ""
+    else:
+        prefix = inputs.out_file
+        ext_ind = max([prefix.lower().rfind(".nii.gz"), prefix.lower().rfind(".nii")])
+        if ext_ind == -1:
+            ext = ".HEAD"
+            suffix = "+tlrc"
+        else:
+            ext = prefix[ext_ind:]
+            suffix = ""
+
+    # All outputs should be in the same directory as the prefix
+    out_dir = os.path.dirname(os.path.abspath(prefix))
+
+    outputs["warped_source"] = (
+        fname_presuffix(prefix, suffix=suffix, use_ext=False, newpath=out_dir) + ext
+    )
+    if not inputs.nowarp:
+        outputs["source_warp"] = (
+            fname_presuffix(
+                prefix, suffix="_WARP" + suffix, use_ext=False, newpath=out_dir
+            )
+            + ext
+        )
+    if inputs.iwarp:
+        outputs["base_warp"] = (
+            fname_presuffix(
+                prefix, suffix="_WARPINV" + suffix, use_ext=False, newpath=out_dir
+            )
+            + ext
+        )
+    if inputs.out_weight_file is not attrs.NOTHING:
+        outputs["weights"] = os.path.abspath(inputs.out_weight_file)
+
+    if inputs.plusminus:
+        outputs["warped_source"] = (
+            fname_presuffix(
+                prefix, suffix="_PLUS" + suffix, use_ext=False, newpath=out_dir
+            )
+            + ext
+        )
+        outputs["warped_base"] = (
+            fname_presuffix(
+                prefix, suffix="_MINUS" + suffix, use_ext=False, newpath=out_dir
+            )
+            + ext
+        )
+        outputs["source_warp"] = (
+            fname_presuffix(
+                prefix, suffix="_PLUS_WARP" + suffix, use_ext=False, newpath=out_dir
+            )
+            + ext
+        )
+        outputs["base_warp"] = (
+            fname_presuffix(
+                prefix,
+                suffix="_MINUS_WARP" + suffix,
+                use_ext=False,
+                newpath=out_dir,
+            )
+            + ext
+        )
+    return outputs
diff --git a/example-specs/task/nipype/afni/re_ho_callables.py b/example-specs/task/nipype/afni/re_ho_callables.py
index b64e6a6c..a8563f41 100644
--- a/example-specs/task/nipype/afni/re_ho_callables.py
+++ b/example-specs/task/nipype/afni/re_ho_callables.py
@@ -1 +1,203 @@
 """Module to put any functions that are referred to in the "callables" section of ReHo.yaml"""
+
+import os
+import os.path as op
+import attrs
+import logging
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+def out_vals_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_vals"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def nipype_interfaces_afni__AFNICommandBase___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    if inputs.label_set:
+        outputs["out_vals"] = outputs["out_file"] + "_ROI_reho.vals"
+    return outputs
diff --git a/example-specs/task/nipype/afni/refit_callables.py b/example-specs/task/nipype/afni/refit_callables.py
index 7ec47a2c..8b1018aa 100644
--- a/example-specs/task/nipype/afni/refit_callables.py
+++ b/example-specs/task/nipype/afni/refit_callables.py
@@ -1 +1,20 @@
 """Module to put any functions that are referred to in the "callables" section of Refit.yaml"""
+
+import os
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = os.path.abspath(inputs.in_file)
+    return outputs
diff --git a/example-specs/task/nipype/afni/remlfit_callables.py b/example-specs/task/nipype/afni/remlfit_callables.py
index 9a3d9922..5f1c7fd1 100644
--- a/example-specs/task/nipype/afni/remlfit_callables.py
+++ b/example-specs/task/nipype/afni/remlfit_callables.py
@@ -1 +1,109 @@
 """Module to put any functions that are referred to in the "callables" section of Remlfit.yaml"""
+
+import os
+import attrs
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+def var_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["var_file"]
+
+
+def rbeta_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["rbeta_file"]
+
+
+def glt_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["glt_file"]
+
+
+def fitts_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["fitts_file"]
+
+
+def errts_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["errts_file"]
+
+
+def wherr_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["wherr_file"]
+
+
+def ovar_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["ovar"]
+
+
+def obeta_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["obeta"]
+
+
+def obuck_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["obuck"]
+
+
+def oglt_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["oglt"]
+
+
+def ofitts_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["ofitts"]
+
+
+def oerrts_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["oerrts"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+
+    for key in outputs.keys():
+        if inputs.get()[key] is not attrs.NOTHING:
+            outputs[key] = os.path.abspath(inputs.get()[key])
+
+    return outputs
diff --git a/example-specs/task/nipype/afni/resample_callables.py b/example-specs/task/nipype/afni/resample_callables.py
index d6f33aaa..4b7e79c4 100644
--- a/example-specs/task/nipype/afni/resample_callables.py
+++ b/example-specs/task/nipype/afni/resample_callables.py
@@ -1 +1,351 @@
 """Module to put any functions that are referred to in the "callables" section of Resample.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def nipype_interfaces_afni__AFNICommandBase___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """Handle afni output type and version information."""
+
+    __outputtype = "AFNI"
+    ftypes = {"NIFTI": ".nii", "AFNI": "", "NIFTI_GZ": ".nii.gz"}
+    version_cmd = "afni --version"
+
+    @staticmethod
+    def parse_version(raw_info):
+        """Check and parse AFNI's version."""
+        version_stamp = raw_info.split("\n")[0].split("Version ")[1]
+        if version_stamp.startswith("AFNI"):
+            version_stamp = version_stamp.split("AFNI_")[1]
+        elif version_stamp.startswith("Debian"):
+            version_stamp = version_stamp.split("Debian-")[1].split("~")[0]
+        else:
+            return None
+
+        version = LooseVersion(version_stamp.replace("_", ".")).version[:3]
+        if version[0] < 1000:
+            version[0] = version[0] + 2000
+        return tuple(version)
+
+    @classmethod
+    def output_type_to_ext(cls, outputtype):
+        """
+        Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        outputtype : {'NIFTI', 'NIFTI_GZ', 'AFNI'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+
+        """
+        try:
+            return cls.ftypes[outputtype]
+        except KeyError as e:
+            msg = "Invalid AFNIOUTPUTTYPE: ", outputtype
+            raise KeyError(msg) from e
+
+    @classmethod
+    def outputtype(cls):
+        """
+        Set default output filetype.
+
+        AFNI has no environment variables, Output filetypes get set in command line calls
+        Nipype uses ``AFNI`` as default
+
+
+        Returns
+        -------
+        None
+
+        """
+        return "AFNI"
+
+    @staticmethod
+    def standard_image(img_name):
+        """
+        Grab an image from the standard location.
+
+        Could be made more fancy to allow for more relocatability
+
+        """
+        clout = CommandLine(
+            "which afni",
+            ignore_exception=True,
+            resource_monitor=False,
+            terminal_output="allatonce",
+        ).run()
+        if clout.runtime.returncode != 0:
+            return None
+
+        out = clout.runtime.stdout
+        basedir = os.path.split(out)[0]
+        return os.path.join(basedir, img_name)
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
diff --git a/example-specs/task/nipype/afni/retroicor_callables.py b/example-specs/task/nipype/afni/retroicor_callables.py
index 83eb5eea..6e629342 100644
--- a/example-specs/task/nipype/afni/retroicor_callables.py
+++ b/example-specs/task/nipype/afni/retroicor_callables.py
@@ -1 +1,351 @@
 """Module to put any functions that are referred to in the "callables" section of Retroicor.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def nipype_interfaces_afni__AFNICommandBase___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """Handle afni output type and version information."""
+
+    __outputtype = "AFNI"
+    ftypes = {"NIFTI": ".nii", "AFNI": "", "NIFTI_GZ": ".nii.gz"}
+    version_cmd = "afni --version"
+
+    @staticmethod
+    def parse_version(raw_info):
+        """Check and parse AFNI's version."""
+        version_stamp = raw_info.split("\n")[0].split("Version ")[1]
+        if version_stamp.startswith("AFNI"):
+            version_stamp = version_stamp.split("AFNI_")[1]
+        elif version_stamp.startswith("Debian"):
+            version_stamp = version_stamp.split("Debian-")[1].split("~")[0]
+        else:
+            return None
+
+        version = LooseVersion(version_stamp.replace("_", ".")).version[:3]
+        if version[0] < 1000:
+            version[0] = version[0] + 2000
+        return tuple(version)
+
+    @classmethod
+    def output_type_to_ext(cls, outputtype):
+        """
+        Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        outputtype : {'NIFTI', 'NIFTI_GZ', 'AFNI'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+
+        """
+        try:
+            return cls.ftypes[outputtype]
+        except KeyError as e:
+            msg = "Invalid AFNIOUTPUTTYPE: ", outputtype
+            raise KeyError(msg) from e
+
+    @classmethod
+    def outputtype(cls):
+        """
+        Set default output filetype.
+
+        AFNI has no environment variables, Output filetypes get set in command line calls
+        Nipype uses ``AFNI`` as default
+
+
+        Returns
+        -------
+        None
+
+        """
+        return "AFNI"
+
+    @staticmethod
+    def standard_image(img_name):
+        """
+        Grab an image from the standard location.
+
+        Could be made more fancy to allow for more relocatability
+
+        """
+        clout = CommandLine(
+            "which afni",
+            ignore_exception=True,
+            resource_monitor=False,
+            terminal_output="allatonce",
+        ).run()
+        if clout.runtime.returncode != 0:
+            return None
+
+        out = clout.runtime.stdout
+        basedir = os.path.split(out)[0]
+        return os.path.join(basedir, img_name)
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
diff --git a/example-specs/task/nipype/afni/roi_stats_callables.py b/example-specs/task/nipype/afni/roi_stats_callables.py
index 3b987779..b61e2468 100644
--- a/example-specs/task/nipype/afni/roi_stats_callables.py
+++ b/example-specs/task/nipype/afni/roi_stats_callables.py
@@ -1 +1,187 @@
 """Module to put any functions that are referred to in the "callables" section of ROIStats.yaml"""
+
+import os
+import os.path as op
+import attrs
+import logging
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
diff --git a/example-specs/task/nipype/afni/seg_callables.py b/example-specs/task/nipype/afni/seg_callables.py
index 3c61b4ea..7b84ec6e 100644
--- a/example-specs/task/nipype/afni/seg_callables.py
+++ b/example-specs/task/nipype/afni/seg_callables.py
@@ -1 +1,187 @@
 """Module to put any functions that are referred to in the "callables" section of Seg.yaml"""
+
+import os
+import os.path as op
+import attrs
+import logging
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
diff --git a/example-specs/task/nipype/afni/skull_strip_callables.py b/example-specs/task/nipype/afni/skull_strip_callables.py
index ffbf4801..cd46720b 100644
--- a/example-specs/task/nipype/afni/skull_strip_callables.py
+++ b/example-specs/task/nipype/afni/skull_strip_callables.py
@@ -1 +1,351 @@
 """Module to put any functions that are referred to in the "callables" section of SkullStrip.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def nipype_interfaces_afni__AFNICommandBase___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """Handle afni output type and version information."""
+
+    __outputtype = "AFNI"
+    ftypes = {"NIFTI": ".nii", "AFNI": "", "NIFTI_GZ": ".nii.gz"}
+    version_cmd = "afni --version"
+
+    @staticmethod
+    def parse_version(raw_info):
+        """Check and parse AFNI's version."""
+        version_stamp = raw_info.split("\n")[0].split("Version ")[1]
+        if version_stamp.startswith("AFNI"):
+            version_stamp = version_stamp.split("AFNI_")[1]
+        elif version_stamp.startswith("Debian"):
+            version_stamp = version_stamp.split("Debian-")[1].split("~")[0]
+        else:
+            return None
+
+        version = LooseVersion(version_stamp.replace("_", ".")).version[:3]
+        if version[0] < 1000:
+            version[0] = version[0] + 2000
+        return tuple(version)
+
+    @classmethod
+    def output_type_to_ext(cls, outputtype):
+        """
+        Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        outputtype : {'NIFTI', 'NIFTI_GZ', 'AFNI'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+
+        """
+        try:
+            return cls.ftypes[outputtype]
+        except KeyError as e:
+            msg = "Invalid AFNIOUTPUTTYPE: ", outputtype
+            raise KeyError(msg) from e
+
+    @classmethod
+    def outputtype(cls):
+        """
+        Set default output filetype.
+
+        AFNI has no environment variables, Output filetypes get set in command line calls
+        Nipype uses ``AFNI`` as default
+
+
+        Returns
+        -------
+        None
+
+        """
+        return "AFNI"
+
+    @staticmethod
+    def standard_image(img_name):
+        """
+        Grab an image from the standard location.
+
+        Could be made more fancy to allow for more relocatability
+
+        """
+        clout = CommandLine(
+            "which afni",
+            ignore_exception=True,
+            resource_monitor=False,
+            terminal_output="allatonce",
+        ).run()
+        if clout.runtime.returncode != 0:
+            return None
+
+        out = clout.runtime.stdout
+        basedir = os.path.split(out)[0]
+        return os.path.join(basedir, img_name)
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
diff --git a/example-specs/task/nipype/afni/svm_test_callables.py b/example-specs/task/nipype/afni/svm_test_callables.py
index 1a9d6ae5..5002741c 100644
--- a/example-specs/task/nipype/afni/svm_test_callables.py
+++ b/example-specs/task/nipype/afni/svm_test_callables.py
@@ -1 +1,351 @@
 """Module to put any functions that are referred to in the "callables" section of SVMTest.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def nipype_interfaces_afni__AFNICommandBase___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """Handle afni output type and version information."""
+
+    __outputtype = "AFNI"
+    ftypes = {"NIFTI": ".nii", "AFNI": "", "NIFTI_GZ": ".nii.gz"}
+    version_cmd = "afni --version"
+
+    @staticmethod
+    def parse_version(raw_info):
+        """Check and parse AFNI's version."""
+        version_stamp = raw_info.split("\n")[0].split("Version ")[1]
+        if version_stamp.startswith("AFNI"):
+            version_stamp = version_stamp.split("AFNI_")[1]
+        elif version_stamp.startswith("Debian"):
+            version_stamp = version_stamp.split("Debian-")[1].split("~")[0]
+        else:
+            return None
+
+        version = LooseVersion(version_stamp.replace("_", ".")).version[:3]
+        if version[0] < 1000:
+            version[0] = version[0] + 2000
+        return tuple(version)
+
+    @classmethod
+    def output_type_to_ext(cls, outputtype):
+        """
+        Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        outputtype : {'NIFTI', 'NIFTI_GZ', 'AFNI'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+
+        """
+        try:
+            return cls.ftypes[outputtype]
+        except KeyError as e:
+            msg = "Invalid AFNIOUTPUTTYPE: ", outputtype
+            raise KeyError(msg) from e
+
+    @classmethod
+    def outputtype(cls):
+        """
+        Set default output filetype.
+
+        AFNI has no environment variables, Output filetypes get set in command line calls
+        Nipype uses ``AFNI`` as default
+
+
+        Returns
+        -------
+        None
+
+        """
+        return "AFNI"
+
+    @staticmethod
+    def standard_image(img_name):
+        """
+        Grab an image from the standard location.
+
+        Could be made more fancy to allow for more relocatability
+
+        """
+        clout = CommandLine(
+            "which afni",
+            ignore_exception=True,
+            resource_monitor=False,
+            terminal_output="allatonce",
+        ).run()
+        if clout.runtime.returncode != 0:
+            return None
+
+        out = clout.runtime.stdout
+        basedir = os.path.split(out)[0]
+        return os.path.join(basedir, img_name)
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
diff --git a/example-specs/task/nipype/afni/svm_train_callables.py b/example-specs/task/nipype/afni/svm_train_callables.py
index 3ee35f3f..c985b921 100644
--- a/example-specs/task/nipype/afni/svm_train_callables.py
+++ b/example-specs/task/nipype/afni/svm_train_callables.py
@@ -1 +1,365 @@
 """Module to put any functions that are referred to in the "callables" section of SVMTrain.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+def model_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["model"]
+
+
+def alphas_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["alphas"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def nipype_interfaces_afni__AFNICommandBase___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """Handle afni output type and version information."""
+
+    __outputtype = "AFNI"
+    ftypes = {"NIFTI": ".nii", "AFNI": "", "NIFTI_GZ": ".nii.gz"}
+    version_cmd = "afni --version"
+
+    @staticmethod
+    def parse_version(raw_info):
+        """Check and parse AFNI's version."""
+        version_stamp = raw_info.split("\n")[0].split("Version ")[1]
+        if version_stamp.startswith("AFNI"):
+            version_stamp = version_stamp.split("AFNI_")[1]
+        elif version_stamp.startswith("Debian"):
+            version_stamp = version_stamp.split("Debian-")[1].split("~")[0]
+        else:
+            return None
+
+        version = LooseVersion(version_stamp.replace("_", ".")).version[:3]
+        if version[0] < 1000:
+            version[0] = version[0] + 2000
+        return tuple(version)
+
+    @classmethod
+    def output_type_to_ext(cls, outputtype):
+        """
+        Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        outputtype : {'NIFTI', 'NIFTI_GZ', 'AFNI'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+
+        """
+        try:
+            return cls.ftypes[outputtype]
+        except KeyError as e:
+            msg = "Invalid AFNIOUTPUTTYPE: ", outputtype
+            raise KeyError(msg) from e
+
+    @classmethod
+    def outputtype(cls):
+        """
+        Set default output filetype.
+
+        AFNI has no environment variables, Output filetypes get set in command line calls
+        Nipype uses ``AFNI`` as default
+
+
+        Returns
+        -------
+        None
+
+        """
+        return "AFNI"
+
+    @staticmethod
+    def standard_image(img_name):
+        """
+        Grab an image from the standard location.
+
+        Could be made more fancy to allow for more relocatability
+
+        """
+        clout = CommandLine(
+            "which afni",
+            ignore_exception=True,
+            resource_monitor=False,
+            terminal_output="allatonce",
+        ).run()
+        if clout.runtime.returncode != 0:
+            return None
+
+        out = clout.runtime.stdout
+        basedir = os.path.split(out)[0]
+        return os.path.join(basedir, img_name)
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
diff --git a/example-specs/task/nipype/afni/synthesize_callables.py b/example-specs/task/nipype/afni/synthesize_callables.py
index 585387ab..e42e6aef 100644
--- a/example-specs/task/nipype/afni/synthesize_callables.py
+++ b/example-specs/task/nipype/afni/synthesize_callables.py
@@ -1 +1,25 @@
 """Module to put any functions that are referred to in the "callables" section of Synthesize.yaml"""
+
+import os
+import attrs
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+
+    for key in outputs.keys():
+        if inputs.get()[key] is not attrs.NOTHING:
+            outputs[key] = os.path.abspath(inputs.get()[key])
+
+    return outputs
diff --git a/example-specs/task/nipype/afni/t_cat_callables.py b/example-specs/task/nipype/afni/t_cat_callables.py
index b1e4956f..7c4941ce 100644
--- a/example-specs/task/nipype/afni/t_cat_callables.py
+++ b/example-specs/task/nipype/afni/t_cat_callables.py
@@ -1 +1,351 @@
 """Module to put any functions that are referred to in the "callables" section of TCat.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def nipype_interfaces_afni__AFNICommandBase___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """Handle afni output type and version information."""
+
+    __outputtype = "AFNI"
+    ftypes = {"NIFTI": ".nii", "AFNI": "", "NIFTI_GZ": ".nii.gz"}
+    version_cmd = "afni --version"
+
+    @staticmethod
+    def parse_version(raw_info):
+        """Check and parse AFNI's version."""
+        version_stamp = raw_info.split("\n")[0].split("Version ")[1]
+        if version_stamp.startswith("AFNI"):
+            version_stamp = version_stamp.split("AFNI_")[1]
+        elif version_stamp.startswith("Debian"):
+            version_stamp = version_stamp.split("Debian-")[1].split("~")[0]
+        else:
+            return None
+
+        version = LooseVersion(version_stamp.replace("_", ".")).version[:3]
+        if version[0] < 1000:
+            version[0] = version[0] + 2000
+        return tuple(version)
+
+    @classmethod
+    def output_type_to_ext(cls, outputtype):
+        """
+        Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        outputtype : {'NIFTI', 'NIFTI_GZ', 'AFNI'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+
+        """
+        try:
+            return cls.ftypes[outputtype]
+        except KeyError as e:
+            msg = "Invalid AFNIOUTPUTTYPE: ", outputtype
+            raise KeyError(msg) from e
+
+    @classmethod
+    def outputtype(cls):
+        """
+        Set default output filetype.
+
+        AFNI has no environment variables, Output filetypes get set in command line calls
+        Nipype uses ``AFNI`` as default
+
+
+        Returns
+        -------
+        None
+
+        """
+        return "AFNI"
+
+    @staticmethod
+    def standard_image(img_name):
+        """
+        Grab an image from the standard location.
+
+        Could be made more fancy to allow for more relocatability
+
+        """
+        clout = CommandLine(
+            "which afni",
+            ignore_exception=True,
+            resource_monitor=False,
+            terminal_output="allatonce",
+        ).run()
+        if clout.runtime.returncode != 0:
+            return None
+
+        out = clout.runtime.stdout
+        basedir = os.path.split(out)[0]
+        return os.path.join(basedir, img_name)
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
diff --git a/example-specs/task/nipype/afni/t_cat_sub_brick_callables.py b/example-specs/task/nipype/afni/t_cat_sub_brick_callables.py
index 5abad487..040c54bf 100644
--- a/example-specs/task/nipype/afni/t_cat_sub_brick_callables.py
+++ b/example-specs/task/nipype/afni/t_cat_sub_brick_callables.py
@@ -1 +1,459 @@
 """Module to put any functions that are referred to in the "callables" section of TCatSubBrick.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+
+
+def out_file_default(inputs):
+    return _gen_filename("out_file", inputs=inputs)
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def nipype_interfaces_afni__AFNICommandBase___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _gen_fname(
+            inputs.in_files[0][0],
+            suffix="_tcat",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """Handle afni output type and version information."""
+
+    __outputtype = "AFNI"
+    ftypes = {"NIFTI": ".nii", "AFNI": "", "NIFTI_GZ": ".nii.gz"}
+    version_cmd = "afni --version"
+
+    @staticmethod
+    def parse_version(raw_info):
+        """Check and parse AFNI's version."""
+        version_stamp = raw_info.split("\n")[0].split("Version ")[1]
+        if version_stamp.startswith("AFNI"):
+            version_stamp = version_stamp.split("AFNI_")[1]
+        elif version_stamp.startswith("Debian"):
+            version_stamp = version_stamp.split("Debian-")[1].split("~")[0]
+        else:
+            return None
+
+        version = LooseVersion(version_stamp.replace("_", ".")).version[:3]
+        if version[0] < 1000:
+            version[0] = version[0] + 2000
+        return tuple(version)
+
+    @classmethod
+    def output_type_to_ext(cls, outputtype):
+        """
+        Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        outputtype : {'NIFTI', 'NIFTI_GZ', 'AFNI'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+
+        """
+        try:
+            return cls.ftypes[outputtype]
+        except KeyError as e:
+            msg = "Invalid AFNIOUTPUTTYPE: ", outputtype
+            raise KeyError(msg) from e
+
+    @classmethod
+    def outputtype(cls):
+        """
+        Set default output filetype.
+
+        AFNI has no environment variables, Output filetypes get set in command line calls
+        Nipype uses ``AFNI`` as default
+
+
+        Returns
+        -------
+        None
+
+        """
+        return "AFNI"
+
+    @staticmethod
+    def standard_image(img_name):
+        """
+        Grab an image from the standard location.
+
+        Could be made more fancy to allow for more relocatability
+
+        """
+        clout = CommandLine(
+            "which afni",
+            ignore_exception=True,
+            resource_monitor=False,
+            terminal_output="allatonce",
+        ).run()
+        if clout.runtime.returncode != 0:
+            return None
+
+        out = clout.runtime.stdout
+        basedir = os.path.split(out)[0]
+        return os.path.join(basedir, img_name)
+
+
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """
+    Generate a filename based on the given parameters.
+
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
+
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
+
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+    if not basename:
+        msg = "Unable to generate filename for command %s. " % "3dTcat"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.outputtype)
+    if change_ext:
+        suffix = "".join((suffix, ext)) if suffix else ext
+
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
diff --git a/example-specs/task/nipype/afni/t_corr_1d_callables.py b/example-specs/task/nipype/afni/t_corr_1d_callables.py
index 9a0d0b90..74b88ff3 100644
--- a/example-specs/task/nipype/afni/t_corr_1d_callables.py
+++ b/example-specs/task/nipype/afni/t_corr_1d_callables.py
@@ -1 +1,351 @@
 """Module to put any functions that are referred to in the "callables" section of TCorr1D.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def nipype_interfaces_afni__AFNICommandBase___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """Handle afni output type and version information."""
+
+    __outputtype = "AFNI"
+    ftypes = {"NIFTI": ".nii", "AFNI": "", "NIFTI_GZ": ".nii.gz"}
+    version_cmd = "afni --version"
+
+    @staticmethod
+    def parse_version(raw_info):
+        """Check and parse AFNI's version."""
+        version_stamp = raw_info.split("\n")[0].split("Version ")[1]
+        if version_stamp.startswith("AFNI"):
+            version_stamp = version_stamp.split("AFNI_")[1]
+        elif version_stamp.startswith("Debian"):
+            version_stamp = version_stamp.split("Debian-")[1].split("~")[0]
+        else:
+            return None
+
+        version = LooseVersion(version_stamp.replace("_", ".")).version[:3]
+        if version[0] < 1000:
+            version[0] = version[0] + 2000
+        return tuple(version)
+
+    @classmethod
+    def output_type_to_ext(cls, outputtype):
+        """
+        Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        outputtype : {'NIFTI', 'NIFTI_GZ', 'AFNI'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+
+        """
+        try:
+            return cls.ftypes[outputtype]
+        except KeyError as e:
+            msg = "Invalid AFNIOUTPUTTYPE: ", outputtype
+            raise KeyError(msg) from e
+
+    @classmethod
+    def outputtype(cls):
+        """
+        Set default output filetype.
+
+        AFNI has no environment variables, Output filetypes get set in command line calls
+        Nipype uses ``AFNI`` as default
+
+
+        Returns
+        -------
+        None
+
+        """
+        return "AFNI"
+
+    @staticmethod
+    def standard_image(img_name):
+        """
+        Grab an image from the standard location.
+
+        Could be made more fancy to allow for more relocatability
+
+        """
+        clout = CommandLine(
+            "which afni",
+            ignore_exception=True,
+            resource_monitor=False,
+            terminal_output="allatonce",
+        ).run()
+        if clout.runtime.returncode != 0:
+            return None
+
+        out = clout.runtime.stdout
+        basedir = os.path.split(out)[0]
+        return os.path.join(basedir, img_name)
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
diff --git a/example-specs/task/nipype/afni/t_corr_map.yaml b/example-specs/task/nipype/afni/t_corr_map.yaml
index 3a4988a3..4436e621 100644
--- a/example-specs/task/nipype/afni/t_corr_map.yaml
+++ b/example-specs/task/nipype/afni/t_corr_map.yaml
@@ -161,7 +161,7 @@ tests:
     polort:
     # type=int|default=0: 
     bandpass:
-    # type=tuple|default=(<traits.trait_types.Float object at 0x10af6e590>, <traits.trait_types.Float object at 0x10af6e650>): 
+    # type=tuple|default=(<traits.trait_types.Float object at 0x10a991a90>, <traits.trait_types.Float object at 0x10a991dd0>): 
     regress_out_timeseries:
     # type=file|default=<undefined>: 
     blur_fwhm:
diff --git a/example-specs/task/nipype/afni/t_corr_map_callables.py b/example-specs/task/nipype/afni/t_corr_map_callables.py
index ad59b583..2807ade5 100644
--- a/example-specs/task/nipype/afni/t_corr_map_callables.py
+++ b/example-specs/task/nipype/afni/t_corr_map_callables.py
@@ -1 +1,435 @@
 """Module to put any functions that are referred to in the "callables" section of TCorrMap.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+
+
+def mean_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["mean_file"]
+
+
+def zmean_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["zmean"]
+
+
+def qmean_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["qmean"]
+
+
+def pmean_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["pmean"]
+
+
+def absolute_threshold_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["absolute_threshold"]
+
+
+def var_absolute_threshold_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["var_absolute_threshold"]
+
+
+def var_absolute_threshold_normalize_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["var_absolute_threshold_normalize"]
+
+
+def correlation_maps_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["correlation_maps"]
+
+
+def correlation_maps_masked_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["correlation_maps_masked"]
+
+
+def average_expr_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["average_expr"]
+
+
+def average_expr_nonzero_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["average_expr_nonzero"]
+
+
+def sum_expr_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["sum_expr"]
+
+
+def histogram_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["histogram"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def nipype_interfaces_afni__AFNICommandBase___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """Handle afni output type and version information."""
+
+    __outputtype = "AFNI"
+    ftypes = {"NIFTI": ".nii", "AFNI": "", "NIFTI_GZ": ".nii.gz"}
+    version_cmd = "afni --version"
+
+    @staticmethod
+    def parse_version(raw_info):
+        """Check and parse AFNI's version."""
+        version_stamp = raw_info.split("\n")[0].split("Version ")[1]
+        if version_stamp.startswith("AFNI"):
+            version_stamp = version_stamp.split("AFNI_")[1]
+        elif version_stamp.startswith("Debian"):
+            version_stamp = version_stamp.split("Debian-")[1].split("~")[0]
+        else:
+            return None
+
+        version = LooseVersion(version_stamp.replace("_", ".")).version[:3]
+        if version[0] < 1000:
+            version[0] = version[0] + 2000
+        return tuple(version)
+
+    @classmethod
+    def output_type_to_ext(cls, outputtype):
+        """
+        Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        outputtype : {'NIFTI', 'NIFTI_GZ', 'AFNI'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+
+        """
+        try:
+            return cls.ftypes[outputtype]
+        except KeyError as e:
+            msg = "Invalid AFNIOUTPUTTYPE: ", outputtype
+            raise KeyError(msg) from e
+
+    @classmethod
+    def outputtype(cls):
+        """
+        Set default output filetype.
+
+        AFNI has no environment variables, Output filetypes get set in command line calls
+        Nipype uses ``AFNI`` as default
+
+
+        Returns
+        -------
+        None
+
+        """
+        return "AFNI"
+
+    @staticmethod
+    def standard_image(img_name):
+        """
+        Grab an image from the standard location.
+
+        Could be made more fancy to allow for more relocatability
+
+        """
+        clout = CommandLine(
+            "which afni",
+            ignore_exception=True,
+            resource_monitor=False,
+            terminal_output="allatonce",
+        ).run()
+        if clout.runtime.returncode != 0:
+            return None
+
+        out = clout.runtime.stdout
+        basedir = os.path.split(out)[0]
+        return os.path.join(basedir, img_name)
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
diff --git a/example-specs/task/nipype/afni/t_correlate_callables.py b/example-specs/task/nipype/afni/t_correlate_callables.py
index 666c5b1f..28605f19 100644
--- a/example-specs/task/nipype/afni/t_correlate_callables.py
+++ b/example-specs/task/nipype/afni/t_correlate_callables.py
@@ -1 +1,351 @@
 """Module to put any functions that are referred to in the "callables" section of TCorrelate.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def nipype_interfaces_afni__AFNICommandBase___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """Handle afni output type and version information."""
+
+    __outputtype = "AFNI"
+    ftypes = {"NIFTI": ".nii", "AFNI": "", "NIFTI_GZ": ".nii.gz"}
+    version_cmd = "afni --version"
+
+    @staticmethod
+    def parse_version(raw_info):
+        """Check and parse AFNI's version."""
+        version_stamp = raw_info.split("\n")[0].split("Version ")[1]
+        if version_stamp.startswith("AFNI"):
+            version_stamp = version_stamp.split("AFNI_")[1]
+        elif version_stamp.startswith("Debian"):
+            version_stamp = version_stamp.split("Debian-")[1].split("~")[0]
+        else:
+            return None
+
+        version = LooseVersion(version_stamp.replace("_", ".")).version[:3]
+        if version[0] < 1000:
+            version[0] = version[0] + 2000
+        return tuple(version)
+
+    @classmethod
+    def output_type_to_ext(cls, outputtype):
+        """
+        Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        outputtype : {'NIFTI', 'NIFTI_GZ', 'AFNI'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+
+        """
+        try:
+            return cls.ftypes[outputtype]
+        except KeyError as e:
+            msg = "Invalid AFNIOUTPUTTYPE: ", outputtype
+            raise KeyError(msg) from e
+
+    @classmethod
+    def outputtype(cls):
+        """
+        Set default output filetype.
+
+        AFNI has no environment variables, Output filetypes get set in command line calls
+        Nipype uses ``AFNI`` as default
+
+
+        Returns
+        -------
+        None
+
+        """
+        return "AFNI"
+
+    @staticmethod
+    def standard_image(img_name):
+        """
+        Grab an image from the standard location.
+
+        Could be made more fancy to allow for more relocatability
+
+        """
+        clout = CommandLine(
+            "which afni",
+            ignore_exception=True,
+            resource_monitor=False,
+            terminal_output="allatonce",
+        ).run()
+        if clout.runtime.returncode != 0:
+            return None
+
+        out = clout.runtime.stdout
+        basedir = os.path.split(out)[0]
+        return os.path.join(basedir, img_name)
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
diff --git a/example-specs/task/nipype/afni/t_norm_callables.py b/example-specs/task/nipype/afni/t_norm_callables.py
index c23dd2fe..37c15427 100644
--- a/example-specs/task/nipype/afni/t_norm_callables.py
+++ b/example-specs/task/nipype/afni/t_norm_callables.py
@@ -1 +1,351 @@
 """Module to put any functions that are referred to in the "callables" section of TNorm.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def nipype_interfaces_afni__AFNICommandBase___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """Handle afni output type and version information."""
+
+    __outputtype = "AFNI"
+    ftypes = {"NIFTI": ".nii", "AFNI": "", "NIFTI_GZ": ".nii.gz"}
+    version_cmd = "afni --version"
+
+    @staticmethod
+    def parse_version(raw_info):
+        """Check and parse AFNI's version."""
+        version_stamp = raw_info.split("\n")[0].split("Version ")[1]
+        if version_stamp.startswith("AFNI"):
+            version_stamp = version_stamp.split("AFNI_")[1]
+        elif version_stamp.startswith("Debian"):
+            version_stamp = version_stamp.split("Debian-")[1].split("~")[0]
+        else:
+            return None
+
+        version = LooseVersion(version_stamp.replace("_", ".")).version[:3]
+        if version[0] < 1000:
+            version[0] = version[0] + 2000
+        return tuple(version)
+
+    @classmethod
+    def output_type_to_ext(cls, outputtype):
+        """
+        Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        outputtype : {'NIFTI', 'NIFTI_GZ', 'AFNI'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+
+        """
+        try:
+            return cls.ftypes[outputtype]
+        except KeyError as e:
+            msg = "Invalid AFNIOUTPUTTYPE: ", outputtype
+            raise KeyError(msg) from e
+
+    @classmethod
+    def outputtype(cls):
+        """
+        Set default output filetype.
+
+        AFNI has no environment variables, Output filetypes get set in command line calls
+        Nipype uses ``AFNI`` as default
+
+
+        Returns
+        -------
+        None
+
+        """
+        return "AFNI"
+
+    @staticmethod
+    def standard_image(img_name):
+        """
+        Grab an image from the standard location.
+
+        Could be made more fancy to allow for more relocatability
+
+        """
+        clout = CommandLine(
+            "which afni",
+            ignore_exception=True,
+            resource_monitor=False,
+            terminal_output="allatonce",
+        ).run()
+        if clout.runtime.returncode != 0:
+            return None
+
+        out = clout.runtime.stdout
+        basedir = os.path.split(out)[0]
+        return os.path.join(basedir, img_name)
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
diff --git a/example-specs/task/nipype/afni/t_project_callables.py b/example-specs/task/nipype/afni/t_project_callables.py
index 7f0383d4..73763425 100644
--- a/example-specs/task/nipype/afni/t_project_callables.py
+++ b/example-specs/task/nipype/afni/t_project_callables.py
@@ -1 +1,351 @@
 """Module to put any functions that are referred to in the "callables" section of TProject.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def nipype_interfaces_afni__AFNICommandBase___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """Handle afni output type and version information."""
+
+    __outputtype = "AFNI"
+    ftypes = {"NIFTI": ".nii", "AFNI": "", "NIFTI_GZ": ".nii.gz"}
+    version_cmd = "afni --version"
+
+    @staticmethod
+    def parse_version(raw_info):
+        """Check and parse AFNI's version."""
+        version_stamp = raw_info.split("\n")[0].split("Version ")[1]
+        if version_stamp.startswith("AFNI"):
+            version_stamp = version_stamp.split("AFNI_")[1]
+        elif version_stamp.startswith("Debian"):
+            version_stamp = version_stamp.split("Debian-")[1].split("~")[0]
+        else:
+            return None
+
+        version = LooseVersion(version_stamp.replace("_", ".")).version[:3]
+        if version[0] < 1000:
+            version[0] = version[0] + 2000
+        return tuple(version)
+
+    @classmethod
+    def output_type_to_ext(cls, outputtype):
+        """
+        Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        outputtype : {'NIFTI', 'NIFTI_GZ', 'AFNI'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+
+        """
+        try:
+            return cls.ftypes[outputtype]
+        except KeyError as e:
+            msg = "Invalid AFNIOUTPUTTYPE: ", outputtype
+            raise KeyError(msg) from e
+
+    @classmethod
+    def outputtype(cls):
+        """
+        Set default output filetype.
+
+        AFNI has no environment variables, Output filetypes get set in command line calls
+        Nipype uses ``AFNI`` as default
+
+
+        Returns
+        -------
+        None
+
+        """
+        return "AFNI"
+
+    @staticmethod
+    def standard_image(img_name):
+        """
+        Grab an image from the standard location.
+
+        Could be made more fancy to allow for more relocatability
+
+        """
+        clout = CommandLine(
+            "which afni",
+            ignore_exception=True,
+            resource_monitor=False,
+            terminal_output="allatonce",
+        ).run()
+        if clout.runtime.returncode != 0:
+            return None
+
+        out = clout.runtime.stdout
+        basedir = os.path.split(out)[0]
+        return os.path.join(basedir, img_name)
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
diff --git a/example-specs/task/nipype/afni/t_shift_callables.py b/example-specs/task/nipype/afni/t_shift_callables.py
index 9272e6ef..efcc9381 100644
--- a/example-specs/task/nipype/afni/t_shift_callables.py
+++ b/example-specs/task/nipype/afni/t_shift_callables.py
@@ -1 +1,355 @@
 """Module to put any functions that are referred to in the "callables" section of TShift.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+
+
+def timing_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["timing_file"]
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """Handle afni output type and version information."""
+
+    __outputtype = "AFNI"
+    ftypes = {"NIFTI": ".nii", "AFNI": "", "NIFTI_GZ": ".nii.gz"}
+    version_cmd = "afni --version"
+
+    @staticmethod
+    def parse_version(raw_info):
+        """Check and parse AFNI's version."""
+        version_stamp = raw_info.split("\n")[0].split("Version ")[1]
+        if version_stamp.startswith("AFNI"):
+            version_stamp = version_stamp.split("AFNI_")[1]
+        elif version_stamp.startswith("Debian"):
+            version_stamp = version_stamp.split("Debian-")[1].split("~")[0]
+        else:
+            return None
+
+        version = LooseVersion(version_stamp.replace("_", ".")).version[:3]
+        if version[0] < 1000:
+            version[0] = version[0] + 2000
+        return tuple(version)
+
+    @classmethod
+    def output_type_to_ext(cls, outputtype):
+        """
+        Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        outputtype : {'NIFTI', 'NIFTI_GZ', 'AFNI'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+
+        """
+        try:
+            return cls.ftypes[outputtype]
+        except KeyError as e:
+            msg = "Invalid AFNIOUTPUTTYPE: ", outputtype
+            raise KeyError(msg) from e
+
+    @classmethod
+    def outputtype(cls):
+        """
+        Set default output filetype.
+
+        AFNI has no environment variables, Output filetypes get set in command line calls
+        Nipype uses ``AFNI`` as default
+
+
+        Returns
+        -------
+        None
+
+        """
+        return "AFNI"
+
+    @staticmethod
+    def standard_image(img_name):
+        """
+        Grab an image from the standard location.
+
+        Could be made more fancy to allow for more relocatability
+
+        """
+        clout = CommandLine(
+            "which afni",
+            ignore_exception=True,
+            resource_monitor=False,
+            terminal_output="allatonce",
+        ).run()
+        if clout.runtime.returncode != 0:
+            return None
+
+        out = clout.runtime.stdout
+        basedir = os.path.split(out)[0]
+        return os.path.join(basedir, img_name)
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def nipype_interfaces_afni__AFNICommandBase___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    if inputs.slice_timing is not attrs.NOTHING:
+        if isinstance(inputs.slice_timing, list):
+            outputs["timing_file"] = os.path.abspath("slice_timing.1D")
+        else:
+            outputs["timing_file"] = os.path.abspath(inputs.slice_timing)
+    return outputs
diff --git a/example-specs/task/nipype/afni/t_smooth_callables.py b/example-specs/task/nipype/afni/t_smooth_callables.py
index e27dc268..cd0fdfce 100644
--- a/example-specs/task/nipype/afni/t_smooth_callables.py
+++ b/example-specs/task/nipype/afni/t_smooth_callables.py
@@ -1 +1,351 @@
 """Module to put any functions that are referred to in the "callables" section of TSmooth.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def nipype_interfaces_afni__AFNICommandBase___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """Handle afni output type and version information."""
+
+    __outputtype = "AFNI"
+    ftypes = {"NIFTI": ".nii", "AFNI": "", "NIFTI_GZ": ".nii.gz"}
+    version_cmd = "afni --version"
+
+    @staticmethod
+    def parse_version(raw_info):
+        """Check and parse AFNI's version."""
+        version_stamp = raw_info.split("\n")[0].split("Version ")[1]
+        if version_stamp.startswith("AFNI"):
+            version_stamp = version_stamp.split("AFNI_")[1]
+        elif version_stamp.startswith("Debian"):
+            version_stamp = version_stamp.split("Debian-")[1].split("~")[0]
+        else:
+            return None
+
+        version = LooseVersion(version_stamp.replace("_", ".")).version[:3]
+        if version[0] < 1000:
+            version[0] = version[0] + 2000
+        return tuple(version)
+
+    @classmethod
+    def output_type_to_ext(cls, outputtype):
+        """
+        Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        outputtype : {'NIFTI', 'NIFTI_GZ', 'AFNI'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+
+        """
+        try:
+            return cls.ftypes[outputtype]
+        except KeyError as e:
+            msg = "Invalid AFNIOUTPUTTYPE: ", outputtype
+            raise KeyError(msg) from e
+
+    @classmethod
+    def outputtype(cls):
+        """
+        Set default output filetype.
+
+        AFNI has no environment variables, Output filetypes get set in command line calls
+        Nipype uses ``AFNI`` as default
+
+
+        Returns
+        -------
+        None
+
+        """
+        return "AFNI"
+
+    @staticmethod
+    def standard_image(img_name):
+        """
+        Grab an image from the standard location.
+
+        Could be made more fancy to allow for more relocatability
+
+        """
+        clout = CommandLine(
+            "which afni",
+            ignore_exception=True,
+            resource_monitor=False,
+            terminal_output="allatonce",
+        ).run()
+        if clout.runtime.returncode != 0:
+            return None
+
+        out = clout.runtime.stdout
+        basedir = os.path.split(out)[0]
+        return os.path.join(basedir, img_name)
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
diff --git a/example-specs/task/nipype/afni/t_stat_callables.py b/example-specs/task/nipype/afni/t_stat_callables.py
index 03658302..f07c9596 100644
--- a/example-specs/task/nipype/afni/t_stat_callables.py
+++ b/example-specs/task/nipype/afni/t_stat_callables.py
@@ -1 +1,351 @@
 """Module to put any functions that are referred to in the "callables" section of TStat.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def nipype_interfaces_afni__AFNICommandBase___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """Handle afni output type and version information."""
+
+    __outputtype = "AFNI"
+    ftypes = {"NIFTI": ".nii", "AFNI": "", "NIFTI_GZ": ".nii.gz"}
+    version_cmd = "afni --version"
+
+    @staticmethod
+    def parse_version(raw_info):
+        """Check and parse AFNI's version."""
+        version_stamp = raw_info.split("\n")[0].split("Version ")[1]
+        if version_stamp.startswith("AFNI"):
+            version_stamp = version_stamp.split("AFNI_")[1]
+        elif version_stamp.startswith("Debian"):
+            version_stamp = version_stamp.split("Debian-")[1].split("~")[0]
+        else:
+            return None
+
+        version = LooseVersion(version_stamp.replace("_", ".")).version[:3]
+        if version[0] < 1000:
+            version[0] = version[0] + 2000
+        return tuple(version)
+
+    @classmethod
+    def output_type_to_ext(cls, outputtype):
+        """
+        Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        outputtype : {'NIFTI', 'NIFTI_GZ', 'AFNI'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+
+        """
+        try:
+            return cls.ftypes[outputtype]
+        except KeyError as e:
+            msg = "Invalid AFNIOUTPUTTYPE: ", outputtype
+            raise KeyError(msg) from e
+
+    @classmethod
+    def outputtype(cls):
+        """
+        Set default output filetype.
+
+        AFNI has no environment variables, Output filetypes get set in command line calls
+        Nipype uses ``AFNI`` as default
+
+
+        Returns
+        -------
+        None
+
+        """
+        return "AFNI"
+
+    @staticmethod
+    def standard_image(img_name):
+        """
+        Grab an image from the standard location.
+
+        Could be made more fancy to allow for more relocatability
+
+        """
+        clout = CommandLine(
+            "which afni",
+            ignore_exception=True,
+            resource_monitor=False,
+            terminal_output="allatonce",
+        ).run()
+        if clout.runtime.returncode != 0:
+            return None
+
+        out = clout.runtime.stdout
+        basedir = os.path.split(out)[0]
+        return os.path.join(basedir, img_name)
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
diff --git a/example-specs/task/nipype/afni/to_3d_callables.py b/example-specs/task/nipype/afni/to_3d_callables.py
index b03a6700..f9475285 100644
--- a/example-specs/task/nipype/afni/to_3d_callables.py
+++ b/example-specs/task/nipype/afni/to_3d_callables.py
@@ -1 +1,351 @@
 """Module to put any functions that are referred to in the "callables" section of To3D.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def nipype_interfaces_afni__AFNICommandBase___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """Handle afni output type and version information."""
+
+    __outputtype = "AFNI"
+    ftypes = {"NIFTI": ".nii", "AFNI": "", "NIFTI_GZ": ".nii.gz"}
+    version_cmd = "afni --version"
+
+    @staticmethod
+    def parse_version(raw_info):
+        """Check and parse AFNI's version."""
+        version_stamp = raw_info.split("\n")[0].split("Version ")[1]
+        if version_stamp.startswith("AFNI"):
+            version_stamp = version_stamp.split("AFNI_")[1]
+        elif version_stamp.startswith("Debian"):
+            version_stamp = version_stamp.split("Debian-")[1].split("~")[0]
+        else:
+            return None
+
+        version = LooseVersion(version_stamp.replace("_", ".")).version[:3]
+        if version[0] < 1000:
+            version[0] = version[0] + 2000
+        return tuple(version)
+
+    @classmethod
+    def output_type_to_ext(cls, outputtype):
+        """
+        Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        outputtype : {'NIFTI', 'NIFTI_GZ', 'AFNI'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+
+        """
+        try:
+            return cls.ftypes[outputtype]
+        except KeyError as e:
+            msg = "Invalid AFNIOUTPUTTYPE: ", outputtype
+            raise KeyError(msg) from e
+
+    @classmethod
+    def outputtype(cls):
+        """
+        Set default output filetype.
+
+        AFNI has no environment variables, Output filetypes get set in command line calls
+        Nipype uses ``AFNI`` as default
+
+
+        Returns
+        -------
+        None
+
+        """
+        return "AFNI"
+
+    @staticmethod
+    def standard_image(img_name):
+        """
+        Grab an image from the standard location.
+
+        Could be made more fancy to allow for more relocatability
+
+        """
+        clout = CommandLine(
+            "which afni",
+            ignore_exception=True,
+            resource_monitor=False,
+            terminal_output="allatonce",
+        ).run()
+        if clout.runtime.returncode != 0:
+            return None
+
+        out = clout.runtime.stdout
+        basedir = os.path.split(out)[0]
+        return os.path.join(basedir, img_name)
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
diff --git a/example-specs/task/nipype/afni/undump_callables.py b/example-specs/task/nipype/afni/undump_callables.py
index d549409b..3fd38408 100644
--- a/example-specs/task/nipype/afni/undump_callables.py
+++ b/example-specs/task/nipype/afni/undump_callables.py
@@ -1 +1,351 @@
 """Module to put any functions that are referred to in the "callables" section of Undump.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def nipype_interfaces_afni__AFNICommandBase___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """Handle afni output type and version information."""
+
+    __outputtype = "AFNI"
+    ftypes = {"NIFTI": ".nii", "AFNI": "", "NIFTI_GZ": ".nii.gz"}
+    version_cmd = "afni --version"
+
+    @staticmethod
+    def parse_version(raw_info):
+        """Check and parse AFNI's version."""
+        version_stamp = raw_info.split("\n")[0].split("Version ")[1]
+        if version_stamp.startswith("AFNI"):
+            version_stamp = version_stamp.split("AFNI_")[1]
+        elif version_stamp.startswith("Debian"):
+            version_stamp = version_stamp.split("Debian-")[1].split("~")[0]
+        else:
+            return None
+
+        version = LooseVersion(version_stamp.replace("_", ".")).version[:3]
+        if version[0] < 1000:
+            version[0] = version[0] + 2000
+        return tuple(version)
+
+    @classmethod
+    def output_type_to_ext(cls, outputtype):
+        """
+        Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        outputtype : {'NIFTI', 'NIFTI_GZ', 'AFNI'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+
+        """
+        try:
+            return cls.ftypes[outputtype]
+        except KeyError as e:
+            msg = "Invalid AFNIOUTPUTTYPE: ", outputtype
+            raise KeyError(msg) from e
+
+    @classmethod
+    def outputtype(cls):
+        """
+        Set default output filetype.
+
+        AFNI has no environment variables, Output filetypes get set in command line calls
+        Nipype uses ``AFNI`` as default
+
+
+        Returns
+        -------
+        None
+
+        """
+        return "AFNI"
+
+    @staticmethod
+    def standard_image(img_name):
+        """
+        Grab an image from the standard location.
+
+        Could be made more fancy to allow for more relocatability
+
+        """
+        clout = CommandLine(
+            "which afni",
+            ignore_exception=True,
+            resource_monitor=False,
+            terminal_output="allatonce",
+        ).run()
+        if clout.runtime.returncode != 0:
+            return None
+
+        out = clout.runtime.stdout
+        basedir = os.path.split(out)[0]
+        return os.path.join(basedir, img_name)
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
diff --git a/example-specs/task/nipype/afni/unifize_callables.py b/example-specs/task/nipype/afni/unifize_callables.py
index fccd5af3..3dad41ce 100644
--- a/example-specs/task/nipype/afni/unifize_callables.py
+++ b/example-specs/task/nipype/afni/unifize_callables.py
@@ -1 +1,358 @@
 """Module to put any functions that are referred to in the "callables" section of Unifize.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+
+
+def scale_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["scale_file"]
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def nipype_interfaces_afni__AFNICommandBase___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """Handle afni output type and version information."""
+
+    __outputtype = "AFNI"
+    ftypes = {"NIFTI": ".nii", "AFNI": "", "NIFTI_GZ": ".nii.gz"}
+    version_cmd = "afni --version"
+
+    @staticmethod
+    def parse_version(raw_info):
+        """Check and parse AFNI's version."""
+        version_stamp = raw_info.split("\n")[0].split("Version ")[1]
+        if version_stamp.startswith("AFNI"):
+            version_stamp = version_stamp.split("AFNI_")[1]
+        elif version_stamp.startswith("Debian"):
+            version_stamp = version_stamp.split("Debian-")[1].split("~")[0]
+        else:
+            return None
+
+        version = LooseVersion(version_stamp.replace("_", ".")).version[:3]
+        if version[0] < 1000:
+            version[0] = version[0] + 2000
+        return tuple(version)
+
+    @classmethod
+    def output_type_to_ext(cls, outputtype):
+        """
+        Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        outputtype : {'NIFTI', 'NIFTI_GZ', 'AFNI'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+
+        """
+        try:
+            return cls.ftypes[outputtype]
+        except KeyError as e:
+            msg = "Invalid AFNIOUTPUTTYPE: ", outputtype
+            raise KeyError(msg) from e
+
+    @classmethod
+    def outputtype(cls):
+        """
+        Set default output filetype.
+
+        AFNI has no environment variables, Output filetypes get set in command line calls
+        Nipype uses ``AFNI`` as default
+
+
+        Returns
+        -------
+        None
+
+        """
+        return "AFNI"
+
+    @staticmethod
+    def standard_image(img_name):
+        """
+        Grab an image from the standard location.
+
+        Could be made more fancy to allow for more relocatability
+
+        """
+        clout = CommandLine(
+            "which afni",
+            ignore_exception=True,
+            resource_monitor=False,
+            terminal_output="allatonce",
+        ).run()
+        if clout.runtime.returncode != 0:
+            return None
+
+        out = clout.runtime.stdout
+        basedir = os.path.split(out)[0]
+        return os.path.join(basedir, img_name)
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
diff --git a/example-specs/task/nipype/afni/volreg_callables.py b/example-specs/task/nipype/afni/volreg_callables.py
index 0ca457b4..4e5b9644 100644
--- a/example-specs/task/nipype/afni/volreg_callables.py
+++ b/example-specs/task/nipype/afni/volreg_callables.py
@@ -1 +1,372 @@
 """Module to put any functions that are referred to in the "callables" section of Volreg.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+def md1d_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["md1d_file"]
+
+
+def oned_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["oned_file"]
+
+
+def oned_matrix_save_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["oned_matrix_save"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def nipype_interfaces_afni__AFNICommandBase___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """Handle afni output type and version information."""
+
+    __outputtype = "AFNI"
+    ftypes = {"NIFTI": ".nii", "AFNI": "", "NIFTI_GZ": ".nii.gz"}
+    version_cmd = "afni --version"
+
+    @staticmethod
+    def parse_version(raw_info):
+        """Check and parse AFNI's version."""
+        version_stamp = raw_info.split("\n")[0].split("Version ")[1]
+        if version_stamp.startswith("AFNI"):
+            version_stamp = version_stamp.split("AFNI_")[1]
+        elif version_stamp.startswith("Debian"):
+            version_stamp = version_stamp.split("Debian-")[1].split("~")[0]
+        else:
+            return None
+
+        version = LooseVersion(version_stamp.replace("_", ".")).version[:3]
+        if version[0] < 1000:
+            version[0] = version[0] + 2000
+        return tuple(version)
+
+    @classmethod
+    def output_type_to_ext(cls, outputtype):
+        """
+        Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        outputtype : {'NIFTI', 'NIFTI_GZ', 'AFNI'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+
+        """
+        try:
+            return cls.ftypes[outputtype]
+        except KeyError as e:
+            msg = "Invalid AFNIOUTPUTTYPE: ", outputtype
+            raise KeyError(msg) from e
+
+    @classmethod
+    def outputtype(cls):
+        """
+        Set default output filetype.
+
+        AFNI has no environment variables, Output filetypes get set in command line calls
+        Nipype uses ``AFNI`` as default
+
+
+        Returns
+        -------
+        None
+
+        """
+        return "AFNI"
+
+    @staticmethod
+    def standard_image(img_name):
+        """
+        Grab an image from the standard location.
+
+        Could be made more fancy to allow for more relocatability
+
+        """
+        clout = CommandLine(
+            "which afni",
+            ignore_exception=True,
+            resource_monitor=False,
+            terminal_output="allatonce",
+        ).run()
+        if clout.runtime.returncode != 0:
+            return None
+
+        out = clout.runtime.stdout
+        basedir = os.path.split(out)[0]
+        return os.path.join(basedir, img_name)
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
diff --git a/example-specs/task/nipype/afni/warp_callables.py b/example-specs/task/nipype/afni/warp_callables.py
index 56e75cc8..7a9c2285 100644
--- a/example-specs/task/nipype/afni/warp_callables.py
+++ b/example-specs/task/nipype/afni/warp_callables.py
@@ -1 +1,447 @@
 """Module to put any functions that are referred to in the "callables" section of Warp.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+def warp_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["warp_file"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """Handle afni output type and version information."""
+
+    __outputtype = "AFNI"
+    ftypes = {"NIFTI": ".nii", "AFNI": "", "NIFTI_GZ": ".nii.gz"}
+    version_cmd = "afni --version"
+
+    @staticmethod
+    def parse_version(raw_info):
+        """Check and parse AFNI's version."""
+        version_stamp = raw_info.split("\n")[0].split("Version ")[1]
+        if version_stamp.startswith("AFNI"):
+            version_stamp = version_stamp.split("AFNI_")[1]
+        elif version_stamp.startswith("Debian"):
+            version_stamp = version_stamp.split("Debian-")[1].split("~")[0]
+        else:
+            return None
+
+        version = LooseVersion(version_stamp.replace("_", ".")).version[:3]
+        if version[0] < 1000:
+            version[0] = version[0] + 2000
+        return tuple(version)
+
+    @classmethod
+    def output_type_to_ext(cls, outputtype):
+        """
+        Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        outputtype : {'NIFTI', 'NIFTI_GZ', 'AFNI'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+
+        """
+        try:
+            return cls.ftypes[outputtype]
+        except KeyError as e:
+            msg = "Invalid AFNIOUTPUTTYPE: ", outputtype
+            raise KeyError(msg) from e
+
+    @classmethod
+    def outputtype(cls):
+        """
+        Set default output filetype.
+
+        AFNI has no environment variables, Output filetypes get set in command line calls
+        Nipype uses ``AFNI`` as default
+
+
+        Returns
+        -------
+        None
+
+        """
+        return "AFNI"
+
+    @staticmethod
+    def standard_image(img_name):
+        """
+        Grab an image from the standard location.
+
+        Could be made more fancy to allow for more relocatability
+
+        """
+        clout = CommandLine(
+            "which afni",
+            ignore_exception=True,
+            resource_monitor=False,
+            terminal_output="allatonce",
+        ).run()
+        if clout.runtime.returncode != 0:
+            return None
+
+        out = clout.runtime.stdout
+        basedir = os.path.split(out)[0]
+        return os.path.join(basedir, img_name)
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def nipype_interfaces_afni__AFNICommandBase___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    if inputs.save_warp:
+        outputs["warp_file"] = fname_presuffix(
+            outputs["out_file"], suffix="_transform.mat", use_ext=False
+        )
+
+    return outputs
diff --git a/example-specs/task/nipype/afni/z_cut_up_callables.py b/example-specs/task/nipype/afni/z_cut_up_callables.py
index 5e6f7ecc..2403dc5e 100644
--- a/example-specs/task/nipype/afni/z_cut_up_callables.py
+++ b/example-specs/task/nipype/afni/z_cut_up_callables.py
@@ -1 +1,351 @@
 """Module to put any functions that are referred to in the "callables" section of ZCutUp.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def nipype_interfaces_afni__AFNICommandBase___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """Handle afni output type and version information."""
+
+    __outputtype = "AFNI"
+    ftypes = {"NIFTI": ".nii", "AFNI": "", "NIFTI_GZ": ".nii.gz"}
+    version_cmd = "afni --version"
+
+    @staticmethod
+    def parse_version(raw_info):
+        """Check and parse AFNI's version."""
+        version_stamp = raw_info.split("\n")[0].split("Version ")[1]
+        if version_stamp.startswith("AFNI"):
+            version_stamp = version_stamp.split("AFNI_")[1]
+        elif version_stamp.startswith("Debian"):
+            version_stamp = version_stamp.split("Debian-")[1].split("~")[0]
+        else:
+            return None
+
+        version = LooseVersion(version_stamp.replace("_", ".")).version[:3]
+        if version[0] < 1000:
+            version[0] = version[0] + 2000
+        return tuple(version)
+
+    @classmethod
+    def output_type_to_ext(cls, outputtype):
+        """
+        Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        outputtype : {'NIFTI', 'NIFTI_GZ', 'AFNI'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+
+        """
+        try:
+            return cls.ftypes[outputtype]
+        except KeyError as e:
+            msg = "Invalid AFNIOUTPUTTYPE: ", outputtype
+            raise KeyError(msg) from e
+
+    @classmethod
+    def outputtype(cls):
+        """
+        Set default output filetype.
+
+        AFNI has no environment variables, Output filetypes get set in command line calls
+        Nipype uses ``AFNI`` as default
+
+
+        Returns
+        -------
+        None
+
+        """
+        return "AFNI"
+
+    @staticmethod
+    def standard_image(img_name):
+        """
+        Grab an image from the standard location.
+
+        Could be made more fancy to allow for more relocatability
+
+        """
+        clout = CommandLine(
+            "which afni",
+            ignore_exception=True,
+            resource_monitor=False,
+            terminal_output="allatonce",
+        ).run()
+        if clout.runtime.returncode != 0:
+            return None
+
+        out = clout.runtime.stdout
+        basedir = os.path.split(out)[0]
+        return os.path.join(basedir, img_name)
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
diff --git a/example-specs/task/nipype/afni/zcat_callables.py b/example-specs/task/nipype/afni/zcat_callables.py
index 3c00bd17..7cc24cba 100644
--- a/example-specs/task/nipype/afni/zcat_callables.py
+++ b/example-specs/task/nipype/afni/zcat_callables.py
@@ -1 +1,351 @@
 """Module to put any functions that are referred to in the "callables" section of Zcat.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def nipype_interfaces_afni__AFNICommandBase___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """Handle afni output type and version information."""
+
+    __outputtype = "AFNI"
+    ftypes = {"NIFTI": ".nii", "AFNI": "", "NIFTI_GZ": ".nii.gz"}
+    version_cmd = "afni --version"
+
+    @staticmethod
+    def parse_version(raw_info):
+        """Check and parse AFNI's version."""
+        version_stamp = raw_info.split("\n")[0].split("Version ")[1]
+        if version_stamp.startswith("AFNI"):
+            version_stamp = version_stamp.split("AFNI_")[1]
+        elif version_stamp.startswith("Debian"):
+            version_stamp = version_stamp.split("Debian-")[1].split("~")[0]
+        else:
+            return None
+
+        version = LooseVersion(version_stamp.replace("_", ".")).version[:3]
+        if version[0] < 1000:
+            version[0] = version[0] + 2000
+        return tuple(version)
+
+    @classmethod
+    def output_type_to_ext(cls, outputtype):
+        """
+        Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        outputtype : {'NIFTI', 'NIFTI_GZ', 'AFNI'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+
+        """
+        try:
+            return cls.ftypes[outputtype]
+        except KeyError as e:
+            msg = "Invalid AFNIOUTPUTTYPE: ", outputtype
+            raise KeyError(msg) from e
+
+    @classmethod
+    def outputtype(cls):
+        """
+        Set default output filetype.
+
+        AFNI has no environment variables, Output filetypes get set in command line calls
+        Nipype uses ``AFNI`` as default
+
+
+        Returns
+        -------
+        None
+
+        """
+        return "AFNI"
+
+    @staticmethod
+    def standard_image(img_name):
+        """
+        Grab an image from the standard location.
+
+        Could be made more fancy to allow for more relocatability
+
+        """
+        clout = CommandLine(
+            "which afni",
+            ignore_exception=True,
+            resource_monitor=False,
+            terminal_output="allatonce",
+        ).run()
+        if clout.runtime.returncode != 0:
+            return None
+
+        out = clout.runtime.stdout
+        basedir = os.path.split(out)[0]
+        return os.path.join(basedir, img_name)
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
diff --git a/example-specs/task/nipype/afni/zeropad_callables.py b/example-specs/task/nipype/afni/zeropad_callables.py
index 14e582d6..25a978a6 100644
--- a/example-specs/task/nipype/afni/zeropad_callables.py
+++ b/example-specs/task/nipype/afni/zeropad_callables.py
@@ -1 +1,351 @@
 """Module to put any functions that are referred to in the "callables" section of Zeropad.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def nipype_interfaces_afni__AFNICommandBase___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """Handle afni output type and version information."""
+
+    __outputtype = "AFNI"
+    ftypes = {"NIFTI": ".nii", "AFNI": "", "NIFTI_GZ": ".nii.gz"}
+    version_cmd = "afni --version"
+
+    @staticmethod
+    def parse_version(raw_info):
+        """Check and parse AFNI's version."""
+        version_stamp = raw_info.split("\n")[0].split("Version ")[1]
+        if version_stamp.startswith("AFNI"):
+            version_stamp = version_stamp.split("AFNI_")[1]
+        elif version_stamp.startswith("Debian"):
+            version_stamp = version_stamp.split("Debian-")[1].split("~")[0]
+        else:
+            return None
+
+        version = LooseVersion(version_stamp.replace("_", ".")).version[:3]
+        if version[0] < 1000:
+            version[0] = version[0] + 2000
+        return tuple(version)
+
+    @classmethod
+    def output_type_to_ext(cls, outputtype):
+        """
+        Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        outputtype : {'NIFTI', 'NIFTI_GZ', 'AFNI'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+
+        """
+        try:
+            return cls.ftypes[outputtype]
+        except KeyError as e:
+            msg = "Invalid AFNIOUTPUTTYPE: ", outputtype
+            raise KeyError(msg) from e
+
+    @classmethod
+    def outputtype(cls):
+        """
+        Set default output filetype.
+
+        AFNI has no environment variables, Output filetypes get set in command line calls
+        Nipype uses ``AFNI`` as default
+
+
+        Returns
+        -------
+        None
+
+        """
+        return "AFNI"
+
+    @staticmethod
+    def standard_image(img_name):
+        """
+        Grab an image from the standard location.
+
+        Could be made more fancy to allow for more relocatability
+
+        """
+        clout = CommandLine(
+            "which afni",
+            ignore_exception=True,
+            resource_monitor=False,
+            terminal_output="allatonce",
+        ).run()
+        if clout.runtime.returncode != 0:
+            return None
+
+        out = clout.runtime.stdout
+        basedir = os.path.split(out)[0]
+        return os.path.join(basedir, img_name)
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
diff --git a/example-specs/task/nipype/ants/affine_initializer_callables.py b/example-specs/task/nipype/ants/affine_initializer_callables.py
index e438336f..90fccc67 100644
--- a/example-specs/task/nipype/ants/affine_initializer_callables.py
+++ b/example-specs/task/nipype/ants/affine_initializer_callables.py
@@ -1 +1,18 @@
 """Module to put any functions that are referred to in the "callables" section of AffineInitializer.yaml"""
+
+import os
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    return {"out_file": os.path.abspath(inputs.out_file)}
diff --git a/example-specs/task/nipype/ants/ai_callables.py b/example-specs/task/nipype/ants/ai_callables.py
index 84c22ddd..50eef097 100644
--- a/example-specs/task/nipype/ants/ai_callables.py
+++ b/example-specs/task/nipype/ants/ai_callables.py
@@ -1 +1,16 @@
 """Module to put any functions that are referred to in the "callables" section of AI.yaml"""
+
+
+def output_transform_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["output_transform"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    return getattr(self, "_output")
diff --git a/example-specs/task/nipype/ants/ants_callables.py b/example-specs/task/nipype/ants/ants_callables.py
index 2245171d..ddea22ee 100644
--- a/example-specs/task/nipype/ants/ants_callables.py
+++ b/example-specs/task/nipype/ants/ants_callables.py
@@ -1 +1,58 @@
 """Module to put any functions that are referred to in the "callables" section of ANTS.yaml"""
+
+import os
+
+
+def affine_transform_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["affine_transform"]
+
+
+def warp_transform_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["warp_transform"]
+
+
+def inverse_warp_transform_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["inverse_warp_transform"]
+
+
+def metaheader_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["metaheader"]
+
+
+def metaheader_raw_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["metaheader_raw"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["affine_transform"] = os.path.abspath(
+        inputs.output_transform_prefix + "Affine.txt"
+    )
+    outputs["warp_transform"] = os.path.abspath(
+        inputs.output_transform_prefix + "Warp.nii.gz"
+    )
+    outputs["inverse_warp_transform"] = os.path.abspath(
+        inputs.output_transform_prefix + "InverseWarp.nii.gz"
+    )
+    # outputs['metaheader'] = os.path.abspath(inputs.output_transform_prefix + 'velocity.mhd')
+    # outputs['metaheader_raw'] = os.path.abspath(inputs.output_transform_prefix + 'velocity.raw')
+    return outputs
diff --git a/example-specs/task/nipype/ants/ants_introduction_callables.py b/example-specs/task/nipype/ants/ants_introduction_callables.py
index 74ee5c8f..eafba515 100644
--- a/example-specs/task/nipype/ants/ants_introduction_callables.py
+++ b/example-specs/task/nipype/ants/ants_introduction_callables.py
@@ -1 +1,72 @@
 """Module to put any functions that are referred to in the "callables" section of antsIntroduction.yaml"""
+
+import os
+import attrs
+
+
+def affine_transformation_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["affine_transformation"]
+
+
+def warp_field_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["warp_field"]
+
+
+def inverse_warp_field_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["inverse_warp_field"]
+
+
+def input_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["input_file"]
+
+
+def output_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["output_file"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    transmodel = inputs.transformation_model
+
+    # When transform is set as 'RI'/'RA', wrap fields should not be expected
+    # The default transformation is GR, which outputs the wrap fields
+    if (transmodel is attrs.NOTHING) or (
+        (transmodel is not attrs.NOTHING) and transmodel not in ["RI", "RA"]
+    ):
+        outputs["warp_field"] = os.path.join(
+            output_dir, inputs.out_prefix + "Warp.nii.gz"
+        )
+        outputs["inverse_warp_field"] = os.path.join(
+            output_dir, inputs.out_prefix + "InverseWarp.nii.gz"
+        )
+
+    outputs["affine_transformation"] = os.path.join(
+        output_dir, inputs.out_prefix + "Affine.txt"
+    )
+    outputs["input_file"] = os.path.join(
+        output_dir, inputs.out_prefix + "repaired.nii.gz"
+    )
+    outputs["output_file"] = os.path.join(
+        output_dir, inputs.out_prefix + "deformed.nii.gz"
+    )
+
+    return outputs
diff --git a/example-specs/task/nipype/ants/apply_transforms_callables.py b/example-specs/task/nipype/ants/apply_transforms_callables.py
index dd38b019..3e41684e 100644
--- a/example-specs/task/nipype/ants/apply_transforms_callables.py
+++ b/example-specs/task/nipype/ants/apply_transforms_callables.py
@@ -1 +1,90 @@
 """Module to put any functions that are referred to in the "callables" section of ApplyTransforms.yaml"""
+
+import os
+import attrs
+import os.path as op
+
+
+def output_image_default(inputs):
+    return _gen_filename("output_image", inputs=inputs)
+
+
+def output_image_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["output_image"]
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "output_image":
+        output = inputs.output_image
+        if output is attrs.NOTHING:
+            _, name, ext = split_filename(inputs.input_image)
+            output = name + inputs.out_postfix + ext
+        return output
+    return None
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["output_image"] = os.path.abspath(
+        _gen_filename(
+            "output_image",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    )
+    return outputs
diff --git a/example-specs/task/nipype/ants/apply_transforms_to_points_callables.py b/example-specs/task/nipype/ants/apply_transforms_to_points_callables.py
index dc9684a9..90a0da3d 100644
--- a/example-specs/task/nipype/ants/apply_transforms_to_points_callables.py
+++ b/example-specs/task/nipype/ants/apply_transforms_to_points_callables.py
@@ -1 +1,187 @@
 """Module to put any functions that are referred to in the "callables" section of ApplyTransformsToPoints.yaml"""
+
+import os
+import os.path as op
+import attrs
+import logging
+
+
+def output_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["output_file"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
diff --git a/example-specs/task/nipype/ants/atropos.yaml b/example-specs/task/nipype/ants/atropos.yaml
index a7665fee..25cd1f35 100644
--- a/example-specs/task/nipype/ants/atropos.yaml
+++ b/example-specs/task/nipype/ants/atropos.yaml
@@ -117,6 +117,8 @@ outputs:
   # passed to the field in the automatically generated unittests.
     classified_image: generic/file
     # type=file: 
+    posteriors: generic/file+list-of
+    # type=outputmultiobject: 
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/ants/atropos_callables.py b/example-specs/task/nipype/ants/atropos_callables.py
index f8a0d92b..f48c0db8 100644
--- a/example-specs/task/nipype/ants/atropos_callables.py
+++ b/example-specs/task/nipype/ants/atropos_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of Atropos.yaml"""
 
-import attrs
 import os
+import attrs
 import os.path as op
 
 
@@ -9,11 +9,18 @@ def out_classified_image_name_default(inputs):
     return _gen_filename("out_classified_image_name", inputs=inputs)
 
 
-def out_classified_image_name_callable(output_dir, inputs, stdout, stderr):
+def classified_image_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["classified_image"]
+
+
+def posteriors_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_classified_image_name"]
+    return outputs["posteriors"]
 
 
 def split_filename(fname):
@@ -66,6 +73,15 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_classified_image_name":
+        output = inputs.out_classified_image_name
+        if output is attrs.NOTHING:
+            _, name, ext = split_filename(inputs.intensity_images[0])
+            output = name + "_labeled" + ext
+        return output
+
+
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["classified_image"] = os.path.abspath(
@@ -77,19 +93,10 @@ def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
             output_dir=output_dir,
         )
     )
-    if inputs.save_posteriors is not attrs.NOTHING and inputs.save_posteriors:
+    if (inputs.save_posteriors is not attrs.NOTHING) and inputs.save_posteriors:
         outputs["posteriors"] = []
         for i in range(inputs.number_of_tissue_classes):
             outputs["posteriors"].append(
                 os.path.abspath(inputs.output_posteriors_name_template % (i + 1))
             )
     return outputs
-
-
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "out_classified_image_name":
-        output = inputs.out_classified_image_name
-        if output is attrs.NOTHING:
-            _, name, ext = split_filename(inputs.intensity_images[0])
-            output = name + "_labeled" + ext
-        return output
diff --git a/example-specs/task/nipype/ants/average_affine_transform_callables.py b/example-specs/task/nipype/ants/average_affine_transform_callables.py
index f0714454..822212c0 100644
--- a/example-specs/task/nipype/ants/average_affine_transform_callables.py
+++ b/example-specs/task/nipype/ants/average_affine_transform_callables.py
@@ -1 +1,20 @@
 """Module to put any functions that are referred to in the "callables" section of AverageAffineTransform.yaml"""
+
+import os
+
+
+def affine_transform_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["affine_transform"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["affine_transform"] = os.path.abspath(inputs.output_affine_transform)
+    return outputs
diff --git a/example-specs/task/nipype/ants/average_images_callables.py b/example-specs/task/nipype/ants/average_images_callables.py
index 95359fbf..b2f08446 100644
--- a/example-specs/task/nipype/ants/average_images_callables.py
+++ b/example-specs/task/nipype/ants/average_images_callables.py
@@ -1 +1,20 @@
 """Module to put any functions that are referred to in the "callables" section of AverageImages.yaml"""
+
+import os
+
+
+def output_average_image_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["output_average_image"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["output_average_image"] = os.path.realpath(inputs.output_average_image)
+    return outputs
diff --git a/example-specs/task/nipype/ants/brain_extraction_callables.py b/example-specs/task/nipype/ants/brain_extraction_callables.py
index d2dfd412..b7b45348 100644
--- a/example-specs/task/nipype/ants/brain_extraction_callables.py
+++ b/example-specs/task/nipype/ants/brain_extraction_callables.py
@@ -1 +1,222 @@
 """Module to put any functions that are referred to in the "callables" section of BrainExtraction.yaml"""
+
+import os
+import attrs
+
+
+def BrainExtractionMask_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["BrainExtractionMask"]
+
+
+def BrainExtractionBrain_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["BrainExtractionBrain"]
+
+
+def BrainExtractionCSF_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["BrainExtractionCSF"]
+
+
+def BrainExtractionGM_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["BrainExtractionGM"]
+
+
+def BrainExtractionInitialAffine_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["BrainExtractionInitialAffine"]
+
+
+def BrainExtractionInitialAffineFixed_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["BrainExtractionInitialAffineFixed"]
+
+
+def BrainExtractionInitialAffineMoving_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["BrainExtractionInitialAffineMoving"]
+
+
+def BrainExtractionLaplacian_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["BrainExtractionLaplacian"]
+
+
+def BrainExtractionPrior0GenericAffine_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["BrainExtractionPrior0GenericAffine"]
+
+
+def BrainExtractionPrior1InverseWarp_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["BrainExtractionPrior1InverseWarp"]
+
+
+def BrainExtractionPrior1Warp_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["BrainExtractionPrior1Warp"]
+
+
+def BrainExtractionPriorWarped_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["BrainExtractionPriorWarped"]
+
+
+def BrainExtractionSegmentation_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["BrainExtractionSegmentation"]
+
+
+def BrainExtractionTemplateLaplacian_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["BrainExtractionTemplateLaplacian"]
+
+
+def BrainExtractionTmp_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["BrainExtractionTmp"]
+
+
+def BrainExtractionWM_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["BrainExtractionWM"]
+
+
+def N4Corrected0_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["N4Corrected0"]
+
+
+def N4Truncated0_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["N4Truncated0"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["BrainExtractionMask"] = os.path.join(
+        output_dir,
+        inputs.out_prefix + "BrainExtractionMask." + inputs.image_suffix,
+    )
+    outputs["BrainExtractionBrain"] = os.path.join(
+        output_dir,
+        inputs.out_prefix + "BrainExtractionBrain." + inputs.image_suffix,
+    )
+    if (
+        inputs.keep_temporary_files is not attrs.NOTHING
+    ) and inputs.keep_temporary_files != 0:
+        outputs["BrainExtractionCSF"] = os.path.join(
+            output_dir,
+            inputs.out_prefix + "BrainExtractionCSF." + inputs.image_suffix,
+        )
+        outputs["BrainExtractionGM"] = os.path.join(
+            output_dir,
+            inputs.out_prefix + "BrainExtractionGM." + inputs.image_suffix,
+        )
+        outputs["BrainExtractionInitialAffine"] = os.path.join(
+            output_dir, inputs.out_prefix + "BrainExtractionInitialAffine.mat"
+        )
+        outputs["BrainExtractionInitialAffineFixed"] = os.path.join(
+            output_dir,
+            inputs.out_prefix
+            + "BrainExtractionInitialAffineFixed."
+            + inputs.image_suffix,
+        )
+        outputs["BrainExtractionInitialAffineMoving"] = os.path.join(
+            output_dir,
+            inputs.out_prefix
+            + "BrainExtractionInitialAffineMoving."
+            + inputs.image_suffix,
+        )
+        outputs["BrainExtractionLaplacian"] = os.path.join(
+            output_dir,
+            inputs.out_prefix + "BrainExtractionLaplacian." + inputs.image_suffix,
+        )
+        outputs["BrainExtractionPrior0GenericAffine"] = os.path.join(
+            output_dir,
+            inputs.out_prefix + "BrainExtractionPrior0GenericAffine.mat",
+        )
+        outputs["BrainExtractionPrior1InverseWarp"] = os.path.join(
+            output_dir,
+            inputs.out_prefix
+            + "BrainExtractionPrior1InverseWarp."
+            + inputs.image_suffix,
+        )
+        outputs["BrainExtractionPrior1Warp"] = os.path.join(
+            output_dir,
+            inputs.out_prefix + "BrainExtractionPrior1Warp." + inputs.image_suffix,
+        )
+        outputs["BrainExtractionPriorWarped"] = os.path.join(
+            output_dir,
+            inputs.out_prefix + "BrainExtractionPriorWarped." + inputs.image_suffix,
+        )
+        outputs["BrainExtractionSegmentation"] = os.path.join(
+            output_dir,
+            inputs.out_prefix + "BrainExtractionSegmentation." + inputs.image_suffix,
+        )
+        outputs["BrainExtractionTemplateLaplacian"] = os.path.join(
+            output_dir,
+            inputs.out_prefix
+            + "BrainExtractionTemplateLaplacian."
+            + inputs.image_suffix,
+        )
+        outputs["BrainExtractionTmp"] = os.path.join(
+            output_dir,
+            inputs.out_prefix + "BrainExtractionTmp." + inputs.image_suffix,
+        )
+        outputs["BrainExtractionWM"] = os.path.join(
+            output_dir,
+            inputs.out_prefix + "BrainExtractionWM." + inputs.image_suffix,
+        )
+        outputs["N4Corrected0"] = os.path.join(
+            output_dir,
+            inputs.out_prefix + "N4Corrected0." + inputs.image_suffix,
+        )
+        outputs["N4Truncated0"] = os.path.join(
+            output_dir,
+            inputs.out_prefix + "N4Truncated0." + inputs.image_suffix,
+        )
+
+    return outputs
diff --git a/example-specs/task/nipype/ants/buildtemplateparallel.yaml b/example-specs/task/nipype/ants/buildtemplateparallel.yaml
index 82938fed..0cc29eb4 100644
--- a/example-specs/task/nipype/ants/buildtemplateparallel.yaml
+++ b/example-specs/task/nipype/ants/buildtemplateparallel.yaml
@@ -53,6 +53,10 @@ outputs:
   # passed to the field in the automatically generated unittests.
     final_template_file: generic/file
     # type=file: final ANTS template
+    subject_outfiles: generic/file+list-of
+    # type=outputmultiobject: Outputs for each input image. Includes warp field, inverse warp, Affine, original image (repaired) and warped image (deformed)
+    template_files: generic/file+list-of
+    # type=outputmultiobject: Templates from different stages of iteration
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/ants/buildtemplateparallel_callables.py b/example-specs/task/nipype/ants/buildtemplateparallel_callables.py
index f1425283..2b8df5b0 100644
--- a/example-specs/task/nipype/ants/buildtemplateparallel_callables.py
+++ b/example-specs/task/nipype/ants/buildtemplateparallel_callables.py
@@ -1 +1,115 @@
 """Module to put any functions that are referred to in the "callables" section of buildtemplateparallel.yaml"""
+
+import os
+from glob import glob
+import os.path as op
+
+
+def final_template_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["final_template_file"]
+
+
+def template_files_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["template_files"]
+
+
+def subject_outfiles_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["subject_outfiles"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["template_files"] = []
+    for i in range(len(glob(os.path.realpath("*iteration*")))):
+        temp = os.path.realpath(
+            "%s_iteration_%d/%stemplate.nii.gz"
+            % (inputs.transformation_model, i, inputs.out_prefix)
+        )
+        os.rename(
+            temp,
+            os.path.realpath(
+                "%s_iteration_%d/%stemplate_i%d.nii.gz"
+                % (inputs.transformation_model, i, inputs.out_prefix, i)
+            ),
+        )
+        file_ = "%s_iteration_%d/%stemplate_i%d.nii.gz" % (
+            inputs.transformation_model,
+            i,
+            inputs.out_prefix,
+            i,
+        )
+
+        outputs["template_files"].append(os.path.realpath(file_))
+        outputs["final_template_file"] = os.path.realpath(
+            "%stemplate.nii.gz" % inputs.out_prefix
+        )
+    outputs["subject_outfiles"] = []
+    for filename in inputs.in_files:
+        _, base, _ = split_filename(filename)
+        temp = glob(os.path.realpath("%s%s*" % (inputs.out_prefix, base)))
+        for file_ in temp:
+            outputs["subject_outfiles"].append(file_)
+    return outputs
diff --git a/example-specs/task/nipype/ants/compose_multi_transform_callables.py b/example-specs/task/nipype/ants/compose_multi_transform_callables.py
index c9410a1f..ad164db5 100644
--- a/example-specs/task/nipype/ants/compose_multi_transform_callables.py
+++ b/example-specs/task/nipype/ants/compose_multi_transform_callables.py
@@ -1 +1,187 @@
 """Module to put any functions that are referred to in the "callables" section of ComposeMultiTransform.yaml"""
+
+import os
+import os.path as op
+import attrs
+import logging
+
+
+def output_transform_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["output_transform"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
diff --git a/example-specs/task/nipype/ants/composite_transform_util_callables.py b/example-specs/task/nipype/ants/composite_transform_util_callables.py
index f8ae9933..c336bb38 100644
--- a/example-specs/task/nipype/ants/composite_transform_util_callables.py
+++ b/example-specs/task/nipype/ants/composite_transform_util_callables.py
@@ -1 +1,42 @@
 """Module to put any functions that are referred to in the "callables" section of CompositeTransformUtil.yaml"""
+
+import os
+
+
+def affine_transform_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["affine_transform"]
+
+
+def displacement_field_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["displacement_field"]
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    if inputs.process == "disassemble":
+        outputs["affine_transform"] = os.path.abspath(
+            "00_{}_AffineTransform.mat".format(inputs.output_prefix)
+        )
+        outputs["displacement_field"] = os.path.abspath(
+            "01_{}_DisplacementFieldTransform.nii.gz".format(inputs.output_prefix)
+        )
+    if inputs.process == "assemble":
+        outputs["out_file"] = os.path.abspath(inputs.out_file)
+    return outputs
diff --git a/example-specs/task/nipype/ants/convert_scalar_image_to_rgb_callables.py b/example-specs/task/nipype/ants/convert_scalar_image_to_rgb_callables.py
index e06a95d3..566a65a1 100644
--- a/example-specs/task/nipype/ants/convert_scalar_image_to_rgb_callables.py
+++ b/example-specs/task/nipype/ants/convert_scalar_image_to_rgb_callables.py
@@ -1 +1,20 @@
 """Module to put any functions that are referred to in the "callables" section of ConvertScalarImageToRGB.yaml"""
+
+import os
+
+
+def output_image_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["output_image"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["output_image"] = os.path.join(output_dir, inputs.output_image)
+    return outputs
diff --git a/example-specs/task/nipype/ants/cortical_thickness.yaml b/example-specs/task/nipype/ants/cortical_thickness.yaml
index dc23839e..e1ad0e70 100644
--- a/example-specs/task/nipype/ants/cortical_thickness.yaml
+++ b/example-specs/task/nipype/ants/cortical_thickness.yaml
@@ -72,6 +72,8 @@ outputs:
     # type=file: brain segmentation image
     BrainSegmentationN4: generic/file
     # type=file: N4 corrected image
+    BrainSegmentationPosteriors: generic/file+list-of
+    # type=outputmultiobject: Posterior probability images
     BrainVolumes: generic/file
     # type=file: Brain volumes as text
     CorticalThickness: generic/file
diff --git a/example-specs/task/nipype/ants/cortical_thickness_callables.py b/example-specs/task/nipype/ants/cortical_thickness_callables.py
index 058413a9..6191e471 100644
--- a/example-specs/task/nipype/ants/cortical_thickness_callables.py
+++ b/example-specs/task/nipype/ants/cortical_thickness_callables.py
@@ -1 +1,159 @@
 """Module to put any functions that are referred to in the "callables" section of CorticalThickness.yaml"""
+
+import os
+
+
+def BrainExtractionMask_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["BrainExtractionMask"]
+
+
+def ExtractedBrainN4_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["ExtractedBrainN4"]
+
+
+def BrainSegmentation_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["BrainSegmentation"]
+
+
+def BrainSegmentationN4_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["BrainSegmentationN4"]
+
+
+def BrainSegmentationPosteriors_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["BrainSegmentationPosteriors"]
+
+
+def CorticalThickness_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["CorticalThickness"]
+
+
+def TemplateToSubject1GenericAffine_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["TemplateToSubject1GenericAffine"]
+
+
+def TemplateToSubject0Warp_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["TemplateToSubject0Warp"]
+
+
+def SubjectToTemplate1Warp_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["SubjectToTemplate1Warp"]
+
+
+def SubjectToTemplate0GenericAffine_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["SubjectToTemplate0GenericAffine"]
+
+
+def SubjectToTemplateLogJacobian_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["SubjectToTemplateLogJacobian"]
+
+
+def CorticalThicknessNormedToTemplate_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["CorticalThicknessNormedToTemplate"]
+
+
+def BrainVolumes_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["BrainVolumes"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["BrainExtractionMask"] = os.path.join(
+        output_dir,
+        inputs.out_prefix + "BrainExtractionMask." + inputs.image_suffix,
+    )
+    outputs["ExtractedBrainN4"] = os.path.join(
+        output_dir,
+        inputs.out_prefix + "ExtractedBrain0N4." + inputs.image_suffix,
+    )
+    outputs["BrainSegmentation"] = os.path.join(
+        output_dir,
+        inputs.out_prefix + "BrainSegmentation." + inputs.image_suffix,
+    )
+    outputs["BrainSegmentationN4"] = os.path.join(
+        output_dir,
+        inputs.out_prefix + "BrainSegmentation0N4." + inputs.image_suffix,
+    )
+    posteriors = []
+    for i in range(len(inputs.segmentation_priors)):
+        posteriors.append(
+            os.path.join(
+                output_dir,
+                inputs.out_prefix
+                + "BrainSegmentationPosteriors%02d." % (i + 1)
+                + inputs.image_suffix,
+            )
+        )
+    outputs["BrainSegmentationPosteriors"] = posteriors
+    outputs["CorticalThickness"] = os.path.join(
+        output_dir,
+        inputs.out_prefix + "CorticalThickness." + inputs.image_suffix,
+    )
+    outputs["TemplateToSubject1GenericAffine"] = os.path.join(
+        output_dir, inputs.out_prefix + "TemplateToSubject1GenericAffine.mat"
+    )
+    outputs["TemplateToSubject0Warp"] = os.path.join(
+        output_dir,
+        inputs.out_prefix + "TemplateToSubject0Warp." + inputs.image_suffix,
+    )
+    outputs["SubjectToTemplate1Warp"] = os.path.join(
+        output_dir,
+        inputs.out_prefix + "SubjectToTemplate1Warp." + inputs.image_suffix,
+    )
+    outputs["SubjectToTemplate0GenericAffine"] = os.path.join(
+        output_dir, inputs.out_prefix + "SubjectToTemplate0GenericAffine.mat"
+    )
+    outputs["SubjectToTemplateLogJacobian"] = os.path.join(
+        output_dir,
+        inputs.out_prefix + "SubjectToTemplateLogJacobian." + inputs.image_suffix,
+    )
+    outputs["CorticalThicknessNormedToTemplate"] = os.path.join(
+        output_dir,
+        inputs.out_prefix + "CorticalThickness." + inputs.image_suffix,
+    )
+    outputs["BrainVolumes"] = os.path.join(
+        output_dir, inputs.out_prefix + "brainvols.csv"
+    )
+    return outputs
diff --git a/example-specs/task/nipype/ants/create_jacobian_determinant_image_callables.py b/example-specs/task/nipype/ants/create_jacobian_determinant_image_callables.py
index 79119041..7fe3fe9e 100644
--- a/example-specs/task/nipype/ants/create_jacobian_determinant_image_callables.py
+++ b/example-specs/task/nipype/ants/create_jacobian_determinant_image_callables.py
@@ -1 +1,20 @@
 """Module to put any functions that are referred to in the "callables" section of CreateJacobianDeterminantImage.yaml"""
+
+import os
+
+
+def jacobian_image_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["jacobian_image"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["jacobian_image"] = os.path.abspath(inputs.outputImage)
+    return outputs
diff --git a/example-specs/task/nipype/ants/create_tiled_mosaic_callables.py b/example-specs/task/nipype/ants/create_tiled_mosaic_callables.py
index 0deb50b6..090836ff 100644
--- a/example-specs/task/nipype/ants/create_tiled_mosaic_callables.py
+++ b/example-specs/task/nipype/ants/create_tiled_mosaic_callables.py
@@ -1 +1,20 @@
 """Module to put any functions that are referred to in the "callables" section of CreateTiledMosaic.yaml"""
+
+import os
+
+
+def output_image_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["output_image"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["output_image"] = os.path.join(output_dir, inputs.output_image)
+    return outputs
diff --git a/example-specs/task/nipype/ants/denoise_image_callables.py b/example-specs/task/nipype/ants/denoise_image_callables.py
index 771da693..49f14355 100644
--- a/example-specs/task/nipype/ants/denoise_image_callables.py
+++ b/example-specs/task/nipype/ants/denoise_image_callables.py
@@ -1 +1,194 @@
 """Module to put any functions that are referred to in the "callables" section of DenoiseImage.yaml"""
+
+import os
+import os.path as op
+import attrs
+import logging
+
+
+def output_image_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["output_image"]
+
+
+def noise_image_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["noise_image"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
diff --git a/example-specs/task/nipype/ants/gen_warp_fields_callables.py b/example-specs/task/nipype/ants/gen_warp_fields_callables.py
index 83591d3b..5b0cc3f6 100644
--- a/example-specs/task/nipype/ants/gen_warp_fields_callables.py
+++ b/example-specs/task/nipype/ants/gen_warp_fields_callables.py
@@ -1 +1,72 @@
 """Module to put any functions that are referred to in the "callables" section of GenWarpFields.yaml"""
+
+import os
+import attrs
+
+
+def affine_transformation_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["affine_transformation"]
+
+
+def warp_field_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["warp_field"]
+
+
+def inverse_warp_field_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["inverse_warp_field"]
+
+
+def input_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["input_file"]
+
+
+def output_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["output_file"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    transmodel = inputs.transformation_model
+
+    # When transform is set as 'RI'/'RA', wrap fields should not be expected
+    # The default transformation is GR, which outputs the wrap fields
+    if (transmodel is attrs.NOTHING) or (
+        (transmodel is not attrs.NOTHING) and transmodel not in ["RI", "RA"]
+    ):
+        outputs["warp_field"] = os.path.join(
+            output_dir, inputs.out_prefix + "Warp.nii.gz"
+        )
+        outputs["inverse_warp_field"] = os.path.join(
+            output_dir, inputs.out_prefix + "InverseWarp.nii.gz"
+        )
+
+    outputs["affine_transformation"] = os.path.join(
+        output_dir, inputs.out_prefix + "Affine.txt"
+    )
+    outputs["input_file"] = os.path.join(
+        output_dir, inputs.out_prefix + "repaired.nii.gz"
+    )
+    outputs["output_file"] = os.path.join(
+        output_dir, inputs.out_prefix + "deformed.nii.gz"
+    )
+
+    return outputs
diff --git a/example-specs/task/nipype/ants/image_math_callables.py b/example-specs/task/nipype/ants/image_math_callables.py
index ae493e18..4f40c39a 100644
--- a/example-specs/task/nipype/ants/image_math_callables.py
+++ b/example-specs/task/nipype/ants/image_math_callables.py
@@ -1 +1,187 @@
 """Module to put any functions that are referred to in the "callables" section of ImageMath.yaml"""
+
+import os
+import os.path as op
+import attrs
+import logging
+
+
+def output_image_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["output_image"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
diff --git a/example-specs/task/nipype/ants/joint_fusion.yaml b/example-specs/task/nipype/ants/joint_fusion.yaml
index c8a32ab0..c5c34ddb 100644
--- a/example-specs/task/nipype/ants/joint_fusion.yaml
+++ b/example-specs/task/nipype/ants/joint_fusion.yaml
@@ -115,9 +115,15 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    out_atlas_voting_weight: generic/file+list-of
+    # type=outputmultiobject: 
+    out_intensity_fusion: generic/file+list-of
+    # type=outputmultiobject: 
     out_label_fusion: medimage/nifti1
     # type=file: 
     # type=file|default=<undefined>: The output label fusion image.
+    out_label_post_prob: generic/file+list-of
+    # type=outputmultiobject: 
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/ants/joint_fusion_callables.py b/example-specs/task/nipype/ants/joint_fusion_callables.py
index 9b345a81..64d0f448 100644
--- a/example-specs/task/nipype/ants/joint_fusion_callables.py
+++ b/example-specs/task/nipype/ants/joint_fusion_callables.py
@@ -1 +1,58 @@
 """Module to put any functions that are referred to in the "callables" section of JointFusion.yaml"""
+
+import os
+from glob import glob
+import attrs
+
+
+def out_label_fusion_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_label_fusion"]
+
+
+def out_intensity_fusion_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_intensity_fusion"]
+
+
+def out_label_post_prob_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_label_post_prob"]
+
+
+def out_atlas_voting_weight_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_atlas_voting_weight"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    if inputs.out_label_fusion is not attrs.NOTHING:
+        outputs["out_label_fusion"] = os.path.abspath(inputs.out_label_fusion)
+    if inputs.out_intensity_fusion_name_format is not attrs.NOTHING:
+        outputs["out_intensity_fusion"] = glob(
+            os.path.abspath(inputs.out_intensity_fusion_name_format.replace("%d", "*"))
+        )
+    if inputs.out_label_post_prob_name_format is not attrs.NOTHING:
+        outputs["out_label_post_prob"] = glob(
+            os.path.abspath(inputs.out_label_post_prob_name_format.replace("%d", "*"))
+        )
+    if inputs.out_atlas_voting_weight_name_format is not attrs.NOTHING:
+        outputs["out_atlas_voting_weight"] = glob(
+            os.path.abspath(
+                inputs.out_atlas_voting_weight_name_format.replace("%d", "*")
+            )
+        )
+    return outputs
diff --git a/example-specs/task/nipype/ants/kelly_kapowski_callables.py b/example-specs/task/nipype/ants/kelly_kapowski_callables.py
index ef06c0ee..e26417c1 100644
--- a/example-specs/task/nipype/ants/kelly_kapowski_callables.py
+++ b/example-specs/task/nipype/ants/kelly_kapowski_callables.py
@@ -1 +1,256 @@
 """Module to put any functions that are referred to in the "callables" section of KellyKapowski.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+
+
+def cortical_thickness_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["cortical_thickness"]
+
+
+def warped_white_matter_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["warped_white_matter"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "cortical_thickness":
+        output = inputs.cortical_thickness
+        if output is attrs.NOTHING:
+            _, name, ext = split_filename(inputs.segmentation_image)
+            output = name + "_cortical_thickness" + ext
+        return output
+
+    if name == "warped_white_matter":
+        output = inputs.warped_white_matter
+        if output is attrs.NOTHING:
+            _, name, ext = split_filename(inputs.segmentation_image)
+            output = name + "_warped_white_matter" + ext
+        return output
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
diff --git a/example-specs/task/nipype/ants/label_geometry_callables.py b/example-specs/task/nipype/ants/label_geometry_callables.py
index 9fd98ea1..d339049a 100644
--- a/example-specs/task/nipype/ants/label_geometry_callables.py
+++ b/example-specs/task/nipype/ants/label_geometry_callables.py
@@ -1 +1,187 @@
 """Module to put any functions that are referred to in the "callables" section of LabelGeometry.yaml"""
+
+import os
+import os.path as op
+import attrs
+import logging
+
+
+def output_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["output_file"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
diff --git a/example-specs/task/nipype/ants/laplacian_thickness_callables.py b/example-specs/task/nipype/ants/laplacian_thickness_callables.py
index e853d05c..89033eac 100644
--- a/example-specs/task/nipype/ants/laplacian_thickness_callables.py
+++ b/example-specs/task/nipype/ants/laplacian_thickness_callables.py
@@ -1 +1,187 @@
 """Module to put any functions that are referred to in the "callables" section of LaplacianThickness.yaml"""
+
+import os
+import os.path as op
+import attrs
+import logging
+
+
+def output_image_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["output_image"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
diff --git a/example-specs/task/nipype/ants/measure_image_similarity.yaml b/example-specs/task/nipype/ants/measure_image_similarity.yaml
index 2294a99b..fd360ab9 100644
--- a/example-specs/task/nipype/ants/measure_image_similarity.yaml
+++ b/example-specs/task/nipype/ants/measure_image_similarity.yaml
@@ -64,6 +64,8 @@ outputs:
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
+    similarity: similarity_callable
+    # type=float: 
   templates:
   # dict[str, str] - `output_file_template` values to be provided to output fields
   requirements:
diff --git a/example-specs/task/nipype/ants/measure_image_similarity_callables.py b/example-specs/task/nipype/ants/measure_image_similarity_callables.py
index df6075c2..dd5a8eb8 100644
--- a/example-specs/task/nipype/ants/measure_image_similarity_callables.py
+++ b/example-specs/task/nipype/ants/measure_image_similarity_callables.py
@@ -1 +1,187 @@
 """Module to put any functions that are referred to in the "callables" section of MeasureImageSimilarity.yaml"""
+
+import os
+import os.path as op
+import attrs
+import logging
+
+
+def similarity_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["similarity"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
diff --git a/example-specs/task/nipype/ants/multiply_images_callables.py b/example-specs/task/nipype/ants/multiply_images_callables.py
index fdc71011..b3366bd1 100644
--- a/example-specs/task/nipype/ants/multiply_images_callables.py
+++ b/example-specs/task/nipype/ants/multiply_images_callables.py
@@ -1 +1,20 @@
 """Module to put any functions that are referred to in the "callables" section of MultiplyImages.yaml"""
+
+import os
+
+
+def output_product_image_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["output_product_image"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["output_product_image"] = os.path.abspath(inputs.output_product_image)
+    return outputs
diff --git a/example-specs/task/nipype/ants/n4_bias_field_correction_callables.py b/example-specs/task/nipype/ants/n4_bias_field_correction_callables.py
index 28e01a34..febe11bd 100644
--- a/example-specs/task/nipype/ants/n4_bias_field_correction_callables.py
+++ b/example-specs/task/nipype/ants/n4_bias_field_correction_callables.py
@@ -1 +1,203 @@
 """Module to put any functions that are referred to in the "callables" section of N4BiasFieldCorrection.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+
+
+def output_image_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["output_image"]
+
+
+def bias_image_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["bias_image"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def nipype_interfaces_ants__ANTSCommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_ants__ANTSCommand___list_outputs()
+    if _out_bias_file:
+        outputs["bias_image"] = os.path.abspath(_out_bias_file)
+    return outputs
diff --git a/example-specs/task/nipype/ants/registration.yaml b/example-specs/task/nipype/ants/registration.yaml
index f95b6999..436b9113 100644
--- a/example-specs/task/nipype/ants/registration.yaml
+++ b/example-specs/task/nipype/ants/registration.yaml
@@ -303,10 +303,16 @@ outputs:
   # passed to the field in the automatically generated unittests.
     composite_transform: generic/file
     # type=file: Composite transform file
+    forward_transforms: generic/file+list-of
+    # type=list: List of output transforms for forward registration
     inverse_composite_transform: generic/file
     # type=file: Inverse composite transform file
     inverse_warped_image: generic/file
     # type=file: Outputs the inverse of the warped image
+    reverse_forward_transforms: generic/file+list-of
+    # type=list: List of output transforms for forward registration reversed for antsApplyTransform
+    reverse_transforms: generic/file+list-of
+    # type=list: List of output transforms for reverse registration
     save_state: datascience/text-matrix
     # type=file: The saved registration state to be restored
     # type=file|default=<undefined>: Filename for saving the internal restorable state of the registration
@@ -315,6 +321,10 @@ outputs:
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
+    elapsed_time: elapsed_time_callable
+    # type=float: the total elapsed time as reported by ANTs
+    metric_value: metric_value_callable
+    # type=float: the final value of metric
   templates:
   # dict[str, str] - `output_file_template` values to be provided to output fields
   requirements:
diff --git a/example-specs/task/nipype/ants/registration_callables.py b/example-specs/task/nipype/ants/registration_callables.py
index c815d4c4..321b352e 100644
--- a/example-specs/task/nipype/ants/registration_callables.py
+++ b/example-specs/task/nipype/ants/registration_callables.py
@@ -1 +1,314 @@
 """Module to put any functions that are referred to in the "callables" section of Registration.yaml"""
+
+import os
+import attrs
+
+
+def forward_transforms_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["forward_transforms"]
+
+
+def reverse_forward_transforms_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["reverse_forward_transforms"]
+
+
+def reverse_transforms_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["reverse_transforms"]
+
+
+def forward_invert_flags_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["forward_invert_flags"]
+
+
+def reverse_forward_invert_flags_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["reverse_forward_invert_flags"]
+
+
+def reverse_invert_flags_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["reverse_invert_flags"]
+
+
+def composite_transform_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["composite_transform"]
+
+
+def inverse_composite_transform_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["inverse_composite_transform"]
+
+
+def warped_image_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["warped_image"]
+
+
+def inverse_warped_image_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["inverse_warped_image"]
+
+
+def save_state_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["save_state"]
+
+
+def metric_value_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["metric_value"]
+
+
+def elapsed_time_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["elapsed_time"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _get_outputfilenames(
+    inverse=False, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    output_filename = None
+    if not inverse:
+        if (
+            inputs.output_warped_image is not attrs.NOTHING
+        ) and inputs.output_warped_image:
+            output_filename = inputs.output_warped_image
+            if isinstance(output_filename, bool):
+                output_filename = "%s_Warped.nii.gz" % inputs.output_transform_prefix
+        return output_filename
+    inv_output_filename = None
+    if (
+        inputs.output_inverse_warped_image is not attrs.NOTHING
+    ) and inputs.output_inverse_warped_image:
+        inv_output_filename = inputs.output_inverse_warped_image
+        if isinstance(inv_output_filename, bool):
+            inv_output_filename = (
+                "%s_InverseWarped.nii.gz" % inputs.output_transform_prefix
+            )
+    return inv_output_filename
+
+
+def _output_filenames(
+    prefix,
+    count,
+    transform,
+    inverse=False,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    low_dimensional_transform_map = {
+        "Rigid": "Rigid.mat",
+        "Affine": "Affine.mat",
+        "GenericAffine": "GenericAffine.mat",
+        "CompositeAffine": "Affine.mat",
+        "Similarity": "Similarity.mat",
+        "Translation": "Translation.mat",
+        "BSpline": "BSpline.txt",
+        "Initial": "DerivedInitialMovingTranslation.mat",
+    }
+    if transform in list(low_dimensional_transform_map.keys()):
+        suffix = low_dimensional_transform_map[transform]
+        inverse_mode = inverse
+    else:
+        inverse_mode = False  # These are not analytically invertable
+        if inverse:
+            suffix = "InverseWarp.nii.gz"
+        else:
+            suffix = "Warp.nii.gz"
+    return "%s%d%s" % (prefix, count, suffix), inverse_mode
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["forward_transforms"] = []
+    outputs["forward_invert_flags"] = []
+    outputs["reverse_transforms"] = []
+    outputs["reverse_invert_flags"] = []
+
+    # invert_initial_moving_transform should be always defined, even if
+    # there's no initial transform
+    invert_initial_moving_transform = [False] * len(inputs.initial_moving_transform)
+    if inputs.invert_initial_moving_transform is not attrs.NOTHING:
+        invert_initial_moving_transform = inputs.invert_initial_moving_transform
+
+    if inputs.write_composite_transform:
+        filename = inputs.output_transform_prefix + "Composite.h5"
+        outputs["composite_transform"] = os.path.abspath(filename)
+        filename = inputs.output_transform_prefix + "InverseComposite.h5"
+        outputs["inverse_composite_transform"] = os.path.abspath(filename)
+    # If composite transforms are written, then individuals are not written (as of 2014-10-26
+    else:
+        if not inputs.collapse_output_transforms:
+            transform_count = 0
+            if inputs.initial_moving_transform is not attrs.NOTHING:
+                outputs["forward_transforms"] += inputs.initial_moving_transform
+                outputs["forward_invert_flags"] += invert_initial_moving_transform
+                outputs["reverse_transforms"] = (
+                    inputs.initial_moving_transform + outputs["reverse_transforms"]
+                )
+                outputs["reverse_invert_flags"] = [
+                    not e for e in invert_initial_moving_transform
+                ] + outputs[
+                    "reverse_invert_flags"
+                ]  # Prepend
+                transform_count += len(inputs.initial_moving_transform)
+            elif inputs.initial_moving_transform_com is not attrs.NOTHING:
+                forward_filename, forward_inversemode = _output_filenames(
+                    inputs.output_transform_prefix,
+                    transform_count,
+                    "Initial",
+                    inputs=inputs,
+                    stdout=stdout,
+                    stderr=stderr,
+                    output_dir=output_dir,
+                )
+                reverse_filename, reverse_inversemode = _output_filenames(
+                    inputs.output_transform_prefix,
+                    transform_count,
+                    "Initial",
+                    True,
+                    inputs=inputs,
+                    stdout=stdout,
+                    stderr=stderr,
+                    output_dir=output_dir,
+                )
+                outputs["forward_transforms"].append(os.path.abspath(forward_filename))
+                outputs["forward_invert_flags"].append(False)
+                outputs["reverse_transforms"].insert(
+                    0, os.path.abspath(reverse_filename)
+                )
+                outputs["reverse_invert_flags"].insert(0, True)
+                transform_count += 1
+
+            for count in range(len(inputs.transforms)):
+                forward_filename, forward_inversemode = _output_filenames(
+                    inputs.output_transform_prefix,
+                    transform_count,
+                    inputs.transforms[count],
+                    inputs=inputs,
+                    stdout=stdout,
+                    stderr=stderr,
+                    output_dir=output_dir,
+                )
+                reverse_filename, reverse_inversemode = _output_filenames(
+                    inputs.output_transform_prefix,
+                    transform_count,
+                    inputs.transforms[count],
+                    True,
+                    inputs=inputs,
+                    stdout=stdout,
+                    stderr=stderr,
+                    output_dir=output_dir,
+                )
+                outputs["forward_transforms"].append(os.path.abspath(forward_filename))
+                outputs["forward_invert_flags"].append(forward_inversemode)
+                outputs["reverse_transforms"].insert(
+                    0, os.path.abspath(reverse_filename)
+                )
+                outputs["reverse_invert_flags"].insert(0, reverse_inversemode)
+                transform_count += 1
+        else:
+            transform_count = 0
+            is_linear = [t in _linear_transform_names for t in inputs.transforms]
+            collapse_list = []
+
+            if (inputs.initial_moving_transform is not attrs.NOTHING) or (
+                inputs.initial_moving_transform_com is not attrs.NOTHING
+            ):
+                is_linear.insert(0, True)
+
+            # Only files returned by collapse_output_transforms
+            if any(is_linear):
+                collapse_list.append("GenericAffine")
+            if not all(is_linear):
+                collapse_list.append("SyN")
+
+            for transform in collapse_list:
+                forward_filename, forward_inversemode = _output_filenames(
+                    inputs.output_transform_prefix,
+                    transform_count,
+                    transform,
+                    inverse=False,
+                    inputs=inputs,
+                    stdout=stdout,
+                    stderr=stderr,
+                    output_dir=output_dir,
+                )
+                reverse_filename, reverse_inversemode = _output_filenames(
+                    inputs.output_transform_prefix,
+                    transform_count,
+                    transform,
+                    inverse=True,
+                    inputs=inputs,
+                    stdout=stdout,
+                    stderr=stderr,
+                    output_dir=output_dir,
+                )
+                outputs["forward_transforms"].append(os.path.abspath(forward_filename))
+                outputs["forward_invert_flags"].append(forward_inversemode)
+                outputs["reverse_transforms"].append(os.path.abspath(reverse_filename))
+                outputs["reverse_invert_flags"].append(reverse_inversemode)
+                transform_count += 1
+
+    out_filename = _get_outputfilenames(
+        inverse=False,
+        inputs=inputs,
+        stdout=stdout,
+        stderr=stderr,
+        output_dir=output_dir,
+    )
+    inv_out_filename = _get_outputfilenames(
+        inverse=True, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+    )
+    if out_filename:
+        outputs["warped_image"] = os.path.abspath(out_filename)
+    if inv_out_filename:
+        outputs["inverse_warped_image"] = os.path.abspath(inv_out_filename)
+    if len(inputs.save_state):
+        outputs["save_state"] = os.path.abspath(inputs.save_state)
+    if _metric_value:
+        outputs["metric_value"] = _metric_value
+    if _elapsed_time:
+        outputs["elapsed_time"] = _elapsed_time
+
+    outputs["reverse_forward_transforms"] = outputs["forward_transforms"][::-1]
+    outputs["reverse_forward_invert_flags"] = outputs["forward_invert_flags"][::-1]
+
+    return outputs
diff --git a/example-specs/task/nipype/ants/registration_syn_quick_callables.py b/example-specs/task/nipype/ants/registration_syn_quick_callables.py
index 6de253a7..3fabebb5 100644
--- a/example-specs/task/nipype/ants/registration_syn_quick_callables.py
+++ b/example-specs/task/nipype/ants/registration_syn_quick_callables.py
@@ -1 +1,55 @@
 """Module to put any functions that are referred to in the "callables" section of RegistrationSynQuick.yaml"""
+
+import os
+
+
+def warped_image_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["warped_image"]
+
+
+def inverse_warped_image_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["inverse_warped_image"]
+
+
+def out_matrix_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_matrix"]
+
+
+def forward_warp_field_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["forward_warp_field"]
+
+
+def inverse_warp_field_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["inverse_warp_field"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    out_base = os.path.abspath(inputs.output_prefix)
+    outputs["warped_image"] = out_base + "Warped.nii.gz"
+    outputs["inverse_warped_image"] = out_base + "InverseWarped.nii.gz"
+    outputs["out_matrix"] = out_base + "0GenericAffine.mat"
+
+    if inputs.transform_type not in ("t", "r", "a"):
+        outputs["forward_warp_field"] = out_base + "1Warp.nii.gz"
+        outputs["inverse_warp_field"] = out_base + "1InverseWarp.nii.gz"
+    return outputs
diff --git a/example-specs/task/nipype/ants/resample_image_by_spacing_callables.py b/example-specs/task/nipype/ants/resample_image_by_spacing_callables.py
index ef1c5ab6..a856ebba 100644
--- a/example-specs/task/nipype/ants/resample_image_by_spacing_callables.py
+++ b/example-specs/task/nipype/ants/resample_image_by_spacing_callables.py
@@ -1 +1,187 @@
 """Module to put any functions that are referred to in the "callables" section of ResampleImageBySpacing.yaml"""
+
+import os
+import os.path as op
+import attrs
+import logging
+
+
+def output_image_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["output_image"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
diff --git a/example-specs/task/nipype/ants/threshold_image_callables.py b/example-specs/task/nipype/ants/threshold_image_callables.py
index 25fa00ba..5414c9dd 100644
--- a/example-specs/task/nipype/ants/threshold_image_callables.py
+++ b/example-specs/task/nipype/ants/threshold_image_callables.py
@@ -1 +1,187 @@
 """Module to put any functions that are referred to in the "callables" section of ThresholdImage.yaml"""
+
+import os
+import os.path as op
+import attrs
+import logging
+
+
+def output_image_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["output_image"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
diff --git a/example-specs/task/nipype/ants/warp_image_multi_transform_callables.py b/example-specs/task/nipype/ants/warp_image_multi_transform_callables.py
index 6a7febac..74db17ea 100644
--- a/example-specs/task/nipype/ants/warp_image_multi_transform_callables.py
+++ b/example-specs/task/nipype/ants/warp_image_multi_transform_callables.py
@@ -1 +1,90 @@
 """Module to put any functions that are referred to in the "callables" section of WarpImageMultiTransform.yaml"""
+
+import os
+import attrs
+import os.path as op
+
+
+def output_image_default(inputs):
+    return _gen_filename("output_image", inputs=inputs)
+
+
+def output_image_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["output_image"]
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "output_image":
+        _, name, ext = split_filename(os.path.abspath(inputs.input_image))
+        return "".join((name, inputs.out_postfix, ext))
+    return None
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    if inputs.output_image is not attrs.NOTHING:
+        outputs["output_image"] = os.path.abspath(inputs.output_image)
+    else:
+        outputs["output_image"] = os.path.abspath(
+            _gen_filename(
+                "output_image",
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+        )
+    return outputs
diff --git a/example-specs/task/nipype/ants/warp_time_series_image_multi_transform_callables.py b/example-specs/task/nipype/ants/warp_time_series_image_multi_transform_callables.py
index e944a608..8d34c398 100644
--- a/example-specs/task/nipype/ants/warp_time_series_image_multi_transform_callables.py
+++ b/example-specs/task/nipype/ants/warp_time_series_image_multi_transform_callables.py
@@ -1 +1,74 @@
 """Module to put any functions that are referred to in the "callables" section of WarpTimeSeriesImageMultiTransform.yaml"""
+
+import os
+import os.path as op
+
+
+def output_image_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["output_image"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    _, name, ext = split_filename(os.path.abspath(inputs.input_image))
+    outputs["output_image"] = os.path.join(
+        output_dir, "".join((name, inputs.out_postfix, ext))
+    )
+    return outputs
diff --git a/example-specs/task/nipype/freesurfer/add_x_form_to_header_callables.py b/example-specs/task/nipype/freesurfer/add_x_form_to_header_callables.py
index e9a18b75..931b1336 100644
--- a/example-specs/task/nipype/freesurfer/add_x_form_to_header_callables.py
+++ b/example-specs/task/nipype/freesurfer/add_x_form_to_header_callables.py
@@ -1 +1,20 @@
 """Module to put any functions that are referred to in the "callables" section of AddXFormToHeader.yaml"""
+
+import os
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = os.path.abspath(inputs.out_file)
+    return outputs
diff --git a/example-specs/task/nipype/freesurfer/aparc_2_aseg_callables.py b/example-specs/task/nipype/freesurfer/aparc_2_aseg_callables.py
index d73de6af..6e3385fa 100644
--- a/example-specs/task/nipype/freesurfer/aparc_2_aseg_callables.py
+++ b/example-specs/task/nipype/freesurfer/aparc_2_aseg_callables.py
@@ -1 +1,20 @@
 """Module to put any functions that are referred to in the "callables" section of Aparc2Aseg.yaml"""
+
+import os
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = os.path.abspath(inputs.out_file)
+    return outputs
diff --git a/example-specs/task/nipype/freesurfer/apas_2_aseg_callables.py b/example-specs/task/nipype/freesurfer/apas_2_aseg_callables.py
index 80244c3e..efee0d15 100644
--- a/example-specs/task/nipype/freesurfer/apas_2_aseg_callables.py
+++ b/example-specs/task/nipype/freesurfer/apas_2_aseg_callables.py
@@ -1 +1,20 @@
 """Module to put any functions that are referred to in the "callables" section of Apas2Aseg.yaml"""
+
+import os
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = os.path.abspath(inputs.out_file)
+    return outputs
diff --git a/example-specs/task/nipype/freesurfer/apply_mask_callables.py b/example-specs/task/nipype/freesurfer/apply_mask_callables.py
index 411af901..53a377cd 100644
--- a/example-specs/task/nipype/freesurfer/apply_mask_callables.py
+++ b/example-specs/task/nipype/freesurfer/apply_mask_callables.py
@@ -1 +1,187 @@
 """Module to put any functions that are referred to in the "callables" section of ApplyMask.yaml"""
+
+import os
+import os.path as op
+import attrs
+import logging
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
diff --git a/example-specs/task/nipype/freesurfer/apply_vol_transform_callables.py b/example-specs/task/nipype/freesurfer/apply_vol_transform_callables.py
index a14c8eb1..9e0b2f32 100644
--- a/example-specs/task/nipype/freesurfer/apply_vol_transform_callables.py
+++ b/example-specs/task/nipype/freesurfer/apply_vol_transform_callables.py
@@ -1 +1,138 @@
 """Module to put any functions that are referred to in the "callables" section of ApplyVolTransform.yaml"""
+
+import os
+import attrs
+import os.path as op
+
+
+def transformed_file_default(inputs):
+    return _gen_filename("transformed_file", inputs=inputs)
+
+
+def transformed_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["transformed_file"]
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _get_outfile(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outfile = inputs.transformed_file
+    if outfile is attrs.NOTHING:
+        if inputs.inverse is True:
+            if inputs.fs_target is True:
+                src = "orig.mgz"
+            else:
+                src = inputs.target_file
+        else:
+            src = inputs.source_file
+        outfile = fname_presuffix(src, newpath=output_dir, suffix="_warped")
+    return outfile
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "transformed_file":
+        return _get_outfile(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )
+    return None
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["transformed_file"] = os.path.abspath(
+        _get_outfile(inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir)
+    )
+    return outputs
diff --git a/example-specs/task/nipype/freesurfer/bb_register_callables.py b/example-specs/task/nipype/freesurfer/bb_register_callables.py
index b022ad47..85cd4704 100644
--- a/example-specs/task/nipype/freesurfer/bb_register_callables.py
+++ b/example-specs/task/nipype/freesurfer/bb_register_callables.py
@@ -1 +1,200 @@
 """Module to put any functions that are referred to in the "callables" section of BBRegister.yaml"""
+
+import attrs
+import os.path as op
+
+
+def out_reg_file_default(inputs):
+    return _gen_filename("out_reg_file", inputs=inputs)
+
+
+def out_reg_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_reg_file"]
+
+
+def out_fsl_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_fsl_file"]
+
+
+def out_lta_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_lta_file"]
+
+
+def min_cost_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["min_cost_file"]
+
+
+def init_cost_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["init_cost_file"]
+
+
+def registered_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["registered_file"]
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_reg_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )[name]
+    return None
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    _in = inputs
+
+    if _in.out_reg_file is not attrs.NOTHING:
+        outputs["out_reg_file"] = op.abspath(_in.out_reg_file)
+    elif _in.source_file:
+        suffix = "_bbreg_%s.dat" % _in.subject_id
+        outputs["out_reg_file"] = fname_presuffix(
+            _in.source_file, suffix=suffix, use_ext=False
+        )
+
+    if _in.registered_file is not attrs.NOTHING:
+        if isinstance(_in.registered_file, bool):
+            outputs["registered_file"] = fname_presuffix(
+                _in.source_file, suffix="_bbreg"
+            )
+        else:
+            outputs["registered_file"] = op.abspath(_in.registered_file)
+
+    if _in.out_lta_file is not attrs.NOTHING:
+        if isinstance(_in.out_lta_file, bool):
+            suffix = "_bbreg_%s.lta" % _in.subject_id
+            out_lta_file = fname_presuffix(
+                _in.source_file, suffix=suffix, use_ext=False
+            )
+            outputs["out_lta_file"] = out_lta_file
+        else:
+            outputs["out_lta_file"] = op.abspath(_in.out_lta_file)
+
+    if _in.out_fsl_file is not attrs.NOTHING:
+        if isinstance(_in.out_fsl_file, bool):
+            suffix = "_bbreg_%s.mat" % _in.subject_id
+            out_fsl_file = fname_presuffix(
+                _in.source_file, suffix=suffix, use_ext=False
+            )
+            outputs["out_fsl_file"] = out_fsl_file
+        else:
+            outputs["out_fsl_file"] = op.abspath(_in.out_fsl_file)
+
+    if _in.init_cost_file is not attrs.NOTHING:
+        if isinstance(_in.out_fsl_file, bool):
+            outputs["init_cost_file"] = outputs["out_reg_file"] + ".initcost"
+        else:
+            outputs["init_cost_file"] = op.abspath(_in.init_cost_file)
+
+    outputs["min_cost_file"] = outputs["out_reg_file"] + ".mincost"
+    return outputs
diff --git a/example-specs/task/nipype/freesurfer/binarize_callables.py b/example-specs/task/nipype/freesurfer/binarize_callables.py
index 01354d75..0af5ea07 100644
--- a/example-specs/task/nipype/freesurfer/binarize_callables.py
+++ b/example-specs/task/nipype/freesurfer/binarize_callables.py
@@ -1 +1,154 @@
 """Module to put any functions that are referred to in the "callables" section of Binarize.yaml"""
+
+import os
+import attrs
+import os.path as op
+
+
+def binary_file_default(inputs):
+    return _gen_filename("binary_file", inputs=inputs)
+
+
+def binary_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["binary_file"]
+
+
+def count_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["count_file"]
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "binary_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )[name]
+    return None
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outfile = inputs.binary_file
+    if outfile is attrs.NOTHING:
+        if inputs.out_type is not attrs.NOTHING:
+            outfile = fname_presuffix(
+                inputs.in_file,
+                newpath=output_dir,
+                suffix=".".join(("_thresh", inputs.out_type)),
+                use_ext=False,
+            )
+        else:
+            outfile = fname_presuffix(
+                inputs.in_file, newpath=output_dir, suffix="_thresh"
+            )
+    outputs["binary_file"] = os.path.abspath(outfile)
+    value = inputs.count_file
+    if value is not attrs.NOTHING:
+        if isinstance(value, bool):
+            if value:
+                outputs["count_file"] = fname_presuffix(
+                    inputs.in_file,
+                    suffix="_count.txt",
+                    newpath=output_dir,
+                    use_ext=False,
+                )
+        else:
+            outputs["count_file"] = value
+    return outputs
diff --git a/example-specs/task/nipype/freesurfer/ca_label_callables.py b/example-specs/task/nipype/freesurfer/ca_label_callables.py
index 60c89013..e6be59ff 100644
--- a/example-specs/task/nipype/freesurfer/ca_label_callables.py
+++ b/example-specs/task/nipype/freesurfer/ca_label_callables.py
@@ -1 +1,20 @@
 """Module to put any functions that are referred to in the "callables" section of CALabel.yaml"""
+
+import os
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = os.path.abspath(inputs.out_file)
+    return outputs
diff --git a/example-specs/task/nipype/freesurfer/ca_normalize_callables.py b/example-specs/task/nipype/freesurfer/ca_normalize_callables.py
index c74a5710..aeb4f9b6 100644
--- a/example-specs/task/nipype/freesurfer/ca_normalize_callables.py
+++ b/example-specs/task/nipype/freesurfer/ca_normalize_callables.py
@@ -1 +1,28 @@
 """Module to put any functions that are referred to in the "callables" section of CANormalize.yaml"""
+
+import os
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+def control_points_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["control_points"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = os.path.abspath(inputs.out_file)
+    outputs["control_points"] = os.path.abspath(inputs.control_points)
+    return outputs
diff --git a/example-specs/task/nipype/freesurfer/ca_register_callables.py b/example-specs/task/nipype/freesurfer/ca_register_callables.py
index 1e79583d..067f9bef 100644
--- a/example-specs/task/nipype/freesurfer/ca_register_callables.py
+++ b/example-specs/task/nipype/freesurfer/ca_register_callables.py
@@ -1 +1,24 @@
 """Module to put any functions that are referred to in the "callables" section of CARegister.yaml"""
+
+import os
+
+
+def out_file_default(inputs):
+    return _gen_filename("out_file", inputs=inputs)
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = os.path.abspath(inputs.out_file)
+    return outputs
diff --git a/example-specs/task/nipype/freesurfer/check_talairach_alignment_callables.py b/example-specs/task/nipype/freesurfer/check_talairach_alignment_callables.py
index 159abe65..46bc0adf 100644
--- a/example-specs/task/nipype/freesurfer/check_talairach_alignment_callables.py
+++ b/example-specs/task/nipype/freesurfer/check_talairach_alignment_callables.py
@@ -1 +1,18 @@
 """Module to put any functions that are referred to in the "callables" section of CheckTalairachAlignment.yaml"""
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = inputs.in_file
+    return outputs
diff --git a/example-specs/task/nipype/freesurfer/concatenate_callables.py b/example-specs/task/nipype/freesurfer/concatenate_callables.py
index 2eb26502..53084261 100644
--- a/example-specs/task/nipype/freesurfer/concatenate_callables.py
+++ b/example-specs/task/nipype/freesurfer/concatenate_callables.py
@@ -1 +1,33 @@
 """Module to put any functions that are referred to in the "callables" section of Concatenate.yaml"""
+
+import os
+import attrs
+
+
+def concatenated_file_default(inputs):
+    return _gen_filename("concatenated_file", inputs=inputs)
+
+
+def concatenated_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["concatenated_file"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "concatenated_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )[name]
+    return None
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+
+    fname = inputs.concatenated_file
+    if fname is attrs.NOTHING:
+        fname = "concat_output.nii.gz"
+    outputs["concatenated_file"] = os.path.join(output_dir, fname)
+    return outputs
diff --git a/example-specs/task/nipype/freesurfer/concatenate_lta_callables.py b/example-specs/task/nipype/freesurfer/concatenate_lta_callables.py
index 534cd698..8cbb01e5 100644
--- a/example-specs/task/nipype/freesurfer/concatenate_lta_callables.py
+++ b/example-specs/task/nipype/freesurfer/concatenate_lta_callables.py
@@ -1 +1,187 @@
 """Module to put any functions that are referred to in the "callables" section of ConcatenateLTA.yaml"""
+
+import os
+import os.path as op
+import attrs
+import logging
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
diff --git a/example-specs/task/nipype/freesurfer/contrast_callables.py b/example-specs/task/nipype/freesurfer/contrast_callables.py
index cab5f447..dad73aac 100644
--- a/example-specs/task/nipype/freesurfer/contrast_callables.py
+++ b/example-specs/task/nipype/freesurfer/contrast_callables.py
@@ -1 +1,41 @@
 """Module to put any functions that are referred to in the "callables" section of Contrast.yaml"""
+
+import os
+
+
+def out_contrast_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_contrast"]
+
+
+def out_stats_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_stats"]
+
+
+def out_log_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_log"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    subject_dir = os.path.join(inputs.subjects_dir, inputs.subject_id)
+    outputs["out_contrast"] = os.path.join(
+        subject_dir, "surf", str(inputs.hemisphere) + ".w-g.pct.mgh"
+    )
+    outputs["out_stats"] = os.path.join(
+        subject_dir, "stats", str(inputs.hemisphere) + ".w-g.pct.stats"
+    )
+    outputs["out_log"] = os.path.join(subject_dir, "scripts", "pctsurfcon.log")
+    return outputs
diff --git a/example-specs/task/nipype/freesurfer/curvature_callables.py b/example-specs/task/nipype/freesurfer/curvature_callables.py
index 9b95a834..c4997eb6 100644
--- a/example-specs/task/nipype/freesurfer/curvature_callables.py
+++ b/example-specs/task/nipype/freesurfer/curvature_callables.py
@@ -1 +1,32 @@
 """Module to put any functions that are referred to in the "callables" section of Curvature.yaml"""
+
+import os
+
+
+def out_mean_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_mean"]
+
+
+def out_gauss_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_gauss"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    if inputs.copy_input:
+        in_file = os.path.basename(inputs.in_file)
+    else:
+        in_file = inputs.in_file
+    outputs["out_mean"] = os.path.abspath(in_file) + ".H"
+    outputs["out_gauss"] = os.path.abspath(in_file) + ".K"
+    return outputs
diff --git a/example-specs/task/nipype/freesurfer/curvature_stats_callables.py b/example-specs/task/nipype/freesurfer/curvature_stats_callables.py
index 9e579e65..5d1773aa 100644
--- a/example-specs/task/nipype/freesurfer/curvature_stats_callables.py
+++ b/example-specs/task/nipype/freesurfer/curvature_stats_callables.py
@@ -1 +1,20 @@
 """Module to put any functions that are referred to in the "callables" section of CurvatureStats.yaml"""
+
+import os
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = os.path.abspath(inputs.out_file)
+    return outputs
diff --git a/example-specs/task/nipype/freesurfer/dicom_convert_callables.py b/example-specs/task/nipype/freesurfer/dicom_convert_callables.py
index 8cd6f466..8e80e78a 100644
--- a/example-specs/task/nipype/freesurfer/dicom_convert_callables.py
+++ b/example-specs/task/nipype/freesurfer/dicom_convert_callables.py
@@ -1 +1,179 @@
 """Module to put any functions that are referred to in the "callables" section of DICOMConvert.yaml"""
+
+import os
+import os.path as op
+import attrs
+import logging
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
diff --git a/example-specs/task/nipype/freesurfer/edit_w_mwith_aseg_callables.py b/example-specs/task/nipype/freesurfer/edit_w_mwith_aseg_callables.py
index a0c459f0..25073f5a 100644
--- a/example-specs/task/nipype/freesurfer/edit_w_mwith_aseg_callables.py
+++ b/example-specs/task/nipype/freesurfer/edit_w_mwith_aseg_callables.py
@@ -1 +1,20 @@
 """Module to put any functions that are referred to in the "callables" section of EditWMwithAseg.yaml"""
+
+import os
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = os.path.abspath(inputs.out_file)
+    return outputs
diff --git a/example-specs/task/nipype/freesurfer/em_register_callables.py b/example-specs/task/nipype/freesurfer/em_register_callables.py
index bc3efc0f..04345168 100644
--- a/example-specs/task/nipype/freesurfer/em_register_callables.py
+++ b/example-specs/task/nipype/freesurfer/em_register_callables.py
@@ -1 +1,20 @@
 """Module to put any functions that are referred to in the "callables" section of EMRegister.yaml"""
+
+import os
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = os.path.abspath(inputs.out_file)
+    return outputs
diff --git a/example-specs/task/nipype/freesurfer/euler_number.yaml b/example-specs/task/nipype/freesurfer/euler_number.yaml
index 74628bb3..5ac4a5ef 100644
--- a/example-specs/task/nipype/freesurfer/euler_number.yaml
+++ b/example-specs/task/nipype/freesurfer/euler_number.yaml
@@ -50,6 +50,10 @@ outputs:
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
+    defects: defects_callable
+    # type=int: Number of defects
+    euler: euler_callable
+    # type=int: Euler number of cortical surface. A value of 2 signals a topologically correct surface model with no holes
   templates:
   # dict[str, str] - `output_file_template` values to be provided to output fields
   requirements:
diff --git a/example-specs/task/nipype/freesurfer/euler_number_callables.py b/example-specs/task/nipype/freesurfer/euler_number_callables.py
index 2e9a493e..3055ab4e 100644
--- a/example-specs/task/nipype/freesurfer/euler_number_callables.py
+++ b/example-specs/task/nipype/freesurfer/euler_number_callables.py
@@ -1 +1,26 @@
 """Module to put any functions that are referred to in the "callables" section of EulerNumber.yaml"""
+
+
+def euler_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["euler"]
+
+
+def defects_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["defects"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["defects"] = _defects
+    outputs["euler"] = 2 - (2 * _defects)
+    return outputs
diff --git a/example-specs/task/nipype/freesurfer/extract_main_component_callables.py b/example-specs/task/nipype/freesurfer/extract_main_component_callables.py
index b73a2742..ed6d7473 100644
--- a/example-specs/task/nipype/freesurfer/extract_main_component_callables.py
+++ b/example-specs/task/nipype/freesurfer/extract_main_component_callables.py
@@ -1 +1,187 @@
 """Module to put any functions that are referred to in the "callables" section of ExtractMainComponent.yaml"""
+
+import os
+import os.path as op
+import attrs
+import logging
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
diff --git a/example-specs/task/nipype/freesurfer/fit_ms_params_callables.py b/example-specs/task/nipype/freesurfer/fit_ms_params_callables.py
index d150f96d..a12c332f 100644
--- a/example-specs/task/nipype/freesurfer/fit_ms_params_callables.py
+++ b/example-specs/task/nipype/freesurfer/fit_ms_params_callables.py
@@ -1,18 +1,32 @@
 """Module to put any functions that are referred to in the "callables" section of FitMSParams.yaml"""
 
-import attrs
 import os
+import attrs
 
 
 def out_dir_default(inputs):
     return _gen_filename("out_dir", inputs=inputs)
 
 
-def out_dir_callable(output_dir, inputs, stdout, stderr):
+def t1_image_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["t1_image"]
+
+
+def pd_image_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["pd_image"]
+
+
+def t2star_image_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_dir"]
+    return outputs["t2star_image"]
 
 
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
diff --git a/example-specs/task/nipype/freesurfer/fix_topology_callables.py b/example-specs/task/nipype/freesurfer/fix_topology_callables.py
index 06798671..abd893f1 100644
--- a/example-specs/task/nipype/freesurfer/fix_topology_callables.py
+++ b/example-specs/task/nipype/freesurfer/fix_topology_callables.py
@@ -1 +1,20 @@
 """Module to put any functions that are referred to in the "callables" section of FixTopology.yaml"""
+
+import os
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = os.path.abspath(inputs.in_orig)
+    return outputs
diff --git a/example-specs/task/nipype/freesurfer/fuse_segmentations_callables.py b/example-specs/task/nipype/freesurfer/fuse_segmentations_callables.py
index d76154ac..c33c4f22 100644
--- a/example-specs/task/nipype/freesurfer/fuse_segmentations_callables.py
+++ b/example-specs/task/nipype/freesurfer/fuse_segmentations_callables.py
@@ -1 +1,20 @@
 """Module to put any functions that are referred to in the "callables" section of FuseSegmentations.yaml"""
+
+import os
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = os.path.abspath(inputs.out_file)
+    return outputs
diff --git a/example-specs/task/nipype/freesurfer/glm_fit_callables.py b/example-specs/task/nipype/freesurfer/glm_fit_callables.py
index df81d5b9..b738898f 100644
--- a/example-specs/task/nipype/freesurfer/glm_fit_callables.py
+++ b/example-specs/task/nipype/freesurfer/glm_fit_callables.py
@@ -1 +1,261 @@
 """Module to put any functions that are referred to in the "callables" section of GLMFit.yaml"""
+
+import os
+import attrs
+import os.path as op
+
+
+def glm_dir_default(inputs):
+    return _gen_filename("glm_dir", inputs=inputs)
+
+
+def glm_dir_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["glm_dir"]
+
+
+def beta_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["beta_file"]
+
+
+def error_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["error_file"]
+
+
+def error_var_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["error_var_file"]
+
+
+def error_stddev_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["error_stddev_file"]
+
+
+def estimate_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["estimate_file"]
+
+
+def mask_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["mask_file"]
+
+
+def fwhm_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["fwhm_file"]
+
+
+def dof_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["dof_file"]
+
+
+def gamma_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["gamma_file"]
+
+
+def gamma_var_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["gamma_var_file"]
+
+
+def sig_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["sig_file"]
+
+
+def ftest_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["ftest_file"]
+
+
+def spatial_eigenvectors_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["spatial_eigenvectors"]
+
+
+def frame_eigenvectors_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["frame_eigenvectors"]
+
+
+def singular_values_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["singular_values"]
+
+
+def svd_stats_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["svd_stats_file"]
+
+
+def k2p_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["k2p_file"]
+
+
+def bp_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["bp_file"]
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "glm_dir":
+        return output_dir
+    return None
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    # Get the top-level output directory
+    if inputs.glm_dir is attrs.NOTHING:
+        glmdir = output_dir
+    else:
+        glmdir = os.path.abspath(inputs.glm_dir)
+    outputs["glm_dir"] = glmdir
+
+    if inputs.nii_gz is not attrs.NOTHING:
+        ext = "nii.gz"
+    elif inputs.nii is not attrs.NOTHING:
+        ext = "nii"
+    else:
+        ext = "mgh"
+
+    # Assign the output files that always get created
+    outputs["beta_file"] = os.path.join(glmdir, f"beta.{ext}")
+    outputs["error_var_file"] = os.path.join(glmdir, f"rvar.{ext}")
+    outputs["error_stddev_file"] = os.path.join(glmdir, f"rstd.{ext}")
+    outputs["mask_file"] = os.path.join(glmdir, f"mask.{ext}")
+    outputs["fwhm_file"] = os.path.join(glmdir, "fwhm.dat")
+    outputs["dof_file"] = os.path.join(glmdir, "dof.dat")
+    # Assign the conditional outputs
+    if inputs.save_residual:
+        outputs["error_file"] = os.path.join(glmdir, f"eres.{ext}")
+    if inputs.save_estimate:
+        outputs["estimate_file"] = os.path.join(glmdir, f"yhat.{ext}")
+    if any((inputs.mrtm1, inputs.mrtm2, inputs.logan)):
+        outputs["bp_file"] = os.path.join(glmdir, f"bp.{ext}")
+    if inputs.mrtm1:
+        outputs["k2p_file"] = os.path.join(glmdir, "k2prime.dat")
+
+    # Get the contrast directory name(s)
+    contrasts = []
+    if inputs.contrast is not attrs.NOTHING:
+        for c in inputs.contrast:
+            if split_filename(c)[2] in [".mat", ".dat", ".mtx", ".con"]:
+                contrasts.append(split_filename(c)[1])
+            else:
+                contrasts.append(os.path.split(c)[1])
+    elif (inputs.one_sample is not attrs.NOTHING) and inputs.one_sample:
+        contrasts = ["osgm"]
+
+    # Add in the contrast images
+    outputs["sig_file"] = [os.path.join(glmdir, c, f"sig.{ext}") for c in contrasts]
+    outputs["ftest_file"] = [os.path.join(glmdir, c, f"F.{ext}") for c in contrasts]
+    outputs["gamma_file"] = [os.path.join(glmdir, c, f"gamma.{ext}") for c in contrasts]
+    outputs["gamma_var_file"] = [
+        os.path.join(glmdir, c, f"gammavar.{ext}") for c in contrasts
+    ]
+
+    # Add in the PCA results, if relevant
+    if (inputs.pca is not attrs.NOTHING) and inputs.pca:
+        pcadir = os.path.join(glmdir, "pca-eres")
+        outputs["spatial_eigenvectors"] = os.path.join(pcadir, f"v.{ext}")
+        outputs["frame_eigenvectors"] = os.path.join(pcadir, "u.mtx")
+        outputs["singluar_values"] = os.path.join(pcadir, "sdiag.mat")
+        outputs["svd_stats_file"] = os.path.join(pcadir, "stats.dat")
+
+    return outputs
diff --git a/example-specs/task/nipype/freesurfer/gtm_seg_callables.py b/example-specs/task/nipype/freesurfer/gtm_seg_callables.py
index adf8196e..9e70fe90 100644
--- a/example-specs/task/nipype/freesurfer/gtm_seg_callables.py
+++ b/example-specs/task/nipype/freesurfer/gtm_seg_callables.py
@@ -1 +1,25 @@
 """Module to put any functions that are referred to in the "callables" section of GTMSeg.yaml"""
+
+import os
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = os.path.join(
+        inputs.subjects_dir,
+        inputs.subject_id,
+        "mri",
+        inputs.out_file,
+    )
+    return outputs
diff --git a/example-specs/task/nipype/freesurfer/gtmpvc_callables.py b/example-specs/task/nipype/freesurfer/gtmpvc_callables.py
index 8741b758..2216c632 100644
--- a/example-specs/task/nipype/freesurfer/gtmpvc_callables.py
+++ b/example-specs/task/nipype/freesurfer/gtmpvc_callables.py
@@ -1 +1,203 @@
 """Module to put any functions that are referred to in the "callables" section of GTMPVC.yaml"""
+
+import os
+import attrs
+
+
+def pvc_dir_default(inputs):
+    return _gen_filename("pvc_dir", inputs=inputs)
+
+
+def pvc_dir_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["pvc_dir"]
+
+
+def ref_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["ref_file"]
+
+
+def hb_nifti_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["hb_nifti"]
+
+
+def hb_dat_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["hb_dat"]
+
+
+def nopvc_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["nopvc_file"]
+
+
+def gtm_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["gtm_file"]
+
+
+def gtm_stats_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["gtm_stats"]
+
+
+def input_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["input_file"]
+
+
+def reg_pet2anat_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["reg_pet2anat"]
+
+
+def reg_anat2pet_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["reg_anat2pet"]
+
+
+def reg_rbvpet2anat_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["reg_rbvpet2anat"]
+
+
+def reg_anat2rbvpet_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["reg_anat2rbvpet"]
+
+
+def mgx_ctxgm_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["mgx_ctxgm"]
+
+
+def mgx_subctxgm_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["mgx_subctxgm"]
+
+
+def mgx_gm_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["mgx_gm"]
+
+
+def rbv_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["rbv"]
+
+
+def opt_params_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["opt_params"]
+
+
+def yhat0_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["yhat0"]
+
+
+def yhat_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["yhat"]
+
+
+def yhat_full_fov_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["yhat_full_fov"]
+
+
+def yhat_with_noise_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["yhat_with_noise"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    # Get the top-level output directory
+    if inputs.pvc_dir is attrs.NOTHING:
+        pvcdir = output_dir
+    else:
+        pvcdir = os.path.abspath(inputs.pvc_dir)
+    outputs["pvc_dir"] = pvcdir
+
+    # Assign the output files that always get created
+    outputs["ref_file"] = os.path.join(pvcdir, "km.ref.tac.dat")
+    outputs["hb_nifti"] = os.path.join(pvcdir, "km.hb.tac.nii.gz")
+    outputs["hb_dat"] = os.path.join(pvcdir, "km.hb.tac.dat")
+    outputs["nopvc_file"] = os.path.join(pvcdir, "nopvc.nii.gz")
+    outputs["gtm_file"] = os.path.join(pvcdir, "gtm.nii.gz")
+    outputs["gtm_stats"] = os.path.join(pvcdir, "gtm.stats.dat")
+    outputs["reg_pet2anat"] = os.path.join(pvcdir, "aux", "bbpet2anat.lta")
+    outputs["reg_anat2pet"] = os.path.join(pvcdir, "aux", "anat2bbpet.lta")
+
+    # Assign the conditional outputs
+    if inputs.save_input:
+        outputs["input_file"] = os.path.join(pvcdir, "input.nii.gz")
+    if inputs.save_yhat0:
+        outputs["yhat0"] = os.path.join(pvcdir, "yhat0.nii.gz")
+    if inputs.save_yhat:
+        outputs["yhat"] = os.path.join(pvcdir, "yhat.nii.gz")
+    if inputs.save_yhat_full_fov:
+        outputs["yhat_full_fov"] = os.path.join(pvcdir, "yhat.fullfov.nii.gz")
+    if inputs.save_yhat_with_noise:
+        outputs["yhat_with_noise"] = os.path.join(pvcdir, "yhat.nii.gz")
+    if inputs.mgx:
+        outputs["mgx_ctxgm"] = os.path.join(pvcdir, "mgx.ctxgm.nii.gz")
+        outputs["mgx_subctxgm"] = os.path.join(pvcdir, "mgx.subctxgm.nii.gz")
+        outputs["mgx_gm"] = os.path.join(pvcdir, "mgx.gm.nii.gz")
+    if inputs.rbv:
+        outputs["rbv"] = os.path.join(pvcdir, "rbv.nii.gz")
+        outputs["reg_rbvpet2anat"] = os.path.join(pvcdir, "aux", "rbv2anat.lta")
+        outputs["reg_anat2rbvpet"] = os.path.join(pvcdir, "aux", "anat2rbv.lta")
+    if inputs.opt:
+        outputs["opt_params"] = os.path.join(pvcdir, "aux", "opt.params.dat")
+
+    return outputs
diff --git a/example-specs/task/nipype/freesurfer/image_info.yaml b/example-specs/task/nipype/freesurfer/image_info.yaml
index fc2171d5..199af399 100644
--- a/example-specs/task/nipype/freesurfer/image_info.yaml
+++ b/example-specs/task/nipype/freesurfer/image_info.yaml
@@ -42,6 +42,26 @@ outputs:
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
+    TE: TE_callable
+    # type=string: echo time (msec)
+    TI: TI_callable
+    # type=string: inversion time (msec)
+    TR: TR_callable
+    # type=string: repetition time(msec)
+    data_type: data_type_callable
+    # type=string: image data type
+    dimensions: dimensions_callable
+    # type=tuple: image dimensions (voxels)
+    file_format: file_format_callable
+    # type=string: file format
+    info: info_callable
+    # type=any: output of mri_info
+    orientation: orientation_callable
+    # type=string: image orientation
+    ph_enc_dir: ph_enc_dir_callable
+    # type=string: phase encode direction
+    vox_sizes: vox_sizes_callable
+    # type=tuple: voxel sizes (mm)
   templates:
   # dict[str, str] - `output_file_template` values to be provided to output fields
   requirements:
diff --git a/example-specs/task/nipype/freesurfer/image_info_callables.py b/example-specs/task/nipype/freesurfer/image_info_callables.py
index baa0543b..ad69c856 100644
--- a/example-specs/task/nipype/freesurfer/image_info_callables.py
+++ b/example-specs/task/nipype/freesurfer/image_info_callables.py
@@ -1 +1,257 @@
 """Module to put any functions that are referred to in the "callables" section of ImageInfo.yaml"""
+
+import os
+import os.path as op
+import attrs
+import logging
+
+
+def info_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["info"]
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+def data_type_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["data_type"]
+
+
+def file_format_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["file_format"]
+
+
+def TE_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["TE"]
+
+
+def TR_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["TR"]
+
+
+def TI_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["TI"]
+
+
+def dimensions_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["dimensions"]
+
+
+def vox_sizes_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["vox_sizes"]
+
+
+def orientation_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["orientation"]
+
+
+def ph_enc_dir_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["ph_enc_dir"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
diff --git a/example-specs/task/nipype/freesurfer/jacobian_callables.py b/example-specs/task/nipype/freesurfer/jacobian_callables.py
index 513e3766..a5e7b26f 100644
--- a/example-specs/task/nipype/freesurfer/jacobian_callables.py
+++ b/example-specs/task/nipype/freesurfer/jacobian_callables.py
@@ -1 +1,20 @@
 """Module to put any functions that are referred to in the "callables" section of Jacobian.yaml"""
+
+import os
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = os.path.abspath(inputs.out_file)
+    return outputs
diff --git a/example-specs/task/nipype/freesurfer/label_2_annot_callables.py b/example-specs/task/nipype/freesurfer/label_2_annot_callables.py
index 404675fc..63dd3568 100644
--- a/example-specs/task/nipype/freesurfer/label_2_annot_callables.py
+++ b/example-specs/task/nipype/freesurfer/label_2_annot_callables.py
@@ -1 +1,25 @@
 """Module to put any functions that are referred to in the "callables" section of Label2Annot.yaml"""
+
+import os
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = os.path.join(
+        str(inputs.subjects_dir),
+        str(inputs.subject_id),
+        "label",
+        str(inputs.hemisphere) + "." + str(inputs.out_annot) + ".annot",
+    )
+    return outputs
diff --git a/example-specs/task/nipype/freesurfer/label_2_label_callables.py b/example-specs/task/nipype/freesurfer/label_2_label_callables.py
index f00cdebe..6d44dc4e 100644
--- a/example-specs/task/nipype/freesurfer/label_2_label_callables.py
+++ b/example-specs/task/nipype/freesurfer/label_2_label_callables.py
@@ -1 +1,25 @@
 """Module to put any functions that are referred to in the "callables" section of Label2Label.yaml"""
+
+import os
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = os.path.join(
+        inputs.subjects_dir,
+        inputs.subject_id,
+        "label",
+        inputs.out_file,
+    )
+    return outputs
diff --git a/example-specs/task/nipype/freesurfer/label_2_vol_callables.py b/example-specs/task/nipype/freesurfer/label_2_vol_callables.py
index 1f5bf397..ce9da230 100644
--- a/example-specs/task/nipype/freesurfer/label_2_vol_callables.py
+++ b/example-specs/task/nipype/freesurfer/label_2_vol_callables.py
@@ -1 +1,135 @@
 """Module to put any functions that are referred to in the "callables" section of Label2Vol.yaml"""
+
+import os
+import attrs
+import os.path as op
+
+
+def vol_label_file_default(inputs):
+    return _gen_filename("vol_label_file", inputs=inputs)
+
+
+def vol_label_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["vol_label_file"]
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "vol_label_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )[name]
+    return None
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outfile = inputs.vol_label_file
+    if outfile is attrs.NOTHING:
+        for key in ["label_file", "annot_file", "seg_file"]:
+            if getattr(inputs, key) is not attrs.NOTHING:
+                path = getattr(inputs, key)
+                if isinstance(path, list):
+                    path = path[0]
+                _, src = os.path.split(path)
+        if inputs.aparc_aseg is not attrs.NOTHING:
+            src = "aparc+aseg.mgz"
+        outfile = fname_presuffix(
+            src, suffix="_vol.nii.gz", newpath=output_dir, use_ext=False
+        )
+    outputs["vol_label_file"] = outfile
+    return outputs
diff --git a/example-specs/task/nipype/freesurfer/logan_ref_callables.py b/example-specs/task/nipype/freesurfer/logan_ref_callables.py
index f7878b7a..e4dbf7a1 100644
--- a/example-specs/task/nipype/freesurfer/logan_ref_callables.py
+++ b/example-specs/task/nipype/freesurfer/logan_ref_callables.py
@@ -1 +1,261 @@
 """Module to put any functions that are referred to in the "callables" section of LoganRef.yaml"""
+
+import os
+import attrs
+import os.path as op
+
+
+def glm_dir_default(inputs):
+    return _gen_filename("glm_dir", inputs=inputs)
+
+
+def glm_dir_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["glm_dir"]
+
+
+def beta_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["beta_file"]
+
+
+def error_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["error_file"]
+
+
+def error_var_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["error_var_file"]
+
+
+def error_stddev_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["error_stddev_file"]
+
+
+def estimate_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["estimate_file"]
+
+
+def mask_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["mask_file"]
+
+
+def fwhm_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["fwhm_file"]
+
+
+def dof_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["dof_file"]
+
+
+def gamma_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["gamma_file"]
+
+
+def gamma_var_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["gamma_var_file"]
+
+
+def sig_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["sig_file"]
+
+
+def ftest_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["ftest_file"]
+
+
+def spatial_eigenvectors_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["spatial_eigenvectors"]
+
+
+def frame_eigenvectors_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["frame_eigenvectors"]
+
+
+def singular_values_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["singular_values"]
+
+
+def svd_stats_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["svd_stats_file"]
+
+
+def k2p_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["k2p_file"]
+
+
+def bp_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["bp_file"]
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "glm_dir":
+        return output_dir
+    return None
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    # Get the top-level output directory
+    if inputs.glm_dir is attrs.NOTHING:
+        glmdir = output_dir
+    else:
+        glmdir = os.path.abspath(inputs.glm_dir)
+    outputs["glm_dir"] = glmdir
+
+    if inputs.nii_gz is not attrs.NOTHING:
+        ext = "nii.gz"
+    elif inputs.nii is not attrs.NOTHING:
+        ext = "nii"
+    else:
+        ext = "mgh"
+
+    # Assign the output files that always get created
+    outputs["beta_file"] = os.path.join(glmdir, f"beta.{ext}")
+    outputs["error_var_file"] = os.path.join(glmdir, f"rvar.{ext}")
+    outputs["error_stddev_file"] = os.path.join(glmdir, f"rstd.{ext}")
+    outputs["mask_file"] = os.path.join(glmdir, f"mask.{ext}")
+    outputs["fwhm_file"] = os.path.join(glmdir, "fwhm.dat")
+    outputs["dof_file"] = os.path.join(glmdir, "dof.dat")
+    # Assign the conditional outputs
+    if inputs.save_residual:
+        outputs["error_file"] = os.path.join(glmdir, f"eres.{ext}")
+    if inputs.save_estimate:
+        outputs["estimate_file"] = os.path.join(glmdir, f"yhat.{ext}")
+    if any((inputs.mrtm1, inputs.mrtm2, inputs.logan)):
+        outputs["bp_file"] = os.path.join(glmdir, f"bp.{ext}")
+    if inputs.mrtm1:
+        outputs["k2p_file"] = os.path.join(glmdir, "k2prime.dat")
+
+    # Get the contrast directory name(s)
+    contrasts = []
+    if inputs.contrast is not attrs.NOTHING:
+        for c in inputs.contrast:
+            if split_filename(c)[2] in [".mat", ".dat", ".mtx", ".con"]:
+                contrasts.append(split_filename(c)[1])
+            else:
+                contrasts.append(os.path.split(c)[1])
+    elif (inputs.one_sample is not attrs.NOTHING) and inputs.one_sample:
+        contrasts = ["osgm"]
+
+    # Add in the contrast images
+    outputs["sig_file"] = [os.path.join(glmdir, c, f"sig.{ext}") for c in contrasts]
+    outputs["ftest_file"] = [os.path.join(glmdir, c, f"F.{ext}") for c in contrasts]
+    outputs["gamma_file"] = [os.path.join(glmdir, c, f"gamma.{ext}") for c in contrasts]
+    outputs["gamma_var_file"] = [
+        os.path.join(glmdir, c, f"gammavar.{ext}") for c in contrasts
+    ]
+
+    # Add in the PCA results, if relevant
+    if (inputs.pca is not attrs.NOTHING) and inputs.pca:
+        pcadir = os.path.join(glmdir, "pca-eres")
+        outputs["spatial_eigenvectors"] = os.path.join(pcadir, f"v.{ext}")
+        outputs["frame_eigenvectors"] = os.path.join(pcadir, "u.mtx")
+        outputs["singluar_values"] = os.path.join(pcadir, "sdiag.mat")
+        outputs["svd_stats_file"] = os.path.join(pcadir, "stats.dat")
+
+    return outputs
diff --git a/example-specs/task/nipype/freesurfer/lta_convert_callables.py b/example-specs/task/nipype/freesurfer/lta_convert_callables.py
index a8761ea3..e56c94f4 100644
--- a/example-specs/task/nipype/freesurfer/lta_convert_callables.py
+++ b/example-specs/task/nipype/freesurfer/lta_convert_callables.py
@@ -1 +1,59 @@
 """Module to put any functions that are referred to in the "callables" section of LTAConvert.yaml"""
+
+import os
+
+
+def out_lta_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_lta"]
+
+
+def out_fsl_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_fsl"]
+
+
+def out_mni_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_mni"]
+
+
+def out_reg_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_reg"]
+
+
+def out_itk_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_itk"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    for name, default in (
+        ("out_lta", "out.lta"),
+        ("out_fsl", "out.mat"),
+        ("out_mni", "out.xfm"),
+        ("out_reg", "out.dat"),
+        ("out_itk", "out.txt"),
+    ):
+        attr = getattr(inputs, name)
+        if attr:
+            fname = default if attr is True else attr
+            outputs[name] = os.path.abspath(fname)
+
+    return outputs
diff --git a/example-specs/task/nipype/freesurfer/make_average_subject.yaml b/example-specs/task/nipype/freesurfer/make_average_subject.yaml
index 52738e25..cb703b5c 100644
--- a/example-specs/task/nipype/freesurfer/make_average_subject.yaml
+++ b/example-specs/task/nipype/freesurfer/make_average_subject.yaml
@@ -50,6 +50,8 @@ outputs:
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
+    average_subject_name: average_subject_name_callable
+    # type=str: Output registration file
   templates:
   # dict[str, str] - `output_file_template` values to be provided to output fields
   requirements:
diff --git a/example-specs/task/nipype/freesurfer/make_average_subject_callables.py b/example-specs/task/nipype/freesurfer/make_average_subject_callables.py
index 71a755c2..33ead557 100644
--- a/example-specs/task/nipype/freesurfer/make_average_subject_callables.py
+++ b/example-specs/task/nipype/freesurfer/make_average_subject_callables.py
@@ -1 +1,18 @@
 """Module to put any functions that are referred to in the "callables" section of MakeAverageSubject.yaml"""
+
+
+def average_subject_name_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["average_subject_name"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["average_subject_name"] = inputs.out_name
+    return outputs
diff --git a/example-specs/task/nipype/freesurfer/make_surfaces_callables.py b/example-specs/task/nipype/freesurfer/make_surfaces_callables.py
index ecddf133..36df4e15 100644
--- a/example-specs/task/nipype/freesurfer/make_surfaces_callables.py
+++ b/example-specs/task/nipype/freesurfer/make_surfaces_callables.py
@@ -1 +1,80 @@
 """Module to put any functions that are referred to in the "callables" section of MakeSurfaces.yaml"""
+
+import os
+import attrs
+
+
+def out_white_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_white"]
+
+
+def out_curv_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_curv"]
+
+
+def out_area_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_area"]
+
+
+def out_cortex_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_cortex"]
+
+
+def out_pial_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_pial"]
+
+
+def out_thickness_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_thickness"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    # Outputs are saved in the surf directory
+    dest_dir = os.path.join(inputs.subjects_dir, inputs.subject_id, "surf")
+    # labels are saved in the label directory
+    label_dir = os.path.join(inputs.subjects_dir, inputs.subject_id, "label")
+    if not inputs.no_white:
+        outputs["out_white"] = os.path.join(dest_dir, str(inputs.hemisphere) + ".white")
+    # The curv and area files must have the hemisphere names as a prefix
+    outputs["out_curv"] = os.path.join(dest_dir, str(inputs.hemisphere) + ".curv")
+    outputs["out_area"] = os.path.join(dest_dir, str(inputs.hemisphere) + ".area")
+    # Something determines when a pial surface and thickness file is generated
+    # but documentation doesn't say what.
+    # The orig_pial input is just a guess
+    if (inputs.orig_pial is not attrs.NOTHING) or inputs.white == "NOWRITE":
+        outputs["out_curv"] = outputs["out_curv"] + ".pial"
+        outputs["out_area"] = outputs["out_area"] + ".pial"
+        outputs["out_pial"] = os.path.join(dest_dir, str(inputs.hemisphere) + ".pial")
+        outputs["out_thickness"] = os.path.join(
+            dest_dir, str(inputs.hemisphere) + ".thickness"
+        )
+    else:
+        # when a pial surface is generated, the cortex label file is not
+        # generated
+        outputs["out_cortex"] = os.path.join(
+            label_dir, str(inputs.hemisphere) + ".cortex.label"
+        )
+    return outputs
diff --git a/example-specs/task/nipype/freesurfer/mni_bias_correction_callables.py b/example-specs/task/nipype/freesurfer/mni_bias_correction_callables.py
index ed299b8c..ab790a4a 100644
--- a/example-specs/task/nipype/freesurfer/mni_bias_correction_callables.py
+++ b/example-specs/task/nipype/freesurfer/mni_bias_correction_callables.py
@@ -1 +1,187 @@
 """Module to put any functions that are referred to in the "callables" section of MNIBiasCorrection.yaml"""
+
+import os
+import os.path as op
+import attrs
+import logging
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
diff --git a/example-specs/task/nipype/freesurfer/mp_rto_mni305_callables.py b/example-specs/task/nipype/freesurfer/mp_rto_mni305_callables.py
index f180eb22..786db1bf 100644
--- a/example-specs/task/nipype/freesurfer/mp_rto_mni305_callables.py
+++ b/example-specs/task/nipype/freesurfer/mp_rto_mni305_callables.py
@@ -1 +1,105 @@
 """Module to put any functions that are referred to in the "callables" section of MPRtoMNI305.yaml"""
+
+import os
+import os.path as op
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+def log_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["log_file"]
+
+
+def nipype_interfaces_freesurfer__FSScriptCommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = {}
+    outputs["log_file"] = os.path.abspath("output.nipype")
+    return outputs
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _get_fname(fname, inputs=None, stdout=None, stderr=None, output_dir=None):
+    return split_filename(fname)[1]
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_freesurfer__FSScriptCommand___list_outputs()
+    fullname = "_".join(
+        [
+            _get_fname(
+                inputs.in_file,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            ),
+            "to",
+            inputs.target,
+            "t4",
+            "vox2vox.txt",
+        ]
+    )
+    outputs["out_file"] = os.path.abspath(fullname)
+    return outputs
diff --git a/example-specs/task/nipype/freesurfer/mr_is_ca_label_callables.py b/example-specs/task/nipype/freesurfer/mr_is_ca_label_callables.py
index aacca75c..3a63573f 100644
--- a/example-specs/task/nipype/freesurfer/mr_is_ca_label_callables.py
+++ b/example-specs/task/nipype/freesurfer/mr_is_ca_label_callables.py
@@ -1 +1,23 @@
 """Module to put any functions that are referred to in the "callables" section of MRIsCALabel.yaml"""
+
+import os
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    out_basename = os.path.basename(inputs.out_file)
+    outputs["out_file"] = os.path.join(
+        inputs.subjects_dir, inputs.subject_id, "label", out_basename
+    )
+    return outputs
diff --git a/example-specs/task/nipype/freesurfer/mr_is_calc_callables.py b/example-specs/task/nipype/freesurfer/mr_is_calc_callables.py
index 58765cbe..ebb0c535 100644
--- a/example-specs/task/nipype/freesurfer/mr_is_calc_callables.py
+++ b/example-specs/task/nipype/freesurfer/mr_is_calc_callables.py
@@ -1 +1,20 @@
 """Module to put any functions that are referred to in the "callables" section of MRIsCalc.yaml"""
+
+import os
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = os.path.abspath(inputs.out_file)
+    return outputs
diff --git a/example-specs/task/nipype/freesurfer/mr_is_combine_callables.py b/example-specs/task/nipype/freesurfer/mr_is_combine_callables.py
index c6b6d55a..6914def6 100644
--- a/example-specs/task/nipype/freesurfer/mr_is_combine_callables.py
+++ b/example-specs/task/nipype/freesurfer/mr_is_combine_callables.py
@@ -1 +1,32 @@
 """Module to put any functions that are referred to in the "callables" section of MRIsCombine.yaml"""
+
+import os
+
+
+def out_file_default(inputs):
+    return _gen_filename("out_file", inputs=inputs)
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+
+    # mris_convert --combinesurfs uses lh. as the default prefix
+    # regardless of input file names, except when path info is
+    # specified
+    path, base = os.path.split(inputs.out_file)
+    if path == "" and base[:3] not in ("lh.", "rh."):
+        base = "lh." + base
+    outputs["out_file"] = os.path.abspath(os.path.join(path, base))
+
+    return outputs
diff --git a/example-specs/task/nipype/freesurfer/mr_is_convert_callables.py b/example-specs/task/nipype/freesurfer/mr_is_convert_callables.py
index b23a1f21..0391d40f 100644
--- a/example-specs/task/nipype/freesurfer/mr_is_convert_callables.py
+++ b/example-specs/task/nipype/freesurfer/mr_is_convert_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of MRIsConvert.yaml"""
 
-import attrs
 import os
+import attrs
 import os.path as op
 
 
@@ -9,11 +9,11 @@ def out_file_default(inputs):
     return _gen_filename("out_file", inputs=inputs)
 
 
-def out_file_callable(output_dir, inputs, stdout, stderr):
+def converted_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_file"]
+    return outputs["converted"]
 
 
 def split_filename(fname):
diff --git a/example-specs/task/nipype/freesurfer/mr_is_expand_callables.py b/example-specs/task/nipype/freesurfer/mr_is_expand_callables.py
index 3581af2c..4ed8df57 100644
--- a/example-specs/task/nipype/freesurfer/mr_is_expand_callables.py
+++ b/example-specs/task/nipype/freesurfer/mr_is_expand_callables.py
@@ -1 +1,46 @@
 """Module to put any functions that are referred to in the "callables" section of MRIsExpand.yaml"""
+
+import os
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+@staticmethod
+def _associated_file(out_name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    """Based on MRIsBuildFileName in freesurfer/utils/mrisurf.c
+
+    If no path information is provided for out_name, use path and
+    hemisphere (if also unspecified) from in_file to determine the path
+    of the associated file.
+    Use in_file prefix to indicate hemisphere for out_name, rather than
+    inspecting the surface data structure.
+    """
+    path, base = os.path.split(out_name)
+    if path == "":
+        path, in_file = os.path.split(in_file)
+        hemis = ("lh.", "rh.")
+        if in_file[:3] in hemis and base[:3] not in hemis:
+            base = in_file[:3] + base
+    return os.path.join(path, base)
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = _associated_file(
+        inputs.in_file,
+        inputs.out_name,
+        inputs=inputs,
+        stdout=stdout,
+        stderr=stderr,
+        output_dir=output_dir,
+    )
+    return outputs
diff --git a/example-specs/task/nipype/freesurfer/mr_is_inflate_callables.py b/example-specs/task/nipype/freesurfer/mr_is_inflate_callables.py
index 76ee3f78..ef4fd9df 100644
--- a/example-specs/task/nipype/freesurfer/mr_is_inflate_callables.py
+++ b/example-specs/task/nipype/freesurfer/mr_is_inflate_callables.py
@@ -1 +1,30 @@
 """Module to put any functions that are referred to in the "callables" section of MRIsInflate.yaml"""
+
+import os
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+def out_sulc_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_sulc"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = os.path.abspath(inputs.out_file)
+    if not inputs.no_save_sulc:
+        # if the sulc file will be saved
+        outputs["out_sulc"] = os.path.abspath(inputs.out_sulc)
+    return outputs
diff --git a/example-specs/task/nipype/freesurfer/mri_convert.yaml b/example-specs/task/nipype/freesurfer/mri_convert.yaml
index 026942bb..c4a5dab5 100644
--- a/example-specs/task/nipype/freesurfer/mri_convert.yaml
+++ b/example-specs/task/nipype/freesurfer/mri_convert.yaml
@@ -71,14 +71,17 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    out_file: medimage/mgh-gz+list-of
+    # type=outputmultiobject: converted output file
+    # type=file|default=<undefined>: output filename or True to generate one
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
-    out_file: out_file_callable
-    # type=outputmultiobject: converted output file
-    # type=file|default=<undefined>: output filename or True to generate one
   templates:
   # dict[str, str] - `output_file_template` values to be provided to output fields
+    out_file: '"outfile.mgz"'
+    # type=outputmultiobject: converted output file
+    # type=file|default=<undefined>: output filename or True to generate one
   requirements:
   # dict[str, list[str]] - input fields that are required to be provided for the output field to be present
 tests:
diff --git a/example-specs/task/nipype/freesurfer/mri_convert_callables.py b/example-specs/task/nipype/freesurfer/mri_convert_callables.py
index 9b81ca1e..7c8b0a3f 100644
--- a/example-specs/task/nipype/freesurfer/mri_convert_callables.py
+++ b/example-specs/task/nipype/freesurfer/mri_convert_callables.py
@@ -1,10 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of MRIConvert.yaml"""
 
-import attrs
 import os
-from nibabel import load
+from nibabel.loadsave import load
+import attrs
 import os.path as op
-from pathlib import Path
 
 
 def out_file_default(inputs):
@@ -44,8 +43,8 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     >>> fname_presuffix(fname,'pre','post','/tmp')
     '/tmp/prefoopost.nii.gz'
 
-    >>> from nipype.interfaces.base import Undefined
-    >>> fname_presuffix(fname, 'pre', 'post', Undefined) == \
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
             fname_presuffix(fname, 'pre', 'post')
     True
 
@@ -54,7 +53,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     if not use_ext:
         ext = ""
 
-    # No need for isdefined: bool(Undefined) evaluates to False
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
     if newpath:
         pth = op.abspath(newpath)
     return op.join(pth, prefix + fname + suffix + ext)
@@ -136,7 +135,7 @@ def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outfile = _get_outfilename(
         inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
     )
-    if inputs.split is not attrs.NOTHING and inputs.split:
+    if (inputs.split is not attrs.NOTHING) and inputs.split:
         size = load(inputs.in_file).shape
         if len(size) == 3:
             tp = 1
diff --git a/example-specs/task/nipype/freesurfer/mri_coreg_callables.py b/example-specs/task/nipype/freesurfer/mri_coreg_callables.py
index 8b951039..5fb95e94 100644
--- a/example-specs/task/nipype/freesurfer/mri_coreg_callables.py
+++ b/example-specs/task/nipype/freesurfer/mri_coreg_callables.py
@@ -1 +1,53 @@
 """Module to put any functions that are referred to in the "callables" section of MRICoreg.yaml"""
+
+import os
+import attrs
+
+
+def out_reg_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_reg_file"]
+
+
+def out_lta_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_lta_file"]
+
+
+def out_params_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_params_file"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+
+    out_lta_file = inputs.out_lta_file
+    if out_lta_file is not attrs.NOTHING:
+        if out_lta_file is True:
+            out_lta_file = "registration.lta"
+        outputs["out_lta_file"] = os.path.abspath(out_lta_file)
+
+    out_reg_file = inputs.out_reg_file
+    if out_reg_file is not attrs.NOTHING:
+        if out_reg_file is True:
+            out_reg_file = "registration.dat"
+        outputs["out_reg_file"] = os.path.abspath(out_reg_file)
+
+    out_params_file = inputs.out_params_file
+    if out_params_file is not attrs.NOTHING:
+        if out_params_file is True:
+            out_params_file = "registration.par"
+        outputs["out_params_file"] = os.path.abspath(out_params_file)
+
+    return outputs
diff --git a/example-specs/task/nipype/freesurfer/mri_fill_callables.py b/example-specs/task/nipype/freesurfer/mri_fill_callables.py
index 6dc1c03b..f5f3f3b4 100644
--- a/example-specs/task/nipype/freesurfer/mri_fill_callables.py
+++ b/example-specs/task/nipype/freesurfer/mri_fill_callables.py
@@ -1 +1,30 @@
 """Module to put any functions that are referred to in the "callables" section of MRIFill.yaml"""
+
+import os
+import attrs
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+def log_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["log_file"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = os.path.abspath(inputs.out_file)
+    if inputs.log_file is not attrs.NOTHING:
+        outputs["log_file"] = os.path.abspath(inputs.log_file)
+    return outputs
diff --git a/example-specs/task/nipype/freesurfer/mri_marching_cubes_callables.py b/example-specs/task/nipype/freesurfer/mri_marching_cubes_callables.py
index 336c63b9..0635a75d 100644
--- a/example-specs/task/nipype/freesurfer/mri_marching_cubes_callables.py
+++ b/example-specs/task/nipype/freesurfer/mri_marching_cubes_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of MRIMarchingCubes.yaml"""
 
-import attrs
 import os
+import attrs
 import os.path as op
 
 
@@ -9,11 +9,11 @@ def out_file_default(inputs):
     return _gen_filename("out_file", inputs=inputs)
 
 
-def out_file_callable(output_dir, inputs, stdout, stderr):
+def surface_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_file"]
+    return outputs["surface"]
 
 
 def split_filename(fname):
diff --git a/example-specs/task/nipype/freesurfer/mri_pretess_callables.py b/example-specs/task/nipype/freesurfer/mri_pretess_callables.py
index d1e58dd9..3385c8b6 100644
--- a/example-specs/task/nipype/freesurfer/mri_pretess_callables.py
+++ b/example-specs/task/nipype/freesurfer/mri_pretess_callables.py
@@ -1 +1,187 @@
 """Module to put any functions that are referred to in the "callables" section of MRIPretess.yaml"""
+
+import os
+import os.path as op
+import attrs
+import logging
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
diff --git a/example-specs/task/nipype/freesurfer/mri_tessellate_callables.py b/example-specs/task/nipype/freesurfer/mri_tessellate_callables.py
index de06ab0a..c36564a9 100644
--- a/example-specs/task/nipype/freesurfer/mri_tessellate_callables.py
+++ b/example-specs/task/nipype/freesurfer/mri_tessellate_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of MRITessellate.yaml"""
 
-import attrs
 import os
+import attrs
 import os.path as op
 
 
@@ -9,11 +9,11 @@ def out_file_default(inputs):
     return _gen_filename("out_file", inputs=inputs)
 
 
-def out_file_callable(output_dir, inputs, stdout, stderr):
+def surface_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_file"]
+    return outputs["surface"]
 
 
 def split_filename(fname):
diff --git a/example-specs/task/nipype/freesurfer/mris_preproc_callables.py b/example-specs/task/nipype/freesurfer/mris_preproc_callables.py
index cf78adf6..934e086e 100644
--- a/example-specs/task/nipype/freesurfer/mris_preproc_callables.py
+++ b/example-specs/task/nipype/freesurfer/mris_preproc_callables.py
@@ -1 +1,34 @@
 """Module to put any functions that are referred to in the "callables" section of MRISPreproc.yaml"""
+
+import os
+import attrs
+
+
+def out_file_default(inputs):
+    return _gen_filename("out_file", inputs=inputs)
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )[name]
+    return None
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outfile = inputs.out_file
+    outputs["out_file"] = outfile
+    if outfile is attrs.NOTHING:
+        outputs["out_file"] = os.path.join(
+            output_dir, "concat_%s_%s.mgz" % (inputs.hemi, inputs.target)
+        )
+    return outputs
diff --git a/example-specs/task/nipype/freesurfer/mris_preproc_recon_all_callables.py b/example-specs/task/nipype/freesurfer/mris_preproc_recon_all_callables.py
index 430e1ee9..024f4f1a 100644
--- a/example-specs/task/nipype/freesurfer/mris_preproc_recon_all_callables.py
+++ b/example-specs/task/nipype/freesurfer/mris_preproc_recon_all_callables.py
@@ -1 +1,34 @@
 """Module to put any functions that are referred to in the "callables" section of MRISPreprocReconAll.yaml"""
+
+import os
+import attrs
+
+
+def out_file_default(inputs):
+    return _gen_filename("out_file", inputs=inputs)
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )[name]
+    return None
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outfile = inputs.out_file
+    outputs["out_file"] = outfile
+    if outfile is attrs.NOTHING:
+        outputs["out_file"] = os.path.join(
+            output_dir, "concat_%s_%s.mgz" % (inputs.hemi, inputs.target)
+        )
+    return outputs
diff --git a/example-specs/task/nipype/freesurfer/mrtm2_callables.py b/example-specs/task/nipype/freesurfer/mrtm2_callables.py
index 929db38f..5eda3372 100644
--- a/example-specs/task/nipype/freesurfer/mrtm2_callables.py
+++ b/example-specs/task/nipype/freesurfer/mrtm2_callables.py
@@ -1 +1,261 @@
 """Module to put any functions that are referred to in the "callables" section of MRTM2.yaml"""
+
+import os
+import attrs
+import os.path as op
+
+
+def glm_dir_default(inputs):
+    return _gen_filename("glm_dir", inputs=inputs)
+
+
+def glm_dir_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["glm_dir"]
+
+
+def beta_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["beta_file"]
+
+
+def error_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["error_file"]
+
+
+def error_var_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["error_var_file"]
+
+
+def error_stddev_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["error_stddev_file"]
+
+
+def estimate_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["estimate_file"]
+
+
+def mask_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["mask_file"]
+
+
+def fwhm_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["fwhm_file"]
+
+
+def dof_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["dof_file"]
+
+
+def gamma_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["gamma_file"]
+
+
+def gamma_var_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["gamma_var_file"]
+
+
+def sig_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["sig_file"]
+
+
+def ftest_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["ftest_file"]
+
+
+def spatial_eigenvectors_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["spatial_eigenvectors"]
+
+
+def frame_eigenvectors_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["frame_eigenvectors"]
+
+
+def singular_values_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["singular_values"]
+
+
+def svd_stats_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["svd_stats_file"]
+
+
+def k2p_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["k2p_file"]
+
+
+def bp_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["bp_file"]
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "glm_dir":
+        return output_dir
+    return None
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    # Get the top-level output directory
+    if inputs.glm_dir is attrs.NOTHING:
+        glmdir = output_dir
+    else:
+        glmdir = os.path.abspath(inputs.glm_dir)
+    outputs["glm_dir"] = glmdir
+
+    if inputs.nii_gz is not attrs.NOTHING:
+        ext = "nii.gz"
+    elif inputs.nii is not attrs.NOTHING:
+        ext = "nii"
+    else:
+        ext = "mgh"
+
+    # Assign the output files that always get created
+    outputs["beta_file"] = os.path.join(glmdir, f"beta.{ext}")
+    outputs["error_var_file"] = os.path.join(glmdir, f"rvar.{ext}")
+    outputs["error_stddev_file"] = os.path.join(glmdir, f"rstd.{ext}")
+    outputs["mask_file"] = os.path.join(glmdir, f"mask.{ext}")
+    outputs["fwhm_file"] = os.path.join(glmdir, "fwhm.dat")
+    outputs["dof_file"] = os.path.join(glmdir, "dof.dat")
+    # Assign the conditional outputs
+    if inputs.save_residual:
+        outputs["error_file"] = os.path.join(glmdir, f"eres.{ext}")
+    if inputs.save_estimate:
+        outputs["estimate_file"] = os.path.join(glmdir, f"yhat.{ext}")
+    if any((inputs.mrtm1, inputs.mrtm2, inputs.logan)):
+        outputs["bp_file"] = os.path.join(glmdir, f"bp.{ext}")
+    if inputs.mrtm1:
+        outputs["k2p_file"] = os.path.join(glmdir, "k2prime.dat")
+
+    # Get the contrast directory name(s)
+    contrasts = []
+    if inputs.contrast is not attrs.NOTHING:
+        for c in inputs.contrast:
+            if split_filename(c)[2] in [".mat", ".dat", ".mtx", ".con"]:
+                contrasts.append(split_filename(c)[1])
+            else:
+                contrasts.append(os.path.split(c)[1])
+    elif (inputs.one_sample is not attrs.NOTHING) and inputs.one_sample:
+        contrasts = ["osgm"]
+
+    # Add in the contrast images
+    outputs["sig_file"] = [os.path.join(glmdir, c, f"sig.{ext}") for c in contrasts]
+    outputs["ftest_file"] = [os.path.join(glmdir, c, f"F.{ext}") for c in contrasts]
+    outputs["gamma_file"] = [os.path.join(glmdir, c, f"gamma.{ext}") for c in contrasts]
+    outputs["gamma_var_file"] = [
+        os.path.join(glmdir, c, f"gammavar.{ext}") for c in contrasts
+    ]
+
+    # Add in the PCA results, if relevant
+    if (inputs.pca is not attrs.NOTHING) and inputs.pca:
+        pcadir = os.path.join(glmdir, "pca-eres")
+        outputs["spatial_eigenvectors"] = os.path.join(pcadir, f"v.{ext}")
+        outputs["frame_eigenvectors"] = os.path.join(pcadir, "u.mtx")
+        outputs["singluar_values"] = os.path.join(pcadir, "sdiag.mat")
+        outputs["svd_stats_file"] = os.path.join(pcadir, "stats.dat")
+
+    return outputs
diff --git a/example-specs/task/nipype/freesurfer/mrtm_callables.py b/example-specs/task/nipype/freesurfer/mrtm_callables.py
index 190f5610..2691dc9b 100644
--- a/example-specs/task/nipype/freesurfer/mrtm_callables.py
+++ b/example-specs/task/nipype/freesurfer/mrtm_callables.py
@@ -1 +1,261 @@
 """Module to put any functions that are referred to in the "callables" section of MRTM.yaml"""
+
+import os
+import attrs
+import os.path as op
+
+
+def glm_dir_default(inputs):
+    return _gen_filename("glm_dir", inputs=inputs)
+
+
+def glm_dir_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["glm_dir"]
+
+
+def beta_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["beta_file"]
+
+
+def error_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["error_file"]
+
+
+def error_var_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["error_var_file"]
+
+
+def error_stddev_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["error_stddev_file"]
+
+
+def estimate_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["estimate_file"]
+
+
+def mask_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["mask_file"]
+
+
+def fwhm_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["fwhm_file"]
+
+
+def dof_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["dof_file"]
+
+
+def gamma_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["gamma_file"]
+
+
+def gamma_var_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["gamma_var_file"]
+
+
+def sig_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["sig_file"]
+
+
+def ftest_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["ftest_file"]
+
+
+def spatial_eigenvectors_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["spatial_eigenvectors"]
+
+
+def frame_eigenvectors_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["frame_eigenvectors"]
+
+
+def singular_values_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["singular_values"]
+
+
+def svd_stats_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["svd_stats_file"]
+
+
+def k2p_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["k2p_file"]
+
+
+def bp_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["bp_file"]
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "glm_dir":
+        return output_dir
+    return None
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    # Get the top-level output directory
+    if inputs.glm_dir is attrs.NOTHING:
+        glmdir = output_dir
+    else:
+        glmdir = os.path.abspath(inputs.glm_dir)
+    outputs["glm_dir"] = glmdir
+
+    if inputs.nii_gz is not attrs.NOTHING:
+        ext = "nii.gz"
+    elif inputs.nii is not attrs.NOTHING:
+        ext = "nii"
+    else:
+        ext = "mgh"
+
+    # Assign the output files that always get created
+    outputs["beta_file"] = os.path.join(glmdir, f"beta.{ext}")
+    outputs["error_var_file"] = os.path.join(glmdir, f"rvar.{ext}")
+    outputs["error_stddev_file"] = os.path.join(glmdir, f"rstd.{ext}")
+    outputs["mask_file"] = os.path.join(glmdir, f"mask.{ext}")
+    outputs["fwhm_file"] = os.path.join(glmdir, "fwhm.dat")
+    outputs["dof_file"] = os.path.join(glmdir, "dof.dat")
+    # Assign the conditional outputs
+    if inputs.save_residual:
+        outputs["error_file"] = os.path.join(glmdir, f"eres.{ext}")
+    if inputs.save_estimate:
+        outputs["estimate_file"] = os.path.join(glmdir, f"yhat.{ext}")
+    if any((inputs.mrtm1, inputs.mrtm2, inputs.logan)):
+        outputs["bp_file"] = os.path.join(glmdir, f"bp.{ext}")
+    if inputs.mrtm1:
+        outputs["k2p_file"] = os.path.join(glmdir, "k2prime.dat")
+
+    # Get the contrast directory name(s)
+    contrasts = []
+    if inputs.contrast is not attrs.NOTHING:
+        for c in inputs.contrast:
+            if split_filename(c)[2] in [".mat", ".dat", ".mtx", ".con"]:
+                contrasts.append(split_filename(c)[1])
+            else:
+                contrasts.append(os.path.split(c)[1])
+    elif (inputs.one_sample is not attrs.NOTHING) and inputs.one_sample:
+        contrasts = ["osgm"]
+
+    # Add in the contrast images
+    outputs["sig_file"] = [os.path.join(glmdir, c, f"sig.{ext}") for c in contrasts]
+    outputs["ftest_file"] = [os.path.join(glmdir, c, f"F.{ext}") for c in contrasts]
+    outputs["gamma_file"] = [os.path.join(glmdir, c, f"gamma.{ext}") for c in contrasts]
+    outputs["gamma_var_file"] = [
+        os.path.join(glmdir, c, f"gammavar.{ext}") for c in contrasts
+    ]
+
+    # Add in the PCA results, if relevant
+    if (inputs.pca is not attrs.NOTHING) and inputs.pca:
+        pcadir = os.path.join(glmdir, "pca-eres")
+        outputs["spatial_eigenvectors"] = os.path.join(pcadir, f"v.{ext}")
+        outputs["frame_eigenvectors"] = os.path.join(pcadir, "u.mtx")
+        outputs["singluar_values"] = os.path.join(pcadir, "sdiag.mat")
+        outputs["svd_stats_file"] = os.path.join(pcadir, "stats.dat")
+
+    return outputs
diff --git a/example-specs/task/nipype/freesurfer/ms__lda_callables.py b/example-specs/task/nipype/freesurfer/ms__lda_callables.py
index ae275a53..41b18e86 100644
--- a/example-specs/task/nipype/freesurfer/ms__lda_callables.py
+++ b/example-specs/task/nipype/freesurfer/ms__lda_callables.py
@@ -1 +1,33 @@
 """Module to put any functions that are referred to in the "callables" section of MS_LDA.yaml"""
+
+import os
+import attrs
+
+
+def weight_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["weight_file"]
+
+
+def vol_synth_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["vol_synth_file"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    pass
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    if inputs.output_synth is not attrs.NOTHING:
+        outputs["vol_synth_file"] = os.path.abspath(inputs.output_synth)
+    else:
+        outputs["vol_synth_file"] = os.path.abspath(inputs.vol_synth_file)
+    if (inputs.use_weights is attrs.NOTHING) or inputs.use_weights is False:
+        outputs["weight_file"] = os.path.abspath(inputs.weight_file)
+    return outputs
diff --git a/example-specs/task/nipype/freesurfer/normalize_callables.py b/example-specs/task/nipype/freesurfer/normalize_callables.py
index 38d7c349..1e18e278 100644
--- a/example-specs/task/nipype/freesurfer/normalize_callables.py
+++ b/example-specs/task/nipype/freesurfer/normalize_callables.py
@@ -1 +1,20 @@
 """Module to put any functions that are referred to in the "callables" section of Normalize.yaml"""
+
+import os
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = os.path.abspath(inputs.out_file)
+    return outputs
diff --git a/example-specs/task/nipype/freesurfer/one_sample_t_test_callables.py b/example-specs/task/nipype/freesurfer/one_sample_t_test_callables.py
index 3c8dc1c7..5b504cee 100644
--- a/example-specs/task/nipype/freesurfer/one_sample_t_test_callables.py
+++ b/example-specs/task/nipype/freesurfer/one_sample_t_test_callables.py
@@ -1 +1,261 @@
 """Module to put any functions that are referred to in the "callables" section of OneSampleTTest.yaml"""
+
+import os
+import attrs
+import os.path as op
+
+
+def glm_dir_default(inputs):
+    return _gen_filename("glm_dir", inputs=inputs)
+
+
+def glm_dir_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["glm_dir"]
+
+
+def beta_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["beta_file"]
+
+
+def error_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["error_file"]
+
+
+def error_var_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["error_var_file"]
+
+
+def error_stddev_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["error_stddev_file"]
+
+
+def estimate_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["estimate_file"]
+
+
+def mask_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["mask_file"]
+
+
+def fwhm_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["fwhm_file"]
+
+
+def dof_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["dof_file"]
+
+
+def gamma_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["gamma_file"]
+
+
+def gamma_var_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["gamma_var_file"]
+
+
+def sig_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["sig_file"]
+
+
+def ftest_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["ftest_file"]
+
+
+def spatial_eigenvectors_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["spatial_eigenvectors"]
+
+
+def frame_eigenvectors_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["frame_eigenvectors"]
+
+
+def singular_values_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["singular_values"]
+
+
+def svd_stats_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["svd_stats_file"]
+
+
+def k2p_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["k2p_file"]
+
+
+def bp_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["bp_file"]
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "glm_dir":
+        return output_dir
+    return None
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    # Get the top-level output directory
+    if inputs.glm_dir is attrs.NOTHING:
+        glmdir = output_dir
+    else:
+        glmdir = os.path.abspath(inputs.glm_dir)
+    outputs["glm_dir"] = glmdir
+
+    if inputs.nii_gz is not attrs.NOTHING:
+        ext = "nii.gz"
+    elif inputs.nii is not attrs.NOTHING:
+        ext = "nii"
+    else:
+        ext = "mgh"
+
+    # Assign the output files that always get created
+    outputs["beta_file"] = os.path.join(glmdir, f"beta.{ext}")
+    outputs["error_var_file"] = os.path.join(glmdir, f"rvar.{ext}")
+    outputs["error_stddev_file"] = os.path.join(glmdir, f"rstd.{ext}")
+    outputs["mask_file"] = os.path.join(glmdir, f"mask.{ext}")
+    outputs["fwhm_file"] = os.path.join(glmdir, "fwhm.dat")
+    outputs["dof_file"] = os.path.join(glmdir, "dof.dat")
+    # Assign the conditional outputs
+    if inputs.save_residual:
+        outputs["error_file"] = os.path.join(glmdir, f"eres.{ext}")
+    if inputs.save_estimate:
+        outputs["estimate_file"] = os.path.join(glmdir, f"yhat.{ext}")
+    if any((inputs.mrtm1, inputs.mrtm2, inputs.logan)):
+        outputs["bp_file"] = os.path.join(glmdir, f"bp.{ext}")
+    if inputs.mrtm1:
+        outputs["k2p_file"] = os.path.join(glmdir, "k2prime.dat")
+
+    # Get the contrast directory name(s)
+    contrasts = []
+    if inputs.contrast is not attrs.NOTHING:
+        for c in inputs.contrast:
+            if split_filename(c)[2] in [".mat", ".dat", ".mtx", ".con"]:
+                contrasts.append(split_filename(c)[1])
+            else:
+                contrasts.append(os.path.split(c)[1])
+    elif (inputs.one_sample is not attrs.NOTHING) and inputs.one_sample:
+        contrasts = ["osgm"]
+
+    # Add in the contrast images
+    outputs["sig_file"] = [os.path.join(glmdir, c, f"sig.{ext}") for c in contrasts]
+    outputs["ftest_file"] = [os.path.join(glmdir, c, f"F.{ext}") for c in contrasts]
+    outputs["gamma_file"] = [os.path.join(glmdir, c, f"gamma.{ext}") for c in contrasts]
+    outputs["gamma_var_file"] = [
+        os.path.join(glmdir, c, f"gammavar.{ext}") for c in contrasts
+    ]
+
+    # Add in the PCA results, if relevant
+    if (inputs.pca is not attrs.NOTHING) and inputs.pca:
+        pcadir = os.path.join(glmdir, "pca-eres")
+        outputs["spatial_eigenvectors"] = os.path.join(pcadir, f"v.{ext}")
+        outputs["frame_eigenvectors"] = os.path.join(pcadir, "u.mtx")
+        outputs["singluar_values"] = os.path.join(pcadir, "sdiag.mat")
+        outputs["svd_stats_file"] = os.path.join(pcadir, "stats.dat")
+
+    return outputs
diff --git a/example-specs/task/nipype/freesurfer/paint_callables.py b/example-specs/task/nipype/freesurfer/paint_callables.py
index f836bd38..b33ee6de 100644
--- a/example-specs/task/nipype/freesurfer/paint_callables.py
+++ b/example-specs/task/nipype/freesurfer/paint_callables.py
@@ -1 +1,20 @@
 """Module to put any functions that are referred to in the "callables" section of Paint.yaml"""
+
+import os
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = os.path.abspath(inputs.out_file)
+    return outputs
diff --git a/example-specs/task/nipype/freesurfer/parcellation_stats_callables.py b/example-specs/task/nipype/freesurfer/parcellation_stats_callables.py
index d20ea541..d28dc7b6 100644
--- a/example-specs/task/nipype/freesurfer/parcellation_stats_callables.py
+++ b/example-specs/task/nipype/freesurfer/parcellation_stats_callables.py
@@ -1 +1,88 @@
 """Module to put any functions that are referred to in the "callables" section of ParcellationStats.yaml"""
+
+import os
+import attrs
+
+
+def out_table_default(inputs):
+    return _gen_filename("out_table", inputs=inputs)
+
+
+def out_color_default(inputs):
+    return _gen_filename("out_color", inputs=inputs)
+
+
+def out_table_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_table"]
+
+
+def out_color_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_color"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name in ["out_table", "out_color"]:
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )[name]
+    return None
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    if inputs.out_table is not attrs.NOTHING:
+        outputs["out_table"] = os.path.abspath(inputs.out_table)
+    else:
+        # subject stats directory
+        stats_dir = os.path.join(inputs.subjects_dir, inputs.subject_id, "stats")
+        if inputs.in_annotation is not attrs.NOTHING:
+            # if out_table is not defined just tag .stats on the end
+            # instead of .annot
+            if inputs.surface == "pial":
+                basename = os.path.basename(inputs.in_annotation).replace(
+                    ".annot", ".pial.stats"
+                )
+            else:
+                basename = os.path.basename(inputs.in_annotation).replace(
+                    ".annot", ".stats"
+                )
+        elif inputs.in_label is not attrs.NOTHING:
+            # if out_table is not defined just tag .stats on the end
+            # instead of .label
+            if inputs.surface == "pial":
+                basename = os.path.basename(inputs.in_label).replace(
+                    ".label", ".pial.stats"
+                )
+            else:
+                basename = os.path.basename(inputs.in_label).replace(".label", ".stats")
+        else:
+            basename = str(inputs.hemisphere) + ".aparc.annot.stats"
+        outputs["out_table"] = os.path.join(stats_dir, basename)
+    if inputs.out_color is not attrs.NOTHING:
+        outputs["out_color"] = os.path.abspath(inputs.out_color)
+    else:
+        # subject label directory
+        out_dir = os.path.join(inputs.subjects_dir, inputs.subject_id, "label")
+        if inputs.in_annotation is not attrs.NOTHING:
+            # find the annotation name (if it exists)
+            basename = os.path.basename(inputs.in_annotation)
+            for item in ["lh.", "rh.", "aparc.", "annot"]:
+                basename = basename.replace(item, "")
+            annot = basename
+            # if the out_color table is not defined, one with the annotation
+            # name will be created
+            if "BA" in annot:
+                outputs["out_color"] = os.path.join(out_dir, annot + "ctab")
+            else:
+                outputs["out_color"] = os.path.join(
+                    out_dir, "aparc.annot." + annot + "ctab"
+                )
+        else:
+            outputs["out_color"] = os.path.join(out_dir, "aparc.annot.ctab")
+    return outputs
diff --git a/example-specs/task/nipype/freesurfer/parse_dicom_dir_callables.py b/example-specs/task/nipype/freesurfer/parse_dicom_dir_callables.py
index 65467f64..1c123cd4 100644
--- a/example-specs/task/nipype/freesurfer/parse_dicom_dir_callables.py
+++ b/example-specs/task/nipype/freesurfer/parse_dicom_dir_callables.py
@@ -1 +1,22 @@
 """Module to put any functions that are referred to in the "callables" section of ParseDICOMDir.yaml"""
+
+import os
+import attrs
+
+
+def dicom_info_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["dicom_info_file"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    if inputs.dicom_info_file is not attrs.NOTHING:
+        outputs["dicom_info_file"] = os.path.join(output_dir, inputs.dicom_info_file)
+    return outputs
diff --git a/example-specs/task/nipype/freesurfer/recon_all.yaml b/example-specs/task/nipype/freesurfer/recon_all.yaml
index af49e9cc..33021c67 100644
--- a/example-specs/task/nipype/freesurfer/recon_all.yaml
+++ b/example-specs/task/nipype/freesurfer/recon_all.yaml
@@ -96,34 +96,89 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    BA_stats: generic/file+list-of
+    # type=outputmultiobject: Brodmann Area statistics files
     T1: generic/file
     # type=file: Intensity normalized whole-head volume
+    annot: generic/file+list-of
+    # type=outputmultiobject: Surface annotation files
+    aparc_a2009s_stats: generic/file+list-of
+    # type=outputmultiobject: Aparc a2009s parcellation statistics files
+    aparc_aseg: generic/file+list-of
+    # type=outputmultiobject: Aparc parcellation projected into aseg volume
+    aparc_stats: generic/file+list-of
+    # type=outputmultiobject: Aparc parcellation statistics files
+    area_pial: generic/file+list-of
+    # type=outputmultiobject: Mean area of triangles each vertex on the pial surface is associated with
     aseg: generic/file
     # type=file: Volumetric map of regions from automatic segmentation
+    aseg_stats: generic/file+list-of
+    # type=outputmultiobject: Automated segmentation statistics file
+    avg_curv: generic/file+list-of
+    # type=outputmultiobject: Average atlas curvature, sampled to subject
     brain: generic/file
     # type=file: Intensity normalized brain-only volume
     brainmask: generic/file
     # type=file: Skull-stripped (brain-only) volume
+    curv: generic/file+list-of
+    # type=outputmultiobject: Maps of surface curvature
+    curv_pial: generic/file+list-of
+    # type=outputmultiobject: Curvature of pial surface
+    curv_stats: generic/file+list-of
+    # type=outputmultiobject: Curvature statistics files
+    entorhinal_exvivo_stats: generic/file+list-of
+    # type=outputmultiobject: Entorhinal exvivo statistics files
     filled: generic/file
     # type=file: Subcortical mass volume
+    graymid: generic/file+list-of
+    # type=outputmultiobject: Graymid/midthickness surface meshes
+    inflated: generic/file+list-of
+    # type=outputmultiobject: Inflated surface meshes
+    jacobian_white: generic/file+list-of
+    # type=outputmultiobject: Distortion required to register to spherical atlas
+    label: generic/file+list-of
+    # type=outputmultiobject: Volume and surface label files
     norm: generic/file
     # type=file: Normalized skull-stripped volume
     nu: generic/file
     # type=file: Non-uniformity corrected whole-head volume
     orig: generic/file
     # type=file: Base image conformed to Freesurfer space
+    pial: generic/file+list-of
+    # type=outputmultiobject: Gray matter/pia mater surface meshes
     rawavg: generic/file
     # type=file: Volume formed by averaging input images
+    ribbon: generic/file+list-of
+    # type=outputmultiobject: Volumetric maps of cortical ribbons
+    smoothwm: generic/file+list-of
+    # type=outputmultiobject: Smoothed original surface meshes
+    sphere: generic/file+list-of
+    # type=outputmultiobject: Spherical surface meshes
+    sphere_reg: generic/file+list-of
+    # type=outputmultiobject: Spherical registration file
     subjects_dir: generic/directory
     # type=directory: Freesurfer subjects directory.
     # type=directory|default=<undefined>: path to subjects directory
+    sulc: generic/file+list-of
+    # type=outputmultiobject: Surface maps of sulcal depth
+    thickness: generic/file+list-of
+    # type=outputmultiobject: Surface maps of cortical thickness
+    volume: generic/file+list-of
+    # type=outputmultiobject: Surface maps of cortical volume
+    white: generic/file+list-of
+    # type=outputmultiobject: White/gray matter surface meshes
     wm: generic/file
     # type=file: Segmented white-matter volume
     wmparc: generic/file
     # type=file: Aparc parcellation projected into subcortical white matter
+    wmparc_stats: generic/file+list-of
+    # type=outputmultiobject: White matter parcellation statistics file
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
+    subject_id: subject_id_callable
+    # type=str: Subject name for whom to retrieve data
+    # type=str|default='recon_all': subject name
   templates:
   # dict[str, str] - `output_file_template` values to be provided to output fields
     subjects_dir: '"."'
diff --git a/example-specs/task/nipype/freesurfer/recon_all_callables.py b/example-specs/task/nipype/freesurfer/recon_all_callables.py
index a67a91e3..12c87ee8 100644
--- a/example-specs/task/nipype/freesurfer/recon_all_callables.py
+++ b/example-specs/task/nipype/freesurfer/recon_all_callables.py
@@ -1 +1,320 @@
 """Module to put any functions that are referred to in the "callables" section of ReconAll.yaml"""
+
+import attrs
+
+
+def subjects_dir_default(inputs):
+    return _gen_filename("subjects_dir", inputs=inputs)
+
+
+def subjects_dir_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["subjects_dir"]
+
+
+def subject_id_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["subject_id"]
+
+
+def T1_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["T1"]
+
+
+def aseg_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["aseg"]
+
+
+def brain_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["brain"]
+
+
+def brainmask_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["brainmask"]
+
+
+def filled_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["filled"]
+
+
+def norm_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["norm"]
+
+
+def nu_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["nu"]
+
+
+def orig_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["orig"]
+
+
+def rawavg_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["rawavg"]
+
+
+def ribbon_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["ribbon"]
+
+
+def wm_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["wm"]
+
+
+def wmparc_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["wmparc"]
+
+
+def curv_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["curv"]
+
+
+def avg_curv_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["avg_curv"]
+
+
+def inflated_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["inflated"]
+
+
+def pial_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["pial"]
+
+
+def area_pial_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["area_pial"]
+
+
+def curv_pial_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["curv_pial"]
+
+
+def smoothwm_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["smoothwm"]
+
+
+def sphere_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["sphere"]
+
+
+def sulc_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["sulc"]
+
+
+def thickness_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["thickness"]
+
+
+def volume_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["volume"]
+
+
+def white_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["white"]
+
+
+def jacobian_white_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["jacobian_white"]
+
+
+def graymid_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["graymid"]
+
+
+def label_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["label"]
+
+
+def annot_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["annot"]
+
+
+def aparc_aseg_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["aparc_aseg"]
+
+
+def sphere_reg_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["sphere_reg"]
+
+
+def aseg_stats_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["aseg_stats"]
+
+
+def wmparc_stats_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["wmparc_stats"]
+
+
+def aparc_stats_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["aparc_stats"]
+
+
+def BA_stats_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["BA_stats"]
+
+
+def aparc_a2009s_stats_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["aparc_a2009s_stats"]
+
+
+def curv_stats_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["curv_stats"]
+
+
+def entorhinal_exvivo_stats_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["entorhinal_exvivo_stats"]
+
+
+def _gen_subjects_dir(inputs=None, stdout=None, stderr=None, output_dir=None):
+    return output_dir
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "subjects_dir":
+        return _gen_subjects_dir(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )
+    return None
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    """
+    See io.FreeSurferSource.outputs for the list of outputs returned
+    """
+    if inputs.subjects_dir is not attrs.NOTHING:
+        subjects_dir = inputs.subjects_dir
+    else:
+        subjects_dir = _gen_subjects_dir(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )
+
+    if inputs.hemi is not attrs.NOTHING:
+        hemi = inputs.hemi
+    else:
+        hemi = "both"
+
+    outputs = {}
+
+    outputs.update(
+        FreeSurferSource(
+            subject_id=inputs.subject_id, subjects_dir=subjects_dir, hemi=hemi
+        )._list_outputs()
+    )
+    outputs["subject_id"] = inputs.subject_id
+    outputs["subjects_dir"] = subjects_dir
+    return outputs
diff --git a/example-specs/task/nipype/freesurfer/register_av_ito_talairach_callables.py b/example-specs/task/nipype/freesurfer/register_av_ito_talairach_callables.py
index 72e18eb6..c222f28b 100644
--- a/example-specs/task/nipype/freesurfer/register_av_ito_talairach_callables.py
+++ b/example-specs/task/nipype/freesurfer/register_av_ito_talairach_callables.py
@@ -1 +1,27 @@
 """Module to put any functions that are referred to in the "callables" section of RegisterAVItoTalairach.yaml"""
+
+import os
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+def log_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["log_file"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = os.path.abspath(inputs.out_file)
+    return outputs
diff --git a/example-specs/task/nipype/freesurfer/register_callables.py b/example-specs/task/nipype/freesurfer/register_callables.py
index 5acaa15e..3681fa67 100644
--- a/example-specs/task/nipype/freesurfer/register_callables.py
+++ b/example-specs/task/nipype/freesurfer/register_callables.py
@@ -1 +1,32 @@
 """Module to put any functions that are referred to in the "callables" section of Register.yaml"""
+
+import os
+import attrs
+
+
+def out_file_default(inputs):
+    return _gen_filename("out_file", inputs=inputs)
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )[name]
+    return None
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    if inputs.out_file is not attrs.NOTHING:
+        outputs["out_file"] = os.path.abspath(inputs.out_file)
+    else:
+        outputs["out_file"] = os.path.abspath(inputs.in_surf) + ".reg"
+    return outputs
diff --git a/example-specs/task/nipype/freesurfer/relabel_hypointensities_callables.py b/example-specs/task/nipype/freesurfer/relabel_hypointensities_callables.py
index 1d61dce8..03891a26 100644
--- a/example-specs/task/nipype/freesurfer/relabel_hypointensities_callables.py
+++ b/example-specs/task/nipype/freesurfer/relabel_hypointensities_callables.py
@@ -1 +1,20 @@
 """Module to put any functions that are referred to in the "callables" section of RelabelHypointensities.yaml"""
+
+import os
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = os.path.abspath(inputs.out_file)
+    return outputs
diff --git a/example-specs/task/nipype/freesurfer/remove_intersection_callables.py b/example-specs/task/nipype/freesurfer/remove_intersection_callables.py
index 50dc2b82..0a03c662 100644
--- a/example-specs/task/nipype/freesurfer/remove_intersection_callables.py
+++ b/example-specs/task/nipype/freesurfer/remove_intersection_callables.py
@@ -1 +1,20 @@
 """Module to put any functions that are referred to in the "callables" section of RemoveIntersection.yaml"""
+
+import os
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = os.path.abspath(inputs.out_file)
+    return outputs
diff --git a/example-specs/task/nipype/freesurfer/remove_neck_callables.py b/example-specs/task/nipype/freesurfer/remove_neck_callables.py
index 4ea5176e..4d4ecec7 100644
--- a/example-specs/task/nipype/freesurfer/remove_neck_callables.py
+++ b/example-specs/task/nipype/freesurfer/remove_neck_callables.py
@@ -1 +1,20 @@
 """Module to put any functions that are referred to in the "callables" section of RemoveNeck.yaml"""
+
+import os
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = os.path.abspath(inputs.out_file)
+    return outputs
diff --git a/example-specs/task/nipype/freesurfer/resample_callables.py b/example-specs/task/nipype/freesurfer/resample_callables.py
index d6f33aaa..71e48035 100644
--- a/example-specs/task/nipype/freesurfer/resample_callables.py
+++ b/example-specs/task/nipype/freesurfer/resample_callables.py
@@ -1 +1,133 @@
 """Module to put any functions that are referred to in the "callables" section of Resample.yaml"""
+
+import attrs
+import os.path as op
+
+
+def resampled_file_default(inputs):
+    return _gen_filename("resampled_file", inputs=inputs)
+
+
+def resampled_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["resampled_file"]
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _get_outfilename(inputs=None, stdout=None, stderr=None, output_dir=None):
+    if inputs.resampled_file is not attrs.NOTHING:
+        outfile = inputs.resampled_file
+    else:
+        outfile = fname_presuffix(
+            inputs.in_file, newpath=output_dir, suffix="_resample"
+        )
+    return outfile
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "resampled_file":
+        return _get_outfilename(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )
+    return None
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["resampled_file"] = _get_outfilename(
+        inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+    )
+    return outputs
diff --git a/example-specs/task/nipype/freesurfer/robust_register_callables.py b/example-specs/task/nipype/freesurfer/robust_register_callables.py
index d8f48bf5..dd59414c 100644
--- a/example-specs/task/nipype/freesurfer/robust_register_callables.py
+++ b/example-specs/task/nipype/freesurfer/robust_register_callables.py
@@ -1 +1,185 @@
 """Module to put any functions that are referred to in the "callables" section of RobustRegister.yaml"""
+
+import os
+import os.path as op
+
+
+def out_reg_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_reg_file"]
+
+
+def registered_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["registered_file"]
+
+
+def weights_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["weights_file"]
+
+
+def half_source_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["half_source"]
+
+
+def half_targ_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["half_targ"]
+
+
+def half_weights_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["half_weights"]
+
+
+def half_source_xfm_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["half_source_xfm"]
+
+
+def half_targ_xfm_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["half_targ_xfm"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    cwd = output_dir
+    prefixes = dict(src=inputs.source_file, trg=inputs.target_file)
+    suffixes = dict(
+        out_reg_file=("src", "_robustreg.lta", False),
+        registered_file=("src", "_robustreg", True),
+        weights_file=("src", "_robustweights", True),
+        half_source=("src", "_halfway", True),
+        half_targ=("trg", "_halfway", True),
+        half_weights=("src", "_halfweights", True),
+        half_source_xfm=("src", "_robustxfm.lta", False),
+        half_targ_xfm=("trg", "_robustxfm.lta", False),
+    )
+    for name, sufftup in list(suffixes.items()):
+        value = getattr(inputs, name)
+        if value:
+            if value is True:
+                outputs[name] = fname_presuffix(
+                    prefixes[sufftup[0]],
+                    suffix=sufftup[1],
+                    newpath=cwd,
+                    use_ext=sufftup[2],
+                )
+            else:
+                outputs[name] = os.path.abspath(value)
+    return outputs
diff --git a/example-specs/task/nipype/freesurfer/robust_template.yaml b/example-specs/task/nipype/freesurfer/robust_template.yaml
index 2944a5e2..41ef08ea 100644
--- a/example-specs/task/nipype/freesurfer/robust_template.yaml
+++ b/example-specs/task/nipype/freesurfer/robust_template.yaml
@@ -84,6 +84,12 @@ outputs:
     out_file: medimage/nifti1
     # type=file: output template volume (final mean/median image)
     # type=file|default='mri_robust_template_out.mgz': output template volume (final mean/median image)
+    scaled_intensity_outputs: text/text-file+list-of
+    # type=outputmultiobject: output final intensity scales
+    # type=traitcompound|default=[None]: final intensity scales (will activate --iscale)
+    transform_outputs: medimage-freesurfer/lta+list-of
+    # type=outputmultiobject: output xform files from moving to template
+    # type=traitcompound|default=[None]: output xforms to template (for each input)
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/freesurfer/robust_template_callables.py b/example-specs/task/nipype/freesurfer/robust_template_callables.py
index 1aa8753c..850904da 100644
--- a/example-specs/task/nipype/freesurfer/robust_template_callables.py
+++ b/example-specs/task/nipype/freesurfer/robust_template_callables.py
@@ -1 +1,47 @@
 """Module to put any functions that are referred to in the "callables" section of RobustTemplate.yaml"""
+
+import os
+import attrs
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+def transform_outputs_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["transform_outputs"]
+
+
+def scaled_intensity_outputs_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["scaled_intensity_outputs"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = os.path.abspath(inputs.out_file)
+    n_files = len(inputs.in_files)
+    fmt = "{}{:02d}.{}" if n_files > 9 else "{}{:d}.{}"
+    if inputs.transform_outputs is not attrs.NOTHING:
+        fnames = inputs.transform_outputs
+        if fnames is True:
+            fnames = [fmt.format("tp", i + 1, "lta") for i in range(n_files)]
+        outputs["transform_outputs"] = [os.path.abspath(x) for x in fnames]
+    if inputs.scaled_intensity_outputs is not attrs.NOTHING:
+        fnames = inputs.scaled_intensity_outputs
+        if fnames is True:
+            fnames = [fmt.format("is", i + 1, "txt") for i in range(n_files)]
+        outputs["scaled_intensity_outputs"] = [os.path.abspath(x) for x in fnames]
+    return outputs
diff --git a/example-specs/task/nipype/freesurfer/sample_to_surface_callables.py b/example-specs/task/nipype/freesurfer/sample_to_surface_callables.py
index a675706f..4e8ed3a1 100644
--- a/example-specs/task/nipype/freesurfer/sample_to_surface_callables.py
+++ b/example-specs/task/nipype/freesurfer/sample_to_surface_callables.py
@@ -1 +1,205 @@
 """Module to put any functions that are referred to in the "callables" section of SampleToSurface.yaml"""
+
+import os
+import attrs
+import os.path as op
+
+
+def out_file_default(inputs):
+    return _gen_filename("out_file", inputs=inputs)
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+def hits_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["hits_file"]
+
+
+def vox_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["vox_file"]
+
+
+filemap = dict(
+    cor="cor",
+    mgh="mgh",
+    mgz="mgz",
+    minc="mnc",
+    afni="brik",
+    brik="brik",
+    bshort="bshort",
+    spm="img",
+    analyze="img",
+    analyze4d="img",
+    bfloat="bfloat",
+    nifti1="img",
+    nii="nii",
+    niigz="nii.gz",
+    gii="gii",
+)
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _get_outfilename(
+    opt="out_file", inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outfile = getattr(inputs, opt)
+    if (outfile is attrs.NOTHING) or isinstance(outfile, bool):
+        if inputs.out_type is not attrs.NOTHING:
+            if opt == "hits_file":
+                suffix = "_hits." + filemap[inputs.out_type]
+            else:
+                suffix = "." + filemap[inputs.out_type]
+        elif opt == "hits_file":
+            suffix = "_hits.mgz"
+        else:
+            suffix = ".mgz"
+        outfile = fname_presuffix(
+            inputs.source_file,
+            newpath=output_dir,
+            prefix=inputs.hemi + ".",
+            suffix=suffix,
+            use_ext=False,
+        )
+    return outfile
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )[name]
+    return None
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = os.path.abspath(
+        _get_outfilename(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )
+    )
+    hitsfile = inputs.hits_file
+    if hitsfile is not attrs.NOTHING:
+        outputs["hits_file"] = hitsfile
+        if isinstance(hitsfile, bool):
+            hitsfile = _get_outfilename(
+                "hits_file",
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    voxfile = inputs.vox_file
+    if voxfile is not attrs.NOTHING:
+        if isinstance(voxfile, bool):
+            voxfile = fname_presuffix(
+                inputs.source_file,
+                newpath=output_dir,
+                prefix=inputs.hemi + ".",
+                suffix="_vox.txt",
+                use_ext=False,
+            )
+        outputs["vox_file"] = voxfile
+    return outputs
diff --git a/example-specs/task/nipype/freesurfer/seg_stats_callables.py b/example-specs/task/nipype/freesurfer/seg_stats_callables.py
index 5ee4b4e0..afaee3a6 100644
--- a/example-specs/task/nipype/freesurfer/seg_stats_callables.py
+++ b/example-specs/task/nipype/freesurfer/seg_stats_callables.py
@@ -1 +1,166 @@
 """Module to put any functions that are referred to in the "callables" section of SegStats.yaml"""
+
+import os
+import attrs
+import os.path as op
+
+
+def summary_file_default(inputs):
+    return _gen_filename("summary_file", inputs=inputs)
+
+
+def summary_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["summary_file"]
+
+
+def avgwf_txt_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["avgwf_txt_file"]
+
+
+def avgwf_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["avgwf_file"]
+
+
+def sf_avg_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["sf_avg_file"]
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "summary_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )[name]
+    return None
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    if inputs.summary_file is not attrs.NOTHING:
+        outputs["summary_file"] = os.path.abspath(inputs.summary_file)
+    else:
+        outputs["summary_file"] = os.path.join(output_dir, "summary.stats")
+    suffices = dict(
+        avgwf_txt_file="_avgwf.txt",
+        avgwf_file="_avgwf.nii.gz",
+        sf_avg_file="sfavg.txt",
+    )
+    if inputs.segmentation_file is not attrs.NOTHING:
+        _, src = os.path.split(inputs.segmentation_file)
+    if inputs.annot is not attrs.NOTHING:
+        src = "_".join(inputs.annot)
+    if inputs.surf_label is not attrs.NOTHING:
+        src = "_".join(inputs.surf_label)
+    for name, suffix in list(suffices.items()):
+        value = getattr(inputs, name)
+        if value is not attrs.NOTHING:
+            if isinstance(value, bool):
+                outputs[name] = fname_presuffix(
+                    src, suffix=suffix, newpath=output_dir, use_ext=False
+                )
+            else:
+                outputs[name] = os.path.abspath(value)
+    return outputs
diff --git a/example-specs/task/nipype/freesurfer/seg_stats_recon_all_callables.py b/example-specs/task/nipype/freesurfer/seg_stats_recon_all_callables.py
index 17259997..0658160a 100644
--- a/example-specs/task/nipype/freesurfer/seg_stats_recon_all_callables.py
+++ b/example-specs/task/nipype/freesurfer/seg_stats_recon_all_callables.py
@@ -1 +1,166 @@
 """Module to put any functions that are referred to in the "callables" section of SegStatsReconAll.yaml"""
+
+import os
+import attrs
+import os.path as op
+
+
+def summary_file_default(inputs):
+    return _gen_filename("summary_file", inputs=inputs)
+
+
+def summary_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["summary_file"]
+
+
+def avgwf_txt_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["avgwf_txt_file"]
+
+
+def avgwf_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["avgwf_file"]
+
+
+def sf_avg_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["sf_avg_file"]
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "summary_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )[name]
+    return None
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    if inputs.summary_file is not attrs.NOTHING:
+        outputs["summary_file"] = os.path.abspath(inputs.summary_file)
+    else:
+        outputs["summary_file"] = os.path.join(output_dir, "summary.stats")
+    suffices = dict(
+        avgwf_txt_file="_avgwf.txt",
+        avgwf_file="_avgwf.nii.gz",
+        sf_avg_file="sfavg.txt",
+    )
+    if inputs.segmentation_file is not attrs.NOTHING:
+        _, src = os.path.split(inputs.segmentation_file)
+    if inputs.annot is not attrs.NOTHING:
+        src = "_".join(inputs.annot)
+    if inputs.surf_label is not attrs.NOTHING:
+        src = "_".join(inputs.surf_label)
+    for name, suffix in list(suffices.items()):
+        value = getattr(inputs, name)
+        if value is not attrs.NOTHING:
+            if isinstance(value, bool):
+                outputs[name] = fname_presuffix(
+                    src, suffix=suffix, newpath=output_dir, use_ext=False
+                )
+            else:
+                outputs[name] = os.path.abspath(value)
+    return outputs
diff --git a/example-specs/task/nipype/freesurfer/segment_cc_callables.py b/example-specs/task/nipype/freesurfer/segment_cc_callables.py
index cc2bd0d6..3e8ea8d3 100644
--- a/example-specs/task/nipype/freesurfer/segment_cc_callables.py
+++ b/example-specs/task/nipype/freesurfer/segment_cc_callables.py
@@ -1 +1,28 @@
 """Module to put any functions that are referred to in the "callables" section of SegmentCC.yaml"""
+
+import os
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+def out_rotation_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_rotation"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = os.path.abspath(inputs.out_file)
+    outputs["out_rotation"] = os.path.abspath(inputs.out_rotation)
+    return outputs
diff --git a/example-specs/task/nipype/freesurfer/segment_wm_callables.py b/example-specs/task/nipype/freesurfer/segment_wm_callables.py
index 7c13fcb5..9bf6f872 100644
--- a/example-specs/task/nipype/freesurfer/segment_wm_callables.py
+++ b/example-specs/task/nipype/freesurfer/segment_wm_callables.py
@@ -1 +1,20 @@
 """Module to put any functions that are referred to in the "callables" section of SegmentWM.yaml"""
+
+import os
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = os.path.abspath(inputs.out_file)
+    return outputs
diff --git a/example-specs/task/nipype/freesurfer/smooth_callables.py b/example-specs/task/nipype/freesurfer/smooth_callables.py
index 277b109d..d645f421 100644
--- a/example-specs/task/nipype/freesurfer/smooth_callables.py
+++ b/example-specs/task/nipype/freesurfer/smooth_callables.py
@@ -1 +1,167 @@
 """Module to put any functions that are referred to in the "callables" section of Smooth.yaml"""
+
+import attrs
+import os.path as op
+
+
+def smoothed_file_default(inputs):
+    return _gen_filename("smoothed_file", inputs=inputs)
+
+
+def smoothed_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["smoothed_file"]
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _gen_fname(
+    basename,
+    fname=None,
+    cwd=None,
+    suffix="_fs",
+    use_ext=True,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Define a generic mapping for a single outfile
+
+    The filename is potentially autogenerated by suffixing inputs.infile
+
+    Parameters
+    ----------
+    basename : string (required)
+        filename to base the new filename on
+    fname : string
+        if not None, just use this fname
+    cwd : string
+        prefix paths with cwd, otherwise output_dir
+    suffix : string
+        default suffix
+    """
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "mris_volsmooth"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=use_ext, newpath=cwd)
+    return fname
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "smoothed_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )[name]
+    return None
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outfile = inputs.smoothed_file
+    if outfile is attrs.NOTHING:
+        outfile = _gen_fname(
+            inputs.in_file,
+            suffix="_smooth",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    outputs["smoothed_file"] = outfile
+    return outputs
diff --git a/example-specs/task/nipype/freesurfer/smooth_tessellation_callables.py b/example-specs/task/nipype/freesurfer/smooth_tessellation_callables.py
index 739dd25b..9936647e 100644
--- a/example-specs/task/nipype/freesurfer/smooth_tessellation_callables.py
+++ b/example-specs/task/nipype/freesurfer/smooth_tessellation_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of SmoothTessellation.yaml"""
 
-import attrs
 import os
+import attrs
 import os.path as op
 
 
@@ -9,11 +9,11 @@ def out_file_default(inputs):
     return _gen_filename("out_file", inputs=inputs)
 
 
-def out_file_callable(output_dir, inputs, stdout, stderr):
+def surface_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_file"]
+    return outputs["surface"]
 
 
 def split_filename(fname):
@@ -66,6 +66,14 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+def _gen_outfilename(inputs=None, stdout=None, stderr=None, output_dir=None):
+    if inputs.out_file is not attrs.NOTHING:
+        return os.path.abspath(inputs.out_file)
+    else:
+        _, name, ext = split_filename(inputs.in_file)
+        return os.path.abspath(name + "_smoothed" + ext)
+
+
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "out_file":
         return _gen_outfilename(
@@ -81,11 +89,3 @@ def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
         inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
     )
     return outputs
-
-
-def _gen_outfilename(inputs=None, stdout=None, stderr=None, output_dir=None):
-    if inputs.out_file is not attrs.NOTHING:
-        return os.path.abspath(inputs.out_file)
-    else:
-        _, name, ext = split_filename(inputs.in_file)
-        return os.path.abspath(name + "_smoothed" + ext)
diff --git a/example-specs/task/nipype/freesurfer/sphere_callables.py b/example-specs/task/nipype/freesurfer/sphere_callables.py
index 0d813120..4961c188 100644
--- a/example-specs/task/nipype/freesurfer/sphere_callables.py
+++ b/example-specs/task/nipype/freesurfer/sphere_callables.py
@@ -1 +1,20 @@
 """Module to put any functions that are referred to in the "callables" section of Sphere.yaml"""
+
+import os
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = os.path.abspath(inputs.out_file)
+    return outputs
diff --git a/example-specs/task/nipype/freesurfer/spherical_average_callables.py b/example-specs/task/nipype/freesurfer/spherical_average_callables.py
index 2eeafdc4..225d0557 100644
--- a/example-specs/task/nipype/freesurfer/spherical_average_callables.py
+++ b/example-specs/task/nipype/freesurfer/spherical_average_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of SphericalAverage.yaml"""
 
-import attrs
 import os
+import attrs
 
 
 def out_file_default(inputs):
@@ -12,11 +12,11 @@ def in_average_default(inputs):
     return _gen_filename("in_average", inputs=inputs)
 
 
-def in_average_callable(output_dir, inputs, stdout, stderr):
+def out_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["in_average"]
+    return outputs["out_file"]
 
 
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
diff --git a/example-specs/task/nipype/freesurfer/surface_2_vol_transform_callables.py b/example-specs/task/nipype/freesurfer/surface_2_vol_transform_callables.py
index 331967de..14ba6392 100644
--- a/example-specs/task/nipype/freesurfer/surface_2_vol_transform_callables.py
+++ b/example-specs/task/nipype/freesurfer/surface_2_vol_transform_callables.py
@@ -1 +1,194 @@
 """Module to put any functions that are referred to in the "callables" section of Surface2VolTransform.yaml"""
+
+import os
+import os.path as op
+import attrs
+import logging
+
+
+def transformed_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["transformed_file"]
+
+
+def vertexvol_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["vertexvol_file"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
diff --git a/example-specs/task/nipype/freesurfer/surface_smooth_callables.py b/example-specs/task/nipype/freesurfer/surface_smooth_callables.py
index 63295d6d..2e51d3bc 100644
--- a/example-specs/task/nipype/freesurfer/surface_smooth_callables.py
+++ b/example-specs/task/nipype/freesurfer/surface_smooth_callables.py
@@ -1 +1,130 @@
 """Module to put any functions that are referred to in the "callables" section of SurfaceSmooth.yaml"""
+
+import attrs
+import os.path as op
+
+
+def out_file_default(inputs):
+    return _gen_filename("out_file", inputs=inputs)
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )[name]
+    return None
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = inputs.out_file
+    if outputs["out_file"] is attrs.NOTHING:
+        in_file = inputs.in_file
+        if inputs.fwhm is not attrs.NOTHING:
+            kernel = inputs.fwhm
+        else:
+            kernel = inputs.smooth_iters
+        outputs["out_file"] = fname_presuffix(
+            in_file, suffix="_smooth%d" % kernel, newpath=output_dir
+        )
+    return outputs
diff --git a/example-specs/task/nipype/freesurfer/surface_snapshots.yaml b/example-specs/task/nipype/freesurfer/surface_snapshots.yaml
index 88b38e2d..7165db7f 100644
--- a/example-specs/task/nipype/freesurfer/surface_snapshots.yaml
+++ b/example-specs/task/nipype/freesurfer/surface_snapshots.yaml
@@ -73,6 +73,8 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    snapshots: generic/file+list-of
+    # type=outputmultiobject: tiff images of the surface from different perspectives
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/freesurfer/surface_snapshots_callables.py b/example-specs/task/nipype/freesurfer/surface_snapshots_callables.py
index 848d740c..33e8ca6d 100644
--- a/example-specs/task/nipype/freesurfer/surface_snapshots_callables.py
+++ b/example-specs/task/nipype/freesurfer/surface_snapshots_callables.py
@@ -2,18 +2,17 @@
 
 import attrs
 import os.path as op
-from pathlib import Path
 
 
 def tcl_script_default(inputs):
     return _gen_filename("tcl_script", inputs=inputs)
 
 
-def tcl_script_callable(output_dir, inputs, stdout, stderr):
+def snapshots_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["tcl_script"]
+    return outputs["snapshots"]
 
 
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
@@ -42,8 +41,8 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     >>> fname_presuffix(fname,'pre','post','/tmp')
     '/tmp/prefoopost.nii.gz'
 
-    >>> from nipype.interfaces.base import Undefined
-    >>> fname_presuffix(fname, 'pre', 'post', Undefined) == \
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
             fname_presuffix(fname, 'pre', 'post')
     True
 
@@ -52,7 +51,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     if not use_ext:
         ext = ""
 
-    # No need for isdefined: bool(Undefined) evaluates to False
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
     if newpath:
         pth = op.abspath(newpath)
     return op.join(pth, prefix + fname + suffix + ext)
diff --git a/example-specs/task/nipype/freesurfer/surface_transform_callables.py b/example-specs/task/nipype/freesurfer/surface_transform_callables.py
index bc0bb94c..66831f96 100644
--- a/example-specs/task/nipype/freesurfer/surface_transform_callables.py
+++ b/example-specs/task/nipype/freesurfer/surface_transform_callables.py
@@ -1 +1,186 @@
 """Module to put any functions that are referred to in the "callables" section of SurfaceTransform.yaml"""
+
+import os
+import attrs
+import os.path as op
+
+
+def out_file_default(inputs):
+    return _gen_filename("out_file", inputs=inputs)
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+filemap = dict(
+    cor="cor",
+    mgh="mgh",
+    mgz="mgz",
+    minc="mnc",
+    afni="brik",
+    brik="brik",
+    bshort="bshort",
+    spm="img",
+    analyze="img",
+    analyze4d="img",
+    bfloat="bfloat",
+    nifti1="img",
+    nii="nii",
+    niigz="nii.gz",
+    gii="gii",
+)
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )[name]
+    return None
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = inputs.out_file
+    if outputs["out_file"] is attrs.NOTHING:
+        if inputs.source_file is not attrs.NOTHING:
+            source = inputs.source_file
+        else:
+            source = inputs.source_annot_file
+
+        # Some recon-all files don't have a proper extension (e.g. "lh.thickness")
+        # so we have to account for that here
+        bad_extensions = [
+            ".%s" % e
+            for e in [
+                "area",
+                "mid",
+                "pial",
+                "avg_curv",
+                "curv",
+                "inflated",
+                "jacobian_white",
+                "orig",
+                "nofix",
+                "smoothwm",
+                "crv",
+                "sphere",
+                "sulc",
+                "thickness",
+                "volume",
+                "white",
+            ]
+        ]
+        use_ext = True
+        if split_filename(source)[2] in bad_extensions:
+            source = source + ".stripme"
+            use_ext = False
+        ext = ""
+        if inputs.target_type is not attrs.NOTHING:
+            ext = "." + filemap[inputs.target_type]
+            use_ext = False
+        outputs["out_file"] = fname_presuffix(
+            source,
+            suffix=".%s%s" % (inputs.target_subject, ext),
+            newpath=output_dir,
+            use_ext=use_ext,
+        )
+    else:
+        outputs["out_file"] = os.path.abspath(inputs.out_file)
+    return outputs
diff --git a/example-specs/task/nipype/freesurfer/synthesize_flash_callables.py b/example-specs/task/nipype/freesurfer/synthesize_flash_callables.py
index 3d8b5898..f24024e8 100644
--- a/example-specs/task/nipype/freesurfer/synthesize_flash_callables.py
+++ b/example-specs/task/nipype/freesurfer/synthesize_flash_callables.py
@@ -1 +1,167 @@
 """Module to put any functions that are referred to in the "callables" section of SynthesizeFLASH.yaml"""
+
+import attrs
+import os.path as op
+
+
+def out_file_default(inputs):
+    return _gen_filename("out_file", inputs=inputs)
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _gen_fname(
+    basename,
+    fname=None,
+    cwd=None,
+    suffix="_fs",
+    use_ext=True,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Define a generic mapping for a single outfile
+
+    The filename is potentially autogenerated by suffixing inputs.infile
+
+    Parameters
+    ----------
+    basename : string (required)
+        filename to base the new filename on
+    fname : string
+        if not None, just use this fname
+    cwd : string
+        prefix paths with cwd, otherwise output_dir
+    suffix : string
+        default suffix
+    """
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "mri_synthesize"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=use_ext, newpath=cwd)
+    return fname
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )["out_file"]
+    return None
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    if inputs.out_file is not attrs.NOTHING:
+        outputs["out_file"] = inputs.out_file
+    else:
+        outputs["out_file"] = _gen_fname(
+            "synth-flash_%02d.mgz" % inputs.flip_angle,
+            suffix="",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    return outputs
diff --git a/example-specs/task/nipype/freesurfer/talairach_avi_callables.py b/example-specs/task/nipype/freesurfer/talairach_avi_callables.py
index ba6cd07a..d9ffd30c 100644
--- a/example-specs/task/nipype/freesurfer/talairach_avi_callables.py
+++ b/example-specs/task/nipype/freesurfer/talairach_avi_callables.py
@@ -1 +1,39 @@
 """Module to put any functions that are referred to in the "callables" section of TalairachAVI.yaml"""
+
+import os
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+def out_log_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_log"]
+
+
+def out_txt_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_txt"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = os.path.abspath(inputs.out_file)
+    outputs["out_log"] = os.path.abspath("talairach_avi.log")
+    outputs["out_txt"] = os.path.join(
+        os.path.dirname(inputs.out_file),
+        "talsrcimg_to_" + str(inputs.atlas) + "t4_vox2vox.txt",
+    )
+    return outputs
diff --git a/example-specs/task/nipype/freesurfer/talairach_qc_callables.py b/example-specs/task/nipype/freesurfer/talairach_qc_callables.py
index d172a503..8c6a837a 100644
--- a/example-specs/task/nipype/freesurfer/talairach_qc_callables.py
+++ b/example-specs/task/nipype/freesurfer/talairach_qc_callables.py
@@ -1 +1,20 @@
 """Module to put any functions that are referred to in the "callables" section of TalairachQC.yaml"""
+
+import os
+
+
+def log_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["log_file"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["log_file"] = os.path.abspath("output.nipype")
+    return outputs
diff --git a/example-specs/task/nipype/freesurfer/tkregister_2_callables.py b/example-specs/task/nipype/freesurfer/tkregister_2_callables.py
index e34e8b6f..a3e3995d 100644
--- a/example-specs/task/nipype/freesurfer/tkregister_2_callables.py
+++ b/example-specs/task/nipype/freesurfer/tkregister_2_callables.py
@@ -1 +1,148 @@
 """Module to put any functions that are referred to in the "callables" section of Tkregister2.yaml"""
+
+import os
+import attrs
+import os.path as op
+
+
+def reg_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["reg_file"]
+
+
+def fsl_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["fsl_file"]
+
+
+def lta_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["lta_file"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    reg_file = os.path.abspath(inputs.reg_file)
+    outputs["reg_file"] = reg_file
+
+    cwd = output_dir
+    fsl_out = inputs.fsl_out
+    if fsl_out is not attrs.NOTHING:
+        if fsl_out is True:
+            outputs["fsl_file"] = fname_presuffix(
+                reg_file, suffix=".mat", newpath=cwd, use_ext=False
+            )
+        else:
+            outputs["fsl_file"] = os.path.abspath(inputs.fsl_out)
+
+    lta_out = inputs.lta_out
+    if lta_out is not attrs.NOTHING:
+        if lta_out is True:
+            outputs["lta_file"] = fname_presuffix(
+                reg_file, suffix=".lta", newpath=cwd, use_ext=False
+            )
+        else:
+            outputs["lta_file"] = os.path.abspath(inputs.lta_out)
+    return outputs
diff --git a/example-specs/task/nipype/freesurfer/unpack_sdicom_dir_callables.py b/example-specs/task/nipype/freesurfer/unpack_sdicom_dir_callables.py
index 486de40a..8ffc7493 100644
--- a/example-specs/task/nipype/freesurfer/unpack_sdicom_dir_callables.py
+++ b/example-specs/task/nipype/freesurfer/unpack_sdicom_dir_callables.py
@@ -1 +1,179 @@
 """Module to put any functions that are referred to in the "callables" section of UnpackSDICOMDir.yaml"""
+
+import os
+import os.path as op
+import attrs
+import logging
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
diff --git a/example-specs/task/nipype/freesurfer/volume_mask_callables.py b/example-specs/task/nipype/freesurfer/volume_mask_callables.py
index 027c538a..c95387ab 100644
--- a/example-specs/task/nipype/freesurfer/volume_mask_callables.py
+++ b/example-specs/task/nipype/freesurfer/volume_mask_callables.py
@@ -1 +1,38 @@
 """Module to put any functions that are referred to in the "callables" section of VolumeMask.yaml"""
+
+import os
+
+
+def out_ribbon_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_ribbon"]
+
+
+def lh_ribbon_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["lh_ribbon"]
+
+
+def rh_ribbon_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["rh_ribbon"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    out_dir = os.path.join(inputs.subjects_dir, inputs.subject_id, "mri")
+    outputs["out_ribbon"] = os.path.join(out_dir, "ribbon.mgz")
+    if inputs.save_ribbon:
+        outputs["rh_ribbon"] = os.path.join(out_dir, "rh.ribbon.mgz")
+        outputs["lh_ribbon"] = os.path.join(out_dir, "lh.ribbon.mgz")
+    return outputs
diff --git a/example-specs/task/nipype/freesurfer/watershed_skull_strip_callables.py b/example-specs/task/nipype/freesurfer/watershed_skull_strip_callables.py
index 3501134e..a7556061 100644
--- a/example-specs/task/nipype/freesurfer/watershed_skull_strip_callables.py
+++ b/example-specs/task/nipype/freesurfer/watershed_skull_strip_callables.py
@@ -1 +1,20 @@
 """Module to put any functions that are referred to in the "callables" section of WatershedSkullStrip.yaml"""
+
+import os
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = os.path.abspath(inputs.out_file)
+    return outputs
diff --git a/example-specs/task/nipype/fsl/accuracy_tester_callables.py b/example-specs/task/nipype/fsl/accuracy_tester_callables.py
index c69be900..15a082cf 100644
--- a/example-specs/task/nipype/fsl/accuracy_tester_callables.py
+++ b/example-specs/task/nipype/fsl/accuracy_tester_callables.py
@@ -1 +1,25 @@
 """Module to put any functions that are referred to in the "callables" section of AccuracyTester.yaml"""
+
+import attrs
+
+
+def output_directory_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["output_directory"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    if inputs.output_directory is not attrs.NOTHING:
+        outputs["output_directory"] = Directory(
+            exists=False, value=inputs.output_directory
+        )
+    else:
+        outputs["output_directory"] = Directory(exists=False, value="accuracy_test")
+    return outputs
diff --git a/example-specs/task/nipype/fsl/apply_mask_callables.py b/example-specs/task/nipype/fsl/apply_mask_callables.py
index 411af901..4394f71d 100644
--- a/example-specs/task/nipype/fsl/apply_mask_callables.py
+++ b/example-specs/task/nipype/fsl/apply_mask_callables.py
@@ -1 +1,284 @@
 """Module to put any functions that are referred to in the "callables" section of ApplyMask.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+from glob import glob
+
+
+def out_file_default(inputs):
+    return _gen_filename("out_file", inputs=inputs)
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+IFLOGGER = logging.getLogger("nipype.interface")
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """
+    Handle FSL ``output_type`` and version information.
+
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
+
+    """
+
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
+
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
+
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
+
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
+
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
+
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
+
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
+
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
+
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
+
+        Returns a list of standard images if called without arguments.
+
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
+
+
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
+
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
+
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
+
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "fslmaths"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )["out_file"]
+    return None
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = inputs.out_file
+    if inputs.out_file is attrs.NOTHING:
+        outputs["out_file"] = _gen_fname(
+            inputs.in_file,
+            suffix=_suffix,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    outputs["out_file"] = os.path.abspath(outputs["out_file"])
+    return outputs
diff --git a/example-specs/task/nipype/fsl/apply_topup_callables.py b/example-specs/task/nipype/fsl/apply_topup_callables.py
index f16621a9..01af91c2 100644
--- a/example-specs/task/nipype/fsl/apply_topup_callables.py
+++ b/example-specs/task/nipype/fsl/apply_topup_callables.py
@@ -1 +1,283 @@
 """Module to put any functions that are referred to in the "callables" section of ApplyTOPUP.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+from glob import glob
+
+
+def out_corrected_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_corrected"]
+
+
+IFLOGGER = logging.getLogger("nipype.interface")
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+class Info(PackageInfo):
+    """
+    Handle FSL ``output_type`` and version information.
+
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
+
+    """
+
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
+
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
+
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
+
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
+
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
+
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
+
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
+
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
+
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
+
+        Returns a list of standard images if called without arguments.
+
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value + Info.output_type_to_ext(inputs.output_type)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
diff --git a/example-specs/task/nipype/fsl/apply_warp_callables.py b/example-specs/task/nipype/fsl/apply_warp_callables.py
index d4827d57..893eb20b 100644
--- a/example-specs/task/nipype/fsl/apply_warp_callables.py
+++ b/example-specs/task/nipype/fsl/apply_warp_callables.py
@@ -1 +1,284 @@
 """Module to put any functions that are referred to in the "callables" section of ApplyWarp.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+from glob import glob
+
+
+def out_file_default(inputs):
+    return _gen_filename("out_file", inputs=inputs)
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+IFLOGGER = logging.getLogger("nipype.interface")
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """
+    Handle FSL ``output_type`` and version information.
+
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
+
+    """
+
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
+
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
+
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
+
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
+
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
+
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
+
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
+
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
+
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
+
+        Returns a list of standard images if called without arguments.
+
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
+
+
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
+
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
+
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
+
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "applywarp"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )[name]
+    return None
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    if inputs.out_file is attrs.NOTHING:
+        outputs["out_file"] = _gen_fname(
+            inputs.in_file,
+            suffix="_warp",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    else:
+        outputs["out_file"] = os.path.abspath(inputs.out_file)
+    return outputs
diff --git a/example-specs/task/nipype/fsl/apply_xfm_callables.py b/example-specs/task/nipype/fsl/apply_xfm_callables.py
index 1dce24c5..f84b64d5 100644
--- a/example-specs/task/nipype/fsl/apply_xfm_callables.py
+++ b/example-specs/task/nipype/fsl/apply_xfm_callables.py
@@ -1 +1,297 @@
 """Module to put any functions that are referred to in the "callables" section of ApplyXFM.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+from glob import glob
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+def out_matrix_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_matrix_file"]
+
+
+def out_log_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_log"]
+
+
+IFLOGGER = logging.getLogger("nipype.interface")
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+class Info(PackageInfo):
+    """
+    Handle FSL ``output_type`` and version information.
+
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
+
+    """
+
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
+
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
+
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
+
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
+
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
+
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
+
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
+
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
+
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
+
+        Returns a list of standard images if called without arguments.
+
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value + Info.output_type_to_ext(inputs.output_type)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
diff --git a/example-specs/task/nipype/fsl/ar1_image_callables.py b/example-specs/task/nipype/fsl/ar1_image_callables.py
index 25964e2e..6f761cde 100644
--- a/example-specs/task/nipype/fsl/ar1_image_callables.py
+++ b/example-specs/task/nipype/fsl/ar1_image_callables.py
@@ -1 +1,284 @@
 """Module to put any functions that are referred to in the "callables" section of AR1Image.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+from glob import glob
+
+
+def out_file_default(inputs):
+    return _gen_filename("out_file", inputs=inputs)
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+IFLOGGER = logging.getLogger("nipype.interface")
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """
+    Handle FSL ``output_type`` and version information.
+
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
+
+    """
+
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
+
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
+
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
+
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
+
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
+
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
+
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
+
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
+
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
+
+        Returns a list of standard images if called without arguments.
+
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
+
+
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
+
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
+
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
+
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "fslmaths"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )["out_file"]
+    return None
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = inputs.out_file
+    if inputs.out_file is attrs.NOTHING:
+        outputs["out_file"] = _gen_fname(
+            inputs.in_file,
+            suffix=_suffix,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    outputs["out_file"] = os.path.abspath(outputs["out_file"])
+    return outputs
diff --git a/example-specs/task/nipype/fsl/av_scale.yaml b/example-specs/task/nipype/fsl/av_scale.yaml
index aa961366..49020e14 100644
--- a/example-specs/task/nipype/fsl/av_scale.yaml
+++ b/example-specs/task/nipype/fsl/av_scale.yaml
@@ -50,6 +50,12 @@ outputs:
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
+    average_scaling: average_scaling_callable
+    # type=float: Average Scaling
+    determinant: determinant_callable
+    # type=float: Determinant
+    left_right_orientation_preserved: left_right_orientation_preserved_callable
+    # type=bool: True if LR orientation preserved
   templates:
   # dict[str, str] - `output_file_template` values to be provided to output fields
   requirements:
diff --git a/example-specs/task/nipype/fsl/av_scale_callables.py b/example-specs/task/nipype/fsl/av_scale_callables.py
index 6a1d0bde..359c4d77 100644
--- a/example-specs/task/nipype/fsl/av_scale_callables.py
+++ b/example-specs/task/nipype/fsl/av_scale_callables.py
@@ -1 +1,79 @@
 """Module to put any functions that are referred to in the "callables" section of AvScale.yaml"""
+
+
+def rotation_translation_matrix_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["rotation_translation_matrix"]
+
+
+def scales_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["scales"]
+
+
+def skews_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["skews"]
+
+
+def average_scaling_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["average_scaling"]
+
+
+def determinant_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["determinant"]
+
+
+def forward_half_transform_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["forward_half_transform"]
+
+
+def backward_half_transform_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["backward_half_transform"]
+
+
+def left_right_orientation_preserved_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["left_right_orientation_preserved"]
+
+
+def rot_angles_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["rot_angles"]
+
+
+def translations_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["translations"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    return _results
diff --git a/example-specs/task/nipype/fsl/b0_calc_callables.py b/example-specs/task/nipype/fsl/b0_calc_callables.py
index 95f757d4..71dd1c42 100644
--- a/example-specs/task/nipype/fsl/b0_calc_callables.py
+++ b/example-specs/task/nipype/fsl/b0_calc_callables.py
@@ -1 +1,283 @@
 """Module to put any functions that are referred to in the "callables" section of B0Calc.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+from glob import glob
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+IFLOGGER = logging.getLogger("nipype.interface")
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+class Info(PackageInfo):
+    """
+    Handle FSL ``output_type`` and version information.
+
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
+
+    """
+
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
+
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
+
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
+
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
+
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
+
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
+
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
+
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
+
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
+
+        Returns a list of standard images if called without arguments.
+
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value + Info.output_type_to_ext(inputs.output_type)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
diff --git a/example-specs/task/nipype/fsl/bedpostx5.yaml b/example-specs/task/nipype/fsl/bedpostx5.yaml
index 0d6f6e48..d43927d0 100644
--- a/example-specs/task/nipype/fsl/bedpostx5.yaml
+++ b/example-specs/task/nipype/fsl/bedpostx5.yaml
@@ -70,10 +70,26 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    dyads: generic/file+list-of
+    # type=outputmultiobject: Mean of PDD distribution in vector form.
+    dyads_dispersion: generic/file+list-of
+    # type=outputmultiobject: Dispersion
     mean_S0samples: generic/file
     # type=file: Mean of distribution on T2wbaseline signal intensity S0
     mean_dsamples: generic/file
     # type=file: Mean of distribution on diffusivity d
+    mean_fsamples: generic/file+list-of
+    # type=outputmultiobject: Mean of distribution on f anisotropy
+    mean_phsamples: generic/file+list-of
+    # type=outputmultiobject: Mean of distribution on phi
+    mean_thsamples: generic/file+list-of
+    # type=outputmultiobject: Mean of distribution on theta
+    merged_fsamples: generic/file+list-of
+    # type=outputmultiobject: Samples from the distribution on anisotropic volume fraction
+    merged_phsamples: generic/file+list-of
+    # type=outputmultiobject: Samples from the distribution on phi
+    merged_thsamples: generic/file+list-of
+    # type=outputmultiobject: Samples from the distribution on theta
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/fsl/bedpostx5_callables.py b/example-specs/task/nipype/fsl/bedpostx5_callables.py
index f03ac323..31d37c11 100644
--- a/example-specs/task/nipype/fsl/bedpostx5_callables.py
+++ b/example-specs/task/nipype/fsl/bedpostx5_callables.py
@@ -1 +1,436 @@
 """Module to put any functions that are referred to in the "callables" section of BEDPOSTX5.yaml"""
+
+import os
+from glob import glob
+import os.path as op
+import logging
+
+
+def mean_dsamples_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["mean_dsamples"]
+
+
+def mean_fsamples_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["mean_fsamples"]
+
+
+def mean_S0samples_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["mean_S0samples"]
+
+
+def mean_phsamples_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["mean_phsamples"]
+
+
+def mean_thsamples_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["mean_thsamples"]
+
+
+def merged_thsamples_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["merged_thsamples"]
+
+
+def merged_phsamples_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["merged_phsamples"]
+
+
+def merged_fsamples_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["merged_fsamples"]
+
+
+def dyads_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["dyads"]
+
+
+def dyads_dispersion_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["dyads_dispersion"]
+
+
+IFLOGGER = logging.getLogger("nipype.interface")
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """
+    Handle FSL ``output_type`` and version information.
+
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
+
+    """
+
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
+
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
+
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
+
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
+
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
+
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
+
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
+
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
+
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
+
+        Returns a list of standard images if called without arguments.
+
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
+
+
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
+
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
+
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
+
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "bedpostx"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    n_fibres = inputs.n_fibres
+
+    multi_out = [
+        "merged_thsamples",
+        "merged_fsamples",
+        "merged_phsamples",
+        "mean_phsamples",
+        "mean_thsamples",
+        "mean_fsamples",
+        "dyads_dispersion",
+        "dyads",
+    ]
+
+    single_out = ["mean_dsamples", "mean_S0samples"]
+
+    for k in single_out:
+        outputs[k] = _gen_fname(
+            k,
+            cwd=_out_dir,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+
+    for k in multi_out:
+        outputs[k] = []
+
+    for i in range(1, n_fibres + 1):
+        outputs["merged_thsamples"].append(
+            _gen_fname(
+                "merged_th%dsamples" % i,
+                cwd=_out_dir,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+        )
+        outputs["merged_fsamples"].append(
+            _gen_fname(
+                "merged_f%dsamples" % i,
+                cwd=_out_dir,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+        )
+        outputs["merged_phsamples"].append(
+            _gen_fname(
+                "merged_ph%dsamples" % i,
+                cwd=_out_dir,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+        )
+        outputs["mean_thsamples"].append(
+            _gen_fname(
+                "mean_th%dsamples" % i,
+                cwd=_out_dir,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+        )
+        outputs["mean_phsamples"].append(
+            _gen_fname(
+                "mean_ph%dsamples" % i,
+                cwd=_out_dir,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+        )
+        outputs["mean_fsamples"].append(
+            _gen_fname(
+                "mean_f%dsamples" % i,
+                cwd=_out_dir,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+        )
+        outputs["dyads"].append(
+            _gen_fname(
+                "dyads%d" % i,
+                cwd=_out_dir,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+        )
+        outputs["dyads_dispersion"].append(
+            _gen_fname(
+                "dyads%d_dispersion" % i,
+                cwd=_out_dir,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+        )
+    return outputs
diff --git a/example-specs/task/nipype/fsl/bet_callables.py b/example-specs/task/nipype/fsl/bet_callables.py
index 6b806f68..752f0a51 100644
--- a/example-specs/task/nipype/fsl/bet_callables.py
+++ b/example-specs/task/nipype/fsl/bet_callables.py
@@ -1 +1,478 @@
 """Module to put any functions that are referred to in the "callables" section of BET.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+from glob import glob
+
+
+def out_file_default(inputs):
+    return _gen_filename("out_file", inputs=inputs)
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+def mask_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["mask_file"]
+
+
+def outline_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["outline_file"]
+
+
+def meshfile_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["meshfile"]
+
+
+def inskull_mask_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["inskull_mask_file"]
+
+
+def inskull_mesh_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["inskull_mesh_file"]
+
+
+def outskull_mask_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["outskull_mask_file"]
+
+
+def outskull_mesh_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["outskull_mesh_file"]
+
+
+def outskin_mask_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["outskin_mask_file"]
+
+
+def outskin_mesh_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["outskin_mesh_file"]
+
+
+def skull_mask_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["skull_mask_file"]
+
+
+def skull_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["skull_file"]
+
+
+IFLOGGER = logging.getLogger("nipype.interface")
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """
+    Handle FSL ``output_type`` and version information.
+
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
+
+    """
+
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
+
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
+
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
+
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
+
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
+
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
+
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
+
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
+
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
+
+        Returns a list of standard images if called without arguments.
+
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
+
+
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
+
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
+
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
+
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "bet"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+def _gen_outfilename(inputs=None, stdout=None, stderr=None, output_dir=None):
+    out_file = inputs.out_file
+    # Generate default output filename if non specified.
+    if (out_file is attrs.NOTHING) and (inputs.in_file is not attrs.NOTHING):
+        out_file = _gen_fname(
+            inputs.in_file,
+            suffix="_brain",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+        # Convert to relative path to prevent BET failure
+        # with long paths.
+        return op.relpath(out_file, start=output_dir)
+    return out_file
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _gen_outfilename(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )
+    return None
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = os.path.abspath(
+        _gen_outfilename(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )
+    )
+
+    basename = os.path.basename(outputs["out_file"])
+    cwd = os.path.dirname(outputs["out_file"])
+    kwargs = {"basename": basename, "cwd": cwd}
+
+    if ((inputs.mesh is not attrs.NOTHING) and inputs.mesh) or (
+        (inputs.surfaces is not attrs.NOTHING) and inputs.surfaces
+    ):
+        outputs["meshfile"] = _gen_fname(
+            suffix="_mesh.vtk",
+            change_ext=False,
+            **kwargs,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir
+        )
+    if ((inputs.mask is not attrs.NOTHING) and inputs.mask) or (
+        (inputs.reduce_bias is not attrs.NOTHING) and inputs.reduce_bias
+    ):
+        outputs["mask_file"] = _gen_fname(
+            suffix="_mask",
+            **kwargs,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir
+        )
+    if (inputs.outline is not attrs.NOTHING) and inputs.outline:
+        outputs["outline_file"] = _gen_fname(
+            suffix="_overlay",
+            **kwargs,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir
+        )
+    if (inputs.surfaces is not attrs.NOTHING) and inputs.surfaces:
+        outputs["inskull_mask_file"] = _gen_fname(
+            suffix="_inskull_mask",
+            **kwargs,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir
+        )
+        outputs["inskull_mesh_file"] = _gen_fname(
+            suffix="_inskull_mesh",
+            **kwargs,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir
+        )
+        outputs["outskull_mask_file"] = _gen_fname(
+            suffix="_outskull_mask",
+            **kwargs,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir
+        )
+        outputs["outskull_mesh_file"] = _gen_fname(
+            suffix="_outskull_mesh",
+            **kwargs,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir
+        )
+        outputs["outskin_mask_file"] = _gen_fname(
+            suffix="_outskin_mask",
+            **kwargs,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir
+        )
+        outputs["outskin_mesh_file"] = _gen_fname(
+            suffix="_outskin_mesh",
+            **kwargs,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir
+        )
+        outputs["skull_mask_file"] = _gen_fname(
+            suffix="_skull_mask",
+            **kwargs,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir
+        )
+    if (inputs.skull is not attrs.NOTHING) and inputs.skull:
+        outputs["skull_file"] = _gen_fname(
+            suffix="_skull",
+            **kwargs,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir
+        )
+    if (inputs.no_output is not attrs.NOTHING) and inputs.no_output:
+        outputs["out_file"] = attrs.NOTHING
+    return outputs
diff --git a/example-specs/task/nipype/fsl/binary_maths_callables.py b/example-specs/task/nipype/fsl/binary_maths_callables.py
index 2bfff1ee..7ad73e1c 100644
--- a/example-specs/task/nipype/fsl/binary_maths_callables.py
+++ b/example-specs/task/nipype/fsl/binary_maths_callables.py
@@ -1 +1,284 @@
 """Module to put any functions that are referred to in the "callables" section of BinaryMaths.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+from glob import glob
+
+
+def out_file_default(inputs):
+    return _gen_filename("out_file", inputs=inputs)
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+IFLOGGER = logging.getLogger("nipype.interface")
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """
+    Handle FSL ``output_type`` and version information.
+
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
+
+    """
+
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
+
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
+
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
+
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
+
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
+
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
+
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
+
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
+
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
+
+        Returns a list of standard images if called without arguments.
+
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
+
+
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
+
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
+
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
+
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "fslmaths"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )["out_file"]
+    return None
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = inputs.out_file
+    if inputs.out_file is attrs.NOTHING:
+        outputs["out_file"] = _gen_fname(
+            inputs.in_file,
+            suffix=_suffix,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    outputs["out_file"] = os.path.abspath(outputs["out_file"])
+    return outputs
diff --git a/example-specs/task/nipype/fsl/change_data_type_callables.py b/example-specs/task/nipype/fsl/change_data_type_callables.py
index 85403873..b7357aeb 100644
--- a/example-specs/task/nipype/fsl/change_data_type_callables.py
+++ b/example-specs/task/nipype/fsl/change_data_type_callables.py
@@ -1 +1,284 @@
 """Module to put any functions that are referred to in the "callables" section of ChangeDataType.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+from glob import glob
+
+
+def out_file_default(inputs):
+    return _gen_filename("out_file", inputs=inputs)
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+IFLOGGER = logging.getLogger("nipype.interface")
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """
+    Handle FSL ``output_type`` and version information.
+
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
+
+    """
+
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
+
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
+
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
+
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
+
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
+
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
+
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
+
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
+
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
+
+        Returns a list of standard images if called without arguments.
+
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
+
+
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
+
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
+
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
+
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "fslmaths"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )["out_file"]
+    return None
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = inputs.out_file
+    if inputs.out_file is attrs.NOTHING:
+        outputs["out_file"] = _gen_fname(
+            inputs.in_file,
+            suffix=_suffix,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    outputs["out_file"] = os.path.abspath(outputs["out_file"])
+    return outputs
diff --git a/example-specs/task/nipype/fsl/classifier_callables.py b/example-specs/task/nipype/fsl/classifier_callables.py
index fa0d814f..3402f70b 100644
--- a/example-specs/task/nipype/fsl/classifier_callables.py
+++ b/example-specs/task/nipype/fsl/classifier_callables.py
@@ -1 +1,39 @@
 """Module to put any functions that are referred to in the "callables" section of Classifier.yaml"""
+
+import os
+
+
+def artifacts_list_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["artifacts_list_file"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _gen_artifacts_list_file(
+    mel_ica, thresh, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    _, trained_wts_file = os.path.split(inputs.trained_wts_file)
+    trained_wts_filestem = trained_wts_file.split(".")[0]
+    filestem = "fix4melview_" + trained_wts_filestem + "_thr"
+
+    fname = os.path.join(mel_ica, filestem + str(thresh) + ".txt")
+    return fname
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["artifacts_list_file"] = _gen_artifacts_list_file(
+        inputs.mel_ica,
+        inputs.thresh,
+        inputs=inputs,
+        stdout=stdout,
+        stderr=stderr,
+        output_dir=output_dir,
+    )
+
+    return outputs
diff --git a/example-specs/task/nipype/fsl/cleaner_callables.py b/example-specs/task/nipype/fsl/cleaner_callables.py
index 3e7367f3..f4f7c27e 100644
--- a/example-specs/task/nipype/fsl/cleaner_callables.py
+++ b/example-specs/task/nipype/fsl/cleaner_callables.py
@@ -1 +1,39 @@
 """Module to put any functions that are referred to in the "callables" section of Cleaner.yaml"""
+
+import os
+
+
+def cleaned_functional_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["cleaned_functional_file"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _get_cleaned_functional_filename(
+    artifacts_list_filename, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    """extract the proper filename from the first line of the artifacts file"""
+    artifacts_list_file = open(artifacts_list_filename, "r")
+    functional_filename, extension = artifacts_list_file.readline().split(".")
+    artifacts_list_file_path, artifacts_list_filename = os.path.split(
+        artifacts_list_filename
+    )
+
+    return os.path.join(artifacts_list_file_path, functional_filename + "_clean.nii.gz")
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["cleaned_functional_file"] = _get_cleaned_functional_filename(
+        inputs.artifacts_list_file,
+        inputs=inputs,
+        stdout=stdout,
+        stderr=stderr,
+        output_dir=output_dir,
+    )
+    return outputs
diff --git a/example-specs/task/nipype/fsl/cluster_callables.py b/example-specs/task/nipype/fsl/cluster_callables.py
index c189bff1..2cb9f8e8 100644
--- a/example-specs/task/nipype/fsl/cluster_callables.py
+++ b/example-specs/task/nipype/fsl/cluster_callables.py
@@ -1 +1,334 @@
 """Module to put any functions that are referred to in the "callables" section of Cluster.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+from glob import glob
+
+
+def index_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["index_file"]
+
+
+def threshold_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["threshold_file"]
+
+
+def localmax_txt_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["localmax_txt_file"]
+
+
+def localmax_vol_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["localmax_vol_file"]
+
+
+def size_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["size_file"]
+
+
+def max_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["max_file"]
+
+
+def mean_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["mean_file"]
+
+
+def pval_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["pval_file"]
+
+
+IFLOGGER = logging.getLogger("nipype.interface")
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """
+    Handle FSL ``output_type`` and version information.
+
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
+
+    """
+
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
+
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
+
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
+
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
+
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
+
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
+
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
+
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
+
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
+
+        Returns a list of standard images if called without arguments.
+
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
+
+
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
+
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
+
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
+
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "cluster"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    for key, suffix in list(filemap.items()):
+        outkey = key[4:]
+        inval = getattr(inputs, key)
+        if inval is not attrs.NOTHING:
+            if isinstance(inval, bool):
+                if inval:
+                    change_ext = True
+                    if suffix.endswith(".txt"):
+                        change_ext = False
+                    outputs[outkey] = _gen_fname(
+                        inputs.in_file,
+                        suffix="_" + suffix,
+                        change_ext=change_ext,
+                        inputs=inputs,
+                        stdout=stdout,
+                        stderr=stderr,
+                        output_dir=output_dir,
+                    )
+            else:
+                outputs[outkey] = os.path.abspath(inval)
+    return outputs
diff --git a/example-specs/task/nipype/fsl/complex_callables.py b/example-specs/task/nipype/fsl/complex_callables.py
index 93bb00f0..1d057ccc 100644
--- a/example-specs/task/nipype/fsl/complex_callables.py
+++ b/example-specs/task/nipype/fsl/complex_callables.py
@@ -1 +1,418 @@
 """Module to put any functions that are referred to in the "callables" section of Complex.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+from glob import glob
+
+
+def complex_out_file_default(inputs):
+    return _gen_filename("complex_out_file", inputs=inputs)
+
+
+def magnitude_out_file_default(inputs):
+    return _gen_filename("magnitude_out_file", inputs=inputs)
+
+
+def phase_out_file_default(inputs):
+    return _gen_filename("phase_out_file", inputs=inputs)
+
+
+def real_out_file_default(inputs):
+    return _gen_filename("real_out_file", inputs=inputs)
+
+
+def imaginary_out_file_default(inputs):
+    return _gen_filename("imaginary_out_file", inputs=inputs)
+
+
+def magnitude_out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["magnitude_out_file"]
+
+
+def phase_out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["phase_out_file"]
+
+
+def real_out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["real_out_file"]
+
+
+def imaginary_out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["imaginary_out_file"]
+
+
+def complex_out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["complex_out_file"]
+
+
+IFLOGGER = logging.getLogger("nipype.interface")
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """
+    Handle FSL ``output_type`` and version information.
+
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
+
+    """
+
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
+
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
+
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
+
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
+
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
+
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
+
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
+
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
+
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
+
+        Returns a list of standard images if called without arguments.
+
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
+
+
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
+
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
+
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
+
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "fslcomplex"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+def _get_output(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    output = getattr(inputs, name)
+    if output is attrs.NOTHING:
+        output = _gen_filename(
+            name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )
+    return os.path.abspath(output)
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "complex_out_file":
+        if inputs.complex_cartesian:
+            in_file = inputs.real_in_file
+        elif inputs.complex_polar:
+            in_file = inputs.magnitude_in_file
+        elif inputs.complex_split or inputs.complex_merge:
+            in_file = inputs.complex_in_file
+        else:
+            return None
+        return _gen_fname(
+            in_file,
+            suffix="_cplx",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    elif name == "magnitude_out_file":
+        return _gen_fname(
+            inputs.complex_in_file,
+            suffix="_mag",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    elif name == "phase_out_file":
+        return _gen_fname(
+            inputs.complex_in_file,
+            suffix="_phase",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    elif name == "real_out_file":
+        return _gen_fname(
+            inputs.complex_in_file,
+            suffix="_real",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    elif name == "imaginary_out_file":
+        return _gen_fname(
+            inputs.complex_in_file,
+            suffix="_imag",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    return None
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    if (
+        inputs.complex_cartesian
+        or inputs.complex_polar
+        or inputs.complex_split
+        or inputs.complex_merge
+    ):
+        outputs["complex_out_file"] = _get_output(
+            "complex_out_file",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    elif inputs.real_cartesian:
+        outputs["real_out_file"] = _get_output(
+            "real_out_file",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+        outputs["imaginary_out_file"] = _get_output(
+            "imaginary_out_file",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    elif inputs.real_polar:
+        outputs["magnitude_out_file"] = _get_output(
+            "magnitude_out_file",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+        outputs["phase_out_file"] = _get_output(
+            "phase_out_file",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    return outputs
diff --git a/example-specs/task/nipype/fsl/contrast_mgr.yaml b/example-specs/task/nipype/fsl/contrast_mgr.yaml
index 76c7d1f0..29242499 100644
--- a/example-specs/task/nipype/fsl/contrast_mgr.yaml
+++ b/example-specs/task/nipype/fsl/contrast_mgr.yaml
@@ -50,6 +50,20 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    copes: generic/file+list-of
+    # type=outputmultiobject: Contrast estimates for each contrast
+    fstats: generic/file+list-of
+    # type=outputmultiobject: f-stat file for each contrast
+    neffs: generic/file+list-of
+    # type=outputmultiobject: neff file ?? for each contrast
+    tstats: generic/file+list-of
+    # type=outputmultiobject: t-stat file for each contrast
+    varcopes: generic/file+list-of
+    # type=outputmultiobject: Variance estimates for each contrast
+    zfstats: generic/file+list-of
+    # type=outputmultiobject: z-stat file for each F contrast
+    zstats: generic/file+list-of
+    # type=outputmultiobject: z-stat file for each contrast
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/fsl/contrast_mgr_callables.py b/example-specs/task/nipype/fsl/contrast_mgr_callables.py
index f42e6470..3533fae6 100644
--- a/example-specs/task/nipype/fsl/contrast_mgr_callables.py
+++ b/example-specs/task/nipype/fsl/contrast_mgr_callables.py
@@ -1 +1,422 @@
 """Module to put any functions that are referred to in the "callables" section of ContrastMgr.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+from glob import glob
+
+
+def copes_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["copes"]
+
+
+def varcopes_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["varcopes"]
+
+
+def zstats_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["zstats"]
+
+
+def tstats_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["tstats"]
+
+
+def fstats_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["fstats"]
+
+
+def zfstats_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["zfstats"]
+
+
+def neffs_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["neffs"]
+
+
+IFLOGGER = logging.getLogger("nipype.interface")
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """
+    Handle FSL ``output_type`` and version information.
+
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
+
+    """
+
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
+
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
+
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
+
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
+
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
+
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
+
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
+
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
+
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
+
+        Returns a list of standard images if called without arguments.
+
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
+
+
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
+
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
+
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
+
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "contrast_mgr"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _get_numcons(inputs=None, stdout=None, stderr=None, output_dir=None):
+    numtcons = 0
+    numfcons = 0
+    if inputs.tcon_file is not attrs.NOTHING:
+        fp = open(inputs.tcon_file, "rt")
+        for line in fp.readlines():
+            if line.startswith("/NumContrasts"):
+                numtcons = int(line.split()[-1])
+                break
+        fp.close()
+    if inputs.fcon_file is not attrs.NOTHING:
+        fp = open(inputs.fcon_file, "rt")
+        for line in fp.readlines():
+            if line.startswith("/NumContrasts"):
+                numfcons = int(line.split()[-1])
+                break
+        fp.close()
+    return numtcons, numfcons
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    pth, _ = os.path.split(inputs.sigmasquareds)
+    numtcons, numfcons = _get_numcons(
+        inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+    )
+    base_contrast = 1
+    if inputs.contrast_num is not attrs.NOTHING:
+        base_contrast = inputs.contrast_num
+    copes = []
+    varcopes = []
+    zstats = []
+    tstats = []
+    neffs = []
+    for i in range(numtcons):
+        copes.append(
+            _gen_fname(
+                "cope%d.nii" % (base_contrast + i),
+                cwd=pth,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+        )
+        varcopes.append(
+            _gen_fname(
+                "varcope%d.nii" % (base_contrast + i),
+                cwd=pth,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+        )
+        zstats.append(
+            _gen_fname(
+                "zstat%d.nii" % (base_contrast + i),
+                cwd=pth,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+        )
+        tstats.append(
+            _gen_fname(
+                "tstat%d.nii" % (base_contrast + i),
+                cwd=pth,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+        )
+        neffs.append(
+            _gen_fname(
+                "neff%d.nii" % (base_contrast + i),
+                cwd=pth,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+        )
+    if copes:
+        outputs["copes"] = copes
+        outputs["varcopes"] = varcopes
+        outputs["zstats"] = zstats
+        outputs["tstats"] = tstats
+        outputs["neffs"] = neffs
+    fstats = []
+    zfstats = []
+    for i in range(numfcons):
+        fstats.append(
+            _gen_fname(
+                "fstat%d.nii" % (base_contrast + i),
+                cwd=pth,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+        )
+        zfstats.append(
+            _gen_fname(
+                "zfstat%d.nii" % (base_contrast + i),
+                cwd=pth,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+        )
+    if fstats:
+        outputs["fstats"] = fstats
+        outputs["zfstats"] = zfstats
+    return outputs
diff --git a/example-specs/task/nipype/fsl/convert_warp_callables.py b/example-specs/task/nipype/fsl/convert_warp_callables.py
index 09e19634..f7e68635 100644
--- a/example-specs/task/nipype/fsl/convert_warp_callables.py
+++ b/example-specs/task/nipype/fsl/convert_warp_callables.py
@@ -1 +1,283 @@
 """Module to put any functions that are referred to in the "callables" section of ConvertWarp.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+from glob import glob
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+IFLOGGER = logging.getLogger("nipype.interface")
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+class Info(PackageInfo):
+    """
+    Handle FSL ``output_type`` and version information.
+
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
+
+    """
+
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
+
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
+
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
+
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
+
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
+
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
+
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
+
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
+
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
+
+        Returns a list of standard images if called without arguments.
+
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value + Info.output_type_to_ext(inputs.output_type)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
diff --git a/example-specs/task/nipype/fsl/convert_xfm_callables.py b/example-specs/task/nipype/fsl/convert_xfm_callables.py
index c4ba5ac2..25c5fb87 100644
--- a/example-specs/task/nipype/fsl/convert_xfm_callables.py
+++ b/example-specs/task/nipype/fsl/convert_xfm_callables.py
@@ -1 +1,142 @@
 """Module to put any functions that are referred to in the "callables" section of ConvertXFM.yaml"""
+
+import os
+import attrs
+import os.path as op
+
+
+def out_file_default(inputs):
+    return _gen_filename("out_file", inputs=inputs)
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )["out_file"]
+    return None
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outfile = inputs.out_file
+    if outfile is attrs.NOTHING:
+        _, infile1, _ = split_filename(inputs.in_file)
+        if inputs.invert_xfm:
+            outfile = fname_presuffix(
+                infile1, suffix="_inv.mat", newpath=output_dir, use_ext=False
+            )
+        else:
+            if inputs.concat_xfm:
+                _, infile2, _ = split_filename(inputs.in_file2)
+                outfile = fname_presuffix(
+                    "%s_%s" % (infile1, infile2),
+                    suffix=".mat",
+                    newpath=output_dir,
+                    use_ext=False,
+                )
+            else:
+                outfile = fname_presuffix(
+                    infile1, suffix="_fix.mat", newpath=output_dir, use_ext=False
+                )
+    outputs["out_file"] = os.path.abspath(outfile)
+    return outputs
diff --git a/example-specs/task/nipype/fsl/copy_geom_callables.py b/example-specs/task/nipype/fsl/copy_geom_callables.py
index b1b163c5..72844f07 100644
--- a/example-specs/task/nipype/fsl/copy_geom_callables.py
+++ b/example-specs/task/nipype/fsl/copy_geom_callables.py
@@ -1 +1,283 @@
 """Module to put any functions that are referred to in the "callables" section of CopyGeom.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+from glob import glob
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+IFLOGGER = logging.getLogger("nipype.interface")
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+class Info(PackageInfo):
+    """
+    Handle FSL ``output_type`` and version information.
+
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
+
+    """
+
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
+
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
+
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
+
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
+
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
+
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
+
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
+
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
+
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
+
+        Returns a list of standard images if called without arguments.
+
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value + Info.output_type_to_ext(inputs.output_type)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
diff --git a/example-specs/task/nipype/fsl/dilate_image_callables.py b/example-specs/task/nipype/fsl/dilate_image_callables.py
index 5a40faf7..9f107e78 100644
--- a/example-specs/task/nipype/fsl/dilate_image_callables.py
+++ b/example-specs/task/nipype/fsl/dilate_image_callables.py
@@ -1 +1,284 @@
 """Module to put any functions that are referred to in the "callables" section of DilateImage.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+from glob import glob
+
+
+def out_file_default(inputs):
+    return _gen_filename("out_file", inputs=inputs)
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+IFLOGGER = logging.getLogger("nipype.interface")
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """
+    Handle FSL ``output_type`` and version information.
+
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
+
+    """
+
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
+
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
+
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
+
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
+
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
+
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
+
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
+
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
+
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
+
+        Returns a list of standard images if called without arguments.
+
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
+
+
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
+
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
+
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
+
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "fslmaths"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )["out_file"]
+    return None
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = inputs.out_file
+    if inputs.out_file is attrs.NOTHING:
+        outputs["out_file"] = _gen_fname(
+            inputs.in_file,
+            suffix=_suffix,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    outputs["out_file"] = os.path.abspath(outputs["out_file"])
+    return outputs
diff --git a/example-specs/task/nipype/fsl/distance_map_callables.py b/example-specs/task/nipype/fsl/distance_map_callables.py
index 25cceb09..6715b468 100644
--- a/example-specs/task/nipype/fsl/distance_map_callables.py
+++ b/example-specs/task/nipype/fsl/distance_map_callables.py
@@ -1 +1,142 @@
 """Module to put any functions that are referred to in the "callables" section of DistanceMap.yaml"""
+
+import os
+import attrs
+import os.path as op
+
+
+def distance_map_default(inputs):
+    return _gen_filename("distance_map", inputs=inputs)
+
+
+def distance_map_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["distance_map"]
+
+
+def local_max_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["local_max_file"]
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "distance_map":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )["distance_map"]
+    return None
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    _si = inputs
+    outputs["distance_map"] = _si.distance_map
+    if _si.distance_map is attrs.NOTHING:
+        outputs["distance_map"] = fname_presuffix(
+            _si.in_file, suffix="_dstmap", use_ext=True, newpath=output_dir
+        )
+    outputs["distance_map"] = os.path.abspath(outputs["distance_map"])
+    if _si.local_max_file is not attrs.NOTHING:
+        outputs["local_max_file"] = _si.local_max_file
+        if isinstance(_si.local_max_file, bool):
+            outputs["local_max_file"] = fname_presuffix(
+                _si.in_file, suffix="_lclmax", use_ext=True, newpath=output_dir
+            )
+        outputs["local_max_file"] = os.path.abspath(outputs["local_max_file"])
+    return outputs
diff --git a/example-specs/task/nipype/fsl/dti_fit_callables.py b/example-specs/task/nipype/fsl/dti_fit_callables.py
index 2cbb4e91..81cc530c 100644
--- a/example-specs/task/nipype/fsl/dti_fit_callables.py
+++ b/example-specs/task/nipype/fsl/dti_fit_callables.py
@@ -1 +1,362 @@
 """Module to put any functions that are referred to in the "callables" section of DTIFit.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+from glob import glob
+
+
+def V1_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["V1"]
+
+
+def V2_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["V2"]
+
+
+def V3_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["V3"]
+
+
+def L1_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["L1"]
+
+
+def L2_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["L2"]
+
+
+def L3_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["L3"]
+
+
+def MD_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["MD"]
+
+
+def FA_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["FA"]
+
+
+def MO_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["MO"]
+
+
+def S0_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["S0"]
+
+
+def tensor_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["tensor"]
+
+
+def sse_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["sse"]
+
+
+IFLOGGER = logging.getLogger("nipype.interface")
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """
+    Handle FSL ``output_type`` and version information.
+
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
+
+    """
+
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
+
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
+
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
+
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
+
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
+
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
+
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
+
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
+
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
+
+        Returns a list of standard images if called without arguments.
+
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
+
+
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
+
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
+
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
+
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "dtifit"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    keys_to_ignore = {"outputtype", "environ", "args"}
+    # Optional output: Map output name to input flag
+    opt_output = {"tensor": inputs.save_tensor, "sse": inputs.sse}
+    # Ignore optional output, whose corresponding input-flag is not defined
+    # or set to False
+    for output, input_flag in opt_output.items():
+        if (input_flag is not attrs.NOTHING) and input_flag:
+            # this is wanted output, do not ignore
+            continue
+        keys_to_ignore.add(output)
+
+    outputs = {}
+    for k in set(outputs.keys()) - keys_to_ignore:
+        outputs[k] = _gen_fname(
+            inputs.base_name,
+            suffix="_" + k,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    return outputs
diff --git a/example-specs/task/nipype/fsl/dual_regression_callables.py b/example-specs/task/nipype/fsl/dual_regression_callables.py
index 6c58bd05..649ac858 100644
--- a/example-specs/task/nipype/fsl/dual_regression_callables.py
+++ b/example-specs/task/nipype/fsl/dual_regression_callables.py
@@ -1 +1,35 @@
 """Module to put any functions that are referred to in the "callables" section of DualRegression.yaml"""
+
+import os
+import attrs
+
+
+def out_dir_default(inputs):
+    return _gen_filename("out_dir", inputs=inputs)
+
+
+def out_dir_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_dir"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_dir":
+        return output_dir
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    if inputs.out_dir is not attrs.NOTHING:
+        outputs["out_dir"] = os.path.abspath(inputs.out_dir)
+    else:
+        outputs["out_dir"] = _gen_filename(
+            "out_dir",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    return outputs
diff --git a/example-specs/task/nipype/fsl/eddy_callables.py b/example-specs/task/nipype/fsl/eddy_callables.py
index d52a039a..38aed023 100644
--- a/example-specs/task/nipype/fsl/eddy_callables.py
+++ b/example-specs/task/nipype/fsl/eddy_callables.py
@@ -1 +1,183 @@
 """Module to put any functions that are referred to in the "callables" section of Eddy.yaml"""
+
+import os
+import attrs
+
+
+def out_corrected_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_corrected"]
+
+
+def out_parameter_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_parameter"]
+
+
+def out_rotated_bvecs_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_rotated_bvecs"]
+
+
+def out_movement_rms_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_movement_rms"]
+
+
+def out_restricted_movement_rms_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_restricted_movement_rms"]
+
+
+def out_shell_alignment_parameters_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_shell_alignment_parameters"]
+
+
+def out_shell_pe_translation_parameters_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_shell_pe_translation_parameters"]
+
+
+def out_outlier_map_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_outlier_map"]
+
+
+def out_outlier_n_stdev_map_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_outlier_n_stdev_map"]
+
+
+def out_outlier_n_sqr_stdev_map_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_outlier_n_sqr_stdev_map"]
+
+
+def out_outlier_report_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_outlier_report"]
+
+
+def out_outlier_free_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_outlier_free"]
+
+
+def out_movement_over_time_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_movement_over_time"]
+
+
+def out_cnr_maps_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_cnr_maps"]
+
+
+def out_residuals_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_residuals"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_corrected"] = os.path.abspath("%s.nii.gz" % inputs.out_base)
+    outputs["out_parameter"] = os.path.abspath("%s.eddy_parameters" % inputs.out_base)
+
+    # File generation might depend on the version of EDDY
+    out_rotated_bvecs = os.path.abspath("%s.eddy_rotated_bvecs" % inputs.out_base)
+    out_movement_rms = os.path.abspath("%s.eddy_movement_rms" % inputs.out_base)
+    out_restricted_movement_rms = os.path.abspath(
+        "%s.eddy_restricted_movement_rms" % inputs.out_base
+    )
+    out_shell_alignment_parameters = os.path.abspath(
+        "%s.eddy_post_eddy_shell_alignment_parameters" % inputs.out_base
+    )
+    out_shell_pe_translation_parameters = os.path.abspath(
+        "%s.eddy_post_eddy_shell_PE_translation_parameters" % inputs.out_base
+    )
+    out_outlier_map = os.path.abspath("%s.eddy_outlier_map" % inputs.out_base)
+    out_outlier_n_stdev_map = os.path.abspath(
+        "%s.eddy_outlier_n_stdev_map" % inputs.out_base
+    )
+    out_outlier_n_sqr_stdev_map = os.path.abspath(
+        "%s.eddy_outlier_n_sqr_stdev_map" % inputs.out_base
+    )
+    out_outlier_report = os.path.abspath("%s.eddy_outlier_report" % inputs.out_base)
+    if (inputs.repol is not attrs.NOTHING) and inputs.repol:
+        out_outlier_free = os.path.abspath(
+            "%s.eddy_outlier_free_data" % inputs.out_base
+        )
+        if os.path.exists(out_outlier_free):
+            outputs["out_outlier_free"] = out_outlier_free
+    if (inputs.mporder is not attrs.NOTHING) and inputs.mporder > 0:
+        out_movement_over_time = os.path.abspath(
+            "%s.eddy_movement_over_time" % inputs.out_base
+        )
+        if os.path.exists(out_movement_over_time):
+            outputs["out_movement_over_time"] = out_movement_over_time
+    if (inputs.cnr_maps is not attrs.NOTHING) and inputs.cnr_maps:
+        out_cnr_maps = os.path.abspath("%s.eddy_cnr_maps.nii.gz" % inputs.out_base)
+        if os.path.exists(out_cnr_maps):
+            outputs["out_cnr_maps"] = out_cnr_maps
+    if (inputs.residuals is not attrs.NOTHING) and inputs.residuals:
+        out_residuals = os.path.abspath("%s.eddy_residuals.nii.gz" % inputs.out_base)
+        if os.path.exists(out_residuals):
+            outputs["out_residuals"] = out_residuals
+
+    if os.path.exists(out_rotated_bvecs):
+        outputs["out_rotated_bvecs"] = out_rotated_bvecs
+    if os.path.exists(out_movement_rms):
+        outputs["out_movement_rms"] = out_movement_rms
+    if os.path.exists(out_restricted_movement_rms):
+        outputs["out_restricted_movement_rms"] = out_restricted_movement_rms
+    if os.path.exists(out_shell_alignment_parameters):
+        outputs["out_shell_alignment_parameters"] = out_shell_alignment_parameters
+    if os.path.exists(out_shell_pe_translation_parameters):
+        outputs["out_shell_pe_translation_parameters"] = (
+            out_shell_pe_translation_parameters
+        )
+    if os.path.exists(out_outlier_map):
+        outputs["out_outlier_map"] = out_outlier_map
+    if os.path.exists(out_outlier_n_stdev_map):
+        outputs["out_outlier_n_stdev_map"] = out_outlier_n_stdev_map
+    if os.path.exists(out_outlier_n_sqr_stdev_map):
+        outputs["out_outlier_n_sqr_stdev_map"] = out_outlier_n_sqr_stdev_map
+    if os.path.exists(out_outlier_report):
+        outputs["out_outlier_report"] = out_outlier_report
+
+    return outputs
diff --git a/example-specs/task/nipype/fsl/eddy_correct_callables.py b/example-specs/task/nipype/fsl/eddy_correct_callables.py
index 746a59a5..589587c9 100644
--- a/example-specs/task/nipype/fsl/eddy_correct_callables.py
+++ b/example-specs/task/nipype/fsl/eddy_correct_callables.py
@@ -1 +1,283 @@
 """Module to put any functions that are referred to in the "callables" section of EddyCorrect.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+from glob import glob
+
+
+def eddy_corrected_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["eddy_corrected"]
+
+
+IFLOGGER = logging.getLogger("nipype.interface")
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+class Info(PackageInfo):
+    """
+    Handle FSL ``output_type`` and version information.
+
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
+
+    """
+
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
+
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
+
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
+
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
+
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
+
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
+
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
+
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
+
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
+
+        Returns a list of standard images if called without arguments.
+
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value + Info.output_type_to_ext(inputs.output_type)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
diff --git a/example-specs/task/nipype/fsl/eddy_quad.yaml b/example-specs/task/nipype/fsl/eddy_quad.yaml
index 354ed2ca..f20520b3 100644
--- a/example-specs/task/nipype/fsl/eddy_quad.yaml
+++ b/example-specs/task/nipype/fsl/eddy_quad.yaml
@@ -70,8 +70,14 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    avg_b0_pe_png: generic/file+list-of
+    # type=list: Image showing mid-sagittal, -coronal and -axial slices of each averaged pe-direction b0 volume. Generated when using the -f option.
+    avg_b_png: generic/file+list-of
+    # type=list: Image showing mid-sagittal, -coronal and -axial slices of each averaged b-shell volume.
     clean_volumes: generic/file
     # type=file: Text file containing a list of clean volumes, based on the eddy squared residuals. To generate a version of the pre-processed dataset without outlier volumes, use: `fslselectvols -i <eddy_corrected_data> -o eddy_corrected_data_clean --vols=vols_no_outliers.txt`
+    cnr_png: generic/file+list-of
+    # type=list: Image showing mid-sagittal, -coronal and -axial slices of each b-shell CNR volume. Generated when CNR maps are available.
     qc_json: generic/file
     # type=file: Single subject database containing quality metrics and data info.
     qc_pdf: generic/file
diff --git a/example-specs/task/nipype/fsl/eddy_quad_callables.py b/example-specs/task/nipype/fsl/eddy_quad_callables.py
index 2fb7e400..302c7a6b 100644
--- a/example-specs/task/nipype/fsl/eddy_quad_callables.py
+++ b/example-specs/task/nipype/fsl/eddy_quad_callables.py
@@ -1 +1,108 @@
 """Module to put any functions that are referred to in the "callables" section of EddyQuad.yaml"""
+
+import os
+import attrs
+
+
+def qc_json_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["qc_json"]
+
+
+def qc_pdf_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["qc_pdf"]
+
+
+def avg_b_png_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["avg_b_png"]
+
+
+def avg_b0_pe_png_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["avg_b0_pe_png"]
+
+
+def cnr_png_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["cnr_png"]
+
+
+def vdm_png_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["vdm_png"]
+
+
+def residuals_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["residuals"]
+
+
+def clean_volumes_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["clean_volumes"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    from glob import glob
+
+    outputs = {}
+
+    # If the output directory isn't defined, the interface seems to use
+    # the default but not set its value in `inputs.output_dir`
+    if inputs.output_dir is attrs.NOTHING:
+        out_dir = os.path.abspath(os.path.basename(inputs.base_name) + ".qc")
+    else:
+        out_dir = os.path.abspath(inputs.output_dir)
+
+    outputs["qc_json"] = os.path.join(out_dir, "qc.json")
+    outputs["qc_pdf"] = os.path.join(out_dir, "qc.pdf")
+
+    # Grab all b* files here. This will also grab the b0_pe* files
+    # as well, but only if the field input was provided. So we'll remove
+    # them later in the next conditional.
+    outputs["avg_b_png"] = sorted(glob(os.path.join(out_dir, "avg_b*.png")))
+
+    if inputs.field is not attrs.NOTHING:
+        outputs["avg_b0_pe_png"] = sorted(glob(os.path.join(out_dir, "avg_b0_pe*.png")))
+
+        # The previous glob for `avg_b_png` also grabbed the
+        # `avg_b0_pe_png` files so we have to remove them
+        # from `avg_b_png`.
+        for fname in outputs["avg_b0_pe_png"]:
+            outputs["avg_b_png"].remove(fname)
+
+        outputs["vdm_png"] = os.path.join(out_dir, "vdm.png")
+
+    outputs["cnr_png"] = sorted(glob(os.path.join(out_dir, "cnr*.png")))
+
+    residuals = os.path.join(out_dir, "eddy_msr.txt")
+    if os.path.isfile(residuals):
+        outputs["residuals"] = residuals
+
+    clean_volumes = os.path.join(out_dir, "vols_no_outliers.txt")
+    if os.path.isfile(clean_volumes):
+        outputs["clean_volumes"] = clean_volumes
+
+    return outputs
diff --git a/example-specs/task/nipype/fsl/epi_de_warp_callables.py b/example-specs/task/nipype/fsl/epi_de_warp_callables.py
index 41d6b2b8..ebdd1fb6 100644
--- a/example-specs/task/nipype/fsl/epi_de_warp_callables.py
+++ b/example-specs/task/nipype/fsl/epi_de_warp_callables.py
@@ -1,11 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of EPIDeWarp.yaml"""
 
-from glob import glob
-import attrs
 import os
+import attrs
 import os.path as op
-from pathlib import Path
 import logging
+from glob import glob
 
 
 def vsm_default(inputs):
@@ -20,148 +19,35 @@ def tmpdir_default(inputs):
     return _gen_filename("tmpdir", inputs=inputs)
 
 
-def vsm_callable(output_dir, inputs, stdout, stderr):
+def unwarped_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["vsm"]
+    return outputs["unwarped_file"]
 
 
-def tmpdir_callable(output_dir, inputs, stdout, stderr):
+def vsm_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["tmpdir"]
-
-
-IFLOGGER = logging.getLogger("nipype.interface")
-
-
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    if inputs.exfdw is attrs.NOTHING:
-        outputs["exfdw"] = _gen_filename(
-            "exfdw", inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-        )
-    else:
-        outputs["exfdw"] = inputs.exfdw
-    if inputs.epi_file is not attrs.NOTHING:
-        if inputs.epidw is not attrs.NOTHING:
-            outputs["unwarped_file"] = inputs.epidw
-        else:
-            outputs["unwarped_file"] = _gen_filename(
-                "epidw",
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-    if inputs.vsm is attrs.NOTHING:
-        outputs["vsm_file"] = _gen_filename(
-            "vsm", inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-        )
-    else:
-        outputs["vsm_file"] = _gen_fname(
-            inputs.vsm,
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-    if inputs.tmpdir is attrs.NOTHING:
-        outputs["exf_mask"] = _gen_fname(
-            cwd=_gen_filename("tmpdir"),
-            basename="maskexf",
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-    else:
-        outputs["exf_mask"] = _gen_fname(
-            cwd=inputs.tmpdir,
-            basename="maskexf",
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-    return outputs
+    return outputs["vsm_file"]
 
 
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "exfdw":
-        if inputs.exf_file is not attrs.NOTHING:
-            return _gen_fname(
-                inputs.exf_file,
-                suffix="_exfdw",
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-        else:
-            return _gen_fname(
-                "exfdw",
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-    if name == "epidw":
-        if inputs.epi_file is not attrs.NOTHING:
-            return _gen_fname(
-                inputs.epi_file,
-                suffix="_epidw",
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-    if name == "vsm":
-        return _gen_fname(
-            "vsm", inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-        )
-    if name == "tmpdir":
-        return os.path.join(output_dir, "temp")
-    return None
+def exfdw_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["exfdw"]
 
 
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
+def exf_mask_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["exf_mask"]
 
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
-
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
-
-            klass._version = klass.parse_version(raw_info)
-
-        return klass._version
 
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+IFLOGGER = logging.getLogger("nipype.interface")
 
 
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
@@ -190,8 +76,8 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     >>> fname_presuffix(fname,'pre','post','/tmp')
     '/tmp/prefoopost.nii.gz'
 
-    >>> from nipype.interfaces.base import Undefined
-    >>> fname_presuffix(fname, 'pre', 'post', Undefined) == \
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
             fname_presuffix(fname, 'pre', 'post')
     True
 
@@ -200,7 +86,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     if not use_ext:
         ext = ""
 
-    # No need for isdefined: bool(Undefined) evaluates to False
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
     if newpath:
         pth = op.abspath(newpath)
     return op.join(pth, prefix + fname + suffix + ext)
@@ -401,3 +287,93 @@ def _gen_fname(
         suffix = ""
     fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
     return fname
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "exfdw":
+        if inputs.exf_file is not attrs.NOTHING:
+            return _gen_fname(
+                inputs.exf_file,
+                suffix="_exfdw",
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+        else:
+            return _gen_fname(
+                "exfdw",
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    if name == "epidw":
+        if inputs.epi_file is not attrs.NOTHING:
+            return _gen_fname(
+                inputs.epi_file,
+                suffix="_epidw",
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    if name == "vsm":
+        return _gen_fname(
+            "vsm", inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )
+    if name == "tmpdir":
+        return os.path.join(output_dir, "temp")
+    return None
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    if inputs.exfdw is attrs.NOTHING:
+        outputs["exfdw"] = _gen_filename(
+            "exfdw", inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )
+    else:
+        outputs["exfdw"] = inputs.exfdw
+    if inputs.epi_file is not attrs.NOTHING:
+        if inputs.epidw is not attrs.NOTHING:
+            outputs["unwarped_file"] = inputs.epidw
+        else:
+            outputs["unwarped_file"] = _gen_filename(
+                "epidw",
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    if inputs.vsm is attrs.NOTHING:
+        outputs["vsm_file"] = _gen_filename(
+            "vsm", inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )
+    else:
+        outputs["vsm_file"] = _gen_fname(
+            inputs.vsm,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    if inputs.tmpdir is attrs.NOTHING:
+        outputs["exf_mask"] = _gen_fname(
+            cwd=_gen_filename("tmpdir"),
+            basename="maskexf",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    else:
+        outputs["exf_mask"] = _gen_fname(
+            cwd=inputs.tmpdir,
+            basename="maskexf",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    return outputs
diff --git a/example-specs/task/nipype/fsl/epi_reg_callables.py b/example-specs/task/nipype/fsl/epi_reg_callables.py
index f595e74a..6b713816 100644
--- a/example-specs/task/nipype/fsl/epi_reg_callables.py
+++ b/example-specs/task/nipype/fsl/epi_reg_callables.py
@@ -1 +1,145 @@
 """Module to put any functions that are referred to in the "callables" section of EpiReg.yaml"""
+
+import os
+import attrs
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+def out_1vol_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_1vol"]
+
+
+def fmap2str_mat_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["fmap2str_mat"]
+
+
+def fmap2epi_mat_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["fmap2epi_mat"]
+
+
+def fmap_epi_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["fmap_epi"]
+
+
+def fmap_str_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["fmap_str"]
+
+
+def fmapmag_str_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["fmapmag_str"]
+
+
+def epi2str_inv_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["epi2str_inv"]
+
+
+def epi2str_mat_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["epi2str_mat"]
+
+
+def shiftmap_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["shiftmap"]
+
+
+def fullwarp_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["fullwarp"]
+
+
+def wmseg_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["wmseg"]
+
+
+def seg_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["seg"]
+
+
+def wmedge_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["wmedge"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = os.path.join(output_dir, inputs.out_base + ".nii.gz")
+    if not ((inputs.no_fmapreg is not attrs.NOTHING) and inputs.no_fmapreg) and (
+        inputs.fmap is not attrs.NOTHING
+    ):
+        outputs["out_1vol"] = os.path.join(output_dir, inputs.out_base + "_1vol.nii.gz")
+        outputs["fmap2str_mat"] = os.path.join(
+            output_dir, inputs.out_base + "_fieldmap2str.mat"
+        )
+        outputs["fmap2epi_mat"] = os.path.join(
+            output_dir, inputs.out_base + "_fieldmaprads2epi.mat"
+        )
+        outputs["fmap_epi"] = os.path.join(
+            output_dir, inputs.out_base + "_fieldmaprads2epi.nii.gz"
+        )
+        outputs["fmap_str"] = os.path.join(
+            output_dir, inputs.out_base + "_fieldmaprads2str.nii.gz"
+        )
+        outputs["fmapmag_str"] = os.path.join(
+            output_dir, inputs.out_base + "_fieldmap2str.nii.gz"
+        )
+        outputs["shiftmap"] = os.path.join(
+            output_dir, inputs.out_base + "_fieldmaprads2epi_shift.nii.gz"
+        )
+        outputs["fullwarp"] = os.path.join(output_dir, inputs.out_base + "_warp.nii.gz")
+        outputs["epi2str_inv"] = os.path.join(output_dir, inputs.out_base + "_inv.mat")
+    if inputs.wmseg is attrs.NOTHING:
+        outputs["wmedge"] = os.path.join(
+            output_dir, inputs.out_base + "_fast_wmedge.nii.gz"
+        )
+        outputs["wmseg"] = os.path.join(
+            output_dir, inputs.out_base + "_fast_wmseg.nii.gz"
+        )
+        outputs["seg"] = os.path.join(output_dir, inputs.out_base + "_fast_seg.nii.gz")
+    outputs["epi2str_mat"] = os.path.join(output_dir, inputs.out_base + ".mat")
+    return outputs
diff --git a/example-specs/task/nipype/fsl/erode_image_callables.py b/example-specs/task/nipype/fsl/erode_image_callables.py
index 9cbdb4b7..56df727b 100644
--- a/example-specs/task/nipype/fsl/erode_image_callables.py
+++ b/example-specs/task/nipype/fsl/erode_image_callables.py
@@ -1 +1,284 @@
 """Module to put any functions that are referred to in the "callables" section of ErodeImage.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+from glob import glob
+
+
+def out_file_default(inputs):
+    return _gen_filename("out_file", inputs=inputs)
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+IFLOGGER = logging.getLogger("nipype.interface")
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """
+    Handle FSL ``output_type`` and version information.
+
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
+
+    """
+
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
+
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
+
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
+
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
+
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
+
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
+
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
+
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
+
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
+
+        Returns a list of standard images if called without arguments.
+
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
+
+
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
+
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
+
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
+
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "fslmaths"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )["out_file"]
+    return None
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = inputs.out_file
+    if inputs.out_file is attrs.NOTHING:
+        outputs["out_file"] = _gen_fname(
+            inputs.in_file,
+            suffix=_suffix,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    outputs["out_file"] = os.path.abspath(outputs["out_file"])
+    return outputs
diff --git a/example-specs/task/nipype/fsl/extract_roi_callables.py b/example-specs/task/nipype/fsl/extract_roi_callables.py
index 4fef61a5..ee547187 100644
--- a/example-specs/task/nipype/fsl/extract_roi_callables.py
+++ b/example-specs/task/nipype/fsl/extract_roi_callables.py
@@ -1 +1,300 @@
 """Module to put any functions that are referred to in the "callables" section of ExtractROI.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+from glob import glob
+
+
+def roi_file_default(inputs):
+    return _gen_filename("roi_file", inputs=inputs)
+
+
+def roi_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["roi_file"]
+
+
+IFLOGGER = logging.getLogger("nipype.interface")
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """
+    Handle FSL ``output_type`` and version information.
+
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
+
+    """
+
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
+
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
+
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
+
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
+
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
+
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
+
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
+
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
+
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
+
+        Returns a list of standard images if called without arguments.
+
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
+
+
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
+
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
+
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
+
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "fslroi"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "roi_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )[name]
+    return None
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    """Create a Bunch which contains all possible files generated
+    by running the interface.  Some files are always generated, others
+    depending on which ``inputs`` options are set.
+
+
+    Returns
+    -------
+
+    outputs : Bunch object
+        Bunch object containing all possible files generated by
+        interface object.
+
+        If None, file was not generated
+        Else, contains path, filename of generated outputfile
+
+    """
+    outputs = {}
+    outputs["roi_file"] = inputs.roi_file
+    if outputs["roi_file"] is attrs.NOTHING:
+        outputs["roi_file"] = _gen_fname(
+            inputs.in_file,
+            suffix="_roi",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    outputs["roi_file"] = os.path.abspath(outputs["roi_file"])
+    return outputs
diff --git a/example-specs/task/nipype/fsl/fast.yaml b/example-specs/task/nipype/fsl/fast.yaml
index 5cf2f7bf..6378b4c9 100644
--- a/example-specs/task/nipype/fsl/fast.yaml
+++ b/example-specs/task/nipype/fsl/fast.yaml
@@ -58,10 +58,21 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    bias_field: generic/file+list-of
+    # type=outputmultiobject: 
     mixeltype: generic/file
     # type=file: path/name of mixeltype volume file _mixeltype
+    partial_volume_files: generic/file+list-of
+    # type=outputmultiobject: 
     partial_volume_map: generic/file
     # type=file: path/name of partial volume file _pveseg
+    probability_maps: generic/file+list-of
+    # type=outputmultiobject: 
+    # type=bool|default=False: outputs individual probability maps
+    restored_image: generic/file+list-of
+    # type=outputmultiobject: 
+    tissue_class_files: generic/file+list-of
+    # type=outputmultiobject: 
     tissue_class_map: generic/file
     # type=file: path/name of binary segmented volume file one val for each class  _seg
   callables:
diff --git a/example-specs/task/nipype/fsl/fast_callables.py b/example-specs/task/nipype/fsl/fast_callables.py
index 3ba8f036..a2ec6c7f 100644
--- a/example-specs/task/nipype/fsl/fast_callables.py
+++ b/example-specs/task/nipype/fsl/fast_callables.py
@@ -1 +1,501 @@
 """Module to put any functions that are referred to in the "callables" section of FAST.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+from glob import glob
+
+
+def tissue_class_map_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["tissue_class_map"]
+
+
+def tissue_class_files_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["tissue_class_files"]
+
+
+def restored_image_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["restored_image"]
+
+
+def mixeltype_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["mixeltype"]
+
+
+def partial_volume_map_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["partial_volume_map"]
+
+
+def partial_volume_files_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["partial_volume_files"]
+
+
+def bias_field_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["bias_field"]
+
+
+def probability_maps_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["probability_maps"]
+
+
+IFLOGGER = logging.getLogger("nipype.interface")
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """
+    Handle FSL ``output_type`` and version information.
+
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
+
+    """
+
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
+
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
+
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
+
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
+
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
+
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
+
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
+
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
+
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
+
+        Returns a list of standard images if called without arguments.
+
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
+
+
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
+
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
+
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
+
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "fast"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    if inputs.number_classes is attrs.NOTHING:
+        nclasses = 3
+    else:
+        nclasses = inputs.number_classes
+    # when using multichannel, results basename is based on last
+    # input filename
+    _gen_fname_opts = {}
+    if inputs.out_basename is not attrs.NOTHING:
+        _gen_fname_opts["basename"] = inputs.out_basename
+        _gen_fname_opts["cwd"] = output_dir
+    else:
+        _gen_fname_opts["basename"] = inputs.in_files[-1]
+        _gen_fname_opts["cwd"], _, _ = split_filename(_gen_fname_opts["basename"])
+
+    outputs["tissue_class_map"] = _gen_fname(
+        suffix="_seg",
+        **_gen_fname_opts,
+        inputs=inputs,
+        stdout=stdout,
+        stderr=stderr,
+        output_dir=output_dir
+    )
+    if inputs.segments:
+        outputs["tissue_class_files"] = []
+        for i in range(nclasses):
+            outputs["tissue_class_files"].append(
+                _gen_fname(
+                    suffix="_seg_%d" % i,
+                    **_gen_fname_opts,
+                    inputs=inputs,
+                    stdout=stdout,
+                    stderr=stderr,
+                    output_dir=output_dir
+                )
+            )
+    if inputs.output_biascorrected is not attrs.NOTHING:
+        outputs["restored_image"] = []
+        if len(inputs.in_files) > 1:
+            # for multi-image segmentation there is one corrected image
+            # per input
+            for val, f in enumerate(inputs.in_files):
+                # image numbering is 1-based
+                outputs["restored_image"].append(
+                    _gen_fname(
+                        suffix="_restore_%d" % (val + 1),
+                        **_gen_fname_opts,
+                        inputs=inputs,
+                        stdout=stdout,
+                        stderr=stderr,
+                        output_dir=output_dir
+                    )
+                )
+        else:
+            # single image segmentation has unnumbered output image
+            outputs["restored_image"].append(
+                _gen_fname(
+                    suffix="_restore",
+                    **_gen_fname_opts,
+                    inputs=inputs,
+                    stdout=stdout,
+                    stderr=stderr,
+                    output_dir=output_dir
+                )
+            )
+
+    outputs["mixeltype"] = _gen_fname(
+        suffix="_mixeltype",
+        **_gen_fname_opts,
+        inputs=inputs,
+        stdout=stdout,
+        stderr=stderr,
+        output_dir=output_dir
+    )
+    if not inputs.no_pve:
+        outputs["partial_volume_map"] = _gen_fname(
+            suffix="_pveseg",
+            **_gen_fname_opts,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir
+        )
+        outputs["partial_volume_files"] = []
+        for i in range(nclasses):
+            outputs["partial_volume_files"].append(
+                _gen_fname(
+                    suffix="_pve_%d" % i,
+                    **_gen_fname_opts,
+                    inputs=inputs,
+                    stdout=stdout,
+                    stderr=stderr,
+                    output_dir=output_dir
+                )
+            )
+    if inputs.output_biasfield:
+        outputs["bias_field"] = []
+        if len(inputs.in_files) > 1:
+            # for multi-image segmentation there is one bias field image
+            # per input
+            for val, f in enumerate(inputs.in_files):
+                # image numbering is 1-based
+                outputs["bias_field"].append(
+                    _gen_fname(
+                        suffix="_bias_%d" % (val + 1),
+                        **_gen_fname_opts,
+                        inputs=inputs,
+                        stdout=stdout,
+                        stderr=stderr,
+                        output_dir=output_dir
+                    )
+                )
+        else:
+            # single image segmentation has unnumbered output image
+            outputs["bias_field"].append(
+                _gen_fname(
+                    suffix="_bias",
+                    **_gen_fname_opts,
+                    inputs=inputs,
+                    stdout=stdout,
+                    stderr=stderr,
+                    output_dir=output_dir
+                )
+            )
+
+    if inputs.probability_maps:
+        outputs["probability_maps"] = []
+        for i in range(nclasses):
+            outputs["probability_maps"].append(
+                _gen_fname(
+                    suffix="_prob_%d" % i,
+                    **_gen_fname_opts,
+                    inputs=inputs,
+                    stdout=stdout,
+                    stderr=stderr,
+                    output_dir=output_dir
+                )
+            )
+    return outputs
diff --git a/example-specs/task/nipype/fsl/feat_callables.py b/example-specs/task/nipype/fsl/feat_callables.py
index cc49a4c8..7ad7f7ac 100644
--- a/example-specs/task/nipype/fsl/feat_callables.py
+++ b/example-specs/task/nipype/fsl/feat_callables.py
@@ -1 +1,40 @@
 """Module to put any functions that are referred to in the "callables" section of FEAT.yaml"""
+
+import os
+from glob import glob
+
+
+def feat_dir_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["feat_dir"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    is_ica = False
+    outputs["feat_dir"] = None
+    with open(inputs.fsf_file, "rt") as fp:
+        text = fp.read()
+        if "set fmri(inmelodic) 1" in text:
+            is_ica = True
+        for line in text.split("\n"):
+            if line.find("set fmri(outputdir)") > -1:
+                try:
+                    outputdir_spec = line.split('"')[-2]
+                    if os.path.exists(outputdir_spec):
+                        outputs["feat_dir"] = outputdir_spec
+
+                except:
+                    pass
+    if not outputs["feat_dir"]:
+        if is_ica:
+            outputs["feat_dir"] = glob(os.path.join(output_dir, "*ica"))[0]
+        else:
+            outputs["feat_dir"] = glob(os.path.join(output_dir, "*feat"))[0]
+    return outputs
diff --git a/example-specs/task/nipype/fsl/feat_model_callables.py b/example-specs/task/nipype/fsl/feat_model_callables.py
index 4ce6666d..fd0bbdda 100644
--- a/example-specs/task/nipype/fsl/feat_model_callables.py
+++ b/example-specs/task/nipype/fsl/feat_model_callables.py
@@ -1 +1,161 @@
 """Module to put any functions that are referred to in the "callables" section of FEATModel.yaml"""
+
+import os
+from glob import glob
+import logging
+
+
+def design_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["design_file"]
+
+
+def design_image_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["design_image"]
+
+
+def design_cov_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["design_cov"]
+
+
+def con_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["con_file"]
+
+
+def fcon_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["fcon_file"]
+
+
+IFLOGGER = logging.getLogger("nipype.interface")
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+class FSLCommandInputSpec(CommandLineInputSpec):
+    """
+    Base Input Specification for all FSL Commands
+
+    All command support specifying FSLOUTPUTTYPE dynamically
+    via output_type.
+
+    Example
+    -------
+    fsl.ExtractRoi(tmin=42, tsize=1, output_type='NIFTI')
+    """
+
+    output_type = traits.Enum("NIFTI", list(Info.ftypes.keys()), desc="FSL output type")
+
+
+class TraitedSpec(BaseTraitedSpec):
+    """Create a subclass with strict traits.
+
+    This is used in 90% of the cases.
+    """
+
+    _ = traits.Disallow
+
+
+def simplify_list(filelist):
+    """Returns a list if filelist is a list of length greater than 1,
+    otherwise returns the first element
+    """
+    if len(filelist) > 1:
+        return filelist
+    else:
+        return filelist[0]
+
+
+class FEATOutputSpec(TraitedSpec):
+    feat_dir = Directory(exists=True)
+
+
+class FEATInputSpec(FSLCommandInputSpec):
+    fsf_file = File(
+        exists=True,
+        mandatory=True,
+        argstr="%s",
+        position=0,
+        desc="File specifying the feat design spec file",
+    )
+
+
+class FEAT(FSLCommand):
+    """Uses FSL feat to calculate first level stats"""
+
+    _cmd = "feat"
+    input_spec = FEATInputSpec
+    output_spec = FEATOutputSpec
+
+    def _list_outputs(self):
+        outputs = self._outputs().get()
+        is_ica = False
+        outputs["feat_dir"] = None
+        with open(self.inputs.fsf_file, "rt") as fp:
+            text = fp.read()
+            if "set fmri(inmelodic) 1" in text:
+                is_ica = True
+            for line in text.split("\n"):
+                if line.find("set fmri(outputdir)") > -1:
+                    try:
+                        outputdir_spec = line.split('"')[-2]
+                        if os.path.exists(outputdir_spec):
+                            outputs["feat_dir"] = outputdir_spec
+
+                    except:
+                        pass
+        if not outputs["feat_dir"]:
+            if is_ica:
+                outputs["feat_dir"] = glob(os.path.join(os.getcwd(), "*ica"))[0]
+            else:
+                outputs["feat_dir"] = glob(os.path.join(os.getcwd(), "*feat"))[0]
+        return outputs
+
+
+def _get_design_root(infile, inputs=None, stdout=None, stderr=None, output_dir=None):
+    _, fname = os.path.split(infile)
+    return fname.split(".")[0]
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    # TODO: figure out file names and get rid off the globs
+    outputs = {}
+    root = _get_design_root(
+        simplify_list(inputs.fsf_file),
+        inputs=inputs,
+        stdout=stdout,
+        stderr=stderr,
+        output_dir=output_dir,
+    )
+    design_file = glob(os.path.join(output_dir, "%s*.mat" % root))
+    assert len(design_file) == 1, "No mat file generated by FEAT Model"
+    outputs["design_file"] = design_file[0]
+    design_image = glob(os.path.join(output_dir, "%s.png" % root))
+    assert len(design_image) == 1, "No design image generated by FEAT Model"
+    outputs["design_image"] = design_image[0]
+    design_cov = glob(os.path.join(output_dir, "%s_cov.png" % root))
+    assert len(design_cov) == 1, "No covariance image generated by FEAT Model"
+    outputs["design_cov"] = design_cov[0]
+    con_file = glob(os.path.join(output_dir, "%s*.con" % root))
+    assert len(con_file) == 1, "No con file generated by FEAT Model"
+    outputs["con_file"] = con_file[0]
+    fcon_file = glob(os.path.join(output_dir, "%s*.fts" % root))
+    if fcon_file:
+        assert len(fcon_file) == 1, "No fts file generated by FEAT Model"
+        outputs["fcon_file"] = fcon_file[0]
+    return outputs
diff --git a/example-specs/task/nipype/fsl/feature_extractor_callables.py b/example-specs/task/nipype/fsl/feature_extractor_callables.py
index cf383991..9a85e662 100644
--- a/example-specs/task/nipype/fsl/feature_extractor_callables.py
+++ b/example-specs/task/nipype/fsl/feature_extractor_callables.py
@@ -1 +1,18 @@
 """Module to put any functions that are referred to in the "callables" section of FeatureExtractor.yaml"""
+
+
+def mel_ica_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["mel_ica"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["mel_ica"] = inputs.mel_ica
+    return outputs
diff --git a/example-specs/task/nipype/fsl/filmgls.yaml b/example-specs/task/nipype/fsl/filmgls.yaml
index ba632896..b92be438 100644
--- a/example-specs/task/nipype/fsl/filmgls.yaml
+++ b/example-specs/task/nipype/fsl/filmgls.yaml
@@ -71,10 +71,16 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    copes: generic/file+list-of
+    # type=outputmultiobject: Contrast estimates for each contrast
     dof_file: generic/file
     # type=file: degrees of freedom
+    fstats: generic/file+list-of
+    # type=outputmultiobject: f-stat file for each contrast
     logfile: generic/file
     # type=file: FILM run logfile
+    param_estimates: generic/file+list-of
+    # type=outputmultiobject: Parameter estimates for each column of the design matrix
     residual4d: generic/file
     # type=file: Model fit residual mean-squared error for each time point
     results_dir: generic/directory
@@ -84,6 +90,14 @@ outputs:
     # type=file: summary of residuals, See Woolrich, et. al., 2001
     thresholdac: generic/file
     # type=file: The FILM autocorrelation parameters
+    tstats: generic/file+list-of
+    # type=outputmultiobject: t-stat file for each contrast
+    varcopes: generic/file+list-of
+    # type=outputmultiobject: Variance estimates for each contrast
+    zfstats: generic/file+list-of
+    # type=outputmultiobject: z-stat file for each F contrast
+    zstats: generic/file+list-of
+    # type=outputmultiobject: z-stat file for each contrast
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/fsl/filmgls_callables.py b/example-specs/task/nipype/fsl/filmgls_callables.py
index 5ba862af..afe9771b 100644
--- a/example-specs/task/nipype/fsl/filmgls_callables.py
+++ b/example-specs/task/nipype/fsl/filmgls_callables.py
@@ -1 +1,527 @@
 """Module to put any functions that are referred to in the "callables" section of FILMGLS.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+from glob import glob
+
+
+def param_estimates_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["param_estimates"]
+
+
+def residual4d_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["residual4d"]
+
+
+def dof_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["dof_file"]
+
+
+def sigmasquareds_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["sigmasquareds"]
+
+
+def results_dir_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["results_dir"]
+
+
+def thresholdac_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["thresholdac"]
+
+
+def logfile_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["logfile"]
+
+
+def copes_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["copes"]
+
+
+def varcopes_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["varcopes"]
+
+
+def zstats_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["zstats"]
+
+
+def tstats_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["tstats"]
+
+
+def fstats_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["fstats"]
+
+
+def zfstats_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["zfstats"]
+
+
+IFLOGGER = logging.getLogger("nipype.interface")
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """
+    Handle FSL ``output_type`` and version information.
+
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
+
+    """
+
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
+
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
+
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
+
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
+
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
+
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
+
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
+
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
+
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
+
+        Returns a list of standard images if called without arguments.
+
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
+
+
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
+
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
+
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
+
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "film_gls"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _get_numcons(inputs=None, stdout=None, stderr=None, output_dir=None):
+    numtcons = 0
+    numfcons = 0
+    if inputs.tcon_file is not attrs.NOTHING:
+        fp = open(inputs.tcon_file, "rt")
+        for line in fp.readlines():
+            if line.startswith("/NumContrasts"):
+                numtcons = int(line.split()[-1])
+                break
+        fp.close()
+    if inputs.fcon_file is not attrs.NOTHING:
+        fp = open(inputs.fcon_file, "rt")
+        for line in fp.readlines():
+            if line.startswith("/NumContrasts"):
+                numfcons = int(line.split()[-1])
+                break
+        fp.close()
+    return numtcons, numfcons
+
+
+def _get_pe_files(cwd, inputs=None, stdout=None, stderr=None, output_dir=None):
+    files = None
+    if inputs.design_file is not attrs.NOTHING:
+        fp = open(inputs.design_file, "rt")
+        for line in fp.readlines():
+            if line.startswith("/NumWaves"):
+                numpes = int(line.split()[-1])
+                files = []
+                for i in range(numpes):
+                    files.append(
+                        _gen_fname(
+                            "pe%d.nii" % (i + 1),
+                            cwd=cwd,
+                            inputs=inputs,
+                            stdout=stdout,
+                            stderr=stderr,
+                            output_dir=output_dir,
+                        )
+                    )
+                break
+        fp.close()
+    return files
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    cwd = output_dir
+    results_dir = os.path.join(cwd, inputs.results_dir)
+    outputs["results_dir"] = results_dir
+    pe_files = _get_pe_files(
+        results_dir, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+    )
+    if pe_files:
+        outputs["param_estimates"] = pe_files
+    outputs["residual4d"] = _gen_fname(
+        "res4d.nii",
+        cwd=results_dir,
+        inputs=inputs,
+        stdout=stdout,
+        stderr=stderr,
+        output_dir=output_dir,
+    )
+    outputs["dof_file"] = os.path.join(results_dir, "dof")
+    outputs["sigmasquareds"] = _gen_fname(
+        "sigmasquareds.nii",
+        cwd=results_dir,
+        inputs=inputs,
+        stdout=stdout,
+        stderr=stderr,
+        output_dir=output_dir,
+    )
+    outputs["thresholdac"] = _gen_fname(
+        "threshac1.nii",
+        cwd=results_dir,
+        inputs=inputs,
+        stdout=stdout,
+        stderr=stderr,
+        output_dir=output_dir,
+    )
+    if Info.version() and LooseVersion(Info.version()) < LooseVersion("5.0.7"):
+        outputs["corrections"] = _gen_fname(
+            "corrections.nii",
+            cwd=results_dir,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    outputs["logfile"] = _gen_fname(
+        "logfile",
+        change_ext=False,
+        cwd=results_dir,
+        inputs=inputs,
+        stdout=stdout,
+        stderr=stderr,
+        output_dir=output_dir,
+    )
+
+    if Info.version() and LooseVersion(Info.version()) > LooseVersion("5.0.6"):
+        pth = results_dir
+        numtcons, numfcons = _get_numcons(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )
+        base_contrast = 1
+        copes = []
+        varcopes = []
+        zstats = []
+        tstats = []
+        for i in range(numtcons):
+            copes.append(
+                _gen_fname(
+                    "cope%d.nii" % (base_contrast + i),
+                    cwd=pth,
+                    inputs=inputs,
+                    stdout=stdout,
+                    stderr=stderr,
+                    output_dir=output_dir,
+                )
+            )
+            varcopes.append(
+                _gen_fname(
+                    "varcope%d.nii" % (base_contrast + i),
+                    cwd=pth,
+                    inputs=inputs,
+                    stdout=stdout,
+                    stderr=stderr,
+                    output_dir=output_dir,
+                )
+            )
+            zstats.append(
+                _gen_fname(
+                    "zstat%d.nii" % (base_contrast + i),
+                    cwd=pth,
+                    inputs=inputs,
+                    stdout=stdout,
+                    stderr=stderr,
+                    output_dir=output_dir,
+                )
+            )
+            tstats.append(
+                _gen_fname(
+                    "tstat%d.nii" % (base_contrast + i),
+                    cwd=pth,
+                    inputs=inputs,
+                    stdout=stdout,
+                    stderr=stderr,
+                    output_dir=output_dir,
+                )
+            )
+        if copes:
+            outputs["copes"] = copes
+            outputs["varcopes"] = varcopes
+            outputs["zstats"] = zstats
+            outputs["tstats"] = tstats
+        fstats = []
+        zfstats = []
+        for i in range(numfcons):
+            fstats.append(
+                _gen_fname(
+                    "fstat%d.nii" % (base_contrast + i),
+                    cwd=pth,
+                    inputs=inputs,
+                    stdout=stdout,
+                    stderr=stderr,
+                    output_dir=output_dir,
+                )
+            )
+            zfstats.append(
+                _gen_fname(
+                    "zfstat%d.nii" % (base_contrast + i),
+                    cwd=pth,
+                    inputs=inputs,
+                    stdout=stdout,
+                    stderr=stderr,
+                    output_dir=output_dir,
+                )
+            )
+        if fstats:
+            outputs["fstats"] = fstats
+            outputs["zfstats"] = zfstats
+    return outputs
diff --git a/example-specs/task/nipype/fsl/filter_regressor_callables.py b/example-specs/task/nipype/fsl/filter_regressor_callables.py
index 53d67339..6d3ba0e4 100644
--- a/example-specs/task/nipype/fsl/filter_regressor_callables.py
+++ b/example-specs/task/nipype/fsl/filter_regressor_callables.py
@@ -1 +1,284 @@
 """Module to put any functions that are referred to in the "callables" section of FilterRegressor.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+from glob import glob
+
+
+def out_file_default(inputs):
+    return _gen_filename("out_file", inputs=inputs)
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+IFLOGGER = logging.getLogger("nipype.interface")
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """
+    Handle FSL ``output_type`` and version information.
+
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
+
+    """
+
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
+
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
+
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
+
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
+
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
+
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
+
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
+
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
+
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
+
+        Returns a list of standard images if called without arguments.
+
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
+
+
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
+
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
+
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
+
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "fsl_regfilt"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )[name]
+    return None
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = inputs.out_file
+    if outputs["out_file"] is attrs.NOTHING:
+        outputs["out_file"] = _gen_fname(
+            inputs.in_file,
+            suffix="_regfilt",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    outputs["out_file"] = os.path.abspath(outputs["out_file"])
+    return outputs
diff --git a/example-specs/task/nipype/fsl/find_the_biggest_callables.py b/example-specs/task/nipype/fsl/find_the_biggest_callables.py
index ac9adbb5..8ebd7042 100644
--- a/example-specs/task/nipype/fsl/find_the_biggest_callables.py
+++ b/example-specs/task/nipype/fsl/find_the_biggest_callables.py
@@ -1 +1,285 @@
 """Module to put any functions that are referred to in the "callables" section of FindTheBiggest.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+from glob import glob
+
+
+def out_file_default(inputs):
+    return _gen_filename("out_file", inputs=inputs)
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+IFLOGGER = logging.getLogger("nipype.interface")
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """
+    Handle FSL ``output_type`` and version information.
+
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
+
+    """
+
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
+
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
+
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
+
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
+
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
+
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
+
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
+
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
+
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
+
+        Returns a list of standard images if called without arguments.
+
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
+
+
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
+
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
+
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
+
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "find_the_biggest"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )[name]
+    else:
+        return None
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = inputs.out_file
+    if outputs["out_file"] is attrs.NOTHING:
+        outputs["out_file"] = _gen_fname(
+            "biggestSegmentation",
+            suffix="",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    outputs["out_file"] = os.path.abspath(outputs["out_file"])
+    return outputs
diff --git a/example-specs/task/nipype/fsl/first.yaml b/example-specs/task/nipype/fsl/first.yaml
index 329292f8..9da759a6 100644
--- a/example-specs/task/nipype/fsl/first.yaml
+++ b/example-specs/task/nipype/fsl/first.yaml
@@ -52,10 +52,14 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    bvars: generic/file+list-of
+    # type=outputmultiobject: bvars for each subcortical region
     original_segmentations: generic/file
     # type=file: 3D image file containing the segmented regions as integer values. Uses CMA labelling
     segmentation_file: generic/file
     # type=file: 4D image file containing a single volume per segmented region
+    vtk_surfaces: generic/file+list-of
+    # type=outputmultiobject: VTK format meshes for each subcortical region
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/fsl/first_callables.py b/example-specs/task/nipype/fsl/first_callables.py
index d1e94f42..fea44e53 100644
--- a/example-specs/task/nipype/fsl/first_callables.py
+++ b/example-specs/task/nipype/fsl/first_callables.py
@@ -1 +1,182 @@
 """Module to put any functions that are referred to in the "callables" section of FIRST.yaml"""
+
+import attrs
+import os.path as op
+
+
+def vtk_surfaces_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["vtk_surfaces"]
+
+
+def bvars_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["bvars"]
+
+
+def original_segmentations_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["original_segmentations"]
+
+
+def segmentation_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["segmentation_file"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _gen_mesh_names(
+    name, structures, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, prefix, ext = split_filename(inputs.out_file)
+    if name == "vtk_surfaces":
+        vtks = list()
+        for struct in structures:
+            vtk = prefix + "-" + struct + "_first.vtk"
+            vtks.append(op.abspath(vtk))
+        return vtks
+    if name == "bvars":
+        bvars = list()
+        for struct in structures:
+            bvar = prefix + "-" + struct + "_first.bvars"
+            bvars.append(op.abspath(bvar))
+        return bvars
+    return None
+
+
+def _gen_fname(basename, inputs=None, stdout=None, stderr=None, output_dir=None):
+    path, outname, ext = split_filename(inputs.out_file)
+
+    method = "none"
+    if (inputs.method is not attrs.NOTHING) and inputs.method != "none":
+        method = "fast"
+        if inputs.list_of_specific_structures and inputs.method == "auto":
+            method = "none"
+
+    if inputs.method_as_numerical_threshold is not attrs.NOTHING:
+        thres = "%.4f" % inputs.method_as_numerical_threshold
+        method = thres.replace(".", "")
+
+    if basename == "original_segmentations":
+        return op.abspath("%s_all_%s_origsegs.nii.gz" % (outname, method))
+    if basename == "segmentation_file":
+        return op.abspath("%s_all_%s_firstseg.nii.gz" % (outname, method))
+
+    return None
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+
+    if inputs.list_of_specific_structures is not attrs.NOTHING:
+        structures = inputs.list_of_specific_structures
+    else:
+        structures = [
+            "L_Hipp",
+            "R_Hipp",
+            "L_Accu",
+            "R_Accu",
+            "L_Amyg",
+            "R_Amyg",
+            "L_Caud",
+            "R_Caud",
+            "L_Pall",
+            "R_Pall",
+            "L_Puta",
+            "R_Puta",
+            "L_Thal",
+            "R_Thal",
+            "BrStem",
+        ]
+    outputs["original_segmentations"] = _gen_fname(
+        "original_segmentations",
+        inputs=inputs,
+        stdout=stdout,
+        stderr=stderr,
+        output_dir=output_dir,
+    )
+    outputs["segmentation_file"] = _gen_fname(
+        "segmentation_file",
+        inputs=inputs,
+        stdout=stdout,
+        stderr=stderr,
+        output_dir=output_dir,
+    )
+    outputs["vtk_surfaces"] = _gen_mesh_names(
+        "vtk_surfaces",
+        structures,
+        inputs=inputs,
+        stdout=stdout,
+        stderr=stderr,
+        output_dir=output_dir,
+    )
+    outputs["bvars"] = _gen_mesh_names(
+        "bvars",
+        structures,
+        inputs=inputs,
+        stdout=stdout,
+        stderr=stderr,
+        output_dir=output_dir,
+    )
+    return outputs
diff --git a/example-specs/task/nipype/fsl/flameo.yaml b/example-specs/task/nipype/fsl/flameo.yaml
index 71a90216..1918e793 100644
--- a/example-specs/task/nipype/fsl/flameo.yaml
+++ b/example-specs/task/nipype/fsl/flameo.yaml
@@ -70,8 +70,30 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    copes: generic/file+list-of
+    # type=outputmultiobject: Contrast estimates for each contrast
+    fstats: generic/file+list-of
+    # type=outputmultiobject: f-stat file for each contrast
+    mrefvars: generic/file+list-of
+    # type=outputmultiobject: mean random effect variances for each contrast
+    pes: generic/file+list-of
+    # type=outputmultiobject: Parameter estimates for each column of the design matrix for each voxel
+    res4d: generic/file+list-of
+    # type=outputmultiobject: Model fit residual mean-squared error for each time point
     stats_dir: generic/directory
     # type=directory: directory storing model estimation output
+    tdof: generic/file+list-of
+    # type=outputmultiobject: temporal dof file for each contrast
+    tstats: generic/file+list-of
+    # type=outputmultiobject: t-stat file for each contrast
+    var_copes: generic/file+list-of
+    # type=outputmultiobject: Variance estimates for each contrast
+    weights: generic/file+list-of
+    # type=outputmultiobject: weights file for each contrast
+    zfstats: generic/file+list-of
+    # type=outputmultiobject: z stat file for each f contrast
+    zstats: generic/file+list-of
+    # type=outputmultiobject: z-stat file for each contrast
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/fsl/flameo_callables.py b/example-specs/task/nipype/fsl/flameo_callables.py
index f6edf1f8..7fb6a779 100644
--- a/example-specs/task/nipype/fsl/flameo_callables.py
+++ b/example-specs/task/nipype/fsl/flameo_callables.py
@@ -1 +1,164 @@
 """Module to put any functions that are referred to in the "callables" section of FLAMEO.yaml"""
+
+import os
+import re
+from glob import glob
+import attrs
+
+
+def pes_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["pes"]
+
+
+def res4d_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["res4d"]
+
+
+def copes_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["copes"]
+
+
+def var_copes_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["var_copes"]
+
+
+def zstats_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["zstats"]
+
+
+def tstats_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["tstats"]
+
+
+def zfstats_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["zfstats"]
+
+
+def fstats_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["fstats"]
+
+
+def mrefvars_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["mrefvars"]
+
+
+def tdof_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["tdof"]
+
+
+def weights_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["weights"]
+
+
+def stats_dir_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["stats_dir"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def human_order_sorted(l):
+    """Sorts string in human order (i.e. 'stat10' will go after 'stat2')"""
+
+    def atoi(text):
+        return int(text) if text.isdigit() else text
+
+    def natural_keys(text):
+        if isinstance(text, tuple):
+            text = text[0]
+        return [atoi(c) for c in re.split(r"(\d+)", text)]
+
+    return sorted(l, key=natural_keys)
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    pth = os.path.join(output_dir, inputs.log_dir)
+
+    pes = human_order_sorted(glob(os.path.join(pth, "pe[0-9]*.*")))
+    assert len(pes) >= 1, "No pe volumes generated by FSL Estimate"
+    outputs["pes"] = pes
+
+    res4d = human_order_sorted(glob(os.path.join(pth, "res4d.*")))
+    assert len(res4d) == 1, "No residual volume generated by FSL Estimate"
+    outputs["res4d"] = res4d[0]
+
+    copes = human_order_sorted(glob(os.path.join(pth, "cope[0-9]*.*")))
+    assert len(copes) >= 1, "No cope volumes generated by FSL CEstimate"
+    outputs["copes"] = copes
+
+    var_copes = human_order_sorted(glob(os.path.join(pth, "varcope[0-9]*.*")))
+    assert len(var_copes) >= 1, "No varcope volumes generated by FSL CEstimate"
+    outputs["var_copes"] = var_copes
+
+    zstats = human_order_sorted(glob(os.path.join(pth, "zstat[0-9]*.*")))
+    assert len(zstats) >= 1, "No zstat volumes generated by FSL CEstimate"
+    outputs["zstats"] = zstats
+
+    if inputs.f_con_file is not attrs.NOTHING:
+        zfstats = human_order_sorted(glob(os.path.join(pth, "zfstat[0-9]*.*")))
+        assert len(zfstats) >= 1, "No zfstat volumes generated by FSL CEstimate"
+        outputs["zfstats"] = zfstats
+
+        fstats = human_order_sorted(glob(os.path.join(pth, "fstat[0-9]*.*")))
+        assert len(fstats) >= 1, "No fstat volumes generated by FSL CEstimate"
+        outputs["fstats"] = fstats
+
+    tstats = human_order_sorted(glob(os.path.join(pth, "tstat[0-9]*.*")))
+    assert len(tstats) >= 1, "No tstat volumes generated by FSL CEstimate"
+    outputs["tstats"] = tstats
+
+    mrefs = human_order_sorted(
+        glob(os.path.join(pth, "mean_random_effects_var[0-9]*.*"))
+    )
+    assert len(mrefs) >= 1, "No mean random effects volumes generated by FLAMEO"
+    outputs["mrefvars"] = mrefs
+
+    tdof = human_order_sorted(glob(os.path.join(pth, "tdof_t[0-9]*.*")))
+    assert len(tdof) >= 1, "No T dof volumes generated by FLAMEO"
+    outputs["tdof"] = tdof
+
+    weights = human_order_sorted(glob(os.path.join(pth, "weights[0-9]*.*")))
+    assert len(weights) >= 1, "No weight volumes generated by FLAMEO"
+    outputs["weights"] = weights
+
+    outputs["stats_dir"] = pth
+
+    return outputs
diff --git a/example-specs/task/nipype/fsl/flirt_callables.py b/example-specs/task/nipype/fsl/flirt_callables.py
index 81dbf4aa..c81ecaba 100644
--- a/example-specs/task/nipype/fsl/flirt_callables.py
+++ b/example-specs/task/nipype/fsl/flirt_callables.py
@@ -1 +1,297 @@
 """Module to put any functions that are referred to in the "callables" section of FLIRT.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+from glob import glob
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+def out_matrix_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_matrix_file"]
+
+
+def out_log_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_log"]
+
+
+IFLOGGER = logging.getLogger("nipype.interface")
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+class Info(PackageInfo):
+    """
+    Handle FSL ``output_type`` and version information.
+
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
+
+    """
+
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
+
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
+
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
+
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
+
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
+
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
+
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
+
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
+
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
+
+        Returns a list of standard images if called without arguments.
+
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value + Info.output_type_to_ext(inputs.output_type)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
diff --git a/example-specs/task/nipype/fsl/fnirt.yaml b/example-specs/task/nipype/fsl/fnirt.yaml
index 94efb952..9c0f7e34 100644
--- a/example-specs/task/nipype/fsl/fnirt.yaml
+++ b/example-specs/task/nipype/fsl/fnirt.yaml
@@ -97,6 +97,9 @@ outputs:
     modulatedref_file: generic/file
     # type=file: file containing intensity modulated --ref
     # type=traitcompound|default=None: name of file for writing out intensity modulated --ref (for diagnostic purposes)
+    out_intensitymap_file: generic/file+list-of
+    # type=list: files containing info pertaining to intensity mapping
+    # type=traitcompound|default=None: name of files for writing information pertaining to intensity mapping
     warped_file: generic/file
     # type=file: warped image
     # type=file|default=<undefined>: name of output image
diff --git a/example-specs/task/nipype/fsl/fnirt_callables.py b/example-specs/task/nipype/fsl/fnirt_callables.py
index e48495e3..f754dc5f 100644
--- a/example-specs/task/nipype/fsl/fnirt_callables.py
+++ b/example-specs/task/nipype/fsl/fnirt_callables.py
@@ -1 +1,779 @@
 """Module to put any functions that are referred to in the "callables" section of FNIRT.yaml"""
+
+import attrs
+import logging
+from glob import glob
+import os
+import os.path as op
+
+
+def warped_file_default(inputs):
+    return _gen_filename("warped_file", inputs=inputs)
+
+
+def log_file_default(inputs):
+    return _gen_filename("log_file", inputs=inputs)
+
+
+def fieldcoeff_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["fieldcoeff_file"]
+
+
+def warped_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["warped_file"]
+
+
+def field_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["field_file"]
+
+
+def jacobian_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["jacobian_file"]
+
+
+def modulatedref_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["modulatedref_file"]
+
+
+def out_intensitymap_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_intensitymap_file"]
+
+
+def log_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["log_file"]
+
+
+IFLOGGER = logging.getLogger("nipype.interface")
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """
+    Handle FSL ``output_type`` and version information.
+
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
+
+    """
+
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
+
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
+
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
+
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
+
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
+
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
+
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
+
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
+
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
+
+        Returns a list of standard images if called without arguments.
+
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
+
+
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
+
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
+
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
+
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "fnirt"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+class FSLCommandInputSpec(CommandLineInputSpec):
+    """
+    Base Input Specification for all FSL Commands
+
+    All command support specifying FSLOUTPUTTYPE dynamically
+    via output_type.
+
+    Example
+    -------
+    fsl.ExtractRoi(tmin=42, tsize=1, output_type='NIFTI')
+    """
+
+    output_type = traits.Enum("NIFTI", list(Info.ftypes.keys()), desc="FSL output type")
+
+
+class TraitedSpec(BaseTraitedSpec):
+    """Create a subclass with strict traits.
+
+    This is used in 90% of the cases.
+    """
+
+    _ = traits.Disallow
+
+
+class FNIRTOutputSpec(TraitedSpec):
+    fieldcoeff_file = File(exists=True, desc="file with field coefficients")
+    warped_file = File(exists=True, desc="warped image")
+    field_file = File(desc="file with warp field")
+    jacobian_file = File(desc="file containing Jacobian of the field")
+    modulatedref_file = File(desc="file containing intensity modulated --ref")
+    out_intensitymap_file = traits.List(
+        File,
+        minlen=2,
+        maxlen=2,
+        desc="files containing info pertaining to intensity mapping",
+    )
+    log_file = File(desc="Name of log-file")
+
+
+class FNIRTInputSpec(FSLCommandInputSpec):
+    ref_file = File(
+        exists=True, argstr="--ref=%s", mandatory=True, desc="name of reference image"
+    )
+    in_file = File(
+        exists=True, argstr="--in=%s", mandatory=True, desc="name of input image"
+    )
+    affine_file = File(
+        exists=True, argstr="--aff=%s", desc="name of file containing affine transform"
+    )
+    inwarp_file = File(
+        exists=True,
+        argstr="--inwarp=%s",
+        desc="name of file containing initial non-linear warps",
+    )
+    in_intensitymap_file = traits.List(
+        File(exists=True),
+        argstr="--intin=%s",
+        copyfile=False,
+        minlen=1,
+        maxlen=2,
+        desc=(
+            "name of file/files containing "
+            "initial intensity mapping "
+            "usually generated by previous "
+            "fnirt run"
+        ),
+    )
+    fieldcoeff_file = traits.Either(
+        traits.Bool,
+        File,
+        argstr="--cout=%s",
+        desc="name of output file with field coefficients or true",
+    )
+    warped_file = File(
+        argstr="--iout=%s", desc="name of output image", genfile=True, hash_files=False
+    )
+    field_file = traits.Either(
+        traits.Bool,
+        File,
+        argstr="--fout=%s",
+        desc="name of output file with field or true",
+        hash_files=False,
+    )
+    jacobian_file = traits.Either(
+        traits.Bool,
+        File,
+        argstr="--jout=%s",
+        desc=(
+            "name of file for writing out the "
+            "Jacobian of the field (for "
+            "diagnostic or VBM purposes)"
+        ),
+        hash_files=False,
+    )
+    modulatedref_file = traits.Either(
+        traits.Bool,
+        File,
+        argstr="--refout=%s",
+        desc=(
+            "name of file for writing out "
+            "intensity modulated --ref (for "
+            "diagnostic purposes)"
+        ),
+        hash_files=False,
+    )
+    out_intensitymap_file = traits.Either(
+        traits.Bool,
+        File,
+        argstr="--intout=%s",
+        desc=(
+            "name of files for writing "
+            "information pertaining to "
+            "intensity mapping"
+        ),
+        hash_files=False,
+    )
+    log_file = File(
+        argstr="--logout=%s", desc="Name of log-file", genfile=True, hash_files=False
+    )
+    config_file = traits.Either(
+        traits.Enum("T1_2_MNI152_2mm", "FA_2_FMRIB58_1mm"),
+        File(exists=True),
+        argstr="--config=%s",
+        desc="Name of config file specifying command line arguments",
+    )
+    refmask_file = File(
+        exists=True,
+        argstr="--refmask=%s",
+        desc="name of file with mask in reference space",
+    )
+    inmask_file = File(
+        exists=True,
+        argstr="--inmask=%s",
+        desc="name of file with mask in input image space",
+    )
+    skip_refmask = traits.Bool(
+        argstr="--applyrefmask=0",
+        xor=["apply_refmask"],
+        desc="Skip specified refmask if set, default false",
+    )
+    skip_inmask = traits.Bool(
+        argstr="--applyinmask=0",
+        xor=["apply_inmask"],
+        desc="skip specified inmask if set, default false",
+    )
+    apply_refmask = traits.List(
+        traits.Enum(0, 1),
+        argstr="--applyrefmask=%s",
+        xor=["skip_refmask"],
+        desc=("list of iterations to use reference mask on (1 to use, 0 to " "skip)"),
+        sep=",",
+    )
+    apply_inmask = traits.List(
+        traits.Enum(0, 1),
+        argstr="--applyinmask=%s",
+        xor=["skip_inmask"],
+        desc="list of iterations to use input mask on (1 to use, 0 to skip)",
+        sep=",",
+    )
+    skip_implicit_ref_masking = traits.Bool(
+        argstr="--imprefm=0",
+        desc=("skip implicit masking  based on value in --ref image. " "Default = 0"),
+    )
+    skip_implicit_in_masking = traits.Bool(
+        argstr="--impinm=0",
+        desc=("skip implicit masking  based on value in --in image. " "Default = 0"),
+    )
+    refmask_val = traits.Float(
+        argstr="--imprefval=%f", desc="Value to mask out in --ref image. Default =0.0"
+    )
+    inmask_val = traits.Float(
+        argstr="--impinval=%f", desc="Value to mask out in --in image. Default =0.0"
+    )
+    max_nonlin_iter = traits.List(
+        traits.Int,
+        argstr="--miter=%s",
+        desc="Max # of non-linear iterations list, default [5, 5, 5, 5]",
+        sep=",",
+    )
+    subsampling_scheme = traits.List(
+        traits.Int,
+        argstr="--subsamp=%s",
+        desc="sub-sampling scheme, list, default [4, 2, 1, 1]",
+        sep=",",
+    )
+    warp_resolution = traits.Tuple(
+        traits.Int,
+        traits.Int,
+        traits.Int,
+        argstr="--warpres=%d,%d,%d",
+        desc=(
+            "(approximate) resolution (in mm) of warp basis in x-, y- and "
+            "z-direction, default 10, 10, 10"
+        ),
+    )
+    spline_order = traits.Int(
+        argstr="--splineorder=%d",
+        desc="Order of spline, 2->Qadratic spline, 3->Cubic spline. Default=3",
+    )
+    in_fwhm = traits.List(
+        traits.Int,
+        argstr="--infwhm=%s",
+        desc=(
+            "FWHM (in mm) of gaussian smoothing kernel for input volume, "
+            "default [6, 4, 2, 2]"
+        ),
+        sep=",",
+    )
+    ref_fwhm = traits.List(
+        traits.Int,
+        argstr="--reffwhm=%s",
+        desc=(
+            "FWHM (in mm) of gaussian smoothing kernel for ref volume, "
+            "default [4, 2, 0, 0]"
+        ),
+        sep=",",
+    )
+    regularization_model = traits.Enum(
+        "membrane_energy",
+        "bending_energy",
+        argstr="--regmod=%s",
+        desc=(
+            "Model for regularisation of warp-field [membrane_energy "
+            "bending_energy], default bending_energy"
+        ),
+    )
+    regularization_lambda = traits.List(
+        traits.Float,
+        argstr="--lambda=%s",
+        desc=(
+            "Weight of regularisation, default depending on --ssqlambda and "
+            "--regmod switches. See user documentation."
+        ),
+        sep=",",
+    )
+    skip_lambda_ssq = traits.Bool(
+        argstr="--ssqlambda=0",
+        desc="If true, lambda is not weighted by current ssq, default false",
+    )
+    jacobian_range = traits.Tuple(
+        traits.Float,
+        traits.Float,
+        argstr="--jacrange=%f,%f",
+        desc="Allowed range of Jacobian determinants, default 0.01, 100.0",
+    )
+    derive_from_ref = traits.Bool(
+        argstr="--refderiv",
+        desc=("If true, ref image is used to calculate derivatives. " "Default false"),
+    )
+    intensity_mapping_model = traits.Enum(
+        "none",
+        "global_linear",
+        "global_non_linear",
+        "local_linear",
+        "global_non_linear_with_bias",
+        "local_non_linear",
+        argstr="--intmod=%s",
+        desc="Model for intensity-mapping",
+    )
+    intensity_mapping_order = traits.Int(
+        argstr="--intorder=%d",
+        desc="Order of poynomial for mapping intensities, default 5",
+    )
+    biasfield_resolution = traits.Tuple(
+        traits.Int,
+        traits.Int,
+        traits.Int,
+        argstr="--biasres=%d,%d,%d",
+        desc=(
+            "Resolution (in mm) of bias-field modelling local intensities, "
+            "default 50, 50, 50"
+        ),
+    )
+    bias_regularization_lambda = traits.Float(
+        argstr="--biaslambda=%f",
+        desc="Weight of regularisation for bias-field, default 10000",
+    )
+    skip_intensity_mapping = traits.Bool(
+        argstr="--estint=0",
+        xor=["apply_intensity_mapping"],
+        desc="Skip estimate intensity-mapping default false",
+    )
+    apply_intensity_mapping = traits.List(
+        traits.Enum(0, 1),
+        argstr="--estint=%s",
+        xor=["skip_intensity_mapping"],
+        desc=(
+            "List of subsampling levels to apply intensity mapping for "
+            "(0 to skip, 1 to apply)"
+        ),
+        sep=",",
+    )
+    hessian_precision = traits.Enum(
+        "double",
+        "float",
+        argstr="--numprec=%s",
+        desc=("Precision for representing Hessian, double or float. " "Default double"),
+    )
+
+
+class FNIRT(FSLCommand):
+    """FSL FNIRT wrapper for non-linear registration
+
+    For complete details, see the `FNIRT Documentation.
+    <https://fsl.fmrib.ox.ac.uk/fsl/fslwiki/FNIRT>`_
+
+    Examples
+    --------
+    >>> from nipype.interfaces import fsl
+    >>> from nipype.testing import example_data
+    >>> fnt = fsl.FNIRT(affine_file=example_data('trans.mat'))
+    >>> res = fnt.run(ref_file=example_data('mni.nii', in_file=example_data('structural.nii')) #doctest: +SKIP
+
+    T1 -> Mni153
+
+    >>> from nipype.interfaces import fsl
+    >>> fnirt_mprage = fsl.FNIRT()
+    >>> fnirt_mprage.inputs.in_fwhm = [8, 4, 2, 2]
+    >>> fnirt_mprage.inputs.subsampling_scheme = [4, 2, 1, 1]
+
+    Specify the resolution of the warps
+
+    >>> fnirt_mprage.inputs.warp_resolution = (6, 6, 6)
+    >>> res = fnirt_mprage.run(in_file='structural.nii', ref_file='mni.nii', warped_file='warped.nii', fieldcoeff_file='fieldcoeff.nii')#doctest: +SKIP
+
+    We can check the command line and confirm that it's what we expect.
+
+    >>> fnirt_mprage.cmdline  #doctest: +SKIP
+    'fnirt --cout=fieldcoeff.nii --in=structural.nii --infwhm=8,4,2,2 --ref=mni.nii --subsamp=4,2,1,1 --warpres=6,6,6 --iout=warped.nii'
+
+    """
+
+    _cmd = "fnirt"
+    input_spec = FNIRTInputSpec
+    output_spec = FNIRTOutputSpec
+
+    filemap = {
+        "warped_file": "warped",
+        "field_file": "field",
+        "jacobian_file": "field_jacobian",
+        "modulatedref_file": "modulated",
+        "out_intensitymap_file": "intmap",
+        "log_file": "log.txt",
+        "fieldcoeff_file": "fieldwarp",
+    }
+
+    def _list_outputs(self):
+        outputs = self.output_spec().get()
+        for key, suffix in list(self.filemap.items()):
+            inval = getattr(self.inputs, key)
+            change_ext = True
+            if key in ["warped_file", "log_file"]:
+                if suffix.endswith(".txt"):
+                    change_ext = False
+                if inval is not attrs.NOTHING:
+                    outputs[key] = os.path.abspath(inval)
+                else:
+                    outputs[key] = self._gen_fname(
+                        self.inputs.in_file, suffix="_" + suffix, change_ext=change_ext
+                    )
+            elif inval is not attrs.NOTHING:
+                if isinstance(inval, bool):
+                    if inval:
+                        outputs[key] = self._gen_fname(
+                            self.inputs.in_file,
+                            suffix="_" + suffix,
+                            change_ext=change_ext,
+                        )
+                else:
+                    outputs[key] = os.path.abspath(inval)
+
+            if key == "out_intensitymap_file" and (outputs[key] is not attrs.NOTHING):
+                basename = FNIRT.intensitymap_file_basename(outputs[key])
+                outputs[key] = [outputs[key], "%s.txt" % basename]
+        return outputs
+
+    def _format_arg(self, name, spec, value):
+        if name in ("in_intensitymap_file", "out_intensitymap_file"):
+            if name == "out_intensitymap_file":
+                value = self._list_outputs()[name]
+            value = [FNIRT.intensitymap_file_basename(v) for v in value]
+            assert len(set(value)) == 1, "Found different basenames for {}: {}".format(
+                name, value
+            )
+            return spec.argstr % value[0]
+        if name in list(self.filemap.keys()):
+            return spec.argstr % self._list_outputs()[name]
+        return super(FNIRT, self)._format_arg(name, spec, value)
+
+    def _gen_filename(self, name):
+        if name in ["warped_file", "log_file"]:
+            return self._list_outputs()[name]
+        return None
+
+    def write_config(self, configfile):
+        """Writes out currently set options to specified config file
+
+        XX TODO : need to figure out how the config file is written
+
+        Parameters
+        ----------
+        configfile : /path/to/configfile
+        """
+        try:
+            fid = open(configfile, "w+")
+        except IOError:
+            print("unable to create config_file %s" % (configfile))
+
+        for item in list(self.inputs.get().items()):
+            fid.write("%s\n" % (item))
+        fid.close()
+
+    @classmethod
+    def intensitymap_file_basename(cls, f):
+        """Removes valid intensitymap extensions from `f`, returning a basename
+        that can refer to both intensitymap files.
+        """
+        for ext in list(Info.ftypes.values()) + [".txt"]:
+            if f.endswith(ext):
+                return f[: -len(ext)]
+        # TODO consider warning for this case
+        return f
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name in ["warped_file", "log_file"]:
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )[name]
+    return None
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    for key, suffix in list(filemap.items()):
+        inval = getattr(inputs, key)
+        change_ext = True
+        if key in ["warped_file", "log_file"]:
+            if suffix.endswith(".txt"):
+                change_ext = False
+            if inval is not attrs.NOTHING:
+                outputs[key] = os.path.abspath(inval)
+            else:
+                outputs[key] = _gen_fname(
+                    inputs.in_file,
+                    suffix="_" + suffix,
+                    change_ext=change_ext,
+                    inputs=inputs,
+                    stdout=stdout,
+                    stderr=stderr,
+                    output_dir=output_dir,
+                )
+        elif inval is not attrs.NOTHING:
+            if isinstance(inval, bool):
+                if inval:
+                    outputs[key] = _gen_fname(
+                        inputs.in_file,
+                        suffix="_" + suffix,
+                        change_ext=change_ext,
+                        inputs=inputs,
+                        stdout=stdout,
+                        stderr=stderr,
+                        output_dir=output_dir,
+                    )
+            else:
+                outputs[key] = os.path.abspath(inval)
+
+        if key == "out_intensitymap_file" and (outputs[key] is not attrs.NOTHING):
+            basename = FNIRT.intensitymap_file_basename(outputs[key])
+            outputs[key] = [outputs[key], "%s.txt" % basename]
+    return outputs
diff --git a/example-specs/task/nipype/fsl/fugue_callables.py b/example-specs/task/nipype/fsl/fugue_callables.py
index 142154ca..b5ec9ab6 100644
--- a/example-specs/task/nipype/fsl/fugue_callables.py
+++ b/example-specs/task/nipype/fsl/fugue_callables.py
@@ -1 +1,304 @@
 """Module to put any functions that are referred to in the "callables" section of FUGUE.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+from glob import glob
+
+
+def unwarped_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["unwarped_file"]
+
+
+def warped_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["warped_file"]
+
+
+def shift_out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["shift_out_file"]
+
+
+def fmap_out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["fmap_out_file"]
+
+
+IFLOGGER = logging.getLogger("nipype.interface")
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+class Info(PackageInfo):
+    """
+    Handle FSL ``output_type`` and version information.
+
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
+
+    """
+
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
+
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
+
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
+
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
+
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
+
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
+
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
+
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
+
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
+
+        Returns a list of standard images if called without arguments.
+
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value + Info.output_type_to_ext(inputs.output_type)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
diff --git a/example-specs/task/nipype/fsl/glm.yaml b/example-specs/task/nipype/fsl/glm.yaml
index 0e402987..e12cb30f 100644
--- a/example-specs/task/nipype/fsl/glm.yaml
+++ b/example-specs/task/nipype/fsl/glm.yaml
@@ -77,9 +77,32 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    out_cope: generic/file+list-of
+    # type=outputmultiobject: output file name for COPEs (either as text file or image)
+    # type=file|default=<undefined>: output file name for COPE (either as txt or image
+    out_data: generic/file+list-of
+    # type=outputmultiobject: output file for preprocessed data
+    out_f: generic/file+list-of
+    # type=outputmultiobject: output file name for F-value of full model fit
     out_file: generic/file
     # type=file: file name of GLM parameters (if generated)
     # type=file|default=<undefined>: filename for GLM parameter estimates (GLM betas)
+    out_p: generic/file+list-of
+    # type=outputmultiobject: output file name for p-values of Z-stats (either as text file or image)
+    out_pf: generic/file+list-of
+    # type=outputmultiobject: output file name for p-value for full model fit
+    out_res: generic/file+list-of
+    # type=outputmultiobject: output file name for residuals
+    out_sigsq: generic/file+list-of
+    # type=outputmultiobject: output file name for residual noise variance sigma-square
+    out_t: generic/file+list-of
+    # type=outputmultiobject: output file name for t-stats (either as text file or image)
+    out_varcb: generic/file+list-of
+    # type=outputmultiobject: output file name for variance of COPEs
+    out_vnscales: generic/file+list-of
+    # type=outputmultiobject: output file name for scaling factors for variance normalisation
+    out_z: generic/file+list-of
+    # type=outputmultiobject: output file name for COPEs (either as text file or image)
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/fsl/glm_callables.py b/example-specs/task/nipype/fsl/glm_callables.py
index c1050522..5e72d07a 100644
--- a/example-specs/task/nipype/fsl/glm_callables.py
+++ b/example-specs/task/nipype/fsl/glm_callables.py
@@ -1 +1,401 @@
 """Module to put any functions that are referred to in the "callables" section of GLM.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+from glob import glob
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+def out_cope_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_cope"]
+
+
+def out_z_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_z"]
+
+
+def out_t_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_t"]
+
+
+def out_p_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_p"]
+
+
+def out_f_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_f"]
+
+
+def out_pf_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_pf"]
+
+
+def out_res_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_res"]
+
+
+def out_varcb_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_varcb"]
+
+
+def out_sigsq_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_sigsq"]
+
+
+def out_data_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_data"]
+
+
+def out_vnscales_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_vnscales"]
+
+
+IFLOGGER = logging.getLogger("nipype.interface")
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+class Info(PackageInfo):
+    """
+    Handle FSL ``output_type`` and version information.
+
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
+
+    """
+
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
+
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
+
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
+
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
+
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
+
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
+
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
+
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
+
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
+
+        Returns a list of standard images if called without arguments.
+
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value + Info.output_type_to_ext(inputs.output_type)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def nipype_interfaces_fsl__FSLCommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_fsl__FSLCommand___list_outputs()
+
+    if inputs.out_cope is not attrs.NOTHING:
+        outputs["out_cope"] = os.path.abspath(inputs.out_cope)
+
+    if inputs.out_z_name is not attrs.NOTHING:
+        outputs["out_z"] = os.path.abspath(inputs.out_z_name)
+
+    if inputs.out_t_name is not attrs.NOTHING:
+        outputs["out_t"] = os.path.abspath(inputs.out_t_name)
+
+    if inputs.out_p_name is not attrs.NOTHING:
+        outputs["out_p"] = os.path.abspath(inputs.out_p_name)
+
+    if inputs.out_f_name is not attrs.NOTHING:
+        outputs["out_f"] = os.path.abspath(inputs.out_f_name)
+
+    if inputs.out_pf_name is not attrs.NOTHING:
+        outputs["out_pf"] = os.path.abspath(inputs.out_pf_name)
+
+    if inputs.out_res_name is not attrs.NOTHING:
+        outputs["out_res"] = os.path.abspath(inputs.out_res_name)
+
+    if inputs.out_varcb_name is not attrs.NOTHING:
+        outputs["out_varcb"] = os.path.abspath(inputs.out_varcb_name)
+
+    if inputs.out_sigsq_name is not attrs.NOTHING:
+        outputs["out_sigsq"] = os.path.abspath(inputs.out_sigsq_name)
+
+    if inputs.out_data_name is not attrs.NOTHING:
+        outputs["out_data"] = os.path.abspath(inputs.out_data_name)
+
+    if inputs.out_vnscales_name is not attrs.NOTHING:
+        outputs["out_vnscales"] = os.path.abspath(inputs.out_vnscales_name)
+
+    return outputs
diff --git a/example-specs/task/nipype/fsl/ica__aroma_callables.py b/example-specs/task/nipype/fsl/ica__aroma_callables.py
index 76cdd5ab..88339edb 100644
--- a/example-specs/task/nipype/fsl/ica__aroma_callables.py
+++ b/example-specs/task/nipype/fsl/ica__aroma_callables.py
@@ -1 +1,44 @@
 """Module to put any functions that are referred to in the "callables" section of ICA_AROMA.yaml"""
+
+import os
+
+
+def aggr_denoised_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["aggr_denoised_file"]
+
+
+def nonaggr_denoised_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["nonaggr_denoised_file"]
+
+
+def out_dir_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_dir"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_dir"] = os.path.abspath(inputs.out_dir)
+    out_dir = outputs["out_dir"]
+
+    if inputs.denoise_type in ("aggr", "both"):
+        outputs["aggr_denoised_file"] = os.path.join(
+            out_dir, "denoised_func_data_aggr.nii.gz"
+        )
+    if inputs.denoise_type in ("nonaggr", "both"):
+        outputs["nonaggr_denoised_file"] = os.path.join(
+            out_dir, "denoised_func_data_nonaggr.nii.gz"
+        )
+    return outputs
diff --git a/example-specs/task/nipype/fsl/image_maths_callables.py b/example-specs/task/nipype/fsl/image_maths_callables.py
index 831ceab4..9d22e275 100644
--- a/example-specs/task/nipype/fsl/image_maths_callables.py
+++ b/example-specs/task/nipype/fsl/image_maths_callables.py
@@ -1 +1,287 @@
 """Module to put any functions that are referred to in the "callables" section of ImageMaths.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+from glob import glob
+
+
+def out_file_default(inputs):
+    return _gen_filename("out_file", inputs=inputs)
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+IFLOGGER = logging.getLogger("nipype.interface")
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """
+    Handle FSL ``output_type`` and version information.
+
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
+
+    """
+
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
+
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
+
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
+
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
+
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
+
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
+
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
+
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
+
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
+
+        Returns a list of standard images if called without arguments.
+
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
+
+
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
+
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
+
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
+
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "fslmaths"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )[name]
+    return None
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    suffix = "_maths"  # ohinds: build suffix
+    if inputs.suffix is not attrs.NOTHING:
+        suffix = inputs.suffix
+    outputs = {}
+    outputs["out_file"] = inputs.out_file
+    if outputs["out_file"] is attrs.NOTHING:
+        outputs["out_file"] = _gen_fname(
+            inputs.in_file,
+            suffix=suffix,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    outputs["out_file"] = os.path.abspath(outputs["out_file"])
+    return outputs
diff --git a/example-specs/task/nipype/fsl/image_meants_callables.py b/example-specs/task/nipype/fsl/image_meants_callables.py
index 5132ce61..671db373 100644
--- a/example-specs/task/nipype/fsl/image_meants_callables.py
+++ b/example-specs/task/nipype/fsl/image_meants_callables.py
@@ -1 +1,286 @@
 """Module to put any functions that are referred to in the "callables" section of ImageMeants.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+from glob import glob
+
+
+def out_file_default(inputs):
+    return _gen_filename("out_file", inputs=inputs)
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+IFLOGGER = logging.getLogger("nipype.interface")
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """
+    Handle FSL ``output_type`` and version information.
+
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
+
+    """
+
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
+
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
+
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
+
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
+
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
+
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
+
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
+
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
+
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
+
+        Returns a list of standard images if called without arguments.
+
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
+
+
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
+
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
+
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
+
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "fslmeants"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )[name]
+    return None
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = inputs.out_file
+    if outputs["out_file"] is attrs.NOTHING:
+        outputs["out_file"] = _gen_fname(
+            inputs.in_file,
+            suffix="_ts",
+            ext=".txt",
+            change_ext=True,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    outputs["out_file"] = os.path.abspath(outputs["out_file"])
+    return outputs
diff --git a/example-specs/task/nipype/fsl/image_stats.yaml b/example-specs/task/nipype/fsl/image_stats.yaml
index 748e5eb9..131f2817 100644
--- a/example-specs/task/nipype/fsl/image_stats.yaml
+++ b/example-specs/task/nipype/fsl/image_stats.yaml
@@ -57,6 +57,8 @@ outputs:
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
+    out_stat: out_stat_callable
+    # type=any: stats output
   templates:
   # dict[str, str] - `output_file_template` values to be provided to output fields
   requirements:
diff --git a/example-specs/task/nipype/fsl/image_stats_callables.py b/example-specs/task/nipype/fsl/image_stats_callables.py
index ed9ee2e9..2b939a04 100644
--- a/example-specs/task/nipype/fsl/image_stats_callables.py
+++ b/example-specs/task/nipype/fsl/image_stats_callables.py
@@ -1 +1,283 @@
 """Module to put any functions that are referred to in the "callables" section of ImageStats.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+from glob import glob
+
+
+def out_stat_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_stat"]
+
+
+IFLOGGER = logging.getLogger("nipype.interface")
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+class Info(PackageInfo):
+    """
+    Handle FSL ``output_type`` and version information.
+
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
+
+    """
+
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
+
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
+
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
+
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
+
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
+
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
+
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
+
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
+
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
+
+        Returns a list of standard images if called without arguments.
+
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value + Info.output_type_to_ext(inputs.output_type)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
diff --git a/example-specs/task/nipype/fsl/inv_warp_callables.py b/example-specs/task/nipype/fsl/inv_warp_callables.py
index 88c75fd3..76144fbe 100644
--- a/example-specs/task/nipype/fsl/inv_warp_callables.py
+++ b/example-specs/task/nipype/fsl/inv_warp_callables.py
@@ -1 +1,283 @@
 """Module to put any functions that are referred to in the "callables" section of InvWarp.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+from glob import glob
+
+
+def inverse_warp_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["inverse_warp"]
+
+
+IFLOGGER = logging.getLogger("nipype.interface")
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+class Info(PackageInfo):
+    """
+    Handle FSL ``output_type`` and version information.
+
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
+
+    """
+
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
+
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
+
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
+
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
+
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
+
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
+
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
+
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
+
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
+
+        Returns a list of standard images if called without arguments.
+
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value + Info.output_type_to_ext(inputs.output_type)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
diff --git a/example-specs/task/nipype/fsl/isotropic_smooth_callables.py b/example-specs/task/nipype/fsl/isotropic_smooth_callables.py
index b5f489b7..54bb1029 100644
--- a/example-specs/task/nipype/fsl/isotropic_smooth_callables.py
+++ b/example-specs/task/nipype/fsl/isotropic_smooth_callables.py
@@ -1 +1,284 @@
 """Module to put any functions that are referred to in the "callables" section of IsotropicSmooth.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+from glob import glob
+
+
+def out_file_default(inputs):
+    return _gen_filename("out_file", inputs=inputs)
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+IFLOGGER = logging.getLogger("nipype.interface")
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """
+    Handle FSL ``output_type`` and version information.
+
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
+
+    """
+
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
+
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
+
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
+
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
+
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
+
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
+
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
+
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
+
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
+
+        Returns a list of standard images if called without arguments.
+
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
+
+
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
+
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
+
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
+
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "fslmaths"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )["out_file"]
+    return None
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = inputs.out_file
+    if inputs.out_file is attrs.NOTHING:
+        outputs["out_file"] = _gen_fname(
+            inputs.in_file,
+            suffix=_suffix,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    outputs["out_file"] = os.path.abspath(outputs["out_file"])
+    return outputs
diff --git a/example-specs/task/nipype/fsl/l2_model_callables.py b/example-specs/task/nipype/fsl/l2_model_callables.py
index abebe77c..feb23eef 100644
--- a/example-specs/task/nipype/fsl/l2_model_callables.py
+++ b/example-specs/task/nipype/fsl/l2_model_callables.py
@@ -1 +1,28 @@
 """Module to put any functions that are referred to in the "callables" section of L2Model.yaml"""
+
+
+def design_mat_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["design_mat"]
+
+
+def design_con_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["design_con"]
+
+
+def design_grp_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["design_grp"]
+
+
+def _gen_filename(field, inputs, output_dir, stdout, stderr):
+    raise NotImplementedError(
+        "Could not find '_gen_filename' method in nipype.interfaces.fsl.model.L2Model"
+    )
diff --git a/example-specs/task/nipype/fsl/level_1_design.yaml b/example-specs/task/nipype/fsl/level_1_design.yaml
index 97fe32d5..b96cab0b 100644
--- a/example-specs/task/nipype/fsl/level_1_design.yaml
+++ b/example-specs/task/nipype/fsl/level_1_design.yaml
@@ -44,6 +44,8 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    fsf_files: generic/file+list-of
+    # type=outputmultiobject: FSL feat specification files
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/fsl/level_1_design_callables.py b/example-specs/task/nipype/fsl/level_1_design_callables.py
index 936f279e..2df671c8 100644
--- a/example-specs/task/nipype/fsl/level_1_design_callables.py
+++ b/example-specs/task/nipype/fsl/level_1_design_callables.py
@@ -1 +1,21 @@
 """Module to put any functions that are referred to in the "callables" section of Level1Design.yaml"""
+
+
+def fsf_files_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["fsf_files"]
+
+
+def ev_files_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["ev_files"]
+
+
+def _gen_filename(field, inputs, output_dir, stdout, stderr):
+    raise NotImplementedError(
+        "Could not find '_gen_filename' method in nipype.interfaces.fsl.model.Level1Design"
+    )
diff --git a/example-specs/task/nipype/fsl/make_dyadic_vectors_callables.py b/example-specs/task/nipype/fsl/make_dyadic_vectors_callables.py
index 8e6285b5..f4fb2ce8 100644
--- a/example-specs/task/nipype/fsl/make_dyadic_vectors_callables.py
+++ b/example-specs/task/nipype/fsl/make_dyadic_vectors_callables.py
@@ -1 +1,287 @@
 """Module to put any functions that are referred to in the "callables" section of MakeDyadicVectors.yaml"""
+
+import os
+from glob import glob
+import os.path as op
+import logging
+
+
+def dyads_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["dyads"]
+
+
+def dispersion_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["dispersion"]
+
+
+IFLOGGER = logging.getLogger("nipype.interface")
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """
+    Handle FSL ``output_type`` and version information.
+
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
+
+    """
+
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
+
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
+
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
+
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
+
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
+
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
+
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
+
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
+
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
+
+        Returns a list of standard images if called without arguments.
+
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
+
+
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
+
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
+
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
+
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "make_dyadic_vectors"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["dyads"] = _gen_fname(
+        inputs.output,
+        inputs=inputs,
+        stdout=stdout,
+        stderr=stderr,
+        output_dir=output_dir,
+    )
+    outputs["dispersion"] = _gen_fname(
+        inputs.output,
+        suffix="_dispersion",
+        inputs=inputs,
+        stdout=stdout,
+        stderr=stderr,
+        output_dir=output_dir,
+    )
+
+    return outputs
diff --git a/example-specs/task/nipype/fsl/maths_command_callables.py b/example-specs/task/nipype/fsl/maths_command_callables.py
index a952571f..7c79ed84 100644
--- a/example-specs/task/nipype/fsl/maths_command_callables.py
+++ b/example-specs/task/nipype/fsl/maths_command_callables.py
@@ -1 +1,284 @@
 """Module to put any functions that are referred to in the "callables" section of MathsCommand.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+from glob import glob
+
+
+def out_file_default(inputs):
+    return _gen_filename("out_file", inputs=inputs)
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+IFLOGGER = logging.getLogger("nipype.interface")
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """
+    Handle FSL ``output_type`` and version information.
+
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
+
+    """
+
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
+
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
+
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
+
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
+
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
+
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
+
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
+
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
+
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
+
+        Returns a list of standard images if called without arguments.
+
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
+
+
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
+
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
+
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
+
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "fslmaths"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )["out_file"]
+    return None
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = inputs.out_file
+    if inputs.out_file is attrs.NOTHING:
+        outputs["out_file"] = _gen_fname(
+            inputs.in_file,
+            suffix=_suffix,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    outputs["out_file"] = os.path.abspath(outputs["out_file"])
+    return outputs
diff --git a/example-specs/task/nipype/fsl/max_image_callables.py b/example-specs/task/nipype/fsl/max_image_callables.py
index 2c2f6c1c..281f7bca 100644
--- a/example-specs/task/nipype/fsl/max_image_callables.py
+++ b/example-specs/task/nipype/fsl/max_image_callables.py
@@ -1 +1,284 @@
 """Module to put any functions that are referred to in the "callables" section of MaxImage.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+from glob import glob
+
+
+def out_file_default(inputs):
+    return _gen_filename("out_file", inputs=inputs)
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+IFLOGGER = logging.getLogger("nipype.interface")
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """
+    Handle FSL ``output_type`` and version information.
+
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
+
+    """
+
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
+
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
+
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
+
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
+
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
+
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
+
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
+
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
+
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
+
+        Returns a list of standard images if called without arguments.
+
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
+
+
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
+
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
+
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
+
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "fslmaths"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )["out_file"]
+    return None
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = inputs.out_file
+    if inputs.out_file is attrs.NOTHING:
+        outputs["out_file"] = _gen_fname(
+            inputs.in_file,
+            suffix=_suffix,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    outputs["out_file"] = os.path.abspath(outputs["out_file"])
+    return outputs
diff --git a/example-specs/task/nipype/fsl/maxn_image_callables.py b/example-specs/task/nipype/fsl/maxn_image_callables.py
index 3c27500d..b565d43c 100644
--- a/example-specs/task/nipype/fsl/maxn_image_callables.py
+++ b/example-specs/task/nipype/fsl/maxn_image_callables.py
@@ -1 +1,284 @@
 """Module to put any functions that are referred to in the "callables" section of MaxnImage.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+from glob import glob
+
+
+def out_file_default(inputs):
+    return _gen_filename("out_file", inputs=inputs)
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+IFLOGGER = logging.getLogger("nipype.interface")
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """
+    Handle FSL ``output_type`` and version information.
+
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
+
+    """
+
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
+
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
+
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
+
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
+
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
+
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
+
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
+
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
+
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
+
+        Returns a list of standard images if called without arguments.
+
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
+
+
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
+
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
+
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
+
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "fslmaths"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )["out_file"]
+    return None
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = inputs.out_file
+    if inputs.out_file is attrs.NOTHING:
+        outputs["out_file"] = _gen_fname(
+            inputs.in_file,
+            suffix=_suffix,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    outputs["out_file"] = os.path.abspath(outputs["out_file"])
+    return outputs
diff --git a/example-specs/task/nipype/fsl/mcflirt.yaml b/example-specs/task/nipype/fsl/mcflirt.yaml
index 6f578245..93705796 100644
--- a/example-specs/task/nipype/fsl/mcflirt.yaml
+++ b/example-specs/task/nipype/fsl/mcflirt.yaml
@@ -58,6 +58,8 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    mat_file: generic/file+list-of
+    # type=outputmultiobject: transformation matrices
     mean_img: generic/file
     # type=file: mean timeseries image (if mean_vol=True)
     out_file: medimage/nifti1
@@ -65,6 +67,8 @@ outputs:
     # type=file|default=<undefined>: file to write
     par_file: generic/file
     # type=file: text-file with motion parameters
+    rms_files: generic/file+list-of
+    # type=outputmultiobject: absolute and relative displacement parameters
     std_img: generic/file
     # type=file: standard deviation image
     variance_img: generic/file
diff --git a/example-specs/task/nipype/fsl/mcflirt_callables.py b/example-specs/task/nipype/fsl/mcflirt_callables.py
index d8aee9f1..7aa37b80 100644
--- a/example-specs/task/nipype/fsl/mcflirt_callables.py
+++ b/example-specs/task/nipype/fsl/mcflirt_callables.py
@@ -1 +1,419 @@
 """Module to put any functions that are referred to in the "callables" section of MCFLIRT.yaml"""
+
+import os
+from nibabel.loadsave import load
+import attrs
+import os.path as op
+import logging
+from glob import glob
+
+
+def out_file_default(inputs):
+    return _gen_filename("out_file", inputs=inputs)
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+def variance_img_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["variance_img"]
+
+
+def std_img_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["std_img"]
+
+
+def mean_img_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["mean_img"]
+
+
+def par_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["par_file"]
+
+
+def mat_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["mat_file"]
+
+
+def rms_files_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["rms_files"]
+
+
+IFLOGGER = logging.getLogger("nipype.interface")
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """
+    Handle FSL ``output_type`` and version information.
+
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
+
+    """
+
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
+
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
+
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
+
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
+
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
+
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
+
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
+
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
+
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
+
+        Returns a list of standard images if called without arguments.
+
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
+
+
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
+
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
+
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
+
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "mcflirt"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+def _gen_outfilename(inputs=None, stdout=None, stderr=None, output_dir=None):
+    out_file = inputs.out_file
+    if out_file is not attrs.NOTHING:
+        out_file = os.path.realpath(out_file)
+    if (out_file is attrs.NOTHING) and (inputs.in_file is not attrs.NOTHING):
+        out_file = _gen_fname(
+            inputs.in_file,
+            suffix="_mcf",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    return os.path.abspath(out_file)
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _gen_outfilename(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )
+    return None
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+
+    outputs["out_file"] = _gen_outfilename(
+        inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+    )
+    output_dir = os.path.dirname(outputs["out_file"])
+
+    if (inputs.stats_imgs is not attrs.NOTHING) and inputs.stats_imgs:
+        if LooseVersion(Info.version()) < LooseVersion("6.0.0"):
+            # FSL <6.0 outputs have .nii.gz_variance.nii.gz as extension
+            outputs["variance_img"] = _gen_fname(
+                outputs["out_file"] + "_variance.ext",
+                cwd=output_dir,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            outputs["std_img"] = _gen_fname(
+                outputs["out_file"] + "_sigma.ext",
+                cwd=output_dir,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+        else:
+            outputs["variance_img"] = _gen_fname(
+                outputs["out_file"],
+                suffix="_variance",
+                cwd=output_dir,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            outputs["std_img"] = _gen_fname(
+                outputs["out_file"],
+                suffix="_sigma",
+                cwd=output_dir,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+
+    # The mean image created if -stats option is specified ('meanvol')
+    # is missing the top and bottom slices. Therefore we only expose the
+    # mean image created by -meanvol option ('mean_reg') which isn't
+    # corrupted.
+    # Note that the same problem holds for the std and variance image.
+
+    if (inputs.mean_vol is not attrs.NOTHING) and inputs.mean_vol:
+        if LooseVersion(Info.version()) < LooseVersion("6.0.0"):
+            # FSL <6.0 outputs have .nii.gz_mean_img.nii.gz as extension
+            outputs["mean_img"] = _gen_fname(
+                outputs["out_file"] + "_mean_reg.ext",
+                cwd=output_dir,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+        else:
+            outputs["mean_img"] = _gen_fname(
+                outputs["out_file"],
+                suffix="_mean_reg",
+                cwd=output_dir,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+
+    if (inputs.save_mats is not attrs.NOTHING) and inputs.save_mats:
+        _, filename = os.path.split(outputs["out_file"])
+        matpathname = os.path.join(output_dir, filename + ".mat")
+        _, _, _, timepoints = load(inputs.in_file).shape
+        outputs["mat_file"] = []
+        for t in range(timepoints):
+            outputs["mat_file"].append(os.path.join(matpathname, "MAT_%04d" % t))
+    if (inputs.save_plots is not attrs.NOTHING) and inputs.save_plots:
+        # Note - if e.g. out_file has .nii.gz, you get .nii.gz.par,
+        # which is what mcflirt does!
+        outputs["par_file"] = outputs["out_file"] + ".par"
+    if (inputs.save_rms is not attrs.NOTHING) and inputs.save_rms:
+        outfile = outputs["out_file"]
+        outputs["rms_files"] = [outfile + "_abs.rms", outfile + "_rel.rms"]
+    return outputs
diff --git a/example-specs/task/nipype/fsl/mean_image_callables.py b/example-specs/task/nipype/fsl/mean_image_callables.py
index bc7a08f8..df6430e9 100644
--- a/example-specs/task/nipype/fsl/mean_image_callables.py
+++ b/example-specs/task/nipype/fsl/mean_image_callables.py
@@ -1 +1,284 @@
 """Module to put any functions that are referred to in the "callables" section of MeanImage.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+from glob import glob
+
+
+def out_file_default(inputs):
+    return _gen_filename("out_file", inputs=inputs)
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+IFLOGGER = logging.getLogger("nipype.interface")
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """
+    Handle FSL ``output_type`` and version information.
+
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
+
+    """
+
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
+
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
+
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
+
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
+
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
+
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
+
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
+
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
+
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
+
+        Returns a list of standard images if called without arguments.
+
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
+
+
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
+
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
+
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
+
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "fslmaths"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )["out_file"]
+    return None
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = inputs.out_file
+    if inputs.out_file is attrs.NOTHING:
+        outputs["out_file"] = _gen_fname(
+            inputs.in_file,
+            suffix=_suffix,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    outputs["out_file"] = os.path.abspath(outputs["out_file"])
+    return outputs
diff --git a/example-specs/task/nipype/fsl/median_image_callables.py b/example-specs/task/nipype/fsl/median_image_callables.py
index 492c6bf4..2137005b 100644
--- a/example-specs/task/nipype/fsl/median_image_callables.py
+++ b/example-specs/task/nipype/fsl/median_image_callables.py
@@ -1 +1,284 @@
 """Module to put any functions that are referred to in the "callables" section of MedianImage.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+from glob import glob
+
+
+def out_file_default(inputs):
+    return _gen_filename("out_file", inputs=inputs)
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+IFLOGGER = logging.getLogger("nipype.interface")
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """
+    Handle FSL ``output_type`` and version information.
+
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
+
+    """
+
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
+
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
+
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
+
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
+
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
+
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
+
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
+
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
+
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
+
+        Returns a list of standard images if called without arguments.
+
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
+
+
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
+
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
+
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
+
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "fslmaths"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )["out_file"]
+    return None
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = inputs.out_file
+    if inputs.out_file is attrs.NOTHING:
+        outputs["out_file"] = _gen_fname(
+            inputs.in_file,
+            suffix=_suffix,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    outputs["out_file"] = os.path.abspath(outputs["out_file"])
+    return outputs
diff --git a/example-specs/task/nipype/fsl/melodic_callables.py b/example-specs/task/nipype/fsl/melodic_callables.py
index 65e696fa..5086dd84 100644
--- a/example-specs/task/nipype/fsl/melodic_callables.py
+++ b/example-specs/task/nipype/fsl/melodic_callables.py
@@ -1 +1,44 @@
 """Module to put any functions that are referred to in the "callables" section of MELODIC.yaml"""
+
+import os
+import attrs
+
+
+def out_dir_default(inputs):
+    return _gen_filename("out_dir", inputs=inputs)
+
+
+def out_dir_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_dir"]
+
+
+def report_dir_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["report_dir"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_dir":
+        return output_dir
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    if inputs.out_dir is not attrs.NOTHING:
+        outputs["out_dir"] = os.path.abspath(inputs.out_dir)
+    else:
+        outputs["out_dir"] = _gen_filename(
+            "out_dir",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    if (inputs.report is not attrs.NOTHING) and inputs.report:
+        outputs["report_dir"] = os.path.join(outputs["out_dir"], "report")
+    return outputs
diff --git a/example-specs/task/nipype/fsl/merge_callables.py b/example-specs/task/nipype/fsl/merge_callables.py
index a64071b1..2ff904b0 100644
--- a/example-specs/task/nipype/fsl/merge_callables.py
+++ b/example-specs/task/nipype/fsl/merge_callables.py
@@ -1 +1,283 @@
 """Module to put any functions that are referred to in the "callables" section of Merge.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+from glob import glob
+
+
+def merged_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["merged_file"]
+
+
+IFLOGGER = logging.getLogger("nipype.interface")
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+class Info(PackageInfo):
+    """
+    Handle FSL ``output_type`` and version information.
+
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
+
+    """
+
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
+
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
+
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
+
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
+
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
+
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
+
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
+
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
+
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
+
+        Returns a list of standard images if called without arguments.
+
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value + Info.output_type_to_ext(inputs.output_type)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
diff --git a/example-specs/task/nipype/fsl/min_image_callables.py b/example-specs/task/nipype/fsl/min_image_callables.py
index e01f3541..04c834c2 100644
--- a/example-specs/task/nipype/fsl/min_image_callables.py
+++ b/example-specs/task/nipype/fsl/min_image_callables.py
@@ -1 +1,284 @@
 """Module to put any functions that are referred to in the "callables" section of MinImage.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+from glob import glob
+
+
+def out_file_default(inputs):
+    return _gen_filename("out_file", inputs=inputs)
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+IFLOGGER = logging.getLogger("nipype.interface")
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """
+    Handle FSL ``output_type`` and version information.
+
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
+
+    """
+
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
+
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
+
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
+
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
+
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
+
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
+
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
+
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
+
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
+
+        Returns a list of standard images if called without arguments.
+
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
+
+
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
+
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
+
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
+
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "fslmaths"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )["out_file"]
+    return None
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = inputs.out_file
+    if inputs.out_file is attrs.NOTHING:
+        outputs["out_file"] = _gen_fname(
+            inputs.in_file,
+            suffix=_suffix,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    outputs["out_file"] = os.path.abspath(outputs["out_file"])
+    return outputs
diff --git a/example-specs/task/nipype/fsl/motion_outliers_callables.py b/example-specs/task/nipype/fsl/motion_outliers_callables.py
index 00364833..506e2ef7 100644
--- a/example-specs/task/nipype/fsl/motion_outliers_callables.py
+++ b/example-specs/task/nipype/fsl/motion_outliers_callables.py
@@ -1 +1,297 @@
 """Module to put any functions that are referred to in the "callables" section of MotionOutliers.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+from glob import glob
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+def out_metric_values_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_metric_values"]
+
+
+def out_metric_plot_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_metric_plot"]
+
+
+IFLOGGER = logging.getLogger("nipype.interface")
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+class Info(PackageInfo):
+    """
+    Handle FSL ``output_type`` and version information.
+
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
+
+    """
+
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
+
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
+
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
+
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
+
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
+
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
+
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
+
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
+
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
+
+        Returns a list of standard images if called without arguments.
+
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value + Info.output_type_to_ext(inputs.output_type)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
diff --git a/example-specs/task/nipype/fsl/multi_image_maths_callables.py b/example-specs/task/nipype/fsl/multi_image_maths_callables.py
index df382bdc..3f7345f5 100644
--- a/example-specs/task/nipype/fsl/multi_image_maths_callables.py
+++ b/example-specs/task/nipype/fsl/multi_image_maths_callables.py
@@ -1 +1,284 @@
 """Module to put any functions that are referred to in the "callables" section of MultiImageMaths.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+from glob import glob
+
+
+def out_file_default(inputs):
+    return _gen_filename("out_file", inputs=inputs)
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+IFLOGGER = logging.getLogger("nipype.interface")
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """
+    Handle FSL ``output_type`` and version information.
+
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
+
+    """
+
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
+
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
+
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
+
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
+
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
+
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
+
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
+
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
+
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
+
+        Returns a list of standard images if called without arguments.
+
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
+
+
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
+
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
+
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
+
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "fslmaths"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )["out_file"]
+    return None
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = inputs.out_file
+    if inputs.out_file is attrs.NOTHING:
+        outputs["out_file"] = _gen_fname(
+            inputs.in_file,
+            suffix=_suffix,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    outputs["out_file"] = os.path.abspath(outputs["out_file"])
+    return outputs
diff --git a/example-specs/task/nipype/fsl/multiple_regress_design_callables.py b/example-specs/task/nipype/fsl/multiple_regress_design_callables.py
index d862eb2a..d22ba883 100644
--- a/example-specs/task/nipype/fsl/multiple_regress_design_callables.py
+++ b/example-specs/task/nipype/fsl/multiple_regress_design_callables.py
@@ -1 +1,35 @@
 """Module to put any functions that are referred to in the "callables" section of MultipleRegressDesign.yaml"""
+
+
+def design_mat_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["design_mat"]
+
+
+def design_con_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["design_con"]
+
+
+def design_fts_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["design_fts"]
+
+
+def design_grp_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["design_grp"]
+
+
+def _gen_filename(field, inputs, output_dir, stdout, stderr):
+    raise NotImplementedError(
+        "Could not find '_gen_filename' method in nipype.interfaces.fsl.model.MultipleRegressDesign"
+    )
diff --git a/example-specs/task/nipype/fsl/overlay_callables.py b/example-specs/task/nipype/fsl/overlay_callables.py
index a6094ad6..2bcd9560 100644
--- a/example-specs/task/nipype/fsl/overlay_callables.py
+++ b/example-specs/task/nipype/fsl/overlay_callables.py
@@ -1 +1,344 @@
 """Module to put any functions that are referred to in the "callables" section of Overlay.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+from glob import glob
+
+
+def out_file_default(inputs):
+    return _gen_filename("out_file", inputs=inputs)
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+IFLOGGER = logging.getLogger("nipype.interface")
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """
+    Handle FSL ``output_type`` and version information.
+
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
+
+    """
+
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
+
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
+
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
+
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
+
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
+
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
+
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
+
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
+
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
+
+        Returns a list of standard images if called without arguments.
+
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
+
+
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
+
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
+
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
+
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "overlay"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )["out_file"]
+    return None
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    out_file = inputs.out_file
+    if out_file is attrs.NOTHING:
+        if (inputs.stat_image2 is not attrs.NOTHING) and (
+            (inputs.show_negative_stats is attrs.NOTHING)
+            or not inputs.show_negative_stats
+        ):
+            stem = "%s_and_%s" % (
+                split_filename(inputs.stat_image)[1],
+                split_filename(inputs.stat_image2)[1],
+            )
+        else:
+            stem = split_filename(inputs.stat_image)[1]
+        out_file = _gen_fname(
+            stem,
+            suffix="_overlay",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    outputs["out_file"] = os.path.abspath(out_file)
+    return outputs
diff --git a/example-specs/task/nipype/fsl/percentile_image_callables.py b/example-specs/task/nipype/fsl/percentile_image_callables.py
index 54f2d358..dc636d4d 100644
--- a/example-specs/task/nipype/fsl/percentile_image_callables.py
+++ b/example-specs/task/nipype/fsl/percentile_image_callables.py
@@ -1 +1,284 @@
 """Module to put any functions that are referred to in the "callables" section of PercentileImage.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+from glob import glob
+
+
+def out_file_default(inputs):
+    return _gen_filename("out_file", inputs=inputs)
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+IFLOGGER = logging.getLogger("nipype.interface")
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """
+    Handle FSL ``output_type`` and version information.
+
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
+
+    """
+
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
+
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
+
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
+
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
+
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
+
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
+
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
+
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
+
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
+
+        Returns a list of standard images if called without arguments.
+
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
+
+
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
+
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
+
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
+
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "fslmaths"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )["out_file"]
+    return None
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = inputs.out_file
+    if inputs.out_file is attrs.NOTHING:
+        outputs["out_file"] = _gen_fname(
+            inputs.in_file,
+            suffix=_suffix,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    outputs["out_file"] = os.path.abspath(outputs["out_file"])
+    return outputs
diff --git a/example-specs/task/nipype/fsl/plot_motion_params_callables.py b/example-specs/task/nipype/fsl/plot_motion_params_callables.py
index 8f0266b7..9014b597 100644
--- a/example-specs/task/nipype/fsl/plot_motion_params_callables.py
+++ b/example-specs/task/nipype/fsl/plot_motion_params_callables.py
@@ -1 +1,130 @@
 """Module to put any functions that are referred to in the "callables" section of PlotMotionParams.yaml"""
+
+import os
+import attrs
+import os.path as op
+
+
+def out_file_default(inputs):
+    return _gen_filename("out_file", inputs=inputs)
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )["out_file"]
+    return None
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    out_file = inputs.out_file
+    if out_file is attrs.NOTHING:
+        if isinstance(inputs.in_file, list):
+            infile = inputs.in_file[0]
+        else:
+            infile = inputs.in_file
+        plttype = dict(rot="rot", tra="trans", dis="disp")[inputs.plot_type[:3]]
+        out_file = fname_presuffix(infile, suffix="_%s.png" % plttype, use_ext=False)
+    outputs["out_file"] = os.path.abspath(out_file)
+    return outputs
diff --git a/example-specs/task/nipype/fsl/plot_time_series_callables.py b/example-specs/task/nipype/fsl/plot_time_series_callables.py
index ebbcab6f..52d60591 100644
--- a/example-specs/task/nipype/fsl/plot_time_series_callables.py
+++ b/example-specs/task/nipype/fsl/plot_time_series_callables.py
@@ -1 +1,288 @@
 """Module to put any functions that are referred to in the "callables" section of PlotTimeSeries.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+from glob import glob
+
+
+def out_file_default(inputs):
+    return _gen_filename("out_file", inputs=inputs)
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+IFLOGGER = logging.getLogger("nipype.interface")
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """
+    Handle FSL ``output_type`` and version information.
+
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
+
+    """
+
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
+
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
+
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
+
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
+
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
+
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
+
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
+
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
+
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
+
+        Returns a list of standard images if called without arguments.
+
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
+
+
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
+
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
+
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
+
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "fsl_tsplot"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )["out_file"]
+    return None
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    out_file = inputs.out_file
+    if out_file is attrs.NOTHING:
+        if isinstance(inputs.in_file, list):
+            infile = inputs.in_file[0]
+        else:
+            infile = inputs.in_file
+        out_file = _gen_fname(
+            infile,
+            ext=".png",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    outputs["out_file"] = os.path.abspath(out_file)
+    return outputs
diff --git a/example-specs/task/nipype/fsl/power_spectrum_callables.py b/example-specs/task/nipype/fsl/power_spectrum_callables.py
index d6dc3fd3..4345553c 100644
--- a/example-specs/task/nipype/fsl/power_spectrum_callables.py
+++ b/example-specs/task/nipype/fsl/power_spectrum_callables.py
@@ -1 +1,292 @@
 """Module to put any functions that are referred to in the "callables" section of PowerSpectrum.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+from glob import glob
+
+
+def out_file_default(inputs):
+    return _gen_filename("out_file", inputs=inputs)
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+IFLOGGER = logging.getLogger("nipype.interface")
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """
+    Handle FSL ``output_type`` and version information.
+
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
+
+    """
+
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
+
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
+
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
+
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
+
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
+
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
+
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
+
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
+
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
+
+        Returns a list of standard images if called without arguments.
+
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
+
+
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
+
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
+
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
+
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "fslpspec"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+def _gen_outfilename(inputs=None, stdout=None, stderr=None, output_dir=None):
+    out_file = inputs.out_file
+    if (out_file is attrs.NOTHING) and (inputs.in_file is not attrs.NOTHING):
+        out_file = _gen_fname(
+            inputs.in_file,
+            suffix="_ps",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    return out_file
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _gen_outfilename(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )
+    return None
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = os.path.abspath(
+        _gen_outfilename(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )
+    )
+    return outputs
diff --git a/example-specs/task/nipype/fsl/prelude_callables.py b/example-specs/task/nipype/fsl/prelude_callables.py
index aad67925..f3b4b831 100644
--- a/example-specs/task/nipype/fsl/prelude_callables.py
+++ b/example-specs/task/nipype/fsl/prelude_callables.py
@@ -1 +1,294 @@
 """Module to put any functions that are referred to in the "callables" section of PRELUDE.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+from glob import glob
+
+
+def unwrapped_phase_file_default(inputs):
+    return _gen_filename("unwrapped_phase_file", inputs=inputs)
+
+
+def unwrapped_phase_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["unwrapped_phase_file"]
+
+
+IFLOGGER = logging.getLogger("nipype.interface")
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """
+    Handle FSL ``output_type`` and version information.
+
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
+
+    """
+
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
+
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
+
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
+
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
+
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
+
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
+
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
+
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
+
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
+
+        Returns a list of standard images if called without arguments.
+
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
+
+
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
+
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
+
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
+
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "prelude"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "unwrapped_phase_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )["unwrapped_phase_file"]
+    return None
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    out_file = inputs.unwrapped_phase_file
+    if out_file is attrs.NOTHING:
+        if inputs.phase_file is not attrs.NOTHING:
+            out_file = _gen_fname(
+                inputs.phase_file,
+                suffix="_unwrapped",
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+        elif inputs.complex_phase_file is not attrs.NOTHING:
+            out_file = _gen_fname(
+                inputs.complex_phase_file,
+                suffix="_phase_unwrapped",
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    outputs["unwrapped_phase_file"] = os.path.abspath(out_file)
+    return outputs
diff --git a/example-specs/task/nipype/fsl/prepare_fieldmap_callables.py b/example-specs/task/nipype/fsl/prepare_fieldmap_callables.py
index 8d4cf635..7ae72b04 100644
--- a/example-specs/task/nipype/fsl/prepare_fieldmap_callables.py
+++ b/example-specs/task/nipype/fsl/prepare_fieldmap_callables.py
@@ -1 +1,18 @@
 """Module to put any functions that are referred to in the "callables" section of PrepareFieldmap.yaml"""
+
+
+def out_fieldmap_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_fieldmap"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_fieldmap"] = inputs.out_fieldmap
+    return outputs
diff --git a/example-specs/task/nipype/fsl/prob_track_x.yaml b/example-specs/task/nipype/fsl/prob_track_x.yaml
index 44aa3bf9..cc05720a 100644
--- a/example-specs/task/nipype/fsl/prob_track_x.yaml
+++ b/example-specs/task/nipype/fsl/prob_track_x.yaml
@@ -71,8 +71,14 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    fdt_paths: generic/file+list-of
+    # type=outputmultiobject: path/name of a 3D image file containing the output connectivity distribution to the seed mask
     log: generic/file
     # type=file: path/name of a text record of the command that was run
+    particle_files: generic/file+list-of
+    # type=list: Files describing all of the tract samples. Generated only if verbose is set to 2
+    targets: generic/file+list-of
+    # type=list: a list with all generated seeds_to_target files
     way_total: generic/file
     # type=file: path/name of a text file containing a single number corresponding to the total number of generated tracts that have not been rejected by inclusion/exclusion mask criteria
   callables:
diff --git a/example-specs/task/nipype/fsl/prob_track_x2.yaml b/example-specs/task/nipype/fsl/prob_track_x2.yaml
index 6f2e7056..a6e16130 100644
--- a/example-specs/task/nipype/fsl/prob_track_x2.yaml
+++ b/example-specs/task/nipype/fsl/prob_track_x2.yaml
@@ -86,6 +86,8 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    fdt_paths: generic/file+list-of
+    # type=outputmultiobject: path/name of a 3D image file containing the output connectivity distribution to the seed mask
     log: generic/file
     # type=file: path/name of a text record of the command that was run
     lookup_tractspace: generic/file
@@ -98,6 +100,10 @@ outputs:
     # type=file: Output matrix3 - NxN connectivity matrix
     network_matrix: generic/file
     # type=file: the network matrix generated by --omatrix1 option
+    particle_files: generic/file+list-of
+    # type=list: Files describing all of the tract samples. Generated only if verbose is set to 2
+    targets: generic/file+list-of
+    # type=list: a list with all generated seeds_to_target files
     way_total: generic/file
     # type=file: path/name of a text file containing a single number corresponding to the total number of generated tracts that have not been rejected by inclusion/exclusion mask criteria
   callables:
diff --git a/example-specs/task/nipype/fsl/prob_track_x2_callables.py b/example-specs/task/nipype/fsl/prob_track_x2_callables.py
index 23601cb9..d0649a0a 100644
--- a/example-specs/task/nipype/fsl/prob_track_x2_callables.py
+++ b/example-specs/task/nipype/fsl/prob_track_x2_callables.py
@@ -1,165 +1,129 @@
 """Module to put any functions that are referred to in the "callables" section of ProbTrackX2.yaml"""
 
-import warnings
-import re
-from hashlib import md5
-import shutil
 import os
-from pathlib import Path
-from fileformats.generic import File, Directory
-from glob import glob
+import attrs
 import os.path as op
 import logging
-import hashlib
-import attrs
-import subprocess as sp
-import simplejson as json
-from fileformats.generic import File
-import posixpath
+from glob import glob
 
 
 def out_dir_default(inputs):
     return _gen_filename("out_dir", inputs=inputs)
 
 
-def out_dir_callable(output_dir, inputs, stdout, stderr):
+def network_matrix_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_dir"]
+    return outputs["network_matrix"]
 
 
-related_filetype_sets = [(".hdr", ".img", ".mat"), (".nii", ".mat"), (".BRIK", ".HEAD")]
+def matrix1_dot_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["matrix1_dot"]
 
 
-_cifs_table = _generate_cifs_table()
+def lookup_tractspace_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["lookup_tractspace"]
 
 
-fmlogger = logging.getLogger("nipype.utils")
+def matrix2_dot_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["matrix2_dot"]
 
 
-IFLOGGER = logging.getLogger("nipype.interface")
+def matrix3_dot_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["matrix3_dot"]
 
 
-class FSLCommandInputSpec(CommandLineInputSpec):
-    """
-    Base Input Specification for all FSL Commands
+def log_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["log"]
 
-    All command support specifying FSLOUTPUTTYPE dynamically
-    via output_type.
 
-    Example
-    -------
-    fsl.ExtractRoi(tmin=42, tsize=1, output_type='NIFTI')
-    """
+def fdt_paths_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["fdt_paths"]
 
-    output_type = traits.Enum("NIFTI", list(Info.ftypes.keys()), desc="FSL output type")
-
-
-class FSLCommand(CommandLine):
-    """Base support for FSL commands."""
-
-    input_spec = FSLCommandInputSpec
-    _output_type = None
-
-    _references = [
-        {
-            "entry": BibTeX(
-                "@article{JenkinsonBeckmannBehrensWoolrichSmith2012,"
-                "author={M. Jenkinson, C.F. Beckmann, T.E. Behrens, "
-                "M.W. Woolrich, and S.M. Smith},"
-                "title={FSL},"
-                "journal={NeuroImage},"
-                "volume={62},"
-                "pages={782-790},"
-                "year={2012},"
-                "}"
-            ),
-            "tags": ["implementation"],
-        }
-    ]
-
-    def __init__(self, **inputs):
-        super(FSLCommand, self).__init__(**inputs)
-        self.inputs.on_trait_change(self._output_update, "output_type")
-
-        if self._output_type is None:
-            self._output_type = Info.output_type()
-
-        if self.inputs.output_type is attrs.NOTHING:
-            self.inputs.output_type = self._output_type
-        else:
-            self._output_update()
 
-    def _output_update(self):
-        self._output_type = self.inputs.output_type
-        self.inputs.environ.update({"FSLOUTPUTTYPE": self.inputs.output_type})
+def way_total_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["way_total"]
 
-    @classmethod
-    def set_default_output_type(cls, output_type):
-        """Set the default output type for FSL classes.
 
-        This method is used to set the default output type for all fSL
-        subclasses.  However, setting this will not update the output
-        type for any existing instances.  For these, assign the
-        <instance>.inputs.output_type.
-        """
+def targets_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["targets"]
 
-        if output_type in Info.ftypes:
-            cls._output_type = output_type
-        else:
-            raise AttributeError("Invalid FSL output_type: %s" % output_type)
 
-    @property
-    def version(self):
-        return Info.version()
+def particle_files_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["particle_files"]
 
-    def _gen_fname(self, basename, cwd=None, suffix=None, change_ext=True, ext=None):
-        """Generate a filename based on the given parameters.
 
-        The filename will take the form: cwd/basename<suffix><ext>.
-        If change_ext is True, it will use the extensions specified in
-        <instance>inputs.output_type.
+IFLOGGER = logging.getLogger("nipype.interface")
 
-        Parameters
-        ----------
-        basename : str
-            Filename to base the new filename on.
-        cwd : str
-            Path to prefix to the new filename. (default is os.getcwd())
-        suffix : str
-            Suffix to add to the `basename`.  (defaults is '' )
-        change_ext : bool
-            Flag to change the filename extension to the FSL output type.
-            (default True)
 
-        Returns
-        -------
-        fname : str
-            New filename based on given parameters.
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
 
-        """
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
 
-        if basename == "":
-            msg = "Unable to generate filename for command %s. " % self.cmd
-            msg += "basename is not set!"
-            raise ValueError(msg)
-        if cwd is None:
-            cwd = os.getcwd()
-        if ext is None:
-            ext = Info.output_type_to_ext(self.inputs.output_type)
-        if change_ext:
-            if suffix:
-                suffix = "".join((suffix, ext))
-            else:
-                suffix = ext
-        if suffix is None:
-            suffix = ""
-        fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
-        return fname
-
-    def _overload_extension(self, value, name=None):
-        return value + Info.output_type_to_ext(self.inputs.output_type)
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
 
 
 def split_filename(fname):
@@ -212,930 +176,224 @@ def split_filename(fname):
     return pth, fname, ext
 
 
-def on_cifs(fname):
+class Info(PackageInfo):
     """
-    Checks whether a file path is on a CIFS filesystem mounted in a POSIX
-    host (i.e., has the ``mount`` command).
+    Handle FSL ``output_type`` and version information.
 
-    On Windows, Docker mounts host directories into containers through CIFS
-    shares, which has support for Minshall+French symlinks, or text files that
-    the CIFS driver exposes to the OS as symlinks.
-    We have found that under concurrent access to the filesystem, this feature
-    can result in failures to create or read recently-created symlinks,
-    leading to inconsistent behavior and ``FileNotFoundError``.
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
 
-    This check is written to support disabling symlinks on CIFS shares.
-
-    """
-    # Only the first match (most recent parent) counts
-    for fspath, fstype in _cifs_table:
-        if fname.startswith(fspath):
-            return fstype == "cifs"
-    return False
-
-
-def BibTeX(*args, **kwargs):
-    """Perform no good and no bad"""
-    pass
-
-
-def _donothing_func(*args, **kwargs):
-    """Perform no good and no bad"""
-    pass
-
-
-def which(cmd, env=None, pathext=None):
-    """
-    Return the path to an executable which would be run if the given
-    cmd was called. If no cmd would be called, return ``None``.
+    Examples
+    --------
 
-    Code for Python < 3.3 is based on a code snippet from
-    http://orip.org/2009/08/python-checking-if-executable-exists-in.html
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
 
     """
 
-    if pathext is None:
-        pathext = os.getenv("PATHEXT", "").split(os.pathsep)
-        pathext.insert(0, "")
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
 
-    path = os.getenv("PATH", os.defpath)
-    if env and "PATH" in env:
-        path = env.get("PATH")
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
 
-    for ext in pathext:
-        filename = shutil.which(cmd + ext, path=path)
-        if filename:
-            return filename
-    return None
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
 
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
 
-def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
-    """Manipulates path and name of input filename
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
 
-    Parameters
-    ----------
-    fname : string
-        A filename (may or may not include path)
-    prefix : string
-        Characters to prepend to the filename
-    suffix : string
-        Characters to append to the filename
-    newpath : string
-        Path to replace the path of the input fname
-    use_ext : boolean
-        If True (default), appends the extension of the original file
-        to the output name.
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
 
-    Returns
-    -------
-    Absolute path of the modified filename
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
 
-    >>> from nipype.utils.filemanip import fname_presuffix
-    >>> fname = 'foo.nii.gz'
-    >>> fname_presuffix(fname,'pre','post','/tmp')
-    '/tmp/prefoopost.nii.gz'
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
 
-    >>> from nipype.interfaces.base import Undefined
-    >>> fname_presuffix(fname, 'pre', 'post', Undefined) == \
-            fname_presuffix(fname, 'pre', 'post')
-    True
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
 
-    """
-    pth, fname, ext = split_filename(fname)
-    if not use_ext:
-        ext = ""
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
 
-    # No need for isdefined: bool(Undefined) evaluates to False
-    if newpath:
-        pth = op.abspath(newpath)
-    return op.join(pth, prefix + fname + suffix + ext)
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
 
+        Returns a list of standard images if called without arguments.
 
-def copyfile(
-    originalfile,
-    newfile,
-    copy=False,
-    create_new=False,
-    hashmethod=None,
-    use_hardlink=False,
-    copy_related_files=True,
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
+
+
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
 ):
-    """Copy or link ``originalfile`` to ``newfile``.
-
-    If ``use_hardlink`` is True, and the file can be hard-linked, then a
-    link is created, instead of copying the file.
+    """Generate a filename based on the given parameters.
 
-    If a hard link is not created and ``copy`` is False, then a symbolic
-    link is created.
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
 
     Parameters
     ----------
-    originalfile : str
-        full path to original file
-    newfile : str
-        full path to new file
-    copy : Bool
-        specifies whether to copy or symlink files
-        (default=False) but only for POSIX systems
-    use_hardlink : Bool
-        specifies whether to hard-link files, when able
-        (Default=False), taking precedence over copy
-    copy_related_files : Bool
-        specifies whether to also operate on related files, as defined in
-        ``related_filetype_sets``
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
 
     Returns
     -------
-    None
+    fname : str
+        New filename based on given parameters.
 
     """
-    newhash = None
-    orighash = None
-    fmlogger.debug(newfile)
-
-    if create_new:
-        while op.exists(newfile):
-            base, fname, ext = split_filename(newfile)
-            s = re.search("_c[0-9]{4,4}$", fname)
-            i = 0
-            if s:
-                i = int(s.group()[2:]) + 1
-                fname = fname[:-6] + "_c%04d" % i
-            else:
-                fname += "_c%04d" % i
-            newfile = base + os.sep + fname + ext
-
-    if hashmethod is None:
-        hashmethod = config.get("execution", "hash_method").lower()
-
-    # Don't try creating symlinks on CIFS
-    if copy is False and on_cifs(newfile):
-        copy = True
-
-    # Existing file
-    # -------------
-    # Options:
-    #   symlink
-    #       to regular file originalfile            (keep if symlinking)
-    #       to same dest as symlink originalfile    (keep if symlinking)
-    #       to other file                           (unlink)
-    #   regular file
-    #       hard link to originalfile               (keep)
-    #       copy of file (same hash)                (keep)
-    #       different file (diff hash)              (unlink)
-    keep = False
-    if op.lexists(newfile):
-        if op.islink(newfile):
-            if all(
-                (
-                    os.readlink(newfile) == op.realpath(originalfile),
-                    not use_hardlink,
-                    not copy,
-                )
-            ):
-                keep = True
-        elif posixpath.samefile(newfile, originalfile):
-            keep = True
-        else:
-            if hashmethod == "timestamp":
-                hashfn = hash_timestamp
-            elif hashmethod == "content":
-                hashfn = hash_infile
-            else:
-                raise AttributeError("Unknown hash method found:", hashmethod)
-            newhash = hashfn(newfile)
-            fmlogger.debug(
-                "File: %s already exists,%s, copy:%d", newfile, newhash, copy
-            )
-            orighash = hashfn(originalfile)
-            keep = newhash == orighash
-        if keep:
-            fmlogger.debug(
-                "File: %s already exists, not overwriting, copy:%d", newfile, copy
-            )
-        else:
-            os.unlink(newfile)
-
-    # New file
-    # --------
-    # use_hardlink & can_hardlink => hardlink
-    # ~hardlink & ~copy & can_symlink => symlink
-    # ~hardlink & ~symlink => copy
-    if not keep and use_hardlink:
-        try:
-            fmlogger.debug("Linking File: %s->%s", newfile, originalfile)
-            # Use realpath to avoid hardlinking symlinks
-            os.link(op.realpath(originalfile), newfile)
-        except OSError:
-            use_hardlink = False  # Disable hardlink for associated files
-        else:
-            keep = True
 
-    if not keep and not copy and os.name == "posix":
-        try:
-            fmlogger.debug("Symlinking File: %s->%s", newfile, originalfile)
-            os.symlink(originalfile, newfile)
-        except OSError:
-            copy = True  # Disable symlink for associated files
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "probtrackx2"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
         else:
-            keep = True
-
-    if not keep:
-        try:
-            fmlogger.debug("Copying File: %s->%s", newfile, originalfile)
-            shutil.copyfile(originalfile, newfile)
-        except shutil.Error as e:
-            fmlogger.warning(str(e))
-
-    # Associated files
-    if copy_related_files:
-        related_file_pairs = (
-            get_related_files(f, include_this_file=False)
-            for f in (originalfile, newfile)
-        )
-        for alt_ofile, alt_nfile in zip(*related_file_pairs):
-            if op.exists(alt_ofile):
-                copyfile(
-                    alt_ofile,
-                    alt_nfile,
-                    copy,
-                    hashmethod=hashmethod,
-                    use_hardlink=use_hardlink,
-                    copy_related_files=False,
-                )
-
-    return newfile
-
-
-def _parse_mount_table(exit_code, output):
-    """Parses the output of ``mount`` to produce (path, fs_type) pairs
-
-    Separated from _generate_cifs_table to enable testing logic with real
-    outputs
-    """
-    # Not POSIX
-    if exit_code != 0:
-        return []
-
-    # Linux mount example:  sysfs on /sys type sysfs (rw,nosuid,nodev,noexec)
-    #                          <PATH>^^^^      ^^^^^<FSTYPE>
-    # OSX mount example:    /dev/disk2 on / (hfs, local, journaled)
-    #                               <PATH>^  ^^^<FSTYPE>
-    pattern = re.compile(r".*? on (/.*?) (?:type |\()([^\s,\)]+)")
-
-    # Keep line and match for error reporting (match == None on failure)
-    # Ignore empty lines
-    matches = [(l, pattern.match(l)) for l in output.strip().splitlines() if l]
-
-    # (path, fstype) tuples, sorted by path length (longest first)
-    mount_info = sorted(
-        (match.groups() for _, match in matches if match is not None),
-        key=lambda x: len(x[0]),
-        reverse=True,
-    )
-    cifs_paths = [path for path, fstype in mount_info if fstype.lower() == "cifs"]
-
-    # Report failures as warnings
-    for line, match in matches:
-        if match is None:
-            fmlogger.debug("Cannot parse mount line: '%s'", line)
-
-    return [
-        mount
-        for mount in mount_info
-        if any(mount[0].startswith(path) for path in cifs_paths)
-    ]
-
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
 
-def hash_timestamp(afile):
-    """Computes md5 hash of the timestamp of a file"""
-    md5hex = None
-    if op.isfile(afile):
-        md5obj = md5()
-        stat = os.stat(afile)
-        md5obj.update(str(stat.st_size).encode())
-        md5obj.update(str(stat.st_mtime).encode())
-        md5hex = md5obj.hexdigest()
-    return md5hex
 
-
-def _generate_cifs_table():
-    """Construct a reverse-length-ordered list of mount points that
-    fall under a CIFS mount.
-
-    This precomputation allows efficient checking for whether a given path
-    would be on a CIFS filesystem.
-
-    On systems without a ``mount`` command, or with no CIFS mounts, returns an
-    empty list.
-    """
-    exit_code, output = sp.getstatusoutput("mount")
-    return _parse_mount_table(exit_code, output)
-
-
-def hash_infile(afile, chunk_len=8192, crypto=hashlib.md5, raise_notfound=False):
-    """
-    Computes hash of a file using 'crypto' module
-
-    >>> hash_infile('smri_ants_registration_settings.json')
-    'f225785dfb0db9032aa5a0e4f2c730ad'
-
-    >>> hash_infile('surf01.vtk')
-    'fdf1cf359b4e346034372cdeb58f9a88'
-
-    >>> hash_infile('spminfo')
-    '0dc55e3888c98a182dab179b976dfffc'
-
-    >>> hash_infile('fsl_motion_outliers_fd.txt')
-    'defd1812c22405b1ee4431aac5bbdd73'
-
-
-    """
-    if not op.isfile(afile):
-        if raise_notfound:
-            raise RuntimeError('File "%s" not found.' % afile)
-        return None
-
-    crypto_obj = crypto()
-    with open(afile, "rb") as fp:
-        while True:
-            data = fp.read(chunk_len)
-            if not data:
-                break
-            crypto_obj.update(data)
-    return crypto_obj.hexdigest()
-
-
-def get_related_files(filename, include_this_file=True):
-    """Returns a list of related files, as defined in
-    ``related_filetype_sets``, for a filename. (e.g., Nifti-Pair, Analyze (SPM)
-    and AFNI files).
-
-    Parameters
-    ----------
-    filename : str
-        File name to find related filetypes of.
-    include_this_file : bool
-        If true, output includes the input filename.
-    """
-    related_files = []
-    path, name, this_type = split_filename(filename)
-    for type_set in related_filetype_sets:
-        if this_type in type_set:
-            for related_type in type_set:
-                if include_this_file or related_type != this_type:
-                    related_files.append(op.join(path, name + related_type))
-    if not len(related_files):
-        related_files = [filename]
-    return related_files
-
-
-class ProbTrackXInputSpec(ProbTrackXBaseInputSpec):
-    mode = traits.Enum(
-        "simple",
-        "two_mask_symm",
-        "seedmask",
-        desc=(
-            "options: simple (single seed voxel), seedmask "
-            "(mask of seed voxels), twomask_symm (two bet "
-            "binary masks)"
-        ),
-        argstr="--mode=%s",
-        genfile=True,
-    )
-    mask2 = File(
-        exists=True,
-        desc=("second bet binary mask (in diffusion space) in " "twomask_symm mode"),
-        argstr="--mask2=%s",
-    )
-    mesh = File(
-        exists=True,
-        desc="Freesurfer-type surface descriptor (in ascii format)",
-        argstr="--mesh=%s",
-    )
-
-
-class ProbTrackX(FSLCommand):
-    """ Use FSL  probtrackx for tractography on bedpostx results
-
-    Examples
-    --------
-
-    >>> from nipype.interfaces import fsl
-    >>> pbx = fsl.ProbTrackX(samples_base_name='merged', mask='mask.nii', \
-    seed='MASK_average_thal_right.nii', mode='seedmask', \
-    xfm='trans.mat', n_samples=3, n_steps=10, force_dir=True, opd=True, \
-    os2t=True, target_masks = ['targets_MASK1.nii', 'targets_MASK2.nii'], \
-    thsamples='merged_thsamples.nii', fsamples='merged_fsamples.nii', \
-    phsamples='merged_phsamples.nii', out_dir='.')
-    >>> pbx.cmdline
-    'probtrackx --forcedir -m mask.nii --mode=seedmask --nsamples=3 --nsteps=10 --opd --os2t --dir=. --samples=merged --seed=MASK_average_thal_right.nii --targetmasks=targets.txt --xfm=trans.mat'
-
-    """
-
-    _cmd = "probtrackx"
-    input_spec = ProbTrackXInputSpec
-    output_spec = ProbTrackXOutputSpec
-
-    def __init__(self, **inputs):
-        warnings.warn(
-            ("Deprecated: Please use create_bedpostx_pipeline " "instead"),
-            DeprecationWarning,
+def nipype_interfaces_fsl_dti__ProbTrackX___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = {}
+    if inputs.out_dir is attrs.NOTHING:
+        out_dir = _gen_filename(
+            "out_dir",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
         )
-        return super(ProbTrackX, self).__init__(**inputs)
-
-    def _run_interface(self, runtime):
-        for i in range(1, len(self.inputs.thsamples) + 1):
-            _, _, ext = split_filename(self.inputs.thsamples[i - 1])
-            copyfile(
-                self.inputs.thsamples[i - 1],
-                self.inputs.samples_base_name + "_th%dsamples" % i + ext,
-                copy=False,
-            )
-            _, _, ext = split_filename(self.inputs.thsamples[i - 1])
-            copyfile(
-                self.inputs.phsamples[i - 1],
-                self.inputs.samples_base_name + "_ph%dsamples" % i + ext,
-                copy=False,
-            )
-            _, _, ext = split_filename(self.inputs.thsamples[i - 1])
-            copyfile(
-                self.inputs.fsamples[i - 1],
-                self.inputs.samples_base_name + "_f%dsamples" % i + ext,
-                copy=False,
-            )
-
-        if self.inputs.target_masks is not attrs.NOTHING:
-            f = open("targets.txt", "w")
-            for target in self.inputs.target_masks:
-                f.write("%s\n" % target)
-            f.close()
-        if isinstance(self.inputs.seed, list):
-            f = open("seeds.txt", "w")
-            for seed in self.inputs.seed:
-                if isinstance(seed, list):
-                    f.write("%s\n" % (" ".join([str(s) for s in seed])))
-                else:
-                    f.write("%s\n" % seed)
-            f.close()
-
-        runtime = super(ProbTrackX, self)._run_interface(runtime)
-        if runtime.stderr:
-            self.raise_exception(runtime)
-        return runtime
-
-    def _format_arg(self, name, spec, value):
-        if name == "target_masks" and value is not attrs.NOTHING:
-            fname = "targets.txt"
-            return super(ProbTrackX, self)._format_arg(name, spec, [fname])
-        elif name == "seed" and isinstance(value, list):
-            fname = "seeds.txt"
-            return super(ProbTrackX, self)._format_arg(name, spec, fname)
-        else:
-            return super(ProbTrackX, self)._format_arg(name, spec, value)
-
-    def _list_outputs(self):
-        outputs = self.output_spec().get()
-        if self.inputs.out_dir is attrs.NOTHING:
-            out_dir = self._gen_filename("out_dir")
-        else:
-            out_dir = self.inputs.out_dir
-
-        outputs["log"] = os.path.abspath(os.path.join(out_dir, "probtrackx.log"))
-        # outputs['way_total'] = os.path.abspath(os.path.join(out_dir,
-        #                                                    'waytotal'))
-        if isdefined(self.inputs.opd is True):
-            if isinstance(self.inputs.seed, list) and isinstance(
-                self.inputs.seed[0], list
-            ):
-                outputs["fdt_paths"] = []
-                for seed in self.inputs.seed:
-                    outputs["fdt_paths"].append(
-                        os.path.abspath(
-                            self._gen_fname(
-                                ("fdt_paths_%s" % ("_".join([str(s) for s in seed]))),
-                                cwd=out_dir,
-                                suffix="",
-                            )
-                        )
-                    )
-            else:
-                outputs["fdt_paths"] = os.path.abspath(
-                    self._gen_fname("fdt_paths", cwd=out_dir, suffix="")
-                )
+    else:
+        out_dir = inputs.out_dir
 
-        # handle seeds-to-target output files
-        if self.inputs.target_masks is not attrs.NOTHING:
-            outputs["targets"] = []
-            for target in self.inputs.target_masks:
-                outputs["targets"].append(
+    outputs["log"] = os.path.abspath(os.path.join(out_dir, "probtrackx.log"))
+    # outputs['way_total'] = os.path.abspath(os.path.join(out_dir,
+    #                                                    'waytotal'))
+    if inputs.opd is True is not attrs.NOTHING:
+        if isinstance(inputs.seed, list) and isinstance(inputs.seed[0], list):
+            outputs["fdt_paths"] = []
+            for seed in inputs.seed:
+                outputs["fdt_paths"].append(
                     os.path.abspath(
-                        self._gen_fname(
-                            "seeds_to_" + os.path.split(target)[1],
+                        _gen_fname(
+                            ("fdt_paths_%s" % ("_".join([str(s) for s in seed]))),
                             cwd=out_dir,
                             suffix="",
+                            inputs=inputs,
+                            stdout=stdout,
+                            stderr=stderr,
+                            output_dir=output_dir,
                         )
                     )
                 )
-        if self.inputs.verbose is not attrs.NOTHING and self.inputs.verbose == 2:
-            outputs["particle_files"] = [
-                os.path.abspath(os.path.join(out_dir, "particle%d" % i))
-                for i in range(self.inputs.n_samples)
-            ]
-        return outputs
-
-    def _gen_filename(self, name):
-        if name == "out_dir":
-            return os.getcwd()
-        elif name == "mode":
-            if isinstance(self.inputs.seed, list) and isinstance(
-                self.inputs.seed[0], list
-            ):
-                return "simple"
-            else:
-                return "seedmask"
-
-
-class ProbTrackXOutputSpec(TraitedSpec):
-    log = File(
-        exists=True, desc="path/name of a text record of the command that was run"
-    )
-    fdt_paths = OutputMultiPath(
-        File(exists=True),
-        desc=(
-            "path/name of a 3D image file "
-            "containing the output connectivity "
-            "distribution to the seed mask"
-        ),
-    )
-    way_total = File(
-        exists=True,
-        desc=(
-            "path/name of a text file containing a single "
-            "number corresponding to the total number of "
-            "generated tracts that have not been rejected by "
-            "inclusion/exclusion mask criteria"
-        ),
-    )
-    targets = traits.List(
-        File(exists=True), desc=("a list with all generated seeds_to_target " "files")
-    )
-    particle_files = traits.List(
-        File(exists=True),
-        desc=(
-            "Files describing all of the tract "
-            "samples. Generated only if verbose is "
-            "set to 2"
-        ),
-    )
-
-
-class ProbTrackXBaseInputSpec(FSLCommandInputSpec):
-    thsamples = InputMultiPath(File(exists=True), mandatory=True)
-    phsamples = InputMultiPath(File(exists=True), mandatory=True)
-    fsamples = InputMultiPath(File(exists=True), mandatory=True)
-    samples_base_name = traits.Str(
-        "merged",
-        desc=("the rootname/base_name for samples " "files"),
-        argstr="--samples=%s",
-        usedefault=True,
-    )
-    mask = File(
-        exists=True,
-        desc="bet binary mask file in diffusion space",
-        argstr="-m %s",
-        mandatory=True,
-    )
-    seed = traits.Either(
-        File(exists=True),
-        traits.List(File(exists=True)),
-        traits.List(traits.List(traits.Int(), minlen=3, maxlen=3)),
-        desc=("seed volume(s), or voxel(s) or freesurfer " "label file"),
-        argstr="--seed=%s",
-        mandatory=True,
-    )
-    target_masks = InputMultiPath(
-        File(exits=True),
-        desc=("list of target masks - required for " "seeds_to_targets classification"),
-        argstr="--targetmasks=%s",
-    )
-    waypoints = File(
-        exists=True,
-        desc=(
-            "waypoint mask or ascii list of waypoint masks - "
-            "only keep paths going through ALL the masks"
-        ),
-        argstr="--waypoints=%s",
-    )
-    network = traits.Bool(
-        desc=(
-            "activate network mode - only keep paths "
-            "going through at least one seed mask "
-            "(required if multiple seed masks)"
-        ),
-        argstr="--network",
-    )
-    seed_ref = File(
-        exists=True,
-        desc=(
-            "reference vol to define seed space in simple mode "
-            "- diffusion space assumed if absent"
-        ),
-        argstr="--seedref=%s",
-    )
-    out_dir = Directory(
-        exists=True,
-        argstr="--dir=%s",
-        desc="directory to put the final volumes in",
-        genfile=True,
-    )
-    force_dir = traits.Bool(
-        True,
-        desc=(
-            "use the actual directory name given - i.e. "
-            "do not add + to make a new directory"
-        ),
-        argstr="--forcedir",
-        usedefault=True,
-    )
-    opd = traits.Bool(
-        True, desc="outputs path distributions", argstr="--opd", usedefault=True
-    )
-    correct_path_distribution = traits.Bool(
-        desc=("correct path distribution " "for the length of the " "pathways"),
-        argstr="--pd",
-    )
-    os2t = traits.Bool(desc="Outputs seeds to targets", argstr="--os2t")
-    # paths_file = File('nipype_fdtpaths', usedefault=True, argstr='--out=%s',
-    #                 desc='produces an output file (default is fdt_paths)')
-    avoid_mp = File(
-        exists=True,
-        desc=("reject pathways passing through locations given by " "this mask"),
-        argstr="--avoid=%s",
-    )
-    stop_mask = File(
-        exists=True,
-        argstr="--stop=%s",
-        desc="stop tracking at locations given by this mask file",
-    )
-    xfm = File(
-        exists=True,
-        argstr="--xfm=%s",
-        desc=(
-            "transformation matrix taking seed space to DTI space "
-            "(either FLIRT matrix or FNIRT warp_field) - default is "
-            "identity"
-        ),
-    )
-    inv_xfm = File(
-        argstr="--invxfm=%s",
-        desc=(
-            "transformation matrix taking DTI space to seed "
-            "space (compulsory when using a warp_field for "
-            "seeds_to_dti)"
-        ),
-    )
-    n_samples = traits.Int(
-        5000,
-        argstr="--nsamples=%d",
-        desc="number of samples - default=5000",
-        usedefault=True,
-    )
-    n_steps = traits.Int(
-        argstr="--nsteps=%d", desc="number of steps per sample - default=2000"
-    )
-    dist_thresh = traits.Float(
-        argstr="--distthresh=%.3f",
-        desc=("discards samples shorter than this " "threshold (in mm - default=0)"),
-    )
-    c_thresh = traits.Float(
-        argstr="--cthr=%.3f", desc="curvature threshold - default=0.2"
-    )
-    sample_random_points = traits.Bool(
-        argstr="--sampvox", desc=("sample random points within " "seed voxels")
-    )
-    step_length = traits.Float(
-        argstr="--steplength=%.3f", desc="step_length in mm - default=0.5"
-    )
-    loop_check = traits.Bool(
-        argstr="--loopcheck",
-        desc=(
-            "perform loop_checks on paths - slower, "
-            "but allows lower curvature threshold"
-        ),
-    )
-    use_anisotropy = traits.Bool(
-        argstr="--usef", desc="use anisotropy to constrain tracking"
-    )
-    rand_fib = traits.Enum(
-        0,
-        1,
-        2,
-        3,
-        argstr="--randfib=%d",
-        desc=(
-            "options: 0 - default, 1 - to randomly "
-            "sample initial fibres (with f > fibthresh), "
-            "2 - to sample in proportion fibres (with "
-            "f>fibthresh) to f, 3 - to sample ALL "
-            "populations at random (even if "
-            "f<fibthresh)"
-        ),
-    )
-    fibst = traits.Int(
-        argstr="--fibst=%d",
-        desc=(
-            "force a starting fibre for tracking - "
-            "default=1, i.e. first fibre orientation. Only "
-            "works if randfib==0"
-        ),
-    )
-    mod_euler = traits.Bool(argstr="--modeuler", desc="use modified euler streamlining")
-    random_seed = traits.Bool(argstr="--rseed", desc="random seed")
-    s2tastext = traits.Bool(
-        argstr="--s2tastext",
-        desc=(
-            "output seed-to-target counts as a text "
-            "file (useful when seeding from a mesh)"
-        ),
-    )
-    verbose = traits.Enum(
-        0,
-        1,
-        2,
-        desc=("Verbose level, [0-2]. Level 2 is required to " "output particle files."),
-        argstr="--verbose=%d",
-    )
-
-
-class ProbTrackX2OutputSpec(ProbTrackXOutputSpec):
-    network_matrix = File(
-        exists=True, desc=("the network matrix generated by --omatrix1 " "option")
-    )
-    matrix1_dot = File(exists=True, desc="Output matrix1.dot - SeedToSeed Connectivity")
-    lookup_tractspace = File(
-        exists=True, desc=("lookup_tractspace generated by " "--omatrix2 option")
-    )
-    matrix2_dot = File(exists=True, desc="Output matrix2.dot - SeedToLowResMask")
-    matrix3_dot = File(exists=True, desc="Output matrix3 - NxN connectivity matrix")
-
-
-class ProbTrackX2InputSpec(ProbTrackXBaseInputSpec):
-    simple = traits.Bool(
-        desc=(
-            "rack from a list of voxels (seed must be a " "ASCII list of coordinates)"
-        ),
-        argstr="--simple",
-    )
-    fopd = File(
-        exists=True,
-        desc="Other mask for binning tract distribution",
-        argstr="--fopd=%s",
-    )
-    waycond = traits.Enum(
-        "OR",
-        "AND",
-        argstr="--waycond=%s",
-        desc=('Waypoint condition. Either "AND" (default) ' 'or "OR"'),
-    )
-    wayorder = traits.Bool(
-        desc=(
-            "Reject streamlines that do not hit "
-            "waypoints in given order. Only valid if "
-            "waycond=AND"
-        ),
-        argstr="--wayorder",
-    )
-    onewaycondition = traits.Bool(
-        desc=("Apply waypoint conditions to each " "half tract separately"),
-        argstr="--onewaycondition",
-    )
-    omatrix1 = traits.Bool(
-        desc="Output matrix1 - SeedToSeed Connectivity", argstr="--omatrix1"
-    )
-    distthresh1 = traits.Float(
-        argstr="--distthresh1=%.3f",
-        desc=(
-            "Discards samples (in matrix1) shorter "
-            "than this threshold (in mm - "
-            "default=0)"
-        ),
-    )
-    omatrix2 = traits.Bool(
-        desc="Output matrix2 - SeedToLowResMask",
-        argstr="--omatrix2",
-        requires=["target2"],
-    )
-    target2 = File(
-        exists=True,
-        desc=(
-            "Low resolution binary brain mask for storing "
-            "connectivity distribution in matrix2 mode"
-        ),
-        argstr="--target2=%s",
-    )
-    omatrix3 = traits.Bool(
-        desc="Output matrix3 (NxN connectivity matrix)",
-        argstr="--omatrix3",
-        requires=["target3", "lrtarget3"],
-    )
-    target3 = File(
-        exists=True,
-        desc=("Mask used for NxN connectivity matrix (or Nxn if " "lrtarget3 is set)"),
-        argstr="--target3=%s",
-    )
-    lrtarget3 = File(
-        exists=True,
-        desc="Column-space mask used for Nxn connectivity matrix",
-        argstr="--lrtarget3=%s",
-    )
-    distthresh3 = traits.Float(
-        argstr="--distthresh3=%.3f",
-        desc=(
-            "Discards samples (in matrix3) shorter "
-            "than this threshold (in mm - "
-            "default=0)"
-        ),
-    )
-    omatrix4 = traits.Bool(
-        desc=("Output matrix4 - DtiMaskToSeed (special " "Oxford Sparse Format)"),
-        argstr="--omatrix4",
-    )
-    colmask4 = File(
-        exists=True,
-        desc="Mask for columns of matrix4 (default=seed mask)",
-        argstr="--colmask4=%s",
-    )
-    target4 = File(exists=True, desc="Brain mask in DTI space", argstr="--target4=%s")
-    meshspace = traits.Enum(
-        "caret",
-        "freesurfer",
-        "first",
-        "vox",
-        argstr="--meshspace=%s",
-        desc=(
-            'Mesh reference space - either "caret" '
-            '(default) or "freesurfer" or "first" or '
-            '"vox"'
-        ),
-    )
-
-
-class ProbTrackX2(ProbTrackX):
-    """Use FSL  probtrackx2 for tractography on bedpostx results
-
-    Examples
-    --------
-
-    >>> from nipype.interfaces import fsl
-    >>> pbx2 = fsl.ProbTrackX2()
-    >>> pbx2.inputs.seed = 'seed_source.nii.gz'
-    >>> pbx2.inputs.thsamples = 'merged_th1samples.nii.gz'
-    >>> pbx2.inputs.fsamples = 'merged_f1samples.nii.gz'
-    >>> pbx2.inputs.phsamples = 'merged_ph1samples.nii.gz'
-    >>> pbx2.inputs.mask = 'nodif_brain_mask.nii.gz'
-    >>> pbx2.inputs.out_dir = '.'
-    >>> pbx2.inputs.n_samples = 3
-    >>> pbx2.inputs.n_steps = 10
-    >>> pbx2.cmdline
-    'probtrackx2 --forcedir -m nodif_brain_mask.nii.gz --nsamples=3 --nsteps=10 --opd --dir=. --samples=merged --seed=seed_source.nii.gz'
-    """
-
-    _cmd = "probtrackx2"
-    input_spec = ProbTrackX2InputSpec
-    output_spec = ProbTrackX2OutputSpec
-
-    def _list_outputs(self):
-        outputs = super(ProbTrackX2, self)._list_outputs()
-
-        if self.inputs.out_dir is attrs.NOTHING:
-            out_dir = os.getcwd()
         else:
-            out_dir = self.inputs.out_dir
-
-        outputs["way_total"] = os.path.abspath(os.path.join(out_dir, "waytotal"))
-
-        if self.inputs.omatrix1 is not attrs.NOTHING:
-            outputs["network_matrix"] = os.path.abspath(
-                os.path.join(out_dir, "matrix_seeds_to_all_targets")
-            )
-            outputs["matrix1_dot"] = os.path.abspath(
-                os.path.join(out_dir, "fdt_matrix1.dot")
-            )
-
-        if self.inputs.omatrix2 is not attrs.NOTHING:
-            outputs["lookup_tractspace"] = os.path.abspath(
-                os.path.join(out_dir, "lookup_tractspace_fdt_matrix2.nii.gz")
-            )
-            outputs["matrix2_dot"] = os.path.abspath(
-                os.path.join(out_dir, "fdt_matrix2.dot")
+            outputs["fdt_paths"] = os.path.abspath(
+                _gen_fname(
+                    "fdt_paths",
+                    cwd=out_dir,
+                    suffix="",
+                    inputs=inputs,
+                    stdout=stdout,
+                    stderr=stderr,
+                    output_dir=output_dir,
+                )
             )
 
-        if self.inputs.omatrix3 is not attrs.NOTHING:
-            outputs["matrix3_dot"] = os.path.abspath(
-                os.path.join(out_dir, "fdt_matrix3.dot")
+    # handle seeds-to-target output files
+    if inputs.target_masks is not attrs.NOTHING:
+        outputs["targets"] = []
+        for target in inputs.target_masks:
+            outputs["targets"].append(
+                os.path.abspath(
+                    _gen_fname(
+                        "seeds_to_" + os.path.split(target)[1],
+                        cwd=out_dir,
+                        suffix="",
+                        inputs=inputs,
+                        stdout=stdout,
+                        stderr=stderr,
+                        output_dir=output_dir,
+                    )
+                )
             )
-        return outputs
+    if (inputs.verbose is not attrs.NOTHING) and inputs.verbose == 2:
+        outputs["particle_files"] = [
+            os.path.abspath(os.path.join(out_dir, "particle%d" % i))
+            for i in range(inputs.n_samples)
+        ]
+    return outputs
 
 
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
@@ -1149,7 +407,7 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
 
 
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = super(ProbTrackX2, self)._list_outputs()
+    outputs = nipype_interfaces_fsl_dti__ProbTrackX___list_outputs()
 
     if inputs.out_dir is attrs.NOTHING:
         out_dir = output_dir
diff --git a/example-specs/task/nipype/fsl/prob_track_x_callables.py b/example-specs/task/nipype/fsl/prob_track_x_callables.py
index 19e8b343..4dd86139 100644
--- a/example-specs/task/nipype/fsl/prob_track_x_callables.py
+++ b/example-specs/task/nipype/fsl/prob_track_x_callables.py
@@ -1,11 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of ProbTrackX.yaml"""
 
-from glob import glob
-import attrs
 import os
+import attrs
 import os.path as op
-from pathlib import Path
 import logging
+from glob import glob
 
 
 def mode_default(inputs):
@@ -16,139 +15,42 @@ def out_dir_default(inputs):
     return _gen_filename("out_dir", inputs=inputs)
 
 
-def mode_callable(output_dir, inputs, stdout, stderr):
+def log_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["mode"]
+    return outputs["log"]
 
 
-def out_dir_callable(output_dir, inputs, stdout, stderr):
+def fdt_paths_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_dir"]
-
+    return outputs["fdt_paths"]
 
-IFLOGGER = logging.getLogger("nipype.interface")
-
-
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "out_dir":
-        return output_dir
-    elif name == "mode":
-        if isinstance(inputs.seed, list) and isinstance(inputs.seed[0], list):
-            return "simple"
-        else:
-            return "seedmask"
 
+def way_total_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["way_total"]
 
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    if inputs.out_dir is attrs.NOTHING:
-        out_dir = _gen_filename(
-            "out_dir",
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-    else:
-        out_dir = inputs.out_dir
 
-    outputs["log"] = os.path.abspath(os.path.join(out_dir, "probtrackx.log"))
-    # outputs['way_total'] = os.path.abspath(os.path.join(out_dir,
-    #                                                    'waytotal'))
-    if isdefined(inputs.opd is True):
-        if isinstance(inputs.seed, list) and isinstance(inputs.seed[0], list):
-            outputs["fdt_paths"] = []
-            for seed in inputs.seed:
-                outputs["fdt_paths"].append(
-                    os.path.abspath(
-                        _gen_fname(
-                            ("fdt_paths_%s" % ("_".join([str(s) for s in seed]))),
-                            cwd=out_dir,
-                            suffix="",
-                            inputs=inputs,
-                            stdout=stdout,
-                            stderr=stderr,
-                            output_dir=output_dir,
-                        )
-                    )
-                )
-        else:
-            outputs["fdt_paths"] = os.path.abspath(
-                _gen_fname(
-                    "fdt_paths",
-                    cwd=out_dir,
-                    suffix="",
-                    inputs=inputs,
-                    stdout=stdout,
-                    stderr=stderr,
-                    output_dir=output_dir,
-                )
-            )
-
-    # handle seeds-to-target output files
-    if inputs.target_masks is not attrs.NOTHING:
-        outputs["targets"] = []
-        for target in inputs.target_masks:
-            outputs["targets"].append(
-                os.path.abspath(
-                    _gen_fname(
-                        "seeds_to_" + os.path.split(target)[1],
-                        cwd=out_dir,
-                        suffix="",
-                        inputs=inputs,
-                        stdout=stdout,
-                        stderr=stderr,
-                        output_dir=output_dir,
-                    )
-                )
-            )
-    if inputs.verbose is not attrs.NOTHING and inputs.verbose == 2:
-        outputs["particle_files"] = [
-            os.path.abspath(os.path.join(out_dir, "particle%d" % i))
-            for i in range(inputs.n_samples)
-        ]
-    return outputs
+def targets_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["targets"]
 
 
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
+def particle_files_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["particle_files"]
 
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
-
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
-
-            klass._version = klass.parse_version(raw_info)
-
-        return klass._version
 
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+IFLOGGER = logging.getLogger("nipype.interface")
 
 
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
@@ -177,8 +79,8 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     >>> fname_presuffix(fname,'pre','post','/tmp')
     '/tmp/prefoopost.nii.gz'
 
-    >>> from nipype.interfaces.base import Undefined
-    >>> fname_presuffix(fname, 'pre', 'post', Undefined) == \
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
             fname_presuffix(fname, 'pre', 'post')
     True
 
@@ -187,7 +89,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     if not use_ext:
         ext = ""
 
-    # No need for isdefined: bool(Undefined) evaluates to False
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
     if newpath:
         pth = op.abspath(newpath)
     return op.join(pth, prefix + fname + suffix + ext)
@@ -388,3 +290,84 @@ def _gen_fname(
         suffix = ""
     fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
     return fname
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_dir":
+        return output_dir
+    elif name == "mode":
+        if isinstance(inputs.seed, list) and isinstance(inputs.seed[0], list):
+            return "simple"
+        else:
+            return "seedmask"
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    if inputs.out_dir is attrs.NOTHING:
+        out_dir = _gen_filename(
+            "out_dir",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    else:
+        out_dir = inputs.out_dir
+
+    outputs["log"] = os.path.abspath(os.path.join(out_dir, "probtrackx.log"))
+    # outputs['way_total'] = os.path.abspath(os.path.join(out_dir,
+    #                                                    'waytotal'))
+    if inputs.opd is True is not attrs.NOTHING:
+        if isinstance(inputs.seed, list) and isinstance(inputs.seed[0], list):
+            outputs["fdt_paths"] = []
+            for seed in inputs.seed:
+                outputs["fdt_paths"].append(
+                    os.path.abspath(
+                        _gen_fname(
+                            ("fdt_paths_%s" % ("_".join([str(s) for s in seed]))),
+                            cwd=out_dir,
+                            suffix="",
+                            inputs=inputs,
+                            stdout=stdout,
+                            stderr=stderr,
+                            output_dir=output_dir,
+                        )
+                    )
+                )
+        else:
+            outputs["fdt_paths"] = os.path.abspath(
+                _gen_fname(
+                    "fdt_paths",
+                    cwd=out_dir,
+                    suffix="",
+                    inputs=inputs,
+                    stdout=stdout,
+                    stderr=stderr,
+                    output_dir=output_dir,
+                )
+            )
+
+    # handle seeds-to-target output files
+    if inputs.target_masks is not attrs.NOTHING:
+        outputs["targets"] = []
+        for target in inputs.target_masks:
+            outputs["targets"].append(
+                os.path.abspath(
+                    _gen_fname(
+                        "seeds_to_" + os.path.split(target)[1],
+                        cwd=out_dir,
+                        suffix="",
+                        inputs=inputs,
+                        stdout=stdout,
+                        stderr=stderr,
+                        output_dir=output_dir,
+                    )
+                )
+            )
+    if (inputs.verbose is not attrs.NOTHING) and inputs.verbose == 2:
+        outputs["particle_files"] = [
+            os.path.abspath(os.path.join(out_dir, "particle%d" % i))
+            for i in range(inputs.n_samples)
+        ]
+    return outputs
diff --git a/example-specs/task/nipype/fsl/proj_thresh.yaml b/example-specs/task/nipype/fsl/proj_thresh.yaml
index 7f0fea03..872965ed 100644
--- a/example-specs/task/nipype/fsl/proj_thresh.yaml
+++ b/example-specs/task/nipype/fsl/proj_thresh.yaml
@@ -48,6 +48,8 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    out_files: generic/file+list-of
+    # type=list: path/name of output volume after thresholding
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/fsl/proj_thresh_callables.py b/example-specs/task/nipype/fsl/proj_thresh_callables.py
index dd6e1c7b..f357252e 100644
--- a/example-specs/task/nipype/fsl/proj_thresh_callables.py
+++ b/example-specs/task/nipype/fsl/proj_thresh_callables.py
@@ -1 +1,278 @@
 """Module to put any functions that are referred to in the "callables" section of ProjThresh.yaml"""
+
+import os
+import os.path as op
+import logging
+from glob import glob
+
+
+def out_files_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_files"]
+
+
+IFLOGGER = logging.getLogger("nipype.interface")
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """
+    Handle FSL ``output_type`` and version information.
+
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
+
+    """
+
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
+
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
+
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
+
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
+
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
+
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
+
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
+
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
+
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
+
+        Returns a list of standard images if called without arguments.
+
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
+
+
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
+
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
+
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
+
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "proj_thresh"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_files"] = []
+    for name in inputs.in_files:
+        cwd, base_name = os.path.split(name)
+        outputs["out_files"].append(
+            _gen_fname(
+                base_name,
+                cwd=cwd,
+                suffix="_proj_seg_thr_{}".format(inputs.threshold),
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+        )
+    return outputs
diff --git a/example-specs/task/nipype/fsl/randomise.yaml b/example-specs/task/nipype/fsl/randomise.yaml
index c692d1d4..32a36403 100644
--- a/example-specs/task/nipype/fsl/randomise.yaml
+++ b/example-specs/task/nipype/fsl/randomise.yaml
@@ -56,6 +56,18 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    f_corrected_p_files: generic/file+list-of
+    # type=list: f contrast FWE (Family-wise error) corrected p values files
+    f_p_files: generic/file+list-of
+    # type=list: f contrast uncorrected p values files
+    fstat_files: generic/file+list-of
+    # type=list: f contrast raw statistic
+    t_corrected_p_files: generic/file+list-of
+    # type=list: t contrast FWE (Family-wise error) corrected p values files
+    t_p_files: generic/file+list-of
+    # type=list: f contrast uncorrected p values files
+    tstat_files: generic/file+list-of
+    # type=list: t contrast raw statistic
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/fsl/randomise_callables.py b/example-specs/task/nipype/fsl/randomise_callables.py
index dad09814..85d1bc20 100644
--- a/example-specs/task/nipype/fsl/randomise_callables.py
+++ b/example-specs/task/nipype/fsl/randomise_callables.py
@@ -1 +1,364 @@
 """Module to put any functions that are referred to in the "callables" section of Randomise.yaml"""
+
+import os
+import os.path as op
+import logging
+from glob import glob
+
+
+def tstat_files_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["tstat_files"]
+
+
+def fstat_files_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["fstat_files"]
+
+
+def t_p_files_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["t_p_files"]
+
+
+def f_p_files_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["f_p_files"]
+
+
+def t_corrected_p_files_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["t_corrected_p_files"]
+
+
+def f_corrected_p_files_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["f_corrected_p_files"]
+
+
+IFLOGGER = logging.getLogger("nipype.interface")
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """
+    Handle FSL ``output_type`` and version information.
+
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
+
+    """
+
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
+
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
+
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
+
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
+
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
+
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
+
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
+
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
+
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
+
+        Returns a list of standard images if called without arguments.
+
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
+
+
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
+
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
+
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
+
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "randomise"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["tstat_files"] = glob(
+        _gen_fname(
+            "%s_tstat*.nii" % inputs.base_name,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    )
+    outputs["fstat_files"] = glob(
+        _gen_fname(
+            "%s_fstat*.nii" % inputs.base_name,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    )
+    prefix = False
+    if inputs.tfce or inputs.tfce2D:
+        prefix = "tfce"
+    elif inputs.vox_p_values:
+        prefix = "vox"
+    elif inputs.c_thresh or inputs.f_c_thresh:
+        prefix = "clustere"
+    elif inputs.cm_thresh or inputs.f_cm_thresh:
+        prefix = "clusterm"
+    if prefix:
+        outputs["t_p_files"] = glob(
+            _gen_fname(
+                "%s_%s_p_tstat*" % (inputs.base_name, prefix),
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+        )
+        outputs["t_corrected_p_files"] = glob(
+            _gen_fname(
+                "%s_%s_corrp_tstat*.nii" % (inputs.base_name, prefix),
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+        )
+
+        outputs["f_p_files"] = glob(
+            _gen_fname(
+                "%s_%s_p_fstat*.nii" % (inputs.base_name, prefix),
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+        )
+        outputs["f_corrected_p_files"] = glob(
+            _gen_fname(
+                "%s_%s_corrp_fstat*.nii" % (inputs.base_name, prefix),
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+        )
+    return outputs
diff --git a/example-specs/task/nipype/fsl/reorient_2_std_callables.py b/example-specs/task/nipype/fsl/reorient_2_std_callables.py
index c2c600d6..78710bd2 100644
--- a/example-specs/task/nipype/fsl/reorient_2_std_callables.py
+++ b/example-specs/task/nipype/fsl/reorient_2_std_callables.py
@@ -1 +1,288 @@
 """Module to put any functions that are referred to in the "callables" section of Reorient2Std.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+from glob import glob
+
+
+def out_file_default(inputs):
+    return _gen_filename("out_file", inputs=inputs)
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+IFLOGGER = logging.getLogger("nipype.interface")
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """
+    Handle FSL ``output_type`` and version information.
+
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
+
+    """
+
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
+
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
+
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
+
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
+
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
+
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
+
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
+
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
+
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
+
+        Returns a list of standard images if called without arguments.
+
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
+
+
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
+
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
+
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
+
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "fslreorient2std"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _gen_fname(
+            inputs.in_file,
+            suffix="_reoriented",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    return None
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    if inputs.out_file is attrs.NOTHING:
+        outputs["out_file"] = _gen_filename(
+            "out_file",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    else:
+        outputs["out_file"] = os.path.abspath(inputs.out_file)
+    return outputs
diff --git a/example-specs/task/nipype/fsl/robust_fov_callables.py b/example-specs/task/nipype/fsl/robust_fov_callables.py
index a37d6861..7c9e0402 100644
--- a/example-specs/task/nipype/fsl/robust_fov_callables.py
+++ b/example-specs/task/nipype/fsl/robust_fov_callables.py
@@ -1 +1,290 @@
 """Module to put any functions that are referred to in the "callables" section of RobustFOV.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+from glob import glob
+
+
+def out_roi_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_roi"]
+
+
+def out_transform_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_transform"]
+
+
+IFLOGGER = logging.getLogger("nipype.interface")
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+class Info(PackageInfo):
+    """
+    Handle FSL ``output_type`` and version information.
+
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
+
+    """
+
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
+
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
+
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
+
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
+
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
+
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
+
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
+
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
+
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
+
+        Returns a list of standard images if called without arguments.
+
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value + Info.output_type_to_ext(inputs.output_type)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
diff --git a/example-specs/task/nipype/fsl/sig_loss_callables.py b/example-specs/task/nipype/fsl/sig_loss_callables.py
index 0e195a9f..4e870b47 100644
--- a/example-specs/task/nipype/fsl/sig_loss_callables.py
+++ b/example-specs/task/nipype/fsl/sig_loss_callables.py
@@ -1 +1,283 @@
 """Module to put any functions that are referred to in the "callables" section of SigLoss.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+from glob import glob
+
+
+def out_file_default(inputs):
+    return _gen_filename("out_file", inputs=inputs)
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+IFLOGGER = logging.getLogger("nipype.interface")
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """
+    Handle FSL ``output_type`` and version information.
+
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
+
+    """
+
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
+
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
+
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
+
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
+
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
+
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
+
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
+
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
+
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
+
+        Returns a list of standard images if called without arguments.
+
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
+
+
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
+
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
+
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
+
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "sigloss"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )["out_file"]
+    return None
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = inputs.out_file
+    if (outputs["out_file"] is attrs.NOTHING) and (inputs.in_file is not attrs.NOTHING):
+        outputs["out_file"] = _gen_fname(
+            inputs.in_file,
+            suffix="_sigloss",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    return outputs
diff --git a/example-specs/task/nipype/fsl/slice.yaml b/example-specs/task/nipype/fsl/slice.yaml
index b4dcfc94..887de4e9 100644
--- a/example-specs/task/nipype/fsl/slice.yaml
+++ b/example-specs/task/nipype/fsl/slice.yaml
@@ -49,6 +49,8 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    out_files: generic/file+list-of
+    # type=outputmultiobject: 
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/fsl/slice_callables.py b/example-specs/task/nipype/fsl/slice_callables.py
index 005d7999..62b03cc6 100644
--- a/example-specs/task/nipype/fsl/slice_callables.py
+++ b/example-specs/task/nipype/fsl/slice_callables.py
@@ -1 +1,138 @@
 """Module to put any functions that are referred to in the "callables" section of Slice.yaml"""
+
+import os
+from glob import glob
+import attrs
+import os.path as op
+
+
+def out_files_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_files"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    """Create a Bunch which contains all possible files generated
+    by running the interface.  Some files are always generated, others
+    depending on which ``inputs`` options are set.
+
+    Returns
+    -------
+
+    outputs : Bunch object
+        Bunch object containing all possible files generated by
+        interface object.
+
+        If None, file was not generated
+        Else, contains path, filename of generated outputfile
+
+    """
+    outputs = {}
+    ext = Info.output_type_to_ext(inputs.output_type)
+    suffix = "_slice_*" + ext
+    if inputs.out_base_name is not attrs.NOTHING:
+        fname_template = os.path.abspath(inputs.out_base_name + suffix)
+    else:
+        fname_template = fname_presuffix(inputs.in_file, suffix=suffix, use_ext=False)
+
+    outputs["out_files"] = sorted(glob(fname_template))
+
+    return outputs
diff --git a/example-specs/task/nipype/fsl/slice_timer_callables.py b/example-specs/task/nipype/fsl/slice_timer_callables.py
index 80734620..8546a28d 100644
--- a/example-specs/task/nipype/fsl/slice_timer_callables.py
+++ b/example-specs/task/nipype/fsl/slice_timer_callables.py
@@ -1,88 +1,26 @@
 """Module to put any functions that are referred to in the "callables" section of SliceTimer.yaml"""
 
-from glob import glob
-import attrs
 import os
+import attrs
 import os.path as op
-from pathlib import Path
 import logging
+from glob import glob
 
 
 def out_file_default(inputs):
     return _gen_filename("out_file", inputs=inputs)
 
 
-def out_file_callable(output_dir, inputs, stdout, stderr):
+def slice_time_corrected_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_file"]
+    return outputs["slice_time_corrected_file"]
 
 
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "out_file":
-        return _list_outputs(
-            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-        )["slice_time_corrected_file"]
-    return None
-
-
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    out_file = inputs.out_file
-    if out_file is attrs.NOTHING:
-        out_file = _gen_fname(
-            inputs.in_file,
-            suffix="_st",
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-    outputs["slice_time_corrected_file"] = os.path.abspath(out_file)
-    return outputs
-
-
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
-
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
-
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
-
-            klass._version = klass.parse_version(raw_info)
-
-        return klass._version
-
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
-
-
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -109,8 +47,8 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     >>> fname_presuffix(fname,'pre','post','/tmp')
     '/tmp/prefoopost.nii.gz'
 
-    >>> from nipype.interfaces.base import Undefined
-    >>> fname_presuffix(fname, 'pre', 'post', Undefined) == \
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
             fname_presuffix(fname, 'pre', 'post')
     True
 
@@ -119,7 +57,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     if not use_ext:
         ext = ""
 
-    # No need for isdefined: bool(Undefined) evaluates to False
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
     if newpath:
         pth = op.abspath(newpath)
     return op.join(pth, prefix + fname + suffix + ext)
@@ -320,3 +258,27 @@ def _gen_fname(
         suffix = ""
     fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
     return fname
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )["slice_time_corrected_file"]
+    return None
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    out_file = inputs.out_file
+    if out_file is attrs.NOTHING:
+        out_file = _gen_fname(
+            inputs.in_file,
+            suffix="_st",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    outputs["slice_time_corrected_file"] = os.path.abspath(out_file)
+    return outputs
diff --git a/example-specs/task/nipype/fsl/slicer_callables.py b/example-specs/task/nipype/fsl/slicer_callables.py
index c50250bb..2d757273 100644
--- a/example-specs/task/nipype/fsl/slicer_callables.py
+++ b/example-specs/task/nipype/fsl/slicer_callables.py
@@ -1 +1,284 @@
 """Module to put any functions that are referred to in the "callables" section of Slicer.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+from glob import glob
+
+
+def out_file_default(inputs):
+    return _gen_filename("out_file", inputs=inputs)
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+IFLOGGER = logging.getLogger("nipype.interface")
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """
+    Handle FSL ``output_type`` and version information.
+
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
+
+    """
+
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
+
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
+
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
+
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
+
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
+
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
+
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
+
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
+
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
+
+        Returns a list of standard images if called without arguments.
+
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
+
+
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
+
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
+
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
+
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "slicer"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )["out_file"]
+    return None
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    out_file = inputs.out_file
+    if out_file is attrs.NOTHING:
+        out_file = _gen_fname(
+            inputs.in_file,
+            ext=".png",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    outputs["out_file"] = os.path.abspath(out_file)
+    return outputs
diff --git a/example-specs/task/nipype/fsl/smm_callables.py b/example-specs/task/nipype/fsl/smm_callables.py
index 6368393a..8947521b 100644
--- a/example-specs/task/nipype/fsl/smm_callables.py
+++ b/example-specs/task/nipype/fsl/smm_callables.py
@@ -1 +1,307 @@
 """Module to put any functions that are referred to in the "callables" section of SMM.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+from glob import glob
+
+
+def null_p_map_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["null_p_map"]
+
+
+def activation_p_map_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["activation_p_map"]
+
+
+def deactivation_p_map_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["deactivation_p_map"]
+
+
+IFLOGGER = logging.getLogger("nipype.interface")
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """
+    Handle FSL ``output_type`` and version information.
+
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
+
+    """
+
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
+
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
+
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
+
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
+
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
+
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
+
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
+
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
+
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
+
+        Returns a list of standard images if called without arguments.
+
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
+
+
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
+
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
+
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
+
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "mm --ld=logdir"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    # TODO get the true logdir from the stdout
+    outputs["null_p_map"] = _gen_fname(
+        basename="w1_mean",
+        cwd="logdir",
+        inputs=inputs,
+        stdout=stdout,
+        stderr=stderr,
+        output_dir=output_dir,
+    )
+    outputs["activation_p_map"] = _gen_fname(
+        basename="w2_mean",
+        cwd="logdir",
+        inputs=inputs,
+        stdout=stdout,
+        stderr=stderr,
+        output_dir=output_dir,
+    )
+    if (
+        inputs.no_deactivation_class is attrs.NOTHING
+    ) or not inputs.no_deactivation_class:
+        outputs["deactivation_p_map"] = _gen_fname(
+            basename="w3_mean",
+            cwd="logdir",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    return outputs
diff --git a/example-specs/task/nipype/fsl/smooth_callables.py b/example-specs/task/nipype/fsl/smooth_callables.py
index 277b109d..00d34e56 100644
--- a/example-specs/task/nipype/fsl/smooth_callables.py
+++ b/example-specs/task/nipype/fsl/smooth_callables.py
@@ -1 +1,283 @@
 """Module to put any functions that are referred to in the "callables" section of Smooth.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+from glob import glob
+
+
+def smoothed_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["smoothed_file"]
+
+
+IFLOGGER = logging.getLogger("nipype.interface")
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+class Info(PackageInfo):
+    """
+    Handle FSL ``output_type`` and version information.
+
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
+
+    """
+
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
+
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
+
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
+
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
+
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
+
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
+
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
+
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
+
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
+
+        Returns a list of standard images if called without arguments.
+
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value + Info.output_type_to_ext(inputs.output_type)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
diff --git a/example-specs/task/nipype/fsl/smooth_estimate.yaml b/example-specs/task/nipype/fsl/smooth_estimate.yaml
index ae8d0708..6ce6c70e 100644
--- a/example-specs/task/nipype/fsl/smooth_estimate.yaml
+++ b/example-specs/task/nipype/fsl/smooth_estimate.yaml
@@ -53,6 +53,12 @@ outputs:
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
+    dlh: dlh_callable
+    # type=float: smoothness estimate sqrt(det(Lambda))
+    resels: resels_callable
+    # type=float: volume of resel, in voxels, defined as FWHM_x * FWHM_y * FWHM_z
+    volume: volume_callable
+    # type=int: number of voxels in mask
   templates:
   # dict[str, str] - `output_file_template` values to be provided to output fields
   requirements:
diff --git a/example-specs/task/nipype/fsl/smooth_estimate_callables.py b/example-specs/task/nipype/fsl/smooth_estimate_callables.py
index a2168bae..20aaec48 100644
--- a/example-specs/task/nipype/fsl/smooth_estimate_callables.py
+++ b/example-specs/task/nipype/fsl/smooth_estimate_callables.py
@@ -1 +1,297 @@
 """Module to put any functions that are referred to in the "callables" section of SmoothEstimate.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+from glob import glob
+
+
+def dlh_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["dlh"]
+
+
+def volume_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["volume"]
+
+
+def resels_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["resels"]
+
+
+IFLOGGER = logging.getLogger("nipype.interface")
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+class Info(PackageInfo):
+    """
+    Handle FSL ``output_type`` and version information.
+
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
+
+    """
+
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
+
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
+
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
+
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
+
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
+
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
+
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
+
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
+
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
+
+        Returns a list of standard images if called without arguments.
+
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value + Info.output_type_to_ext(inputs.output_type)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
diff --git a/example-specs/task/nipype/fsl/spatial_filter_callables.py b/example-specs/task/nipype/fsl/spatial_filter_callables.py
index 99a68b98..03912482 100644
--- a/example-specs/task/nipype/fsl/spatial_filter_callables.py
+++ b/example-specs/task/nipype/fsl/spatial_filter_callables.py
@@ -1 +1,284 @@
 """Module to put any functions that are referred to in the "callables" section of SpatialFilter.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+from glob import glob
+
+
+def out_file_default(inputs):
+    return _gen_filename("out_file", inputs=inputs)
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+IFLOGGER = logging.getLogger("nipype.interface")
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """
+    Handle FSL ``output_type`` and version information.
+
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
+
+    """
+
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
+
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
+
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
+
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
+
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
+
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
+
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
+
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
+
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
+
+        Returns a list of standard images if called without arguments.
+
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
+
+
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
+
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
+
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
+
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "fslmaths"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )["out_file"]
+    return None
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = inputs.out_file
+    if inputs.out_file is attrs.NOTHING:
+        outputs["out_file"] = _gen_fname(
+            inputs.in_file,
+            suffix=_suffix,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    outputs["out_file"] = os.path.abspath(outputs["out_file"])
+    return outputs
diff --git a/example-specs/task/nipype/fsl/split.yaml b/example-specs/task/nipype/fsl/split.yaml
index 5d2a4e8c..c2998b78 100644
--- a/example-specs/task/nipype/fsl/split.yaml
+++ b/example-specs/task/nipype/fsl/split.yaml
@@ -37,6 +37,8 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    out_files: generic/file+list-of
+    # type=outputmultiobject: 
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/fsl/split_callables.py b/example-specs/task/nipype/fsl/split_callables.py
index ea00acce..639debd0 100644
--- a/example-specs/task/nipype/fsl/split_callables.py
+++ b/example-specs/task/nipype/fsl/split_callables.py
@@ -1 +1,41 @@
 """Module to put any functions that are referred to in the "callables" section of Split.yaml"""
+
+import os
+from glob import glob
+import attrs
+
+
+def out_files_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_files"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    """Create a Bunch which contains all possible files generated
+    by running the interface.  Some files are always generated, others
+    depending on which ``inputs`` options are set.
+
+    Returns
+    -------
+
+    outputs : Bunch object
+        Bunch object containing all possible files generated by
+        interface object.
+
+        If None, file was not generated
+        Else, contains path, filename of generated outputfile
+
+    """
+    outputs = {}
+    ext = Info.output_type_to_ext(inputs.output_type)
+    outbase = "vol[0-9]*"
+    if inputs.out_base_name is not attrs.NOTHING:
+        outbase = "%s[0-9]*" % inputs.out_base_name
+    outputs["out_files"] = sorted(glob(os.path.join(output_dir, outbase + ext)))
+    return outputs
diff --git a/example-specs/task/nipype/fsl/std_image_callables.py b/example-specs/task/nipype/fsl/std_image_callables.py
index 8dabe984..c1ae7ce5 100644
--- a/example-specs/task/nipype/fsl/std_image_callables.py
+++ b/example-specs/task/nipype/fsl/std_image_callables.py
@@ -1 +1,284 @@
 """Module to put any functions that are referred to in the "callables" section of StdImage.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+from glob import glob
+
+
+def out_file_default(inputs):
+    return _gen_filename("out_file", inputs=inputs)
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+IFLOGGER = logging.getLogger("nipype.interface")
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """
+    Handle FSL ``output_type`` and version information.
+
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
+
+    """
+
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
+
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
+
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
+
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
+
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
+
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
+
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
+
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
+
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
+
+        Returns a list of standard images if called without arguments.
+
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
+
+
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
+
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
+
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
+
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "fslmaths"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )["out_file"]
+    return None
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = inputs.out_file
+    if inputs.out_file is attrs.NOTHING:
+        outputs["out_file"] = _gen_fname(
+            inputs.in_file,
+            suffix=_suffix,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    outputs["out_file"] = os.path.abspath(outputs["out_file"])
+    return outputs
diff --git a/example-specs/task/nipype/fsl/susan_callables.py b/example-specs/task/nipype/fsl/susan_callables.py
index fdfecf82..5d8ac242 100644
--- a/example-specs/task/nipype/fsl/susan_callables.py
+++ b/example-specs/task/nipype/fsl/susan_callables.py
@@ -1,88 +1,26 @@
 """Module to put any functions that are referred to in the "callables" section of SUSAN.yaml"""
 
-from glob import glob
-import attrs
 import os
+import attrs
 import os.path as op
-from pathlib import Path
 import logging
+from glob import glob
 
 
 def out_file_default(inputs):
     return _gen_filename("out_file", inputs=inputs)
 
 
-def out_file_callable(output_dir, inputs, stdout, stderr):
+def smoothed_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_file"]
+    return outputs["smoothed_file"]
 
 
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "out_file":
-        return _list_outputs(
-            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-        )["smoothed_file"]
-    return None
-
-
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    out_file = inputs.out_file
-    if out_file is attrs.NOTHING:
-        out_file = _gen_fname(
-            inputs.in_file,
-            suffix="_smooth",
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-    outputs["smoothed_file"] = os.path.abspath(out_file)
-    return outputs
-
-
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
-
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
-
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
-
-            klass._version = klass.parse_version(raw_info)
-
-        return klass._version
-
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
-
-
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -109,8 +47,8 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     >>> fname_presuffix(fname,'pre','post','/tmp')
     '/tmp/prefoopost.nii.gz'
 
-    >>> from nipype.interfaces.base import Undefined
-    >>> fname_presuffix(fname, 'pre', 'post', Undefined) == \
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
             fname_presuffix(fname, 'pre', 'post')
     True
 
@@ -119,7 +57,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     if not use_ext:
         ext = ""
 
-    # No need for isdefined: bool(Undefined) evaluates to False
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
     if newpath:
         pth = op.abspath(newpath)
     return op.join(pth, prefix + fname + suffix + ext)
@@ -320,3 +258,27 @@ def _gen_fname(
         suffix = ""
     fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
     return fname
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )["smoothed_file"]
+    return None
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    out_file = inputs.out_file
+    if out_file is attrs.NOTHING:
+        out_file = _gen_fname(
+            inputs.in_file,
+            suffix="_smooth",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    outputs["smoothed_file"] = os.path.abspath(out_file)
+    return outputs
diff --git a/example-specs/task/nipype/fsl/swap_dimensions_callables.py b/example-specs/task/nipype/fsl/swap_dimensions_callables.py
index da4e9b2c..992d84ce 100644
--- a/example-specs/task/nipype/fsl/swap_dimensions_callables.py
+++ b/example-specs/task/nipype/fsl/swap_dimensions_callables.py
@@ -1 +1,284 @@
 """Module to put any functions that are referred to in the "callables" section of SwapDimensions.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+from glob import glob
+
+
+def out_file_default(inputs):
+    return _gen_filename("out_file", inputs=inputs)
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+IFLOGGER = logging.getLogger("nipype.interface")
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """
+    Handle FSL ``output_type`` and version information.
+
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
+
+    """
+
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
+
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
+
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
+
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
+
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
+
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
+
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
+
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
+
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
+
+        Returns a list of standard images if called without arguments.
+
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
+
+
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
+
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
+
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
+
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "fslswapdim"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )["out_file"]
+    return None
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = inputs.out_file
+    if inputs.out_file is attrs.NOTHING:
+        outputs["out_file"] = _gen_fname(
+            inputs.in_file,
+            suffix="_newdims",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    outputs["out_file"] = os.path.abspath(outputs["out_file"])
+    return outputs
diff --git a/example-specs/task/nipype/fsl/temporal_filter_callables.py b/example-specs/task/nipype/fsl/temporal_filter_callables.py
index aceb51d3..f62b0b52 100644
--- a/example-specs/task/nipype/fsl/temporal_filter_callables.py
+++ b/example-specs/task/nipype/fsl/temporal_filter_callables.py
@@ -1 +1,284 @@
 """Module to put any functions that are referred to in the "callables" section of TemporalFilter.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+from glob import glob
+
+
+def out_file_default(inputs):
+    return _gen_filename("out_file", inputs=inputs)
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+IFLOGGER = logging.getLogger("nipype.interface")
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """
+    Handle FSL ``output_type`` and version information.
+
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
+
+    """
+
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
+
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
+
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
+
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
+
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
+
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
+
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
+
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
+
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
+
+        Returns a list of standard images if called without arguments.
+
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
+
+
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
+
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
+
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
+
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "fslmaths"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )["out_file"]
+    return None
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = inputs.out_file
+    if inputs.out_file is attrs.NOTHING:
+        outputs["out_file"] = _gen_fname(
+            inputs.in_file,
+            suffix=_suffix,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    outputs["out_file"] = os.path.abspath(outputs["out_file"])
+    return outputs
diff --git a/example-specs/task/nipype/fsl/text_2_vest_callables.py b/example-specs/task/nipype/fsl/text_2_vest_callables.py
index 3f719aa1..a3e14842 100644
--- a/example-specs/task/nipype/fsl/text_2_vest_callables.py
+++ b/example-specs/task/nipype/fsl/text_2_vest_callables.py
@@ -1 +1,283 @@
 """Module to put any functions that are referred to in the "callables" section of Text2Vest.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+from glob import glob
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+IFLOGGER = logging.getLogger("nipype.interface")
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+class Info(PackageInfo):
+    """
+    Handle FSL ``output_type`` and version information.
+
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
+
+    """
+
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
+
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
+
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
+
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
+
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
+
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
+
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
+
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
+
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
+
+        Returns a list of standard images if called without arguments.
+
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value + Info.output_type_to_ext(inputs.output_type)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
diff --git a/example-specs/task/nipype/fsl/threshold_callables.py b/example-specs/task/nipype/fsl/threshold_callables.py
index f5f33571..f5cd1f08 100644
--- a/example-specs/task/nipype/fsl/threshold_callables.py
+++ b/example-specs/task/nipype/fsl/threshold_callables.py
@@ -1 +1,284 @@
 """Module to put any functions that are referred to in the "callables" section of Threshold.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+from glob import glob
+
+
+def out_file_default(inputs):
+    return _gen_filename("out_file", inputs=inputs)
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+IFLOGGER = logging.getLogger("nipype.interface")
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """
+    Handle FSL ``output_type`` and version information.
+
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
+
+    """
+
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
+
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
+
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
+
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
+
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
+
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
+
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
+
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
+
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
+
+        Returns a list of standard images if called without arguments.
+
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
+
+
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
+
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
+
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
+
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "fslmaths"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )["out_file"]
+    return None
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = inputs.out_file
+    if inputs.out_file is attrs.NOTHING:
+        outputs["out_file"] = _gen_fname(
+            inputs.in_file,
+            suffix=_suffix,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    outputs["out_file"] = os.path.abspath(outputs["out_file"])
+    return outputs
diff --git a/example-specs/task/nipype/fsl/topup.yaml b/example-specs/task/nipype/fsl/topup.yaml
index b02c52ee..27c1f78c 100644
--- a/example-specs/task/nipype/fsl/topup.yaml
+++ b/example-specs/task/nipype/fsl/topup.yaml
@@ -79,11 +79,17 @@ outputs:
     # type=file|default=<undefined>: name of image file with field (Hz)
     out_fieldcoef: generic/file
     # type=file: file containing the field coefficients
+    out_jacs: generic/file+list-of
+    # type=list: Jacobian images
     out_logfile: generic/file
     # type=file: name of log-file
     # type=file|default=<undefined>: name of log-file
+    out_mats: generic/file+list-of
+    # type=list: realignment matrices
     out_movpar: generic/file
     # type=file: movpar.txt output file
+    out_warps: generic/file+list-of
+    # type=list: warpfield images
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/fsl/topup_callables.py b/example-specs/task/nipype/fsl/topup_callables.py
index eec1880d..ad56f18e 100644
--- a/example-specs/task/nipype/fsl/topup_callables.py
+++ b/example-specs/task/nipype/fsl/topup_callables.py
@@ -1 +1,604 @@
 """Module to put any functions that are referred to in the "callables" section of TOPUP.yaml"""
+
+import attrs
+import logging
+from glob import glob
+import os
+import nibabel as nb
+import os.path as op
+
+
+def out_fieldcoef_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_fieldcoef"]
+
+
+def out_movpar_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_movpar"]
+
+
+def out_enc_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_enc_file"]
+
+
+def out_field_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_field"]
+
+
+def out_warps_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_warps"]
+
+
+def out_jacs_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_jacs"]
+
+
+def out_mats_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_mats"]
+
+
+def out_corrected_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_corrected"]
+
+
+def out_logfile_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_logfile"]
+
+
+IFLOGGER = logging.getLogger("nipype.interface")
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """
+    Handle FSL ``output_type`` and version information.
+
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
+
+    """
+
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
+
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
+
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
+
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
+
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
+
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
+
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
+
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
+
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
+
+        Returns a list of standard images if called without arguments.
+
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
+
+
+def nipype_interfaces_fsl__FSLCommand___overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value + Info.output_type_to_ext(inputs.output_type)
+
+
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
+
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
+
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
+
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "topup"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = nipype_interfaces_fsl__FSLCommand___overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def nipype_interfaces_fsl__FSLCommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if name == "out_base":
+        return value
+    return nipype_interfaces_fsl__FSLCommand___overload_extension(value, name)
+
+
+def _get_encfilename(inputs=None, stdout=None, stderr=None, output_dir=None):
+    out_file = os.path.join(
+        output_dir, ("%s_encfile.txt" % split_filename(inputs.in_file)[1])
+    )
+    return out_file
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_fsl__FSLCommand___list_outputs()
+    del outputs["out_base"]
+    base_path = None
+    if inputs.out_base is not attrs.NOTHING:
+        base_path, base, _ = split_filename(inputs.out_base)
+        if base_path == "":
+            base_path = None
+    else:
+        base = split_filename(inputs.in_file)[1] + "_base"
+    outputs["out_fieldcoef"] = _gen_fname(
+        base,
+        suffix="_fieldcoef",
+        cwd=base_path,
+        inputs=inputs,
+        stdout=stdout,
+        stderr=stderr,
+        output_dir=output_dir,
+    )
+    outputs["out_movpar"] = _gen_fname(
+        base,
+        suffix="_movpar",
+        ext=".txt",
+        cwd=base_path,
+        inputs=inputs,
+        stdout=stdout,
+        stderr=stderr,
+        output_dir=output_dir,
+    )
+
+    n_vols = nb.load(inputs.in_file).shape[-1]
+    ext = Info.output_type_to_ext(inputs.output_type)
+    fmt = os.path.abspath("{prefix}_{i:02d}{ext}").format
+    outputs["out_warps"] = [
+        fmt(prefix=inputs.out_warp_prefix, i=i, ext=ext) for i in range(1, n_vols + 1)
+    ]
+    outputs["out_jacs"] = [
+        fmt(prefix=inputs.out_jac_prefix, i=i, ext=ext) for i in range(1, n_vols + 1)
+    ]
+    outputs["out_mats"] = [
+        fmt(prefix=inputs.out_mat_prefix, i=i, ext=".mat") for i in range(1, n_vols + 1)
+    ]
+
+    if inputs.encoding_direction is not attrs.NOTHING:
+        outputs["out_enc_file"] = _get_encfilename(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )
+    return outputs
diff --git a/example-specs/task/nipype/fsl/tract_skeleton_callables.py b/example-specs/task/nipype/fsl/tract_skeleton_callables.py
index dd8ab045..33f142e1 100644
--- a/example-specs/task/nipype/fsl/tract_skeleton_callables.py
+++ b/example-specs/task/nipype/fsl/tract_skeleton_callables.py
@@ -1 +1,136 @@
 """Module to put any functions that are referred to in the "callables" section of TractSkeleton.yaml"""
+
+import attrs
+import os.path as op
+
+
+def projected_data_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["projected_data"]
+
+
+def skeleton_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["skeleton_file"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    _si = inputs
+    if (_si.project_data is not attrs.NOTHING) and _si.project_data:
+        proj_data = _si.projected_data
+        outputs["projected_data"] = proj_data
+        if proj_data is attrs.NOTHING:
+            stem = _si.data_file
+            if _si.alt_data_file is not attrs.NOTHING:
+                stem = _si.alt_data_file
+            outputs["projected_data"] = fname_presuffix(
+                stem, suffix="_skeletonised", newpath=output_dir, use_ext=True
+            )
+    if (_si.skeleton_file is not attrs.NOTHING) and _si.skeleton_file:
+        outputs["skeleton_file"] = _si.skeleton_file
+        if isinstance(_si.skeleton_file, bool):
+            outputs["skeleton_file"] = fname_presuffix(
+                _si.in_file, suffix="_skeleton", newpath=output_dir, use_ext=True
+            )
+    return outputs
diff --git a/example-specs/task/nipype/fsl/training_callables.py b/example-specs/task/nipype/fsl/training_callables.py
index 36362c92..0d5195d8 100644
--- a/example-specs/task/nipype/fsl/training_callables.py
+++ b/example-specs/task/nipype/fsl/training_callables.py
@@ -1 +1,26 @@
 """Module to put any functions that are referred to in the "callables" section of Training.yaml"""
+
+import os
+import attrs
+
+
+def trained_wts_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["trained_wts_file"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    if inputs.trained_wts_filestem is not attrs.NOTHING:
+        outputs["trained_wts_file"] = os.path.abspath(
+            inputs.trained_wts_filestem + ".RData"
+        )
+    else:
+        outputs["trained_wts_file"] = os.path.abspath("trained_wts_file.RData")
+    return outputs
diff --git a/example-specs/task/nipype/fsl/training_set_creator.yaml b/example-specs/task/nipype/fsl/training_set_creator.yaml
index f3a0a06c..4024408c 100644
--- a/example-specs/task/nipype/fsl/training_set_creator.yaml
+++ b/example-specs/task/nipype/fsl/training_set_creator.yaml
@@ -42,6 +42,8 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    mel_icas_out: generic/directory+list-of
+    # type=outputmultiobject: Hand labels for noise vs signal
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/fsl/training_set_creator_callables.py b/example-specs/task/nipype/fsl/training_set_creator_callables.py
index f750b5c1..51e4898b 100644
--- a/example-specs/task/nipype/fsl/training_set_creator_callables.py
+++ b/example-specs/task/nipype/fsl/training_set_creator_callables.py
@@ -1 +1,14 @@
 """Module to put any functions that are referred to in the "callables" section of TrainingSetCreator.yaml"""
+
+
+def mel_icas_out_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["mel_icas_out"]
+
+
+def _gen_filename(field, inputs, output_dir, stdout, stderr):
+    raise NotImplementedError(
+        "Could not find '_gen_filename' method in nipype.interfaces.fsl.fix.TrainingSetCreator"
+    )
diff --git a/example-specs/task/nipype/fsl/unary_maths_callables.py b/example-specs/task/nipype/fsl/unary_maths_callables.py
index b2b7ec0a..27ade468 100644
--- a/example-specs/task/nipype/fsl/unary_maths_callables.py
+++ b/example-specs/task/nipype/fsl/unary_maths_callables.py
@@ -1 +1,291 @@
 """Module to put any functions that are referred to in the "callables" section of UnaryMaths.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+from glob import glob
+
+
+def out_file_default(inputs):
+    return _gen_filename("out_file", inputs=inputs)
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+IFLOGGER = logging.getLogger("nipype.interface")
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """
+    Handle FSL ``output_type`` and version information.
+
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
+
+    """
+
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
+
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
+
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
+
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
+
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
+
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
+
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
+
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
+
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
+
+        Returns a list of standard images if called without arguments.
+
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
+
+
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
+
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
+
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
+
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "fslmaths"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+def nipype_interfaces_fsl_maths__MathsCommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = {}
+    outputs["out_file"] = inputs.out_file
+    if inputs.out_file is attrs.NOTHING:
+        outputs["out_file"] = _gen_fname(
+            inputs.in_file,
+            suffix=_suffix,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    outputs["out_file"] = os.path.abspath(outputs["out_file"])
+    return outputs
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return nipype_interfaces_fsl_maths__MathsCommand___list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )["out_file"]
+    return None
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    _suffix = "_" + inputs.operation
+    return nipype_interfaces_fsl_maths__MathsCommand___list_outputs()
diff --git a/example-specs/task/nipype/fsl/vec_reg_callables.py b/example-specs/task/nipype/fsl/vec_reg_callables.py
index 0ae08a62..2c3dd98a 100644
--- a/example-specs/task/nipype/fsl/vec_reg_callables.py
+++ b/example-specs/task/nipype/fsl/vec_reg_callables.py
@@ -1 +1,287 @@
 """Module to put any functions that are referred to in the "callables" section of VecReg.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+from glob import glob
+
+
+def out_file_default(inputs):
+    return _gen_filename("out_file", inputs=inputs)
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+IFLOGGER = logging.getLogger("nipype.interface")
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """
+    Handle FSL ``output_type`` and version information.
+
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
+
+    """
+
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
+
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
+
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
+
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
+
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
+
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
+
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
+
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
+
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
+
+        Returns a list of standard images if called without arguments.
+
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
+
+
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
+
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
+
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
+
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "vecreg"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )[name]
+    else:
+        return None
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = inputs.out_file
+    if (outputs["out_file"] is attrs.NOTHING) and (inputs.in_file is not attrs.NOTHING):
+        pth, base_name = os.path.split(inputs.in_file)
+        outputs["out_file"] = _gen_fname(
+            base_name,
+            cwd=os.path.abspath(pth),
+            suffix="_vreg",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    outputs["out_file"] = os.path.abspath(outputs["out_file"])
+    return outputs
diff --git a/example-specs/task/nipype/fsl/vest_2_text_callables.py b/example-specs/task/nipype/fsl/vest_2_text_callables.py
index aaa2d8d1..c2091f41 100644
--- a/example-specs/task/nipype/fsl/vest_2_text_callables.py
+++ b/example-specs/task/nipype/fsl/vest_2_text_callables.py
@@ -1 +1,283 @@
 """Module to put any functions that are referred to in the "callables" section of Vest2Text.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+from glob import glob
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+IFLOGGER = logging.getLogger("nipype.interface")
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+class Info(PackageInfo):
+    """
+    Handle FSL ``output_type`` and version information.
+
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
+
+    """
+
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
+
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
+
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
+
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
+
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
+
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
+
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
+
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
+
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
+
+        Returns a list of standard images if called without arguments.
+
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value + Info.output_type_to_ext(inputs.output_type)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
diff --git a/example-specs/task/nipype/fsl/warp_points_callables.py b/example-specs/task/nipype/fsl/warp_points_callables.py
index 49f2e25e..d2c5fc3d 100644
--- a/example-specs/task/nipype/fsl/warp_points_callables.py
+++ b/example-specs/task/nipype/fsl/warp_points_callables.py
@@ -1 +1,188 @@
 """Module to put any functions that are referred to in the "callables" section of WarpPoints.yaml"""
+
+import os
+import os.path as op
+import attrs
+import logging
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def _overload_extension(
+    value, name, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if name == "out_file":
+        return "%s.%s" % (value, getattr(self, "_outformat"))
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
diff --git a/example-specs/task/nipype/fsl/warp_points_from_std_callables.py b/example-specs/task/nipype/fsl/warp_points_from_std_callables.py
index e5b9aebe..604af246 100644
--- a/example-specs/task/nipype/fsl/warp_points_from_std_callables.py
+++ b/example-specs/task/nipype/fsl/warp_points_from_std_callables.py
@@ -1 +1,20 @@
 """Module to put any functions that are referred to in the "callables" section of WarpPointsFromStd.yaml"""
+
+import os.path as op
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = op.abspath("stdout.nipype")
+    return outputs
diff --git a/example-specs/task/nipype/fsl/warp_points_to_std_callables.py b/example-specs/task/nipype/fsl/warp_points_to_std_callables.py
index 390b14dc..dcef9677 100644
--- a/example-specs/task/nipype/fsl/warp_points_to_std_callables.py
+++ b/example-specs/task/nipype/fsl/warp_points_to_std_callables.py
@@ -1 +1,188 @@
 """Module to put any functions that are referred to in the "callables" section of WarpPointsToStd.yaml"""
+
+import os
+import os.path as op
+import attrs
+import logging
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+def _overload_extension(
+    value, name, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if name == "out_file":
+        return "%s.%s" % (value, getattr(self, "_outformat"))
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
diff --git a/example-specs/task/nipype/fsl/warp_utils_callables.py b/example-specs/task/nipype/fsl/warp_utils_callables.py
index 1f873334..e8dbca2b 100644
--- a/example-specs/task/nipype/fsl/warp_utils_callables.py
+++ b/example-specs/task/nipype/fsl/warp_utils_callables.py
@@ -1 +1,290 @@
 """Module to put any functions that are referred to in the "callables" section of WarpUtils.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+from glob import glob
+
+
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
+
+
+def out_jacobian_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_jacobian"]
+
+
+IFLOGGER = logging.getLogger("nipype.interface")
+
+
+iflogger = logging.getLogger("nipype.interface")
+
+
+class Info(PackageInfo):
+    """
+    Handle FSL ``output_type`` and version information.
+
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
+
+    """
+
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
+
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
+
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
+
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
+
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
+
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
+
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
+
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
+
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
+
+        Returns a list of standard images if called without arguments.
+
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
+
+
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value + Info.output_type_to_ext(inputs.output_type)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
diff --git a/example-specs/task/nipype/fsl/x_fibres_5.yaml b/example-specs/task/nipype/fsl/x_fibres_5.yaml
index 2764ee56..a49c6ccf 100644
--- a/example-specs/task/nipype/fsl/x_fibres_5.yaml
+++ b/example-specs/task/nipype/fsl/x_fibres_5.yaml
@@ -48,12 +48,22 @@ outputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+    dyads: generic/file+list-of
+    # type=outputmultiobject: Mean of PDD distribution in vector form.
+    fsamples: generic/file+list-of
+    # type=outputmultiobject: Samples from the distribution on f anisotropy
     mean_S0samples: generic/file
     # type=file: Mean of distribution on T2wbaseline signal intensity S0
     mean_dsamples: generic/file
     # type=file: Mean of distribution on diffusivity d
+    mean_fsamples: generic/file+list-of
+    # type=outputmultiobject: Mean of distribution on f anisotropy
     mean_tausamples: generic/file
     # type=file: Mean of distribution on tau samples (only with rician noise)
+    phsamples: generic/file+list-of
+    # type=outputmultiobject: phi samples, per fiber
+    thsamples: generic/file+list-of
+    # type=outputmultiobject: theta samples, per fiber
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
diff --git a/example-specs/task/nipype/fsl/x_fibres_5_callables.py b/example-specs/task/nipype/fsl/x_fibres_5_callables.py
index b2469497..06c11d88 100644
--- a/example-specs/task/nipype/fsl/x_fibres_5_callables.py
+++ b/example-specs/task/nipype/fsl/x_fibres_5_callables.py
@@ -1 +1,401 @@
 """Module to put any functions that are referred to in the "callables" section of XFibres5.yaml"""
+
+import os
+import attrs
+import os.path as op
+import logging
+from glob import glob
+
+
+def dyads_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["dyads"]
+
+
+def fsamples_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["fsamples"]
+
+
+def mean_dsamples_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["mean_dsamples"]
+
+
+def mean_fsamples_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["mean_fsamples"]
+
+
+def mean_S0samples_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["mean_S0samples"]
+
+
+def mean_tausamples_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["mean_tausamples"]
+
+
+def phsamples_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["phsamples"]
+
+
+def thsamples_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["thsamples"]
+
+
+IFLOGGER = logging.getLogger("nipype.interface")
+
+
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+class Info(PackageInfo):
+    """
+    Handle FSL ``output_type`` and version information.
+
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
+
+    """
+
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
+
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
+
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
+
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
+
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
+
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
+
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
+
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
+
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
+
+        Returns a list of standard images if called without arguments.
+
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
+
+
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
+
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
+
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
+
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "xfibres"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+def _list_outputs(out_dir=None, inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    n_fibres = inputs.n_fibres
+    if not out_dir:
+        if inputs.logdir is not attrs.NOTHING:
+            out_dir = os.path.abspath(inputs.logdir)
+        else:
+            out_dir = os.path.abspath("logdir")
+
+    multi_out = ["dyads", "fsamples", "mean_fsamples", "phsamples", "thsamples"]
+    single_out = ["mean_dsamples", "mean_S0samples"]
+
+    for k in single_out:
+        outputs[k] = _gen_fname(
+            k,
+            cwd=out_dir,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+
+    if (inputs.rician is not attrs.NOTHING) and inputs.rician:
+        outputs["mean_tausamples"] = _gen_fname(
+            "mean_tausamples",
+            cwd=out_dir,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+
+    for k in multi_out:
+        outputs[k] = []
+
+    for i in range(1, n_fibres + 1):
+        outputs["fsamples"].append(
+            _gen_fname(
+                "f%dsamples" % i,
+                cwd=out_dir,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+        )
+        outputs["mean_fsamples"].append(
+            _gen_fname(
+                "mean_f%dsamples" % i,
+                cwd=out_dir,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+        )
+
+    for i in range(1, n_fibres + 1):
+        outputs["dyads"].append(
+            _gen_fname(
+                "dyads%d" % i,
+                cwd=out_dir,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+        )
+        outputs["phsamples"].append(
+            _gen_fname(
+                "ph%dsamples" % i,
+                cwd=out_dir,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+        )
+        outputs["thsamples"].append(
+            _gen_fname(
+                "th%dsamples" % i,
+                cwd=out_dir,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+        )
+
+    return outputs
diff --git a/nipype2pydra/pkg_gen/__init__.py b/nipype2pydra/pkg_gen/__init__.py
index 8882ce75..766d3919 100644
--- a/nipype2pydra/pkg_gen/__init__.py
+++ b/nipype2pydra/pkg_gen/__init__.py
@@ -33,6 +33,7 @@
     split_parens_contents,
     cleanup_function_body,
     insert_args_in_signature,
+    INBUILT_NIPYPE_TRAIT_NAMES,
 )
 from nipype2pydra.exceptions import UnmatchedParensException
 
@@ -90,6 +91,8 @@ class NipypeInterface:
     dir_inputs: ty.List[str] = attrs.field(factory=list)
     dir_outputs: ty.List[str] = attrs.field(factory=list)
     callables: ty.List[str] = attrs.field(factory=list)
+    callable_defaults: ty.List[str] = attrs.field(factory=list)
+    multi_outputs: ty.List[str] = attrs.field(factory=list)
 
     unmatched_formats: ty.List[str] = attrs.field(factory=list)
     ambiguous_formats: ty.List[str] = attrs.field(factory=list)
@@ -115,7 +118,7 @@ def parse(
 # ----
 # {doc_string}\n"""
         ).replace("        #", "#")
-        
+
         parsed = cls(
             name=nipype_interface.__name__,
             doc_str=nipype_interface.__doc__ if nipype_interface.__doc__ else "",
@@ -133,10 +136,20 @@ def parse(
                 parsed.output_helps[outpt_name] = (
                     f"type={type(outpt.trait_type).__name__.lower()}: {outpt_desc}"
                 )
-                if type(outpt.trait_type).__name__ == "File":
+                output_type_str = type(outpt.trait_type).__name__
+                if output_type_str == "File":
                     parsed.file_outputs.append(outpt_name)
-                elif type(outpt.trait_type).__name__ == "Directory":
+                elif output_type_str == "Directory":
                     parsed.dir_outputs.append(outpt_name)
+                elif output_type_str in ("OutputMultiObject", "List"):
+                    inner_type_str = type(outpt.trait_type.item_trait.trait_type).__name__
+                    if inner_type_str == "Directory":
+                        parsed.dir_outputs.append(outpt_name)
+                    elif inner_type_str == "File":
+                        parsed.file_outputs.append(outpt_name)
+                    parsed.multi_outputs.append(outpt_name)
+                else:
+                    parsed.callables.append(outpt_name)
         # Parse input types, descriptions and metadata
         for inpt_name, inpt in nipype_interface.input_spec().traits().items():
             if inpt_name in ("trait_added", "trait_modified"):
@@ -153,7 +166,7 @@ def parse(
                 if inpt_name in (parsed.file_outputs + parsed.dir_outputs):
                     parsed.template_outputs.append(inpt_name)
                 else:
-                    parsed.callables.append(inpt_name)
+                    parsed.callable_defaults.append(inpt_name)
             elif trait_type_name == "File" and inpt_name not in parsed.file_outputs:
                 # override logic if it is named as an output
                 if (
@@ -231,11 +244,15 @@ def generate_yaml_spec(self) -> str:
                         ext = frmt.strext
                 output_templates[outpt] = outpt + ext
 
-        # convert to multi-input types to lists
+        # convert to multi-in/output types to lists
         input_types = {
             n: ty.List[t] if n in self.multi_inputs else t
             for n, t in input_types.items()
         }
+        output_types = {
+            n: ty.List[t] if n in self.multi_outputs else t
+            for n, t in output_types.items()
+        }
 
         non_mime = [Path, str]
 
@@ -320,29 +337,31 @@ def generate_callables(self, nipype_interface) -> str:
             f'"""Module to put any functions that are referred to in the "callables"'
             f' section of {self.name}.yaml"""\n\n'
         )
-        if self.callables:
-            # Convert the "_gen_filename" method into a function with any referenced
-            # methods, functions and constants included in the module
-            funcs, imports, consts = get_callable_sources(nipype_interface)
-            callables_str += "\n".join(imports) + "\n\n"
-            # Create separate callable function for each callable field, which
-            # reference the magic "_gen_filename" method
-            for inpt_name, inpt in nipype_interface.input_spec().traits().items():
-                if inpt.genfile:
-                    callables_str += (
-                        f"def {inpt_name}_default(inputs):\n"
-                        f'    return _gen_filename("{inpt_name}", inputs=inputs)\n\n'
-                    )
-            
-            for output_name in self.callables:
+        # Convert the "_gen_filename" method into a function with any referenced
+        # methods, functions and constants included in the module
+        funcs, imports, consts = get_callable_sources(nipype_interface)
+        callables_str += "\n".join(imports) + "\n\n"
+        # Create separate default function for each input field with genfile, which
+        # reference the magic "_gen_filename" method
+        for inpt_name, inpt in nipype_interface.input_spec().traits().items():
+            if inpt.genfile:
                 callables_str += (
-                    f"def {output_name}_callable(output_dir, inputs, stdout, stderr):\n"
-                    '    outputs = _list_outputs(output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr)\n'
-                    '    return outputs["' + output_name + '"]\n\n'
+                    f"def {inpt_name}_default(inputs):\n"
+                    f'    return _gen_filename("{inpt_name}", inputs=inputs)\n\n'
                 )
-            for const in consts:
-                callables_str += f"{const[0]} = {const[1]}\n" + "\n\n"
-            callables_str += "\n\n".join(funcs) + "\n\n"
+        # Create separate function for each output field in the "callables" section
+        if nipype_interface.output_spec:
+            for output_name in nipype_interface.output_spec().traits().keys():
+                if output_name not in INBUILT_NIPYPE_TRAIT_NAMES:
+                    callables_str += (
+                        f"def {output_name}_callable(output_dir, inputs, stdout, stderr):\n"
+                        "    outputs = _list_outputs(output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr)\n"
+                        '    return outputs["' + output_name + '"]\n\n'
+                    )
+        # Add any constants to the module
+        for const in consts:
+            callables_str += f"{const[0]} = {const[1]}\n" + "\n\n"
+        callables_str += "\n\n".join(funcs) + "\n\n"
         # Format the generated code with black
         try:
             callables_str = black.format_file_contents(
@@ -797,26 +816,76 @@ def _gen_filename(field, inputs, output_dir, stdout, stderr):
 
     IMPLICIT_ARGS = ["inputs", "stdout", "stderr", "output_dir"]
 
-    def find_nested_methods(methods: ty.List[ty.Callable]) -> ty.List[str]:
-        all_nested = set(methods)
+    def common_parent_pkg_prefix(mod_name: str) -> str:
+        """Return the common part of two package names"""
+        ref_parts = nipype_interface.__module__.split(".")
+        mod_parts = mod_name.split(".")
+        common = []
+        for r_part, m_part in zip(ref_parts, mod_parts):
+            if r_part == m_part:
+                common.append(r_part)
+            else:
+                break
+        if not common:
+            return ""
+        return "_".join(common) + "__"
+
+    def find_nested_methods(methods: ty.List[ty.Callable], interface=None) -> ty.Dict[str, ty.Callable]:
+        if interface is None:
+            interface = nipype_interface
+        all_nested = {}
         for method in methods:
-            for match in re.findall(r"self\.(\w+)\(", inspect.getsource(method)):
+            method_src = inspect.getsource(method)
+            for match in re.findall(r"self\.(\w+)\(", method_src):
                 if match in ("output_spec", "_outputs"):
                     continue
                 nested = getattr(nipype_interface, match)
-                if nested not in all_nested:
-                    all_nested.add(nested)
+                func_name = nested.__name__
+                if func_name not in all_nested and func_name != method.__name__:
+                    all_nested[func_name] = nested
                     all_nested.update(find_nested_methods([nested]))
+            for match in re.findall(r"super\([^\)]*\)\.(\w+)\(", method_src):
+                nested = None
+                for base in interface.__bases__:
+                    try:
+                        nested = getattr(base, match)
+                    except AttributeError:
+                        continue
+                    else:
+                        break
+                assert (
+                    nested is not None
+                ), f"Could not find {match} in base classes of {nipype_interface}"
+                func_name = (
+                    common_parent_pkg_prefix(base.__module__)
+                    + base.__name__
+                    + "__"
+                    + nested.__name__
+                )
+                if func_name not in all_nested:
+                    all_nested[func_name] = nested
+                    all_nested.update(find_nested_methods([nested], interface=base))
         return all_nested
 
-    def process_method(method: ty.Callable) -> str:
+    def process_method(
+        method: ty.Callable, new_name: str, name_map: ty.Dict[str, str]
+    ) -> str:
         src = inspect.getsource(method)
         src = src.replace("if self.output_spec:", "if True:")
-        src = re.sub(r"outputs = self\.(output_spec|_outputs)\(\).*$", r"outputs = {}", src, flags=re.MULTILINE)        
+        src = re.sub(
+            r"outputs = self\.(output_spec|_outputs)\(\).*$",
+            r"outputs = {}",
+            src,
+            flags=re.MULTILINE,
+        )
         prefix, args, body = split_parens_contents(src)
-        body = insert_args_in_method_calls(body, [f"{a}={a}" for a in IMPLICIT_ARGS])
-        body = body.replace("self.cmd", f'"{nipype_interface._cmd}"')
+        body = insert_args_in_method_calls(
+            body, [f"{a}={a}" for a in IMPLICIT_ARGS], name_map
+        )
+        if hasattr(nipype_interface, "_cmd"):
+            body = body.replace("self.cmd", f'"{nipype_interface._cmd}"')
         body = body.replace("self.", "")
+        body = re.sub(r"super\([^\)]*\)\.(\w+)\(", lambda m: name_map[m.group(1)] + "(", body)
         body = re.sub(r"\w+runtime\.(stdout|stderr)", r"\1", body)
         body = body.replace("os.getcwd()", "output_dir")
         # drop 'self' from the args and add the implicit callable args
@@ -825,11 +894,14 @@ def process_method(method: ty.Callable) -> str:
         for implicit in IMPLICIT_ARGS:
             if implicit not in arg_names:
                 args.append(f"{implicit}=None")
-        src = prefix + ", ".join(args) + body
+        match = re.match(r"(.*\n?\s*def\s+)", prefix)
+        src = match.group(1) + new_name + "(" + ", ".join(args) + body
         src = cleanup_function_body(src)
         return src
 
-    def insert_args_in_method_calls(src: str, args: ty.List[ty.Tuple[str, str]]) -> str:
+    def insert_args_in_method_calls(
+        src: str, args: ty.List[ty.Tuple[str, str]], name_map: ty.Dict[str, str]
+    ) -> str:
         """Insert additional arguments into the method calls
 
         Parameters
@@ -859,44 +931,48 @@ def insert_args_in_method_calls(src: str, args: ty.List[ty.Tuple[str, str]]) ->
                 outer_name = name
             else:
                 if outer_name:
-                    new_sig = insert_args_in_method_calls(new_sig, args)
-                    new_src += outer_name + new_sig
+                    new_sig = insert_args_in_method_calls(new_sig, args, name_map=name_map)
+                    new_src += name_map[outer_name] + new_sig
                     outer_name = None
                 else:
-                    new_src += name + new_sig
+                    new_src += name_map[name] + new_sig
                 sig = ""
         return new_src
 
     methods_to_process = [nipype_interface._list_outputs]
     if hasattr(nipype_interface, "_gen_filename"):
         methods_to_process.append(nipype_interface._gen_filename)
-    
-    func_srcs = defaultdict(list)
-    for method in find_nested_methods(methods_to_process):
-        func_srcs[method.__module__].append(process_method(method))
+
+    # Get all methods to be included in the callables module
+    all_methods = {m.__name__: m for m in methods_to_process}
+    all_methods.update(find_nested_methods(methods_to_process))
+    name_map = {m.__name__: n for n, m in all_methods.items()}
+    # Group the nested methods by their module
+    grouped_methods = defaultdict(list)
+    for method_name, method in all_methods.items():
+        grouped_methods[method.__module__].append(
+            process_method(method, method_name, name_map)
+        )
+    # Initialise the source code, imports and constants
     all_funcs = []
     all_imports = set()
     all_constants = set()
-    for mod_name, funcs in func_srcs.items():
+    for mod_name, methods in grouped_methods.items():
         mod = import_module(mod_name)
-        used = UsedSymbols.find(mod, funcs)
-        all_funcs.extend(funcs)
+        used = UsedSymbols.find(mod, methods)
+        all_funcs.extend(methods)
         for func in used.local_functions:
-            all_funcs.append(
-                cleanup_function_body(inspect.getsource(func))
-            )
+            all_funcs.append(cleanup_function_body(inspect.getsource(func)))
         for klass in used.local_classes:
-            all_funcs.append(
-                cleanup_function_body(inspect.getsource(klass))
-            )            
+            all_funcs.append(cleanup_function_body(inspect.getsource(klass)))
         for new_func_name, func in used.funcs_to_include:
             func_src = inspect.getsource(func)
             match = re.match(
-                r" *def *" + func.__name__ + r"(?=\()(.*)$",
+                r"(.*)\bdef *" + func.__name__ + r"(?=\()(.*)$",
                 func_src,
                 re.DOTALL | re.MULTILINE,
             )
-            func_src = "def " + new_func_name + match.group(1)
+            func_src = match.group(1) + "def " + new_func_name + match.group(2)
             all_funcs.append(cleanup_function_body(func_src))
         for new_klass_name, klass in used.classes_to_include:
             klass_src = inspect.getsource(klass)
@@ -906,7 +982,7 @@ def insert_args_in_method_calls(src: str, args: ty.List[ty.Tuple[str, str]]) ->
                 re.DOTALL | re.MULTILINE,
             )
             klass_src = "class " + new_klass_name + match.group(1)
-            all_funcs.append(cleanup_function_body(klass_src))            
+            all_funcs.append(cleanup_function_body(klass_src))
         all_imports.update(used.imports)
         all_constants.update(used.constants)
     return (
diff --git a/nipype2pydra/task/base.py b/nipype2pydra/task/base.py
index 1266e6aa..6a0ddc89 100644
--- a/nipype2pydra/task/base.py
+++ b/nipype2pydra/task/base.py
@@ -157,7 +157,14 @@ class InputsConverter(SpecConverter):
     metadata: dict[str, dict[str, Any]], optional
         additional metadata to set on any of the input fields (e.g. out_file: position: 1)
     """
-
+    callable_defaults: ty.Dict[str, str] = attrs.field(
+        factory=dict,
+        converter=default_if_none(factory=dict),  # type: ignore
+        metadata={
+            "help": """names of methods/callable classes defined in the adjacent `*_callables.py`
+                to set as the `default` method of input fields"""
+        },
+    )
     metadata: ty.Dict[str, ty.Dict[str, ty.Any]] = attrs.field(
         factory=dict,
         converter=default_if_none(factory=dict),  # type: ignore
diff --git a/nipype2pydra/task/tests/test_task.py b/nipype2pydra/task/tests/test_task.py
index 59f4795b..b79b68df 100644
--- a/nipype2pydra/task/tests/test_task.py
+++ b/nipype2pydra/task/tests/test_task.py
@@ -5,22 +5,13 @@
 from conftest import show_cli_trace
 from traceback import format_exc
 from nipype2pydra.cli.task import task as task_cli
-from nipype2pydra.utils import add_to_sys_path, add_exc_note
+from nipype2pydra.utils import add_to_sys_path, add_exc_note, INBUILT_NIPYPE_TRAIT_NAMES
 from conftest import EXAMPLE_TASKS_DIR
 
 
 logging.basicConfig(level=logging.INFO)
 
 
-INBUILT_NIPYPE_TRAIT_NAMES = [
-    "__all__",
-    "args",
-    "trait_added",
-    "trait_modified",
-    "environ",
-    "output_type",
-]
-
 XFAIL_INTERFACES = [
     "fsl-prob_track_x2",
     "fsl-flameo",
diff --git a/nipype2pydra/utils.py b/nipype2pydra/utils.py
index 1dd16399..4ba64d7a 100644
--- a/nipype2pydra/utils.py
+++ b/nipype2pydra/utils.py
@@ -5,11 +5,13 @@
 import re
 import os
 import inspect
+import builtins
 from contextlib import contextmanager
 import attrs
 from pathlib import Path
 from fileformats.core import FileSet
 from .exceptions import UnmatchedParensException
+from nipype.interfaces.base import BaseInterface, TraitedSpec, isdefined, Undefined
 
 try:
     from typing import GenericAlias
@@ -17,6 +19,20 @@
     from typing import _GenericAlias as GenericAlias
 
 from importlib import import_module
+from logging import getLogger
+
+
+logger = getLogger("nipype2pydra")
+
+
+INBUILT_NIPYPE_TRAIT_NAMES = [
+    "__all__",
+    "args",
+    "trait_added",
+    "trait_modified",
+    "environ",
+    "output_type",
+]
 
 
 def load_class_or_func(location_str):
@@ -208,8 +224,11 @@ def split_parens_contents(snippet, brackets: bool = False, delimiter=","):
                     if next_item:
                         contents.append(next_item)
                     return pre, contents, "".join(splits[i:])
-            if first and depth[first] == 1 and delimiter in s and all(
-                d == 0 for b, d in depth.items() if b != first
+            if (
+                first
+                and depth[first] == 1
+                and delimiter in s
+                and all(d == 0 for b, d in depth.items() if b != first)
             ):
                 parts = [p.strip() for p in s.split(delimiter)]
                 if parts:
@@ -293,20 +312,26 @@ def find(
         local_constants = get_local_constants(module)
         local_classes = get_local_classes(module)
         for line in source_code.split("\n"):
-            if line.startswith("from") or line.startswith("import"):
-                if "(" in line:
-                    block = line
+            if (line.startswith("from") and " import " in line) or line.startswith(
+                "import"
+            ):
+                if "(" in line and ")" not in line:
+                    block = line.strip()
                 else:
-                    imports.append(line)
-            if ")" in line and block:
-                imports.append(block + line)
+                    imports.append(line.strip())
+            elif ")" in line and block:
+                imports.append(block + line.strip())
                 block = ""
+            elif block:
+                block += line.strip()
         # extract imported symbols from import statements
+        symbols_re = re.compile(r"(?<!\"|')\b(\w+)\b(?!\"|')")
+        comments_re = re.compile(r"\s*#.*")
         used_symbols = set()
         for function_body in function_bodies:
             # Strip comments from function body
-            function_body = re.sub(r"\s*#.*", "", function_body)
-            used_symbols.update(re.findall(r"\b(\w+)\b", function_body))
+            function_body = comments_re.sub("", function_body)
+            used_symbols.update(symbols_re.findall(function_body))
         # Keep looping through local function source until all local functions and constants
         # are added to the used symbols
         new_symbols = True
@@ -319,8 +344,8 @@ def find(
                 ):
                     used.local_functions.add(local_func)
                     func_body = inspect.getsource(local_func)
-                    func_body = re.sub(r"\s*#.*", "", func_body)
-                    local_func_symbols = re.findall(r"\b(\w+)\b", func_body)
+                    func_body = comments_re.sub("", func_body)
+                    local_func_symbols = symbols_re.findall(func_body)
                     used_symbols.update(local_func_symbols)
                     new_symbols = True
             for local_class in local_classes:
@@ -332,8 +357,8 @@ def find(
                     class_body = inspect.getsource(local_class)
                     bases = split_parens_contents(class_body)[1]
                     used_symbols.update(bases)
-                    class_body = re.sub(r"\s*#.*", "", class_body)
-                    local_class_symbols = re.findall(r"\b(\w+)\b", class_body)
+                    class_body = comments_re.sub("", class_body)
+                    local_class_symbols = symbols_re.findall(class_body)
                     used_symbols.update(local_class_symbols)
                     new_symbols = True
             for const_name, const_def in local_constants:
@@ -342,7 +367,7 @@ def find(
                     and (const_name, const_def) not in used.constants
                 ):
                     used.constants.add((const_name, const_def))
-                    const_def_symbols = re.findall(r"\b(\w+)\b", const_def)
+                    const_def_symbols = symbols_re.findall(const_def)
                     used_symbols.update(const_def_symbols)
                     new_symbols = True
         used_symbols -= set(cls.SYMBOLS_TO_IGNORE)
@@ -363,41 +388,79 @@ def find(
                 )
                 match = re.match(r"from ([\w\.]+)", base_stmt)
                 import_mod = match.group(1) if match else ""
-                if import_mod.startswith(".") or import_mod.startswith("nipype."):
-                    if import_mod.startswith("."):
-                        match = re.match(r"(\.*)(.*)", import_mod)
-                        mod_parts = module.__name__.split(".")
-                        nparents = len(match.group(1))
-                        if Path(module.__file__).stem == "__init__":
-                            nparents -= 1
-                        if nparents:
-                            mod_parts = mod_parts[:-nparents]
-                        mod_name = ".".join(mod_parts)
-                        if match.group(2):
-                            mod_name += "." + match.group(2)
-                    elif import_mod.startswith("nipype."):
-                        mod_name = import_mod
+                if import_mod:
+                    if import_mod.startswith(".") or import_mod.startswith("nipype."):
+                        to_include = True
+                        if import_mod.startswith("."):
+                            match = re.match(r"(\.*)(.*)", import_mod)
+                            mod_parts = module.__name__.split(".")
+                            nparents = len(match.group(1))
+                            if Path(module.__file__).stem == "__init__":
+                                nparents -= 1
+                            if nparents:
+                                mod_parts = mod_parts[:-nparents]
+                            mod_name = ".".join(mod_parts)
+                            if match.group(2):
+                                mod_name += "." + match.group(2)
+                        elif import_mod.startswith("nipype."):
+                            mod_name = import_mod
+                        else:
+                            assert False
                     else:
-                        assert False
+                        to_include = True
+                        mod_name = import_mod
                     mod = import_module(mod_name)
-                    mod_func_bodies = []
-                    for used_part in used_parts:
-                        atr = getattr(mod, used_part[0])
-                        if inspect.isfunction(atr):
-                            used.funcs_to_include.add((used_part[-1], atr))
-                            mod_func_bodies.append(inspect.getsource(atr))
-                        elif inspect.isclass(atr):
-                            used.classes_to_include.add((used_part[-1], atr))
-                            class_body = split_parens_contents(inspect.getsource(atr))[
-                                2
-                            ].split("\n", 1)[1]
-                            mod_func_bodies.append(class_body)
-                    # Recursively include neighbouring objects imported in the module
-                    used_in_mod = cls.find(
-                        mod,
-                        function_bodies=mod_func_bodies,
-                    )
-                    used.update(used_in_mod)
+                    # Filter out any interfaces that have been dragged in
+                    used_parts = [
+                        p
+                        for p in used_parts
+                        if not (
+                            (
+                                inspect.isclass(getattr(mod, p[0]))
+                                and not (
+                                    issubclass(getattr(mod, p[0]), BaseInterface)
+                                    or issubclass(getattr(mod, p[0]), TraitedSpec)
+                                )
+                            )
+                            or getattr(mod, p[0]) in (Undefined, isdefined)
+                        )
+                    ]
+                    if not used_parts:
+                        continue
+                    if to_include:
+                        mod_func_bodies = []
+                        for used_part in used_parts:
+                            atr = getattr(mod, used_part[0])
+                            if (
+                                inspect.isfunction(atr) or inspect.isclass(atr)
+                            ) and not atr.__module__.startswith(
+                                "nipype."
+                            ):  # Check that it is actually a local import
+                                used.imports.add(
+                                    f"from {atr.__module__} import "
+                                    + " as ".join(used_part)
+                                )
+                            elif inspect.isfunction(atr):
+                                used.funcs_to_include.add((used_part[-1], atr))
+                                mod_func_bodies.append(inspect.getsource(atr))
+                            elif inspect.isclass(atr):
+                                if issubclass(atr, BaseInterface):
+                                    # TODO: add warning here
+                                    continue  # Don't include nipype interfaces as it gets silly
+                                used.classes_to_include.add((used_part[-1], atr))
+                                class_body = split_parens_contents(
+                                    inspect.getsource(atr)
+                                )[2].split("\n", 1)[1]
+                                mod_func_bodies.append(class_body)
+                        # Recursively include neighbouring objects imported in the module
+                        if mod is not builtins:
+                            used_in_mod = cls.find(
+                                mod,
+                                function_bodies=mod_func_bodies,
+                            )
+                            used.update(used_in_mod)
+                    else:
+                        used.imports.add(required_stmt)
                 else:
                     used.imports.add(required_stmt)
         return used
@@ -434,13 +497,16 @@ def get_local_constants(mod):
     parts = re.split(r"^(\w+) *= *", source_code, flags=re.MULTILINE)
     local_vars = []
     for attr_name, following in zip(parts[1::2], parts[2::2]):
-        if "(" in following or "[" in following:
+        first_line = following.splitlines()[0]
+        if ("(" in first_line and ")" not in first_line) or (
+            "[" in first_line and "]" not in first_line
+        ):
             pre, args, post = split_parens_contents(following)
             local_vars.append(
                 (attr_name, pre + re.sub(r"\n *", "", ", ".join(args)) + post[0])
             )
         else:
-            local_vars.append((attr_name, following.splitlines()[0]))
+            local_vars.append((attr_name, first_line))
     return local_vars
 
 
@@ -460,7 +526,7 @@ def cleanup_function_body(function_body: str) -> str:
     function_body: str
         The processed source code
     """
-    if re.match(r"\s*(def|class)\s+", function_body):
+    if re.match(r".*\n?\s*(def|class)\s+", function_body):
         with_signature = True
     else:
         with_signature = False
@@ -469,8 +535,8 @@ def cleanup_function_body(function_body: str) -> str:
     min_indent = min(len(i) for i in indents) if indents else 0
     indent_reduction = min_indent - (0 if with_signature else 4)
     assert indent_reduction >= 0, (
-        "Indentation reduction cannot be negative, probably need to set "
-        "'with_signature' to True"
+        "Indentation reduction cannot be negative, probably didn't detect signature of "
+        f"method correctly:\n{function_body}"
     )
     if indent_reduction:
         function_body = re.sub(
@@ -478,18 +544,21 @@ def cleanup_function_body(function_body: str) -> str:
         )
     # Other misc replacements
     # function_body = function_body.replace("LOGGER.", "logger.")
-    function_body = re.sub(
-        r"not isdefined\(([a-zA-Z0-9\_\.]+)\)",
-        r"\1 is attrs.NOTHING",
-        function_body,
-        flags=re.MULTILINE,
-    )
-    function_body = re.sub(
-        r"isdefined\(([a-zA-Z0-9\_\.]+)\)",
-        r"\1 is not attrs.NOTHING",
-        function_body,
-        flags=re.MULTILINE,
-    )
+    parts = re.split(r"not isdefined\b", function_body, flags=re.MULTILINE)
+    new_function_body = parts[0]
+    for part in parts[1:]:
+        pre, args, post = split_parens_contents(part)
+        new_function_body += pre + f"{args[0]} is attrs.NOTHING" + post
+    function_body = new_function_body
+    parts = re.split(r"isdefined\b", function_body, flags=re.MULTILINE)
+    new_function_body = parts[0]
+    for part in parts[1:]:
+        pre, args, post = split_parens_contents(part)
+        assert len(args) == 1, f"Unexpected number of arguments in isdefined: {args}"
+        new_function_body += pre + f"{args[0]} is not attrs.NOTHING" + post
+    function_body = new_function_body
+    function_body = function_body.replace("_Undefined", "attrs.NOTHING")
+    function_body = function_body.replace("Undefined", "attrs.NOTHING")
     return function_body
 
 

From 9765d2a08cf89e20597210f80e377d7cf8824897 Mon Sep 17 00:00:00 2001
From: Tom Close <tom.g.close@gmail.com>
Date: Wed, 13 Mar 2024 13:44:55 +1100
Subject: [PATCH 61/78] all generated interfaces pass (except for the xfails)

---
 .../task/nipype/afni/a_boverlap.yaml          |   3 +
 .../task/nipype/afni/a_boverlap_callables.py  |  54 ++-
 .../task/nipype/afni/afn_ito_nifti.yaml       |   3 +
 .../nipype/afni/afn_ito_nifti_callables.py    |  16 +-
 .../task/nipype/afni/align_epi_anat_py.yaml   |   3 +
 .../afni/align_epi_anat_py_callables.py       | 124 +++++-
 example-specs/task/nipype/afni/allineate.yaml |   3 +
 .../task/nipype/afni/allineate_callables.py   |  55 ++-
 .../task/nipype/afni/auto_tcorrelate.yaml     |   3 +
 .../nipype/afni/auto_tcorrelate_callables.py  |  16 +-
 example-specs/task/nipype/afni/auto_tlrc.yaml |   3 +
 .../task/nipype/afni/auto_tlrc_callables.py   |  41 +-
 example-specs/task/nipype/afni/autobox.yaml   |   3 +
 .../task/nipype/afni/autobox_callables.py     |  54 ++-
 example-specs/task/nipype/afni/automask.yaml  |   3 +
 .../task/nipype/afni/automask_callables.py    |  54 ++-
 example-specs/task/nipype/afni/axialize.yaml  |   3 +
 .../task/nipype/afni/axialize_callables.py    |  54 ++-
 example-specs/task/nipype/afni/bandpass.yaml  |   3 +
 .../task/nipype/afni/bandpass_callables.py    |  54 ++-
 .../task/nipype/afni/blur_in_mask.yaml        |   3 +
 .../nipype/afni/blur_in_mask_callables.py     |  54 ++-
 .../task/nipype/afni/blur_to_fwhm.yaml        |   3 +
 .../nipype/afni/blur_to_fwhm_callables.py     |  54 ++-
 .../task/nipype/afni/brick_stat.yaml          |   3 +
 .../task/nipype/afni/brick_stat_callables.py  |  14 +-
 example-specs/task/nipype/afni/bucket.yaml    |   3 +
 .../task/nipype/afni/bucket_callables.py      |  54 ++-
 example-specs/task/nipype/afni/calc.yaml      |   3 +
 .../task/nipype/afni/calc_callables.py        |  54 ++-
 example-specs/task/nipype/afni/cat.yaml       |   3 +
 .../task/nipype/afni/cat_callables.py         |  54 ++-
 .../task/nipype/afni/cat_matvec.yaml          |   3 +
 .../task/nipype/afni/cat_matvec_callables.py  |  54 ++-
 .../task/nipype/afni/center_mass.yaml         |   5 +-
 .../task/nipype/afni/center_mass_callables.py |  18 +-
 .../task/nipype/afni/clip_level.yaml          |   3 +
 .../task/nipype/afni/clip_level_callables.py  |  14 +-
 .../task/nipype/afni/convert_dset.yaml        |   3 +
 example-specs/task/nipype/afni/copy.yaml      |   3 +
 .../task/nipype/afni/copy_callables.py        |  54 ++-
 .../task/nipype/afni/deconvolve.yaml          |   3 +
 .../task/nipype/afni/deconvolve_callables.py  |  43 +-
 .../task/nipype/afni/degree_centrality.yaml   |   3 +
 .../afni/degree_centrality_callables.py       |  54 ++-
 example-specs/task/nipype/afni/despike.yaml   |   3 +
 .../task/nipype/afni/despike_callables.py     |  54 ++-
 example-specs/task/nipype/afni/detrend.yaml   |   3 +
 .../task/nipype/afni/detrend_callables.py     |  54 ++-
 example-specs/task/nipype/afni/dot.yaml       |   5 +-
 .../task/nipype/afni/dot_callables.py         |  54 ++-
 example-specs/task/nipype/afni/ecm.yaml       |   3 +
 .../task/nipype/afni/ecm_callables.py         |  54 ++-
 example-specs/task/nipype/afni/edge_3.yaml    |   3 +
 .../task/nipype/afni/edge_3_callables.py      |  54 ++-
 example-specs/task/nipype/afni/eval.yaml      |   3 +
 .../task/nipype/afni/eval_callables.py        |  54 ++-
 example-specs/task/nipype/afni/fim.yaml       |   3 +
 .../task/nipype/afni/fim_callables.py         |  54 ++-
 example-specs/task/nipype/afni/fourier.yaml   |   3 +
 .../task/nipype/afni/fourier_callables.py     |  54 ++-
 example-specs/task/nipype/afni/fwh_mx.yaml    |   3 +
 .../task/nipype/afni/fwh_mx_callables.py      |  18 +-
 example-specs/task/nipype/afni/gcor.yaml      |   3 +
 example-specs/task/nipype/afni/hist.yaml      |   3 +
 .../task/nipype/afni/hist_callables.py        |  16 +-
 example-specs/task/nipype/afni/lfcd.yaml      |   3 +
 .../task/nipype/afni/lfcd_callables.py        |  54 ++-
 .../task/nipype/afni/local_bistat.yaml        |   3 +
 .../nipype/afni/local_bistat_callables.py     |  54 ++-
 example-specs/task/nipype/afni/localstat.yaml |   3 +
 .../task/nipype/afni/localstat_callables.py   |  54 ++-
 example-specs/task/nipype/afni/mask_tool.yaml |   3 +
 .../task/nipype/afni/mask_tool_callables.py   |  54 ++-
 example-specs/task/nipype/afni/maskave.yaml   |   3 +
 .../task/nipype/afni/maskave_callables.py     |  54 ++-
 example-specs/task/nipype/afni/means.yaml     |   3 +
 .../task/nipype/afni/means_callables.py       |  54 ++-
 example-specs/task/nipype/afni/merge.yaml     |   3 +
 .../task/nipype/afni/merge_callables.py       |  54 ++-
 example-specs/task/nipype/afni/net_corr.yaml  |   3 +
 .../task/nipype/afni/net_corr_callables.py    |  43 +-
 example-specs/task/nipype/afni/notes.yaml     |   3 +
 .../task/nipype/afni/nwarp_adjust.yaml        |   3 +
 .../nipype/afni/nwarp_adjust_callables.py     |   2 +-
 .../task/nipype/afni/nwarp_apply.yaml         |   3 +
 .../task/nipype/afni/nwarp_apply_callables.py |  14 +-
 example-specs/task/nipype/afni/nwarp_cat.yaml |   3 +
 .../task/nipype/afni/nwarp_cat_callables.py   |  43 +-
 .../task/nipype/afni/one_d_tool_py.yaml       |   5 +-
 .../nipype/afni/one_d_tool_py_callables.py    |   2 +-
 .../task/nipype/afni/outlier_count.yaml       |   3 +
 .../task/nipype/afni/quality_index.yaml       |   3 +
 .../nipype/afni/quality_index_callables.py    |  14 +-
 example-specs/task/nipype/afni/qwarp.yaml     |   5 +-
 .../task/nipype/afni/qwarp_callables.py       | 126 +++++-
 .../task/nipype/afni/qwarp_plus_minus.yaml    |   5 +-
 .../nipype/afni/qwarp_plus_minus_callables.py | 126 +++++-
 example-specs/task/nipype/afni/re_ho.yaml     |   3 +
 .../task/nipype/afni/re_ho_callables.py       |  14 +-
 example-specs/task/nipype/afni/refit.yaml     |   3 +
 example-specs/task/nipype/afni/remlfit.yaml   |   3 +
 .../task/nipype/afni/remlfit_callables.py     |   2 +-
 example-specs/task/nipype/afni/resample.yaml  |   3 +
 .../task/nipype/afni/resample_callables.py    |  54 ++-
 example-specs/task/nipype/afni/retroicor.yaml |   3 +
 .../task/nipype/afni/retroicor_callables.py   |  54 ++-
 example-specs/task/nipype/afni/roi_stats.yaml |   3 +
 .../task/nipype/afni/roi_stats_callables.py   |  14 +-
 example-specs/task/nipype/afni/seg.yaml       |   3 +
 .../task/nipype/afni/seg_callables.py         |  14 +-
 .../task/nipype/afni/skull_strip.yaml         |   3 +
 .../task/nipype/afni/skull_strip_callables.py |  54 ++-
 example-specs/task/nipype/afni/svm_test.yaml  |   3 +
 .../task/nipype/afni/svm_test_callables.py    |  54 ++-
 example-specs/task/nipype/afni/svm_train.yaml |   3 +
 .../task/nipype/afni/svm_train_callables.py   |  54 ++-
 .../task/nipype/afni/synthesize.yaml          |   3 +
 .../task/nipype/afni/synthesize_callables.py  |   2 +-
 example-specs/task/nipype/afni/t_cat.yaml     |   3 +
 .../task/nipype/afni/t_cat_callables.py       |  54 ++-
 .../task/nipype/afni/t_cat_sub_brick.yaml     |   3 +
 .../nipype/afni/t_cat_sub_brick_callables.py  |  55 ++-
 example-specs/task/nipype/afni/t_corr_1d.yaml |   3 +
 .../task/nipype/afni/t_corr_1d_callables.py   |  54 ++-
 .../task/nipype/afni/t_corr_map.yaml          |   5 +-
 .../task/nipype/afni/t_corr_map_callables.py  |  54 ++-
 .../task/nipype/afni/t_correlate.yaml         |   3 +
 .../task/nipype/afni/t_correlate_callables.py |  54 ++-
 example-specs/task/nipype/afni/t_norm.yaml    |   3 +
 .../task/nipype/afni/t_norm_callables.py      |  54 ++-
 example-specs/task/nipype/afni/t_project.yaml |   3 +
 .../task/nipype/afni/t_project_callables.py   |  54 ++-
 example-specs/task/nipype/afni/t_shift.yaml   |   3 +
 .../task/nipype/afni/t_shift_callables.py     |  54 ++-
 example-specs/task/nipype/afni/t_smooth.yaml  |   3 +
 .../task/nipype/afni/t_smooth_callables.py    |  54 ++-
 example-specs/task/nipype/afni/t_stat.yaml    |   3 +
 .../task/nipype/afni/t_stat_callables.py      |  54 ++-
 example-specs/task/nipype/afni/to_3d.yaml     |   3 +
 .../task/nipype/afni/to_3d_callables.py       |  54 ++-
 example-specs/task/nipype/afni/undump.yaml    |   3 +
 .../task/nipype/afni/undump_callables.py      |  54 ++-
 example-specs/task/nipype/afni/unifize.yaml   |   3 +
 .../task/nipype/afni/unifize_callables.py     |  54 ++-
 example-specs/task/nipype/afni/volreg.yaml    |   3 +
 .../task/nipype/afni/volreg_callables.py      |  54 ++-
 example-specs/task/nipype/afni/warp.yaml      |   3 +
 .../task/nipype/afni/warp_callables.py        |  55 ++-
 example-specs/task/nipype/afni/z_cut_up.yaml  |   3 +
 .../task/nipype/afni/z_cut_up_callables.py    |  54 ++-
 example-specs/task/nipype/afni/zcat.yaml      |   3 +
 .../task/nipype/afni/zcat_callables.py        |  54 ++-
 example-specs/task/nipype/afni/zeropad.yaml   |   3 +
 .../task/nipype/afni/zeropad_callables.py     |  54 ++-
 .../task/nipype/ants/affine_initializer.yaml  |   3 +
 example-specs/task/nipype/ants/ai.yaml        |   3 +
 example-specs/task/nipype/ants/ants.yaml      |   3 +
 .../task/nipype/ants/ants_introduction.yaml   |   3 +
 .../ants/ants_introduction_callables.py       |   2 +-
 .../task/nipype/ants/apply_transforms.yaml    |   3 +
 .../nipype/ants/apply_transforms_callables.py |   4 +-
 .../ants/apply_transforms_to_points.yaml      |   3 +
 .../apply_transforms_to_points_callables.py   |  14 +-
 example-specs/task/nipype/ants/atropos.yaml   |   7 +-
 .../task/nipype/ants/atropos_callables.py     |   4 +-
 .../nipype/ants/average_affine_transform.yaml |   3 +
 .../task/nipype/ants/average_images.yaml      |   3 +
 .../task/nipype/ants/brain_extraction.yaml    |   3 +
 .../nipype/ants/brain_extraction_callables.py |   2 +-
 .../nipype/ants/buildtemplateparallel.yaml    |   3 +
 .../ants/buildtemplateparallel_callables.py   |   5 +-
 .../nipype/ants/compose_multi_transform.yaml  |   3 +
 .../ants/compose_multi_transform_callables.py |  14 +-
 .../nipype/ants/composite_transform_util.yaml |   3 +
 .../ants/convert_scalar_image_to_rgb.yaml     |   3 +
 .../task/nipype/ants/cortical_thickness.yaml  |   3 +
 .../create_jacobian_determinant_image.yaml    |   3 +
 .../task/nipype/ants/create_tiled_mosaic.yaml |   3 +
 .../task/nipype/ants/denoise_image.yaml       |   3 +
 .../nipype/ants/denoise_image_callables.py    |  14 +-
 .../task/nipype/ants/gen_warp_fields.yaml     |   3 +
 .../nipype/ants/gen_warp_fields_callables.py  |   2 +-
 .../task/nipype/ants/image_math.yaml          |   3 +
 .../task/nipype/ants/image_math_callables.py  |  14 +-
 .../task/nipype/ants/joint_fusion.yaml        |   3 +
 .../nipype/ants/joint_fusion_callables.py     |   2 +-
 .../task/nipype/ants/kelly_kapowski.yaml      |   3 +
 .../nipype/ants/kelly_kapowski_callables.py   |  16 +-
 .../task/nipype/ants/label_geometry.yaml      |   3 +
 .../nipype/ants/label_geometry_callables.py   |  14 +-
 .../task/nipype/ants/laplacian_thickness.yaml |   3 +
 .../ants/laplacian_thickness_callables.py     |  14 +-
 .../nipype/ants/measure_image_similarity.yaml |   3 +
 .../measure_image_similarity_callables.py     |  14 +-
 .../task/nipype/ants/multiply_images.yaml     |   3 +
 .../nipype/ants/n4_bias_field_correction.yaml |   3 +
 .../n4_bias_field_correction_callables.py     |  16 +-
 .../task/nipype/ants/registration.yaml        |   3 +
 .../nipype/ants/registration_callables.py     |   2 +-
 .../nipype/ants/registration_syn_quick.yaml   |   3 +
 .../ants/resample_image_by_spacing.yaml       |   3 +
 .../resample_image_by_spacing_callables.py    |  14 +-
 .../task/nipype/ants/threshold_image.yaml     |   3 +
 .../nipype/ants/threshold_image_callables.py  |  14 +-
 .../ants/warp_image_multi_transform.yaml      |   3 +
 .../warp_image_multi_transform_callables.py   |   4 +-
 ...arp_time_series_image_multi_transform.yaml |   3 +
 ..._series_image_multi_transform_callables.py |   2 +-
 .../freesurfer/add_x_form_to_header.yaml      |   3 +
 .../task/nipype/freesurfer/aparc_2_aseg.yaml  |   3 +
 .../task/nipype/freesurfer/apas_2_aseg.yaml   |   3 +
 .../task/nipype/freesurfer/apply_mask.yaml    |   3 +
 .../nipype/freesurfer/apply_mask_callables.py |  14 +-
 .../freesurfer/apply_vol_transform.yaml       |   3 +
 .../apply_vol_transform_callables.py          |   5 +-
 .../task/nipype/freesurfer/bb_register.yaml   |   3 +
 .../freesurfer/bb_register_callables.py       |   3 +-
 .../task/nipype/freesurfer/binarize.yaml      |   3 +
 .../nipype/freesurfer/binarize_callables.py   |   5 +-
 .../task/nipype/freesurfer/ca_label.yaml      |   3 +
 .../task/nipype/freesurfer/ca_normalize.yaml  |   3 +
 .../task/nipype/freesurfer/ca_register.yaml   |   3 +
 .../freesurfer/check_talairach_alignment.yaml |   3 +
 .../task/nipype/freesurfer/concatenate.yaml   |   3 +
 .../freesurfer/concatenate_callables.py       |   2 +-
 .../nipype/freesurfer/concatenate_lta.yaml    |   3 +
 .../freesurfer/concatenate_lta_callables.py   |  14 +-
 .../task/nipype/freesurfer/contrast.yaml      |   3 +
 .../task/nipype/freesurfer/curvature.yaml     |   3 +
 .../nipype/freesurfer/curvature_stats.yaml    |   3 +
 .../task/nipype/freesurfer/dicom_convert.yaml |   3 +
 .../freesurfer/dicom_convert_callables.py     |  14 +-
 .../nipype/freesurfer/edit_w_mwith_aseg.yaml  |   3 +
 .../task/nipype/freesurfer/em_register.yaml   |   3 +
 .../task/nipype/freesurfer/euler_number.yaml  |   3 +
 .../freesurfer/extract_main_component.yaml    |   3 +
 .../extract_main_component_callables.py       |  14 +-
 .../task/nipype/freesurfer/fit_ms_params.yaml |   7 +-
 .../freesurfer/fit_ms_params_callables.py     |   2 +-
 .../task/nipype/freesurfer/fix_topology.yaml  |   3 +
 .../nipype/freesurfer/fuse_segmentations.yaml |   3 +
 .../task/nipype/freesurfer/glm_fit.yaml       |   3 +
 .../nipype/freesurfer/glm_fit_callables.py    |   4 +-
 .../task/nipype/freesurfer/gtm_seg.yaml       |   3 +
 .../task/nipype/freesurfer/gtmpvc.yaml        |   3 +
 .../nipype/freesurfer/gtmpvc_callables.py     |   2 +-
 .../task/nipype/freesurfer/image_info.yaml    |   3 +
 .../nipype/freesurfer/image_info_callables.py |  14 +-
 .../task/nipype/freesurfer/jacobian.yaml      |   3 +
 .../task/nipype/freesurfer/label_2_annot.yaml |   3 +
 .../task/nipype/freesurfer/label_2_label.yaml |   3 +
 .../task/nipype/freesurfer/label_2_vol.yaml   |   3 +
 .../freesurfer/label_2_vol_callables.py       |   5 +-
 .../task/nipype/freesurfer/logan_ref.yaml     |   3 +
 .../nipype/freesurfer/logan_ref_callables.py  |   4 +-
 .../task/nipype/freesurfer/lta_convert.yaml   |   3 +
 .../freesurfer/make_average_subject.yaml      |   3 +
 .../task/nipype/freesurfer/make_surfaces.yaml |   3 +
 .../freesurfer/make_surfaces_callables.py     |   2 +-
 .../freesurfer/mni_bias_correction.yaml       |   3 +
 .../mni_bias_correction_callables.py          |  14 +-
 .../task/nipype/freesurfer/mp_rto_mni305.yaml |   3 +
 .../freesurfer/mp_rto_mni305_callables.py     |   2 +-
 .../nipype/freesurfer/mr_is_ca_label.yaml     |   3 +
 .../task/nipype/freesurfer/mr_is_calc.yaml    |   3 +
 .../task/nipype/freesurfer/mr_is_combine.yaml |   3 +
 .../task/nipype/freesurfer/mr_is_convert.yaml |   7 +-
 .../freesurfer/mr_is_convert_callables.py     |   4 +-
 .../task/nipype/freesurfer/mr_is_expand.yaml  |   3 +
 .../task/nipype/freesurfer/mr_is_inflate.yaml |   3 +
 .../task/nipype/freesurfer/mri_convert.yaml   |   3 +
 .../freesurfer/mri_convert_callables.py       |   5 +-
 .../task/nipype/freesurfer/mri_coreg.yaml     |   3 +
 .../nipype/freesurfer/mri_coreg_callables.py  |   2 +-
 .../task/nipype/freesurfer/mri_fill.yaml      |   3 +
 .../nipype/freesurfer/mri_fill_callables.py   |   2 +-
 .../nipype/freesurfer/mri_marching_cubes.yaml |   7 +-
 .../mri_marching_cubes_callables.py           |   4 +-
 .../task/nipype/freesurfer/mri_pretess.yaml   |   3 +
 .../freesurfer/mri_pretess_callables.py       |  14 +-
 .../nipype/freesurfer/mri_tessellate.yaml     |   7 +-
 .../freesurfer/mri_tessellate_callables.py    |   4 +-
 .../task/nipype/freesurfer/mris_preproc.yaml  |   3 +
 .../freesurfer/mris_preproc_callables.py      |   2 +-
 .../freesurfer/mris_preproc_recon_all.yaml    |   3 +
 .../mris_preproc_recon_all_callables.py       |   2 +-
 .../task/nipype/freesurfer/mrtm.yaml          |   3 +
 .../task/nipype/freesurfer/mrtm2.yaml         |   3 +
 .../task/nipype/freesurfer/mrtm2_callables.py |   4 +-
 .../task/nipype/freesurfer/mrtm_callables.py  |   4 +-
 .../task/nipype/freesurfer/ms__lda.yaml       |   3 +
 .../nipype/freesurfer/ms__lda_callables.py    |   2 +-
 .../task/nipype/freesurfer/normalize.yaml     |   3 +
 .../nipype/freesurfer/one_sample_t_test.yaml  |   3 +
 .../freesurfer/one_sample_t_test_callables.py |   4 +-
 .../task/nipype/freesurfer/paint.yaml         |   3 +
 .../nipype/freesurfer/parcellation_stats.yaml |   3 +
 .../parcellation_stats_callables.py           |   2 +-
 .../nipype/freesurfer/parse_dicom_dir.yaml    |   3 +
 .../freesurfer/parse_dicom_dir_callables.py   |   2 +-
 .../task/nipype/freesurfer/recon_all.yaml     |   3 +
 .../task/nipype/freesurfer/register.yaml      |   3 +
 .../freesurfer/register_av_ito_talairach.yaml |   3 +
 .../nipype/freesurfer/register_callables.py   |   2 +-
 .../freesurfer/relabel_hypointensities.yaml   |   3 +
 .../freesurfer/remove_intersection.yaml       |   3 +
 .../task/nipype/freesurfer/remove_neck.yaml   |   3 +
 .../task/nipype/freesurfer/resample.yaml      |   3 +
 .../nipype/freesurfer/resample_callables.py   |   3 +-
 .../nipype/freesurfer/robust_register.yaml    |   3 +
 .../freesurfer/robust_register_callables.py   |   3 +-
 .../nipype/freesurfer/robust_template.yaml    |   3 +
 .../freesurfer/robust_template_callables.py   |   2 +-
 .../nipype/freesurfer/sample_to_surface.yaml  |   3 +
 .../freesurfer/sample_to_surface_callables.py |   5 +-
 .../task/nipype/freesurfer/seg_stats.yaml     |   3 +
 .../nipype/freesurfer/seg_stats_callables.py  |   5 +-
 .../freesurfer/seg_stats_recon_all.yaml       |   3 +
 .../seg_stats_recon_all_callables.py          |   5 +-
 .../task/nipype/freesurfer/segment_cc.yaml    |   3 +
 .../task/nipype/freesurfer/segment_wm.yaml    |   3 +
 .../task/nipype/freesurfer/smooth.yaml        |   3 +
 .../nipype/freesurfer/smooth_callables.py     |   3 +-
 .../freesurfer/smooth_tessellation.yaml       |   7 +-
 .../smooth_tessellation_callables.py          |   4 +-
 .../task/nipype/freesurfer/sphere.yaml        |   3 +
 .../nipype/freesurfer/spherical_average.yaml  |   7 +-
 .../freesurfer/spherical_average_callables.py |   2 +-
 .../freesurfer/surface_2_vol_transform.yaml   |   3 +
 .../surface_2_vol_transform_callables.py      |  14 +-
 .../nipype/freesurfer/surface_smooth.yaml     |   3 +
 .../freesurfer/surface_smooth_callables.py    |   3 +-
 .../nipype/freesurfer/surface_snapshots.yaml  |   7 +-
 .../freesurfer/surface_snapshots_callables.py |   3 +-
 .../nipype/freesurfer/surface_transform.yaml  |   3 +
 .../freesurfer/surface_transform_callables.py |   5 +-
 .../nipype/freesurfer/synthesize_flash.yaml   |   3 +
 .../freesurfer/synthesize_flash_callables.py  |   3 +-
 .../task/nipype/freesurfer/talairach_avi.yaml |   3 +
 .../task/nipype/freesurfer/talairach_qc.yaml  |   3 +
 .../task/nipype/freesurfer/tkregister_2.yaml  |   3 +
 .../freesurfer/tkregister_2_callables.py      |   5 +-
 .../nipype/freesurfer/unpack_sdicom_dir.yaml  |   3 +
 .../freesurfer/unpack_sdicom_dir_callables.py |  14 +-
 .../task/nipype/freesurfer/volume_mask.yaml   |   3 +
 .../freesurfer/watershed_skull_strip.yaml     |   3 +
 .../task/nipype/fsl/accuracy_tester.yaml      |   3 +
 .../nipype/fsl/accuracy_tester_callables.py   | 148 +++++++
 example-specs/task/nipype/fsl/apply_mask.yaml |   3 +
 .../task/nipype/fsl/apply_mask_callables.py   |  46 +-
 .../task/nipype/fsl/apply_topup.yaml          |   3 +
 .../task/nipype/fsl/apply_topup_callables.py  |  55 ++-
 example-specs/task/nipype/fsl/apply_warp.yaml |   3 +
 .../task/nipype/fsl/apply_warp_callables.py   |  46 +-
 example-specs/task/nipype/fsl/apply_xfm.yaml  |   3 +
 .../task/nipype/fsl/apply_xfm_callables.py    |  55 ++-
 example-specs/task/nipype/fsl/ar1_image.yaml  |   3 +
 .../task/nipype/fsl/ar1_image_callables.py    |  46 +-
 example-specs/task/nipype/fsl/av_scale.yaml   |   3 +
 example-specs/task/nipype/fsl/b0_calc.yaml    |   3 +
 .../task/nipype/fsl/b0_calc_callables.py      |  55 ++-
 example-specs/task/nipype/fsl/bedpostx5.yaml  |   3 +
 .../task/nipype/fsl/bedpostx5_callables.py    |  42 +-
 example-specs/task/nipype/fsl/bet.yaml        |   3 +
 .../task/nipype/fsl/bet_callables.py          |  44 +-
 .../task/nipype/fsl/binary_maths.yaml         |   3 +
 .../task/nipype/fsl/binary_maths_callables.py |  46 +-
 .../task/nipype/fsl/change_data_type.yaml     |   3 +
 .../nipype/fsl/change_data_type_callables.py  |  46 +-
 example-specs/task/nipype/fsl/classifier.yaml |   3 +
 example-specs/task/nipype/fsl/cleaner.yaml    |   3 +
 example-specs/task/nipype/fsl/cluster.yaml    |   3 +
 .../task/nipype/fsl/cluster_callables.py      |  46 +-
 example-specs/task/nipype/fsl/complex.yaml    |   3 +
 .../task/nipype/fsl/complex_callables.py      |  46 +-
 .../task/nipype/fsl/contrast_mgr.yaml         |   3 +
 .../task/nipype/fsl/contrast_mgr_callables.py |  46 +-
 .../task/nipype/fsl/convert_warp.yaml         |   3 +
 .../task/nipype/fsl/convert_warp_callables.py |  55 ++-
 .../task/nipype/fsl/convert_xfm.yaml          |   3 +
 .../task/nipype/fsl/convert_xfm_callables.py  |   5 +-
 example-specs/task/nipype/fsl/copy_geom.yaml  |   3 +
 .../task/nipype/fsl/copy_geom_callables.py    |  55 ++-
 .../task/nipype/fsl/dilate_image.yaml         |   3 +
 .../task/nipype/fsl/dilate_image_callables.py |  46 +-
 .../task/nipype/fsl/distance_map.yaml         |   3 +
 .../task/nipype/fsl/distance_map_callables.py |   5 +-
 example-specs/task/nipype/fsl/dti_fit.yaml    |   3 +
 .../task/nipype/fsl/dti_fit_callables.py      |  46 +-
 .../task/nipype/fsl/dual_regression.yaml      |   3 +
 .../nipype/fsl/dual_regression_callables.py   |   2 +-
 example-specs/task/nipype/fsl/eddy.yaml       |   3 +
 .../task/nipype/fsl/eddy_callables.py         |   2 +-
 .../task/nipype/fsl/eddy_correct.yaml         |   3 +
 .../task/nipype/fsl/eddy_correct_callables.py |  55 ++-
 example-specs/task/nipype/fsl/eddy_quad.yaml  |   3 +
 .../task/nipype/fsl/eddy_quad_callables.py    |   2 +-
 .../task/nipype/fsl/epi_de_warp.yaml          |  11 +-
 .../task/nipype/fsl/epi_de_warp_callables.py  |  46 +-
 example-specs/task/nipype/fsl/epi_reg.yaml    |   3 +
 .../task/nipype/fsl/epi_reg_callables.py      |   2 +-
 .../task/nipype/fsl/erode_image.yaml          |   3 +
 .../task/nipype/fsl/erode_image_callables.py  |  46 +-
 .../task/nipype/fsl/extract_roi.yaml          |   3 +
 .../task/nipype/fsl/extract_roi_callables.py  |  46 +-
 example-specs/task/nipype/fsl/fast.yaml       |   3 +
 .../task/nipype/fsl/fast_callables.py         |  46 +-
 example-specs/task/nipype/fsl/feat.yaml       |   3 +
 .../task/nipype/fsl/feat_callables.py         |   2 +-
 example-specs/task/nipype/fsl/feat_model.yaml |   3 +
 .../task/nipype/fsl/feat_model_callables.py   | 289 ++++++++++++-
 .../task/nipype/fsl/feature_extractor.yaml    |   3 +
 example-specs/task/nipype/fsl/filmgls.yaml    |   3 +
 .../task/nipype/fsl/filmgls_callables.py      | 174 +++++++-
 .../task/nipype/fsl/filter_regressor.yaml     |   3 +
 .../nipype/fsl/filter_regressor_callables.py  |  46 +-
 .../task/nipype/fsl/find_the_biggest.yaml     |   3 +
 .../nipype/fsl/find_the_biggest_callables.py  |  46 +-
 example-specs/task/nipype/fsl/first.yaml      |   3 +
 .../task/nipype/fsl/first_callables.py        |   2 +-
 example-specs/task/nipype/fsl/flameo.yaml     |   3 +
 .../task/nipype/fsl/flameo_callables.py       |   2 +-
 example-specs/task/nipype/fsl/flirt.yaml      |   3 +
 .../task/nipype/fsl/flirt_callables.py        |  55 ++-
 example-specs/task/nipype/fsl/fnirt.yaml      |   3 +
 .../task/nipype/fsl/fnirt_callables.py        | 397 +++++++++++++++++-
 example-specs/task/nipype/fsl/fugue.yaml      |   3 +
 .../task/nipype/fsl/fugue_callables.py        |  55 ++-
 example-specs/task/nipype/fsl/glm.yaml        |   3 +
 .../task/nipype/fsl/glm_callables.py          |  55 ++-
 example-specs/task/nipype/fsl/ica__aroma.yaml |   3 +
 .../task/nipype/fsl/image_maths.yaml          |   3 +
 .../task/nipype/fsl/image_maths_callables.py  |  46 +-
 .../task/nipype/fsl/image_meants.yaml         |   3 +
 .../task/nipype/fsl/image_meants_callables.py |  46 +-
 .../task/nipype/fsl/image_stats.yaml          |   3 +
 .../task/nipype/fsl/image_stats_callables.py  |  55 ++-
 example-specs/task/nipype/fsl/inv_warp.yaml   |   3 +
 .../task/nipype/fsl/inv_warp_callables.py     |  55 ++-
 .../task/nipype/fsl/isotropic_smooth.yaml     |   3 +
 .../nipype/fsl/isotropic_smooth_callables.py  |  46 +-
 example-specs/task/nipype/fsl/l2_model.yaml   |   3 +
 .../task/nipype/fsl/level_1_design.yaml       |   3 +
 .../task/nipype/fsl/make_dyadic_vectors.yaml  |   3 +
 .../fsl/make_dyadic_vectors_callables.py      |  42 +-
 .../task/nipype/fsl/maths_command.yaml        |   3 +
 .../nipype/fsl/maths_command_callables.py     |  46 +-
 example-specs/task/nipype/fsl/max_image.yaml  |   3 +
 .../task/nipype/fsl/max_image_callables.py    |  46 +-
 example-specs/task/nipype/fsl/maxn_image.yaml |   3 +
 .../task/nipype/fsl/maxn_image_callables.py   |  46 +-
 example-specs/task/nipype/fsl/mcflirt.yaml    |   3 +
 .../task/nipype/fsl/mcflirt_callables.py      | 176 +++++++-
 example-specs/task/nipype/fsl/mean_image.yaml |   3 +
 .../task/nipype/fsl/mean_image_callables.py   |  46 +-
 .../task/nipype/fsl/median_image.yaml         |   3 +
 .../task/nipype/fsl/median_image_callables.py |  46 +-
 example-specs/task/nipype/fsl/melodic.yaml    |   3 +
 .../task/nipype/fsl/melodic_callables.py      |   2 +-
 example-specs/task/nipype/fsl/merge.yaml      |   3 +
 .../task/nipype/fsl/merge_callables.py        |  55 ++-
 example-specs/task/nipype/fsl/min_image.yaml  |   3 +
 .../task/nipype/fsl/min_image_callables.py    |  46 +-
 .../task/nipype/fsl/motion_outliers.yaml      |   3 +
 .../nipype/fsl/motion_outliers_callables.py   |  55 ++-
 .../task/nipype/fsl/multi_image_maths.yaml    |   3 +
 .../nipype/fsl/multi_image_maths_callables.py |  46 +-
 .../nipype/fsl/multiple_regress_design.yaml   |   3 +
 example-specs/task/nipype/fsl/overlay.yaml    |   3 +
 .../task/nipype/fsl/overlay_callables.py      |  44 +-
 .../task/nipype/fsl/percentile_image.yaml     |   3 +
 .../nipype/fsl/percentile_image_callables.py  |  46 +-
 .../task/nipype/fsl/plot_motion_params.yaml   |   3 +
 .../fsl/plot_motion_params_callables.py       |   5 +-
 .../task/nipype/fsl/plot_time_series.yaml     |   3 +
 .../nipype/fsl/plot_time_series_callables.py  |  46 +-
 .../task/nipype/fsl/power_spectrum.yaml       |   3 +
 .../nipype/fsl/power_spectrum_callables.py    |  46 +-
 example-specs/task/nipype/fsl/prelude.yaml    |   3 +
 .../task/nipype/fsl/prelude_callables.py      |  46 +-
 .../task/nipype/fsl/prepare_fieldmap.yaml     |   3 +
 .../task/nipype/fsl/prob_track_x.yaml         |  11 +-
 .../task/nipype/fsl/prob_track_x2.yaml        |   7 +-
 .../nipype/fsl/prob_track_x2_callables.py     |  46 +-
 .../task/nipype/fsl/prob_track_x_callables.py |  46 +-
 .../task/nipype/fsl/proj_thresh.yaml          |   3 +
 .../task/nipype/fsl/proj_thresh_callables.py  |  44 +-
 example-specs/task/nipype/fsl/randomise.yaml  |   3 +
 .../task/nipype/fsl/randomise_callables.py    |  44 +-
 .../task/nipype/fsl/reorient_2_std.yaml       |   3 +
 .../nipype/fsl/reorient_2_std_callables.py    |  46 +-
 example-specs/task/nipype/fsl/robust_fov.yaml |   3 +
 .../task/nipype/fsl/robust_fov_callables.py   |  55 ++-
 example-specs/task/nipype/fsl/sig_loss.yaml   |   3 +
 .../task/nipype/fsl/sig_loss_callables.py     |  46 +-
 example-specs/task/nipype/fsl/slice.yaml      |   3 +
 .../task/nipype/fsl/slice_callables.py        | 138 +++++-
 .../task/nipype/fsl/slice_timer.yaml          |   7 +-
 .../task/nipype/fsl/slice_timer_callables.py  |  46 +-
 example-specs/task/nipype/fsl/slicer.yaml     |   3 +
 .../task/nipype/fsl/slicer_callables.py       |  46 +-
 example-specs/task/nipype/fsl/smm.yaml        |   3 +
 .../task/nipype/fsl/smm_callables.py          |  46 +-
 example-specs/task/nipype/fsl/smooth.yaml     |   3 +
 .../task/nipype/fsl/smooth_callables.py       |  55 ++-
 .../task/nipype/fsl/smooth_estimate.yaml      |   3 +
 .../nipype/fsl/smooth_estimate_callables.py   |  55 ++-
 .../task/nipype/fsl/spatial_filter.yaml       |   3 +
 .../nipype/fsl/spatial_filter_callables.py    |  46 +-
 example-specs/task/nipype/fsl/split.yaml      |   3 +
 .../task/nipype/fsl/split_callables.py        | 135 +++++-
 example-specs/task/nipype/fsl/std_image.yaml  |   3 +
 .../task/nipype/fsl/std_image_callables.py    |  46 +-
 example-specs/task/nipype/fsl/susan.yaml      |   7 +-
 .../task/nipype/fsl/susan_callables.py        |  46 +-
 .../task/nipype/fsl/swap_dimensions.yaml      |   3 +
 .../nipype/fsl/swap_dimensions_callables.py   |  46 +-
 .../task/nipype/fsl/temporal_filter.yaml      |   3 +
 .../nipype/fsl/temporal_filter_callables.py   |  46 +-
 .../task/nipype/fsl/text_2_vest.yaml          |   3 +
 .../task/nipype/fsl/text_2_vest_callables.py  |  55 ++-
 example-specs/task/nipype/fsl/threshold.yaml  |   3 +
 .../task/nipype/fsl/threshold_callables.py    |  46 +-
 example-specs/task/nipype/fsl/topup.yaml      |   3 +
 .../task/nipype/fsl/topup_callables.py        | 185 +++++++-
 .../task/nipype/fsl/tract_skeleton.yaml       |   3 +
 .../nipype/fsl/tract_skeleton_callables.py    |   3 +-
 example-specs/task/nipype/fsl/training.yaml   |   3 +
 .../task/nipype/fsl/training_callables.py     |   2 +-
 .../task/nipype/fsl/training_set_creator.yaml |   3 +
 .../task/nipype/fsl/unary_maths.yaml          |   3 +
 .../task/nipype/fsl/unary_maths_callables.py  |  46 +-
 example-specs/task/nipype/fsl/vec_reg.yaml    |   3 +
 .../task/nipype/fsl/vec_reg_callables.py      |  46 +-
 .../task/nipype/fsl/vest_2_text.yaml          |   3 +
 .../task/nipype/fsl/vest_2_text_callables.py  |  55 ++-
 .../task/nipype/fsl/warp_points.yaml          |   3 +
 .../task/nipype/fsl/warp_points_callables.py  |  14 +-
 .../task/nipype/fsl/warp_points_from_std.yaml |   3 +
 .../task/nipype/fsl/warp_points_to_std.yaml   |   3 +
 .../fsl/warp_points_to_std_callables.py       |  14 +-
 example-specs/task/nipype/fsl/warp_utils.yaml |   3 +
 .../task/nipype/fsl/warp_utils_callables.py   |  55 ++-
 example-specs/task/nipype/fsl/x_fibres_5.yaml |   3 +
 .../task/nipype/fsl/x_fibres_5_callables.py   |  46 +-
 nipype2pydra/pkg_gen/__init__.py              |  23 +-
 nipype2pydra/task/base.py                     |   5 +-
 nipype2pydra/utils.py                         |  20 +-
 549 files changed, 9455 insertions(+), 705 deletions(-)

diff --git a/example-specs/task/nipype/afni/a_boverlap.yaml b/example-specs/task/nipype/afni/a_boverlap.yaml
index feee2e75..d36bb443 100644
--- a/example-specs/task/nipype/afni/a_boverlap.yaml
+++ b/example-specs/task/nipype/afni/a_boverlap.yaml
@@ -44,6 +44,9 @@ inputs:
     out_file: Path
     # type=file: output file
     # type=file|default=<undefined>: collect output to a file
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/a_boverlap_callables.py b/example-specs/task/nipype/afni/a_boverlap_callables.py
index fd07d144..f199f389 100644
--- a/example-specs/task/nipype/afni/a_boverlap_callables.py
+++ b/example-specs/task/nipype/afni/a_boverlap_callables.py
@@ -1,9 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of ABoverlap.yaml"""
 
-import os
-import attrs
-import os.path as op
+from looseversion import LooseVersion
 import logging
+import os.path as op
+import attrs
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +17,16 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -183,6 +194,43 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/afni/afn_ito_nifti.yaml b/example-specs/task/nipype/afni/afn_ito_nifti.yaml
index f881f485..37cce29d 100644
--- a/example-specs/task/nipype/afni/afn_ito_nifti.yaml
+++ b/example-specs/task/nipype/afni/afn_ito_nifti.yaml
@@ -41,6 +41,9 @@ inputs:
     out_file: Path
     # type=file: output file
     # type=file|default=<undefined>: output image file name
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/afn_ito_nifti_callables.py b/example-specs/task/nipype/afni/afn_ito_nifti_callables.py
index 178875c1..d60e087e 100644
--- a/example-specs/task/nipype/afni/afn_ito_nifti_callables.py
+++ b/example-specs/task/nipype/afni/afn_ito_nifti_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of AFNItoNIFTI.yaml"""
 
-import os
-import attrs
-import os.path as op
 import logging
+import os.path as op
+import attrs
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +16,16 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/afni/align_epi_anat_py.yaml b/example-specs/task/nipype/afni/align_epi_anat_py.yaml
index e6fd8200..50367a88 100644
--- a/example-specs/task/nipype/afni/align_epi_anat_py.yaml
+++ b/example-specs/task/nipype/afni/align_epi_anat_py.yaml
@@ -74,6 +74,9 @@ inputs:
     # type=file|default=<undefined>: name of structural dataset
     in_file: medimage/nifti1
     # type=file|default=<undefined>: EPI dataset to align
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/align_epi_anat_py_callables.py b/example-specs/task/nipype/afni/align_epi_anat_py_callables.py
index 5c90be59..72862ae5 100644
--- a/example-specs/task/nipype/afni/align_epi_anat_py_callables.py
+++ b/example-specs/task/nipype/afni/align_epi_anat_py_callables.py
@@ -1,7 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of AlignEpiAnatPy.yaml"""
 
-import os
+from looseversion import LooseVersion
+from pathlib import Path
 import os.path as op
+import os
 
 
 def anat_al_orig_callable(output_dir, inputs, stdout, stderr):
@@ -74,6 +76,43 @@ def skullstrip_callable(output_dir, inputs, stdout, stderr):
     return outputs["skullstrip"]
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -307,6 +346,89 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+class Info(PackageInfo):
+    """Handle afni output type and version information."""
+
+    __outputtype = "AFNI"
+    ftypes = {"NIFTI": ".nii", "AFNI": "", "NIFTI_GZ": ".nii.gz"}
+    version_cmd = "afni --version"
+
+    @staticmethod
+    def parse_version(raw_info):
+        """Check and parse AFNI's version."""
+        version_stamp = raw_info.split("\n")[0].split("Version ")[1]
+        if version_stamp.startswith("AFNI"):
+            version_stamp = version_stamp.split("AFNI_")[1]
+        elif version_stamp.startswith("Debian"):
+            version_stamp = version_stamp.split("Debian-")[1].split("~")[0]
+        else:
+            return None
+
+        version = LooseVersion(version_stamp.replace("_", ".")).version[:3]
+        if version[0] < 1000:
+            version[0] = version[0] + 2000
+        return tuple(version)
+
+    @classmethod
+    def output_type_to_ext(cls, outputtype):
+        """
+        Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        outputtype : {'NIFTI', 'NIFTI_GZ', 'AFNI'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+
+        """
+        try:
+            return cls.ftypes[outputtype]
+        except KeyError as e:
+            msg = "Invalid AFNIOUTPUTTYPE: ", outputtype
+            raise KeyError(msg) from e
+
+    @classmethod
+    def outputtype(cls):
+        """
+        Set default output filetype.
+
+        AFNI has no environment variables, Output filetypes get set in command line calls
+        Nipype uses ``AFNI`` as default
+
+
+        Returns
+        -------
+        None
+
+        """
+        return "AFNI"
+
+    @staticmethod
+    def standard_image(img_name):
+        """
+        Grab an image from the standard location.
+
+        Could be made more fancy to allow for more relocatability
+
+        """
+        clout = CommandLine(
+            "which afni",
+            ignore_exception=True,
+            resource_monitor=False,
+            terminal_output="allatonce",
+        ).run()
+        if clout.runtime.returncode != 0:
+            return None
+
+        out = clout.runtime.stdout
+        basedir = os.path.split(out)[0]
+        return os.path.join(basedir, img_name)
+
+
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     anat_prefix = _gen_fname(
diff --git a/example-specs/task/nipype/afni/allineate.yaml b/example-specs/task/nipype/afni/allineate.yaml
index f53cd86e..ba89bbef 100644
--- a/example-specs/task/nipype/afni/allineate.yaml
+++ b/example-specs/task/nipype/afni/allineate.yaml
@@ -80,6 +80,9 @@ inputs:
     # type=file|default=<undefined>: mask the input dataset
     weight_file: generic/file
     # type=file|default=<undefined>: Set the weighting for each voxel in the base dataset; larger weights mean that voxel count more in the cost function. Must be defined on the same grid as the base dataset
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/allineate_callables.py b/example-specs/task/nipype/afni/allineate_callables.py
index b28448db..84570c63 100644
--- a/example-specs/task/nipype/afni/allineate_callables.py
+++ b/example-specs/task/nipype/afni/allineate_callables.py
@@ -1,9 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of Allineate.yaml"""
 
-import os
-import attrs
-import os.path as op
+from looseversion import LooseVersion
 import logging
+from pathlib import Path
+import os.path as op
+import attrs
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -44,6 +46,43 @@ def allcostx_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -295,6 +334,16 @@ def _gen_fname(
     return fname
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/afni/auto_tcorrelate.yaml b/example-specs/task/nipype/afni/auto_tcorrelate.yaml
index fce64ac6..b9d34a84 100644
--- a/example-specs/task/nipype/afni/auto_tcorrelate.yaml
+++ b/example-specs/task/nipype/afni/auto_tcorrelate.yaml
@@ -48,6 +48,9 @@ inputs:
     out_file: Path
     # type=file: output file
     # type=file|default=<undefined>: output image file name
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/auto_tcorrelate_callables.py b/example-specs/task/nipype/afni/auto_tcorrelate_callables.py
index cc1abafc..2feaf232 100644
--- a/example-specs/task/nipype/afni/auto_tcorrelate_callables.py
+++ b/example-specs/task/nipype/afni/auto_tcorrelate_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of AutoTcorrelate.yaml"""
 
-import os
-import attrs
-import os.path as op
 import logging
+import os.path as op
+import attrs
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -75,6 +75,16 @@ def _overload_extension(
     return os.path.join(path, base + ext)
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/afni/auto_tlrc.yaml b/example-specs/task/nipype/afni/auto_tlrc.yaml
index 9decfcbe..3d30de20 100644
--- a/example-specs/task/nipype/afni/auto_tlrc.yaml
+++ b/example-specs/task/nipype/afni/auto_tlrc.yaml
@@ -38,6 +38,9 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/nifti1
     # type=file|default=<undefined>: Original anatomical volume (+orig).The skull is removed by this scriptunless instructed otherwise (-no_ss).
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/auto_tlrc_callables.py b/example-specs/task/nipype/afni/auto_tlrc_callables.py
index a308d53d..67bf2581 100644
--- a/example-specs/task/nipype/afni/auto_tlrc_callables.py
+++ b/example-specs/task/nipype/afni/auto_tlrc_callables.py
@@ -1,7 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of AutoTLRC.yaml"""
 
-import os
+from looseversion import LooseVersion
+from pathlib import Path
 import os.path as op
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -11,6 +13,43 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_file"]
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
diff --git a/example-specs/task/nipype/afni/autobox.yaml b/example-specs/task/nipype/afni/autobox.yaml
index 5393082e..8b34631c 100644
--- a/example-specs/task/nipype/afni/autobox.yaml
+++ b/example-specs/task/nipype/afni/autobox.yaml
@@ -41,6 +41,9 @@ inputs:
     out_file: Path
     # type=file: output file
     # type=file|default=<undefined>: 
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/autobox_callables.py b/example-specs/task/nipype/afni/autobox_callables.py
index c698a6c1..daaea063 100644
--- a/example-specs/task/nipype/afni/autobox_callables.py
+++ b/example-specs/task/nipype/afni/autobox_callables.py
@@ -1,9 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Autobox.yaml"""
 
-import os
-import attrs
-import os.path as op
+from looseversion import LooseVersion
 import logging
+import os.path as op
+import attrs
+import os
 
 
 def x_min_callable(output_dir, inputs, stdout, stderr):
@@ -58,6 +59,16 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -225,6 +236,43 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/afni/automask.yaml b/example-specs/task/nipype/afni/automask.yaml
index fa692b23..4b1d2a0f 100644
--- a/example-specs/task/nipype/afni/automask.yaml
+++ b/example-specs/task/nipype/afni/automask.yaml
@@ -44,6 +44,9 @@ inputs:
     out_file: Path
     # type=file: mask file
     # type=file|default=<undefined>: output image file name
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/automask_callables.py b/example-specs/task/nipype/afni/automask_callables.py
index 130f59a5..36b39aa3 100644
--- a/example-specs/task/nipype/afni/automask_callables.py
+++ b/example-specs/task/nipype/afni/automask_callables.py
@@ -1,9 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Automask.yaml"""
 
-import os
-import attrs
-import os.path as op
+from looseversion import LooseVersion
 import logging
+import os.path as op
+import attrs
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -23,6 +24,16 @@ def brain_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -190,6 +201,43 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/afni/axialize.yaml b/example-specs/task/nipype/afni/axialize.yaml
index 15d7c942..5cef0105 100644
--- a/example-specs/task/nipype/afni/axialize.yaml
+++ b/example-specs/task/nipype/afni/axialize.yaml
@@ -41,6 +41,9 @@ inputs:
     out_file: Path
     # type=file: output file
     # type=file|default=<undefined>: output image file name
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/axialize_callables.py b/example-specs/task/nipype/afni/axialize_callables.py
index 10eb0039..73457687 100644
--- a/example-specs/task/nipype/afni/axialize_callables.py
+++ b/example-specs/task/nipype/afni/axialize_callables.py
@@ -1,9 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Axialize.yaml"""
 
-import os
-import attrs
-import os.path as op
+from looseversion import LooseVersion
 import logging
+import os.path as op
+import attrs
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +17,16 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -183,6 +194,43 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/afni/bandpass.yaml b/example-specs/task/nipype/afni/bandpass.yaml
index af0d857c..cb60f0b7 100644
--- a/example-specs/task/nipype/afni/bandpass.yaml
+++ b/example-specs/task/nipype/afni/bandpass.yaml
@@ -49,6 +49,9 @@ inputs:
     out_file: Path
     # type=file: output file
     # type=file|default=<undefined>: output file from 3dBandpass
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/bandpass_callables.py b/example-specs/task/nipype/afni/bandpass_callables.py
index c66e3d13..ebf616be 100644
--- a/example-specs/task/nipype/afni/bandpass_callables.py
+++ b/example-specs/task/nipype/afni/bandpass_callables.py
@@ -1,9 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Bandpass.yaml"""
 
-import os
-import attrs
-import os.path as op
+from looseversion import LooseVersion
 import logging
+import os.path as op
+import attrs
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +17,16 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -183,6 +194,43 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/afni/blur_in_mask.yaml b/example-specs/task/nipype/afni/blur_in_mask.yaml
index cf1e87c2..6c2e90ac 100644
--- a/example-specs/task/nipype/afni/blur_in_mask.yaml
+++ b/example-specs/task/nipype/afni/blur_in_mask.yaml
@@ -45,6 +45,9 @@ inputs:
     out_file: Path
     # type=file: output file
     # type=file|default=<undefined>: output to the file
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/blur_in_mask_callables.py b/example-specs/task/nipype/afni/blur_in_mask_callables.py
index a08927eb..595b9b6b 100644
--- a/example-specs/task/nipype/afni/blur_in_mask_callables.py
+++ b/example-specs/task/nipype/afni/blur_in_mask_callables.py
@@ -1,9 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of BlurInMask.yaml"""
 
-import os
-import attrs
-import os.path as op
+from looseversion import LooseVersion
 import logging
+import os.path as op
+import attrs
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +17,16 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -183,6 +194,43 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/afni/blur_to_fwhm.yaml b/example-specs/task/nipype/afni/blur_to_fwhm.yaml
index f47d34af..aec24f30 100644
--- a/example-specs/task/nipype/afni/blur_to_fwhm.yaml
+++ b/example-specs/task/nipype/afni/blur_to_fwhm.yaml
@@ -45,6 +45,9 @@ inputs:
     out_file: Path
     # type=file: output file
     # type=file|default=<undefined>: output image file name
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/blur_to_fwhm_callables.py b/example-specs/task/nipype/afni/blur_to_fwhm_callables.py
index a3b3e2dc..7ed9c0c0 100644
--- a/example-specs/task/nipype/afni/blur_to_fwhm_callables.py
+++ b/example-specs/task/nipype/afni/blur_to_fwhm_callables.py
@@ -1,9 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of BlurToFWHM.yaml"""
 
-import os
-import attrs
-import os.path as op
+from looseversion import LooseVersion
 import logging
+import os.path as op
+import attrs
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +17,16 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -183,6 +194,43 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/afni/brick_stat.yaml b/example-specs/task/nipype/afni/brick_stat.yaml
index 6675ed50..6c74e1a3 100644
--- a/example-specs/task/nipype/afni/brick_stat.yaml
+++ b/example-specs/task/nipype/afni/brick_stat.yaml
@@ -41,6 +41,9 @@ inputs:
     # type=file|default=<undefined>: input file to 3dmaskave
     mask: medimage/nifti-gz
     # type=file|default=<undefined>: -mask dset = use dset as mask to include/exclude voxels
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/brick_stat_callables.py b/example-specs/task/nipype/afni/brick_stat_callables.py
index 68498b74..94e47a75 100644
--- a/example-specs/task/nipype/afni/brick_stat_callables.py
+++ b/example-specs/task/nipype/afni/brick_stat_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of BrickStat.yaml"""
 
-import os
+import logging
 import os.path as op
 import attrs
-import logging
+import os
 
 
 def min_val_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +16,16 @@ def min_val_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/afni/bucket.yaml b/example-specs/task/nipype/afni/bucket.yaml
index 51046d36..c9e9c2d2 100644
--- a/example-specs/task/nipype/afni/bucket.yaml
+++ b/example-specs/task/nipype/afni/bucket.yaml
@@ -49,6 +49,9 @@ inputs:
     out_file: Path
     # type=file: output file
     # type=file|default=<undefined>: 
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/bucket_callables.py b/example-specs/task/nipype/afni/bucket_callables.py
index cd06e4a0..7de7c58a 100644
--- a/example-specs/task/nipype/afni/bucket_callables.py
+++ b/example-specs/task/nipype/afni/bucket_callables.py
@@ -1,9 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Bucket.yaml"""
 
-import os
-import attrs
-import os.path as op
+from looseversion import LooseVersion
 import logging
+import os.path as op
+import attrs
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +17,16 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -183,6 +194,43 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/afni/calc.yaml b/example-specs/task/nipype/afni/calc.yaml
index 1bd485b1..86bc8152 100644
--- a/example-specs/task/nipype/afni/calc.yaml
+++ b/example-specs/task/nipype/afni/calc.yaml
@@ -59,6 +59,9 @@ inputs:
     out_file: Path
     # type=file: output file
     # type=file|default=<undefined>: output image file name
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/calc_callables.py b/example-specs/task/nipype/afni/calc_callables.py
index 6ef9e409..46758951 100644
--- a/example-specs/task/nipype/afni/calc_callables.py
+++ b/example-specs/task/nipype/afni/calc_callables.py
@@ -1,9 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Calc.yaml"""
 
-import os
-import attrs
-import os.path as op
+from looseversion import LooseVersion
 import logging
+import os.path as op
+import attrs
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +17,16 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -183,6 +194,43 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/afni/cat.yaml b/example-specs/task/nipype/afni/cat.yaml
index e0bd15ca..c59ee780 100644
--- a/example-specs/task/nipype/afni/cat.yaml
+++ b/example-specs/task/nipype/afni/cat.yaml
@@ -43,6 +43,9 @@ inputs:
     out_file: Path
     # type=file: output file
     # type=file|default='catout.1d': output (concatenated) file name
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/cat_callables.py b/example-specs/task/nipype/afni/cat_callables.py
index e2691aac..9dbfe814 100644
--- a/example-specs/task/nipype/afni/cat_callables.py
+++ b/example-specs/task/nipype/afni/cat_callables.py
@@ -1,9 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Cat.yaml"""
 
-import os
-import attrs
-import os.path as op
+from looseversion import LooseVersion
 import logging
+import os.path as op
+import attrs
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +17,16 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -183,6 +194,43 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/afni/cat_matvec.yaml b/example-specs/task/nipype/afni/cat_matvec.yaml
index 2e222e3c..678b5673 100644
--- a/example-specs/task/nipype/afni/cat_matvec.yaml
+++ b/example-specs/task/nipype/afni/cat_matvec.yaml
@@ -38,6 +38,9 @@ inputs:
     out_file: Path
     # type=file: output file
     # type=file|default=<undefined>: File to write concattenated matvecs to
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/cat_matvec_callables.py b/example-specs/task/nipype/afni/cat_matvec_callables.py
index 176000e6..bcccc59c 100644
--- a/example-specs/task/nipype/afni/cat_matvec_callables.py
+++ b/example-specs/task/nipype/afni/cat_matvec_callables.py
@@ -1,9 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of CatMatvec.yaml"""
 
-import os
-import attrs
-import os.path as op
+from looseversion import LooseVersion
 import logging
+import os.path as op
+import attrs
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +17,16 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -183,6 +194,43 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/afni/center_mass.yaml b/example-specs/task/nipype/afni/center_mass.yaml
index a6a758cb..f66bb73b 100644
--- a/example-specs/task/nipype/afni/center_mass.yaml
+++ b/example-specs/task/nipype/afni/center_mass.yaml
@@ -49,6 +49,9 @@ inputs:
     # type=file|default=<undefined>: input file to 3dCM
     mask_file: generic/file
     # type=file|default=<undefined>: Only voxels with nonzero values in the provided mask will be averaged.
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -88,7 +91,7 @@ tests:
     automask:
     # type=bool|default=False: Generate the mask automatically
     set_cm:
-    # type=tuple|default=(<traits.trait_types.Float object at 0x10aa84810>, <traits.trait_types.Float object at 0x10aa84910>, <traits.trait_types.Float object at 0x10aa84990>): After computing the center of mass, set the origin fields in the header so that the center of mass will be at (x,y,z) in DICOM coords.
+    # type=tuple|default=(<traits.trait_types.Float object at 0x1121a7a50>, <traits.trait_types.Float object at 0x1121a7b50>, <traits.trait_types.Float object at 0x1121a7bd0>): After computing the center of mass, set the origin fields in the header so that the center of mass will be at (x,y,z) in DICOM coords.
     local_ijk:
     # type=bool|default=False: Output values as (i,j,k) in local orientation
     roi_vals:
diff --git a/example-specs/task/nipype/afni/center_mass_callables.py b/example-specs/task/nipype/afni/center_mass_callables.py
index fc522168..98b2d9c9 100644
--- a/example-specs/task/nipype/afni/center_mass_callables.py
+++ b/example-specs/task/nipype/afni/center_mass_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of CenterMass.yaml"""
 
-import os
-import attrs
-import os.path as op
-import logging
 import numpy as np
+import logging
+import os.path as op
+import attrs
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -31,6 +31,16 @@ def cm_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/afni/clip_level.yaml b/example-specs/task/nipype/afni/clip_level.yaml
index 10e029a0..bc1eb0b0 100644
--- a/example-specs/task/nipype/afni/clip_level.yaml
+++ b/example-specs/task/nipype/afni/clip_level.yaml
@@ -39,6 +39,9 @@ inputs:
     # type=file|default=<undefined>: Also compute a 'gradual' clip level as a function of voxel position, and output that to a dataset.
     in_file: medimage/nifti1
     # type=file|default=<undefined>: input file to 3dClipLevel
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/clip_level_callables.py b/example-specs/task/nipype/afni/clip_level_callables.py
index 7b7e5c35..11355d4d 100644
--- a/example-specs/task/nipype/afni/clip_level_callables.py
+++ b/example-specs/task/nipype/afni/clip_level_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of ClipLevel.yaml"""
 
-import os
+import logging
 import os.path as op
 import attrs
-import logging
+import os
 
 
 def clip_val_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +16,16 @@ def clip_val_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/afni/convert_dset.yaml b/example-specs/task/nipype/afni/convert_dset.yaml
index 17bd9095..70b3be29 100644
--- a/example-specs/task/nipype/afni/convert_dset.yaml
+++ b/example-specs/task/nipype/afni/convert_dset.yaml
@@ -41,6 +41,9 @@ inputs:
     out_file: Path
     # type=file: output file
     # type=file|default=<undefined>: output file for ConvertDset
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/copy.yaml b/example-specs/task/nipype/afni/copy.yaml
index 48e7b944..94c744c1 100644
--- a/example-specs/task/nipype/afni/copy.yaml
+++ b/example-specs/task/nipype/afni/copy.yaml
@@ -59,6 +59,9 @@ inputs:
     out_file: Path
     # type=file: output file
     # type=file|default=<undefined>: output image file name
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/copy_callables.py b/example-specs/task/nipype/afni/copy_callables.py
index 28aa757c..50b8383d 100644
--- a/example-specs/task/nipype/afni/copy_callables.py
+++ b/example-specs/task/nipype/afni/copy_callables.py
@@ -1,9 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Copy.yaml"""
 
-import os
-import attrs
-import os.path as op
+from looseversion import LooseVersion
 import logging
+import os.path as op
+import attrs
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +17,16 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -183,6 +194,43 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/afni/deconvolve.yaml b/example-specs/task/nipype/afni/deconvolve.yaml
index 35693fcc..97d640a0 100644
--- a/example-specs/task/nipype/afni/deconvolve.yaml
+++ b/example-specs/task/nipype/afni/deconvolve.yaml
@@ -57,6 +57,9 @@ inputs:
     x1D: Path
     # type=file: save out X matrix
     # type=file|default=<undefined>: specify name for saved X matrix
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/deconvolve_callables.py b/example-specs/task/nipype/afni/deconvolve_callables.py
index 71fca94c..5cbd9dc5 100644
--- a/example-specs/task/nipype/afni/deconvolve_callables.py
+++ b/example-specs/task/nipype/afni/deconvolve_callables.py
@@ -1,8 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Deconvolve.yaml"""
 
-import os
-import attrs
+from looseversion import LooseVersion
+from pathlib import Path
 import os.path as op
+import attrs
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -33,6 +35,43 @@ def cbucket_callable(output_dir, inputs, stdout, stderr):
     return outputs["cbucket"]
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
diff --git a/example-specs/task/nipype/afni/degree_centrality.yaml b/example-specs/task/nipype/afni/degree_centrality.yaml
index f744c61d..f187adce 100644
--- a/example-specs/task/nipype/afni/degree_centrality.yaml
+++ b/example-specs/task/nipype/afni/degree_centrality.yaml
@@ -45,6 +45,9 @@ inputs:
     out_file: Path
     # type=file: output file
     # type=file|default=<undefined>: output image file name
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/degree_centrality_callables.py b/example-specs/task/nipype/afni/degree_centrality_callables.py
index 777a981e..02e7b8c0 100644
--- a/example-specs/task/nipype/afni/degree_centrality_callables.py
+++ b/example-specs/task/nipype/afni/degree_centrality_callables.py
@@ -1,9 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of DegreeCentrality.yaml"""
 
-import os
-import attrs
-import os.path as op
+from looseversion import LooseVersion
 import logging
+import os.path as op
+import attrs
+import os
 
 
 def oned_file_callable(output_dir, inputs, stdout, stderr):
@@ -23,6 +24,43 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -178,6 +216,16 @@ def nipype_interfaces_afni__AFNICommand___list_outputs(
     return outputs
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/afni/despike.yaml b/example-specs/task/nipype/afni/despike.yaml
index 5cc7b147..23855511 100644
--- a/example-specs/task/nipype/afni/despike.yaml
+++ b/example-specs/task/nipype/afni/despike.yaml
@@ -39,6 +39,9 @@ inputs:
     out_file: Path
     # type=file: output file
     # type=file|default=<undefined>: output image file name
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/despike_callables.py b/example-specs/task/nipype/afni/despike_callables.py
index 6f9d8f0e..d9c9ecf4 100644
--- a/example-specs/task/nipype/afni/despike_callables.py
+++ b/example-specs/task/nipype/afni/despike_callables.py
@@ -1,9 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Despike.yaml"""
 
-import os
-import attrs
-import os.path as op
+from looseversion import LooseVersion
 import logging
+import os.path as op
+import attrs
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +17,16 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -183,6 +194,43 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/afni/detrend.yaml b/example-specs/task/nipype/afni/detrend.yaml
index 82a275a1..d4089ebb 100644
--- a/example-specs/task/nipype/afni/detrend.yaml
+++ b/example-specs/task/nipype/afni/detrend.yaml
@@ -42,6 +42,9 @@ inputs:
     out_file: Path
     # type=file: output file
     # type=file|default=<undefined>: output image file name
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/detrend_callables.py b/example-specs/task/nipype/afni/detrend_callables.py
index c53f0fb8..25a3490f 100644
--- a/example-specs/task/nipype/afni/detrend_callables.py
+++ b/example-specs/task/nipype/afni/detrend_callables.py
@@ -1,9 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Detrend.yaml"""
 
-import os
-import attrs
-import os.path as op
+from looseversion import LooseVersion
 import logging
+import os.path as op
+import attrs
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +17,16 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -183,6 +194,43 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/afni/dot.yaml b/example-specs/task/nipype/afni/dot.yaml
index 13328318..2a5adbd8 100644
--- a/example-specs/task/nipype/afni/dot.yaml
+++ b/example-specs/task/nipype/afni/dot.yaml
@@ -47,6 +47,9 @@ inputs:
     out_file: Path
     # type=file: output file
     # type=file|default=<undefined>: collect output to a file
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -82,7 +85,7 @@ tests:
     mask:
     # type=file|default=<undefined>: Use this dataset as a mask
     mrange:
-    # type=tuple|default=(<traits.trait_types.Float object at 0x10aa87250>, <traits.trait_types.Float object at 0x10aa87150>): Means to further restrict the voxels from 'mset' so thatonly those mask values within this range (inclusive) willbe used.
+    # type=tuple|default=(<traits.trait_types.Float object at 0x1121ae190>, <traits.trait_types.Float object at 0x1121ae090>): Means to further restrict the voxels from 'mset' so thatonly those mask values within this range (inclusive) willbe used.
     demean:
     # type=bool|default=False: Remove the mean from each volume prior to computing the correlation
     docor:
diff --git a/example-specs/task/nipype/afni/dot_callables.py b/example-specs/task/nipype/afni/dot_callables.py
index fcc3f28d..c79c04f3 100644
--- a/example-specs/task/nipype/afni/dot_callables.py
+++ b/example-specs/task/nipype/afni/dot_callables.py
@@ -1,9 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Dot.yaml"""
 
-import os
-import attrs
-import os.path as op
+from looseversion import LooseVersion
 import logging
+import os.path as op
+import attrs
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +17,16 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -183,6 +194,43 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/afni/ecm.yaml b/example-specs/task/nipype/afni/ecm.yaml
index 4403999f..d813de93 100644
--- a/example-specs/task/nipype/afni/ecm.yaml
+++ b/example-specs/task/nipype/afni/ecm.yaml
@@ -45,6 +45,9 @@ inputs:
     out_file: Path
     # type=file: output file
     # type=file|default=<undefined>: output image file name
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/ecm_callables.py b/example-specs/task/nipype/afni/ecm_callables.py
index a7306533..4afbdd00 100644
--- a/example-specs/task/nipype/afni/ecm_callables.py
+++ b/example-specs/task/nipype/afni/ecm_callables.py
@@ -1,9 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of ECM.yaml"""
 
-import os
-import attrs
-import os.path as op
+from looseversion import LooseVersion
 import logging
+import os.path as op
+import attrs
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +17,16 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -183,6 +194,43 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/afni/edge_3.yaml b/example-specs/task/nipype/afni/edge_3.yaml
index 81f33864..f5a6aa1f 100644
--- a/example-specs/task/nipype/afni/edge_3.yaml
+++ b/example-specs/task/nipype/afni/edge_3.yaml
@@ -42,6 +42,9 @@ inputs:
     out_file: Path
     # type=file: output file
     # type=file|default=<undefined>: output image file name
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/edge_3_callables.py b/example-specs/task/nipype/afni/edge_3_callables.py
index 510c8ca7..80b60e13 100644
--- a/example-specs/task/nipype/afni/edge_3_callables.py
+++ b/example-specs/task/nipype/afni/edge_3_callables.py
@@ -1,9 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Edge3.yaml"""
 
-import os
-import attrs
-import os.path as op
+from looseversion import LooseVersion
 import logging
+import os.path as op
+import attrs
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +17,16 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -183,6 +194,43 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/afni/eval.yaml b/example-specs/task/nipype/afni/eval.yaml
index c863a94f..98089057 100644
--- a/example-specs/task/nipype/afni/eval.yaml
+++ b/example-specs/task/nipype/afni/eval.yaml
@@ -50,6 +50,9 @@ inputs:
     out_file: Path
     # type=file: output file
     # type=file|default=<undefined>: output image file name
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/eval_callables.py b/example-specs/task/nipype/afni/eval_callables.py
index 2ab11fb1..db7222d7 100644
--- a/example-specs/task/nipype/afni/eval_callables.py
+++ b/example-specs/task/nipype/afni/eval_callables.py
@@ -1,9 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Eval.yaml"""
 
-import os
-import attrs
-import os.path as op
+from looseversion import LooseVersion
 import logging
+import os.path as op
+import attrs
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +17,16 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -183,6 +194,43 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/afni/fim.yaml b/example-specs/task/nipype/afni/fim.yaml
index 7f517923..a483114b 100644
--- a/example-specs/task/nipype/afni/fim.yaml
+++ b/example-specs/task/nipype/afni/fim.yaml
@@ -46,6 +46,9 @@ inputs:
     out_file: Path
     # type=file: output file
     # type=file|default=<undefined>: output image file name
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/fim_callables.py b/example-specs/task/nipype/afni/fim_callables.py
index 4b4428c8..fc328e13 100644
--- a/example-specs/task/nipype/afni/fim_callables.py
+++ b/example-specs/task/nipype/afni/fim_callables.py
@@ -1,9 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Fim.yaml"""
 
-import os
-import attrs
-import os.path as op
+from looseversion import LooseVersion
 import logging
+import os.path as op
+import attrs
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +17,16 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -183,6 +194,43 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/afni/fourier.yaml b/example-specs/task/nipype/afni/fourier.yaml
index 5b7d8666..d5afa6f1 100644
--- a/example-specs/task/nipype/afni/fourier.yaml
+++ b/example-specs/task/nipype/afni/fourier.yaml
@@ -43,6 +43,9 @@ inputs:
     out_file: Path
     # type=file: output file
     # type=file|default=<undefined>: output image file name
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/fourier_callables.py b/example-specs/task/nipype/afni/fourier_callables.py
index 65f79bfa..5bd1161f 100644
--- a/example-specs/task/nipype/afni/fourier_callables.py
+++ b/example-specs/task/nipype/afni/fourier_callables.py
@@ -1,9 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Fourier.yaml"""
 
-import os
-import attrs
-import os.path as op
+from looseversion import LooseVersion
 import logging
+import os.path as op
+import attrs
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +17,16 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -183,6 +194,43 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/afni/fwh_mx.yaml b/example-specs/task/nipype/afni/fwh_mx.yaml
index 453cbdd4..f429f2df 100644
--- a/example-specs/task/nipype/afni/fwh_mx.yaml
+++ b/example-specs/task/nipype/afni/fwh_mx.yaml
@@ -126,6 +126,9 @@ inputs:
     out_subbricks: Path
     # type=file: output file (subbricks)
     # type=file|default=<undefined>: output file listing the subbricks FWHM
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/fwh_mx_callables.py b/example-specs/task/nipype/afni/fwh_mx_callables.py
index 77ac2f3b..e492af77 100644
--- a/example-specs/task/nipype/afni/fwh_mx_callables.py
+++ b/example-specs/task/nipype/afni/fwh_mx_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of FWHMx.yaml"""
 
-import os
-import attrs
-import os.path as op
-import logging
 import numpy as np
+import logging
+import os.path as op
+import attrs
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -52,6 +52,16 @@ def out_acf_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/afni/gcor.yaml b/example-specs/task/nipype/afni/gcor.yaml
index 41c739aa..ec32ac93 100644
--- a/example-specs/task/nipype/afni/gcor.yaml
+++ b/example-specs/task/nipype/afni/gcor.yaml
@@ -42,6 +42,9 @@ inputs:
     # type=file|default=<undefined>: input dataset to compute the GCOR over
     mask: generic/file
     # type=file|default=<undefined>: mask dataset, for restricting the computation
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/hist.yaml b/example-specs/task/nipype/afni/hist.yaml
index 46a7fcd7..88a41000 100644
--- a/example-specs/task/nipype/afni/hist.yaml
+++ b/example-specs/task/nipype/afni/hist.yaml
@@ -45,6 +45,9 @@ inputs:
     out_show: Path
     # type=file: output visual histogram
     # type=file|default=<undefined>: output image file name
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/hist_callables.py b/example-specs/task/nipype/afni/hist_callables.py
index 4ed98612..04f5d6f5 100644
--- a/example-specs/task/nipype/afni/hist_callables.py
+++ b/example-specs/task/nipype/afni/hist_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of Hist.yaml"""
 
-import os
-import attrs
-import os.path as op
 import logging
+import os.path as op
+import attrs
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -23,6 +23,16 @@ def out_show_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/afni/lfcd.yaml b/example-specs/task/nipype/afni/lfcd.yaml
index 2ac7e333..61155920 100644
--- a/example-specs/task/nipype/afni/lfcd.yaml
+++ b/example-specs/task/nipype/afni/lfcd.yaml
@@ -44,6 +44,9 @@ inputs:
     out_file: Path
     # type=file: output file
     # type=file|default=<undefined>: output image file name
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/lfcd_callables.py b/example-specs/task/nipype/afni/lfcd_callables.py
index aa9268d5..348bf494 100644
--- a/example-specs/task/nipype/afni/lfcd_callables.py
+++ b/example-specs/task/nipype/afni/lfcd_callables.py
@@ -1,9 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of LFCD.yaml"""
 
-import os
-import attrs
-import os.path as op
+from looseversion import LooseVersion
 import logging
+import os.path as op
+import attrs
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +17,16 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -183,6 +194,43 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/afni/local_bistat.yaml b/example-specs/task/nipype/afni/local_bistat.yaml
index c8bb4c78..eba6cc0b 100644
--- a/example-specs/task/nipype/afni/local_bistat.yaml
+++ b/example-specs/task/nipype/afni/local_bistat.yaml
@@ -50,6 +50,9 @@ inputs:
     # type=file|default=<undefined>: Output dataset.
     weight_file: generic/file
     # type=file|default=<undefined>: File name of an image to use as a weight.  Only applies to 'pearson' statistics.
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/local_bistat_callables.py b/example-specs/task/nipype/afni/local_bistat_callables.py
index 11ff92c6..73c07460 100644
--- a/example-specs/task/nipype/afni/local_bistat_callables.py
+++ b/example-specs/task/nipype/afni/local_bistat_callables.py
@@ -1,9 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of LocalBistat.yaml"""
 
-import os
-import attrs
-import os.path as op
+from looseversion import LooseVersion
 import logging
+import os.path as op
+import attrs
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +17,16 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -183,6 +194,43 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/afni/localstat.yaml b/example-specs/task/nipype/afni/localstat.yaml
index 50f65960..60cabd9b 100644
--- a/example-specs/task/nipype/afni/localstat.yaml
+++ b/example-specs/task/nipype/afni/localstat.yaml
@@ -47,6 +47,9 @@ inputs:
     out_file: Path
     # type=file: output file
     # type=file|default=<undefined>: Output dataset.
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/localstat_callables.py b/example-specs/task/nipype/afni/localstat_callables.py
index 88c27a86..e6677971 100644
--- a/example-specs/task/nipype/afni/localstat_callables.py
+++ b/example-specs/task/nipype/afni/localstat_callables.py
@@ -1,9 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Localstat.yaml"""
 
-import os
-import attrs
-import os.path as op
+from looseversion import LooseVersion
 import logging
+import os.path as op
+import attrs
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +17,16 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -183,6 +194,43 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/afni/mask_tool.yaml b/example-specs/task/nipype/afni/mask_tool.yaml
index a637defc..e53b9679 100644
--- a/example-specs/task/nipype/afni/mask_tool.yaml
+++ b/example-specs/task/nipype/afni/mask_tool.yaml
@@ -40,6 +40,9 @@ inputs:
     out_file: Path
     # type=file: mask file
     # type=file|default=<undefined>: output image file name
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/mask_tool_callables.py b/example-specs/task/nipype/afni/mask_tool_callables.py
index 6825ec7a..f4fa78db 100644
--- a/example-specs/task/nipype/afni/mask_tool_callables.py
+++ b/example-specs/task/nipype/afni/mask_tool_callables.py
@@ -1,9 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of MaskTool.yaml"""
 
-import os
-import attrs
-import os.path as op
+from looseversion import LooseVersion
 import logging
+import os.path as op
+import attrs
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +17,16 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -183,6 +194,43 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/afni/maskave.yaml b/example-specs/task/nipype/afni/maskave.yaml
index 9722dbb5..4cdfab64 100644
--- a/example-specs/task/nipype/afni/maskave.yaml
+++ b/example-specs/task/nipype/afni/maskave.yaml
@@ -44,6 +44,9 @@ inputs:
     out_file: Path
     # type=file: output file
     # type=file|default=<undefined>: output image file name
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/maskave_callables.py b/example-specs/task/nipype/afni/maskave_callables.py
index 847d55fc..7a9593f2 100644
--- a/example-specs/task/nipype/afni/maskave_callables.py
+++ b/example-specs/task/nipype/afni/maskave_callables.py
@@ -1,9 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Maskave.yaml"""
 
-import os
-import attrs
-import os.path as op
+from looseversion import LooseVersion
 import logging
+import os.path as op
+import attrs
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +17,16 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -183,6 +194,43 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/afni/means.yaml b/example-specs/task/nipype/afni/means.yaml
index 094308ea..e0d94cbf 100644
--- a/example-specs/task/nipype/afni/means.yaml
+++ b/example-specs/task/nipype/afni/means.yaml
@@ -52,6 +52,9 @@ inputs:
     out_file: Path
     # type=file: output file
     # type=file|default=<undefined>: output image file name
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/means_callables.py b/example-specs/task/nipype/afni/means_callables.py
index 7ffb1b73..5b899adb 100644
--- a/example-specs/task/nipype/afni/means_callables.py
+++ b/example-specs/task/nipype/afni/means_callables.py
@@ -1,9 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Means.yaml"""
 
-import os
-import attrs
-import os.path as op
+from looseversion import LooseVersion
 import logging
+import os.path as op
+import attrs
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +17,16 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -183,6 +194,43 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/afni/merge.yaml b/example-specs/task/nipype/afni/merge.yaml
index 52790c6a..64e45124 100644
--- a/example-specs/task/nipype/afni/merge.yaml
+++ b/example-specs/task/nipype/afni/merge.yaml
@@ -42,6 +42,9 @@ inputs:
     out_file: Path
     # type=file: output file
     # type=file|default=<undefined>: output image file name
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/merge_callables.py b/example-specs/task/nipype/afni/merge_callables.py
index 25ce8640..232b7149 100644
--- a/example-specs/task/nipype/afni/merge_callables.py
+++ b/example-specs/task/nipype/afni/merge_callables.py
@@ -1,9 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Merge.yaml"""
 
-import os
-import attrs
-import os.path as op
+from looseversion import LooseVersion
 import logging
+import os.path as op
+import attrs
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +17,16 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -183,6 +194,43 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/afni/net_corr.yaml b/example-specs/task/nipype/afni/net_corr.yaml
index 6779ad53..afbce2ba 100644
--- a/example-specs/task/nipype/afni/net_corr.yaml
+++ b/example-specs/task/nipype/afni/net_corr.yaml
@@ -51,6 +51,9 @@ inputs:
     # type=file|default=<undefined>: output file name part
     weight_ts: generic/file
     # type=file|default=<undefined>: input a 1D file WTS of weights that will be applied multiplicatively to each ROI's average time series. WTS can be a column- or row-file of values, but it must have the same length as the input time series volume. If the initial average time series was A[n] for n=0,..,(N-1) time points, then applying a set of weights W[n] of the same length from WTS would produce a new time series:  B[n] = A[n] * W[n]
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/net_corr_callables.py b/example-specs/task/nipype/afni/net_corr_callables.py
index 3b96db11..45487ad9 100644
--- a/example-specs/task/nipype/afni/net_corr_callables.py
+++ b/example-specs/task/nipype/afni/net_corr_callables.py
@@ -1,8 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of NetCorr.yaml"""
 
-import os
-import attrs
+from looseversion import LooseVersion
+from pathlib import Path
 import os.path as op
+import attrs
+import os
 
 
 def out_corr_matrix_callable(output_dir, inputs, stdout, stderr):
@@ -19,6 +21,43 @@ def out_corr_maps_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_corr_maps"]
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
diff --git a/example-specs/task/nipype/afni/notes.yaml b/example-specs/task/nipype/afni/notes.yaml
index 18d4de18..12862ecc 100644
--- a/example-specs/task/nipype/afni/notes.yaml
+++ b/example-specs/task/nipype/afni/notes.yaml
@@ -41,6 +41,9 @@ inputs:
     out_file: Path
     # type=file: output file
     # type=file|default=<undefined>: output image file name
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/nwarp_adjust.yaml b/example-specs/task/nipype/afni/nwarp_adjust.yaml
index e87d1cfd..74eb8757 100644
--- a/example-specs/task/nipype/afni/nwarp_adjust.yaml
+++ b/example-specs/task/nipype/afni/nwarp_adjust.yaml
@@ -46,6 +46,9 @@ inputs:
     # type=file|default=<undefined>: Output mean dataset, only needed if in_files are also given. The output dataset will be on the common grid shared by the source datasets.
     warps: medimage/nifti-gz+list-of
     # type=inputmultiobject|default=[]: List of input 3D warp datasets
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/nwarp_adjust_callables.py b/example-specs/task/nipype/afni/nwarp_adjust_callables.py
index c26ca491..d056064c 100644
--- a/example-specs/task/nipype/afni/nwarp_adjust_callables.py
+++ b/example-specs/task/nipype/afni/nwarp_adjust_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of NwarpAdjust.yaml"""
 
-import os
 import os.path as op
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/afni/nwarp_apply.yaml b/example-specs/task/nipype/afni/nwarp_apply.yaml
index c54c65c3..fee70bec 100644
--- a/example-specs/task/nipype/afni/nwarp_apply.yaml
+++ b/example-specs/task/nipype/afni/nwarp_apply.yaml
@@ -43,6 +43,9 @@ inputs:
     out_file: Path
     # type=file: output file
     # type=file|default=<undefined>: output image file name
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/nwarp_apply_callables.py b/example-specs/task/nipype/afni/nwarp_apply_callables.py
index 7f1a7d63..82f27eda 100644
--- a/example-specs/task/nipype/afni/nwarp_apply_callables.py
+++ b/example-specs/task/nipype/afni/nwarp_apply_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of NwarpApply.yaml"""
 
-import os
+import logging
 import os.path as op
 import attrs
-import logging
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +16,16 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/afni/nwarp_cat.yaml b/example-specs/task/nipype/afni/nwarp_cat.yaml
index 0a6924fe..170a1ed6 100644
--- a/example-specs/task/nipype/afni/nwarp_cat.yaml
+++ b/example-specs/task/nipype/afni/nwarp_cat.yaml
@@ -72,6 +72,9 @@ inputs:
     out_file: Path
     # type=file: output file
     # type=file|default=<undefined>: output image file name
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/nwarp_cat_callables.py b/example-specs/task/nipype/afni/nwarp_cat_callables.py
index 42487caa..1211b0f3 100644
--- a/example-specs/task/nipype/afni/nwarp_cat_callables.py
+++ b/example-specs/task/nipype/afni/nwarp_cat_callables.py
@@ -1,8 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of NwarpCat.yaml"""
 
-import os
-import attrs
+from looseversion import LooseVersion
+from pathlib import Path
 import os.path as op
+import attrs
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -12,6 +14,43 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_file"]
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
diff --git a/example-specs/task/nipype/afni/one_d_tool_py.yaml b/example-specs/task/nipype/afni/one_d_tool_py.yaml
index 06e44a7f..0c532f5b 100644
--- a/example-specs/task/nipype/afni/one_d_tool_py.yaml
+++ b/example-specs/task/nipype/afni/one_d_tool_py.yaml
@@ -38,6 +38,9 @@ inputs:
     # type=file|default=<undefined>: write the current 1D data to FILE
     show_cormat_warnings: generic/file
     # type=file|default=<undefined>: Write cormat warnings to a file
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -79,7 +82,7 @@ tests:
     show_censor_count:
     # type=bool|default=False: display the total number of censored TRs  Note : if input is a valid xmat.1D dataset, then the count will come from the header.  Otherwise the input is assumed to be a binary censorfile, and zeros are simply counted.
     censor_motion:
-    # type=tuple|default=(<traits.trait_types.Float object at 0x10aaaf210>, <nipype.interfaces.base.traits_extension.File object at 0x10aaaf2d0>): Tuple of motion limit and outfile prefix. need to also set set_nruns -r set_run_lengths
+    # type=tuple|default=(<traits.trait_types.Float object at 0x1121da450>, <nipype.interfaces.base.traits_extension.File object at 0x1121da510>): Tuple of motion limit and outfile prefix. need to also set set_nruns -r set_run_lengths
     censor_prev_TR:
     # type=bool|default=False: for each censored TR, also censor previous
     show_trs_uncensored:
diff --git a/example-specs/task/nipype/afni/one_d_tool_py_callables.py b/example-specs/task/nipype/afni/one_d_tool_py_callables.py
index 111b687e..5e90daa0 100644
--- a/example-specs/task/nipype/afni/one_d_tool_py_callables.py
+++ b/example-specs/task/nipype/afni/one_d_tool_py_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of OneDToolPy.yaml"""
 
-import os
 import attrs
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/afni/outlier_count.yaml b/example-specs/task/nipype/afni/outlier_count.yaml
index 274067c2..0e74700f 100644
--- a/example-specs/task/nipype/afni/outlier_count.yaml
+++ b/example-specs/task/nipype/afni/outlier_count.yaml
@@ -44,6 +44,9 @@ inputs:
     # type=file|default=<undefined>: capture standard output
     outliers_file: generic/file
     # type=file|default=<undefined>: output image file name
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/quality_index.yaml b/example-specs/task/nipype/afni/quality_index.yaml
index 9680a1b7..5380f415 100644
--- a/example-specs/task/nipype/afni/quality_index.yaml
+++ b/example-specs/task/nipype/afni/quality_index.yaml
@@ -45,6 +45,9 @@ inputs:
     out_file: Path
     # type=file: file containing the captured standard output
     # type=file|default=<undefined>: capture standard output
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/quality_index_callables.py b/example-specs/task/nipype/afni/quality_index_callables.py
index 2a263807..96b6ac80 100644
--- a/example-specs/task/nipype/afni/quality_index_callables.py
+++ b/example-specs/task/nipype/afni/quality_index_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of QualityIndex.yaml"""
 
-import os
+import logging
 import os.path as op
 import attrs
-import logging
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +16,16 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/afni/qwarp.yaml b/example-specs/task/nipype/afni/qwarp.yaml
index 6a2e179d..dacb919c 100644
--- a/example-specs/task/nipype/afni/qwarp.yaml
+++ b/example-specs/task/nipype/afni/qwarp.yaml
@@ -125,6 +125,9 @@ inputs:
     # type=file|default=<undefined>: Write the weight volume to disk as a dataset
     weight: generic/file
     # type=file|default=<undefined>: Instead of computing the weight from the base dataset,directly input the weight volume from dataset 'www'.Useful if you know what over parts of the base image youwant to emphasize or de-emphasize the matching functional.
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -190,7 +193,7 @@ tests:
     wball:
     # type=list|default=[]: "``-wball x y z r f`` Enhance automatic weight from '-useweight' by a factor of 1+f\*Gaussian(FWHM=r) centered in the base image at DICOM coordinates (x,y,z) and with radius 'r'. The goal of this option is to try and make the alignment better in a specific part of the brain. Example:  -wball 0 14 6 30 40 to emphasize the thalamic area (in MNI/Talairach space).  * The 'r' parameter must be positive! * The 'f' parameter must be between 1 and 100 (inclusive). * '-wball' does nothing if you input your own weight   with the '-weight' option. * '-wball' does change the binary weight created by   the '-noweight' option. * You can only use '-wball' once in a run of 3dQwarp.  **The effect of '-wball' is not dramatic.** The example above makes the average brain image across a collection of subjects a little sharper in the thalamic area, which might have some small value.  If you care enough about alignment to use '-wball', then you should examine the results from 3dQwarp for each subject, to see if the alignments are good enough for your purposes.
     wmask:
-    # type=tuple|default=(<nipype.interfaces.base.traits_extension.File object at 0x10a9b4410>, <traits.trait_types.Float object at 0x10a9b4490>): Similar to '-wball', but here, you provide a dataset 'ws' that indicates where to increase the weight.  * The 'ws' dataset must be on the same 3D grid as the base dataset. * 'ws' is treated as a mask -- it only matters where it   is nonzero -- otherwise, the values inside are not used. * After 'ws' comes the factor 'f' by which to increase the   automatically computed weight.  Where 'ws' is nonzero,   the weighting will be multiplied by (1+f). * As with '-wball', the factor 'f' should be between 1 and 100.  
+    # type=tuple|default=(<nipype.interfaces.base.traits_extension.File object at 0x1120d3c90>, <traits.trait_types.Float object at 0x1120d3910>): Similar to '-wball', but here, you provide a dataset 'ws' that indicates where to increase the weight.  * The 'ws' dataset must be on the same 3D grid as the base dataset. * 'ws' is treated as a mask -- it only matters where it   is nonzero -- otherwise, the values inside are not used. * After 'ws' comes the factor 'f' by which to increase the   automatically computed weight.  Where 'ws' is nonzero,   the weighting will be multiplied by (1+f). * As with '-wball', the factor 'f' should be between 1 and 100.  
     out_weight_file:
     # type=file|default=<undefined>: Write the weight volume to disk as a dataset
     blur:
diff --git a/example-specs/task/nipype/afni/qwarp_callables.py b/example-specs/task/nipype/afni/qwarp_callables.py
index f4493348..32817510 100644
--- a/example-specs/task/nipype/afni/qwarp_callables.py
+++ b/example-specs/task/nipype/afni/qwarp_callables.py
@@ -1,8 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Qwarp.yaml"""
 
-import os
-import attrs
+from pathlib import Path
+from looseversion import LooseVersion
 import os.path as op
+import attrs
+import os
 
 
 def warped_source_callable(output_dir, inputs, stdout, stderr):
@@ -40,6 +42,43 @@ def weights_callable(output_dir, inputs, stdout, stderr):
     return outputs["weights"]
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -269,6 +308,89 @@ def _gen_fname(
     return fname
 
 
+class Info(PackageInfo):
+    """Handle afni output type and version information."""
+
+    __outputtype = "AFNI"
+    ftypes = {"NIFTI": ".nii", "AFNI": "", "NIFTI_GZ": ".nii.gz"}
+    version_cmd = "afni --version"
+
+    @staticmethod
+    def parse_version(raw_info):
+        """Check and parse AFNI's version."""
+        version_stamp = raw_info.split("\n")[0].split("Version ")[1]
+        if version_stamp.startswith("AFNI"):
+            version_stamp = version_stamp.split("AFNI_")[1]
+        elif version_stamp.startswith("Debian"):
+            version_stamp = version_stamp.split("Debian-")[1].split("~")[0]
+        else:
+            return None
+
+        version = LooseVersion(version_stamp.replace("_", ".")).version[:3]
+        if version[0] < 1000:
+            version[0] = version[0] + 2000
+        return tuple(version)
+
+    @classmethod
+    def output_type_to_ext(cls, outputtype):
+        """
+        Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        outputtype : {'NIFTI', 'NIFTI_GZ', 'AFNI'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+
+        """
+        try:
+            return cls.ftypes[outputtype]
+        except KeyError as e:
+            msg = "Invalid AFNIOUTPUTTYPE: ", outputtype
+            raise KeyError(msg) from e
+
+    @classmethod
+    def outputtype(cls):
+        """
+        Set default output filetype.
+
+        AFNI has no environment variables, Output filetypes get set in command line calls
+        Nipype uses ``AFNI`` as default
+
+
+        Returns
+        -------
+        None
+
+        """
+        return "AFNI"
+
+    @staticmethod
+    def standard_image(img_name):
+        """
+        Grab an image from the standard location.
+
+        Could be made more fancy to allow for more relocatability
+
+        """
+        clout = CommandLine(
+            "which afni",
+            ignore_exception=True,
+            resource_monitor=False,
+            terminal_output="allatonce",
+        ).run()
+        if clout.runtime.returncode != 0:
+            return None
+
+        out = clout.runtime.stdout
+        basedir = os.path.split(out)[0]
+        return os.path.join(basedir, img_name)
+
+
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
diff --git a/example-specs/task/nipype/afni/qwarp_plus_minus.yaml b/example-specs/task/nipype/afni/qwarp_plus_minus.yaml
index a6fe983a..3f4e8642 100644
--- a/example-specs/task/nipype/afni/qwarp_plus_minus.yaml
+++ b/example-specs/task/nipype/afni/qwarp_plus_minus.yaml
@@ -57,6 +57,9 @@ inputs:
     # type=file|default=<undefined>: Source image (opposite phase encoding direction than base image)
     weight: generic/file
     # type=file|default=<undefined>: Instead of computing the weight from the base dataset,directly input the weight volume from dataset 'www'.Useful if you know what over parts of the base image youwant to emphasize or de-emphasize the matching functional.
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -126,7 +129,7 @@ tests:
     wball:
     # type=list|default=[]: "``-wball x y z r f`` Enhance automatic weight from '-useweight' by a factor of 1+f\*Gaussian(FWHM=r) centered in the base image at DICOM coordinates (x,y,z) and with radius 'r'. The goal of this option is to try and make the alignment better in a specific part of the brain. Example:  -wball 0 14 6 30 40 to emphasize the thalamic area (in MNI/Talairach space).  * The 'r' parameter must be positive! * The 'f' parameter must be between 1 and 100 (inclusive). * '-wball' does nothing if you input your own weight   with the '-weight' option. * '-wball' does change the binary weight created by   the '-noweight' option. * You can only use '-wball' once in a run of 3dQwarp.  **The effect of '-wball' is not dramatic.** The example above makes the average brain image across a collection of subjects a little sharper in the thalamic area, which might have some small value.  If you care enough about alignment to use '-wball', then you should examine the results from 3dQwarp for each subject, to see if the alignments are good enough for your purposes.
     wmask:
-    # type=tuple|default=(<nipype.interfaces.base.traits_extension.File object at 0x10a9b4410>, <traits.trait_types.Float object at 0x10a9b4490>): Similar to '-wball', but here, you provide a dataset 'ws' that indicates where to increase the weight.  * The 'ws' dataset must be on the same 3D grid as the base dataset. * 'ws' is treated as a mask -- it only matters where it   is nonzero -- otherwise, the values inside are not used. * After 'ws' comes the factor 'f' by which to increase the   automatically computed weight.  Where 'ws' is nonzero,   the weighting will be multiplied by (1+f). * As with '-wball', the factor 'f' should be between 1 and 100.  
+    # type=tuple|default=(<nipype.interfaces.base.traits_extension.File object at 0x1120d3c90>, <traits.trait_types.Float object at 0x1120d3910>): Similar to '-wball', but here, you provide a dataset 'ws' that indicates where to increase the weight.  * The 'ws' dataset must be on the same 3D grid as the base dataset. * 'ws' is treated as a mask -- it only matters where it   is nonzero -- otherwise, the values inside are not used. * After 'ws' comes the factor 'f' by which to increase the   automatically computed weight.  Where 'ws' is nonzero,   the weighting will be multiplied by (1+f). * As with '-wball', the factor 'f' should be between 1 and 100.  
     out_weight_file:
     # type=file|default=<undefined>: Write the weight volume to disk as a dataset
     blur:
diff --git a/example-specs/task/nipype/afni/qwarp_plus_minus_callables.py b/example-specs/task/nipype/afni/qwarp_plus_minus_callables.py
index 30d2ae9c..e85b078f 100644
--- a/example-specs/task/nipype/afni/qwarp_plus_minus_callables.py
+++ b/example-specs/task/nipype/afni/qwarp_plus_minus_callables.py
@@ -1,8 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of QwarpPlusMinus.yaml"""
 
-import os
-import attrs
+from pathlib import Path
+from looseversion import LooseVersion
 import os.path as op
+import attrs
+import os
 
 
 def warped_source_callable(output_dir, inputs, stdout, stderr):
@@ -40,6 +42,43 @@ def weights_callable(output_dir, inputs, stdout, stderr):
     return outputs["weights"]
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -269,6 +308,89 @@ def _gen_fname(
     return fname
 
 
+class Info(PackageInfo):
+    """Handle afni output type and version information."""
+
+    __outputtype = "AFNI"
+    ftypes = {"NIFTI": ".nii", "AFNI": "", "NIFTI_GZ": ".nii.gz"}
+    version_cmd = "afni --version"
+
+    @staticmethod
+    def parse_version(raw_info):
+        """Check and parse AFNI's version."""
+        version_stamp = raw_info.split("\n")[0].split("Version ")[1]
+        if version_stamp.startswith("AFNI"):
+            version_stamp = version_stamp.split("AFNI_")[1]
+        elif version_stamp.startswith("Debian"):
+            version_stamp = version_stamp.split("Debian-")[1].split("~")[0]
+        else:
+            return None
+
+        version = LooseVersion(version_stamp.replace("_", ".")).version[:3]
+        if version[0] < 1000:
+            version[0] = version[0] + 2000
+        return tuple(version)
+
+    @classmethod
+    def output_type_to_ext(cls, outputtype):
+        """
+        Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        outputtype : {'NIFTI', 'NIFTI_GZ', 'AFNI'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+
+        """
+        try:
+            return cls.ftypes[outputtype]
+        except KeyError as e:
+            msg = "Invalid AFNIOUTPUTTYPE: ", outputtype
+            raise KeyError(msg) from e
+
+    @classmethod
+    def outputtype(cls):
+        """
+        Set default output filetype.
+
+        AFNI has no environment variables, Output filetypes get set in command line calls
+        Nipype uses ``AFNI`` as default
+
+
+        Returns
+        -------
+        None
+
+        """
+        return "AFNI"
+
+    @staticmethod
+    def standard_image(img_name):
+        """
+        Grab an image from the standard location.
+
+        Could be made more fancy to allow for more relocatability
+
+        """
+        clout = CommandLine(
+            "which afni",
+            ignore_exception=True,
+            resource_monitor=False,
+            terminal_output="allatonce",
+        ).run()
+        if clout.runtime.returncode != 0:
+            return None
+
+        out = clout.runtime.stdout
+        basedir = os.path.split(out)[0]
+        return os.path.join(basedir, img_name)
+
+
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
diff --git a/example-specs/task/nipype/afni/re_ho.yaml b/example-specs/task/nipype/afni/re_ho.yaml
index 4987f290..e12c8d8c 100644
--- a/example-specs/task/nipype/afni/re_ho.yaml
+++ b/example-specs/task/nipype/afni/re_ho.yaml
@@ -46,6 +46,9 @@ inputs:
     out_file: Path
     # type=file: Voxelwise regional homogeneity map
     # type=file|default=<undefined>: Output dataset.
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/re_ho_callables.py b/example-specs/task/nipype/afni/re_ho_callables.py
index a8563f41..79ba9979 100644
--- a/example-specs/task/nipype/afni/re_ho_callables.py
+++ b/example-specs/task/nipype/afni/re_ho_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of ReHo.yaml"""
 
-import os
+import logging
 import os.path as op
 import attrs
-import logging
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -23,6 +23,16 @@ def out_vals_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/afni/refit.yaml b/example-specs/task/nipype/afni/refit.yaml
index 05b14b34..94ccb95a 100644
--- a/example-specs/task/nipype/afni/refit.yaml
+++ b/example-specs/task/nipype/afni/refit.yaml
@@ -46,6 +46,9 @@ inputs:
     # type=file|default=<undefined>: Copies the xorigin, yorigin, and zorigin values from the header of the given dataset
     in_file: medimage/nifti1
     # type=file|default=<undefined>: input file to 3drefit
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/remlfit.yaml b/example-specs/task/nipype/afni/remlfit.yaml
index 7ee246f7..4f00a7b3 100644
--- a/example-specs/task/nipype/afni/remlfit.yaml
+++ b/example-specs/task/nipype/afni/remlfit.yaml
@@ -96,6 +96,9 @@ inputs:
     wherr_file: Path
     # type=file: dataset for REML residual, whitened using the estimated ARMA(1,1) correlation matrix of the noise (if generated)
     # type=file|default=<undefined>: dataset for REML residual, whitened using the estimated ARMA(1,1) correlation matrix of the noise
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/remlfit_callables.py b/example-specs/task/nipype/afni/remlfit_callables.py
index 5f1c7fd1..e7a1571b 100644
--- a/example-specs/task/nipype/afni/remlfit_callables.py
+++ b/example-specs/task/nipype/afni/remlfit_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of Remlfit.yaml"""
 
-import os
 import attrs
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/afni/resample.yaml b/example-specs/task/nipype/afni/resample.yaml
index ca2abef3..8cbb778e 100644
--- a/example-specs/task/nipype/afni/resample.yaml
+++ b/example-specs/task/nipype/afni/resample.yaml
@@ -43,6 +43,9 @@ inputs:
     out_file: Path
     # type=file: output file
     # type=file|default=<undefined>: output image file name
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/resample_callables.py b/example-specs/task/nipype/afni/resample_callables.py
index 4b7e79c4..368b442d 100644
--- a/example-specs/task/nipype/afni/resample_callables.py
+++ b/example-specs/task/nipype/afni/resample_callables.py
@@ -1,9 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Resample.yaml"""
 
-import os
-import attrs
-import os.path as op
+from looseversion import LooseVersion
 import logging
+import os.path as op
+import attrs
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +17,16 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -183,6 +194,43 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/afni/retroicor.yaml b/example-specs/task/nipype/afni/retroicor.yaml
index 8a054165..de9f2f1a 100644
--- a/example-specs/task/nipype/afni/retroicor.yaml
+++ b/example-specs/task/nipype/afni/retroicor.yaml
@@ -65,6 +65,9 @@ inputs:
     # type=file|default=<undefined>: 1D respiratory waveform data for correction
     respphase: generic/file
     # type=file|default=<undefined>: Filename for 1D resp phase output
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/retroicor_callables.py b/example-specs/task/nipype/afni/retroicor_callables.py
index 6e629342..9fd4993a 100644
--- a/example-specs/task/nipype/afni/retroicor_callables.py
+++ b/example-specs/task/nipype/afni/retroicor_callables.py
@@ -1,9 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Retroicor.yaml"""
 
-import os
-import attrs
-import os.path as op
+from looseversion import LooseVersion
 import logging
+import os.path as op
+import attrs
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +17,16 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -183,6 +194,43 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/afni/roi_stats.yaml b/example-specs/task/nipype/afni/roi_stats.yaml
index 6f02ac8a..3360e295 100644
--- a/example-specs/task/nipype/afni/roi_stats.yaml
+++ b/example-specs/task/nipype/afni/roi_stats.yaml
@@ -48,6 +48,9 @@ inputs:
     # type=file|default=<undefined>: output file
     roisel: generic/file
     # type=file|default=<undefined>: Only considers ROIs denoted by values found in the specified file. Note that the order of the ROIs as specified in the file is not preserved. So an SEL.1D of '2 8 20' produces the same output as '8 20 2'
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/roi_stats_callables.py b/example-specs/task/nipype/afni/roi_stats_callables.py
index b61e2468..f772564f 100644
--- a/example-specs/task/nipype/afni/roi_stats_callables.py
+++ b/example-specs/task/nipype/afni/roi_stats_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of ROIStats.yaml"""
 
-import os
+import logging
 import os.path as op
 import attrs
-import logging
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +16,16 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/afni/seg.yaml b/example-specs/task/nipype/afni/seg.yaml
index 29aee342..8704d95a 100644
--- a/example-specs/task/nipype/afni/seg.yaml
+++ b/example-specs/task/nipype/afni/seg.yaml
@@ -39,6 +39,9 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/nifti1
     # type=file|default=<undefined>: ANAT is the volume to segment
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/seg_callables.py b/example-specs/task/nipype/afni/seg_callables.py
index 7b84ec6e..fe47595b 100644
--- a/example-specs/task/nipype/afni/seg_callables.py
+++ b/example-specs/task/nipype/afni/seg_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of Seg.yaml"""
 
-import os
+import logging
 import os.path as op
 import attrs
-import logging
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +16,16 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/afni/skull_strip.yaml b/example-specs/task/nipype/afni/skull_strip.yaml
index 18848cba..6b1993e8 100644
--- a/example-specs/task/nipype/afni/skull_strip.yaml
+++ b/example-specs/task/nipype/afni/skull_strip.yaml
@@ -42,6 +42,9 @@ inputs:
     out_file: Path
     # type=file: output file
     # type=file|default=<undefined>: output image file name
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/skull_strip_callables.py b/example-specs/task/nipype/afni/skull_strip_callables.py
index cd46720b..f05ba630 100644
--- a/example-specs/task/nipype/afni/skull_strip_callables.py
+++ b/example-specs/task/nipype/afni/skull_strip_callables.py
@@ -1,9 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of SkullStrip.yaml"""
 
-import os
-import attrs
-import os.path as op
+from looseversion import LooseVersion
 import logging
+import os.path as op
+import attrs
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +17,16 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -183,6 +194,43 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/afni/svm_test.yaml b/example-specs/task/nipype/afni/svm_test.yaml
index 9e6c11b4..e2c7be1a 100644
--- a/example-specs/task/nipype/afni/svm_test.yaml
+++ b/example-specs/task/nipype/afni/svm_test.yaml
@@ -43,6 +43,9 @@ inputs:
     # type=file|default=<undefined>: filename for .1D prediction file(s).
     testlabels: generic/file
     # type=file|default=<undefined>: *true* class category .1D labels for the test dataset. It is used to calculate the prediction accuracy performance
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/svm_test_callables.py b/example-specs/task/nipype/afni/svm_test_callables.py
index 5002741c..f04d969c 100644
--- a/example-specs/task/nipype/afni/svm_test_callables.py
+++ b/example-specs/task/nipype/afni/svm_test_callables.py
@@ -1,9 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of SVMTest.yaml"""
 
-import os
-import attrs
-import os.path as op
+from looseversion import LooseVersion
 import logging
+import os.path as op
+import attrs
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +17,16 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -183,6 +194,43 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/afni/svm_train.yaml b/example-specs/task/nipype/afni/svm_train.yaml
index 791f713c..e33492e0 100644
--- a/example-specs/task/nipype/afni/svm_train.yaml
+++ b/example-specs/task/nipype/afni/svm_train.yaml
@@ -55,6 +55,9 @@ inputs:
     # type=file|default=<undefined>: output sum of weighted linear support vectors file name
     trainlabels: generic/file
     # type=file|default=<undefined>: .1D labels corresponding to the stimulus paradigm for the training data.
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/svm_train_callables.py b/example-specs/task/nipype/afni/svm_train_callables.py
index c985b921..05fdd888 100644
--- a/example-specs/task/nipype/afni/svm_train_callables.py
+++ b/example-specs/task/nipype/afni/svm_train_callables.py
@@ -1,9 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of SVMTrain.yaml"""
 
-import os
-import attrs
-import os.path as op
+from looseversion import LooseVersion
 import logging
+import os.path as op
+import attrs
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -30,6 +31,16 @@ def alphas_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -197,6 +208,43 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/afni/synthesize.yaml b/example-specs/task/nipype/afni/synthesize.yaml
index 9216639b..874088d4 100644
--- a/example-specs/task/nipype/afni/synthesize.yaml
+++ b/example-specs/task/nipype/afni/synthesize.yaml
@@ -45,6 +45,9 @@ inputs:
     out_file: Path
     # type=file: output file
     # type=file|default=<undefined>: output dataset prefix name (default 'syn')
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/synthesize_callables.py b/example-specs/task/nipype/afni/synthesize_callables.py
index e42e6aef..7b3637bb 100644
--- a/example-specs/task/nipype/afni/synthesize_callables.py
+++ b/example-specs/task/nipype/afni/synthesize_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of Synthesize.yaml"""
 
-import os
 import attrs
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/afni/t_cat.yaml b/example-specs/task/nipype/afni/t_cat.yaml
index 64487cd3..c15b03d9 100644
--- a/example-specs/task/nipype/afni/t_cat.yaml
+++ b/example-specs/task/nipype/afni/t_cat.yaml
@@ -44,6 +44,9 @@ inputs:
     out_file: Path
     # type=file: output file
     # type=file|default=<undefined>: output image file name
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/t_cat_callables.py b/example-specs/task/nipype/afni/t_cat_callables.py
index 7c4941ce..78daeace 100644
--- a/example-specs/task/nipype/afni/t_cat_callables.py
+++ b/example-specs/task/nipype/afni/t_cat_callables.py
@@ -1,9 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of TCat.yaml"""
 
-import os
-import attrs
-import os.path as op
+from looseversion import LooseVersion
 import logging
+import os.path as op
+import attrs
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +17,16 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -183,6 +194,43 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/afni/t_cat_sub_brick.yaml b/example-specs/task/nipype/afni/t_cat_sub_brick.yaml
index 4ab0216b..68739d1b 100644
--- a/example-specs/task/nipype/afni/t_cat_sub_brick.yaml
+++ b/example-specs/task/nipype/afni/t_cat_sub_brick.yaml
@@ -40,6 +40,9 @@ inputs:
     out_file: Path
     # type=file: output file
     # type=file|default=<undefined>: output image file name
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/t_cat_sub_brick_callables.py b/example-specs/task/nipype/afni/t_cat_sub_brick_callables.py
index 040c54bf..f2539d5c 100644
--- a/example-specs/task/nipype/afni/t_cat_sub_brick_callables.py
+++ b/example-specs/task/nipype/afni/t_cat_sub_brick_callables.py
@@ -1,9 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of TCatSubBrick.yaml"""
 
-import os
-import attrs
-import os.path as op
 import logging
+from pathlib import Path
+from looseversion import LooseVersion
+import os.path as op
+import attrs
+import os
 
 
 def out_file_default(inputs):
@@ -20,6 +22,16 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -195,6 +207,43 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
         )
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
diff --git a/example-specs/task/nipype/afni/t_corr_1d.yaml b/example-specs/task/nipype/afni/t_corr_1d.yaml
index 75192bbc..d173bc3d 100644
--- a/example-specs/task/nipype/afni/t_corr_1d.yaml
+++ b/example-specs/task/nipype/afni/t_corr_1d.yaml
@@ -41,6 +41,9 @@ inputs:
     # type=file|default=<undefined>: 3d+time dataset input
     y_1d: medimage-afni/oned
     # type=file|default=<undefined>: 1D time series file input
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/t_corr_1d_callables.py b/example-specs/task/nipype/afni/t_corr_1d_callables.py
index 74b88ff3..d1bf846c 100644
--- a/example-specs/task/nipype/afni/t_corr_1d_callables.py
+++ b/example-specs/task/nipype/afni/t_corr_1d_callables.py
@@ -1,9 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of TCorr1D.yaml"""
 
-import os
-import attrs
-import os.path as op
+from looseversion import LooseVersion
 import logging
+import os.path as op
+import attrs
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +17,16 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -183,6 +194,43 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/afni/t_corr_map.yaml b/example-specs/task/nipype/afni/t_corr_map.yaml
index 4436e621..7baee5c9 100644
--- a/example-specs/task/nipype/afni/t_corr_map.yaml
+++ b/example-specs/task/nipype/afni/t_corr_map.yaml
@@ -87,6 +87,9 @@ inputs:
     zmean: Path
     # type=file: 
     # type=file|default=<undefined>: 
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -161,7 +164,7 @@ tests:
     polort:
     # type=int|default=0: 
     bandpass:
-    # type=tuple|default=(<traits.trait_types.Float object at 0x10a991a90>, <traits.trait_types.Float object at 0x10a991dd0>): 
+    # type=tuple|default=(<traits.trait_types.Float object at 0x1120bd1d0>, <traits.trait_types.Float object at 0x1120bd150>): 
     regress_out_timeseries:
     # type=file|default=<undefined>: 
     blur_fwhm:
diff --git a/example-specs/task/nipype/afni/t_corr_map_callables.py b/example-specs/task/nipype/afni/t_corr_map_callables.py
index 2807ade5..1e597299 100644
--- a/example-specs/task/nipype/afni/t_corr_map_callables.py
+++ b/example-specs/task/nipype/afni/t_corr_map_callables.py
@@ -1,9 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of TCorrMap.yaml"""
 
-import os
-import attrs
-import os.path as op
+from looseversion import LooseVersion
 import logging
+import os.path as op
+import attrs
+import os
 
 
 def mean_file_callable(output_dir, inputs, stdout, stderr):
@@ -100,6 +101,16 @@ def histogram_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -267,6 +278,43 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/afni/t_correlate.yaml b/example-specs/task/nipype/afni/t_correlate.yaml
index 5e658494..f1be2e6c 100644
--- a/example-specs/task/nipype/afni/t_correlate.yaml
+++ b/example-specs/task/nipype/afni/t_correlate.yaml
@@ -46,6 +46,9 @@ inputs:
     # type=file|default=<undefined>: input xset
     yset: medimage/nifti1
     # type=file|default=<undefined>: input yset
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/t_correlate_callables.py b/example-specs/task/nipype/afni/t_correlate_callables.py
index 28605f19..1094da73 100644
--- a/example-specs/task/nipype/afni/t_correlate_callables.py
+++ b/example-specs/task/nipype/afni/t_correlate_callables.py
@@ -1,9 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of TCorrelate.yaml"""
 
-import os
-import attrs
-import os.path as op
+from looseversion import LooseVersion
 import logging
+import os.path as op
+import attrs
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +17,16 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -183,6 +194,43 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/afni/t_norm.yaml b/example-specs/task/nipype/afni/t_norm.yaml
index dd7f1c58..6c7d143a 100644
--- a/example-specs/task/nipype/afni/t_norm.yaml
+++ b/example-specs/task/nipype/afni/t_norm.yaml
@@ -42,6 +42,9 @@ inputs:
     out_file: Path
     # type=file: output file
     # type=file|default=<undefined>: output image file name
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/t_norm_callables.py b/example-specs/task/nipype/afni/t_norm_callables.py
index 37c15427..56a26af1 100644
--- a/example-specs/task/nipype/afni/t_norm_callables.py
+++ b/example-specs/task/nipype/afni/t_norm_callables.py
@@ -1,9 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of TNorm.yaml"""
 
-import os
-import attrs
-import os.path as op
+from looseversion import LooseVersion
 import logging
+import os.path as op
+import attrs
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +17,16 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -183,6 +194,43 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/afni/t_project.yaml b/example-specs/task/nipype/afni/t_project.yaml
index 4b42ccef..31d2bb7c 100644
--- a/example-specs/task/nipype/afni/t_project.yaml
+++ b/example-specs/task/nipype/afni/t_project.yaml
@@ -63,6 +63,9 @@ inputs:
     out_file: Path
     # type=file: output file
     # type=file|default=<undefined>: output image file name
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/t_project_callables.py b/example-specs/task/nipype/afni/t_project_callables.py
index 73763425..f3284a0f 100644
--- a/example-specs/task/nipype/afni/t_project_callables.py
+++ b/example-specs/task/nipype/afni/t_project_callables.py
@@ -1,9 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of TProject.yaml"""
 
-import os
-import attrs
-import os.path as op
+from looseversion import LooseVersion
 import logging
+import os.path as op
+import attrs
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +17,16 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -183,6 +194,43 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/afni/t_shift.yaml b/example-specs/task/nipype/afni/t_shift.yaml
index 3c25526a..4201d06d 100644
--- a/example-specs/task/nipype/afni/t_shift.yaml
+++ b/example-specs/task/nipype/afni/t_shift.yaml
@@ -112,6 +112,9 @@ inputs:
     out_file: Path
     # type=file: output file
     # type=file|default=<undefined>: output image file name
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/t_shift_callables.py b/example-specs/task/nipype/afni/t_shift_callables.py
index efcc9381..9129a55f 100644
--- a/example-specs/task/nipype/afni/t_shift_callables.py
+++ b/example-specs/task/nipype/afni/t_shift_callables.py
@@ -1,9 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of TShift.yaml"""
 
-import os
-import attrs
-import os.path as op
+from looseversion import LooseVersion
 import logging
+import os.path as op
+import attrs
+import os
 
 
 def timing_file_callable(output_dir, inputs, stdout, stderr):
@@ -23,6 +24,43 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -178,6 +216,16 @@ def nipype_interfaces_afni__AFNICommand___list_outputs(
     return outputs
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/afni/t_smooth.yaml b/example-specs/task/nipype/afni/t_smooth.yaml
index 90e586ed..4a29400e 100644
--- a/example-specs/task/nipype/afni/t_smooth.yaml
+++ b/example-specs/task/nipype/afni/t_smooth.yaml
@@ -44,6 +44,9 @@ inputs:
     out_file: Path
     # type=file: output file
     # type=file|default=<undefined>: output file from 3dTSmooth
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/t_smooth_callables.py b/example-specs/task/nipype/afni/t_smooth_callables.py
index cd0fdfce..979ae331 100644
--- a/example-specs/task/nipype/afni/t_smooth_callables.py
+++ b/example-specs/task/nipype/afni/t_smooth_callables.py
@@ -1,9 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of TSmooth.yaml"""
 
-import os
-import attrs
-import os.path as op
+from looseversion import LooseVersion
 import logging
+import os.path as op
+import attrs
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +17,16 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -183,6 +194,43 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/afni/t_stat.yaml b/example-specs/task/nipype/afni/t_stat.yaml
index 2ab04a44..67dc3bfa 100644
--- a/example-specs/task/nipype/afni/t_stat.yaml
+++ b/example-specs/task/nipype/afni/t_stat.yaml
@@ -43,6 +43,9 @@ inputs:
     out_file: Path
     # type=file: output file
     # type=file|default=<undefined>: output image file name
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/t_stat_callables.py b/example-specs/task/nipype/afni/t_stat_callables.py
index f07c9596..1b3a6660 100644
--- a/example-specs/task/nipype/afni/t_stat_callables.py
+++ b/example-specs/task/nipype/afni/t_stat_callables.py
@@ -1,9 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of TStat.yaml"""
 
-import os
-import attrs
-import os.path as op
+from looseversion import LooseVersion
 import logging
+import os.path as op
+import attrs
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +17,16 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -183,6 +194,43 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/afni/to_3d.yaml b/example-specs/task/nipype/afni/to_3d.yaml
index cefd2110..2676d1dc 100644
--- a/example-specs/task/nipype/afni/to_3d.yaml
+++ b/example-specs/task/nipype/afni/to_3d.yaml
@@ -42,6 +42,9 @@ inputs:
     out_file: Path
     # type=file: output file
     # type=file|default=<undefined>: output image file name
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/to_3d_callables.py b/example-specs/task/nipype/afni/to_3d_callables.py
index f9475285..2dd192fa 100644
--- a/example-specs/task/nipype/afni/to_3d_callables.py
+++ b/example-specs/task/nipype/afni/to_3d_callables.py
@@ -1,9 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of To3D.yaml"""
 
-import os
-import attrs
-import os.path as op
+from looseversion import LooseVersion
 import logging
+import os.path as op
+import attrs
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +17,16 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -183,6 +194,43 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/afni/undump.yaml b/example-specs/task/nipype/afni/undump.yaml
index 8e43c6c5..1e676425 100644
--- a/example-specs/task/nipype/afni/undump.yaml
+++ b/example-specs/task/nipype/afni/undump.yaml
@@ -60,6 +60,9 @@ inputs:
     out_file: Path
     # type=file: assembled file
     # type=file|default=<undefined>: output image file name
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/undump_callables.py b/example-specs/task/nipype/afni/undump_callables.py
index 3fd38408..0b5b8ee3 100644
--- a/example-specs/task/nipype/afni/undump_callables.py
+++ b/example-specs/task/nipype/afni/undump_callables.py
@@ -1,9 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Undump.yaml"""
 
-import os
-import attrs
-import os.path as op
+from looseversion import LooseVersion
 import logging
+import os.path as op
+import attrs
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +17,16 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -183,6 +194,43 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/afni/unifize.yaml b/example-specs/task/nipype/afni/unifize.yaml
index cbb34b07..898ba78e 100644
--- a/example-specs/task/nipype/afni/unifize.yaml
+++ b/example-specs/task/nipype/afni/unifize.yaml
@@ -68,6 +68,9 @@ inputs:
     scale_file: Path
     # type=file: scale factor file
     # type=file|default=<undefined>: output file name to save the scale factor used at each voxel 
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/unifize_callables.py b/example-specs/task/nipype/afni/unifize_callables.py
index 3dad41ce..470554ce 100644
--- a/example-specs/task/nipype/afni/unifize_callables.py
+++ b/example-specs/task/nipype/afni/unifize_callables.py
@@ -1,9 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Unifize.yaml"""
 
-import os
-import attrs
-import os.path as op
+from looseversion import LooseVersion
 import logging
+import os.path as op
+import attrs
+import os
 
 
 def scale_file_callable(output_dir, inputs, stdout, stderr):
@@ -23,6 +24,16 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -190,6 +201,43 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/afni/volreg.yaml b/example-specs/task/nipype/afni/volreg.yaml
index 23d34552..8cab1e9f 100644
--- a/example-specs/task/nipype/afni/volreg.yaml
+++ b/example-specs/task/nipype/afni/volreg.yaml
@@ -67,6 +67,9 @@ inputs:
     out_file: Path
     # type=file: registered file
     # type=file|default=<undefined>: output image file name
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/volreg_callables.py b/example-specs/task/nipype/afni/volreg_callables.py
index 4e5b9644..9285c217 100644
--- a/example-specs/task/nipype/afni/volreg_callables.py
+++ b/example-specs/task/nipype/afni/volreg_callables.py
@@ -1,9 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Volreg.yaml"""
 
-import os
-import attrs
-import os.path as op
+from looseversion import LooseVersion
 import logging
+import os.path as op
+import attrs
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -37,6 +38,16 @@ def oned_matrix_save_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -204,6 +215,43 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/afni/warp.yaml b/example-specs/task/nipype/afni/warp.yaml
index 8a799785..6dd7d8e0 100644
--- a/example-specs/task/nipype/afni/warp.yaml
+++ b/example-specs/task/nipype/afni/warp.yaml
@@ -57,6 +57,9 @@ inputs:
     out_file: Path
     # type=file: Warped file.
     # type=file|default=<undefined>: output image file name
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/warp_callables.py b/example-specs/task/nipype/afni/warp_callables.py
index 7a9c2285..d5cff1fc 100644
--- a/example-specs/task/nipype/afni/warp_callables.py
+++ b/example-specs/task/nipype/afni/warp_callables.py
@@ -1,9 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of Warp.yaml"""
 
-import os
-import attrs
-import os.path as op
+from looseversion import LooseVersion
 import logging
+from pathlib import Path
+import os.path as op
+import attrs
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -23,6 +25,43 @@ def warp_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -178,6 +217,16 @@ def nipype_interfaces_afni__AFNICommand___list_outputs(
     return outputs
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/afni/z_cut_up.yaml b/example-specs/task/nipype/afni/z_cut_up.yaml
index df107055..d724a5e8 100644
--- a/example-specs/task/nipype/afni/z_cut_up.yaml
+++ b/example-specs/task/nipype/afni/z_cut_up.yaml
@@ -41,6 +41,9 @@ inputs:
     out_file: Path
     # type=file: output file
     # type=file|default=<undefined>: output image file name
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/z_cut_up_callables.py b/example-specs/task/nipype/afni/z_cut_up_callables.py
index 2403dc5e..11fd70b3 100644
--- a/example-specs/task/nipype/afni/z_cut_up_callables.py
+++ b/example-specs/task/nipype/afni/z_cut_up_callables.py
@@ -1,9 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of ZCutUp.yaml"""
 
-import os
-import attrs
-import os.path as op
+from looseversion import LooseVersion
 import logging
+import os.path as op
+import attrs
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +17,16 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -183,6 +194,43 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/afni/zcat.yaml b/example-specs/task/nipype/afni/zcat.yaml
index eafc89ee..f2e17845 100644
--- a/example-specs/task/nipype/afni/zcat.yaml
+++ b/example-specs/task/nipype/afni/zcat.yaml
@@ -41,6 +41,9 @@ inputs:
     out_file: Path
     # type=file: output file
     # type=file|default=<undefined>: output dataset prefix name (default 'zcat')
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/zcat_callables.py b/example-specs/task/nipype/afni/zcat_callables.py
index 7cc24cba..032833d4 100644
--- a/example-specs/task/nipype/afni/zcat_callables.py
+++ b/example-specs/task/nipype/afni/zcat_callables.py
@@ -1,9 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Zcat.yaml"""
 
-import os
-import attrs
-import os.path as op
+from looseversion import LooseVersion
 import logging
+import os.path as op
+import attrs
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +17,16 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -183,6 +194,43 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/afni/zeropad.yaml b/example-specs/task/nipype/afni/zeropad.yaml
index 2490c52e..fd943cd7 100644
--- a/example-specs/task/nipype/afni/zeropad.yaml
+++ b/example-specs/task/nipype/afni/zeropad.yaml
@@ -48,6 +48,9 @@ inputs:
     out_file: Path
     # type=file: output file
     # type=file|default=<undefined>: output dataset prefix name (default 'zeropad')
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/afni/zeropad_callables.py b/example-specs/task/nipype/afni/zeropad_callables.py
index 25a978a6..53afa228 100644
--- a/example-specs/task/nipype/afni/zeropad_callables.py
+++ b/example-specs/task/nipype/afni/zeropad_callables.py
@@ -1,9 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Zeropad.yaml"""
 
-import os
-import attrs
-import os.path as op
+from looseversion import LooseVersion
 import logging
+import os.path as op
+import attrs
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +17,16 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -183,6 +194,43 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/ants/affine_initializer.yaml b/example-specs/task/nipype/ants/affine_initializer.yaml
index ede71972..dac8edfc 100644
--- a/example-specs/task/nipype/ants/affine_initializer.yaml
+++ b/example-specs/task/nipype/ants/affine_initializer.yaml
@@ -37,6 +37,9 @@ inputs:
     out_file: Path
     # type=file: output transform file
     # type=file|default='transform.mat': output transform file
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/ants/ai.yaml b/example-specs/task/nipype/ants/ai.yaml
index 60714fe8..840ce367 100644
--- a/example-specs/task/nipype/ants/ai.yaml
+++ b/example-specs/task/nipype/ants/ai.yaml
@@ -52,6 +52,9 @@ inputs:
     output_transform: Path
     # type=file: output file name
     # type=file|default='initialization.mat': output file name
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/ants/ants.yaml b/example-specs/task/nipype/ants/ants.yaml
index e22f2cc4..2d0f9219 100644
--- a/example-specs/task/nipype/ants/ants.yaml
+++ b/example-specs/task/nipype/ants/ants.yaml
@@ -50,6 +50,9 @@ inputs:
     # type=inputmultiobject|default=[]: image to which the moving image is warped
     moving_image: medimage/nifti1+list-of
     # type=inputmultiobject|default=[]: image to apply transformation to (generally a coregisteredfunctional)
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/ants/ants_introduction.yaml b/example-specs/task/nipype/ants/ants_introduction.yaml
index 6ba47ad7..710529d2 100644
--- a/example-specs/task/nipype/ants/ants_introduction.yaml
+++ b/example-specs/task/nipype/ants/ants_introduction.yaml
@@ -37,6 +37,9 @@ inputs:
     # type=file|default=<undefined>: input image to warp to template
     reference_image: medimage/nifti1
     # type=file|default=<undefined>: template file to warp to
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/ants/ants_introduction_callables.py b/example-specs/task/nipype/ants/ants_introduction_callables.py
index eafba515..8e960e85 100644
--- a/example-specs/task/nipype/ants/ants_introduction_callables.py
+++ b/example-specs/task/nipype/ants/ants_introduction_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of antsIntroduction.yaml"""
 
-import os
 import attrs
+import os
 
 
 def affine_transformation_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/ants/apply_transforms.yaml b/example-specs/task/nipype/ants/apply_transforms.yaml
index 4b145ddb..eba0fbbb 100644
--- a/example-specs/task/nipype/ants/apply_transforms.yaml
+++ b/example-specs/task/nipype/ants/apply_transforms.yaml
@@ -76,6 +76,9 @@ inputs:
     # type=file|default=<undefined>: image to apply transformation to (generally a coregistered functional)
     reference_image: medimage/nifti1
     # type=file|default=<undefined>: reference image space that you wish to warp INTO
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/ants/apply_transforms_callables.py b/example-specs/task/nipype/ants/apply_transforms_callables.py
index 3e41684e..468f358c 100644
--- a/example-specs/task/nipype/ants/apply_transforms_callables.py
+++ b/example-specs/task/nipype/ants/apply_transforms_callables.py
@@ -1,8 +1,8 @@
 """Module to put any functions that are referred to in the "callables" section of ApplyTransforms.yaml"""
 
-import os
-import attrs
 import os.path as op
+import attrs
+import os
 
 
 def output_image_default(inputs):
diff --git a/example-specs/task/nipype/ants/apply_transforms_to_points.yaml b/example-specs/task/nipype/ants/apply_transforms_to_points.yaml
index 067d5a98..4fd4309d 100644
--- a/example-specs/task/nipype/ants/apply_transforms_to_points.yaml
+++ b/example-specs/task/nipype/ants/apply_transforms_to_points.yaml
@@ -40,6 +40,9 @@ inputs:
     # type=file|default=<undefined>: Currently, the only input supported is a csv file with columns including x,y (2D), x,y,z (3D) or x,y,z,t,label (4D) column headers. The points should be defined in physical space. If in doubt how to convert coordinates from your files to the space required by antsApplyTransformsToPoints try creating/drawing a simple label volume with only one voxel set to 1 and all others set to 0. Write down the voxel coordinates. Then use ImageMaths LabelStats to find out what coordinates for this voxel antsApplyTransformsToPoints is expecting.
     transforms: datascience/text-matrix+list-of
     # type=list|default=[]: transforms that will be applied to the points
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/ants/apply_transforms_to_points_callables.py b/example-specs/task/nipype/ants/apply_transforms_to_points_callables.py
index 90a0da3d..04f155cb 100644
--- a/example-specs/task/nipype/ants/apply_transforms_to_points_callables.py
+++ b/example-specs/task/nipype/ants/apply_transforms_to_points_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of ApplyTransformsToPoints.yaml"""
 
-import os
+import logging
 import os.path as op
 import attrs
-import logging
+import os
 
 
 def output_file_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +16,16 @@ def output_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/ants/atropos.yaml b/example-specs/task/nipype/ants/atropos.yaml
index 25cd1f35..5d28ba86 100644
--- a/example-specs/task/nipype/ants/atropos.yaml
+++ b/example-specs/task/nipype/ants/atropos.yaml
@@ -102,6 +102,11 @@ inputs:
     # type=file|default=<undefined>: 
     out_classified_image_name: Path
     # type=file|default=<undefined>: 
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
+    out_classified_image_name: out_classified_image_name_default
+    # type=file|default=<undefined>: 
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -122,8 +127,6 @@ outputs:
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
-    out_classified_image_name: out_classified_image_name_callable
-    # type=file|default=<undefined>: 
   templates:
   # dict[str, str] - `output_file_template` values to be provided to output fields
   requirements:
diff --git a/example-specs/task/nipype/ants/atropos_callables.py b/example-specs/task/nipype/ants/atropos_callables.py
index f48c0db8..c5a27be2 100644
--- a/example-specs/task/nipype/ants/atropos_callables.py
+++ b/example-specs/task/nipype/ants/atropos_callables.py
@@ -1,8 +1,8 @@
 """Module to put any functions that are referred to in the "callables" section of Atropos.yaml"""
 
-import os
-import attrs
 import os.path as op
+import attrs
+import os
 
 
 def out_classified_image_name_default(inputs):
diff --git a/example-specs/task/nipype/ants/average_affine_transform.yaml b/example-specs/task/nipype/ants/average_affine_transform.yaml
index 62946e20..eb2d770a 100644
--- a/example-specs/task/nipype/ants/average_affine_transform.yaml
+++ b/example-specs/task/nipype/ants/average_affine_transform.yaml
@@ -35,6 +35,9 @@ inputs:
     # type=file|default=<undefined>: Outputfname.txt: the name of the resulting transform.
     transforms: datascience/text-matrix+list-of
     # type=inputmultiobject|default=[]: transforms to average
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/ants/average_images.yaml b/example-specs/task/nipype/ants/average_images.yaml
index ff38d027..15817cba 100644
--- a/example-specs/task/nipype/ants/average_images.yaml
+++ b/example-specs/task/nipype/ants/average_images.yaml
@@ -36,6 +36,9 @@ inputs:
     output_average_image: Path
     # type=file: average image file
     # type=file|default='average.nii': the name of the resulting image.
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/ants/brain_extraction.yaml b/example-specs/task/nipype/ants/brain_extraction.yaml
index 32752462..df8a8400 100644
--- a/example-specs/task/nipype/ants/brain_extraction.yaml
+++ b/example-specs/task/nipype/ants/brain_extraction.yaml
@@ -43,6 +43,9 @@ inputs:
     # type=file|default=<undefined>: Anatomical template created using e.g. LPBA40 data set with buildtemplateparallel.sh in ANTs.
     extraction_registration_mask: generic/file
     # type=file|default=<undefined>: Mask (defined in the template space) used during registration for brain extraction. To limit the metric computation to a specific region.
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/ants/brain_extraction_callables.py b/example-specs/task/nipype/ants/brain_extraction_callables.py
index b7b45348..fcb649e1 100644
--- a/example-specs/task/nipype/ants/brain_extraction_callables.py
+++ b/example-specs/task/nipype/ants/brain_extraction_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of BrainExtraction.yaml"""
 
-import os
 import attrs
+import os
 
 
 def BrainExtractionMask_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/ants/buildtemplateparallel.yaml b/example-specs/task/nipype/ants/buildtemplateparallel.yaml
index 0cc29eb4..a712377c 100644
--- a/example-specs/task/nipype/ants/buildtemplateparallel.yaml
+++ b/example-specs/task/nipype/ants/buildtemplateparallel.yaml
@@ -38,6 +38,9 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_files: medimage/nifti1+list-of
     # type=list|default=[]: list of images to generate template from
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/ants/buildtemplateparallel_callables.py b/example-specs/task/nipype/ants/buildtemplateparallel_callables.py
index 2b8df5b0..8662ba95 100644
--- a/example-specs/task/nipype/ants/buildtemplateparallel_callables.py
+++ b/example-specs/task/nipype/ants/buildtemplateparallel_callables.py
@@ -1,8 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of buildtemplateparallel.yaml"""
 
-import os
-from glob import glob
 import os.path as op
+from glob import glob
+from builtins import range
+import os
 
 
 def final_template_file_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/ants/compose_multi_transform.yaml b/example-specs/task/nipype/ants/compose_multi_transform.yaml
index 6bc5c609..fe0dce81 100644
--- a/example-specs/task/nipype/ants/compose_multi_transform.yaml
+++ b/example-specs/task/nipype/ants/compose_multi_transform.yaml
@@ -40,6 +40,9 @@ inputs:
     # type=file|default=<undefined>: Reference image (only necessary when output is warpfield)
     transforms: datascience/text-matrix+list-of
     # type=inputmultiobject|default=[]: transforms to average
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/ants/compose_multi_transform_callables.py b/example-specs/task/nipype/ants/compose_multi_transform_callables.py
index ad164db5..bc5b324f 100644
--- a/example-specs/task/nipype/ants/compose_multi_transform_callables.py
+++ b/example-specs/task/nipype/ants/compose_multi_transform_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of ComposeMultiTransform.yaml"""
 
-import os
+import logging
 import os.path as op
 import attrs
-import logging
+import os
 
 
 def output_transform_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +16,16 @@ def output_transform_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/ants/composite_transform_util.yaml b/example-specs/task/nipype/ants/composite_transform_util.yaml
index 16e204d7..70147e30 100644
--- a/example-specs/task/nipype/ants/composite_transform_util.yaml
+++ b/example-specs/task/nipype/ants/composite_transform_util.yaml
@@ -50,6 +50,9 @@ inputs:
     out_file: Path
     # type=file: Compound transformation file
     # type=file|default=<undefined>: Output file path (only used for disassembly).
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/ants/convert_scalar_image_to_rgb.yaml b/example-specs/task/nipype/ants/convert_scalar_image_to_rgb.yaml
index 6faac3c1..fb24feea 100644
--- a/example-specs/task/nipype/ants/convert_scalar_image_to_rgb.yaml
+++ b/example-specs/task/nipype/ants/convert_scalar_image_to_rgb.yaml
@@ -37,6 +37,9 @@ inputs:
   # passed to the field in the automatically generated unittests.
     input_image: medimage/nifti-gz
     # type=file|default=<undefined>: Main input is a 3-D grayscale image.
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/ants/cortical_thickness.yaml b/example-specs/task/nipype/ants/cortical_thickness.yaml
index e1ad0e70..d12f14de 100644
--- a/example-specs/task/nipype/ants/cortical_thickness.yaml
+++ b/example-specs/task/nipype/ants/cortical_thickness.yaml
@@ -53,6 +53,9 @@ inputs:
     # type=inputmultiobject|default=[]: 
     t1_registration_template: medimage/nifti-gz
     # type=file|default=<undefined>: Anatomical *intensity* template (assumed to be skull-stripped). A common case would be where this would be the same template as specified in the -e option which is not skull stripped.
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/ants/create_jacobian_determinant_image.yaml b/example-specs/task/nipype/ants/create_jacobian_determinant_image.yaml
index 78da54d7..d524d09a 100644
--- a/example-specs/task/nipype/ants/create_jacobian_determinant_image.yaml
+++ b/example-specs/task/nipype/ants/create_jacobian_determinant_image.yaml
@@ -34,6 +34,9 @@ inputs:
     # type=file|default=<undefined>: deformation transformation file
     outputImage: medimage/nifti-gz
     # type=file|default=<undefined>: output filename
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/ants/create_tiled_mosaic.yaml b/example-specs/task/nipype/ants/create_tiled_mosaic.yaml
index 9a319fe3..3d370ee9 100644
--- a/example-specs/task/nipype/ants/create_tiled_mosaic.yaml
+++ b/example-specs/task/nipype/ants/create_tiled_mosaic.yaml
@@ -46,6 +46,9 @@ inputs:
     # type=file|default=<undefined>: Specifies the ROI of the RGB voxels used.
     rgb_image: medimage/nifti-gz
     # type=file|default=<undefined>: An optional Rgb image can be added as an overlay.It must have the same imagegeometry as the input grayscale image.
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/ants/denoise_image.yaml b/example-specs/task/nipype/ants/denoise_image.yaml
index 01e51e78..a0e0ea7c 100644
--- a/example-specs/task/nipype/ants/denoise_image.yaml
+++ b/example-specs/task/nipype/ants/denoise_image.yaml
@@ -52,6 +52,9 @@ inputs:
     output_image: Path
     # type=file: 
     # type=file|default=<undefined>: The output consists of the noise corrected version of the input image.
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/ants/denoise_image_callables.py b/example-specs/task/nipype/ants/denoise_image_callables.py
index 49f14355..71313d03 100644
--- a/example-specs/task/nipype/ants/denoise_image_callables.py
+++ b/example-specs/task/nipype/ants/denoise_image_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of DenoiseImage.yaml"""
 
-import os
+import logging
 import os.path as op
 import attrs
-import logging
+import os
 
 
 def output_image_callable(output_dir, inputs, stdout, stderr):
@@ -23,6 +23,16 @@ def noise_image_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/ants/gen_warp_fields.yaml b/example-specs/task/nipype/ants/gen_warp_fields.yaml
index 52e68aff..2050e919 100644
--- a/example-specs/task/nipype/ants/gen_warp_fields.yaml
+++ b/example-specs/task/nipype/ants/gen_warp_fields.yaml
@@ -24,6 +24,9 @@ inputs:
     # type=file|default=<undefined>: input image to warp to template
     reference_image: generic/file
     # type=file|default=<undefined>: template file to warp to
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/ants/gen_warp_fields_callables.py b/example-specs/task/nipype/ants/gen_warp_fields_callables.py
index 5b0cc3f6..b6a9e182 100644
--- a/example-specs/task/nipype/ants/gen_warp_fields_callables.py
+++ b/example-specs/task/nipype/ants/gen_warp_fields_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of GenWarpFields.yaml"""
 
-import os
 import attrs
+import os
 
 
 def affine_transformation_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/ants/image_math.yaml b/example-specs/task/nipype/ants/image_math.yaml
index e920cc83..c453d829 100644
--- a/example-specs/task/nipype/ants/image_math.yaml
+++ b/example-specs/task/nipype/ants/image_math.yaml
@@ -79,6 +79,9 @@ inputs:
     output_image: Path
     # type=file: output image file
     # type=file|default=<undefined>: output image file
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/ants/image_math_callables.py b/example-specs/task/nipype/ants/image_math_callables.py
index 4f40c39a..ea88e0c1 100644
--- a/example-specs/task/nipype/ants/image_math_callables.py
+++ b/example-specs/task/nipype/ants/image_math_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of ImageMath.yaml"""
 
-import os
+import logging
 import os.path as op
 import attrs
-import logging
+import os
 
 
 def output_image_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +16,16 @@ def output_image_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/ants/joint_fusion.yaml b/example-specs/task/nipype/ants/joint_fusion.yaml
index c5c34ddb..7039070a 100644
--- a/example-specs/task/nipype/ants/joint_fusion.yaml
+++ b/example-specs/task/nipype/ants/joint_fusion.yaml
@@ -102,6 +102,9 @@ inputs:
     out_label_fusion: Path
     # type=file: 
     # type=file|default=<undefined>: The output label fusion image.
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/ants/joint_fusion_callables.py b/example-specs/task/nipype/ants/joint_fusion_callables.py
index 64d0f448..ad1c44bd 100644
--- a/example-specs/task/nipype/ants/joint_fusion_callables.py
+++ b/example-specs/task/nipype/ants/joint_fusion_callables.py
@@ -1,8 +1,8 @@
 """Module to put any functions that are referred to in the "callables" section of JointFusion.yaml"""
 
-import os
 from glob import glob
 import attrs
+import os
 
 
 def out_label_fusion_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/ants/kelly_kapowski.yaml b/example-specs/task/nipype/ants/kelly_kapowski.yaml
index d53e6c20..b8b533d6 100644
--- a/example-specs/task/nipype/ants/kelly_kapowski.yaml
+++ b/example-specs/task/nipype/ants/kelly_kapowski.yaml
@@ -57,6 +57,9 @@ inputs:
     # type=file|default=<undefined>: Filename for the warped white matter file.
     white_matter_prob_image: generic/file
     # type=file|default=<undefined>: In addition to the segmentation image, a white matter probability image can be used. If no such image is supplied, one is created using the segmentation image and a variance of 1.0 mm.
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/ants/kelly_kapowski_callables.py b/example-specs/task/nipype/ants/kelly_kapowski_callables.py
index e26417c1..43879a02 100644
--- a/example-specs/task/nipype/ants/kelly_kapowski_callables.py
+++ b/example-specs/task/nipype/ants/kelly_kapowski_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of KellyKapowski.yaml"""
 
-import os
-import attrs
-import os.path as op
 import logging
+import os.path as op
+import attrs
+import os
 
 
 def cortical_thickness_callable(output_dir, inputs, stdout, stderr):
@@ -89,6 +89,16 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
         return output
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/ants/label_geometry.yaml b/example-specs/task/nipype/ants/label_geometry.yaml
index b4c4c262..21fc257c 100644
--- a/example-specs/task/nipype/ants/label_geometry.yaml
+++ b/example-specs/task/nipype/ants/label_geometry.yaml
@@ -40,6 +40,9 @@ inputs:
     # type=file|default='[]': Intensity image to extract values from. This is an optional input
     label_image: medimage/nifti-gz
     # type=file|default=<undefined>: label image to use for extracting geometry measures
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/ants/label_geometry_callables.py b/example-specs/task/nipype/ants/label_geometry_callables.py
index d339049a..1124bea1 100644
--- a/example-specs/task/nipype/ants/label_geometry_callables.py
+++ b/example-specs/task/nipype/ants/label_geometry_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of LabelGeometry.yaml"""
 
-import os
+import logging
 import os.path as op
 import attrs
-import logging
+import os
 
 
 def output_file_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +16,16 @@ def output_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/ants/laplacian_thickness.yaml b/example-specs/task/nipype/ants/laplacian_thickness.yaml
index f39981fe..23d4a392 100644
--- a/example-specs/task/nipype/ants/laplacian_thickness.yaml
+++ b/example-specs/task/nipype/ants/laplacian_thickness.yaml
@@ -40,6 +40,9 @@ inputs:
     # type=file|default=<undefined>: gray matter segmentation image
     input_wm: medimage/nifti-gz
     # type=file|default=<undefined>: white matter segmentation image
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/ants/laplacian_thickness_callables.py b/example-specs/task/nipype/ants/laplacian_thickness_callables.py
index 89033eac..593e6247 100644
--- a/example-specs/task/nipype/ants/laplacian_thickness_callables.py
+++ b/example-specs/task/nipype/ants/laplacian_thickness_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of LaplacianThickness.yaml"""
 
-import os
+import logging
 import os.path as op
 import attrs
-import logging
+import os
 
 
 def output_image_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +16,16 @@ def output_image_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/ants/measure_image_similarity.yaml b/example-specs/task/nipype/ants/measure_image_similarity.yaml
index fd360ab9..cc086bec 100644
--- a/example-specs/task/nipype/ants/measure_image_similarity.yaml
+++ b/example-specs/task/nipype/ants/measure_image_similarity.yaml
@@ -48,6 +48,9 @@ inputs:
     # type=file|default=<undefined>: Image to apply transformation to (generally a coregistered functional)
     moving_image_mask: medimage/nifti-gz
     # type=file|default=<undefined>: mask used to limit metric sampling region of the moving image
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/ants/measure_image_similarity_callables.py b/example-specs/task/nipype/ants/measure_image_similarity_callables.py
index dd5a8eb8..df32b70e 100644
--- a/example-specs/task/nipype/ants/measure_image_similarity_callables.py
+++ b/example-specs/task/nipype/ants/measure_image_similarity_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of MeasureImageSimilarity.yaml"""
 
-import os
+import logging
 import os.path as op
 import attrs
-import logging
+import os
 
 
 def similarity_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +16,16 @@ def similarity_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/ants/multiply_images.yaml b/example-specs/task/nipype/ants/multiply_images.yaml
index f69faa09..aacb7cdb 100644
--- a/example-specs/task/nipype/ants/multiply_images.yaml
+++ b/example-specs/task/nipype/ants/multiply_images.yaml
@@ -36,6 +36,9 @@ inputs:
     output_product_image: Path
     # type=file: average image file
     # type=file|default=<undefined>: Outputfname.nii.gz: the name of the resulting image.
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/ants/n4_bias_field_correction.yaml b/example-specs/task/nipype/ants/n4_bias_field_correction.yaml
index a644a06d..bb3f0d73 100644
--- a/example-specs/task/nipype/ants/n4_bias_field_correction.yaml
+++ b/example-specs/task/nipype/ants/n4_bias_field_correction.yaml
@@ -94,6 +94,9 @@ inputs:
     # type=file|default=<undefined>: image to specify region to perform final bias correction in
     weight_image: generic/file
     # type=file|default=<undefined>: image for relative weighting (e.g. probability map of the white matter) of voxels during the B-spline fitting. 
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/ants/n4_bias_field_correction_callables.py b/example-specs/task/nipype/ants/n4_bias_field_correction_callables.py
index febe11bd..3cdce1e9 100644
--- a/example-specs/task/nipype/ants/n4_bias_field_correction_callables.py
+++ b/example-specs/task/nipype/ants/n4_bias_field_correction_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of N4BiasFieldCorrection.yaml"""
 
-import os
-import attrs
-import os.path as op
 import logging
+import os.path as op
+import attrs
+import os
 
 
 def output_image_callable(output_dir, inputs, stdout, stderr):
@@ -23,6 +23,16 @@ def bias_image_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/ants/registration.yaml b/example-specs/task/nipype/ants/registration.yaml
index 436b9113..d066ce5c 100644
--- a/example-specs/task/nipype/ants/registration.yaml
+++ b/example-specs/task/nipype/ants/registration.yaml
@@ -288,6 +288,9 @@ inputs:
     save_state: Path
     # type=file: The saved registration state to be restored
     # type=file|default=<undefined>: Filename for saving the internal restorable state of the registration
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/ants/registration_callables.py b/example-specs/task/nipype/ants/registration_callables.py
index 321b352e..3931ad38 100644
--- a/example-specs/task/nipype/ants/registration_callables.py
+++ b/example-specs/task/nipype/ants/registration_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of Registration.yaml"""
 
-import os
 import attrs
+import os
 
 
 def forward_transforms_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/ants/registration_syn_quick.yaml b/example-specs/task/nipype/ants/registration_syn_quick.yaml
index 543ee7ff..70a63846 100644
--- a/example-specs/task/nipype/ants/registration_syn_quick.yaml
+++ b/example-specs/task/nipype/ants/registration_syn_quick.yaml
@@ -51,6 +51,9 @@ inputs:
     # type=inputmultiobject|default=[]: Fixed image or source image or reference image
     moving_image: medimage/nifti1+list-of
     # type=inputmultiobject|default=[]: Moving image or target image
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/ants/resample_image_by_spacing.yaml b/example-specs/task/nipype/ants/resample_image_by_spacing.yaml
index d509a953..7c61c1e9 100644
--- a/example-specs/task/nipype/ants/resample_image_by_spacing.yaml
+++ b/example-specs/task/nipype/ants/resample_image_by_spacing.yaml
@@ -55,6 +55,9 @@ inputs:
     output_image: Path
     # type=file: resampled file
     # type=file|default=<undefined>: output image file
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/ants/resample_image_by_spacing_callables.py b/example-specs/task/nipype/ants/resample_image_by_spacing_callables.py
index a856ebba..30276d34 100644
--- a/example-specs/task/nipype/ants/resample_image_by_spacing_callables.py
+++ b/example-specs/task/nipype/ants/resample_image_by_spacing_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of ResampleImageBySpacing.yaml"""
 
-import os
+import logging
 import os.path as op
 import attrs
-import logging
+import os
 
 
 def output_image_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +16,16 @@ def output_image_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/ants/threshold_image.yaml b/example-specs/task/nipype/ants/threshold_image.yaml
index 6fa05b67..beace54c 100644
--- a/example-specs/task/nipype/ants/threshold_image.yaml
+++ b/example-specs/task/nipype/ants/threshold_image.yaml
@@ -50,6 +50,9 @@ inputs:
     output_image: Path
     # type=file: resampled file
     # type=file|default=<undefined>: output image file
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/ants/threshold_image_callables.py b/example-specs/task/nipype/ants/threshold_image_callables.py
index 5414c9dd..bb57552e 100644
--- a/example-specs/task/nipype/ants/threshold_image_callables.py
+++ b/example-specs/task/nipype/ants/threshold_image_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of ThresholdImage.yaml"""
 
-import os
+import logging
 import os.path as op
 import attrs
-import logging
+import os
 
 
 def output_image_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +16,16 @@ def output_image_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/ants/warp_image_multi_transform.yaml b/example-specs/task/nipype/ants/warp_image_multi_transform.yaml
index 0f296f77..ea6fde25 100644
--- a/example-specs/task/nipype/ants/warp_image_multi_transform.yaml
+++ b/example-specs/task/nipype/ants/warp_image_multi_transform.yaml
@@ -52,6 +52,9 @@ inputs:
     # type=file|default=<undefined>: reference image space that you wish to warp INTO
     transformation_series: '[text/text-file,medimage/nifti-gz]+list-of'
     # type=inputmultiobject|default=[]: transformation file(s) to be applied
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/ants/warp_image_multi_transform_callables.py b/example-specs/task/nipype/ants/warp_image_multi_transform_callables.py
index 74db17ea..ad32a2db 100644
--- a/example-specs/task/nipype/ants/warp_image_multi_transform_callables.py
+++ b/example-specs/task/nipype/ants/warp_image_multi_transform_callables.py
@@ -1,8 +1,8 @@
 """Module to put any functions that are referred to in the "callables" section of WarpImageMultiTransform.yaml"""
 
-import os
-import attrs
 import os.path as op
+import attrs
+import os
 
 
 def output_image_default(inputs):
diff --git a/example-specs/task/nipype/ants/warp_time_series_image_multi_transform.yaml b/example-specs/task/nipype/ants/warp_time_series_image_multi_transform.yaml
index 2ab6266c..3884b36d 100644
--- a/example-specs/task/nipype/ants/warp_time_series_image_multi_transform.yaml
+++ b/example-specs/task/nipype/ants/warp_time_series_image_multi_transform.yaml
@@ -46,6 +46,9 @@ inputs:
     # type=file|default=<undefined>: reference image space that you wish to warp INTO
     transformation_series: medimage/nifti-gz+list-of
     # type=inputmultiobject|default=[]: transformation file(s) to be applied
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/ants/warp_time_series_image_multi_transform_callables.py b/example-specs/task/nipype/ants/warp_time_series_image_multi_transform_callables.py
index 8d34c398..4f061b87 100644
--- a/example-specs/task/nipype/ants/warp_time_series_image_multi_transform_callables.py
+++ b/example-specs/task/nipype/ants/warp_time_series_image_multi_transform_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of WarpTimeSeriesImageMultiTransform.yaml"""
 
-import os
 import os.path as op
+import os
 
 
 def output_image_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/freesurfer/add_x_form_to_header.yaml b/example-specs/task/nipype/freesurfer/add_x_form_to_header.yaml
index 81505624..207f942d 100644
--- a/example-specs/task/nipype/freesurfer/add_x_form_to_header.yaml
+++ b/example-specs/task/nipype/freesurfer/add_x_form_to_header.yaml
@@ -55,6 +55,9 @@ inputs:
     # type=directory|default=<undefined>: subjects directory
     transform: datascience/text-matrix
     # type=file|default=<undefined>: xfm file
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/aparc_2_aseg.yaml b/example-specs/task/nipype/freesurfer/aparc_2_aseg.yaml
index ecb97d38..985782bb 100644
--- a/example-specs/task/nipype/freesurfer/aparc_2_aseg.yaml
+++ b/example-specs/task/nipype/freesurfer/aparc_2_aseg.yaml
@@ -84,6 +84,9 @@ inputs:
     # type=file|default=<undefined>: Input file must be <subject_id>/mri/ribbon.mgz
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/apas_2_aseg.yaml b/example-specs/task/nipype/freesurfer/apas_2_aseg.yaml
index c247750e..1f7ce546 100644
--- a/example-specs/task/nipype/freesurfer/apas_2_aseg.yaml
+++ b/example-specs/task/nipype/freesurfer/apas_2_aseg.yaml
@@ -42,6 +42,9 @@ inputs:
     # type=file|default=<undefined>: Output aseg file
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/apply_mask.yaml b/example-specs/task/nipype/freesurfer/apply_mask.yaml
index 7d633987..0c7783f0 100644
--- a/example-specs/task/nipype/freesurfer/apply_mask.yaml
+++ b/example-specs/task/nipype/freesurfer/apply_mask.yaml
@@ -41,6 +41,9 @@ inputs:
     # type=file|default=<undefined>: image defining transform source space
     xfm_target: generic/file
     # type=file|default=<undefined>: image defining transform target space
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/apply_mask_callables.py b/example-specs/task/nipype/freesurfer/apply_mask_callables.py
index 53a377cd..ebe44572 100644
--- a/example-specs/task/nipype/freesurfer/apply_mask_callables.py
+++ b/example-specs/task/nipype/freesurfer/apply_mask_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of ApplyMask.yaml"""
 
-import os
+import logging
 import os.path as op
 import attrs
-import logging
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +16,16 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/freesurfer/apply_vol_transform.yaml b/example-specs/task/nipype/freesurfer/apply_vol_transform.yaml
index 2142b743..5311dc29 100644
--- a/example-specs/task/nipype/freesurfer/apply_vol_transform.yaml
+++ b/example-specs/task/nipype/freesurfer/apply_vol_transform.yaml
@@ -55,6 +55,9 @@ inputs:
     # type=file|default=<undefined>: Output volume
     xfm_reg_file: generic/file
     # type=file|default=<undefined>: ScannerRAS-to-ScannerRAS matrix (MNI format)
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/apply_vol_transform_callables.py b/example-specs/task/nipype/freesurfer/apply_vol_transform_callables.py
index 9e0b2f32..01932a50 100644
--- a/example-specs/task/nipype/freesurfer/apply_vol_transform_callables.py
+++ b/example-specs/task/nipype/freesurfer/apply_vol_transform_callables.py
@@ -1,8 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of ApplyVolTransform.yaml"""
 
-import os
-import attrs
+from pathlib import Path
 import os.path as op
+import attrs
+import os
 
 
 def transformed_file_default(inputs):
diff --git a/example-specs/task/nipype/freesurfer/bb_register.yaml b/example-specs/task/nipype/freesurfer/bb_register.yaml
index 993f37eb..3da85166 100644
--- a/example-specs/task/nipype/freesurfer/bb_register.yaml
+++ b/example-specs/task/nipype/freesurfer/bb_register.yaml
@@ -45,6 +45,9 @@ inputs:
     # type=file|default=<undefined>: source file to be registered
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/bb_register_callables.py b/example-specs/task/nipype/freesurfer/bb_register_callables.py
index 85cd4704..1264b998 100644
--- a/example-specs/task/nipype/freesurfer/bb_register_callables.py
+++ b/example-specs/task/nipype/freesurfer/bb_register_callables.py
@@ -1,7 +1,8 @@
 """Module to put any functions that are referred to in the "callables" section of BBRegister.yaml"""
 
-import attrs
+from pathlib import Path
 import os.path as op
+import attrs
 
 
 def out_reg_file_default(inputs):
diff --git a/example-specs/task/nipype/freesurfer/binarize.yaml b/example-specs/task/nipype/freesurfer/binarize.yaml
index dd8358b1..8f385c0d 100644
--- a/example-specs/task/nipype/freesurfer/binarize.yaml
+++ b/example-specs/task/nipype/freesurfer/binarize.yaml
@@ -39,6 +39,9 @@ inputs:
     # type=file|default=<undefined>: merge with mergevol
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/binarize_callables.py b/example-specs/task/nipype/freesurfer/binarize_callables.py
index 0af5ea07..2aa5268a 100644
--- a/example-specs/task/nipype/freesurfer/binarize_callables.py
+++ b/example-specs/task/nipype/freesurfer/binarize_callables.py
@@ -1,8 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of Binarize.yaml"""
 
-import os
-import attrs
+from pathlib import Path
 import os.path as op
+import attrs
+import os
 
 
 def binary_file_default(inputs):
diff --git a/example-specs/task/nipype/freesurfer/ca_label.yaml b/example-specs/task/nipype/freesurfer/ca_label.yaml
index 01a9f92a..eec07a8c 100644
--- a/example-specs/task/nipype/freesurfer/ca_label.yaml
+++ b/example-specs/task/nipype/freesurfer/ca_label.yaml
@@ -57,6 +57,9 @@ inputs:
     # type=file|default=<undefined>: Input template for CALabel
     transform: datascience/text-matrix
     # type=file|default=<undefined>: Input transform for CALabel
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/ca_normalize.yaml b/example-specs/task/nipype/freesurfer/ca_normalize.yaml
index b39d54da..eaabedaf 100644
--- a/example-specs/task/nipype/freesurfer/ca_normalize.yaml
+++ b/example-specs/task/nipype/freesurfer/ca_normalize.yaml
@@ -56,6 +56,9 @@ inputs:
     # type=directory|default=<undefined>: subjects directory
     transform: datascience/text-matrix
     # type=file|default=<undefined>: The transform file in lta format
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/ca_register.yaml b/example-specs/task/nipype/freesurfer/ca_register.yaml
index 3b979e28..c34ea647 100644
--- a/example-specs/task/nipype/freesurfer/ca_register.yaml
+++ b/example-specs/task/nipype/freesurfer/ca_register.yaml
@@ -51,6 +51,9 @@ inputs:
     # type=file|default=<undefined>: The template file in gca format
     transform: generic/file
     # type=file|default=<undefined>: Specifies transform in lta format
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/check_talairach_alignment.yaml b/example-specs/task/nipype/freesurfer/check_talairach_alignment.yaml
index 149cf366..6cf973ea 100644
--- a/example-specs/task/nipype/freesurfer/check_talairach_alignment.yaml
+++ b/example-specs/task/nipype/freesurfer/check_talairach_alignment.yaml
@@ -39,6 +39,9 @@ inputs:
     # type=file|default=<undefined>: specify the talairach.xfm file to check
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/concatenate.yaml b/example-specs/task/nipype/freesurfer/concatenate.yaml
index efb3f8a6..6b55ebca 100644
--- a/example-specs/task/nipype/freesurfer/concatenate.yaml
+++ b/example-specs/task/nipype/freesurfer/concatenate.yaml
@@ -45,6 +45,9 @@ inputs:
     # type=file|default=<undefined>: Multiply input by an ascii matrix in file
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/concatenate_callables.py b/example-specs/task/nipype/freesurfer/concatenate_callables.py
index 53084261..f2dd9e7d 100644
--- a/example-specs/task/nipype/freesurfer/concatenate_callables.py
+++ b/example-specs/task/nipype/freesurfer/concatenate_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of Concatenate.yaml"""
 
-import os
 import attrs
+import os
 
 
 def concatenated_file_default(inputs):
diff --git a/example-specs/task/nipype/freesurfer/concatenate_lta.yaml b/example-specs/task/nipype/freesurfer/concatenate_lta.yaml
index 974f0a6f..ee794e25 100644
--- a/example-specs/task/nipype/freesurfer/concatenate_lta.yaml
+++ b/example-specs/task/nipype/freesurfer/concatenate_lta.yaml
@@ -58,6 +58,9 @@ inputs:
     # type=file|default=<undefined>: if in_lta2 is talairach.xfm, specify source for talairach
     tal_template_file: generic/file
     # type=file|default=<undefined>: if in_lta2 is talairach.xfm, specify template for talairach
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/concatenate_lta_callables.py b/example-specs/task/nipype/freesurfer/concatenate_lta_callables.py
index 8cbb01e5..7a02d0fa 100644
--- a/example-specs/task/nipype/freesurfer/concatenate_lta_callables.py
+++ b/example-specs/task/nipype/freesurfer/concatenate_lta_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of ConcatenateLTA.yaml"""
 
-import os
+import logging
 import os.path as op
 import attrs
-import logging
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +16,16 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/freesurfer/contrast.yaml b/example-specs/task/nipype/freesurfer/contrast.yaml
index 3a863cdc..3a915bfa 100644
--- a/example-specs/task/nipype/freesurfer/contrast.yaml
+++ b/example-specs/task/nipype/freesurfer/contrast.yaml
@@ -51,6 +51,9 @@ inputs:
     # type=file|default=<undefined>: Input file must be <subject_id>/surf/?h.thickness
     white: medimage-freesurfer/white
     # type=file|default=<undefined>: Input file must be <subject_id>/surf/<hemisphere>.white
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/curvature.yaml b/example-specs/task/nipype/freesurfer/curvature.yaml
index d1724e42..0b1253cd 100644
--- a/example-specs/task/nipype/freesurfer/curvature.yaml
+++ b/example-specs/task/nipype/freesurfer/curvature.yaml
@@ -37,6 +37,9 @@ inputs:
     # type=file|default=<undefined>: Input file for Curvature
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/curvature_stats.yaml b/example-specs/task/nipype/freesurfer/curvature_stats.yaml
index 03352fb8..15332102 100644
--- a/example-specs/task/nipype/freesurfer/curvature_stats.yaml
+++ b/example-specs/task/nipype/freesurfer/curvature_stats.yaml
@@ -67,6 +67,9 @@ inputs:
     # type=directory|default=<undefined>: subjects directory
     surface: medimage-freesurfer/pial
     # type=file|default=<undefined>: Specify surface file for CurvatureStats
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/dicom_convert.yaml b/example-specs/task/nipype/freesurfer/dicom_convert.yaml
index d2b9371f..8dca10ce 100644
--- a/example-specs/task/nipype/freesurfer/dicom_convert.yaml
+++ b/example-specs/task/nipype/freesurfer/dicom_convert.yaml
@@ -38,6 +38,9 @@ inputs:
     # type=file|default=<undefined>: File containing summary information from mri_parse_sdcmdir
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/dicom_convert_callables.py b/example-specs/task/nipype/freesurfer/dicom_convert_callables.py
index 8e80e78a..e1c4fb23 100644
--- a/example-specs/task/nipype/freesurfer/dicom_convert_callables.py
+++ b/example-specs/task/nipype/freesurfer/dicom_convert_callables.py
@@ -1,13 +1,23 @@
 """Module to put any functions that are referred to in the "callables" section of DICOMConvert.yaml"""
 
-import os
+import logging
 import os.path as op
 import attrs
-import logging
+import os
 
 iflogger = logging.getLogger("nipype.interface")
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/freesurfer/edit_w_mwith_aseg.yaml b/example-specs/task/nipype/freesurfer/edit_w_mwith_aseg.yaml
index 7bdc14b8..132b6c56 100644
--- a/example-specs/task/nipype/freesurfer/edit_w_mwith_aseg.yaml
+++ b/example-specs/task/nipype/freesurfer/edit_w_mwith_aseg.yaml
@@ -45,6 +45,9 @@ inputs:
     # type=file|default=<undefined>: Input presurf segmentation file
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/em_register.yaml b/example-specs/task/nipype/freesurfer/em_register.yaml
index db7a38c5..3b23bb7e 100644
--- a/example-specs/task/nipype/freesurfer/em_register.yaml
+++ b/example-specs/task/nipype/freesurfer/em_register.yaml
@@ -46,6 +46,9 @@ inputs:
     # type=file|default=<undefined>: template gca
     transform: generic/file
     # type=file|default=<undefined>: Previously computed transform
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/euler_number.yaml b/example-specs/task/nipype/freesurfer/euler_number.yaml
index 5ac4a5ef..a753c37b 100644
--- a/example-specs/task/nipype/freesurfer/euler_number.yaml
+++ b/example-specs/task/nipype/freesurfer/euler_number.yaml
@@ -34,6 +34,9 @@ inputs:
     # type=file|default=<undefined>: Input file for EulerNumber
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/extract_main_component.yaml b/example-specs/task/nipype/freesurfer/extract_main_component.yaml
index 0ad30468..039b28f5 100644
--- a/example-specs/task/nipype/freesurfer/extract_main_component.yaml
+++ b/example-specs/task/nipype/freesurfer/extract_main_component.yaml
@@ -35,6 +35,9 @@ inputs:
     out_file: Path
     # type=file: surface containing main component
     # type=file|default=<undefined>: surface containing main component
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/extract_main_component_callables.py b/example-specs/task/nipype/freesurfer/extract_main_component_callables.py
index ed6d7473..e917a268 100644
--- a/example-specs/task/nipype/freesurfer/extract_main_component_callables.py
+++ b/example-specs/task/nipype/freesurfer/extract_main_component_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of ExtractMainComponent.yaml"""
 
-import os
+import logging
 import os.path as op
 import attrs
-import logging
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +16,16 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/freesurfer/fit_ms_params.yaml b/example-specs/task/nipype/freesurfer/fit_ms_params.yaml
index 6a8bea02..671df7de 100644
--- a/example-specs/task/nipype/freesurfer/fit_ms_params.yaml
+++ b/example-specs/task/nipype/freesurfer/fit_ms_params.yaml
@@ -39,6 +39,11 @@ inputs:
     # type=directory|default=<undefined>: subjects directory
     xfm_list: generic/file+list-of
     # type=list|default=[]: list of transform files to apply to each FLASH image
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
+    out_dir: out_dir_default
+    # type=directory|default=<undefined>: directory to store output in
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -61,8 +66,6 @@ outputs:
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
-    out_dir: out_dir_callable
-    # type=directory|default=<undefined>: directory to store output in
   templates:
   # dict[str, str] - `output_file_template` values to be provided to output fields
   requirements:
diff --git a/example-specs/task/nipype/freesurfer/fit_ms_params_callables.py b/example-specs/task/nipype/freesurfer/fit_ms_params_callables.py
index a12c332f..dc87f90f 100644
--- a/example-specs/task/nipype/freesurfer/fit_ms_params_callables.py
+++ b/example-specs/task/nipype/freesurfer/fit_ms_params_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of FitMSParams.yaml"""
 
-import os
 import attrs
+import os
 
 
 def out_dir_default(inputs):
diff --git a/example-specs/task/nipype/freesurfer/fix_topology.yaml b/example-specs/task/nipype/freesurfer/fix_topology.yaml
index 4c164714..9a52ec79 100644
--- a/example-specs/task/nipype/freesurfer/fix_topology.yaml
+++ b/example-specs/task/nipype/freesurfer/fix_topology.yaml
@@ -50,6 +50,9 @@ inputs:
     # type=file|default=<undefined>: Sphere input file
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/fuse_segmentations.yaml b/example-specs/task/nipype/freesurfer/fuse_segmentations.yaml
index 6d98f0b4..e97b6641 100644
--- a/example-specs/task/nipype/freesurfer/fuse_segmentations.yaml
+++ b/example-specs/task/nipype/freesurfer/fuse_segmentations.yaml
@@ -45,6 +45,9 @@ inputs:
     # type=file|default=<undefined>: output fused segmentation file
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/glm_fit.yaml b/example-specs/task/nipype/freesurfer/glm_fit.yaml
index 7a0e1622..b00e24ac 100644
--- a/example-specs/task/nipype/freesurfer/glm_fit.yaml
+++ b/example-specs/task/nipype/freesurfer/glm_fit.yaml
@@ -55,6 +55,9 @@ inputs:
     # type=file|default=<undefined>: weight for each input at each voxel
     weighted_ls: generic/file
     # type=file|default=<undefined>: weighted least squares
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/glm_fit_callables.py b/example-specs/task/nipype/freesurfer/glm_fit_callables.py
index b738898f..12981d63 100644
--- a/example-specs/task/nipype/freesurfer/glm_fit_callables.py
+++ b/example-specs/task/nipype/freesurfer/glm_fit_callables.py
@@ -1,8 +1,8 @@
 """Module to put any functions that are referred to in the "callables" section of GLMFit.yaml"""
 
-import os
-import attrs
 import os.path as op
+import attrs
+import os
 
 
 def glm_dir_default(inputs):
diff --git a/example-specs/task/nipype/freesurfer/gtm_seg.yaml b/example-specs/task/nipype/freesurfer/gtm_seg.yaml
index e5b68fc0..9b533db5 100644
--- a/example-specs/task/nipype/freesurfer/gtm_seg.yaml
+++ b/example-specs/task/nipype/freesurfer/gtm_seg.yaml
@@ -35,6 +35,9 @@ inputs:
     # type=file|default='gtmseg.mgz': output volume relative to subject/mri
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/gtmpvc.yaml b/example-specs/task/nipype/freesurfer/gtmpvc.yaml
index 5b32ebc6..a3a23ced 100644
--- a/example-specs/task/nipype/freesurfer/gtmpvc.yaml
+++ b/example-specs/task/nipype/freesurfer/gtmpvc.yaml
@@ -61,6 +61,9 @@ inputs:
     # type=file|default=<undefined>: segfile : anatomical segmentation to define regions for GTM
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/gtmpvc_callables.py b/example-specs/task/nipype/freesurfer/gtmpvc_callables.py
index 2216c632..81c7e065 100644
--- a/example-specs/task/nipype/freesurfer/gtmpvc_callables.py
+++ b/example-specs/task/nipype/freesurfer/gtmpvc_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of GTMPVC.yaml"""
 
-import os
 import attrs
+import os
 
 
 def pvc_dir_default(inputs):
diff --git a/example-specs/task/nipype/freesurfer/image_info.yaml b/example-specs/task/nipype/freesurfer/image_info.yaml
index 199af399..9e2c025a 100644
--- a/example-specs/task/nipype/freesurfer/image_info.yaml
+++ b/example-specs/task/nipype/freesurfer/image_info.yaml
@@ -24,6 +24,9 @@ inputs:
     # type=file|default=<undefined>: image to query
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/image_info_callables.py b/example-specs/task/nipype/freesurfer/image_info_callables.py
index ad69c856..a0766f45 100644
--- a/example-specs/task/nipype/freesurfer/image_info_callables.py
+++ b/example-specs/task/nipype/freesurfer/image_info_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of ImageInfo.yaml"""
 
-import os
+import logging
 import os.path as op
 import attrs
-import logging
+import os
 
 
 def info_callable(output_dir, inputs, stdout, stderr):
@@ -86,6 +86,16 @@ def ph_enc_dir_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/freesurfer/jacobian.yaml b/example-specs/task/nipype/freesurfer/jacobian.yaml
index 495a1b0b..9ef02846 100644
--- a/example-specs/task/nipype/freesurfer/jacobian.yaml
+++ b/example-specs/task/nipype/freesurfer/jacobian.yaml
@@ -40,6 +40,9 @@ inputs:
     # type=file|default=<undefined>: Output Jacobian of the surface mapping
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/label_2_annot.yaml b/example-specs/task/nipype/freesurfer/label_2_annot.yaml
index 07da90e7..ea454c64 100644
--- a/example-specs/task/nipype/freesurfer/label_2_annot.yaml
+++ b/example-specs/task/nipype/freesurfer/label_2_annot.yaml
@@ -40,6 +40,9 @@ inputs:
     # type=file|default=<undefined>: implicit {hemisphere}.orig
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/label_2_label.yaml b/example-specs/task/nipype/freesurfer/label_2_label.yaml
index 18289854..7b76aa46 100644
--- a/example-specs/task/nipype/freesurfer/label_2_label.yaml
+++ b/example-specs/task/nipype/freesurfer/label_2_label.yaml
@@ -60,6 +60,9 @@ inputs:
     # type=directory|default=<undefined>: subjects directory
     white: medimage-freesurfer/pial
     # type=file|default=<undefined>: Implicit input <hemisphere>.white
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/label_2_vol.yaml b/example-specs/task/nipype/freesurfer/label_2_vol.yaml
index 792e9bf0..37b2cdb4 100644
--- a/example-specs/task/nipype/freesurfer/label_2_vol.yaml
+++ b/example-specs/task/nipype/freesurfer/label_2_vol.yaml
@@ -49,6 +49,9 @@ inputs:
     vol_label_file: Path
     # type=file: output volume
     # type=file|default=<undefined>: output volume
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/label_2_vol_callables.py b/example-specs/task/nipype/freesurfer/label_2_vol_callables.py
index ce9da230..1b3538d6 100644
--- a/example-specs/task/nipype/freesurfer/label_2_vol_callables.py
+++ b/example-specs/task/nipype/freesurfer/label_2_vol_callables.py
@@ -1,8 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of Label2Vol.yaml"""
 
-import os
-import attrs
+from pathlib import Path
 import os.path as op
+import attrs
+import os
 
 
 def vol_label_file_default(inputs):
diff --git a/example-specs/task/nipype/freesurfer/logan_ref.yaml b/example-specs/task/nipype/freesurfer/logan_ref.yaml
index 05219af1..2e4c1679 100644
--- a/example-specs/task/nipype/freesurfer/logan_ref.yaml
+++ b/example-specs/task/nipype/freesurfer/logan_ref.yaml
@@ -54,6 +54,9 @@ inputs:
     # type=file|default=<undefined>: weight for each input at each voxel
     weighted_ls: generic/file
     # type=file|default=<undefined>: weighted least squares
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/logan_ref_callables.py b/example-specs/task/nipype/freesurfer/logan_ref_callables.py
index e4dbf7a1..98ae11a9 100644
--- a/example-specs/task/nipype/freesurfer/logan_ref_callables.py
+++ b/example-specs/task/nipype/freesurfer/logan_ref_callables.py
@@ -1,8 +1,8 @@
 """Module to put any functions that are referred to in the "callables" section of LoganRef.yaml"""
 
-import os
-import attrs
 import os.path as op
+import attrs
+import os
 
 
 def glm_dir_default(inputs):
diff --git a/example-specs/task/nipype/freesurfer/lta_convert.yaml b/example-specs/task/nipype/freesurfer/lta_convert.yaml
index 2735f875..64dee1bc 100644
--- a/example-specs/task/nipype/freesurfer/lta_convert.yaml
+++ b/example-specs/task/nipype/freesurfer/lta_convert.yaml
@@ -40,6 +40,9 @@ inputs:
     # type=file|default=<undefined>: 
     target_file: generic/file
     # type=file|default=<undefined>: 
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/make_average_subject.yaml b/example-specs/task/nipype/freesurfer/make_average_subject.yaml
index cb703b5c..3e10edbc 100644
--- a/example-specs/task/nipype/freesurfer/make_average_subject.yaml
+++ b/example-specs/task/nipype/freesurfer/make_average_subject.yaml
@@ -34,6 +34,9 @@ inputs:
     # type=file|default='average': name for the average subject
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/make_surfaces.yaml b/example-specs/task/nipype/freesurfer/make_surfaces.yaml
index f59aeb08..af45fac6 100644
--- a/example-specs/task/nipype/freesurfer/make_surfaces.yaml
+++ b/example-specs/task/nipype/freesurfer/make_surfaces.yaml
@@ -61,6 +61,9 @@ inputs:
     # type=file|default=<undefined>: Specify a white surface to start with
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/make_surfaces_callables.py b/example-specs/task/nipype/freesurfer/make_surfaces_callables.py
index 36df4e15..b38f90ac 100644
--- a/example-specs/task/nipype/freesurfer/make_surfaces_callables.py
+++ b/example-specs/task/nipype/freesurfer/make_surfaces_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of MakeSurfaces.yaml"""
 
-import os
 import attrs
+import os
 
 
 def out_white_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/freesurfer/mni_bias_correction.yaml b/example-specs/task/nipype/freesurfer/mni_bias_correction.yaml
index 8b626ba6..421d0f5c 100644
--- a/example-specs/task/nipype/freesurfer/mni_bias_correction.yaml
+++ b/example-specs/task/nipype/freesurfer/mni_bias_correction.yaml
@@ -57,6 +57,9 @@ inputs:
     # type=directory|default=<undefined>: subjects directory
     transform: generic/file
     # type=file|default=<undefined>: tal.xfm. Use mri_make_uchar instead of conforming
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/mni_bias_correction_callables.py b/example-specs/task/nipype/freesurfer/mni_bias_correction_callables.py
index ab790a4a..e956cdd8 100644
--- a/example-specs/task/nipype/freesurfer/mni_bias_correction_callables.py
+++ b/example-specs/task/nipype/freesurfer/mni_bias_correction_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of MNIBiasCorrection.yaml"""
 
-import os
+import logging
 import os.path as op
 import attrs
-import logging
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +16,16 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/freesurfer/mp_rto_mni305.yaml b/example-specs/task/nipype/freesurfer/mp_rto_mni305.yaml
index 13b24260..9ce30dca 100644
--- a/example-specs/task/nipype/freesurfer/mp_rto_mni305.yaml
+++ b/example-specs/task/nipype/freesurfer/mp_rto_mni305.yaml
@@ -46,6 +46,9 @@ inputs:
     # type=directory|default='': TODO
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/mp_rto_mni305_callables.py b/example-specs/task/nipype/freesurfer/mp_rto_mni305_callables.py
index 786db1bf..6051bb60 100644
--- a/example-specs/task/nipype/freesurfer/mp_rto_mni305_callables.py
+++ b/example-specs/task/nipype/freesurfer/mp_rto_mni305_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of MPRtoMNI305.yaml"""
 
-import os
 import os.path as op
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/freesurfer/mr_is_ca_label.yaml b/example-specs/task/nipype/freesurfer/mr_is_ca_label.yaml
index 9b0930e4..bc35ea7e 100644
--- a/example-specs/task/nipype/freesurfer/mr_is_ca_label.yaml
+++ b/example-specs/task/nipype/freesurfer/mr_is_ca_label.yaml
@@ -63,6 +63,9 @@ inputs:
     # type=directory|default=<undefined>: subjects directory
     sulc: medimage-freesurfer/pial
     # type=file|default=<undefined>: implicit input {hemisphere}.sulc
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/mr_is_calc.yaml b/example-specs/task/nipype/freesurfer/mr_is_calc.yaml
index f3c7ec97..28a9a0d7 100644
--- a/example-specs/task/nipype/freesurfer/mr_is_calc.yaml
+++ b/example-specs/task/nipype/freesurfer/mr_is_calc.yaml
@@ -51,6 +51,9 @@ inputs:
     # type=file|default=<undefined>: Output file after calculation
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/mr_is_combine.yaml b/example-specs/task/nipype/freesurfer/mr_is_combine.yaml
index ee0e71a6..13d4483f 100644
--- a/example-specs/task/nipype/freesurfer/mr_is_combine.yaml
+++ b/example-specs/task/nipype/freesurfer/mr_is_combine.yaml
@@ -50,6 +50,9 @@ inputs:
     # type=file|default=<undefined>: Output filename. Combined surfaces from in_files.
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/mr_is_convert.yaml b/example-specs/task/nipype/freesurfer/mr_is_convert.yaml
index d7038b32..cdf8f3ab 100644
--- a/example-specs/task/nipype/freesurfer/mr_is_convert.yaml
+++ b/example-specs/task/nipype/freesurfer/mr_is_convert.yaml
@@ -49,6 +49,11 @@ inputs:
     # type=file|default=<undefined>: input is scalar curv overlay file (must still specify surface)
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
+    out_file: out_file_default
+    # type=file|default=<undefined>: output filename or True to generate one
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -67,8 +72,6 @@ outputs:
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
-    out_file: out_file_callable
-    # type=file|default=<undefined>: output filename or True to generate one
   templates:
   # dict[str, str] - `output_file_template` values to be provided to output fields
   requirements:
diff --git a/example-specs/task/nipype/freesurfer/mr_is_convert_callables.py b/example-specs/task/nipype/freesurfer/mr_is_convert_callables.py
index 0391d40f..61c26c82 100644
--- a/example-specs/task/nipype/freesurfer/mr_is_convert_callables.py
+++ b/example-specs/task/nipype/freesurfer/mr_is_convert_callables.py
@@ -1,8 +1,8 @@
 """Module to put any functions that are referred to in the "callables" section of MRIsConvert.yaml"""
 
-import os
-import attrs
 import os.path as op
+import attrs
+import os
 
 
 def out_file_default(inputs):
diff --git a/example-specs/task/nipype/freesurfer/mr_is_expand.yaml b/example-specs/task/nipype/freesurfer/mr_is_expand.yaml
index 49d36df2..ed473360 100644
--- a/example-specs/task/nipype/freesurfer/mr_is_expand.yaml
+++ b/example-specs/task/nipype/freesurfer/mr_is_expand.yaml
@@ -38,6 +38,9 @@ inputs:
     # type=file|default=<undefined>: Surface to expand
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/mr_is_inflate.yaml b/example-specs/task/nipype/freesurfer/mr_is_inflate.yaml
index 3bcbb4c3..ca9cbe35 100644
--- a/example-specs/task/nipype/freesurfer/mr_is_inflate.yaml
+++ b/example-specs/task/nipype/freesurfer/mr_is_inflate.yaml
@@ -41,6 +41,9 @@ inputs:
     # type=file|default=<undefined>: Output sulc file
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/mri_convert.yaml b/example-specs/task/nipype/freesurfer/mri_convert.yaml
index c4a5dab5..462e6087 100644
--- a/example-specs/task/nipype/freesurfer/mri_convert.yaml
+++ b/example-specs/task/nipype/freesurfer/mri_convert.yaml
@@ -58,6 +58,9 @@ inputs:
     # type=file|default=<undefined>: status file for DICOM conversion
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/mri_convert_callables.py b/example-specs/task/nipype/freesurfer/mri_convert_callables.py
index 7c8b0a3f..40a19d73 100644
--- a/example-specs/task/nipype/freesurfer/mri_convert_callables.py
+++ b/example-specs/task/nipype/freesurfer/mri_convert_callables.py
@@ -1,9 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of MRIConvert.yaml"""
 
-import os
+from pathlib import Path
+import os.path as op
 from nibabel.loadsave import load
 import attrs
-import os.path as op
+import os
 
 
 def out_file_default(inputs):
diff --git a/example-specs/task/nipype/freesurfer/mri_coreg.yaml b/example-specs/task/nipype/freesurfer/mri_coreg.yaml
index 9abcc938..bfed9616 100644
--- a/example-specs/task/nipype/freesurfer/mri_coreg.yaml
+++ b/example-specs/task/nipype/freesurfer/mri_coreg.yaml
@@ -59,6 +59,9 @@ inputs:
     # type=file|default=<undefined>: source file to be registered
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: FreeSurfer SUBJECTS_DIR
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/mri_coreg_callables.py b/example-specs/task/nipype/freesurfer/mri_coreg_callables.py
index 5fb95e94..81461d76 100644
--- a/example-specs/task/nipype/freesurfer/mri_coreg_callables.py
+++ b/example-specs/task/nipype/freesurfer/mri_coreg_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of MRICoreg.yaml"""
 
-import os
 import attrs
+import os
 
 
 def out_reg_file_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/freesurfer/mri_fill.yaml b/example-specs/task/nipype/freesurfer/mri_fill.yaml
index 0cb8f88b..840d1330 100644
--- a/example-specs/task/nipype/freesurfer/mri_fill.yaml
+++ b/example-specs/task/nipype/freesurfer/mri_fill.yaml
@@ -46,6 +46,9 @@ inputs:
     # type=directory|default=<undefined>: subjects directory
     transform: generic/file
     # type=file|default=<undefined>: Input transform file for MRIFill
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/mri_fill_callables.py b/example-specs/task/nipype/freesurfer/mri_fill_callables.py
index f5f3f3b4..f0280586 100644
--- a/example-specs/task/nipype/freesurfer/mri_fill_callables.py
+++ b/example-specs/task/nipype/freesurfer/mri_fill_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of MRIFill.yaml"""
 
-import os
 import attrs
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/freesurfer/mri_marching_cubes.yaml b/example-specs/task/nipype/freesurfer/mri_marching_cubes.yaml
index 40d9bd47..a81ebcc2 100644
--- a/example-specs/task/nipype/freesurfer/mri_marching_cubes.yaml
+++ b/example-specs/task/nipype/freesurfer/mri_marching_cubes.yaml
@@ -38,6 +38,11 @@ inputs:
     # type=file|default=<undefined>: output filename or True to generate one
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
+    out_file: out_file_default
+    # type=file|default=<undefined>: output filename or True to generate one
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -56,8 +61,6 @@ outputs:
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
-    out_file: out_file_callable
-    # type=file|default=<undefined>: output filename or True to generate one
   templates:
   # dict[str, str] - `output_file_template` values to be provided to output fields
   requirements:
diff --git a/example-specs/task/nipype/freesurfer/mri_marching_cubes_callables.py b/example-specs/task/nipype/freesurfer/mri_marching_cubes_callables.py
index 0635a75d..bc7475a7 100644
--- a/example-specs/task/nipype/freesurfer/mri_marching_cubes_callables.py
+++ b/example-specs/task/nipype/freesurfer/mri_marching_cubes_callables.py
@@ -1,8 +1,8 @@
 """Module to put any functions that are referred to in the "callables" section of MRIMarchingCubes.yaml"""
 
-import os
-import attrs
 import os.path as op
+import attrs
+import os
 
 
 def out_file_default(inputs):
diff --git a/example-specs/task/nipype/freesurfer/mri_pretess.yaml b/example-specs/task/nipype/freesurfer/mri_pretess.yaml
index f34b20a5..31d1f7d7 100644
--- a/example-specs/task/nipype/freesurfer/mri_pretess.yaml
+++ b/example-specs/task/nipype/freesurfer/mri_pretess.yaml
@@ -47,6 +47,9 @@ inputs:
     # type=file|default=<undefined>: the output file after mri_pretess.
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/mri_pretess_callables.py b/example-specs/task/nipype/freesurfer/mri_pretess_callables.py
index 3385c8b6..4aee90b2 100644
--- a/example-specs/task/nipype/freesurfer/mri_pretess_callables.py
+++ b/example-specs/task/nipype/freesurfer/mri_pretess_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of MRIPretess.yaml"""
 
-import os
+import logging
 import os.path as op
 import attrs
-import logging
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +16,16 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/freesurfer/mri_tessellate.yaml b/example-specs/task/nipype/freesurfer/mri_tessellate.yaml
index b516a7f2..cfec799c 100644
--- a/example-specs/task/nipype/freesurfer/mri_tessellate.yaml
+++ b/example-specs/task/nipype/freesurfer/mri_tessellate.yaml
@@ -38,6 +38,11 @@ inputs:
     # type=file|default=<undefined>: output filename or True to generate one
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
+    out_file: out_file_default
+    # type=file|default=<undefined>: output filename or True to generate one
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -56,8 +61,6 @@ outputs:
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
-    out_file: out_file_callable
-    # type=file|default=<undefined>: output filename or True to generate one
   templates:
   # dict[str, str] - `output_file_template` values to be provided to output fields
   requirements:
diff --git a/example-specs/task/nipype/freesurfer/mri_tessellate_callables.py b/example-specs/task/nipype/freesurfer/mri_tessellate_callables.py
index c36564a9..bd722f38 100644
--- a/example-specs/task/nipype/freesurfer/mri_tessellate_callables.py
+++ b/example-specs/task/nipype/freesurfer/mri_tessellate_callables.py
@@ -1,8 +1,8 @@
 """Module to put any functions that are referred to in the "callables" section of MRITessellate.yaml"""
 
-import os
-import attrs
 import os.path as op
+import attrs
+import os
 
 
 def out_file_default(inputs):
diff --git a/example-specs/task/nipype/freesurfer/mris_preproc.yaml b/example-specs/task/nipype/freesurfer/mris_preproc.yaml
index fb7afc3a..8dba105c 100644
--- a/example-specs/task/nipype/freesurfer/mris_preproc.yaml
+++ b/example-specs/task/nipype/freesurfer/mris_preproc.yaml
@@ -44,6 +44,9 @@ inputs:
     # type=directory|default=<undefined>: subjects directory
     surf_measure_file: generic/file+list-of
     # type=inputmultiobject|default=[]: file alternative to surfmeas, still requires list of subjects
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/mris_preproc_callables.py b/example-specs/task/nipype/freesurfer/mris_preproc_callables.py
index 934e086e..0838bc29 100644
--- a/example-specs/task/nipype/freesurfer/mris_preproc_callables.py
+++ b/example-specs/task/nipype/freesurfer/mris_preproc_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of MRISPreproc.yaml"""
 
-import os
 import attrs
+import os
 
 
 def out_file_default(inputs):
diff --git a/example-specs/task/nipype/freesurfer/mris_preproc_recon_all.yaml b/example-specs/task/nipype/freesurfer/mris_preproc_recon_all.yaml
index dd26feb3..f475db2e 100644
--- a/example-specs/task/nipype/freesurfer/mris_preproc_recon_all.yaml
+++ b/example-specs/task/nipype/freesurfer/mris_preproc_recon_all.yaml
@@ -49,6 +49,9 @@ inputs:
     # type=file|default=<undefined>: file necessary for surfmeas
     surfreg_files: generic/file+list-of
     # type=inputmultiobject|default=[]: lh and rh input surface registration files
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/mris_preproc_recon_all_callables.py b/example-specs/task/nipype/freesurfer/mris_preproc_recon_all_callables.py
index 024f4f1a..2cd221bb 100644
--- a/example-specs/task/nipype/freesurfer/mris_preproc_recon_all_callables.py
+++ b/example-specs/task/nipype/freesurfer/mris_preproc_recon_all_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of MRISPreprocReconAll.yaml"""
 
-import os
 import attrs
+import os
 
 
 def out_file_default(inputs):
diff --git a/example-specs/task/nipype/freesurfer/mrtm.yaml b/example-specs/task/nipype/freesurfer/mrtm.yaml
index a8a3b4d0..73756894 100644
--- a/example-specs/task/nipype/freesurfer/mrtm.yaml
+++ b/example-specs/task/nipype/freesurfer/mrtm.yaml
@@ -55,6 +55,9 @@ inputs:
     # type=file|default=<undefined>: weight for each input at each voxel
     weighted_ls: generic/file
     # type=file|default=<undefined>: weighted least squares
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/mrtm2.yaml b/example-specs/task/nipype/freesurfer/mrtm2.yaml
index 1e84f44f..4150c4b0 100644
--- a/example-specs/task/nipype/freesurfer/mrtm2.yaml
+++ b/example-specs/task/nipype/freesurfer/mrtm2.yaml
@@ -54,6 +54,9 @@ inputs:
     # type=file|default=<undefined>: weight for each input at each voxel
     weighted_ls: generic/file
     # type=file|default=<undefined>: weighted least squares
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/mrtm2_callables.py b/example-specs/task/nipype/freesurfer/mrtm2_callables.py
index 5eda3372..e9bda75c 100644
--- a/example-specs/task/nipype/freesurfer/mrtm2_callables.py
+++ b/example-specs/task/nipype/freesurfer/mrtm2_callables.py
@@ -1,8 +1,8 @@
 """Module to put any functions that are referred to in the "callables" section of MRTM2.yaml"""
 
-import os
-import attrs
 import os.path as op
+import attrs
+import os
 
 
 def glm_dir_default(inputs):
diff --git a/example-specs/task/nipype/freesurfer/mrtm_callables.py b/example-specs/task/nipype/freesurfer/mrtm_callables.py
index 2691dc9b..e359005e 100644
--- a/example-specs/task/nipype/freesurfer/mrtm_callables.py
+++ b/example-specs/task/nipype/freesurfer/mrtm_callables.py
@@ -1,8 +1,8 @@
 """Module to put any functions that are referred to in the "callables" section of MRTM.yaml"""
 
-import os
-import attrs
 import os.path as op
+import attrs
+import os
 
 
 def glm_dir_default(inputs):
diff --git a/example-specs/task/nipype/freesurfer/ms__lda.yaml b/example-specs/task/nipype/freesurfer/ms__lda.yaml
index 5848ae13..5cb56ade 100644
--- a/example-specs/task/nipype/freesurfer/ms__lda.yaml
+++ b/example-specs/task/nipype/freesurfer/ms__lda.yaml
@@ -45,6 +45,9 @@ inputs:
     weight_file: Path
     # type=file: 
     # type=file|default=<undefined>: filename for the LDA weights (input or output)
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/ms__lda_callables.py b/example-specs/task/nipype/freesurfer/ms__lda_callables.py
index 41b18e86..a5434bf6 100644
--- a/example-specs/task/nipype/freesurfer/ms__lda_callables.py
+++ b/example-specs/task/nipype/freesurfer/ms__lda_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of MS_LDA.yaml"""
 
-import os
 import attrs
+import os
 
 
 def weight_file_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/freesurfer/normalize.yaml b/example-specs/task/nipype/freesurfer/normalize.yaml
index ca908368..9fd7b237 100644
--- a/example-specs/task/nipype/freesurfer/normalize.yaml
+++ b/example-specs/task/nipype/freesurfer/normalize.yaml
@@ -46,6 +46,9 @@ inputs:
     # type=directory|default=<undefined>: subjects directory
     transform: generic/file
     # type=file|default=<undefined>: Transform file from the header of the input file
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/one_sample_t_test.yaml b/example-specs/task/nipype/freesurfer/one_sample_t_test.yaml
index e313b817..a92ef111 100644
--- a/example-specs/task/nipype/freesurfer/one_sample_t_test.yaml
+++ b/example-specs/task/nipype/freesurfer/one_sample_t_test.yaml
@@ -45,6 +45,9 @@ inputs:
     # type=file|default=<undefined>: weight for each input at each voxel
     weighted_ls: generic/file
     # type=file|default=<undefined>: weighted least squares
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/one_sample_t_test_callables.py b/example-specs/task/nipype/freesurfer/one_sample_t_test_callables.py
index 5b504cee..731b5299 100644
--- a/example-specs/task/nipype/freesurfer/one_sample_t_test_callables.py
+++ b/example-specs/task/nipype/freesurfer/one_sample_t_test_callables.py
@@ -1,8 +1,8 @@
 """Module to put any functions that are referred to in the "callables" section of OneSampleTTest.yaml"""
 
-import os
-import attrs
 import os.path as op
+import attrs
+import os
 
 
 def glm_dir_default(inputs):
diff --git a/example-specs/task/nipype/freesurfer/paint.yaml b/example-specs/task/nipype/freesurfer/paint.yaml
index ab9c160a..13450840 100644
--- a/example-specs/task/nipype/freesurfer/paint.yaml
+++ b/example-specs/task/nipype/freesurfer/paint.yaml
@@ -46,6 +46,9 @@ inputs:
     # type=directory|default=<undefined>: subjects directory
     template: medimage/mgh-gz
     # type=file|default=<undefined>: Template file
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/parcellation_stats.yaml b/example-specs/task/nipype/freesurfer/parcellation_stats.yaml
index 327ff2cc..94c84b8f 100644
--- a/example-specs/task/nipype/freesurfer/parcellation_stats.yaml
+++ b/example-specs/task/nipype/freesurfer/parcellation_stats.yaml
@@ -81,6 +81,9 @@ inputs:
     # type=file|default=<undefined>: Input file must be <subject_id>/mri/transforms/talairach.xfm
     wm: medimage/mgh-gz
     # type=file|default=<undefined>: Input file must be <subject_id>/mri/wm.mgz
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/parcellation_stats_callables.py b/example-specs/task/nipype/freesurfer/parcellation_stats_callables.py
index d28dc7b6..c8385f54 100644
--- a/example-specs/task/nipype/freesurfer/parcellation_stats_callables.py
+++ b/example-specs/task/nipype/freesurfer/parcellation_stats_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of ParcellationStats.yaml"""
 
-import os
 import attrs
+import os
 
 
 def out_table_default(inputs):
diff --git a/example-specs/task/nipype/freesurfer/parse_dicom_dir.yaml b/example-specs/task/nipype/freesurfer/parse_dicom_dir.yaml
index 306e22e1..e534cf0a 100644
--- a/example-specs/task/nipype/freesurfer/parse_dicom_dir.yaml
+++ b/example-specs/task/nipype/freesurfer/parse_dicom_dir.yaml
@@ -40,6 +40,9 @@ inputs:
     # type=file|default='dicominfo.txt': file to which results are written
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/parse_dicom_dir_callables.py b/example-specs/task/nipype/freesurfer/parse_dicom_dir_callables.py
index 1c123cd4..f1020a22 100644
--- a/example-specs/task/nipype/freesurfer/parse_dicom_dir_callables.py
+++ b/example-specs/task/nipype/freesurfer/parse_dicom_dir_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of ParseDICOMDir.yaml"""
 
-import os
 import attrs
+import os
 
 
 def dicom_info_file_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/freesurfer/recon_all.yaml b/example-specs/task/nipype/freesurfer/recon_all.yaml
index 33021c67..1e460283 100644
--- a/example-specs/task/nipype/freesurfer/recon_all.yaml
+++ b/example-specs/task/nipype/freesurfer/recon_all.yaml
@@ -83,6 +83,9 @@ inputs:
     subjects_dir: Path
     # type=directory: Freesurfer subjects directory.
     # type=directory|default=<undefined>: path to subjects directory
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/register.yaml b/example-specs/task/nipype/freesurfer/register.yaml
index 5ceda4f7..8290675e 100644
--- a/example-specs/task/nipype/freesurfer/register.yaml
+++ b/example-specs/task/nipype/freesurfer/register.yaml
@@ -47,6 +47,9 @@ inputs:
     # type=directory|default=<undefined>: subjects directory
     target: medimage/mgh-gz
     # type=file|default=<undefined>: The data to register to. In normal recon-all usage, this is a template file for average surface.
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/register_av_ito_talairach.yaml b/example-specs/task/nipype/freesurfer/register_av_ito_talairach.yaml
index 15c2d982..fca71c21 100644
--- a/example-specs/task/nipype/freesurfer/register_av_ito_talairach.yaml
+++ b/example-specs/task/nipype/freesurfer/register_av_ito_talairach.yaml
@@ -55,6 +55,9 @@ inputs:
     # type=file|default=<undefined>: The target file
     vox2vox: text/text-file
     # type=file|default=<undefined>: The vox2vox file
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/register_callables.py b/example-specs/task/nipype/freesurfer/register_callables.py
index 3681fa67..321e501c 100644
--- a/example-specs/task/nipype/freesurfer/register_callables.py
+++ b/example-specs/task/nipype/freesurfer/register_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of Register.yaml"""
 
-import os
 import attrs
+import os
 
 
 def out_file_default(inputs):
diff --git a/example-specs/task/nipype/freesurfer/relabel_hypointensities.yaml b/example-specs/task/nipype/freesurfer/relabel_hypointensities.yaml
index c3fef856..9446c782 100644
--- a/example-specs/task/nipype/freesurfer/relabel_hypointensities.yaml
+++ b/example-specs/task/nipype/freesurfer/relabel_hypointensities.yaml
@@ -46,6 +46,9 @@ inputs:
     # type=directory|default=<undefined>: subjects directory
     surf_directory: generic/directory
     # type=directory|default='.': Directory containing lh.white and rh.white
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/remove_intersection.yaml b/example-specs/task/nipype/freesurfer/remove_intersection.yaml
index a0760ca5..1fb2b8d7 100644
--- a/example-specs/task/nipype/freesurfer/remove_intersection.yaml
+++ b/example-specs/task/nipype/freesurfer/remove_intersection.yaml
@@ -37,6 +37,9 @@ inputs:
     # type=file|default=<undefined>: Output file for RemoveIntersection
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/remove_neck.yaml b/example-specs/task/nipype/freesurfer/remove_neck.yaml
index 28708b7f..39d7b5ca 100644
--- a/example-specs/task/nipype/freesurfer/remove_neck.yaml
+++ b/example-specs/task/nipype/freesurfer/remove_neck.yaml
@@ -44,6 +44,9 @@ inputs:
     # type=file|default=<undefined>: Input template file for RemoveNeck
     transform: datascience/text-matrix
     # type=file|default=<undefined>: Input transform file for RemoveNeck
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/resample.yaml b/example-specs/task/nipype/freesurfer/resample.yaml
index 4976c93c..15c6481c 100644
--- a/example-specs/task/nipype/freesurfer/resample.yaml
+++ b/example-specs/task/nipype/freesurfer/resample.yaml
@@ -40,6 +40,9 @@ inputs:
     # type=file|default=<undefined>: output filename
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/resample_callables.py b/example-specs/task/nipype/freesurfer/resample_callables.py
index 71e48035..29883c93 100644
--- a/example-specs/task/nipype/freesurfer/resample_callables.py
+++ b/example-specs/task/nipype/freesurfer/resample_callables.py
@@ -1,7 +1,8 @@
 """Module to put any functions that are referred to in the "callables" section of Resample.yaml"""
 
-import attrs
+from pathlib import Path
 import os.path as op
+import attrs
 
 
 def resampled_file_default(inputs):
diff --git a/example-specs/task/nipype/freesurfer/robust_register.yaml b/example-specs/task/nipype/freesurfer/robust_register.yaml
index 2e68f678..11217c66 100644
--- a/example-specs/task/nipype/freesurfer/robust_register.yaml
+++ b/example-specs/task/nipype/freesurfer/robust_register.yaml
@@ -51,6 +51,9 @@ inputs:
     # type=directory|default=<undefined>: subjects directory
     target_file: medimage/nifti1
     # type=file|default=<undefined>: target volume for the registration
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/robust_register_callables.py b/example-specs/task/nipype/freesurfer/robust_register_callables.py
index dd59414c..f6604d22 100644
--- a/example-specs/task/nipype/freesurfer/robust_register_callables.py
+++ b/example-specs/task/nipype/freesurfer/robust_register_callables.py
@@ -1,7 +1,8 @@
 """Module to put any functions that are referred to in the "callables" section of RobustRegister.yaml"""
 
-import os
 import os.path as op
+from pathlib import Path
+import os
 
 
 def out_reg_file_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/freesurfer/robust_template.yaml b/example-specs/task/nipype/freesurfer/robust_template.yaml
index 41ef08ea..14d42b67 100644
--- a/example-specs/task/nipype/freesurfer/robust_template.yaml
+++ b/example-specs/task/nipype/freesurfer/robust_template.yaml
@@ -68,6 +68,9 @@ inputs:
     # type=file|default='mri_robust_template_out.mgz': output template volume (final mean/median image)
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/robust_template_callables.py b/example-specs/task/nipype/freesurfer/robust_template_callables.py
index 850904da..db1e2f14 100644
--- a/example-specs/task/nipype/freesurfer/robust_template_callables.py
+++ b/example-specs/task/nipype/freesurfer/robust_template_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of RobustTemplate.yaml"""
 
-import os
 import attrs
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/freesurfer/sample_to_surface.yaml b/example-specs/task/nipype/freesurfer/sample_to_surface.yaml
index 41dbc3d0..8480e191 100644
--- a/example-specs/task/nipype/freesurfer/sample_to_surface.yaml
+++ b/example-specs/task/nipype/freesurfer/sample_to_surface.yaml
@@ -61,6 +61,9 @@ inputs:
     # type=file|default=<undefined>: volume to sample values from
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/sample_to_surface_callables.py b/example-specs/task/nipype/freesurfer/sample_to_surface_callables.py
index 4e8ed3a1..15507d52 100644
--- a/example-specs/task/nipype/freesurfer/sample_to_surface_callables.py
+++ b/example-specs/task/nipype/freesurfer/sample_to_surface_callables.py
@@ -1,8 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of SampleToSurface.yaml"""
 
-import os
-import attrs
+from pathlib import Path
 import os.path as op
+import attrs
+import os
 
 
 def out_file_default(inputs):
diff --git a/example-specs/task/nipype/freesurfer/seg_stats.yaml b/example-specs/task/nipype/freesurfer/seg_stats.yaml
index 072d3f8f..1d776c13 100644
--- a/example-specs/task/nipype/freesurfer/seg_stats.yaml
+++ b/example-specs/task/nipype/freesurfer/seg_stats.yaml
@@ -55,6 +55,9 @@ inputs:
     summary_file: Path
     # type=file: Segmentation summary statistics table
     # type=file|default=<undefined>: Segmentation stats summary table file
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/seg_stats_callables.py b/example-specs/task/nipype/freesurfer/seg_stats_callables.py
index afaee3a6..d82c36cb 100644
--- a/example-specs/task/nipype/freesurfer/seg_stats_callables.py
+++ b/example-specs/task/nipype/freesurfer/seg_stats_callables.py
@@ -1,8 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of SegStats.yaml"""
 
-import os
-import attrs
+from pathlib import Path
 import os.path as op
+import attrs
+import os
 
 
 def summary_file_default(inputs):
diff --git a/example-specs/task/nipype/freesurfer/seg_stats_recon_all.yaml b/example-specs/task/nipype/freesurfer/seg_stats_recon_all.yaml
index a21e3add..53f82c5c 100644
--- a/example-specs/task/nipype/freesurfer/seg_stats_recon_all.yaml
+++ b/example-specs/task/nipype/freesurfer/seg_stats_recon_all.yaml
@@ -97,6 +97,9 @@ inputs:
     # type=file|default=<undefined>: Segmentation stats summary table file
     transform: datascience/text-matrix
     # type=file|default=<undefined>: Input transform file
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/seg_stats_recon_all_callables.py b/example-specs/task/nipype/freesurfer/seg_stats_recon_all_callables.py
index 0658160a..7706d394 100644
--- a/example-specs/task/nipype/freesurfer/seg_stats_recon_all_callables.py
+++ b/example-specs/task/nipype/freesurfer/seg_stats_recon_all_callables.py
@@ -1,8 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of SegStatsReconAll.yaml"""
 
-import os
-import attrs
+from pathlib import Path
 import os.path as op
+import attrs
+import os
 
 
 def summary_file_default(inputs):
diff --git a/example-specs/task/nipype/freesurfer/segment_cc.yaml b/example-specs/task/nipype/freesurfer/segment_cc.yaml
index 32da9287..f02a9eb1 100644
--- a/example-specs/task/nipype/freesurfer/segment_cc.yaml
+++ b/example-specs/task/nipype/freesurfer/segment_cc.yaml
@@ -52,6 +52,9 @@ inputs:
     # type=file|default=<undefined>: Global filepath for writing rotation lta
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/segment_wm.yaml b/example-specs/task/nipype/freesurfer/segment_wm.yaml
index 92c294a5..c0de8828 100644
--- a/example-specs/task/nipype/freesurfer/segment_wm.yaml
+++ b/example-specs/task/nipype/freesurfer/segment_wm.yaml
@@ -41,6 +41,9 @@ inputs:
     # type=file|default=<undefined>: File to be written as output for SegmentWM
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/smooth.yaml b/example-specs/task/nipype/freesurfer/smooth.yaml
index bf4a54a1..83884a4a 100644
--- a/example-specs/task/nipype/freesurfer/smooth.yaml
+++ b/example-specs/task/nipype/freesurfer/smooth.yaml
@@ -48,6 +48,9 @@ inputs:
     # type=file|default=<undefined>: output volume
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/smooth_callables.py b/example-specs/task/nipype/freesurfer/smooth_callables.py
index d645f421..afe077d2 100644
--- a/example-specs/task/nipype/freesurfer/smooth_callables.py
+++ b/example-specs/task/nipype/freesurfer/smooth_callables.py
@@ -1,7 +1,8 @@
 """Module to put any functions that are referred to in the "callables" section of Smooth.yaml"""
 
-import attrs
+from pathlib import Path
 import os.path as op
+import attrs
 
 
 def smoothed_file_default(inputs):
diff --git a/example-specs/task/nipype/freesurfer/smooth_tessellation.yaml b/example-specs/task/nipype/freesurfer/smooth_tessellation.yaml
index 3aca79a1..408bb92a 100644
--- a/example-specs/task/nipype/freesurfer/smooth_tessellation.yaml
+++ b/example-specs/task/nipype/freesurfer/smooth_tessellation.yaml
@@ -45,6 +45,11 @@ inputs:
     # type=file|default=<undefined>: output filename or True to generate one
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
+    out_file: out_file_default
+    # type=file|default=<undefined>: output filename or True to generate one
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -63,8 +68,6 @@ outputs:
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
-    out_file: out_file_callable
-    # type=file|default=<undefined>: output filename or True to generate one
   templates:
   # dict[str, str] - `output_file_template` values to be provided to output fields
   requirements:
diff --git a/example-specs/task/nipype/freesurfer/smooth_tessellation_callables.py b/example-specs/task/nipype/freesurfer/smooth_tessellation_callables.py
index 9936647e..3bf1b5d6 100644
--- a/example-specs/task/nipype/freesurfer/smooth_tessellation_callables.py
+++ b/example-specs/task/nipype/freesurfer/smooth_tessellation_callables.py
@@ -1,8 +1,8 @@
 """Module to put any functions that are referred to in the "callables" section of SmoothTessellation.yaml"""
 
-import os
-import attrs
 import os.path as op
+import attrs
+import os
 
 
 def out_file_default(inputs):
diff --git a/example-specs/task/nipype/freesurfer/sphere.yaml b/example-specs/task/nipype/freesurfer/sphere.yaml
index 128ca016..26e27c07 100644
--- a/example-specs/task/nipype/freesurfer/sphere.yaml
+++ b/example-specs/task/nipype/freesurfer/sphere.yaml
@@ -39,6 +39,9 @@ inputs:
     # type=file|default=<undefined>: Output file for Sphere
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/spherical_average.yaml b/example-specs/task/nipype/freesurfer/spherical_average.yaml
index 04a8406e..0926bb7b 100644
--- a/example-specs/task/nipype/freesurfer/spherical_average.yaml
+++ b/example-specs/task/nipype/freesurfer/spherical_average.yaml
@@ -50,6 +50,11 @@ inputs:
     # type=file|default=<undefined>: Output filename
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
+    in_average: in_average_default
+    # type=directory|default=<undefined>: Average subject
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -69,8 +74,6 @@ outputs:
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
-    in_average: in_average_callable
-    # type=directory|default=<undefined>: Average subject
   templates:
   # dict[str, str] - `output_file_template` values to be provided to output fields
     out_file: '"test.out"'
diff --git a/example-specs/task/nipype/freesurfer/spherical_average_callables.py b/example-specs/task/nipype/freesurfer/spherical_average_callables.py
index 225d0557..4253966a 100644
--- a/example-specs/task/nipype/freesurfer/spherical_average_callables.py
+++ b/example-specs/task/nipype/freesurfer/spherical_average_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of SphericalAverage.yaml"""
 
-import os
 import attrs
+import os
 
 
 def out_file_default(inputs):
diff --git a/example-specs/task/nipype/freesurfer/surface_2_vol_transform.yaml b/example-specs/task/nipype/freesurfer/surface_2_vol_transform.yaml
index e8b18003..5490ad6b 100644
--- a/example-specs/task/nipype/freesurfer/surface_2_vol_transform.yaml
+++ b/example-specs/task/nipype/freesurfer/surface_2_vol_transform.yaml
@@ -48,6 +48,9 @@ inputs:
     vertexvol_file: Path
     # type=file: vertex map volume path id. Optional
     # type=file|default=<undefined>: Path name of the vertex output volume, which is the same as output volume except that the value of each voxel is the vertex-id that is mapped to that voxel.
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/surface_2_vol_transform_callables.py b/example-specs/task/nipype/freesurfer/surface_2_vol_transform_callables.py
index 14ba6392..3c0aae1d 100644
--- a/example-specs/task/nipype/freesurfer/surface_2_vol_transform_callables.py
+++ b/example-specs/task/nipype/freesurfer/surface_2_vol_transform_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of Surface2VolTransform.yaml"""
 
-import os
+import logging
 import os.path as op
 import attrs
-import logging
+import os
 
 
 def transformed_file_callable(output_dir, inputs, stdout, stderr):
@@ -23,6 +23,16 @@ def vertexvol_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/freesurfer/surface_smooth.yaml b/example-specs/task/nipype/freesurfer/surface_smooth.yaml
index 35eed358..eb3ac37a 100644
--- a/example-specs/task/nipype/freesurfer/surface_smooth.yaml
+++ b/example-specs/task/nipype/freesurfer/surface_smooth.yaml
@@ -52,6 +52,9 @@ inputs:
     # type=file|default=<undefined>: surface file to write
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/surface_smooth_callables.py b/example-specs/task/nipype/freesurfer/surface_smooth_callables.py
index 2e51d3bc..6bdcf9cf 100644
--- a/example-specs/task/nipype/freesurfer/surface_smooth_callables.py
+++ b/example-specs/task/nipype/freesurfer/surface_smooth_callables.py
@@ -1,7 +1,8 @@
 """Module to put any functions that are referred to in the "callables" section of SurfaceSmooth.yaml"""
 
-import attrs
+from pathlib import Path
 import os.path as op
+import attrs
 
 
 def out_file_default(inputs):
diff --git a/example-specs/task/nipype/freesurfer/surface_snapshots.yaml b/example-specs/task/nipype/freesurfer/surface_snapshots.yaml
index 7165db7f..31c1f362 100644
--- a/example-specs/task/nipype/freesurfer/surface_snapshots.yaml
+++ b/example-specs/task/nipype/freesurfer/surface_snapshots.yaml
@@ -60,6 +60,11 @@ inputs:
     # type=directory|default=<undefined>: subjects directory
     tcl_script: Path
     # type=file|default=<undefined>: override default screenshot script
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
+    tcl_script: tcl_script_default
+    # type=file|default=<undefined>: override default screenshot script
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -78,8 +83,6 @@ outputs:
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
-    tcl_script: tcl_script_callable
-    # type=file|default=<undefined>: override default screenshot script
   templates:
   # dict[str, str] - `output_file_template` values to be provided to output fields
   requirements:
diff --git a/example-specs/task/nipype/freesurfer/surface_snapshots_callables.py b/example-specs/task/nipype/freesurfer/surface_snapshots_callables.py
index 33e8ca6d..98cf1d20 100644
--- a/example-specs/task/nipype/freesurfer/surface_snapshots_callables.py
+++ b/example-specs/task/nipype/freesurfer/surface_snapshots_callables.py
@@ -1,7 +1,8 @@
 """Module to put any functions that are referred to in the "callables" section of SurfaceSnapshots.yaml"""
 
-import attrs
+from pathlib import Path
 import os.path as op
+import attrs
 
 
 def tcl_script_default(inputs):
diff --git a/example-specs/task/nipype/freesurfer/surface_transform.yaml b/example-specs/task/nipype/freesurfer/surface_transform.yaml
index deb32790..bb24de3e 100644
--- a/example-specs/task/nipype/freesurfer/surface_transform.yaml
+++ b/example-specs/task/nipype/freesurfer/surface_transform.yaml
@@ -46,6 +46,9 @@ inputs:
     # type=file|default=<undefined>: surface file with source values
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/surface_transform_callables.py b/example-specs/task/nipype/freesurfer/surface_transform_callables.py
index 66831f96..96c0ae27 100644
--- a/example-specs/task/nipype/freesurfer/surface_transform_callables.py
+++ b/example-specs/task/nipype/freesurfer/surface_transform_callables.py
@@ -1,8 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of SurfaceTransform.yaml"""
 
-import os
-import attrs
+from pathlib import Path
 import os.path as op
+import attrs
+import os
 
 
 def out_file_default(inputs):
diff --git a/example-specs/task/nipype/freesurfer/synthesize_flash.yaml b/example-specs/task/nipype/freesurfer/synthesize_flash.yaml
index 38e5bc97..90691c2a 100644
--- a/example-specs/task/nipype/freesurfer/synthesize_flash.yaml
+++ b/example-specs/task/nipype/freesurfer/synthesize_flash.yaml
@@ -41,6 +41,9 @@ inputs:
     # type=directory|default=<undefined>: subjects directory
     t1_image: medimage/mgh-gz
     # type=file|default=<undefined>: image of T1 values
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/synthesize_flash_callables.py b/example-specs/task/nipype/freesurfer/synthesize_flash_callables.py
index f24024e8..34da4035 100644
--- a/example-specs/task/nipype/freesurfer/synthesize_flash_callables.py
+++ b/example-specs/task/nipype/freesurfer/synthesize_flash_callables.py
@@ -1,7 +1,8 @@
 """Module to put any functions that are referred to in the "callables" section of SynthesizeFLASH.yaml"""
 
-import attrs
+from pathlib import Path
 import os.path as op
+import attrs
 
 
 def out_file_default(inputs):
diff --git a/example-specs/task/nipype/freesurfer/talairach_avi.yaml b/example-specs/task/nipype/freesurfer/talairach_avi.yaml
index 4a09eef7..33d19d45 100644
--- a/example-specs/task/nipype/freesurfer/talairach_avi.yaml
+++ b/example-specs/task/nipype/freesurfer/talairach_avi.yaml
@@ -45,6 +45,9 @@ inputs:
     # type=file|default=<undefined>: output xfm file
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/talairach_qc.yaml b/example-specs/task/nipype/freesurfer/talairach_qc.yaml
index 611eb0a9..bf3984d6 100644
--- a/example-specs/task/nipype/freesurfer/talairach_qc.yaml
+++ b/example-specs/task/nipype/freesurfer/talairach_qc.yaml
@@ -34,6 +34,9 @@ inputs:
     # type=file|default=<undefined>: The log file for TalairachQC
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/tkregister_2.yaml b/example-specs/task/nipype/freesurfer/tkregister_2.yaml
index 0e511783..f1ae047f 100644
--- a/example-specs/task/nipype/freesurfer/tkregister_2.yaml
+++ b/example-specs/task/nipype/freesurfer/tkregister_2.yaml
@@ -64,6 +64,9 @@ inputs:
     # type=file|default=<undefined>: target volume
     xfm: generic/file
     # type=file|default=<undefined>: use a matrix in MNI coordinates as initial registration
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/tkregister_2_callables.py b/example-specs/task/nipype/freesurfer/tkregister_2_callables.py
index a3e3995d..91fe8fcf 100644
--- a/example-specs/task/nipype/freesurfer/tkregister_2_callables.py
+++ b/example-specs/task/nipype/freesurfer/tkregister_2_callables.py
@@ -1,8 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of Tkregister2.yaml"""
 
-import os
-import attrs
+from pathlib import Path
 import os.path as op
+import attrs
+import os
 
 
 def reg_file_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/freesurfer/unpack_sdicom_dir.yaml b/example-specs/task/nipype/freesurfer/unpack_sdicom_dir.yaml
index 1f6e69f5..e3fab34a 100644
--- a/example-specs/task/nipype/freesurfer/unpack_sdicom_dir.yaml
+++ b/example-specs/task/nipype/freesurfer/unpack_sdicom_dir.yaml
@@ -50,6 +50,9 @@ inputs:
     # type=directory|default=<undefined>: directory with the DICOM files
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/unpack_sdicom_dir_callables.py b/example-specs/task/nipype/freesurfer/unpack_sdicom_dir_callables.py
index 8ffc7493..bcb6650f 100644
--- a/example-specs/task/nipype/freesurfer/unpack_sdicom_dir_callables.py
+++ b/example-specs/task/nipype/freesurfer/unpack_sdicom_dir_callables.py
@@ -1,13 +1,23 @@
 """Module to put any functions that are referred to in the "callables" section of UnpackSDICOMDir.yaml"""
 
-import os
+import logging
 import os.path as op
 import attrs
-import logging
+import os
 
 iflogger = logging.getLogger("nipype.interface")
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/freesurfer/volume_mask.yaml b/example-specs/task/nipype/freesurfer/volume_mask.yaml
index 53297484..b911c25c 100644
--- a/example-specs/task/nipype/freesurfer/volume_mask.yaml
+++ b/example-specs/task/nipype/freesurfer/volume_mask.yaml
@@ -59,6 +59,9 @@ inputs:
     # type=file|default=<undefined>: Implicit input right white matter surface
     subjects_dir: generic/directory
     # type=directory|default=<undefined>: subjects directory
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/freesurfer/watershed_skull_strip.yaml b/example-specs/task/nipype/freesurfer/watershed_skull_strip.yaml
index 76b9a9f7..eea42ee6 100644
--- a/example-specs/task/nipype/freesurfer/watershed_skull_strip.yaml
+++ b/example-specs/task/nipype/freesurfer/watershed_skull_strip.yaml
@@ -54,6 +54,9 @@ inputs:
     # type=directory|default=<undefined>: subjects directory
     transform: medimage-freesurfer/lta
     # type=file|default=<undefined>: undocumented
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/accuracy_tester.yaml b/example-specs/task/nipype/fsl/accuracy_tester.yaml
index 571881d0..54388d14 100644
--- a/example-specs/task/nipype/fsl/accuracy_tester.yaml
+++ b/example-specs/task/nipype/fsl/accuracy_tester.yaml
@@ -30,6 +30,9 @@ inputs:
     # type=directory|default=<undefined>: Path to folder in which to store the results of the accuracy test.
     trained_wts_file: generic/file
     # type=file|default=<undefined>: trained-weights file
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/accuracy_tester_callables.py b/example-specs/task/nipype/fsl/accuracy_tester_callables.py
index 15a082cf..6ad99bac 100644
--- a/example-specs/task/nipype/fsl/accuracy_tester_callables.py
+++ b/example-specs/task/nipype/fsl/accuracy_tester_callables.py
@@ -1,5 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of AccuracyTester.yaml"""
 
+from fileformats.generic import Directory
+from traits.trait_errors import TraitError
+from pathlib import Path
+from traits.trait_type import TraitType
+from traits.trait_base import _Undefined
 import attrs
 
 
@@ -10,10 +15,153 @@ def output_directory_callable(output_dir, inputs, stdout, stderr):
     return outputs["output_directory"]
 
 
+Undefined = _Undefined()
+
+
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+class BasePath(TraitType):
+    """Defines a trait whose value must be a valid filesystem path."""
+
+    # A description of the type of value this trait accepts:
+    exists = False
+    resolve = False
+    _is_file = False
+    _is_dir = False
+
+    @property
+    def info_text(self):
+        """Create the trait's general description."""
+        info_text = "a pathlike object or string"
+        if any((self.exists, self._is_file, self._is_dir)):
+            info_text += " representing a"
+            if self.exists:
+                info_text += "n existing"
+            if self._is_file:
+                info_text += " file"
+            elif self._is_dir:
+                info_text += " directory"
+            else:
+                info_text += " file or directory"
+        return info_text
+
+    def __init__(self, value=attrs.NOTHING, exists=False, resolve=False, **metadata):
+        """Create a BasePath trait."""
+        self.exists = exists
+        self.resolve = resolve
+        super(BasePath, self).__init__(value, **metadata)
+
+    def validate(self, objekt, name, value, return_pathlike=False):
+        """Validate a value change."""
+        try:
+            value = Path(value)  # Use pathlib's validation
+        except Exception:
+            self.error(objekt, name, str(value))
+
+        if self.exists:
+            if not value.exists():
+                self.error(objekt, name, str(value))
+
+            if self._is_file and not value.is_file():
+                self.error(objekt, name, str(value))
+
+            if self._is_dir and not value.is_dir():
+                self.error(objekt, name, str(value))
+
+        if self.resolve:
+            value = path_resolve(value, strict=self.exists)
+
+        if not return_pathlike:
+            value = str(value)
+
+        return value
+
+
+class Directory(BasePath):
+    """
+    Defines a trait whose value must be a directory path.
+
+    >>> from nipype.interfaces.base import Directory, TraitedSpec, TraitError
+    >>> class A(TraitedSpec):
+    ...     foo = Directory(exists=False)
+    >>> a = A()
+    >>> a.foo
+    <undefined>
+
+    >>> a.foo = '/some/made/out/path'
+    >>> a.foo
+    '/some/made/out/path'
+
+    >>> class A(TraitedSpec):
+    ...     foo = Directory(exists=False, resolve=True)
+    >>> a = A(foo='relative_dir')
+    >>> a.foo  # doctest: +ELLIPSIS
+    '.../relative_dir'
+
+    >>> class A(TraitedSpec):
+    ...     foo = Directory(exists=True, resolve=True)
+    >>> a = A()
+    >>> a.foo = 'relative_dir'  # doctest: +IGNORE_EXCEPTION_DETAIL
+    Traceback (most recent call last):
+    TraitError:
+
+    >>> from os import mkdir
+    >>> mkdir('relative_dir')
+    >>> a.foo = 'relative_dir'
+    >>> a.foo  # doctest: +ELLIPSIS
+    '.../relative_dir'
+
+    >>> class A(TraitedSpec):
+    ...     foo = Directory(exists=True, resolve=False)
+    >>> a = A(foo='relative_dir')
+    >>> a.foo
+    'relative_dir'
+
+    >>> class A(TraitedSpec):
+    ...     foo = Directory('tmpdir')
+    >>> a = A()
+    >>> a.foo  # doctest: +ELLIPSIS
+    <undefined>
+
+    >>> class A(TraitedSpec):
+    ...     foo = Directory('tmpdir', usedefault=True)
+    >>> a = A()
+    >>> a.foo  # doctest: +ELLIPSIS
+    'tmpdir'
+
+    """
+
+    _is_dir = True
+
+
+def path_resolve(path, strict=False):
+    try:
+        return _resolve_with_filenotfound(path, strict=strict)
+    except TypeError:  # PY35
+        pass
+
+    path = path.absolute()
+    if strict or path.exists():
+        return _resolve_with_filenotfound(path)
+
+    # This is a hacky shortcut, using path.absolute() unmodified
+    # In cases where the existing part of the path contains a
+    # symlink, different results will be produced
+    return path
+
+
+def _resolve_with_filenotfound(path, **kwargs):
+    """Raise FileNotFoundError instead of OSError"""
+    try:
+        return path.resolve(**kwargs)
+    except OSError as e:
+        if isinstance(e, FileNotFoundError):
+            raise
+        raise FileNotFoundError(str(path))
+
+
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     if inputs.output_directory is not attrs.NOTHING:
diff --git a/example-specs/task/nipype/fsl/apply_mask.yaml b/example-specs/task/nipype/fsl/apply_mask.yaml
index d2a24be6..53f7d018 100644
--- a/example-specs/task/nipype/fsl/apply_mask.yaml
+++ b/example-specs/task/nipype/fsl/apply_mask.yaml
@@ -27,6 +27,9 @@ inputs:
     out_file: Path
     # type=file: image written after calculations
     # type=file|default=<undefined>: image to write
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/apply_mask_callables.py b/example-specs/task/nipype/fsl/apply_mask_callables.py
index 4394f71d..145e3812 100644
--- a/example-specs/task/nipype/fsl/apply_mask_callables.py
+++ b/example-specs/task/nipype/fsl/apply_mask_callables.py
@@ -1,10 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of ApplyMask.yaml"""
 
-import os
-import attrs
-import os.path as op
-import logging
 from glob import glob
+import logging
+from pathlib import Path
+import os.path as op
+import attrs
+import os
 
 
 def out_file_default(inputs):
@@ -21,6 +22,43 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
diff --git a/example-specs/task/nipype/fsl/apply_topup.yaml b/example-specs/task/nipype/fsl/apply_topup.yaml
index 0addbf7a..3763901a 100644
--- a/example-specs/task/nipype/fsl/apply_topup.yaml
+++ b/example-specs/task/nipype/fsl/apply_topup.yaml
@@ -54,6 +54,9 @@ inputs:
     out_corrected: Path
     # type=file: name of 4D image file with unwarped images
     # type=file|default=<undefined>: output (warped) image
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/apply_topup_callables.py b/example-specs/task/nipype/fsl/apply_topup_callables.py
index 01af91c2..cca286ba 100644
--- a/example-specs/task/nipype/fsl/apply_topup_callables.py
+++ b/example-specs/task/nipype/fsl/apply_topup_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of ApplyTOPUP.yaml"""
 
-import os
-import attrs
-import os.path as op
 import logging
 from glob import glob
+import os.path as op
+import attrs
+import os
 
 
 def out_corrected_callable(output_dir, inputs, stdout, stderr):
@@ -14,10 +14,47 @@ def out_corrected_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_corrected"]
 
 
+iflogger = logging.getLogger("nipype.interface")
+
+
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
-iflogger = logging.getLogger("nipype.interface")
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
 
 
 class Info(PackageInfo):
@@ -118,6 +155,16 @@ def _overload_extension(
     return value + Info.output_type_to_ext(inputs.output_type)
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/fsl/apply_warp.yaml b/example-specs/task/nipype/fsl/apply_warp.yaml
index d722faef..08f921ef 100644
--- a/example-specs/task/nipype/fsl/apply_warp.yaml
+++ b/example-specs/task/nipype/fsl/apply_warp.yaml
@@ -48,6 +48,9 @@ inputs:
     # type=file|default=<undefined>: filename for pre-transform (affine matrix)
     ref_file: generic/file
     # type=file|default=<undefined>: reference image
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/apply_warp_callables.py b/example-specs/task/nipype/fsl/apply_warp_callables.py
index 893eb20b..d3326038 100644
--- a/example-specs/task/nipype/fsl/apply_warp_callables.py
+++ b/example-specs/task/nipype/fsl/apply_warp_callables.py
@@ -1,10 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of ApplyWarp.yaml"""
 
-import os
-import attrs
-import os.path as op
-import logging
 from glob import glob
+import logging
+from pathlib import Path
+import os.path as op
+import attrs
+import os
 
 
 def out_file_default(inputs):
@@ -21,6 +22,43 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
diff --git a/example-specs/task/nipype/fsl/apply_xfm.yaml b/example-specs/task/nipype/fsl/apply_xfm.yaml
index 21c8788f..ae9ca242 100644
--- a/example-specs/task/nipype/fsl/apply_xfm.yaml
+++ b/example-specs/task/nipype/fsl/apply_xfm.yaml
@@ -70,6 +70,9 @@ inputs:
     # type=file|default=<undefined>: white matter boundary coordinates for BBR cost function
     wmnorms: generic/file
     # type=file|default=<undefined>: white matter boundary normals for BBR cost function
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/apply_xfm_callables.py b/example-specs/task/nipype/fsl/apply_xfm_callables.py
index f84b64d5..7c76eb44 100644
--- a/example-specs/task/nipype/fsl/apply_xfm_callables.py
+++ b/example-specs/task/nipype/fsl/apply_xfm_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of ApplyXFM.yaml"""
 
-import os
-import attrs
-import os.path as op
 import logging
 from glob import glob
+import os.path as op
+import attrs
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -28,10 +28,47 @@ def out_log_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_log"]
 
 
+iflogger = logging.getLogger("nipype.interface")
+
+
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
-iflogger = logging.getLogger("nipype.interface")
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
 
 
 class Info(PackageInfo):
@@ -132,6 +169,16 @@ def _overload_extension(
     return value + Info.output_type_to_ext(inputs.output_type)
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/fsl/ar1_image.yaml b/example-specs/task/nipype/fsl/ar1_image.yaml
index 7bea654f..722dc9a2 100644
--- a/example-specs/task/nipype/fsl/ar1_image.yaml
+++ b/example-specs/task/nipype/fsl/ar1_image.yaml
@@ -28,6 +28,9 @@ inputs:
     out_file: Path
     # type=file: image written after calculations
     # type=file|default=<undefined>: image to write
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/ar1_image_callables.py b/example-specs/task/nipype/fsl/ar1_image_callables.py
index 6f761cde..1e6231d8 100644
--- a/example-specs/task/nipype/fsl/ar1_image_callables.py
+++ b/example-specs/task/nipype/fsl/ar1_image_callables.py
@@ -1,10 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of AR1Image.yaml"""
 
-import os
-import attrs
-import os.path as op
-import logging
 from glob import glob
+import logging
+from pathlib import Path
+import os.path as op
+import attrs
+import os
 
 
 def out_file_default(inputs):
@@ -21,6 +22,43 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
diff --git a/example-specs/task/nipype/fsl/av_scale.yaml b/example-specs/task/nipype/fsl/av_scale.yaml
index 49020e14..ca203626 100644
--- a/example-specs/task/nipype/fsl/av_scale.yaml
+++ b/example-specs/task/nipype/fsl/av_scale.yaml
@@ -34,6 +34,9 @@ inputs:
     # type=file|default=<undefined>: mat file to read
     ref_file: generic/file
     # type=file|default=<undefined>: reference file to get center of rotation
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/b0_calc.yaml b/example-specs/task/nipype/fsl/b0_calc.yaml
index 6235b9cd..bbcbe51b 100644
--- a/example-specs/task/nipype/fsl/b0_calc.yaml
+++ b/example-specs/task/nipype/fsl/b0_calc.yaml
@@ -42,6 +42,9 @@ inputs:
     out_file: Path
     # type=file: filename of B0 output volume
     # type=file|default=<undefined>: filename of B0 output volume
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/b0_calc_callables.py b/example-specs/task/nipype/fsl/b0_calc_callables.py
index 71dd1c42..d3116a5d 100644
--- a/example-specs/task/nipype/fsl/b0_calc_callables.py
+++ b/example-specs/task/nipype/fsl/b0_calc_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of B0Calc.yaml"""
 
-import os
-import attrs
-import os.path as op
 import logging
 from glob import glob
+import os.path as op
+import attrs
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -14,10 +14,47 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_file"]
 
 
+iflogger = logging.getLogger("nipype.interface")
+
+
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
-iflogger = logging.getLogger("nipype.interface")
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
 
 
 class Info(PackageInfo):
@@ -118,6 +155,16 @@ def _overload_extension(
     return value + Info.output_type_to_ext(inputs.output_type)
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/fsl/bedpostx5.yaml b/example-specs/task/nipype/fsl/bedpostx5.yaml
index d43927d0..5ac61639 100644
--- a/example-specs/task/nipype/fsl/bedpostx5.yaml
+++ b/example-specs/task/nipype/fsl/bedpostx5.yaml
@@ -57,6 +57,9 @@ inputs:
     # type=file|default=<undefined>: bet binary mask file
     out_dir: generic/directory
     # type=directory|default='bedpostx': output directory
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/bedpostx5_callables.py b/example-specs/task/nipype/fsl/bedpostx5_callables.py
index 31d37c11..986ad26c 100644
--- a/example-specs/task/nipype/fsl/bedpostx5_callables.py
+++ b/example-specs/task/nipype/fsl/bedpostx5_callables.py
@@ -1,9 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of BEDPOSTX5.yaml"""
 
-import os
 from glob import glob
-import os.path as op
 import logging
+from pathlib import Path
+import os.path as op
+import os
 
 
 def mean_dsamples_callable(output_dir, inputs, stdout, stderr):
@@ -79,6 +80,43 @@ def dyads_dispersion_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
diff --git a/example-specs/task/nipype/fsl/bet.yaml b/example-specs/task/nipype/fsl/bet.yaml
index 35b58d5d..b33740f2 100644
--- a/example-specs/task/nipype/fsl/bet.yaml
+++ b/example-specs/task/nipype/fsl/bet.yaml
@@ -43,6 +43,9 @@ inputs:
     # type=file|default=<undefined>: name of output skull stripped image
     t2_guided: generic/file
     # type=file|default=<undefined>: as with creating surfaces, when also feeding in non-brain-extracted T2 (includes registrations)
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/bet_callables.py b/example-specs/task/nipype/fsl/bet_callables.py
index 752f0a51..6dd47111 100644
--- a/example-specs/task/nipype/fsl/bet_callables.py
+++ b/example-specs/task/nipype/fsl/bet_callables.py
@@ -1,10 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of BET.yaml"""
 
-import os
-import attrs
-import os.path as op
 import logging
+from pathlib import Path
 from glob import glob
+import os.path as op
+import attrs
+import os
 
 
 def out_file_default(inputs):
@@ -98,6 +99,43 @@ def skull_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
diff --git a/example-specs/task/nipype/fsl/binary_maths.yaml b/example-specs/task/nipype/fsl/binary_maths.yaml
index c496039e..bd135d34 100644
--- a/example-specs/task/nipype/fsl/binary_maths.yaml
+++ b/example-specs/task/nipype/fsl/binary_maths.yaml
@@ -30,6 +30,9 @@ inputs:
     out_file: Path
     # type=file: image written after calculations
     # type=file|default=<undefined>: image to write
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/binary_maths_callables.py b/example-specs/task/nipype/fsl/binary_maths_callables.py
index 7ad73e1c..be3fdeea 100644
--- a/example-specs/task/nipype/fsl/binary_maths_callables.py
+++ b/example-specs/task/nipype/fsl/binary_maths_callables.py
@@ -1,10 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of BinaryMaths.yaml"""
 
-import os
-import attrs
-import os.path as op
-import logging
 from glob import glob
+import logging
+from pathlib import Path
+import os.path as op
+import attrs
+import os
 
 
 def out_file_default(inputs):
@@ -21,6 +22,43 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
diff --git a/example-specs/task/nipype/fsl/change_data_type.yaml b/example-specs/task/nipype/fsl/change_data_type.yaml
index 924e49cf..e1c6460d 100644
--- a/example-specs/task/nipype/fsl/change_data_type.yaml
+++ b/example-specs/task/nipype/fsl/change_data_type.yaml
@@ -25,6 +25,9 @@ inputs:
     out_file: Path
     # type=file: image written after calculations
     # type=file|default=<undefined>: image to write
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/change_data_type_callables.py b/example-specs/task/nipype/fsl/change_data_type_callables.py
index b7357aeb..4cc4ecfe 100644
--- a/example-specs/task/nipype/fsl/change_data_type_callables.py
+++ b/example-specs/task/nipype/fsl/change_data_type_callables.py
@@ -1,10 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of ChangeDataType.yaml"""
 
-import os
-import attrs
-import os.path as op
-import logging
 from glob import glob
+import logging
+from pathlib import Path
+import os.path as op
+import attrs
+import os
 
 
 def out_file_default(inputs):
@@ -21,6 +22,43 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
diff --git a/example-specs/task/nipype/fsl/classifier.yaml b/example-specs/task/nipype/fsl/classifier.yaml
index 25920b74..2b42cb02 100644
--- a/example-specs/task/nipype/fsl/classifier.yaml
+++ b/example-specs/task/nipype/fsl/classifier.yaml
@@ -29,6 +29,9 @@ inputs:
     # type=directory|default=<undefined>: Melodic output directory or directories
     trained_wts_file: generic/file
     # type=file|default=<undefined>: trained-weights file
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/cleaner.yaml b/example-specs/task/nipype/fsl/cleaner.yaml
index 177943ac..6be0935a 100644
--- a/example-specs/task/nipype/fsl/cleaner.yaml
+++ b/example-specs/task/nipype/fsl/cleaner.yaml
@@ -30,6 +30,9 @@ inputs:
     # type=file|default=<undefined>: Include additional confound file.
     confound_file_2: generic/file
     # type=file|default=<undefined>: Include additional confound file.
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/cluster.yaml b/example-specs/task/nipype/fsl/cluster.yaml
index 8fa634dd..3e651f7e 100644
--- a/example-specs/task/nipype/fsl/cluster.yaml
+++ b/example-specs/task/nipype/fsl/cluster.yaml
@@ -43,6 +43,9 @@ inputs:
     # type=file|default=<undefined>: file contining warpfield
     xfm_file: generic/file
     # type=file|default=<undefined>: filename for Linear: input->standard-space transform. Non-linear: input->highres transform
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/cluster_callables.py b/example-specs/task/nipype/fsl/cluster_callables.py
index 2cb9f8e8..4145ddbc 100644
--- a/example-specs/task/nipype/fsl/cluster_callables.py
+++ b/example-specs/task/nipype/fsl/cluster_callables.py
@@ -1,10 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of Cluster.yaml"""
 
-import os
-import attrs
-import os.path as op
-import logging
 from glob import glob
+import logging
+from pathlib import Path
+import os.path as op
+import attrs
+import os
 
 
 def index_file_callable(output_dir, inputs, stdout, stderr):
@@ -66,6 +67,43 @@ def pval_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
diff --git a/example-specs/task/nipype/fsl/complex.yaml b/example-specs/task/nipype/fsl/complex.yaml
index 0a239a53..19104469 100644
--- a/example-specs/task/nipype/fsl/complex.yaml
+++ b/example-specs/task/nipype/fsl/complex.yaml
@@ -58,6 +58,9 @@ inputs:
     real_out_file: Path
     # type=file: 
     # type=file|default=<undefined>: 
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/complex_callables.py b/example-specs/task/nipype/fsl/complex_callables.py
index 1d057ccc..bcae56c7 100644
--- a/example-specs/task/nipype/fsl/complex_callables.py
+++ b/example-specs/task/nipype/fsl/complex_callables.py
@@ -1,10 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of Complex.yaml"""
 
-import os
-import attrs
-import os.path as op
-import logging
 from glob import glob
+import logging
+from pathlib import Path
+import os.path as op
+import attrs
+import os
 
 
 def complex_out_file_default(inputs):
@@ -65,6 +66,43 @@ def complex_out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
diff --git a/example-specs/task/nipype/fsl/contrast_mgr.yaml b/example-specs/task/nipype/fsl/contrast_mgr.yaml
index 29242499..a3f5071f 100644
--- a/example-specs/task/nipype/fsl/contrast_mgr.yaml
+++ b/example-specs/task/nipype/fsl/contrast_mgr.yaml
@@ -37,6 +37,9 @@ inputs:
     # type=file|default=<undefined>: summary of residuals, See Woolrich, et. al., 2001
     tcon_file: generic/file
     # type=file|default=<undefined>: contrast file containing T-contrasts
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/contrast_mgr_callables.py b/example-specs/task/nipype/fsl/contrast_mgr_callables.py
index 3533fae6..b2aa487a 100644
--- a/example-specs/task/nipype/fsl/contrast_mgr_callables.py
+++ b/example-specs/task/nipype/fsl/contrast_mgr_callables.py
@@ -1,10 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of ContrastMgr.yaml"""
 
-import os
-import attrs
-import os.path as op
-import logging
 from glob import glob
+import logging
+from pathlib import Path
+import os.path as op
+import attrs
+import os
 
 
 def copes_callable(output_dir, inputs, stdout, stderr):
@@ -59,6 +60,43 @@ def neffs_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
diff --git a/example-specs/task/nipype/fsl/convert_warp.yaml b/example-specs/task/nipype/fsl/convert_warp.yaml
index 31c0eeb6..5fbd7a1a 100644
--- a/example-specs/task/nipype/fsl/convert_warp.yaml
+++ b/example-specs/task/nipype/fsl/convert_warp.yaml
@@ -55,6 +55,9 @@ inputs:
     # type=file|default=<undefined>: Name of file containing initial warp-fields/coefficients (follows premat). This could e.g. be a fnirt-transform from a subjects structural scan to an average of a group of subjects.
     warp2: generic/file
     # type=file|default=<undefined>: Name of file containing secondary warp-fields/coefficients (after warp1/midmat but before postmat). This could e.g. be a fnirt-transform from the average of a group of subjects to some standard space (e.g. MNI152).
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/convert_warp_callables.py b/example-specs/task/nipype/fsl/convert_warp_callables.py
index f7e68635..2be5d54b 100644
--- a/example-specs/task/nipype/fsl/convert_warp_callables.py
+++ b/example-specs/task/nipype/fsl/convert_warp_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of ConvertWarp.yaml"""
 
-import os
-import attrs
-import os.path as op
 import logging
 from glob import glob
+import os.path as op
+import attrs
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -14,10 +14,47 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_file"]
 
 
+iflogger = logging.getLogger("nipype.interface")
+
+
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
-iflogger = logging.getLogger("nipype.interface")
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
 
 
 class Info(PackageInfo):
@@ -118,6 +155,16 @@ def _overload_extension(
     return value + Info.output_type_to_ext(inputs.output_type)
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/fsl/convert_xfm.yaml b/example-specs/task/nipype/fsl/convert_xfm.yaml
index 7e83f4ad..cfd52113 100644
--- a/example-specs/task/nipype/fsl/convert_xfm.yaml
+++ b/example-specs/task/nipype/fsl/convert_xfm.yaml
@@ -41,6 +41,9 @@ inputs:
     out_file: Path
     # type=file: output transformation matrix
     # type=file|default=<undefined>: final transformation matrix
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/convert_xfm_callables.py b/example-specs/task/nipype/fsl/convert_xfm_callables.py
index 25c5fb87..d4b6f501 100644
--- a/example-specs/task/nipype/fsl/convert_xfm_callables.py
+++ b/example-specs/task/nipype/fsl/convert_xfm_callables.py
@@ -1,8 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of ConvertXFM.yaml"""
 
-import os
-import attrs
+from pathlib import Path
 import os.path as op
+import attrs
+import os
 
 
 def out_file_default(inputs):
diff --git a/example-specs/task/nipype/fsl/copy_geom.yaml b/example-specs/task/nipype/fsl/copy_geom.yaml
index c6e16e1b..677859c6 100644
--- a/example-specs/task/nipype/fsl/copy_geom.yaml
+++ b/example-specs/task/nipype/fsl/copy_geom.yaml
@@ -31,6 +31,9 @@ inputs:
     # type=file|default=<undefined>: destination image
     in_file: generic/file
     # type=file|default=<undefined>: source image
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/copy_geom_callables.py b/example-specs/task/nipype/fsl/copy_geom_callables.py
index 72844f07..bfa0c459 100644
--- a/example-specs/task/nipype/fsl/copy_geom_callables.py
+++ b/example-specs/task/nipype/fsl/copy_geom_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of CopyGeom.yaml"""
 
-import os
-import attrs
-import os.path as op
 import logging
 from glob import glob
+import os.path as op
+import attrs
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -14,10 +14,47 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_file"]
 
 
+iflogger = logging.getLogger("nipype.interface")
+
+
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
-iflogger = logging.getLogger("nipype.interface")
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
 
 
 class Info(PackageInfo):
@@ -118,6 +155,16 @@ def _overload_extension(
     return value + Info.output_type_to_ext(inputs.output_type)
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/fsl/dilate_image.yaml b/example-specs/task/nipype/fsl/dilate_image.yaml
index dafbfb82..5f29bf3c 100644
--- a/example-specs/task/nipype/fsl/dilate_image.yaml
+++ b/example-specs/task/nipype/fsl/dilate_image.yaml
@@ -27,6 +27,9 @@ inputs:
     out_file: Path
     # type=file: image written after calculations
     # type=file|default=<undefined>: image to write
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/dilate_image_callables.py b/example-specs/task/nipype/fsl/dilate_image_callables.py
index 9f107e78..fc31d3cf 100644
--- a/example-specs/task/nipype/fsl/dilate_image_callables.py
+++ b/example-specs/task/nipype/fsl/dilate_image_callables.py
@@ -1,10 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of DilateImage.yaml"""
 
-import os
-import attrs
-import os.path as op
-import logging
 from glob import glob
+import logging
+from pathlib import Path
+import os.path as op
+import attrs
+import os
 
 
 def out_file_default(inputs):
@@ -21,6 +22,43 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
diff --git a/example-specs/task/nipype/fsl/distance_map.yaml b/example-specs/task/nipype/fsl/distance_map.yaml
index 2bced5c8..d027bbdb 100644
--- a/example-specs/task/nipype/fsl/distance_map.yaml
+++ b/example-specs/task/nipype/fsl/distance_map.yaml
@@ -38,6 +38,9 @@ inputs:
     # type=file|default=<undefined>: image to calculate distance values for
     mask_file: generic/file
     # type=file|default=<undefined>: binary mask to constrain calculations
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/distance_map_callables.py b/example-specs/task/nipype/fsl/distance_map_callables.py
index 6715b468..171c41c8 100644
--- a/example-specs/task/nipype/fsl/distance_map_callables.py
+++ b/example-specs/task/nipype/fsl/distance_map_callables.py
@@ -1,8 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of DistanceMap.yaml"""
 
-import os
-import attrs
+from pathlib import Path
 import os.path as op
+import attrs
+import os
 
 
 def distance_map_default(inputs):
diff --git a/example-specs/task/nipype/fsl/dti_fit.yaml b/example-specs/task/nipype/fsl/dti_fit.yaml
index cd97a22e..ee0044ec 100644
--- a/example-specs/task/nipype/fsl/dti_fit.yaml
+++ b/example-specs/task/nipype/fsl/dti_fit.yaml
@@ -48,6 +48,9 @@ inputs:
     # type=file|default=<undefined>: gradient non linearities
     mask: medimage/nifti1
     # type=file|default=<undefined>: bet binary mask file
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/dti_fit_callables.py b/example-specs/task/nipype/fsl/dti_fit_callables.py
index 81cc530c..65e73892 100644
--- a/example-specs/task/nipype/fsl/dti_fit_callables.py
+++ b/example-specs/task/nipype/fsl/dti_fit_callables.py
@@ -1,10 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of DTIFit.yaml"""
 
-import os
-import attrs
-import os.path as op
-import logging
 from glob import glob
+import logging
+from pathlib import Path
+import os.path as op
+import attrs
+import os
 
 
 def V1_callable(output_dir, inputs, stdout, stderr):
@@ -94,6 +95,43 @@ def sse_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
diff --git a/example-specs/task/nipype/fsl/dual_regression.yaml b/example-specs/task/nipype/fsl/dual_regression.yaml
index ab6d490b..51b9625b 100644
--- a/example-specs/task/nipype/fsl/dual_regression.yaml
+++ b/example-specs/task/nipype/fsl/dual_regression.yaml
@@ -47,6 +47,9 @@ inputs:
     out_dir: Path
     # type=directory: 
     # type=directory|default='output': This directory will be created to hold all output and logfiles
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/dual_regression_callables.py b/example-specs/task/nipype/fsl/dual_regression_callables.py
index 649ac858..75a4a0cb 100644
--- a/example-specs/task/nipype/fsl/dual_regression_callables.py
+++ b/example-specs/task/nipype/fsl/dual_regression_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of DualRegression.yaml"""
 
-import os
 import attrs
+import os
 
 
 def out_dir_default(inputs):
diff --git a/example-specs/task/nipype/fsl/eddy.yaml b/example-specs/task/nipype/fsl/eddy.yaml
index ed6f5f73..1e4e2bd6 100644
--- a/example-specs/task/nipype/fsl/eddy.yaml
+++ b/example-specs/task/nipype/fsl/eddy.yaml
@@ -84,6 +84,9 @@ inputs:
     # type=file|default=<undefined>: File containing session indices for all volumes in --imain
     slice_order: text/text-file
     # type=file|default='': Name of text file completely specifying slice/group acquisition
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/eddy_callables.py b/example-specs/task/nipype/fsl/eddy_callables.py
index 38aed023..f1b30997 100644
--- a/example-specs/task/nipype/fsl/eddy_callables.py
+++ b/example-specs/task/nipype/fsl/eddy_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of Eddy.yaml"""
 
-import os
 import attrs
+import os
 
 
 def out_corrected_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/fsl/eddy_correct.yaml b/example-specs/task/nipype/fsl/eddy_correct.yaml
index 8afb9f66..bc60065e 100644
--- a/example-specs/task/nipype/fsl/eddy_correct.yaml
+++ b/example-specs/task/nipype/fsl/eddy_correct.yaml
@@ -38,6 +38,9 @@ inputs:
     # type=file|default=<undefined>: 4D input file
     out_file: Path
     # type=file|default=<undefined>: 4D output file
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/eddy_correct_callables.py b/example-specs/task/nipype/fsl/eddy_correct_callables.py
index 589587c9..74bba26e 100644
--- a/example-specs/task/nipype/fsl/eddy_correct_callables.py
+++ b/example-specs/task/nipype/fsl/eddy_correct_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of EddyCorrect.yaml"""
 
-import os
-import attrs
-import os.path as op
 import logging
 from glob import glob
+import os.path as op
+import attrs
+import os
 
 
 def eddy_corrected_callable(output_dir, inputs, stdout, stderr):
@@ -14,10 +14,47 @@ def eddy_corrected_callable(output_dir, inputs, stdout, stderr):
     return outputs["eddy_corrected"]
 
 
+iflogger = logging.getLogger("nipype.interface")
+
+
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
-iflogger = logging.getLogger("nipype.interface")
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
 
 
 class Info(PackageInfo):
@@ -118,6 +155,16 @@ def _overload_extension(
     return value + Info.output_type_to_ext(inputs.output_type)
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/fsl/eddy_quad.yaml b/example-specs/task/nipype/fsl/eddy_quad.yaml
index f20520b3..5889b2c3 100644
--- a/example-specs/task/nipype/fsl/eddy_quad.yaml
+++ b/example-specs/task/nipype/fsl/eddy_quad.yaml
@@ -57,6 +57,9 @@ inputs:
     # type=file|default=<undefined>: File containing acquisition parameters
     slice_spec: generic/file
     # type=file|default=<undefined>: Text file specifying slice/group acquisition
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/eddy_quad_callables.py b/example-specs/task/nipype/fsl/eddy_quad_callables.py
index 302c7a6b..ee314728 100644
--- a/example-specs/task/nipype/fsl/eddy_quad_callables.py
+++ b/example-specs/task/nipype/fsl/eddy_quad_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of EddyQuad.yaml"""
 
-import os
 import attrs
+import os
 
 
 def qc_json_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/fsl/epi_de_warp.yaml b/example-specs/task/nipype/fsl/epi_de_warp.yaml
index f91e8ef4..94e043d7 100644
--- a/example-specs/task/nipype/fsl/epi_de_warp.yaml
+++ b/example-specs/task/nipype/fsl/epi_de_warp.yaml
@@ -49,6 +49,13 @@ inputs:
     # type=file|default=<undefined>: example func volume (or use epi)
     mag_file: medimage/nifti1
     # type=file|default=<undefined>: Magnitude file
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
+    tmpdir: tmpdir_default
+    # type=string|default='': tmpdir
+    vsm: vsm_default
+    # type=string|default='': voxel shift map
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -74,10 +81,6 @@ outputs:
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
-    tmpdir: tmpdir_callable
-    # type=string|default='': tmpdir
-    vsm: vsm_callable
-    # type=string|default='': voxel shift map
   templates:
   # dict[str, str] - `output_file_template` values to be provided to output fields
     exfdw: exfdw
diff --git a/example-specs/task/nipype/fsl/epi_de_warp_callables.py b/example-specs/task/nipype/fsl/epi_de_warp_callables.py
index ebdd1fb6..32bdbd89 100644
--- a/example-specs/task/nipype/fsl/epi_de_warp_callables.py
+++ b/example-specs/task/nipype/fsl/epi_de_warp_callables.py
@@ -1,10 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of EPIDeWarp.yaml"""
 
-import os
-import attrs
-import os.path as op
-import logging
 from glob import glob
+import logging
+from pathlib import Path
+import os.path as op
+import attrs
+import os
 
 
 def vsm_default(inputs):
@@ -50,6 +51,43 @@ def exf_mask_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
diff --git a/example-specs/task/nipype/fsl/epi_reg.yaml b/example-specs/task/nipype/fsl/epi_reg.yaml
index 3e81104e..9f5ee15f 100644
--- a/example-specs/task/nipype/fsl/epi_reg.yaml
+++ b/example-specs/task/nipype/fsl/epi_reg.yaml
@@ -60,6 +60,9 @@ inputs:
     wmseg: Path
     # type=file: white matter segmentation used in flirt bbr
     # type=file|default=<undefined>: white matter segmentation of T1 image, has to be named                  like the t1brain and end on _wmseg
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/epi_reg_callables.py b/example-specs/task/nipype/fsl/epi_reg_callables.py
index 6b713816..eaa4a758 100644
--- a/example-specs/task/nipype/fsl/epi_reg_callables.py
+++ b/example-specs/task/nipype/fsl/epi_reg_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of EpiReg.yaml"""
 
-import os
 import attrs
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/fsl/erode_image.yaml b/example-specs/task/nipype/fsl/erode_image.yaml
index 943984c4..9bcb725e 100644
--- a/example-specs/task/nipype/fsl/erode_image.yaml
+++ b/example-specs/task/nipype/fsl/erode_image.yaml
@@ -27,6 +27,9 @@ inputs:
     out_file: Path
     # type=file: image written after calculations
     # type=file|default=<undefined>: image to write
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/erode_image_callables.py b/example-specs/task/nipype/fsl/erode_image_callables.py
index 56df727b..7da90653 100644
--- a/example-specs/task/nipype/fsl/erode_image_callables.py
+++ b/example-specs/task/nipype/fsl/erode_image_callables.py
@@ -1,10 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of ErodeImage.yaml"""
 
-import os
-import attrs
-import os.path as op
-import logging
 from glob import glob
+import logging
+from pathlib import Path
+import os.path as op
+import attrs
+import os
 
 
 def out_file_default(inputs):
@@ -21,6 +22,43 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
diff --git a/example-specs/task/nipype/fsl/extract_roi.yaml b/example-specs/task/nipype/fsl/extract_roi.yaml
index c7e9a156..510f7faa 100644
--- a/example-specs/task/nipype/fsl/extract_roi.yaml
+++ b/example-specs/task/nipype/fsl/extract_roi.yaml
@@ -48,6 +48,9 @@ inputs:
     roi_file: Path
     # type=file: 
     # type=file|default=<undefined>: output file
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/extract_roi_callables.py b/example-specs/task/nipype/fsl/extract_roi_callables.py
index ee547187..d551ef58 100644
--- a/example-specs/task/nipype/fsl/extract_roi_callables.py
+++ b/example-specs/task/nipype/fsl/extract_roi_callables.py
@@ -1,10 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of ExtractROI.yaml"""
 
-import os
-import attrs
-import os.path as op
-import logging
 from glob import glob
+import logging
+from pathlib import Path
+import os.path as op
+import attrs
+import os
 
 
 def roi_file_default(inputs):
@@ -21,6 +22,43 @@ def roi_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
diff --git a/example-specs/task/nipype/fsl/fast.yaml b/example-specs/task/nipype/fsl/fast.yaml
index 6378b4c9..46f3df50 100644
--- a/example-specs/task/nipype/fsl/fast.yaml
+++ b/example-specs/task/nipype/fsl/fast.yaml
@@ -45,6 +45,9 @@ inputs:
     # type=inputmultiobject|default=[]: alternative prior images
     out_basename: Path
     # type=file|default=<undefined>: base name of output files
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/fast_callables.py b/example-specs/task/nipype/fsl/fast_callables.py
index a2ec6c7f..e7836de6 100644
--- a/example-specs/task/nipype/fsl/fast_callables.py
+++ b/example-specs/task/nipype/fsl/fast_callables.py
@@ -1,10 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of FAST.yaml"""
 
-import os
-import attrs
-import os.path as op
-import logging
 from glob import glob
+import logging
+from pathlib import Path
+import os.path as op
+import attrs
+import os
 
 
 def tissue_class_map_callable(output_dir, inputs, stdout, stderr):
@@ -66,6 +67,43 @@ def probability_maps_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
diff --git a/example-specs/task/nipype/fsl/feat.yaml b/example-specs/task/nipype/fsl/feat.yaml
index 78cb408f..9bde3588 100644
--- a/example-specs/task/nipype/fsl/feat.yaml
+++ b/example-specs/task/nipype/fsl/feat.yaml
@@ -22,6 +22,9 @@ inputs:
   # passed to the field in the automatically generated unittests.
     fsf_file: generic/file
     # type=file|default=<undefined>: File specifying the feat design spec file
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/feat_callables.py b/example-specs/task/nipype/fsl/feat_callables.py
index 7ad7f7ac..acb17e86 100644
--- a/example-specs/task/nipype/fsl/feat_callables.py
+++ b/example-specs/task/nipype/fsl/feat_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of FEAT.yaml"""
 
-import os
 from glob import glob
+import os
 
 
 def feat_dir_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/fsl/feat_model.yaml b/example-specs/task/nipype/fsl/feat_model.yaml
index 27c52acb..430e8cea 100644
--- a/example-specs/task/nipype/fsl/feat_model.yaml
+++ b/example-specs/task/nipype/fsl/feat_model.yaml
@@ -24,6 +24,9 @@ inputs:
     # type=list|default=[]: Event spec files generated by level1design
     fsf_file: generic/file
     # type=file|default=<undefined>: File specifying the feat design spec file
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/feat_model_callables.py b/example-specs/task/nipype/fsl/feat_model_callables.py
index fd0bbdda..e139661e 100644
--- a/example-specs/task/nipype/fsl/feat_model_callables.py
+++ b/example-specs/task/nipype/fsl/feat_model_callables.py
@@ -1,8 +1,13 @@
 """Module to put any functions that are referred to in the "callables" section of FEATModel.yaml"""
 
-import os
+from fileformats.generic import Directory
+from traits.trait_errors import TraitError
+from pathlib import Path
+from fileformats.generic import File
 from glob import glob
-import logging
+from traits.trait_type import TraitType
+from traits.trait_base import _Undefined
+import os
 
 
 def design_file_callable(output_dir, inputs, stdout, stderr):
@@ -40,35 +45,287 @@ def fcon_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["fcon_file"]
 
 
-IFLOGGER = logging.getLogger("nipype.interface")
+Undefined = _Undefined()
+
+
+IMG_ZIP_FMT = set([".nii.gz", "tar.gz", ".gii.gz", ".mgz", ".mgh.gz", "img.gz"])
 
 
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
-class FSLCommandInputSpec(CommandLineInputSpec):
-    """
-    Base Input Specification for all FSL Commands
+class BasePath(TraitType):
+    """Defines a trait whose value must be a valid filesystem path."""
+
+    # A description of the type of value this trait accepts:
+    exists = False
+    resolve = False
+    _is_file = False
+    _is_dir = False
+
+    @property
+    def info_text(self):
+        """Create the trait's general description."""
+        info_text = "a pathlike object or string"
+        if any((self.exists, self._is_file, self._is_dir)):
+            info_text += " representing a"
+            if self.exists:
+                info_text += "n existing"
+            if self._is_file:
+                info_text += " file"
+            elif self._is_dir:
+                info_text += " directory"
+            else:
+                info_text += " file or directory"
+        return info_text
+
+    def __init__(self, value=attrs.NOTHING, exists=False, resolve=False, **metadata):
+        """Create a BasePath trait."""
+        self.exists = exists
+        self.resolve = resolve
+        super(BasePath, self).__init__(value, **metadata)
+
+    def validate(self, objekt, name, value, return_pathlike=False):
+        """Validate a value change."""
+        try:
+            value = Path(value)  # Use pathlib's validation
+        except Exception:
+            self.error(objekt, name, str(value))
+
+        if self.exists:
+            if not value.exists():
+                self.error(objekt, name, str(value))
 
-    All command support specifying FSLOUTPUTTYPE dynamically
-    via output_type.
+            if self._is_file and not value.is_file():
+                self.error(objekt, name, str(value))
+
+            if self._is_dir and not value.is_dir():
+                self.error(objekt, name, str(value))
+
+        if self.resolve:
+            value = path_resolve(value, strict=self.exists)
+
+        if not return_pathlike:
+            value = str(value)
+
+        return value
+
+
+class Directory(BasePath):
+    """
+    Defines a trait whose value must be a directory path.
+
+    >>> from nipype.interfaces.base import Directory, TraitedSpec, TraitError
+    >>> class A(TraitedSpec):
+    ...     foo = Directory(exists=False)
+    >>> a = A()
+    >>> a.foo
+    <undefined>
+
+    >>> a.foo = '/some/made/out/path'
+    >>> a.foo
+    '/some/made/out/path'
+
+    >>> class A(TraitedSpec):
+    ...     foo = Directory(exists=False, resolve=True)
+    >>> a = A(foo='relative_dir')
+    >>> a.foo  # doctest: +ELLIPSIS
+    '.../relative_dir'
+
+    >>> class A(TraitedSpec):
+    ...     foo = Directory(exists=True, resolve=True)
+    >>> a = A()
+    >>> a.foo = 'relative_dir'  # doctest: +IGNORE_EXCEPTION_DETAIL
+    Traceback (most recent call last):
+    TraitError:
+
+    >>> from os import mkdir
+    >>> mkdir('relative_dir')
+    >>> a.foo = 'relative_dir'
+    >>> a.foo  # doctest: +ELLIPSIS
+    '.../relative_dir'
+
+    >>> class A(TraitedSpec):
+    ...     foo = Directory(exists=True, resolve=False)
+    >>> a = A(foo='relative_dir')
+    >>> a.foo
+    'relative_dir'
+
+    >>> class A(TraitedSpec):
+    ...     foo = Directory('tmpdir')
+    >>> a = A()
+    >>> a.foo  # doctest: +ELLIPSIS
+    <undefined>
+
+    >>> class A(TraitedSpec):
+    ...     foo = Directory('tmpdir', usedefault=True)
+    >>> a = A()
+    >>> a.foo  # doctest: +ELLIPSIS
+    'tmpdir'
 
-    Example
-    -------
-    fsl.ExtractRoi(tmin=42, tsize=1, output_type='NIFTI')
     """
 
-    output_type = traits.Enum("NIFTI", list(Info.ftypes.keys()), desc="FSL output type")
+    _is_dir = True
 
 
-class TraitedSpec(BaseTraitedSpec):
-    """Create a subclass with strict traits.
+class File(BasePath):
+    """
+    Defines a trait whose value must be a file path.
+
+    >>> from nipype.interfaces.base import File, TraitedSpec, TraitError
+    >>> class A(TraitedSpec):
+    ...     foo = File()
+    >>> a = A()
+    >>> a.foo
+    <undefined>
+
+    >>> a.foo = '/some/made/out/path/to/file'
+    >>> a.foo
+    '/some/made/out/path/to/file'
+
+    >>> class A(TraitedSpec):
+    ...     foo = File(exists=False, resolve=True)
+    >>> a = A(foo='idontexist.txt')
+    >>> a.foo  # doctest: +ELLIPSIS
+    '.../idontexist.txt'
+
+    >>> class A(TraitedSpec):
+    ...     foo = File(exists=True, resolve=True)
+    >>> a = A()
+    >>> a.foo = 'idontexist.txt'  # doctest: +IGNORE_EXCEPTION_DETAIL
+    Traceback (most recent call last):
+    TraitError:
+
+    >>> open('idoexist.txt', 'w').close()
+    >>> a.foo = 'idoexist.txt'
+    >>> a.foo  # doctest: +ELLIPSIS
+    '.../idoexist.txt'
+
+    >>> class A(TraitedSpec):
+    ...     foo = File('idoexist.txt')
+    >>> a = A()
+    >>> a.foo
+    <undefined>
+
+    >>> class A(TraitedSpec):
+    ...     foo = File('idoexist.txt', usedefault=True)
+    >>> a = A()
+    >>> a.foo
+    'idoexist.txt'
+
+    >>> class A(TraitedSpec):
+    ...     foo = File(exists=True, resolve=True, extensions=['.txt', 'txt.gz'])
+    >>> a = A()
+    >>> a.foo = 'idoexist.badtxt'  # doctest: +IGNORE_EXCEPTION_DETAIL
+    Traceback (most recent call last):
+    TraitError:
+
+    >>> a.foo = 'idoexist.txt'
+    >>> a.foo  # doctest: +ELLIPSIS
+    '.../idoexist.txt'
+
+    >>> class A(TraitedSpec):
+    ...     foo = File(extensions=['.nii', '.nii.gz'])
+    >>> a = A()
+    >>> a.foo = 'badext.txt'  # doctest: +IGNORE_EXCEPTION_DETAIL
+    Traceback (most recent call last):
+    TraitError:
+
+    >>> class A(TraitedSpec):
+    ...     foo = File(extensions=['.nii', '.nii.gz'])
+    >>> a = A()
+    >>> a.foo = 'goodext.nii'
+    >>> a.foo
+    'goodext.nii'
+
+    >>> a = A()
+    >>> a.foo = 'idontexist.000.nii'
+    >>> a.foo  # doctest: +ELLIPSIS
+    'idontexist.000.nii'
+
+    >>> a = A()
+    >>> a.foo = 'idontexist.000.nii.gz'
+    >>> a.foo  # doctest: +ELLIPSIS
+    'idontexist.000.nii.gz'
 
-    This is used in 90% of the cases.
     """
 
-    _ = traits.Disallow
+    _is_file = True
+    _exts = None
+
+    def __init__(
+        self,
+        value=NoDefaultSpecified,
+        exists=False,
+        resolve=False,
+        allow_compressed=True,
+        extensions=None,
+        **metadata
+    ):
+        """Create a File trait."""
+        if extensions is not None:
+            if isinstance(extensions, (bytes, str)):
+                extensions = [extensions]
+
+            if allow_compressed is False:
+                extensions = list(set(extensions) - IMG_ZIP_FMT)
+
+            self._exts = sorted(
+                set(
+                    [
+                        ".%s" % ext if not ext.startswith(".") else ext
+                        for ext in extensions
+                    ]
+                )
+            )
+
+        super(File, self).__init__(
+            value=value,
+            exists=exists,
+            resolve=resolve,
+            extensions=self._exts,
+            **metadata
+        )
+
+    def validate(self, objekt, name, value, return_pathlike=False):
+        """Validate a value change."""
+        value = super(File, self).validate(objekt, name, value, return_pathlike=True)
+        if self._exts:
+            fname = value.name
+            if not any((fname.endswith(e) for e in self._exts)):
+                self.error(objekt, name, str(value))
+
+        if not return_pathlike:
+            value = str(value)
+
+        return value
+
+
+def _resolve_with_filenotfound(path, **kwargs):
+    """Raise FileNotFoundError instead of OSError"""
+    try:
+        return path.resolve(**kwargs)
+    except OSError as e:
+        if isinstance(e, FileNotFoundError):
+            raise
+        raise FileNotFoundError(str(path))
+
+
+def path_resolve(path, strict=False):
+    try:
+        return _resolve_with_filenotfound(path, strict=strict)
+    except TypeError:  # PY35
+        pass
+
+    path = path.absolute()
+    if strict or path.exists():
+        return _resolve_with_filenotfound(path)
+
+    # This is a hacky shortcut, using path.absolute() unmodified
+    # In cases where the existing part of the path contains a
+    # symlink, different results will be produced
+    return path
 
 
 def simplify_list(filelist):
diff --git a/example-specs/task/nipype/fsl/feature_extractor.yaml b/example-specs/task/nipype/fsl/feature_extractor.yaml
index a3d2221d..fdd69d31 100644
--- a/example-specs/task/nipype/fsl/feature_extractor.yaml
+++ b/example-specs/task/nipype/fsl/feature_extractor.yaml
@@ -25,6 +25,9 @@ inputs:
     mel_ica: Path
     # type=directory: Melodic output directory or directories
     # type=directory|default=<undefined>: Melodic output directory or directories
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/filmgls.yaml b/example-specs/task/nipype/fsl/filmgls.yaml
index b92be438..2e15e916 100644
--- a/example-specs/task/nipype/fsl/filmgls.yaml
+++ b/example-specs/task/nipype/fsl/filmgls.yaml
@@ -58,6 +58,9 @@ inputs:
     # type=file|default=<undefined>: input surface for autocorr smoothing in surface-based analyses
     tcon_file: generic/file
     # type=file|default=<undefined>: contrast file containing T-contrasts
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/filmgls_callables.py b/example-specs/task/nipype/fsl/filmgls_callables.py
index afe9771b..72bc72a1 100644
--- a/example-specs/task/nipype/fsl/filmgls_callables.py
+++ b/example-specs/task/nipype/fsl/filmgls_callables.py
@@ -1,10 +1,12 @@
 """Module to put any functions that are referred to in the "callables" section of FILMGLS.yaml"""
 
-import os
-import attrs
-import os.path as op
 import logging
+from pathlib import Path
+from looseversion import LooseVersion
 from glob import glob
+import os.path as op
+import attrs
+import os
 
 
 def param_estimates_callable(output_dir, inputs, stdout, stderr):
@@ -101,6 +103,43 @@ def zfstats_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -344,6 +383,135 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
+class Info(PackageInfo):
+    """
+    Handle FSL ``output_type`` and version information.
+
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
+
+    """
+
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
+
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
+
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
+
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
+
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
+
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
+
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
+
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
+
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
+
+        Returns a list of standard images if called without arguments.
+
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
+
+
 def _get_numcons(inputs=None, stdout=None, stderr=None, output_dir=None):
     numtcons = 0
     numfcons = 0
diff --git a/example-specs/task/nipype/fsl/filter_regressor.yaml b/example-specs/task/nipype/fsl/filter_regressor.yaml
index 5ff3d9a5..f3af84ba 100644
--- a/example-specs/task/nipype/fsl/filter_regressor.yaml
+++ b/example-specs/task/nipype/fsl/filter_regressor.yaml
@@ -32,6 +32,9 @@ inputs:
     out_file: Path
     # type=file: output file name for the filtered data
     # type=file|default=<undefined>: output file name for the filtered data
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/filter_regressor_callables.py b/example-specs/task/nipype/fsl/filter_regressor_callables.py
index 6d3ba0e4..7d643ec3 100644
--- a/example-specs/task/nipype/fsl/filter_regressor_callables.py
+++ b/example-specs/task/nipype/fsl/filter_regressor_callables.py
@@ -1,10 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of FilterRegressor.yaml"""
 
-import os
-import attrs
-import os.path as op
-import logging
 from glob import glob
+import logging
+from pathlib import Path
+import os.path as op
+import attrs
+import os
 
 
 def out_file_default(inputs):
@@ -21,6 +22,43 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
diff --git a/example-specs/task/nipype/fsl/find_the_biggest.yaml b/example-specs/task/nipype/fsl/find_the_biggest.yaml
index eff63541..9a279486 100644
--- a/example-specs/task/nipype/fsl/find_the_biggest.yaml
+++ b/example-specs/task/nipype/fsl/find_the_biggest.yaml
@@ -40,6 +40,9 @@ inputs:
     out_file: Path
     # type=file: output file indexed in order of input files
     # type=file|default=<undefined>: file with the resulting segmentation
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/find_the_biggest_callables.py b/example-specs/task/nipype/fsl/find_the_biggest_callables.py
index 8ebd7042..84be4958 100644
--- a/example-specs/task/nipype/fsl/find_the_biggest_callables.py
+++ b/example-specs/task/nipype/fsl/find_the_biggest_callables.py
@@ -1,10 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of FindTheBiggest.yaml"""
 
-import os
-import attrs
-import os.path as op
-import logging
 from glob import glob
+import logging
+from pathlib import Path
+import os.path as op
+import attrs
+import os
 
 
 def out_file_default(inputs):
@@ -21,6 +22,43 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
diff --git a/example-specs/task/nipype/fsl/first.yaml b/example-specs/task/nipype/fsl/first.yaml
index 9da759a6..bb3e4307 100644
--- a/example-specs/task/nipype/fsl/first.yaml
+++ b/example-specs/task/nipype/fsl/first.yaml
@@ -39,6 +39,9 @@ inputs:
     # type=file|default=<undefined>: input data file
     out_file: Path
     # type=file|default='segmented': output data file
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/first_callables.py b/example-specs/task/nipype/fsl/first_callables.py
index fea44e53..711324a1 100644
--- a/example-specs/task/nipype/fsl/first_callables.py
+++ b/example-specs/task/nipype/fsl/first_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of FIRST.yaml"""
 
-import attrs
 import os.path as op
+import attrs
 
 
 def vtk_surfaces_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/fsl/flameo.yaml b/example-specs/task/nipype/fsl/flameo.yaml
index 1918e793..a62ae479 100644
--- a/example-specs/task/nipype/fsl/flameo.yaml
+++ b/example-specs/task/nipype/fsl/flameo.yaml
@@ -57,6 +57,9 @@ inputs:
     # type=file|default=<undefined>: ascii matrix specifying t-contrasts
     var_cope_file: medimage/nifti-gz
     # type=file|default=<undefined>: varcope weightings data file
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/flameo_callables.py b/example-specs/task/nipype/fsl/flameo_callables.py
index 7fb6a779..b3e25f88 100644
--- a/example-specs/task/nipype/fsl/flameo_callables.py
+++ b/example-specs/task/nipype/fsl/flameo_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of FLAMEO.yaml"""
 
-import os
 import re
 from glob import glob
 import attrs
+import os
 
 
 def pes_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/fsl/flirt.yaml b/example-specs/task/nipype/fsl/flirt.yaml
index 6d677c87..150b8331 100644
--- a/example-specs/task/nipype/fsl/flirt.yaml
+++ b/example-specs/task/nipype/fsl/flirt.yaml
@@ -71,6 +71,9 @@ inputs:
     # type=file|default=<undefined>: white matter boundary coordinates for BBR cost function
     wmnorms: generic/file
     # type=file|default=<undefined>: white matter boundary normals for BBR cost function
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/flirt_callables.py b/example-specs/task/nipype/fsl/flirt_callables.py
index c81ecaba..5328ef79 100644
--- a/example-specs/task/nipype/fsl/flirt_callables.py
+++ b/example-specs/task/nipype/fsl/flirt_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of FLIRT.yaml"""
 
-import os
-import attrs
-import os.path as op
 import logging
 from glob import glob
+import os.path as op
+import attrs
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -28,10 +28,47 @@ def out_log_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_log"]
 
 
+iflogger = logging.getLogger("nipype.interface")
+
+
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
-iflogger = logging.getLogger("nipype.interface")
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
 
 
 class Info(PackageInfo):
@@ -132,6 +169,16 @@ def _overload_extension(
     return value + Info.output_type_to_ext(inputs.output_type)
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/fsl/fnirt.yaml b/example-specs/task/nipype/fsl/fnirt.yaml
index 9c0f7e34..84d3b6d1 100644
--- a/example-specs/task/nipype/fsl/fnirt.yaml
+++ b/example-specs/task/nipype/fsl/fnirt.yaml
@@ -69,6 +69,9 @@ inputs:
     warped_file: Path
     # type=file: warped image
     # type=file|default=<undefined>: name of output image
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/fnirt_callables.py b/example-specs/task/nipype/fsl/fnirt_callables.py
index f754dc5f..2c84c963 100644
--- a/example-specs/task/nipype/fsl/fnirt_callables.py
+++ b/example-specs/task/nipype/fsl/fnirt_callables.py
@@ -1,10 +1,15 @@
 """Module to put any functions that are referred to in the "callables" section of FNIRT.yaml"""
 
-import attrs
 import logging
+from traits.trait_errors import TraitError
+from pathlib import Path
+from fileformats.generic import File
 from glob import glob
-import os
+from traits.trait_type import TraitType
+from traits.trait_base import _Undefined
 import os.path as op
+import attrs
+import os
 
 
 def warped_file_default(inputs):
@@ -64,9 +69,52 @@ def log_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["log_file"]
 
 
+Undefined = _Undefined()
+
+
+IMG_ZIP_FMT = set([".nii.gz", "tar.gz", ".gii.gz", ".mgz", ".mgh.gz", "img.gz"])
+
+
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -306,28 +354,349 @@ def _gen_fname(
     return fname
 
 
-class FSLCommandInputSpec(CommandLineInputSpec):
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
+class Info(PackageInfo):
     """
-    Base Input Specification for all FSL Commands
+    Handle FSL ``output_type`` and version information.
 
-    All command support specifying FSLOUTPUTTYPE dynamically
-    via output_type.
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
 
-    Example
-    -------
-    fsl.ExtractRoi(tmin=42, tsize=1, output_type='NIFTI')
     """
 
-    output_type = traits.Enum("NIFTI", list(Info.ftypes.keys()), desc="FSL output type")
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
+
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
+
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
+
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
+
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
 
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
 
-class TraitedSpec(BaseTraitedSpec):
-    """Create a subclass with strict traits.
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
+
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
+
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
+
+        Returns a list of standard images if called without arguments.
+
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
+
+
+class BasePath(TraitType):
+    """Defines a trait whose value must be a valid filesystem path."""
+
+    # A description of the type of value this trait accepts:
+    exists = False
+    resolve = False
+    _is_file = False
+    _is_dir = False
+
+    @property
+    def info_text(self):
+        """Create the trait's general description."""
+        info_text = "a pathlike object or string"
+        if any((self.exists, self._is_file, self._is_dir)):
+            info_text += " representing a"
+            if self.exists:
+                info_text += "n existing"
+            if self._is_file:
+                info_text += " file"
+            elif self._is_dir:
+                info_text += " directory"
+            else:
+                info_text += " file or directory"
+        return info_text
+
+    def __init__(self, value=attrs.NOTHING, exists=False, resolve=False, **metadata):
+        """Create a BasePath trait."""
+        self.exists = exists
+        self.resolve = resolve
+        super(BasePath, self).__init__(value, **metadata)
+
+    def validate(self, objekt, name, value, return_pathlike=False):
+        """Validate a value change."""
+        try:
+            value = Path(value)  # Use pathlib's validation
+        except Exception:
+            self.error(objekt, name, str(value))
+
+        if self.exists:
+            if not value.exists():
+                self.error(objekt, name, str(value))
+
+            if self._is_file and not value.is_file():
+                self.error(objekt, name, str(value))
+
+            if self._is_dir and not value.is_dir():
+                self.error(objekt, name, str(value))
+
+        if self.resolve:
+            value = path_resolve(value, strict=self.exists)
+
+        if not return_pathlike:
+            value = str(value)
+
+        return value
+
+
+class File(BasePath):
+    """
+    Defines a trait whose value must be a file path.
+
+    >>> from nipype.interfaces.base import File, TraitedSpec, TraitError
+    >>> class A(TraitedSpec):
+    ...     foo = File()
+    >>> a = A()
+    >>> a.foo
+    <undefined>
+
+    >>> a.foo = '/some/made/out/path/to/file'
+    >>> a.foo
+    '/some/made/out/path/to/file'
+
+    >>> class A(TraitedSpec):
+    ...     foo = File(exists=False, resolve=True)
+    >>> a = A(foo='idontexist.txt')
+    >>> a.foo  # doctest: +ELLIPSIS
+    '.../idontexist.txt'
+
+    >>> class A(TraitedSpec):
+    ...     foo = File(exists=True, resolve=True)
+    >>> a = A()
+    >>> a.foo = 'idontexist.txt'  # doctest: +IGNORE_EXCEPTION_DETAIL
+    Traceback (most recent call last):
+    TraitError:
+
+    >>> open('idoexist.txt', 'w').close()
+    >>> a.foo = 'idoexist.txt'
+    >>> a.foo  # doctest: +ELLIPSIS
+    '.../idoexist.txt'
+
+    >>> class A(TraitedSpec):
+    ...     foo = File('idoexist.txt')
+    >>> a = A()
+    >>> a.foo
+    <undefined>
+
+    >>> class A(TraitedSpec):
+    ...     foo = File('idoexist.txt', usedefault=True)
+    >>> a = A()
+    >>> a.foo
+    'idoexist.txt'
+
+    >>> class A(TraitedSpec):
+    ...     foo = File(exists=True, resolve=True, extensions=['.txt', 'txt.gz'])
+    >>> a = A()
+    >>> a.foo = 'idoexist.badtxt'  # doctest: +IGNORE_EXCEPTION_DETAIL
+    Traceback (most recent call last):
+    TraitError:
+
+    >>> a.foo = 'idoexist.txt'
+    >>> a.foo  # doctest: +ELLIPSIS
+    '.../idoexist.txt'
+
+    >>> class A(TraitedSpec):
+    ...     foo = File(extensions=['.nii', '.nii.gz'])
+    >>> a = A()
+    >>> a.foo = 'badext.txt'  # doctest: +IGNORE_EXCEPTION_DETAIL
+    Traceback (most recent call last):
+    TraitError:
+
+    >>> class A(TraitedSpec):
+    ...     foo = File(extensions=['.nii', '.nii.gz'])
+    >>> a = A()
+    >>> a.foo = 'goodext.nii'
+    >>> a.foo
+    'goodext.nii'
+
+    >>> a = A()
+    >>> a.foo = 'idontexist.000.nii'
+    >>> a.foo  # doctest: +ELLIPSIS
+    'idontexist.000.nii'
+
+    >>> a = A()
+    >>> a.foo = 'idontexist.000.nii.gz'
+    >>> a.foo  # doctest: +ELLIPSIS
+    'idontexist.000.nii.gz'
 
-    This is used in 90% of the cases.
     """
 
-    _ = traits.Disallow
+    _is_file = True
+    _exts = None
+
+    def __init__(
+        self,
+        value=NoDefaultSpecified,
+        exists=False,
+        resolve=False,
+        allow_compressed=True,
+        extensions=None,
+        **metadata
+    ):
+        """Create a File trait."""
+        if extensions is not None:
+            if isinstance(extensions, (bytes, str)):
+                extensions = [extensions]
+
+            if allow_compressed is False:
+                extensions = list(set(extensions) - IMG_ZIP_FMT)
+
+            self._exts = sorted(
+                set(
+                    [
+                        ".%s" % ext if not ext.startswith(".") else ext
+                        for ext in extensions
+                    ]
+                )
+            )
+
+        super(File, self).__init__(
+            value=value,
+            exists=exists,
+            resolve=resolve,
+            extensions=self._exts,
+            **metadata
+        )
+
+    def validate(self, objekt, name, value, return_pathlike=False):
+        """Validate a value change."""
+        value = super(File, self).validate(objekt, name, value, return_pathlike=True)
+        if self._exts:
+            fname = value.name
+            if not any((fname.endswith(e) for e in self._exts)):
+                self.error(objekt, name, str(value))
+
+        if not return_pathlike:
+            value = str(value)
+
+        return value
+
+
+def path_resolve(path, strict=False):
+    try:
+        return _resolve_with_filenotfound(path, strict=strict)
+    except TypeError:  # PY35
+        pass
+
+    path = path.absolute()
+    if strict or path.exists():
+        return _resolve_with_filenotfound(path)
+
+    # This is a hacky shortcut, using path.absolute() unmodified
+    # In cases where the existing part of the path contains a
+    # symlink, different results will be produced
+    return path
+
+
+def _resolve_with_filenotfound(path, **kwargs):
+    """Raise FileNotFoundError instead of OSError"""
+    try:
+        return path.resolve(**kwargs)
+    except OSError as e:
+        if isinstance(e, FileNotFoundError):
+            raise
+        raise FileNotFoundError(str(path))
 
 
 class FNIRTOutputSpec(TraitedSpec):
diff --git a/example-specs/task/nipype/fsl/fugue.yaml b/example-specs/task/nipype/fsl/fugue.yaml
index ca21c208..560b3dce 100644
--- a/example-specs/task/nipype/fsl/fugue.yaml
+++ b/example-specs/task/nipype/fsl/fugue.yaml
@@ -104,6 +104,9 @@ inputs:
     warped_file: Path
     # type=file: forward warped file
     # type=file|default=<undefined>: apply forward warping and save as filename
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/fugue_callables.py b/example-specs/task/nipype/fsl/fugue_callables.py
index b5ec9ab6..99be751c 100644
--- a/example-specs/task/nipype/fsl/fugue_callables.py
+++ b/example-specs/task/nipype/fsl/fugue_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of FUGUE.yaml"""
 
-import os
-import attrs
-import os.path as op
 import logging
 from glob import glob
+import os.path as op
+import attrs
+import os
 
 
 def unwarped_file_callable(output_dir, inputs, stdout, stderr):
@@ -35,10 +35,47 @@ def fmap_out_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["fmap_out_file"]
 
 
+iflogger = logging.getLogger("nipype.interface")
+
+
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
-iflogger = logging.getLogger("nipype.interface")
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
 
 
 class Info(PackageInfo):
@@ -139,6 +176,16 @@ def _overload_extension(
     return value + Info.output_type_to_ext(inputs.output_type)
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/fsl/glm.yaml b/example-specs/task/nipype/fsl/glm.yaml
index e12cb30f..1b61e1c9 100644
--- a/example-specs/task/nipype/fsl/glm.yaml
+++ b/example-specs/task/nipype/fsl/glm.yaml
@@ -64,6 +64,9 @@ inputs:
     # type=file|default=<undefined>: output file name for scaling factors for variance normalisation
     out_z_name: Path
     # type=file|default=<undefined>: output file name for Z-stats (either as txt or image
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/glm_callables.py b/example-specs/task/nipype/fsl/glm_callables.py
index 5e72d07a..faf428f7 100644
--- a/example-specs/task/nipype/fsl/glm_callables.py
+++ b/example-specs/task/nipype/fsl/glm_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of GLM.yaml"""
 
-import os
-import attrs
-import os.path as op
 import logging
 from glob import glob
+import os.path as op
+import attrs
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -91,10 +91,47 @@ def out_vnscales_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_vnscales"]
 
 
+iflogger = logging.getLogger("nipype.interface")
+
+
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
-iflogger = logging.getLogger("nipype.interface")
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
 
 
 class Info(PackageInfo):
@@ -195,6 +232,16 @@ def _overload_extension(
     return value + Info.output_type_to_ext(inputs.output_type)
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/fsl/ica__aroma.yaml b/example-specs/task/nipype/fsl/ica__aroma.yaml
index d6b80bc6..db48d378 100644
--- a/example-specs/task/nipype/fsl/ica__aroma.yaml
+++ b/example-specs/task/nipype/fsl/ica__aroma.yaml
@@ -63,6 +63,9 @@ inputs:
     out_dir: Path
     # type=directory: directory contains (in addition to the denoised files): melodic.ica + classified_motion_components + classification_overview + feature_scores + melodic_ic_mni)
     # type=directory|default='out': output directory
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/image_maths.yaml b/example-specs/task/nipype/fsl/image_maths.yaml
index c5652f77..57a2e7ee 100644
--- a/example-specs/task/nipype/fsl/image_maths.yaml
+++ b/example-specs/task/nipype/fsl/image_maths.yaml
@@ -44,6 +44,9 @@ inputs:
     out_file: Path
     # type=file: 
     # type=file|default=<undefined>: 
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/image_maths_callables.py b/example-specs/task/nipype/fsl/image_maths_callables.py
index 9d22e275..9fced413 100644
--- a/example-specs/task/nipype/fsl/image_maths_callables.py
+++ b/example-specs/task/nipype/fsl/image_maths_callables.py
@@ -1,10 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of ImageMaths.yaml"""
 
-import os
-import attrs
-import os.path as op
-import logging
 from glob import glob
+import logging
+from pathlib import Path
+import os.path as op
+import attrs
+import os
 
 
 def out_file_default(inputs):
@@ -21,6 +22,43 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
diff --git a/example-specs/task/nipype/fsl/image_meants.yaml b/example-specs/task/nipype/fsl/image_meants.yaml
index 0939da7b..37df8536 100644
--- a/example-specs/task/nipype/fsl/image_meants.yaml
+++ b/example-specs/task/nipype/fsl/image_meants.yaml
@@ -31,6 +31,9 @@ inputs:
     out_file: Path
     # type=file: path/name of output text matrix
     # type=file|default=<undefined>: name of output text matrix
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/image_meants_callables.py b/example-specs/task/nipype/fsl/image_meants_callables.py
index 671db373..b925250f 100644
--- a/example-specs/task/nipype/fsl/image_meants_callables.py
+++ b/example-specs/task/nipype/fsl/image_meants_callables.py
@@ -1,10 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of ImageMeants.yaml"""
 
-import os
-import attrs
-import os.path as op
-import logging
 from glob import glob
+import logging
+from pathlib import Path
+import os.path as op
+import attrs
+import os
 
 
 def out_file_default(inputs):
@@ -21,6 +22,43 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
diff --git a/example-specs/task/nipype/fsl/image_stats.yaml b/example-specs/task/nipype/fsl/image_stats.yaml
index 131f2817..8fe54170 100644
--- a/example-specs/task/nipype/fsl/image_stats.yaml
+++ b/example-specs/task/nipype/fsl/image_stats.yaml
@@ -41,6 +41,9 @@ inputs:
     # type=file|default=<undefined>: generate separate n submasks from indexMask, for indexvalues 1..n where n is the maximum index value in indexMask, and generate statistics for each submask
     mask_file: generic/file
     # type=file|default=<undefined>: mask file used for option -k %s
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/image_stats_callables.py b/example-specs/task/nipype/fsl/image_stats_callables.py
index 2b939a04..6a2502f2 100644
--- a/example-specs/task/nipype/fsl/image_stats_callables.py
+++ b/example-specs/task/nipype/fsl/image_stats_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of ImageStats.yaml"""
 
-import os
-import attrs
-import os.path as op
 import logging
 from glob import glob
+import os.path as op
+import attrs
+import os
 
 
 def out_stat_callable(output_dir, inputs, stdout, stderr):
@@ -14,10 +14,47 @@ def out_stat_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_stat"]
 
 
+iflogger = logging.getLogger("nipype.interface")
+
+
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
-iflogger = logging.getLogger("nipype.interface")
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
 
 
 class Info(PackageInfo):
@@ -118,6 +155,16 @@ def _overload_extension(
     return value + Info.output_type_to_ext(inputs.output_type)
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/fsl/inv_warp.yaml b/example-specs/task/nipype/fsl/inv_warp.yaml
index 134c7541..ba8855c9 100644
--- a/example-specs/task/nipype/fsl/inv_warp.yaml
+++ b/example-specs/task/nipype/fsl/inv_warp.yaml
@@ -44,6 +44,9 @@ inputs:
     # type=file|default=<undefined>: Name of a file in target space. Note that the target space is now different from the target space that was used to create the --warp file. It would typically be the file that was specified with the --in argument when running fnirt.
     warp: medimage/nifti1
     # type=file|default=<undefined>: Name of file containing warp-coefficients/fields. This would typically be the output from the --cout switch of fnirt (but can also use fields, like the output from --fout).
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/inv_warp_callables.py b/example-specs/task/nipype/fsl/inv_warp_callables.py
index 76144fbe..0b8e0e86 100644
--- a/example-specs/task/nipype/fsl/inv_warp_callables.py
+++ b/example-specs/task/nipype/fsl/inv_warp_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of InvWarp.yaml"""
 
-import os
-import attrs
-import os.path as op
 import logging
 from glob import glob
+import os.path as op
+import attrs
+import os
 
 
 def inverse_warp_callable(output_dir, inputs, stdout, stderr):
@@ -14,10 +14,47 @@ def inverse_warp_callable(output_dir, inputs, stdout, stderr):
     return outputs["inverse_warp"]
 
 
+iflogger = logging.getLogger("nipype.interface")
+
+
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
-iflogger = logging.getLogger("nipype.interface")
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
 
 
 class Info(PackageInfo):
@@ -118,6 +155,16 @@ def _overload_extension(
     return value + Info.output_type_to_ext(inputs.output_type)
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/fsl/isotropic_smooth.yaml b/example-specs/task/nipype/fsl/isotropic_smooth.yaml
index 053bb995..6ffdabde 100644
--- a/example-specs/task/nipype/fsl/isotropic_smooth.yaml
+++ b/example-specs/task/nipype/fsl/isotropic_smooth.yaml
@@ -25,6 +25,9 @@ inputs:
     out_file: Path
     # type=file: image written after calculations
     # type=file|default=<undefined>: image to write
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/isotropic_smooth_callables.py b/example-specs/task/nipype/fsl/isotropic_smooth_callables.py
index 54bb1029..377ec797 100644
--- a/example-specs/task/nipype/fsl/isotropic_smooth_callables.py
+++ b/example-specs/task/nipype/fsl/isotropic_smooth_callables.py
@@ -1,10 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of IsotropicSmooth.yaml"""
 
-import os
-import attrs
-import os.path as op
-import logging
 from glob import glob
+import logging
+from pathlib import Path
+import os.path as op
+import attrs
+import os
 
 
 def out_file_default(inputs):
@@ -21,6 +22,43 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
diff --git a/example-specs/task/nipype/fsl/l2_model.yaml b/example-specs/task/nipype/fsl/l2_model.yaml
index 6276feef..fb142c54 100644
--- a/example-specs/task/nipype/fsl/l2_model.yaml
+++ b/example-specs/task/nipype/fsl/l2_model.yaml
@@ -28,6 +28,9 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/level_1_design.yaml b/example-specs/task/nipype/fsl/level_1_design.yaml
index b96cab0b..a85f6a94 100644
--- a/example-specs/task/nipype/fsl/level_1_design.yaml
+++ b/example-specs/task/nipype/fsl/level_1_design.yaml
@@ -31,6 +31,9 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/make_dyadic_vectors.yaml b/example-specs/task/nipype/fsl/make_dyadic_vectors.yaml
index 264c87df..e41d3cd0 100644
--- a/example-specs/task/nipype/fsl/make_dyadic_vectors.yaml
+++ b/example-specs/task/nipype/fsl/make_dyadic_vectors.yaml
@@ -29,6 +29,9 @@ inputs:
     # type=file|default=<undefined>: 
     theta_vol: generic/file
     # type=file|default=<undefined>: 
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/make_dyadic_vectors_callables.py b/example-specs/task/nipype/fsl/make_dyadic_vectors_callables.py
index f4fb2ce8..808affe0 100644
--- a/example-specs/task/nipype/fsl/make_dyadic_vectors_callables.py
+++ b/example-specs/task/nipype/fsl/make_dyadic_vectors_callables.py
@@ -1,9 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of MakeDyadicVectors.yaml"""
 
-import os
 from glob import glob
-import os.path as op
 import logging
+from pathlib import Path
+import os.path as op
+import os
 
 
 def dyads_callable(output_dir, inputs, stdout, stderr):
@@ -23,6 +24,43 @@ def dispersion_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
diff --git a/example-specs/task/nipype/fsl/maths_command.yaml b/example-specs/task/nipype/fsl/maths_command.yaml
index 7c2814c2..e9acb762 100644
--- a/example-specs/task/nipype/fsl/maths_command.yaml
+++ b/example-specs/task/nipype/fsl/maths_command.yaml
@@ -25,6 +25,9 @@ inputs:
     out_file: Path
     # type=file: image written after calculations
     # type=file|default=<undefined>: image to write
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/maths_command_callables.py b/example-specs/task/nipype/fsl/maths_command_callables.py
index 7c79ed84..17c11afd 100644
--- a/example-specs/task/nipype/fsl/maths_command_callables.py
+++ b/example-specs/task/nipype/fsl/maths_command_callables.py
@@ -1,10 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of MathsCommand.yaml"""
 
-import os
-import attrs
-import os.path as op
-import logging
 from glob import glob
+import logging
+from pathlib import Path
+import os.path as op
+import attrs
+import os
 
 
 def out_file_default(inputs):
@@ -21,6 +22,43 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
diff --git a/example-specs/task/nipype/fsl/max_image.yaml b/example-specs/task/nipype/fsl/max_image.yaml
index 9d80c01d..24d270c8 100644
--- a/example-specs/task/nipype/fsl/max_image.yaml
+++ b/example-specs/task/nipype/fsl/max_image.yaml
@@ -36,6 +36,9 @@ inputs:
     out_file: Path
     # type=file: image written after calculations
     # type=file|default=<undefined>: image to write
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/max_image_callables.py b/example-specs/task/nipype/fsl/max_image_callables.py
index 281f7bca..97c53d6d 100644
--- a/example-specs/task/nipype/fsl/max_image_callables.py
+++ b/example-specs/task/nipype/fsl/max_image_callables.py
@@ -1,10 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of MaxImage.yaml"""
 
-import os
-import attrs
-import os.path as op
-import logging
 from glob import glob
+import logging
+from pathlib import Path
+import os.path as op
+import attrs
+import os
 
 
 def out_file_default(inputs):
@@ -21,6 +22,43 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
diff --git a/example-specs/task/nipype/fsl/maxn_image.yaml b/example-specs/task/nipype/fsl/maxn_image.yaml
index 4c742711..ac326f39 100644
--- a/example-specs/task/nipype/fsl/maxn_image.yaml
+++ b/example-specs/task/nipype/fsl/maxn_image.yaml
@@ -28,6 +28,9 @@ inputs:
     out_file: Path
     # type=file: image written after calculations
     # type=file|default=<undefined>: image to write
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/maxn_image_callables.py b/example-specs/task/nipype/fsl/maxn_image_callables.py
index b565d43c..dbcc27f6 100644
--- a/example-specs/task/nipype/fsl/maxn_image_callables.py
+++ b/example-specs/task/nipype/fsl/maxn_image_callables.py
@@ -1,10 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of MaxnImage.yaml"""
 
-import os
-import attrs
-import os.path as op
-import logging
 from glob import glob
+import logging
+from pathlib import Path
+import os.path as op
+import attrs
+import os
 
 
 def out_file_default(inputs):
@@ -21,6 +22,43 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
diff --git a/example-specs/task/nipype/fsl/mcflirt.yaml b/example-specs/task/nipype/fsl/mcflirt.yaml
index 93705796..0b252239 100644
--- a/example-specs/task/nipype/fsl/mcflirt.yaml
+++ b/example-specs/task/nipype/fsl/mcflirt.yaml
@@ -45,6 +45,9 @@ inputs:
     # type=file|default=<undefined>: file to write
     ref_file: generic/file
     # type=file|default=<undefined>: target image for motion correction
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/mcflirt_callables.py b/example-specs/task/nipype/fsl/mcflirt_callables.py
index 7aa37b80..8113c914 100644
--- a/example-specs/task/nipype/fsl/mcflirt_callables.py
+++ b/example-specs/task/nipype/fsl/mcflirt_callables.py
@@ -1,11 +1,13 @@
 """Module to put any functions that are referred to in the "callables" section of MCFLIRT.yaml"""
 
-import os
-from nibabel.loadsave import load
-import attrs
-import os.path as op
 import logging
+from pathlib import Path
+from looseversion import LooseVersion
 from glob import glob
+import os.path as op
+from nibabel.loadsave import load
+import attrs
+import os
 
 
 def out_file_default(inputs):
@@ -64,6 +66,43 @@ def rms_files_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -303,6 +342,135 @@ def _gen_fname(
     return fname
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
+class Info(PackageInfo):
+    """
+    Handle FSL ``output_type`` and version information.
+
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
+
+    """
+
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
+
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
+
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
+
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
+
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
+
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
+
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
+
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
+
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
+
+        Returns a list of standard images if called without arguments.
+
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
+
+
 def _gen_outfilename(inputs=None, stdout=None, stderr=None, output_dir=None):
     out_file = inputs.out_file
     if out_file is not attrs.NOTHING:
diff --git a/example-specs/task/nipype/fsl/mean_image.yaml b/example-specs/task/nipype/fsl/mean_image.yaml
index c4fcaae9..c30b5413 100644
--- a/example-specs/task/nipype/fsl/mean_image.yaml
+++ b/example-specs/task/nipype/fsl/mean_image.yaml
@@ -25,6 +25,9 @@ inputs:
     out_file: Path
     # type=file: image written after calculations
     # type=file|default=<undefined>: image to write
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/mean_image_callables.py b/example-specs/task/nipype/fsl/mean_image_callables.py
index df6430e9..bfa76a70 100644
--- a/example-specs/task/nipype/fsl/mean_image_callables.py
+++ b/example-specs/task/nipype/fsl/mean_image_callables.py
@@ -1,10 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of MeanImage.yaml"""
 
-import os
-import attrs
-import os.path as op
-import logging
 from glob import glob
+import logging
+from pathlib import Path
+import os.path as op
+import attrs
+import os
 
 
 def out_file_default(inputs):
@@ -21,6 +22,43 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
diff --git a/example-specs/task/nipype/fsl/median_image.yaml b/example-specs/task/nipype/fsl/median_image.yaml
index 30bc3891..9b40b414 100644
--- a/example-specs/task/nipype/fsl/median_image.yaml
+++ b/example-specs/task/nipype/fsl/median_image.yaml
@@ -25,6 +25,9 @@ inputs:
     out_file: Path
     # type=file: image written after calculations
     # type=file|default=<undefined>: image to write
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/median_image_callables.py b/example-specs/task/nipype/fsl/median_image_callables.py
index 2137005b..814df76c 100644
--- a/example-specs/task/nipype/fsl/median_image_callables.py
+++ b/example-specs/task/nipype/fsl/median_image_callables.py
@@ -1,10 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of MedianImage.yaml"""
 
-import os
-import attrs
-import os.path as op
-import logging
 from glob import glob
+import logging
+from pathlib import Path
+import os.path as op
+import attrs
+import os
 
 
 def out_file_default(inputs):
@@ -21,6 +22,43 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
diff --git a/example-specs/task/nipype/fsl/melodic.yaml b/example-specs/task/nipype/fsl/melodic.yaml
index 5917e209..9dca483d 100644
--- a/example-specs/task/nipype/fsl/melodic.yaml
+++ b/example-specs/task/nipype/fsl/melodic.yaml
@@ -67,6 +67,9 @@ inputs:
     # type=file|default=<undefined>: t-contrast matrix across time-domain
     t_des: datascience/text-matrix
     # type=file|default=<undefined>: design matrix across time-domain
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/melodic_callables.py b/example-specs/task/nipype/fsl/melodic_callables.py
index 5086dd84..5541fa51 100644
--- a/example-specs/task/nipype/fsl/melodic_callables.py
+++ b/example-specs/task/nipype/fsl/melodic_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of MELODIC.yaml"""
 
-import os
 import attrs
+import os
 
 
 def out_dir_default(inputs):
diff --git a/example-specs/task/nipype/fsl/merge.yaml b/example-specs/task/nipype/fsl/merge.yaml
index d1605f0d..5602a912 100644
--- a/example-specs/task/nipype/fsl/merge.yaml
+++ b/example-specs/task/nipype/fsl/merge.yaml
@@ -49,6 +49,9 @@ inputs:
     merged_file: Path
     # type=file: 
     # type=file|default=<undefined>: 
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/merge_callables.py b/example-specs/task/nipype/fsl/merge_callables.py
index 2ff904b0..bb90ff86 100644
--- a/example-specs/task/nipype/fsl/merge_callables.py
+++ b/example-specs/task/nipype/fsl/merge_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Merge.yaml"""
 
-import os
-import attrs
-import os.path as op
 import logging
 from glob import glob
+import os.path as op
+import attrs
+import os
 
 
 def merged_file_callable(output_dir, inputs, stdout, stderr):
@@ -14,10 +14,47 @@ def merged_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["merged_file"]
 
 
+iflogger = logging.getLogger("nipype.interface")
+
+
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
-iflogger = logging.getLogger("nipype.interface")
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
 
 
 class Info(PackageInfo):
@@ -118,6 +155,16 @@ def _overload_extension(
     return value + Info.output_type_to_ext(inputs.output_type)
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/fsl/min_image.yaml b/example-specs/task/nipype/fsl/min_image.yaml
index 30fad4dd..d6c07210 100644
--- a/example-specs/task/nipype/fsl/min_image.yaml
+++ b/example-specs/task/nipype/fsl/min_image.yaml
@@ -25,6 +25,9 @@ inputs:
     out_file: Path
     # type=file: image written after calculations
     # type=file|default=<undefined>: image to write
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/min_image_callables.py b/example-specs/task/nipype/fsl/min_image_callables.py
index 04c834c2..feec3d89 100644
--- a/example-specs/task/nipype/fsl/min_image_callables.py
+++ b/example-specs/task/nipype/fsl/min_image_callables.py
@@ -1,10 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of MinImage.yaml"""
 
-import os
-import attrs
-import os.path as op
-import logging
 from glob import glob
+import logging
+from pathlib import Path
+import os.path as op
+import attrs
+import os
 
 
 def out_file_default(inputs):
@@ -21,6 +22,43 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
diff --git a/example-specs/task/nipype/fsl/motion_outliers.yaml b/example-specs/task/nipype/fsl/motion_outliers.yaml
index 7d98d27f..d8e53c75 100644
--- a/example-specs/task/nipype/fsl/motion_outliers.yaml
+++ b/example-specs/task/nipype/fsl/motion_outliers.yaml
@@ -43,6 +43,9 @@ inputs:
     out_metric_values: Path
     # type=file: 
     # type=file|default=<undefined>: output metric values (DVARS etc.) file name
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/motion_outliers_callables.py b/example-specs/task/nipype/fsl/motion_outliers_callables.py
index 506e2ef7..09d72133 100644
--- a/example-specs/task/nipype/fsl/motion_outliers_callables.py
+++ b/example-specs/task/nipype/fsl/motion_outliers_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of MotionOutliers.yaml"""
 
-import os
-import attrs
-import os.path as op
 import logging
 from glob import glob
+import os.path as op
+import attrs
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -28,10 +28,47 @@ def out_metric_plot_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_metric_plot"]
 
 
+iflogger = logging.getLogger("nipype.interface")
+
+
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
-iflogger = logging.getLogger("nipype.interface")
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
 
 
 class Info(PackageInfo):
@@ -132,6 +169,16 @@ def _overload_extension(
     return value + Info.output_type_to_ext(inputs.output_type)
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/fsl/multi_image_maths.yaml b/example-specs/task/nipype/fsl/multi_image_maths.yaml
index e3228269..edf4250d 100644
--- a/example-specs/task/nipype/fsl/multi_image_maths.yaml
+++ b/example-specs/task/nipype/fsl/multi_image_maths.yaml
@@ -40,6 +40,9 @@ inputs:
     out_file: Path
     # type=file: image written after calculations
     # type=file|default=<undefined>: image to write
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/multi_image_maths_callables.py b/example-specs/task/nipype/fsl/multi_image_maths_callables.py
index 3f7345f5..d2b014e4 100644
--- a/example-specs/task/nipype/fsl/multi_image_maths_callables.py
+++ b/example-specs/task/nipype/fsl/multi_image_maths_callables.py
@@ -1,10 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of MultiImageMaths.yaml"""
 
-import os
-import attrs
-import os.path as op
-import logging
 from glob import glob
+import logging
+from pathlib import Path
+import os.path as op
+import attrs
+import os
 
 
 def out_file_default(inputs):
@@ -21,6 +22,43 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
diff --git a/example-specs/task/nipype/fsl/multiple_regress_design.yaml b/example-specs/task/nipype/fsl/multiple_regress_design.yaml
index 58c3bf16..bd39d051 100644
--- a/example-specs/task/nipype/fsl/multiple_regress_design.yaml
+++ b/example-specs/task/nipype/fsl/multiple_regress_design.yaml
@@ -38,6 +38,9 @@ inputs:
   # from the nipype interface, but you may want to be more specific, particularly
   # for file types, where specifying the format also specifies the file that will be
   # passed to the field in the automatically generated unittests.
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/overlay.yaml b/example-specs/task/nipype/fsl/overlay.yaml
index c73bc36c..155e80a0 100644
--- a/example-specs/task/nipype/fsl/overlay.yaml
+++ b/example-specs/task/nipype/fsl/overlay.yaml
@@ -46,6 +46,9 @@ inputs:
     # type=file|default=<undefined>: statistical image to overlay in color
     stat_image2: generic/file
     # type=file|default=<undefined>: second statistical image to overlay in color
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/overlay_callables.py b/example-specs/task/nipype/fsl/overlay_callables.py
index 2bcd9560..2d281ac1 100644
--- a/example-specs/task/nipype/fsl/overlay_callables.py
+++ b/example-specs/task/nipype/fsl/overlay_callables.py
@@ -1,10 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of Overlay.yaml"""
 
-import os
-import attrs
-import os.path as op
 import logging
+from pathlib import Path
 from glob import glob
+import os.path as op
+import attrs
+import os
 
 
 def out_file_default(inputs):
@@ -21,6 +22,43 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
diff --git a/example-specs/task/nipype/fsl/percentile_image.yaml b/example-specs/task/nipype/fsl/percentile_image.yaml
index 5f0cf9e7..fada70e4 100644
--- a/example-specs/task/nipype/fsl/percentile_image.yaml
+++ b/example-specs/task/nipype/fsl/percentile_image.yaml
@@ -37,6 +37,9 @@ inputs:
     out_file: Path
     # type=file: image written after calculations
     # type=file|default=<undefined>: image to write
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/percentile_image_callables.py b/example-specs/task/nipype/fsl/percentile_image_callables.py
index dc636d4d..64dcbb4f 100644
--- a/example-specs/task/nipype/fsl/percentile_image_callables.py
+++ b/example-specs/task/nipype/fsl/percentile_image_callables.py
@@ -1,10 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of PercentileImage.yaml"""
 
-import os
-import attrs
-import os.path as op
-import logging
 from glob import glob
+import logging
+from pathlib import Path
+import os.path as op
+import attrs
+import os
 
 
 def out_file_default(inputs):
@@ -21,6 +22,43 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
diff --git a/example-specs/task/nipype/fsl/plot_motion_params.yaml b/example-specs/task/nipype/fsl/plot_motion_params.yaml
index 232d0ecb..997f47b1 100644
--- a/example-specs/task/nipype/fsl/plot_motion_params.yaml
+++ b/example-specs/task/nipype/fsl/plot_motion_params.yaml
@@ -48,6 +48,9 @@ inputs:
     out_file: Path
     # type=file: image to write
     # type=file|default=<undefined>: image to write
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/plot_motion_params_callables.py b/example-specs/task/nipype/fsl/plot_motion_params_callables.py
index 9014b597..8fe1cdd6 100644
--- a/example-specs/task/nipype/fsl/plot_motion_params_callables.py
+++ b/example-specs/task/nipype/fsl/plot_motion_params_callables.py
@@ -1,8 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of PlotMotionParams.yaml"""
 
-import os
-import attrs
+from pathlib import Path
 import os.path as op
+import attrs
+import os
 
 
 def out_file_default(inputs):
diff --git a/example-specs/task/nipype/fsl/plot_time_series.yaml b/example-specs/task/nipype/fsl/plot_time_series.yaml
index a577325b..8d0c3cd8 100644
--- a/example-specs/task/nipype/fsl/plot_time_series.yaml
+++ b/example-specs/task/nipype/fsl/plot_time_series.yaml
@@ -38,6 +38,9 @@ inputs:
     out_file: Path
     # type=file: image to write
     # type=file|default=<undefined>: image to write
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/plot_time_series_callables.py b/example-specs/task/nipype/fsl/plot_time_series_callables.py
index 52d60591..dbdbdcd9 100644
--- a/example-specs/task/nipype/fsl/plot_time_series_callables.py
+++ b/example-specs/task/nipype/fsl/plot_time_series_callables.py
@@ -1,10 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of PlotTimeSeries.yaml"""
 
-import os
-import attrs
-import os.path as op
-import logging
 from glob import glob
+import logging
+from pathlib import Path
+import os.path as op
+import attrs
+import os
 
 
 def out_file_default(inputs):
@@ -21,6 +22,43 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
diff --git a/example-specs/task/nipype/fsl/power_spectrum.yaml b/example-specs/task/nipype/fsl/power_spectrum.yaml
index 71c0bbf6..770bf1da 100644
--- a/example-specs/task/nipype/fsl/power_spectrum.yaml
+++ b/example-specs/task/nipype/fsl/power_spectrum.yaml
@@ -36,6 +36,9 @@ inputs:
     out_file: Path
     # type=file: path/name of the output 4D power spectrum file
     # type=file|default=<undefined>: name of output 4D file for power spectrum
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/power_spectrum_callables.py b/example-specs/task/nipype/fsl/power_spectrum_callables.py
index 4345553c..a2652b17 100644
--- a/example-specs/task/nipype/fsl/power_spectrum_callables.py
+++ b/example-specs/task/nipype/fsl/power_spectrum_callables.py
@@ -1,10 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of PowerSpectrum.yaml"""
 
-import os
-import attrs
-import os.path as op
-import logging
 from glob import glob
+import logging
+from pathlib import Path
+import os.path as op
+import attrs
+import os
 
 
 def out_file_default(inputs):
@@ -21,6 +22,43 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
diff --git a/example-specs/task/nipype/fsl/prelude.yaml b/example-specs/task/nipype/fsl/prelude.yaml
index cbe0d2ca..ac6a82c3 100644
--- a/example-specs/task/nipype/fsl/prelude.yaml
+++ b/example-specs/task/nipype/fsl/prelude.yaml
@@ -44,6 +44,9 @@ inputs:
     unwrapped_phase_file: Path
     # type=file: unwrapped phase file
     # type=file|default=<undefined>: file containing unwrapepd phase
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/prelude_callables.py b/example-specs/task/nipype/fsl/prelude_callables.py
index f3b4b831..1017e4a8 100644
--- a/example-specs/task/nipype/fsl/prelude_callables.py
+++ b/example-specs/task/nipype/fsl/prelude_callables.py
@@ -1,10 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of PRELUDE.yaml"""
 
-import os
-import attrs
-import os.path as op
-import logging
 from glob import glob
+import logging
+from pathlib import Path
+import os.path as op
+import attrs
+import os
 
 
 def unwrapped_phase_file_default(inputs):
@@ -21,6 +22,43 @@ def unwrapped_phase_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
diff --git a/example-specs/task/nipype/fsl/prepare_fieldmap.yaml b/example-specs/task/nipype/fsl/prepare_fieldmap.yaml
index 0cb04343..43346d59 100644
--- a/example-specs/task/nipype/fsl/prepare_fieldmap.yaml
+++ b/example-specs/task/nipype/fsl/prepare_fieldmap.yaml
@@ -48,6 +48,9 @@ inputs:
     out_fieldmap: Path
     # type=file: output name for prepared fieldmap
     # type=file|default=<undefined>: output name for prepared fieldmap
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/prob_track_x.yaml b/example-specs/task/nipype/fsl/prob_track_x.yaml
index cc05720a..9929df40 100644
--- a/example-specs/task/nipype/fsl/prob_track_x.yaml
+++ b/example-specs/task/nipype/fsl/prob_track_x.yaml
@@ -58,6 +58,13 @@ inputs:
     # type=file|default=<undefined>: waypoint mask or ascii list of waypoint masks - only keep paths going through ALL the masks
     xfm: datascience/text-matrix
     # type=file|default=<undefined>: transformation matrix taking seed space to DTI space (either FLIRT matrix or FNIRT warp_field) - default is identity
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
+    mode: mode_default
+    # type=enum|default='simple'|allowed['seedmask','simple','two_mask_symm']: options: simple (single seed voxel), seedmask (mask of seed voxels), twomask_symm (two bet binary masks)
+    out_dir: out_dir_default
+    # type=directory|default=<undefined>: directory to put the final volumes in
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -84,10 +91,6 @@ outputs:
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
-    mode: mode_callable
-    # type=enum|default='simple'|allowed['seedmask','simple','two_mask_symm']: options: simple (single seed voxel), seedmask (mask of seed voxels), twomask_symm (two bet binary masks)
-    out_dir: out_dir_callable
-    # type=directory|default=<undefined>: directory to put the final volumes in
   templates:
   # dict[str, str] - `output_file_template` values to be provided to output fields
   requirements:
diff --git a/example-specs/task/nipype/fsl/prob_track_x2.yaml b/example-specs/task/nipype/fsl/prob_track_x2.yaml
index a6e16130..cd542edf 100644
--- a/example-specs/task/nipype/fsl/prob_track_x2.yaml
+++ b/example-specs/task/nipype/fsl/prob_track_x2.yaml
@@ -73,6 +73,11 @@ inputs:
     # type=file|default=<undefined>: waypoint mask or ascii list of waypoint masks - only keep paths going through ALL the masks
     xfm: generic/file
     # type=file|default=<undefined>: transformation matrix taking seed space to DTI space (either FLIRT matrix or FNIRT warp_field) - default is identity
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
+    out_dir: out_dir_default
+    # type=directory|default=<undefined>: directory to put the final volumes in
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -109,8 +114,6 @@ outputs:
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
-    out_dir: out_dir_callable
-    # type=directory|default=<undefined>: directory to put the final volumes in
   templates:
   # dict[str, str] - `output_file_template` values to be provided to output fields
   requirements:
diff --git a/example-specs/task/nipype/fsl/prob_track_x2_callables.py b/example-specs/task/nipype/fsl/prob_track_x2_callables.py
index d0649a0a..d66e7cad 100644
--- a/example-specs/task/nipype/fsl/prob_track_x2_callables.py
+++ b/example-specs/task/nipype/fsl/prob_track_x2_callables.py
@@ -1,10 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of ProbTrackX2.yaml"""
 
-import os
-import attrs
-import os.path as op
-import logging
 from glob import glob
+import logging
+from pathlib import Path
+import os.path as op
+import attrs
+import os
 
 
 def out_dir_default(inputs):
@@ -84,6 +85,43 @@ def particle_files_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
diff --git a/example-specs/task/nipype/fsl/prob_track_x_callables.py b/example-specs/task/nipype/fsl/prob_track_x_callables.py
index 4dd86139..839bc58c 100644
--- a/example-specs/task/nipype/fsl/prob_track_x_callables.py
+++ b/example-specs/task/nipype/fsl/prob_track_x_callables.py
@@ -1,10 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of ProbTrackX.yaml"""
 
-import os
-import attrs
-import os.path as op
-import logging
 from glob import glob
+import logging
+from pathlib import Path
+import os.path as op
+import attrs
+import os
 
 
 def mode_default(inputs):
@@ -53,6 +54,43 @@ def particle_files_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
diff --git a/example-specs/task/nipype/fsl/proj_thresh.yaml b/example-specs/task/nipype/fsl/proj_thresh.yaml
index 872965ed..0db2ffe1 100644
--- a/example-specs/task/nipype/fsl/proj_thresh.yaml
+++ b/example-specs/task/nipype/fsl/proj_thresh.yaml
@@ -35,6 +35,9 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_files: generic/file+list-of
     # type=list|default=[]: a list of input volumes
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/proj_thresh_callables.py b/example-specs/task/nipype/fsl/proj_thresh_callables.py
index f357252e..9e2d4282 100644
--- a/example-specs/task/nipype/fsl/proj_thresh_callables.py
+++ b/example-specs/task/nipype/fsl/proj_thresh_callables.py
@@ -1,9 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of ProjThresh.yaml"""
 
-import os
-import os.path as op
-import logging
 from glob import glob
+import logging
+from pathlib import Path
+import os.path as op
+import os
 
 
 def out_files_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +17,43 @@ def out_files_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
diff --git a/example-specs/task/nipype/fsl/randomise.yaml b/example-specs/task/nipype/fsl/randomise.yaml
index 32a36403..5de6f0ec 100644
--- a/example-specs/task/nipype/fsl/randomise.yaml
+++ b/example-specs/task/nipype/fsl/randomise.yaml
@@ -43,6 +43,9 @@ inputs:
     # type=file|default=<undefined>: t contrasts file
     x_block_labels: generic/file
     # type=file|default=<undefined>: exchangeability block labels file
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/randomise_callables.py b/example-specs/task/nipype/fsl/randomise_callables.py
index 85d1bc20..5df4da5c 100644
--- a/example-specs/task/nipype/fsl/randomise_callables.py
+++ b/example-specs/task/nipype/fsl/randomise_callables.py
@@ -1,9 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Randomise.yaml"""
 
-import os
-import os.path as op
-import logging
 from glob import glob
+import logging
+from pathlib import Path
+import os.path as op
+import os
 
 
 def tstat_files_callable(output_dir, inputs, stdout, stderr):
@@ -51,6 +52,43 @@ def f_corrected_p_files_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
diff --git a/example-specs/task/nipype/fsl/reorient_2_std.yaml b/example-specs/task/nipype/fsl/reorient_2_std.yaml
index eb684efb..17ce6e8e 100644
--- a/example-specs/task/nipype/fsl/reorient_2_std.yaml
+++ b/example-specs/task/nipype/fsl/reorient_2_std.yaml
@@ -37,6 +37,9 @@ inputs:
     out_file: Path
     # type=file: 
     # type=file|default=<undefined>: 
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/reorient_2_std_callables.py b/example-specs/task/nipype/fsl/reorient_2_std_callables.py
index 78710bd2..eee58e42 100644
--- a/example-specs/task/nipype/fsl/reorient_2_std_callables.py
+++ b/example-specs/task/nipype/fsl/reorient_2_std_callables.py
@@ -1,10 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of Reorient2Std.yaml"""
 
-import os
-import attrs
-import os.path as op
-import logging
 from glob import glob
+import logging
+from pathlib import Path
+import os.path as op
+import attrs
+import os
 
 
 def out_file_default(inputs):
@@ -21,6 +22,43 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
diff --git a/example-specs/task/nipype/fsl/robust_fov.yaml b/example-specs/task/nipype/fsl/robust_fov.yaml
index 79154107..151fb656 100644
--- a/example-specs/task/nipype/fsl/robust_fov.yaml
+++ b/example-specs/task/nipype/fsl/robust_fov.yaml
@@ -32,6 +32,9 @@ inputs:
     out_transform: Path
     # type=file: Transformation matrix in_file to out_roi output name
     # type=file|default=<undefined>: Transformation matrix in_file to out_roi output name
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/robust_fov_callables.py b/example-specs/task/nipype/fsl/robust_fov_callables.py
index 7c9e0402..03ef2380 100644
--- a/example-specs/task/nipype/fsl/robust_fov_callables.py
+++ b/example-specs/task/nipype/fsl/robust_fov_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of RobustFOV.yaml"""
 
-import os
-import attrs
-import os.path as op
 import logging
 from glob import glob
+import os.path as op
+import attrs
+import os
 
 
 def out_roi_callable(output_dir, inputs, stdout, stderr):
@@ -21,10 +21,47 @@ def out_transform_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_transform"]
 
 
+iflogger = logging.getLogger("nipype.interface")
+
+
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
-iflogger = logging.getLogger("nipype.interface")
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
 
 
 class Info(PackageInfo):
@@ -125,6 +162,16 @@ def _overload_extension(
     return value + Info.output_type_to_ext(inputs.output_type)
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/fsl/sig_loss.yaml b/example-specs/task/nipype/fsl/sig_loss.yaml
index c83bc2f5..67dcec9f 100644
--- a/example-specs/task/nipype/fsl/sig_loss.yaml
+++ b/example-specs/task/nipype/fsl/sig_loss.yaml
@@ -38,6 +38,9 @@ inputs:
     out_file: Path
     # type=file: signal loss estimate file
     # type=file|default=<undefined>: output signal loss estimate file
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/sig_loss_callables.py b/example-specs/task/nipype/fsl/sig_loss_callables.py
index 4e870b47..bab7e3c0 100644
--- a/example-specs/task/nipype/fsl/sig_loss_callables.py
+++ b/example-specs/task/nipype/fsl/sig_loss_callables.py
@@ -1,10 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of SigLoss.yaml"""
 
-import os
-import attrs
-import os.path as op
-import logging
 from glob import glob
+import logging
+from pathlib import Path
+import os.path as op
+import attrs
+import os
 
 
 def out_file_default(inputs):
@@ -21,6 +22,43 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
diff --git a/example-specs/task/nipype/fsl/slice.yaml b/example-specs/task/nipype/fsl/slice.yaml
index 887de4e9..cc5e6135 100644
--- a/example-specs/task/nipype/fsl/slice.yaml
+++ b/example-specs/task/nipype/fsl/slice.yaml
@@ -36,6 +36,9 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: medimage/nifti1
     # type=file|default=<undefined>: input filename
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/slice_callables.py b/example-specs/task/nipype/fsl/slice_callables.py
index 62b03cc6..8e921eca 100644
--- a/example-specs/task/nipype/fsl/slice_callables.py
+++ b/example-specs/task/nipype/fsl/slice_callables.py
@@ -1,9 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of Slice.yaml"""
 
-import os
 from glob import glob
-import attrs
+import logging
+from pathlib import Path
 import os.path as op
+import attrs
+import os
 
 
 def out_files_callable(output_dir, inputs, stdout, stderr):
@@ -13,10 +15,142 @@ def out_files_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_files"]
 
 
+IFLOGGER = logging.getLogger("nipype.interface")
+
+
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
+class Info(PackageInfo):
+    """
+    Handle FSL ``output_type`` and version information.
+
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
+
+    """
+
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
+
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
+
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
+
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
+
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
+
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
+
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
+
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
+
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
+
+        Returns a list of standard images if called without arguments.
+
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
+
+
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
diff --git a/example-specs/task/nipype/fsl/slice_timer.yaml b/example-specs/task/nipype/fsl/slice_timer.yaml
index c3d317f4..dff7e082 100644
--- a/example-specs/task/nipype/fsl/slice_timer.yaml
+++ b/example-specs/task/nipype/fsl/slice_timer.yaml
@@ -39,6 +39,11 @@ inputs:
     # type=file|default=<undefined>: filename of input timeseries
     out_file: Path
     # type=file|default=<undefined>: filename of output timeseries
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
+    out_file: out_file_default
+    # type=file|default=<undefined>: filename of output timeseries
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -57,8 +62,6 @@ outputs:
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
-    out_file: out_file_callable
-    # type=file|default=<undefined>: filename of output timeseries
   templates:
   # dict[str, str] - `output_file_template` values to be provided to output fields
   requirements:
diff --git a/example-specs/task/nipype/fsl/slice_timer_callables.py b/example-specs/task/nipype/fsl/slice_timer_callables.py
index 8546a28d..f57ce24d 100644
--- a/example-specs/task/nipype/fsl/slice_timer_callables.py
+++ b/example-specs/task/nipype/fsl/slice_timer_callables.py
@@ -1,10 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of SliceTimer.yaml"""
 
-import os
-import attrs
-import os.path as op
-import logging
 from glob import glob
+import logging
+from pathlib import Path
+import os.path as op
+import attrs
+import os
 
 
 def out_file_default(inputs):
@@ -21,6 +22,43 @@ def slice_time_corrected_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
diff --git a/example-specs/task/nipype/fsl/slicer.yaml b/example-specs/task/nipype/fsl/slicer.yaml
index 8d211f5c..da04f77e 100644
--- a/example-specs/task/nipype/fsl/slicer.yaml
+++ b/example-specs/task/nipype/fsl/slicer.yaml
@@ -44,6 +44,9 @@ inputs:
     out_file: Path
     # type=file: picture to write
     # type=file|default=<undefined>: picture to write
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/slicer_callables.py b/example-specs/task/nipype/fsl/slicer_callables.py
index 2d757273..269f0311 100644
--- a/example-specs/task/nipype/fsl/slicer_callables.py
+++ b/example-specs/task/nipype/fsl/slicer_callables.py
@@ -1,10 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of Slicer.yaml"""
 
-import os
-import attrs
-import os.path as op
-import logging
 from glob import glob
+import logging
+from pathlib import Path
+import os.path as op
+import attrs
+import os
 
 
 def out_file_default(inputs):
@@ -21,6 +22,43 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
diff --git a/example-specs/task/nipype/fsl/smm.yaml b/example-specs/task/nipype/fsl/smm.yaml
index 34aa637c..04aad0b3 100644
--- a/example-specs/task/nipype/fsl/smm.yaml
+++ b/example-specs/task/nipype/fsl/smm.yaml
@@ -29,6 +29,9 @@ inputs:
     # type=file|default=<undefined>: mask file
     spatial_data_file: generic/file
     # type=file|default=<undefined>: statistics spatial map
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/smm_callables.py b/example-specs/task/nipype/fsl/smm_callables.py
index 8947521b..0e833ebf 100644
--- a/example-specs/task/nipype/fsl/smm_callables.py
+++ b/example-specs/task/nipype/fsl/smm_callables.py
@@ -1,10 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of SMM.yaml"""
 
-import os
-import attrs
-import os.path as op
-import logging
 from glob import glob
+import logging
+from pathlib import Path
+import os.path as op
+import attrs
+import os
 
 
 def null_p_map_callable(output_dir, inputs, stdout, stderr):
@@ -31,6 +32,43 @@ def deactivation_p_map_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
diff --git a/example-specs/task/nipype/fsl/smooth.yaml b/example-specs/task/nipype/fsl/smooth.yaml
index fec86574..9c31083a 100644
--- a/example-specs/task/nipype/fsl/smooth.yaml
+++ b/example-specs/task/nipype/fsl/smooth.yaml
@@ -60,6 +60,9 @@ inputs:
     smoothed_file: Path
     # type=file: 
     # type=file|default=<undefined>: 
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/smooth_callables.py b/example-specs/task/nipype/fsl/smooth_callables.py
index 00d34e56..d09be82d 100644
--- a/example-specs/task/nipype/fsl/smooth_callables.py
+++ b/example-specs/task/nipype/fsl/smooth_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Smooth.yaml"""
 
-import os
-import attrs
-import os.path as op
 import logging
 from glob import glob
+import os.path as op
+import attrs
+import os
 
 
 def smoothed_file_callable(output_dir, inputs, stdout, stderr):
@@ -14,10 +14,47 @@ def smoothed_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["smoothed_file"]
 
 
+iflogger = logging.getLogger("nipype.interface")
+
+
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
-iflogger = logging.getLogger("nipype.interface")
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
 
 
 class Info(PackageInfo):
@@ -118,6 +155,16 @@ def _overload_extension(
     return value + Info.output_type_to_ext(inputs.output_type)
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/fsl/smooth_estimate.yaml b/example-specs/task/nipype/fsl/smooth_estimate.yaml
index 6ce6c70e..0acf4f9c 100644
--- a/example-specs/task/nipype/fsl/smooth_estimate.yaml
+++ b/example-specs/task/nipype/fsl/smooth_estimate.yaml
@@ -37,6 +37,9 @@ inputs:
     # type=file|default=<undefined>: residual-fit image file
     zstat_file: medimage/nifti-gz
     # type=file|default=<undefined>: zstat image file
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/smooth_estimate_callables.py b/example-specs/task/nipype/fsl/smooth_estimate_callables.py
index 20aaec48..79a92dd7 100644
--- a/example-specs/task/nipype/fsl/smooth_estimate_callables.py
+++ b/example-specs/task/nipype/fsl/smooth_estimate_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of SmoothEstimate.yaml"""
 
-import os
-import attrs
-import os.path as op
 import logging
 from glob import glob
+import os.path as op
+import attrs
+import os
 
 
 def dlh_callable(output_dir, inputs, stdout, stderr):
@@ -28,10 +28,47 @@ def resels_callable(output_dir, inputs, stdout, stderr):
     return outputs["resels"]
 
 
+iflogger = logging.getLogger("nipype.interface")
+
+
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
-iflogger = logging.getLogger("nipype.interface")
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
 
 
 class Info(PackageInfo):
@@ -132,6 +169,16 @@ def _overload_extension(
     return value + Info.output_type_to_ext(inputs.output_type)
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/fsl/spatial_filter.yaml b/example-specs/task/nipype/fsl/spatial_filter.yaml
index 2caa4035..2f09a218 100644
--- a/example-specs/task/nipype/fsl/spatial_filter.yaml
+++ b/example-specs/task/nipype/fsl/spatial_filter.yaml
@@ -27,6 +27,9 @@ inputs:
     out_file: Path
     # type=file: image written after calculations
     # type=file|default=<undefined>: image to write
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/spatial_filter_callables.py b/example-specs/task/nipype/fsl/spatial_filter_callables.py
index 03912482..78294b60 100644
--- a/example-specs/task/nipype/fsl/spatial_filter_callables.py
+++ b/example-specs/task/nipype/fsl/spatial_filter_callables.py
@@ -1,10 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of SpatialFilter.yaml"""
 
-import os
-import attrs
-import os.path as op
-import logging
 from glob import glob
+import logging
+from pathlib import Path
+import os.path as op
+import attrs
+import os
 
 
 def out_file_default(inputs):
@@ -21,6 +22,43 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
diff --git a/example-specs/task/nipype/fsl/split.yaml b/example-specs/task/nipype/fsl/split.yaml
index c2998b78..afa9aeaf 100644
--- a/example-specs/task/nipype/fsl/split.yaml
+++ b/example-specs/task/nipype/fsl/split.yaml
@@ -24,6 +24,9 @@ inputs:
   # passed to the field in the automatically generated unittests.
     in_file: generic/file
     # type=file|default=<undefined>: input filename
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/split_callables.py b/example-specs/task/nipype/fsl/split_callables.py
index 639debd0..73d0854b 100644
--- a/example-specs/task/nipype/fsl/split_callables.py
+++ b/example-specs/task/nipype/fsl/split_callables.py
@@ -1,8 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of Split.yaml"""
 
-import os
 from glob import glob
 import attrs
+import logging
+import os
 
 
 def out_files_callable(output_dir, inputs, stdout, stderr):
@@ -12,10 +13,142 @@ def out_files_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_files"]
 
 
+IFLOGGER = logging.getLogger("nipype.interface")
+
+
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
+class Info(PackageInfo):
+    """
+    Handle FSL ``output_type`` and version information.
+
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
+
+    """
+
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
+
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
+
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
+
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
+
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
+
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
+
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
+
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
+
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
+
+        Returns a list of standard images if called without arguments.
+
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
+
+
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     """Create a Bunch which contains all possible files generated
     by running the interface.  Some files are always generated, others
diff --git a/example-specs/task/nipype/fsl/std_image.yaml b/example-specs/task/nipype/fsl/std_image.yaml
index c2bd0928..7e77e98b 100644
--- a/example-specs/task/nipype/fsl/std_image.yaml
+++ b/example-specs/task/nipype/fsl/std_image.yaml
@@ -27,6 +27,9 @@ inputs:
     out_file: Path
     # type=file: image written after calculations
     # type=file|default=<undefined>: image to write
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/std_image_callables.py b/example-specs/task/nipype/fsl/std_image_callables.py
index c1ae7ce5..3cf12051 100644
--- a/example-specs/task/nipype/fsl/std_image_callables.py
+++ b/example-specs/task/nipype/fsl/std_image_callables.py
@@ -1,10 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of StdImage.yaml"""
 
-import os
-import attrs
-import os.path as op
-import logging
 from glob import glob
+import logging
+from pathlib import Path
+import os.path as op
+import attrs
+import os
 
 
 def out_file_default(inputs):
@@ -21,6 +22,43 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
diff --git a/example-specs/task/nipype/fsl/susan.yaml b/example-specs/task/nipype/fsl/susan.yaml
index cf6d21a9..527da306 100644
--- a/example-specs/task/nipype/fsl/susan.yaml
+++ b/example-specs/task/nipype/fsl/susan.yaml
@@ -41,6 +41,11 @@ inputs:
     # type=file|default=<undefined>: filename of input timeseries
     out_file: Path
     # type=file|default=<undefined>: output file name
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
+    out_file: out_file_default
+    # type=file|default=<undefined>: output file name
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
@@ -59,8 +64,6 @@ outputs:
   callables:
   # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
   # to set to the `callable` attribute of output fields
-    out_file: out_file_callable
-    # type=file|default=<undefined>: output file name
   templates:
   # dict[str, str] - `output_file_template` values to be provided to output fields
   requirements:
diff --git a/example-specs/task/nipype/fsl/susan_callables.py b/example-specs/task/nipype/fsl/susan_callables.py
index 5d8ac242..902d0a1e 100644
--- a/example-specs/task/nipype/fsl/susan_callables.py
+++ b/example-specs/task/nipype/fsl/susan_callables.py
@@ -1,10 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of SUSAN.yaml"""
 
-import os
-import attrs
-import os.path as op
-import logging
 from glob import glob
+import logging
+from pathlib import Path
+import os.path as op
+import attrs
+import os
 
 
 def out_file_default(inputs):
@@ -21,6 +22,43 @@ def smoothed_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
diff --git a/example-specs/task/nipype/fsl/swap_dimensions.yaml b/example-specs/task/nipype/fsl/swap_dimensions.yaml
index a6c6572f..f0be3678 100644
--- a/example-specs/task/nipype/fsl/swap_dimensions.yaml
+++ b/example-specs/task/nipype/fsl/swap_dimensions.yaml
@@ -32,6 +32,9 @@ inputs:
     out_file: Path
     # type=file: image with new dimensions
     # type=file|default=<undefined>: image to write
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/swap_dimensions_callables.py b/example-specs/task/nipype/fsl/swap_dimensions_callables.py
index 992d84ce..8e47e87a 100644
--- a/example-specs/task/nipype/fsl/swap_dimensions_callables.py
+++ b/example-specs/task/nipype/fsl/swap_dimensions_callables.py
@@ -1,10 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of SwapDimensions.yaml"""
 
-import os
-import attrs
-import os.path as op
-import logging
 from glob import glob
+import logging
+from pathlib import Path
+import os.path as op
+import attrs
+import os
 
 
 def out_file_default(inputs):
@@ -21,6 +22,43 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
diff --git a/example-specs/task/nipype/fsl/temporal_filter.yaml b/example-specs/task/nipype/fsl/temporal_filter.yaml
index 84311577..0534a5be 100644
--- a/example-specs/task/nipype/fsl/temporal_filter.yaml
+++ b/example-specs/task/nipype/fsl/temporal_filter.yaml
@@ -28,6 +28,9 @@ inputs:
     out_file: Path
     # type=file: image written after calculations
     # type=file|default=<undefined>: image to write
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/temporal_filter_callables.py b/example-specs/task/nipype/fsl/temporal_filter_callables.py
index f62b0b52..d6e9fa55 100644
--- a/example-specs/task/nipype/fsl/temporal_filter_callables.py
+++ b/example-specs/task/nipype/fsl/temporal_filter_callables.py
@@ -1,10 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of TemporalFilter.yaml"""
 
-import os
-import attrs
-import os.path as op
-import logging
 from glob import glob
+import logging
+from pathlib import Path
+import os.path as op
+import attrs
+import os
 
 
 def out_file_default(inputs):
@@ -21,6 +22,43 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
diff --git a/example-specs/task/nipype/fsl/text_2_vest.yaml b/example-specs/task/nipype/fsl/text_2_vest.yaml
index b608dfa3..b8f18b2d 100644
--- a/example-specs/task/nipype/fsl/text_2_vest.yaml
+++ b/example-specs/task/nipype/fsl/text_2_vest.yaml
@@ -38,6 +38,9 @@ inputs:
     out_file: Path
     # type=file: matrix data in the format used by FSL tools
     # type=file|default=<undefined>: file name to store matrix data in the format used by FSL tools (e.g., design.mat, design.con design.fts)
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/text_2_vest_callables.py b/example-specs/task/nipype/fsl/text_2_vest_callables.py
index a3e14842..403cecbc 100644
--- a/example-specs/task/nipype/fsl/text_2_vest_callables.py
+++ b/example-specs/task/nipype/fsl/text_2_vest_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Text2Vest.yaml"""
 
-import os
-import attrs
-import os.path as op
 import logging
 from glob import glob
+import os.path as op
+import attrs
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -14,10 +14,47 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_file"]
 
 
+iflogger = logging.getLogger("nipype.interface")
+
+
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
-iflogger = logging.getLogger("nipype.interface")
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
 
 
 class Info(PackageInfo):
@@ -118,6 +155,16 @@ def _overload_extension(
     return value + Info.output_type_to_ext(inputs.output_type)
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/fsl/threshold.yaml b/example-specs/task/nipype/fsl/threshold.yaml
index ebb81daf..a9c7d62e 100644
--- a/example-specs/task/nipype/fsl/threshold.yaml
+++ b/example-specs/task/nipype/fsl/threshold.yaml
@@ -25,6 +25,9 @@ inputs:
     out_file: Path
     # type=file: image written after calculations
     # type=file|default=<undefined>: image to write
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/threshold_callables.py b/example-specs/task/nipype/fsl/threshold_callables.py
index f5cd1f08..9258a1d4 100644
--- a/example-specs/task/nipype/fsl/threshold_callables.py
+++ b/example-specs/task/nipype/fsl/threshold_callables.py
@@ -1,10 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of Threshold.yaml"""
 
-import os
-import attrs
-import os.path as op
-import logging
 from glob import glob
+import logging
+from pathlib import Path
+import os.path as op
+import attrs
+import os
 
 
 def out_file_default(inputs):
@@ -21,6 +22,43 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
diff --git a/example-specs/task/nipype/fsl/topup.yaml b/example-specs/task/nipype/fsl/topup.yaml
index 27c1f78c..f6cb6c7f 100644
--- a/example-specs/task/nipype/fsl/topup.yaml
+++ b/example-specs/task/nipype/fsl/topup.yaml
@@ -56,6 +56,9 @@ inputs:
     out_logfile: Path
     # type=file: name of log-file
     # type=file|default=<undefined>: name of log-file
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/topup_callables.py b/example-specs/task/nipype/fsl/topup_callables.py
index ad56f18e..335182b4 100644
--- a/example-specs/task/nipype/fsl/topup_callables.py
+++ b/example-specs/task/nipype/fsl/topup_callables.py
@@ -1,11 +1,12 @@
 """Module to put any functions that are referred to in the "callables" section of TOPUP.yaml"""
 
-import attrs
 import logging
-from glob import glob
-import os
+from pathlib import Path
 import nibabel as nb
+from glob import glob
 import os.path as op
+import attrs
+import os
 
 
 def out_fieldcoef_callable(output_dir, inputs, stdout, stderr):
@@ -71,10 +72,47 @@ def out_logfile_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_logfile"]
 
 
+iflogger = logging.getLogger("nipype.interface")
+
+
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
-iflogger = logging.getLogger("nipype.interface")
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
 
 
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
@@ -322,6 +360,16 @@ def _gen_fname(
     return fname
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -489,6 +537,135 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
+class Info(PackageInfo):
+    """
+    Handle FSL ``output_type`` and version information.
+
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
+
+    """
+
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
+
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
+
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
+
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
+
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
+
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
+
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
+
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
+
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
+
+        Returns a list of standard images if called without arguments.
+
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/fsl/tract_skeleton.yaml b/example-specs/task/nipype/fsl/tract_skeleton.yaml
index 271adccf..05335385 100644
--- a/example-specs/task/nipype/fsl/tract_skeleton.yaml
+++ b/example-specs/task/nipype/fsl/tract_skeleton.yaml
@@ -57,6 +57,9 @@ inputs:
     # type=file|default=<undefined>: input data projected onto skeleton
     search_mask_file: generic/file
     # type=file|default=<undefined>: mask in which to use alternate search rule
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/tract_skeleton_callables.py b/example-specs/task/nipype/fsl/tract_skeleton_callables.py
index 33f142e1..20c8eb7c 100644
--- a/example-specs/task/nipype/fsl/tract_skeleton_callables.py
+++ b/example-specs/task/nipype/fsl/tract_skeleton_callables.py
@@ -1,7 +1,8 @@
 """Module to put any functions that are referred to in the "callables" section of TractSkeleton.yaml"""
 
-import attrs
+from pathlib import Path
 import os.path as op
+import attrs
 
 
 def projected_data_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/fsl/training.yaml b/example-specs/task/nipype/fsl/training.yaml
index 5c972428..52ac3028 100644
--- a/example-specs/task/nipype/fsl/training.yaml
+++ b/example-specs/task/nipype/fsl/training.yaml
@@ -24,6 +24,9 @@ inputs:
   # passed to the field in the automatically generated unittests.
     mel_icas: generic/directory+list-of
     # type=inputmultiobject|default=[]: Melodic output directories
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/training_callables.py b/example-specs/task/nipype/fsl/training_callables.py
index 0d5195d8..1ac9734b 100644
--- a/example-specs/task/nipype/fsl/training_callables.py
+++ b/example-specs/task/nipype/fsl/training_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of Training.yaml"""
 
-import os
 import attrs
+import os
 
 
 def trained_wts_file_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/fsl/training_set_creator.yaml b/example-specs/task/nipype/fsl/training_set_creator.yaml
index 4024408c..af7716c7 100644
--- a/example-specs/task/nipype/fsl/training_set_creator.yaml
+++ b/example-specs/task/nipype/fsl/training_set_creator.yaml
@@ -29,6 +29,9 @@ inputs:
   # passed to the field in the automatically generated unittests.
     mel_icas_in: generic/directory+list-of
     # type=inputmultiobject|default=[]: Melodic output directories
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/unary_maths.yaml b/example-specs/task/nipype/fsl/unary_maths.yaml
index 8df0c997..2c0829b0 100644
--- a/example-specs/task/nipype/fsl/unary_maths.yaml
+++ b/example-specs/task/nipype/fsl/unary_maths.yaml
@@ -25,6 +25,9 @@ inputs:
     out_file: Path
     # type=file: image written after calculations
     # type=file|default=<undefined>: image to write
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/unary_maths_callables.py b/example-specs/task/nipype/fsl/unary_maths_callables.py
index 27ade468..224f7db4 100644
--- a/example-specs/task/nipype/fsl/unary_maths_callables.py
+++ b/example-specs/task/nipype/fsl/unary_maths_callables.py
@@ -1,10 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of UnaryMaths.yaml"""
 
-import os
-import attrs
-import os.path as op
-import logging
 from glob import glob
+import logging
+from pathlib import Path
+import os.path as op
+import attrs
+import os
 
 
 def out_file_default(inputs):
@@ -21,6 +22,43 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
diff --git a/example-specs/task/nipype/fsl/vec_reg.yaml b/example-specs/task/nipype/fsl/vec_reg.yaml
index fc61d08e..a17eea51 100644
--- a/example-specs/task/nipype/fsl/vec_reg.yaml
+++ b/example-specs/task/nipype/fsl/vec_reg.yaml
@@ -51,6 +51,9 @@ inputs:
     # type=file|default=<undefined>: filename for secondary warp field if set, this will be used for the rotation of the vector/tensor field
     warp_field: generic/file
     # type=file|default=<undefined>: filename for 4D warp field for nonlinear registration
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/vec_reg_callables.py b/example-specs/task/nipype/fsl/vec_reg_callables.py
index 2c3dd98a..5e5a9d86 100644
--- a/example-specs/task/nipype/fsl/vec_reg_callables.py
+++ b/example-specs/task/nipype/fsl/vec_reg_callables.py
@@ -1,10 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of VecReg.yaml"""
 
-import os
-import attrs
-import os.path as op
-import logging
 from glob import glob
+import logging
+from pathlib import Path
+import os.path as op
+import attrs
+import os
 
 
 def out_file_default(inputs):
@@ -21,6 +22,43 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
diff --git a/example-specs/task/nipype/fsl/vest_2_text.yaml b/example-specs/task/nipype/fsl/vest_2_text.yaml
index 4b696f1a..d022a691 100644
--- a/example-specs/task/nipype/fsl/vest_2_text.yaml
+++ b/example-specs/task/nipype/fsl/vest_2_text.yaml
@@ -37,6 +37,9 @@ inputs:
     out_file: Path
     # type=file: plain text representation of FSL matrix
     # type=file|default='design.txt': file name to store text output from matrix
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/vest_2_text_callables.py b/example-specs/task/nipype/fsl/vest_2_text_callables.py
index c2091f41..9efcea5e 100644
--- a/example-specs/task/nipype/fsl/vest_2_text_callables.py
+++ b/example-specs/task/nipype/fsl/vest_2_text_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Vest2Text.yaml"""
 
-import os
-import attrs
-import os.path as op
 import logging
 from glob import glob
+import os.path as op
+import attrs
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -14,10 +14,47 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_file"]
 
 
+iflogger = logging.getLogger("nipype.interface")
+
+
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
-iflogger = logging.getLogger("nipype.interface")
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
 
 
 class Info(PackageInfo):
@@ -118,6 +155,16 @@ def _overload_extension(
     return value + Info.output_type_to_ext(inputs.output_type)
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/fsl/warp_points.yaml b/example-specs/task/nipype/fsl/warp_points.yaml
index 740df315..3ddb40e9 100644
--- a/example-specs/task/nipype/fsl/warp_points.yaml
+++ b/example-specs/task/nipype/fsl/warp_points.yaml
@@ -54,6 +54,9 @@ inputs:
     # type=file|default=<undefined>: filename of warpfield (e.g. intermediate2dest_warp.nii.gz)
     xfm_file: generic/file
     # type=file|default=<undefined>: filename of affine transform (e.g. source2dest.mat)
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/warp_points_callables.py b/example-specs/task/nipype/fsl/warp_points_callables.py
index d2c5fc3d..f4a6c46b 100644
--- a/example-specs/task/nipype/fsl/warp_points_callables.py
+++ b/example-specs/task/nipype/fsl/warp_points_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of WarpPoints.yaml"""
 
-import os
+import logging
 import os.path as op
 import attrs
-import logging
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -23,6 +23,16 @@ def _overload_extension(
         return "%s.%s" % (value, getattr(self, "_outformat"))
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/fsl/warp_points_from_std.yaml b/example-specs/task/nipype/fsl/warp_points_from_std.yaml
index 4737ba00..9642f878 100644
--- a/example-specs/task/nipype/fsl/warp_points_from_std.yaml
+++ b/example-specs/task/nipype/fsl/warp_points_from_std.yaml
@@ -51,6 +51,9 @@ inputs:
     # type=file|default=<undefined>: filename of warpfield (e.g. intermediate2dest_warp.nii.gz)
     xfm_file: generic/file
     # type=file|default=<undefined>: filename of affine transform (e.g. source2dest.mat)
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/warp_points_to_std.yaml b/example-specs/task/nipype/fsl/warp_points_to_std.yaml
index c0a108dd..84f714e1 100644
--- a/example-specs/task/nipype/fsl/warp_points_to_std.yaml
+++ b/example-specs/task/nipype/fsl/warp_points_to_std.yaml
@@ -58,6 +58,9 @@ inputs:
     # type=file|default=<undefined>: filename of warpfield (e.g. intermediate2dest_warp.nii.gz)
     xfm_file: generic/file
     # type=file|default=<undefined>: filename of affine transform (e.g. source2dest.mat)
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/warp_points_to_std_callables.py b/example-specs/task/nipype/fsl/warp_points_to_std_callables.py
index dcef9677..ac832e5d 100644
--- a/example-specs/task/nipype/fsl/warp_points_to_std_callables.py
+++ b/example-specs/task/nipype/fsl/warp_points_to_std_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of WarpPointsToStd.yaml"""
 
-import os
+import logging
 import os.path as op
 import attrs
-import logging
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -23,6 +23,16 @@ def _overload_extension(
         return "%s.%s" % (value, getattr(self, "_outformat"))
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/fsl/warp_utils.yaml b/example-specs/task/nipype/fsl/warp_utils.yaml
index a3cc43da..558d63fa 100644
--- a/example-specs/task/nipype/fsl/warp_utils.yaml
+++ b/example-specs/task/nipype/fsl/warp_utils.yaml
@@ -49,6 +49,9 @@ inputs:
     # type=file|default=<undefined>: Specifies that a (3D) file of Jacobian determinants corresponding to --in should be produced and written to filename.
     reference: medimage/nifti1
     # type=file|default=<undefined>: Name of a file in target space. Note that the target space is now different from the target space that was used to create the --warp file. It would typically be the file that was specified with the --in argument when running fnirt.
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/warp_utils_callables.py b/example-specs/task/nipype/fsl/warp_utils_callables.py
index e8dbca2b..b197536b 100644
--- a/example-specs/task/nipype/fsl/warp_utils_callables.py
+++ b/example-specs/task/nipype/fsl/warp_utils_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of WarpUtils.yaml"""
 
-import os
-import attrs
-import os.path as op
 import logging
 from glob import glob
+import os.path as op
+import attrs
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -21,10 +21,47 @@ def out_jacobian_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_jacobian"]
 
 
+iflogger = logging.getLogger("nipype.interface")
+
+
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
-iflogger = logging.getLogger("nipype.interface")
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
 
 
 class Info(PackageInfo):
@@ -125,6 +162,16 @@ def _overload_extension(
     return value + Info.output_type_to_ext(inputs.output_type)
 
 
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
diff --git a/example-specs/task/nipype/fsl/x_fibres_5.yaml b/example-specs/task/nipype/fsl/x_fibres_5.yaml
index a49c6ccf..9ea798fb 100644
--- a/example-specs/task/nipype/fsl/x_fibres_5.yaml
+++ b/example-specs/task/nipype/fsl/x_fibres_5.yaml
@@ -35,6 +35,9 @@ inputs:
     # type=directory|default='.': 
     mask: generic/file
     # type=file|default=<undefined>: brain binary mask file (i.e. from BET)
+  callable_defaults:
+  # dict[str, str] - names of methods/callable classes defined in the adjacent `*_callables.py`
+  # to set as the `default` method of input fields
   metadata:
   # dict[str, dict[str, any]] - additional metadata to set on any of the input fields (e.g. out_file: position: 1)
 outputs:
diff --git a/example-specs/task/nipype/fsl/x_fibres_5_callables.py b/example-specs/task/nipype/fsl/x_fibres_5_callables.py
index 06c11d88..06533fd4 100644
--- a/example-specs/task/nipype/fsl/x_fibres_5_callables.py
+++ b/example-specs/task/nipype/fsl/x_fibres_5_callables.py
@@ -1,10 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of XFibres5.yaml"""
 
-import os
-import attrs
-import os.path as op
-import logging
 from glob import glob
+import logging
+from pathlib import Path
+import os.path as op
+import attrs
+import os
 
 
 def dyads_callable(output_dir, inputs, stdout, stderr):
@@ -66,6 +67,43 @@ def thsamples_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
diff --git a/nipype2pydra/pkg_gen/__init__.py b/nipype2pydra/pkg_gen/__init__.py
index 766d3919..d9c6a71e 100644
--- a/nipype2pydra/pkg_gen/__init__.py
+++ b/nipype2pydra/pkg_gen/__init__.py
@@ -142,7 +142,9 @@ def parse(
                 elif output_type_str == "Directory":
                     parsed.dir_outputs.append(outpt_name)
                 elif output_type_str in ("OutputMultiObject", "List"):
-                    inner_type_str = type(outpt.trait_type.item_trait.trait_type).__name__
+                    inner_type_str = type(
+                        outpt.trait_type.item_trait.trait_type
+                    ).__name__
                     if inner_type_str == "Directory":
                         parsed.dir_outputs.append(outpt_name)
                     elif inner_type_str == "File":
@@ -277,7 +279,12 @@ def type2str(tp):
             "inputs": self._fields_stub(
                 "inputs",
                 InputsConverter,
-                {"types": {n: type2str(t) for n, t in input_types.items()}},
+                {
+                    "types": {n: type2str(t) for n, t in input_types.items()},
+                    "callable_defaults": {
+                        n: f"{n}_default" for n in sorted(self.callable_defaults)
+                    },
+                },
             ),
             "outputs": self._fields_stub(
                 "outputs",
@@ -830,7 +837,9 @@ def common_parent_pkg_prefix(mod_name: str) -> str:
             return ""
         return "_".join(common) + "__"
 
-    def find_nested_methods(methods: ty.List[ty.Callable], interface=None) -> ty.Dict[str, ty.Callable]:
+    def find_nested_methods(
+        methods: ty.List[ty.Callable], interface=None
+    ) -> ty.Dict[str, ty.Callable]:
         if interface is None:
             interface = nipype_interface
         all_nested = {}
@@ -885,7 +894,9 @@ def process_method(
         if hasattr(nipype_interface, "_cmd"):
             body = body.replace("self.cmd", f'"{nipype_interface._cmd}"')
         body = body.replace("self.", "")
-        body = re.sub(r"super\([^\)]*\)\.(\w+)\(", lambda m: name_map[m.group(1)] + "(", body)
+        body = re.sub(
+            r"super\([^\)]*\)\.(\w+)\(", lambda m: name_map[m.group(1)] + "(", body
+        )
         body = re.sub(r"\w+runtime\.(stdout|stderr)", r"\1", body)
         body = body.replace("os.getcwd()", "output_dir")
         # drop 'self' from the args and add the implicit callable args
@@ -931,7 +942,9 @@ def insert_args_in_method_calls(
                 outer_name = name
             else:
                 if outer_name:
-                    new_sig = insert_args_in_method_calls(new_sig, args, name_map=name_map)
+                    new_sig = insert_args_in_method_calls(
+                        new_sig, args, name_map=name_map
+                    )
                     new_src += name_map[outer_name] + new_sig
                     outer_name = None
                 else:
diff --git a/nipype2pydra/task/base.py b/nipype2pydra/task/base.py
index 6a0ddc89..a8aab4ad 100644
--- a/nipype2pydra/task/base.py
+++ b/nipype2pydra/task/base.py
@@ -564,9 +564,10 @@ def pydra_fld_input(self, field, nm):
                     specs.Directory,
                 ]:  # since this is a template, the file doesn't exist
                     pydra_type = Path
-            elif nm not in self.outputs.callables:
+            elif nm not in self.inputs.callable_defaults:
                 raise Exception(
-                    f"the filed {nm} has genfile=True, but no output template or callables_module provided"
+                    f"the filed {nm} has genfile=True, but no template or "
+                    "`callables_default` function in the callables_module provided"
                 )
 
         pydra_metadata.update(metadata_extra_spec)
diff --git a/nipype2pydra/utils.py b/nipype2pydra/utils.py
index 4ba64d7a..45c87ea6 100644
--- a/nipype2pydra/utils.py
+++ b/nipype2pydra/utils.py
@@ -269,7 +269,7 @@ class UsedSymbols:
 
     imports: ty.Set[str] = attrs.field(factory=set)
     funcs_to_include: ty.Set[ty.Tuple[str, ty.Callable]] = attrs.field(factory=set)
-    classes_to_include: ty.List[ty.Tuple[str, ty.Callable]] = attrs.field(factory=set)
+    classes_to_include: ty.List[ty.Tuple[str, ty.Callable]] = attrs.field(factory=list)
     local_functions: ty.Set[ty.Callable] = attrs.field(factory=set)
     local_classes: ty.List[type] = attrs.field(factory=list)
     constants: ty.Set[ty.Tuple[str, str]] = attrs.field(factory=set)
@@ -278,6 +278,14 @@ def update(self, other: "UsedSymbols"):
         self.imports.update(other.imports)
         self.funcs_to_include.update(other.funcs_to_include)
         self.funcs_to_include.update((f.__name__, f) for f in other.local_functions)
+        self.classes_to_include.extend(
+            c for c in other.classes_to_include if c not in self.classes_to_include
+        )
+        self.classes_to_include.extend(
+            (c.__name__, c)
+            for c in other.local_classes
+            if (c.__name__, c) not in self.classes_to_include
+        )
         self.constants.update(other.constants)
 
     @classmethod
@@ -417,9 +425,8 @@ def find(
                         if not (
                             (
                                 inspect.isclass(getattr(mod, p[0]))
-                                and not (
-                                    issubclass(getattr(mod, p[0]), BaseInterface)
-                                    or issubclass(getattr(mod, p[0]), TraitedSpec)
+                                and issubclass(
+                                    getattr(mod, p[0]), (BaseInterface, TraitedSpec)
                                 )
                             )
                             or getattr(mod, p[0]) in (Undefined, isdefined)
@@ -447,7 +454,10 @@ def find(
                                 if issubclass(atr, BaseInterface):
                                     # TODO: add warning here
                                     continue  # Don't include nipype interfaces as it gets silly
-                                used.classes_to_include.add((used_part[-1], atr))
+                                # We can't use a set here because we need to preserve the order
+                                class_def = (used_part[-1], atr)
+                                if class_def not in used.classes_to_include:
+                                    used.classes_to_include.append(class_def)
                                 class_body = split_parens_contents(
                                     inspect.getsource(atr)
                                 )[2].split("\n", 1)[1]

From 4a1e434c3c4d7f8f8853e7185a9715b309869e8a Mon Sep 17 00:00:00 2001
From: Tom Close <tom.g.close@gmail.com>
Date: Wed, 13 Mar 2024 13:49:06 +1100
Subject: [PATCH 62/78] added fileformats requirements to tests

---
 .github/workflows/tests.yml           |  6 ++++++
 required-fileformats/requirements.txt | 29 ---------------------------
 2 files changed, 6 insertions(+), 29 deletions(-)

diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
index 181bd372..5b2e47fb 100644
--- a/.github/workflows/tests.yml
+++ b/.github/workflows/tests.yml
@@ -35,6 +35,12 @@ jobs:
     - name: Update build tools
       run: python -m pip install --upgrade pip
 
+    - name: Install required file-formats packages
+      run: |
+        pushd required-fileformats
+        python -m pip install -r requirements.txt
+        popd
+
     - name: Install Package
       run: python -m pip install -e .[test]
 
diff --git a/required-fileformats/requirements.txt b/required-fileformats/requirements.txt
index 3ac37073..1ad26fca 100644
--- a/required-fileformats/requirements.txt
+++ b/required-fileformats/requirements.txt
@@ -1,33 +1,4 @@
 -e ./afni
 -e ./ants
--e ./brainsuite
--e ./bru2nii
--e ./c3
--e ./camino
--e ./camino2trackvis
--e ./cat12
--e ./cmtk
--e ./dcmstack
--e ./diffusion_toolkit
--e ./dipy
--e ./dtitk
--e ./dynamic_slicer
--e ./elastix
 -e ./freesurfer
 -e ./fsl
--e ./meshfix
--e ./minc
--e ./mipav
--e ./niftyfit
--e ./niftyreg
--e ./niftyseg
--e ./nilearn
--e ./nitime
--e ./petpvc
--e ./quickshear
--e ./robex
--e ./semtools
--e ./slicer
--e ./spm
--e ./vista
--e ./workbench
\ No newline at end of file

From 5d0760896603ccec955e2fd5809267c6cd4aee1a Mon Sep 17 00:00:00 2001
From: Tom Close <tom.g.close@gmail.com>
Date: Thu, 14 Mar 2024 16:31:37 +1100
Subject: [PATCH 63/78] all tests pass after generation

---
 .../task/nipype/afni/a_boverlap_callables.py  |  64 +-
 .../nipype/afni/afn_ito_nifti_callables.py    | 113 +--
 .../afni/align_epi_anat_py_callables.py       |  95 +--
 .../task/nipype/afni/allineate_callables.py   | 118 +--
 .../nipype/afni/auto_tcorrelate_callables.py  | 112 +--
 .../task/nipype/afni/auto_tlrc_callables.py   |  12 +-
 .../task/nipype/afni/autobox_callables.py     |  64 +-
 .../task/nipype/afni/automask_callables.py    |  64 +-
 .../task/nipype/afni/axialize_callables.py    |  64 +-
 .../task/nipype/afni/bandpass_callables.py    |  64 +-
 .../nipype/afni/blur_in_mask_callables.py     |  64 +-
 .../nipype/afni/blur_to_fwhm_callables.py     |  64 +-
 .../task/nipype/afni/brick_stat_callables.py  |   8 +-
 .../task/nipype/afni/bucket_callables.py      |  64 +-
 .../task/nipype/afni/calc_callables.py        |  64 +-
 .../task/nipype/afni/cat_callables.py         |  64 +-
 .../task/nipype/afni/cat_matvec_callables.py  |  64 +-
 .../task/nipype/afni/center_mass.yaml         |   2 +-
 .../task/nipype/afni/center_mass_callables.py |  11 +-
 .../task/nipype/afni/clip_level_callables.py  |   8 +-
 .../nipype/afni/convert_dset_callables.py     |   3 +
 .../task/nipype/afni/copy_callables.py        |  64 +-
 .../task/nipype/afni/deconvolve_callables.py  |  11 +-
 .../afni/degree_centrality_callables.py       |  64 +-
 .../task/nipype/afni/despike_callables.py     |  64 +-
 .../task/nipype/afni/detrend_callables.py     |  64 +-
 example-specs/task/nipype/afni/dot.yaml       |   2 +-
 .../task/nipype/afni/dot_callables.py         |  64 +-
 .../task/nipype/afni/ecm_callables.py         |  64 +-
 .../task/nipype/afni/edge_3_callables.py      |  64 +-
 .../task/nipype/afni/eval_callables.py        |  64 +-
 .../task/nipype/afni/fim_callables.py         |  64 +-
 .../task/nipype/afni/fourier_callables.py     |  64 +-
 .../task/nipype/afni/fwh_mx_callables.py      |  11 +-
 .../task/nipype/afni/gcor_callables.py        |   4 +
 .../task/nipype/afni/hist_callables.py        |  11 +-
 .../task/nipype/afni/lfcd_callables.py        |  64 +-
 .../nipype/afni/local_bistat_callables.py     |  64 +-
 .../task/nipype/afni/localstat_callables.py   |  64 +-
 .../task/nipype/afni/mask_tool_callables.py   |  64 +-
 .../task/nipype/afni/maskave_callables.py     |  64 +-
 .../task/nipype/afni/means_callables.py       |  64 +-
 .../task/nipype/afni/merge_callables.py       |  64 +-
 .../task/nipype/afni/net_corr_callables.py    |  12 +-
 .../task/nipype/afni/notes_callables.py       |   3 +
 .../nipype/afni/nwarp_adjust_callables.py     |   5 +-
 .../task/nipype/afni/nwarp_apply_callables.py |   8 +-
 .../task/nipype/afni/nwarp_cat_callables.py   |  11 +-
 .../task/nipype/afni/one_d_tool_py.yaml       |   2 +-
 .../nipype/afni/one_d_tool_py_callables.py    |   4 +-
 .../nipype/afni/outlier_count_callables.py    |   3 +
 .../nipype/afni/quality_index_callables.py    |   8 +-
 example-specs/task/nipype/afni/qwarp.yaml     |   2 +-
 .../task/nipype/afni/qwarp_callables.py       | 186 +----
 .../task/nipype/afni/qwarp_plus_minus.yaml    |   2 +-
 .../nipype/afni/qwarp_plus_minus_callables.py | 186 +----
 .../task/nipype/afni/re_ho_callables.py       |   9 +-
 .../task/nipype/afni/refit_callables.py       |   3 +
 .../task/nipype/afni/remlfit_callables.py     |   4 +-
 .../task/nipype/afni/resample_callables.py    |  64 +-
 .../task/nipype/afni/retroicor_callables.py   |  64 +-
 .../task/nipype/afni/roi_stats_callables.py   |   8 +-
 .../task/nipype/afni/seg_callables.py         |   8 +-
 .../task/nipype/afni/skull_strip_callables.py |  64 +-
 .../task/nipype/afni/svm_test_callables.py    |  64 +-
 .../task/nipype/afni/svm_train_callables.py   |  64 +-
 .../task/nipype/afni/synthesize_callables.py  |   4 +-
 .../task/nipype/afni/t_cat_callables.py       |  64 +-
 .../nipype/afni/t_cat_sub_brick_callables.py  | 152 ++--
 .../task/nipype/afni/t_corr_1d_callables.py   |  64 +-
 .../task/nipype/afni/t_corr_map.yaml          |   2 +-
 .../task/nipype/afni/t_corr_map_callables.py  |  64 +-
 .../task/nipype/afni/t_correlate_callables.py |  64 +-
 .../task/nipype/afni/t_norm_callables.py      |  64 +-
 .../task/nipype/afni/t_project_callables.py   |  64 +-
 .../task/nipype/afni/t_shift_callables.py     |  64 +-
 .../task/nipype/afni/t_smooth_callables.py    |  64 +-
 .../task/nipype/afni/t_stat_callables.py      |  64 +-
 .../task/nipype/afni/to_3d_callables.py       |  64 +-
 .../task/nipype/afni/undump_callables.py      |  64 +-
 .../task/nipype/afni/unifize_callables.py     |  64 +-
 .../task/nipype/afni/volreg_callables.py      |  64 +-
 .../task/nipype/afni/warp_callables.py        | 117 +--
 .../task/nipype/afni/z_cut_up_callables.py    |  64 +-
 .../task/nipype/afni/zcat_callables.py        |  64 +-
 .../task/nipype/afni/zeropad_callables.py     |  64 +-
 .../ants/affine_initializer_callables.py      |   3 +
 .../task/nipype/ants/ai_callables.py          |   4 +
 .../task/nipype/ants/ants_callables.py        |   3 +
 .../ants/ants_introduction_callables.py       |   4 +-
 .../nipype/ants/apply_transforms_callables.py |   5 +-
 .../apply_transforms_to_points_callables.py   |   8 +-
 .../task/nipype/ants/atropos_callables.py     |   5 +-
 .../average_affine_transform_callables.py     |   3 +
 .../nipype/ants/average_images_callables.py   |   3 +
 .../nipype/ants/brain_extraction_callables.py |   4 +-
 .../ants/buildtemplateparallel_callables.py   |   8 +-
 .../ants/compose_multi_transform_callables.py |   8 +-
 .../composite_transform_util_callables.py     |   3 +
 .../convert_scalar_image_to_rgb_callables.py  |   3 +
 .../ants/cortical_thickness_callables.py      |   3 +
 ...te_jacobian_determinant_image_callables.py |   3 +
 .../ants/create_tiled_mosaic_callables.py     |   3 +
 .../nipype/ants/denoise_image_callables.py    |   8 +-
 .../nipype/ants/gen_warp_fields_callables.py  |   4 +-
 .../task/nipype/ants/image_math_callables.py  |   8 +-
 .../nipype/ants/joint_fusion_callables.py     |   4 +-
 .../nipype/ants/kelly_kapowski_callables.py   |  60 +-
 .../nipype/ants/label_geometry_callables.py   |   8 +-
 .../ants/laplacian_thickness_callables.py     |   8 +-
 .../measure_image_similarity_callables.py     |   8 +-
 .../nipype/ants/multiply_images_callables.py  |   3 +
 .../n4_bias_field_correction_callables.py     |  11 +-
 .../nipype/ants/registration_callables.py     |   6 +-
 .../ants/registration_syn_quick_callables.py  |   3 +
 .../resample_image_by_spacing_callables.py    |   8 +-
 .../nipype/ants/threshold_image_callables.py  |   8 +-
 .../warp_image_multi_transform_callables.py   |   5 +-
 ..._series_image_multi_transform_callables.py |   6 +-
 .../add_x_form_to_header_callables.py         |   3 +
 .../freesurfer/aparc_2_aseg_callables.py      |   3 +
 .../freesurfer/apas_2_aseg_callables.py       |   3 +
 .../nipype/freesurfer/apply_mask_callables.py |   8 +-
 .../apply_vol_transform_callables.py          |   9 +-
 .../freesurfer/bb_register_callables.py       |   6 +-
 .../nipype/freesurfer/binarize_callables.py   |   8 +-
 .../nipype/freesurfer/ca_label_callables.py   |   3 +
 .../freesurfer/ca_normalize_callables.py      |   3 +
 .../freesurfer/ca_register_callables.py       |   3 +
 .../check_talairach_alignment_callables.py    |   4 +
 .../freesurfer/concatenate_callables.py       |   4 +-
 .../freesurfer/concatenate_lta_callables.py   |   8 +-
 .../nipype/freesurfer/contrast_callables.py   |   3 +
 .../nipype/freesurfer/curvature_callables.py  |   3 +
 .../freesurfer/curvature_stats_callables.py   |   3 +
 .../freesurfer/dicom_convert_callables.py     |   8 +-
 .../freesurfer/edit_w_mwith_aseg_callables.py |   3 +
 .../freesurfer/em_register_callables.py       |   3 +
 .../freesurfer/euler_number_callables.py      |   4 +
 .../extract_main_component_callables.py       |   8 +-
 .../freesurfer/fit_ms_params_callables.py     |   4 +-
 .../freesurfer/fix_topology_callables.py      |   3 +
 .../fuse_segmentations_callables.py           |   3 +
 .../nipype/freesurfer/glm_fit_callables.py    |   5 +-
 .../nipype/freesurfer/gtm_seg_callables.py    |   3 +
 .../nipype/freesurfer/gtmpvc_callables.py     |   4 +-
 .../nipype/freesurfer/image_info_callables.py |   8 +-
 .../nipype/freesurfer/jacobian_callables.py   |   3 +
 .../freesurfer/label_2_annot_callables.py     |   3 +
 .../freesurfer/label_2_label_callables.py     |   3 +
 .../freesurfer/label_2_vol_callables.py       |   8 +-
 .../nipype/freesurfer/logan_ref_callables.py  |   5 +-
 .../freesurfer/lta_convert_callables.py       |   3 +
 .../make_average_subject_callables.py         |   4 +
 .../freesurfer/make_surfaces_callables.py     |   4 +-
 .../mni_bias_correction_callables.py          |   8 +-
 .../freesurfer/mp_rto_mni305_callables.py     |   8 +-
 .../freesurfer/mr_is_ca_label_callables.py    |   3 +
 .../nipype/freesurfer/mr_is_calc_callables.py |   3 +
 .../freesurfer/mr_is_combine_callables.py     |   3 +
 .../freesurfer/mr_is_convert_callables.py     |   6 +-
 .../freesurfer/mr_is_expand_callables.py      |   4 +
 .../freesurfer/mr_is_inflate_callables.py     |   3 +
 .../freesurfer/mri_convert_callables.py       |  11 +-
 .../nipype/freesurfer/mri_coreg_callables.py  |   4 +-
 .../nipype/freesurfer/mri_fill_callables.py   |   4 +-
 .../mri_marching_cubes_callables.py           |   6 +-
 .../freesurfer/mri_pretess_callables.py       |   8 +-
 .../freesurfer/mri_tessellate_callables.py    |   6 +-
 .../freesurfer/mris_preproc_callables.py      |   4 +-
 .../mris_preproc_recon_all_callables.py       |   4 +-
 .../task/nipype/freesurfer/mrtm2_callables.py |   5 +-
 .../task/nipype/freesurfer/mrtm_callables.py  |   5 +-
 .../nipype/freesurfer/ms__lda_callables.py    |   4 +-
 .../nipype/freesurfer/normalize_callables.py  |   3 +
 .../freesurfer/one_sample_t_test_callables.py |   5 +-
 .../task/nipype/freesurfer/paint_callables.py |   3 +
 .../parcellation_stats_callables.py           |   4 +-
 .../freesurfer/parse_dicom_dir_callables.py   |   4 +-
 .../nipype/freesurfer/recon_all_callables.py  |   3 +
 .../register_av_ito_talairach_callables.py    |   3 +
 .../nipype/freesurfer/register_callables.py   |   4 +-
 .../relabel_hypointensities_callables.py      |   3 +
 .../remove_intersection_callables.py          |   3 +
 .../freesurfer/remove_neck_callables.py       |   3 +
 .../nipype/freesurfer/resample_callables.py   |   7 +-
 .../freesurfer/robust_register_callables.py   |   7 +-
 .../freesurfer/robust_template_callables.py   |   4 +-
 .../freesurfer/sample_to_surface_callables.py |   9 +-
 .../nipype/freesurfer/seg_stats_callables.py  |   8 +-
 .../seg_stats_recon_all_callables.py          |   8 +-
 .../nipype/freesurfer/segment_cc_callables.py |   3 +
 .../nipype/freesurfer/segment_wm_callables.py |   3 +
 .../nipype/freesurfer/smooth_callables.py     |   7 +-
 .../smooth_tessellation_callables.py          |   6 +-
 .../nipype/freesurfer/sphere_callables.py     |   3 +
 .../freesurfer/spherical_average_callables.py |   4 +-
 .../surface_2_vol_transform_callables.py      |   8 +-
 .../freesurfer/surface_smooth_callables.py    |   6 +-
 .../freesurfer/surface_snapshots_callables.py |   7 +-
 .../freesurfer/surface_transform_callables.py |   8 +-
 .../freesurfer/synthesize_flash_callables.py  |   7 +-
 .../freesurfer/talairach_avi_callables.py     |   3 +
 .../freesurfer/talairach_qc_callables.py      |   3 +
 .../freesurfer/tkregister_2_callables.py      |   8 +-
 .../freesurfer/unpack_sdicom_dir_callables.py |   8 +-
 .../freesurfer/volume_mask_callables.py       |   3 +
 .../watershed_skull_strip_callables.py        |   3 +
 .../nipype/fsl/accuracy_tester_callables.py   | 149 +---
 .../task/nipype/fsl/apply_mask_callables.py   |  13 +-
 .../task/nipype/fsl/apply_topup_callables.py  |  16 +-
 .../task/nipype/fsl/apply_warp_callables.py   |  13 +-
 .../task/nipype/fsl/apply_xfm_callables.py    |  16 +-
 .../task/nipype/fsl/ar1_image_callables.py    |  13 +-
 .../task/nipype/fsl/av_scale_callables.py     |   4 +
 .../task/nipype/fsl/b0_calc_callables.py      |  16 +-
 .../task/nipype/fsl/bedpostx5_callables.py    |  12 +-
 .../task/nipype/fsl/bet_callables.py          |  16 +-
 .../task/nipype/fsl/binary_maths_callables.py |  13 +-
 .../nipype/fsl/change_data_type_callables.py  |  13 +-
 .../task/nipype/fsl/classifier_callables.py   |   4 +
 .../task/nipype/fsl/cleaner_callables.py      |   4 +
 .../task/nipype/fsl/cluster_callables.py      |  13 +-
 .../task/nipype/fsl/complex_callables.py      |  14 +-
 .../task/nipype/fsl/contrast_mgr_callables.py |  14 +-
 .../task/nipype/fsl/convert_warp_callables.py |  16 +-
 .../task/nipype/fsl/convert_xfm_callables.py  |  92 +-
 .../task/nipype/fsl/copy_geom_callables.py    |  16 +-
 .../task/nipype/fsl/dilate_image_callables.py |  13 +-
 .../task/nipype/fsl/distance_map_callables.py |   8 +-
 .../task/nipype/fsl/dti_fit_callables.py      |  13 +-
 .../nipype/fsl/dual_regression_callables.py   |   4 +-
 .../task/nipype/fsl/eddy_callables.py         |   4 +-
 .../task/nipype/fsl/eddy_correct_callables.py |  16 +-
 .../task/nipype/fsl/eddy_quad_callables.py    |   5 +-
 .../task/nipype/fsl/epi_de_warp_callables.py  |  13 +-
 .../task/nipype/fsl/epi_reg_callables.py      |   4 +-
 .../task/nipype/fsl/erode_image_callables.py  |  13 +-
 .../task/nipype/fsl/extract_roi_callables.py  |  13 +-
 .../task/nipype/fsl/fast_callables.py         |  63 +-
 .../task/nipype/fsl/feat_callables.py         |   5 +-
 .../task/nipype/fsl/feat_model_callables.py   | 338 +-------
 .../nipype/fsl/feature_extractor_callables.py |   4 +
 .../task/nipype/fsl/filmgls_callables.py      | 146 +---
 .../nipype/fsl/filter_regressor_callables.py  |  13 +-
 .../nipype/fsl/find_the_biggest_callables.py  |  13 +-
 .../task/nipype/fsl/first_callables.py        |   5 +
 .../task/nipype/fsl/flameo_callables.py       |   5 +-
 .../task/nipype/fsl/flirt_callables.py        |  16 +-
 .../task/nipype/fsl/fnirt_callables.py        | 786 +-----------------
 .../task/nipype/fsl/fugue_callables.py        |  16 +-
 .../task/nipype/fsl/glm_callables.py          |  17 +-
 .../task/nipype/fsl/ica__aroma_callables.py   |   3 +
 .../task/nipype/fsl/image_maths_callables.py  |  13 +-
 .../task/nipype/fsl/image_meants_callables.py |  13 +-
 .../task/nipype/fsl/image_stats_callables.py  |  16 +-
 .../task/nipype/fsl/inv_warp_callables.py     |  16 +-
 .../nipype/fsl/isotropic_smooth_callables.py  |  13 +-
 .../task/nipype/fsl/l2_model_callables.py     |   2 +
 .../nipype/fsl/level_1_design_callables.py    |   2 +
 .../fsl/make_dyadic_vectors_callables.py      |  12 +-
 .../nipype/fsl/maths_command_callables.py     |  13 +-
 .../task/nipype/fsl/max_image_callables.py    |  13 +-
 .../task/nipype/fsl/maxn_image_callables.py   |  13 +-
 .../task/nipype/fsl/mcflirt_callables.py      | 147 +---
 .../task/nipype/fsl/mean_image_callables.py   |  13 +-
 .../task/nipype/fsl/median_image_callables.py |  13 +-
 .../task/nipype/fsl/melodic_callables.py      |   4 +-
 .../task/nipype/fsl/merge_callables.py        |  16 +-
 .../task/nipype/fsl/min_image_callables.py    |  13 +-
 .../nipype/fsl/motion_outliers_callables.py   |  16 +-
 .../nipype/fsl/multi_image_maths_callables.py |  13 +-
 .../fsl/multiple_regress_design_callables.py  |   2 +
 .../task/nipype/fsl/overlay_callables.py      |  65 +-
 .../nipype/fsl/percentile_image_callables.py  |  13 +-
 .../fsl/plot_motion_params_callables.py       |   8 +-
 .../nipype/fsl/plot_time_series_callables.py  |  13 +-
 .../nipype/fsl/power_spectrum_callables.py    |  14 +-
 .../task/nipype/fsl/prelude_callables.py      |  13 +-
 .../nipype/fsl/prepare_fieldmap_callables.py  |   4 +
 .../nipype/fsl/prob_track_x2_callables.py     |  14 +-
 .../task/nipype/fsl/prob_track_x_callables.py |  13 +-
 .../task/nipype/fsl/proj_thresh_callables.py  |  12 +-
 .../task/nipype/fsl/randomise_callables.py    |  12 +-
 .../nipype/fsl/reorient_2_std_callables.py    |  13 +-
 .../task/nipype/fsl/robust_fov_callables.py   |  16 +-
 .../task/nipype/fsl/sig_loss_callables.py     |  13 +-
 .../task/nipype/fsl/slice_callables.py        |  12 +-
 .../task/nipype/fsl/slice_timer_callables.py  |  13 +-
 .../task/nipype/fsl/slicer_callables.py       |  13 +-
 .../task/nipype/fsl/smm_callables.py          |  13 +-
 .../task/nipype/fsl/smooth_callables.py       |  16 +-
 .../nipype/fsl/smooth_estimate_callables.py   |  16 +-
 .../nipype/fsl/spatial_filter_callables.py    |  13 +-
 .../task/nipype/fsl/split_callables.py        |   8 +-
 .../task/nipype/fsl/std_image_callables.py    |  13 +-
 .../task/nipype/fsl/susan_callables.py        |  13 +-
 .../nipype/fsl/swap_dimensions_callables.py   |  13 +-
 .../nipype/fsl/temporal_filter_callables.py   |  13 +-
 .../task/nipype/fsl/text_2_vest_callables.py  |  16 +-
 .../task/nipype/fsl/threshold_callables.py    |  13 +-
 .../task/nipype/fsl/topup_callables.py        | 252 +-----
 .../nipype/fsl/tract_skeleton_callables.py    |   6 +-
 .../task/nipype/fsl/training_callables.py     |   4 +-
 .../fsl/training_set_creator_callables.py     |   2 +
 .../task/nipype/fsl/unary_maths_callables.py  |  14 +-
 .../task/nipype/fsl/vec_reg_callables.py      |  13 +-
 .../task/nipype/fsl/vest_2_text_callables.py  |  16 +-
 .../task/nipype/fsl/warp_points_callables.py  |   8 +-
 .../fsl/warp_points_from_std_callables.py     |   3 +
 .../fsl/warp_points_to_std_callables.py       |   8 +-
 .../task/nipype/fsl/warp_utils_callables.py   |  16 +-
 .../task/nipype/fsl/x_fibres_5_callables.py   |  13 +-
 nipype2pydra/pkg_gen/__init__.py              |  94 ++-
 nipype2pydra/task/function.py                 |  15 +-
 nipype2pydra/tests/test_utils.py              |  35 +-
 nipype2pydra/utils.py                         | 121 ++-
 317 files changed, 2581 insertions(+), 5873 deletions(-)

diff --git a/example-specs/task/nipype/afni/a_boverlap_callables.py b/example-specs/task/nipype/afni/a_boverlap_callables.py
index f199f389..6671798a 100644
--- a/example-specs/task/nipype/afni/a_boverlap_callables.py
+++ b/example-specs/task/nipype/afni/a_boverlap_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of ABoverlap.yaml"""
 
 from looseversion import LooseVersion
-import logging
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,6 +17,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -27,56 +28,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -171,6 +123,7 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -190,10 +143,12 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -231,6 +186,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -281,6 +237,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
 
@@ -364,6 +321,7 @@ def standard_image(img_name):
         return os.path.join(basedir, img_name)
 
 
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -371,6 +329,7 @@ def _overload_extension(
     return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def nipype_interfaces_afni__AFNICommand___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -386,6 +345,7 @@ def nipype_interfaces_afni__AFNICommand___list_outputs(
     return outputs
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
     metadata = dict(name_source=lambda t: t is not None)
diff --git a/example-specs/task/nipype/afni/afn_ito_nifti_callables.py b/example-specs/task/nipype/afni/afn_ito_nifti_callables.py
index d60e087e..b300a94d 100644
--- a/example-specs/task/nipype/afni/afn_ito_nifti_callables.py
+++ b/example-specs/task/nipype/afni/afn_ito_nifti_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of AFNItoNIFTI.yaml"""
 
-import logging
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +16,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -26,62 +27,14 @@ def __str__(self):
         return "{}".format(self.value)
 
 
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommand___gen_filename(
     name, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
     raise NotImplementedError
 
 
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -176,6 +129,7 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -195,56 +149,7 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
+# Original source at L159 of <nipype-install>/interfaces/afni/utils.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -254,10 +159,12 @@ def _overload_extension(
     return os.path.join(path, base + ext)
 
 
+# Original source at L165 of <nipype-install>/interfaces/afni/utils.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     return os.path.abspath(nipype_interfaces_afni__AFNICommand___gen_filename(name))
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -308,6 +215,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def nipype_interfaces_afni__AFNICommand___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -323,6 +231,7 @@ def nipype_interfaces_afni__AFNICommand___list_outputs(
     return outputs
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
     metadata = dict(name_source=lambda t: t is not None)
diff --git a/example-specs/task/nipype/afni/align_epi_anat_py_callables.py b/example-specs/task/nipype/afni/align_epi_anat_py_callables.py
index 72862ae5..1a3eb2c6 100644
--- a/example-specs/task/nipype/afni/align_epi_anat_py_callables.py
+++ b/example-specs/task/nipype/afni/align_epi_anat_py_callables.py
@@ -1,9 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of AlignEpiAnatPy.yaml"""
 
 from looseversion import LooseVersion
-from pathlib import Path
-import os.path as op
+import attrs
 import os
+import os.path as op
+from pathlib import Path
 
 
 def anat_al_orig_callable(output_dir, inputs, stdout, stderr):
@@ -76,6 +77,7 @@ def skullstrip_callable(output_dir, inputs, stdout, stderr):
     return outputs["skullstrip"]
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -113,6 +115,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -155,6 +158,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -205,89 +209,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
-class Info(PackageInfo):
-    """Handle afni output type and version information."""
-
-    __outputtype = "AFNI"
-    ftypes = {"NIFTI": ".nii", "AFNI": "", "NIFTI_GZ": ".nii.gz"}
-    version_cmd = "afni --version"
-
-    @staticmethod
-    def parse_version(raw_info):
-        """Check and parse AFNI's version."""
-        version_stamp = raw_info.split("\n")[0].split("Version ")[1]
-        if version_stamp.startswith("AFNI"):
-            version_stamp = version_stamp.split("AFNI_")[1]
-        elif version_stamp.startswith("Debian"):
-            version_stamp = version_stamp.split("Debian-")[1].split("~")[0]
-        else:
-            return None
-
-        version = LooseVersion(version_stamp.replace("_", ".")).version[:3]
-        if version[0] < 1000:
-            version[0] = version[0] + 2000
-        return tuple(version)
-
-    @classmethod
-    def output_type_to_ext(cls, outputtype):
-        """
-        Get the file extension for the given output type.
-
-        Parameters
-        ----------
-        outputtype : {'NIFTI', 'NIFTI_GZ', 'AFNI'}
-            String specifying the output type.
-
-        Returns
-        -------
-        extension : str
-            The file extension for the output type.
-
-        """
-        try:
-            return cls.ftypes[outputtype]
-        except KeyError as e:
-            msg = "Invalid AFNIOUTPUTTYPE: ", outputtype
-            raise KeyError(msg) from e
-
-    @classmethod
-    def outputtype(cls):
-        """
-        Set default output filetype.
-
-        AFNI has no environment variables, Output filetypes get set in command line calls
-        Nipype uses ``AFNI`` as default
-
-
-        Returns
-        -------
-        None
-
-        """
-        return "AFNI"
-
-    @staticmethod
-    def standard_image(img_name):
-        """
-        Grab an image from the standard location.
-
-        Could be made more fancy to allow for more relocatability
-
-        """
-        clout = CommandLine(
-            "which afni",
-            ignore_exception=True,
-            resource_monitor=False,
-            terminal_output="allatonce",
-        ).run()
-        if clout.runtime.returncode != 0:
-            return None
-
-        out = clout.runtime.stdout
-        basedir = os.path.split(out)[0]
-        return os.path.join(basedir, img_name)
-
-
+# Original source at L260 of <nipype-install>/interfaces/afni/base.py
 def _gen_fname(
     basename,
     cwd=None,
@@ -342,10 +264,12 @@ def _gen_fname(
     return fname
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
 
@@ -429,6 +353,7 @@ def standard_image(img_name):
         return os.path.join(basedir, img_name)
 
 
+# Original source at L197 of <nipype-install>/interfaces/afni/preprocess.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     anat_prefix = _gen_fname(
diff --git a/example-specs/task/nipype/afni/allineate_callables.py b/example-specs/task/nipype/afni/allineate_callables.py
index 84570c63..994c3e0a 100644
--- a/example-specs/task/nipype/afni/allineate_callables.py
+++ b/example-specs/task/nipype/afni/allineate_callables.py
@@ -1,11 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of Allineate.yaml"""
 
 from looseversion import LooseVersion
-import logging
-from pathlib import Path
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
+from pathlib import Path
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -46,6 +46,7 @@ def allcostx_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -83,6 +84,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -125,56 +127,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
+# Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
 
@@ -258,6 +211,7 @@ def standard_image(img_name):
         return os.path.join(basedir, img_name)
 
 
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -265,6 +219,7 @@ def _overload_extension(
     return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def nipype_interfaces_afni__AFNICommand___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -280,6 +235,7 @@ def nipype_interfaces_afni__AFNICommand___list_outputs(
     return outputs
 
 
+# Original source at L260 of <nipype-install>/interfaces/afni/base.py
 def _gen_fname(
     basename,
     cwd=None,
@@ -334,6 +290,7 @@ def _gen_fname(
     return fname
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -344,56 +301,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -488,6 +396,7 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -507,10 +416,12 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -561,6 +472,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L586 of <nipype-install>/interfaces/afni/preprocess.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
 
diff --git a/example-specs/task/nipype/afni/auto_tcorrelate_callables.py b/example-specs/task/nipype/afni/auto_tcorrelate_callables.py
index 2feaf232..9f080b00 100644
--- a/example-specs/task/nipype/afni/auto_tcorrelate_callables.py
+++ b/example-specs/task/nipype/afni/auto_tcorrelate_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of AutoTcorrelate.yaml"""
 
-import logging
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -16,56 +16,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
+# Original source at L675 of <nipype-install>/interfaces/afni/preprocess.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -75,6 +26,7 @@ def _overload_extension(
     return os.path.join(path, base + ext)
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -85,56 +37,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -229,6 +132,7 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -248,10 +152,12 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -302,6 +208,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def nipype_interfaces_afni__AFNICommand___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -317,6 +224,7 @@ def nipype_interfaces_afni__AFNICommand___list_outputs(
     return outputs
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
     metadata = dict(name_source=lambda t: t is not None)
diff --git a/example-specs/task/nipype/afni/auto_tlrc_callables.py b/example-specs/task/nipype/afni/auto_tlrc_callables.py
index 67bf2581..830ac740 100644
--- a/example-specs/task/nipype/afni/auto_tlrc_callables.py
+++ b/example-specs/task/nipype/afni/auto_tlrc_callables.py
@@ -1,9 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of AutoTLRC.yaml"""
 
 from looseversion import LooseVersion
-from pathlib import Path
-import os.path as op
+import attrs
 import os
+import os.path as op
+from pathlib import Path
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -13,6 +14,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_file"]
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -50,6 +52,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -92,6 +95,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -142,6 +146,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
 
@@ -225,6 +230,7 @@ def standard_image(img_name):
         return os.path.join(basedir, img_name)
 
 
+# Original source at L260 of <nipype-install>/interfaces/afni/base.py
 def _gen_fname(
     basename,
     cwd=None,
@@ -279,10 +285,12 @@ def _gen_fname(
     return fname
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L846 of <nipype-install>/interfaces/afni/preprocess.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     ext = ".HEAD"
diff --git a/example-specs/task/nipype/afni/autobox_callables.py b/example-specs/task/nipype/afni/autobox_callables.py
index daaea063..e18d68cd 100644
--- a/example-specs/task/nipype/afni/autobox_callables.py
+++ b/example-specs/task/nipype/afni/autobox_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Autobox.yaml"""
 
 from looseversion import LooseVersion
-import logging
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
 
 
 def x_min_callable(output_dir, inputs, stdout, stderr):
@@ -59,6 +59,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -69,56 +70,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -213,6 +165,7 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -232,10 +185,12 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -273,6 +228,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -323,6 +279,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
 
@@ -406,6 +363,7 @@ def standard_image(img_name):
         return os.path.join(basedir, img_name)
 
 
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -413,6 +371,7 @@ def _overload_extension(
     return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def nipype_interfaces_afni__AFNICommand___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -428,6 +387,7 @@ def nipype_interfaces_afni__AFNICommand___list_outputs(
     return outputs
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
     metadata = dict(name_source=lambda t: t is not None)
diff --git a/example-specs/task/nipype/afni/automask_callables.py b/example-specs/task/nipype/afni/automask_callables.py
index 36b39aa3..e3810af0 100644
--- a/example-specs/task/nipype/afni/automask_callables.py
+++ b/example-specs/task/nipype/afni/automask_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Automask.yaml"""
 
 from looseversion import LooseVersion
-import logging
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -24,6 +24,7 @@ def brain_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -34,56 +35,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -178,6 +130,7 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -197,10 +150,12 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -238,6 +193,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -288,6 +244,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
 
@@ -371,6 +328,7 @@ def standard_image(img_name):
         return os.path.join(basedir, img_name)
 
 
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -378,6 +336,7 @@ def _overload_extension(
     return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def nipype_interfaces_afni__AFNICommand___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -393,6 +352,7 @@ def nipype_interfaces_afni__AFNICommand___list_outputs(
     return outputs
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
     metadata = dict(name_source=lambda t: t is not None)
diff --git a/example-specs/task/nipype/afni/axialize_callables.py b/example-specs/task/nipype/afni/axialize_callables.py
index 73457687..879823c2 100644
--- a/example-specs/task/nipype/afni/axialize_callables.py
+++ b/example-specs/task/nipype/afni/axialize_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Axialize.yaml"""
 
 from looseversion import LooseVersion
-import logging
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,6 +17,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -27,56 +28,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -171,6 +123,7 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -190,10 +143,12 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -231,6 +186,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -281,6 +237,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
 
@@ -364,6 +321,7 @@ def standard_image(img_name):
         return os.path.join(basedir, img_name)
 
 
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -371,6 +329,7 @@ def _overload_extension(
     return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def nipype_interfaces_afni__AFNICommand___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -386,6 +345,7 @@ def nipype_interfaces_afni__AFNICommand___list_outputs(
     return outputs
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
     metadata = dict(name_source=lambda t: t is not None)
diff --git a/example-specs/task/nipype/afni/bandpass_callables.py b/example-specs/task/nipype/afni/bandpass_callables.py
index ebf616be..208a51e5 100644
--- a/example-specs/task/nipype/afni/bandpass_callables.py
+++ b/example-specs/task/nipype/afni/bandpass_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Bandpass.yaml"""
 
 from looseversion import LooseVersion
-import logging
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,6 +17,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -27,56 +28,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -171,6 +123,7 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -190,10 +143,12 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -231,6 +186,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -281,6 +237,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
 
@@ -364,6 +321,7 @@ def standard_image(img_name):
         return os.path.join(basedir, img_name)
 
 
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -371,6 +329,7 @@ def _overload_extension(
     return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def nipype_interfaces_afni__AFNICommand___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -386,6 +345,7 @@ def nipype_interfaces_afni__AFNICommand___list_outputs(
     return outputs
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
     metadata = dict(name_source=lambda t: t is not None)
diff --git a/example-specs/task/nipype/afni/blur_in_mask_callables.py b/example-specs/task/nipype/afni/blur_in_mask_callables.py
index 595b9b6b..4925e04f 100644
--- a/example-specs/task/nipype/afni/blur_in_mask_callables.py
+++ b/example-specs/task/nipype/afni/blur_in_mask_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of BlurInMask.yaml"""
 
 from looseversion import LooseVersion
-import logging
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,6 +17,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -27,56 +28,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -171,6 +123,7 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -190,10 +143,12 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -231,6 +186,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -281,6 +237,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
 
@@ -364,6 +321,7 @@ def standard_image(img_name):
         return os.path.join(basedir, img_name)
 
 
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -371,6 +329,7 @@ def _overload_extension(
     return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def nipype_interfaces_afni__AFNICommand___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -386,6 +345,7 @@ def nipype_interfaces_afni__AFNICommand___list_outputs(
     return outputs
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
     metadata = dict(name_source=lambda t: t is not None)
diff --git a/example-specs/task/nipype/afni/blur_to_fwhm_callables.py b/example-specs/task/nipype/afni/blur_to_fwhm_callables.py
index 7ed9c0c0..bbe20394 100644
--- a/example-specs/task/nipype/afni/blur_to_fwhm_callables.py
+++ b/example-specs/task/nipype/afni/blur_to_fwhm_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of BlurToFWHM.yaml"""
 
 from looseversion import LooseVersion
-import logging
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,6 +17,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -27,56 +28,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -171,6 +123,7 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -190,10 +143,12 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -231,6 +186,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -281,6 +237,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
 
@@ -364,6 +321,7 @@ def standard_image(img_name):
         return os.path.join(basedir, img_name)
 
 
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -371,6 +329,7 @@ def _overload_extension(
     return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def nipype_interfaces_afni__AFNICommand___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -386,6 +345,7 @@ def nipype_interfaces_afni__AFNICommand___list_outputs(
     return outputs
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
     metadata = dict(name_source=lambda t: t is not None)
diff --git a/example-specs/task/nipype/afni/brick_stat_callables.py b/example-specs/task/nipype/afni/brick_stat_callables.py
index 94e47a75..48e68771 100644
--- a/example-specs/task/nipype/afni/brick_stat_callables.py
+++ b/example-specs/task/nipype/afni/brick_stat_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of BrickStat.yaml"""
 
 import logging
+import os
 import os.path as op
 import attrs
-import os
 
 
 def min_val_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +16,7 @@ def min_val_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -26,6 +27,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -76,12 +78,14 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L888 of <nipype-install>/interfaces/base/core.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
     return value
 
 
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -176,10 +180,12 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     metadata = dict(name_source=lambda t: t is not None)
     traits = inputs.traits(**metadata)
diff --git a/example-specs/task/nipype/afni/bucket_callables.py b/example-specs/task/nipype/afni/bucket_callables.py
index 7de7c58a..9459f487 100644
--- a/example-specs/task/nipype/afni/bucket_callables.py
+++ b/example-specs/task/nipype/afni/bucket_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Bucket.yaml"""
 
 from looseversion import LooseVersion
-import logging
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,6 +17,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -27,56 +28,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -171,6 +123,7 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -190,10 +143,12 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -231,6 +186,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -281,6 +237,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
 
@@ -364,6 +321,7 @@ def standard_image(img_name):
         return os.path.join(basedir, img_name)
 
 
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -371,6 +329,7 @@ def _overload_extension(
     return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def nipype_interfaces_afni__AFNICommand___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -386,6 +345,7 @@ def nipype_interfaces_afni__AFNICommand___list_outputs(
     return outputs
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
     metadata = dict(name_source=lambda t: t is not None)
diff --git a/example-specs/task/nipype/afni/calc_callables.py b/example-specs/task/nipype/afni/calc_callables.py
index 46758951..7232c0e5 100644
--- a/example-specs/task/nipype/afni/calc_callables.py
+++ b/example-specs/task/nipype/afni/calc_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Calc.yaml"""
 
 from looseversion import LooseVersion
-import logging
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,6 +17,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -27,56 +28,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -171,6 +123,7 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -190,10 +143,12 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -231,6 +186,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -281,6 +237,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
 
@@ -364,6 +321,7 @@ def standard_image(img_name):
         return os.path.join(basedir, img_name)
 
 
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -371,6 +329,7 @@ def _overload_extension(
     return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def nipype_interfaces_afni__AFNICommand___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -386,6 +345,7 @@ def nipype_interfaces_afni__AFNICommand___list_outputs(
     return outputs
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
     metadata = dict(name_source=lambda t: t is not None)
diff --git a/example-specs/task/nipype/afni/cat_callables.py b/example-specs/task/nipype/afni/cat_callables.py
index 9dbfe814..0ecf8223 100644
--- a/example-specs/task/nipype/afni/cat_callables.py
+++ b/example-specs/task/nipype/afni/cat_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Cat.yaml"""
 
 from looseversion import LooseVersion
-import logging
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,6 +17,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -27,56 +28,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -171,6 +123,7 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -190,10 +143,12 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -231,6 +186,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -281,6 +237,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
 
@@ -364,6 +321,7 @@ def standard_image(img_name):
         return os.path.join(basedir, img_name)
 
 
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -371,6 +329,7 @@ def _overload_extension(
     return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def nipype_interfaces_afni__AFNICommand___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -386,6 +345,7 @@ def nipype_interfaces_afni__AFNICommand___list_outputs(
     return outputs
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
     metadata = dict(name_source=lambda t: t is not None)
diff --git a/example-specs/task/nipype/afni/cat_matvec_callables.py b/example-specs/task/nipype/afni/cat_matvec_callables.py
index bcccc59c..ebb68254 100644
--- a/example-specs/task/nipype/afni/cat_matvec_callables.py
+++ b/example-specs/task/nipype/afni/cat_matvec_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of CatMatvec.yaml"""
 
 from looseversion import LooseVersion
-import logging
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,6 +17,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -27,56 +28,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -171,6 +123,7 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -190,10 +143,12 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -231,6 +186,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -281,6 +237,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
 
@@ -364,6 +321,7 @@ def standard_image(img_name):
         return os.path.join(basedir, img_name)
 
 
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -371,6 +329,7 @@ def _overload_extension(
     return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def nipype_interfaces_afni__AFNICommand___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -386,6 +345,7 @@ def nipype_interfaces_afni__AFNICommand___list_outputs(
     return outputs
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
     metadata = dict(name_source=lambda t: t is not None)
diff --git a/example-specs/task/nipype/afni/center_mass.yaml b/example-specs/task/nipype/afni/center_mass.yaml
index f66bb73b..529ff6fd 100644
--- a/example-specs/task/nipype/afni/center_mass.yaml
+++ b/example-specs/task/nipype/afni/center_mass.yaml
@@ -91,7 +91,7 @@ tests:
     automask:
     # type=bool|default=False: Generate the mask automatically
     set_cm:
-    # type=tuple|default=(<traits.trait_types.Float object at 0x1121a7a50>, <traits.trait_types.Float object at 0x1121a7b50>, <traits.trait_types.Float object at 0x1121a7bd0>): After computing the center of mass, set the origin fields in the header so that the center of mass will be at (x,y,z) in DICOM coords.
+    # type=tuple|default=(<traits.trait_types.Float object at 0x1079ed690>, <traits.trait_types.Float object at 0x1079ed790>, <traits.trait_types.Float object at 0x1079ed810>): After computing the center of mass, set the origin fields in the header so that the center of mass will be at (x,y,z) in DICOM coords.
     local_ijk:
     # type=bool|default=False: Output values as (i,j,k) in local orientation
     roi_vals:
diff --git a/example-specs/task/nipype/afni/center_mass_callables.py b/example-specs/task/nipype/afni/center_mass_callables.py
index 98b2d9c9..42503938 100644
--- a/example-specs/task/nipype/afni/center_mass_callables.py
+++ b/example-specs/task/nipype/afni/center_mass_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of CenterMass.yaml"""
 
 import numpy as np
-import logging
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -31,6 +31,7 @@ def cm_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -41,6 +42,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -91,12 +93,14 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L888 of <nipype-install>/interfaces/base/core.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
     return value
 
 
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -191,6 +195,7 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -210,10 +215,12 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L749 of <nipype-install>/interfaces/afni/utils.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
     outputs["out_file"] = os.path.abspath(inputs.in_file)
diff --git a/example-specs/task/nipype/afni/clip_level_callables.py b/example-specs/task/nipype/afni/clip_level_callables.py
index 11355d4d..5dbe29ed 100644
--- a/example-specs/task/nipype/afni/clip_level_callables.py
+++ b/example-specs/task/nipype/afni/clip_level_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of ClipLevel.yaml"""
 
 import logging
+import os
 import os.path as op
 import attrs
-import os
 
 
 def clip_val_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +16,7 @@ def clip_val_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -26,6 +27,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -76,12 +78,14 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L888 of <nipype-install>/interfaces/base/core.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
     return value
 
 
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -176,10 +180,12 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     metadata = dict(name_source=lambda t: t is not None)
     traits = inputs.traits(**metadata)
diff --git a/example-specs/task/nipype/afni/convert_dset_callables.py b/example-specs/task/nipype/afni/convert_dset_callables.py
index 7b83b67a..63ab8d03 100644
--- a/example-specs/task/nipype/afni/convert_dset_callables.py
+++ b/example-specs/task/nipype/afni/convert_dset_callables.py
@@ -1,6 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of ConvertDset.yaml"""
 
 import os.path as op
+import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -10,10 +11,12 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_file"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L817 of <nipype-install>/interfaces/afni/utils.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["out_file"] = op.abspath(inputs.out_file)
diff --git a/example-specs/task/nipype/afni/copy_callables.py b/example-specs/task/nipype/afni/copy_callables.py
index 50b8383d..4e6230b4 100644
--- a/example-specs/task/nipype/afni/copy_callables.py
+++ b/example-specs/task/nipype/afni/copy_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Copy.yaml"""
 
 from looseversion import LooseVersion
-import logging
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,6 +17,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -27,56 +28,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -171,6 +123,7 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -190,10 +143,12 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -231,6 +186,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -281,6 +237,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
 
@@ -364,6 +321,7 @@ def standard_image(img_name):
         return os.path.join(basedir, img_name)
 
 
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -371,6 +329,7 @@ def _overload_extension(
     return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def nipype_interfaces_afni__AFNICommand___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -386,6 +345,7 @@ def nipype_interfaces_afni__AFNICommand___list_outputs(
     return outputs
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
     metadata = dict(name_source=lambda t: t is not None)
diff --git a/example-specs/task/nipype/afni/deconvolve_callables.py b/example-specs/task/nipype/afni/deconvolve_callables.py
index 5cbd9dc5..c5607d17 100644
--- a/example-specs/task/nipype/afni/deconvolve_callables.py
+++ b/example-specs/task/nipype/afni/deconvolve_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Deconvolve.yaml"""
 
 from looseversion import LooseVersion
-from pathlib import Path
-import os.path as op
 import attrs
 import os
+import os.path as op
+from pathlib import Path
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -35,6 +35,7 @@ def cbucket_callable(output_dir, inputs, stdout, stderr):
     return outputs["cbucket"]
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -72,6 +73,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -114,6 +116,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -164,6 +167,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
 
@@ -247,6 +251,7 @@ def standard_image(img_name):
         return os.path.join(basedir, img_name)
 
 
+# Original source at L260 of <nipype-install>/interfaces/afni/base.py
 def _gen_fname(
     basename,
     cwd=None,
@@ -301,10 +306,12 @@ def _gen_fname(
     return fname
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L322 of <nipype-install>/interfaces/afni/model.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
 
diff --git a/example-specs/task/nipype/afni/degree_centrality_callables.py b/example-specs/task/nipype/afni/degree_centrality_callables.py
index 02e7b8c0..ec134941 100644
--- a/example-specs/task/nipype/afni/degree_centrality_callables.py
+++ b/example-specs/task/nipype/afni/degree_centrality_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of DegreeCentrality.yaml"""
 
 from looseversion import LooseVersion
-import logging
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
 
 
 def oned_file_callable(output_dir, inputs, stdout, stderr):
@@ -24,6 +24,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -61,56 +62,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
+# Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
 
@@ -194,6 +146,7 @@ def standard_image(img_name):
         return os.path.join(basedir, img_name)
 
 
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -201,6 +154,7 @@ def _overload_extension(
     return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def nipype_interfaces_afni__AFNICommand___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -216,6 +170,7 @@ def nipype_interfaces_afni__AFNICommand___list_outputs(
     return outputs
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -226,6 +181,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -276,6 +232,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -370,6 +327,7 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -389,10 +347,12 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L1218 of <nipype-install>/interfaces/afni/preprocess.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     # Update outputs dictionary if oned file is defined
     outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
diff --git a/example-specs/task/nipype/afni/despike_callables.py b/example-specs/task/nipype/afni/despike_callables.py
index d9c9ecf4..39a1ea46 100644
--- a/example-specs/task/nipype/afni/despike_callables.py
+++ b/example-specs/task/nipype/afni/despike_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Despike.yaml"""
 
 from looseversion import LooseVersion
-import logging
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,6 +17,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -27,56 +28,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -171,6 +123,7 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -190,10 +143,12 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -231,6 +186,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -281,6 +237,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
 
@@ -364,6 +321,7 @@ def standard_image(img_name):
         return os.path.join(basedir, img_name)
 
 
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -371,6 +329,7 @@ def _overload_extension(
     return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def nipype_interfaces_afni__AFNICommand___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -386,6 +345,7 @@ def nipype_interfaces_afni__AFNICommand___list_outputs(
     return outputs
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
     metadata = dict(name_source=lambda t: t is not None)
diff --git a/example-specs/task/nipype/afni/detrend_callables.py b/example-specs/task/nipype/afni/detrend_callables.py
index 25a3490f..b6cc756f 100644
--- a/example-specs/task/nipype/afni/detrend_callables.py
+++ b/example-specs/task/nipype/afni/detrend_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Detrend.yaml"""
 
 from looseversion import LooseVersion
-import logging
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,6 +17,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -27,56 +28,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -171,6 +123,7 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -190,10 +143,12 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -231,6 +186,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -281,6 +237,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
 
@@ -364,6 +321,7 @@ def standard_image(img_name):
         return os.path.join(basedir, img_name)
 
 
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -371,6 +329,7 @@ def _overload_extension(
     return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def nipype_interfaces_afni__AFNICommand___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -386,6 +345,7 @@ def nipype_interfaces_afni__AFNICommand___list_outputs(
     return outputs
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
     metadata = dict(name_source=lambda t: t is not None)
diff --git a/example-specs/task/nipype/afni/dot.yaml b/example-specs/task/nipype/afni/dot.yaml
index 2a5adbd8..bbceadab 100644
--- a/example-specs/task/nipype/afni/dot.yaml
+++ b/example-specs/task/nipype/afni/dot.yaml
@@ -85,7 +85,7 @@ tests:
     mask:
     # type=file|default=<undefined>: Use this dataset as a mask
     mrange:
-    # type=tuple|default=(<traits.trait_types.Float object at 0x1121ae190>, <traits.trait_types.Float object at 0x1121ae090>): Means to further restrict the voxels from 'mset' so thatonly those mask values within this range (inclusive) willbe used.
+    # type=tuple|default=(<traits.trait_types.Float object at 0x1079efdd0>, <traits.trait_types.Float object at 0x1079efcd0>): Means to further restrict the voxels from 'mset' so thatonly those mask values within this range (inclusive) willbe used.
     demean:
     # type=bool|default=False: Remove the mean from each volume prior to computing the correlation
     docor:
diff --git a/example-specs/task/nipype/afni/dot_callables.py b/example-specs/task/nipype/afni/dot_callables.py
index c79c04f3..c1ef6c5d 100644
--- a/example-specs/task/nipype/afni/dot_callables.py
+++ b/example-specs/task/nipype/afni/dot_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Dot.yaml"""
 
 from looseversion import LooseVersion
-import logging
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,6 +17,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -27,56 +28,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -171,6 +123,7 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -190,10 +143,12 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -231,6 +186,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -281,6 +237,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
 
@@ -364,6 +321,7 @@ def standard_image(img_name):
         return os.path.join(basedir, img_name)
 
 
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -371,6 +329,7 @@ def _overload_extension(
     return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def nipype_interfaces_afni__AFNICommand___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -386,6 +345,7 @@ def nipype_interfaces_afni__AFNICommand___list_outputs(
     return outputs
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
     metadata = dict(name_source=lambda t: t is not None)
diff --git a/example-specs/task/nipype/afni/ecm_callables.py b/example-specs/task/nipype/afni/ecm_callables.py
index 4afbdd00..e2c5ff6d 100644
--- a/example-specs/task/nipype/afni/ecm_callables.py
+++ b/example-specs/task/nipype/afni/ecm_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of ECM.yaml"""
 
 from looseversion import LooseVersion
-import logging
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,6 +17,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -27,56 +28,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -171,6 +123,7 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -190,10 +143,12 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -231,6 +186,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -281,6 +237,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
 
@@ -364,6 +321,7 @@ def standard_image(img_name):
         return os.path.join(basedir, img_name)
 
 
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -371,6 +329,7 @@ def _overload_extension(
     return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def nipype_interfaces_afni__AFNICommand___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -386,6 +345,7 @@ def nipype_interfaces_afni__AFNICommand___list_outputs(
     return outputs
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
     metadata = dict(name_source=lambda t: t is not None)
diff --git a/example-specs/task/nipype/afni/edge_3_callables.py b/example-specs/task/nipype/afni/edge_3_callables.py
index 80b60e13..27344a9a 100644
--- a/example-specs/task/nipype/afni/edge_3_callables.py
+++ b/example-specs/task/nipype/afni/edge_3_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Edge3.yaml"""
 
 from looseversion import LooseVersion
-import logging
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,6 +17,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -27,56 +28,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -171,6 +123,7 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -190,10 +143,12 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -231,6 +186,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -281,6 +237,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
 
@@ -364,6 +321,7 @@ def standard_image(img_name):
         return os.path.join(basedir, img_name)
 
 
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -371,6 +329,7 @@ def _overload_extension(
     return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def nipype_interfaces_afni__AFNICommand___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -386,6 +345,7 @@ def nipype_interfaces_afni__AFNICommand___list_outputs(
     return outputs
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
     metadata = dict(name_source=lambda t: t is not None)
diff --git a/example-specs/task/nipype/afni/eval_callables.py b/example-specs/task/nipype/afni/eval_callables.py
index db7222d7..716d57f8 100644
--- a/example-specs/task/nipype/afni/eval_callables.py
+++ b/example-specs/task/nipype/afni/eval_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Eval.yaml"""
 
 from looseversion import LooseVersion
-import logging
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,6 +17,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -27,56 +28,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -171,6 +123,7 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -190,10 +143,12 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -231,6 +186,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -281,6 +237,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
 
@@ -364,6 +321,7 @@ def standard_image(img_name):
         return os.path.join(basedir, img_name)
 
 
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -371,6 +329,7 @@ def _overload_extension(
     return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def nipype_interfaces_afni__AFNICommand___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -386,6 +345,7 @@ def nipype_interfaces_afni__AFNICommand___list_outputs(
     return outputs
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
     metadata = dict(name_source=lambda t: t is not None)
diff --git a/example-specs/task/nipype/afni/fim_callables.py b/example-specs/task/nipype/afni/fim_callables.py
index fc328e13..0d81fd13 100644
--- a/example-specs/task/nipype/afni/fim_callables.py
+++ b/example-specs/task/nipype/afni/fim_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Fim.yaml"""
 
 from looseversion import LooseVersion
-import logging
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,6 +17,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -27,56 +28,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -171,6 +123,7 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -190,10 +143,12 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -231,6 +186,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -281,6 +237,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
 
@@ -364,6 +321,7 @@ def standard_image(img_name):
         return os.path.join(basedir, img_name)
 
 
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -371,6 +329,7 @@ def _overload_extension(
     return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def nipype_interfaces_afni__AFNICommand___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -386,6 +345,7 @@ def nipype_interfaces_afni__AFNICommand___list_outputs(
     return outputs
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
     metadata = dict(name_source=lambda t: t is not None)
diff --git a/example-specs/task/nipype/afni/fourier_callables.py b/example-specs/task/nipype/afni/fourier_callables.py
index 5bd1161f..52a35176 100644
--- a/example-specs/task/nipype/afni/fourier_callables.py
+++ b/example-specs/task/nipype/afni/fourier_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Fourier.yaml"""
 
 from looseversion import LooseVersion
-import logging
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,6 +17,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -27,56 +28,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -171,6 +123,7 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -190,10 +143,12 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -231,6 +186,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -281,6 +237,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
 
@@ -364,6 +321,7 @@ def standard_image(img_name):
         return os.path.join(basedir, img_name)
 
 
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -371,6 +329,7 @@ def _overload_extension(
     return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def nipype_interfaces_afni__AFNICommand___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -386,6 +345,7 @@ def nipype_interfaces_afni__AFNICommand___list_outputs(
     return outputs
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
     metadata = dict(name_source=lambda t: t is not None)
diff --git a/example-specs/task/nipype/afni/fwh_mx_callables.py b/example-specs/task/nipype/afni/fwh_mx_callables.py
index e492af77..1a610cb9 100644
--- a/example-specs/task/nipype/afni/fwh_mx_callables.py
+++ b/example-specs/task/nipype/afni/fwh_mx_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of FWHMx.yaml"""
 
 import numpy as np
-import logging
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -52,6 +52,7 @@ def out_acf_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -62,6 +63,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -112,12 +114,14 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L888 of <nipype-install>/interfaces/base/core.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
     return value
 
 
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -212,6 +216,7 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -231,10 +236,12 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L1386 of <nipype-install>/interfaces/afni/utils.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
 
diff --git a/example-specs/task/nipype/afni/gcor_callables.py b/example-specs/task/nipype/afni/gcor_callables.py
index a44c6a53..761e0b40 100644
--- a/example-specs/task/nipype/afni/gcor_callables.py
+++ b/example-specs/task/nipype/afni/gcor_callables.py
@@ -1,5 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of GCOR.yaml"""
 
+import attrs
+
 
 def out_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
@@ -8,9 +10,11 @@ def out_callable(output_dir, inputs, stdout, stderr):
     return outputs["out"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L3250 of <nipype-install>/interfaces/afni/utils.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     return {"out": getattr(self, "_gcor")}
diff --git a/example-specs/task/nipype/afni/hist_callables.py b/example-specs/task/nipype/afni/hist_callables.py
index 04f5d6f5..d136ec93 100644
--- a/example-specs/task/nipype/afni/hist_callables.py
+++ b/example-specs/task/nipype/afni/hist_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of Hist.yaml"""
 
-import logging
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -23,6 +23,7 @@ def out_show_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -33,6 +34,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -83,12 +85,14 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L888 of <nipype-install>/interfaces/base/core.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
     return value
 
 
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -183,6 +187,7 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -202,10 +207,12 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L1572 of <nipype-install>/interfaces/afni/preprocess.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
     outputs["out_file"] += ".niml.hist"
diff --git a/example-specs/task/nipype/afni/lfcd_callables.py b/example-specs/task/nipype/afni/lfcd_callables.py
index 348bf494..426af988 100644
--- a/example-specs/task/nipype/afni/lfcd_callables.py
+++ b/example-specs/task/nipype/afni/lfcd_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of LFCD.yaml"""
 
 from looseversion import LooseVersion
-import logging
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,6 +17,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -27,56 +28,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -171,6 +123,7 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -190,10 +143,12 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -231,6 +186,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -281,6 +237,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
 
@@ -364,6 +321,7 @@ def standard_image(img_name):
         return os.path.join(basedir, img_name)
 
 
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -371,6 +329,7 @@ def _overload_extension(
     return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def nipype_interfaces_afni__AFNICommand___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -386,6 +345,7 @@ def nipype_interfaces_afni__AFNICommand___list_outputs(
     return outputs
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
     metadata = dict(name_source=lambda t: t is not None)
diff --git a/example-specs/task/nipype/afni/local_bistat_callables.py b/example-specs/task/nipype/afni/local_bistat_callables.py
index 73c07460..2460317c 100644
--- a/example-specs/task/nipype/afni/local_bistat_callables.py
+++ b/example-specs/task/nipype/afni/local_bistat_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of LocalBistat.yaml"""
 
 from looseversion import LooseVersion
-import logging
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,6 +17,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -27,56 +28,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -171,6 +123,7 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -190,10 +143,12 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -231,6 +186,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -281,6 +237,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
 
@@ -364,6 +321,7 @@ def standard_image(img_name):
         return os.path.join(basedir, img_name)
 
 
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -371,6 +329,7 @@ def _overload_extension(
     return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def nipype_interfaces_afni__AFNICommand___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -386,6 +345,7 @@ def nipype_interfaces_afni__AFNICommand___list_outputs(
     return outputs
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
     metadata = dict(name_source=lambda t: t is not None)
diff --git a/example-specs/task/nipype/afni/localstat_callables.py b/example-specs/task/nipype/afni/localstat_callables.py
index e6677971..491992e9 100644
--- a/example-specs/task/nipype/afni/localstat_callables.py
+++ b/example-specs/task/nipype/afni/localstat_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Localstat.yaml"""
 
 from looseversion import LooseVersion
-import logging
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,6 +17,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -27,56 +28,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -171,6 +123,7 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -190,10 +143,12 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -231,6 +186,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -281,6 +237,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
 
@@ -364,6 +321,7 @@ def standard_image(img_name):
         return os.path.join(basedir, img_name)
 
 
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -371,6 +329,7 @@ def _overload_extension(
     return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def nipype_interfaces_afni__AFNICommand___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -386,6 +345,7 @@ def nipype_interfaces_afni__AFNICommand___list_outputs(
     return outputs
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
     metadata = dict(name_source=lambda t: t is not None)
diff --git a/example-specs/task/nipype/afni/mask_tool_callables.py b/example-specs/task/nipype/afni/mask_tool_callables.py
index f4fa78db..2ca951f5 100644
--- a/example-specs/task/nipype/afni/mask_tool_callables.py
+++ b/example-specs/task/nipype/afni/mask_tool_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of MaskTool.yaml"""
 
 from looseversion import LooseVersion
-import logging
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,6 +17,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -27,56 +28,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -171,6 +123,7 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -190,10 +143,12 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -231,6 +186,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -281,6 +237,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
 
@@ -364,6 +321,7 @@ def standard_image(img_name):
         return os.path.join(basedir, img_name)
 
 
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -371,6 +329,7 @@ def _overload_extension(
     return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def nipype_interfaces_afni__AFNICommand___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -386,6 +345,7 @@ def nipype_interfaces_afni__AFNICommand___list_outputs(
     return outputs
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
     metadata = dict(name_source=lambda t: t is not None)
diff --git a/example-specs/task/nipype/afni/maskave_callables.py b/example-specs/task/nipype/afni/maskave_callables.py
index 7a9593f2..9ae65d62 100644
--- a/example-specs/task/nipype/afni/maskave_callables.py
+++ b/example-specs/task/nipype/afni/maskave_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Maskave.yaml"""
 
 from looseversion import LooseVersion
-import logging
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,6 +17,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -27,56 +28,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -171,6 +123,7 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -190,10 +143,12 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -231,6 +186,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -281,6 +237,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
 
@@ -364,6 +321,7 @@ def standard_image(img_name):
         return os.path.join(basedir, img_name)
 
 
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -371,6 +329,7 @@ def _overload_extension(
     return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def nipype_interfaces_afni__AFNICommand___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -386,6 +345,7 @@ def nipype_interfaces_afni__AFNICommand___list_outputs(
     return outputs
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
     metadata = dict(name_source=lambda t: t is not None)
diff --git a/example-specs/task/nipype/afni/means_callables.py b/example-specs/task/nipype/afni/means_callables.py
index 5b899adb..0c2cdec1 100644
--- a/example-specs/task/nipype/afni/means_callables.py
+++ b/example-specs/task/nipype/afni/means_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Means.yaml"""
 
 from looseversion import LooseVersion
-import logging
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,6 +17,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -27,56 +28,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -171,6 +123,7 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -190,10 +143,12 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -231,6 +186,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -281,6 +237,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
 
@@ -364,6 +321,7 @@ def standard_image(img_name):
         return os.path.join(basedir, img_name)
 
 
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -371,6 +329,7 @@ def _overload_extension(
     return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def nipype_interfaces_afni__AFNICommand___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -386,6 +345,7 @@ def nipype_interfaces_afni__AFNICommand___list_outputs(
     return outputs
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
     metadata = dict(name_source=lambda t: t is not None)
diff --git a/example-specs/task/nipype/afni/merge_callables.py b/example-specs/task/nipype/afni/merge_callables.py
index 232b7149..75a551d9 100644
--- a/example-specs/task/nipype/afni/merge_callables.py
+++ b/example-specs/task/nipype/afni/merge_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Merge.yaml"""
 
 from looseversion import LooseVersion
-import logging
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,6 +17,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -27,56 +28,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -171,6 +123,7 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -190,10 +143,12 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -231,6 +186,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -281,6 +237,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
 
@@ -364,6 +321,7 @@ def standard_image(img_name):
         return os.path.join(basedir, img_name)
 
 
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -371,6 +329,7 @@ def _overload_extension(
     return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def nipype_interfaces_afni__AFNICommand___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -386,6 +345,7 @@ def nipype_interfaces_afni__AFNICommand___list_outputs(
     return outputs
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
     metadata = dict(name_source=lambda t: t is not None)
diff --git a/example-specs/task/nipype/afni/net_corr_callables.py b/example-specs/task/nipype/afni/net_corr_callables.py
index 45487ad9..be193a75 100644
--- a/example-specs/task/nipype/afni/net_corr_callables.py
+++ b/example-specs/task/nipype/afni/net_corr_callables.py
@@ -1,10 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of NetCorr.yaml"""
 
 from looseversion import LooseVersion
-from pathlib import Path
-import os.path as op
+import glob
 import attrs
 import os
+import os.path as op
+from pathlib import Path
 
 
 def out_corr_matrix_callable(output_dir, inputs, stdout, stderr):
@@ -21,6 +22,7 @@ def out_corr_maps_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_corr_maps"]
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -58,6 +60,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -100,6 +103,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -150,6 +154,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
 
@@ -233,6 +238,7 @@ def standard_image(img_name):
         return os.path.join(basedir, img_name)
 
 
+# Original source at L260 of <nipype-install>/interfaces/afni/base.py
 def _gen_fname(
     basename,
     cwd=None,
@@ -287,10 +293,12 @@ def _gen_fname(
     return fname
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L2732 of <nipype-install>/interfaces/afni/preprocess.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     import glob
 
diff --git a/example-specs/task/nipype/afni/notes_callables.py b/example-specs/task/nipype/afni/notes_callables.py
index c8d03bfd..f5d9673f 100644
--- a/example-specs/task/nipype/afni/notes_callables.py
+++ b/example-specs/task/nipype/afni/notes_callables.py
@@ -1,6 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of Notes.yaml"""
 
 import os
+import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -10,10 +11,12 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_file"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L1949 of <nipype-install>/interfaces/afni/utils.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["out_file"] = os.path.abspath(inputs.in_file)
diff --git a/example-specs/task/nipype/afni/nwarp_adjust_callables.py b/example-specs/task/nipype/afni/nwarp_adjust_callables.py
index d056064c..3f6aaeb8 100644
--- a/example-specs/task/nipype/afni/nwarp_adjust_callables.py
+++ b/example-specs/task/nipype/afni/nwarp_adjust_callables.py
@@ -1,7 +1,8 @@
 """Module to put any functions that are referred to in the "callables" section of NwarpAdjust.yaml"""
 
-import os.path as op
 import os
+import os.path as op
+import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -11,10 +12,12 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_file"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L2016 of <nipype-install>/interfaces/afni/utils.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
 
diff --git a/example-specs/task/nipype/afni/nwarp_apply_callables.py b/example-specs/task/nipype/afni/nwarp_apply_callables.py
index 82f27eda..399d47d6 100644
--- a/example-specs/task/nipype/afni/nwarp_apply_callables.py
+++ b/example-specs/task/nipype/afni/nwarp_apply_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of NwarpApply.yaml"""
 
 import logging
+import os
 import os.path as op
 import attrs
-import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +16,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -26,6 +27,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -76,12 +78,14 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L888 of <nipype-install>/interfaces/base/core.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
     return value
 
 
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -176,10 +180,12 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     metadata = dict(name_source=lambda t: t is not None)
     traits = inputs.traits(**metadata)
diff --git a/example-specs/task/nipype/afni/nwarp_cat_callables.py b/example-specs/task/nipype/afni/nwarp_cat_callables.py
index 1211b0f3..83981a96 100644
--- a/example-specs/task/nipype/afni/nwarp_cat_callables.py
+++ b/example-specs/task/nipype/afni/nwarp_cat_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of NwarpCat.yaml"""
 
 from looseversion import LooseVersion
-from pathlib import Path
-import os.path as op
 import attrs
 import os
+import os.path as op
+from pathlib import Path
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -14,6 +14,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_file"]
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -51,6 +52,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -93,6 +95,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -143,6 +146,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
 
@@ -226,6 +230,7 @@ def standard_image(img_name):
         return os.path.join(basedir, img_name)
 
 
+# Original source at L260 of <nipype-install>/interfaces/afni/base.py
 def _gen_fname(
     basename,
     cwd=None,
@@ -280,6 +285,7 @@ def _gen_fname(
     return fname
 
 
+# Original source at L2235 of <nipype-install>/interfaces/afni/utils.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "out_file":
         return _gen_fname(
@@ -292,6 +298,7 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
         )
 
 
+# Original source at L2239 of <nipype-install>/interfaces/afni/utils.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     if inputs.out_file is not attrs.NOTHING:
diff --git a/example-specs/task/nipype/afni/one_d_tool_py.yaml b/example-specs/task/nipype/afni/one_d_tool_py.yaml
index 0c532f5b..01d955da 100644
--- a/example-specs/task/nipype/afni/one_d_tool_py.yaml
+++ b/example-specs/task/nipype/afni/one_d_tool_py.yaml
@@ -82,7 +82,7 @@ tests:
     show_censor_count:
     # type=bool|default=False: display the total number of censored TRs  Note : if input is a valid xmat.1D dataset, then the count will come from the header.  Otherwise the input is assumed to be a binary censorfile, and zeros are simply counted.
     censor_motion:
-    # type=tuple|default=(<traits.trait_types.Float object at 0x1121da450>, <nipype.interfaces.base.traits_extension.File object at 0x1121da510>): Tuple of motion limit and outfile prefix. need to also set set_nruns -r set_run_lengths
+    # type=tuple|default=(<traits.trait_types.Float object at 0x107a1bcd0>, <nipype.interfaces.base.traits_extension.File object at 0x107a1bd90>): Tuple of motion limit and outfile prefix. need to also set set_nruns -r set_run_lengths
     censor_prev_TR:
     # type=bool|default=False: for each censored TR, also censor previous
     show_trs_uncensored:
diff --git a/example-specs/task/nipype/afni/one_d_tool_py_callables.py b/example-specs/task/nipype/afni/one_d_tool_py_callables.py
index 5e90daa0..2462a10d 100644
--- a/example-specs/task/nipype/afni/one_d_tool_py_callables.py
+++ b/example-specs/task/nipype/afni/one_d_tool_py_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of OneDToolPy.yaml"""
 
-import attrs
 import os
+import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -11,10 +11,12 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_file"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L2332 of <nipype-install>/interfaces/afni/utils.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
 
diff --git a/example-specs/task/nipype/afni/outlier_count_callables.py b/example-specs/task/nipype/afni/outlier_count_callables.py
index 7f671a86..10af7cc3 100644
--- a/example-specs/task/nipype/afni/outlier_count_callables.py
+++ b/example-specs/task/nipype/afni/outlier_count_callables.py
@@ -1,6 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of OutlierCount.yaml"""
 
 import os.path as op
+import attrs
 
 
 def out_outliers_callable(output_dir, inputs, stdout, stderr):
@@ -17,10 +18,12 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_file"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L1848 of <nipype-install>/interfaces/afni/preprocess.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["out_file"] = op.abspath(inputs.out_file)
diff --git a/example-specs/task/nipype/afni/quality_index_callables.py b/example-specs/task/nipype/afni/quality_index_callables.py
index 96b6ac80..297de710 100644
--- a/example-specs/task/nipype/afni/quality_index_callables.py
+++ b/example-specs/task/nipype/afni/quality_index_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of QualityIndex.yaml"""
 
 import logging
+import os
 import os.path as op
 import attrs
-import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +16,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -26,6 +27,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -76,12 +78,14 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L888 of <nipype-install>/interfaces/base/core.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
     return value
 
 
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -176,10 +180,12 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     metadata = dict(name_source=lambda t: t is not None)
     traits = inputs.traits(**metadata)
diff --git a/example-specs/task/nipype/afni/qwarp.yaml b/example-specs/task/nipype/afni/qwarp.yaml
index dacb919c..bb49eb53 100644
--- a/example-specs/task/nipype/afni/qwarp.yaml
+++ b/example-specs/task/nipype/afni/qwarp.yaml
@@ -193,7 +193,7 @@ tests:
     wball:
     # type=list|default=[]: "``-wball x y z r f`` Enhance automatic weight from '-useweight' by a factor of 1+f\*Gaussian(FWHM=r) centered in the base image at DICOM coordinates (x,y,z) and with radius 'r'. The goal of this option is to try and make the alignment better in a specific part of the brain. Example:  -wball 0 14 6 30 40 to emphasize the thalamic area (in MNI/Talairach space).  * The 'r' parameter must be positive! * The 'f' parameter must be between 1 and 100 (inclusive). * '-wball' does nothing if you input your own weight   with the '-weight' option. * '-wball' does change the binary weight created by   the '-noweight' option. * You can only use '-wball' once in a run of 3dQwarp.  **The effect of '-wball' is not dramatic.** The example above makes the average brain image across a collection of subjects a little sharper in the thalamic area, which might have some small value.  If you care enough about alignment to use '-wball', then you should examine the results from 3dQwarp for each subject, to see if the alignments are good enough for your purposes.
     wmask:
-    # type=tuple|default=(<nipype.interfaces.base.traits_extension.File object at 0x1120d3c90>, <traits.trait_types.Float object at 0x1120d3910>): Similar to '-wball', but here, you provide a dataset 'ws' that indicates where to increase the weight.  * The 'ws' dataset must be on the same 3D grid as the base dataset. * 'ws' is treated as a mask -- it only matters where it   is nonzero -- otherwise, the values inside are not used. * After 'ws' comes the factor 'f' by which to increase the   automatically computed weight.  Where 'ws' is nonzero,   the weighting will be multiplied by (1+f). * As with '-wball', the factor 'f' should be between 1 and 100.  
+    # type=tuple|default=(<nipype.interfaces.base.traits_extension.File object at 0x10791de50>, <traits.trait_types.Float object at 0x10791e190>): Similar to '-wball', but here, you provide a dataset 'ws' that indicates where to increase the weight.  * The 'ws' dataset must be on the same 3D grid as the base dataset. * 'ws' is treated as a mask -- it only matters where it   is nonzero -- otherwise, the values inside are not used. * After 'ws' comes the factor 'f' by which to increase the   automatically computed weight.  Where 'ws' is nonzero,   the weighting will be multiplied by (1+f). * As with '-wball', the factor 'f' should be between 1 and 100.  
     out_weight_file:
     # type=file|default=<undefined>: Write the weight volume to disk as a dataset
     blur:
diff --git a/example-specs/task/nipype/afni/qwarp_callables.py b/example-specs/task/nipype/afni/qwarp_callables.py
index 32817510..8a001f67 100644
--- a/example-specs/task/nipype/afni/qwarp_callables.py
+++ b/example-specs/task/nipype/afni/qwarp_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Qwarp.yaml"""
 
-from pathlib import Path
 from looseversion import LooseVersion
-import os.path as op
 import attrs
 import os
+import os.path as op
+from pathlib import Path
 
 
 def warped_source_callable(output_dir, inputs, stdout, stderr):
@@ -42,6 +42,7 @@ def weights_callable(output_dir, inputs, stdout, stderr):
     return outputs["weights"]
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -79,181 +80,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
-def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
-    """Manipulates path and name of input filename
-
-    Parameters
-    ----------
-    fname : string
-        A filename (may or may not include path)
-    prefix : string
-        Characters to prepend to the filename
-    suffix : string
-        Characters to append to the filename
-    newpath : string
-        Path to replace the path of the input fname
-    use_ext : boolean
-        If True (default), appends the extension of the original file
-        to the output name.
-
-    Returns
-    -------
-    Absolute path of the modified filename
-
-    >>> from nipype.utils.filemanip import fname_presuffix
-    >>> fname = 'foo.nii.gz'
-    >>> fname_presuffix(fname,'pre','post','/tmp')
-    '/tmp/prefoopost.nii.gz'
-
-    >>> from nipype.interfaces.base import attrs.NOTHING
-    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
-            fname_presuffix(fname, 'pre', 'post')
-    True
-
-    """
-    pth, fname, ext = split_filename(fname)
-    if not use_ext:
-        ext = ""
-
-    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
-    if newpath:
-        pth = op.abspath(newpath)
-    return op.join(pth, prefix + fname + suffix + ext)
-
-
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
-class Info(PackageInfo):
-    """Handle afni output type and version information."""
-
-    __outputtype = "AFNI"
-    ftypes = {"NIFTI": ".nii", "AFNI": "", "NIFTI_GZ": ".nii.gz"}
-    version_cmd = "afni --version"
-
-    @staticmethod
-    def parse_version(raw_info):
-        """Check and parse AFNI's version."""
-        version_stamp = raw_info.split("\n")[0].split("Version ")[1]
-        if version_stamp.startswith("AFNI"):
-            version_stamp = version_stamp.split("AFNI_")[1]
-        elif version_stamp.startswith("Debian"):
-            version_stamp = version_stamp.split("Debian-")[1].split("~")[0]
-        else:
-            return None
-
-        version = LooseVersion(version_stamp.replace("_", ".")).version[:3]
-        if version[0] < 1000:
-            version[0] = version[0] + 2000
-        return tuple(version)
-
-    @classmethod
-    def output_type_to_ext(cls, outputtype):
-        """
-        Get the file extension for the given output type.
-
-        Parameters
-        ----------
-        outputtype : {'NIFTI', 'NIFTI_GZ', 'AFNI'}
-            String specifying the output type.
-
-        Returns
-        -------
-        extension : str
-            The file extension for the output type.
-
-        """
-        try:
-            return cls.ftypes[outputtype]
-        except KeyError as e:
-            msg = "Invalid AFNIOUTPUTTYPE: ", outputtype
-            raise KeyError(msg) from e
-
-    @classmethod
-    def outputtype(cls):
-        """
-        Set default output filetype.
-
-        AFNI has no environment variables, Output filetypes get set in command line calls
-        Nipype uses ``AFNI`` as default
-
-
-        Returns
-        -------
-        None
-
-        """
-        return "AFNI"
-
-    @staticmethod
-    def standard_image(img_name):
-        """
-        Grab an image from the standard location.
-
-        Could be made more fancy to allow for more relocatability
-
-        """
-        clout = CommandLine(
-            "which afni",
-            ignore_exception=True,
-            resource_monitor=False,
-            terminal_output="allatonce",
-        ).run()
-        if clout.runtime.returncode != 0:
-            return None
-
-        out = clout.runtime.stdout
-        basedir = os.path.split(out)[0]
-        return os.path.join(basedir, img_name)
-
-
+# Original source at L260 of <nipype-install>/interfaces/afni/base.py
 def _gen_fname(
     basename,
     cwd=None,
@@ -308,6 +135,7 @@ def _gen_fname(
     return fname
 
 
+# Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
 
@@ -391,6 +219,7 @@ def standard_image(img_name):
         return os.path.join(basedir, img_name)
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -433,6 +262,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -483,6 +313,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L4449 of <nipype-install>/interfaces/afni/preprocess.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "out_file":
         return _gen_fname(
@@ -495,6 +326,7 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
         )
 
 
+# Original source at L4372 of <nipype-install>/interfaces/afni/preprocess.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
 
diff --git a/example-specs/task/nipype/afni/qwarp_plus_minus.yaml b/example-specs/task/nipype/afni/qwarp_plus_minus.yaml
index 3f4e8642..b6984cbb 100644
--- a/example-specs/task/nipype/afni/qwarp_plus_minus.yaml
+++ b/example-specs/task/nipype/afni/qwarp_plus_minus.yaml
@@ -129,7 +129,7 @@ tests:
     wball:
     # type=list|default=[]: "``-wball x y z r f`` Enhance automatic weight from '-useweight' by a factor of 1+f\*Gaussian(FWHM=r) centered in the base image at DICOM coordinates (x,y,z) and with radius 'r'. The goal of this option is to try and make the alignment better in a specific part of the brain. Example:  -wball 0 14 6 30 40 to emphasize the thalamic area (in MNI/Talairach space).  * The 'r' parameter must be positive! * The 'f' parameter must be between 1 and 100 (inclusive). * '-wball' does nothing if you input your own weight   with the '-weight' option. * '-wball' does change the binary weight created by   the '-noweight' option. * You can only use '-wball' once in a run of 3dQwarp.  **The effect of '-wball' is not dramatic.** The example above makes the average brain image across a collection of subjects a little sharper in the thalamic area, which might have some small value.  If you care enough about alignment to use '-wball', then you should examine the results from 3dQwarp for each subject, to see if the alignments are good enough for your purposes.
     wmask:
-    # type=tuple|default=(<nipype.interfaces.base.traits_extension.File object at 0x1120d3c90>, <traits.trait_types.Float object at 0x1120d3910>): Similar to '-wball', but here, you provide a dataset 'ws' that indicates where to increase the weight.  * The 'ws' dataset must be on the same 3D grid as the base dataset. * 'ws' is treated as a mask -- it only matters where it   is nonzero -- otherwise, the values inside are not used. * After 'ws' comes the factor 'f' by which to increase the   automatically computed weight.  Where 'ws' is nonzero,   the weighting will be multiplied by (1+f). * As with '-wball', the factor 'f' should be between 1 and 100.  
+    # type=tuple|default=(<nipype.interfaces.base.traits_extension.File object at 0x10791de50>, <traits.trait_types.Float object at 0x10791e190>): Similar to '-wball', but here, you provide a dataset 'ws' that indicates where to increase the weight.  * The 'ws' dataset must be on the same 3D grid as the base dataset. * 'ws' is treated as a mask -- it only matters where it   is nonzero -- otherwise, the values inside are not used. * After 'ws' comes the factor 'f' by which to increase the   automatically computed weight.  Where 'ws' is nonzero,   the weighting will be multiplied by (1+f). * As with '-wball', the factor 'f' should be between 1 and 100.  
     out_weight_file:
     # type=file|default=<undefined>: Write the weight volume to disk as a dataset
     blur:
diff --git a/example-specs/task/nipype/afni/qwarp_plus_minus_callables.py b/example-specs/task/nipype/afni/qwarp_plus_minus_callables.py
index e85b078f..92727841 100644
--- a/example-specs/task/nipype/afni/qwarp_plus_minus_callables.py
+++ b/example-specs/task/nipype/afni/qwarp_plus_minus_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of QwarpPlusMinus.yaml"""
 
-from pathlib import Path
 from looseversion import LooseVersion
-import os.path as op
 import attrs
 import os
+import os.path as op
+from pathlib import Path
 
 
 def warped_source_callable(output_dir, inputs, stdout, stderr):
@@ -42,6 +42,7 @@ def weights_callable(output_dir, inputs, stdout, stderr):
     return outputs["weights"]
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -79,181 +80,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
-def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
-    """Manipulates path and name of input filename
-
-    Parameters
-    ----------
-    fname : string
-        A filename (may or may not include path)
-    prefix : string
-        Characters to prepend to the filename
-    suffix : string
-        Characters to append to the filename
-    newpath : string
-        Path to replace the path of the input fname
-    use_ext : boolean
-        If True (default), appends the extension of the original file
-        to the output name.
-
-    Returns
-    -------
-    Absolute path of the modified filename
-
-    >>> from nipype.utils.filemanip import fname_presuffix
-    >>> fname = 'foo.nii.gz'
-    >>> fname_presuffix(fname,'pre','post','/tmp')
-    '/tmp/prefoopost.nii.gz'
-
-    >>> from nipype.interfaces.base import attrs.NOTHING
-    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
-            fname_presuffix(fname, 'pre', 'post')
-    True
-
-    """
-    pth, fname, ext = split_filename(fname)
-    if not use_ext:
-        ext = ""
-
-    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
-    if newpath:
-        pth = op.abspath(newpath)
-    return op.join(pth, prefix + fname + suffix + ext)
-
-
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
-class Info(PackageInfo):
-    """Handle afni output type and version information."""
-
-    __outputtype = "AFNI"
-    ftypes = {"NIFTI": ".nii", "AFNI": "", "NIFTI_GZ": ".nii.gz"}
-    version_cmd = "afni --version"
-
-    @staticmethod
-    def parse_version(raw_info):
-        """Check and parse AFNI's version."""
-        version_stamp = raw_info.split("\n")[0].split("Version ")[1]
-        if version_stamp.startswith("AFNI"):
-            version_stamp = version_stamp.split("AFNI_")[1]
-        elif version_stamp.startswith("Debian"):
-            version_stamp = version_stamp.split("Debian-")[1].split("~")[0]
-        else:
-            return None
-
-        version = LooseVersion(version_stamp.replace("_", ".")).version[:3]
-        if version[0] < 1000:
-            version[0] = version[0] + 2000
-        return tuple(version)
-
-    @classmethod
-    def output_type_to_ext(cls, outputtype):
-        """
-        Get the file extension for the given output type.
-
-        Parameters
-        ----------
-        outputtype : {'NIFTI', 'NIFTI_GZ', 'AFNI'}
-            String specifying the output type.
-
-        Returns
-        -------
-        extension : str
-            The file extension for the output type.
-
-        """
-        try:
-            return cls.ftypes[outputtype]
-        except KeyError as e:
-            msg = "Invalid AFNIOUTPUTTYPE: ", outputtype
-            raise KeyError(msg) from e
-
-    @classmethod
-    def outputtype(cls):
-        """
-        Set default output filetype.
-
-        AFNI has no environment variables, Output filetypes get set in command line calls
-        Nipype uses ``AFNI`` as default
-
-
-        Returns
-        -------
-        None
-
-        """
-        return "AFNI"
-
-    @staticmethod
-    def standard_image(img_name):
-        """
-        Grab an image from the standard location.
-
-        Could be made more fancy to allow for more relocatability
-
-        """
-        clout = CommandLine(
-            "which afni",
-            ignore_exception=True,
-            resource_monitor=False,
-            terminal_output="allatonce",
-        ).run()
-        if clout.runtime.returncode != 0:
-            return None
-
-        out = clout.runtime.stdout
-        basedir = os.path.split(out)[0]
-        return os.path.join(basedir, img_name)
-
-
+# Original source at L260 of <nipype-install>/interfaces/afni/base.py
 def _gen_fname(
     basename,
     cwd=None,
@@ -308,6 +135,7 @@ def _gen_fname(
     return fname
 
 
+# Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
 
@@ -391,6 +219,7 @@ def standard_image(img_name):
         return os.path.join(basedir, img_name)
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -433,6 +262,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -483,6 +313,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L4449 of <nipype-install>/interfaces/afni/preprocess.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "out_file":
         return _gen_fname(
@@ -495,6 +326,7 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
         )
 
 
+# Original source at L4372 of <nipype-install>/interfaces/afni/preprocess.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
 
diff --git a/example-specs/task/nipype/afni/re_ho_callables.py b/example-specs/task/nipype/afni/re_ho_callables.py
index 79ba9979..e8777d55 100644
--- a/example-specs/task/nipype/afni/re_ho_callables.py
+++ b/example-specs/task/nipype/afni/re_ho_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of ReHo.yaml"""
 
 import logging
+import os
 import os.path as op
 import attrs
-import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -23,6 +23,7 @@ def out_vals_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -33,6 +34,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -83,12 +85,14 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L888 of <nipype-install>/interfaces/base/core.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
     return value
 
 
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -183,6 +187,7 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -202,10 +207,12 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L2583 of <nipype-install>/interfaces/afni/utils.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
     if inputs.label_set:
diff --git a/example-specs/task/nipype/afni/refit_callables.py b/example-specs/task/nipype/afni/refit_callables.py
index 8b1018aa..1d36898e 100644
--- a/example-specs/task/nipype/afni/refit_callables.py
+++ b/example-specs/task/nipype/afni/refit_callables.py
@@ -1,6 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of Refit.yaml"""
 
 import os
+import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -10,10 +11,12 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_file"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L2463 of <nipype-install>/interfaces/afni/utils.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["out_file"] = os.path.abspath(inputs.in_file)
diff --git a/example-specs/task/nipype/afni/remlfit_callables.py b/example-specs/task/nipype/afni/remlfit_callables.py
index e7a1571b..08925cd9 100644
--- a/example-specs/task/nipype/afni/remlfit_callables.py
+++ b/example-specs/task/nipype/afni/remlfit_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of Remlfit.yaml"""
 
-import attrs
 import os
+import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -95,10 +95,12 @@ def oerrts_callable(output_dir, inputs, stdout, stderr):
     return outputs["oerrts"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L642 of <nipype-install>/interfaces/afni/model.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
 
diff --git a/example-specs/task/nipype/afni/resample_callables.py b/example-specs/task/nipype/afni/resample_callables.py
index 368b442d..9dfccc6d 100644
--- a/example-specs/task/nipype/afni/resample_callables.py
+++ b/example-specs/task/nipype/afni/resample_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Resample.yaml"""
 
 from looseversion import LooseVersion
-import logging
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,6 +17,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -27,56 +28,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -171,6 +123,7 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -190,10 +143,12 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -231,6 +186,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -281,6 +237,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
 
@@ -364,6 +321,7 @@ def standard_image(img_name):
         return os.path.join(basedir, img_name)
 
 
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -371,6 +329,7 @@ def _overload_extension(
     return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def nipype_interfaces_afni__AFNICommand___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -386,6 +345,7 @@ def nipype_interfaces_afni__AFNICommand___list_outputs(
     return outputs
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
     metadata = dict(name_source=lambda t: t is not None)
diff --git a/example-specs/task/nipype/afni/retroicor_callables.py b/example-specs/task/nipype/afni/retroicor_callables.py
index 9fd4993a..e0d2fbd2 100644
--- a/example-specs/task/nipype/afni/retroicor_callables.py
+++ b/example-specs/task/nipype/afni/retroicor_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Retroicor.yaml"""
 
 from looseversion import LooseVersion
-import logging
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,6 +17,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -27,56 +28,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -171,6 +123,7 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -190,10 +143,12 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -231,6 +186,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -281,6 +237,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
 
@@ -364,6 +321,7 @@ def standard_image(img_name):
         return os.path.join(basedir, img_name)
 
 
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -371,6 +329,7 @@ def _overload_extension(
     return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def nipype_interfaces_afni__AFNICommand___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -386,6 +345,7 @@ def nipype_interfaces_afni__AFNICommand___list_outputs(
     return outputs
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
     metadata = dict(name_source=lambda t: t is not None)
diff --git a/example-specs/task/nipype/afni/roi_stats_callables.py b/example-specs/task/nipype/afni/roi_stats_callables.py
index f772564f..263d67ff 100644
--- a/example-specs/task/nipype/afni/roi_stats_callables.py
+++ b/example-specs/task/nipype/afni/roi_stats_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of ROIStats.yaml"""
 
 import logging
+import os
 import os.path as op
 import attrs
-import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +16,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -26,6 +27,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -76,12 +78,14 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L888 of <nipype-install>/interfaces/base/core.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
     return value
 
 
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -176,10 +180,12 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     metadata = dict(name_source=lambda t: t is not None)
     traits = inputs.traits(**metadata)
diff --git a/example-specs/task/nipype/afni/seg_callables.py b/example-specs/task/nipype/afni/seg_callables.py
index fe47595b..4c1a0ae0 100644
--- a/example-specs/task/nipype/afni/seg_callables.py
+++ b/example-specs/task/nipype/afni/seg_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of Seg.yaml"""
 
 import logging
+import os
 import os.path as op
 import attrs
-import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +16,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -26,6 +27,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -76,12 +78,14 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L888 of <nipype-install>/interfaces/base/core.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
     return value
 
 
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -176,10 +180,12 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     metadata = dict(name_source=lambda t: t is not None)
     traits = inputs.traits(**metadata)
diff --git a/example-specs/task/nipype/afni/skull_strip_callables.py b/example-specs/task/nipype/afni/skull_strip_callables.py
index f05ba630..5798aa6b 100644
--- a/example-specs/task/nipype/afni/skull_strip_callables.py
+++ b/example-specs/task/nipype/afni/skull_strip_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of SkullStrip.yaml"""
 
 from looseversion import LooseVersion
-import logging
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,6 +17,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -27,56 +28,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -171,6 +123,7 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -190,10 +143,12 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -231,6 +186,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -281,6 +237,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
 
@@ -364,6 +321,7 @@ def standard_image(img_name):
         return os.path.join(basedir, img_name)
 
 
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -371,6 +329,7 @@ def _overload_extension(
     return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def nipype_interfaces_afni__AFNICommand___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -386,6 +345,7 @@ def nipype_interfaces_afni__AFNICommand___list_outputs(
     return outputs
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
     metadata = dict(name_source=lambda t: t is not None)
diff --git a/example-specs/task/nipype/afni/svm_test_callables.py b/example-specs/task/nipype/afni/svm_test_callables.py
index f04d969c..d3bfcd02 100644
--- a/example-specs/task/nipype/afni/svm_test_callables.py
+++ b/example-specs/task/nipype/afni/svm_test_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of SVMTest.yaml"""
 
 from looseversion import LooseVersion
-import logging
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,6 +17,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -27,56 +28,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -171,6 +123,7 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -190,10 +143,12 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -231,6 +186,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -281,6 +237,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
 
@@ -364,6 +321,7 @@ def standard_image(img_name):
         return os.path.join(basedir, img_name)
 
 
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -371,6 +329,7 @@ def _overload_extension(
     return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def nipype_interfaces_afni__AFNICommand___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -386,6 +345,7 @@ def nipype_interfaces_afni__AFNICommand___list_outputs(
     return outputs
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
     metadata = dict(name_source=lambda t: t is not None)
diff --git a/example-specs/task/nipype/afni/svm_train_callables.py b/example-specs/task/nipype/afni/svm_train_callables.py
index 05fdd888..aa2edc24 100644
--- a/example-specs/task/nipype/afni/svm_train_callables.py
+++ b/example-specs/task/nipype/afni/svm_train_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of SVMTrain.yaml"""
 
 from looseversion import LooseVersion
-import logging
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -31,6 +31,7 @@ def alphas_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -41,56 +42,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -185,6 +137,7 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -204,10 +157,12 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -245,6 +200,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -295,6 +251,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
 
@@ -378,6 +335,7 @@ def standard_image(img_name):
         return os.path.join(basedir, img_name)
 
 
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -385,6 +343,7 @@ def _overload_extension(
     return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def nipype_interfaces_afni__AFNICommand___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -400,6 +359,7 @@ def nipype_interfaces_afni__AFNICommand___list_outputs(
     return outputs
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
     metadata = dict(name_source=lambda t: t is not None)
diff --git a/example-specs/task/nipype/afni/synthesize_callables.py b/example-specs/task/nipype/afni/synthesize_callables.py
index 7b3637bb..faf2cd00 100644
--- a/example-specs/task/nipype/afni/synthesize_callables.py
+++ b/example-specs/task/nipype/afni/synthesize_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of Synthesize.yaml"""
 
-import attrs
 import os
+import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -11,10 +11,12 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_file"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L728 of <nipype-install>/interfaces/afni/model.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
 
diff --git a/example-specs/task/nipype/afni/t_cat_callables.py b/example-specs/task/nipype/afni/t_cat_callables.py
index 78daeace..c799d9e0 100644
--- a/example-specs/task/nipype/afni/t_cat_callables.py
+++ b/example-specs/task/nipype/afni/t_cat_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of TCat.yaml"""
 
 from looseversion import LooseVersion
-import logging
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,6 +17,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -27,56 +28,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -171,6 +123,7 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -190,10 +143,12 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -231,6 +186,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -281,6 +237,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
 
@@ -364,6 +321,7 @@ def standard_image(img_name):
         return os.path.join(basedir, img_name)
 
 
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -371,6 +329,7 @@ def _overload_extension(
     return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def nipype_interfaces_afni__AFNICommand___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -386,6 +345,7 @@ def nipype_interfaces_afni__AFNICommand___list_outputs(
     return outputs
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
     metadata = dict(name_source=lambda t: t is not None)
diff --git a/example-specs/task/nipype/afni/t_cat_sub_brick_callables.py b/example-specs/task/nipype/afni/t_cat_sub_brick_callables.py
index f2539d5c..a58c00cf 100644
--- a/example-specs/task/nipype/afni/t_cat_sub_brick_callables.py
+++ b/example-specs/task/nipype/afni/t_cat_sub_brick_callables.py
@@ -1,11 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of TCatSubBrick.yaml"""
 
-import logging
-from pathlib import Path
 from looseversion import LooseVersion
-import os.path as op
 import attrs
 import os
+import os.path as op
+import logging
+from pathlib import Path
 
 
 def out_file_default(inputs):
@@ -22,6 +22,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -32,56 +33,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -176,6 +128,7 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -195,6 +148,7 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
+# Original source at L2763 of <nipype-install>/interfaces/afni/utils.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "out_file":
         return _gen_fname(
@@ -207,6 +161,7 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
         )
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -244,48 +199,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
-def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
-    """Manipulates path and name of input filename
-
-    Parameters
-    ----------
-    fname : string
-        A filename (may or may not include path)
-    prefix : string
-        Characters to prepend to the filename
-    suffix : string
-        Characters to append to the filename
-    newpath : string
-        Path to replace the path of the input fname
-    use_ext : boolean
-        If True (default), appends the extension of the original file
-        to the output name.
-
-    Returns
-    -------
-    Absolute path of the modified filename
-
-    >>> from nipype.utils.filemanip import fname_presuffix
-    >>> fname = 'foo.nii.gz'
-    >>> fname_presuffix(fname,'pre','post','/tmp')
-    '/tmp/prefoopost.nii.gz'
-
-    >>> from nipype.interfaces.base import attrs.NOTHING
-    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
-            fname_presuffix(fname, 'pre', 'post')
-    True
-
-    """
-    pth, fname, ext = split_filename(fname)
-    if not use_ext:
-        ext = ""
-
-    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
-    if newpath:
-        pth = op.abspath(newpath)
-    return op.join(pth, prefix + fname + suffix + ext)
-
-
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -336,6 +250,50 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+# Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
 
@@ -419,6 +377,7 @@ def standard_image(img_name):
         return os.path.join(basedir, img_name)
 
 
+# Original source at L260 of <nipype-install>/interfaces/afni/base.py
 def _gen_fname(
     basename,
     cwd=None,
@@ -473,6 +432,7 @@ def _gen_fname(
     return fname
 
 
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -480,6 +440,7 @@ def _overload_extension(
     return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def nipype_interfaces_afni__AFNICommand___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -495,6 +456,7 @@ def nipype_interfaces_afni__AFNICommand___list_outputs(
     return outputs
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
     metadata = dict(name_source=lambda t: t is not None)
diff --git a/example-specs/task/nipype/afni/t_corr_1d_callables.py b/example-specs/task/nipype/afni/t_corr_1d_callables.py
index d1bf846c..ed32f60f 100644
--- a/example-specs/task/nipype/afni/t_corr_1d_callables.py
+++ b/example-specs/task/nipype/afni/t_corr_1d_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of TCorr1D.yaml"""
 
 from looseversion import LooseVersion
-import logging
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,6 +17,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -27,56 +28,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -171,6 +123,7 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -190,10 +143,12 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -231,6 +186,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -281,6 +237,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
 
@@ -364,6 +321,7 @@ def standard_image(img_name):
         return os.path.join(basedir, img_name)
 
 
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -371,6 +329,7 @@ def _overload_extension(
     return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def nipype_interfaces_afni__AFNICommand___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -386,6 +345,7 @@ def nipype_interfaces_afni__AFNICommand___list_outputs(
     return outputs
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
     metadata = dict(name_source=lambda t: t is not None)
diff --git a/example-specs/task/nipype/afni/t_corr_map.yaml b/example-specs/task/nipype/afni/t_corr_map.yaml
index 7baee5c9..968baa72 100644
--- a/example-specs/task/nipype/afni/t_corr_map.yaml
+++ b/example-specs/task/nipype/afni/t_corr_map.yaml
@@ -164,7 +164,7 @@ tests:
     polort:
     # type=int|default=0: 
     bandpass:
-    # type=tuple|default=(<traits.trait_types.Float object at 0x1120bd1d0>, <traits.trait_types.Float object at 0x1120bd150>): 
+    # type=tuple|default=(<traits.trait_types.Float object at 0x1078fa310>, <traits.trait_types.Float object at 0x107909610>): 
     regress_out_timeseries:
     # type=file|default=<undefined>: 
     blur_fwhm:
diff --git a/example-specs/task/nipype/afni/t_corr_map_callables.py b/example-specs/task/nipype/afni/t_corr_map_callables.py
index 1e597299..c08934cc 100644
--- a/example-specs/task/nipype/afni/t_corr_map_callables.py
+++ b/example-specs/task/nipype/afni/t_corr_map_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of TCorrMap.yaml"""
 
 from looseversion import LooseVersion
-import logging
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
 
 
 def mean_file_callable(output_dir, inputs, stdout, stderr):
@@ -101,6 +101,7 @@ def histogram_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -111,56 +112,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -255,6 +207,7 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -274,10 +227,12 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -315,6 +270,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -365,6 +321,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
 
@@ -448,6 +405,7 @@ def standard_image(img_name):
         return os.path.join(basedir, img_name)
 
 
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -455,6 +413,7 @@ def _overload_extension(
     return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def nipype_interfaces_afni__AFNICommand___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -470,6 +429,7 @@ def nipype_interfaces_afni__AFNICommand___list_outputs(
     return outputs
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
     metadata = dict(name_source=lambda t: t is not None)
diff --git a/example-specs/task/nipype/afni/t_correlate_callables.py b/example-specs/task/nipype/afni/t_correlate_callables.py
index 1094da73..8f603d0a 100644
--- a/example-specs/task/nipype/afni/t_correlate_callables.py
+++ b/example-specs/task/nipype/afni/t_correlate_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of TCorrelate.yaml"""
 
 from looseversion import LooseVersion
-import logging
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,6 +17,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -27,56 +28,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -171,6 +123,7 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -190,10 +143,12 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -231,6 +186,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -281,6 +237,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
 
@@ -364,6 +321,7 @@ def standard_image(img_name):
         return os.path.join(basedir, img_name)
 
 
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -371,6 +329,7 @@ def _overload_extension(
     return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def nipype_interfaces_afni__AFNICommand___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -386,6 +345,7 @@ def nipype_interfaces_afni__AFNICommand___list_outputs(
     return outputs
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
     metadata = dict(name_source=lambda t: t is not None)
diff --git a/example-specs/task/nipype/afni/t_norm_callables.py b/example-specs/task/nipype/afni/t_norm_callables.py
index 56a26af1..13cf6c59 100644
--- a/example-specs/task/nipype/afni/t_norm_callables.py
+++ b/example-specs/task/nipype/afni/t_norm_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of TNorm.yaml"""
 
 from looseversion import LooseVersion
-import logging
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,6 +17,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -27,56 +28,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -171,6 +123,7 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -190,10 +143,12 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -231,6 +186,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -281,6 +237,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
 
@@ -364,6 +321,7 @@ def standard_image(img_name):
         return os.path.join(basedir, img_name)
 
 
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -371,6 +329,7 @@ def _overload_extension(
     return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def nipype_interfaces_afni__AFNICommand___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -386,6 +345,7 @@ def nipype_interfaces_afni__AFNICommand___list_outputs(
     return outputs
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
     metadata = dict(name_source=lambda t: t is not None)
diff --git a/example-specs/task/nipype/afni/t_project_callables.py b/example-specs/task/nipype/afni/t_project_callables.py
index f3284a0f..ac8d2895 100644
--- a/example-specs/task/nipype/afni/t_project_callables.py
+++ b/example-specs/task/nipype/afni/t_project_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of TProject.yaml"""
 
 from looseversion import LooseVersion
-import logging
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,6 +17,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -27,56 +28,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -171,6 +123,7 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -190,10 +143,12 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -231,6 +186,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -281,6 +237,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
 
@@ -364,6 +321,7 @@ def standard_image(img_name):
         return os.path.join(basedir, img_name)
 
 
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -371,6 +329,7 @@ def _overload_extension(
     return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def nipype_interfaces_afni__AFNICommand___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -386,6 +345,7 @@ def nipype_interfaces_afni__AFNICommand___list_outputs(
     return outputs
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
     metadata = dict(name_source=lambda t: t is not None)
diff --git a/example-specs/task/nipype/afni/t_shift_callables.py b/example-specs/task/nipype/afni/t_shift_callables.py
index 9129a55f..b2d092b1 100644
--- a/example-specs/task/nipype/afni/t_shift_callables.py
+++ b/example-specs/task/nipype/afni/t_shift_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of TShift.yaml"""
 
 from looseversion import LooseVersion
-import logging
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
 
 
 def timing_file_callable(output_dir, inputs, stdout, stderr):
@@ -24,6 +24,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -61,56 +62,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
+# Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
 
@@ -194,6 +146,7 @@ def standard_image(img_name):
         return os.path.join(basedir, img_name)
 
 
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -201,6 +154,7 @@ def _overload_extension(
     return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def nipype_interfaces_afni__AFNICommand___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -216,6 +170,7 @@ def nipype_interfaces_afni__AFNICommand___list_outputs(
     return outputs
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -226,6 +181,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -276,6 +232,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -370,6 +327,7 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -389,10 +347,12 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L3302 of <nipype-install>/interfaces/afni/preprocess.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
     if inputs.slice_timing is not attrs.NOTHING:
diff --git a/example-specs/task/nipype/afni/t_smooth_callables.py b/example-specs/task/nipype/afni/t_smooth_callables.py
index 979ae331..579240e2 100644
--- a/example-specs/task/nipype/afni/t_smooth_callables.py
+++ b/example-specs/task/nipype/afni/t_smooth_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of TSmooth.yaml"""
 
 from looseversion import LooseVersion
-import logging
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,6 +17,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -27,56 +28,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -171,6 +123,7 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -190,10 +143,12 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -231,6 +186,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -281,6 +237,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
 
@@ -364,6 +321,7 @@ def standard_image(img_name):
         return os.path.join(basedir, img_name)
 
 
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -371,6 +329,7 @@ def _overload_extension(
     return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def nipype_interfaces_afni__AFNICommand___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -386,6 +345,7 @@ def nipype_interfaces_afni__AFNICommand___list_outputs(
     return outputs
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
     metadata = dict(name_source=lambda t: t is not None)
diff --git a/example-specs/task/nipype/afni/t_stat_callables.py b/example-specs/task/nipype/afni/t_stat_callables.py
index 1b3a6660..5347d6ed 100644
--- a/example-specs/task/nipype/afni/t_stat_callables.py
+++ b/example-specs/task/nipype/afni/t_stat_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of TStat.yaml"""
 
 from looseversion import LooseVersion
-import logging
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,6 +17,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -27,56 +28,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -171,6 +123,7 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -190,10 +143,12 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -231,6 +186,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -281,6 +237,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
 
@@ -364,6 +321,7 @@ def standard_image(img_name):
         return os.path.join(basedir, img_name)
 
 
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -371,6 +329,7 @@ def _overload_extension(
     return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def nipype_interfaces_afni__AFNICommand___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -386,6 +345,7 @@ def nipype_interfaces_afni__AFNICommand___list_outputs(
     return outputs
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
     metadata = dict(name_source=lambda t: t is not None)
diff --git a/example-specs/task/nipype/afni/to_3d_callables.py b/example-specs/task/nipype/afni/to_3d_callables.py
index 2dd192fa..1b4af9cb 100644
--- a/example-specs/task/nipype/afni/to_3d_callables.py
+++ b/example-specs/task/nipype/afni/to_3d_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of To3D.yaml"""
 
 from looseversion import LooseVersion
-import logging
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,6 +17,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -27,56 +28,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -171,6 +123,7 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -190,10 +143,12 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -231,6 +186,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -281,6 +237,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
 
@@ -364,6 +321,7 @@ def standard_image(img_name):
         return os.path.join(basedir, img_name)
 
 
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -371,6 +329,7 @@ def _overload_extension(
     return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def nipype_interfaces_afni__AFNICommand___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -386,6 +345,7 @@ def nipype_interfaces_afni__AFNICommand___list_outputs(
     return outputs
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
     metadata = dict(name_source=lambda t: t is not None)
diff --git a/example-specs/task/nipype/afni/undump_callables.py b/example-specs/task/nipype/afni/undump_callables.py
index 0b5b8ee3..cddb3740 100644
--- a/example-specs/task/nipype/afni/undump_callables.py
+++ b/example-specs/task/nipype/afni/undump_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Undump.yaml"""
 
 from looseversion import LooseVersion
-import logging
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,6 +17,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -27,56 +28,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -171,6 +123,7 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -190,10 +143,12 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -231,6 +186,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -281,6 +237,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
 
@@ -364,6 +321,7 @@ def standard_image(img_name):
         return os.path.join(basedir, img_name)
 
 
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -371,6 +329,7 @@ def _overload_extension(
     return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def nipype_interfaces_afni__AFNICommand___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -386,6 +345,7 @@ def nipype_interfaces_afni__AFNICommand___list_outputs(
     return outputs
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
     metadata = dict(name_source=lambda t: t is not None)
diff --git a/example-specs/task/nipype/afni/unifize_callables.py b/example-specs/task/nipype/afni/unifize_callables.py
index 470554ce..94e1028d 100644
--- a/example-specs/task/nipype/afni/unifize_callables.py
+++ b/example-specs/task/nipype/afni/unifize_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Unifize.yaml"""
 
 from looseversion import LooseVersion
-import logging
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
 
 
 def scale_file_callable(output_dir, inputs, stdout, stderr):
@@ -24,6 +24,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -34,56 +35,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -178,6 +130,7 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -197,10 +150,12 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -238,6 +193,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -288,6 +244,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
 
@@ -371,6 +328,7 @@ def standard_image(img_name):
         return os.path.join(basedir, img_name)
 
 
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -378,6 +336,7 @@ def _overload_extension(
     return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def nipype_interfaces_afni__AFNICommand___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -393,6 +352,7 @@ def nipype_interfaces_afni__AFNICommand___list_outputs(
     return outputs
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
     metadata = dict(name_source=lambda t: t is not None)
diff --git a/example-specs/task/nipype/afni/volreg_callables.py b/example-specs/task/nipype/afni/volreg_callables.py
index 9285c217..cadd735f 100644
--- a/example-specs/task/nipype/afni/volreg_callables.py
+++ b/example-specs/task/nipype/afni/volreg_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Volreg.yaml"""
 
 from looseversion import LooseVersion
-import logging
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -38,6 +38,7 @@ def oned_matrix_save_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -48,56 +49,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -192,6 +144,7 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -211,10 +164,12 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -252,6 +207,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -302,6 +258,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
 
@@ -385,6 +342,7 @@ def standard_image(img_name):
         return os.path.join(basedir, img_name)
 
 
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -392,6 +350,7 @@ def _overload_extension(
     return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def nipype_interfaces_afni__AFNICommand___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -407,6 +366,7 @@ def nipype_interfaces_afni__AFNICommand___list_outputs(
     return outputs
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
     metadata = dict(name_source=lambda t: t is not None)
diff --git a/example-specs/task/nipype/afni/warp_callables.py b/example-specs/task/nipype/afni/warp_callables.py
index d5cff1fc..59bd6001 100644
--- a/example-specs/task/nipype/afni/warp_callables.py
+++ b/example-specs/task/nipype/afni/warp_callables.py
@@ -1,11 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of Warp.yaml"""
 
 from looseversion import LooseVersion
-import logging
-from pathlib import Path
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
+from pathlib import Path
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -25,6 +25,7 @@ def warp_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -62,56 +63,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
+# Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
 
@@ -195,6 +147,7 @@ def standard_image(img_name):
         return os.path.join(basedir, img_name)
 
 
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -202,6 +155,7 @@ def _overload_extension(
     return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def nipype_interfaces_afni__AFNICommand___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -217,6 +171,7 @@ def nipype_interfaces_afni__AFNICommand___list_outputs(
     return outputs
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -227,56 +182,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -371,6 +277,7 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -390,10 +297,12 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -436,6 +345,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -486,6 +396,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L3615 of <nipype-install>/interfaces/afni/preprocess.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
     if inputs.save_warp:
diff --git a/example-specs/task/nipype/afni/z_cut_up_callables.py b/example-specs/task/nipype/afni/z_cut_up_callables.py
index 11fd70b3..61677e82 100644
--- a/example-specs/task/nipype/afni/z_cut_up_callables.py
+++ b/example-specs/task/nipype/afni/z_cut_up_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of ZCutUp.yaml"""
 
 from looseversion import LooseVersion
-import logging
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,6 +17,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -27,56 +28,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -171,6 +123,7 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -190,10 +143,12 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -231,6 +186,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -281,6 +237,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
 
@@ -364,6 +321,7 @@ def standard_image(img_name):
         return os.path.join(basedir, img_name)
 
 
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -371,6 +329,7 @@ def _overload_extension(
     return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def nipype_interfaces_afni__AFNICommand___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -386,6 +345,7 @@ def nipype_interfaces_afni__AFNICommand___list_outputs(
     return outputs
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
     metadata = dict(name_source=lambda t: t is not None)
diff --git a/example-specs/task/nipype/afni/zcat_callables.py b/example-specs/task/nipype/afni/zcat_callables.py
index 032833d4..30ab6cd7 100644
--- a/example-specs/task/nipype/afni/zcat_callables.py
+++ b/example-specs/task/nipype/afni/zcat_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Zcat.yaml"""
 
 from looseversion import LooseVersion
-import logging
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,6 +17,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -27,56 +28,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -171,6 +123,7 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -190,10 +143,12 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -231,6 +186,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -281,6 +237,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
 
@@ -364,6 +321,7 @@ def standard_image(img_name):
         return os.path.join(basedir, img_name)
 
 
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -371,6 +329,7 @@ def _overload_extension(
     return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def nipype_interfaces_afni__AFNICommand___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -386,6 +345,7 @@ def nipype_interfaces_afni__AFNICommand___list_outputs(
     return outputs
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
     metadata = dict(name_source=lambda t: t is not None)
diff --git a/example-specs/task/nipype/afni/zeropad_callables.py b/example-specs/task/nipype/afni/zeropad_callables.py
index 53afa228..1e137b69 100644
--- a/example-specs/task/nipype/afni/zeropad_callables.py
+++ b/example-specs/task/nipype/afni/zeropad_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Zeropad.yaml"""
 
 from looseversion import LooseVersion
-import logging
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,6 +17,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -27,56 +28,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -171,6 +123,7 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -190,10 +143,12 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -231,6 +186,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -281,6 +237,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
 
@@ -364,6 +321,7 @@ def standard_image(img_name):
         return os.path.join(basedir, img_name)
 
 
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -371,6 +329,7 @@ def _overload_extension(
     return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def nipype_interfaces_afni__AFNICommand___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -386,6 +345,7 @@ def nipype_interfaces_afni__AFNICommand___list_outputs(
     return outputs
 
 
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
     metadata = dict(name_source=lambda t: t is not None)
diff --git a/example-specs/task/nipype/ants/affine_initializer_callables.py b/example-specs/task/nipype/ants/affine_initializer_callables.py
index 90fccc67..1c877819 100644
--- a/example-specs/task/nipype/ants/affine_initializer_callables.py
+++ b/example-specs/task/nipype/ants/affine_initializer_callables.py
@@ -1,6 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of AffineInitializer.yaml"""
 
 import os
+import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -10,9 +11,11 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_file"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L834 of <nipype-install>/interfaces/ants/utils.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     return {"out_file": os.path.abspath(inputs.out_file)}
diff --git a/example-specs/task/nipype/ants/ai_callables.py b/example-specs/task/nipype/ants/ai_callables.py
index 50eef097..64cfad3f 100644
--- a/example-specs/task/nipype/ants/ai_callables.py
+++ b/example-specs/task/nipype/ants/ai_callables.py
@@ -1,5 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of AI.yaml"""
 
+import attrs
+
 
 def output_transform_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
@@ -8,9 +10,11 @@ def output_transform_callable(output_dir, inputs, stdout, stderr):
     return outputs["output_transform"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L539 of <nipype-install>/interfaces/ants/utils.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     return getattr(self, "_output")
diff --git a/example-specs/task/nipype/ants/ants_callables.py b/example-specs/task/nipype/ants/ants_callables.py
index ddea22ee..18da57a0 100644
--- a/example-specs/task/nipype/ants/ants_callables.py
+++ b/example-specs/task/nipype/ants/ants_callables.py
@@ -1,6 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of ANTS.yaml"""
 
 import os
+import attrs
 
 
 def affine_transform_callable(output_dir, inputs, stdout, stderr):
@@ -38,10 +39,12 @@ def metaheader_raw_callable(output_dir, inputs, stdout, stderr):
     return outputs["metaheader_raw"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L242 of <nipype-install>/interfaces/ants/registration.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["affine_transform"] = os.path.abspath(
diff --git a/example-specs/task/nipype/ants/ants_introduction_callables.py b/example-specs/task/nipype/ants/ants_introduction_callables.py
index 8e960e85..9b46dbf0 100644
--- a/example-specs/task/nipype/ants/ants_introduction_callables.py
+++ b/example-specs/task/nipype/ants/ants_introduction_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of antsIntroduction.yaml"""
 
-import attrs
 import os
+import attrs
 
 
 def affine_transformation_callable(output_dir, inputs, stdout, stderr):
@@ -39,10 +39,12 @@ def output_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["output_file"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L141 of <nipype-install>/interfaces/ants/legacy.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     transmodel = inputs.transformation_model
diff --git a/example-specs/task/nipype/ants/apply_transforms_callables.py b/example-specs/task/nipype/ants/apply_transforms_callables.py
index 468f358c..6b09bb57 100644
--- a/example-specs/task/nipype/ants/apply_transforms_callables.py
+++ b/example-specs/task/nipype/ants/apply_transforms_callables.py
@@ -1,8 +1,8 @@
 """Module to put any functions that are referred to in the "callables" section of ApplyTransforms.yaml"""
 
+import os
 import os.path as op
 import attrs
-import os
 
 
 def output_image_default(inputs):
@@ -16,6 +16,7 @@ def output_image_callable(output_dir, inputs, stdout, stderr):
     return outputs["output_image"]
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -66,6 +67,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L465 of <nipype-install>/interfaces/ants/resampling.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "output_image":
         output = inputs.output_image
@@ -76,6 +78,7 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     return None
 
 
+# Original source at L522 of <nipype-install>/interfaces/ants/resampling.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["output_image"] = os.path.abspath(
diff --git a/example-specs/task/nipype/ants/apply_transforms_to_points_callables.py b/example-specs/task/nipype/ants/apply_transforms_to_points_callables.py
index 04f155cb..71178089 100644
--- a/example-specs/task/nipype/ants/apply_transforms_to_points_callables.py
+++ b/example-specs/task/nipype/ants/apply_transforms_to_points_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of ApplyTransformsToPoints.yaml"""
 
 import logging
+import os
 import os.path as op
 import attrs
-import os
 
 
 def output_file_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +16,7 @@ def output_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -26,6 +27,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -76,12 +78,14 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L888 of <nipype-install>/interfaces/base/core.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
     return value
 
 
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -176,10 +180,12 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     metadata = dict(name_source=lambda t: t is not None)
     traits = inputs.traits(**metadata)
diff --git a/example-specs/task/nipype/ants/atropos_callables.py b/example-specs/task/nipype/ants/atropos_callables.py
index c5a27be2..7577d0ce 100644
--- a/example-specs/task/nipype/ants/atropos_callables.py
+++ b/example-specs/task/nipype/ants/atropos_callables.py
@@ -1,8 +1,8 @@
 """Module to put any functions that are referred to in the "callables" section of Atropos.yaml"""
 
+import os
 import os.path as op
 import attrs
-import os
 
 
 def out_classified_image_name_default(inputs):
@@ -23,6 +23,7 @@ def posteriors_callable(output_dir, inputs, stdout, stderr):
     return outputs["posteriors"]
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -73,6 +74,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L232 of <nipype-install>/interfaces/ants/segmentation.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "out_classified_image_name":
         output = inputs.out_classified_image_name
@@ -82,6 +84,7 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
         return output
 
 
+# Original source at L240 of <nipype-install>/interfaces/ants/segmentation.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["classified_image"] = os.path.abspath(
diff --git a/example-specs/task/nipype/ants/average_affine_transform_callables.py b/example-specs/task/nipype/ants/average_affine_transform_callables.py
index 822212c0..3d0b945f 100644
--- a/example-specs/task/nipype/ants/average_affine_transform_callables.py
+++ b/example-specs/task/nipype/ants/average_affine_transform_callables.py
@@ -1,6 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of AverageAffineTransform.yaml"""
 
 import os
+import attrs
 
 
 def affine_transform_callable(output_dir, inputs, stdout, stderr):
@@ -10,10 +11,12 @@ def affine_transform_callable(output_dir, inputs, stdout, stderr):
     return outputs["affine_transform"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L587 of <nipype-install>/interfaces/ants/utils.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["affine_transform"] = os.path.abspath(inputs.output_affine_transform)
diff --git a/example-specs/task/nipype/ants/average_images_callables.py b/example-specs/task/nipype/ants/average_images_callables.py
index b2f08446..e4973c3e 100644
--- a/example-specs/task/nipype/ants/average_images_callables.py
+++ b/example-specs/task/nipype/ants/average_images_callables.py
@@ -1,6 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of AverageImages.yaml"""
 
 import os
+import attrs
 
 
 def output_average_image_callable(output_dir, inputs, stdout, stderr):
@@ -10,10 +11,12 @@ def output_average_image_callable(output_dir, inputs, stdout, stderr):
     return outputs["output_average_image"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L648 of <nipype-install>/interfaces/ants/utils.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["output_average_image"] = os.path.realpath(inputs.output_average_image)
diff --git a/example-specs/task/nipype/ants/brain_extraction_callables.py b/example-specs/task/nipype/ants/brain_extraction_callables.py
index fcb649e1..5b80d0f2 100644
--- a/example-specs/task/nipype/ants/brain_extraction_callables.py
+++ b/example-specs/task/nipype/ants/brain_extraction_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of BrainExtraction.yaml"""
 
-import attrs
 import os
+import attrs
 
 
 def BrainExtractionMask_callable(output_dir, inputs, stdout, stderr):
@@ -130,10 +130,12 @@ def N4Truncated0_callable(output_dir, inputs, stdout, stderr):
     return outputs["N4Truncated0"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L1031 of <nipype-install>/interfaces/ants/segmentation.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["BrainExtractionMask"] = os.path.join(
diff --git a/example-specs/task/nipype/ants/buildtemplateparallel_callables.py b/example-specs/task/nipype/ants/buildtemplateparallel_callables.py
index 8662ba95..149002f4 100644
--- a/example-specs/task/nipype/ants/buildtemplateparallel_callables.py
+++ b/example-specs/task/nipype/ants/buildtemplateparallel_callables.py
@@ -1,9 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of buildtemplateparallel.yaml"""
 
-import os.path as op
-from glob import glob
 from builtins import range
+import attrs
 import os
+import os.path as op
+from glob import glob
 
 
 def final_template_file_callable(output_dir, inputs, stdout, stderr):
@@ -27,10 +28,12 @@ def subject_outfiles_callable(output_dir, inputs, stdout, stderr):
     return outputs["subject_outfiles"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -81,6 +84,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L340 of <nipype-install>/interfaces/ants/legacy.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["template_files"] = []
diff --git a/example-specs/task/nipype/ants/compose_multi_transform_callables.py b/example-specs/task/nipype/ants/compose_multi_transform_callables.py
index bc5b324f..265ff1bf 100644
--- a/example-specs/task/nipype/ants/compose_multi_transform_callables.py
+++ b/example-specs/task/nipype/ants/compose_multi_transform_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of ComposeMultiTransform.yaml"""
 
 import logging
+import os
 import os.path as op
 import attrs
-import os
 
 
 def output_transform_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +16,7 @@ def output_transform_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -26,6 +27,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -76,12 +78,14 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L888 of <nipype-install>/interfaces/base/core.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
     return value
 
 
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -176,10 +180,12 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     metadata = dict(name_source=lambda t: t is not None)
     traits = inputs.traits(**metadata)
diff --git a/example-specs/task/nipype/ants/composite_transform_util_callables.py b/example-specs/task/nipype/ants/composite_transform_util_callables.py
index c336bb38..7009fafd 100644
--- a/example-specs/task/nipype/ants/composite_transform_util_callables.py
+++ b/example-specs/task/nipype/ants/composite_transform_util_callables.py
@@ -1,6 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of CompositeTransformUtil.yaml"""
 
 import os
+import attrs
 
 
 def affine_transform_callable(output_dir, inputs, stdout, stderr):
@@ -24,10 +25,12 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_file"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L1873 of <nipype-install>/interfaces/ants/registration.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     if inputs.process == "disassemble":
diff --git a/example-specs/task/nipype/ants/convert_scalar_image_to_rgb_callables.py b/example-specs/task/nipype/ants/convert_scalar_image_to_rgb_callables.py
index 566a65a1..59dae516 100644
--- a/example-specs/task/nipype/ants/convert_scalar_image_to_rgb_callables.py
+++ b/example-specs/task/nipype/ants/convert_scalar_image_to_rgb_callables.py
@@ -1,6 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of ConvertScalarImageToRGB.yaml"""
 
 import os
+import attrs
 
 
 def output_image_callable(output_dir, inputs, stdout, stderr):
@@ -10,10 +11,12 @@ def output_image_callable(output_dir, inputs, stdout, stderr):
     return outputs["output_image"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L103 of <nipype-install>/interfaces/ants/visualization.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["output_image"] = os.path.join(output_dir, inputs.output_image)
diff --git a/example-specs/task/nipype/ants/cortical_thickness_callables.py b/example-specs/task/nipype/ants/cortical_thickness_callables.py
index 6191e471..d7610e62 100644
--- a/example-specs/task/nipype/ants/cortical_thickness_callables.py
+++ b/example-specs/task/nipype/ants/cortical_thickness_callables.py
@@ -1,6 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of CorticalThickness.yaml"""
 
 import os
+import attrs
 
 
 def BrainExtractionMask_callable(output_dir, inputs, stdout, stderr):
@@ -94,10 +95,12 @@ def BrainVolumes_callable(output_dir, inputs, stdout, stderr):
     return outputs["BrainVolumes"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L789 of <nipype-install>/interfaces/ants/segmentation.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["BrainExtractionMask"] = os.path.join(
diff --git a/example-specs/task/nipype/ants/create_jacobian_determinant_image_callables.py b/example-specs/task/nipype/ants/create_jacobian_determinant_image_callables.py
index 7fe3fe9e..09a9e469 100644
--- a/example-specs/task/nipype/ants/create_jacobian_determinant_image_callables.py
+++ b/example-specs/task/nipype/ants/create_jacobian_determinant_image_callables.py
@@ -1,6 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of CreateJacobianDeterminantImage.yaml"""
 
 import os
+import attrs
 
 
 def jacobian_image_callable(output_dir, inputs, stdout, stderr):
@@ -10,10 +11,12 @@ def jacobian_image_callable(output_dir, inputs, stdout, stderr):
     return outputs["jacobian_image"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L756 of <nipype-install>/interfaces/ants/utils.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["jacobian_image"] = os.path.abspath(inputs.outputImage)
diff --git a/example-specs/task/nipype/ants/create_tiled_mosaic_callables.py b/example-specs/task/nipype/ants/create_tiled_mosaic_callables.py
index 090836ff..f7e7fc1a 100644
--- a/example-specs/task/nipype/ants/create_tiled_mosaic_callables.py
+++ b/example-specs/task/nipype/ants/create_tiled_mosaic_callables.py
@@ -1,6 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of CreateTiledMosaic.yaml"""
 
 import os
+import attrs
 
 
 def output_image_callable(output_dir, inputs, stdout, stderr):
@@ -10,10 +11,12 @@ def output_image_callable(output_dir, inputs, stdout, stderr):
     return outputs["output_image"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L217 of <nipype-install>/interfaces/ants/visualization.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["output_image"] = os.path.join(output_dir, inputs.output_image)
diff --git a/example-specs/task/nipype/ants/denoise_image_callables.py b/example-specs/task/nipype/ants/denoise_image_callables.py
index 71313d03..eadf041c 100644
--- a/example-specs/task/nipype/ants/denoise_image_callables.py
+++ b/example-specs/task/nipype/ants/denoise_image_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of DenoiseImage.yaml"""
 
 import logging
+import os
 import os.path as op
 import attrs
-import os
 
 
 def output_image_callable(output_dir, inputs, stdout, stderr):
@@ -23,6 +23,7 @@ def noise_image_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -33,6 +34,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -83,12 +85,14 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L888 of <nipype-install>/interfaces/base/core.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
     return value
 
 
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -183,10 +187,12 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     metadata = dict(name_source=lambda t: t is not None)
     traits = inputs.traits(**metadata)
diff --git a/example-specs/task/nipype/ants/gen_warp_fields_callables.py b/example-specs/task/nipype/ants/gen_warp_fields_callables.py
index b6a9e182..a9bfcf23 100644
--- a/example-specs/task/nipype/ants/gen_warp_fields_callables.py
+++ b/example-specs/task/nipype/ants/gen_warp_fields_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of GenWarpFields.yaml"""
 
-import attrs
 import os
+import attrs
 
 
 def affine_transformation_callable(output_dir, inputs, stdout, stderr):
@@ -39,10 +39,12 @@ def output_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["output_file"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L141 of <nipype-install>/interfaces/ants/legacy.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     transmodel = inputs.transformation_model
diff --git a/example-specs/task/nipype/ants/image_math_callables.py b/example-specs/task/nipype/ants/image_math_callables.py
index ea88e0c1..95feab5c 100644
--- a/example-specs/task/nipype/ants/image_math_callables.py
+++ b/example-specs/task/nipype/ants/image_math_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of ImageMath.yaml"""
 
 import logging
+import os
 import os.path as op
 import attrs
-import os
 
 
 def output_image_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +16,7 @@ def output_image_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -26,6 +27,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -76,12 +78,14 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L888 of <nipype-install>/interfaces/base/core.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
     return value
 
 
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -176,10 +180,12 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     metadata = dict(name_source=lambda t: t is not None)
     traits = inputs.traits(**metadata)
diff --git a/example-specs/task/nipype/ants/joint_fusion_callables.py b/example-specs/task/nipype/ants/joint_fusion_callables.py
index ad1c44bd..212ac8da 100644
--- a/example-specs/task/nipype/ants/joint_fusion_callables.py
+++ b/example-specs/task/nipype/ants/joint_fusion_callables.py
@@ -1,8 +1,8 @@
 """Module to put any functions that are referred to in the "callables" section of JointFusion.yaml"""
 
+import os
 from glob import glob
 import attrs
-import os
 
 
 def out_label_fusion_callable(output_dir, inputs, stdout, stderr):
@@ -33,10 +33,12 @@ def out_atlas_voting_weight_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_atlas_voting_weight"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L1541 of <nipype-install>/interfaces/ants/segmentation.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     if inputs.out_label_fusion is not attrs.NOTHING:
diff --git a/example-specs/task/nipype/ants/kelly_kapowski_callables.py b/example-specs/task/nipype/ants/kelly_kapowski_callables.py
index 43879a02..86267514 100644
--- a/example-specs/task/nipype/ants/kelly_kapowski_callables.py
+++ b/example-specs/task/nipype/ants/kelly_kapowski_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of KellyKapowski.yaml"""
 
-import logging
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
 
 
 def cortical_thickness_callable(output_dir, inputs, stdout, stderr):
@@ -23,56 +23,7 @@ def warped_white_matter_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
+# Original source at L1765 of <nipype-install>/interfaces/ants/segmentation.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "cortical_thickness":
         output = inputs.cortical_thickness
@@ -89,6 +40,7 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
         return output
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -99,6 +51,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -149,12 +102,14 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L888 of <nipype-install>/interfaces/base/core.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
     return value
 
 
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -249,6 +204,7 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     metadata = dict(name_source=lambda t: t is not None)
     traits = inputs.traits(**metadata)
diff --git a/example-specs/task/nipype/ants/label_geometry_callables.py b/example-specs/task/nipype/ants/label_geometry_callables.py
index 1124bea1..580ac76a 100644
--- a/example-specs/task/nipype/ants/label_geometry_callables.py
+++ b/example-specs/task/nipype/ants/label_geometry_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of LabelGeometry.yaml"""
 
 import logging
+import os
 import os.path as op
 import attrs
-import os
 
 
 def output_file_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +16,7 @@ def output_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -26,6 +27,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -76,12 +78,14 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L888 of <nipype-install>/interfaces/base/core.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
     return value
 
 
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -176,10 +180,12 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     metadata = dict(name_source=lambda t: t is not None)
     traits = inputs.traits(**metadata)
diff --git a/example-specs/task/nipype/ants/laplacian_thickness_callables.py b/example-specs/task/nipype/ants/laplacian_thickness_callables.py
index 593e6247..2c7c369b 100644
--- a/example-specs/task/nipype/ants/laplacian_thickness_callables.py
+++ b/example-specs/task/nipype/ants/laplacian_thickness_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of LaplacianThickness.yaml"""
 
 import logging
+import os
 import os.path as op
 import attrs
-import os
 
 
 def output_image_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +16,7 @@ def output_image_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -26,6 +27,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -76,12 +78,14 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L888 of <nipype-install>/interfaces/base/core.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
     return value
 
 
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -176,10 +180,12 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     metadata = dict(name_source=lambda t: t is not None)
     traits = inputs.traits(**metadata)
diff --git a/example-specs/task/nipype/ants/measure_image_similarity_callables.py b/example-specs/task/nipype/ants/measure_image_similarity_callables.py
index df32b70e..b3c53329 100644
--- a/example-specs/task/nipype/ants/measure_image_similarity_callables.py
+++ b/example-specs/task/nipype/ants/measure_image_similarity_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of MeasureImageSimilarity.yaml"""
 
 import logging
+import os
 import os.path as op
 import attrs
-import os
 
 
 def similarity_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +16,7 @@ def similarity_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -26,6 +27,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -76,12 +78,14 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L888 of <nipype-install>/interfaces/base/core.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
     return value
 
 
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -176,10 +180,12 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     metadata = dict(name_source=lambda t: t is not None)
     traits = inputs.traits(**metadata)
diff --git a/example-specs/task/nipype/ants/multiply_images_callables.py b/example-specs/task/nipype/ants/multiply_images_callables.py
index b3366bd1..bd99f681 100644
--- a/example-specs/task/nipype/ants/multiply_images_callables.py
+++ b/example-specs/task/nipype/ants/multiply_images_callables.py
@@ -1,6 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of MultiplyImages.yaml"""
 
 import os
+import attrs
 
 
 def output_product_image_callable(output_dir, inputs, stdout, stderr):
@@ -10,10 +11,12 @@ def output_product_image_callable(output_dir, inputs, stdout, stderr):
     return outputs["output_product_image"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L704 of <nipype-install>/interfaces/ants/utils.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["output_product_image"] = os.path.abspath(inputs.output_product_image)
diff --git a/example-specs/task/nipype/ants/n4_bias_field_correction_callables.py b/example-specs/task/nipype/ants/n4_bias_field_correction_callables.py
index 3cdce1e9..edc5d4a0 100644
--- a/example-specs/task/nipype/ants/n4_bias_field_correction_callables.py
+++ b/example-specs/task/nipype/ants/n4_bias_field_correction_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of N4BiasFieldCorrection.yaml"""
 
-import logging
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
 
 
 def output_image_callable(output_dir, inputs, stdout, stderr):
@@ -23,6 +23,7 @@ def bias_image_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -33,6 +34,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -83,12 +85,14 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L888 of <nipype-install>/interfaces/base/core.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
     return value
 
 
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -183,6 +187,7 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_ants__ANTSCommand___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -202,10 +207,12 @@ def nipype_interfaces_ants__ANTSCommand___list_outputs(
         return outputs
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L540 of <nipype-install>/interfaces/ants/segmentation.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = nipype_interfaces_ants__ANTSCommand___list_outputs()
     if _out_bias_file:
diff --git a/example-specs/task/nipype/ants/registration_callables.py b/example-specs/task/nipype/ants/registration_callables.py
index 3931ad38..a223cc85 100644
--- a/example-specs/task/nipype/ants/registration_callables.py
+++ b/example-specs/task/nipype/ants/registration_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of Registration.yaml"""
 
-import attrs
 import os
+import attrs
 
 
 def forward_transforms_callable(output_dir, inputs, stdout, stderr):
@@ -95,10 +95,12 @@ def elapsed_time_callable(output_dir, inputs, stdout, stderr):
     return outputs["elapsed_time"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L1201 of <nipype-install>/interfaces/ants/registration.py
 def _get_outputfilenames(
     inverse=False, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -123,6 +125,7 @@ def _get_outputfilenames(
     return inv_output_filename
 
 
+# Original source at L1341 of <nipype-install>/interfaces/ants/registration.py
 def _output_filenames(
     prefix,
     count,
@@ -155,6 +158,7 @@ def _output_filenames(
     return "%s%d%s" % (prefix, count, suffix), inverse_mode
 
 
+# Original source at L1363 of <nipype-install>/interfaces/ants/registration.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["forward_transforms"] = []
diff --git a/example-specs/task/nipype/ants/registration_syn_quick_callables.py b/example-specs/task/nipype/ants/registration_syn_quick_callables.py
index 3fabebb5..ebd7de22 100644
--- a/example-specs/task/nipype/ants/registration_syn_quick_callables.py
+++ b/example-specs/task/nipype/ants/registration_syn_quick_callables.py
@@ -1,6 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of RegistrationSynQuick.yaml"""
 
 import os
+import attrs
 
 
 def warped_image_callable(output_dir, inputs, stdout, stderr):
@@ -38,10 +39,12 @@ def inverse_warp_field_callable(output_dir, inputs, stdout, stderr):
     return outputs["inverse_warp_field"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L1777 of <nipype-install>/interfaces/ants/registration.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     out_base = os.path.abspath(inputs.output_prefix)
diff --git a/example-specs/task/nipype/ants/resample_image_by_spacing_callables.py b/example-specs/task/nipype/ants/resample_image_by_spacing_callables.py
index 30276d34..45c466bd 100644
--- a/example-specs/task/nipype/ants/resample_image_by_spacing_callables.py
+++ b/example-specs/task/nipype/ants/resample_image_by_spacing_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of ResampleImageBySpacing.yaml"""
 
 import logging
+import os
 import os.path as op
 import attrs
-import os
 
 
 def output_image_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +16,7 @@ def output_image_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -26,6 +27,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -76,12 +78,14 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L888 of <nipype-install>/interfaces/base/core.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
     return value
 
 
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -176,10 +180,12 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     metadata = dict(name_source=lambda t: t is not None)
     traits = inputs.traits(**metadata)
diff --git a/example-specs/task/nipype/ants/threshold_image_callables.py b/example-specs/task/nipype/ants/threshold_image_callables.py
index bb57552e..6091ab63 100644
--- a/example-specs/task/nipype/ants/threshold_image_callables.py
+++ b/example-specs/task/nipype/ants/threshold_image_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of ThresholdImage.yaml"""
 
 import logging
+import os
 import os.path as op
 import attrs
-import os
 
 
 def output_image_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +16,7 @@ def output_image_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -26,6 +27,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -76,12 +78,14 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L888 of <nipype-install>/interfaces/base/core.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
     return value
 
 
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -176,10 +180,12 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     metadata = dict(name_source=lambda t: t is not None)
     traits = inputs.traits(**metadata)
diff --git a/example-specs/task/nipype/ants/warp_image_multi_transform_callables.py b/example-specs/task/nipype/ants/warp_image_multi_transform_callables.py
index ad32a2db..1db58751 100644
--- a/example-specs/task/nipype/ants/warp_image_multi_transform_callables.py
+++ b/example-specs/task/nipype/ants/warp_image_multi_transform_callables.py
@@ -1,8 +1,8 @@
 """Module to put any functions that are referred to in the "callables" section of WarpImageMultiTransform.yaml"""
 
+import os
 import os.path as op
 import attrs
-import os
 
 
 def output_image_default(inputs):
@@ -16,6 +16,7 @@ def output_image_callable(output_dir, inputs, stdout, stderr):
     return outputs["output_image"]
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -66,6 +67,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L262 of <nipype-install>/interfaces/ants/resampling.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "output_image":
         _, name, ext = split_filename(os.path.abspath(inputs.input_image))
@@ -73,6 +75,7 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     return None
 
 
+# Original source at L295 of <nipype-install>/interfaces/ants/resampling.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     if inputs.output_image is not attrs.NOTHING:
diff --git a/example-specs/task/nipype/ants/warp_time_series_image_multi_transform_callables.py b/example-specs/task/nipype/ants/warp_time_series_image_multi_transform_callables.py
index 4f061b87..9812aa7a 100644
--- a/example-specs/task/nipype/ants/warp_time_series_image_multi_transform_callables.py
+++ b/example-specs/task/nipype/ants/warp_time_series_image_multi_transform_callables.py
@@ -1,7 +1,8 @@
 """Module to put any functions that are referred to in the "callables" section of WarpTimeSeriesImageMultiTransform.yaml"""
 
-import os.path as op
 import os
+import os.path as op
+import attrs
 
 
 def output_image_callable(output_dir, inputs, stdout, stderr):
@@ -11,10 +12,12 @@ def output_image_callable(output_dir, inputs, stdout, stderr):
     return outputs["output_image"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -65,6 +68,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L137 of <nipype-install>/interfaces/ants/resampling.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     _, name, ext = split_filename(os.path.abspath(inputs.input_image))
diff --git a/example-specs/task/nipype/freesurfer/add_x_form_to_header_callables.py b/example-specs/task/nipype/freesurfer/add_x_form_to_header_callables.py
index 931b1336..02026206 100644
--- a/example-specs/task/nipype/freesurfer/add_x_form_to_header_callables.py
+++ b/example-specs/task/nipype/freesurfer/add_x_form_to_header_callables.py
@@ -1,6 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of AddXFormToHeader.yaml"""
 
 import os
+import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -10,10 +11,12 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_file"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L2069 of <nipype-install>/interfaces/freesurfer/utils.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["out_file"] = os.path.abspath(inputs.out_file)
diff --git a/example-specs/task/nipype/freesurfer/aparc_2_aseg_callables.py b/example-specs/task/nipype/freesurfer/aparc_2_aseg_callables.py
index 6e3385fa..05ce556b 100644
--- a/example-specs/task/nipype/freesurfer/aparc_2_aseg_callables.py
+++ b/example-specs/task/nipype/freesurfer/aparc_2_aseg_callables.py
@@ -1,6 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of Aparc2Aseg.yaml"""
 
 import os
+import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -10,10 +11,12 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_file"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L3922 of <nipype-install>/interfaces/freesurfer/utils.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["out_file"] = os.path.abspath(inputs.out_file)
diff --git a/example-specs/task/nipype/freesurfer/apas_2_aseg_callables.py b/example-specs/task/nipype/freesurfer/apas_2_aseg_callables.py
index efee0d15..5d5a90c5 100644
--- a/example-specs/task/nipype/freesurfer/apas_2_aseg_callables.py
+++ b/example-specs/task/nipype/freesurfer/apas_2_aseg_callables.py
@@ -1,6 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of Apas2Aseg.yaml"""
 
 import os
+import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -10,10 +11,12 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_file"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L3962 of <nipype-install>/interfaces/freesurfer/utils.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["out_file"] = os.path.abspath(inputs.out_file)
diff --git a/example-specs/task/nipype/freesurfer/apply_mask_callables.py b/example-specs/task/nipype/freesurfer/apply_mask_callables.py
index ebe44572..ca156541 100644
--- a/example-specs/task/nipype/freesurfer/apply_mask_callables.py
+++ b/example-specs/task/nipype/freesurfer/apply_mask_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of ApplyMask.yaml"""
 
 import logging
+import os
 import os.path as op
 import attrs
-import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +16,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -26,6 +27,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -76,12 +78,14 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L888 of <nipype-install>/interfaces/base/core.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
     return value
 
 
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -176,10 +180,12 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     metadata = dict(name_source=lambda t: t is not None)
     traits = inputs.traits(**metadata)
diff --git a/example-specs/task/nipype/freesurfer/apply_vol_transform_callables.py b/example-specs/task/nipype/freesurfer/apply_vol_transform_callables.py
index 01932a50..ac2693a2 100644
--- a/example-specs/task/nipype/freesurfer/apply_vol_transform_callables.py
+++ b/example-specs/task/nipype/freesurfer/apply_vol_transform_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of ApplyVolTransform.yaml"""
 
-from pathlib import Path
+import os
 import os.path as op
+from pathlib import Path
 import attrs
-import os
 
 
 def transformed_file_default(inputs):
@@ -17,6 +17,7 @@ def transformed_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["transformed_file"]
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -59,6 +60,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -109,6 +111,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L2070 of <nipype-install>/interfaces/freesurfer/preprocess.py
 def _get_outfile(inputs=None, stdout=None, stderr=None, output_dir=None):
     outfile = inputs.transformed_file
     if outfile is attrs.NOTHING:
@@ -123,6 +126,7 @@ def _get_outfile(inputs=None, stdout=None, stderr=None, output_dir=None):
     return outfile
 
 
+# Original source at L2088 of <nipype-install>/interfaces/freesurfer/preprocess.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "transformed_file":
         return _get_outfile(
@@ -131,6 +135,7 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     return None
 
 
+# Original source at L2083 of <nipype-install>/interfaces/freesurfer/preprocess.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["transformed_file"] = os.path.abspath(
diff --git a/example-specs/task/nipype/freesurfer/bb_register_callables.py b/example-specs/task/nipype/freesurfer/bb_register_callables.py
index 1264b998..dd924803 100644
--- a/example-specs/task/nipype/freesurfer/bb_register_callables.py
+++ b/example-specs/task/nipype/freesurfer/bb_register_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of BBRegister.yaml"""
 
-from pathlib import Path
 import os.path as op
+from pathlib import Path
 import attrs
 
 
@@ -51,6 +51,7 @@ def registered_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["registered_file"]
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -93,6 +94,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -143,6 +145,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L1894 of <nipype-install>/interfaces/freesurfer/preprocess.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "out_reg_file":
         return _list_outputs(
@@ -151,6 +154,7 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     return None
 
 
+# Original source at L1835 of <nipype-install>/interfaces/freesurfer/preprocess.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     _in = inputs
diff --git a/example-specs/task/nipype/freesurfer/binarize_callables.py b/example-specs/task/nipype/freesurfer/binarize_callables.py
index 2aa5268a..8d948ca1 100644
--- a/example-specs/task/nipype/freesurfer/binarize_callables.py
+++ b/example-specs/task/nipype/freesurfer/binarize_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of Binarize.yaml"""
 
-from pathlib import Path
+import os
 import os.path as op
+from pathlib import Path
 import attrs
-import os
 
 
 def binary_file_default(inputs):
@@ -24,6 +24,7 @@ def count_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["count_file"]
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -66,6 +67,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -116,6 +118,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L702 of <nipype-install>/interfaces/freesurfer/model.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "binary_file":
         return _list_outputs(
@@ -124,6 +127,7 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     return None
 
 
+# Original source at L661 of <nipype-install>/interfaces/freesurfer/model.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outfile = inputs.binary_file
diff --git a/example-specs/task/nipype/freesurfer/ca_label_callables.py b/example-specs/task/nipype/freesurfer/ca_label_callables.py
index e6be59ff..74c5feb4 100644
--- a/example-specs/task/nipype/freesurfer/ca_label_callables.py
+++ b/example-specs/task/nipype/freesurfer/ca_label_callables.py
@@ -1,6 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of CALabel.yaml"""
 
 import os
+import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -10,10 +11,12 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_file"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L3000 of <nipype-install>/interfaces/freesurfer/preprocess.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["out_file"] = os.path.abspath(inputs.out_file)
diff --git a/example-specs/task/nipype/freesurfer/ca_normalize_callables.py b/example-specs/task/nipype/freesurfer/ca_normalize_callables.py
index aeb4f9b6..507a3bab 100644
--- a/example-specs/task/nipype/freesurfer/ca_normalize_callables.py
+++ b/example-specs/task/nipype/freesurfer/ca_normalize_callables.py
@@ -1,6 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of CANormalize.yaml"""
 
 import os
+import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,10 +18,12 @@ def control_points_callable(output_dir, inputs, stdout, stderr):
     return outputs["control_points"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L2816 of <nipype-install>/interfaces/freesurfer/preprocess.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["out_file"] = os.path.abspath(inputs.out_file)
diff --git a/example-specs/task/nipype/freesurfer/ca_register_callables.py b/example-specs/task/nipype/freesurfer/ca_register_callables.py
index 067f9bef..ee160eb9 100644
--- a/example-specs/task/nipype/freesurfer/ca_register_callables.py
+++ b/example-specs/task/nipype/freesurfer/ca_register_callables.py
@@ -1,6 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of CARegister.yaml"""
 
 import os
+import attrs
 
 
 def out_file_default(inputs):
@@ -14,10 +15,12 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_file"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L2903 of <nipype-install>/interfaces/freesurfer/preprocess.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["out_file"] = os.path.abspath(inputs.out_file)
diff --git a/example-specs/task/nipype/freesurfer/check_talairach_alignment_callables.py b/example-specs/task/nipype/freesurfer/check_talairach_alignment_callables.py
index 46bc0adf..03f47ee1 100644
--- a/example-specs/task/nipype/freesurfer/check_talairach_alignment_callables.py
+++ b/example-specs/task/nipype/freesurfer/check_talairach_alignment_callables.py
@@ -1,5 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of CheckTalairachAlignment.yaml"""
 
+import attrs
+
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
@@ -8,10 +10,12 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_file"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L2127 of <nipype-install>/interfaces/freesurfer/utils.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["out_file"] = inputs.in_file
diff --git a/example-specs/task/nipype/freesurfer/concatenate_callables.py b/example-specs/task/nipype/freesurfer/concatenate_callables.py
index f2dd9e7d..6b46c027 100644
--- a/example-specs/task/nipype/freesurfer/concatenate_callables.py
+++ b/example-specs/task/nipype/freesurfer/concatenate_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of Concatenate.yaml"""
 
-import attrs
 import os
+import attrs
 
 
 def concatenated_file_default(inputs):
@@ -15,6 +15,7 @@ def concatenated_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["concatenated_file"]
 
 
+# Original source at L814 of <nipype-install>/interfaces/freesurfer/model.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "concatenated_file":
         return _list_outputs(
@@ -23,6 +24,7 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     return None
 
 
+# Original source at L805 of <nipype-install>/interfaces/freesurfer/model.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
 
diff --git a/example-specs/task/nipype/freesurfer/concatenate_lta_callables.py b/example-specs/task/nipype/freesurfer/concatenate_lta_callables.py
index 7a02d0fa..ec10e218 100644
--- a/example-specs/task/nipype/freesurfer/concatenate_lta_callables.py
+++ b/example-specs/task/nipype/freesurfer/concatenate_lta_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of ConcatenateLTA.yaml"""
 
 import logging
+import os
 import os.path as op
 import attrs
-import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +16,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -26,6 +27,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -76,12 +78,14 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L888 of <nipype-install>/interfaces/base/core.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
     return value
 
 
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -176,10 +180,12 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     metadata = dict(name_source=lambda t: t is not None)
     traits = inputs.traits(**metadata)
diff --git a/example-specs/task/nipype/freesurfer/contrast_callables.py b/example-specs/task/nipype/freesurfer/contrast_callables.py
index dad73aac..41f6216c 100644
--- a/example-specs/task/nipype/freesurfer/contrast_callables.py
+++ b/example-specs/task/nipype/freesurfer/contrast_callables.py
@@ -1,6 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of Contrast.yaml"""
 
 import os
+import attrs
 
 
 def out_contrast_callable(output_dir, inputs, stdout, stderr):
@@ -24,10 +25,12 @@ def out_log_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_log"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L3684 of <nipype-install>/interfaces/freesurfer/utils.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     subject_dir = os.path.join(inputs.subjects_dir, inputs.subject_id)
diff --git a/example-specs/task/nipype/freesurfer/curvature_callables.py b/example-specs/task/nipype/freesurfer/curvature_callables.py
index c4997eb6..2ca204f7 100644
--- a/example-specs/task/nipype/freesurfer/curvature_callables.py
+++ b/example-specs/task/nipype/freesurfer/curvature_callables.py
@@ -1,6 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of Curvature.yaml"""
 
 import os
+import attrs
 
 
 def out_mean_callable(output_dir, inputs, stdout, stderr):
@@ -17,10 +18,12 @@ def out_gauss_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_gauss"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L2953 of <nipype-install>/interfaces/freesurfer/utils.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     if inputs.copy_input:
diff --git a/example-specs/task/nipype/freesurfer/curvature_stats_callables.py b/example-specs/task/nipype/freesurfer/curvature_stats_callables.py
index 5d1773aa..12f81fb8 100644
--- a/example-specs/task/nipype/freesurfer/curvature_stats_callables.py
+++ b/example-specs/task/nipype/freesurfer/curvature_stats_callables.py
@@ -1,6 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of CurvatureStats.yaml"""
 
 import os
+import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -10,10 +11,12 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_file"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L3074 of <nipype-install>/interfaces/freesurfer/utils.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["out_file"] = os.path.abspath(inputs.out_file)
diff --git a/example-specs/task/nipype/freesurfer/dicom_convert_callables.py b/example-specs/task/nipype/freesurfer/dicom_convert_callables.py
index e1c4fb23..57ab2b1f 100644
--- a/example-specs/task/nipype/freesurfer/dicom_convert_callables.py
+++ b/example-specs/task/nipype/freesurfer/dicom_convert_callables.py
@@ -1,13 +1,14 @@
 """Module to put any functions that are referred to in the "callables" section of DICOMConvert.yaml"""
 
 import logging
+import os
 import os.path as op
 import attrs
-import os
 
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -18,6 +19,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -68,12 +70,14 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L888 of <nipype-install>/interfaces/base/core.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
     return value
 
 
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -168,10 +172,12 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     metadata = dict(name_source=lambda t: t is not None)
     traits = inputs.traits(**metadata)
diff --git a/example-specs/task/nipype/freesurfer/edit_w_mwith_aseg_callables.py b/example-specs/task/nipype/freesurfer/edit_w_mwith_aseg_callables.py
index 25073f5a..9305cbec 100644
--- a/example-specs/task/nipype/freesurfer/edit_w_mwith_aseg_callables.py
+++ b/example-specs/task/nipype/freesurfer/edit_w_mwith_aseg_callables.py
@@ -1,6 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of EditWMwithAseg.yaml"""
 
 import os
+import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -10,10 +11,12 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_file"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L3384 of <nipype-install>/interfaces/freesurfer/preprocess.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["out_file"] = os.path.abspath(inputs.out_file)
diff --git a/example-specs/task/nipype/freesurfer/em_register_callables.py b/example-specs/task/nipype/freesurfer/em_register_callables.py
index 04345168..ccc663ec 100644
--- a/example-specs/task/nipype/freesurfer/em_register_callables.py
+++ b/example-specs/task/nipype/freesurfer/em_register_callables.py
@@ -1,6 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of EMRegister.yaml"""
 
 import os
+import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -10,10 +11,12 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_file"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L233 of <nipype-install>/interfaces/freesurfer/registration.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["out_file"] = os.path.abspath(inputs.out_file)
diff --git a/example-specs/task/nipype/freesurfer/euler_number_callables.py b/example-specs/task/nipype/freesurfer/euler_number_callables.py
index 3055ab4e..b1d03b2b 100644
--- a/example-specs/task/nipype/freesurfer/euler_number_callables.py
+++ b/example-specs/task/nipype/freesurfer/euler_number_callables.py
@@ -1,5 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of EulerNumber.yaml"""
 
+import attrs
+
 
 def euler_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
@@ -15,10 +17,12 @@ def defects_callable(output_dir, inputs, stdout, stderr):
     return outputs["defects"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L2618 of <nipype-install>/interfaces/freesurfer/utils.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["defects"] = _defects
diff --git a/example-specs/task/nipype/freesurfer/extract_main_component_callables.py b/example-specs/task/nipype/freesurfer/extract_main_component_callables.py
index e917a268..ee6f1fc7 100644
--- a/example-specs/task/nipype/freesurfer/extract_main_component_callables.py
+++ b/example-specs/task/nipype/freesurfer/extract_main_component_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of ExtractMainComponent.yaml"""
 
 import logging
+import os
 import os.path as op
 import attrs
-import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +16,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -26,6 +27,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -76,12 +78,14 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L888 of <nipype-install>/interfaces/base/core.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
     return value
 
 
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -176,10 +180,12 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     metadata = dict(name_source=lambda t: t is not None)
     traits = inputs.traits(**metadata)
diff --git a/example-specs/task/nipype/freesurfer/fit_ms_params_callables.py b/example-specs/task/nipype/freesurfer/fit_ms_params_callables.py
index dc87f90f..ed77741f 100644
--- a/example-specs/task/nipype/freesurfer/fit_ms_params_callables.py
+++ b/example-specs/task/nipype/freesurfer/fit_ms_params_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of FitMSParams.yaml"""
 
-import attrs
 import os
+import attrs
 
 
 def out_dir_default(inputs):
@@ -29,12 +29,14 @@ def t2star_image_callable(output_dir, inputs, stdout, stderr):
     return outputs["t2star_image"]
 
 
+# Original source at L2456 of <nipype-install>/interfaces/freesurfer/preprocess.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "out_dir":
         return output_dir
     return None
 
 
+# Original source at L2445 of <nipype-install>/interfaces/freesurfer/preprocess.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     if inputs.out_dir is attrs.NOTHING:
diff --git a/example-specs/task/nipype/freesurfer/fix_topology_callables.py b/example-specs/task/nipype/freesurfer/fix_topology_callables.py
index abd893f1..b0a85981 100644
--- a/example-specs/task/nipype/freesurfer/fix_topology_callables.py
+++ b/example-specs/task/nipype/freesurfer/fix_topology_callables.py
@@ -1,6 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of FixTopology.yaml"""
 
 import os
+import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -10,10 +11,12 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_file"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L2565 of <nipype-install>/interfaces/freesurfer/utils.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["out_file"] = os.path.abspath(inputs.in_orig)
diff --git a/example-specs/task/nipype/freesurfer/fuse_segmentations_callables.py b/example-specs/task/nipype/freesurfer/fuse_segmentations_callables.py
index c33c4f22..68f3822a 100644
--- a/example-specs/task/nipype/freesurfer/fuse_segmentations_callables.py
+++ b/example-specs/task/nipype/freesurfer/fuse_segmentations_callables.py
@@ -1,6 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of FuseSegmentations.yaml"""
 
 import os
+import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -10,10 +11,12 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_file"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L250 of <nipype-install>/interfaces/freesurfer/longitudinal.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["out_file"] = os.path.abspath(inputs.out_file)
diff --git a/example-specs/task/nipype/freesurfer/glm_fit_callables.py b/example-specs/task/nipype/freesurfer/glm_fit_callables.py
index 12981d63..30fe5e43 100644
--- a/example-specs/task/nipype/freesurfer/glm_fit_callables.py
+++ b/example-specs/task/nipype/freesurfer/glm_fit_callables.py
@@ -1,8 +1,8 @@
 """Module to put any functions that are referred to in the "callables" section of GLMFit.yaml"""
 
+import os
 import os.path as op
 import attrs
-import os
 
 
 def glm_dir_default(inputs):
@@ -142,6 +142,7 @@ def bp_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["bp_file"]
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -192,12 +193,14 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L560 of <nipype-install>/interfaces/freesurfer/model.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "glm_dir":
         return output_dir
     return None
 
 
+# Original source at L496 of <nipype-install>/interfaces/freesurfer/model.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     # Get the top-level output directory
diff --git a/example-specs/task/nipype/freesurfer/gtm_seg_callables.py b/example-specs/task/nipype/freesurfer/gtm_seg_callables.py
index 9e70fe90..fd6b31c1 100644
--- a/example-specs/task/nipype/freesurfer/gtm_seg_callables.py
+++ b/example-specs/task/nipype/freesurfer/gtm_seg_callables.py
@@ -1,6 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of GTMSeg.yaml"""
 
 import os
+import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -10,10 +11,12 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_file"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L126 of <nipype-install>/interfaces/freesurfer/petsurfer.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["out_file"] = os.path.join(
diff --git a/example-specs/task/nipype/freesurfer/gtmpvc_callables.py b/example-specs/task/nipype/freesurfer/gtmpvc_callables.py
index 81c7e065..ed31cb9e 100644
--- a/example-specs/task/nipype/freesurfer/gtmpvc_callables.py
+++ b/example-specs/task/nipype/freesurfer/gtmpvc_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of GTMPVC.yaml"""
 
-import attrs
 import os
+import attrs
 
 
 def pvc_dir_default(inputs):
@@ -155,10 +155,12 @@ def yhat_with_noise_callable(output_dir, inputs, stdout, stderr):
     return outputs["yhat_with_noise"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L522 of <nipype-install>/interfaces/freesurfer/petsurfer.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     # Get the top-level output directory
diff --git a/example-specs/task/nipype/freesurfer/image_info_callables.py b/example-specs/task/nipype/freesurfer/image_info_callables.py
index a0766f45..d07673d9 100644
--- a/example-specs/task/nipype/freesurfer/image_info_callables.py
+++ b/example-specs/task/nipype/freesurfer/image_info_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of ImageInfo.yaml"""
 
 import logging
+import os
 import os.path as op
 import attrs
-import os
 
 
 def info_callable(output_dir, inputs, stdout, stderr):
@@ -86,6 +86,7 @@ def ph_enc_dir_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -96,6 +97,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -146,12 +148,14 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L888 of <nipype-install>/interfaces/base/core.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
     return value
 
 
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -246,10 +250,12 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     metadata = dict(name_source=lambda t: t is not None)
     traits = inputs.traits(**metadata)
diff --git a/example-specs/task/nipype/freesurfer/jacobian_callables.py b/example-specs/task/nipype/freesurfer/jacobian_callables.py
index a5e7b26f..181490d5 100644
--- a/example-specs/task/nipype/freesurfer/jacobian_callables.py
+++ b/example-specs/task/nipype/freesurfer/jacobian_callables.py
@@ -1,6 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of Jacobian.yaml"""
 
 import os
+import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -10,10 +11,12 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_file"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L3133 of <nipype-install>/interfaces/freesurfer/utils.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["out_file"] = os.path.abspath(inputs.out_file)
diff --git a/example-specs/task/nipype/freesurfer/label_2_annot_callables.py b/example-specs/task/nipype/freesurfer/label_2_annot_callables.py
index 63dd3568..bbab02c1 100644
--- a/example-specs/task/nipype/freesurfer/label_2_annot_callables.py
+++ b/example-specs/task/nipype/freesurfer/label_2_annot_callables.py
@@ -1,6 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of Label2Annot.yaml"""
 
 import os
+import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -10,10 +11,12 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_file"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L1631 of <nipype-install>/interfaces/freesurfer/model.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["out_file"] = os.path.join(
diff --git a/example-specs/task/nipype/freesurfer/label_2_label_callables.py b/example-specs/task/nipype/freesurfer/label_2_label_callables.py
index 6d44dc4e..9fc48fbc 100644
--- a/example-specs/task/nipype/freesurfer/label_2_label_callables.py
+++ b/example-specs/task/nipype/freesurfer/label_2_label_callables.py
@@ -1,6 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of Label2Label.yaml"""
 
 import os
+import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -10,10 +11,12 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_file"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L1506 of <nipype-install>/interfaces/freesurfer/model.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["out_file"] = os.path.join(
diff --git a/example-specs/task/nipype/freesurfer/label_2_vol_callables.py b/example-specs/task/nipype/freesurfer/label_2_vol_callables.py
index 1b3538d6..904dd416 100644
--- a/example-specs/task/nipype/freesurfer/label_2_vol_callables.py
+++ b/example-specs/task/nipype/freesurfer/label_2_vol_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of Label2Vol.yaml"""
 
-from pathlib import Path
+import os
 import os.path as op
+from pathlib import Path
 import attrs
-import os
 
 
 def vol_label_file_default(inputs):
@@ -17,6 +17,7 @@ def vol_label_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["vol_label_file"]
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -59,6 +60,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -109,6 +111,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L1311 of <nipype-install>/interfaces/freesurfer/model.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "vol_label_file":
         return _list_outputs(
@@ -117,6 +120,7 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     return None
 
 
+# Original source at L1293 of <nipype-install>/interfaces/freesurfer/model.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outfile = inputs.vol_label_file
diff --git a/example-specs/task/nipype/freesurfer/logan_ref_callables.py b/example-specs/task/nipype/freesurfer/logan_ref_callables.py
index 98ae11a9..fc99270b 100644
--- a/example-specs/task/nipype/freesurfer/logan_ref_callables.py
+++ b/example-specs/task/nipype/freesurfer/logan_ref_callables.py
@@ -1,8 +1,8 @@
 """Module to put any functions that are referred to in the "callables" section of LoganRef.yaml"""
 
+import os
 import os.path as op
 import attrs
-import os
 
 
 def glm_dir_default(inputs):
@@ -142,6 +142,7 @@ def bp_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["bp_file"]
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -192,12 +193,14 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L560 of <nipype-install>/interfaces/freesurfer/model.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "glm_dir":
         return output_dir
     return None
 
 
+# Original source at L496 of <nipype-install>/interfaces/freesurfer/model.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     # Get the top-level output directory
diff --git a/example-specs/task/nipype/freesurfer/lta_convert_callables.py b/example-specs/task/nipype/freesurfer/lta_convert_callables.py
index e56c94f4..16f2180e 100644
--- a/example-specs/task/nipype/freesurfer/lta_convert_callables.py
+++ b/example-specs/task/nipype/freesurfer/lta_convert_callables.py
@@ -1,6 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of LTAConvert.yaml"""
 
 import os
+import attrs
 
 
 def out_lta_callable(output_dir, inputs, stdout, stderr):
@@ -38,10 +39,12 @@ def out_itk_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_itk"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L4206 of <nipype-install>/interfaces/freesurfer/utils.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     for name, default in (
diff --git a/example-specs/task/nipype/freesurfer/make_average_subject_callables.py b/example-specs/task/nipype/freesurfer/make_average_subject_callables.py
index 33ead557..cf1e7e56 100644
--- a/example-specs/task/nipype/freesurfer/make_average_subject_callables.py
+++ b/example-specs/task/nipype/freesurfer/make_average_subject_callables.py
@@ -1,5 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of MakeAverageSubject.yaml"""
 
+import attrs
+
 
 def average_subject_name_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
@@ -8,10 +10,12 @@ def average_subject_name_callable(output_dir, inputs, stdout, stderr):
     return outputs["average_subject_name"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L1810 of <nipype-install>/interfaces/freesurfer/utils.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["average_subject_name"] = inputs.out_name
diff --git a/example-specs/task/nipype/freesurfer/make_surfaces_callables.py b/example-specs/task/nipype/freesurfer/make_surfaces_callables.py
index b38f90ac..0a3b83f6 100644
--- a/example-specs/task/nipype/freesurfer/make_surfaces_callables.py
+++ b/example-specs/task/nipype/freesurfer/make_surfaces_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of MakeSurfaces.yaml"""
 
-import attrs
 import os
+import attrs
 
 
 def out_white_callable(output_dir, inputs, stdout, stderr):
@@ -46,10 +46,12 @@ def out_thickness_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_thickness"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L2850 of <nipype-install>/interfaces/freesurfer/utils.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     # Outputs are saved in the surf directory
diff --git a/example-specs/task/nipype/freesurfer/mni_bias_correction_callables.py b/example-specs/task/nipype/freesurfer/mni_bias_correction_callables.py
index e956cdd8..fc93ae5c 100644
--- a/example-specs/task/nipype/freesurfer/mni_bias_correction_callables.py
+++ b/example-specs/task/nipype/freesurfer/mni_bias_correction_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of MNIBiasCorrection.yaml"""
 
 import logging
+import os
 import os.path as op
 import attrs
-import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +16,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -26,6 +27,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -76,12 +78,14 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L888 of <nipype-install>/interfaces/base/core.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
     return value
 
 
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -176,10 +180,12 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     metadata = dict(name_source=lambda t: t is not None)
     traits = inputs.traits(**metadata)
diff --git a/example-specs/task/nipype/freesurfer/mp_rto_mni305_callables.py b/example-specs/task/nipype/freesurfer/mp_rto_mni305_callables.py
index 6051bb60..52319a85 100644
--- a/example-specs/task/nipype/freesurfer/mp_rto_mni305_callables.py
+++ b/example-specs/task/nipype/freesurfer/mp_rto_mni305_callables.py
@@ -1,7 +1,8 @@
 """Module to put any functions that are referred to in the "callables" section of MPRtoMNI305.yaml"""
 
-import os.path as op
 import os
+import os.path as op
+import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -18,6 +19,7 @@ def log_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["log_file"]
 
 
+# Original source at L216 of <nipype-install>/interfaces/freesurfer/base.py
 def nipype_interfaces_freesurfer__FSScriptCommand___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -26,10 +28,12 @@ def nipype_interfaces_freesurfer__FSScriptCommand___list_outputs(
     return outputs
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -80,10 +84,12 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L97 of <nipype-install>/interfaces/freesurfer/registration.py
 def _get_fname(fname, inputs=None, stdout=None, stderr=None, output_dir=None):
     return split_filename(fname)[1]
 
 
+# Original source at L100 of <nipype-install>/interfaces/freesurfer/registration.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = nipype_interfaces_freesurfer__FSScriptCommand___list_outputs()
     fullname = "_".join(
diff --git a/example-specs/task/nipype/freesurfer/mr_is_ca_label_callables.py b/example-specs/task/nipype/freesurfer/mr_is_ca_label_callables.py
index 3a63573f..f0990aea 100644
--- a/example-specs/task/nipype/freesurfer/mr_is_ca_label_callables.py
+++ b/example-specs/task/nipype/freesurfer/mr_is_ca_label_callables.py
@@ -1,6 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of MRIsCALabel.yaml"""
 
 import os
+import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -10,10 +11,12 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_file"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L3141 of <nipype-install>/interfaces/freesurfer/preprocess.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     out_basename = os.path.basename(inputs.out_file)
diff --git a/example-specs/task/nipype/freesurfer/mr_is_calc_callables.py b/example-specs/task/nipype/freesurfer/mr_is_calc_callables.py
index ebb0c535..667e9b4a 100644
--- a/example-specs/task/nipype/freesurfer/mr_is_calc_callables.py
+++ b/example-specs/task/nipype/freesurfer/mr_is_calc_callables.py
@@ -1,6 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of MRIsCalc.yaml"""
 
 import os
+import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -10,10 +11,12 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_file"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L3203 of <nipype-install>/interfaces/freesurfer/utils.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["out_file"] = os.path.abspath(inputs.out_file)
diff --git a/example-specs/task/nipype/freesurfer/mr_is_combine_callables.py b/example-specs/task/nipype/freesurfer/mr_is_combine_callables.py
index 6914def6..38db9962 100644
--- a/example-specs/task/nipype/freesurfer/mr_is_combine_callables.py
+++ b/example-specs/task/nipype/freesurfer/mr_is_combine_callables.py
@@ -1,6 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of MRIsCombine.yaml"""
 
 import os
+import attrs
 
 
 def out_file_default(inputs):
@@ -14,10 +15,12 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_file"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L1397 of <nipype-install>/interfaces/freesurfer/utils.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
 
diff --git a/example-specs/task/nipype/freesurfer/mr_is_convert_callables.py b/example-specs/task/nipype/freesurfer/mr_is_convert_callables.py
index 61c26c82..0a72d065 100644
--- a/example-specs/task/nipype/freesurfer/mr_is_convert_callables.py
+++ b/example-specs/task/nipype/freesurfer/mr_is_convert_callables.py
@@ -1,8 +1,8 @@
 """Module to put any functions that are referred to in the "callables" section of MRIsConvert.yaml"""
 
+import os
 import os.path as op
 import attrs
-import os
 
 
 def out_file_default(inputs):
@@ -16,6 +16,7 @@ def converted_callable(output_dir, inputs, stdout, stderr):
     return outputs["converted"]
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -66,6 +67,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L1315 of <nipype-install>/interfaces/freesurfer/utils.py
 def _gen_outfilename(inputs=None, stdout=None, stderr=None, output_dir=None):
     if inputs.out_file is not attrs.NOTHING:
         return inputs.out_file
@@ -85,6 +87,7 @@ def _gen_outfilename(inputs=None, stdout=None, stderr=None, output_dir=None):
     return name + ext + "_converted." + inputs.out_datatype
 
 
+# Original source at L1309 of <nipype-install>/interfaces/freesurfer/utils.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "out_file":
         return os.path.abspath(
@@ -96,6 +99,7 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
         return None
 
 
+# Original source at L1304 of <nipype-install>/interfaces/freesurfer/utils.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["converted"] = os.path.abspath(
diff --git a/example-specs/task/nipype/freesurfer/mr_is_expand_callables.py b/example-specs/task/nipype/freesurfer/mr_is_expand_callables.py
index 4ed8df57..3d8a156a 100644
--- a/example-specs/task/nipype/freesurfer/mr_is_expand_callables.py
+++ b/example-specs/task/nipype/freesurfer/mr_is_expand_callables.py
@@ -1,6 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of MRIsExpand.yaml"""
 
 import os
+import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -10,6 +11,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_file"]
 
 
+# Original source at L191 of <nipype-install>/interfaces/freesurfer/base.py
 @staticmethod
 def _associated_file(out_name, inputs=None, stdout=None, stderr=None, output_dir=None):
     """Based on MRIsBuildFileName in freesurfer/utils/mrisurf.c
@@ -29,10 +31,12 @@ def _associated_file(out_name, inputs=None, stdout=None, stderr=None, output_dir
     return os.path.join(path, base)
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L4072 of <nipype-install>/interfaces/freesurfer/utils.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["out_file"] = _associated_file(
diff --git a/example-specs/task/nipype/freesurfer/mr_is_inflate_callables.py b/example-specs/task/nipype/freesurfer/mr_is_inflate_callables.py
index ef4fd9df..865790a8 100644
--- a/example-specs/task/nipype/freesurfer/mr_is_inflate_callables.py
+++ b/example-specs/task/nipype/freesurfer/mr_is_inflate_callables.py
@@ -1,6 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of MRIsInflate.yaml"""
 
 import os
+import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,10 +18,12 @@ def out_sulc_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_sulc"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L2392 of <nipype-install>/interfaces/freesurfer/utils.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["out_file"] = os.path.abspath(inputs.out_file)
diff --git a/example-specs/task/nipype/freesurfer/mri_convert_callables.py b/example-specs/task/nipype/freesurfer/mri_convert_callables.py
index 40a19d73..cb7cec93 100644
--- a/example-specs/task/nipype/freesurfer/mri_convert_callables.py
+++ b/example-specs/task/nipype/freesurfer/mri_convert_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of MRIConvert.yaml"""
 
-from pathlib import Path
-import os.path as op
-from nibabel.loadsave import load
+from nibabel import load
 import attrs
 import os
+import os.path as op
+from pathlib import Path
 
 
 def out_file_default(inputs):
@@ -18,6 +18,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_file"]
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -60,6 +61,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -110,6 +112,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L550 of <nipype-install>/interfaces/freesurfer/preprocess.py
 def _get_outfilename(inputs=None, stdout=None, stderr=None, output_dir=None):
     outfile = inputs.out_file
     if outfile is attrs.NOTHING:
@@ -123,6 +126,7 @@ def _get_outfilename(inputs=None, stdout=None, stderr=None, output_dir=None):
     return os.path.abspath(outfile)
 
 
+# Original source at L603 of <nipype-install>/interfaces/freesurfer/preprocess.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "out_file":
         return _get_outfilename(
@@ -131,6 +135,7 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     return None
 
 
+# Original source at L562 of <nipype-install>/interfaces/freesurfer/preprocess.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outfile = _get_outfilename(
diff --git a/example-specs/task/nipype/freesurfer/mri_coreg_callables.py b/example-specs/task/nipype/freesurfer/mri_coreg_callables.py
index 81461d76..02dd828f 100644
--- a/example-specs/task/nipype/freesurfer/mri_coreg_callables.py
+++ b/example-specs/task/nipype/freesurfer/mri_coreg_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of MRICoreg.yaml"""
 
-import attrs
 import os
+import attrs
 
 
 def out_reg_file_callable(output_dir, inputs, stdout, stderr):
@@ -25,10 +25,12 @@ def out_params_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_params_file"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L592 of <nipype-install>/interfaces/freesurfer/registration.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
 
diff --git a/example-specs/task/nipype/freesurfer/mri_fill_callables.py b/example-specs/task/nipype/freesurfer/mri_fill_callables.py
index f0280586..92532698 100644
--- a/example-specs/task/nipype/freesurfer/mri_fill_callables.py
+++ b/example-specs/task/nipype/freesurfer/mri_fill_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of MRIFill.yaml"""
 
-import attrs
 import os
+import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -18,10 +18,12 @@ def log_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["log_file"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L2335 of <nipype-install>/interfaces/freesurfer/utils.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["out_file"] = os.path.abspath(inputs.out_file)
diff --git a/example-specs/task/nipype/freesurfer/mri_marching_cubes_callables.py b/example-specs/task/nipype/freesurfer/mri_marching_cubes_callables.py
index bc7475a7..49b33fb6 100644
--- a/example-specs/task/nipype/freesurfer/mri_marching_cubes_callables.py
+++ b/example-specs/task/nipype/freesurfer/mri_marching_cubes_callables.py
@@ -1,8 +1,8 @@
 """Module to put any functions that are referred to in the "callables" section of MRIMarchingCubes.yaml"""
 
+import os
 import os.path as op
 import attrs
-import os
 
 
 def out_file_default(inputs):
@@ -16,6 +16,7 @@ def surface_callable(output_dir, inputs, stdout, stderr):
     return outputs["surface"]
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -66,6 +67,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L1653 of <nipype-install>/interfaces/freesurfer/utils.py
 def _gen_outfilename(inputs=None, stdout=None, stderr=None, output_dir=None):
     if inputs.out_file is not attrs.NOTHING:
         return os.path.abspath(inputs.out_file)
@@ -74,6 +76,7 @@ def _gen_outfilename(inputs=None, stdout=None, stderr=None, output_dir=None):
         return os.path.abspath(name + ext + "_" + str(inputs.label_value))
 
 
+# Original source at L1647 of <nipype-install>/interfaces/freesurfer/utils.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "out_file":
         return _gen_outfilename(
@@ -83,6 +86,7 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
         return None
 
 
+# Original source at L1642 of <nipype-install>/interfaces/freesurfer/utils.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["surface"] = _gen_outfilename(
diff --git a/example-specs/task/nipype/freesurfer/mri_pretess_callables.py b/example-specs/task/nipype/freesurfer/mri_pretess_callables.py
index 4aee90b2..ffcd2bdb 100644
--- a/example-specs/task/nipype/freesurfer/mri_pretess_callables.py
+++ b/example-specs/task/nipype/freesurfer/mri_pretess_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of MRIPretess.yaml"""
 
 import logging
+import os
 import os.path as op
 import attrs
-import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +16,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -26,6 +27,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -76,12 +78,14 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L888 of <nipype-install>/interfaces/base/core.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
     return value
 
 
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -176,10 +180,12 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     metadata = dict(name_source=lambda t: t is not None)
     traits = inputs.traits(**metadata)
diff --git a/example-specs/task/nipype/freesurfer/mri_tessellate_callables.py b/example-specs/task/nipype/freesurfer/mri_tessellate_callables.py
index bd722f38..95df8ef1 100644
--- a/example-specs/task/nipype/freesurfer/mri_tessellate_callables.py
+++ b/example-specs/task/nipype/freesurfer/mri_tessellate_callables.py
@@ -1,8 +1,8 @@
 """Module to put any functions that are referred to in the "callables" section of MRITessellate.yaml"""
 
+import os
 import os.path as op
 import attrs
-import os
 
 
 def out_file_default(inputs):
@@ -16,6 +16,7 @@ def surface_callable(output_dir, inputs, stdout, stderr):
     return outputs["surface"]
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -66,6 +67,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L1490 of <nipype-install>/interfaces/freesurfer/utils.py
 def _gen_outfilename(inputs=None, stdout=None, stderr=None, output_dir=None):
     if inputs.out_file is not attrs.NOTHING:
         return inputs.out_file
@@ -74,6 +76,7 @@ def _gen_outfilename(inputs=None, stdout=None, stderr=None, output_dir=None):
         return name + ext + "_" + str(inputs.label_value)
 
 
+# Original source at L1484 of <nipype-install>/interfaces/freesurfer/utils.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "out_file":
         return _gen_outfilename(
@@ -83,6 +86,7 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
         return None
 
 
+# Original source at L1479 of <nipype-install>/interfaces/freesurfer/utils.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["surface"] = os.path.abspath(
diff --git a/example-specs/task/nipype/freesurfer/mris_preproc_callables.py b/example-specs/task/nipype/freesurfer/mris_preproc_callables.py
index 0838bc29..f1eeda6d 100644
--- a/example-specs/task/nipype/freesurfer/mris_preproc_callables.py
+++ b/example-specs/task/nipype/freesurfer/mris_preproc_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of MRISPreproc.yaml"""
 
-import attrs
 import os
+import attrs
 
 
 def out_file_default(inputs):
@@ -15,6 +15,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_file"]
 
 
+# Original source at L144 of <nipype-install>/interfaces/freesurfer/model.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "out_file":
         return _list_outputs(
@@ -23,6 +24,7 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     return None
 
 
+# Original source at L134 of <nipype-install>/interfaces/freesurfer/model.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outfile = inputs.out_file
diff --git a/example-specs/task/nipype/freesurfer/mris_preproc_recon_all_callables.py b/example-specs/task/nipype/freesurfer/mris_preproc_recon_all_callables.py
index 2cd221bb..b6e54979 100644
--- a/example-specs/task/nipype/freesurfer/mris_preproc_recon_all_callables.py
+++ b/example-specs/task/nipype/freesurfer/mris_preproc_recon_all_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of MRISPreprocReconAll.yaml"""
 
-import attrs
 import os
+import attrs
 
 
 def out_file_default(inputs):
@@ -15,6 +15,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_file"]
 
 
+# Original source at L144 of <nipype-install>/interfaces/freesurfer/model.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "out_file":
         return _list_outputs(
@@ -23,6 +24,7 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     return None
 
 
+# Original source at L134 of <nipype-install>/interfaces/freesurfer/model.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outfile = inputs.out_file
diff --git a/example-specs/task/nipype/freesurfer/mrtm2_callables.py b/example-specs/task/nipype/freesurfer/mrtm2_callables.py
index e9bda75c..98b9c2ba 100644
--- a/example-specs/task/nipype/freesurfer/mrtm2_callables.py
+++ b/example-specs/task/nipype/freesurfer/mrtm2_callables.py
@@ -1,8 +1,8 @@
 """Module to put any functions that are referred to in the "callables" section of MRTM2.yaml"""
 
+import os
 import os.path as op
 import attrs
-import os
 
 
 def glm_dir_default(inputs):
@@ -142,6 +142,7 @@ def bp_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["bp_file"]
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -192,12 +193,14 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L560 of <nipype-install>/interfaces/freesurfer/model.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "glm_dir":
         return output_dir
     return None
 
 
+# Original source at L496 of <nipype-install>/interfaces/freesurfer/model.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     # Get the top-level output directory
diff --git a/example-specs/task/nipype/freesurfer/mrtm_callables.py b/example-specs/task/nipype/freesurfer/mrtm_callables.py
index e359005e..efbae1a8 100644
--- a/example-specs/task/nipype/freesurfer/mrtm_callables.py
+++ b/example-specs/task/nipype/freesurfer/mrtm_callables.py
@@ -1,8 +1,8 @@
 """Module to put any functions that are referred to in the "callables" section of MRTM.yaml"""
 
+import os
 import os.path as op
 import attrs
-import os
 
 
 def glm_dir_default(inputs):
@@ -142,6 +142,7 @@ def bp_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["bp_file"]
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -192,12 +193,14 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L560 of <nipype-install>/interfaces/freesurfer/model.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "glm_dir":
         return output_dir
     return None
 
 
+# Original source at L496 of <nipype-install>/interfaces/freesurfer/model.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     # Get the top-level output directory
diff --git a/example-specs/task/nipype/freesurfer/ms__lda_callables.py b/example-specs/task/nipype/freesurfer/ms__lda_callables.py
index a5434bf6..7edd8b2d 100644
--- a/example-specs/task/nipype/freesurfer/ms__lda_callables.py
+++ b/example-specs/task/nipype/freesurfer/ms__lda_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of MS_LDA.yaml"""
 
-import attrs
 import os
+import attrs
 
 
 def weight_file_callable(output_dir, inputs, stdout, stderr):
@@ -18,10 +18,12 @@ def vol_synth_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["vol_synth_file"]
 
 
+# Original source at L1416 of <nipype-install>/interfaces/freesurfer/model.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     pass
 
 
+# Original source at L1391 of <nipype-install>/interfaces/freesurfer/model.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     if inputs.output_synth is not attrs.NOTHING:
diff --git a/example-specs/task/nipype/freesurfer/normalize_callables.py b/example-specs/task/nipype/freesurfer/normalize_callables.py
index 1e18e278..d44de81f 100644
--- a/example-specs/task/nipype/freesurfer/normalize_callables.py
+++ b/example-specs/task/nipype/freesurfer/normalize_callables.py
@@ -1,6 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of Normalize.yaml"""
 
 import os
+import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -10,10 +11,12 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_file"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L2739 of <nipype-install>/interfaces/freesurfer/preprocess.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["out_file"] = os.path.abspath(inputs.out_file)
diff --git a/example-specs/task/nipype/freesurfer/one_sample_t_test_callables.py b/example-specs/task/nipype/freesurfer/one_sample_t_test_callables.py
index 731b5299..dae959f0 100644
--- a/example-specs/task/nipype/freesurfer/one_sample_t_test_callables.py
+++ b/example-specs/task/nipype/freesurfer/one_sample_t_test_callables.py
@@ -1,8 +1,8 @@
 """Module to put any functions that are referred to in the "callables" section of OneSampleTTest.yaml"""
 
+import os
 import os.path as op
 import attrs
-import os
 
 
 def glm_dir_default(inputs):
@@ -142,6 +142,7 @@ def bp_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["bp_file"]
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -192,12 +193,14 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L560 of <nipype-install>/interfaces/freesurfer/model.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "glm_dir":
         return output_dir
     return None
 
 
+# Original source at L496 of <nipype-install>/interfaces/freesurfer/model.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     # Get the top-level output directory
diff --git a/example-specs/task/nipype/freesurfer/paint_callables.py b/example-specs/task/nipype/freesurfer/paint_callables.py
index b33ee6de..10b251da 100644
--- a/example-specs/task/nipype/freesurfer/paint_callables.py
+++ b/example-specs/task/nipype/freesurfer/paint_callables.py
@@ -1,6 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of Paint.yaml"""
 
 import os
+import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -10,10 +11,12 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_file"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L393 of <nipype-install>/interfaces/freesurfer/registration.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["out_file"] = os.path.abspath(inputs.out_file)
diff --git a/example-specs/task/nipype/freesurfer/parcellation_stats_callables.py b/example-specs/task/nipype/freesurfer/parcellation_stats_callables.py
index c8385f54..d7de17e5 100644
--- a/example-specs/task/nipype/freesurfer/parcellation_stats_callables.py
+++ b/example-specs/task/nipype/freesurfer/parcellation_stats_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of ParcellationStats.yaml"""
 
-import attrs
 import os
+import attrs
 
 
 def out_table_default(inputs):
@@ -26,6 +26,7 @@ def out_color_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_color"]
 
 
+# Original source at L3519 of <nipype-install>/interfaces/freesurfer/utils.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name in ["out_table", "out_color"]:
         return _list_outputs(
@@ -34,6 +35,7 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     return None
 
 
+# Original source at L3524 of <nipype-install>/interfaces/freesurfer/utils.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     if inputs.out_table is not attrs.NOTHING:
diff --git a/example-specs/task/nipype/freesurfer/parse_dicom_dir_callables.py b/example-specs/task/nipype/freesurfer/parse_dicom_dir_callables.py
index f1020a22..2001c30f 100644
--- a/example-specs/task/nipype/freesurfer/parse_dicom_dir_callables.py
+++ b/example-specs/task/nipype/freesurfer/parse_dicom_dir_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of ParseDICOMDir.yaml"""
 
-import attrs
 import os
+import attrs
 
 
 def dicom_info_file_callable(output_dir, inputs, stdout, stderr):
@@ -11,10 +11,12 @@ def dicom_info_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["dicom_info_file"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L83 of <nipype-install>/interfaces/freesurfer/preprocess.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     if inputs.dicom_info_file is not attrs.NOTHING:
diff --git a/example-specs/task/nipype/freesurfer/recon_all_callables.py b/example-specs/task/nipype/freesurfer/recon_all_callables.py
index 12c87ee8..bff05e41 100644
--- a/example-specs/task/nipype/freesurfer/recon_all_callables.py
+++ b/example-specs/task/nipype/freesurfer/recon_all_callables.py
@@ -280,10 +280,12 @@ def entorhinal_exvivo_stats_callable(output_dir, inputs, stdout, stderr):
     return outputs["entorhinal_exvivo_stats"]
 
 
+# Original source at L1502 of <nipype-install>/interfaces/freesurfer/preprocess.py
 def _gen_subjects_dir(inputs=None, stdout=None, stderr=None, output_dir=None):
     return output_dir
 
 
+# Original source at L1505 of <nipype-install>/interfaces/freesurfer/preprocess.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "subjects_dir":
         return _gen_subjects_dir(
@@ -292,6 +294,7 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     return None
 
 
+# Original source at L1510 of <nipype-install>/interfaces/freesurfer/preprocess.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     """
     See io.FreeSurferSource.outputs for the list of outputs returned
diff --git a/example-specs/task/nipype/freesurfer/register_av_ito_talairach_callables.py b/example-specs/task/nipype/freesurfer/register_av_ito_talairach_callables.py
index c222f28b..c931c743 100644
--- a/example-specs/task/nipype/freesurfer/register_av_ito_talairach_callables.py
+++ b/example-specs/task/nipype/freesurfer/register_av_ito_talairach_callables.py
@@ -1,6 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of RegisterAVItoTalairach.yaml"""
 
 import os
+import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,10 +18,12 @@ def log_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["log_file"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L175 of <nipype-install>/interfaces/freesurfer/registration.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["out_file"] = os.path.abspath(inputs.out_file)
diff --git a/example-specs/task/nipype/freesurfer/register_callables.py b/example-specs/task/nipype/freesurfer/register_callables.py
index 321e501c..22649f42 100644
--- a/example-specs/task/nipype/freesurfer/register_callables.py
+++ b/example-specs/task/nipype/freesurfer/register_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of Register.yaml"""
 
-import attrs
 import os
+import attrs
 
 
 def out_file_default(inputs):
@@ -15,6 +15,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_file"]
 
 
+# Original source at L313 of <nipype-install>/interfaces/freesurfer/registration.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "out_file":
         return _list_outputs(
@@ -23,6 +24,7 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     return None
 
 
+# Original source at L318 of <nipype-install>/interfaces/freesurfer/registration.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     if inputs.out_file is not attrs.NOTHING:
diff --git a/example-specs/task/nipype/freesurfer/relabel_hypointensities_callables.py b/example-specs/task/nipype/freesurfer/relabel_hypointensities_callables.py
index 03891a26..6e9bce30 100644
--- a/example-specs/task/nipype/freesurfer/relabel_hypointensities_callables.py
+++ b/example-specs/task/nipype/freesurfer/relabel_hypointensities_callables.py
@@ -1,6 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of RelabelHypointensities.yaml"""
 
 import os
+import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -10,10 +11,12 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_file"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L3758 of <nipype-install>/interfaces/freesurfer/utils.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["out_file"] = os.path.abspath(inputs.out_file)
diff --git a/example-specs/task/nipype/freesurfer/remove_intersection_callables.py b/example-specs/task/nipype/freesurfer/remove_intersection_callables.py
index 0a03c662..a53b979d 100644
--- a/example-specs/task/nipype/freesurfer/remove_intersection_callables.py
+++ b/example-specs/task/nipype/freesurfer/remove_intersection_callables.py
@@ -1,6 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of RemoveIntersection.yaml"""
 
 import os
+import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -10,10 +11,12 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_file"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L2667 of <nipype-install>/interfaces/freesurfer/utils.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["out_file"] = os.path.abspath(inputs.out_file)
diff --git a/example-specs/task/nipype/freesurfer/remove_neck_callables.py b/example-specs/task/nipype/freesurfer/remove_neck_callables.py
index 4d4ecec7..6e30bc13 100644
--- a/example-specs/task/nipype/freesurfer/remove_neck_callables.py
+++ b/example-specs/task/nipype/freesurfer/remove_neck_callables.py
@@ -1,6 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of RemoveNeck.yaml"""
 
 import os
+import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -10,10 +11,12 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_file"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L2278 of <nipype-install>/interfaces/freesurfer/utils.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["out_file"] = os.path.abspath(inputs.out_file)
diff --git a/example-specs/task/nipype/freesurfer/resample_callables.py b/example-specs/task/nipype/freesurfer/resample_callables.py
index 29883c93..81f3fb9e 100644
--- a/example-specs/task/nipype/freesurfer/resample_callables.py
+++ b/example-specs/task/nipype/freesurfer/resample_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of Resample.yaml"""
 
-from pathlib import Path
 import os.path as op
+from pathlib import Path
 import attrs
 
 
@@ -16,6 +16,7 @@ def resampled_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["resampled_file"]
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -58,6 +59,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -108,6 +110,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L797 of <nipype-install>/interfaces/freesurfer/preprocess.py
 def _get_outfilename(inputs=None, stdout=None, stderr=None, output_dir=None):
     if inputs.resampled_file is not attrs.NOTHING:
         outfile = inputs.resampled_file
@@ -118,6 +121,7 @@ def _get_outfilename(inputs=None, stdout=None, stderr=None, output_dir=None):
     return outfile
 
 
+# Original source at L811 of <nipype-install>/interfaces/freesurfer/preprocess.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "resampled_file":
         return _get_outfilename(
@@ -126,6 +130,7 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     return None
 
 
+# Original source at L806 of <nipype-install>/interfaces/freesurfer/preprocess.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["resampled_file"] = _get_outfilename(
diff --git a/example-specs/task/nipype/freesurfer/robust_register_callables.py b/example-specs/task/nipype/freesurfer/robust_register_callables.py
index f6604d22..24c0edab 100644
--- a/example-specs/task/nipype/freesurfer/robust_register_callables.py
+++ b/example-specs/task/nipype/freesurfer/robust_register_callables.py
@@ -1,8 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of RobustRegister.yaml"""
 
+import attrs
+import os
 import os.path as op
 from pathlib import Path
-import os
 
 
 def out_reg_file_callable(output_dir, inputs, stdout, stderr):
@@ -61,10 +62,12 @@ def half_targ_xfm_callable(output_dir, inputs, stdout, stderr):
     return outputs["half_targ_xfm"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -107,6 +110,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -157,6 +161,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L2357 of <nipype-install>/interfaces/freesurfer/preprocess.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     cwd = output_dir
diff --git a/example-specs/task/nipype/freesurfer/robust_template_callables.py b/example-specs/task/nipype/freesurfer/robust_template_callables.py
index db1e2f14..9e0f032a 100644
--- a/example-specs/task/nipype/freesurfer/robust_template_callables.py
+++ b/example-specs/task/nipype/freesurfer/robust_template_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of RobustTemplate.yaml"""
 
-import attrs
 import os
+import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -25,10 +25,12 @@ def scaled_intensity_outputs_callable(output_dir, inputs, stdout, stderr):
     return outputs["scaled_intensity_outputs"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L162 of <nipype-install>/interfaces/freesurfer/longitudinal.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["out_file"] = os.path.abspath(inputs.out_file)
diff --git a/example-specs/task/nipype/freesurfer/sample_to_surface_callables.py b/example-specs/task/nipype/freesurfer/sample_to_surface_callables.py
index 15507d52..fbcb1623 100644
--- a/example-specs/task/nipype/freesurfer/sample_to_surface_callables.py
+++ b/example-specs/task/nipype/freesurfer/sample_to_surface_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of SampleToSurface.yaml"""
 
-from pathlib import Path
+import os
 import os.path as op
+from pathlib import Path
 import attrs
-import os
 
 
 def out_file_default(inputs):
@@ -50,6 +50,7 @@ def vox_file_callable(output_dir, inputs, stdout, stderr):
 )
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -92,6 +93,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -142,6 +144,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L378 of <nipype-install>/interfaces/freesurfer/utils.py
 def _get_outfilename(
     opt="out_file", inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -166,6 +169,7 @@ def _get_outfilename(
     return outfile
 
 
+# Original source at L420 of <nipype-install>/interfaces/freesurfer/utils.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "out_file":
         return _list_outputs(
@@ -174,6 +178,7 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     return None
 
 
+# Original source at L399 of <nipype-install>/interfaces/freesurfer/utils.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["out_file"] = os.path.abspath(
diff --git a/example-specs/task/nipype/freesurfer/seg_stats_callables.py b/example-specs/task/nipype/freesurfer/seg_stats_callables.py
index d82c36cb..7e30a4fa 100644
--- a/example-specs/task/nipype/freesurfer/seg_stats_callables.py
+++ b/example-specs/task/nipype/freesurfer/seg_stats_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of SegStats.yaml"""
 
-from pathlib import Path
+import os
 import os.path as op
+from pathlib import Path
 import attrs
-import os
 
 
 def summary_file_default(inputs):
@@ -38,6 +38,7 @@ def sf_avg_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["sf_avg_file"]
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -80,6 +81,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -130,6 +132,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L1071 of <nipype-install>/interfaces/freesurfer/model.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "summary_file":
         return _list_outputs(
@@ -138,6 +141,7 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     return None
 
 
+# Original source at L1025 of <nipype-install>/interfaces/freesurfer/model.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     if inputs.summary_file is not attrs.NOTHING:
diff --git a/example-specs/task/nipype/freesurfer/seg_stats_recon_all_callables.py b/example-specs/task/nipype/freesurfer/seg_stats_recon_all_callables.py
index 7706d394..c39da23e 100644
--- a/example-specs/task/nipype/freesurfer/seg_stats_recon_all_callables.py
+++ b/example-specs/task/nipype/freesurfer/seg_stats_recon_all_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of SegStatsReconAll.yaml"""
 
-from pathlib import Path
+import os
 import os.path as op
+from pathlib import Path
 import attrs
-import os
 
 
 def summary_file_default(inputs):
@@ -38,6 +38,7 @@ def sf_avg_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["sf_avg_file"]
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -80,6 +81,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -130,6 +132,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L1071 of <nipype-install>/interfaces/freesurfer/model.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "summary_file":
         return _list_outputs(
@@ -138,6 +141,7 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     return None
 
 
+# Original source at L1025 of <nipype-install>/interfaces/freesurfer/model.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     if inputs.summary_file is not attrs.NOTHING:
diff --git a/example-specs/task/nipype/freesurfer/segment_cc_callables.py b/example-specs/task/nipype/freesurfer/segment_cc_callables.py
index 3e8ea8d3..aa7f4f43 100644
--- a/example-specs/task/nipype/freesurfer/segment_cc_callables.py
+++ b/example-specs/task/nipype/freesurfer/segment_cc_callables.py
@@ -1,6 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of SegmentCC.yaml"""
 
 import os
+import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,10 +18,12 @@ def out_rotation_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_rotation"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L3235 of <nipype-install>/interfaces/freesurfer/preprocess.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["out_file"] = os.path.abspath(inputs.out_file)
diff --git a/example-specs/task/nipype/freesurfer/segment_wm_callables.py b/example-specs/task/nipype/freesurfer/segment_wm_callables.py
index 9bf6f872..404d80c2 100644
--- a/example-specs/task/nipype/freesurfer/segment_wm_callables.py
+++ b/example-specs/task/nipype/freesurfer/segment_wm_callables.py
@@ -1,6 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of SegmentWM.yaml"""
 
 import os
+import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -10,10 +11,12 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_file"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L3320 of <nipype-install>/interfaces/freesurfer/preprocess.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["out_file"] = os.path.abspath(inputs.out_file)
diff --git a/example-specs/task/nipype/freesurfer/smooth_callables.py b/example-specs/task/nipype/freesurfer/smooth_callables.py
index afe077d2..76413468 100644
--- a/example-specs/task/nipype/freesurfer/smooth_callables.py
+++ b/example-specs/task/nipype/freesurfer/smooth_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of Smooth.yaml"""
 
-from pathlib import Path
 import os.path as op
+from pathlib import Path
 import attrs
 
 
@@ -16,6 +16,7 @@ def smoothed_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["smoothed_file"]
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -58,6 +59,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -108,6 +110,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L151 of <nipype-install>/interfaces/freesurfer/base.py
 def _gen_fname(
     basename,
     fname=None,
@@ -144,6 +147,7 @@ def _gen_fname(
     return fname
 
 
+# Original source at L2174 of <nipype-install>/interfaces/freesurfer/preprocess.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "smoothed_file":
         return _list_outputs(
@@ -152,6 +156,7 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     return None
 
 
+# Original source at L2166 of <nipype-install>/interfaces/freesurfer/preprocess.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outfile = inputs.smoothed_file
diff --git a/example-specs/task/nipype/freesurfer/smooth_tessellation_callables.py b/example-specs/task/nipype/freesurfer/smooth_tessellation_callables.py
index 3bf1b5d6..fdd45bb1 100644
--- a/example-specs/task/nipype/freesurfer/smooth_tessellation_callables.py
+++ b/example-specs/task/nipype/freesurfer/smooth_tessellation_callables.py
@@ -1,8 +1,8 @@
 """Module to put any functions that are referred to in the "callables" section of SmoothTessellation.yaml"""
 
+import os
 import os.path as op
 import attrs
-import os
 
 
 def out_file_default(inputs):
@@ -16,6 +16,7 @@ def surface_callable(output_dir, inputs, stdout, stderr):
     return outputs["surface"]
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -66,6 +67,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L1756 of <nipype-install>/interfaces/freesurfer/utils.py
 def _gen_outfilename(inputs=None, stdout=None, stderr=None, output_dir=None):
     if inputs.out_file is not attrs.NOTHING:
         return os.path.abspath(inputs.out_file)
@@ -74,6 +76,7 @@ def _gen_outfilename(inputs=None, stdout=None, stderr=None, output_dir=None):
         return os.path.abspath(name + "_smoothed" + ext)
 
 
+# Original source at L1750 of <nipype-install>/interfaces/freesurfer/utils.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "out_file":
         return _gen_outfilename(
@@ -83,6 +86,7 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
         return None
 
 
+# Original source at L1745 of <nipype-install>/interfaces/freesurfer/utils.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["surface"] = _gen_outfilename(
diff --git a/example-specs/task/nipype/freesurfer/sphere_callables.py b/example-specs/task/nipype/freesurfer/sphere_callables.py
index 4961c188..123c8ea6 100644
--- a/example-specs/task/nipype/freesurfer/sphere_callables.py
+++ b/example-specs/task/nipype/freesurfer/sphere_callables.py
@@ -1,6 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of Sphere.yaml"""
 
 import os
+import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -10,10 +11,12 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_file"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L2455 of <nipype-install>/interfaces/freesurfer/utils.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["out_file"] = os.path.abspath(inputs.out_file)
diff --git a/example-specs/task/nipype/freesurfer/spherical_average_callables.py b/example-specs/task/nipype/freesurfer/spherical_average_callables.py
index 4253966a..6c8967cd 100644
--- a/example-specs/task/nipype/freesurfer/spherical_average_callables.py
+++ b/example-specs/task/nipype/freesurfer/spherical_average_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of SphericalAverage.yaml"""
 
-import attrs
 import os
+import attrs
 
 
 def out_file_default(inputs):
@@ -19,6 +19,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_file"]
 
 
+# Original source at L1721 of <nipype-install>/interfaces/freesurfer/model.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "in_average":
         avg_subject = str(inputs.hemisphere) + ".EC_average"
@@ -34,6 +35,7 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
         return None
 
 
+# Original source at L1733 of <nipype-install>/interfaces/freesurfer/model.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     if inputs.out_file is not attrs.NOTHING:
diff --git a/example-specs/task/nipype/freesurfer/surface_2_vol_transform_callables.py b/example-specs/task/nipype/freesurfer/surface_2_vol_transform_callables.py
index 3c0aae1d..417ab246 100644
--- a/example-specs/task/nipype/freesurfer/surface_2_vol_transform_callables.py
+++ b/example-specs/task/nipype/freesurfer/surface_2_vol_transform_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of Surface2VolTransform.yaml"""
 
 import logging
+import os
 import os.path as op
 import attrs
-import os
 
 
 def transformed_file_callable(output_dir, inputs, stdout, stderr):
@@ -23,6 +23,7 @@ def vertexvol_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -33,6 +34,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -83,12 +85,14 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L888 of <nipype-install>/interfaces/base/core.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
     return value
 
 
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -183,10 +187,12 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     metadata = dict(name_source=lambda t: t is not None)
     traits = inputs.traits(**metadata)
diff --git a/example-specs/task/nipype/freesurfer/surface_smooth_callables.py b/example-specs/task/nipype/freesurfer/surface_smooth_callables.py
index 6bdcf9cf..d28091ca 100644
--- a/example-specs/task/nipype/freesurfer/surface_smooth_callables.py
+++ b/example-specs/task/nipype/freesurfer/surface_smooth_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of SurfaceSmooth.yaml"""
 
-from pathlib import Path
 import os.path as op
+from pathlib import Path
 import attrs
 
 
@@ -16,6 +16,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_file"]
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -58,6 +59,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -108,6 +110,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L504 of <nipype-install>/interfaces/freesurfer/utils.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "out_file":
         return _list_outputs(
@@ -116,6 +119,7 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     return None
 
 
+# Original source at L490 of <nipype-install>/interfaces/freesurfer/utils.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["out_file"] = inputs.out_file
diff --git a/example-specs/task/nipype/freesurfer/surface_snapshots_callables.py b/example-specs/task/nipype/freesurfer/surface_snapshots_callables.py
index 98cf1d20..e514023f 100644
--- a/example-specs/task/nipype/freesurfer/surface_snapshots_callables.py
+++ b/example-specs/task/nipype/freesurfer/surface_snapshots_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of SurfaceSnapshots.yaml"""
 
-from pathlib import Path
 import os.path as op
+from pathlib import Path
 import attrs
 
 
@@ -16,6 +16,7 @@ def snapshots_callable(output_dir, inputs, stdout, stderr):
     return outputs["snapshots"]
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -58,6 +59,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -108,6 +110,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L151 of <nipype-install>/interfaces/freesurfer/base.py
 def _gen_fname(
     basename,
     fname=None,
@@ -144,12 +147,14 @@ def _gen_fname(
     return fname
 
 
+# Original source at L1106 of <nipype-install>/interfaces/freesurfer/utils.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "tcl_script":
         return "snapshots.tcl"
     return None
 
 
+# Original source at L1085 of <nipype-install>/interfaces/freesurfer/utils.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     if inputs.screenshot_stem is attrs.NOTHING:
diff --git a/example-specs/task/nipype/freesurfer/surface_transform_callables.py b/example-specs/task/nipype/freesurfer/surface_transform_callables.py
index 96c0ae27..20f73b1b 100644
--- a/example-specs/task/nipype/freesurfer/surface_transform_callables.py
+++ b/example-specs/task/nipype/freesurfer/surface_transform_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of SurfaceTransform.yaml"""
 
-from pathlib import Path
+import os
 import os.path as op
+from pathlib import Path
 import attrs
-import os
 
 
 def out_file_default(inputs):
@@ -36,6 +36,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 )
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -78,6 +79,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -128,6 +130,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L663 of <nipype-install>/interfaces/freesurfer/utils.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "out_file":
         return _list_outputs(
@@ -136,6 +139,7 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     return None
 
 
+# Original source at L613 of <nipype-install>/interfaces/freesurfer/utils.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["out_file"] = inputs.out_file
diff --git a/example-specs/task/nipype/freesurfer/synthesize_flash_callables.py b/example-specs/task/nipype/freesurfer/synthesize_flash_callables.py
index 34da4035..9c1b5709 100644
--- a/example-specs/task/nipype/freesurfer/synthesize_flash_callables.py
+++ b/example-specs/task/nipype/freesurfer/synthesize_flash_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of SynthesizeFLASH.yaml"""
 
-from pathlib import Path
 import os.path as op
+from pathlib import Path
 import attrs
 
 
@@ -16,6 +16,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_file"]
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -58,6 +59,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -108,6 +110,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L151 of <nipype-install>/interfaces/freesurfer/base.py
 def _gen_fname(
     basename,
     fname=None,
@@ -144,6 +147,7 @@ def _gen_fname(
     return fname
 
 
+# Original source at L2523 of <nipype-install>/interfaces/freesurfer/preprocess.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "out_file":
         return _list_outputs(
@@ -152,6 +156,7 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     return None
 
 
+# Original source at L2513 of <nipype-install>/interfaces/freesurfer/preprocess.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     if inputs.out_file is not attrs.NOTHING:
diff --git a/example-specs/task/nipype/freesurfer/talairach_avi_callables.py b/example-specs/task/nipype/freesurfer/talairach_avi_callables.py
index d9ffd30c..5bb00a1d 100644
--- a/example-specs/task/nipype/freesurfer/talairach_avi_callables.py
+++ b/example-specs/task/nipype/freesurfer/talairach_avi_callables.py
@@ -1,6 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of TalairachAVI.yaml"""
 
 import os
+import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -24,10 +25,12 @@ def out_txt_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_txt"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L2175 of <nipype-install>/interfaces/freesurfer/utils.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["out_file"] = os.path.abspath(inputs.out_file)
diff --git a/example-specs/task/nipype/freesurfer/talairach_qc_callables.py b/example-specs/task/nipype/freesurfer/talairach_qc_callables.py
index 8c6a837a..833876f7 100644
--- a/example-specs/task/nipype/freesurfer/talairach_qc_callables.py
+++ b/example-specs/task/nipype/freesurfer/talairach_qc_callables.py
@@ -1,6 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of TalairachQC.yaml"""
 
 import os
+import attrs
 
 
 def log_file_callable(output_dir, inputs, stdout, stderr):
@@ -10,10 +11,12 @@ def log_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["log_file"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L216 of <nipype-install>/interfaces/freesurfer/base.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["log_file"] = os.path.abspath("output.nipype")
diff --git a/example-specs/task/nipype/freesurfer/tkregister_2_callables.py b/example-specs/task/nipype/freesurfer/tkregister_2_callables.py
index 91fe8fcf..c218e975 100644
--- a/example-specs/task/nipype/freesurfer/tkregister_2_callables.py
+++ b/example-specs/task/nipype/freesurfer/tkregister_2_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of Tkregister2.yaml"""
 
-from pathlib import Path
+import os
 import os.path as op
+from pathlib import Path
 import attrs
-import os
 
 
 def reg_file_callable(output_dir, inputs, stdout, stderr):
@@ -27,10 +27,12 @@ def lta_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["lta_file"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -73,6 +75,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -123,6 +126,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L1973 of <nipype-install>/interfaces/freesurfer/utils.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     reg_file = os.path.abspath(inputs.reg_file)
diff --git a/example-specs/task/nipype/freesurfer/unpack_sdicom_dir_callables.py b/example-specs/task/nipype/freesurfer/unpack_sdicom_dir_callables.py
index bcb6650f..c6db768b 100644
--- a/example-specs/task/nipype/freesurfer/unpack_sdicom_dir_callables.py
+++ b/example-specs/task/nipype/freesurfer/unpack_sdicom_dir_callables.py
@@ -1,13 +1,14 @@
 """Module to put any functions that are referred to in the "callables" section of UnpackSDICOMDir.yaml"""
 
 import logging
+import os
 import os.path as op
 import attrs
-import os
 
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -18,6 +19,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -68,12 +70,14 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L888 of <nipype-install>/interfaces/base/core.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
     return value
 
 
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -168,10 +172,12 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     metadata = dict(name_source=lambda t: t is not None)
     traits = inputs.traits(**metadata)
diff --git a/example-specs/task/nipype/freesurfer/volume_mask_callables.py b/example-specs/task/nipype/freesurfer/volume_mask_callables.py
index c95387ab..cb811151 100644
--- a/example-specs/task/nipype/freesurfer/volume_mask_callables.py
+++ b/example-specs/task/nipype/freesurfer/volume_mask_callables.py
@@ -1,6 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of VolumeMask.yaml"""
 
 import os
+import attrs
 
 
 def out_ribbon_callable(output_dir, inputs, stdout, stderr):
@@ -24,10 +25,12 @@ def rh_ribbon_callable(output_dir, inputs, stdout, stderr):
     return outputs["rh_ribbon"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L3326 of <nipype-install>/interfaces/freesurfer/utils.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     out_dir = os.path.join(inputs.subjects_dir, inputs.subject_id, "mri")
diff --git a/example-specs/task/nipype/freesurfer/watershed_skull_strip_callables.py b/example-specs/task/nipype/freesurfer/watershed_skull_strip_callables.py
index a7556061..4019b9af 100644
--- a/example-specs/task/nipype/freesurfer/watershed_skull_strip_callables.py
+++ b/example-specs/task/nipype/freesurfer/watershed_skull_strip_callables.py
@@ -1,6 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of WatershedSkullStrip.yaml"""
 
 import os
+import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -10,10 +11,12 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_file"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L2676 of <nipype-install>/interfaces/freesurfer/preprocess.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["out_file"] = os.path.abspath(inputs.out_file)
diff --git a/example-specs/task/nipype/fsl/accuracy_tester_callables.py b/example-specs/task/nipype/fsl/accuracy_tester_callables.py
index 6ad99bac..ff348117 100644
--- a/example-specs/task/nipype/fsl/accuracy_tester_callables.py
+++ b/example-specs/task/nipype/fsl/accuracy_tester_callables.py
@@ -1,10 +1,6 @@
 """Module to put any functions that are referred to in the "callables" section of AccuracyTester.yaml"""
 
 from fileformats.generic import Directory
-from traits.trait_errors import TraitError
-from pathlib import Path
-from traits.trait_type import TraitType
-from traits.trait_base import _Undefined
 import attrs
 
 
@@ -15,153 +11,12 @@ def output_directory_callable(output_dir, inputs, stdout, stderr):
     return outputs["output_directory"]
 
 
-Undefined = _Undefined()
-
-
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
-class BasePath(TraitType):
-    """Defines a trait whose value must be a valid filesystem path."""
-
-    # A description of the type of value this trait accepts:
-    exists = False
-    resolve = False
-    _is_file = False
-    _is_dir = False
-
-    @property
-    def info_text(self):
-        """Create the trait's general description."""
-        info_text = "a pathlike object or string"
-        if any((self.exists, self._is_file, self._is_dir)):
-            info_text += " representing a"
-            if self.exists:
-                info_text += "n existing"
-            if self._is_file:
-                info_text += " file"
-            elif self._is_dir:
-                info_text += " directory"
-            else:
-                info_text += " file or directory"
-        return info_text
-
-    def __init__(self, value=attrs.NOTHING, exists=False, resolve=False, **metadata):
-        """Create a BasePath trait."""
-        self.exists = exists
-        self.resolve = resolve
-        super(BasePath, self).__init__(value, **metadata)
-
-    def validate(self, objekt, name, value, return_pathlike=False):
-        """Validate a value change."""
-        try:
-            value = Path(value)  # Use pathlib's validation
-        except Exception:
-            self.error(objekt, name, str(value))
-
-        if self.exists:
-            if not value.exists():
-                self.error(objekt, name, str(value))
-
-            if self._is_file and not value.is_file():
-                self.error(objekt, name, str(value))
-
-            if self._is_dir and not value.is_dir():
-                self.error(objekt, name, str(value))
-
-        if self.resolve:
-            value = path_resolve(value, strict=self.exists)
-
-        if not return_pathlike:
-            value = str(value)
-
-        return value
-
-
-class Directory(BasePath):
-    """
-    Defines a trait whose value must be a directory path.
-
-    >>> from nipype.interfaces.base import Directory, TraitedSpec, TraitError
-    >>> class A(TraitedSpec):
-    ...     foo = Directory(exists=False)
-    >>> a = A()
-    >>> a.foo
-    <undefined>
-
-    >>> a.foo = '/some/made/out/path'
-    >>> a.foo
-    '/some/made/out/path'
-
-    >>> class A(TraitedSpec):
-    ...     foo = Directory(exists=False, resolve=True)
-    >>> a = A(foo='relative_dir')
-    >>> a.foo  # doctest: +ELLIPSIS
-    '.../relative_dir'
-
-    >>> class A(TraitedSpec):
-    ...     foo = Directory(exists=True, resolve=True)
-    >>> a = A()
-    >>> a.foo = 'relative_dir'  # doctest: +IGNORE_EXCEPTION_DETAIL
-    Traceback (most recent call last):
-    TraitError:
-
-    >>> from os import mkdir
-    >>> mkdir('relative_dir')
-    >>> a.foo = 'relative_dir'
-    >>> a.foo  # doctest: +ELLIPSIS
-    '.../relative_dir'
-
-    >>> class A(TraitedSpec):
-    ...     foo = Directory(exists=True, resolve=False)
-    >>> a = A(foo='relative_dir')
-    >>> a.foo
-    'relative_dir'
-
-    >>> class A(TraitedSpec):
-    ...     foo = Directory('tmpdir')
-    >>> a = A()
-    >>> a.foo  # doctest: +ELLIPSIS
-    <undefined>
-
-    >>> class A(TraitedSpec):
-    ...     foo = Directory('tmpdir', usedefault=True)
-    >>> a = A()
-    >>> a.foo  # doctest: +ELLIPSIS
-    'tmpdir'
-
-    """
-
-    _is_dir = True
-
-
-def path_resolve(path, strict=False):
-    try:
-        return _resolve_with_filenotfound(path, strict=strict)
-    except TypeError:  # PY35
-        pass
-
-    path = path.absolute()
-    if strict or path.exists():
-        return _resolve_with_filenotfound(path)
-
-    # This is a hacky shortcut, using path.absolute() unmodified
-    # In cases where the existing part of the path contains a
-    # symlink, different results will be produced
-    return path
-
-
-def _resolve_with_filenotfound(path, **kwargs):
-    """Raise FileNotFoundError instead of OSError"""
-    try:
-        return path.resolve(**kwargs)
-    except OSError as e:
-        if isinstance(e, FileNotFoundError):
-            raise
-        raise FileNotFoundError(str(path))
-
-
+# Original source at L251 of <nipype-install>/interfaces/fsl/fix.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     if inputs.output_directory is not attrs.NOTHING:
diff --git a/example-specs/task/nipype/fsl/apply_mask_callables.py b/example-specs/task/nipype/fsl/apply_mask_callables.py
index 145e3812..61903295 100644
--- a/example-specs/task/nipype/fsl/apply_mask_callables.py
+++ b/example-specs/task/nipype/fsl/apply_mask_callables.py
@@ -1,11 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of ApplyMask.yaml"""
 
 from glob import glob
-import logging
-from pathlib import Path
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
+from pathlib import Path
 
 
 def out_file_default(inputs):
@@ -22,6 +22,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -59,6 +60,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -101,6 +103,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -151,6 +154,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
     Handle FSL ``output_type`` and version information.
@@ -243,6 +247,7 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
 def _gen_fname(
     basename,
     cwd=None,
@@ -298,6 +303,7 @@ def _gen_fname(
     return fname
 
 
+# Original source at L61 of <nipype-install>/interfaces/fsl/maths.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "out_file":
         return _list_outputs(
@@ -306,6 +312,7 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     return None
 
 
+# Original source at L51 of <nipype-install>/interfaces/fsl/maths.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["out_file"] = inputs.out_file
diff --git a/example-specs/task/nipype/fsl/apply_topup_callables.py b/example-specs/task/nipype/fsl/apply_topup_callables.py
index cca286ba..8f59a046 100644
--- a/example-specs/task/nipype/fsl/apply_topup_callables.py
+++ b/example-specs/task/nipype/fsl/apply_topup_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of ApplyTOPUP.yaml"""
 
-import logging
 from glob import glob
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
 
 
 def out_corrected_callable(output_dir, inputs, stdout, stderr):
@@ -14,12 +14,13 @@ def out_corrected_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_corrected"]
 
 
-iflogger = logging.getLogger("nipype.interface")
+IFLOGGER = logging.getLogger("nipype.interface")
 
 
-IFLOGGER = logging.getLogger("nipype.interface")
+iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -57,6 +58,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
     Handle FSL ``output_type`` and version information.
@@ -149,12 +151,14 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
+# Original source at L249 of <nipype-install>/interfaces/fsl/base.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
     return value + Info.output_type_to_ext(inputs.output_type)
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -165,6 +169,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -215,6 +220,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -309,10 +315,12 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     metadata = dict(name_source=lambda t: t is not None)
     traits = inputs.traits(**metadata)
diff --git a/example-specs/task/nipype/fsl/apply_warp_callables.py b/example-specs/task/nipype/fsl/apply_warp_callables.py
index d3326038..cff717fd 100644
--- a/example-specs/task/nipype/fsl/apply_warp_callables.py
+++ b/example-specs/task/nipype/fsl/apply_warp_callables.py
@@ -1,11 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of ApplyWarp.yaml"""
 
 from glob import glob
-import logging
-from pathlib import Path
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
+from pathlib import Path
 
 
 def out_file_default(inputs):
@@ -22,6 +22,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -59,6 +60,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -101,6 +103,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -151,6 +154,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
     Handle FSL ``output_type`` and version information.
@@ -243,6 +247,7 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
 def _gen_fname(
     basename,
     cwd=None,
@@ -298,6 +303,7 @@ def _gen_fname(
     return fname
 
 
+# Original source at L1494 of <nipype-install>/interfaces/fsl/preprocess.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "out_file":
         return _list_outputs(
@@ -306,6 +312,7 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     return None
 
 
+# Original source at L1486 of <nipype-install>/interfaces/fsl/preprocess.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     if inputs.out_file is attrs.NOTHING:
diff --git a/example-specs/task/nipype/fsl/apply_xfm_callables.py b/example-specs/task/nipype/fsl/apply_xfm_callables.py
index 7c76eb44..5e7ef67b 100644
--- a/example-specs/task/nipype/fsl/apply_xfm_callables.py
+++ b/example-specs/task/nipype/fsl/apply_xfm_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of ApplyXFM.yaml"""
 
-import logging
 from glob import glob
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -28,12 +28,13 @@ def out_log_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_log"]
 
 
-iflogger = logging.getLogger("nipype.interface")
+IFLOGGER = logging.getLogger("nipype.interface")
 
 
-IFLOGGER = logging.getLogger("nipype.interface")
+iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -71,6 +72,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
     Handle FSL ``output_type`` and version information.
@@ -163,12 +165,14 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
+# Original source at L249 of <nipype-install>/interfaces/fsl/base.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
     return value + Info.output_type_to_ext(inputs.output_type)
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -179,6 +183,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -229,6 +234,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -323,10 +329,12 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     metadata = dict(name_source=lambda t: t is not None)
     traits = inputs.traits(**metadata)
diff --git a/example-specs/task/nipype/fsl/ar1_image_callables.py b/example-specs/task/nipype/fsl/ar1_image_callables.py
index 1e6231d8..147bb098 100644
--- a/example-specs/task/nipype/fsl/ar1_image_callables.py
+++ b/example-specs/task/nipype/fsl/ar1_image_callables.py
@@ -1,11 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of AR1Image.yaml"""
 
 from glob import glob
-import logging
-from pathlib import Path
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
+from pathlib import Path
 
 
 def out_file_default(inputs):
@@ -22,6 +22,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -59,6 +60,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -101,6 +103,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -151,6 +154,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
     Handle FSL ``output_type`` and version information.
@@ -243,6 +247,7 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
 def _gen_fname(
     basename,
     cwd=None,
@@ -298,6 +303,7 @@ def _gen_fname(
     return fname
 
 
+# Original source at L61 of <nipype-install>/interfaces/fsl/maths.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "out_file":
         return _list_outputs(
@@ -306,6 +312,7 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     return None
 
 
+# Original source at L51 of <nipype-install>/interfaces/fsl/maths.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["out_file"] = inputs.out_file
diff --git a/example-specs/task/nipype/fsl/av_scale_callables.py b/example-specs/task/nipype/fsl/av_scale_callables.py
index 359c4d77..6a870f78 100644
--- a/example-specs/task/nipype/fsl/av_scale_callables.py
+++ b/example-specs/task/nipype/fsl/av_scale_callables.py
@@ -1,5 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of AvScale.yaml"""
 
+import attrs
+
 
 def rotation_translation_matrix_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
@@ -71,9 +73,11 @@ def translations_callable(output_dir, inputs, stdout, stderr):
     return outputs["translations"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L935 of <nipype-install>/interfaces/fsl/utils.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     return _results
diff --git a/example-specs/task/nipype/fsl/b0_calc_callables.py b/example-specs/task/nipype/fsl/b0_calc_callables.py
index d3116a5d..a925759c 100644
--- a/example-specs/task/nipype/fsl/b0_calc_callables.py
+++ b/example-specs/task/nipype/fsl/b0_calc_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of B0Calc.yaml"""
 
-import logging
 from glob import glob
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -14,12 +14,13 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_file"]
 
 
-iflogger = logging.getLogger("nipype.interface")
+IFLOGGER = logging.getLogger("nipype.interface")
 
 
-IFLOGGER = logging.getLogger("nipype.interface")
+iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -57,6 +58,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
     Handle FSL ``output_type`` and version information.
@@ -149,12 +151,14 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
+# Original source at L249 of <nipype-install>/interfaces/fsl/base.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
     return value + Info.output_type_to_ext(inputs.output_type)
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -165,6 +169,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -215,6 +220,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -309,10 +315,12 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     metadata = dict(name_source=lambda t: t is not None)
     traits = inputs.traits(**metadata)
diff --git a/example-specs/task/nipype/fsl/bedpostx5_callables.py b/example-specs/task/nipype/fsl/bedpostx5_callables.py
index 986ad26c..9d320bbc 100644
--- a/example-specs/task/nipype/fsl/bedpostx5_callables.py
+++ b/example-specs/task/nipype/fsl/bedpostx5_callables.py
@@ -1,10 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of BEDPOSTX5.yaml"""
 
+import attrs
 from glob import glob
 import logging
-from pathlib import Path
-import os.path as op
 import os
+import os.path as op
+from pathlib import Path
 
 
 def mean_dsamples_callable(output_dir, inputs, stdout, stderr):
@@ -80,6 +81,7 @@ def dyads_dispersion_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -117,6 +119,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -159,6 +162,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -209,6 +213,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
     Handle FSL ``output_type`` and version information.
@@ -301,6 +306,7 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
 def _gen_fname(
     basename,
     cwd=None,
@@ -356,10 +362,12 @@ def _gen_fname(
     return fname
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L483 of <nipype-install>/interfaces/fsl/dti.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     n_fibres = inputs.n_fibres
diff --git a/example-specs/task/nipype/fsl/bet_callables.py b/example-specs/task/nipype/fsl/bet_callables.py
index 6dd47111..35014b16 100644
--- a/example-specs/task/nipype/fsl/bet_callables.py
+++ b/example-specs/task/nipype/fsl/bet_callables.py
@@ -1,11 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of BET.yaml"""
 
-import logging
-from pathlib import Path
-from glob import glob
-import os.path as op
 import attrs
 import os
+import os.path as op
+from glob import glob
+import logging
+from pathlib import Path
 
 
 def out_file_default(inputs):
@@ -99,6 +99,7 @@ def skull_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -136,6 +137,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -178,6 +180,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -228,6 +231,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
     Handle FSL ``output_type`` and version information.
@@ -320,6 +324,7 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
 def _gen_fname(
     basename,
     cwd=None,
@@ -375,6 +380,7 @@ def _gen_fname(
     return fname
 
 
+# Original source at L176 of <nipype-install>/interfaces/fsl/preprocess.py
 def _gen_outfilename(inputs=None, stdout=None, stderr=None, output_dir=None):
     out_file = inputs.out_file
     # Generate default output filename if non specified.
@@ -393,6 +399,7 @@ def _gen_outfilename(inputs=None, stdout=None, stderr=None, output_dir=None):
     return out_file
 
 
+# Original source at L232 of <nipype-install>/interfaces/fsl/preprocess.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "out_file":
         return _gen_outfilename(
@@ -401,6 +408,7 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     return None
 
 
+# Original source at L186 of <nipype-install>/interfaces/fsl/preprocess.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["out_file"] = os.path.abspath(
diff --git a/example-specs/task/nipype/fsl/binary_maths_callables.py b/example-specs/task/nipype/fsl/binary_maths_callables.py
index be3fdeea..0a6774f0 100644
--- a/example-specs/task/nipype/fsl/binary_maths_callables.py
+++ b/example-specs/task/nipype/fsl/binary_maths_callables.py
@@ -1,11 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of BinaryMaths.yaml"""
 
 from glob import glob
-import logging
-from pathlib import Path
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
+from pathlib import Path
 
 
 def out_file_default(inputs):
@@ -22,6 +22,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -59,6 +60,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -101,6 +103,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -151,6 +154,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
     Handle FSL ``output_type`` and version information.
@@ -243,6 +247,7 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
 def _gen_fname(
     basename,
     cwd=None,
@@ -298,6 +303,7 @@ def _gen_fname(
     return fname
 
 
+# Original source at L61 of <nipype-install>/interfaces/fsl/maths.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "out_file":
         return _list_outputs(
@@ -306,6 +312,7 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     return None
 
 
+# Original source at L51 of <nipype-install>/interfaces/fsl/maths.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["out_file"] = inputs.out_file
diff --git a/example-specs/task/nipype/fsl/change_data_type_callables.py b/example-specs/task/nipype/fsl/change_data_type_callables.py
index 4cc4ecfe..bc224338 100644
--- a/example-specs/task/nipype/fsl/change_data_type_callables.py
+++ b/example-specs/task/nipype/fsl/change_data_type_callables.py
@@ -1,11 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of ChangeDataType.yaml"""
 
 from glob import glob
-import logging
-from pathlib import Path
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
+from pathlib import Path
 
 
 def out_file_default(inputs):
@@ -22,6 +22,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -59,6 +60,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -101,6 +103,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -151,6 +154,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
     Handle FSL ``output_type`` and version information.
@@ -243,6 +247,7 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
 def _gen_fname(
     basename,
     cwd=None,
@@ -298,6 +303,7 @@ def _gen_fname(
     return fname
 
 
+# Original source at L61 of <nipype-install>/interfaces/fsl/maths.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "out_file":
         return _list_outputs(
@@ -306,6 +312,7 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     return None
 
 
+# Original source at L51 of <nipype-install>/interfaces/fsl/maths.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["out_file"] = inputs.out_file
diff --git a/example-specs/task/nipype/fsl/classifier_callables.py b/example-specs/task/nipype/fsl/classifier_callables.py
index 3402f70b..10b1f450 100644
--- a/example-specs/task/nipype/fsl/classifier_callables.py
+++ b/example-specs/task/nipype/fsl/classifier_callables.py
@@ -1,6 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of Classifier.yaml"""
 
 import os
+import attrs
 
 
 def artifacts_list_file_callable(output_dir, inputs, stdout, stderr):
@@ -10,10 +11,12 @@ def artifacts_list_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["artifacts_list_file"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L304 of <nipype-install>/interfaces/fsl/fix.py
 def _gen_artifacts_list_file(
     mel_ica, thresh, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -25,6 +28,7 @@ def _gen_artifacts_list_file(
     return fname
 
 
+# Original source at L312 of <nipype-install>/interfaces/fsl/fix.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["artifacts_list_file"] = _gen_artifacts_list_file(
diff --git a/example-specs/task/nipype/fsl/cleaner_callables.py b/example-specs/task/nipype/fsl/cleaner_callables.py
index f4f7c27e..637b1842 100644
--- a/example-specs/task/nipype/fsl/cleaner_callables.py
+++ b/example-specs/task/nipype/fsl/cleaner_callables.py
@@ -1,6 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of Cleaner.yaml"""
 
 import os
+import attrs
 
 
 def cleaned_functional_file_callable(output_dir, inputs, stdout, stderr):
@@ -10,10 +11,12 @@ def cleaned_functional_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["cleaned_functional_file"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L376 of <nipype-install>/interfaces/fsl/fix.py
 def _get_cleaned_functional_filename(
     artifacts_list_filename, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -27,6 +30,7 @@ def _get_cleaned_functional_filename(
     return os.path.join(artifacts_list_file_path, functional_filename + "_clean.nii.gz")
 
 
+# Original source at L388 of <nipype-install>/interfaces/fsl/fix.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["cleaned_functional_file"] = _get_cleaned_functional_filename(
diff --git a/example-specs/task/nipype/fsl/cluster_callables.py b/example-specs/task/nipype/fsl/cluster_callables.py
index 4145ddbc..0a414387 100644
--- a/example-specs/task/nipype/fsl/cluster_callables.py
+++ b/example-specs/task/nipype/fsl/cluster_callables.py
@@ -1,11 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of Cluster.yaml"""
 
 from glob import glob
-import logging
-from pathlib import Path
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
+from pathlib import Path
 
 
 def index_file_callable(output_dir, inputs, stdout, stderr):
@@ -67,6 +67,7 @@ def pval_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -104,6 +105,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -146,6 +148,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -196,6 +199,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
     Handle FSL ``output_type`` and version information.
@@ -288,6 +292,7 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
 def _gen_fname(
     basename,
     cwd=None,
@@ -343,10 +348,12 @@ def _gen_fname(
     return fname
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L2074 of <nipype-install>/interfaces/fsl/model.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     for key, suffix in list(filemap.items()):
diff --git a/example-specs/task/nipype/fsl/complex_callables.py b/example-specs/task/nipype/fsl/complex_callables.py
index bcae56c7..36d6d67c 100644
--- a/example-specs/task/nipype/fsl/complex_callables.py
+++ b/example-specs/task/nipype/fsl/complex_callables.py
@@ -1,11 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of Complex.yaml"""
 
 from glob import glob
-import logging
-from pathlib import Path
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
+from pathlib import Path
 
 
 def complex_out_file_default(inputs):
@@ -66,6 +66,7 @@ def complex_out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -103,6 +104,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -145,6 +147,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -195,6 +198,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
     Handle FSL ``output_type`` and version information.
@@ -287,6 +291,7 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
 def _gen_fname(
     basename,
     cwd=None,
@@ -342,6 +347,7 @@ def _gen_fname(
     return fname
 
 
+# Original source at L2052 of <nipype-install>/interfaces/fsl/utils.py
 def _get_output(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     output = getattr(inputs, name)
     if output is attrs.NOTHING:
@@ -351,6 +357,7 @@ def _get_output(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     return os.path.abspath(output)
 
 
+# Original source at L2031 of <nipype-install>/interfaces/fsl/utils.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "complex_out_file":
         if inputs.complex_cartesian:
@@ -408,6 +415,7 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     return None
 
 
+# Original source at L2058 of <nipype-install>/interfaces/fsl/utils.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     if (
diff --git a/example-specs/task/nipype/fsl/contrast_mgr_callables.py b/example-specs/task/nipype/fsl/contrast_mgr_callables.py
index b2aa487a..87f2bd88 100644
--- a/example-specs/task/nipype/fsl/contrast_mgr_callables.py
+++ b/example-specs/task/nipype/fsl/contrast_mgr_callables.py
@@ -1,11 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of ContrastMgr.yaml"""
 
 from glob import glob
-import logging
-from pathlib import Path
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
+from pathlib import Path
 
 
 def copes_callable(output_dir, inputs, stdout, stderr):
@@ -60,6 +60,7 @@ def neffs_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -97,6 +98,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -139,6 +141,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -189,6 +192,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
     Handle FSL ``output_type`` and version information.
@@ -281,6 +285,7 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
 def _gen_fname(
     basename,
     cwd=None,
@@ -336,10 +341,12 @@ def _gen_fname(
     return fname
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L1301 of <nipype-install>/interfaces/fsl/model.py
 def _get_numcons(inputs=None, stdout=None, stderr=None, output_dir=None):
     numtcons = 0
     numfcons = 0
@@ -360,6 +367,7 @@ def _get_numcons(inputs=None, stdout=None, stderr=None, output_dir=None):
     return numtcons, numfcons
 
 
+# Original source at L1320 of <nipype-install>/interfaces/fsl/model.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     pth, _ = os.path.split(inputs.sigmasquareds)
diff --git a/example-specs/task/nipype/fsl/convert_warp_callables.py b/example-specs/task/nipype/fsl/convert_warp_callables.py
index 2be5d54b..58058e5b 100644
--- a/example-specs/task/nipype/fsl/convert_warp_callables.py
+++ b/example-specs/task/nipype/fsl/convert_warp_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of ConvertWarp.yaml"""
 
-import logging
 from glob import glob
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -14,12 +14,13 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_file"]
 
 
-iflogger = logging.getLogger("nipype.interface")
+IFLOGGER = logging.getLogger("nipype.interface")
 
 
-IFLOGGER = logging.getLogger("nipype.interface")
+iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -57,6 +58,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
     Handle FSL ``output_type`` and version information.
@@ -149,12 +151,14 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
+# Original source at L249 of <nipype-install>/interfaces/fsl/base.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
     return value + Info.output_type_to_ext(inputs.output_type)
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -165,6 +169,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -215,6 +220,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -309,10 +315,12 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     metadata = dict(name_source=lambda t: t is not None)
     traits = inputs.traits(**metadata)
diff --git a/example-specs/task/nipype/fsl/convert_xfm_callables.py b/example-specs/task/nipype/fsl/convert_xfm_callables.py
index d4b6f501..840647a0 100644
--- a/example-specs/task/nipype/fsl/convert_xfm_callables.py
+++ b/example-specs/task/nipype/fsl/convert_xfm_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of ConvertXFM.yaml"""
 
-from pathlib import Path
+import os
 import os.path as op
+from pathlib import Path
 import attrs
-import os
 
 
 def out_file_default(inputs):
@@ -17,48 +17,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_file"]
 
 
-def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
-    """Manipulates path and name of input filename
-
-    Parameters
-    ----------
-    fname : string
-        A filename (may or may not include path)
-    prefix : string
-        Characters to prepend to the filename
-    suffix : string
-        Characters to append to the filename
-    newpath : string
-        Path to replace the path of the input fname
-    use_ext : boolean
-        If True (default), appends the extension of the original file
-        to the output name.
-
-    Returns
-    -------
-    Absolute path of the modified filename
-
-    >>> from nipype.utils.filemanip import fname_presuffix
-    >>> fname = 'foo.nii.gz'
-    >>> fname_presuffix(fname,'pre','post','/tmp')
-    '/tmp/prefoopost.nii.gz'
-
-    >>> from nipype.interfaces.base import attrs.NOTHING
-    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
-            fname_presuffix(fname, 'pre', 'post')
-    True
-
-    """
-    pth, fname, ext = split_filename(fname)
-    if not use_ext:
-        ext = ""
-
-    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
-    if newpath:
-        pth = op.abspath(newpath)
-    return op.join(pth, prefix + fname + suffix + ext)
-
-
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -109,6 +68,50 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+# Original source at L1592 of <nipype-install>/interfaces/fsl/utils.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "out_file":
         return _list_outputs(
@@ -117,6 +120,7 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     return None
 
 
+# Original source at L1567 of <nipype-install>/interfaces/fsl/utils.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outfile = inputs.out_file
diff --git a/example-specs/task/nipype/fsl/copy_geom_callables.py b/example-specs/task/nipype/fsl/copy_geom_callables.py
index bfa0c459..1d7e8a6f 100644
--- a/example-specs/task/nipype/fsl/copy_geom_callables.py
+++ b/example-specs/task/nipype/fsl/copy_geom_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of CopyGeom.yaml"""
 
-import logging
 from glob import glob
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -14,12 +14,13 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_file"]
 
 
-iflogger = logging.getLogger("nipype.interface")
+IFLOGGER = logging.getLogger("nipype.interface")
 
 
-IFLOGGER = logging.getLogger("nipype.interface")
+iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -57,6 +58,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
     Handle FSL ``output_type`` and version information.
@@ -149,12 +151,14 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
+# Original source at L249 of <nipype-install>/interfaces/fsl/base.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
     return value + Info.output_type_to_ext(inputs.output_type)
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -165,6 +169,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -215,6 +220,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -309,10 +315,12 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     metadata = dict(name_source=lambda t: t is not None)
     traits = inputs.traits(**metadata)
diff --git a/example-specs/task/nipype/fsl/dilate_image_callables.py b/example-specs/task/nipype/fsl/dilate_image_callables.py
index fc31d3cf..319edd93 100644
--- a/example-specs/task/nipype/fsl/dilate_image_callables.py
+++ b/example-specs/task/nipype/fsl/dilate_image_callables.py
@@ -1,11 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of DilateImage.yaml"""
 
 from glob import glob
-import logging
-from pathlib import Path
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
+from pathlib import Path
 
 
 def out_file_default(inputs):
@@ -22,6 +22,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -59,6 +60,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -101,6 +103,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -151,6 +154,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
     Handle FSL ``output_type`` and version information.
@@ -243,6 +247,7 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
 def _gen_fname(
     basename,
     cwd=None,
@@ -298,6 +303,7 @@ def _gen_fname(
     return fname
 
 
+# Original source at L61 of <nipype-install>/interfaces/fsl/maths.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "out_file":
         return _list_outputs(
@@ -306,6 +312,7 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     return None
 
 
+# Original source at L51 of <nipype-install>/interfaces/fsl/maths.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["out_file"] = inputs.out_file
diff --git a/example-specs/task/nipype/fsl/distance_map_callables.py b/example-specs/task/nipype/fsl/distance_map_callables.py
index 171c41c8..46ae75eb 100644
--- a/example-specs/task/nipype/fsl/distance_map_callables.py
+++ b/example-specs/task/nipype/fsl/distance_map_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of DistanceMap.yaml"""
 
-from pathlib import Path
+import os
 import os.path as op
+from pathlib import Path
 import attrs
-import os
 
 
 def distance_map_default(inputs):
@@ -24,6 +24,7 @@ def local_max_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["local_max_file"]
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -66,6 +67,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -116,6 +118,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L1537 of <nipype-install>/interfaces/fsl/dti.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "distance_map":
         return _list_outputs(
@@ -124,6 +127,7 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     return None
 
 
+# Original source at L1519 of <nipype-install>/interfaces/fsl/dti.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     _si = inputs
diff --git a/example-specs/task/nipype/fsl/dti_fit_callables.py b/example-specs/task/nipype/fsl/dti_fit_callables.py
index 65e73892..cd7f9ee6 100644
--- a/example-specs/task/nipype/fsl/dti_fit_callables.py
+++ b/example-specs/task/nipype/fsl/dti_fit_callables.py
@@ -1,11 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of DTIFit.yaml"""
 
 from glob import glob
-import logging
-from pathlib import Path
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
+from pathlib import Path
 
 
 def V1_callable(output_dir, inputs, stdout, stderr):
@@ -95,6 +95,7 @@ def sse_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -132,6 +133,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -174,6 +176,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -224,6 +227,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
     Handle FSL ``output_type`` and version information.
@@ -316,6 +320,7 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
 def _gen_fname(
     basename,
     cwd=None,
@@ -371,10 +376,12 @@ def _gen_fname(
     return fname
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L114 of <nipype-install>/interfaces/fsl/dti.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     keys_to_ignore = {"outputtype", "environ", "args"}
     # Optional output: Map output name to input flag
diff --git a/example-specs/task/nipype/fsl/dual_regression_callables.py b/example-specs/task/nipype/fsl/dual_regression_callables.py
index 75a4a0cb..341d74ec 100644
--- a/example-specs/task/nipype/fsl/dual_regression_callables.py
+++ b/example-specs/task/nipype/fsl/dual_regression_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of DualRegression.yaml"""
 
-import attrs
 import os
+import attrs
 
 
 def out_dir_default(inputs):
@@ -15,11 +15,13 @@ def out_dir_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_dir"]
 
 
+# Original source at L2198 of <nipype-install>/interfaces/fsl/model.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "out_dir":
         return output_dir
 
 
+# Original source at L2190 of <nipype-install>/interfaces/fsl/model.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     if inputs.out_dir is not attrs.NOTHING:
diff --git a/example-specs/task/nipype/fsl/eddy_callables.py b/example-specs/task/nipype/fsl/eddy_callables.py
index f1b30997..d38ccc25 100644
--- a/example-specs/task/nipype/fsl/eddy_callables.py
+++ b/example-specs/task/nipype/fsl/eddy_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of Eddy.yaml"""
 
-import attrs
 import os
+import attrs
 
 
 def out_corrected_callable(output_dir, inputs, stdout, stderr):
@@ -109,10 +109,12 @@ def out_residuals_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_residuals"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L1008 of <nipype-install>/interfaces/fsl/epi.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["out_corrected"] = os.path.abspath("%s.nii.gz" % inputs.out_base)
diff --git a/example-specs/task/nipype/fsl/eddy_correct_callables.py b/example-specs/task/nipype/fsl/eddy_correct_callables.py
index 74bba26e..965e4f1c 100644
--- a/example-specs/task/nipype/fsl/eddy_correct_callables.py
+++ b/example-specs/task/nipype/fsl/eddy_correct_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of EddyCorrect.yaml"""
 
-import logging
 from glob import glob
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
 
 
 def eddy_corrected_callable(output_dir, inputs, stdout, stderr):
@@ -14,12 +14,13 @@ def eddy_corrected_callable(output_dir, inputs, stdout, stderr):
     return outputs["eddy_corrected"]
 
 
-iflogger = logging.getLogger("nipype.interface")
+IFLOGGER = logging.getLogger("nipype.interface")
 
 
-IFLOGGER = logging.getLogger("nipype.interface")
+iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -57,6 +58,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
     Handle FSL ``output_type`` and version information.
@@ -149,12 +151,14 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
+# Original source at L249 of <nipype-install>/interfaces/fsl/base.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
     return value + Info.output_type_to_ext(inputs.output_type)
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -165,6 +169,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -215,6 +220,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -309,10 +315,12 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     metadata = dict(name_source=lambda t: t is not None)
     traits = inputs.traits(**metadata)
diff --git a/example-specs/task/nipype/fsl/eddy_quad_callables.py b/example-specs/task/nipype/fsl/eddy_quad_callables.py
index ee314728..de2f4937 100644
--- a/example-specs/task/nipype/fsl/eddy_quad_callables.py
+++ b/example-specs/task/nipype/fsl/eddy_quad_callables.py
@@ -1,7 +1,8 @@
 """Module to put any functions that are referred to in the "callables" section of EddyQuad.yaml"""
 
-import attrs
 import os
+from glob import glob
+import attrs
 
 
 def qc_json_callable(output_dir, inputs, stdout, stderr):
@@ -60,10 +61,12 @@ def clean_volumes_callable(output_dir, inputs, stdout, stderr):
     return outputs["clean_volumes"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L1673 of <nipype-install>/interfaces/fsl/epi.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     from glob import glob
 
diff --git a/example-specs/task/nipype/fsl/epi_de_warp_callables.py b/example-specs/task/nipype/fsl/epi_de_warp_callables.py
index 32bdbd89..abd37be7 100644
--- a/example-specs/task/nipype/fsl/epi_de_warp_callables.py
+++ b/example-specs/task/nipype/fsl/epi_de_warp_callables.py
@@ -1,11 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of EPIDeWarp.yaml"""
 
 from glob import glob
-import logging
-from pathlib import Path
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
+from pathlib import Path
 
 
 def vsm_default(inputs):
@@ -51,6 +51,7 @@ def exf_mask_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -88,6 +89,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -130,6 +132,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -180,6 +183,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
     Handle FSL ``output_type`` and version information.
@@ -272,6 +276,7 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
 def _gen_fname(
     basename,
     cwd=None,
@@ -327,6 +332,7 @@ def _gen_fname(
     return fname
 
 
+# Original source at L1428 of <nipype-install>/interfaces/fsl/epi.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "exfdw":
         if inputs.exf_file is not attrs.NOTHING:
@@ -365,6 +371,7 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     return None
 
 
+# Original source at L1443 of <nipype-install>/interfaces/fsl/epi.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     if inputs.exfdw is attrs.NOTHING:
diff --git a/example-specs/task/nipype/fsl/epi_reg_callables.py b/example-specs/task/nipype/fsl/epi_reg_callables.py
index eaa4a758..c50c7e4b 100644
--- a/example-specs/task/nipype/fsl/epi_reg_callables.py
+++ b/example-specs/task/nipype/fsl/epi_reg_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of EpiReg.yaml"""
 
-import attrs
 import os
+import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -102,10 +102,12 @@ def wmedge_callable(output_dir, inputs, stdout, stderr):
     return outputs["wmedge"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L1271 of <nipype-install>/interfaces/fsl/epi.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["out_file"] = os.path.join(output_dir, inputs.out_base + ".nii.gz")
diff --git a/example-specs/task/nipype/fsl/erode_image_callables.py b/example-specs/task/nipype/fsl/erode_image_callables.py
index 7da90653..bfefdc6d 100644
--- a/example-specs/task/nipype/fsl/erode_image_callables.py
+++ b/example-specs/task/nipype/fsl/erode_image_callables.py
@@ -1,11 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of ErodeImage.yaml"""
 
 from glob import glob
-import logging
-from pathlib import Path
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
+from pathlib import Path
 
 
 def out_file_default(inputs):
@@ -22,6 +22,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -59,6 +60,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -101,6 +103,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -151,6 +154,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
     Handle FSL ``output_type`` and version information.
@@ -243,6 +247,7 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
 def _gen_fname(
     basename,
     cwd=None,
@@ -298,6 +303,7 @@ def _gen_fname(
     return fname
 
 
+# Original source at L61 of <nipype-install>/interfaces/fsl/maths.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "out_file":
         return _list_outputs(
@@ -306,6 +312,7 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     return None
 
 
+# Original source at L51 of <nipype-install>/interfaces/fsl/maths.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["out_file"] = inputs.out_file
diff --git a/example-specs/task/nipype/fsl/extract_roi_callables.py b/example-specs/task/nipype/fsl/extract_roi_callables.py
index d551ef58..136e8997 100644
--- a/example-specs/task/nipype/fsl/extract_roi_callables.py
+++ b/example-specs/task/nipype/fsl/extract_roi_callables.py
@@ -1,11 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of ExtractROI.yaml"""
 
 from glob import glob
-import logging
-from pathlib import Path
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
+from pathlib import Path
 
 
 def roi_file_default(inputs):
@@ -22,6 +22,7 @@ def roi_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -59,6 +60,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -101,6 +103,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -151,6 +154,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
     Handle FSL ``output_type`` and version information.
@@ -243,6 +247,7 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
 def _gen_fname(
     basename,
     cwd=None,
@@ -298,6 +303,7 @@ def _gen_fname(
     return fname
 
 
+# Original source at L513 of <nipype-install>/interfaces/fsl/utils.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "roi_file":
         return _list_outputs(
@@ -306,6 +312,7 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     return None
 
 
+# Original source at L489 of <nipype-install>/interfaces/fsl/utils.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     """Create a Bunch which contains all possible files generated
     by running the interface.  Some files are always generated, others
diff --git a/example-specs/task/nipype/fsl/fast_callables.py b/example-specs/task/nipype/fsl/fast_callables.py
index e7836de6..95c21f76 100644
--- a/example-specs/task/nipype/fsl/fast_callables.py
+++ b/example-specs/task/nipype/fsl/fast_callables.py
@@ -1,11 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of FAST.yaml"""
 
 from glob import glob
-import logging
-from pathlib import Path
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
+from pathlib import Path
 
 
 def tissue_class_map_callable(output_dir, inputs, stdout, stderr):
@@ -67,6 +67,7 @@ def probability_maps_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -104,6 +105,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -146,56 +148,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
+# Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
     Handle FSL ``output_type`` and version information.
@@ -288,6 +241,7 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
 def _gen_fname(
     basename,
     cwd=None,
@@ -343,10 +297,12 @@ def _gen_fname(
     return fname
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -397,6 +353,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L401 of <nipype-install>/interfaces/fsl/preprocess.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     if inputs.number_classes is attrs.NOTHING:
diff --git a/example-specs/task/nipype/fsl/feat_callables.py b/example-specs/task/nipype/fsl/feat_callables.py
index acb17e86..f23bc0ca 100644
--- a/example-specs/task/nipype/fsl/feat_callables.py
+++ b/example-specs/task/nipype/fsl/feat_callables.py
@@ -1,7 +1,8 @@
 """Module to put any functions that are referred to in the "callables" section of FEAT.yaml"""
 
-from glob import glob
+import attrs
 import os
+from glob import glob
 
 
 def feat_dir_callable(output_dir, inputs, stdout, stderr):
@@ -11,10 +12,12 @@ def feat_dir_callable(output_dir, inputs, stdout, stderr):
     return outputs["feat_dir"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L465 of <nipype-install>/interfaces/fsl/model.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     is_ica = False
diff --git a/example-specs/task/nipype/fsl/feat_model_callables.py b/example-specs/task/nipype/fsl/feat_model_callables.py
index e139661e..14efa29c 100644
--- a/example-specs/task/nipype/fsl/feat_model_callables.py
+++ b/example-specs/task/nipype/fsl/feat_model_callables.py
@@ -1,13 +1,8 @@
 """Module to put any functions that are referred to in the "callables" section of FEATModel.yaml"""
 
-from fileformats.generic import Directory
-from traits.trait_errors import TraitError
-from pathlib import Path
-from fileformats.generic import File
-from glob import glob
-from traits.trait_type import TraitType
-from traits.trait_base import _Undefined
+import attrs
 import os
+from glob import glob
 
 
 def design_file_callable(output_dir, inputs, stdout, stderr):
@@ -45,289 +40,12 @@ def fcon_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["fcon_file"]
 
 
-Undefined = _Undefined()
-
-
-IMG_ZIP_FMT = set([".nii.gz", "tar.gz", ".gii.gz", ".mgz", ".mgh.gz", "img.gz"])
-
-
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
-class BasePath(TraitType):
-    """Defines a trait whose value must be a valid filesystem path."""
-
-    # A description of the type of value this trait accepts:
-    exists = False
-    resolve = False
-    _is_file = False
-    _is_dir = False
-
-    @property
-    def info_text(self):
-        """Create the trait's general description."""
-        info_text = "a pathlike object or string"
-        if any((self.exists, self._is_file, self._is_dir)):
-            info_text += " representing a"
-            if self.exists:
-                info_text += "n existing"
-            if self._is_file:
-                info_text += " file"
-            elif self._is_dir:
-                info_text += " directory"
-            else:
-                info_text += " file or directory"
-        return info_text
-
-    def __init__(self, value=attrs.NOTHING, exists=False, resolve=False, **metadata):
-        """Create a BasePath trait."""
-        self.exists = exists
-        self.resolve = resolve
-        super(BasePath, self).__init__(value, **metadata)
-
-    def validate(self, objekt, name, value, return_pathlike=False):
-        """Validate a value change."""
-        try:
-            value = Path(value)  # Use pathlib's validation
-        except Exception:
-            self.error(objekt, name, str(value))
-
-        if self.exists:
-            if not value.exists():
-                self.error(objekt, name, str(value))
-
-            if self._is_file and not value.is_file():
-                self.error(objekt, name, str(value))
-
-            if self._is_dir and not value.is_dir():
-                self.error(objekt, name, str(value))
-
-        if self.resolve:
-            value = path_resolve(value, strict=self.exists)
-
-        if not return_pathlike:
-            value = str(value)
-
-        return value
-
-
-class Directory(BasePath):
-    """
-    Defines a trait whose value must be a directory path.
-
-    >>> from nipype.interfaces.base import Directory, TraitedSpec, TraitError
-    >>> class A(TraitedSpec):
-    ...     foo = Directory(exists=False)
-    >>> a = A()
-    >>> a.foo
-    <undefined>
-
-    >>> a.foo = '/some/made/out/path'
-    >>> a.foo
-    '/some/made/out/path'
-
-    >>> class A(TraitedSpec):
-    ...     foo = Directory(exists=False, resolve=True)
-    >>> a = A(foo='relative_dir')
-    >>> a.foo  # doctest: +ELLIPSIS
-    '.../relative_dir'
-
-    >>> class A(TraitedSpec):
-    ...     foo = Directory(exists=True, resolve=True)
-    >>> a = A()
-    >>> a.foo = 'relative_dir'  # doctest: +IGNORE_EXCEPTION_DETAIL
-    Traceback (most recent call last):
-    TraitError:
-
-    >>> from os import mkdir
-    >>> mkdir('relative_dir')
-    >>> a.foo = 'relative_dir'
-    >>> a.foo  # doctest: +ELLIPSIS
-    '.../relative_dir'
-
-    >>> class A(TraitedSpec):
-    ...     foo = Directory(exists=True, resolve=False)
-    >>> a = A(foo='relative_dir')
-    >>> a.foo
-    'relative_dir'
-
-    >>> class A(TraitedSpec):
-    ...     foo = Directory('tmpdir')
-    >>> a = A()
-    >>> a.foo  # doctest: +ELLIPSIS
-    <undefined>
-
-    >>> class A(TraitedSpec):
-    ...     foo = Directory('tmpdir', usedefault=True)
-    >>> a = A()
-    >>> a.foo  # doctest: +ELLIPSIS
-    'tmpdir'
-
-    """
-
-    _is_dir = True
-
-
-class File(BasePath):
-    """
-    Defines a trait whose value must be a file path.
-
-    >>> from nipype.interfaces.base import File, TraitedSpec, TraitError
-    >>> class A(TraitedSpec):
-    ...     foo = File()
-    >>> a = A()
-    >>> a.foo
-    <undefined>
-
-    >>> a.foo = '/some/made/out/path/to/file'
-    >>> a.foo
-    '/some/made/out/path/to/file'
-
-    >>> class A(TraitedSpec):
-    ...     foo = File(exists=False, resolve=True)
-    >>> a = A(foo='idontexist.txt')
-    >>> a.foo  # doctest: +ELLIPSIS
-    '.../idontexist.txt'
-
-    >>> class A(TraitedSpec):
-    ...     foo = File(exists=True, resolve=True)
-    >>> a = A()
-    >>> a.foo = 'idontexist.txt'  # doctest: +IGNORE_EXCEPTION_DETAIL
-    Traceback (most recent call last):
-    TraitError:
-
-    >>> open('idoexist.txt', 'w').close()
-    >>> a.foo = 'idoexist.txt'
-    >>> a.foo  # doctest: +ELLIPSIS
-    '.../idoexist.txt'
-
-    >>> class A(TraitedSpec):
-    ...     foo = File('idoexist.txt')
-    >>> a = A()
-    >>> a.foo
-    <undefined>
-
-    >>> class A(TraitedSpec):
-    ...     foo = File('idoexist.txt', usedefault=True)
-    >>> a = A()
-    >>> a.foo
-    'idoexist.txt'
-
-    >>> class A(TraitedSpec):
-    ...     foo = File(exists=True, resolve=True, extensions=['.txt', 'txt.gz'])
-    >>> a = A()
-    >>> a.foo = 'idoexist.badtxt'  # doctest: +IGNORE_EXCEPTION_DETAIL
-    Traceback (most recent call last):
-    TraitError:
-
-    >>> a.foo = 'idoexist.txt'
-    >>> a.foo  # doctest: +ELLIPSIS
-    '.../idoexist.txt'
-
-    >>> class A(TraitedSpec):
-    ...     foo = File(extensions=['.nii', '.nii.gz'])
-    >>> a = A()
-    >>> a.foo = 'badext.txt'  # doctest: +IGNORE_EXCEPTION_DETAIL
-    Traceback (most recent call last):
-    TraitError:
-
-    >>> class A(TraitedSpec):
-    ...     foo = File(extensions=['.nii', '.nii.gz'])
-    >>> a = A()
-    >>> a.foo = 'goodext.nii'
-    >>> a.foo
-    'goodext.nii'
-
-    >>> a = A()
-    >>> a.foo = 'idontexist.000.nii'
-    >>> a.foo  # doctest: +ELLIPSIS
-    'idontexist.000.nii'
-
-    >>> a = A()
-    >>> a.foo = 'idontexist.000.nii.gz'
-    >>> a.foo  # doctest: +ELLIPSIS
-    'idontexist.000.nii.gz'
-
-    """
-
-    _is_file = True
-    _exts = None
-
-    def __init__(
-        self,
-        value=NoDefaultSpecified,
-        exists=False,
-        resolve=False,
-        allow_compressed=True,
-        extensions=None,
-        **metadata
-    ):
-        """Create a File trait."""
-        if extensions is not None:
-            if isinstance(extensions, (bytes, str)):
-                extensions = [extensions]
-
-            if allow_compressed is False:
-                extensions = list(set(extensions) - IMG_ZIP_FMT)
-
-            self._exts = sorted(
-                set(
-                    [
-                        ".%s" % ext if not ext.startswith(".") else ext
-                        for ext in extensions
-                    ]
-                )
-            )
-
-        super(File, self).__init__(
-            value=value,
-            exists=exists,
-            resolve=resolve,
-            extensions=self._exts,
-            **metadata
-        )
-
-    def validate(self, objekt, name, value, return_pathlike=False):
-        """Validate a value change."""
-        value = super(File, self).validate(objekt, name, value, return_pathlike=True)
-        if self._exts:
-            fname = value.name
-            if not any((fname.endswith(e) for e in self._exts)):
-                self.error(objekt, name, str(value))
-
-        if not return_pathlike:
-            value = str(value)
-
-        return value
-
-
-def _resolve_with_filenotfound(path, **kwargs):
-    """Raise FileNotFoundError instead of OSError"""
-    try:
-        return path.resolve(**kwargs)
-    except OSError as e:
-        if isinstance(e, FileNotFoundError):
-            raise
-        raise FileNotFoundError(str(path))
-
-
-def path_resolve(path, strict=False):
-    try:
-        return _resolve_with_filenotfound(path, strict=strict)
-    except TypeError:  # PY35
-        pass
-
-    path = path.absolute()
-    if strict or path.exists():
-        return _resolve_with_filenotfound(path)
-
-    # This is a hacky shortcut, using path.absolute() unmodified
-    # In cases where the existing part of the path contains a
-    # symlink, different results will be produced
-    return path
-
-
+# Original source at L530 of <nipype-install>/utils/filemanip.py
 def simplify_list(filelist):
     """Returns a list if filelist is a list of length greater than 1,
     otherwise returns the first element
@@ -338,57 +56,13 @@ def simplify_list(filelist):
         return filelist[0]
 
 
-class FEATOutputSpec(TraitedSpec):
-    feat_dir = Directory(exists=True)
-
-
-class FEATInputSpec(FSLCommandInputSpec):
-    fsf_file = File(
-        exists=True,
-        mandatory=True,
-        argstr="%s",
-        position=0,
-        desc="File specifying the feat design spec file",
-    )
-
-
-class FEAT(FSLCommand):
-    """Uses FSL feat to calculate first level stats"""
-
-    _cmd = "feat"
-    input_spec = FEATInputSpec
-    output_spec = FEATOutputSpec
-
-    def _list_outputs(self):
-        outputs = self._outputs().get()
-        is_ica = False
-        outputs["feat_dir"] = None
-        with open(self.inputs.fsf_file, "rt") as fp:
-            text = fp.read()
-            if "set fmri(inmelodic) 1" in text:
-                is_ica = True
-            for line in text.split("\n"):
-                if line.find("set fmri(outputdir)") > -1:
-                    try:
-                        outputdir_spec = line.split('"')[-2]
-                        if os.path.exists(outputdir_spec):
-                            outputs["feat_dir"] = outputdir_spec
-
-                    except:
-                        pass
-        if not outputs["feat_dir"]:
-            if is_ica:
-                outputs["feat_dir"] = glob(os.path.join(os.getcwd(), "*ica"))[0]
-            else:
-                outputs["feat_dir"] = glob(os.path.join(os.getcwd(), "*feat"))[0]
-        return outputs
-
-
+# Original source at L534 of <nipype-install>/interfaces/fsl/model.py
 def _get_design_root(infile, inputs=None, stdout=None, stderr=None, output_dir=None):
     _, fname = os.path.split(infile)
     return fname.split(".")[0]
 
 
+# Original source at L538 of <nipype-install>/interfaces/fsl/model.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     # TODO: figure out file names and get rid off the globs
     outputs = {}
diff --git a/example-specs/task/nipype/fsl/feature_extractor_callables.py b/example-specs/task/nipype/fsl/feature_extractor_callables.py
index 9a85e662..6ec12b08 100644
--- a/example-specs/task/nipype/fsl/feature_extractor_callables.py
+++ b/example-specs/task/nipype/fsl/feature_extractor_callables.py
@@ -1,5 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of FeatureExtractor.yaml"""
 
+import attrs
+
 
 def mel_ica_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
@@ -8,10 +10,12 @@ def mel_ica_callable(output_dir, inputs, stdout, stderr):
     return outputs["mel_ica"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L161 of <nipype-install>/interfaces/fsl/fix.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["mel_ica"] = inputs.mel_ica
diff --git a/example-specs/task/nipype/fsl/filmgls_callables.py b/example-specs/task/nipype/fsl/filmgls_callables.py
index 72bc72a1..8ca702d7 100644
--- a/example-specs/task/nipype/fsl/filmgls_callables.py
+++ b/example-specs/task/nipype/fsl/filmgls_callables.py
@@ -1,12 +1,12 @@
 """Module to put any functions that are referred to in the "callables" section of FILMGLS.yaml"""
 
-import logging
-from pathlib import Path
 from looseversion import LooseVersion
-from glob import glob
-import os.path as op
 import attrs
 import os
+import os.path as op
+from glob import glob
+import logging
+from pathlib import Path
 
 
 def param_estimates_callable(output_dir, inputs, stdout, stderr):
@@ -103,43 +103,7 @@ def zfstats_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
-
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
-
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
-
-            klass._version = klass.parse_version(raw_info)
-
-        return klass._version
-
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
-
-
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -182,6 +146,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -232,98 +197,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
-class Info(PackageInfo):
-    """
-    Handle FSL ``output_type`` and version information.
-
-    output type refers to the type of file fsl defaults to writing
-    eg, NIFTI, NIFTI_GZ
-
-    Examples
-    --------
-
-    >>> from nipype.interfaces.fsl import Info
-    >>> Info.version()  # doctest: +SKIP
-    >>> Info.output_type()  # doctest: +SKIP
-
-    """
-
-    ftypes = {
-        "NIFTI": ".nii",
-        "NIFTI_PAIR": ".img",
-        "NIFTI_GZ": ".nii.gz",
-        "NIFTI_PAIR_GZ": ".img.gz",
-    }
-
-    if os.getenv("FSLDIR"):
-        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
-
-    @staticmethod
-    def parse_version(raw_info):
-        return raw_info.splitlines()[0]
-
-    @classmethod
-    def output_type_to_ext(cls, output_type):
-        """Get the file extension for the given output type.
-
-        Parameters
-        ----------
-        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
-            String specifying the output type.
-
-        Returns
-        -------
-        extension : str
-            The file extension for the output type.
-        """
-
-        try:
-            return cls.ftypes[output_type]
-        except KeyError:
-            msg = "Invalid FSLOUTPUTTYPE: ", output_type
-            raise KeyError(msg)
-
-    @classmethod
-    def output_type(cls):
-        """Get the global FSL output file type FSLOUTPUTTYPE.
-
-        This returns the value of the environment variable
-        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
-
-        Returns
-        -------
-        fsl_ftype : string
-            Represents the current environment setting of FSLOUTPUTTYPE
-        """
-        try:
-            return os.environ["FSLOUTPUTTYPE"]
-        except KeyError:
-            IFLOGGER.warning(
-                "FSLOUTPUTTYPE environment variable is not set. "
-                "Setting FSLOUTPUTTYPE=NIFTI"
-            )
-            return "NIFTI"
-
-    @staticmethod
-    def standard_image(img_name=None):
-        """Grab an image from the standard location.
-
-        Returns a list of standard images if called without arguments.
-
-        Could be made more fancy to allow for more relocatability"""
-        try:
-            fsldir = os.environ["FSLDIR"]
-        except KeyError:
-            raise Exception("FSL environment variables not set")
-        stdpath = os.path.join(fsldir, "data", "standard")
-        if img_name is None:
-            return [
-                filename.replace(stdpath + "/", "")
-                for filename in glob(os.path.join(stdpath, "*nii*"))
-            ]
-        return os.path.join(stdpath, img_name)
-
-
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
 def _gen_fname(
     basename,
     cwd=None,
@@ -379,10 +253,12 @@ def _gen_fname(
     return fname
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -420,6 +296,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
     Handle FSL ``output_type`` and version information.
@@ -512,6 +389,7 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
+# Original source at L841 of <nipype-install>/interfaces/fsl/model.py
 def _get_numcons(inputs=None, stdout=None, stderr=None, output_dir=None):
     numtcons = 0
     numfcons = 0
@@ -532,6 +410,7 @@ def _get_numcons(inputs=None, stdout=None, stderr=None, output_dir=None):
     return numtcons, numfcons
 
 
+# Original source at L827 of <nipype-install>/interfaces/fsl/model.py
 def _get_pe_files(cwd, inputs=None, stdout=None, stderr=None, output_dir=None):
     files = None
     if inputs.design_file is not attrs.NOTHING:
@@ -556,6 +435,7 @@ def _get_pe_files(cwd, inputs=None, stdout=None, stderr=None, output_dir=None):
     return files
 
 
+# Original source at L860 of <nipype-install>/interfaces/fsl/model.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     cwd = output_dir
diff --git a/example-specs/task/nipype/fsl/filter_regressor_callables.py b/example-specs/task/nipype/fsl/filter_regressor_callables.py
index 7d643ec3..e525052f 100644
--- a/example-specs/task/nipype/fsl/filter_regressor_callables.py
+++ b/example-specs/task/nipype/fsl/filter_regressor_callables.py
@@ -1,11 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of FilterRegressor.yaml"""
 
 from glob import glob
-import logging
-from pathlib import Path
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
+from pathlib import Path
 
 
 def out_file_default(inputs):
@@ -22,6 +22,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -59,6 +60,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -101,6 +103,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -151,6 +154,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
     Handle FSL ``output_type`` and version information.
@@ -243,6 +247,7 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
 def _gen_fname(
     basename,
     cwd=None,
@@ -298,6 +303,7 @@ def _gen_fname(
     return fname
 
 
+# Original source at L731 of <nipype-install>/interfaces/fsl/utils.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "out_file":
         return _list_outputs(
@@ -306,6 +312,7 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     return None
 
 
+# Original source at L721 of <nipype-install>/interfaces/fsl/utils.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["out_file"] = inputs.out_file
diff --git a/example-specs/task/nipype/fsl/find_the_biggest_callables.py b/example-specs/task/nipype/fsl/find_the_biggest_callables.py
index 84be4958..87ccdee2 100644
--- a/example-specs/task/nipype/fsl/find_the_biggest_callables.py
+++ b/example-specs/task/nipype/fsl/find_the_biggest_callables.py
@@ -1,11 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of FindTheBiggest.yaml"""
 
 from glob import glob
-import logging
-from pathlib import Path
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
+from pathlib import Path
 
 
 def out_file_default(inputs):
@@ -22,6 +22,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -59,6 +60,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -101,6 +103,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -151,6 +154,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
     Handle FSL ``output_type`` and version information.
@@ -243,6 +247,7 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
 def _gen_fname(
     basename,
     cwd=None,
@@ -298,6 +303,7 @@ def _gen_fname(
     return fname
 
 
+# Original source at L1341 of <nipype-install>/interfaces/fsl/dti.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "out_file":
         return _list_outputs(
@@ -307,6 +313,7 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
         return None
 
 
+# Original source at L1333 of <nipype-install>/interfaces/fsl/dti.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["out_file"] = inputs.out_file
diff --git a/example-specs/task/nipype/fsl/first_callables.py b/example-specs/task/nipype/fsl/first_callables.py
index 711324a1..054d4f18 100644
--- a/example-specs/task/nipype/fsl/first_callables.py
+++ b/example-specs/task/nipype/fsl/first_callables.py
@@ -32,10 +32,12 @@ def segmentation_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["segmentation_file"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -86,6 +88,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L2279 of <nipype-install>/interfaces/fsl/preprocess.py
 def _gen_mesh_names(
     name, structures, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -105,6 +108,7 @@ def _gen_mesh_names(
     return None
 
 
+# Original source at L2259 of <nipype-install>/interfaces/fsl/preprocess.py
 def _gen_fname(basename, inputs=None, stdout=None, stderr=None, output_dir=None):
     path, outname, ext = split_filename(inputs.out_file)
 
@@ -126,6 +130,7 @@ def _gen_fname(basename, inputs=None, stdout=None, stderr=None, output_dir=None)
     return None
 
 
+# Original source at L2230 of <nipype-install>/interfaces/fsl/preprocess.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
 
diff --git a/example-specs/task/nipype/fsl/flameo_callables.py b/example-specs/task/nipype/fsl/flameo_callables.py
index b3e25f88..8d57d62b 100644
--- a/example-specs/task/nipype/fsl/flameo_callables.py
+++ b/example-specs/task/nipype/fsl/flameo_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of FLAMEO.yaml"""
 
 import re
+import os
 from glob import glob
 import attrs
-import os
 
 
 def pes_callable(output_dir, inputs, stdout, stderr):
@@ -90,10 +90,12 @@ def stats_dir_callable(output_dir, inputs, stdout, stderr):
     return outputs["stats_dir"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L19 of <nipype-install>/utils/misc.py
 def human_order_sorted(l):
     """Sorts string in human order (i.e. 'stat10' will go after 'stat2')"""
 
@@ -108,6 +110,7 @@ def natural_keys(text):
     return sorted(l, key=natural_keys)
 
 
+# Original source at L1143 of <nipype-install>/interfaces/fsl/model.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     pth = os.path.join(output_dir, inputs.log_dir)
diff --git a/example-specs/task/nipype/fsl/flirt_callables.py b/example-specs/task/nipype/fsl/flirt_callables.py
index 5328ef79..4304ab92 100644
--- a/example-specs/task/nipype/fsl/flirt_callables.py
+++ b/example-specs/task/nipype/fsl/flirt_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of FLIRT.yaml"""
 
-import logging
 from glob import glob
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -28,12 +28,13 @@ def out_log_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_log"]
 
 
-iflogger = logging.getLogger("nipype.interface")
+IFLOGGER = logging.getLogger("nipype.interface")
 
 
-IFLOGGER = logging.getLogger("nipype.interface")
+iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -71,6 +72,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
     Handle FSL ``output_type`` and version information.
@@ -163,12 +165,14 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
+# Original source at L249 of <nipype-install>/interfaces/fsl/base.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
     return value + Info.output_type_to_ext(inputs.output_type)
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -179,6 +183,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -229,6 +234,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -323,10 +329,12 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     metadata = dict(name_source=lambda t: t is not None)
     traits = inputs.traits(**metadata)
diff --git a/example-specs/task/nipype/fsl/fnirt_callables.py b/example-specs/task/nipype/fsl/fnirt_callables.py
index 2c84c963..76be5a6b 100644
--- a/example-specs/task/nipype/fsl/fnirt_callables.py
+++ b/example-specs/task/nipype/fsl/fnirt_callables.py
@@ -1,15 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of FNIRT.yaml"""
 
-import logging
-from traits.trait_errors import TraitError
-from pathlib import Path
-from fileformats.generic import File
-from glob import glob
-from traits.trait_type import TraitType
-from traits.trait_base import _Undefined
-import os.path as op
 import attrs
 import os
+import os.path as op
+from glob import glob
+import logging
+from pathlib import Path
 
 
 def warped_file_default(inputs):
@@ -69,52 +65,10 @@ def log_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["log_file"]
 
 
-Undefined = _Undefined()
-
-
-IMG_ZIP_FMT = set([".nii.gz", "tar.gz", ".gii.gz", ".mgz", ".mgh.gz", "img.gz"])
-
-
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
-
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
-
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
-
-            klass._version = klass.parse_version(raw_info)
-
-        return klass._version
-
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
-
-
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -157,6 +111,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -207,98 +162,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
-class Info(PackageInfo):
-    """
-    Handle FSL ``output_type`` and version information.
-
-    output type refers to the type of file fsl defaults to writing
-    eg, NIFTI, NIFTI_GZ
-
-    Examples
-    --------
-
-    >>> from nipype.interfaces.fsl import Info
-    >>> Info.version()  # doctest: +SKIP
-    >>> Info.output_type()  # doctest: +SKIP
-
-    """
-
-    ftypes = {
-        "NIFTI": ".nii",
-        "NIFTI_PAIR": ".img",
-        "NIFTI_GZ": ".nii.gz",
-        "NIFTI_PAIR_GZ": ".img.gz",
-    }
-
-    if os.getenv("FSLDIR"):
-        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
-
-    @staticmethod
-    def parse_version(raw_info):
-        return raw_info.splitlines()[0]
-
-    @classmethod
-    def output_type_to_ext(cls, output_type):
-        """Get the file extension for the given output type.
-
-        Parameters
-        ----------
-        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
-            String specifying the output type.
-
-        Returns
-        -------
-        extension : str
-            The file extension for the output type.
-        """
-
-        try:
-            return cls.ftypes[output_type]
-        except KeyError:
-            msg = "Invalid FSLOUTPUTTYPE: ", output_type
-            raise KeyError(msg)
-
-    @classmethod
-    def output_type(cls):
-        """Get the global FSL output file type FSLOUTPUTTYPE.
-
-        This returns the value of the environment variable
-        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
-
-        Returns
-        -------
-        fsl_ftype : string
-            Represents the current environment setting of FSLOUTPUTTYPE
-        """
-        try:
-            return os.environ["FSLOUTPUTTYPE"]
-        except KeyError:
-            IFLOGGER.warning(
-                "FSLOUTPUTTYPE environment variable is not set. "
-                "Setting FSLOUTPUTTYPE=NIFTI"
-            )
-            return "NIFTI"
-
-    @staticmethod
-    def standard_image(img_name=None):
-        """Grab an image from the standard location.
-
-        Returns a list of standard images if called without arguments.
-
-        Could be made more fancy to allow for more relocatability"""
-        try:
-            fsldir = os.environ["FSLDIR"]
-        except KeyError:
-            raise Exception("FSL environment variables not set")
-        stdpath = os.path.join(fsldir, "data", "standard")
-        if img_name is None:
-            return [
-                filename.replace(stdpath + "/", "")
-                for filename in glob(os.path.join(stdpath, "*nii*"))
-            ]
-        return os.path.join(stdpath, img_name)
-
-
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
 def _gen_fname(
     basename,
     cwd=None,
@@ -354,6 +218,7 @@ def _gen_fname(
     return fname
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -391,6 +256,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
     Handle FSL ``output_type`` and version information.
@@ -483,622 +349,21 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
-class BasePath(TraitType):
-    """Defines a trait whose value must be a valid filesystem path."""
-
-    # A description of the type of value this trait accepts:
-    exists = False
-    resolve = False
-    _is_file = False
-    _is_dir = False
-
-    @property
-    def info_text(self):
-        """Create the trait's general description."""
-        info_text = "a pathlike object or string"
-        if any((self.exists, self._is_file, self._is_dir)):
-            info_text += " representing a"
-            if self.exists:
-                info_text += "n existing"
-            if self._is_file:
-                info_text += " file"
-            elif self._is_dir:
-                info_text += " directory"
-            else:
-                info_text += " file or directory"
-        return info_text
-
-    def __init__(self, value=attrs.NOTHING, exists=False, resolve=False, **metadata):
-        """Create a BasePath trait."""
-        self.exists = exists
-        self.resolve = resolve
-        super(BasePath, self).__init__(value, **metadata)
-
-    def validate(self, objekt, name, value, return_pathlike=False):
-        """Validate a value change."""
-        try:
-            value = Path(value)  # Use pathlib's validation
-        except Exception:
-            self.error(objekt, name, str(value))
-
-        if self.exists:
-            if not value.exists():
-                self.error(objekt, name, str(value))
-
-            if self._is_file and not value.is_file():
-                self.error(objekt, name, str(value))
-
-            if self._is_dir and not value.is_dir():
-                self.error(objekt, name, str(value))
-
-        if self.resolve:
-            value = path_resolve(value, strict=self.exists)
-
-        if not return_pathlike:
-            value = str(value)
-
-        return value
-
-
-class File(BasePath):
-    """
-    Defines a trait whose value must be a file path.
-
-    >>> from nipype.interfaces.base import File, TraitedSpec, TraitError
-    >>> class A(TraitedSpec):
-    ...     foo = File()
-    >>> a = A()
-    >>> a.foo
-    <undefined>
-
-    >>> a.foo = '/some/made/out/path/to/file'
-    >>> a.foo
-    '/some/made/out/path/to/file'
-
-    >>> class A(TraitedSpec):
-    ...     foo = File(exists=False, resolve=True)
-    >>> a = A(foo='idontexist.txt')
-    >>> a.foo  # doctest: +ELLIPSIS
-    '.../idontexist.txt'
-
-    >>> class A(TraitedSpec):
-    ...     foo = File(exists=True, resolve=True)
-    >>> a = A()
-    >>> a.foo = 'idontexist.txt'  # doctest: +IGNORE_EXCEPTION_DETAIL
-    Traceback (most recent call last):
-    TraitError:
-
-    >>> open('idoexist.txt', 'w').close()
-    >>> a.foo = 'idoexist.txt'
-    >>> a.foo  # doctest: +ELLIPSIS
-    '.../idoexist.txt'
-
-    >>> class A(TraitedSpec):
-    ...     foo = File('idoexist.txt')
-    >>> a = A()
-    >>> a.foo
-    <undefined>
-
-    >>> class A(TraitedSpec):
-    ...     foo = File('idoexist.txt', usedefault=True)
-    >>> a = A()
-    >>> a.foo
-    'idoexist.txt'
-
-    >>> class A(TraitedSpec):
-    ...     foo = File(exists=True, resolve=True, extensions=['.txt', 'txt.gz'])
-    >>> a = A()
-    >>> a.foo = 'idoexist.badtxt'  # doctest: +IGNORE_EXCEPTION_DETAIL
-    Traceback (most recent call last):
-    TraitError:
-
-    >>> a.foo = 'idoexist.txt'
-    >>> a.foo  # doctest: +ELLIPSIS
-    '.../idoexist.txt'
-
-    >>> class A(TraitedSpec):
-    ...     foo = File(extensions=['.nii', '.nii.gz'])
-    >>> a = A()
-    >>> a.foo = 'badext.txt'  # doctest: +IGNORE_EXCEPTION_DETAIL
-    Traceback (most recent call last):
-    TraitError:
-
-    >>> class A(TraitedSpec):
-    ...     foo = File(extensions=['.nii', '.nii.gz'])
-    >>> a = A()
-    >>> a.foo = 'goodext.nii'
-    >>> a.foo
-    'goodext.nii'
-
-    >>> a = A()
-    >>> a.foo = 'idontexist.000.nii'
-    >>> a.foo  # doctest: +ELLIPSIS
-    'idontexist.000.nii'
-
-    >>> a = A()
-    >>> a.foo = 'idontexist.000.nii.gz'
-    >>> a.foo  # doctest: +ELLIPSIS
-    'idontexist.000.nii.gz'
-
-    """
-
-    _is_file = True
-    _exts = None
-
-    def __init__(
-        self,
-        value=NoDefaultSpecified,
-        exists=False,
-        resolve=False,
-        allow_compressed=True,
-        extensions=None,
-        **metadata
-    ):
-        """Create a File trait."""
-        if extensions is not None:
-            if isinstance(extensions, (bytes, str)):
-                extensions = [extensions]
-
-            if allow_compressed is False:
-                extensions = list(set(extensions) - IMG_ZIP_FMT)
-
-            self._exts = sorted(
-                set(
-                    [
-                        ".%s" % ext if not ext.startswith(".") else ext
-                        for ext in extensions
-                    ]
-                )
-            )
-
-        super(File, self).__init__(
-            value=value,
-            exists=exists,
-            resolve=resolve,
-            extensions=self._exts,
-            **metadata
-        )
-
-    def validate(self, objekt, name, value, return_pathlike=False):
-        """Validate a value change."""
-        value = super(File, self).validate(objekt, name, value, return_pathlike=True)
-        if self._exts:
-            fname = value.name
-            if not any((fname.endswith(e) for e in self._exts)):
-                self.error(objekt, name, str(value))
-
-        if not return_pathlike:
-            value = str(value)
-
-        return value
-
-
-def path_resolve(path, strict=False):
-    try:
-        return _resolve_with_filenotfound(path, strict=strict)
-    except TypeError:  # PY35
-        pass
-
-    path = path.absolute()
-    if strict or path.exists():
-        return _resolve_with_filenotfound(path)
-
-    # This is a hacky shortcut, using path.absolute() unmodified
-    # In cases where the existing part of the path contains a
-    # symlink, different results will be produced
-    return path
-
-
-def _resolve_with_filenotfound(path, **kwargs):
-    """Raise FileNotFoundError instead of OSError"""
-    try:
-        return path.resolve(**kwargs)
-    except OSError as e:
-        if isinstance(e, FileNotFoundError):
-            raise
-        raise FileNotFoundError(str(path))
-
-
-class FNIRTOutputSpec(TraitedSpec):
-    fieldcoeff_file = File(exists=True, desc="file with field coefficients")
-    warped_file = File(exists=True, desc="warped image")
-    field_file = File(desc="file with warp field")
-    jacobian_file = File(desc="file containing Jacobian of the field")
-    modulatedref_file = File(desc="file containing intensity modulated --ref")
-    out_intensitymap_file = traits.List(
-        File,
-        minlen=2,
-        maxlen=2,
-        desc="files containing info pertaining to intensity mapping",
-    )
-    log_file = File(desc="Name of log-file")
-
-
-class FNIRTInputSpec(FSLCommandInputSpec):
-    ref_file = File(
-        exists=True, argstr="--ref=%s", mandatory=True, desc="name of reference image"
-    )
-    in_file = File(
-        exists=True, argstr="--in=%s", mandatory=True, desc="name of input image"
-    )
-    affine_file = File(
-        exists=True, argstr="--aff=%s", desc="name of file containing affine transform"
-    )
-    inwarp_file = File(
-        exists=True,
-        argstr="--inwarp=%s",
-        desc="name of file containing initial non-linear warps",
-    )
-    in_intensitymap_file = traits.List(
-        File(exists=True),
-        argstr="--intin=%s",
-        copyfile=False,
-        minlen=1,
-        maxlen=2,
-        desc=(
-            "name of file/files containing "
-            "initial intensity mapping "
-            "usually generated by previous "
-            "fnirt run"
-        ),
-    )
-    fieldcoeff_file = traits.Either(
-        traits.Bool,
-        File,
-        argstr="--cout=%s",
-        desc="name of output file with field coefficients or true",
-    )
-    warped_file = File(
-        argstr="--iout=%s", desc="name of output image", genfile=True, hash_files=False
-    )
-    field_file = traits.Either(
-        traits.Bool,
-        File,
-        argstr="--fout=%s",
-        desc="name of output file with field or true",
-        hash_files=False,
-    )
-    jacobian_file = traits.Either(
-        traits.Bool,
-        File,
-        argstr="--jout=%s",
-        desc=(
-            "name of file for writing out the "
-            "Jacobian of the field (for "
-            "diagnostic or VBM purposes)"
-        ),
-        hash_files=False,
-    )
-    modulatedref_file = traits.Either(
-        traits.Bool,
-        File,
-        argstr="--refout=%s",
-        desc=(
-            "name of file for writing out "
-            "intensity modulated --ref (for "
-            "diagnostic purposes)"
-        ),
-        hash_files=False,
-    )
-    out_intensitymap_file = traits.Either(
-        traits.Bool,
-        File,
-        argstr="--intout=%s",
-        desc=(
-            "name of files for writing "
-            "information pertaining to "
-            "intensity mapping"
-        ),
-        hash_files=False,
-    )
-    log_file = File(
-        argstr="--logout=%s", desc="Name of log-file", genfile=True, hash_files=False
-    )
-    config_file = traits.Either(
-        traits.Enum("T1_2_MNI152_2mm", "FA_2_FMRIB58_1mm"),
-        File(exists=True),
-        argstr="--config=%s",
-        desc="Name of config file specifying command line arguments",
-    )
-    refmask_file = File(
-        exists=True,
-        argstr="--refmask=%s",
-        desc="name of file with mask in reference space",
-    )
-    inmask_file = File(
-        exists=True,
-        argstr="--inmask=%s",
-        desc="name of file with mask in input image space",
-    )
-    skip_refmask = traits.Bool(
-        argstr="--applyrefmask=0",
-        xor=["apply_refmask"],
-        desc="Skip specified refmask if set, default false",
-    )
-    skip_inmask = traits.Bool(
-        argstr="--applyinmask=0",
-        xor=["apply_inmask"],
-        desc="skip specified inmask if set, default false",
-    )
-    apply_refmask = traits.List(
-        traits.Enum(0, 1),
-        argstr="--applyrefmask=%s",
-        xor=["skip_refmask"],
-        desc=("list of iterations to use reference mask on (1 to use, 0 to " "skip)"),
-        sep=",",
-    )
-    apply_inmask = traits.List(
-        traits.Enum(0, 1),
-        argstr="--applyinmask=%s",
-        xor=["skip_inmask"],
-        desc="list of iterations to use input mask on (1 to use, 0 to skip)",
-        sep=",",
-    )
-    skip_implicit_ref_masking = traits.Bool(
-        argstr="--imprefm=0",
-        desc=("skip implicit masking  based on value in --ref image. " "Default = 0"),
-    )
-    skip_implicit_in_masking = traits.Bool(
-        argstr="--impinm=0",
-        desc=("skip implicit masking  based on value in --in image. " "Default = 0"),
-    )
-    refmask_val = traits.Float(
-        argstr="--imprefval=%f", desc="Value to mask out in --ref image. Default =0.0"
-    )
-    inmask_val = traits.Float(
-        argstr="--impinval=%f", desc="Value to mask out in --in image. Default =0.0"
-    )
-    max_nonlin_iter = traits.List(
-        traits.Int,
-        argstr="--miter=%s",
-        desc="Max # of non-linear iterations list, default [5, 5, 5, 5]",
-        sep=",",
-    )
-    subsampling_scheme = traits.List(
-        traits.Int,
-        argstr="--subsamp=%s",
-        desc="sub-sampling scheme, list, default [4, 2, 1, 1]",
-        sep=",",
-    )
-    warp_resolution = traits.Tuple(
-        traits.Int,
-        traits.Int,
-        traits.Int,
-        argstr="--warpres=%d,%d,%d",
-        desc=(
-            "(approximate) resolution (in mm) of warp basis in x-, y- and "
-            "z-direction, default 10, 10, 10"
-        ),
-    )
-    spline_order = traits.Int(
-        argstr="--splineorder=%d",
-        desc="Order of spline, 2->Qadratic spline, 3->Cubic spline. Default=3",
-    )
-    in_fwhm = traits.List(
-        traits.Int,
-        argstr="--infwhm=%s",
-        desc=(
-            "FWHM (in mm) of gaussian smoothing kernel for input volume, "
-            "default [6, 4, 2, 2]"
-        ),
-        sep=",",
-    )
-    ref_fwhm = traits.List(
-        traits.Int,
-        argstr="--reffwhm=%s",
-        desc=(
-            "FWHM (in mm) of gaussian smoothing kernel for ref volume, "
-            "default [4, 2, 0, 0]"
-        ),
-        sep=",",
-    )
-    regularization_model = traits.Enum(
-        "membrane_energy",
-        "bending_energy",
-        argstr="--regmod=%s",
-        desc=(
-            "Model for regularisation of warp-field [membrane_energy "
-            "bending_energy], default bending_energy"
-        ),
-    )
-    regularization_lambda = traits.List(
-        traits.Float,
-        argstr="--lambda=%s",
-        desc=(
-            "Weight of regularisation, default depending on --ssqlambda and "
-            "--regmod switches. See user documentation."
-        ),
-        sep=",",
-    )
-    skip_lambda_ssq = traits.Bool(
-        argstr="--ssqlambda=0",
-        desc="If true, lambda is not weighted by current ssq, default false",
-    )
-    jacobian_range = traits.Tuple(
-        traits.Float,
-        traits.Float,
-        argstr="--jacrange=%f,%f",
-        desc="Allowed range of Jacobian determinants, default 0.01, 100.0",
-    )
-    derive_from_ref = traits.Bool(
-        argstr="--refderiv",
-        desc=("If true, ref image is used to calculate derivatives. " "Default false"),
-    )
-    intensity_mapping_model = traits.Enum(
-        "none",
-        "global_linear",
-        "global_non_linear",
-        "local_linear",
-        "global_non_linear_with_bias",
-        "local_non_linear",
-        argstr="--intmod=%s",
-        desc="Model for intensity-mapping",
-    )
-    intensity_mapping_order = traits.Int(
-        argstr="--intorder=%d",
-        desc="Order of poynomial for mapping intensities, default 5",
-    )
-    biasfield_resolution = traits.Tuple(
-        traits.Int,
-        traits.Int,
-        traits.Int,
-        argstr="--biasres=%d,%d,%d",
-        desc=(
-            "Resolution (in mm) of bias-field modelling local intensities, "
-            "default 50, 50, 50"
-        ),
-    )
-    bias_regularization_lambda = traits.Float(
-        argstr="--biaslambda=%f",
-        desc="Weight of regularisation for bias-field, default 10000",
-    )
-    skip_intensity_mapping = traits.Bool(
-        argstr="--estint=0",
-        xor=["apply_intensity_mapping"],
-        desc="Skip estimate intensity-mapping default false",
-    )
-    apply_intensity_mapping = traits.List(
-        traits.Enum(0, 1),
-        argstr="--estint=%s",
-        xor=["skip_intensity_mapping"],
-        desc=(
-            "List of subsampling levels to apply intensity mapping for "
-            "(0 to skip, 1 to apply)"
-        ),
-        sep=",",
-    )
-    hessian_precision = traits.Enum(
-        "double",
-        "float",
-        argstr="--numprec=%s",
-        desc=("Precision for representing Hessian, double or float. " "Default double"),
-    )
-
-
-class FNIRT(FSLCommand):
-    """FSL FNIRT wrapper for non-linear registration
-
-    For complete details, see the `FNIRT Documentation.
-    <https://fsl.fmrib.ox.ac.uk/fsl/fslwiki/FNIRT>`_
-
-    Examples
-    --------
-    >>> from nipype.interfaces import fsl
-    >>> from nipype.testing import example_data
-    >>> fnt = fsl.FNIRT(affine_file=example_data('trans.mat'))
-    >>> res = fnt.run(ref_file=example_data('mni.nii', in_file=example_data('structural.nii')) #doctest: +SKIP
-
-    T1 -> Mni153
-
-    >>> from nipype.interfaces import fsl
-    >>> fnirt_mprage = fsl.FNIRT()
-    >>> fnirt_mprage.inputs.in_fwhm = [8, 4, 2, 2]
-    >>> fnirt_mprage.inputs.subsampling_scheme = [4, 2, 1, 1]
-
-    Specify the resolution of the warps
-
-    >>> fnirt_mprage.inputs.warp_resolution = (6, 6, 6)
-    >>> res = fnirt_mprage.run(in_file='structural.nii', ref_file='mni.nii', warped_file='warped.nii', fieldcoeff_file='fieldcoeff.nii')#doctest: +SKIP
-
-    We can check the command line and confirm that it's what we expect.
-
-    >>> fnirt_mprage.cmdline  #doctest: +SKIP
-    'fnirt --cout=fieldcoeff.nii --in=structural.nii --infwhm=8,4,2,2 --ref=mni.nii --subsamp=4,2,1,1 --warpres=6,6,6 --iout=warped.nii'
-
+# Original source at L1364 of <nipype-install>/interfaces/fsl/preprocess.py
+def intensitymap_file_basename(
+    f, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    """Removes valid intensitymap extensions from `f`, returning a basename
+    that can refer to both intensitymap files.
     """
-
-    _cmd = "fnirt"
-    input_spec = FNIRTInputSpec
-    output_spec = FNIRTOutputSpec
-
-    filemap = {
-        "warped_file": "warped",
-        "field_file": "field",
-        "jacobian_file": "field_jacobian",
-        "modulatedref_file": "modulated",
-        "out_intensitymap_file": "intmap",
-        "log_file": "log.txt",
-        "fieldcoeff_file": "fieldwarp",
-    }
-
-    def _list_outputs(self):
-        outputs = self.output_spec().get()
-        for key, suffix in list(self.filemap.items()):
-            inval = getattr(self.inputs, key)
-            change_ext = True
-            if key in ["warped_file", "log_file"]:
-                if suffix.endswith(".txt"):
-                    change_ext = False
-                if inval is not attrs.NOTHING:
-                    outputs[key] = os.path.abspath(inval)
-                else:
-                    outputs[key] = self._gen_fname(
-                        self.inputs.in_file, suffix="_" + suffix, change_ext=change_ext
-                    )
-            elif inval is not attrs.NOTHING:
-                if isinstance(inval, bool):
-                    if inval:
-                        outputs[key] = self._gen_fname(
-                            self.inputs.in_file,
-                            suffix="_" + suffix,
-                            change_ext=change_ext,
-                        )
-                else:
-                    outputs[key] = os.path.abspath(inval)
-
-            if key == "out_intensitymap_file" and (outputs[key] is not attrs.NOTHING):
-                basename = FNIRT.intensitymap_file_basename(outputs[key])
-                outputs[key] = [outputs[key], "%s.txt" % basename]
-        return outputs
-
-    def _format_arg(self, name, spec, value):
-        if name in ("in_intensitymap_file", "out_intensitymap_file"):
-            if name == "out_intensitymap_file":
-                value = self._list_outputs()[name]
-            value = [FNIRT.intensitymap_file_basename(v) for v in value]
-            assert len(set(value)) == 1, "Found different basenames for {}: {}".format(
-                name, value
-            )
-            return spec.argstr % value[0]
-        if name in list(self.filemap.keys()):
-            return spec.argstr % self._list_outputs()[name]
-        return super(FNIRT, self)._format_arg(name, spec, value)
-
-    def _gen_filename(self, name):
-        if name in ["warped_file", "log_file"]:
-            return self._list_outputs()[name]
-        return None
-
-    def write_config(self, configfile):
-        """Writes out currently set options to specified config file
-
-        XX TODO : need to figure out how the config file is written
-
-        Parameters
-        ----------
-        configfile : /path/to/configfile
-        """
-        try:
-            fid = open(configfile, "w+")
-        except IOError:
-            print("unable to create config_file %s" % (configfile))
-
-        for item in list(self.inputs.get().items()):
-            fid.write("%s\n" % (item))
-        fid.close()
-
-    @classmethod
-    def intensitymap_file_basename(cls, f):
-        """Removes valid intensitymap extensions from `f`, returning a basename
-        that can refer to both intensitymap files.
-        """
-        for ext in list(Info.ftypes.values()) + [".txt"]:
-            if f.endswith(ext):
-                return f[: -len(ext)]
-        # TODO consider warning for this case
-        return f
+    for ext in list(Info.ftypes.values()) + [".txt"]:
+        if f.endswith(ext):
+            return f[: -len(ext)]
+    # TODO consider warning for this case
+    return f
 
 
+# Original source at L1341 of <nipype-install>/interfaces/fsl/preprocess.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name in ["warped_file", "log_file"]:
         return _list_outputs(
@@ -1107,6 +372,7 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     return None
 
 
+# Original source at L1298 of <nipype-install>/interfaces/fsl/preprocess.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     for key, suffix in list(filemap.items()):
@@ -1143,6 +409,12 @@ def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
                 outputs[key] = os.path.abspath(inval)
 
         if key == "out_intensitymap_file" and (outputs[key] is not attrs.NOTHING):
-            basename = FNIRT.intensitymap_file_basename(outputs[key])
+            basename = intensitymap_file_basename(
+                outputs[key],
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
             outputs[key] = [outputs[key], "%s.txt" % basename]
     return outputs
diff --git a/example-specs/task/nipype/fsl/fugue_callables.py b/example-specs/task/nipype/fsl/fugue_callables.py
index 99be751c..03d3a6fa 100644
--- a/example-specs/task/nipype/fsl/fugue_callables.py
+++ b/example-specs/task/nipype/fsl/fugue_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of FUGUE.yaml"""
 
-import logging
 from glob import glob
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
 
 
 def unwarped_file_callable(output_dir, inputs, stdout, stderr):
@@ -35,12 +35,13 @@ def fmap_out_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["fmap_out_file"]
 
 
-iflogger = logging.getLogger("nipype.interface")
+IFLOGGER = logging.getLogger("nipype.interface")
 
 
-IFLOGGER = logging.getLogger("nipype.interface")
+iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -78,6 +79,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
     Handle FSL ``output_type`` and version information.
@@ -170,12 +172,14 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
+# Original source at L249 of <nipype-install>/interfaces/fsl/base.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
     return value + Info.output_type_to_ext(inputs.output_type)
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -186,6 +190,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -236,6 +241,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -330,10 +336,12 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     metadata = dict(name_source=lambda t: t is not None)
     traits = inputs.traits(**metadata)
diff --git a/example-specs/task/nipype/fsl/glm_callables.py b/example-specs/task/nipype/fsl/glm_callables.py
index faf428f7..90a73179 100644
--- a/example-specs/task/nipype/fsl/glm_callables.py
+++ b/example-specs/task/nipype/fsl/glm_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of GLM.yaml"""
 
-import logging
 from glob import glob
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -91,12 +91,13 @@ def out_vnscales_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_vnscales"]
 
 
-iflogger = logging.getLogger("nipype.interface")
+IFLOGGER = logging.getLogger("nipype.interface")
 
 
-IFLOGGER = logging.getLogger("nipype.interface")
+iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -134,6 +135,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
     Handle FSL ``output_type`` and version information.
@@ -226,12 +228,14 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
+# Original source at L249 of <nipype-install>/interfaces/fsl/base.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
     return value + Info.output_type_to_ext(inputs.output_type)
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -242,6 +246,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -292,6 +297,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -386,6 +392,7 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_fsl__FSLCommand___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -405,10 +412,12 @@ def nipype_interfaces_fsl__FSLCommand___list_outputs(
         return outputs
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L2511 of <nipype-install>/interfaces/fsl/model.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = nipype_interfaces_fsl__FSLCommand___list_outputs()
 
diff --git a/example-specs/task/nipype/fsl/ica__aroma_callables.py b/example-specs/task/nipype/fsl/ica__aroma_callables.py
index 88339edb..2a2c7157 100644
--- a/example-specs/task/nipype/fsl/ica__aroma_callables.py
+++ b/example-specs/task/nipype/fsl/ica__aroma_callables.py
@@ -1,6 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of ICA_AROMA.yaml"""
 
 import os
+import attrs
 
 
 def aggr_denoised_file_callable(output_dir, inputs, stdout, stderr):
@@ -24,10 +25,12 @@ def out_dir_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_dir"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L151 of <nipype-install>/interfaces/fsl/aroma.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["out_dir"] = os.path.abspath(inputs.out_dir)
diff --git a/example-specs/task/nipype/fsl/image_maths_callables.py b/example-specs/task/nipype/fsl/image_maths_callables.py
index 9fced413..370aa5c7 100644
--- a/example-specs/task/nipype/fsl/image_maths_callables.py
+++ b/example-specs/task/nipype/fsl/image_maths_callables.py
@@ -1,11 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of ImageMaths.yaml"""
 
 from glob import glob
-import logging
-from pathlib import Path
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
+from pathlib import Path
 
 
 def out_file_default(inputs):
@@ -22,6 +22,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -59,6 +60,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -101,6 +103,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -151,6 +154,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
     Handle FSL ``output_type`` and version information.
@@ -243,6 +247,7 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
 def _gen_fname(
     basename,
     cwd=None,
@@ -298,6 +303,7 @@ def _gen_fname(
     return fname
 
 
+# Original source at L627 of <nipype-install>/interfaces/fsl/utils.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "out_file":
         return _list_outputs(
@@ -306,6 +312,7 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     return None
 
 
+# Original source at L635 of <nipype-install>/interfaces/fsl/utils.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     suffix = "_maths"  # ohinds: build suffix
     if inputs.suffix is not attrs.NOTHING:
diff --git a/example-specs/task/nipype/fsl/image_meants_callables.py b/example-specs/task/nipype/fsl/image_meants_callables.py
index b925250f..a6d74733 100644
--- a/example-specs/task/nipype/fsl/image_meants_callables.py
+++ b/example-specs/task/nipype/fsl/image_meants_callables.py
@@ -1,11 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of ImageMeants.yaml"""
 
 from glob import glob
-import logging
-from pathlib import Path
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
+from pathlib import Path
 
 
 def out_file_default(inputs):
@@ -22,6 +22,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -59,6 +60,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -101,6 +103,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -151,6 +154,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
     Handle FSL ``output_type`` and version information.
@@ -243,6 +247,7 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
 def _gen_fname(
     basename,
     cwd=None,
@@ -298,6 +303,7 @@ def _gen_fname(
     return fname
 
 
+# Original source at L184 of <nipype-install>/interfaces/fsl/utils.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "out_file":
         return _list_outputs(
@@ -306,6 +312,7 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     return None
 
 
+# Original source at L174 of <nipype-install>/interfaces/fsl/utils.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["out_file"] = inputs.out_file
diff --git a/example-specs/task/nipype/fsl/image_stats_callables.py b/example-specs/task/nipype/fsl/image_stats_callables.py
index 6a2502f2..87578728 100644
--- a/example-specs/task/nipype/fsl/image_stats_callables.py
+++ b/example-specs/task/nipype/fsl/image_stats_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of ImageStats.yaml"""
 
-import logging
 from glob import glob
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
 
 
 def out_stat_callable(output_dir, inputs, stdout, stderr):
@@ -14,12 +14,13 @@ def out_stat_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_stat"]
 
 
-iflogger = logging.getLogger("nipype.interface")
+IFLOGGER = logging.getLogger("nipype.interface")
 
 
-IFLOGGER = logging.getLogger("nipype.interface")
+iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -57,6 +58,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
     Handle FSL ``output_type`` and version information.
@@ -149,12 +151,14 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
+# Original source at L249 of <nipype-install>/interfaces/fsl/base.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
     return value + Info.output_type_to_ext(inputs.output_type)
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -165,6 +169,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -215,6 +220,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -309,10 +315,12 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     metadata = dict(name_source=lambda t: t is not None)
     traits = inputs.traits(**metadata)
diff --git a/example-specs/task/nipype/fsl/inv_warp_callables.py b/example-specs/task/nipype/fsl/inv_warp_callables.py
index 0b8e0e86..5d1296e9 100644
--- a/example-specs/task/nipype/fsl/inv_warp_callables.py
+++ b/example-specs/task/nipype/fsl/inv_warp_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of InvWarp.yaml"""
 
-import logging
 from glob import glob
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
 
 
 def inverse_warp_callable(output_dir, inputs, stdout, stderr):
@@ -14,12 +14,13 @@ def inverse_warp_callable(output_dir, inputs, stdout, stderr):
     return outputs["inverse_warp"]
 
 
-iflogger = logging.getLogger("nipype.interface")
+IFLOGGER = logging.getLogger("nipype.interface")
 
 
-IFLOGGER = logging.getLogger("nipype.interface")
+iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -57,6 +58,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
     Handle FSL ``output_type`` and version information.
@@ -149,12 +151,14 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
+# Original source at L249 of <nipype-install>/interfaces/fsl/base.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
     return value + Info.output_type_to_ext(inputs.output_type)
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -165,6 +169,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -215,6 +220,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -309,10 +315,12 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     metadata = dict(name_source=lambda t: t is not None)
     traits = inputs.traits(**metadata)
diff --git a/example-specs/task/nipype/fsl/isotropic_smooth_callables.py b/example-specs/task/nipype/fsl/isotropic_smooth_callables.py
index 377ec797..d1737124 100644
--- a/example-specs/task/nipype/fsl/isotropic_smooth_callables.py
+++ b/example-specs/task/nipype/fsl/isotropic_smooth_callables.py
@@ -1,11 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of IsotropicSmooth.yaml"""
 
 from glob import glob
-import logging
-from pathlib import Path
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
+from pathlib import Path
 
 
 def out_file_default(inputs):
@@ -22,6 +22,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -59,6 +60,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -101,6 +103,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -151,6 +154,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
     Handle FSL ``output_type`` and version information.
@@ -243,6 +247,7 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
 def _gen_fname(
     basename,
     cwd=None,
@@ -298,6 +303,7 @@ def _gen_fname(
     return fname
 
 
+# Original source at L61 of <nipype-install>/interfaces/fsl/maths.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "out_file":
         return _list_outputs(
@@ -306,6 +312,7 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     return None
 
 
+# Original source at L51 of <nipype-install>/interfaces/fsl/maths.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["out_file"] = inputs.out_file
diff --git a/example-specs/task/nipype/fsl/l2_model_callables.py b/example-specs/task/nipype/fsl/l2_model_callables.py
index feb23eef..1b32404c 100644
--- a/example-specs/task/nipype/fsl/l2_model_callables.py
+++ b/example-specs/task/nipype/fsl/l2_model_callables.py
@@ -1,5 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of L2Model.yaml"""
 
+import attrs
+
 
 def design_mat_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
diff --git a/example-specs/task/nipype/fsl/level_1_design_callables.py b/example-specs/task/nipype/fsl/level_1_design_callables.py
index 2df671c8..97269631 100644
--- a/example-specs/task/nipype/fsl/level_1_design_callables.py
+++ b/example-specs/task/nipype/fsl/level_1_design_callables.py
@@ -1,5 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of Level1Design.yaml"""
 
+import attrs
+
 
 def fsf_files_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
diff --git a/example-specs/task/nipype/fsl/make_dyadic_vectors_callables.py b/example-specs/task/nipype/fsl/make_dyadic_vectors_callables.py
index 808affe0..a163cae0 100644
--- a/example-specs/task/nipype/fsl/make_dyadic_vectors_callables.py
+++ b/example-specs/task/nipype/fsl/make_dyadic_vectors_callables.py
@@ -1,10 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of MakeDyadicVectors.yaml"""
 
+import attrs
 from glob import glob
 import logging
-from pathlib import Path
-import os.path as op
 import os
+import os.path as op
+from pathlib import Path
 
 
 def dyads_callable(output_dir, inputs, stdout, stderr):
@@ -24,6 +25,7 @@ def dispersion_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -61,6 +63,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -103,6 +106,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -153,6 +157,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
     Handle FSL ``output_type`` and version information.
@@ -245,6 +250,7 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
 def _gen_fname(
     basename,
     cwd=None,
@@ -300,10 +306,12 @@ def _gen_fname(
     return fname
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L1571 of <nipype-install>/interfaces/fsl/dti.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["dyads"] = _gen_fname(
diff --git a/example-specs/task/nipype/fsl/maths_command_callables.py b/example-specs/task/nipype/fsl/maths_command_callables.py
index 17c11afd..795f883c 100644
--- a/example-specs/task/nipype/fsl/maths_command_callables.py
+++ b/example-specs/task/nipype/fsl/maths_command_callables.py
@@ -1,11 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of MathsCommand.yaml"""
 
 from glob import glob
-import logging
-from pathlib import Path
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
+from pathlib import Path
 
 
 def out_file_default(inputs):
@@ -22,6 +22,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -59,6 +60,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -101,6 +103,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -151,6 +154,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
     Handle FSL ``output_type`` and version information.
@@ -243,6 +247,7 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
 def _gen_fname(
     basename,
     cwd=None,
@@ -298,6 +303,7 @@ def _gen_fname(
     return fname
 
 
+# Original source at L61 of <nipype-install>/interfaces/fsl/maths.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "out_file":
         return _list_outputs(
@@ -306,6 +312,7 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     return None
 
 
+# Original source at L51 of <nipype-install>/interfaces/fsl/maths.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["out_file"] = inputs.out_file
diff --git a/example-specs/task/nipype/fsl/max_image_callables.py b/example-specs/task/nipype/fsl/max_image_callables.py
index 97c53d6d..5ffcc131 100644
--- a/example-specs/task/nipype/fsl/max_image_callables.py
+++ b/example-specs/task/nipype/fsl/max_image_callables.py
@@ -1,11 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of MaxImage.yaml"""
 
 from glob import glob
-import logging
-from pathlib import Path
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
+from pathlib import Path
 
 
 def out_file_default(inputs):
@@ -22,6 +22,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -59,6 +60,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -101,6 +103,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -151,6 +154,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
     Handle FSL ``output_type`` and version information.
@@ -243,6 +247,7 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
 def _gen_fname(
     basename,
     cwd=None,
@@ -298,6 +303,7 @@ def _gen_fname(
     return fname
 
 
+# Original source at L61 of <nipype-install>/interfaces/fsl/maths.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "out_file":
         return _list_outputs(
@@ -306,6 +312,7 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     return None
 
 
+# Original source at L51 of <nipype-install>/interfaces/fsl/maths.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["out_file"] = inputs.out_file
diff --git a/example-specs/task/nipype/fsl/maxn_image_callables.py b/example-specs/task/nipype/fsl/maxn_image_callables.py
index dbcc27f6..2c4431c3 100644
--- a/example-specs/task/nipype/fsl/maxn_image_callables.py
+++ b/example-specs/task/nipype/fsl/maxn_image_callables.py
@@ -1,11 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of MaxnImage.yaml"""
 
 from glob import glob
-import logging
-from pathlib import Path
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
+from pathlib import Path
 
 
 def out_file_default(inputs):
@@ -22,6 +22,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -59,6 +60,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -101,6 +103,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -151,6 +154,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
     Handle FSL ``output_type`` and version information.
@@ -243,6 +247,7 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
 def _gen_fname(
     basename,
     cwd=None,
@@ -298,6 +303,7 @@ def _gen_fname(
     return fname
 
 
+# Original source at L61 of <nipype-install>/interfaces/fsl/maths.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "out_file":
         return _list_outputs(
@@ -306,6 +312,7 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     return None
 
 
+# Original source at L51 of <nipype-install>/interfaces/fsl/maths.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["out_file"] = inputs.out_file
diff --git a/example-specs/task/nipype/fsl/mcflirt_callables.py b/example-specs/task/nipype/fsl/mcflirt_callables.py
index 8113c914..699434a8 100644
--- a/example-specs/task/nipype/fsl/mcflirt_callables.py
+++ b/example-specs/task/nipype/fsl/mcflirt_callables.py
@@ -1,13 +1,13 @@
 """Module to put any functions that are referred to in the "callables" section of MCFLIRT.yaml"""
 
-import logging
-from pathlib import Path
 from looseversion import LooseVersion
-from glob import glob
-import os.path as op
-from nibabel.loadsave import load
 import attrs
 import os
+import os.path as op
+from nibabel import load
+from glob import glob
+import logging
+from pathlib import Path
 
 
 def out_file_default(inputs):
@@ -66,43 +66,7 @@ def rms_files_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
-
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
-
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
-
-            klass._version = klass.parse_version(raw_info)
-
-        return klass._version
-
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
-
-
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -145,6 +109,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -195,98 +160,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
-class Info(PackageInfo):
-    """
-    Handle FSL ``output_type`` and version information.
-
-    output type refers to the type of file fsl defaults to writing
-    eg, NIFTI, NIFTI_GZ
-
-    Examples
-    --------
-
-    >>> from nipype.interfaces.fsl import Info
-    >>> Info.version()  # doctest: +SKIP
-    >>> Info.output_type()  # doctest: +SKIP
-
-    """
-
-    ftypes = {
-        "NIFTI": ".nii",
-        "NIFTI_PAIR": ".img",
-        "NIFTI_GZ": ".nii.gz",
-        "NIFTI_PAIR_GZ": ".img.gz",
-    }
-
-    if os.getenv("FSLDIR"):
-        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
-
-    @staticmethod
-    def parse_version(raw_info):
-        return raw_info.splitlines()[0]
-
-    @classmethod
-    def output_type_to_ext(cls, output_type):
-        """Get the file extension for the given output type.
-
-        Parameters
-        ----------
-        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
-            String specifying the output type.
-
-        Returns
-        -------
-        extension : str
-            The file extension for the output type.
-        """
-
-        try:
-            return cls.ftypes[output_type]
-        except KeyError:
-            msg = "Invalid FSLOUTPUTTYPE: ", output_type
-            raise KeyError(msg)
-
-    @classmethod
-    def output_type(cls):
-        """Get the global FSL output file type FSLOUTPUTTYPE.
-
-        This returns the value of the environment variable
-        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
-
-        Returns
-        -------
-        fsl_ftype : string
-            Represents the current environment setting of FSLOUTPUTTYPE
-        """
-        try:
-            return os.environ["FSLOUTPUTTYPE"]
-        except KeyError:
-            IFLOGGER.warning(
-                "FSLOUTPUTTYPE environment variable is not set. "
-                "Setting FSLOUTPUTTYPE=NIFTI"
-            )
-            return "NIFTI"
-
-    @staticmethod
-    def standard_image(img_name=None):
-        """Grab an image from the standard location.
-
-        Returns a list of standard images if called without arguments.
-
-        Could be made more fancy to allow for more relocatability"""
-        try:
-            fsldir = os.environ["FSLDIR"]
-        except KeyError:
-            raise Exception("FSL environment variables not set")
-        stdpath = os.path.join(fsldir, "data", "standard")
-        if img_name is None:
-            return [
-                filename.replace(stdpath + "/", "")
-                for filename in glob(os.path.join(stdpath, "*nii*"))
-            ]
-        return os.path.join(stdpath, img_name)
-
-
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
 def _gen_fname(
     basename,
     cwd=None,
@@ -342,6 +216,7 @@ def _gen_fname(
     return fname
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -379,6 +254,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
     Handle FSL ``output_type`` and version information.
@@ -471,6 +347,7 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
+# Original source at L967 of <nipype-install>/interfaces/fsl/preprocess.py
 def _gen_outfilename(inputs=None, stdout=None, stderr=None, output_dir=None):
     out_file = inputs.out_file
     if out_file is not attrs.NOTHING:
@@ -487,6 +364,7 @@ def _gen_outfilename(inputs=None, stdout=None, stderr=None, output_dir=None):
     return os.path.abspath(out_file)
 
 
+# Original source at L962 of <nipype-install>/interfaces/fsl/preprocess.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "out_file":
         return _gen_outfilename(
@@ -495,6 +373,7 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     return None
 
 
+# Original source at L906 of <nipype-install>/interfaces/fsl/preprocess.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
 
diff --git a/example-specs/task/nipype/fsl/mean_image_callables.py b/example-specs/task/nipype/fsl/mean_image_callables.py
index bfa76a70..d7cc7a0f 100644
--- a/example-specs/task/nipype/fsl/mean_image_callables.py
+++ b/example-specs/task/nipype/fsl/mean_image_callables.py
@@ -1,11 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of MeanImage.yaml"""
 
 from glob import glob
-import logging
-from pathlib import Path
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
+from pathlib import Path
 
 
 def out_file_default(inputs):
@@ -22,6 +22,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -59,6 +60,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -101,6 +103,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -151,6 +154,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
     Handle FSL ``output_type`` and version information.
@@ -243,6 +247,7 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
 def _gen_fname(
     basename,
     cwd=None,
@@ -298,6 +303,7 @@ def _gen_fname(
     return fname
 
 
+# Original source at L61 of <nipype-install>/interfaces/fsl/maths.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "out_file":
         return _list_outputs(
@@ -306,6 +312,7 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     return None
 
 
+# Original source at L51 of <nipype-install>/interfaces/fsl/maths.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["out_file"] = inputs.out_file
diff --git a/example-specs/task/nipype/fsl/median_image_callables.py b/example-specs/task/nipype/fsl/median_image_callables.py
index 814df76c..bb824477 100644
--- a/example-specs/task/nipype/fsl/median_image_callables.py
+++ b/example-specs/task/nipype/fsl/median_image_callables.py
@@ -1,11 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of MedianImage.yaml"""
 
 from glob import glob
-import logging
-from pathlib import Path
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
+from pathlib import Path
 
 
 def out_file_default(inputs):
@@ -22,6 +22,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -59,6 +60,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -101,6 +103,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -151,6 +154,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
     Handle FSL ``output_type`` and version information.
@@ -243,6 +247,7 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
 def _gen_fname(
     basename,
     cwd=None,
@@ -298,6 +303,7 @@ def _gen_fname(
     return fname
 
 
+# Original source at L61 of <nipype-install>/interfaces/fsl/maths.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "out_file":
         return _list_outputs(
@@ -306,6 +312,7 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     return None
 
 
+# Original source at L51 of <nipype-install>/interfaces/fsl/maths.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["out_file"] = inputs.out_file
diff --git a/example-specs/task/nipype/fsl/melodic_callables.py b/example-specs/task/nipype/fsl/melodic_callables.py
index 5541fa51..291e99f7 100644
--- a/example-specs/task/nipype/fsl/melodic_callables.py
+++ b/example-specs/task/nipype/fsl/melodic_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of MELODIC.yaml"""
 
-import attrs
 import os
+import attrs
 
 
 def out_dir_default(inputs):
@@ -22,11 +22,13 @@ def report_dir_callable(output_dir, inputs, stdout, stderr):
     return outputs["report_dir"]
 
 
+# Original source at L1858 of <nipype-install>/interfaces/fsl/model.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "out_dir":
         return output_dir
 
 
+# Original source at L1848 of <nipype-install>/interfaces/fsl/model.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     if inputs.out_dir is not attrs.NOTHING:
diff --git a/example-specs/task/nipype/fsl/merge_callables.py b/example-specs/task/nipype/fsl/merge_callables.py
index bb90ff86..554cc805 100644
--- a/example-specs/task/nipype/fsl/merge_callables.py
+++ b/example-specs/task/nipype/fsl/merge_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Merge.yaml"""
 
-import logging
 from glob import glob
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
 
 
 def merged_file_callable(output_dir, inputs, stdout, stderr):
@@ -14,12 +14,13 @@ def merged_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["merged_file"]
 
 
-iflogger = logging.getLogger("nipype.interface")
+IFLOGGER = logging.getLogger("nipype.interface")
 
 
-IFLOGGER = logging.getLogger("nipype.interface")
+iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -57,6 +58,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
     Handle FSL ``output_type`` and version information.
@@ -149,12 +151,14 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
+# Original source at L249 of <nipype-install>/interfaces/fsl/base.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
     return value + Info.output_type_to_ext(inputs.output_type)
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -165,6 +169,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -215,6 +220,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -309,10 +315,12 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     metadata = dict(name_source=lambda t: t is not None)
     traits = inputs.traits(**metadata)
diff --git a/example-specs/task/nipype/fsl/min_image_callables.py b/example-specs/task/nipype/fsl/min_image_callables.py
index feec3d89..c3ee5d58 100644
--- a/example-specs/task/nipype/fsl/min_image_callables.py
+++ b/example-specs/task/nipype/fsl/min_image_callables.py
@@ -1,11 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of MinImage.yaml"""
 
 from glob import glob
-import logging
-from pathlib import Path
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
+from pathlib import Path
 
 
 def out_file_default(inputs):
@@ -22,6 +22,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -59,6 +60,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -101,6 +103,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -151,6 +154,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
     Handle FSL ``output_type`` and version information.
@@ -243,6 +247,7 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
 def _gen_fname(
     basename,
     cwd=None,
@@ -298,6 +303,7 @@ def _gen_fname(
     return fname
 
 
+# Original source at L61 of <nipype-install>/interfaces/fsl/maths.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "out_file":
         return _list_outputs(
@@ -306,6 +312,7 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     return None
 
 
+# Original source at L51 of <nipype-install>/interfaces/fsl/maths.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["out_file"] = inputs.out_file
diff --git a/example-specs/task/nipype/fsl/motion_outliers_callables.py b/example-specs/task/nipype/fsl/motion_outliers_callables.py
index 09d72133..d6436449 100644
--- a/example-specs/task/nipype/fsl/motion_outliers_callables.py
+++ b/example-specs/task/nipype/fsl/motion_outliers_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of MotionOutliers.yaml"""
 
-import logging
 from glob import glob
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -28,12 +28,13 @@ def out_metric_plot_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_metric_plot"]
 
 
-iflogger = logging.getLogger("nipype.interface")
+IFLOGGER = logging.getLogger("nipype.interface")
 
 
-IFLOGGER = logging.getLogger("nipype.interface")
+iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -71,6 +72,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
     Handle FSL ``output_type`` and version information.
@@ -163,12 +165,14 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
+# Original source at L249 of <nipype-install>/interfaces/fsl/base.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
     return value + Info.output_type_to_ext(inputs.output_type)
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -179,6 +183,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -229,6 +234,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -323,10 +329,12 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     metadata = dict(name_source=lambda t: t is not None)
     traits = inputs.traits(**metadata)
diff --git a/example-specs/task/nipype/fsl/multi_image_maths_callables.py b/example-specs/task/nipype/fsl/multi_image_maths_callables.py
index d2b014e4..db7e96d9 100644
--- a/example-specs/task/nipype/fsl/multi_image_maths_callables.py
+++ b/example-specs/task/nipype/fsl/multi_image_maths_callables.py
@@ -1,11 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of MultiImageMaths.yaml"""
 
 from glob import glob
-import logging
-from pathlib import Path
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
+from pathlib import Path
 
 
 def out_file_default(inputs):
@@ -22,6 +22,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -59,6 +60,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -101,6 +103,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -151,6 +154,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
     Handle FSL ``output_type`` and version information.
@@ -243,6 +247,7 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
 def _gen_fname(
     basename,
     cwd=None,
@@ -298,6 +303,7 @@ def _gen_fname(
     return fname
 
 
+# Original source at L61 of <nipype-install>/interfaces/fsl/maths.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "out_file":
         return _list_outputs(
@@ -306,6 +312,7 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     return None
 
 
+# Original source at L51 of <nipype-install>/interfaces/fsl/maths.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["out_file"] = inputs.out_file
diff --git a/example-specs/task/nipype/fsl/multiple_regress_design_callables.py b/example-specs/task/nipype/fsl/multiple_regress_design_callables.py
index d22ba883..44eeffe9 100644
--- a/example-specs/task/nipype/fsl/multiple_regress_design_callables.py
+++ b/example-specs/task/nipype/fsl/multiple_regress_design_callables.py
@@ -1,5 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of MultipleRegressDesign.yaml"""
 
+import attrs
+
 
 def design_mat_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
diff --git a/example-specs/task/nipype/fsl/overlay_callables.py b/example-specs/task/nipype/fsl/overlay_callables.py
index 2d281ac1..f0b205ba 100644
--- a/example-specs/task/nipype/fsl/overlay_callables.py
+++ b/example-specs/task/nipype/fsl/overlay_callables.py
@@ -1,11 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of Overlay.yaml"""
 
-import logging
-from pathlib import Path
-from glob import glob
-import os.path as op
 import attrs
 import os
+import os.path as op
+from glob import glob
+import logging
+from pathlib import Path
 
 
 def out_file_default(inputs):
@@ -22,6 +22,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -59,6 +60,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -101,56 +103,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
+# Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
     Handle FSL ``output_type`` and version information.
@@ -243,6 +196,7 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
 def _gen_fname(
     basename,
     cwd=None,
@@ -298,6 +252,7 @@ def _gen_fname(
     return fname
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -348,6 +303,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L1098 of <nipype-install>/interfaces/fsl/utils.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "out_file":
         return _list_outputs(
@@ -356,6 +312,7 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     return None
 
 
+# Original source at L1080 of <nipype-install>/interfaces/fsl/utils.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     out_file = inputs.out_file
diff --git a/example-specs/task/nipype/fsl/percentile_image_callables.py b/example-specs/task/nipype/fsl/percentile_image_callables.py
index 64dcbb4f..f7ffb0eb 100644
--- a/example-specs/task/nipype/fsl/percentile_image_callables.py
+++ b/example-specs/task/nipype/fsl/percentile_image_callables.py
@@ -1,11 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of PercentileImage.yaml"""
 
 from glob import glob
-import logging
-from pathlib import Path
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
+from pathlib import Path
 
 
 def out_file_default(inputs):
@@ -22,6 +22,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -59,6 +60,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -101,6 +103,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -151,6 +154,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
     Handle FSL ``output_type`` and version information.
@@ -243,6 +247,7 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
 def _gen_fname(
     basename,
     cwd=None,
@@ -298,6 +303,7 @@ def _gen_fname(
     return fname
 
 
+# Original source at L61 of <nipype-install>/interfaces/fsl/maths.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "out_file":
         return _list_outputs(
@@ -306,6 +312,7 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     return None
 
 
+# Original source at L51 of <nipype-install>/interfaces/fsl/maths.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["out_file"] = inputs.out_file
diff --git a/example-specs/task/nipype/fsl/plot_motion_params_callables.py b/example-specs/task/nipype/fsl/plot_motion_params_callables.py
index 8fe1cdd6..f83baec1 100644
--- a/example-specs/task/nipype/fsl/plot_motion_params_callables.py
+++ b/example-specs/task/nipype/fsl/plot_motion_params_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of PlotMotionParams.yaml"""
 
-from pathlib import Path
+import os
 import os.path as op
+from pathlib import Path
 import attrs
-import os
 
 
 def out_file_default(inputs):
@@ -17,6 +17,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_file"]
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -59,6 +60,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -109,6 +111,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L1495 of <nipype-install>/interfaces/fsl/utils.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "out_file":
         return _list_outputs(
@@ -117,6 +120,7 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     return None
 
 
+# Original source at L1478 of <nipype-install>/interfaces/fsl/utils.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     out_file = inputs.out_file
diff --git a/example-specs/task/nipype/fsl/plot_time_series_callables.py b/example-specs/task/nipype/fsl/plot_time_series_callables.py
index dbdbdcd9..b5f405be 100644
--- a/example-specs/task/nipype/fsl/plot_time_series_callables.py
+++ b/example-specs/task/nipype/fsl/plot_time_series_callables.py
@@ -1,11 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of PlotTimeSeries.yaml"""
 
 from glob import glob
-import logging
-from pathlib import Path
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
+from pathlib import Path
 
 
 def out_file_default(inputs):
@@ -22,6 +22,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -59,6 +60,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -101,6 +103,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -151,6 +154,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
     Handle FSL ``output_type`` and version information.
@@ -243,6 +247,7 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
 def _gen_fname(
     basename,
     cwd=None,
@@ -298,6 +303,7 @@ def _gen_fname(
     return fname
 
 
+# Original source at L1367 of <nipype-install>/interfaces/fsl/utils.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "out_file":
         return _list_outputs(
@@ -306,6 +312,7 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     return None
 
 
+# Original source at L1355 of <nipype-install>/interfaces/fsl/utils.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     out_file = inputs.out_file
diff --git a/example-specs/task/nipype/fsl/power_spectrum_callables.py b/example-specs/task/nipype/fsl/power_spectrum_callables.py
index a2652b17..2ab10810 100644
--- a/example-specs/task/nipype/fsl/power_spectrum_callables.py
+++ b/example-specs/task/nipype/fsl/power_spectrum_callables.py
@@ -1,11 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of PowerSpectrum.yaml"""
 
 from glob import glob
-import logging
-from pathlib import Path
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
+from pathlib import Path
 
 
 def out_file_default(inputs):
@@ -22,6 +22,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -59,6 +60,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -101,6 +103,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -151,6 +154,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
     Handle FSL ``output_type`` and version information.
@@ -243,6 +247,7 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
 def _gen_fname(
     basename,
     cwd=None,
@@ -298,6 +303,7 @@ def _gen_fname(
     return fname
 
 
+# Original source at L1689 of <nipype-install>/interfaces/fsl/utils.py
 def _gen_outfilename(inputs=None, stdout=None, stderr=None, output_dir=None):
     out_file = inputs.out_file
     if (out_file is attrs.NOTHING) and (inputs.in_file is not attrs.NOTHING):
@@ -312,6 +318,7 @@ def _gen_outfilename(inputs=None, stdout=None, stderr=None, output_dir=None):
     return out_file
 
 
+# Original source at L1700 of <nipype-install>/interfaces/fsl/utils.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "out_file":
         return _gen_outfilename(
@@ -320,6 +327,7 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     return None
 
 
+# Original source at L1695 of <nipype-install>/interfaces/fsl/utils.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["out_file"] = os.path.abspath(
diff --git a/example-specs/task/nipype/fsl/prelude_callables.py b/example-specs/task/nipype/fsl/prelude_callables.py
index 1017e4a8..9ac5f3bb 100644
--- a/example-specs/task/nipype/fsl/prelude_callables.py
+++ b/example-specs/task/nipype/fsl/prelude_callables.py
@@ -1,11 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of PRELUDE.yaml"""
 
 from glob import glob
-import logging
-from pathlib import Path
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
+from pathlib import Path
 
 
 def unwrapped_phase_file_default(inputs):
@@ -22,6 +22,7 @@ def unwrapped_phase_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -59,6 +60,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -101,6 +103,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -151,6 +154,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
     Handle FSL ``output_type`` and version information.
@@ -243,6 +247,7 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
 def _gen_fname(
     basename,
     cwd=None,
@@ -298,6 +303,7 @@ def _gen_fname(
     return fname
 
 
+# Original source at L2115 of <nipype-install>/interfaces/fsl/preprocess.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "unwrapped_phase_file":
         return _list_outputs(
@@ -306,6 +312,7 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     return None
 
 
+# Original source at L2102 of <nipype-install>/interfaces/fsl/preprocess.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     out_file = inputs.unwrapped_phase_file
diff --git a/example-specs/task/nipype/fsl/prepare_fieldmap_callables.py b/example-specs/task/nipype/fsl/prepare_fieldmap_callables.py
index 7ae72b04..b9827e22 100644
--- a/example-specs/task/nipype/fsl/prepare_fieldmap_callables.py
+++ b/example-specs/task/nipype/fsl/prepare_fieldmap_callables.py
@@ -1,5 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of PrepareFieldmap.yaml"""
 
+import attrs
+
 
 def out_fieldmap_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
@@ -8,10 +10,12 @@ def out_fieldmap_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_fieldmap"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L110 of <nipype-install>/interfaces/fsl/epi.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["out_fieldmap"] = inputs.out_fieldmap
diff --git a/example-specs/task/nipype/fsl/prob_track_x2_callables.py b/example-specs/task/nipype/fsl/prob_track_x2_callables.py
index d66e7cad..fc6670b2 100644
--- a/example-specs/task/nipype/fsl/prob_track_x2_callables.py
+++ b/example-specs/task/nipype/fsl/prob_track_x2_callables.py
@@ -1,11 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of ProbTrackX2.yaml"""
 
 from glob import glob
-import logging
-from pathlib import Path
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
+from pathlib import Path
 
 
 def out_dir_default(inputs):
@@ -85,6 +85,7 @@ def particle_files_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -122,6 +123,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -164,6 +166,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -214,6 +217,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
     Handle FSL ``output_type`` and version information.
@@ -306,6 +310,7 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
 def _gen_fname(
     basename,
     cwd=None,
@@ -361,6 +366,7 @@ def _gen_fname(
     return fname
 
 
+# Original source at L871 of <nipype-install>/interfaces/fsl/dti.py
 def nipype_interfaces_fsl_dti__ProbTrackX___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -434,6 +440,7 @@ def nipype_interfaces_fsl_dti__ProbTrackX___list_outputs(
     return outputs
 
 
+# Original source at L921 of <nipype-install>/interfaces/fsl/dti.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "out_dir":
         return output_dir
@@ -444,6 +451,7 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
             return "seedmask"
 
 
+# Original source at L1070 of <nipype-install>/interfaces/fsl/dti.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = nipype_interfaces_fsl_dti__ProbTrackX___list_outputs()
 
diff --git a/example-specs/task/nipype/fsl/prob_track_x_callables.py b/example-specs/task/nipype/fsl/prob_track_x_callables.py
index 839bc58c..62a05006 100644
--- a/example-specs/task/nipype/fsl/prob_track_x_callables.py
+++ b/example-specs/task/nipype/fsl/prob_track_x_callables.py
@@ -1,11 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of ProbTrackX.yaml"""
 
 from glob import glob
-import logging
-from pathlib import Path
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
+from pathlib import Path
 
 
 def mode_default(inputs):
@@ -54,6 +54,7 @@ def particle_files_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -91,6 +92,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -133,6 +135,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -183,6 +186,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
     Handle FSL ``output_type`` and version information.
@@ -275,6 +279,7 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
 def _gen_fname(
     basename,
     cwd=None,
@@ -330,6 +335,7 @@ def _gen_fname(
     return fname
 
 
+# Original source at L921 of <nipype-install>/interfaces/fsl/dti.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "out_dir":
         return output_dir
@@ -340,6 +346,7 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
             return "seedmask"
 
 
+# Original source at L871 of <nipype-install>/interfaces/fsl/dti.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     if inputs.out_dir is attrs.NOTHING:
diff --git a/example-specs/task/nipype/fsl/proj_thresh_callables.py b/example-specs/task/nipype/fsl/proj_thresh_callables.py
index 9e2d4282..cdede2b6 100644
--- a/example-specs/task/nipype/fsl/proj_thresh_callables.py
+++ b/example-specs/task/nipype/fsl/proj_thresh_callables.py
@@ -1,10 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of ProjThresh.yaml"""
 
+import attrs
 from glob import glob
 import logging
-from pathlib import Path
-import os.path as op
 import os
+import os.path as op
+from pathlib import Path
 
 
 def out_files_callable(output_dir, inputs, stdout, stderr):
@@ -17,6 +18,7 @@ def out_files_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -54,6 +56,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -96,6 +99,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -146,6 +150,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
     Handle FSL ``output_type`` and version information.
@@ -238,6 +243,7 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
 def _gen_fname(
     basename,
     cwd=None,
@@ -293,10 +299,12 @@ def _gen_fname(
     return fname
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L1268 of <nipype-install>/interfaces/fsl/dti.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["out_files"] = []
diff --git a/example-specs/task/nipype/fsl/randomise_callables.py b/example-specs/task/nipype/fsl/randomise_callables.py
index 5df4da5c..65a93db7 100644
--- a/example-specs/task/nipype/fsl/randomise_callables.py
+++ b/example-specs/task/nipype/fsl/randomise_callables.py
@@ -1,10 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of Randomise.yaml"""
 
+import attrs
 from glob import glob
 import logging
-from pathlib import Path
-import os.path as op
 import os
+import os.path as op
+from pathlib import Path
 
 
 def tstat_files_callable(output_dir, inputs, stdout, stderr):
@@ -52,6 +53,7 @@ def f_corrected_p_files_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -89,6 +91,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -131,6 +134,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -181,6 +185,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
     Handle FSL ``output_type`` and version information.
@@ -273,6 +278,7 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
 def _gen_fname(
     basename,
     cwd=None,
@@ -328,10 +334,12 @@ def _gen_fname(
     return fname
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L2322 of <nipype-install>/interfaces/fsl/model.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["tstat_files"] = glob(
diff --git a/example-specs/task/nipype/fsl/reorient_2_std_callables.py b/example-specs/task/nipype/fsl/reorient_2_std_callables.py
index eee58e42..85773a63 100644
--- a/example-specs/task/nipype/fsl/reorient_2_std_callables.py
+++ b/example-specs/task/nipype/fsl/reorient_2_std_callables.py
@@ -1,11 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of Reorient2Std.yaml"""
 
 from glob import glob
-import logging
-from pathlib import Path
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
+from pathlib import Path
 
 
 def out_file_default(inputs):
@@ -22,6 +22,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -59,6 +60,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -101,6 +103,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -151,6 +154,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
     Handle FSL ``output_type`` and version information.
@@ -243,6 +247,7 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
 def _gen_fname(
     basename,
     cwd=None,
@@ -298,6 +303,7 @@ def _gen_fname(
     return fname
 
 
+# Original source at L1784 of <nipype-install>/interfaces/fsl/utils.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "out_file":
         return _gen_fname(
@@ -311,6 +317,7 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     return None
 
 
+# Original source at L1789 of <nipype-install>/interfaces/fsl/utils.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     if inputs.out_file is attrs.NOTHING:
diff --git a/example-specs/task/nipype/fsl/robust_fov_callables.py b/example-specs/task/nipype/fsl/robust_fov_callables.py
index 03ef2380..0c62186e 100644
--- a/example-specs/task/nipype/fsl/robust_fov_callables.py
+++ b/example-specs/task/nipype/fsl/robust_fov_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of RobustFOV.yaml"""
 
-import logging
 from glob import glob
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
 
 
 def out_roi_callable(output_dir, inputs, stdout, stderr):
@@ -21,12 +21,13 @@ def out_transform_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_transform"]
 
 
-iflogger = logging.getLogger("nipype.interface")
+IFLOGGER = logging.getLogger("nipype.interface")
 
 
-IFLOGGER = logging.getLogger("nipype.interface")
+iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -64,6 +65,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
     Handle FSL ``output_type`` and version information.
@@ -156,12 +158,14 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
+# Original source at L249 of <nipype-install>/interfaces/fsl/base.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
     return value + Info.output_type_to_ext(inputs.output_type)
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -172,6 +176,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -222,6 +227,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -316,10 +322,12 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     metadata = dict(name_source=lambda t: t is not None)
     traits = inputs.traits(**metadata)
diff --git a/example-specs/task/nipype/fsl/sig_loss_callables.py b/example-specs/task/nipype/fsl/sig_loss_callables.py
index bab7e3c0..35783a3f 100644
--- a/example-specs/task/nipype/fsl/sig_loss_callables.py
+++ b/example-specs/task/nipype/fsl/sig_loss_callables.py
@@ -1,11 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of SigLoss.yaml"""
 
 from glob import glob
-import logging
-from pathlib import Path
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
+from pathlib import Path
 
 
 def out_file_default(inputs):
@@ -22,6 +22,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -59,6 +60,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -101,6 +103,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -151,6 +154,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
     Handle FSL ``output_type`` and version information.
@@ -243,6 +247,7 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
 def _gen_fname(
     basename,
     cwd=None,
@@ -298,6 +303,7 @@ def _gen_fname(
     return fname
 
 
+# Original source at L1750 of <nipype-install>/interfaces/fsl/utils.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "out_file":
         return _list_outputs(
@@ -306,6 +312,7 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     return None
 
 
+# Original source at L1741 of <nipype-install>/interfaces/fsl/utils.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["out_file"] = inputs.out_file
diff --git a/example-specs/task/nipype/fsl/slice_callables.py b/example-specs/task/nipype/fsl/slice_callables.py
index 8e921eca..1bf6c5ac 100644
--- a/example-specs/task/nipype/fsl/slice_callables.py
+++ b/example-specs/task/nipype/fsl/slice_callables.py
@@ -1,11 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of Slice.yaml"""
 
+import attrs
 from glob import glob
 import logging
-from pathlib import Path
-import os.path as op
-import attrs
 import os
+import os.path as op
+from pathlib import Path
 
 
 def out_files_callable(output_dir, inputs, stdout, stderr):
@@ -18,10 +18,12 @@ def out_files_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -59,6 +61,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
     Handle FSL ``output_type`` and version information.
@@ -151,6 +154,7 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -193,6 +197,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -243,6 +248,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L305 of <nipype-install>/interfaces/fsl/utils.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     """Create a Bunch which contains all possible files generated
     by running the interface.  Some files are always generated, others
diff --git a/example-specs/task/nipype/fsl/slice_timer_callables.py b/example-specs/task/nipype/fsl/slice_timer_callables.py
index f57ce24d..763745b3 100644
--- a/example-specs/task/nipype/fsl/slice_timer_callables.py
+++ b/example-specs/task/nipype/fsl/slice_timer_callables.py
@@ -1,11 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of SliceTimer.yaml"""
 
 from glob import glob
-import logging
-from pathlib import Path
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
+from pathlib import Path
 
 
 def out_file_default(inputs):
@@ -22,6 +22,7 @@ def slice_time_corrected_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -59,6 +60,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -101,6 +103,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -151,6 +154,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
     Handle FSL ``output_type`` and version information.
@@ -243,6 +247,7 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
 def _gen_fname(
     basename,
     cwd=None,
@@ -298,6 +303,7 @@ def _gen_fname(
     return fname
 
 
+# Original source at L1578 of <nipype-install>/interfaces/fsl/preprocess.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "out_file":
         return _list_outputs(
@@ -306,6 +312,7 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     return None
 
 
+# Original source at L1570 of <nipype-install>/interfaces/fsl/preprocess.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     out_file = inputs.out_file
diff --git a/example-specs/task/nipype/fsl/slicer_callables.py b/example-specs/task/nipype/fsl/slicer_callables.py
index 269f0311..24ec841d 100644
--- a/example-specs/task/nipype/fsl/slicer_callables.py
+++ b/example-specs/task/nipype/fsl/slicer_callables.py
@@ -1,11 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of Slicer.yaml"""
 
 from glob import glob
-import logging
-from pathlib import Path
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
+from pathlib import Path
 
 
 def out_file_default(inputs):
@@ -22,6 +22,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -59,6 +60,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -101,6 +103,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -151,6 +154,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
     Handle FSL ``output_type`` and version information.
@@ -243,6 +247,7 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
 def _gen_fname(
     basename,
     cwd=None,
@@ -298,6 +303,7 @@ def _gen_fname(
     return fname
 
 
+# Original source at L1246 of <nipype-install>/interfaces/fsl/utils.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "out_file":
         return _list_outputs(
@@ -306,6 +312,7 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     return None
 
 
+# Original source at L1238 of <nipype-install>/interfaces/fsl/utils.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     out_file = inputs.out_file
diff --git a/example-specs/task/nipype/fsl/smm_callables.py b/example-specs/task/nipype/fsl/smm_callables.py
index 0e833ebf..d8088423 100644
--- a/example-specs/task/nipype/fsl/smm_callables.py
+++ b/example-specs/task/nipype/fsl/smm_callables.py
@@ -1,11 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of SMM.yaml"""
 
 from glob import glob
-import logging
-from pathlib import Path
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
+from pathlib import Path
 
 
 def null_p_map_callable(output_dir, inputs, stdout, stderr):
@@ -32,6 +32,7 @@ def deactivation_p_map_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -69,6 +70,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -111,6 +113,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -161,6 +164,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
     Handle FSL ``output_type`` and version information.
@@ -253,6 +257,7 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
 def _gen_fname(
     basename,
     cwd=None,
@@ -308,10 +313,12 @@ def _gen_fname(
     return fname
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L1650 of <nipype-install>/interfaces/fsl/model.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     # TODO get the true logdir from the stdout
diff --git a/example-specs/task/nipype/fsl/smooth_callables.py b/example-specs/task/nipype/fsl/smooth_callables.py
index d09be82d..02d927d5 100644
--- a/example-specs/task/nipype/fsl/smooth_callables.py
+++ b/example-specs/task/nipype/fsl/smooth_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Smooth.yaml"""
 
-import logging
 from glob import glob
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
 
 
 def smoothed_file_callable(output_dir, inputs, stdout, stderr):
@@ -14,12 +14,13 @@ def smoothed_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["smoothed_file"]
 
 
-iflogger = logging.getLogger("nipype.interface")
+IFLOGGER = logging.getLogger("nipype.interface")
 
 
-IFLOGGER = logging.getLogger("nipype.interface")
+iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -57,6 +58,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
     Handle FSL ``output_type`` and version information.
@@ -149,12 +151,14 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
+# Original source at L249 of <nipype-install>/interfaces/fsl/base.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
     return value + Info.output_type_to_ext(inputs.output_type)
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -165,6 +169,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -215,6 +220,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -309,10 +315,12 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     metadata = dict(name_source=lambda t: t is not None)
     traits = inputs.traits(**metadata)
diff --git a/example-specs/task/nipype/fsl/smooth_estimate_callables.py b/example-specs/task/nipype/fsl/smooth_estimate_callables.py
index 79a92dd7..028d9e1e 100644
--- a/example-specs/task/nipype/fsl/smooth_estimate_callables.py
+++ b/example-specs/task/nipype/fsl/smooth_estimate_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of SmoothEstimate.yaml"""
 
-import logging
 from glob import glob
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
 
 
 def dlh_callable(output_dir, inputs, stdout, stderr):
@@ -28,12 +28,13 @@ def resels_callable(output_dir, inputs, stdout, stderr):
     return outputs["resels"]
 
 
-iflogger = logging.getLogger("nipype.interface")
+IFLOGGER = logging.getLogger("nipype.interface")
 
 
-IFLOGGER = logging.getLogger("nipype.interface")
+iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -71,6 +72,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
     Handle FSL ``output_type`` and version information.
@@ -163,12 +165,14 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
+# Original source at L249 of <nipype-install>/interfaces/fsl/base.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
     return value + Info.output_type_to_ext(inputs.output_type)
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -179,6 +183,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -229,6 +234,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -323,10 +329,12 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     metadata = dict(name_source=lambda t: t is not None)
     traits = inputs.traits(**metadata)
diff --git a/example-specs/task/nipype/fsl/spatial_filter_callables.py b/example-specs/task/nipype/fsl/spatial_filter_callables.py
index 78294b60..7dd09c7a 100644
--- a/example-specs/task/nipype/fsl/spatial_filter_callables.py
+++ b/example-specs/task/nipype/fsl/spatial_filter_callables.py
@@ -1,11 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of SpatialFilter.yaml"""
 
 from glob import glob
-import logging
-from pathlib import Path
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
+from pathlib import Path
 
 
 def out_file_default(inputs):
@@ -22,6 +22,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -59,6 +60,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -101,6 +103,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -151,6 +154,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
     Handle FSL ``output_type`` and version information.
@@ -243,6 +247,7 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
 def _gen_fname(
     basename,
     cwd=None,
@@ -298,6 +303,7 @@ def _gen_fname(
     return fname
 
 
+# Original source at L61 of <nipype-install>/interfaces/fsl/maths.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "out_file":
         return _list_outputs(
@@ -306,6 +312,7 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     return None
 
 
+# Original source at L51 of <nipype-install>/interfaces/fsl/maths.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["out_file"] = inputs.out_file
diff --git a/example-specs/task/nipype/fsl/split_callables.py b/example-specs/task/nipype/fsl/split_callables.py
index 73d0854b..2bf84e3b 100644
--- a/example-specs/task/nipype/fsl/split_callables.py
+++ b/example-specs/task/nipype/fsl/split_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of Split.yaml"""
 
-from glob import glob
-import attrs
 import logging
 import os
+from glob import glob
+import attrs
 
 
 def out_files_callable(output_dir, inputs, stdout, stderr):
@@ -16,10 +16,12 @@ def out_files_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -57,6 +59,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
     Handle FSL ``output_type`` and version information.
@@ -149,6 +152,7 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
+# Original source at L549 of <nipype-install>/interfaces/fsl/utils.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     """Create a Bunch which contains all possible files generated
     by running the interface.  Some files are always generated, others
diff --git a/example-specs/task/nipype/fsl/std_image_callables.py b/example-specs/task/nipype/fsl/std_image_callables.py
index 3cf12051..706702bb 100644
--- a/example-specs/task/nipype/fsl/std_image_callables.py
+++ b/example-specs/task/nipype/fsl/std_image_callables.py
@@ -1,11 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of StdImage.yaml"""
 
 from glob import glob
-import logging
-from pathlib import Path
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
+from pathlib import Path
 
 
 def out_file_default(inputs):
@@ -22,6 +22,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -59,6 +60,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -101,6 +103,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -151,6 +154,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
     Handle FSL ``output_type`` and version information.
@@ -243,6 +247,7 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
 def _gen_fname(
     basename,
     cwd=None,
@@ -298,6 +303,7 @@ def _gen_fname(
     return fname
 
 
+# Original source at L61 of <nipype-install>/interfaces/fsl/maths.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "out_file":
         return _list_outputs(
@@ -306,6 +312,7 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     return None
 
 
+# Original source at L51 of <nipype-install>/interfaces/fsl/maths.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["out_file"] = inputs.out_file
diff --git a/example-specs/task/nipype/fsl/susan_callables.py b/example-specs/task/nipype/fsl/susan_callables.py
index 902d0a1e..c741f8e1 100644
--- a/example-specs/task/nipype/fsl/susan_callables.py
+++ b/example-specs/task/nipype/fsl/susan_callables.py
@@ -1,11 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of SUSAN.yaml"""
 
 from glob import glob
-import logging
-from pathlib import Path
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
+from pathlib import Path
 
 
 def out_file_default(inputs):
@@ -22,6 +22,7 @@ def smoothed_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -59,6 +60,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -101,6 +103,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -151,6 +154,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
     Handle FSL ``output_type`` and version information.
@@ -243,6 +247,7 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
 def _gen_fname(
     basename,
     cwd=None,
@@ -298,6 +303,7 @@ def _gen_fname(
     return fname
 
 
+# Original source at L1694 of <nipype-install>/interfaces/fsl/preprocess.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "out_file":
         return _list_outputs(
@@ -306,6 +312,7 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     return None
 
 
+# Original source at L1686 of <nipype-install>/interfaces/fsl/preprocess.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     out_file = inputs.out_file
diff --git a/example-specs/task/nipype/fsl/swap_dimensions_callables.py b/example-specs/task/nipype/fsl/swap_dimensions_callables.py
index 8e47e87a..6eba554c 100644
--- a/example-specs/task/nipype/fsl/swap_dimensions_callables.py
+++ b/example-specs/task/nipype/fsl/swap_dimensions_callables.py
@@ -1,11 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of SwapDimensions.yaml"""
 
 from glob import glob
-import logging
-from pathlib import Path
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
+from pathlib import Path
 
 
 def out_file_default(inputs):
@@ -22,6 +22,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -59,6 +60,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -101,6 +103,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -151,6 +154,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
     Handle FSL ``output_type`` and version information.
@@ -243,6 +247,7 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
 def _gen_fname(
     basename,
     cwd=None,
@@ -298,6 +303,7 @@ def _gen_fname(
     return fname
 
 
+# Original source at L1642 of <nipype-install>/interfaces/fsl/utils.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "out_file":
         return _list_outputs(
@@ -306,6 +312,7 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     return None
 
 
+# Original source at L1632 of <nipype-install>/interfaces/fsl/utils.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["out_file"] = inputs.out_file
diff --git a/example-specs/task/nipype/fsl/temporal_filter_callables.py b/example-specs/task/nipype/fsl/temporal_filter_callables.py
index d6e9fa55..b5d9389d 100644
--- a/example-specs/task/nipype/fsl/temporal_filter_callables.py
+++ b/example-specs/task/nipype/fsl/temporal_filter_callables.py
@@ -1,11 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of TemporalFilter.yaml"""
 
 from glob import glob
-import logging
-from pathlib import Path
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
+from pathlib import Path
 
 
 def out_file_default(inputs):
@@ -22,6 +22,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -59,6 +60,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -101,6 +103,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -151,6 +154,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
     Handle FSL ``output_type`` and version information.
@@ -243,6 +247,7 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
 def _gen_fname(
     basename,
     cwd=None,
@@ -298,6 +303,7 @@ def _gen_fname(
     return fname
 
 
+# Original source at L61 of <nipype-install>/interfaces/fsl/maths.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "out_file":
         return _list_outputs(
@@ -306,6 +312,7 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     return None
 
 
+# Original source at L51 of <nipype-install>/interfaces/fsl/maths.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["out_file"] = inputs.out_file
diff --git a/example-specs/task/nipype/fsl/text_2_vest_callables.py b/example-specs/task/nipype/fsl/text_2_vest_callables.py
index 403cecbc..48aca8b6 100644
--- a/example-specs/task/nipype/fsl/text_2_vest_callables.py
+++ b/example-specs/task/nipype/fsl/text_2_vest_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Text2Vest.yaml"""
 
-import logging
 from glob import glob
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -14,12 +14,13 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_file"]
 
 
-iflogger = logging.getLogger("nipype.interface")
+IFLOGGER = logging.getLogger("nipype.interface")
 
 
-IFLOGGER = logging.getLogger("nipype.interface")
+iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -57,6 +58,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
     Handle FSL ``output_type`` and version information.
@@ -149,12 +151,14 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
+# Original source at L249 of <nipype-install>/interfaces/fsl/base.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
     return value + Info.output_type_to_ext(inputs.output_type)
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -165,6 +169,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -215,6 +220,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -309,10 +315,12 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     metadata = dict(name_source=lambda t: t is not None)
     traits = inputs.traits(**metadata)
diff --git a/example-specs/task/nipype/fsl/threshold_callables.py b/example-specs/task/nipype/fsl/threshold_callables.py
index 9258a1d4..dddc8229 100644
--- a/example-specs/task/nipype/fsl/threshold_callables.py
+++ b/example-specs/task/nipype/fsl/threshold_callables.py
@@ -1,11 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of Threshold.yaml"""
 
 from glob import glob
-import logging
-from pathlib import Path
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
+from pathlib import Path
 
 
 def out_file_default(inputs):
@@ -22,6 +22,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -59,6 +60,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -101,6 +103,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -151,6 +154,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
     Handle FSL ``output_type`` and version information.
@@ -243,6 +247,7 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
 def _gen_fname(
     basename,
     cwd=None,
@@ -298,6 +303,7 @@ def _gen_fname(
     return fname
 
 
+# Original source at L61 of <nipype-install>/interfaces/fsl/maths.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "out_file":
         return _list_outputs(
@@ -306,6 +312,7 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     return None
 
 
+# Original source at L51 of <nipype-install>/interfaces/fsl/maths.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["out_file"] = inputs.out_file
diff --git a/example-specs/task/nipype/fsl/topup_callables.py b/example-specs/task/nipype/fsl/topup_callables.py
index 335182b4..2893bd61 100644
--- a/example-specs/task/nipype/fsl/topup_callables.py
+++ b/example-specs/task/nipype/fsl/topup_callables.py
@@ -1,12 +1,12 @@
 """Module to put any functions that are referred to in the "callables" section of TOPUP.yaml"""
 
-import logging
-from pathlib import Path
 import nibabel as nb
-from glob import glob
-import os.path as op
 import attrs
 import os
+import os.path as op
+from glob import glob
+import logging
+from pathlib import Path
 
 
 def out_fieldcoef_callable(output_dir, inputs, stdout, stderr):
@@ -72,49 +72,13 @@ def out_logfile_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_logfile"]
 
 
-iflogger = logging.getLogger("nipype.interface")
-
-
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
-
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
-
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
-
-            klass._version = klass.parse_version(raw_info)
-
-        return klass._version
-
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -157,154 +121,14 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
-class Info(PackageInfo):
-    """
-    Handle FSL ``output_type`` and version information.
-
-    output type refers to the type of file fsl defaults to writing
-    eg, NIFTI, NIFTI_GZ
-
-    Examples
-    --------
-
-    >>> from nipype.interfaces.fsl import Info
-    >>> Info.version()  # doctest: +SKIP
-    >>> Info.output_type()  # doctest: +SKIP
-
-    """
-
-    ftypes = {
-        "NIFTI": ".nii",
-        "NIFTI_PAIR": ".img",
-        "NIFTI_GZ": ".nii.gz",
-        "NIFTI_PAIR_GZ": ".img.gz",
-    }
-
-    if os.getenv("FSLDIR"):
-        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
-
-    @staticmethod
-    def parse_version(raw_info):
-        return raw_info.splitlines()[0]
-
-    @classmethod
-    def output_type_to_ext(cls, output_type):
-        """Get the file extension for the given output type.
-
-        Parameters
-        ----------
-        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
-            String specifying the output type.
-
-        Returns
-        -------
-        extension : str
-            The file extension for the output type.
-        """
-
-        try:
-            return cls.ftypes[output_type]
-        except KeyError:
-            msg = "Invalid FSLOUTPUTTYPE: ", output_type
-            raise KeyError(msg)
-
-    @classmethod
-    def output_type(cls):
-        """Get the global FSL output file type FSLOUTPUTTYPE.
-
-        This returns the value of the environment variable
-        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
-
-        Returns
-        -------
-        fsl_ftype : string
-            Represents the current environment setting of FSLOUTPUTTYPE
-        """
-        try:
-            return os.environ["FSLOUTPUTTYPE"]
-        except KeyError:
-            IFLOGGER.warning(
-                "FSLOUTPUTTYPE environment variable is not set. "
-                "Setting FSLOUTPUTTYPE=NIFTI"
-            )
-            return "NIFTI"
-
-    @staticmethod
-    def standard_image(img_name=None):
-        """Grab an image from the standard location.
-
-        Returns a list of standard images if called without arguments.
-
-        Could be made more fancy to allow for more relocatability"""
-        try:
-            fsldir = os.environ["FSLDIR"]
-        except KeyError:
-            raise Exception("FSL environment variables not set")
-        stdpath = os.path.join(fsldir, "data", "standard")
-        if img_name is None:
-            return [
-                filename.replace(stdpath + "/", "")
-                for filename in glob(os.path.join(stdpath, "*nii*"))
-            ]
-        return os.path.join(stdpath, img_name)
-
-
+# Original source at L249 of <nipype-install>/interfaces/fsl/base.py
 def nipype_interfaces_fsl__FSLCommand___overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
     return value + Info.output_type_to_ext(inputs.output_type)
 
 
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
 def _gen_fname(
     basename,
     cwd=None,
@@ -360,6 +184,7 @@ def _gen_fname(
     return fname
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -370,56 +195,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -514,6 +290,7 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_fsl__FSLCommand___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -533,10 +310,12 @@ def nipype_interfaces_fsl__FSLCommand___list_outputs(
         return outputs
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -574,6 +353,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
     Handle FSL ``output_type`` and version information.
@@ -666,6 +446,7 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -716,6 +497,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L430 of <nipype-install>/interfaces/fsl/epi.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -724,6 +506,7 @@ def _overload_extension(
     return nipype_interfaces_fsl__FSLCommand___overload_extension(value, name)
 
 
+# Original source at L398 of <nipype-install>/interfaces/fsl/epi.py
 def _get_encfilename(inputs=None, stdout=None, stderr=None, output_dir=None):
     out_file = os.path.join(
         output_dir, ("%s_encfile.txt" % split_filename(inputs.in_file)[1])
@@ -731,6 +514,7 @@ def _get_encfilename(inputs=None, stdout=None, stderr=None, output_dir=None):
     return out_file
 
 
+# Original source at L361 of <nipype-install>/interfaces/fsl/epi.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = nipype_interfaces_fsl__FSLCommand___list_outputs()
     del outputs["out_base"]
diff --git a/example-specs/task/nipype/fsl/tract_skeleton_callables.py b/example-specs/task/nipype/fsl/tract_skeleton_callables.py
index 20c8eb7c..dd060e92 100644
--- a/example-specs/task/nipype/fsl/tract_skeleton_callables.py
+++ b/example-specs/task/nipype/fsl/tract_skeleton_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of TractSkeleton.yaml"""
 
-from pathlib import Path
 import os.path as op
+from pathlib import Path
 import attrs
 
 
@@ -19,10 +19,12 @@ def skeleton_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["skeleton_file"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -65,6 +67,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -115,6 +118,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L1445 of <nipype-install>/interfaces/fsl/dti.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     _si = inputs
diff --git a/example-specs/task/nipype/fsl/training_callables.py b/example-specs/task/nipype/fsl/training_callables.py
index 1ac9734b..05782ab1 100644
--- a/example-specs/task/nipype/fsl/training_callables.py
+++ b/example-specs/task/nipype/fsl/training_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of Training.yaml"""
 
-import attrs
 import os
+import attrs
 
 
 def trained_wts_file_callable(output_dir, inputs, stdout, stderr):
@@ -11,10 +11,12 @@ def trained_wts_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["trained_wts_file"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L200 of <nipype-install>/interfaces/fsl/fix.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     if inputs.trained_wts_filestem is not attrs.NOTHING:
diff --git a/example-specs/task/nipype/fsl/training_set_creator_callables.py b/example-specs/task/nipype/fsl/training_set_creator_callables.py
index 51e4898b..9358836b 100644
--- a/example-specs/task/nipype/fsl/training_set_creator_callables.py
+++ b/example-specs/task/nipype/fsl/training_set_creator_callables.py
@@ -1,5 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of TrainingSetCreator.yaml"""
 
+import attrs
+
 
 def mel_icas_out_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
diff --git a/example-specs/task/nipype/fsl/unary_maths_callables.py b/example-specs/task/nipype/fsl/unary_maths_callables.py
index 224f7db4..46994d20 100644
--- a/example-specs/task/nipype/fsl/unary_maths_callables.py
+++ b/example-specs/task/nipype/fsl/unary_maths_callables.py
@@ -1,11 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of UnaryMaths.yaml"""
 
 from glob import glob
-import logging
-from pathlib import Path
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
+from pathlib import Path
 
 
 def out_file_default(inputs):
@@ -22,6 +22,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -59,6 +60,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -101,6 +103,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -151,6 +154,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
     Handle FSL ``output_type`` and version information.
@@ -243,6 +247,7 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
 def _gen_fname(
     basename,
     cwd=None,
@@ -298,6 +303,7 @@ def _gen_fname(
     return fname
 
 
+# Original source at L51 of <nipype-install>/interfaces/fsl/maths.py
 def nipype_interfaces_fsl_maths__MathsCommand___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -316,6 +322,7 @@ def nipype_interfaces_fsl_maths__MathsCommand___list_outputs(
     return outputs
 
 
+# Original source at L61 of <nipype-install>/interfaces/fsl/maths.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "out_file":
         return nipype_interfaces_fsl_maths__MathsCommand___list_outputs(
@@ -324,6 +331,7 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     return None
 
 
+# Original source at L502 of <nipype-install>/interfaces/fsl/maths.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     _suffix = "_" + inputs.operation
     return nipype_interfaces_fsl_maths__MathsCommand___list_outputs()
diff --git a/example-specs/task/nipype/fsl/vec_reg_callables.py b/example-specs/task/nipype/fsl/vec_reg_callables.py
index 5e5a9d86..4fe66d32 100644
--- a/example-specs/task/nipype/fsl/vec_reg_callables.py
+++ b/example-specs/task/nipype/fsl/vec_reg_callables.py
@@ -1,11 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of VecReg.yaml"""
 
 from glob import glob
-import logging
-from pathlib import Path
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
+from pathlib import Path
 
 
 def out_file_default(inputs):
@@ -22,6 +22,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -59,6 +60,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -101,6 +103,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -151,6 +154,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
     Handle FSL ``output_type`` and version information.
@@ -243,6 +247,7 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
 def _gen_fname(
     basename,
     cwd=None,
@@ -298,6 +303,7 @@ def _gen_fname(
     return fname
 
 
+# Original source at L1216 of <nipype-install>/interfaces/fsl/dti.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     if name == "out_file":
         return _list_outputs(
@@ -307,6 +313,7 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
         return None
 
 
+# Original source at L1205 of <nipype-install>/interfaces/fsl/dti.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["out_file"] = inputs.out_file
diff --git a/example-specs/task/nipype/fsl/vest_2_text_callables.py b/example-specs/task/nipype/fsl/vest_2_text_callables.py
index 9efcea5e..2853cff2 100644
--- a/example-specs/task/nipype/fsl/vest_2_text_callables.py
+++ b/example-specs/task/nipype/fsl/vest_2_text_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Vest2Text.yaml"""
 
-import logging
 from glob import glob
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -14,12 +14,13 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_file"]
 
 
-iflogger = logging.getLogger("nipype.interface")
+IFLOGGER = logging.getLogger("nipype.interface")
 
 
-IFLOGGER = logging.getLogger("nipype.interface")
+iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -57,6 +58,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
     Handle FSL ``output_type`` and version information.
@@ -149,12 +151,14 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
+# Original source at L249 of <nipype-install>/interfaces/fsl/base.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
     return value + Info.output_type_to_ext(inputs.output_type)
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -165,6 +169,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -215,6 +220,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -309,10 +315,12 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     metadata = dict(name_source=lambda t: t is not None)
     traits = inputs.traits(**metadata)
diff --git a/example-specs/task/nipype/fsl/warp_points_callables.py b/example-specs/task/nipype/fsl/warp_points_callables.py
index f4a6c46b..19b91215 100644
--- a/example-specs/task/nipype/fsl/warp_points_callables.py
+++ b/example-specs/task/nipype/fsl/warp_points_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of WarpPoints.yaml"""
 
 import logging
+import os
 import os.path as op
 import attrs
-import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +16,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L2585 of <nipype-install>/interfaces/fsl/utils.py
 def _overload_extension(
     value, name, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -23,6 +24,7 @@ def _overload_extension(
         return "%s.%s" % (value, getattr(self, "_outformat"))
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -33,6 +35,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -83,6 +86,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -177,10 +181,12 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     metadata = dict(name_source=lambda t: t is not None)
     traits = inputs.traits(**metadata)
diff --git a/example-specs/task/nipype/fsl/warp_points_from_std_callables.py b/example-specs/task/nipype/fsl/warp_points_from_std_callables.py
index 604af246..be28f3f6 100644
--- a/example-specs/task/nipype/fsl/warp_points_from_std_callables.py
+++ b/example-specs/task/nipype/fsl/warp_points_from_std_callables.py
@@ -1,6 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of WarpPointsFromStd.yaml"""
 
 import os.path as op
+import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -10,10 +11,12 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_file"]
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L2744 of <nipype-install>/interfaces/fsl/utils.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     outputs["out_file"] = op.abspath("stdout.nipype")
diff --git a/example-specs/task/nipype/fsl/warp_points_to_std_callables.py b/example-specs/task/nipype/fsl/warp_points_to_std_callables.py
index ac832e5d..7b622b8b 100644
--- a/example-specs/task/nipype/fsl/warp_points_to_std_callables.py
+++ b/example-specs/task/nipype/fsl/warp_points_to_std_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of WarpPointsToStd.yaml"""
 
 import logging
+import os
 import os.path as op
 import attrs
-import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -16,6 +16,7 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L2585 of <nipype-install>/interfaces/fsl/utils.py
 def _overload_extension(
     value, name, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -23,6 +24,7 @@ def _overload_extension(
         return "%s.%s" % (value, getattr(self, "_outformat"))
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -33,6 +35,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -83,6 +86,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -177,10 +181,12 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     metadata = dict(name_source=lambda t: t is not None)
     traits = inputs.traits(**metadata)
diff --git a/example-specs/task/nipype/fsl/warp_utils_callables.py b/example-specs/task/nipype/fsl/warp_utils_callables.py
index b197536b..b684143d 100644
--- a/example-specs/task/nipype/fsl/warp_utils_callables.py
+++ b/example-specs/task/nipype/fsl/warp_utils_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of WarpUtils.yaml"""
 
-import logging
 from glob import glob
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -21,12 +21,13 @@ def out_jacobian_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_jacobian"]
 
 
-iflogger = logging.getLogger("nipype.interface")
+IFLOGGER = logging.getLogger("nipype.interface")
 
 
-IFLOGGER = logging.getLogger("nipype.interface")
+iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -64,6 +65,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
     Handle FSL ``output_type`` and version information.
@@ -156,12 +158,14 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
+# Original source at L249 of <nipype-install>/interfaces/fsl/base.py
 def _overload_extension(
     value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
     return value + Info.output_type_to_ext(inputs.output_type)
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
 
@@ -172,6 +176,7 @@ def __str__(self):
         return "{}".format(self.value)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -222,6 +227,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
@@ -316,10 +322,12 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     metadata = dict(name_source=lambda t: t is not None)
     traits = inputs.traits(**metadata)
diff --git a/example-specs/task/nipype/fsl/x_fibres_5_callables.py b/example-specs/task/nipype/fsl/x_fibres_5_callables.py
index 06533fd4..50c01fec 100644
--- a/example-specs/task/nipype/fsl/x_fibres_5_callables.py
+++ b/example-specs/task/nipype/fsl/x_fibres_5_callables.py
@@ -1,11 +1,11 @@
 """Module to put any functions that are referred to in the "callables" section of XFibres5.yaml"""
 
 from glob import glob
-import logging
-from pathlib import Path
-import os.path as op
 import attrs
+import logging
 import os
+import os.path as op
+from pathlib import Path
 
 
 def dyads_callable(output_dir, inputs, stdout, stderr):
@@ -67,6 +67,7 @@ def thsamples_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
     version_cmd = None
@@ -104,6 +105,7 @@ def parse_version(raw_info):
         raise NotImplementedError
 
 
+# Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
 
@@ -146,6 +148,7 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
 
@@ -196,6 +199,7 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
     Handle FSL ``output_type`` and version information.
@@ -288,6 +292,7 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
 def _gen_fname(
     basename,
     cwd=None,
@@ -343,10 +348,12 @@ def _gen_fname(
     return fname
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L298 of <nipype-install>/interfaces/fsl/dti.py
 def _list_outputs(out_dir=None, inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
     n_fibres = inputs.n_fibres
diff --git a/nipype2pydra/pkg_gen/__init__.py b/nipype2pydra/pkg_gen/__init__.py
index d9c6a71e..da15d135 100644
--- a/nipype2pydra/pkg_gen/__init__.py
+++ b/nipype2pydra/pkg_gen/__init__.py
@@ -30,7 +30,8 @@
 )
 from nipype2pydra.utils import (
     UsedSymbols,
-    split_parens_contents,
+    extract_args,
+    get_source_code,
     cleanup_function_body,
     insert_args_in_signature,
     INBUILT_NIPYPE_TRAIT_NAMES,
@@ -347,6 +348,7 @@ def generate_callables(self, nipype_interface) -> str:
         # Convert the "_gen_filename" method into a function with any referenced
         # methods, functions and constants included in the module
         funcs, imports, consts = get_callable_sources(nipype_interface)
+        imports.add("import attrs")
         callables_str += "\n".join(imports) + "\n\n"
         # Create separate default function for each input field with genfile, which
         # reference the magic "_gen_filename" method
@@ -838,21 +840,25 @@ def common_parent_pkg_prefix(mod_name: str) -> str:
         return "_".join(common) + "__"
 
     def find_nested_methods(
-        methods: ty.List[ty.Callable], interface=None
+        methods: ty.List[ty.Callable], class_name: str, interface=None
     ) -> ty.Dict[str, ty.Callable]:
         if interface is None:
             interface = nipype_interface
         all_nested = {}
         for method in methods:
-            method_src = inspect.getsource(method)
-            for match in re.findall(r"self\.(\w+)\(", method_src):
+            method_src = get_source_code(method)
+            for match in re.findall(
+                r"(?:self|" + class_name + r")\.(\w+)\(", method_src
+            ):
                 if match in ("output_spec", "_outputs"):
                     continue
                 nested = getattr(nipype_interface, match)
                 func_name = nested.__name__
                 if func_name not in all_nested and func_name != method.__name__:
                     all_nested[func_name] = nested
-                    all_nested.update(find_nested_methods([nested]))
+                    all_nested.update(
+                        find_nested_methods([nested], class_name=class_name)
+                    )
             for match in re.findall(r"super\([^\)]*\)\.(\w+)\(", method_src):
                 nested = None
                 for base in interface.__bases__:
@@ -873,13 +879,17 @@ def find_nested_methods(
                 )
                 if func_name not in all_nested:
                     all_nested[func_name] = nested
-                    all_nested.update(find_nested_methods([nested], interface=base))
+                    all_nested.update(
+                        find_nested_methods(
+                            [nested], class_name=class_name, interface=base
+                        )
+                    )
         return all_nested
 
     def process_method(
-        method: ty.Callable, new_name: str, name_map: ty.Dict[str, str]
+        method: ty.Callable, new_name: str, name_map: ty.Dict[str, str], class_name: str
     ) -> str:
-        src = inspect.getsource(method)
+        src = get_source_code(method)
         src = src.replace("if self.output_spec:", "if True:")
         src = re.sub(
             r"outputs = self\.(output_spec|_outputs)\(\).*$",
@@ -887,9 +897,9 @@ def process_method(
             src,
             flags=re.MULTILINE,
         )
-        prefix, args, body = split_parens_contents(src)
+        prefix, args, body = extract_args(src)
         body = insert_args_in_method_calls(
-            body, [f"{a}={a}" for a in IMPLICIT_ARGS], name_map
+            body, [f"{a}={a}" for a in IMPLICIT_ARGS], name_map, class_name
         )
         if hasattr(nipype_interface, "_cmd"):
             body = body.replace("self.cmd", f'"{nipype_interface._cmd}"')
@@ -905,13 +915,17 @@ def process_method(
         for implicit in IMPLICIT_ARGS:
             if implicit not in arg_names:
                 args.append(f"{implicit}=None")
-        match = re.match(r"(.*\n?\s*def\s+)", prefix)
-        src = match.group(1) + new_name + "(" + ", ".join(args) + body
+        match = re.match(r"(\s*#[^\n]*\n)(\s*@[^\n]*\n)*(\s*def\s+)", prefix)
+        prefix = "".join(g for g in match.groups() if g and g.strip() != "@classmethod")
+        src = prefix + new_name + "(" + ", ".join(args) + body
         src = cleanup_function_body(src)
         return src
 
     def insert_args_in_method_calls(
-        src: str, args: ty.List[ty.Tuple[str, str]], name_map: ty.Dict[str, str]
+        src: str,
+        args: ty.List[ty.Tuple[str, str]],
+        name_map: ty.Dict[str, str],
+        class_name: str,
     ) -> str:
         """Insert additional arguments into the method calls
 
@@ -923,7 +937,9 @@ def insert_args_in_method_calls(
             the arguments to insert into the method calls
         """
         # Split the src code into chunks delimited by calls to methods (i.e. 'self.<method>(.*)')
-        method_re = re.compile(r"self\.(\w+)(?=\()", flags=re.MULTILINE | re.DOTALL)
+        method_re = re.compile(
+            r"(?:self|" + class_name + r")\.(\w+)(?=\()", flags=re.MULTILINE | re.DOTALL
+        )
         splits = method_re.split(src)
         new_src = splits[0]
         # Iterate through these chunks and add the additional args to the method calls
@@ -943,7 +959,7 @@ def insert_args_in_method_calls(
             else:
                 if outer_name:
                     new_sig = insert_args_in_method_calls(
-                        new_sig, args, name_map=name_map
+                        new_sig, args, name_map=name_map, class_name=class_name
                     )
                     new_src += name_map[outer_name] + new_sig
                     outer_name = None
@@ -958,13 +974,15 @@ def insert_args_in_method_calls(
 
     # Get all methods to be included in the callables module
     all_methods = {m.__name__: m for m in methods_to_process}
-    all_methods.update(find_nested_methods(methods_to_process))
+    all_methods.update(
+        find_nested_methods(methods_to_process, class_name=nipype_interface.__name__)
+    )
     name_map = {m.__name__: n for n, m in all_methods.items()}
     # Group the nested methods by their module
     grouped_methods = defaultdict(list)
     for method_name, method in all_methods.items():
         grouped_methods[method.__module__].append(
-            process_method(method, method_name, name_map)
+            process_method(method, method_name, name_map, nipype_interface.__name__)
         )
     # Initialise the source code, imports and constants
     all_funcs = []
@@ -975,27 +993,51 @@ def insert_args_in_method_calls(
         used = UsedSymbols.find(mod, methods)
         all_funcs.extend(methods)
         for func in used.local_functions:
-            all_funcs.append(cleanup_function_body(inspect.getsource(func)))
+            func_src = cleanup_function_body(get_source_code(func))
+            if func_src not in all_funcs:
+                all_funcs.append(func_src)
         for klass in used.local_classes:
-            all_funcs.append(cleanup_function_body(inspect.getsource(klass)))
+            klass_src = cleanup_function_body(get_source_code(klass))
+            if klass_src not in all_funcs:
+                all_funcs.append(klass_src)
         for new_func_name, func in used.funcs_to_include:
-            func_src = inspect.getsource(func)
+            func_src = get_source_code(func)
+            location_comment, func_src = func_src.split("\n", 1)
             match = re.match(
                 r"(.*)\bdef *" + func.__name__ + r"(?=\()(.*)$",
                 func_src,
                 re.DOTALL | re.MULTILINE,
             )
-            func_src = match.group(1) + "def " + new_func_name + match.group(2)
-            all_funcs.append(cleanup_function_body(func_src))
+            func_src = (
+                location_comment.strip()
+                + "\n"
+                + match.group(1)
+                + "def "
+                + new_func_name
+                + match.group(2)
+            )
+            func_src = cleanup_function_body(func_src)
+            if func_src not in all_funcs:
+                all_funcs.append(func_src)
         for new_klass_name, klass in used.classes_to_include:
-            klass_src = inspect.getsource(klass)
+            klass_src = get_source_code(klass)
+            location_comment, klass_src = klass_src.split("\n", 1)
             match = re.match(
-                r" *class *" + klass.__name__ + r"(?=\()(.*)$",
+                r"(.*)\bclass *" + klass.__name__ + r"(?=\()(.*)$",
                 klass_src,
                 re.DOTALL | re.MULTILINE,
             )
-            klass_src = "class " + new_klass_name + match.group(1)
-            all_funcs.append(cleanup_function_body(klass_src))
+            klass_src = (
+                location_comment.strip()
+                + "\n"
+                + match.group(1)
+                + "class "
+                + new_klass_name
+                + match.group(2)
+            )
+            klass_src = cleanup_function_body(klass_src)
+            if klass_src not in all_funcs:
+                all_funcs.append(klass_src)
         all_imports.update(used.imports)
         all_constants.update(used.constants)
     return (
diff --git a/nipype2pydra/task/function.py b/nipype2pydra/task/function.py
index 10e28693..483dd3d2 100644
--- a/nipype2pydra/task/function.py
+++ b/nipype2pydra/task/function.py
@@ -7,8 +7,9 @@
 import attrs
 from .base import BaseTaskConverter
 from ..utils import (
-    split_parens_contents,
+    extract_args,
     UsedSymbols,
+    get_source_code,
     get_local_functions,
     get_local_constants,
     cleanup_function_body,
@@ -111,15 +112,15 @@ def types_to_names(spec_fields):
 
         for func in sorted(used.local_functions, key=attrgetter("__name__")):
             spec_str += "\n\n" + cleanup_function_body(
-                inspect.getsource(func)
+                get_source_code(func)
             )
 
         spec_str += "\n\n# Functions defined in neighbouring modules that have been included inline instead of imported\n\n"
 
         for func_name, func in sorted(used.funcs_to_include, key=itemgetter(0)):
-            func_src = inspect.getsource(func)
+            func_src = get_source_code(func)
             func_src = re.sub(
-                r"^(def) (\w+)(?=\()",
+                r"^(#[^\n]+\ndef) (\w+)(?=\()",
                 r"\1 " + func_name,
                 func_src,
                 flags=re.MULTILINE,
@@ -127,9 +128,9 @@ def types_to_names(spec_fields):
             spec_str += "\n\n" + cleanup_function_body(func_src)
 
         for klass_name, klass in sorted(used.classes_to_include, key=itemgetter(0)):
-            klass_src = inspect.getsource(klass)
+            klass_src = get_source_code(klass)
             klass_src = re.sub(
-                r"^(class) (\w+)(?=\()",
+                r"^(#[^\n]+\nclass) (\w+)(?=\()",
                 r"\1 " + klass_name,
                 klass_src,
                 flags=re.MULTILINE,
@@ -155,7 +156,7 @@ def process_method(
         method_returns: ty.Dict[str, ty.List[str]] = None,
     ):
         src = inspect.getsource(method)
-        pre, args, post = split_parens_contents(src)
+        pre, args, post = extract_args(src)
         args.remove("self")
         if "runtime" in args:
             args.remove("runtime")
diff --git a/nipype2pydra/tests/test_utils.py b/nipype2pydra/tests/test_utils.py
index 10225eda..8d208edd 100644
--- a/nipype2pydra/tests/test_utils.py
+++ b/nipype2pydra/tests/test_utils.py
@@ -1,72 +1,72 @@
-from nipype2pydra.utils import split_parens_contents
+from nipype2pydra.utils import extract_args, get_source_code
 
 
 def test_split_parens_contents1():
-    assert split_parens_contents(
+    assert extract_args(
         "def foo(a, b, c):\n    return a",
     ) == ("def foo(", ["a", "b", "c"], "):\n    return a")
 
 
 def test_split_parens_contents2():
-    assert split_parens_contents(
+    assert extract_args(
         "foo(a, 'b, c')",
     ) == ("foo(", ["a", "'b, c'"], ")")
 
 
 def test_split_parens_contents2a():
-    assert split_parens_contents(
+    assert extract_args(
         'foo(a, "b, c")',
     ) == ("foo(", ["a", '"b, c"'], ")")
 
 
 def test_split_parens_contents2b():
-    assert split_parens_contents("foo(a, 'b, \"c')") == ("foo(", ["a", "'b, \"c'"], ")")
+    assert extract_args("foo(a, 'b, \"c')") == ("foo(", ["a", "'b, \"c'"], ")")
 
 
 def test_split_parens_contents3():
-    assert split_parens_contents(
+    assert extract_args(
         "foo(a, bar(b, c))",
     ) == ("foo(", ["a", "bar(b, c)"], ")")
 
 
 def test_split_parens_contents3a():
-    assert split_parens_contents(
+    assert extract_args(
         "foo(a, bar[b, c])",
     ) == ("foo(", ["a", "bar[b, c]"], ")")
 
 
 def test_split_parens_contents3b():
-    assert split_parens_contents(
+    assert extract_args(
         "foo(a, bar([b, c]))",
     ) == ("foo(", ["a", "bar([b, c])"], ")")
 
 
 def test_split_parens_contents5():
-    assert split_parens_contents(
+    assert extract_args(
         "foo(a, '\"b\"', c)",
     ) == ("foo(", ["a", "'\"b\"'", "c"], ")")
 
 
 def test_split_parens_contents6():
-    assert split_parens_contents(
+    assert extract_args(
         r"foo(a, '\'b\'', c)",
     ) == ("foo(", ["a", r"'\'b\''", "c"], ")")
 
 
 def test_split_parens_contents6a():
-    assert split_parens_contents(
+    assert extract_args(
         r"foo(a, '\'b\', c')",
     ) == ("foo(", ["a", r"'\'b\', c'"], ")")
 
 
 def test_split_parens_contents7():
-    assert split_parens_contents(
+    assert extract_args(
         '"""Module explanation"""\ndef foo(a, b, c)',
     ) == ('"""Module explanation"""\ndef foo(', ["a", "b", "c"], ")")
 
 
 def test_split_parens_contents8():
-    assert split_parens_contents(
+    assert extract_args(
         """related_filetype_sets = [(".hdr", ".img", ".mat"), (".nii", ".mat"), (".BRIK", ".HEAD")]""",
     ) == (
         "related_filetype_sets = [",
@@ -76,10 +76,17 @@ def test_split_parens_contents8():
 
 
 def test_split_parens_contents9():
-    assert split_parens_contents(
+    assert extract_args(
         'foo(cwd=bar("tmpdir"), basename="maskexf")'
     ) == (
         "foo(",
         ['cwd=bar("tmpdir")', 'basename="maskexf"'],
         ")",
     )
+
+
+def test_source_code():
+    assert get_source_code(extract_args).splitlines()[:2] == [
+        "# Original source at L153 of <nipype2pydra-install>/utils.py",
+        "def extract_args(snippet: str) -> ty.Tuple[str, ty.List[str], str]:"
+    ]
diff --git a/nipype2pydra/utils.py b/nipype2pydra/utils.py
index 45c87ea6..54eb0822 100644
--- a/nipype2pydra/utils.py
+++ b/nipype2pydra/utils.py
@@ -12,6 +12,7 @@
 from fileformats.core import FileSet
 from .exceptions import UnmatchedParensException
 from nipype.interfaces.base import BaseInterface, TraitedSpec, isdefined, Undefined
+from nipype.interfaces.base import traits_extension
 
 try:
     from typing import GenericAlias
@@ -150,28 +151,34 @@ def add_exc_note(e, note):
     return e
 
 
-def split_parens_contents(snippet, brackets: bool = False, delimiter=","):
-    """Splits the code snippet at the first opening parenthesis into a 3-tuple
-    consisting of the pre-paren text, the contents of the parens and the post-paren
+def extract_args(snippet) -> ty.Tuple[str, ty.List[str], str]:
+    """Splits the code snippet at the first opening parenthesis/bracket into a 3-tuple
+    consisting of the preceding text + opening paren/bracket, the arguments/items
+    within the parenthesis/bracket pair, and the closing paren/bracket + trailing text.
+
+    Quotes and escaped characters are handled correctly, and the function can be used
+    to split on either parentheses or brackets. The only limitation is that raw strings
+    are not supported.
 
     Parameters
     ----------
     snippet: str
-        the code snippet to split
-    brackets: bool, optional
-        whether to split at brackets instead of parens, by default False
-    delimiter: str, optional
-        an optional delimiter to split the contents of the parens by, by default None
-        means that they aren't split
+        the code snippet to split on the first opening parenthesis/bracket to its matching
+        closing parenthesis/bracket
 
     Returns
     -------
     pre: str
-        the text before the opening parenthesis
-    contents: str or list[str]
-        the contents of the parens
+        the opening parenthesis/bracket and preceding text
+    args: list[str]
+        the arguments supplied to the callable/signature
     post: str
-        the text after the closing parenthesis
+        the closing parenthesis/bracket and trailing text
+
+    Raises
+    ------
+    UnmatchedParensException
+        if the first parenthesis/bracket in the snippet is unmatched
     """
     splits = re.split(
         r"(\(|\)|\[|\]|'|\"|\\\(|\\\)|\\\[|\\\]|\\'|\\\")",
@@ -227,10 +234,10 @@ def split_parens_contents(snippet, brackets: bool = False, delimiter=","):
             if (
                 first
                 and depth[first] == 1
-                and delimiter in s
+                and "," in s
                 and all(d == 0 for b, d in depth.items() if b != first)
             ):
-                parts = [p.strip() for p in s.split(delimiter)]
+                parts = [p.strip() for p in s.split(",")]
                 if parts:
                     next_item += parts[0]
                     next_item = next_item.strip()
@@ -274,6 +281,10 @@ class UsedSymbols:
     local_classes: ty.List[type] = attrs.field(factory=list)
     constants: ty.Set[ty.Tuple[str, str]] = attrs.field(factory=set)
 
+    IGNORE_MODULES = [
+        "traits.trait_handlers",  # Old traits module, pre v6.0
+    ]
+
     def update(self, other: "UsedSymbols"):
         self.imports.update(other.imports)
         self.funcs_to_include.update(other.funcs_to_include)
@@ -320,18 +331,16 @@ def find(
         local_constants = get_local_constants(module)
         local_classes = get_local_classes(module)
         for line in source_code.split("\n"):
-            if (line.startswith("from") and " import " in line) or line.startswith(
-                "import"
-            ):
+            if block:
+                block += line.strip()
+                if ")" in line:
+                    imports.append(block)
+                    block = ""
+            elif re.match(r"^\s*(from[\w \.]+)?import\b[\w \.\,\(\)]+$", line):
                 if "(" in line and ")" not in line:
                     block = line.strip()
                 else:
                     imports.append(line.strip())
-            elif ")" in line and block:
-                imports.append(block + line.strip())
-                block = ""
-            elif block:
-                block += line.strip()
         # extract imported symbols from import statements
         symbols_re = re.compile(r"(?<!\"|')\b(\w+)\b(?!\"|')")
         comments_re = re.compile(r"\s*#.*")
@@ -361,9 +370,11 @@ def find(
                     local_class.__name__ in used_symbols
                     and local_class not in used.local_classes
                 ):
+                    if issubclass(local_class, (BaseInterface, TraitedSpec)):
+                        continue
                     used.local_classes.append(local_class)
                     class_body = inspect.getsource(local_class)
-                    bases = split_parens_contents(class_body)[1]
+                    bases = extract_args(class_body)[1]
                     used_symbols.update(bases)
                     class_body = comments_re.sub("", class_body)
                     local_class_symbols = symbols_re.findall(class_body)
@@ -379,6 +390,12 @@ def find(
                     used_symbols.update(const_def_symbols)
                     new_symbols = True
         used_symbols -= set(cls.SYMBOLS_TO_IGNORE)
+
+        pkg_name = module.__name__.split(".", 1)[0]
+
+        def is_pkg_import(mod_name: str) -> bool:
+            return mod_name.startswith(".") or mod_name.startswith(f"{pkg_name}.")
+
         # functions to copy from a relative or nipype module into the output module
         for stmt in imports:
             stmt = stmt.replace("\n", "")
@@ -394,10 +411,12 @@ def find(
                     + "import "
                     + ", ".join(" as ".join(p) for p in used_parts)
                 )
-                match = re.match(r"from ([\w\.]+)", base_stmt)
+                match = re.match(r"\s*from ([\w\.]+)", base_stmt)
                 import_mod = match.group(1) if match else ""
+                if import_mod in cls.IGNORE_MODULES:
+                    continue
                 if import_mod:
-                    if import_mod.startswith(".") or import_mod.startswith("nipype."):
+                    if is_pkg_import(import_mod):
                         to_include = True
                         if import_mod.startswith("."):
                             match = re.match(r"(\.*)(.*)", import_mod)
@@ -415,7 +434,7 @@ def find(
                         else:
                             assert False
                     else:
-                        to_include = True
+                        to_include = False
                         mod_name = import_mod
                     mod = import_module(mod_name)
                     # Filter out any interfaces that have been dragged in
@@ -429,7 +448,13 @@ def find(
                                     getattr(mod, p[0]), (BaseInterface, TraitedSpec)
                                 )
                             )
-                            or getattr(mod, p[0]) in (Undefined, isdefined)
+                            or getattr(mod, p[0])
+                            in (
+                                Undefined,
+                                isdefined,
+                                traits_extension.File,
+                                traits_extension.Directory,
+                            )
                         )
                     ]
                     if not used_parts:
@@ -438,11 +463,10 @@ def find(
                         mod_func_bodies = []
                         for used_part in used_parts:
                             atr = getattr(mod, used_part[0])
+                            # Check that it is actually a local import
                             if (
                                 inspect.isfunction(atr) or inspect.isclass(atr)
-                            ) and not atr.__module__.startswith(
-                                "nipype."
-                            ):  # Check that it is actually a local import
+                            ) and not is_pkg_import(atr.__module__):
                                 used.imports.add(
                                     f"from {atr.__module__} import "
                                     + " as ".join(used_part)
@@ -458,9 +482,9 @@ def find(
                                 class_def = (used_part[-1], atr)
                                 if class_def not in used.classes_to_include:
                                     used.classes_to_include.append(class_def)
-                                class_body = split_parens_contents(
-                                    inspect.getsource(atr)
-                                )[2].split("\n", 1)[1]
+                                class_body = extract_args(inspect.getsource(atr))[
+                                    2
+                                ].split("\n", 1)[1]
                                 mod_func_bodies.append(class_body)
                         # Recursively include neighbouring objects imported in the module
                         if mod is not builtins:
@@ -511,7 +535,7 @@ def get_local_constants(mod):
         if ("(" in first_line and ")" not in first_line) or (
             "[" in first_line and "]" not in first_line
         ):
-            pre, args, post = split_parens_contents(following)
+            pre, args, post = extract_args(following)
             local_vars.append(
                 (attr_name, pre + re.sub(r"\n *", "", ", ".join(args)) + post[0])
             )
@@ -536,7 +560,7 @@ def cleanup_function_body(function_body: str) -> str:
     function_body: str
         The processed source code
     """
-    if re.match(r".*\n?\s*(def|class)\s+", function_body):
+    if re.match(r"(\s*#.*\n)?(\s*@.*\n)*\s*(def|class)\s+", function_body):
         with_signature = True
     else:
         with_signature = False
@@ -557,13 +581,13 @@ def cleanup_function_body(function_body: str) -> str:
     parts = re.split(r"not isdefined\b", function_body, flags=re.MULTILINE)
     new_function_body = parts[0]
     for part in parts[1:]:
-        pre, args, post = split_parens_contents(part)
+        pre, args, post = extract_args(part)
         new_function_body += pre + f"{args[0]} is attrs.NOTHING" + post
     function_body = new_function_body
     parts = re.split(r"isdefined\b", function_body, flags=re.MULTILINE)
     new_function_body = parts[0]
     for part in parts[1:]:
-        pre, args, post = split_parens_contents(part)
+        pre, args, post = extract_args(part)
         assert len(args) == 1, f"Unexpected number of arguments in isdefined: {args}"
         new_function_body += pre + f"{args[0]} is not attrs.NOTHING" + post
     function_body = new_function_body
@@ -588,7 +612,26 @@ def insert_args_in_signature(snippet: str, new_args: ty.Iterable[str]) -> str:
         the modified function signature
     """
     # Split out the argstring from the rest of the code snippet
-    pre, args, post = split_parens_contents(snippet)
+    pre, args, post = extract_args(snippet)
     if "runtime" in args:
         args.remove("runtime")
     return pre + ", ".join(args + new_args) + post
+
+
+def get_source_code(func_or_klass: ty.Union[ty.Callable, ty.Type]) -> str:
+    """Get the source code of a function or class, including a comment with the
+    original source location
+    """
+    src = inspect.getsource(func_or_klass)
+    line_number = inspect.getsourcelines(func_or_klass)[1]
+    module = inspect.getmodule(func_or_klass)
+    rel_module_path = os.path.sep.join(
+        module.__name__.split(".")[1:-1] + [Path(module.__file__).name]
+    )
+    install_placeholder = f"<{module.__name__.split('.', 1)[0]}-install>"
+    indent = re.match(r"^(\s*)", src).group(1)
+    comment = (
+        f"{indent}# Original source at L{line_number} of "
+        f"{install_placeholder}{os.path.sep}{rel_module_path}\n"
+    )
+    return comment + src

From c517d6fa785df4ef1b5b1970a306669d6d6cd6d8 Mon Sep 17 00:00:00 2001
From: Tom Close <tom.g.close@gmail.com>
Date: Thu, 14 Mar 2024 17:37:42 +1100
Subject: [PATCH 64/78] reordered how callables files are written

---
 .../task/nipype/afni/a_boverlap_callables.py  | 182 ++---
 .../nipype/afni/afn_ito_nifti_callables.py    | 108 +--
 .../afni/align_epi_anat_py_callables.py       | 433 ++++++-----
 .../task/nipype/afni/allineate_callables.py   | 684 +++++++++---------
 .../nipype/afni/auto_tcorrelate_callables.py  | 100 +--
 .../task/nipype/afni/auto_tlrc_callables.py   | 221 +++---
 .../task/nipype/afni/autobox_callables.py     | 198 ++---
 .../task/nipype/afni/automask_callables.py    | 190 ++---
 .../task/nipype/afni/axialize_callables.py    | 182 ++---
 .../task/nipype/afni/bandpass_callables.py    | 182 ++---
 .../nipype/afni/blur_in_mask_callables.py     | 182 ++---
 .../nipype/afni/blur_to_fwhm_callables.py     | 182 ++---
 .../task/nipype/afni/brick_stat_callables.py  | 140 ++--
 .../task/nipype/afni/bucket_callables.py      | 182 ++---
 .../task/nipype/afni/calc_callables.py        | 182 ++---
 .../task/nipype/afni/cat_callables.py         | 182 ++---
 .../task/nipype/afni/cat_matvec_callables.py  | 182 ++---
 .../task/nipype/afni/center_mass.yaml         |   2 +-
 .../task/nipype/afni/center_mass_callables.py | 170 ++---
 .../task/nipype/afni/clip_level_callables.py  | 140 ++--
 .../nipype/afni/convert_dset_callables.py     |   1 -
 .../task/nipype/afni/copy_callables.py        | 182 ++---
 .../task/nipype/afni/deconvolve_callables.py  | 280 +++----
 .../afni/degree_centrality_callables.py       | 412 +++++------
 .../task/nipype/afni/despike_callables.py     | 182 ++---
 .../task/nipype/afni/detrend_callables.py     | 182 ++---
 example-specs/task/nipype/afni/dot.yaml       |   2 +-
 .../task/nipype/afni/dot_callables.py         | 182 ++---
 .../task/nipype/afni/ecm_callables.py         | 182 ++---
 .../task/nipype/afni/edge_3_callables.py      | 182 ++---
 .../task/nipype/afni/eval_callables.py        | 182 ++---
 .../task/nipype/afni/fim_callables.py         | 182 ++---
 .../task/nipype/afni/fourier_callables.py     | 182 ++---
 .../task/nipype/afni/fwh_mx_callables.py      | 204 +++---
 .../task/nipype/afni/gcor_callables.py        |   2 -
 .../task/nipype/afni/hist_callables.py        | 158 ++--
 .../task/nipype/afni/lfcd_callables.py        | 182 ++---
 .../nipype/afni/local_bistat_callables.py     | 182 ++---
 .../task/nipype/afni/localstat_callables.py   | 182 ++---
 .../task/nipype/afni/mask_tool_callables.py   | 182 ++---
 .../task/nipype/afni/maskave_callables.py     | 182 ++---
 .../task/nipype/afni/means_callables.py       | 182 ++---
 .../task/nipype/afni/merge_callables.py       | 182 ++---
 .../task/nipype/afni/net_corr_callables.py    | 256 +++----
 .../task/nipype/afni/notes_callables.py       |   1 -
 .../nipype/afni/nwarp_adjust_callables.py     |   1 -
 .../task/nipype/afni/nwarp_apply_callables.py | 140 ++--
 .../task/nipype/afni/nwarp_cat_callables.py   | 240 +++---
 .../task/nipype/afni/one_d_tool_py.yaml       |   2 +-
 .../nipype/afni/one_d_tool_py_callables.py    |   2 +-
 .../nipype/afni/outlier_count_callables.py    |   9 +-
 .../nipype/afni/quality_index_callables.py    | 140 ++--
 example-specs/task/nipype/afni/qwarp.yaml     |   2 +-
 .../task/nipype/afni/qwarp_callables.py       | 420 +++++------
 .../task/nipype/afni/qwarp_plus_minus.yaml    |   2 +-
 .../nipype/afni/qwarp_plus_minus_callables.py | 420 +++++------
 .../task/nipype/afni/re_ho_callables.py       | 158 ++--
 .../task/nipype/afni/refit_callables.py       |   1 -
 .../task/nipype/afni/remlfit_callables.py     |  54 +-
 .../task/nipype/afni/resample_callables.py    | 182 ++---
 .../task/nipype/afni/retroicor_callables.py   | 182 ++---
 .../task/nipype/afni/roi_stats_callables.py   | 140 ++--
 .../task/nipype/afni/seg_callables.py         | 140 ++--
 .../task/nipype/afni/skull_strip_callables.py | 182 ++---
 .../task/nipype/afni/svm_test_callables.py    | 182 ++---
 .../task/nipype/afni/svm_train_callables.py   | 190 ++---
 .../task/nipype/afni/synthesize_callables.py  |   2 +-
 .../task/nipype/afni/t_cat_callables.py       | 182 ++---
 .../nipype/afni/t_cat_sub_brick_callables.py  | 380 +++++-----
 .../task/nipype/afni/t_corr_1d_callables.py   | 182 ++---
 .../task/nipype/afni/t_corr_map.yaml          |   2 +-
 .../task/nipype/afni/t_corr_map_callables.py  | 234 +++---
 .../task/nipype/afni/t_correlate_callables.py | 182 ++---
 .../task/nipype/afni/t_norm_callables.py      | 182 ++---
 .../task/nipype/afni/t_project_callables.py   | 182 ++---
 .../task/nipype/afni/t_shift_callables.py     | 422 +++++------
 .../task/nipype/afni/t_smooth_callables.py    | 182 ++---
 .../task/nipype/afni/t_stat_callables.py      | 182 ++---
 .../task/nipype/afni/to_3d_callables.py       | 182 ++---
 .../task/nipype/afni/undump_callables.py      | 182 ++---
 .../task/nipype/afni/unifize_callables.py     | 190 ++---
 .../task/nipype/afni/volreg_callables.py      | 194 ++---
 .../task/nipype/afni/warp_callables.py        | 372 +++++-----
 .../task/nipype/afni/z_cut_up_callables.py    | 182 ++---
 .../task/nipype/afni/zcat_callables.py        | 182 ++---
 .../task/nipype/afni/zeropad_callables.py     | 182 ++---
 .../ants/affine_initializer_callables.py      |   1 -
 .../task/nipype/ants/ai_callables.py          |   2 -
 .../task/nipype/ants/ants_callables.py        |  15 +-
 .../ants/ants_introduction_callables.py       |  14 +-
 .../nipype/ants/apply_transforms_callables.py |  54 +-
 .../apply_transforms_to_points_callables.py   | 140 ++--
 .../task/nipype/ants/atropos_callables.py     |  64 +-
 .../average_affine_transform_callables.py     |   1 -
 .../nipype/ants/average_images_callables.py   |   1 -
 .../nipype/ants/brain_extraction_callables.py |  16 +-
 .../ants/buildtemplateparallel_callables.py   |  83 ++-
 .../ants/compose_multi_transform_callables.py | 140 ++--
 .../composite_transform_util_callables.py     |   1 -
 .../convert_scalar_image_to_rgb_callables.py  |   1 -
 .../ants/cortical_thickness_callables.py      |  39 +-
 ...te_jacobian_determinant_image_callables.py |   1 -
 .../ants/create_tiled_mosaic_callables.py     |   1 -
 .../nipype/ants/denoise_image_callables.py    | 148 ++--
 .../nipype/ants/gen_warp_fields_callables.py  |  14 +-
 .../task/nipype/ants/image_math_callables.py  | 140 ++--
 .../nipype/ants/joint_fusion_callables.py     |  14 +-
 .../nipype/ants/kelly_kapowski_callables.py   | 172 ++---
 .../nipype/ants/label_geometry_callables.py   | 140 ++--
 .../ants/laplacian_thickness_callables.py     | 140 ++--
 .../measure_image_similarity_callables.py     | 140 ++--
 .../nipype/ants/multiply_images_callables.py  |   1 -
 .../n4_bias_field_correction_callables.py     | 164 ++---
 .../nipype/ants/registration_callables.py     | 120 +--
 .../ants/registration_syn_quick_callables.py  |  21 +-
 .../resample_image_by_spacing_callables.py    | 140 ++--
 .../nipype/ants/threshold_image_callables.py  | 140 ++--
 .../warp_image_multi_transform_callables.py   |  54 +-
 ..._series_image_multi_transform_callables.py |  21 +-
 .../add_x_form_to_header_callables.py         |   1 -
 .../freesurfer/aparc_2_aseg_callables.py      |   1 -
 .../freesurfer/apas_2_aseg_callables.py       |   1 -
 .../nipype/freesurfer/apply_mask_callables.py | 140 ++--
 .../apply_vol_transform_callables.py          |  68 +-
 .../freesurfer/bb_register_callables.py       | 142 ++--
 .../nipype/freesurfer/binarize_callables.py   |  84 +--
 .../nipype/freesurfer/ca_label_callables.py   |   1 -
 .../freesurfer/ca_normalize_callables.py      |   9 +-
 .../freesurfer/ca_register_callables.py       |   1 -
 .../check_talairach_alignment_callables.py    |   2 -
 .../freesurfer/concatenate_callables.py       |   2 +-
 .../freesurfer/concatenate_lta_callables.py   | 140 ++--
 .../nipype/freesurfer/contrast_callables.py   |   9 +-
 .../nipype/freesurfer/curvature_callables.py  |   9 +-
 .../freesurfer/curvature_stats_callables.py   |   1 -
 .../freesurfer/dicom_convert_callables.py     | 141 ++--
 .../freesurfer/edit_w_mwith_aseg_callables.py |   1 -
 .../freesurfer/em_register_callables.py       |   1 -
 .../freesurfer/euler_number_callables.py      |  10 +-
 .../extract_main_component_callables.py       | 140 ++--
 .../freesurfer/fit_ms_params_callables.py     |  10 +-
 .../freesurfer/fix_topology_callables.py      |   1 -
 .../fuse_segmentations_callables.py           |   1 -
 .../nipype/freesurfer/glm_fit_callables.py    | 170 ++---
 .../nipype/freesurfer/gtm_seg_callables.py    |   1 -
 .../nipype/freesurfer/gtmpvc_callables.py     |  78 +-
 .../nipype/freesurfer/image_info_callables.py | 184 ++---
 .../nipype/freesurfer/jacobian_callables.py   |   1 -
 .../freesurfer/label_2_annot_callables.py     |   1 -
 .../freesurfer/label_2_label_callables.py     |   1 -
 .../freesurfer/label_2_vol_callables.py       |  60 +-
 .../nipype/freesurfer/logan_ref_callables.py  | 170 ++---
 .../freesurfer/lta_convert_callables.py       |  21 +-
 .../make_average_subject_callables.py         |   2 -
 .../freesurfer/make_surfaces_callables.py     |  26 +-
 .../mni_bias_correction_callables.py          | 140 ++--
 .../freesurfer/mp_rto_mni305_callables.py     |  73 +-
 .../freesurfer/mr_is_ca_label_callables.py    |   1 -
 .../nipype/freesurfer/mr_is_calc_callables.py |   1 -
 .../freesurfer/mr_is_combine_callables.py     |   1 -
 .../freesurfer/mr_is_convert_callables.py     |  88 +--
 .../freesurfer/mr_is_expand_callables.py      |   1 -
 .../freesurfer/mr_is_inflate_callables.py     |   1 -
 .../freesurfer/mri_convert_callables.py       | 142 ++--
 .../nipype/freesurfer/mri_coreg_callables.py  |  14 +-
 .../nipype/freesurfer/mri_fill_callables.py   |  10 +-
 .../mri_marching_cubes_callables.py           |  58 +-
 .../freesurfer/mri_pretess_callables.py       | 140 ++--
 .../freesurfer/mri_tessellate_callables.py    |  62 +-
 .../freesurfer/mris_preproc_callables.py      |   2 +-
 .../mris_preproc_recon_all_callables.py       |   2 +-
 .../task/nipype/freesurfer/mrtm2_callables.py | 170 ++---
 .../task/nipype/freesurfer/mrtm_callables.py  | 170 ++---
 .../nipype/freesurfer/ms__lda_callables.py    |  10 +-
 .../nipype/freesurfer/normalize_callables.py  |   1 -
 .../freesurfer/one_sample_t_test_callables.py | 170 ++---
 .../task/nipype/freesurfer/paint_callables.py |   1 -
 .../parcellation_stats_callables.py           |  18 +-
 .../freesurfer/parse_dicom_dir_callables.py   |   2 +-
 .../nipype/freesurfer/recon_all_callables.py  | 166 ++---
 .../register_av_ito_talairach_callables.py    |   9 +-
 .../nipype/freesurfer/register_callables.py   |   2 +-
 .../relabel_hypointensities_callables.py      |   1 -
 .../remove_intersection_callables.py          |   1 -
 .../freesurfer/remove_neck_callables.py       |   1 -
 .../nipype/freesurfer/resample_callables.py   |  60 +-
 .../freesurfer/robust_register_callables.py   |  93 ++-
 .../freesurfer/robust_template_callables.py   |  10 +-
 .../freesurfer/sample_to_surface_callables.py | 144 ++--
 .../nipype/freesurfer/seg_stats_callables.py  |  92 +--
 .../seg_stats_recon_all_callables.py          |  92 +--
 .../nipype/freesurfer/segment_cc_callables.py |   1 -
 .../nipype/freesurfer/segment_wm_callables.py |   1 -
 .../nipype/freesurfer/smooth_callables.py     | 128 ++--
 .../smooth_tessellation_callables.py          |  58 +-
 .../nipype/freesurfer/sphere_callables.py     |   1 -
 .../freesurfer/spherical_average_callables.py |  10 +-
 .../surface_2_vol_transform_callables.py      | 140 ++--
 .../freesurfer/surface_smooth_callables.py    |  52 +-
 .../freesurfer/surface_snapshots_callables.py | 156 ++--
 .../freesurfer/surface_transform_callables.py | 124 ++--
 .../freesurfer/synthesize_flash_callables.py  | 128 ++--
 .../freesurfer/talairach_avi_callables.py     |   1 -
 .../freesurfer/talairach_qc_callables.py      |   1 -
 .../freesurfer/tkregister_2_callables.py      |  68 +-
 .../freesurfer/unpack_sdicom_dir_callables.py | 141 ++--
 .../freesurfer/volume_mask_callables.py       |   9 +-
 .../watershed_skull_strip_callables.py        |   1 -
 .../nipype/fsl/accuracy_tester_callables.py   |   2 +-
 .../task/nipype/fsl/apply_mask_callables.py   | 228 +++---
 .../task/nipype/fsl/apply_topup_callables.py  | 354 ++++-----
 .../task/nipype/fsl/apply_warp_callables.py   | 228 +++---
 .../task/nipype/fsl/apply_xfm_callables.py    | 362 ++++-----
 .../task/nipype/fsl/ar1_image_callables.py    | 228 +++---
 .../task/nipype/fsl/av_scale_callables.py     |  38 +-
 .../task/nipype/fsl/b0_calc_callables.py      | 354 ++++-----
 .../task/nipype/fsl/bedpostx5_callables.py    | 449 ++++++------
 .../task/nipype/fsl/bet_callables.py          | 508 ++++++-------
 .../task/nipype/fsl/binary_maths_callables.py | 228 +++---
 .../nipype/fsl/change_data_type_callables.py  | 228 +++---
 .../task/nipype/fsl/classifier_callables.py   |  11 +-
 .../task/nipype/fsl/cleaner_callables.py      |   1 -
 .../task/nipype/fsl/cluster_callables.py      | 266 +++----
 .../task/nipype/fsl/complex_callables.py      | 436 +++++------
 .../task/nipype/fsl/contrast_mgr_callables.py | 446 ++++++------
 .../task/nipype/fsl/convert_warp_callables.py | 354 ++++-----
 .../task/nipype/fsl/convert_xfm_callables.py  | 160 ++--
 .../task/nipype/fsl/copy_geom_callables.py    | 354 ++++-----
 .../task/nipype/fsl/dilate_image_callables.py | 228 +++---
 .../task/nipype/fsl/distance_map_callables.py |  60 +-
 .../task/nipype/fsl/dti_fit_callables.py      | 286 ++++----
 .../nipype/fsl/dual_regression_callables.py   |   2 +-
 .../task/nipype/fsl/eddy_callables.py         |  58 +-
 .../task/nipype/fsl/eddy_correct_callables.py | 354 ++++-----
 .../task/nipype/fsl/eddy_quad_callables.py    |  30 +-
 .../task/nipype/fsl/epi_de_warp_callables.py  | 384 +++++-----
 .../task/nipype/fsl/epi_reg_callables.py      |  46 +-
 .../task/nipype/fsl/erode_image_callables.py  | 228 +++---
 .../task/nipype/fsl/extract_roi_callables.py  | 260 +++----
 .../task/nipype/fsl/fast_callables.py         | 490 ++++++-------
 .../task/nipype/fsl/feat_callables.py         |   1 -
 .../task/nipype/fsl/feat_model_callables.py   |  39 +-
 .../nipype/fsl/feature_extractor_callables.py |   2 -
 .../task/nipype/fsl/filmgls_callables.py      | 508 ++++++-------
 .../nipype/fsl/filter_regressor_callables.py  | 228 +++---
 .../nipype/fsl/find_the_biggest_callables.py  | 230 +++---
 .../task/nipype/fsl/first_callables.py        | 150 ++--
 .../task/nipype/fsl/flameo_callables.py       |  82 +--
 .../task/nipype/fsl/flirt_callables.py        | 362 ++++-----
 .../task/nipype/fsl/fnirt_callables.py        | 284 ++++----
 .../task/nipype/fsl/fugue_callables.py        | 370 +++++-----
 .../task/nipype/fsl/glm_callables.py          | 480 ++++++------
 .../task/nipype/fsl/ica__aroma_callables.py   |   1 -
 .../task/nipype/fsl/image_maths_callables.py  | 234 +++---
 .../task/nipype/fsl/image_meants_callables.py | 232 +++---
 .../task/nipype/fsl/image_stats_callables.py  | 354 ++++-----
 .../task/nipype/fsl/inv_warp_callables.py     | 354 ++++-----
 .../nipype/fsl/isotropic_smooth_callables.py  | 228 +++---
 .../task/nipype/fsl/l2_model_callables.py     |  24 +-
 .../nipype/fsl/level_1_design_callables.py    |  58 +-
 .../fsl/make_dyadic_vectors_callables.py      | 239 +++---
 .../nipype/fsl/maths_command_callables.py     | 228 +++---
 .../task/nipype/fsl/max_image_callables.py    | 228 +++---
 .../task/nipype/fsl/maxn_image_callables.py   | 228 +++---
 .../task/nipype/fsl/mcflirt_callables.py      | 384 +++++-----
 .../task/nipype/fsl/mean_image_callables.py   | 228 +++---
 .../task/nipype/fsl/median_image_callables.py | 228 +++---
 .../task/nipype/fsl/melodic_callables.py      |   2 +-
 .../task/nipype/fsl/merge_callables.py        | 354 ++++-----
 .../task/nipype/fsl/min_image_callables.py    | 228 +++---
 .../nipype/fsl/motion_outliers_callables.py   | 362 ++++-----
 .../nipype/fsl/multi_image_maths_callables.py | 228 +++---
 .../fsl/multiple_regress_design_callables.py  |  27 +-
 .../task/nipype/fsl/overlay_callables.py      | 350 ++++-----
 .../nipype/fsl/percentile_image_callables.py  | 228 +++---
 .../fsl/plot_motion_params_callables.py       |  50 +-
 .../nipype/fsl/plot_time_series_callables.py  | 236 +++---
 .../nipype/fsl/power_spectrum_callables.py    | 246 +++----
 .../task/nipype/fsl/prelude_callables.py      | 248 +++----
 .../nipype/fsl/prepare_fieldmap_callables.py  |   2 -
 .../nipype/fsl/prob_track_x2_callables.py     | 446 ++++++------
 .../task/nipype/fsl/prob_track_x_callables.py | 358 ++++-----
 .../task/nipype/fsl/proj_thresh_callables.py  | 227 +++---
 .../task/nipype/fsl/randomise_callables.py    | 353 +++++----
 .../nipype/fsl/reorient_2_std_callables.py    | 236 +++---
 .../task/nipype/fsl/robust_fov_callables.py   | 354 ++++-----
 .../task/nipype/fsl/sig_loss_callables.py     | 226 +++---
 .../task/nipype/fsl/slice_callables.py        | 250 +++----
 .../task/nipype/fsl/slice_timer_callables.py  | 228 +++---
 .../task/nipype/fsl/slicer_callables.py       | 228 +++---
 .../task/nipype/fsl/smm_callables.py          | 266 +++----
 .../task/nipype/fsl/smooth_callables.py       | 354 ++++-----
 .../nipype/fsl/smooth_estimate_callables.py   | 362 ++++-----
 .../nipype/fsl/spatial_filter_callables.py    | 228 +++---
 .../task/nipype/fsl/split_callables.py        |  54 +-
 .../task/nipype/fsl/std_image_callables.py    | 228 +++---
 .../task/nipype/fsl/susan_callables.py        | 228 +++---
 .../nipype/fsl/swap_dimensions_callables.py   | 228 +++---
 .../nipype/fsl/temporal_filter_callables.py   | 228 +++---
 .../task/nipype/fsl/text_2_vest_callables.py  | 354 ++++-----
 .../task/nipype/fsl/threshold_callables.py    | 228 +++---
 .../task/nipype/fsl/topup_callables.py        | 512 ++++++-------
 .../nipype/fsl/tract_skeleton_callables.py    |  48 +-
 .../task/nipype/fsl/training_callables.py     |   2 +-
 .../fsl/training_set_creator_callables.py     |  15 +-
 .../task/nipype/fsl/unary_maths_callables.py  | 244 +++----
 .../task/nipype/fsl/vec_reg_callables.py      | 234 +++---
 .../task/nipype/fsl/vest_2_text_callables.py  | 354 ++++-----
 .../task/nipype/fsl/warp_points_callables.py  | 142 ++--
 .../fsl/warp_points_from_std_callables.py     |   1 -
 .../fsl/warp_points_to_std_callables.py       | 142 ++--
 .../task/nipype/fsl/warp_utils_callables.py   | 354 ++++-----
 .../task/nipype/fsl/x_fibres_5_callables.py   | 384 +++++-----
 nipype2pydra/pkg_gen/__init__.py              |  77 +-
 314 files changed, 23061 insertions(+), 23082 deletions(-)

diff --git a/example-specs/task/nipype/afni/a_boverlap_callables.py b/example-specs/task/nipype/afni/a_boverlap_callables.py
index 6671798a..399660e5 100644
--- a/example-specs/task/nipype/afni/a_boverlap_callables.py
+++ b/example-specs/task/nipype/afni/a_boverlap_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of ABoverlap.yaml"""
 
-from looseversion import LooseVersion
 import attrs
 import logging
 import os
 import os.path as op
+from looseversion import LooseVersion
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,17 +17,6 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
@@ -123,6 +112,33 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
 # Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
@@ -143,47 +159,20 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
-
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
-
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
-
-            klass._version = klass.parse_version(raw_info)
-
-        return klass._version
-
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
 
 
 # Original source at L58 of <nipype-install>/utils/filemanip.py
@@ -237,6 +226,55 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
@@ -319,41 +357,3 @@ def standard_image(img_name):
         out = clout.runtime.stdout
         basedir = os.path.split(out)[0]
         return os.path.join(basedir, img_name)
-
-
-# Original source at L242 of <nipype-install>/interfaces/afni/base.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    path, base, _ = split_filename(value)
-    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def nipype_interfaces_afni__AFNICommand___list_outputs(
-    inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
diff --git a/example-specs/task/nipype/afni/afn_ito_nifti_callables.py b/example-specs/task/nipype/afni/afn_ito_nifti_callables.py
index b300a94d..ba36bc86 100644
--- a/example-specs/task/nipype/afni/afn_ito_nifti_callables.py
+++ b/example-specs/task/nipype/afni/afn_ito_nifti_callables.py
@@ -16,24 +16,6 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def nipype_interfaces_afni__AFNICommand___gen_filename(
-    name, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    raise NotImplementedError
-
-
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
@@ -129,6 +111,35 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L165 of <nipype-install>/interfaces/afni/utils.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    return os.path.abspath(nipype_interfaces_afni__AFNICommand___gen_filename(name))
+
+
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+# Original source at L159 of <nipype-install>/interfaces/afni/utils.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, ext = split_filename(value)
+    if ext.lower() not in [".nii", ".nii.gz", ".1d", ".1D"]:
+        ext += ".nii"
+    return os.path.join(path, base + ext)
+
+
 # Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
@@ -149,19 +160,27 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
-# Original source at L159 of <nipype-install>/interfaces/afni/utils.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def nipype_interfaces_afni__AFNICommand___gen_filename(
+    name, inputs=None, stdout=None, stderr=None, output_dir=None
 ):
-    path, base, ext = split_filename(value)
-    if ext.lower() not in [".nii", ".nii.gz", ".1d", ".1D"]:
-        ext += ".nii"
-    return os.path.join(path, base + ext)
+    raise NotImplementedError
 
 
-# Original source at L165 of <nipype-install>/interfaces/afni/utils.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    return os.path.abspath(nipype_interfaces_afni__AFNICommand___gen_filename(name))
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
 
 
 # Original source at L58 of <nipype-install>/utils/filemanip.py
@@ -215,31 +234,12 @@ def split_filename(fname):
     return pth, fname, ext
 
 
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def nipype_interfaces_afni__AFNICommand___list_outputs(
-    inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
 
+    def __init__(self, value):
+        self.value = value
 
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
+    def __str__(self):
+        return "{}".format(self.value)
diff --git a/example-specs/task/nipype/afni/align_epi_anat_py_callables.py b/example-specs/task/nipype/afni/align_epi_anat_py_callables.py
index 1a3eb2c6..73e3736d 100644
--- a/example-specs/task/nipype/afni/align_epi_anat_py_callables.py
+++ b/example-specs/task/nipype/afni/align_epi_anat_py_callables.py
@@ -1,66 +1,65 @@
 """Module to put any functions that are referred to in the "callables" section of AlignEpiAnatPy.yaml"""
 
-from looseversion import LooseVersion
-import attrs
 import os
 import os.path as op
+from looseversion import LooseVersion
 from pathlib import Path
 
 
-def anat_al_orig_callable(output_dir, inputs, stdout, stderr):
+def anat_al_mat_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["anat_al_orig"]
+    return outputs["anat_al_mat"]
 
 
-def epi_al_orig_callable(output_dir, inputs, stdout, stderr):
+def anat_al_orig_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["epi_al_orig"]
+    return outputs["anat_al_orig"]
 
 
-def epi_tlrc_al_callable(output_dir, inputs, stdout, stderr):
+def epi_al_mat_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["epi_tlrc_al"]
+    return outputs["epi_al_mat"]
 
 
-def anat_al_mat_callable(output_dir, inputs, stdout, stderr):
+def epi_al_orig_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["anat_al_mat"]
+    return outputs["epi_al_orig"]
 
 
-def epi_al_mat_callable(output_dir, inputs, stdout, stderr):
+def epi_al_tlrc_mat_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["epi_al_mat"]
+    return outputs["epi_al_tlrc_mat"]
 
 
-def epi_vr_al_mat_callable(output_dir, inputs, stdout, stderr):
+def epi_reg_al_mat_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["epi_vr_al_mat"]
+    return outputs["epi_reg_al_mat"]
 
 
-def epi_reg_al_mat_callable(output_dir, inputs, stdout, stderr):
+def epi_tlrc_al_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["epi_reg_al_mat"]
+    return outputs["epi_tlrc_al"]
 
 
-def epi_al_tlrc_mat_callable(output_dir, inputs, stdout, stderr):
+def epi_vr_al_mat_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["epi_al_tlrc_mat"]
+    return outputs["epi_vr_al_mat"]
 
 
 def epi_vr_motion_callable(output_dir, inputs, stdout, stderr):
@@ -77,42 +76,179 @@ def skullstrip_callable(output_dir, inputs, stdout, stderr):
     return outputs["skullstrip"]
 
 
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
 
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
 
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
+# Original source at L260 of <nipype-install>/interfaces/afni/base.py
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """
+    Generate a filename based on the given parameters.
 
-            klass._version = klass.parse_version(raw_info)
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
 
-        return klass._version
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
 
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+    if not basename:
+        msg = "Unable to generate filename for command %s. " % "align_epi_anat.py"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.outputtype)
+    if change_ext:
+        suffix = "".join((suffix, ext)) if suffix else ext
+
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+# Original source at L197 of <nipype-install>/interfaces/afni/preprocess.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    anat_prefix = _gen_fname(
+        inputs.anat, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+    )
+    epi_prefix = _gen_fname(
+        inputs.in_file,
+        inputs=inputs,
+        stdout=stdout,
+        stderr=stderr,
+        output_dir=output_dir,
+    )
+    if "+" in anat_prefix:
+        anat_prefix = "".join(anat_prefix.split("+")[:-1])
+    if "+" in epi_prefix:
+        epi_prefix = "".join(epi_prefix.split("+")[:-1])
+    outputtype = inputs.outputtype
+    if outputtype == "AFNI":
+        ext = ".HEAD"
+    else:
+        ext = Info.output_type_to_ext(outputtype)
+    matext = ".1D"
+    suffix = inputs.suffix
+    if inputs.anat2epi:
+        outputs["anat_al_orig"] = _gen_fname(
+            anat_prefix,
+            suffix=suffix + "+orig",
+            ext=ext,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+        outputs["anat_al_mat"] = _gen_fname(
+            anat_prefix,
+            suffix=suffix + "_mat.aff12",
+            ext=matext,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    if inputs.epi2anat:
+        outputs["epi_al_orig"] = _gen_fname(
+            epi_prefix,
+            suffix=suffix + "+orig",
+            ext=ext,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+        outputs["epi_al_mat"] = _gen_fname(
+            epi_prefix,
+            suffix=suffix + "_mat.aff12",
+            ext=matext,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    if inputs.volreg == "on":
+        outputs["epi_vr_al_mat"] = _gen_fname(
+            epi_prefix,
+            suffix="_vr" + suffix + "_mat.aff12",
+            ext=matext,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+        if inputs.tshift == "on":
+            outputs["epi_vr_motion"] = _gen_fname(
+                epi_prefix,
+                suffix="tsh_vr_motion",
+                ext=matext,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+        elif inputs.tshift == "off":
+            outputs["epi_vr_motion"] = _gen_fname(
+                epi_prefix,
+                suffix="vr_motion",
+                ext=matext,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    if inputs.volreg == "on" and inputs.epi2anat:
+        outputs["epi_reg_al_mat"] = _gen_fname(
+            epi_prefix,
+            suffix="_reg" + suffix + "_mat.aff12",
+            ext=matext,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    if inputs.save_skullstrip:
+        outputs.skullstrip = _gen_fname(
+            anat_prefix,
+            suffix="_ns" + "+orig",
+            ext=ext,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    return outputs
 
 
 # Original source at L108 of <nipype-install>/utils/filemanip.py
@@ -209,64 +345,42 @@ def split_filename(fname):
     return pth, fname, ext
 
 
-# Original source at L260 of <nipype-install>/interfaces/afni/base.py
-def _gen_fname(
-    basename,
-    cwd=None,
-    suffix=None,
-    change_ext=True,
-    ext=None,
-    inputs=None,
-    stdout=None,
-    stderr=None,
-    output_dir=None,
-):
-    """
-    Generate a filename based on the given parameters.
-
-    The filename will take the form: cwd/basename<suffix><ext>.
-    If change_ext is True, it will use the extensions specified in
-    <instance>inputs.output_type.
-
-    Parameters
-    ----------
-    basename : str
-        Filename to base the new filename on.
-    cwd : str
-        Path to prefix to the new filename. (default is output_dir)
-    suffix : str
-        Suffix to add to the `basename`.  (defaults is '' )
-    change_ext : bool
-        Flag to change the filename extension to the FSL output type.
-        (default True)
-
-    Returns
-    -------
-    fname : str
-        New filename based on given parameters.
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
 
-    """
-    if not basename:
-        msg = "Unable to generate filename for command %s. " % "align_epi_anat.py"
-        msg += "basename is not set!"
-        raise ValueError(msg)
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
 
-    if cwd is None:
-        cwd = output_dir
-    if ext is None:
-        ext = Info.output_type_to_ext(inputs.outputtype)
-    if change_ext:
-        suffix = "".join((suffix, ext)) if suffix else ext
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
 
-    if suffix is None:
-        suffix = ""
-    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
-    return fname
+            klass._version = klass.parse_version(raw_info)
 
+        return klass._version
 
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
 
 
 # Original source at L26 of <nipype-install>/interfaces/afni/base.py
@@ -351,118 +465,3 @@ def standard_image(img_name):
         out = clout.runtime.stdout
         basedir = os.path.split(out)[0]
         return os.path.join(basedir, img_name)
-
-
-# Original source at L197 of <nipype-install>/interfaces/afni/preprocess.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    anat_prefix = _gen_fname(
-        inputs.anat, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-    )
-    epi_prefix = _gen_fname(
-        inputs.in_file,
-        inputs=inputs,
-        stdout=stdout,
-        stderr=stderr,
-        output_dir=output_dir,
-    )
-    if "+" in anat_prefix:
-        anat_prefix = "".join(anat_prefix.split("+")[:-1])
-    if "+" in epi_prefix:
-        epi_prefix = "".join(epi_prefix.split("+")[:-1])
-    outputtype = inputs.outputtype
-    if outputtype == "AFNI":
-        ext = ".HEAD"
-    else:
-        ext = Info.output_type_to_ext(outputtype)
-    matext = ".1D"
-    suffix = inputs.suffix
-    if inputs.anat2epi:
-        outputs["anat_al_orig"] = _gen_fname(
-            anat_prefix,
-            suffix=suffix + "+orig",
-            ext=ext,
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-        outputs["anat_al_mat"] = _gen_fname(
-            anat_prefix,
-            suffix=suffix + "_mat.aff12",
-            ext=matext,
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-    if inputs.epi2anat:
-        outputs["epi_al_orig"] = _gen_fname(
-            epi_prefix,
-            suffix=suffix + "+orig",
-            ext=ext,
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-        outputs["epi_al_mat"] = _gen_fname(
-            epi_prefix,
-            suffix=suffix + "_mat.aff12",
-            ext=matext,
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-    if inputs.volreg == "on":
-        outputs["epi_vr_al_mat"] = _gen_fname(
-            epi_prefix,
-            suffix="_vr" + suffix + "_mat.aff12",
-            ext=matext,
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-        if inputs.tshift == "on":
-            outputs["epi_vr_motion"] = _gen_fname(
-                epi_prefix,
-                suffix="tsh_vr_motion",
-                ext=matext,
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-        elif inputs.tshift == "off":
-            outputs["epi_vr_motion"] = _gen_fname(
-                epi_prefix,
-                suffix="vr_motion",
-                ext=matext,
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-    if inputs.volreg == "on" and inputs.epi2anat:
-        outputs["epi_reg_al_mat"] = _gen_fname(
-            epi_prefix,
-            suffix="_reg" + suffix + "_mat.aff12",
-            ext=matext,
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-    if inputs.save_skullstrip:
-        outputs.skullstrip = _gen_fname(
-            anat_prefix,
-            suffix="_ns" + "+orig",
-            ext=ext,
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-    return outputs
diff --git a/example-specs/task/nipype/afni/allineate_callables.py b/example-specs/task/nipype/afni/allineate_callables.py
index 994c3e0a..42720463 100644
--- a/example-specs/task/nipype/afni/allineate_callables.py
+++ b/example-specs/task/nipype/afni/allineate_callables.py
@@ -1,13 +1,20 @@
 """Module to put any functions that are referred to in the "callables" section of Allineate.yaml"""
 
-from looseversion import LooseVersion
 import attrs
 import logging
 import os
 import os.path as op
+from looseversion import LooseVersion
 from pathlib import Path
 
 
+def allcostx_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["allcostx"]
+
+
 def out_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
@@ -36,52 +43,210 @@ def out_weight_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_weight_file"]
 
 
-def allcostx_callable(output_dir, inputs, stdout, stderr):
-    outputs = _list_outputs(
-        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
-    )
-    return outputs["allcostx"]
+iflogger = logging.getLogger("nipype.interface")
 
 
-iflogger = logging.getLogger("nipype.interface")
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
 
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
 
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
 
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
 
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
             else:
-                return None
+                # Do not generate filename when required fields are missing
+                return retval
 
-            klass._version = klass.parse_version(raw_info)
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
 
-        return klass._version
 
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+# Original source at L260 of <nipype-install>/interfaces/afni/base.py
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """
+    Generate a filename based on the given parameters.
+
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
+
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
+
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+    if not basename:
+        msg = "Unable to generate filename for command %s. " % "3dAllineate"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.outputtype)
+    if change_ext:
+        suffix = "".join((suffix, ext)) if suffix else ext
+
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+# Original source at L586 of <nipype-install>/interfaces/afni/preprocess.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+
+    if inputs.out_weight_file:
+        outputs["out_weight_file"] = op.abspath(inputs.out_weight_file)
+
+    if inputs.out_matrix:
+        ext = split_filename(inputs.out_matrix)[-1]
+        if ext.lower() not in [".1d", ".1D"]:
+            outputs["out_matrix"] = _gen_fname(
+                inputs.out_matrix,
+                suffix=".aff12.1D",
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+        else:
+            outputs["out_matrix"] = op.abspath(inputs.out_matrix)
+
+    if inputs.out_param_file:
+        ext = split_filename(inputs.out_param_file)[-1]
+        if ext.lower() not in [".1d", ".1D"]:
+            outputs["out_param_file"] = _gen_fname(
+                inputs.out_param_file,
+                suffix=".param.1D",
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+        else:
+            outputs["out_param_file"] = op.abspath(inputs.out_param_file)
+
+    if inputs.allcostx:
+        outputs["allcostX"] = os.path.abspath(inputs.allcostx)
+    return outputs
+
+
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
 
 
 # Original source at L108 of <nipype-install>/utils/filemanip.py
@@ -127,275 +292,6 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
-# Original source at L26 of <nipype-install>/interfaces/afni/base.py
-class Info(PackageInfo):
-    """Handle afni output type and version information."""
-
-    __outputtype = "AFNI"
-    ftypes = {"NIFTI": ".nii", "AFNI": "", "NIFTI_GZ": ".nii.gz"}
-    version_cmd = "afni --version"
-
-    @staticmethod
-    def parse_version(raw_info):
-        """Check and parse AFNI's version."""
-        version_stamp = raw_info.split("\n")[0].split("Version ")[1]
-        if version_stamp.startswith("AFNI"):
-            version_stamp = version_stamp.split("AFNI_")[1]
-        elif version_stamp.startswith("Debian"):
-            version_stamp = version_stamp.split("Debian-")[1].split("~")[0]
-        else:
-            return None
-
-        version = LooseVersion(version_stamp.replace("_", ".")).version[:3]
-        if version[0] < 1000:
-            version[0] = version[0] + 2000
-        return tuple(version)
-
-    @classmethod
-    def output_type_to_ext(cls, outputtype):
-        """
-        Get the file extension for the given output type.
-
-        Parameters
-        ----------
-        outputtype : {'NIFTI', 'NIFTI_GZ', 'AFNI'}
-            String specifying the output type.
-
-        Returns
-        -------
-        extension : str
-            The file extension for the output type.
-
-        """
-        try:
-            return cls.ftypes[outputtype]
-        except KeyError as e:
-            msg = "Invalid AFNIOUTPUTTYPE: ", outputtype
-            raise KeyError(msg) from e
-
-    @classmethod
-    def outputtype(cls):
-        """
-        Set default output filetype.
-
-        AFNI has no environment variables, Output filetypes get set in command line calls
-        Nipype uses ``AFNI`` as default
-
-
-        Returns
-        -------
-        None
-
-        """
-        return "AFNI"
-
-    @staticmethod
-    def standard_image(img_name):
-        """
-        Grab an image from the standard location.
-
-        Could be made more fancy to allow for more relocatability
-
-        """
-        clout = CommandLine(
-            "which afni",
-            ignore_exception=True,
-            resource_monitor=False,
-            terminal_output="allatonce",
-        ).run()
-        if clout.runtime.returncode != 0:
-            return None
-
-        out = clout.runtime.stdout
-        basedir = os.path.split(out)[0]
-        return os.path.join(basedir, img_name)
-
-
-# Original source at L242 of <nipype-install>/interfaces/afni/base.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    path, base, _ = split_filename(value)
-    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def nipype_interfaces_afni__AFNICommand___list_outputs(
-    inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
-
-
-# Original source at L260 of <nipype-install>/interfaces/afni/base.py
-def _gen_fname(
-    basename,
-    cwd=None,
-    suffix=None,
-    change_ext=True,
-    ext=None,
-    inputs=None,
-    stdout=None,
-    stderr=None,
-    output_dir=None,
-):
-    """
-    Generate a filename based on the given parameters.
-
-    The filename will take the form: cwd/basename<suffix><ext>.
-    If change_ext is True, it will use the extensions specified in
-    <instance>inputs.output_type.
-
-    Parameters
-    ----------
-    basename : str
-        Filename to base the new filename on.
-    cwd : str
-        Path to prefix to the new filename. (default is output_dir)
-    suffix : str
-        Suffix to add to the `basename`.  (defaults is '' )
-    change_ext : bool
-        Flag to change the filename extension to the FSL output type.
-        (default True)
-
-    Returns
-    -------
-    fname : str
-        New filename based on given parameters.
-
-    """
-    if not basename:
-        msg = "Unable to generate filename for command %s. " % "3dAllineate"
-        msg += "basename is not set!"
-        raise ValueError(msg)
-
-    if cwd is None:
-        cwd = output_dir
-    if ext is None:
-        ext = Info.output_type_to_ext(inputs.outputtype)
-    if change_ext:
-        suffix = "".join((suffix, ext)) if suffix else ext
-
-    if suffix is None:
-        suffix = ""
-    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
-    return fname
-
-
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
-# Original source at L809 of <nipype-install>/interfaces/base/core.py
-def _filename_from_source(
-    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    if chain is None:
-        chain = []
-
-    trait_spec = inputs.trait(name)
-    retval = getattr(inputs, name)
-    source_ext = None
-    if (retval is attrs.NOTHING) or "%s" in retval:
-        if not trait_spec.name_source:
-            return retval
-
-        # Do not generate filename when excluded by other inputs
-        if any(
-            (getattr(inputs, field) is not attrs.NOTHING)
-            for field in trait_spec.xor or ()
-        ):
-            return retval
-
-        # Do not generate filename when required fields are missing
-        if not all(
-            (getattr(inputs, field) is not attrs.NOTHING)
-            for field in trait_spec.requires or ()
-        ):
-            return retval
-
-        if (retval is not attrs.NOTHING) and "%s" in retval:
-            name_template = retval
-        else:
-            name_template = trait_spec.name_template
-        if not name_template:
-            name_template = "%s_generated"
-
-        ns = trait_spec.name_source
-        while isinstance(ns, (list, tuple)):
-            if len(ns) > 1:
-                iflogger.warning("Only one name_source per trait is allowed")
-            ns = ns[0]
-
-        if not isinstance(ns, (str, bytes)):
-            raise ValueError(
-                "name_source of '{}' trait should be an input trait "
-                "name, but a type {} object was found".format(name, type(ns))
-            )
-
-        if getattr(inputs, ns) is not attrs.NOTHING:
-            name_source = ns
-            source = getattr(inputs, name_source)
-            while isinstance(source, list):
-                source = source[0]
-
-            # special treatment for files
-            try:
-                _, base, source_ext = split_filename(source)
-            except (AttributeError, TypeError):
-                base = source
-        else:
-            if name in chain:
-                raise NipypeInterfaceError("Mutually pointing name_sources")
-
-            chain.append(name)
-            base = _filename_from_source(
-                ns,
-                chain,
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-            if base is not attrs.NOTHING:
-                _, _, source_ext = split_filename(base)
-            else:
-                # Do not generate filename when required fields are missing
-                return retval
-
-        chain = None
-        retval = name_template % base
-        _, _, ext = split_filename(retval)
-        if trait_spec.keep_extension and (ext or source_ext):
-            if (ext is None or not ext) and source_ext:
-                retval = retval + source_ext
-        else:
-            retval = _overload_extension(
-                retval,
-                name,
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-    return retval
-
-
 # Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
@@ -416,9 +312,20 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
 
 
 # Original source at L58 of <nipype-install>/utils/filemanip.py
@@ -472,41 +379,134 @@ def split_filename(fname):
     return pth, fname, ext
 
 
-# Original source at L586 of <nipype-install>/interfaces/afni/preprocess.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
 
-    if inputs.out_weight_file:
-        outputs["out_weight_file"] = op.abspath(inputs.out_weight_file)
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
 
-    if inputs.out_matrix:
-        ext = split_filename(inputs.out_matrix)[-1]
-        if ext.lower() not in [".1d", ".1D"]:
-            outputs["out_matrix"] = _gen_fname(
-                inputs.out_matrix,
-                suffix=".aff12.1D",
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-        else:
-            outputs["out_matrix"] = op.abspath(inputs.out_matrix)
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
 
-    if inputs.out_param_file:
-        ext = split_filename(inputs.out_param_file)[-1]
-        if ext.lower() not in [".1d", ".1D"]:
-            outputs["out_param_file"] = _gen_fname(
-                inputs.out_param_file,
-                suffix=".param.1D",
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
+# Original source at L26 of <nipype-install>/interfaces/afni/base.py
+class Info(PackageInfo):
+    """Handle afni output type and version information."""
+
+    __outputtype = "AFNI"
+    ftypes = {"NIFTI": ".nii", "AFNI": "", "NIFTI_GZ": ".nii.gz"}
+    version_cmd = "afni --version"
+
+    @staticmethod
+    def parse_version(raw_info):
+        """Check and parse AFNI's version."""
+        version_stamp = raw_info.split("\n")[0].split("Version ")[1]
+        if version_stamp.startswith("AFNI"):
+            version_stamp = version_stamp.split("AFNI_")[1]
+        elif version_stamp.startswith("Debian"):
+            version_stamp = version_stamp.split("Debian-")[1].split("~")[0]
         else:
-            outputs["out_param_file"] = op.abspath(inputs.out_param_file)
+            return None
 
-    if inputs.allcostx:
-        outputs["allcostX"] = os.path.abspath(inputs.allcostx)
-    return outputs
+        version = LooseVersion(version_stamp.replace("_", ".")).version[:3]
+        if version[0] < 1000:
+            version[0] = version[0] + 2000
+        return tuple(version)
+
+    @classmethod
+    def output_type_to_ext(cls, outputtype):
+        """
+        Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        outputtype : {'NIFTI', 'NIFTI_GZ', 'AFNI'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+
+        """
+        try:
+            return cls.ftypes[outputtype]
+        except KeyError as e:
+            msg = "Invalid AFNIOUTPUTTYPE: ", outputtype
+            raise KeyError(msg) from e
+
+    @classmethod
+    def outputtype(cls):
+        """
+        Set default output filetype.
+
+        AFNI has no environment variables, Output filetypes get set in command line calls
+        Nipype uses ``AFNI`` as default
+
+
+        Returns
+        -------
+        None
+
+        """
+        return "AFNI"
+
+    @staticmethod
+    def standard_image(img_name):
+        """
+        Grab an image from the standard location.
+
+        Could be made more fancy to allow for more relocatability
+
+        """
+        clout = CommandLine(
+            "which afni",
+            ignore_exception=True,
+            resource_monitor=False,
+            terminal_output="allatonce",
+        ).run()
+        if clout.runtime.returncode != 0:
+            return None
+
+        out = clout.runtime.stdout
+        basedir = os.path.split(out)[0]
+        return os.path.join(basedir, img_name)
+
+
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
diff --git a/example-specs/task/nipype/afni/auto_tcorrelate_callables.py b/example-specs/task/nipype/afni/auto_tcorrelate_callables.py
index 9f080b00..369bd013 100644
--- a/example-specs/task/nipype/afni/auto_tcorrelate_callables.py
+++ b/example-specs/task/nipype/afni/auto_tcorrelate_callables.py
@@ -16,27 +16,6 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
-# Original source at L675 of <nipype-install>/interfaces/afni/preprocess.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    path, base, ext = split_filename(value)
-    if ext.lower() not in [".1d", ".1D", ".nii.gz", ".nii"]:
-        ext = ext + ".1D"
-    return os.path.join(path, base + ext)
-
-
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
@@ -132,6 +111,35 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+# Original source at L675 of <nipype-install>/interfaces/afni/preprocess.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, ext = split_filename(value)
+    if ext.lower() not in [".1d", ".1D", ".nii.gz", ".nii"]:
+        ext = ext + ".1D"
+    return os.path.join(path, base + ext)
+
+
 # Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
@@ -152,9 +160,20 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
 
 
 # Original source at L58 of <nipype-install>/utils/filemanip.py
@@ -208,31 +227,12 @@ def split_filename(fname):
     return pth, fname, ext
 
 
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def nipype_interfaces_afni__AFNICommand___list_outputs(
-    inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
 
+    def __init__(self, value):
+        self.value = value
 
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
+    def __str__(self):
+        return "{}".format(self.value)
diff --git a/example-specs/task/nipype/afni/auto_tlrc_callables.py b/example-specs/task/nipype/afni/auto_tlrc_callables.py
index 830ac740..8be722c8 100644
--- a/example-specs/task/nipype/afni/auto_tlrc_callables.py
+++ b/example-specs/task/nipype/afni/auto_tlrc_callables.py
@@ -1,9 +1,8 @@
 """Module to put any functions that are referred to in the "callables" section of AutoTLRC.yaml"""
 
-from looseversion import LooseVersion
-import attrs
 import os
 import os.path as op
+from looseversion import LooseVersion
 from pathlib import Path
 
 
@@ -14,42 +13,82 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_file"]
 
 
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
 
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
 
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
+# Original source at L260 of <nipype-install>/interfaces/afni/base.py
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """
+    Generate a filename based on the given parameters.
 
-            klass._version = klass.parse_version(raw_info)
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
 
-        return klass._version
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
 
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+    if not basename:
+        msg = "Unable to generate filename for command %s. " % "@auto_tlrc"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.outputtype)
+    if change_ext:
+        suffix = "".join((suffix, ext)) if suffix else ext
+
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+# Original source at L846 of <nipype-install>/interfaces/afni/preprocess.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    ext = ".HEAD"
+    outputs["out_file"] = os.path.abspath(
+        _gen_fname(
+            inputs.in_file,
+            suffix="+tlrc",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+        + ext
+    )
+    return outputs
 
 
 # Original source at L108 of <nipype-install>/utils/filemanip.py
@@ -146,6 +185,44 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
@@ -228,81 +305,3 @@ def standard_image(img_name):
         out = clout.runtime.stdout
         basedir = os.path.split(out)[0]
         return os.path.join(basedir, img_name)
-
-
-# Original source at L260 of <nipype-install>/interfaces/afni/base.py
-def _gen_fname(
-    basename,
-    cwd=None,
-    suffix=None,
-    change_ext=True,
-    ext=None,
-    inputs=None,
-    stdout=None,
-    stderr=None,
-    output_dir=None,
-):
-    """
-    Generate a filename based on the given parameters.
-
-    The filename will take the form: cwd/basename<suffix><ext>.
-    If change_ext is True, it will use the extensions specified in
-    <instance>inputs.output_type.
-
-    Parameters
-    ----------
-    basename : str
-        Filename to base the new filename on.
-    cwd : str
-        Path to prefix to the new filename. (default is output_dir)
-    suffix : str
-        Suffix to add to the `basename`.  (defaults is '' )
-    change_ext : bool
-        Flag to change the filename extension to the FSL output type.
-        (default True)
-
-    Returns
-    -------
-    fname : str
-        New filename based on given parameters.
-
-    """
-    if not basename:
-        msg = "Unable to generate filename for command %s. " % "@auto_tlrc"
-        msg += "basename is not set!"
-        raise ValueError(msg)
-
-    if cwd is None:
-        cwd = output_dir
-    if ext is None:
-        ext = Info.output_type_to_ext(inputs.outputtype)
-    if change_ext:
-        suffix = "".join((suffix, ext)) if suffix else ext
-
-    if suffix is None:
-        suffix = ""
-    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
-    return fname
-
-
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
-# Original source at L846 of <nipype-install>/interfaces/afni/preprocess.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    ext = ".HEAD"
-    outputs["out_file"] = os.path.abspath(
-        _gen_fname(
-            inputs.in_file,
-            suffix="+tlrc",
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-        + ext
-    )
-    return outputs
diff --git a/example-specs/task/nipype/afni/autobox_callables.py b/example-specs/task/nipype/afni/autobox_callables.py
index e18d68cd..dd082f0c 100644
--- a/example-specs/task/nipype/afni/autobox_callables.py
+++ b/example-specs/task/nipype/afni/autobox_callables.py
@@ -1,17 +1,17 @@
 """Module to put any functions that are referred to in the "callables" section of Autobox.yaml"""
 
-from looseversion import LooseVersion
 import attrs
 import logging
 import os
 import os.path as op
+from looseversion import LooseVersion
 
 
-def x_min_callable(output_dir, inputs, stdout, stderr):
+def out_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["x_min"]
+    return outputs["out_file"]
 
 
 def x_max_callable(output_dir, inputs, stdout, stderr):
@@ -21,11 +21,11 @@ def x_max_callable(output_dir, inputs, stdout, stderr):
     return outputs["x_max"]
 
 
-def y_min_callable(output_dir, inputs, stdout, stderr):
+def x_min_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["y_min"]
+    return outputs["x_min"]
 
 
 def y_max_callable(output_dir, inputs, stdout, stderr):
@@ -35,11 +35,11 @@ def y_max_callable(output_dir, inputs, stdout, stderr):
     return outputs["y_max"]
 
 
-def z_min_callable(output_dir, inputs, stdout, stderr):
+def y_min_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["z_min"]
+    return outputs["y_min"]
 
 
 def z_max_callable(output_dir, inputs, stdout, stderr):
@@ -49,27 +49,16 @@ def z_max_callable(output_dir, inputs, stdout, stderr):
     return outputs["z_max"]
 
 
-def out_file_callable(output_dir, inputs, stdout, stderr):
+def z_min_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_file"]
+    return outputs["z_min"]
 
 
 iflogger = logging.getLogger("nipype.interface")
 
 
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
@@ -165,6 +154,33 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
 # Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
@@ -185,47 +201,20 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
-
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
-
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
-
-            klass._version = klass.parse_version(raw_info)
-
-        return klass._version
-
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
 
 
 # Original source at L58 of <nipype-install>/utils/filemanip.py
@@ -279,6 +268,55 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
@@ -361,41 +399,3 @@ def standard_image(img_name):
         out = clout.runtime.stdout
         basedir = os.path.split(out)[0]
         return os.path.join(basedir, img_name)
-
-
-# Original source at L242 of <nipype-install>/interfaces/afni/base.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    path, base, _ = split_filename(value)
-    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def nipype_interfaces_afni__AFNICommand___list_outputs(
-    inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
diff --git a/example-specs/task/nipype/afni/automask_callables.py b/example-specs/task/nipype/afni/automask_callables.py
index e3810af0..fdd35352 100644
--- a/example-specs/task/nipype/afni/automask_callables.py
+++ b/example-specs/task/nipype/afni/automask_callables.py
@@ -1,40 +1,29 @@
 """Module to put any functions that are referred to in the "callables" section of Automask.yaml"""
 
-from looseversion import LooseVersion
 import attrs
 import logging
 import os
 import os.path as op
+from looseversion import LooseVersion
 
 
-def out_file_callable(output_dir, inputs, stdout, stderr):
+def brain_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_file"]
+    return outputs["brain_file"]
 
 
-def brain_file_callable(output_dir, inputs, stdout, stderr):
+def out_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["brain_file"]
+    return outputs["out_file"]
 
 
 iflogger = logging.getLogger("nipype.interface")
 
 
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
@@ -130,6 +119,33 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
 # Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
@@ -150,47 +166,20 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
-
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
-
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
-
-            klass._version = klass.parse_version(raw_info)
-
-        return klass._version
-
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
 
 
 # Original source at L58 of <nipype-install>/utils/filemanip.py
@@ -244,6 +233,55 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
@@ -326,41 +364,3 @@ def standard_image(img_name):
         out = clout.runtime.stdout
         basedir = os.path.split(out)[0]
         return os.path.join(basedir, img_name)
-
-
-# Original source at L242 of <nipype-install>/interfaces/afni/base.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    path, base, _ = split_filename(value)
-    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def nipype_interfaces_afni__AFNICommand___list_outputs(
-    inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
diff --git a/example-specs/task/nipype/afni/axialize_callables.py b/example-specs/task/nipype/afni/axialize_callables.py
index 879823c2..4cfde918 100644
--- a/example-specs/task/nipype/afni/axialize_callables.py
+++ b/example-specs/task/nipype/afni/axialize_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Axialize.yaml"""
 
-from looseversion import LooseVersion
 import attrs
 import logging
 import os
 import os.path as op
+from looseversion import LooseVersion
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,17 +17,6 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
@@ -123,6 +112,33 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
 # Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
@@ -143,47 +159,20 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
-
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
-
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
-
-            klass._version = klass.parse_version(raw_info)
-
-        return klass._version
-
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
 
 
 # Original source at L58 of <nipype-install>/utils/filemanip.py
@@ -237,6 +226,55 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
@@ -319,41 +357,3 @@ def standard_image(img_name):
         out = clout.runtime.stdout
         basedir = os.path.split(out)[0]
         return os.path.join(basedir, img_name)
-
-
-# Original source at L242 of <nipype-install>/interfaces/afni/base.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    path, base, _ = split_filename(value)
-    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def nipype_interfaces_afni__AFNICommand___list_outputs(
-    inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
diff --git a/example-specs/task/nipype/afni/bandpass_callables.py b/example-specs/task/nipype/afni/bandpass_callables.py
index 208a51e5..ba53e785 100644
--- a/example-specs/task/nipype/afni/bandpass_callables.py
+++ b/example-specs/task/nipype/afni/bandpass_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Bandpass.yaml"""
 
-from looseversion import LooseVersion
 import attrs
 import logging
 import os
 import os.path as op
+from looseversion import LooseVersion
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,17 +17,6 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
@@ -123,6 +112,33 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
 # Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
@@ -143,47 +159,20 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
-
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
-
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
-
-            klass._version = klass.parse_version(raw_info)
-
-        return klass._version
-
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
 
 
 # Original source at L58 of <nipype-install>/utils/filemanip.py
@@ -237,6 +226,55 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
@@ -319,41 +357,3 @@ def standard_image(img_name):
         out = clout.runtime.stdout
         basedir = os.path.split(out)[0]
         return os.path.join(basedir, img_name)
-
-
-# Original source at L242 of <nipype-install>/interfaces/afni/base.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    path, base, _ = split_filename(value)
-    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def nipype_interfaces_afni__AFNICommand___list_outputs(
-    inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
diff --git a/example-specs/task/nipype/afni/blur_in_mask_callables.py b/example-specs/task/nipype/afni/blur_in_mask_callables.py
index 4925e04f..7b7c295a 100644
--- a/example-specs/task/nipype/afni/blur_in_mask_callables.py
+++ b/example-specs/task/nipype/afni/blur_in_mask_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of BlurInMask.yaml"""
 
-from looseversion import LooseVersion
 import attrs
 import logging
 import os
 import os.path as op
+from looseversion import LooseVersion
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,17 +17,6 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
@@ -123,6 +112,33 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
 # Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
@@ -143,47 +159,20 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
-
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
-
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
-
-            klass._version = klass.parse_version(raw_info)
-
-        return klass._version
-
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
 
 
 # Original source at L58 of <nipype-install>/utils/filemanip.py
@@ -237,6 +226,55 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
@@ -319,41 +357,3 @@ def standard_image(img_name):
         out = clout.runtime.stdout
         basedir = os.path.split(out)[0]
         return os.path.join(basedir, img_name)
-
-
-# Original source at L242 of <nipype-install>/interfaces/afni/base.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    path, base, _ = split_filename(value)
-    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def nipype_interfaces_afni__AFNICommand___list_outputs(
-    inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
diff --git a/example-specs/task/nipype/afni/blur_to_fwhm_callables.py b/example-specs/task/nipype/afni/blur_to_fwhm_callables.py
index bbe20394..d4571ccd 100644
--- a/example-specs/task/nipype/afni/blur_to_fwhm_callables.py
+++ b/example-specs/task/nipype/afni/blur_to_fwhm_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of BlurToFWHM.yaml"""
 
-from looseversion import LooseVersion
 import attrs
 import logging
 import os
 import os.path as op
+from looseversion import LooseVersion
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,17 +17,6 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
@@ -123,6 +112,33 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
 # Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
@@ -143,47 +159,20 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
-
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
-
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
-
-            klass._version = klass.parse_version(raw_info)
-
-        return klass._version
-
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
 
 
 # Original source at L58 of <nipype-install>/utils/filemanip.py
@@ -237,6 +226,55 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
@@ -319,41 +357,3 @@ def standard_image(img_name):
         out = clout.runtime.stdout
         basedir = os.path.split(out)[0]
         return os.path.join(basedir, img_name)
-
-
-# Original source at L242 of <nipype-install>/interfaces/afni/base.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    path, base, _ = split_filename(value)
-    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def nipype_interfaces_afni__AFNICommand___list_outputs(
-    inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
diff --git a/example-specs/task/nipype/afni/brick_stat_callables.py b/example-specs/task/nipype/afni/brick_stat_callables.py
index 48e68771..88d163a0 100644
--- a/example-specs/task/nipype/afni/brick_stat_callables.py
+++ b/example-specs/task/nipype/afni/brick_stat_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of BrickStat.yaml"""
 
+import attrs
 import logging
 import os
 import os.path as op
-import attrs
 
 
 def min_val_callable(output_dir, inputs, stdout, stderr):
@@ -16,75 +16,6 @@ def min_val_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
-# Original source at L58 of <nipype-install>/utils/filemanip.py
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
-# Original source at L888 of <nipype-install>/interfaces/base/core.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    return value
-
-
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
@@ -201,3 +132,72 @@ def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
             if fname is not attrs.NOTHING:
                 outputs[out_name] = os.path.abspath(fname)
         return outputs
+
+
+# Original source at L888 of <nipype-install>/interfaces/base/core.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value
+
+
+# Original source at L58 of <nipype-install>/utils/filemanip.py
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
diff --git a/example-specs/task/nipype/afni/bucket_callables.py b/example-specs/task/nipype/afni/bucket_callables.py
index 9459f487..324c212a 100644
--- a/example-specs/task/nipype/afni/bucket_callables.py
+++ b/example-specs/task/nipype/afni/bucket_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Bucket.yaml"""
 
-from looseversion import LooseVersion
 import attrs
 import logging
 import os
 import os.path as op
+from looseversion import LooseVersion
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,17 +17,6 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
@@ -123,6 +112,33 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
 # Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
@@ -143,47 +159,20 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
-
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
-
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
-
-            klass._version = klass.parse_version(raw_info)
-
-        return klass._version
-
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
 
 
 # Original source at L58 of <nipype-install>/utils/filemanip.py
@@ -237,6 +226,55 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
@@ -319,41 +357,3 @@ def standard_image(img_name):
         out = clout.runtime.stdout
         basedir = os.path.split(out)[0]
         return os.path.join(basedir, img_name)
-
-
-# Original source at L242 of <nipype-install>/interfaces/afni/base.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    path, base, _ = split_filename(value)
-    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def nipype_interfaces_afni__AFNICommand___list_outputs(
-    inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
diff --git a/example-specs/task/nipype/afni/calc_callables.py b/example-specs/task/nipype/afni/calc_callables.py
index 7232c0e5..7d74b621 100644
--- a/example-specs/task/nipype/afni/calc_callables.py
+++ b/example-specs/task/nipype/afni/calc_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Calc.yaml"""
 
-from looseversion import LooseVersion
 import attrs
 import logging
 import os
 import os.path as op
+from looseversion import LooseVersion
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,17 +17,6 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
@@ -123,6 +112,33 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
 # Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
@@ -143,47 +159,20 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
-
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
-
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
-
-            klass._version = klass.parse_version(raw_info)
-
-        return klass._version
-
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
 
 
 # Original source at L58 of <nipype-install>/utils/filemanip.py
@@ -237,6 +226,55 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
@@ -319,41 +357,3 @@ def standard_image(img_name):
         out = clout.runtime.stdout
         basedir = os.path.split(out)[0]
         return os.path.join(basedir, img_name)
-
-
-# Original source at L242 of <nipype-install>/interfaces/afni/base.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    path, base, _ = split_filename(value)
-    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def nipype_interfaces_afni__AFNICommand___list_outputs(
-    inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
diff --git a/example-specs/task/nipype/afni/cat_callables.py b/example-specs/task/nipype/afni/cat_callables.py
index 0ecf8223..5d0221cb 100644
--- a/example-specs/task/nipype/afni/cat_callables.py
+++ b/example-specs/task/nipype/afni/cat_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Cat.yaml"""
 
-from looseversion import LooseVersion
 import attrs
 import logging
 import os
 import os.path as op
+from looseversion import LooseVersion
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,17 +17,6 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
@@ -123,6 +112,33 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
 # Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
@@ -143,47 +159,20 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
-
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
-
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
-
-            klass._version = klass.parse_version(raw_info)
-
-        return klass._version
-
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
 
 
 # Original source at L58 of <nipype-install>/utils/filemanip.py
@@ -237,6 +226,55 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
@@ -319,41 +357,3 @@ def standard_image(img_name):
         out = clout.runtime.stdout
         basedir = os.path.split(out)[0]
         return os.path.join(basedir, img_name)
-
-
-# Original source at L242 of <nipype-install>/interfaces/afni/base.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    path, base, _ = split_filename(value)
-    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def nipype_interfaces_afni__AFNICommand___list_outputs(
-    inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
diff --git a/example-specs/task/nipype/afni/cat_matvec_callables.py b/example-specs/task/nipype/afni/cat_matvec_callables.py
index ebb68254..512393c2 100644
--- a/example-specs/task/nipype/afni/cat_matvec_callables.py
+++ b/example-specs/task/nipype/afni/cat_matvec_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of CatMatvec.yaml"""
 
-from looseversion import LooseVersion
 import attrs
 import logging
 import os
 import os.path as op
+from looseversion import LooseVersion
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,17 +17,6 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
@@ -123,6 +112,33 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
 # Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
@@ -143,47 +159,20 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
-
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
-
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
-
-            klass._version = klass.parse_version(raw_info)
-
-        return klass._version
-
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
 
 
 # Original source at L58 of <nipype-install>/utils/filemanip.py
@@ -237,6 +226,55 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
@@ -319,41 +357,3 @@ def standard_image(img_name):
         out = clout.runtime.stdout
         basedir = os.path.split(out)[0]
         return os.path.join(basedir, img_name)
-
-
-# Original source at L242 of <nipype-install>/interfaces/afni/base.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    path, base, _ = split_filename(value)
-    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def nipype_interfaces_afni__AFNICommand___list_outputs(
-    inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
diff --git a/example-specs/task/nipype/afni/center_mass.yaml b/example-specs/task/nipype/afni/center_mass.yaml
index 529ff6fd..4a4cb0b6 100644
--- a/example-specs/task/nipype/afni/center_mass.yaml
+++ b/example-specs/task/nipype/afni/center_mass.yaml
@@ -91,7 +91,7 @@ tests:
     automask:
     # type=bool|default=False: Generate the mask automatically
     set_cm:
-    # type=tuple|default=(<traits.trait_types.Float object at 0x1079ed690>, <traits.trait_types.Float object at 0x1079ed790>, <traits.trait_types.Float object at 0x1079ed810>): After computing the center of mass, set the origin fields in the header so that the center of mass will be at (x,y,z) in DICOM coords.
+    # type=tuple|default=(<traits.trait_types.Float object at 0x107b12910>, <traits.trait_types.Float object at 0x107b12a10>, <traits.trait_types.Float object at 0x107b12a90>): After computing the center of mass, set the origin fields in the header so that the center of mass will be at (x,y,z) in DICOM coords.
     local_ijk:
     # type=bool|default=False: Output values as (i,j,k) in local orientation
     roi_vals:
diff --git a/example-specs/task/nipype/afni/center_mass_callables.py b/example-specs/task/nipype/afni/center_mass_callables.py
index 42503938..0fd5d9f0 100644
--- a/example-specs/task/nipype/afni/center_mass_callables.py
+++ b/example-specs/task/nipype/afni/center_mass_callables.py
@@ -1,17 +1,17 @@
 """Module to put any functions that are referred to in the "callables" section of CenterMass.yaml"""
 
-import numpy as np
 import attrs
 import logging
+import numpy as np
 import os
 import os.path as op
 
 
-def out_file_callable(output_dir, inputs, stdout, stderr):
+def cm_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_file"]
+    return outputs["cm"]
 
 
 def cm_file_callable(output_dir, inputs, stdout, stderr):
@@ -21,85 +21,16 @@ def cm_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["cm_file"]
 
 
-def cm_callable(output_dir, inputs, stdout, stderr):
+def out_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["cm"]
+    return outputs["out_file"]
 
 
 iflogger = logging.getLogger("nipype.interface")
 
 
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
-# Original source at L58 of <nipype-install>/utils/filemanip.py
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
-# Original source at L888 of <nipype-install>/interfaces/base/core.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    return value
-
-
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
@@ -195,6 +126,28 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+# Original source at L749 of <nipype-install>/interfaces/afni/utils.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    outputs["out_file"] = os.path.abspath(inputs.in_file)
+    outputs["cm_file"] = os.path.abspath(inputs.cm_file)
+    sout = np.loadtxt(outputs["cm_file"], ndmin=2)
+    outputs["cm"] = [tuple(s) for s in sout]
+    return outputs
+
+
+# Original source at L888 of <nipype-install>/interfaces/base/core.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value
+
+
 # Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
@@ -215,16 +168,63 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
+# Original source at L58 of <nipype-install>/utils/filemanip.py
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
 
+    Parameters
+    ----------
+    fname : str
+        file or path name
 
-# Original source at L749 of <nipype-install>/interfaces/afni/utils.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    outputs["out_file"] = os.path.abspath(inputs.in_file)
-    outputs["cm_file"] = os.path.abspath(inputs.cm_file)
-    sout = np.loadtxt(outputs["cm_file"], ndmin=2)
-    outputs["cm"] = [tuple(s) for s in sout]
-    return outputs
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
diff --git a/example-specs/task/nipype/afni/clip_level_callables.py b/example-specs/task/nipype/afni/clip_level_callables.py
index 5dbe29ed..9443ce79 100644
--- a/example-specs/task/nipype/afni/clip_level_callables.py
+++ b/example-specs/task/nipype/afni/clip_level_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of ClipLevel.yaml"""
 
+import attrs
 import logging
 import os
 import os.path as op
-import attrs
 
 
 def clip_val_callable(output_dir, inputs, stdout, stderr):
@@ -16,75 +16,6 @@ def clip_val_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
-# Original source at L58 of <nipype-install>/utils/filemanip.py
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
-# Original source at L888 of <nipype-install>/interfaces/base/core.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    return value
-
-
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
@@ -201,3 +132,72 @@ def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
             if fname is not attrs.NOTHING:
                 outputs[out_name] = os.path.abspath(fname)
         return outputs
+
+
+# Original source at L888 of <nipype-install>/interfaces/base/core.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value
+
+
+# Original source at L58 of <nipype-install>/utils/filemanip.py
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
diff --git a/example-specs/task/nipype/afni/convert_dset_callables.py b/example-specs/task/nipype/afni/convert_dset_callables.py
index 63ab8d03..73fae583 100644
--- a/example-specs/task/nipype/afni/convert_dset_callables.py
+++ b/example-specs/task/nipype/afni/convert_dset_callables.py
@@ -1,7 +1,6 @@
 """Module to put any functions that are referred to in the "callables" section of ConvertDset.yaml"""
 
 import os.path as op
-import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/afni/copy_callables.py b/example-specs/task/nipype/afni/copy_callables.py
index 4e6230b4..b88d21f3 100644
--- a/example-specs/task/nipype/afni/copy_callables.py
+++ b/example-specs/task/nipype/afni/copy_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Copy.yaml"""
 
-from looseversion import LooseVersion
 import attrs
 import logging
 import os
 import os.path as op
+from looseversion import LooseVersion
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,17 +17,6 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
@@ -123,6 +112,33 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
 # Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
@@ -143,47 +159,20 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
-
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
-
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
-
-            klass._version = klass.parse_version(raw_info)
-
-        return klass._version
-
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
 
 
 # Original source at L58 of <nipype-install>/utils/filemanip.py
@@ -237,6 +226,55 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
@@ -319,41 +357,3 @@ def standard_image(img_name):
         out = clout.runtime.stdout
         basedir = os.path.split(out)[0]
         return os.path.join(basedir, img_name)
-
-
-# Original source at L242 of <nipype-install>/interfaces/afni/base.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    path, base, _ = split_filename(value)
-    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def nipype_interfaces_afni__AFNICommand___list_outputs(
-    inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
diff --git a/example-specs/task/nipype/afni/deconvolve_callables.py b/example-specs/task/nipype/afni/deconvolve_callables.py
index c5607d17..6528c1eb 100644
--- a/example-specs/task/nipype/afni/deconvolve_callables.py
+++ b/example-specs/task/nipype/afni/deconvolve_callables.py
@@ -1,12 +1,19 @@
 """Module to put any functions that are referred to in the "callables" section of Deconvolve.yaml"""
 
-from looseversion import LooseVersion
 import attrs
 import os
 import os.path as op
+from looseversion import LooseVersion
 from pathlib import Path
 
 
+def cbucket_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["cbucket"]
+
+
 def out_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
@@ -28,49 +35,107 @@ def x1D_callable(output_dir, inputs, stdout, stderr):
     return outputs["x1D"]
 
 
-def cbucket_callable(output_dir, inputs, stdout, stderr):
-    outputs = _list_outputs(
-        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
-    )
-    return outputs["cbucket"]
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
 
 
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
+# Original source at L260 of <nipype-install>/interfaces/afni/base.py
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """
+    Generate a filename based on the given parameters.
 
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
 
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
 
-            klass._version = klass.parse_version(raw_info)
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
 
-        return klass._version
+    """
+    if not basename:
+        msg = "Unable to generate filename for command %s. " % "3dDeconvolve"
+        msg += "basename is not set!"
+        raise ValueError(msg)
 
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.outputtype)
+    if change_ext:
+        suffix = "".join((suffix, ext)) if suffix else ext
+
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+# Original source at L322 of <nipype-install>/interfaces/afni/model.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+
+    _gen_fname_opts = {}
+    _gen_fname_opts["basename"] = inputs.out_file
+    _gen_fname_opts["cwd"] = output_dir
+
+    if inputs.x1D is not attrs.NOTHING:
+        if not inputs.x1D.endswith(".xmat.1D"):
+            outputs["x1D"] = os.path.abspath(inputs.x1D + ".xmat.1D")
+        else:
+            outputs["x1D"] = os.path.abspath(inputs.x1D)
+    else:
+        outputs["x1D"] = _gen_fname(
+            suffix=".xmat.1D",
+            **_gen_fname_opts,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir
+        )
+
+    if inputs.cbucket is not attrs.NOTHING:
+        outputs["cbucket"] = os.path.abspath(inputs.cbucket)
+
+    outputs["reml_script"] = _gen_fname(
+        suffix=".REML_cmd",
+        **_gen_fname_opts,
+        inputs=inputs,
+        stdout=stdout,
+        stderr=stderr,
+        output_dir=output_dir
+    )
+    # remove out_file from outputs if x1d_stop set to True
+    if inputs.x1D_stop:
+        del outputs["out_file"], outputs["cbucket"]
+    else:
+        outputs["out_file"] = os.path.abspath(inputs.out_file)
+
+    return outputs
 
 
 # Original source at L108 of <nipype-install>/utils/filemanip.py
@@ -167,6 +232,44 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
@@ -249,106 +352,3 @@ def standard_image(img_name):
         out = clout.runtime.stdout
         basedir = os.path.split(out)[0]
         return os.path.join(basedir, img_name)
-
-
-# Original source at L260 of <nipype-install>/interfaces/afni/base.py
-def _gen_fname(
-    basename,
-    cwd=None,
-    suffix=None,
-    change_ext=True,
-    ext=None,
-    inputs=None,
-    stdout=None,
-    stderr=None,
-    output_dir=None,
-):
-    """
-    Generate a filename based on the given parameters.
-
-    The filename will take the form: cwd/basename<suffix><ext>.
-    If change_ext is True, it will use the extensions specified in
-    <instance>inputs.output_type.
-
-    Parameters
-    ----------
-    basename : str
-        Filename to base the new filename on.
-    cwd : str
-        Path to prefix to the new filename. (default is output_dir)
-    suffix : str
-        Suffix to add to the `basename`.  (defaults is '' )
-    change_ext : bool
-        Flag to change the filename extension to the FSL output type.
-        (default True)
-
-    Returns
-    -------
-    fname : str
-        New filename based on given parameters.
-
-    """
-    if not basename:
-        msg = "Unable to generate filename for command %s. " % "3dDeconvolve"
-        msg += "basename is not set!"
-        raise ValueError(msg)
-
-    if cwd is None:
-        cwd = output_dir
-    if ext is None:
-        ext = Info.output_type_to_ext(inputs.outputtype)
-    if change_ext:
-        suffix = "".join((suffix, ext)) if suffix else ext
-
-    if suffix is None:
-        suffix = ""
-    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
-    return fname
-
-
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
-# Original source at L322 of <nipype-install>/interfaces/afni/model.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-
-    _gen_fname_opts = {}
-    _gen_fname_opts["basename"] = inputs.out_file
-    _gen_fname_opts["cwd"] = output_dir
-
-    if inputs.x1D is not attrs.NOTHING:
-        if not inputs.x1D.endswith(".xmat.1D"):
-            outputs["x1D"] = os.path.abspath(inputs.x1D + ".xmat.1D")
-        else:
-            outputs["x1D"] = os.path.abspath(inputs.x1D)
-    else:
-        outputs["x1D"] = _gen_fname(
-            suffix=".xmat.1D",
-            **_gen_fname_opts,
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir
-        )
-
-    if inputs.cbucket is not attrs.NOTHING:
-        outputs["cbucket"] = os.path.abspath(inputs.cbucket)
-
-    outputs["reml_script"] = _gen_fname(
-        suffix=".REML_cmd",
-        **_gen_fname_opts,
-        inputs=inputs,
-        stdout=stdout,
-        stderr=stderr,
-        output_dir=output_dir
-    )
-    # remove out_file from outputs if x1d_stop set to True
-    if inputs.x1D_stop:
-        del outputs["out_file"], outputs["cbucket"]
-    else:
-        outputs["out_file"] = os.path.abspath(inputs.out_file)
-
-    return outputs
diff --git a/example-specs/task/nipype/afni/degree_centrality_callables.py b/example-specs/task/nipype/afni/degree_centrality_callables.py
index ec134941..e14a4bae 100644
--- a/example-specs/task/nipype/afni/degree_centrality_callables.py
+++ b/example-specs/task/nipype/afni/degree_centrality_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of DegreeCentrality.yaml"""
 
-from looseversion import LooseVersion
 import attrs
 import logging
 import os
 import os.path as op
+from looseversion import LooseVersion
 
 
 def oned_file_callable(output_dir, inputs, stdout, stderr):
@@ -24,6 +24,211 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+# Original source at L1218 of <nipype-install>/interfaces/afni/preprocess.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    # Update outputs dictionary if oned file is defined
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    if inputs.oned_file:
+        outputs["oned_file"] = os.path.abspath(inputs.oned_file)
+
+    return outputs
+
+
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
+def nipype_interfaces_afni__AFNICommandBase___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+# Original source at L58 of <nipype-install>/utils/filemanip.py
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
 # Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
@@ -146,30 +351,6 @@ def standard_image(img_name):
         return os.path.join(basedir, img_name)
 
 
-# Original source at L242 of <nipype-install>/interfaces/afni/base.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    path, base, _ = split_filename(value)
-    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def nipype_interfaces_afni__AFNICommand___list_outputs(
-    inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
-
-
 # Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
@@ -179,184 +360,3 @@ def __init__(self, value):
 
     def __str__(self):
         return "{}".format(self.value)
-
-
-# Original source at L58 of <nipype-install>/utils/filemanip.py
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
-# Original source at L809 of <nipype-install>/interfaces/base/core.py
-def _filename_from_source(
-    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    if chain is None:
-        chain = []
-
-    trait_spec = inputs.trait(name)
-    retval = getattr(inputs, name)
-    source_ext = None
-    if (retval is attrs.NOTHING) or "%s" in retval:
-        if not trait_spec.name_source:
-            return retval
-
-        # Do not generate filename when excluded by other inputs
-        if any(
-            (getattr(inputs, field) is not attrs.NOTHING)
-            for field in trait_spec.xor or ()
-        ):
-            return retval
-
-        # Do not generate filename when required fields are missing
-        if not all(
-            (getattr(inputs, field) is not attrs.NOTHING)
-            for field in trait_spec.requires or ()
-        ):
-            return retval
-
-        if (retval is not attrs.NOTHING) and "%s" in retval:
-            name_template = retval
-        else:
-            name_template = trait_spec.name_template
-        if not name_template:
-            name_template = "%s_generated"
-
-        ns = trait_spec.name_source
-        while isinstance(ns, (list, tuple)):
-            if len(ns) > 1:
-                iflogger.warning("Only one name_source per trait is allowed")
-            ns = ns[0]
-
-        if not isinstance(ns, (str, bytes)):
-            raise ValueError(
-                "name_source of '{}' trait should be an input trait "
-                "name, but a type {} object was found".format(name, type(ns))
-            )
-
-        if getattr(inputs, ns) is not attrs.NOTHING:
-            name_source = ns
-            source = getattr(inputs, name_source)
-            while isinstance(source, list):
-                source = source[0]
-
-            # special treatment for files
-            try:
-                _, base, source_ext = split_filename(source)
-            except (AttributeError, TypeError):
-                base = source
-        else:
-            if name in chain:
-                raise NipypeInterfaceError("Mutually pointing name_sources")
-
-            chain.append(name)
-            base = _filename_from_source(
-                ns,
-                chain,
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-            if base is not attrs.NOTHING:
-                _, _, source_ext = split_filename(base)
-            else:
-                # Do not generate filename when required fields are missing
-                return retval
-
-        chain = None
-        retval = name_template % base
-        _, _, ext = split_filename(retval)
-        if trait_spec.keep_extension and (ext or source_ext):
-            if (ext is None or not ext) and source_ext:
-                retval = retval + source_ext
-        else:
-            retval = _overload_extension(
-                retval,
-                name,
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-    return retval
-
-
-# Original source at L891 of <nipype-install>/interfaces/base/core.py
-def nipype_interfaces_afni__AFNICommandBase___list_outputs(
-    inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    metadata = dict(name_source=lambda t: t is not None)
-    traits = inputs.traits(**metadata)
-    if traits:
-        outputs = {}
-        for name, trait_spec in list(traits.items()):
-            out_name = name
-            if trait_spec.output_name is not None:
-                out_name = trait_spec.output_name
-            fname = _filename_from_source(
-                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-            )
-            if fname is not attrs.NOTHING:
-                outputs[out_name] = os.path.abspath(fname)
-        return outputs
-
-
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
-# Original source at L1218 of <nipype-install>/interfaces/afni/preprocess.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    # Update outputs dictionary if oned file is defined
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    if inputs.oned_file:
-        outputs["oned_file"] = os.path.abspath(inputs.oned_file)
-
-    return outputs
diff --git a/example-specs/task/nipype/afni/despike_callables.py b/example-specs/task/nipype/afni/despike_callables.py
index 39a1ea46..7dd7ae84 100644
--- a/example-specs/task/nipype/afni/despike_callables.py
+++ b/example-specs/task/nipype/afni/despike_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Despike.yaml"""
 
-from looseversion import LooseVersion
 import attrs
 import logging
 import os
 import os.path as op
+from looseversion import LooseVersion
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,17 +17,6 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
@@ -123,6 +112,33 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
 # Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
@@ -143,47 +159,20 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
-
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
-
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
-
-            klass._version = klass.parse_version(raw_info)
-
-        return klass._version
-
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
 
 
 # Original source at L58 of <nipype-install>/utils/filemanip.py
@@ -237,6 +226,55 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
@@ -319,41 +357,3 @@ def standard_image(img_name):
         out = clout.runtime.stdout
         basedir = os.path.split(out)[0]
         return os.path.join(basedir, img_name)
-
-
-# Original source at L242 of <nipype-install>/interfaces/afni/base.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    path, base, _ = split_filename(value)
-    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def nipype_interfaces_afni__AFNICommand___list_outputs(
-    inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
diff --git a/example-specs/task/nipype/afni/detrend_callables.py b/example-specs/task/nipype/afni/detrend_callables.py
index b6cc756f..c5694b30 100644
--- a/example-specs/task/nipype/afni/detrend_callables.py
+++ b/example-specs/task/nipype/afni/detrend_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Detrend.yaml"""
 
-from looseversion import LooseVersion
 import attrs
 import logging
 import os
 import os.path as op
+from looseversion import LooseVersion
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,17 +17,6 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
@@ -123,6 +112,33 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
 # Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
@@ -143,47 +159,20 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
-
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
-
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
-
-            klass._version = klass.parse_version(raw_info)
-
-        return klass._version
-
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
 
 
 # Original source at L58 of <nipype-install>/utils/filemanip.py
@@ -237,6 +226,55 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
@@ -319,41 +357,3 @@ def standard_image(img_name):
         out = clout.runtime.stdout
         basedir = os.path.split(out)[0]
         return os.path.join(basedir, img_name)
-
-
-# Original source at L242 of <nipype-install>/interfaces/afni/base.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    path, base, _ = split_filename(value)
-    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def nipype_interfaces_afni__AFNICommand___list_outputs(
-    inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
diff --git a/example-specs/task/nipype/afni/dot.yaml b/example-specs/task/nipype/afni/dot.yaml
index bbceadab..aed68950 100644
--- a/example-specs/task/nipype/afni/dot.yaml
+++ b/example-specs/task/nipype/afni/dot.yaml
@@ -85,7 +85,7 @@ tests:
     mask:
     # type=file|default=<undefined>: Use this dataset as a mask
     mrange:
-    # type=tuple|default=(<traits.trait_types.Float object at 0x1079efdd0>, <traits.trait_types.Float object at 0x1079efcd0>): Means to further restrict the voxels from 'mset' so thatonly those mask values within this range (inclusive) willbe used.
+    # type=tuple|default=(<traits.trait_types.Float object at 0x107b18fd0>, <traits.trait_types.Float object at 0x107b18ed0>): Means to further restrict the voxels from 'mset' so thatonly those mask values within this range (inclusive) willbe used.
     demean:
     # type=bool|default=False: Remove the mean from each volume prior to computing the correlation
     docor:
diff --git a/example-specs/task/nipype/afni/dot_callables.py b/example-specs/task/nipype/afni/dot_callables.py
index c1ef6c5d..50b87028 100644
--- a/example-specs/task/nipype/afni/dot_callables.py
+++ b/example-specs/task/nipype/afni/dot_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Dot.yaml"""
 
-from looseversion import LooseVersion
 import attrs
 import logging
 import os
 import os.path as op
+from looseversion import LooseVersion
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,17 +17,6 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
@@ -123,6 +112,33 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
 # Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
@@ -143,47 +159,20 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
-
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
-
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
-
-            klass._version = klass.parse_version(raw_info)
-
-        return klass._version
-
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
 
 
 # Original source at L58 of <nipype-install>/utils/filemanip.py
@@ -237,6 +226,55 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
@@ -319,41 +357,3 @@ def standard_image(img_name):
         out = clout.runtime.stdout
         basedir = os.path.split(out)[0]
         return os.path.join(basedir, img_name)
-
-
-# Original source at L242 of <nipype-install>/interfaces/afni/base.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    path, base, _ = split_filename(value)
-    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def nipype_interfaces_afni__AFNICommand___list_outputs(
-    inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
diff --git a/example-specs/task/nipype/afni/ecm_callables.py b/example-specs/task/nipype/afni/ecm_callables.py
index e2c5ff6d..45044797 100644
--- a/example-specs/task/nipype/afni/ecm_callables.py
+++ b/example-specs/task/nipype/afni/ecm_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of ECM.yaml"""
 
-from looseversion import LooseVersion
 import attrs
 import logging
 import os
 import os.path as op
+from looseversion import LooseVersion
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,17 +17,6 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
@@ -123,6 +112,33 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
 # Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
@@ -143,47 +159,20 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
-
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
-
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
-
-            klass._version = klass.parse_version(raw_info)
-
-        return klass._version
-
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
 
 
 # Original source at L58 of <nipype-install>/utils/filemanip.py
@@ -237,6 +226,55 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
@@ -319,41 +357,3 @@ def standard_image(img_name):
         out = clout.runtime.stdout
         basedir = os.path.split(out)[0]
         return os.path.join(basedir, img_name)
-
-
-# Original source at L242 of <nipype-install>/interfaces/afni/base.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    path, base, _ = split_filename(value)
-    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def nipype_interfaces_afni__AFNICommand___list_outputs(
-    inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
diff --git a/example-specs/task/nipype/afni/edge_3_callables.py b/example-specs/task/nipype/afni/edge_3_callables.py
index 27344a9a..ff910f04 100644
--- a/example-specs/task/nipype/afni/edge_3_callables.py
+++ b/example-specs/task/nipype/afni/edge_3_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Edge3.yaml"""
 
-from looseversion import LooseVersion
 import attrs
 import logging
 import os
 import os.path as op
+from looseversion import LooseVersion
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,17 +17,6 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
@@ -123,6 +112,33 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
 # Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
@@ -143,47 +159,20 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
-
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
-
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
-
-            klass._version = klass.parse_version(raw_info)
-
-        return klass._version
-
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
 
 
 # Original source at L58 of <nipype-install>/utils/filemanip.py
@@ -237,6 +226,55 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
@@ -319,41 +357,3 @@ def standard_image(img_name):
         out = clout.runtime.stdout
         basedir = os.path.split(out)[0]
         return os.path.join(basedir, img_name)
-
-
-# Original source at L242 of <nipype-install>/interfaces/afni/base.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    path, base, _ = split_filename(value)
-    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def nipype_interfaces_afni__AFNICommand___list_outputs(
-    inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
diff --git a/example-specs/task/nipype/afni/eval_callables.py b/example-specs/task/nipype/afni/eval_callables.py
index 716d57f8..ec6b163c 100644
--- a/example-specs/task/nipype/afni/eval_callables.py
+++ b/example-specs/task/nipype/afni/eval_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Eval.yaml"""
 
-from looseversion import LooseVersion
 import attrs
 import logging
 import os
 import os.path as op
+from looseversion import LooseVersion
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,17 +17,6 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
@@ -123,6 +112,33 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
 # Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
@@ -143,47 +159,20 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
-
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
-
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
-
-            klass._version = klass.parse_version(raw_info)
-
-        return klass._version
-
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
 
 
 # Original source at L58 of <nipype-install>/utils/filemanip.py
@@ -237,6 +226,55 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
@@ -319,41 +357,3 @@ def standard_image(img_name):
         out = clout.runtime.stdout
         basedir = os.path.split(out)[0]
         return os.path.join(basedir, img_name)
-
-
-# Original source at L242 of <nipype-install>/interfaces/afni/base.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    path, base, _ = split_filename(value)
-    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def nipype_interfaces_afni__AFNICommand___list_outputs(
-    inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
diff --git a/example-specs/task/nipype/afni/fim_callables.py b/example-specs/task/nipype/afni/fim_callables.py
index 0d81fd13..e55a65dd 100644
--- a/example-specs/task/nipype/afni/fim_callables.py
+++ b/example-specs/task/nipype/afni/fim_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Fim.yaml"""
 
-from looseversion import LooseVersion
 import attrs
 import logging
 import os
 import os.path as op
+from looseversion import LooseVersion
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,17 +17,6 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
@@ -123,6 +112,33 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
 # Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
@@ -143,47 +159,20 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
-
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
-
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
-
-            klass._version = klass.parse_version(raw_info)
-
-        return klass._version
-
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
 
 
 # Original source at L58 of <nipype-install>/utils/filemanip.py
@@ -237,6 +226,55 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
@@ -319,41 +357,3 @@ def standard_image(img_name):
         out = clout.runtime.stdout
         basedir = os.path.split(out)[0]
         return os.path.join(basedir, img_name)
-
-
-# Original source at L242 of <nipype-install>/interfaces/afni/base.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    path, base, _ = split_filename(value)
-    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def nipype_interfaces_afni__AFNICommand___list_outputs(
-    inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
diff --git a/example-specs/task/nipype/afni/fourier_callables.py b/example-specs/task/nipype/afni/fourier_callables.py
index 52a35176..7ba1612a 100644
--- a/example-specs/task/nipype/afni/fourier_callables.py
+++ b/example-specs/task/nipype/afni/fourier_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Fourier.yaml"""
 
-from looseversion import LooseVersion
 import attrs
 import logging
 import os
 import os.path as op
+from looseversion import LooseVersion
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,17 +17,6 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
@@ -123,6 +112,33 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
 # Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
@@ -143,47 +159,20 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
-
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
-
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
-
-            klass._version = klass.parse_version(raw_info)
-
-        return klass._version
-
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
 
 
 # Original source at L58 of <nipype-install>/utils/filemanip.py
@@ -237,6 +226,55 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
@@ -319,41 +357,3 @@ def standard_image(img_name):
         out = clout.runtime.stdout
         basedir = os.path.split(out)[0]
         return os.path.join(basedir, img_name)
-
-
-# Original source at L242 of <nipype-install>/interfaces/afni/base.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    path, base, _ = split_filename(value)
-    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def nipype_interfaces_afni__AFNICommand___list_outputs(
-    inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
diff --git a/example-specs/task/nipype/afni/fwh_mx_callables.py b/example-specs/task/nipype/afni/fwh_mx_callables.py
index 1a610cb9..3175e710 100644
--- a/example-specs/task/nipype/afni/fwh_mx_callables.py
+++ b/example-specs/task/nipype/afni/fwh_mx_callables.py
@@ -1,126 +1,57 @@
 """Module to put any functions that are referred to in the "callables" section of FWHMx.yaml"""
 
-import numpy as np
 import attrs
 import logging
+import numpy as np
 import os
 import os.path as op
 
 
-def out_file_callable(output_dir, inputs, stdout, stderr):
+def acf_param_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_file"]
+    return outputs["acf_param"]
 
 
-def out_subbricks_callable(output_dir, inputs, stdout, stderr):
+def fwhm_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_subbricks"]
+    return outputs["fwhm"]
 
 
-def out_detrend_callable(output_dir, inputs, stdout, stderr):
+def out_acf_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_detrend"]
+    return outputs["out_acf"]
 
 
-def fwhm_callable(output_dir, inputs, stdout, stderr):
+def out_detrend_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["fwhm"]
+    return outputs["out_detrend"]
 
 
-def acf_param_callable(output_dir, inputs, stdout, stderr):
+def out_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["acf_param"]
+    return outputs["out_file"]
 
 
-def out_acf_callable(output_dir, inputs, stdout, stderr):
+def out_subbricks_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_acf"]
+    return outputs["out_subbricks"]
 
 
 iflogger = logging.getLogger("nipype.interface")
 
 
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
-# Original source at L58 of <nipype-install>/utils/filemanip.py
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
-# Original source at L888 of <nipype-install>/interfaces/base/core.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    return value
-
-
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
@@ -216,26 +147,6 @@ def _filename_from_source(
     return retval
 
 
-# Original source at L891 of <nipype-install>/interfaces/base/core.py
-def nipype_interfaces_afni__AFNICommandBase___list_outputs(
-    inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    metadata = dict(name_source=lambda t: t is not None)
-    traits = inputs.traits(**metadata)
-    if traits:
-        outputs = {}
-        for name, trait_spec in list(traits.items()):
-            out_name = name
-            if trait_spec.output_name is not None:
-                out_name = trait_spec.output_name
-            fname = _filename_from_source(
-                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-            )
-            if fname is not attrs.NOTHING:
-                outputs[out_name] = os.path.abspath(fname)
-        return outputs
-
-
 # Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
@@ -271,3 +182,92 @@ def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
             outputs["out_acf"] = op.abspath(inputs.acf)
 
     return outputs
+
+
+# Original source at L888 of <nipype-install>/interfaces/base/core.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value
+
+
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
+def nipype_interfaces_afni__AFNICommandBase___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+# Original source at L58 of <nipype-install>/utils/filemanip.py
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
diff --git a/example-specs/task/nipype/afni/gcor_callables.py b/example-specs/task/nipype/afni/gcor_callables.py
index 761e0b40..e6e1068d 100644
--- a/example-specs/task/nipype/afni/gcor_callables.py
+++ b/example-specs/task/nipype/afni/gcor_callables.py
@@ -1,7 +1,5 @@
 """Module to put any functions that are referred to in the "callables" section of GCOR.yaml"""
 
-import attrs
-
 
 def out_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
diff --git a/example-specs/task/nipype/afni/hist_callables.py b/example-specs/task/nipype/afni/hist_callables.py
index d136ec93..8940aad0 100644
--- a/example-specs/task/nipype/afni/hist_callables.py
+++ b/example-specs/task/nipype/afni/hist_callables.py
@@ -23,75 +23,6 @@ def out_show_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
-# Original source at L58 of <nipype-install>/utils/filemanip.py
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
-# Original source at L888 of <nipype-install>/interfaces/base/core.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    return value
-
-
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
@@ -187,6 +118,27 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+# Original source at L1572 of <nipype-install>/interfaces/afni/preprocess.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    outputs["out_file"] += ".niml.hist"
+    if not inputs.showhist:
+        outputs["out_show"] = attrs.NOTHING
+    return outputs
+
+
+# Original source at L888 of <nipype-install>/interfaces/base/core.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value
+
+
 # Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
@@ -207,15 +159,63 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
+# Original source at L58 of <nipype-install>/utils/filemanip.py
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
 
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
 
-# Original source at L1572 of <nipype-install>/interfaces/afni/preprocess.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    outputs["out_file"] += ".niml.hist"
-    if not inputs.showhist:
-        outputs["out_show"] = attrs.NOTHING
-    return outputs
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
diff --git a/example-specs/task/nipype/afni/lfcd_callables.py b/example-specs/task/nipype/afni/lfcd_callables.py
index 426af988..d6cea280 100644
--- a/example-specs/task/nipype/afni/lfcd_callables.py
+++ b/example-specs/task/nipype/afni/lfcd_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of LFCD.yaml"""
 
-from looseversion import LooseVersion
 import attrs
 import logging
 import os
 import os.path as op
+from looseversion import LooseVersion
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,17 +17,6 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
@@ -123,6 +112,33 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
 # Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
@@ -143,47 +159,20 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
-
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
-
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
-
-            klass._version = klass.parse_version(raw_info)
-
-        return klass._version
-
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
 
 
 # Original source at L58 of <nipype-install>/utils/filemanip.py
@@ -237,6 +226,55 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
@@ -319,41 +357,3 @@ def standard_image(img_name):
         out = clout.runtime.stdout
         basedir = os.path.split(out)[0]
         return os.path.join(basedir, img_name)
-
-
-# Original source at L242 of <nipype-install>/interfaces/afni/base.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    path, base, _ = split_filename(value)
-    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def nipype_interfaces_afni__AFNICommand___list_outputs(
-    inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
diff --git a/example-specs/task/nipype/afni/local_bistat_callables.py b/example-specs/task/nipype/afni/local_bistat_callables.py
index 2460317c..09b6666e 100644
--- a/example-specs/task/nipype/afni/local_bistat_callables.py
+++ b/example-specs/task/nipype/afni/local_bistat_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of LocalBistat.yaml"""
 
-from looseversion import LooseVersion
 import attrs
 import logging
 import os
 import os.path as op
+from looseversion import LooseVersion
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,17 +17,6 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
@@ -123,6 +112,33 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
 # Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
@@ -143,47 +159,20 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
-
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
-
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
-
-            klass._version = klass.parse_version(raw_info)
-
-        return klass._version
-
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
 
 
 # Original source at L58 of <nipype-install>/utils/filemanip.py
@@ -237,6 +226,55 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
@@ -319,41 +357,3 @@ def standard_image(img_name):
         out = clout.runtime.stdout
         basedir = os.path.split(out)[0]
         return os.path.join(basedir, img_name)
-
-
-# Original source at L242 of <nipype-install>/interfaces/afni/base.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    path, base, _ = split_filename(value)
-    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def nipype_interfaces_afni__AFNICommand___list_outputs(
-    inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
diff --git a/example-specs/task/nipype/afni/localstat_callables.py b/example-specs/task/nipype/afni/localstat_callables.py
index 491992e9..88e3ba9c 100644
--- a/example-specs/task/nipype/afni/localstat_callables.py
+++ b/example-specs/task/nipype/afni/localstat_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Localstat.yaml"""
 
-from looseversion import LooseVersion
 import attrs
 import logging
 import os
 import os.path as op
+from looseversion import LooseVersion
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,17 +17,6 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
@@ -123,6 +112,33 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
 # Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
@@ -143,47 +159,20 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
-
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
-
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
-
-            klass._version = klass.parse_version(raw_info)
-
-        return klass._version
-
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
 
 
 # Original source at L58 of <nipype-install>/utils/filemanip.py
@@ -237,6 +226,55 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
@@ -319,41 +357,3 @@ def standard_image(img_name):
         out = clout.runtime.stdout
         basedir = os.path.split(out)[0]
         return os.path.join(basedir, img_name)
-
-
-# Original source at L242 of <nipype-install>/interfaces/afni/base.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    path, base, _ = split_filename(value)
-    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def nipype_interfaces_afni__AFNICommand___list_outputs(
-    inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
diff --git a/example-specs/task/nipype/afni/mask_tool_callables.py b/example-specs/task/nipype/afni/mask_tool_callables.py
index 2ca951f5..8a592eda 100644
--- a/example-specs/task/nipype/afni/mask_tool_callables.py
+++ b/example-specs/task/nipype/afni/mask_tool_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of MaskTool.yaml"""
 
-from looseversion import LooseVersion
 import attrs
 import logging
 import os
 import os.path as op
+from looseversion import LooseVersion
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,17 +17,6 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
@@ -123,6 +112,33 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
 # Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
@@ -143,47 +159,20 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
-
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
-
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
-
-            klass._version = klass.parse_version(raw_info)
-
-        return klass._version
-
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
 
 
 # Original source at L58 of <nipype-install>/utils/filemanip.py
@@ -237,6 +226,55 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
@@ -319,41 +357,3 @@ def standard_image(img_name):
         out = clout.runtime.stdout
         basedir = os.path.split(out)[0]
         return os.path.join(basedir, img_name)
-
-
-# Original source at L242 of <nipype-install>/interfaces/afni/base.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    path, base, _ = split_filename(value)
-    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def nipype_interfaces_afni__AFNICommand___list_outputs(
-    inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
diff --git a/example-specs/task/nipype/afni/maskave_callables.py b/example-specs/task/nipype/afni/maskave_callables.py
index 9ae65d62..55221bdd 100644
--- a/example-specs/task/nipype/afni/maskave_callables.py
+++ b/example-specs/task/nipype/afni/maskave_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Maskave.yaml"""
 
-from looseversion import LooseVersion
 import attrs
 import logging
 import os
 import os.path as op
+from looseversion import LooseVersion
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,17 +17,6 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
@@ -123,6 +112,33 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
 # Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
@@ -143,47 +159,20 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
-
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
-
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
-
-            klass._version = klass.parse_version(raw_info)
-
-        return klass._version
-
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
 
 
 # Original source at L58 of <nipype-install>/utils/filemanip.py
@@ -237,6 +226,55 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
@@ -319,41 +357,3 @@ def standard_image(img_name):
         out = clout.runtime.stdout
         basedir = os.path.split(out)[0]
         return os.path.join(basedir, img_name)
-
-
-# Original source at L242 of <nipype-install>/interfaces/afni/base.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    path, base, _ = split_filename(value)
-    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def nipype_interfaces_afni__AFNICommand___list_outputs(
-    inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
diff --git a/example-specs/task/nipype/afni/means_callables.py b/example-specs/task/nipype/afni/means_callables.py
index 0c2cdec1..45f9940d 100644
--- a/example-specs/task/nipype/afni/means_callables.py
+++ b/example-specs/task/nipype/afni/means_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Means.yaml"""
 
-from looseversion import LooseVersion
 import attrs
 import logging
 import os
 import os.path as op
+from looseversion import LooseVersion
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,17 +17,6 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
@@ -123,6 +112,33 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
 # Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
@@ -143,47 +159,20 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
-
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
-
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
-
-            klass._version = klass.parse_version(raw_info)
-
-        return klass._version
-
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
 
 
 # Original source at L58 of <nipype-install>/utils/filemanip.py
@@ -237,6 +226,55 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
@@ -319,41 +357,3 @@ def standard_image(img_name):
         out = clout.runtime.stdout
         basedir = os.path.split(out)[0]
         return os.path.join(basedir, img_name)
-
-
-# Original source at L242 of <nipype-install>/interfaces/afni/base.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    path, base, _ = split_filename(value)
-    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def nipype_interfaces_afni__AFNICommand___list_outputs(
-    inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
diff --git a/example-specs/task/nipype/afni/merge_callables.py b/example-specs/task/nipype/afni/merge_callables.py
index 75a551d9..7fc2ce19 100644
--- a/example-specs/task/nipype/afni/merge_callables.py
+++ b/example-specs/task/nipype/afni/merge_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Merge.yaml"""
 
-from looseversion import LooseVersion
 import attrs
 import logging
 import os
 import os.path as op
+from looseversion import LooseVersion
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,17 +17,6 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
@@ -123,6 +112,33 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
 # Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
@@ -143,47 +159,20 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
-
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
-
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
-
-            klass._version = klass.parse_version(raw_info)
-
-        return klass._version
-
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
 
 
 # Original source at L58 of <nipype-install>/utils/filemanip.py
@@ -237,6 +226,55 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
@@ -319,41 +357,3 @@ def standard_image(img_name):
         out = clout.runtime.stdout
         basedir = os.path.split(out)[0]
         return os.path.join(basedir, img_name)
-
-
-# Original source at L242 of <nipype-install>/interfaces/afni/base.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    path, base, _ = split_filename(value)
-    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def nipype_interfaces_afni__AFNICommand___list_outputs(
-    inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
diff --git a/example-specs/task/nipype/afni/net_corr_callables.py b/example-specs/task/nipype/afni/net_corr_callables.py
index be193a75..8d242d98 100644
--- a/example-specs/task/nipype/afni/net_corr_callables.py
+++ b/example-specs/task/nipype/afni/net_corr_callables.py
@@ -1,63 +1,116 @@
 """Module to put any functions that are referred to in the "callables" section of NetCorr.yaml"""
 
-from looseversion import LooseVersion
-import glob
 import attrs
+import glob
 import os
 import os.path as op
+from looseversion import LooseVersion
 from pathlib import Path
 
 
-def out_corr_matrix_callable(output_dir, inputs, stdout, stderr):
+def out_corr_maps_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_corr_matrix"]
+    return outputs["out_corr_maps"]
 
 
-def out_corr_maps_callable(output_dir, inputs, stdout, stderr):
+def out_corr_matrix_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_corr_maps"]
+    return outputs["out_corr_matrix"]
 
 
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
 
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
 
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
+# Original source at L260 of <nipype-install>/interfaces/afni/base.py
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """
+    Generate a filename based on the given parameters.
 
-            klass._version = klass.parse_version(raw_info)
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
 
-        return klass._version
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
 
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+    if not basename:
+        msg = "Unable to generate filename for command %s. " % "3dNetCorr"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.outputtype)
+    if change_ext:
+        suffix = "".join((suffix, ext)) if suffix else ext
+
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+# Original source at L2732 of <nipype-install>/interfaces/afni/preprocess.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    import glob
+
+    outputs = {}
+
+    if inputs.out_file is attrs.NOTHING:
+        prefix = _gen_fname(
+            inputs.in_file,
+            suffix="_netcorr",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    else:
+        prefix = inputs.out_file
+
+    # All outputs should be in the same directory as the prefix
+    odir = os.path.dirname(os.path.abspath(prefix))
+    outputs["out_corr_matrix"] = glob.glob(os.path.join(odir, "*.netcc"))[0]
+
+    if (inputs.ts_wb_corr is not attrs.NOTHING) or (
+        inputs.ts_Z_corr is not attrs.NOTHING
+    ):
+        corrdir = os.path.join(odir, prefix + "_000_INDIV")
+        outputs["out_corr_maps"] = glob.glob(os.path.join(corrdir, "*.nii.gz"))
+
+    return outputs
 
 
 # Original source at L108 of <nipype-install>/utils/filemanip.py
@@ -154,6 +207,44 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
@@ -236,94 +327,3 @@ def standard_image(img_name):
         out = clout.runtime.stdout
         basedir = os.path.split(out)[0]
         return os.path.join(basedir, img_name)
-
-
-# Original source at L260 of <nipype-install>/interfaces/afni/base.py
-def _gen_fname(
-    basename,
-    cwd=None,
-    suffix=None,
-    change_ext=True,
-    ext=None,
-    inputs=None,
-    stdout=None,
-    stderr=None,
-    output_dir=None,
-):
-    """
-    Generate a filename based on the given parameters.
-
-    The filename will take the form: cwd/basename<suffix><ext>.
-    If change_ext is True, it will use the extensions specified in
-    <instance>inputs.output_type.
-
-    Parameters
-    ----------
-    basename : str
-        Filename to base the new filename on.
-    cwd : str
-        Path to prefix to the new filename. (default is output_dir)
-    suffix : str
-        Suffix to add to the `basename`.  (defaults is '' )
-    change_ext : bool
-        Flag to change the filename extension to the FSL output type.
-        (default True)
-
-    Returns
-    -------
-    fname : str
-        New filename based on given parameters.
-
-    """
-    if not basename:
-        msg = "Unable to generate filename for command %s. " % "3dNetCorr"
-        msg += "basename is not set!"
-        raise ValueError(msg)
-
-    if cwd is None:
-        cwd = output_dir
-    if ext is None:
-        ext = Info.output_type_to_ext(inputs.outputtype)
-    if change_ext:
-        suffix = "".join((suffix, ext)) if suffix else ext
-
-    if suffix is None:
-        suffix = ""
-    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
-    return fname
-
-
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
-# Original source at L2732 of <nipype-install>/interfaces/afni/preprocess.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    import glob
-
-    outputs = {}
-
-    if inputs.out_file is attrs.NOTHING:
-        prefix = _gen_fname(
-            inputs.in_file,
-            suffix="_netcorr",
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-    else:
-        prefix = inputs.out_file
-
-    # All outputs should be in the same directory as the prefix
-    odir = os.path.dirname(os.path.abspath(prefix))
-    outputs["out_corr_matrix"] = glob.glob(os.path.join(odir, "*.netcc"))[0]
-
-    if (inputs.ts_wb_corr is not attrs.NOTHING) or (
-        inputs.ts_Z_corr is not attrs.NOTHING
-    ):
-        corrdir = os.path.join(odir, prefix + "_000_INDIV")
-        outputs["out_corr_maps"] = glob.glob(os.path.join(corrdir, "*.nii.gz"))
-
-    return outputs
diff --git a/example-specs/task/nipype/afni/notes_callables.py b/example-specs/task/nipype/afni/notes_callables.py
index f5d9673f..35a6a6b9 100644
--- a/example-specs/task/nipype/afni/notes_callables.py
+++ b/example-specs/task/nipype/afni/notes_callables.py
@@ -1,7 +1,6 @@
 """Module to put any functions that are referred to in the "callables" section of Notes.yaml"""
 
 import os
-import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/afni/nwarp_adjust_callables.py b/example-specs/task/nipype/afni/nwarp_adjust_callables.py
index 3f6aaeb8..9620f64d 100644
--- a/example-specs/task/nipype/afni/nwarp_adjust_callables.py
+++ b/example-specs/task/nipype/afni/nwarp_adjust_callables.py
@@ -2,7 +2,6 @@
 
 import os
 import os.path as op
-import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/afni/nwarp_apply_callables.py b/example-specs/task/nipype/afni/nwarp_apply_callables.py
index 399d47d6..bba76f4d 100644
--- a/example-specs/task/nipype/afni/nwarp_apply_callables.py
+++ b/example-specs/task/nipype/afni/nwarp_apply_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of NwarpApply.yaml"""
 
+import attrs
 import logging
 import os
 import os.path as op
-import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -16,75 +16,6 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
-# Original source at L58 of <nipype-install>/utils/filemanip.py
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
-# Original source at L888 of <nipype-install>/interfaces/base/core.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    return value
-
-
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
@@ -201,3 +132,72 @@ def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
             if fname is not attrs.NOTHING:
                 outputs[out_name] = os.path.abspath(fname)
         return outputs
+
+
+# Original source at L888 of <nipype-install>/interfaces/base/core.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value
+
+
+# Original source at L58 of <nipype-install>/utils/filemanip.py
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
diff --git a/example-specs/task/nipype/afni/nwarp_cat_callables.py b/example-specs/task/nipype/afni/nwarp_cat_callables.py
index 83981a96..8d92c190 100644
--- a/example-specs/task/nipype/afni/nwarp_cat_callables.py
+++ b/example-specs/task/nipype/afni/nwarp_cat_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of NwarpCat.yaml"""
 
-from looseversion import LooseVersion
 import attrs
 import os
 import os.path as op
+from looseversion import LooseVersion
 from pathlib import Path
 
 
@@ -14,42 +14,92 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_file"]
 
 
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
+# Original source at L2235 of <nipype-install>/interfaces/afni/utils.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _gen_fname(
+            inputs.in_files[0][0],
+            suffix="_NwarpCat",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
 
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
 
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
+# Original source at L260 of <nipype-install>/interfaces/afni/base.py
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """
+    Generate a filename based on the given parameters.
 
-            klass._version = klass.parse_version(raw_info)
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
 
-        return klass._version
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
 
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+    if not basename:
+        msg = "Unable to generate filename for command %s. " % "3dNwarpCat"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.outputtype)
+    if change_ext:
+        suffix = "".join((suffix, ext)) if suffix else ext
+
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+# Original source at L2239 of <nipype-install>/interfaces/afni/utils.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    if inputs.out_file is not attrs.NOTHING:
+        outputs["out_file"] = os.path.abspath(inputs.out_file)
+    else:
+        outputs["out_file"] = os.path.abspath(
+            _gen_fname(
+                inputs.in_files[0],
+                suffix="_NwarpCat+tlrc",
+                ext=".HEAD",
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+        )
+    return outputs
 
 
 # Original source at L108 of <nipype-install>/utils/filemanip.py
@@ -146,6 +196,44 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
@@ -228,91 +316,3 @@ def standard_image(img_name):
         out = clout.runtime.stdout
         basedir = os.path.split(out)[0]
         return os.path.join(basedir, img_name)
-
-
-# Original source at L260 of <nipype-install>/interfaces/afni/base.py
-def _gen_fname(
-    basename,
-    cwd=None,
-    suffix=None,
-    change_ext=True,
-    ext=None,
-    inputs=None,
-    stdout=None,
-    stderr=None,
-    output_dir=None,
-):
-    """
-    Generate a filename based on the given parameters.
-
-    The filename will take the form: cwd/basename<suffix><ext>.
-    If change_ext is True, it will use the extensions specified in
-    <instance>inputs.output_type.
-
-    Parameters
-    ----------
-    basename : str
-        Filename to base the new filename on.
-    cwd : str
-        Path to prefix to the new filename. (default is output_dir)
-    suffix : str
-        Suffix to add to the `basename`.  (defaults is '' )
-    change_ext : bool
-        Flag to change the filename extension to the FSL output type.
-        (default True)
-
-    Returns
-    -------
-    fname : str
-        New filename based on given parameters.
-
-    """
-    if not basename:
-        msg = "Unable to generate filename for command %s. " % "3dNwarpCat"
-        msg += "basename is not set!"
-        raise ValueError(msg)
-
-    if cwd is None:
-        cwd = output_dir
-    if ext is None:
-        ext = Info.output_type_to_ext(inputs.outputtype)
-    if change_ext:
-        suffix = "".join((suffix, ext)) if suffix else ext
-
-    if suffix is None:
-        suffix = ""
-    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
-    return fname
-
-
-# Original source at L2235 of <nipype-install>/interfaces/afni/utils.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "out_file":
-        return _gen_fname(
-            inputs.in_files[0][0],
-            suffix="_NwarpCat",
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-
-
-# Original source at L2239 of <nipype-install>/interfaces/afni/utils.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    if inputs.out_file is not attrs.NOTHING:
-        outputs["out_file"] = os.path.abspath(inputs.out_file)
-    else:
-        outputs["out_file"] = os.path.abspath(
-            _gen_fname(
-                inputs.in_files[0],
-                suffix="_NwarpCat+tlrc",
-                ext=".HEAD",
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-        )
-    return outputs
diff --git a/example-specs/task/nipype/afni/one_d_tool_py.yaml b/example-specs/task/nipype/afni/one_d_tool_py.yaml
index 01d955da..c29ab55c 100644
--- a/example-specs/task/nipype/afni/one_d_tool_py.yaml
+++ b/example-specs/task/nipype/afni/one_d_tool_py.yaml
@@ -82,7 +82,7 @@ tests:
     show_censor_count:
     # type=bool|default=False: display the total number of censored TRs  Note : if input is a valid xmat.1D dataset, then the count will come from the header.  Otherwise the input is assumed to be a binary censorfile, and zeros are simply counted.
     censor_motion:
-    # type=tuple|default=(<traits.trait_types.Float object at 0x107a1bcd0>, <nipype.interfaces.base.traits_extension.File object at 0x107a1bd90>): Tuple of motion limit and outfile prefix. need to also set set_nruns -r set_run_lengths
+    # type=tuple|default=(<traits.trait_types.Float object at 0x107b49590>, <nipype.interfaces.base.traits_extension.File object at 0x107b49650>): Tuple of motion limit and outfile prefix. need to also set set_nruns -r set_run_lengths
     censor_prev_TR:
     # type=bool|default=False: for each censored TR, also censor previous
     show_trs_uncensored:
diff --git a/example-specs/task/nipype/afni/one_d_tool_py_callables.py b/example-specs/task/nipype/afni/one_d_tool_py_callables.py
index 2462a10d..70d2d925 100644
--- a/example-specs/task/nipype/afni/one_d_tool_py_callables.py
+++ b/example-specs/task/nipype/afni/one_d_tool_py_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of OneDToolPy.yaml"""
 
-import os
 import attrs
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/afni/outlier_count_callables.py b/example-specs/task/nipype/afni/outlier_count_callables.py
index 10af7cc3..cb2647da 100644
--- a/example-specs/task/nipype/afni/outlier_count_callables.py
+++ b/example-specs/task/nipype/afni/outlier_count_callables.py
@@ -1,21 +1,20 @@
 """Module to put any functions that are referred to in the "callables" section of OutlierCount.yaml"""
 
 import os.path as op
-import attrs
 
 
-def out_outliers_callable(output_dir, inputs, stdout, stderr):
+def out_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_outliers"]
+    return outputs["out_file"]
 
 
-def out_file_callable(output_dir, inputs, stdout, stderr):
+def out_outliers_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_file"]
+    return outputs["out_outliers"]
 
 
 # Original source at L885 of <nipype-install>/interfaces/base/core.py
diff --git a/example-specs/task/nipype/afni/quality_index_callables.py b/example-specs/task/nipype/afni/quality_index_callables.py
index 297de710..e835dc3f 100644
--- a/example-specs/task/nipype/afni/quality_index_callables.py
+++ b/example-specs/task/nipype/afni/quality_index_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of QualityIndex.yaml"""
 
+import attrs
 import logging
 import os
 import os.path as op
-import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -16,75 +16,6 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
-# Original source at L58 of <nipype-install>/utils/filemanip.py
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
-# Original source at L888 of <nipype-install>/interfaces/base/core.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    return value
-
-
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
@@ -201,3 +132,72 @@ def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
             if fname is not attrs.NOTHING:
                 outputs[out_name] = os.path.abspath(fname)
         return outputs
+
+
+# Original source at L888 of <nipype-install>/interfaces/base/core.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value
+
+
+# Original source at L58 of <nipype-install>/utils/filemanip.py
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
diff --git a/example-specs/task/nipype/afni/qwarp.yaml b/example-specs/task/nipype/afni/qwarp.yaml
index bb49eb53..5106cb0b 100644
--- a/example-specs/task/nipype/afni/qwarp.yaml
+++ b/example-specs/task/nipype/afni/qwarp.yaml
@@ -193,7 +193,7 @@ tests:
     wball:
     # type=list|default=[]: "``-wball x y z r f`` Enhance automatic weight from '-useweight' by a factor of 1+f\*Gaussian(FWHM=r) centered in the base image at DICOM coordinates (x,y,z) and with radius 'r'. The goal of this option is to try and make the alignment better in a specific part of the brain. Example:  -wball 0 14 6 30 40 to emphasize the thalamic area (in MNI/Talairach space).  * The 'r' parameter must be positive! * The 'f' parameter must be between 1 and 100 (inclusive). * '-wball' does nothing if you input your own weight   with the '-weight' option. * '-wball' does change the binary weight created by   the '-noweight' option. * You can only use '-wball' once in a run of 3dQwarp.  **The effect of '-wball' is not dramatic.** The example above makes the average brain image across a collection of subjects a little sharper in the thalamic area, which might have some small value.  If you care enough about alignment to use '-wball', then you should examine the results from 3dQwarp for each subject, to see if the alignments are good enough for your purposes.
     wmask:
-    # type=tuple|default=(<nipype.interfaces.base.traits_extension.File object at 0x10791de50>, <traits.trait_types.Float object at 0x10791e190>): Similar to '-wball', but here, you provide a dataset 'ws' that indicates where to increase the weight.  * The 'ws' dataset must be on the same 3D grid as the base dataset. * 'ws' is treated as a mask -- it only matters where it   is nonzero -- otherwise, the values inside are not used. * After 'ws' comes the factor 'f' by which to increase the   automatically computed weight.  Where 'ws' is nonzero,   the weighting will be multiplied by (1+f). * As with '-wball', the factor 'f' should be between 1 and 100.  
+    # type=tuple|default=(<nipype.interfaces.base.traits_extension.File object at 0x107a43190>, <traits.trait_types.Float object at 0x107a431d0>): Similar to '-wball', but here, you provide a dataset 'ws' that indicates where to increase the weight.  * The 'ws' dataset must be on the same 3D grid as the base dataset. * 'ws' is treated as a mask -- it only matters where it   is nonzero -- otherwise, the values inside are not used. * After 'ws' comes the factor 'f' by which to increase the   automatically computed weight.  Where 'ws' is nonzero,   the weighting will be multiplied by (1+f). * As with '-wball', the factor 'f' should be between 1 and 100.  
     out_weight_file:
     # type=file|default=<undefined>: Write the weight volume to disk as a dataset
     blur:
diff --git a/example-specs/task/nipype/afni/qwarp_callables.py b/example-specs/task/nipype/afni/qwarp_callables.py
index 8a001f67..e515eb0d 100644
--- a/example-specs/task/nipype/afni/qwarp_callables.py
+++ b/example-specs/task/nipype/afni/qwarp_callables.py
@@ -1,38 +1,38 @@
 """Module to put any functions that are referred to in the "callables" section of Qwarp.yaml"""
 
-from looseversion import LooseVersion
 import attrs
 import os
 import os.path as op
+from looseversion import LooseVersion
 from pathlib import Path
 
 
-def warped_source_callable(output_dir, inputs, stdout, stderr):
+def base_warp_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["warped_source"]
+    return outputs["base_warp"]
 
 
-def warped_base_callable(output_dir, inputs, stdout, stderr):
+def source_warp_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["warped_base"]
+    return outputs["source_warp"]
 
 
-def source_warp_callable(output_dir, inputs, stdout, stderr):
+def warped_base_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["source_warp"]
+    return outputs["warped_base"]
 
 
-def base_warp_callable(output_dir, inputs, stdout, stderr):
+def warped_source_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["base_warp"]
+    return outputs["warped_source"]
 
 
 def weights_callable(output_dir, inputs, stdout, stderr):
@@ -42,42 +42,17 @@ def weights_callable(output_dir, inputs, stdout, stderr):
     return outputs["weights"]
 
 
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
-
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
-
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
-
-            klass._version = klass.parse_version(raw_info)
-
-        return klass._version
-
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+# Original source at L4449 of <nipype-install>/interfaces/afni/preprocess.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _gen_fname(
+            inputs.in_file,
+            suffix="_QW",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
 
 
 # Original source at L260 of <nipype-install>/interfaces/afni/base.py
@@ -135,88 +110,88 @@ def _gen_fname(
     return fname
 
 
-# Original source at L26 of <nipype-install>/interfaces/afni/base.py
-class Info(PackageInfo):
-    """Handle afni output type and version information."""
-
-    __outputtype = "AFNI"
-    ftypes = {"NIFTI": ".nii", "AFNI": "", "NIFTI_GZ": ".nii.gz"}
-    version_cmd = "afni --version"
+# Original source at L4372 of <nipype-install>/interfaces/afni/preprocess.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
 
-    @staticmethod
-    def parse_version(raw_info):
-        """Check and parse AFNI's version."""
-        version_stamp = raw_info.split("\n")[0].split("Version ")[1]
-        if version_stamp.startswith("AFNI"):
-            version_stamp = version_stamp.split("AFNI_")[1]
-        elif version_stamp.startswith("Debian"):
-            version_stamp = version_stamp.split("Debian-")[1].split("~")[0]
+    if inputs.out_file is attrs.NOTHING:
+        prefix = _gen_fname(
+            inputs.in_file,
+            suffix="_QW",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+        outputtype = inputs.outputtype
+        if outputtype == "AFNI":
+            ext = ".HEAD"
+            suffix = "+tlrc"
         else:
-            return None
-
-        version = LooseVersion(version_stamp.replace("_", ".")).version[:3]
-        if version[0] < 1000:
-            version[0] = version[0] + 2000
-        return tuple(version)
-
-    @classmethod
-    def output_type_to_ext(cls, outputtype):
-        """
-        Get the file extension for the given output type.
-
-        Parameters
-        ----------
-        outputtype : {'NIFTI', 'NIFTI_GZ', 'AFNI'}
-            String specifying the output type.
-
-        Returns
-        -------
-        extension : str
-            The file extension for the output type.
-
-        """
-        try:
-            return cls.ftypes[outputtype]
-        except KeyError as e:
-            msg = "Invalid AFNIOUTPUTTYPE: ", outputtype
-            raise KeyError(msg) from e
-
-    @classmethod
-    def outputtype(cls):
-        """
-        Set default output filetype.
-
-        AFNI has no environment variables, Output filetypes get set in command line calls
-        Nipype uses ``AFNI`` as default
-
-
-        Returns
-        -------
-        None
-
-        """
-        return "AFNI"
-
-    @staticmethod
-    def standard_image(img_name):
-        """
-        Grab an image from the standard location.
+            ext = Info.output_type_to_ext(outputtype)
+            suffix = ""
+    else:
+        prefix = inputs.out_file
+        ext_ind = max([prefix.lower().rfind(".nii.gz"), prefix.lower().rfind(".nii")])
+        if ext_ind == -1:
+            ext = ".HEAD"
+            suffix = "+tlrc"
+        else:
+            ext = prefix[ext_ind:]
+            suffix = ""
 
-        Could be made more fancy to allow for more relocatability
+    # All outputs should be in the same directory as the prefix
+    out_dir = os.path.dirname(os.path.abspath(prefix))
 
-        """
-        clout = CommandLine(
-            "which afni",
-            ignore_exception=True,
-            resource_monitor=False,
-            terminal_output="allatonce",
-        ).run()
-        if clout.runtime.returncode != 0:
-            return None
+    outputs["warped_source"] = (
+        fname_presuffix(prefix, suffix=suffix, use_ext=False, newpath=out_dir) + ext
+    )
+    if not inputs.nowarp:
+        outputs["source_warp"] = (
+            fname_presuffix(
+                prefix, suffix="_WARP" + suffix, use_ext=False, newpath=out_dir
+            )
+            + ext
+        )
+    if inputs.iwarp:
+        outputs["base_warp"] = (
+            fname_presuffix(
+                prefix, suffix="_WARPINV" + suffix, use_ext=False, newpath=out_dir
+            )
+            + ext
+        )
+    if inputs.out_weight_file is not attrs.NOTHING:
+        outputs["weights"] = os.path.abspath(inputs.out_weight_file)
 
-        out = clout.runtime.stdout
-        basedir = os.path.split(out)[0]
-        return os.path.join(basedir, img_name)
+    if inputs.plusminus:
+        outputs["warped_source"] = (
+            fname_presuffix(
+                prefix, suffix="_PLUS" + suffix, use_ext=False, newpath=out_dir
+            )
+            + ext
+        )
+        outputs["warped_base"] = (
+            fname_presuffix(
+                prefix, suffix="_MINUS" + suffix, use_ext=False, newpath=out_dir
+            )
+            + ext
+        )
+        outputs["source_warp"] = (
+            fname_presuffix(
+                prefix, suffix="_PLUS_WARP" + suffix, use_ext=False, newpath=out_dir
+            )
+            + ext
+        )
+        outputs["base_warp"] = (
+            fname_presuffix(
+                prefix,
+                suffix="_MINUS_WARP" + suffix,
+                use_ext=False,
+                newpath=out_dir,
+            )
+            + ext
+        )
+    return outputs
 
 
 # Original source at L108 of <nipype-install>/utils/filemanip.py
@@ -313,98 +288,123 @@ def split_filename(fname):
     return pth, fname, ext
 
 
-# Original source at L4449 of <nipype-install>/interfaces/afni/preprocess.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "out_file":
-        return _gen_fname(
-            inputs.in_file,
-            suffix="_QW",
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
 
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
 
-# Original source at L4372 of <nipype-install>/interfaces/afni/preprocess.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
 
-    if inputs.out_file is attrs.NOTHING:
-        prefix = _gen_fname(
-            inputs.in_file,
-            suffix="_QW",
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-        outputtype = inputs.outputtype
-        if outputtype == "AFNI":
-            ext = ".HEAD"
-            suffix = "+tlrc"
-        else:
-            ext = Info.output_type_to_ext(outputtype)
-            suffix = ""
-    else:
-        prefix = inputs.out_file
-        ext_ind = max([prefix.lower().rfind(".nii.gz"), prefix.lower().rfind(".nii")])
-        if ext_ind == -1:
-            ext = ".HEAD"
-            suffix = "+tlrc"
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
+# Original source at L26 of <nipype-install>/interfaces/afni/base.py
+class Info(PackageInfo):
+    """Handle afni output type and version information."""
+
+    __outputtype = "AFNI"
+    ftypes = {"NIFTI": ".nii", "AFNI": "", "NIFTI_GZ": ".nii.gz"}
+    version_cmd = "afni --version"
+
+    @staticmethod
+    def parse_version(raw_info):
+        """Check and parse AFNI's version."""
+        version_stamp = raw_info.split("\n")[0].split("Version ")[1]
+        if version_stamp.startswith("AFNI"):
+            version_stamp = version_stamp.split("AFNI_")[1]
+        elif version_stamp.startswith("Debian"):
+            version_stamp = version_stamp.split("Debian-")[1].split("~")[0]
         else:
-            ext = prefix[ext_ind:]
-            suffix = ""
+            return None
 
-    # All outputs should be in the same directory as the prefix
-    out_dir = os.path.dirname(os.path.abspath(prefix))
+        version = LooseVersion(version_stamp.replace("_", ".")).version[:3]
+        if version[0] < 1000:
+            version[0] = version[0] + 2000
+        return tuple(version)
 
-    outputs["warped_source"] = (
-        fname_presuffix(prefix, suffix=suffix, use_ext=False, newpath=out_dir) + ext
-    )
-    if not inputs.nowarp:
-        outputs["source_warp"] = (
-            fname_presuffix(
-                prefix, suffix="_WARP" + suffix, use_ext=False, newpath=out_dir
-            )
-            + ext
-        )
-    if inputs.iwarp:
-        outputs["base_warp"] = (
-            fname_presuffix(
-                prefix, suffix="_WARPINV" + suffix, use_ext=False, newpath=out_dir
-            )
-            + ext
-        )
-    if inputs.out_weight_file is not attrs.NOTHING:
-        outputs["weights"] = os.path.abspath(inputs.out_weight_file)
+    @classmethod
+    def output_type_to_ext(cls, outputtype):
+        """
+        Get the file extension for the given output type.
 
-    if inputs.plusminus:
-        outputs["warped_source"] = (
-            fname_presuffix(
-                prefix, suffix="_PLUS" + suffix, use_ext=False, newpath=out_dir
-            )
-            + ext
-        )
-        outputs["warped_base"] = (
-            fname_presuffix(
-                prefix, suffix="_MINUS" + suffix, use_ext=False, newpath=out_dir
-            )
-            + ext
-        )
-        outputs["source_warp"] = (
-            fname_presuffix(
-                prefix, suffix="_PLUS_WARP" + suffix, use_ext=False, newpath=out_dir
-            )
-            + ext
-        )
-        outputs["base_warp"] = (
-            fname_presuffix(
-                prefix,
-                suffix="_MINUS_WARP" + suffix,
-                use_ext=False,
-                newpath=out_dir,
-            )
-            + ext
-        )
-    return outputs
+        Parameters
+        ----------
+        outputtype : {'NIFTI', 'NIFTI_GZ', 'AFNI'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+
+        """
+        try:
+            return cls.ftypes[outputtype]
+        except KeyError as e:
+            msg = "Invalid AFNIOUTPUTTYPE: ", outputtype
+            raise KeyError(msg) from e
+
+    @classmethod
+    def outputtype(cls):
+        """
+        Set default output filetype.
+
+        AFNI has no environment variables, Output filetypes get set in command line calls
+        Nipype uses ``AFNI`` as default
+
+
+        Returns
+        -------
+        None
+
+        """
+        return "AFNI"
+
+    @staticmethod
+    def standard_image(img_name):
+        """
+        Grab an image from the standard location.
+
+        Could be made more fancy to allow for more relocatability
+
+        """
+        clout = CommandLine(
+            "which afni",
+            ignore_exception=True,
+            resource_monitor=False,
+            terminal_output="allatonce",
+        ).run()
+        if clout.runtime.returncode != 0:
+            return None
+
+        out = clout.runtime.stdout
+        basedir = os.path.split(out)[0]
+        return os.path.join(basedir, img_name)
diff --git a/example-specs/task/nipype/afni/qwarp_plus_minus.yaml b/example-specs/task/nipype/afni/qwarp_plus_minus.yaml
index b6984cbb..0014b8f0 100644
--- a/example-specs/task/nipype/afni/qwarp_plus_minus.yaml
+++ b/example-specs/task/nipype/afni/qwarp_plus_minus.yaml
@@ -129,7 +129,7 @@ tests:
     wball:
     # type=list|default=[]: "``-wball x y z r f`` Enhance automatic weight from '-useweight' by a factor of 1+f\*Gaussian(FWHM=r) centered in the base image at DICOM coordinates (x,y,z) and with radius 'r'. The goal of this option is to try and make the alignment better in a specific part of the brain. Example:  -wball 0 14 6 30 40 to emphasize the thalamic area (in MNI/Talairach space).  * The 'r' parameter must be positive! * The 'f' parameter must be between 1 and 100 (inclusive). * '-wball' does nothing if you input your own weight   with the '-weight' option. * '-wball' does change the binary weight created by   the '-noweight' option. * You can only use '-wball' once in a run of 3dQwarp.  **The effect of '-wball' is not dramatic.** The example above makes the average brain image across a collection of subjects a little sharper in the thalamic area, which might have some small value.  If you care enough about alignment to use '-wball', then you should examine the results from 3dQwarp for each subject, to see if the alignments are good enough for your purposes.
     wmask:
-    # type=tuple|default=(<nipype.interfaces.base.traits_extension.File object at 0x10791de50>, <traits.trait_types.Float object at 0x10791e190>): Similar to '-wball', but here, you provide a dataset 'ws' that indicates where to increase the weight.  * The 'ws' dataset must be on the same 3D grid as the base dataset. * 'ws' is treated as a mask -- it only matters where it   is nonzero -- otherwise, the values inside are not used. * After 'ws' comes the factor 'f' by which to increase the   automatically computed weight.  Where 'ws' is nonzero,   the weighting will be multiplied by (1+f). * As with '-wball', the factor 'f' should be between 1 and 100.  
+    # type=tuple|default=(<nipype.interfaces.base.traits_extension.File object at 0x107a43190>, <traits.trait_types.Float object at 0x107a431d0>): Similar to '-wball', but here, you provide a dataset 'ws' that indicates where to increase the weight.  * The 'ws' dataset must be on the same 3D grid as the base dataset. * 'ws' is treated as a mask -- it only matters where it   is nonzero -- otherwise, the values inside are not used. * After 'ws' comes the factor 'f' by which to increase the   automatically computed weight.  Where 'ws' is nonzero,   the weighting will be multiplied by (1+f). * As with '-wball', the factor 'f' should be between 1 and 100.  
     out_weight_file:
     # type=file|default=<undefined>: Write the weight volume to disk as a dataset
     blur:
diff --git a/example-specs/task/nipype/afni/qwarp_plus_minus_callables.py b/example-specs/task/nipype/afni/qwarp_plus_minus_callables.py
index 92727841..1bcbd706 100644
--- a/example-specs/task/nipype/afni/qwarp_plus_minus_callables.py
+++ b/example-specs/task/nipype/afni/qwarp_plus_minus_callables.py
@@ -1,38 +1,38 @@
 """Module to put any functions that are referred to in the "callables" section of QwarpPlusMinus.yaml"""
 
-from looseversion import LooseVersion
 import attrs
 import os
 import os.path as op
+from looseversion import LooseVersion
 from pathlib import Path
 
 
-def warped_source_callable(output_dir, inputs, stdout, stderr):
+def base_warp_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["warped_source"]
+    return outputs["base_warp"]
 
 
-def warped_base_callable(output_dir, inputs, stdout, stderr):
+def source_warp_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["warped_base"]
+    return outputs["source_warp"]
 
 
-def source_warp_callable(output_dir, inputs, stdout, stderr):
+def warped_base_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["source_warp"]
+    return outputs["warped_base"]
 
 
-def base_warp_callable(output_dir, inputs, stdout, stderr):
+def warped_source_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["base_warp"]
+    return outputs["warped_source"]
 
 
 def weights_callable(output_dir, inputs, stdout, stderr):
@@ -42,42 +42,17 @@ def weights_callable(output_dir, inputs, stdout, stderr):
     return outputs["weights"]
 
 
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
-
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
-
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
-
-            klass._version = klass.parse_version(raw_info)
-
-        return klass._version
-
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+# Original source at L4449 of <nipype-install>/interfaces/afni/preprocess.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _gen_fname(
+            inputs.in_file,
+            suffix="_QW",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
 
 
 # Original source at L260 of <nipype-install>/interfaces/afni/base.py
@@ -135,88 +110,88 @@ def _gen_fname(
     return fname
 
 
-# Original source at L26 of <nipype-install>/interfaces/afni/base.py
-class Info(PackageInfo):
-    """Handle afni output type and version information."""
-
-    __outputtype = "AFNI"
-    ftypes = {"NIFTI": ".nii", "AFNI": "", "NIFTI_GZ": ".nii.gz"}
-    version_cmd = "afni --version"
+# Original source at L4372 of <nipype-install>/interfaces/afni/preprocess.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
 
-    @staticmethod
-    def parse_version(raw_info):
-        """Check and parse AFNI's version."""
-        version_stamp = raw_info.split("\n")[0].split("Version ")[1]
-        if version_stamp.startswith("AFNI"):
-            version_stamp = version_stamp.split("AFNI_")[1]
-        elif version_stamp.startswith("Debian"):
-            version_stamp = version_stamp.split("Debian-")[1].split("~")[0]
+    if inputs.out_file is attrs.NOTHING:
+        prefix = _gen_fname(
+            inputs.in_file,
+            suffix="_QW",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+        outputtype = inputs.outputtype
+        if outputtype == "AFNI":
+            ext = ".HEAD"
+            suffix = "+tlrc"
         else:
-            return None
-
-        version = LooseVersion(version_stamp.replace("_", ".")).version[:3]
-        if version[0] < 1000:
-            version[0] = version[0] + 2000
-        return tuple(version)
-
-    @classmethod
-    def output_type_to_ext(cls, outputtype):
-        """
-        Get the file extension for the given output type.
-
-        Parameters
-        ----------
-        outputtype : {'NIFTI', 'NIFTI_GZ', 'AFNI'}
-            String specifying the output type.
-
-        Returns
-        -------
-        extension : str
-            The file extension for the output type.
-
-        """
-        try:
-            return cls.ftypes[outputtype]
-        except KeyError as e:
-            msg = "Invalid AFNIOUTPUTTYPE: ", outputtype
-            raise KeyError(msg) from e
-
-    @classmethod
-    def outputtype(cls):
-        """
-        Set default output filetype.
-
-        AFNI has no environment variables, Output filetypes get set in command line calls
-        Nipype uses ``AFNI`` as default
-
-
-        Returns
-        -------
-        None
-
-        """
-        return "AFNI"
-
-    @staticmethod
-    def standard_image(img_name):
-        """
-        Grab an image from the standard location.
+            ext = Info.output_type_to_ext(outputtype)
+            suffix = ""
+    else:
+        prefix = inputs.out_file
+        ext_ind = max([prefix.lower().rfind(".nii.gz"), prefix.lower().rfind(".nii")])
+        if ext_ind == -1:
+            ext = ".HEAD"
+            suffix = "+tlrc"
+        else:
+            ext = prefix[ext_ind:]
+            suffix = ""
 
-        Could be made more fancy to allow for more relocatability
+    # All outputs should be in the same directory as the prefix
+    out_dir = os.path.dirname(os.path.abspath(prefix))
 
-        """
-        clout = CommandLine(
-            "which afni",
-            ignore_exception=True,
-            resource_monitor=False,
-            terminal_output="allatonce",
-        ).run()
-        if clout.runtime.returncode != 0:
-            return None
+    outputs["warped_source"] = (
+        fname_presuffix(prefix, suffix=suffix, use_ext=False, newpath=out_dir) + ext
+    )
+    if not inputs.nowarp:
+        outputs["source_warp"] = (
+            fname_presuffix(
+                prefix, suffix="_WARP" + suffix, use_ext=False, newpath=out_dir
+            )
+            + ext
+        )
+    if inputs.iwarp:
+        outputs["base_warp"] = (
+            fname_presuffix(
+                prefix, suffix="_WARPINV" + suffix, use_ext=False, newpath=out_dir
+            )
+            + ext
+        )
+    if inputs.out_weight_file is not attrs.NOTHING:
+        outputs["weights"] = os.path.abspath(inputs.out_weight_file)
 
-        out = clout.runtime.stdout
-        basedir = os.path.split(out)[0]
-        return os.path.join(basedir, img_name)
+    if inputs.plusminus:
+        outputs["warped_source"] = (
+            fname_presuffix(
+                prefix, suffix="_PLUS" + suffix, use_ext=False, newpath=out_dir
+            )
+            + ext
+        )
+        outputs["warped_base"] = (
+            fname_presuffix(
+                prefix, suffix="_MINUS" + suffix, use_ext=False, newpath=out_dir
+            )
+            + ext
+        )
+        outputs["source_warp"] = (
+            fname_presuffix(
+                prefix, suffix="_PLUS_WARP" + suffix, use_ext=False, newpath=out_dir
+            )
+            + ext
+        )
+        outputs["base_warp"] = (
+            fname_presuffix(
+                prefix,
+                suffix="_MINUS_WARP" + suffix,
+                use_ext=False,
+                newpath=out_dir,
+            )
+            + ext
+        )
+    return outputs
 
 
 # Original source at L108 of <nipype-install>/utils/filemanip.py
@@ -313,98 +288,123 @@ def split_filename(fname):
     return pth, fname, ext
 
 
-# Original source at L4449 of <nipype-install>/interfaces/afni/preprocess.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "out_file":
-        return _gen_fname(
-            inputs.in_file,
-            suffix="_QW",
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
 
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
 
-# Original source at L4372 of <nipype-install>/interfaces/afni/preprocess.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
 
-    if inputs.out_file is attrs.NOTHING:
-        prefix = _gen_fname(
-            inputs.in_file,
-            suffix="_QW",
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-        outputtype = inputs.outputtype
-        if outputtype == "AFNI":
-            ext = ".HEAD"
-            suffix = "+tlrc"
-        else:
-            ext = Info.output_type_to_ext(outputtype)
-            suffix = ""
-    else:
-        prefix = inputs.out_file
-        ext_ind = max([prefix.lower().rfind(".nii.gz"), prefix.lower().rfind(".nii")])
-        if ext_ind == -1:
-            ext = ".HEAD"
-            suffix = "+tlrc"
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
+# Original source at L26 of <nipype-install>/interfaces/afni/base.py
+class Info(PackageInfo):
+    """Handle afni output type and version information."""
+
+    __outputtype = "AFNI"
+    ftypes = {"NIFTI": ".nii", "AFNI": "", "NIFTI_GZ": ".nii.gz"}
+    version_cmd = "afni --version"
+
+    @staticmethod
+    def parse_version(raw_info):
+        """Check and parse AFNI's version."""
+        version_stamp = raw_info.split("\n")[0].split("Version ")[1]
+        if version_stamp.startswith("AFNI"):
+            version_stamp = version_stamp.split("AFNI_")[1]
+        elif version_stamp.startswith("Debian"):
+            version_stamp = version_stamp.split("Debian-")[1].split("~")[0]
         else:
-            ext = prefix[ext_ind:]
-            suffix = ""
+            return None
 
-    # All outputs should be in the same directory as the prefix
-    out_dir = os.path.dirname(os.path.abspath(prefix))
+        version = LooseVersion(version_stamp.replace("_", ".")).version[:3]
+        if version[0] < 1000:
+            version[0] = version[0] + 2000
+        return tuple(version)
 
-    outputs["warped_source"] = (
-        fname_presuffix(prefix, suffix=suffix, use_ext=False, newpath=out_dir) + ext
-    )
-    if not inputs.nowarp:
-        outputs["source_warp"] = (
-            fname_presuffix(
-                prefix, suffix="_WARP" + suffix, use_ext=False, newpath=out_dir
-            )
-            + ext
-        )
-    if inputs.iwarp:
-        outputs["base_warp"] = (
-            fname_presuffix(
-                prefix, suffix="_WARPINV" + suffix, use_ext=False, newpath=out_dir
-            )
-            + ext
-        )
-    if inputs.out_weight_file is not attrs.NOTHING:
-        outputs["weights"] = os.path.abspath(inputs.out_weight_file)
+    @classmethod
+    def output_type_to_ext(cls, outputtype):
+        """
+        Get the file extension for the given output type.
 
-    if inputs.plusminus:
-        outputs["warped_source"] = (
-            fname_presuffix(
-                prefix, suffix="_PLUS" + suffix, use_ext=False, newpath=out_dir
-            )
-            + ext
-        )
-        outputs["warped_base"] = (
-            fname_presuffix(
-                prefix, suffix="_MINUS" + suffix, use_ext=False, newpath=out_dir
-            )
-            + ext
-        )
-        outputs["source_warp"] = (
-            fname_presuffix(
-                prefix, suffix="_PLUS_WARP" + suffix, use_ext=False, newpath=out_dir
-            )
-            + ext
-        )
-        outputs["base_warp"] = (
-            fname_presuffix(
-                prefix,
-                suffix="_MINUS_WARP" + suffix,
-                use_ext=False,
-                newpath=out_dir,
-            )
-            + ext
-        )
-    return outputs
+        Parameters
+        ----------
+        outputtype : {'NIFTI', 'NIFTI_GZ', 'AFNI'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+
+        """
+        try:
+            return cls.ftypes[outputtype]
+        except KeyError as e:
+            msg = "Invalid AFNIOUTPUTTYPE: ", outputtype
+            raise KeyError(msg) from e
+
+    @classmethod
+    def outputtype(cls):
+        """
+        Set default output filetype.
+
+        AFNI has no environment variables, Output filetypes get set in command line calls
+        Nipype uses ``AFNI`` as default
+
+
+        Returns
+        -------
+        None
+
+        """
+        return "AFNI"
+
+    @staticmethod
+    def standard_image(img_name):
+        """
+        Grab an image from the standard location.
+
+        Could be made more fancy to allow for more relocatability
+
+        """
+        clout = CommandLine(
+            "which afni",
+            ignore_exception=True,
+            resource_monitor=False,
+            terminal_output="allatonce",
+        ).run()
+        if clout.runtime.returncode != 0:
+            return None
+
+        out = clout.runtime.stdout
+        basedir = os.path.split(out)[0]
+        return os.path.join(basedir, img_name)
diff --git a/example-specs/task/nipype/afni/re_ho_callables.py b/example-specs/task/nipype/afni/re_ho_callables.py
index e8777d55..e07d7284 100644
--- a/example-specs/task/nipype/afni/re_ho_callables.py
+++ b/example-specs/task/nipype/afni/re_ho_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of ReHo.yaml"""
 
+import attrs
 import logging
 import os
 import os.path as op
-import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -23,75 +23,6 @@ def out_vals_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
-# Original source at L58 of <nipype-install>/utils/filemanip.py
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
-# Original source at L888 of <nipype-install>/interfaces/base/core.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    return value
-
-
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
@@ -187,6 +118,26 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+# Original source at L2583 of <nipype-install>/interfaces/afni/utils.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    if inputs.label_set:
+        outputs["out_vals"] = outputs["out_file"] + "_ROI_reho.vals"
+    return outputs
+
+
+# Original source at L888 of <nipype-install>/interfaces/base/core.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value
+
+
 # Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
@@ -207,14 +158,63 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
+# Original source at L58 of <nipype-install>/utils/filemanip.py
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
 
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
 
-# Original source at L2583 of <nipype-install>/interfaces/afni/utils.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    if inputs.label_set:
-        outputs["out_vals"] = outputs["out_file"] + "_ROI_reho.vals"
-    return outputs
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
diff --git a/example-specs/task/nipype/afni/refit_callables.py b/example-specs/task/nipype/afni/refit_callables.py
index 1d36898e..2489c36e 100644
--- a/example-specs/task/nipype/afni/refit_callables.py
+++ b/example-specs/task/nipype/afni/refit_callables.py
@@ -1,7 +1,6 @@
 """Module to put any functions that are referred to in the "callables" section of Refit.yaml"""
 
 import os
-import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/afni/remlfit_callables.py b/example-specs/task/nipype/afni/remlfit_callables.py
index 08925cd9..96360039 100644
--- a/example-specs/task/nipype/afni/remlfit_callables.py
+++ b/example-specs/task/nipype/afni/remlfit_callables.py
@@ -1,98 +1,98 @@
 """Module to put any functions that are referred to in the "callables" section of Remlfit.yaml"""
 
-import os
 import attrs
+import os
 
 
-def out_file_callable(output_dir, inputs, stdout, stderr):
+def errts_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_file"]
+    return outputs["errts_file"]
 
 
-def var_file_callable(output_dir, inputs, stdout, stderr):
+def fitts_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["var_file"]
+    return outputs["fitts_file"]
 
 
-def rbeta_file_callable(output_dir, inputs, stdout, stderr):
+def glt_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["rbeta_file"]
+    return outputs["glt_file"]
 
 
-def glt_file_callable(output_dir, inputs, stdout, stderr):
+def obeta_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["glt_file"]
+    return outputs["obeta"]
 
 
-def fitts_file_callable(output_dir, inputs, stdout, stderr):
+def obuck_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["fitts_file"]
+    return outputs["obuck"]
 
 
-def errts_file_callable(output_dir, inputs, stdout, stderr):
+def oerrts_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["errts_file"]
+    return outputs["oerrts"]
 
 
-def wherr_file_callable(output_dir, inputs, stdout, stderr):
+def ofitts_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["wherr_file"]
+    return outputs["ofitts"]
 
 
-def ovar_callable(output_dir, inputs, stdout, stderr):
+def oglt_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["ovar"]
+    return outputs["oglt"]
 
 
-def obeta_callable(output_dir, inputs, stdout, stderr):
+def out_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["obeta"]
+    return outputs["out_file"]
 
 
-def obuck_callable(output_dir, inputs, stdout, stderr):
+def ovar_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["obuck"]
+    return outputs["ovar"]
 
 
-def oglt_callable(output_dir, inputs, stdout, stderr):
+def rbeta_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["oglt"]
+    return outputs["rbeta_file"]
 
 
-def ofitts_callable(output_dir, inputs, stdout, stderr):
+def var_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["ofitts"]
+    return outputs["var_file"]
 
 
-def oerrts_callable(output_dir, inputs, stdout, stderr):
+def wherr_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["oerrts"]
+    return outputs["wherr_file"]
 
 
 # Original source at L885 of <nipype-install>/interfaces/base/core.py
diff --git a/example-specs/task/nipype/afni/resample_callables.py b/example-specs/task/nipype/afni/resample_callables.py
index 9dfccc6d..577844b3 100644
--- a/example-specs/task/nipype/afni/resample_callables.py
+++ b/example-specs/task/nipype/afni/resample_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Resample.yaml"""
 
-from looseversion import LooseVersion
 import attrs
 import logging
 import os
 import os.path as op
+from looseversion import LooseVersion
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,17 +17,6 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
@@ -123,6 +112,33 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
 # Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
@@ -143,47 +159,20 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
-
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
-
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
-
-            klass._version = klass.parse_version(raw_info)
-
-        return klass._version
-
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
 
 
 # Original source at L58 of <nipype-install>/utils/filemanip.py
@@ -237,6 +226,55 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
@@ -319,41 +357,3 @@ def standard_image(img_name):
         out = clout.runtime.stdout
         basedir = os.path.split(out)[0]
         return os.path.join(basedir, img_name)
-
-
-# Original source at L242 of <nipype-install>/interfaces/afni/base.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    path, base, _ = split_filename(value)
-    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def nipype_interfaces_afni__AFNICommand___list_outputs(
-    inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
diff --git a/example-specs/task/nipype/afni/retroicor_callables.py b/example-specs/task/nipype/afni/retroicor_callables.py
index e0d2fbd2..9f1653ab 100644
--- a/example-specs/task/nipype/afni/retroicor_callables.py
+++ b/example-specs/task/nipype/afni/retroicor_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Retroicor.yaml"""
 
-from looseversion import LooseVersion
 import attrs
 import logging
 import os
 import os.path as op
+from looseversion import LooseVersion
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,17 +17,6 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
@@ -123,6 +112,33 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
 # Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
@@ -143,47 +159,20 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
-
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
-
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
-
-            klass._version = klass.parse_version(raw_info)
-
-        return klass._version
-
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
 
 
 # Original source at L58 of <nipype-install>/utils/filemanip.py
@@ -237,6 +226,55 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
@@ -319,41 +357,3 @@ def standard_image(img_name):
         out = clout.runtime.stdout
         basedir = os.path.split(out)[0]
         return os.path.join(basedir, img_name)
-
-
-# Original source at L242 of <nipype-install>/interfaces/afni/base.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    path, base, _ = split_filename(value)
-    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def nipype_interfaces_afni__AFNICommand___list_outputs(
-    inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
diff --git a/example-specs/task/nipype/afni/roi_stats_callables.py b/example-specs/task/nipype/afni/roi_stats_callables.py
index 263d67ff..f590ee36 100644
--- a/example-specs/task/nipype/afni/roi_stats_callables.py
+++ b/example-specs/task/nipype/afni/roi_stats_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of ROIStats.yaml"""
 
+import attrs
 import logging
 import os
 import os.path as op
-import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -16,75 +16,6 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
-# Original source at L58 of <nipype-install>/utils/filemanip.py
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
-# Original source at L888 of <nipype-install>/interfaces/base/core.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    return value
-
-
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
@@ -201,3 +132,72 @@ def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
             if fname is not attrs.NOTHING:
                 outputs[out_name] = os.path.abspath(fname)
         return outputs
+
+
+# Original source at L888 of <nipype-install>/interfaces/base/core.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value
+
+
+# Original source at L58 of <nipype-install>/utils/filemanip.py
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
diff --git a/example-specs/task/nipype/afni/seg_callables.py b/example-specs/task/nipype/afni/seg_callables.py
index 4c1a0ae0..3f4a63f6 100644
--- a/example-specs/task/nipype/afni/seg_callables.py
+++ b/example-specs/task/nipype/afni/seg_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of Seg.yaml"""
 
+import attrs
 import logging
 import os
 import os.path as op
-import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -16,75 +16,6 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
-# Original source at L58 of <nipype-install>/utils/filemanip.py
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
-# Original source at L888 of <nipype-install>/interfaces/base/core.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    return value
-
-
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
@@ -201,3 +132,72 @@ def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
             if fname is not attrs.NOTHING:
                 outputs[out_name] = os.path.abspath(fname)
         return outputs
+
+
+# Original source at L888 of <nipype-install>/interfaces/base/core.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value
+
+
+# Original source at L58 of <nipype-install>/utils/filemanip.py
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
diff --git a/example-specs/task/nipype/afni/skull_strip_callables.py b/example-specs/task/nipype/afni/skull_strip_callables.py
index 5798aa6b..e62d73d0 100644
--- a/example-specs/task/nipype/afni/skull_strip_callables.py
+++ b/example-specs/task/nipype/afni/skull_strip_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of SkullStrip.yaml"""
 
-from looseversion import LooseVersion
 import attrs
 import logging
 import os
 import os.path as op
+from looseversion import LooseVersion
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,17 +17,6 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
@@ -123,6 +112,33 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
 # Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
@@ -143,47 +159,20 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
-
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
-
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
-
-            klass._version = klass.parse_version(raw_info)
-
-        return klass._version
-
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
 
 
 # Original source at L58 of <nipype-install>/utils/filemanip.py
@@ -237,6 +226,55 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
@@ -319,41 +357,3 @@ def standard_image(img_name):
         out = clout.runtime.stdout
         basedir = os.path.split(out)[0]
         return os.path.join(basedir, img_name)
-
-
-# Original source at L242 of <nipype-install>/interfaces/afni/base.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    path, base, _ = split_filename(value)
-    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def nipype_interfaces_afni__AFNICommand___list_outputs(
-    inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
diff --git a/example-specs/task/nipype/afni/svm_test_callables.py b/example-specs/task/nipype/afni/svm_test_callables.py
index d3bfcd02..af987c97 100644
--- a/example-specs/task/nipype/afni/svm_test_callables.py
+++ b/example-specs/task/nipype/afni/svm_test_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of SVMTest.yaml"""
 
-from looseversion import LooseVersion
 import attrs
 import logging
 import os
 import os.path as op
+from looseversion import LooseVersion
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,17 +17,6 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
@@ -123,6 +112,33 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
 # Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
@@ -143,47 +159,20 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
-
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
-
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
-
-            klass._version = klass.parse_version(raw_info)
-
-        return klass._version
-
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
 
 
 # Original source at L58 of <nipype-install>/utils/filemanip.py
@@ -237,6 +226,55 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
@@ -319,41 +357,3 @@ def standard_image(img_name):
         out = clout.runtime.stdout
         basedir = os.path.split(out)[0]
         return os.path.join(basedir, img_name)
-
-
-# Original source at L242 of <nipype-install>/interfaces/afni/base.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    path, base, _ = split_filename(value)
-    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def nipype_interfaces_afni__AFNICommand___list_outputs(
-    inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
diff --git a/example-specs/task/nipype/afni/svm_train_callables.py b/example-specs/task/nipype/afni/svm_train_callables.py
index aa2edc24..9ff33a77 100644
--- a/example-specs/task/nipype/afni/svm_train_callables.py
+++ b/example-specs/task/nipype/afni/svm_train_callables.py
@@ -1,17 +1,17 @@
 """Module to put any functions that are referred to in the "callables" section of SVMTrain.yaml"""
 
-from looseversion import LooseVersion
 import attrs
 import logging
 import os
 import os.path as op
+from looseversion import LooseVersion
 
 
-def out_file_callable(output_dir, inputs, stdout, stderr):
+def alphas_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_file"]
+    return outputs["alphas"]
 
 
 def model_callable(output_dir, inputs, stdout, stderr):
@@ -21,27 +21,16 @@ def model_callable(output_dir, inputs, stdout, stderr):
     return outputs["model"]
 
 
-def alphas_callable(output_dir, inputs, stdout, stderr):
+def out_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["alphas"]
+    return outputs["out_file"]
 
 
 iflogger = logging.getLogger("nipype.interface")
 
 
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
@@ -137,6 +126,33 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
 # Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
@@ -157,47 +173,20 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
-
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
-
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
-
-            klass._version = klass.parse_version(raw_info)
-
-        return klass._version
-
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
 
 
 # Original source at L58 of <nipype-install>/utils/filemanip.py
@@ -251,6 +240,55 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
@@ -333,41 +371,3 @@ def standard_image(img_name):
         out = clout.runtime.stdout
         basedir = os.path.split(out)[0]
         return os.path.join(basedir, img_name)
-
-
-# Original source at L242 of <nipype-install>/interfaces/afni/base.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    path, base, _ = split_filename(value)
-    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def nipype_interfaces_afni__AFNICommand___list_outputs(
-    inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
diff --git a/example-specs/task/nipype/afni/synthesize_callables.py b/example-specs/task/nipype/afni/synthesize_callables.py
index faf2cd00..156c9d52 100644
--- a/example-specs/task/nipype/afni/synthesize_callables.py
+++ b/example-specs/task/nipype/afni/synthesize_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of Synthesize.yaml"""
 
-import os
 import attrs
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/afni/t_cat_callables.py b/example-specs/task/nipype/afni/t_cat_callables.py
index c799d9e0..2972599e 100644
--- a/example-specs/task/nipype/afni/t_cat_callables.py
+++ b/example-specs/task/nipype/afni/t_cat_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of TCat.yaml"""
 
-from looseversion import LooseVersion
 import attrs
 import logging
 import os
 import os.path as op
+from looseversion import LooseVersion
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,17 +17,6 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
@@ -123,6 +112,33 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
 # Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
@@ -143,47 +159,20 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
-
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
-
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
-
-            klass._version = klass.parse_version(raw_info)
-
-        return klass._version
-
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
 
 
 # Original source at L58 of <nipype-install>/utils/filemanip.py
@@ -237,6 +226,55 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
@@ -319,41 +357,3 @@ def standard_image(img_name):
         out = clout.runtime.stdout
         basedir = os.path.split(out)[0]
         return os.path.join(basedir, img_name)
-
-
-# Original source at L242 of <nipype-install>/interfaces/afni/base.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    path, base, _ = split_filename(value)
-    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def nipype_interfaces_afni__AFNICommand___list_outputs(
-    inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
diff --git a/example-specs/task/nipype/afni/t_cat_sub_brick_callables.py b/example-specs/task/nipype/afni/t_cat_sub_brick_callables.py
index a58c00cf..cbf79afe 100644
--- a/example-specs/task/nipype/afni/t_cat_sub_brick_callables.py
+++ b/example-specs/task/nipype/afni/t_cat_sub_brick_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of TCatSubBrick.yaml"""
 
-from looseversion import LooseVersion
 import attrs
+import logging
 import os
 import os.path as op
-import logging
+from looseversion import LooseVersion
 from pathlib import Path
 
 
@@ -22,17 +22,6 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
@@ -128,6 +117,139 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L2763 of <nipype-install>/interfaces/afni/utils.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _gen_fname(
+            inputs.in_files[0][0],
+            suffix="_tcat",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+
+
+# Original source at L260 of <nipype-install>/interfaces/afni/base.py
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """
+    Generate a filename based on the given parameters.
+
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
+
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
+
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+    if not basename:
+        msg = "Unable to generate filename for command %s. " % "3dTcat"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.outputtype)
+    if change_ext:
+        suffix = "".join((suffix, ext)) if suffix else ext
+
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
+# Original source at L108 of <nipype-install>/utils/filemanip.py
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
 # Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
@@ -148,55 +270,20 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
-# Original source at L2763 of <nipype-install>/interfaces/afni/utils.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "out_file":
-        return _gen_fname(
-            inputs.in_files[0][0],
-            suffix="_tcat",
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-
-
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
-
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
-
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
-
-            klass._version = klass.parse_version(raw_info)
-
-        return klass._version
-
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
 
 
 # Original source at L58 of <nipype-install>/utils/filemanip.py
@@ -250,47 +337,53 @@ def split_filename(fname):
     return pth, fname, ext
 
 
-# Original source at L108 of <nipype-install>/utils/filemanip.py
-def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
-    """Manipulates path and name of input filename
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
 
-    Parameters
-    ----------
-    fname : string
-        A filename (may or may not include path)
-    prefix : string
-        Characters to prepend to the filename
-    suffix : string
-        Characters to append to the filename
-    newpath : string
-        Path to replace the path of the input fname
-    use_ext : boolean
-        If True (default), appends the extension of the original file
-        to the output name.
+    def __init__(self, value):
+        self.value = value
 
-    Returns
-    -------
-    Absolute path of the modified filename
+    def __str__(self):
+        return "{}".format(self.value)
 
-    >>> from nipype.utils.filemanip import fname_presuffix
-    >>> fname = 'foo.nii.gz'
-    >>> fname_presuffix(fname,'pre','post','/tmp')
-    '/tmp/prefoopost.nii.gz'
 
-    >>> from nipype.interfaces.base import attrs.NOTHING
-    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
-            fname_presuffix(fname, 'pre', 'post')
-    True
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
 
-    """
-    pth, fname, ext = split_filename(fname)
-    if not use_ext:
-        ext = ""
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
 
-    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
-    if newpath:
-        pth = op.abspath(newpath)
-    return op.join(pth, prefix + fname + suffix + ext)
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
 
 
 # Original source at L26 of <nipype-install>/interfaces/afni/base.py
@@ -375,96 +468,3 @@ def standard_image(img_name):
         out = clout.runtime.stdout
         basedir = os.path.split(out)[0]
         return os.path.join(basedir, img_name)
-
-
-# Original source at L260 of <nipype-install>/interfaces/afni/base.py
-def _gen_fname(
-    basename,
-    cwd=None,
-    suffix=None,
-    change_ext=True,
-    ext=None,
-    inputs=None,
-    stdout=None,
-    stderr=None,
-    output_dir=None,
-):
-    """
-    Generate a filename based on the given parameters.
-
-    The filename will take the form: cwd/basename<suffix><ext>.
-    If change_ext is True, it will use the extensions specified in
-    <instance>inputs.output_type.
-
-    Parameters
-    ----------
-    basename : str
-        Filename to base the new filename on.
-    cwd : str
-        Path to prefix to the new filename. (default is output_dir)
-    suffix : str
-        Suffix to add to the `basename`.  (defaults is '' )
-    change_ext : bool
-        Flag to change the filename extension to the FSL output type.
-        (default True)
-
-    Returns
-    -------
-    fname : str
-        New filename based on given parameters.
-
-    """
-    if not basename:
-        msg = "Unable to generate filename for command %s. " % "3dTcat"
-        msg += "basename is not set!"
-        raise ValueError(msg)
-
-    if cwd is None:
-        cwd = output_dir
-    if ext is None:
-        ext = Info.output_type_to_ext(inputs.outputtype)
-    if change_ext:
-        suffix = "".join((suffix, ext)) if suffix else ext
-
-    if suffix is None:
-        suffix = ""
-    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
-    return fname
-
-
-# Original source at L242 of <nipype-install>/interfaces/afni/base.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    path, base, _ = split_filename(value)
-    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def nipype_interfaces_afni__AFNICommand___list_outputs(
-    inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
diff --git a/example-specs/task/nipype/afni/t_corr_1d_callables.py b/example-specs/task/nipype/afni/t_corr_1d_callables.py
index ed32f60f..810d154f 100644
--- a/example-specs/task/nipype/afni/t_corr_1d_callables.py
+++ b/example-specs/task/nipype/afni/t_corr_1d_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of TCorr1D.yaml"""
 
-from looseversion import LooseVersion
 import attrs
 import logging
 import os
 import os.path as op
+from looseversion import LooseVersion
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,17 +17,6 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
@@ -123,6 +112,33 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
 # Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
@@ -143,47 +159,20 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
-
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
-
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
-
-            klass._version = klass.parse_version(raw_info)
-
-        return klass._version
-
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
 
 
 # Original source at L58 of <nipype-install>/utils/filemanip.py
@@ -237,6 +226,55 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
@@ -319,41 +357,3 @@ def standard_image(img_name):
         out = clout.runtime.stdout
         basedir = os.path.split(out)[0]
         return os.path.join(basedir, img_name)
-
-
-# Original source at L242 of <nipype-install>/interfaces/afni/base.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    path, base, _ = split_filename(value)
-    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def nipype_interfaces_afni__AFNICommand___list_outputs(
-    inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
diff --git a/example-specs/task/nipype/afni/t_corr_map.yaml b/example-specs/task/nipype/afni/t_corr_map.yaml
index 968baa72..9f0b1508 100644
--- a/example-specs/task/nipype/afni/t_corr_map.yaml
+++ b/example-specs/task/nipype/afni/t_corr_map.yaml
@@ -164,7 +164,7 @@ tests:
     polort:
     # type=int|default=0: 
     bandpass:
-    # type=tuple|default=(<traits.trait_types.Float object at 0x1078fa310>, <traits.trait_types.Float object at 0x107909610>): 
+    # type=tuple|default=(<traits.trait_types.Float object at 0x107a24890>, <traits.trait_types.Float object at 0x107a24850>): 
     regress_out_timeseries:
     # type=file|default=<undefined>: 
     blur_fwhm:
diff --git a/example-specs/task/nipype/afni/t_corr_map_callables.py b/example-specs/task/nipype/afni/t_corr_map_callables.py
index c08934cc..26c0e11f 100644
--- a/example-specs/task/nipype/afni/t_corr_map_callables.py
+++ b/example-specs/task/nipype/afni/t_corr_map_callables.py
@@ -1,117 +1,106 @@
 """Module to put any functions that are referred to in the "callables" section of TCorrMap.yaml"""
 
-from looseversion import LooseVersion
 import attrs
 import logging
 import os
 import os.path as op
+from looseversion import LooseVersion
 
 
-def mean_file_callable(output_dir, inputs, stdout, stderr):
+def absolute_threshold_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["mean_file"]
+    return outputs["absolute_threshold"]
 
 
-def zmean_callable(output_dir, inputs, stdout, stderr):
+def average_expr_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["zmean"]
+    return outputs["average_expr"]
 
 
-def qmean_callable(output_dir, inputs, stdout, stderr):
+def average_expr_nonzero_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["qmean"]
+    return outputs["average_expr_nonzero"]
 
 
-def pmean_callable(output_dir, inputs, stdout, stderr):
+def correlation_maps_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["pmean"]
+    return outputs["correlation_maps"]
 
 
-def absolute_threshold_callable(output_dir, inputs, stdout, stderr):
+def correlation_maps_masked_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["absolute_threshold"]
+    return outputs["correlation_maps_masked"]
 
 
-def var_absolute_threshold_callable(output_dir, inputs, stdout, stderr):
+def histogram_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["var_absolute_threshold"]
+    return outputs["histogram"]
 
 
-def var_absolute_threshold_normalize_callable(output_dir, inputs, stdout, stderr):
+def mean_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["var_absolute_threshold_normalize"]
+    return outputs["mean_file"]
 
 
-def correlation_maps_callable(output_dir, inputs, stdout, stderr):
+def pmean_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["correlation_maps"]
+    return outputs["pmean"]
 
 
-def correlation_maps_masked_callable(output_dir, inputs, stdout, stderr):
+def qmean_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["correlation_maps_masked"]
+    return outputs["qmean"]
 
 
-def average_expr_callable(output_dir, inputs, stdout, stderr):
+def sum_expr_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["average_expr"]
+    return outputs["sum_expr"]
 
 
-def average_expr_nonzero_callable(output_dir, inputs, stdout, stderr):
+def var_absolute_threshold_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["average_expr_nonzero"]
+    return outputs["var_absolute_threshold"]
 
 
-def sum_expr_callable(output_dir, inputs, stdout, stderr):
+def var_absolute_threshold_normalize_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["sum_expr"]
+    return outputs["var_absolute_threshold_normalize"]
 
 
-def histogram_callable(output_dir, inputs, stdout, stderr):
+def zmean_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["histogram"]
+    return outputs["zmean"]
 
 
 iflogger = logging.getLogger("nipype.interface")
 
 
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
@@ -207,6 +196,33 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
 # Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
@@ -227,47 +243,20 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
-
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
-
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
-
-            klass._version = klass.parse_version(raw_info)
-
-        return klass._version
-
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
 
 
 # Original source at L58 of <nipype-install>/utils/filemanip.py
@@ -321,6 +310,55 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
@@ -403,41 +441,3 @@ def standard_image(img_name):
         out = clout.runtime.stdout
         basedir = os.path.split(out)[0]
         return os.path.join(basedir, img_name)
-
-
-# Original source at L242 of <nipype-install>/interfaces/afni/base.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    path, base, _ = split_filename(value)
-    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def nipype_interfaces_afni__AFNICommand___list_outputs(
-    inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
diff --git a/example-specs/task/nipype/afni/t_correlate_callables.py b/example-specs/task/nipype/afni/t_correlate_callables.py
index 8f603d0a..49d62648 100644
--- a/example-specs/task/nipype/afni/t_correlate_callables.py
+++ b/example-specs/task/nipype/afni/t_correlate_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of TCorrelate.yaml"""
 
-from looseversion import LooseVersion
 import attrs
 import logging
 import os
 import os.path as op
+from looseversion import LooseVersion
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,17 +17,6 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
@@ -123,6 +112,33 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
 # Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
@@ -143,47 +159,20 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
-
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
-
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
-
-            klass._version = klass.parse_version(raw_info)
-
-        return klass._version
-
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
 
 
 # Original source at L58 of <nipype-install>/utils/filemanip.py
@@ -237,6 +226,55 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
@@ -319,41 +357,3 @@ def standard_image(img_name):
         out = clout.runtime.stdout
         basedir = os.path.split(out)[0]
         return os.path.join(basedir, img_name)
-
-
-# Original source at L242 of <nipype-install>/interfaces/afni/base.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    path, base, _ = split_filename(value)
-    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def nipype_interfaces_afni__AFNICommand___list_outputs(
-    inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
diff --git a/example-specs/task/nipype/afni/t_norm_callables.py b/example-specs/task/nipype/afni/t_norm_callables.py
index 13cf6c59..dcea4403 100644
--- a/example-specs/task/nipype/afni/t_norm_callables.py
+++ b/example-specs/task/nipype/afni/t_norm_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of TNorm.yaml"""
 
-from looseversion import LooseVersion
 import attrs
 import logging
 import os
 import os.path as op
+from looseversion import LooseVersion
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,17 +17,6 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
@@ -123,6 +112,33 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
 # Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
@@ -143,47 +159,20 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
-
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
-
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
-
-            klass._version = klass.parse_version(raw_info)
-
-        return klass._version
-
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
 
 
 # Original source at L58 of <nipype-install>/utils/filemanip.py
@@ -237,6 +226,55 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
@@ -319,41 +357,3 @@ def standard_image(img_name):
         out = clout.runtime.stdout
         basedir = os.path.split(out)[0]
         return os.path.join(basedir, img_name)
-
-
-# Original source at L242 of <nipype-install>/interfaces/afni/base.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    path, base, _ = split_filename(value)
-    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def nipype_interfaces_afni__AFNICommand___list_outputs(
-    inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
diff --git a/example-specs/task/nipype/afni/t_project_callables.py b/example-specs/task/nipype/afni/t_project_callables.py
index ac8d2895..c9f1e9ce 100644
--- a/example-specs/task/nipype/afni/t_project_callables.py
+++ b/example-specs/task/nipype/afni/t_project_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of TProject.yaml"""
 
-from looseversion import LooseVersion
 import attrs
 import logging
 import os
 import os.path as op
+from looseversion import LooseVersion
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,17 +17,6 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
@@ -123,6 +112,33 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
 # Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
@@ -143,47 +159,20 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
-
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
-
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
-
-            klass._version = klass.parse_version(raw_info)
-
-        return klass._version
-
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
 
 
 # Original source at L58 of <nipype-install>/utils/filemanip.py
@@ -237,6 +226,55 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
@@ -319,41 +357,3 @@ def standard_image(img_name):
         out = clout.runtime.stdout
         basedir = os.path.split(out)[0]
         return os.path.join(basedir, img_name)
-
-
-# Original source at L242 of <nipype-install>/interfaces/afni/base.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    path, base, _ = split_filename(value)
-    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def nipype_interfaces_afni__AFNICommand___list_outputs(
-    inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
diff --git a/example-specs/task/nipype/afni/t_shift_callables.py b/example-specs/task/nipype/afni/t_shift_callables.py
index b2d092b1..ec130782 100644
--- a/example-specs/task/nipype/afni/t_shift_callables.py
+++ b/example-specs/task/nipype/afni/t_shift_callables.py
@@ -1,29 +1,235 @@
 """Module to put any functions that are referred to in the "callables" section of TShift.yaml"""
 
-from looseversion import LooseVersion
 import attrs
 import logging
 import os
 import os.path as op
+from looseversion import LooseVersion
 
 
-def timing_file_callable(output_dir, inputs, stdout, stderr):
+def out_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["timing_file"]
+    return outputs["out_file"]
 
 
-def out_file_callable(output_dir, inputs, stdout, stderr):
+def timing_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_file"]
+    return outputs["timing_file"]
 
 
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+# Original source at L3302 of <nipype-install>/interfaces/afni/preprocess.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    if inputs.slice_timing is not attrs.NOTHING:
+        if isinstance(inputs.slice_timing, list):
+            outputs["timing_file"] = os.path.abspath("slice_timing.1D")
+        else:
+            outputs["timing_file"] = os.path.abspath(inputs.slice_timing)
+    return outputs
+
+
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
+def nipype_interfaces_afni__AFNICommandBase___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+# Original source at L58 of <nipype-install>/utils/filemanip.py
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
 # Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
@@ -146,30 +352,6 @@ def standard_image(img_name):
         return os.path.join(basedir, img_name)
 
 
-# Original source at L242 of <nipype-install>/interfaces/afni/base.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    path, base, _ = split_filename(value)
-    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def nipype_interfaces_afni__AFNICommand___list_outputs(
-    inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
-
-
 # Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
@@ -179,185 +361,3 @@ def __init__(self, value):
 
     def __str__(self):
         return "{}".format(self.value)
-
-
-# Original source at L58 of <nipype-install>/utils/filemanip.py
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
-# Original source at L809 of <nipype-install>/interfaces/base/core.py
-def _filename_from_source(
-    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    if chain is None:
-        chain = []
-
-    trait_spec = inputs.trait(name)
-    retval = getattr(inputs, name)
-    source_ext = None
-    if (retval is attrs.NOTHING) or "%s" in retval:
-        if not trait_spec.name_source:
-            return retval
-
-        # Do not generate filename when excluded by other inputs
-        if any(
-            (getattr(inputs, field) is not attrs.NOTHING)
-            for field in trait_spec.xor or ()
-        ):
-            return retval
-
-        # Do not generate filename when required fields are missing
-        if not all(
-            (getattr(inputs, field) is not attrs.NOTHING)
-            for field in trait_spec.requires or ()
-        ):
-            return retval
-
-        if (retval is not attrs.NOTHING) and "%s" in retval:
-            name_template = retval
-        else:
-            name_template = trait_spec.name_template
-        if not name_template:
-            name_template = "%s_generated"
-
-        ns = trait_spec.name_source
-        while isinstance(ns, (list, tuple)):
-            if len(ns) > 1:
-                iflogger.warning("Only one name_source per trait is allowed")
-            ns = ns[0]
-
-        if not isinstance(ns, (str, bytes)):
-            raise ValueError(
-                "name_source of '{}' trait should be an input trait "
-                "name, but a type {} object was found".format(name, type(ns))
-            )
-
-        if getattr(inputs, ns) is not attrs.NOTHING:
-            name_source = ns
-            source = getattr(inputs, name_source)
-            while isinstance(source, list):
-                source = source[0]
-
-            # special treatment for files
-            try:
-                _, base, source_ext = split_filename(source)
-            except (AttributeError, TypeError):
-                base = source
-        else:
-            if name in chain:
-                raise NipypeInterfaceError("Mutually pointing name_sources")
-
-            chain.append(name)
-            base = _filename_from_source(
-                ns,
-                chain,
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-            if base is not attrs.NOTHING:
-                _, _, source_ext = split_filename(base)
-            else:
-                # Do not generate filename when required fields are missing
-                return retval
-
-        chain = None
-        retval = name_template % base
-        _, _, ext = split_filename(retval)
-        if trait_spec.keep_extension and (ext or source_ext):
-            if (ext is None or not ext) and source_ext:
-                retval = retval + source_ext
-        else:
-            retval = _overload_extension(
-                retval,
-                name,
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-    return retval
-
-
-# Original source at L891 of <nipype-install>/interfaces/base/core.py
-def nipype_interfaces_afni__AFNICommandBase___list_outputs(
-    inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    metadata = dict(name_source=lambda t: t is not None)
-    traits = inputs.traits(**metadata)
-    if traits:
-        outputs = {}
-        for name, trait_spec in list(traits.items()):
-            out_name = name
-            if trait_spec.output_name is not None:
-                out_name = trait_spec.output_name
-            fname = _filename_from_source(
-                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-            )
-            if fname is not attrs.NOTHING:
-                outputs[out_name] = os.path.abspath(fname)
-        return outputs
-
-
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
-# Original source at L3302 of <nipype-install>/interfaces/afni/preprocess.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    if inputs.slice_timing is not attrs.NOTHING:
-        if isinstance(inputs.slice_timing, list):
-            outputs["timing_file"] = os.path.abspath("slice_timing.1D")
-        else:
-            outputs["timing_file"] = os.path.abspath(inputs.slice_timing)
-    return outputs
diff --git a/example-specs/task/nipype/afni/t_smooth_callables.py b/example-specs/task/nipype/afni/t_smooth_callables.py
index 579240e2..df564903 100644
--- a/example-specs/task/nipype/afni/t_smooth_callables.py
+++ b/example-specs/task/nipype/afni/t_smooth_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of TSmooth.yaml"""
 
-from looseversion import LooseVersion
 import attrs
 import logging
 import os
 import os.path as op
+from looseversion import LooseVersion
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,17 +17,6 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
@@ -123,6 +112,33 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
 # Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
@@ -143,47 +159,20 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
-
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
-
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
-
-            klass._version = klass.parse_version(raw_info)
-
-        return klass._version
-
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
 
 
 # Original source at L58 of <nipype-install>/utils/filemanip.py
@@ -237,6 +226,55 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
@@ -319,41 +357,3 @@ def standard_image(img_name):
         out = clout.runtime.stdout
         basedir = os.path.split(out)[0]
         return os.path.join(basedir, img_name)
-
-
-# Original source at L242 of <nipype-install>/interfaces/afni/base.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    path, base, _ = split_filename(value)
-    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def nipype_interfaces_afni__AFNICommand___list_outputs(
-    inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
diff --git a/example-specs/task/nipype/afni/t_stat_callables.py b/example-specs/task/nipype/afni/t_stat_callables.py
index 5347d6ed..a20640fb 100644
--- a/example-specs/task/nipype/afni/t_stat_callables.py
+++ b/example-specs/task/nipype/afni/t_stat_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of TStat.yaml"""
 
-from looseversion import LooseVersion
 import attrs
 import logging
 import os
 import os.path as op
+from looseversion import LooseVersion
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,17 +17,6 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
@@ -123,6 +112,33 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
 # Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
@@ -143,47 +159,20 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
-
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
-
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
-
-            klass._version = klass.parse_version(raw_info)
-
-        return klass._version
-
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
 
 
 # Original source at L58 of <nipype-install>/utils/filemanip.py
@@ -237,6 +226,55 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
@@ -319,41 +357,3 @@ def standard_image(img_name):
         out = clout.runtime.stdout
         basedir = os.path.split(out)[0]
         return os.path.join(basedir, img_name)
-
-
-# Original source at L242 of <nipype-install>/interfaces/afni/base.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    path, base, _ = split_filename(value)
-    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def nipype_interfaces_afni__AFNICommand___list_outputs(
-    inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
diff --git a/example-specs/task/nipype/afni/to_3d_callables.py b/example-specs/task/nipype/afni/to_3d_callables.py
index 1b4af9cb..521d5866 100644
--- a/example-specs/task/nipype/afni/to_3d_callables.py
+++ b/example-specs/task/nipype/afni/to_3d_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of To3D.yaml"""
 
-from looseversion import LooseVersion
 import attrs
 import logging
 import os
 import os.path as op
+from looseversion import LooseVersion
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,17 +17,6 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
@@ -123,6 +112,33 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
 # Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
@@ -143,47 +159,20 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
-
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
-
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
-
-            klass._version = klass.parse_version(raw_info)
-
-        return klass._version
-
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
 
 
 # Original source at L58 of <nipype-install>/utils/filemanip.py
@@ -237,6 +226,55 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
@@ -319,41 +357,3 @@ def standard_image(img_name):
         out = clout.runtime.stdout
         basedir = os.path.split(out)[0]
         return os.path.join(basedir, img_name)
-
-
-# Original source at L242 of <nipype-install>/interfaces/afni/base.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    path, base, _ = split_filename(value)
-    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def nipype_interfaces_afni__AFNICommand___list_outputs(
-    inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
diff --git a/example-specs/task/nipype/afni/undump_callables.py b/example-specs/task/nipype/afni/undump_callables.py
index cddb3740..1309ef74 100644
--- a/example-specs/task/nipype/afni/undump_callables.py
+++ b/example-specs/task/nipype/afni/undump_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Undump.yaml"""
 
-from looseversion import LooseVersion
 import attrs
 import logging
 import os
 import os.path as op
+from looseversion import LooseVersion
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,17 +17,6 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
@@ -123,6 +112,33 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
 # Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
@@ -143,47 +159,20 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
-
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
-
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
-
-            klass._version = klass.parse_version(raw_info)
-
-        return klass._version
-
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
 
 
 # Original source at L58 of <nipype-install>/utils/filemanip.py
@@ -237,6 +226,55 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
@@ -319,41 +357,3 @@ def standard_image(img_name):
         out = clout.runtime.stdout
         basedir = os.path.split(out)[0]
         return os.path.join(basedir, img_name)
-
-
-# Original source at L242 of <nipype-install>/interfaces/afni/base.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    path, base, _ = split_filename(value)
-    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def nipype_interfaces_afni__AFNICommand___list_outputs(
-    inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
diff --git a/example-specs/task/nipype/afni/unifize_callables.py b/example-specs/task/nipype/afni/unifize_callables.py
index 94e1028d..6da79c81 100644
--- a/example-specs/task/nipype/afni/unifize_callables.py
+++ b/example-specs/task/nipype/afni/unifize_callables.py
@@ -1,40 +1,29 @@
 """Module to put any functions that are referred to in the "callables" section of Unifize.yaml"""
 
-from looseversion import LooseVersion
 import attrs
 import logging
 import os
 import os.path as op
+from looseversion import LooseVersion
 
 
-def scale_file_callable(output_dir, inputs, stdout, stderr):
+def out_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["scale_file"]
+    return outputs["out_file"]
 
 
-def out_file_callable(output_dir, inputs, stdout, stderr):
+def scale_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_file"]
+    return outputs["scale_file"]
 
 
 iflogger = logging.getLogger("nipype.interface")
 
 
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
@@ -130,6 +119,33 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
 # Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
@@ -150,47 +166,20 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
-
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
-
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
-
-            klass._version = klass.parse_version(raw_info)
-
-        return klass._version
-
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
 
 
 # Original source at L58 of <nipype-install>/utils/filemanip.py
@@ -244,6 +233,55 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
@@ -326,41 +364,3 @@ def standard_image(img_name):
         out = clout.runtime.stdout
         basedir = os.path.split(out)[0]
         return os.path.join(basedir, img_name)
-
-
-# Original source at L242 of <nipype-install>/interfaces/afni/base.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    path, base, _ = split_filename(value)
-    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def nipype_interfaces_afni__AFNICommand___list_outputs(
-    inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
diff --git a/example-specs/task/nipype/afni/volreg_callables.py b/example-specs/task/nipype/afni/volreg_callables.py
index cadd735f..37d957d6 100644
--- a/example-specs/task/nipype/afni/volreg_callables.py
+++ b/example-specs/task/nipype/afni/volreg_callables.py
@@ -1,17 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Volreg.yaml"""
 
-from looseversion import LooseVersion
 import attrs
 import logging
 import os
 import os.path as op
-
-
-def out_file_callable(output_dir, inputs, stdout, stderr):
-    outputs = _list_outputs(
-        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
-    )
-    return outputs["out_file"]
+from looseversion import LooseVersion
 
 
 def md1d_file_callable(output_dir, inputs, stdout, stderr):
@@ -35,18 +28,14 @@ def oned_matrix_save_callable(output_dir, inputs, stdout, stderr):
     return outputs["oned_matrix_save"]
 
 
-iflogger = logging.getLogger("nipype.interface")
-
-
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
+def out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_file"]
 
-    def __init__(self, value):
-        self.value = value
 
-    def __str__(self):
-        return "{}".format(self.value)
+iflogger = logging.getLogger("nipype.interface")
 
 
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
@@ -144,6 +133,33 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
 # Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
@@ -164,47 +180,20 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
-
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
-
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
-
-            klass._version = klass.parse_version(raw_info)
-
-        return klass._version
-
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
 
 
 # Original source at L58 of <nipype-install>/utils/filemanip.py
@@ -258,6 +247,55 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
@@ -340,41 +378,3 @@ def standard_image(img_name):
         out = clout.runtime.stdout
         basedir = os.path.split(out)[0]
         return os.path.join(basedir, img_name)
-
-
-# Original source at L242 of <nipype-install>/interfaces/afni/base.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    path, base, _ = split_filename(value)
-    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def nipype_interfaces_afni__AFNICommand___list_outputs(
-    inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
diff --git a/example-specs/task/nipype/afni/warp_callables.py b/example-specs/task/nipype/afni/warp_callables.py
index 59bd6001..12cbe59b 100644
--- a/example-specs/task/nipype/afni/warp_callables.py
+++ b/example-specs/task/nipype/afni/warp_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Warp.yaml"""
 
-from looseversion import LooseVersion
 import attrs
 import logging
 import os
 import os.path as op
+from looseversion import LooseVersion
 from pathlib import Path
 
 
@@ -25,163 +25,6 @@ def warp_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
-
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
-
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
-
-            klass._version = klass.parse_version(raw_info)
-
-        return klass._version
-
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
-
-
-# Original source at L26 of <nipype-install>/interfaces/afni/base.py
-class Info(PackageInfo):
-    """Handle afni output type and version information."""
-
-    __outputtype = "AFNI"
-    ftypes = {"NIFTI": ".nii", "AFNI": "", "NIFTI_GZ": ".nii.gz"}
-    version_cmd = "afni --version"
-
-    @staticmethod
-    def parse_version(raw_info):
-        """Check and parse AFNI's version."""
-        version_stamp = raw_info.split("\n")[0].split("Version ")[1]
-        if version_stamp.startswith("AFNI"):
-            version_stamp = version_stamp.split("AFNI_")[1]
-        elif version_stamp.startswith("Debian"):
-            version_stamp = version_stamp.split("Debian-")[1].split("~")[0]
-        else:
-            return None
-
-        version = LooseVersion(version_stamp.replace("_", ".")).version[:3]
-        if version[0] < 1000:
-            version[0] = version[0] + 2000
-        return tuple(version)
-
-    @classmethod
-    def output_type_to_ext(cls, outputtype):
-        """
-        Get the file extension for the given output type.
-
-        Parameters
-        ----------
-        outputtype : {'NIFTI', 'NIFTI_GZ', 'AFNI'}
-            String specifying the output type.
-
-        Returns
-        -------
-        extension : str
-            The file extension for the output type.
-
-        """
-        try:
-            return cls.ftypes[outputtype]
-        except KeyError as e:
-            msg = "Invalid AFNIOUTPUTTYPE: ", outputtype
-            raise KeyError(msg) from e
-
-    @classmethod
-    def outputtype(cls):
-        """
-        Set default output filetype.
-
-        AFNI has no environment variables, Output filetypes get set in command line calls
-        Nipype uses ``AFNI`` as default
-
-
-        Returns
-        -------
-        None
-
-        """
-        return "AFNI"
-
-    @staticmethod
-    def standard_image(img_name):
-        """
-        Grab an image from the standard location.
-
-        Could be made more fancy to allow for more relocatability
-
-        """
-        clout = CommandLine(
-            "which afni",
-            ignore_exception=True,
-            resource_monitor=False,
-            terminal_output="allatonce",
-        ).run()
-        if clout.runtime.returncode != 0:
-            return None
-
-        out = clout.runtime.stdout
-        basedir = os.path.split(out)[0]
-        return os.path.join(basedir, img_name)
-
-
-# Original source at L242 of <nipype-install>/interfaces/afni/base.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    path, base, _ = split_filename(value)
-    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def nipype_interfaces_afni__AFNICommand___list_outputs(
-    inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
-
-
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
@@ -277,31 +120,30 @@ def _filename_from_source(
     return retval
 
 
-# Original source at L891 of <nipype-install>/interfaces/base/core.py
-def nipype_interfaces_afni__AFNICommandBase___list_outputs(
-    inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    metadata = dict(name_source=lambda t: t is not None)
-    traits = inputs.traits(**metadata)
-    if traits:
-        outputs = {}
-        for name, trait_spec in list(traits.items()):
-            out_name = name
-            if trait_spec.output_name is not None:
-                out_name = trait_spec.output_name
-            fname = _filename_from_source(
-                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-            )
-            if fname is not attrs.NOTHING:
-                outputs[out_name] = os.path.abspath(fname)
-        return outputs
-
-
 # Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L3615 of <nipype-install>/interfaces/afni/preprocess.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    if inputs.save_warp:
+        outputs["warp_file"] = fname_presuffix(
+            outputs["out_file"], suffix="_transform.mat", use_ext=False
+        )
+
+    return outputs
+
+
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
 # Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
@@ -345,6 +187,42 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
+def nipype_interfaces_afni__AFNICommandBase___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
 # Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
@@ -396,12 +274,134 @@ def split_filename(fname):
     return pth, fname, ext
 
 
-# Original source at L3615 of <nipype-install>/interfaces/afni/preprocess.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    if inputs.save_warp:
-        outputs["warp_file"] = fname_presuffix(
-            outputs["out_file"], suffix="_transform.mat", use_ext=False
-        )
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
 
-    return outputs
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
+# Original source at L26 of <nipype-install>/interfaces/afni/base.py
+class Info(PackageInfo):
+    """Handle afni output type and version information."""
+
+    __outputtype = "AFNI"
+    ftypes = {"NIFTI": ".nii", "AFNI": "", "NIFTI_GZ": ".nii.gz"}
+    version_cmd = "afni --version"
+
+    @staticmethod
+    def parse_version(raw_info):
+        """Check and parse AFNI's version."""
+        version_stamp = raw_info.split("\n")[0].split("Version ")[1]
+        if version_stamp.startswith("AFNI"):
+            version_stamp = version_stamp.split("AFNI_")[1]
+        elif version_stamp.startswith("Debian"):
+            version_stamp = version_stamp.split("Debian-")[1].split("~")[0]
+        else:
+            return None
+
+        version = LooseVersion(version_stamp.replace("_", ".")).version[:3]
+        if version[0] < 1000:
+            version[0] = version[0] + 2000
+        return tuple(version)
+
+    @classmethod
+    def output_type_to_ext(cls, outputtype):
+        """
+        Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        outputtype : {'NIFTI', 'NIFTI_GZ', 'AFNI'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+
+        """
+        try:
+            return cls.ftypes[outputtype]
+        except KeyError as e:
+            msg = "Invalid AFNIOUTPUTTYPE: ", outputtype
+            raise KeyError(msg) from e
+
+    @classmethod
+    def outputtype(cls):
+        """
+        Set default output filetype.
+
+        AFNI has no environment variables, Output filetypes get set in command line calls
+        Nipype uses ``AFNI`` as default
+
+
+        Returns
+        -------
+        None
+
+        """
+        return "AFNI"
+
+    @staticmethod
+    def standard_image(img_name):
+        """
+        Grab an image from the standard location.
+
+        Could be made more fancy to allow for more relocatability
+
+        """
+        clout = CommandLine(
+            "which afni",
+            ignore_exception=True,
+            resource_monitor=False,
+            terminal_output="allatonce",
+        ).run()
+        if clout.runtime.returncode != 0:
+            return None
+
+        out = clout.runtime.stdout
+        basedir = os.path.split(out)[0]
+        return os.path.join(basedir, img_name)
+
+
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
diff --git a/example-specs/task/nipype/afni/z_cut_up_callables.py b/example-specs/task/nipype/afni/z_cut_up_callables.py
index 61677e82..8cef91a6 100644
--- a/example-specs/task/nipype/afni/z_cut_up_callables.py
+++ b/example-specs/task/nipype/afni/z_cut_up_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of ZCutUp.yaml"""
 
-from looseversion import LooseVersion
 import attrs
 import logging
 import os
 import os.path as op
+from looseversion import LooseVersion
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,17 +17,6 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
@@ -123,6 +112,33 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
 # Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
@@ -143,47 +159,20 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
-
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
-
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
-
-            klass._version = klass.parse_version(raw_info)
-
-        return klass._version
-
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
 
 
 # Original source at L58 of <nipype-install>/utils/filemanip.py
@@ -237,6 +226,55 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
@@ -319,41 +357,3 @@ def standard_image(img_name):
         out = clout.runtime.stdout
         basedir = os.path.split(out)[0]
         return os.path.join(basedir, img_name)
-
-
-# Original source at L242 of <nipype-install>/interfaces/afni/base.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    path, base, _ = split_filename(value)
-    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def nipype_interfaces_afni__AFNICommand___list_outputs(
-    inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
diff --git a/example-specs/task/nipype/afni/zcat_callables.py b/example-specs/task/nipype/afni/zcat_callables.py
index 30ab6cd7..23165e93 100644
--- a/example-specs/task/nipype/afni/zcat_callables.py
+++ b/example-specs/task/nipype/afni/zcat_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Zcat.yaml"""
 
-from looseversion import LooseVersion
 import attrs
 import logging
 import os
 import os.path as op
+from looseversion import LooseVersion
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,17 +17,6 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
@@ -123,6 +112,33 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
 # Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
@@ -143,47 +159,20 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
-
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
-
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
-
-            klass._version = klass.parse_version(raw_info)
-
-        return klass._version
-
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
 
 
 # Original source at L58 of <nipype-install>/utils/filemanip.py
@@ -237,6 +226,55 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
@@ -319,41 +357,3 @@ def standard_image(img_name):
         out = clout.runtime.stdout
         basedir = os.path.split(out)[0]
         return os.path.join(basedir, img_name)
-
-
-# Original source at L242 of <nipype-install>/interfaces/afni/base.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    path, base, _ = split_filename(value)
-    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def nipype_interfaces_afni__AFNICommand___list_outputs(
-    inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
diff --git a/example-specs/task/nipype/afni/zeropad_callables.py b/example-specs/task/nipype/afni/zeropad_callables.py
index 1e137b69..8d112ac8 100644
--- a/example-specs/task/nipype/afni/zeropad_callables.py
+++ b/example-specs/task/nipype/afni/zeropad_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Zeropad.yaml"""
 
-from looseversion import LooseVersion
 import attrs
 import logging
 import os
 import os.path as op
+from looseversion import LooseVersion
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -17,17 +17,6 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
@@ -123,6 +112,33 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
+
+
+# Original source at L242 of <nipype-install>/interfaces/afni/base.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    path, base, _ = split_filename(value)
+    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
+
+
 # Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_afni__AFNICommandBase___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
@@ -143,47 +159,20 @@ def nipype_interfaces_afni__AFNICommandBase___list_outputs(
         return outputs
 
 
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
-
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
-
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
-
-            klass._version = klass.parse_version(raw_info)
-
-        return klass._version
-
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+# Original source at L248 of <nipype-install>/interfaces/afni/base.py
+def nipype_interfaces_afni__AFNICommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
+    metadata = dict(name_source=lambda t: t is not None)
+    out_names = list(inputs.traits(**metadata).keys())
+    if out_names:
+        for name in out_names:
+            if outputs[name]:
+                _, _, ext = split_filename(outputs[name])
+                if ext == "":
+                    outputs[name] = outputs[name] + "+orig.BRIK"
+    return outputs
 
 
 # Original source at L58 of <nipype-install>/utils/filemanip.py
@@ -237,6 +226,55 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L26 of <nipype-install>/interfaces/afni/base.py
 class Info(PackageInfo):
     """Handle afni output type and version information."""
@@ -319,41 +357,3 @@ def standard_image(img_name):
         out = clout.runtime.stdout
         basedir = os.path.split(out)[0]
         return os.path.join(basedir, img_name)
-
-
-# Original source at L242 of <nipype-install>/interfaces/afni/base.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    path, base, _ = split_filename(value)
-    return os.path.join(path, base + Info.output_type_to_ext(inputs.outputtype))
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def nipype_interfaces_afni__AFNICommand___list_outputs(
-    inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
-
-
-# Original source at L248 of <nipype-install>/interfaces/afni/base.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = nipype_interfaces_afni__AFNICommandBase___list_outputs()
-    metadata = dict(name_source=lambda t: t is not None)
-    out_names = list(inputs.traits(**metadata).keys())
-    if out_names:
-        for name in out_names:
-            if outputs[name]:
-                _, _, ext = split_filename(outputs[name])
-                if ext == "":
-                    outputs[name] = outputs[name] + "+orig.BRIK"
-    return outputs
diff --git a/example-specs/task/nipype/ants/affine_initializer_callables.py b/example-specs/task/nipype/ants/affine_initializer_callables.py
index 1c877819..309afdac 100644
--- a/example-specs/task/nipype/ants/affine_initializer_callables.py
+++ b/example-specs/task/nipype/ants/affine_initializer_callables.py
@@ -1,7 +1,6 @@
 """Module to put any functions that are referred to in the "callables" section of AffineInitializer.yaml"""
 
 import os
-import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/ants/ai_callables.py b/example-specs/task/nipype/ants/ai_callables.py
index 64cfad3f..071a285c 100644
--- a/example-specs/task/nipype/ants/ai_callables.py
+++ b/example-specs/task/nipype/ants/ai_callables.py
@@ -1,7 +1,5 @@
 """Module to put any functions that are referred to in the "callables" section of AI.yaml"""
 
-import attrs
-
 
 def output_transform_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
diff --git a/example-specs/task/nipype/ants/ants_callables.py b/example-specs/task/nipype/ants/ants_callables.py
index 18da57a0..93306b73 100644
--- a/example-specs/task/nipype/ants/ants_callables.py
+++ b/example-specs/task/nipype/ants/ants_callables.py
@@ -1,7 +1,6 @@
 """Module to put any functions that are referred to in the "callables" section of ANTS.yaml"""
 
 import os
-import attrs
 
 
 def affine_transform_callable(output_dir, inputs, stdout, stderr):
@@ -11,13 +10,6 @@ def affine_transform_callable(output_dir, inputs, stdout, stderr):
     return outputs["affine_transform"]
 
 
-def warp_transform_callable(output_dir, inputs, stdout, stderr):
-    outputs = _list_outputs(
-        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
-    )
-    return outputs["warp_transform"]
-
-
 def inverse_warp_transform_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
@@ -39,6 +31,13 @@ def metaheader_raw_callable(output_dir, inputs, stdout, stderr):
     return outputs["metaheader_raw"]
 
 
+def warp_transform_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["warp_transform"]
+
+
 # Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
diff --git a/example-specs/task/nipype/ants/ants_introduction_callables.py b/example-specs/task/nipype/ants/ants_introduction_callables.py
index 9b46dbf0..a68abea5 100644
--- a/example-specs/task/nipype/ants/ants_introduction_callables.py
+++ b/example-specs/task/nipype/ants/ants_introduction_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of antsIntroduction.yaml"""
 
-import os
 import attrs
+import os
 
 
 def affine_transformation_callable(output_dir, inputs, stdout, stderr):
@@ -11,11 +11,11 @@ def affine_transformation_callable(output_dir, inputs, stdout, stderr):
     return outputs["affine_transformation"]
 
 
-def warp_field_callable(output_dir, inputs, stdout, stderr):
+def input_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["warp_field"]
+    return outputs["input_file"]
 
 
 def inverse_warp_field_callable(output_dir, inputs, stdout, stderr):
@@ -25,18 +25,18 @@ def inverse_warp_field_callable(output_dir, inputs, stdout, stderr):
     return outputs["inverse_warp_field"]
 
 
-def input_file_callable(output_dir, inputs, stdout, stderr):
+def output_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["input_file"]
+    return outputs["output_file"]
 
 
-def output_file_callable(output_dir, inputs, stdout, stderr):
+def warp_field_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["output_file"]
+    return outputs["warp_field"]
 
 
 # Original source at L885 of <nipype-install>/interfaces/base/core.py
diff --git a/example-specs/task/nipype/ants/apply_transforms_callables.py b/example-specs/task/nipype/ants/apply_transforms_callables.py
index 6b09bb57..303b0944 100644
--- a/example-specs/task/nipype/ants/apply_transforms_callables.py
+++ b/example-specs/task/nipype/ants/apply_transforms_callables.py
@@ -1,8 +1,8 @@
 """Module to put any functions that are referred to in the "callables" section of ApplyTransforms.yaml"""
 
+import attrs
 import os
 import os.path as op
-import attrs
 
 
 def output_image_default(inputs):
@@ -16,6 +16,32 @@ def output_image_callable(output_dir, inputs, stdout, stderr):
     return outputs["output_image"]
 
 
+# Original source at L465 of <nipype-install>/interfaces/ants/resampling.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "output_image":
+        output = inputs.output_image
+        if output is attrs.NOTHING:
+            _, name, ext = split_filename(inputs.input_image)
+            output = name + inputs.out_postfix + ext
+        return output
+    return None
+
+
+# Original source at L522 of <nipype-install>/interfaces/ants/resampling.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["output_image"] = os.path.abspath(
+        _gen_filename(
+            "output_image",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    )
+    return outputs
+
+
 # Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
@@ -65,29 +91,3 @@ def split_filename(fname):
         fname, ext = op.splitext(fname)
 
     return pth, fname, ext
-
-
-# Original source at L465 of <nipype-install>/interfaces/ants/resampling.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "output_image":
-        output = inputs.output_image
-        if output is attrs.NOTHING:
-            _, name, ext = split_filename(inputs.input_image)
-            output = name + inputs.out_postfix + ext
-        return output
-    return None
-
-
-# Original source at L522 of <nipype-install>/interfaces/ants/resampling.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    outputs["output_image"] = os.path.abspath(
-        _gen_filename(
-            "output_image",
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-    )
-    return outputs
diff --git a/example-specs/task/nipype/ants/apply_transforms_to_points_callables.py b/example-specs/task/nipype/ants/apply_transforms_to_points_callables.py
index 71178089..78f8d13d 100644
--- a/example-specs/task/nipype/ants/apply_transforms_to_points_callables.py
+++ b/example-specs/task/nipype/ants/apply_transforms_to_points_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of ApplyTransformsToPoints.yaml"""
 
+import attrs
 import logging
 import os
 import os.path as op
-import attrs
 
 
 def output_file_callable(output_dir, inputs, stdout, stderr):
@@ -16,75 +16,6 @@ def output_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
-# Original source at L58 of <nipype-install>/utils/filemanip.py
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
-# Original source at L888 of <nipype-install>/interfaces/base/core.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    return value
-
-
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
@@ -201,3 +132,72 @@ def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
             if fname is not attrs.NOTHING:
                 outputs[out_name] = os.path.abspath(fname)
         return outputs
+
+
+# Original source at L888 of <nipype-install>/interfaces/base/core.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value
+
+
+# Original source at L58 of <nipype-install>/utils/filemanip.py
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
diff --git a/example-specs/task/nipype/ants/atropos_callables.py b/example-specs/task/nipype/ants/atropos_callables.py
index 7577d0ce..e2b83271 100644
--- a/example-specs/task/nipype/ants/atropos_callables.py
+++ b/example-specs/task/nipype/ants/atropos_callables.py
@@ -1,8 +1,8 @@
 """Module to put any functions that are referred to in the "callables" section of Atropos.yaml"""
 
+import attrs
 import os
 import os.path as op
-import attrs
 
 
 def out_classified_image_name_default(inputs):
@@ -23,6 +23,37 @@ def posteriors_callable(output_dir, inputs, stdout, stderr):
     return outputs["posteriors"]
 
 
+# Original source at L232 of <nipype-install>/interfaces/ants/segmentation.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_classified_image_name":
+        output = inputs.out_classified_image_name
+        if output is attrs.NOTHING:
+            _, name, ext = split_filename(inputs.intensity_images[0])
+            output = name + "_labeled" + ext
+        return output
+
+
+# Original source at L240 of <nipype-install>/interfaces/ants/segmentation.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["classified_image"] = os.path.abspath(
+        _gen_filename(
+            "out_classified_image_name",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    )
+    if (inputs.save_posteriors is not attrs.NOTHING) and inputs.save_posteriors:
+        outputs["posteriors"] = []
+        for i in range(inputs.number_of_tissue_classes):
+            outputs["posteriors"].append(
+                os.path.abspath(inputs.output_posteriors_name_template % (i + 1))
+            )
+    return outputs
+
+
 # Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
@@ -72,34 +103,3 @@ def split_filename(fname):
         fname, ext = op.splitext(fname)
 
     return pth, fname, ext
-
-
-# Original source at L232 of <nipype-install>/interfaces/ants/segmentation.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "out_classified_image_name":
-        output = inputs.out_classified_image_name
-        if output is attrs.NOTHING:
-            _, name, ext = split_filename(inputs.intensity_images[0])
-            output = name + "_labeled" + ext
-        return output
-
-
-# Original source at L240 of <nipype-install>/interfaces/ants/segmentation.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    outputs["classified_image"] = os.path.abspath(
-        _gen_filename(
-            "out_classified_image_name",
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-    )
-    if (inputs.save_posteriors is not attrs.NOTHING) and inputs.save_posteriors:
-        outputs["posteriors"] = []
-        for i in range(inputs.number_of_tissue_classes):
-            outputs["posteriors"].append(
-                os.path.abspath(inputs.output_posteriors_name_template % (i + 1))
-            )
-    return outputs
diff --git a/example-specs/task/nipype/ants/average_affine_transform_callables.py b/example-specs/task/nipype/ants/average_affine_transform_callables.py
index 3d0b945f..ed4730a6 100644
--- a/example-specs/task/nipype/ants/average_affine_transform_callables.py
+++ b/example-specs/task/nipype/ants/average_affine_transform_callables.py
@@ -1,7 +1,6 @@
 """Module to put any functions that are referred to in the "callables" section of AverageAffineTransform.yaml"""
 
 import os
-import attrs
 
 
 def affine_transform_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/ants/average_images_callables.py b/example-specs/task/nipype/ants/average_images_callables.py
index e4973c3e..c0d588d6 100644
--- a/example-specs/task/nipype/ants/average_images_callables.py
+++ b/example-specs/task/nipype/ants/average_images_callables.py
@@ -1,7 +1,6 @@
 """Module to put any functions that are referred to in the "callables" section of AverageImages.yaml"""
 
 import os
-import attrs
 
 
 def output_average_image_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/ants/brain_extraction_callables.py b/example-specs/task/nipype/ants/brain_extraction_callables.py
index 5b80d0f2..157af1e7 100644
--- a/example-specs/task/nipype/ants/brain_extraction_callables.py
+++ b/example-specs/task/nipype/ants/brain_extraction_callables.py
@@ -1,14 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of BrainExtraction.yaml"""
 
-import os
 import attrs
-
-
-def BrainExtractionMask_callable(output_dir, inputs, stdout, stderr):
-    outputs = _list_outputs(
-        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
-    )
-    return outputs["BrainExtractionMask"]
+import os
 
 
 def BrainExtractionBrain_callable(output_dir, inputs, stdout, stderr):
@@ -60,6 +53,13 @@ def BrainExtractionLaplacian_callable(output_dir, inputs, stdout, stderr):
     return outputs["BrainExtractionLaplacian"]
 
 
+def BrainExtractionMask_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["BrainExtractionMask"]
+
+
 def BrainExtractionPrior0GenericAffine_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
diff --git a/example-specs/task/nipype/ants/buildtemplateparallel_callables.py b/example-specs/task/nipype/ants/buildtemplateparallel_callables.py
index 149002f4..17f849e9 100644
--- a/example-specs/task/nipype/ants/buildtemplateparallel_callables.py
+++ b/example-specs/task/nipype/ants/buildtemplateparallel_callables.py
@@ -1,9 +1,8 @@
 """Module to put any functions that are referred to in the "callables" section of buildtemplateparallel.yaml"""
 
-from builtins import range
-import attrs
 import os
 import os.path as op
+from builtins import range
 from glob import glob
 
 
@@ -14,18 +13,18 @@ def final_template_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["final_template_file"]
 
 
-def template_files_callable(output_dir, inputs, stdout, stderr):
+def subject_outfiles_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["template_files"]
+    return outputs["subject_outfiles"]
 
 
-def subject_outfiles_callable(output_dir, inputs, stdout, stderr):
+def template_files_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["subject_outfiles"]
+    return outputs["template_files"]
 
 
 # Original source at L885 of <nipype-install>/interfaces/base/core.py
@@ -33,6 +32,42 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L340 of <nipype-install>/interfaces/ants/legacy.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["template_files"] = []
+    for i in range(len(glob(os.path.realpath("*iteration*")))):
+        temp = os.path.realpath(
+            "%s_iteration_%d/%stemplate.nii.gz"
+            % (inputs.transformation_model, i, inputs.out_prefix)
+        )
+        os.rename(
+            temp,
+            os.path.realpath(
+                "%s_iteration_%d/%stemplate_i%d.nii.gz"
+                % (inputs.transformation_model, i, inputs.out_prefix, i)
+            ),
+        )
+        file_ = "%s_iteration_%d/%stemplate_i%d.nii.gz" % (
+            inputs.transformation_model,
+            i,
+            inputs.out_prefix,
+            i,
+        )
+
+        outputs["template_files"].append(os.path.realpath(file_))
+        outputs["final_template_file"] = os.path.realpath(
+            "%stemplate.nii.gz" % inputs.out_prefix
+        )
+    outputs["subject_outfiles"] = []
+    for filename in inputs.in_files:
+        _, base, _ = split_filename(filename)
+        temp = glob(os.path.realpath("%s%s*" % (inputs.out_prefix, base)))
+        for file_ in temp:
+            outputs["subject_outfiles"].append(file_)
+    return outputs
+
+
 # Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
@@ -82,39 +117,3 @@ def split_filename(fname):
         fname, ext = op.splitext(fname)
 
     return pth, fname, ext
-
-
-# Original source at L340 of <nipype-install>/interfaces/ants/legacy.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    outputs["template_files"] = []
-    for i in range(len(glob(os.path.realpath("*iteration*")))):
-        temp = os.path.realpath(
-            "%s_iteration_%d/%stemplate.nii.gz"
-            % (inputs.transformation_model, i, inputs.out_prefix)
-        )
-        os.rename(
-            temp,
-            os.path.realpath(
-                "%s_iteration_%d/%stemplate_i%d.nii.gz"
-                % (inputs.transformation_model, i, inputs.out_prefix, i)
-            ),
-        )
-        file_ = "%s_iteration_%d/%stemplate_i%d.nii.gz" % (
-            inputs.transformation_model,
-            i,
-            inputs.out_prefix,
-            i,
-        )
-
-        outputs["template_files"].append(os.path.realpath(file_))
-        outputs["final_template_file"] = os.path.realpath(
-            "%stemplate.nii.gz" % inputs.out_prefix
-        )
-    outputs["subject_outfiles"] = []
-    for filename in inputs.in_files:
-        _, base, _ = split_filename(filename)
-        temp = glob(os.path.realpath("%s%s*" % (inputs.out_prefix, base)))
-        for file_ in temp:
-            outputs["subject_outfiles"].append(file_)
-    return outputs
diff --git a/example-specs/task/nipype/ants/compose_multi_transform_callables.py b/example-specs/task/nipype/ants/compose_multi_transform_callables.py
index 265ff1bf..0fff1875 100644
--- a/example-specs/task/nipype/ants/compose_multi_transform_callables.py
+++ b/example-specs/task/nipype/ants/compose_multi_transform_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of ComposeMultiTransform.yaml"""
 
+import attrs
 import logging
 import os
 import os.path as op
-import attrs
 
 
 def output_transform_callable(output_dir, inputs, stdout, stderr):
@@ -16,75 +16,6 @@ def output_transform_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
-# Original source at L58 of <nipype-install>/utils/filemanip.py
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
-# Original source at L888 of <nipype-install>/interfaces/base/core.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    return value
-
-
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
@@ -201,3 +132,72 @@ def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
             if fname is not attrs.NOTHING:
                 outputs[out_name] = os.path.abspath(fname)
         return outputs
+
+
+# Original source at L888 of <nipype-install>/interfaces/base/core.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value
+
+
+# Original source at L58 of <nipype-install>/utils/filemanip.py
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
diff --git a/example-specs/task/nipype/ants/composite_transform_util_callables.py b/example-specs/task/nipype/ants/composite_transform_util_callables.py
index 7009fafd..0c092e5c 100644
--- a/example-specs/task/nipype/ants/composite_transform_util_callables.py
+++ b/example-specs/task/nipype/ants/composite_transform_util_callables.py
@@ -1,7 +1,6 @@
 """Module to put any functions that are referred to in the "callables" section of CompositeTransformUtil.yaml"""
 
 import os
-import attrs
 
 
 def affine_transform_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/ants/convert_scalar_image_to_rgb_callables.py b/example-specs/task/nipype/ants/convert_scalar_image_to_rgb_callables.py
index 59dae516..bf7c5d1d 100644
--- a/example-specs/task/nipype/ants/convert_scalar_image_to_rgb_callables.py
+++ b/example-specs/task/nipype/ants/convert_scalar_image_to_rgb_callables.py
@@ -1,7 +1,6 @@
 """Module to put any functions that are referred to in the "callables" section of ConvertScalarImageToRGB.yaml"""
 
 import os
-import attrs
 
 
 def output_image_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/ants/cortical_thickness_callables.py b/example-specs/task/nipype/ants/cortical_thickness_callables.py
index d7610e62..2113f528 100644
--- a/example-specs/task/nipype/ants/cortical_thickness_callables.py
+++ b/example-specs/task/nipype/ants/cortical_thickness_callables.py
@@ -1,7 +1,6 @@
 """Module to put any functions that are referred to in the "callables" section of CorticalThickness.yaml"""
 
 import os
-import attrs
 
 
 def BrainExtractionMask_callable(output_dir, inputs, stdout, stderr):
@@ -11,13 +10,6 @@ def BrainExtractionMask_callable(output_dir, inputs, stdout, stderr):
     return outputs["BrainExtractionMask"]
 
 
-def ExtractedBrainN4_callable(output_dir, inputs, stdout, stderr):
-    outputs = _list_outputs(
-        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
-    )
-    return outputs["ExtractedBrainN4"]
-
-
 def BrainSegmentation_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
@@ -39,32 +31,32 @@ def BrainSegmentationPosteriors_callable(output_dir, inputs, stdout, stderr):
     return outputs["BrainSegmentationPosteriors"]
 
 
-def CorticalThickness_callable(output_dir, inputs, stdout, stderr):
+def BrainVolumes_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["CorticalThickness"]
+    return outputs["BrainVolumes"]
 
 
-def TemplateToSubject1GenericAffine_callable(output_dir, inputs, stdout, stderr):
+def CorticalThickness_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["TemplateToSubject1GenericAffine"]
+    return outputs["CorticalThickness"]
 
 
-def TemplateToSubject0Warp_callable(output_dir, inputs, stdout, stderr):
+def CorticalThicknessNormedToTemplate_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["TemplateToSubject0Warp"]
+    return outputs["CorticalThicknessNormedToTemplate"]
 
 
-def SubjectToTemplate1Warp_callable(output_dir, inputs, stdout, stderr):
+def ExtractedBrainN4_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["SubjectToTemplate1Warp"]
+    return outputs["ExtractedBrainN4"]
 
 
 def SubjectToTemplate0GenericAffine_callable(output_dir, inputs, stdout, stderr):
@@ -74,6 +66,13 @@ def SubjectToTemplate0GenericAffine_callable(output_dir, inputs, stdout, stderr)
     return outputs["SubjectToTemplate0GenericAffine"]
 
 
+def SubjectToTemplate1Warp_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["SubjectToTemplate1Warp"]
+
+
 def SubjectToTemplateLogJacobian_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
@@ -81,18 +80,18 @@ def SubjectToTemplateLogJacobian_callable(output_dir, inputs, stdout, stderr):
     return outputs["SubjectToTemplateLogJacobian"]
 
 
-def CorticalThicknessNormedToTemplate_callable(output_dir, inputs, stdout, stderr):
+def TemplateToSubject0Warp_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["CorticalThicknessNormedToTemplate"]
+    return outputs["TemplateToSubject0Warp"]
 
 
-def BrainVolumes_callable(output_dir, inputs, stdout, stderr):
+def TemplateToSubject1GenericAffine_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["BrainVolumes"]
+    return outputs["TemplateToSubject1GenericAffine"]
 
 
 # Original source at L885 of <nipype-install>/interfaces/base/core.py
diff --git a/example-specs/task/nipype/ants/create_jacobian_determinant_image_callables.py b/example-specs/task/nipype/ants/create_jacobian_determinant_image_callables.py
index 09a9e469..0bd6e4c8 100644
--- a/example-specs/task/nipype/ants/create_jacobian_determinant_image_callables.py
+++ b/example-specs/task/nipype/ants/create_jacobian_determinant_image_callables.py
@@ -1,7 +1,6 @@
 """Module to put any functions that are referred to in the "callables" section of CreateJacobianDeterminantImage.yaml"""
 
 import os
-import attrs
 
 
 def jacobian_image_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/ants/create_tiled_mosaic_callables.py b/example-specs/task/nipype/ants/create_tiled_mosaic_callables.py
index f7e7fc1a..ffb423b4 100644
--- a/example-specs/task/nipype/ants/create_tiled_mosaic_callables.py
+++ b/example-specs/task/nipype/ants/create_tiled_mosaic_callables.py
@@ -1,7 +1,6 @@
 """Module to put any functions that are referred to in the "callables" section of CreateTiledMosaic.yaml"""
 
 import os
-import attrs
 
 
 def output_image_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/ants/denoise_image_callables.py b/example-specs/task/nipype/ants/denoise_image_callables.py
index eadf041c..b1656c0b 100644
--- a/example-specs/task/nipype/ants/denoise_image_callables.py
+++ b/example-specs/task/nipype/ants/denoise_image_callables.py
@@ -1,97 +1,28 @@
 """Module to put any functions that are referred to in the "callables" section of DenoiseImage.yaml"""
 
+import attrs
 import logging
 import os
 import os.path as op
-import attrs
 
 
-def output_image_callable(output_dir, inputs, stdout, stderr):
+def noise_image_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["output_image"]
+    return outputs["noise_image"]
 
 
-def noise_image_callable(output_dir, inputs, stdout, stderr):
+def output_image_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["noise_image"]
+    return outputs["output_image"]
 
 
 iflogger = logging.getLogger("nipype.interface")
 
 
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
-# Original source at L58 of <nipype-install>/utils/filemanip.py
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
-# Original source at L888 of <nipype-install>/interfaces/base/core.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    return value
-
-
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
@@ -208,3 +139,72 @@ def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
             if fname is not attrs.NOTHING:
                 outputs[out_name] = os.path.abspath(fname)
         return outputs
+
+
+# Original source at L888 of <nipype-install>/interfaces/base/core.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value
+
+
+# Original source at L58 of <nipype-install>/utils/filemanip.py
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
diff --git a/example-specs/task/nipype/ants/gen_warp_fields_callables.py b/example-specs/task/nipype/ants/gen_warp_fields_callables.py
index a9bfcf23..a3b80a60 100644
--- a/example-specs/task/nipype/ants/gen_warp_fields_callables.py
+++ b/example-specs/task/nipype/ants/gen_warp_fields_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of GenWarpFields.yaml"""
 
-import os
 import attrs
+import os
 
 
 def affine_transformation_callable(output_dir, inputs, stdout, stderr):
@@ -11,11 +11,11 @@ def affine_transformation_callable(output_dir, inputs, stdout, stderr):
     return outputs["affine_transformation"]
 
 
-def warp_field_callable(output_dir, inputs, stdout, stderr):
+def input_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["warp_field"]
+    return outputs["input_file"]
 
 
 def inverse_warp_field_callable(output_dir, inputs, stdout, stderr):
@@ -25,18 +25,18 @@ def inverse_warp_field_callable(output_dir, inputs, stdout, stderr):
     return outputs["inverse_warp_field"]
 
 
-def input_file_callable(output_dir, inputs, stdout, stderr):
+def output_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["input_file"]
+    return outputs["output_file"]
 
 
-def output_file_callable(output_dir, inputs, stdout, stderr):
+def warp_field_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["output_file"]
+    return outputs["warp_field"]
 
 
 # Original source at L885 of <nipype-install>/interfaces/base/core.py
diff --git a/example-specs/task/nipype/ants/image_math_callables.py b/example-specs/task/nipype/ants/image_math_callables.py
index 95feab5c..e8451286 100644
--- a/example-specs/task/nipype/ants/image_math_callables.py
+++ b/example-specs/task/nipype/ants/image_math_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of ImageMath.yaml"""
 
+import attrs
 import logging
 import os
 import os.path as op
-import attrs
 
 
 def output_image_callable(output_dir, inputs, stdout, stderr):
@@ -16,75 +16,6 @@ def output_image_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
-# Original source at L58 of <nipype-install>/utils/filemanip.py
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
-# Original source at L888 of <nipype-install>/interfaces/base/core.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    return value
-
-
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
@@ -201,3 +132,72 @@ def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
             if fname is not attrs.NOTHING:
                 outputs[out_name] = os.path.abspath(fname)
         return outputs
+
+
+# Original source at L888 of <nipype-install>/interfaces/base/core.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value
+
+
+# Original source at L58 of <nipype-install>/utils/filemanip.py
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
diff --git a/example-specs/task/nipype/ants/joint_fusion_callables.py b/example-specs/task/nipype/ants/joint_fusion_callables.py
index 212ac8da..57ba4623 100644
--- a/example-specs/task/nipype/ants/joint_fusion_callables.py
+++ b/example-specs/task/nipype/ants/joint_fusion_callables.py
@@ -1,15 +1,15 @@
 """Module to put any functions that are referred to in the "callables" section of JointFusion.yaml"""
 
+import attrs
 import os
 from glob import glob
-import attrs
 
 
-def out_label_fusion_callable(output_dir, inputs, stdout, stderr):
+def out_atlas_voting_weight_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_label_fusion"]
+    return outputs["out_atlas_voting_weight"]
 
 
 def out_intensity_fusion_callable(output_dir, inputs, stdout, stderr):
@@ -19,18 +19,18 @@ def out_intensity_fusion_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_intensity_fusion"]
 
 
-def out_label_post_prob_callable(output_dir, inputs, stdout, stderr):
+def out_label_fusion_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_label_post_prob"]
+    return outputs["out_label_fusion"]
 
 
-def out_atlas_voting_weight_callable(output_dir, inputs, stdout, stderr):
+def out_label_post_prob_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_atlas_voting_weight"]
+    return outputs["out_label_post_prob"]
 
 
 # Original source at L885 of <nipype-install>/interfaces/base/core.py
diff --git a/example-specs/task/nipype/ants/kelly_kapowski_callables.py b/example-specs/task/nipype/ants/kelly_kapowski_callables.py
index 86267514..543950d9 100644
--- a/example-specs/task/nipype/ants/kelly_kapowski_callables.py
+++ b/example-specs/task/nipype/ants/kelly_kapowski_callables.py
@@ -23,92 +23,6 @@ def warped_white_matter_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
-# Original source at L1765 of <nipype-install>/interfaces/ants/segmentation.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "cortical_thickness":
-        output = inputs.cortical_thickness
-        if output is attrs.NOTHING:
-            _, name, ext = split_filename(inputs.segmentation_image)
-            output = name + "_cortical_thickness" + ext
-        return output
-
-    if name == "warped_white_matter":
-        output = inputs.warped_white_matter
-        if output is attrs.NOTHING:
-            _, name, ext = split_filename(inputs.segmentation_image)
-            output = name + "_warped_white_matter" + ext
-        return output
-
-
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
-# Original source at L58 of <nipype-install>/utils/filemanip.py
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
-# Original source at L888 of <nipype-install>/interfaces/base/core.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    return value
-
-
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
@@ -204,6 +118,23 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L1765 of <nipype-install>/interfaces/ants/segmentation.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "cortical_thickness":
+        output = inputs.cortical_thickness
+        if output is attrs.NOTHING:
+            _, name, ext = split_filename(inputs.segmentation_image)
+            output = name + "_cortical_thickness" + ext
+        return output
+
+    if name == "warped_white_matter":
+        output = inputs.warped_white_matter
+        if output is attrs.NOTHING:
+            _, name, ext = split_filename(inputs.segmentation_image)
+            output = name + "_warped_white_matter" + ext
+        return output
+
+
 # Original source at L891 of <nipype-install>/interfaces/base/core.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     metadata = dict(name_source=lambda t: t is not None)
@@ -220,3 +151,72 @@ def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
             if fname is not attrs.NOTHING:
                 outputs[out_name] = os.path.abspath(fname)
         return outputs
+
+
+# Original source at L888 of <nipype-install>/interfaces/base/core.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value
+
+
+# Original source at L58 of <nipype-install>/utils/filemanip.py
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
diff --git a/example-specs/task/nipype/ants/label_geometry_callables.py b/example-specs/task/nipype/ants/label_geometry_callables.py
index 580ac76a..8df4bb8e 100644
--- a/example-specs/task/nipype/ants/label_geometry_callables.py
+++ b/example-specs/task/nipype/ants/label_geometry_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of LabelGeometry.yaml"""
 
+import attrs
 import logging
 import os
 import os.path as op
-import attrs
 
 
 def output_file_callable(output_dir, inputs, stdout, stderr):
@@ -16,75 +16,6 @@ def output_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
-# Original source at L58 of <nipype-install>/utils/filemanip.py
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
-# Original source at L888 of <nipype-install>/interfaces/base/core.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    return value
-
-
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
@@ -201,3 +132,72 @@ def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
             if fname is not attrs.NOTHING:
                 outputs[out_name] = os.path.abspath(fname)
         return outputs
+
+
+# Original source at L888 of <nipype-install>/interfaces/base/core.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value
+
+
+# Original source at L58 of <nipype-install>/utils/filemanip.py
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
diff --git a/example-specs/task/nipype/ants/laplacian_thickness_callables.py b/example-specs/task/nipype/ants/laplacian_thickness_callables.py
index 2c7c369b..0d43117e 100644
--- a/example-specs/task/nipype/ants/laplacian_thickness_callables.py
+++ b/example-specs/task/nipype/ants/laplacian_thickness_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of LaplacianThickness.yaml"""
 
+import attrs
 import logging
 import os
 import os.path as op
-import attrs
 
 
 def output_image_callable(output_dir, inputs, stdout, stderr):
@@ -16,75 +16,6 @@ def output_image_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
-# Original source at L58 of <nipype-install>/utils/filemanip.py
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
-# Original source at L888 of <nipype-install>/interfaces/base/core.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    return value
-
-
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
@@ -201,3 +132,72 @@ def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
             if fname is not attrs.NOTHING:
                 outputs[out_name] = os.path.abspath(fname)
         return outputs
+
+
+# Original source at L888 of <nipype-install>/interfaces/base/core.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value
+
+
+# Original source at L58 of <nipype-install>/utils/filemanip.py
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
diff --git a/example-specs/task/nipype/ants/measure_image_similarity_callables.py b/example-specs/task/nipype/ants/measure_image_similarity_callables.py
index b3c53329..758e2354 100644
--- a/example-specs/task/nipype/ants/measure_image_similarity_callables.py
+++ b/example-specs/task/nipype/ants/measure_image_similarity_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of MeasureImageSimilarity.yaml"""
 
+import attrs
 import logging
 import os
 import os.path as op
-import attrs
 
 
 def similarity_callable(output_dir, inputs, stdout, stderr):
@@ -16,75 +16,6 @@ def similarity_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
-# Original source at L58 of <nipype-install>/utils/filemanip.py
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
-# Original source at L888 of <nipype-install>/interfaces/base/core.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    return value
-
-
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
@@ -201,3 +132,72 @@ def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
             if fname is not attrs.NOTHING:
                 outputs[out_name] = os.path.abspath(fname)
         return outputs
+
+
+# Original source at L888 of <nipype-install>/interfaces/base/core.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value
+
+
+# Original source at L58 of <nipype-install>/utils/filemanip.py
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
diff --git a/example-specs/task/nipype/ants/multiply_images_callables.py b/example-specs/task/nipype/ants/multiply_images_callables.py
index bd99f681..acf302ee 100644
--- a/example-specs/task/nipype/ants/multiply_images_callables.py
+++ b/example-specs/task/nipype/ants/multiply_images_callables.py
@@ -1,7 +1,6 @@
 """Module to put any functions that are referred to in the "callables" section of MultiplyImages.yaml"""
 
 import os
-import attrs
 
 
 def output_product_image_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/ants/n4_bias_field_correction_callables.py b/example-specs/task/nipype/ants/n4_bias_field_correction_callables.py
index edc5d4a0..7bd3daec 100644
--- a/example-specs/task/nipype/ants/n4_bias_field_correction_callables.py
+++ b/example-specs/task/nipype/ants/n4_bias_field_correction_callables.py
@@ -6,92 +6,23 @@
 import os.path as op
 
 
-def output_image_callable(output_dir, inputs, stdout, stderr):
+def bias_image_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["output_image"]
+    return outputs["bias_image"]
 
 
-def bias_image_callable(output_dir, inputs, stdout, stderr):
+def output_image_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["bias_image"]
+    return outputs["output_image"]
 
 
 iflogger = logging.getLogger("nipype.interface")
 
 
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
-# Original source at L58 of <nipype-install>/utils/filemanip.py
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
-# Original source at L888 of <nipype-install>/interfaces/base/core.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    return value
-
-
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
@@ -187,6 +118,26 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+# Original source at L540 of <nipype-install>/interfaces/ants/segmentation.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_ants__ANTSCommand___list_outputs()
+    if _out_bias_file:
+        outputs["bias_image"] = os.path.abspath(_out_bias_file)
+    return outputs
+
+
+# Original source at L888 of <nipype-install>/interfaces/base/core.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value
+
+
 # Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_ants__ANTSCommand___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
@@ -207,14 +158,63 @@ def nipype_interfaces_ants__ANTSCommand___list_outputs(
         return outputs
 
 
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
+# Original source at L58 of <nipype-install>/utils/filemanip.py
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
 
+    Parameters
+    ----------
+    fname : str
+        file or path name
 
-# Original source at L540 of <nipype-install>/interfaces/ants/segmentation.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = nipype_interfaces_ants__ANTSCommand___list_outputs()
-    if _out_bias_file:
-        outputs["bias_image"] = os.path.abspath(_out_bias_file)
-    return outputs
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
diff --git a/example-specs/task/nipype/ants/registration_callables.py b/example-specs/task/nipype/ants/registration_callables.py
index a223cc85..2f2420c3 100644
--- a/example-specs/task/nipype/ants/registration_callables.py
+++ b/example-specs/task/nipype/ants/registration_callables.py
@@ -1,98 +1,98 @@
 """Module to put any functions that are referred to in the "callables" section of Registration.yaml"""
 
-import os
 import attrs
+import os
 
 
-def forward_transforms_callable(output_dir, inputs, stdout, stderr):
+def composite_transform_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["forward_transforms"]
+    return outputs["composite_transform"]
 
 
-def reverse_forward_transforms_callable(output_dir, inputs, stdout, stderr):
+def elapsed_time_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["reverse_forward_transforms"]
+    return outputs["elapsed_time"]
 
 
-def reverse_transforms_callable(output_dir, inputs, stdout, stderr):
+def forward_invert_flags_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["reverse_transforms"]
+    return outputs["forward_invert_flags"]
 
 
-def forward_invert_flags_callable(output_dir, inputs, stdout, stderr):
+def forward_transforms_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["forward_invert_flags"]
+    return outputs["forward_transforms"]
 
 
-def reverse_forward_invert_flags_callable(output_dir, inputs, stdout, stderr):
+def inverse_composite_transform_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["reverse_forward_invert_flags"]
+    return outputs["inverse_composite_transform"]
 
 
-def reverse_invert_flags_callable(output_dir, inputs, stdout, stderr):
+def inverse_warped_image_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["reverse_invert_flags"]
+    return outputs["inverse_warped_image"]
 
 
-def composite_transform_callable(output_dir, inputs, stdout, stderr):
+def metric_value_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["composite_transform"]
+    return outputs["metric_value"]
 
 
-def inverse_composite_transform_callable(output_dir, inputs, stdout, stderr):
+def reverse_forward_invert_flags_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["inverse_composite_transform"]
+    return outputs["reverse_forward_invert_flags"]
 
 
-def warped_image_callable(output_dir, inputs, stdout, stderr):
+def reverse_forward_transforms_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["warped_image"]
+    return outputs["reverse_forward_transforms"]
 
 
-def inverse_warped_image_callable(output_dir, inputs, stdout, stderr):
+def reverse_invert_flags_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["inverse_warped_image"]
+    return outputs["reverse_invert_flags"]
 
 
-def save_state_callable(output_dir, inputs, stdout, stderr):
+def reverse_transforms_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["save_state"]
+    return outputs["reverse_transforms"]
 
 
-def metric_value_callable(output_dir, inputs, stdout, stderr):
+def save_state_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["metric_value"]
+    return outputs["save_state"]
 
 
-def elapsed_time_callable(output_dir, inputs, stdout, stderr):
+def warped_image_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["elapsed_time"]
+    return outputs["warped_image"]
 
 
 # Original source at L885 of <nipype-install>/interfaces/base/core.py
@@ -125,39 +125,6 @@ def _get_outputfilenames(
     return inv_output_filename
 
 
-# Original source at L1341 of <nipype-install>/interfaces/ants/registration.py
-def _output_filenames(
-    prefix,
-    count,
-    transform,
-    inverse=False,
-    inputs=None,
-    stdout=None,
-    stderr=None,
-    output_dir=None,
-):
-    low_dimensional_transform_map = {
-        "Rigid": "Rigid.mat",
-        "Affine": "Affine.mat",
-        "GenericAffine": "GenericAffine.mat",
-        "CompositeAffine": "Affine.mat",
-        "Similarity": "Similarity.mat",
-        "Translation": "Translation.mat",
-        "BSpline": "BSpline.txt",
-        "Initial": "DerivedInitialMovingTranslation.mat",
-    }
-    if transform in list(low_dimensional_transform_map.keys()):
-        suffix = low_dimensional_transform_map[transform]
-        inverse_mode = inverse
-    else:
-        inverse_mode = False  # These are not analytically invertable
-        if inverse:
-            suffix = "InverseWarp.nii.gz"
-        else:
-            suffix = "Warp.nii.gz"
-    return "%s%d%s" % (prefix, count, suffix), inverse_mode
-
-
 # Original source at L1363 of <nipype-install>/interfaces/ants/registration.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
@@ -316,3 +283,36 @@ def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs["reverse_forward_invert_flags"] = outputs["forward_invert_flags"][::-1]
 
     return outputs
+
+
+# Original source at L1341 of <nipype-install>/interfaces/ants/registration.py
+def _output_filenames(
+    prefix,
+    count,
+    transform,
+    inverse=False,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    low_dimensional_transform_map = {
+        "Rigid": "Rigid.mat",
+        "Affine": "Affine.mat",
+        "GenericAffine": "GenericAffine.mat",
+        "CompositeAffine": "Affine.mat",
+        "Similarity": "Similarity.mat",
+        "Translation": "Translation.mat",
+        "BSpline": "BSpline.txt",
+        "Initial": "DerivedInitialMovingTranslation.mat",
+    }
+    if transform in list(low_dimensional_transform_map.keys()):
+        suffix = low_dimensional_transform_map[transform]
+        inverse_mode = inverse
+    else:
+        inverse_mode = False  # These are not analytically invertable
+        if inverse:
+            suffix = "InverseWarp.nii.gz"
+        else:
+            suffix = "Warp.nii.gz"
+    return "%s%d%s" % (prefix, count, suffix), inverse_mode
diff --git a/example-specs/task/nipype/ants/registration_syn_quick_callables.py b/example-specs/task/nipype/ants/registration_syn_quick_callables.py
index ebd7de22..2fb5730e 100644
--- a/example-specs/task/nipype/ants/registration_syn_quick_callables.py
+++ b/example-specs/task/nipype/ants/registration_syn_quick_callables.py
@@ -1,42 +1,41 @@
 """Module to put any functions that are referred to in the "callables" section of RegistrationSynQuick.yaml"""
 
 import os
-import attrs
 
 
-def warped_image_callable(output_dir, inputs, stdout, stderr):
+def forward_warp_field_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["warped_image"]
+    return outputs["forward_warp_field"]
 
 
-def inverse_warped_image_callable(output_dir, inputs, stdout, stderr):
+def inverse_warp_field_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["inverse_warped_image"]
+    return outputs["inverse_warp_field"]
 
 
-def out_matrix_callable(output_dir, inputs, stdout, stderr):
+def inverse_warped_image_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_matrix"]
+    return outputs["inverse_warped_image"]
 
 
-def forward_warp_field_callable(output_dir, inputs, stdout, stderr):
+def out_matrix_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["forward_warp_field"]
+    return outputs["out_matrix"]
 
 
-def inverse_warp_field_callable(output_dir, inputs, stdout, stderr):
+def warped_image_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["inverse_warp_field"]
+    return outputs["warped_image"]
 
 
 # Original source at L885 of <nipype-install>/interfaces/base/core.py
diff --git a/example-specs/task/nipype/ants/resample_image_by_spacing_callables.py b/example-specs/task/nipype/ants/resample_image_by_spacing_callables.py
index 45c466bd..ae2b3216 100644
--- a/example-specs/task/nipype/ants/resample_image_by_spacing_callables.py
+++ b/example-specs/task/nipype/ants/resample_image_by_spacing_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of ResampleImageBySpacing.yaml"""
 
+import attrs
 import logging
 import os
 import os.path as op
-import attrs
 
 
 def output_image_callable(output_dir, inputs, stdout, stderr):
@@ -16,75 +16,6 @@ def output_image_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
-# Original source at L58 of <nipype-install>/utils/filemanip.py
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
-# Original source at L888 of <nipype-install>/interfaces/base/core.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    return value
-
-
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
@@ -201,3 +132,72 @@ def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
             if fname is not attrs.NOTHING:
                 outputs[out_name] = os.path.abspath(fname)
         return outputs
+
+
+# Original source at L888 of <nipype-install>/interfaces/base/core.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value
+
+
+# Original source at L58 of <nipype-install>/utils/filemanip.py
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
diff --git a/example-specs/task/nipype/ants/threshold_image_callables.py b/example-specs/task/nipype/ants/threshold_image_callables.py
index 6091ab63..fce8554c 100644
--- a/example-specs/task/nipype/ants/threshold_image_callables.py
+++ b/example-specs/task/nipype/ants/threshold_image_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of ThresholdImage.yaml"""
 
+import attrs
 import logging
 import os
 import os.path as op
-import attrs
 
 
 def output_image_callable(output_dir, inputs, stdout, stderr):
@@ -16,75 +16,6 @@ def output_image_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
-# Original source at L58 of <nipype-install>/utils/filemanip.py
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
-# Original source at L888 of <nipype-install>/interfaces/base/core.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    return value
-
-
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
@@ -201,3 +132,72 @@ def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
             if fname is not attrs.NOTHING:
                 outputs[out_name] = os.path.abspath(fname)
         return outputs
+
+
+# Original source at L888 of <nipype-install>/interfaces/base/core.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value
+
+
+# Original source at L58 of <nipype-install>/utils/filemanip.py
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
diff --git a/example-specs/task/nipype/ants/warp_image_multi_transform_callables.py b/example-specs/task/nipype/ants/warp_image_multi_transform_callables.py
index 1db58751..fd0ce2b9 100644
--- a/example-specs/task/nipype/ants/warp_image_multi_transform_callables.py
+++ b/example-specs/task/nipype/ants/warp_image_multi_transform_callables.py
@@ -1,8 +1,8 @@
 """Module to put any functions that are referred to in the "callables" section of WarpImageMultiTransform.yaml"""
 
+import attrs
 import os
 import os.path as op
-import attrs
 
 
 def output_image_default(inputs):
@@ -16,6 +16,32 @@ def output_image_callable(output_dir, inputs, stdout, stderr):
     return outputs["output_image"]
 
 
+# Original source at L262 of <nipype-install>/interfaces/ants/resampling.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "output_image":
+        _, name, ext = split_filename(os.path.abspath(inputs.input_image))
+        return "".join((name, inputs.out_postfix, ext))
+    return None
+
+
+# Original source at L295 of <nipype-install>/interfaces/ants/resampling.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    if inputs.output_image is not attrs.NOTHING:
+        outputs["output_image"] = os.path.abspath(inputs.output_image)
+    else:
+        outputs["output_image"] = os.path.abspath(
+            _gen_filename(
+                "output_image",
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+        )
+    return outputs
+
+
 # Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
@@ -65,29 +91,3 @@ def split_filename(fname):
         fname, ext = op.splitext(fname)
 
     return pth, fname, ext
-
-
-# Original source at L262 of <nipype-install>/interfaces/ants/resampling.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "output_image":
-        _, name, ext = split_filename(os.path.abspath(inputs.input_image))
-        return "".join((name, inputs.out_postfix, ext))
-    return None
-
-
-# Original source at L295 of <nipype-install>/interfaces/ants/resampling.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    if inputs.output_image is not attrs.NOTHING:
-        outputs["output_image"] = os.path.abspath(inputs.output_image)
-    else:
-        outputs["output_image"] = os.path.abspath(
-            _gen_filename(
-                "output_image",
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-        )
-    return outputs
diff --git a/example-specs/task/nipype/ants/warp_time_series_image_multi_transform_callables.py b/example-specs/task/nipype/ants/warp_time_series_image_multi_transform_callables.py
index 9812aa7a..3a7dcc98 100644
--- a/example-specs/task/nipype/ants/warp_time_series_image_multi_transform_callables.py
+++ b/example-specs/task/nipype/ants/warp_time_series_image_multi_transform_callables.py
@@ -2,7 +2,6 @@
 
 import os
 import os.path as op
-import attrs
 
 
 def output_image_callable(output_dir, inputs, stdout, stderr):
@@ -17,6 +16,16 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L137 of <nipype-install>/interfaces/ants/resampling.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    _, name, ext = split_filename(os.path.abspath(inputs.input_image))
+    outputs["output_image"] = os.path.join(
+        output_dir, "".join((name, inputs.out_postfix, ext))
+    )
+    return outputs
+
+
 # Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
@@ -66,13 +75,3 @@ def split_filename(fname):
         fname, ext = op.splitext(fname)
 
     return pth, fname, ext
-
-
-# Original source at L137 of <nipype-install>/interfaces/ants/resampling.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    _, name, ext = split_filename(os.path.abspath(inputs.input_image))
-    outputs["output_image"] = os.path.join(
-        output_dir, "".join((name, inputs.out_postfix, ext))
-    )
-    return outputs
diff --git a/example-specs/task/nipype/freesurfer/add_x_form_to_header_callables.py b/example-specs/task/nipype/freesurfer/add_x_form_to_header_callables.py
index 02026206..1f47bf94 100644
--- a/example-specs/task/nipype/freesurfer/add_x_form_to_header_callables.py
+++ b/example-specs/task/nipype/freesurfer/add_x_form_to_header_callables.py
@@ -1,7 +1,6 @@
 """Module to put any functions that are referred to in the "callables" section of AddXFormToHeader.yaml"""
 
 import os
-import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/freesurfer/aparc_2_aseg_callables.py b/example-specs/task/nipype/freesurfer/aparc_2_aseg_callables.py
index 05ce556b..05b9b778 100644
--- a/example-specs/task/nipype/freesurfer/aparc_2_aseg_callables.py
+++ b/example-specs/task/nipype/freesurfer/aparc_2_aseg_callables.py
@@ -1,7 +1,6 @@
 """Module to put any functions that are referred to in the "callables" section of Aparc2Aseg.yaml"""
 
 import os
-import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/freesurfer/apas_2_aseg_callables.py b/example-specs/task/nipype/freesurfer/apas_2_aseg_callables.py
index 5d5a90c5..90fabfb9 100644
--- a/example-specs/task/nipype/freesurfer/apas_2_aseg_callables.py
+++ b/example-specs/task/nipype/freesurfer/apas_2_aseg_callables.py
@@ -1,7 +1,6 @@
 """Module to put any functions that are referred to in the "callables" section of Apas2Aseg.yaml"""
 
 import os
-import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/freesurfer/apply_mask_callables.py b/example-specs/task/nipype/freesurfer/apply_mask_callables.py
index ca156541..3e91a313 100644
--- a/example-specs/task/nipype/freesurfer/apply_mask_callables.py
+++ b/example-specs/task/nipype/freesurfer/apply_mask_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of ApplyMask.yaml"""
 
+import attrs
 import logging
 import os
 import os.path as op
-import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -16,75 +16,6 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
-# Original source at L58 of <nipype-install>/utils/filemanip.py
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
-# Original source at L888 of <nipype-install>/interfaces/base/core.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    return value
-
-
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
@@ -201,3 +132,72 @@ def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
             if fname is not attrs.NOTHING:
                 outputs[out_name] = os.path.abspath(fname)
         return outputs
+
+
+# Original source at L888 of <nipype-install>/interfaces/base/core.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value
+
+
+# Original source at L58 of <nipype-install>/utils/filemanip.py
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
diff --git a/example-specs/task/nipype/freesurfer/apply_vol_transform_callables.py b/example-specs/task/nipype/freesurfer/apply_vol_transform_callables.py
index ac2693a2..349958c7 100644
--- a/example-specs/task/nipype/freesurfer/apply_vol_transform_callables.py
+++ b/example-specs/task/nipype/freesurfer/apply_vol_transform_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of ApplyVolTransform.yaml"""
 
+import attrs
 import os
 import os.path as op
 from pathlib import Path
-import attrs
 
 
 def transformed_file_default(inputs):
@@ -17,6 +17,39 @@ def transformed_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["transformed_file"]
 
 
+# Original source at L2088 of <nipype-install>/interfaces/freesurfer/preprocess.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "transformed_file":
+        return _get_outfile(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )
+    return None
+
+
+# Original source at L2070 of <nipype-install>/interfaces/freesurfer/preprocess.py
+def _get_outfile(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outfile = inputs.transformed_file
+    if outfile is attrs.NOTHING:
+        if inputs.inverse is True:
+            if inputs.fs_target is True:
+                src = "orig.mgz"
+            else:
+                src = inputs.target_file
+        else:
+            src = inputs.source_file
+        outfile = fname_presuffix(src, newpath=output_dir, suffix="_warped")
+    return outfile
+
+
+# Original source at L2083 of <nipype-install>/interfaces/freesurfer/preprocess.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["transformed_file"] = os.path.abspath(
+        _get_outfile(inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir)
+    )
+    return outputs
+
+
 # Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
@@ -109,36 +142,3 @@ def split_filename(fname):
         fname, ext = op.splitext(fname)
 
     return pth, fname, ext
-
-
-# Original source at L2070 of <nipype-install>/interfaces/freesurfer/preprocess.py
-def _get_outfile(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outfile = inputs.transformed_file
-    if outfile is attrs.NOTHING:
-        if inputs.inverse is True:
-            if inputs.fs_target is True:
-                src = "orig.mgz"
-            else:
-                src = inputs.target_file
-        else:
-            src = inputs.source_file
-        outfile = fname_presuffix(src, newpath=output_dir, suffix="_warped")
-    return outfile
-
-
-# Original source at L2088 of <nipype-install>/interfaces/freesurfer/preprocess.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "transformed_file":
-        return _get_outfile(
-            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-        )
-    return None
-
-
-# Original source at L2083 of <nipype-install>/interfaces/freesurfer/preprocess.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    outputs["transformed_file"] = os.path.abspath(
-        _get_outfile(inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir)
-    )
-    return outputs
diff --git a/example-specs/task/nipype/freesurfer/bb_register_callables.py b/example-specs/task/nipype/freesurfer/bb_register_callables.py
index dd924803..d4ffd654 100644
--- a/example-specs/task/nipype/freesurfer/bb_register_callables.py
+++ b/example-specs/task/nipype/freesurfer/bb_register_callables.py
@@ -1,47 +1,47 @@
 """Module to put any functions that are referred to in the "callables" section of BBRegister.yaml"""
 
+import attrs
 import os.path as op
 from pathlib import Path
-import attrs
 
 
 def out_reg_file_default(inputs):
     return _gen_filename("out_reg_file", inputs=inputs)
 
 
-def out_reg_file_callable(output_dir, inputs, stdout, stderr):
+def init_cost_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_reg_file"]
+    return outputs["init_cost_file"]
 
 
-def out_fsl_file_callable(output_dir, inputs, stdout, stderr):
+def min_cost_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_fsl_file"]
+    return outputs["min_cost_file"]
 
 
-def out_lta_file_callable(output_dir, inputs, stdout, stderr):
+def out_fsl_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_lta_file"]
+    return outputs["out_fsl_file"]
 
 
-def min_cost_file_callable(output_dir, inputs, stdout, stderr):
+def out_lta_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["min_cost_file"]
+    return outputs["out_lta_file"]
 
 
-def init_cost_file_callable(output_dir, inputs, stdout, stderr):
+def out_reg_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["init_cost_file"]
+    return outputs["out_reg_file"]
 
 
 def registered_file_callable(output_dir, inputs, stdout, stderr):
@@ -51,6 +51,66 @@ def registered_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["registered_file"]
 
 
+# Original source at L1894 of <nipype-install>/interfaces/freesurfer/preprocess.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_reg_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )[name]
+    return None
+
+
+# Original source at L1835 of <nipype-install>/interfaces/freesurfer/preprocess.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    _in = inputs
+
+    if _in.out_reg_file is not attrs.NOTHING:
+        outputs["out_reg_file"] = op.abspath(_in.out_reg_file)
+    elif _in.source_file:
+        suffix = "_bbreg_%s.dat" % _in.subject_id
+        outputs["out_reg_file"] = fname_presuffix(
+            _in.source_file, suffix=suffix, use_ext=False
+        )
+
+    if _in.registered_file is not attrs.NOTHING:
+        if isinstance(_in.registered_file, bool):
+            outputs["registered_file"] = fname_presuffix(
+                _in.source_file, suffix="_bbreg"
+            )
+        else:
+            outputs["registered_file"] = op.abspath(_in.registered_file)
+
+    if _in.out_lta_file is not attrs.NOTHING:
+        if isinstance(_in.out_lta_file, bool):
+            suffix = "_bbreg_%s.lta" % _in.subject_id
+            out_lta_file = fname_presuffix(
+                _in.source_file, suffix=suffix, use_ext=False
+            )
+            outputs["out_lta_file"] = out_lta_file
+        else:
+            outputs["out_lta_file"] = op.abspath(_in.out_lta_file)
+
+    if _in.out_fsl_file is not attrs.NOTHING:
+        if isinstance(_in.out_fsl_file, bool):
+            suffix = "_bbreg_%s.mat" % _in.subject_id
+            out_fsl_file = fname_presuffix(
+                _in.source_file, suffix=suffix, use_ext=False
+            )
+            outputs["out_fsl_file"] = out_fsl_file
+        else:
+            outputs["out_fsl_file"] = op.abspath(_in.out_fsl_file)
+
+    if _in.init_cost_file is not attrs.NOTHING:
+        if isinstance(_in.out_fsl_file, bool):
+            outputs["init_cost_file"] = outputs["out_reg_file"] + ".initcost"
+        else:
+            outputs["init_cost_file"] = op.abspath(_in.init_cost_file)
+
+    outputs["min_cost_file"] = outputs["out_reg_file"] + ".mincost"
+    return outputs
+
+
 # Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
@@ -143,63 +203,3 @@ def split_filename(fname):
         fname, ext = op.splitext(fname)
 
     return pth, fname, ext
-
-
-# Original source at L1894 of <nipype-install>/interfaces/freesurfer/preprocess.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "out_reg_file":
-        return _list_outputs(
-            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-        )[name]
-    return None
-
-
-# Original source at L1835 of <nipype-install>/interfaces/freesurfer/preprocess.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    _in = inputs
-
-    if _in.out_reg_file is not attrs.NOTHING:
-        outputs["out_reg_file"] = op.abspath(_in.out_reg_file)
-    elif _in.source_file:
-        suffix = "_bbreg_%s.dat" % _in.subject_id
-        outputs["out_reg_file"] = fname_presuffix(
-            _in.source_file, suffix=suffix, use_ext=False
-        )
-
-    if _in.registered_file is not attrs.NOTHING:
-        if isinstance(_in.registered_file, bool):
-            outputs["registered_file"] = fname_presuffix(
-                _in.source_file, suffix="_bbreg"
-            )
-        else:
-            outputs["registered_file"] = op.abspath(_in.registered_file)
-
-    if _in.out_lta_file is not attrs.NOTHING:
-        if isinstance(_in.out_lta_file, bool):
-            suffix = "_bbreg_%s.lta" % _in.subject_id
-            out_lta_file = fname_presuffix(
-                _in.source_file, suffix=suffix, use_ext=False
-            )
-            outputs["out_lta_file"] = out_lta_file
-        else:
-            outputs["out_lta_file"] = op.abspath(_in.out_lta_file)
-
-    if _in.out_fsl_file is not attrs.NOTHING:
-        if isinstance(_in.out_fsl_file, bool):
-            suffix = "_bbreg_%s.mat" % _in.subject_id
-            out_fsl_file = fname_presuffix(
-                _in.source_file, suffix=suffix, use_ext=False
-            )
-            outputs["out_fsl_file"] = out_fsl_file
-        else:
-            outputs["out_fsl_file"] = op.abspath(_in.out_fsl_file)
-
-    if _in.init_cost_file is not attrs.NOTHING:
-        if isinstance(_in.out_fsl_file, bool):
-            outputs["init_cost_file"] = outputs["out_reg_file"] + ".initcost"
-        else:
-            outputs["init_cost_file"] = op.abspath(_in.init_cost_file)
-
-    outputs["min_cost_file"] = outputs["out_reg_file"] + ".mincost"
-    return outputs
diff --git a/example-specs/task/nipype/freesurfer/binarize_callables.py b/example-specs/task/nipype/freesurfer/binarize_callables.py
index 8d948ca1..9c6060c1 100644
--- a/example-specs/task/nipype/freesurfer/binarize_callables.py
+++ b/example-specs/task/nipype/freesurfer/binarize_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of Binarize.yaml"""
 
+import attrs
 import os
 import os.path as op
 from pathlib import Path
-import attrs
 
 
 def binary_file_default(inputs):
@@ -24,6 +24,47 @@ def count_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["count_file"]
 
 
+# Original source at L702 of <nipype-install>/interfaces/freesurfer/model.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "binary_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )[name]
+    return None
+
+
+# Original source at L661 of <nipype-install>/interfaces/freesurfer/model.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outfile = inputs.binary_file
+    if outfile is attrs.NOTHING:
+        if inputs.out_type is not attrs.NOTHING:
+            outfile = fname_presuffix(
+                inputs.in_file,
+                newpath=output_dir,
+                suffix=".".join(("_thresh", inputs.out_type)),
+                use_ext=False,
+            )
+        else:
+            outfile = fname_presuffix(
+                inputs.in_file, newpath=output_dir, suffix="_thresh"
+            )
+    outputs["binary_file"] = os.path.abspath(outfile)
+    value = inputs.count_file
+    if value is not attrs.NOTHING:
+        if isinstance(value, bool):
+            if value:
+                outputs["count_file"] = fname_presuffix(
+                    inputs.in_file,
+                    suffix="_count.txt",
+                    newpath=output_dir,
+                    use_ext=False,
+                )
+        else:
+            outputs["count_file"] = value
+    return outputs
+
+
 # Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
@@ -116,44 +157,3 @@ def split_filename(fname):
         fname, ext = op.splitext(fname)
 
     return pth, fname, ext
-
-
-# Original source at L702 of <nipype-install>/interfaces/freesurfer/model.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "binary_file":
-        return _list_outputs(
-            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-        )[name]
-    return None
-
-
-# Original source at L661 of <nipype-install>/interfaces/freesurfer/model.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    outfile = inputs.binary_file
-    if outfile is attrs.NOTHING:
-        if inputs.out_type is not attrs.NOTHING:
-            outfile = fname_presuffix(
-                inputs.in_file,
-                newpath=output_dir,
-                suffix=".".join(("_thresh", inputs.out_type)),
-                use_ext=False,
-            )
-        else:
-            outfile = fname_presuffix(
-                inputs.in_file, newpath=output_dir, suffix="_thresh"
-            )
-    outputs["binary_file"] = os.path.abspath(outfile)
-    value = inputs.count_file
-    if value is not attrs.NOTHING:
-        if isinstance(value, bool):
-            if value:
-                outputs["count_file"] = fname_presuffix(
-                    inputs.in_file,
-                    suffix="_count.txt",
-                    newpath=output_dir,
-                    use_ext=False,
-                )
-        else:
-            outputs["count_file"] = value
-    return outputs
diff --git a/example-specs/task/nipype/freesurfer/ca_label_callables.py b/example-specs/task/nipype/freesurfer/ca_label_callables.py
index 74c5feb4..e89f3bf5 100644
--- a/example-specs/task/nipype/freesurfer/ca_label_callables.py
+++ b/example-specs/task/nipype/freesurfer/ca_label_callables.py
@@ -1,7 +1,6 @@
 """Module to put any functions that are referred to in the "callables" section of CALabel.yaml"""
 
 import os
-import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/freesurfer/ca_normalize_callables.py b/example-specs/task/nipype/freesurfer/ca_normalize_callables.py
index 507a3bab..a366fdf9 100644
--- a/example-specs/task/nipype/freesurfer/ca_normalize_callables.py
+++ b/example-specs/task/nipype/freesurfer/ca_normalize_callables.py
@@ -1,21 +1,20 @@
 """Module to put any functions that are referred to in the "callables" section of CANormalize.yaml"""
 
 import os
-import attrs
 
 
-def out_file_callable(output_dir, inputs, stdout, stderr):
+def control_points_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_file"]
+    return outputs["control_points"]
 
 
-def control_points_callable(output_dir, inputs, stdout, stderr):
+def out_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["control_points"]
+    return outputs["out_file"]
 
 
 # Original source at L885 of <nipype-install>/interfaces/base/core.py
diff --git a/example-specs/task/nipype/freesurfer/ca_register_callables.py b/example-specs/task/nipype/freesurfer/ca_register_callables.py
index ee160eb9..0269a50d 100644
--- a/example-specs/task/nipype/freesurfer/ca_register_callables.py
+++ b/example-specs/task/nipype/freesurfer/ca_register_callables.py
@@ -1,7 +1,6 @@
 """Module to put any functions that are referred to in the "callables" section of CARegister.yaml"""
 
 import os
-import attrs
 
 
 def out_file_default(inputs):
diff --git a/example-specs/task/nipype/freesurfer/check_talairach_alignment_callables.py b/example-specs/task/nipype/freesurfer/check_talairach_alignment_callables.py
index 03f47ee1..23c6afd3 100644
--- a/example-specs/task/nipype/freesurfer/check_talairach_alignment_callables.py
+++ b/example-specs/task/nipype/freesurfer/check_talairach_alignment_callables.py
@@ -1,7 +1,5 @@
 """Module to put any functions that are referred to in the "callables" section of CheckTalairachAlignment.yaml"""
 
-import attrs
-
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
diff --git a/example-specs/task/nipype/freesurfer/concatenate_callables.py b/example-specs/task/nipype/freesurfer/concatenate_callables.py
index 6b46c027..a70f8611 100644
--- a/example-specs/task/nipype/freesurfer/concatenate_callables.py
+++ b/example-specs/task/nipype/freesurfer/concatenate_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of Concatenate.yaml"""
 
-import os
 import attrs
+import os
 
 
 def concatenated_file_default(inputs):
diff --git a/example-specs/task/nipype/freesurfer/concatenate_lta_callables.py b/example-specs/task/nipype/freesurfer/concatenate_lta_callables.py
index ec10e218..8bd9f8fd 100644
--- a/example-specs/task/nipype/freesurfer/concatenate_lta_callables.py
+++ b/example-specs/task/nipype/freesurfer/concatenate_lta_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of ConcatenateLTA.yaml"""
 
+import attrs
 import logging
 import os
 import os.path as op
-import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -16,75 +16,6 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
-# Original source at L58 of <nipype-install>/utils/filemanip.py
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
-# Original source at L888 of <nipype-install>/interfaces/base/core.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    return value
-
-
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
@@ -201,3 +132,72 @@ def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
             if fname is not attrs.NOTHING:
                 outputs[out_name] = os.path.abspath(fname)
         return outputs
+
+
+# Original source at L888 of <nipype-install>/interfaces/base/core.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value
+
+
+# Original source at L58 of <nipype-install>/utils/filemanip.py
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
diff --git a/example-specs/task/nipype/freesurfer/contrast_callables.py b/example-specs/task/nipype/freesurfer/contrast_callables.py
index 41f6216c..356f0193 100644
--- a/example-specs/task/nipype/freesurfer/contrast_callables.py
+++ b/example-specs/task/nipype/freesurfer/contrast_callables.py
@@ -1,7 +1,6 @@
 """Module to put any functions that are referred to in the "callables" section of Contrast.yaml"""
 
 import os
-import attrs
 
 
 def out_contrast_callable(output_dir, inputs, stdout, stderr):
@@ -11,18 +10,18 @@ def out_contrast_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_contrast"]
 
 
-def out_stats_callable(output_dir, inputs, stdout, stderr):
+def out_log_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_stats"]
+    return outputs["out_log"]
 
 
-def out_log_callable(output_dir, inputs, stdout, stderr):
+def out_stats_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_log"]
+    return outputs["out_stats"]
 
 
 # Original source at L885 of <nipype-install>/interfaces/base/core.py
diff --git a/example-specs/task/nipype/freesurfer/curvature_callables.py b/example-specs/task/nipype/freesurfer/curvature_callables.py
index 2ca204f7..82da1525 100644
--- a/example-specs/task/nipype/freesurfer/curvature_callables.py
+++ b/example-specs/task/nipype/freesurfer/curvature_callables.py
@@ -1,21 +1,20 @@
 """Module to put any functions that are referred to in the "callables" section of Curvature.yaml"""
 
 import os
-import attrs
 
 
-def out_mean_callable(output_dir, inputs, stdout, stderr):
+def out_gauss_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_mean"]
+    return outputs["out_gauss"]
 
 
-def out_gauss_callable(output_dir, inputs, stdout, stderr):
+def out_mean_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_gauss"]
+    return outputs["out_mean"]
 
 
 # Original source at L885 of <nipype-install>/interfaces/base/core.py
diff --git a/example-specs/task/nipype/freesurfer/curvature_stats_callables.py b/example-specs/task/nipype/freesurfer/curvature_stats_callables.py
index 12f81fb8..36f74b26 100644
--- a/example-specs/task/nipype/freesurfer/curvature_stats_callables.py
+++ b/example-specs/task/nipype/freesurfer/curvature_stats_callables.py
@@ -1,7 +1,6 @@
 """Module to put any functions that are referred to in the "callables" section of CurvatureStats.yaml"""
 
 import os
-import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/freesurfer/dicom_convert_callables.py b/example-specs/task/nipype/freesurfer/dicom_convert_callables.py
index 57ab2b1f..23e1672a 100644
--- a/example-specs/task/nipype/freesurfer/dicom_convert_callables.py
+++ b/example-specs/task/nipype/freesurfer/dicom_convert_callables.py
@@ -1,80 +1,12 @@
 """Module to put any functions that are referred to in the "callables" section of DICOMConvert.yaml"""
 
+import attrs
 import logging
 import os
 import os.path as op
-import attrs
-
-iflogger = logging.getLogger("nipype.interface")
-
-
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
-# Original source at L58 of <nipype-install>/utils/filemanip.py
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
 
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
 
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
-# Original source at L888 of <nipype-install>/interfaces/base/core.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    return value
+iflogger = logging.getLogger("nipype.interface")
 
 
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
@@ -193,3 +125,72 @@ def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
             if fname is not attrs.NOTHING:
                 outputs[out_name] = os.path.abspath(fname)
         return outputs
+
+
+# Original source at L888 of <nipype-install>/interfaces/base/core.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value
+
+
+# Original source at L58 of <nipype-install>/utils/filemanip.py
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
diff --git a/example-specs/task/nipype/freesurfer/edit_w_mwith_aseg_callables.py b/example-specs/task/nipype/freesurfer/edit_w_mwith_aseg_callables.py
index 9305cbec..926b9c41 100644
--- a/example-specs/task/nipype/freesurfer/edit_w_mwith_aseg_callables.py
+++ b/example-specs/task/nipype/freesurfer/edit_w_mwith_aseg_callables.py
@@ -1,7 +1,6 @@
 """Module to put any functions that are referred to in the "callables" section of EditWMwithAseg.yaml"""
 
 import os
-import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/freesurfer/em_register_callables.py b/example-specs/task/nipype/freesurfer/em_register_callables.py
index ccc663ec..906f2014 100644
--- a/example-specs/task/nipype/freesurfer/em_register_callables.py
+++ b/example-specs/task/nipype/freesurfer/em_register_callables.py
@@ -1,7 +1,6 @@
 """Module to put any functions that are referred to in the "callables" section of EMRegister.yaml"""
 
 import os
-import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/freesurfer/euler_number_callables.py b/example-specs/task/nipype/freesurfer/euler_number_callables.py
index b1d03b2b..42f2d8c7 100644
--- a/example-specs/task/nipype/freesurfer/euler_number_callables.py
+++ b/example-specs/task/nipype/freesurfer/euler_number_callables.py
@@ -1,20 +1,18 @@
 """Module to put any functions that are referred to in the "callables" section of EulerNumber.yaml"""
 
-import attrs
 
-
-def euler_callable(output_dir, inputs, stdout, stderr):
+def defects_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["euler"]
+    return outputs["defects"]
 
 
-def defects_callable(output_dir, inputs, stdout, stderr):
+def euler_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["defects"]
+    return outputs["euler"]
 
 
 # Original source at L885 of <nipype-install>/interfaces/base/core.py
diff --git a/example-specs/task/nipype/freesurfer/extract_main_component_callables.py b/example-specs/task/nipype/freesurfer/extract_main_component_callables.py
index ee6f1fc7..67d5e246 100644
--- a/example-specs/task/nipype/freesurfer/extract_main_component_callables.py
+++ b/example-specs/task/nipype/freesurfer/extract_main_component_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of ExtractMainComponent.yaml"""
 
+import attrs
 import logging
 import os
 import os.path as op
-import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -16,75 +16,6 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
-# Original source at L58 of <nipype-install>/utils/filemanip.py
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
-# Original source at L888 of <nipype-install>/interfaces/base/core.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    return value
-
-
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
@@ -201,3 +132,72 @@ def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
             if fname is not attrs.NOTHING:
                 outputs[out_name] = os.path.abspath(fname)
         return outputs
+
+
+# Original source at L888 of <nipype-install>/interfaces/base/core.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value
+
+
+# Original source at L58 of <nipype-install>/utils/filemanip.py
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
diff --git a/example-specs/task/nipype/freesurfer/fit_ms_params_callables.py b/example-specs/task/nipype/freesurfer/fit_ms_params_callables.py
index ed77741f..f63be4e3 100644
--- a/example-specs/task/nipype/freesurfer/fit_ms_params_callables.py
+++ b/example-specs/task/nipype/freesurfer/fit_ms_params_callables.py
@@ -1,25 +1,25 @@
 """Module to put any functions that are referred to in the "callables" section of FitMSParams.yaml"""
 
-import os
 import attrs
+import os
 
 
 def out_dir_default(inputs):
     return _gen_filename("out_dir", inputs=inputs)
 
 
-def t1_image_callable(output_dir, inputs, stdout, stderr):
+def pd_image_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["t1_image"]
+    return outputs["pd_image"]
 
 
-def pd_image_callable(output_dir, inputs, stdout, stderr):
+def t1_image_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["pd_image"]
+    return outputs["t1_image"]
 
 
 def t2star_image_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/freesurfer/fix_topology_callables.py b/example-specs/task/nipype/freesurfer/fix_topology_callables.py
index b0a85981..007e915d 100644
--- a/example-specs/task/nipype/freesurfer/fix_topology_callables.py
+++ b/example-specs/task/nipype/freesurfer/fix_topology_callables.py
@@ -1,7 +1,6 @@
 """Module to put any functions that are referred to in the "callables" section of FixTopology.yaml"""
 
 import os
-import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/freesurfer/fuse_segmentations_callables.py b/example-specs/task/nipype/freesurfer/fuse_segmentations_callables.py
index 68f3822a..f6af6be3 100644
--- a/example-specs/task/nipype/freesurfer/fuse_segmentations_callables.py
+++ b/example-specs/task/nipype/freesurfer/fuse_segmentations_callables.py
@@ -1,7 +1,6 @@
 """Module to put any functions that are referred to in the "callables" section of FuseSegmentations.yaml"""
 
 import os
-import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/freesurfer/glm_fit_callables.py b/example-specs/task/nipype/freesurfer/glm_fit_callables.py
index 30fe5e43..0aa47762 100644
--- a/example-specs/task/nipype/freesurfer/glm_fit_callables.py
+++ b/example-specs/task/nipype/freesurfer/glm_fit_callables.py
@@ -1,40 +1,40 @@
 """Module to put any functions that are referred to in the "callables" section of GLMFit.yaml"""
 
+import attrs
 import os
 import os.path as op
-import attrs
 
 
 def glm_dir_default(inputs):
     return _gen_filename("glm_dir", inputs=inputs)
 
 
-def glm_dir_callable(output_dir, inputs, stdout, stderr):
+def beta_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["glm_dir"]
+    return outputs["beta_file"]
 
 
-def beta_file_callable(output_dir, inputs, stdout, stderr):
+def bp_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["beta_file"]
+    return outputs["bp_file"]
 
 
-def error_file_callable(output_dir, inputs, stdout, stderr):
+def dof_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["error_file"]
+    return outputs["dof_file"]
 
 
-def error_var_file_callable(output_dir, inputs, stdout, stderr):
+def error_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["error_var_file"]
+    return outputs["error_file"]
 
 
 def error_stddev_file_callable(output_dir, inputs, stdout, stderr):
@@ -44,6 +44,13 @@ def error_stddev_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["error_stddev_file"]
 
 
+def error_var_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["error_var_file"]
+
+
 def estimate_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
@@ -51,25 +58,25 @@ def estimate_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["estimate_file"]
 
 
-def mask_file_callable(output_dir, inputs, stdout, stderr):
+def frame_eigenvectors_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["mask_file"]
+    return outputs["frame_eigenvectors"]
 
 
-def fwhm_file_callable(output_dir, inputs, stdout, stderr):
+def ftest_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["fwhm_file"]
+    return outputs["ftest_file"]
 
 
-def dof_file_callable(output_dir, inputs, stdout, stderr):
+def fwhm_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["dof_file"]
+    return outputs["fwhm_file"]
 
 
 def gamma_file_callable(output_dir, inputs, stdout, stderr):
@@ -86,32 +93,32 @@ def gamma_var_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["gamma_var_file"]
 
 
-def sig_file_callable(output_dir, inputs, stdout, stderr):
+def glm_dir_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["sig_file"]
+    return outputs["glm_dir"]
 
 
-def ftest_file_callable(output_dir, inputs, stdout, stderr):
+def k2p_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["ftest_file"]
+    return outputs["k2p_file"]
 
 
-def spatial_eigenvectors_callable(output_dir, inputs, stdout, stderr):
+def mask_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["spatial_eigenvectors"]
+    return outputs["mask_file"]
 
 
-def frame_eigenvectors_callable(output_dir, inputs, stdout, stderr):
+def sig_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["frame_eigenvectors"]
+    return outputs["sig_file"]
 
 
 def singular_values_callable(output_dir, inputs, stdout, stderr):
@@ -121,76 +128,18 @@ def singular_values_callable(output_dir, inputs, stdout, stderr):
     return outputs["singular_values"]
 
 
-def svd_stats_file_callable(output_dir, inputs, stdout, stderr):
-    outputs = _list_outputs(
-        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
-    )
-    return outputs["svd_stats_file"]
-
-
-def k2p_file_callable(output_dir, inputs, stdout, stderr):
+def spatial_eigenvectors_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["k2p_file"]
+    return outputs["spatial_eigenvectors"]
 
 
-def bp_file_callable(output_dir, inputs, stdout, stderr):
+def svd_stats_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["bp_file"]
-
-
-# Original source at L58 of <nipype-install>/utils/filemanip.py
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
+    return outputs["svd_stats_file"]
 
 
 # Original source at L560 of <nipype-install>/interfaces/freesurfer/model.py
@@ -262,3 +211,54 @@ def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
         outputs["svd_stats_file"] = os.path.join(pcadir, "stats.dat")
 
     return outputs
+
+
+# Original source at L58 of <nipype-install>/utils/filemanip.py
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
diff --git a/example-specs/task/nipype/freesurfer/gtm_seg_callables.py b/example-specs/task/nipype/freesurfer/gtm_seg_callables.py
index fd6b31c1..eb9e5003 100644
--- a/example-specs/task/nipype/freesurfer/gtm_seg_callables.py
+++ b/example-specs/task/nipype/freesurfer/gtm_seg_callables.py
@@ -1,7 +1,6 @@
 """Module to put any functions that are referred to in the "callables" section of GTMSeg.yaml"""
 
 import os
-import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/freesurfer/gtmpvc_callables.py b/example-specs/task/nipype/freesurfer/gtmpvc_callables.py
index ed31cb9e..2e12a779 100644
--- a/example-specs/task/nipype/freesurfer/gtmpvc_callables.py
+++ b/example-specs/task/nipype/freesurfer/gtmpvc_callables.py
@@ -1,144 +1,144 @@
 """Module to put any functions that are referred to in the "callables" section of GTMPVC.yaml"""
 
-import os
 import attrs
+import os
 
 
 def pvc_dir_default(inputs):
     return _gen_filename("pvc_dir", inputs=inputs)
 
 
-def pvc_dir_callable(output_dir, inputs, stdout, stderr):
+def gtm_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["pvc_dir"]
+    return outputs["gtm_file"]
 
 
-def ref_file_callable(output_dir, inputs, stdout, stderr):
+def gtm_stats_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["ref_file"]
+    return outputs["gtm_stats"]
 
 
-def hb_nifti_callable(output_dir, inputs, stdout, stderr):
+def hb_dat_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["hb_nifti"]
+    return outputs["hb_dat"]
 
 
-def hb_dat_callable(output_dir, inputs, stdout, stderr):
+def hb_nifti_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["hb_dat"]
+    return outputs["hb_nifti"]
 
 
-def nopvc_file_callable(output_dir, inputs, stdout, stderr):
+def input_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["nopvc_file"]
+    return outputs["input_file"]
 
 
-def gtm_file_callable(output_dir, inputs, stdout, stderr):
+def mgx_ctxgm_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["gtm_file"]
+    return outputs["mgx_ctxgm"]
 
 
-def gtm_stats_callable(output_dir, inputs, stdout, stderr):
+def mgx_gm_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["gtm_stats"]
+    return outputs["mgx_gm"]
 
 
-def input_file_callable(output_dir, inputs, stdout, stderr):
+def mgx_subctxgm_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["input_file"]
+    return outputs["mgx_subctxgm"]
 
 
-def reg_pet2anat_callable(output_dir, inputs, stdout, stderr):
+def nopvc_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["reg_pet2anat"]
+    return outputs["nopvc_file"]
 
 
-def reg_anat2pet_callable(output_dir, inputs, stdout, stderr):
+def opt_params_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["reg_anat2pet"]
+    return outputs["opt_params"]
 
 
-def reg_rbvpet2anat_callable(output_dir, inputs, stdout, stderr):
+def pvc_dir_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["reg_rbvpet2anat"]
+    return outputs["pvc_dir"]
 
 
-def reg_anat2rbvpet_callable(output_dir, inputs, stdout, stderr):
+def rbv_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["reg_anat2rbvpet"]
+    return outputs["rbv"]
 
 
-def mgx_ctxgm_callable(output_dir, inputs, stdout, stderr):
+def ref_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["mgx_ctxgm"]
+    return outputs["ref_file"]
 
 
-def mgx_subctxgm_callable(output_dir, inputs, stdout, stderr):
+def reg_anat2pet_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["mgx_subctxgm"]
+    return outputs["reg_anat2pet"]
 
 
-def mgx_gm_callable(output_dir, inputs, stdout, stderr):
+def reg_anat2rbvpet_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["mgx_gm"]
+    return outputs["reg_anat2rbvpet"]
 
 
-def rbv_callable(output_dir, inputs, stdout, stderr):
+def reg_pet2anat_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["rbv"]
+    return outputs["reg_pet2anat"]
 
 
-def opt_params_callable(output_dir, inputs, stdout, stderr):
+def reg_rbvpet2anat_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["opt_params"]
+    return outputs["reg_rbvpet2anat"]
 
 
-def yhat0_callable(output_dir, inputs, stdout, stderr):
+def yhat_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["yhat0"]
+    return outputs["yhat"]
 
 
-def yhat_callable(output_dir, inputs, stdout, stderr):
+def yhat0_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["yhat"]
+    return outputs["yhat0"]
 
 
 def yhat_full_fov_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/freesurfer/image_info_callables.py b/example-specs/task/nipype/freesurfer/image_info_callables.py
index d07673d9..999d6d47 100644
--- a/example-specs/task/nipype/freesurfer/image_info_callables.py
+++ b/example-specs/task/nipype/freesurfer/image_info_callables.py
@@ -1,160 +1,91 @@
 """Module to put any functions that are referred to in the "callables" section of ImageInfo.yaml"""
 
+import attrs
 import logging
 import os
 import os.path as op
-import attrs
 
 
-def info_callable(output_dir, inputs, stdout, stderr):
+def TE_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["info"]
+    return outputs["TE"]
 
 
-def out_file_callable(output_dir, inputs, stdout, stderr):
+def TI_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_file"]
+    return outputs["TI"]
 
 
-def data_type_callable(output_dir, inputs, stdout, stderr):
+def TR_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["data_type"]
+    return outputs["TR"]
 
 
-def file_format_callable(output_dir, inputs, stdout, stderr):
+def data_type_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["file_format"]
+    return outputs["data_type"]
 
 
-def TE_callable(output_dir, inputs, stdout, stderr):
+def dimensions_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["TE"]
+    return outputs["dimensions"]
 
 
-def TR_callable(output_dir, inputs, stdout, stderr):
+def file_format_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["TR"]
+    return outputs["file_format"]
 
 
-def TI_callable(output_dir, inputs, stdout, stderr):
+def info_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["TI"]
+    return outputs["info"]
 
 
-def dimensions_callable(output_dir, inputs, stdout, stderr):
+def orientation_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["dimensions"]
+    return outputs["orientation"]
 
 
-def vox_sizes_callable(output_dir, inputs, stdout, stderr):
+def out_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["vox_sizes"]
+    return outputs["out_file"]
 
 
-def orientation_callable(output_dir, inputs, stdout, stderr):
+def ph_enc_dir_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["orientation"]
+    return outputs["ph_enc_dir"]
 
 
-def ph_enc_dir_callable(output_dir, inputs, stdout, stderr):
+def vox_sizes_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["ph_enc_dir"]
+    return outputs["vox_sizes"]
 
 
 iflogger = logging.getLogger("nipype.interface")
 
 
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
-# Original source at L58 of <nipype-install>/utils/filemanip.py
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
-# Original source at L888 of <nipype-install>/interfaces/base/core.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    return value
-
-
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
@@ -271,3 +202,72 @@ def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
             if fname is not attrs.NOTHING:
                 outputs[out_name] = os.path.abspath(fname)
         return outputs
+
+
+# Original source at L888 of <nipype-install>/interfaces/base/core.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value
+
+
+# Original source at L58 of <nipype-install>/utils/filemanip.py
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
diff --git a/example-specs/task/nipype/freesurfer/jacobian_callables.py b/example-specs/task/nipype/freesurfer/jacobian_callables.py
index 181490d5..46252c09 100644
--- a/example-specs/task/nipype/freesurfer/jacobian_callables.py
+++ b/example-specs/task/nipype/freesurfer/jacobian_callables.py
@@ -1,7 +1,6 @@
 """Module to put any functions that are referred to in the "callables" section of Jacobian.yaml"""
 
 import os
-import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/freesurfer/label_2_annot_callables.py b/example-specs/task/nipype/freesurfer/label_2_annot_callables.py
index bbab02c1..0452e769 100644
--- a/example-specs/task/nipype/freesurfer/label_2_annot_callables.py
+++ b/example-specs/task/nipype/freesurfer/label_2_annot_callables.py
@@ -1,7 +1,6 @@
 """Module to put any functions that are referred to in the "callables" section of Label2Annot.yaml"""
 
 import os
-import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/freesurfer/label_2_label_callables.py b/example-specs/task/nipype/freesurfer/label_2_label_callables.py
index 9fc48fbc..bd3b3167 100644
--- a/example-specs/task/nipype/freesurfer/label_2_label_callables.py
+++ b/example-specs/task/nipype/freesurfer/label_2_label_callables.py
@@ -1,7 +1,6 @@
 """Module to put any functions that are referred to in the "callables" section of Label2Label.yaml"""
 
 import os
-import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/freesurfer/label_2_vol_callables.py b/example-specs/task/nipype/freesurfer/label_2_vol_callables.py
index 904dd416..d107a0ab 100644
--- a/example-specs/task/nipype/freesurfer/label_2_vol_callables.py
+++ b/example-specs/task/nipype/freesurfer/label_2_vol_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of Label2Vol.yaml"""
 
+import attrs
 import os
 import os.path as op
 from pathlib import Path
-import attrs
 
 
 def vol_label_file_default(inputs):
@@ -17,6 +17,35 @@ def vol_label_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["vol_label_file"]
 
 
+# Original source at L1311 of <nipype-install>/interfaces/freesurfer/model.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "vol_label_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )[name]
+    return None
+
+
+# Original source at L1293 of <nipype-install>/interfaces/freesurfer/model.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outfile = inputs.vol_label_file
+    if outfile is attrs.NOTHING:
+        for key in ["label_file", "annot_file", "seg_file"]:
+            if getattr(inputs, key) is not attrs.NOTHING:
+                path = getattr(inputs, key)
+                if isinstance(path, list):
+                    path = path[0]
+                _, src = os.path.split(path)
+        if inputs.aparc_aseg is not attrs.NOTHING:
+            src = "aparc+aseg.mgz"
+        outfile = fname_presuffix(
+            src, suffix="_vol.nii.gz", newpath=output_dir, use_ext=False
+        )
+    outputs["vol_label_file"] = outfile
+    return outputs
+
+
 # Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
@@ -109,32 +138,3 @@ def split_filename(fname):
         fname, ext = op.splitext(fname)
 
     return pth, fname, ext
-
-
-# Original source at L1311 of <nipype-install>/interfaces/freesurfer/model.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "vol_label_file":
-        return _list_outputs(
-            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-        )[name]
-    return None
-
-
-# Original source at L1293 of <nipype-install>/interfaces/freesurfer/model.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    outfile = inputs.vol_label_file
-    if outfile is attrs.NOTHING:
-        for key in ["label_file", "annot_file", "seg_file"]:
-            if getattr(inputs, key) is not attrs.NOTHING:
-                path = getattr(inputs, key)
-                if isinstance(path, list):
-                    path = path[0]
-                _, src = os.path.split(path)
-        if inputs.aparc_aseg is not attrs.NOTHING:
-            src = "aparc+aseg.mgz"
-        outfile = fname_presuffix(
-            src, suffix="_vol.nii.gz", newpath=output_dir, use_ext=False
-        )
-    outputs["vol_label_file"] = outfile
-    return outputs
diff --git a/example-specs/task/nipype/freesurfer/logan_ref_callables.py b/example-specs/task/nipype/freesurfer/logan_ref_callables.py
index fc99270b..c4e13cdf 100644
--- a/example-specs/task/nipype/freesurfer/logan_ref_callables.py
+++ b/example-specs/task/nipype/freesurfer/logan_ref_callables.py
@@ -1,40 +1,40 @@
 """Module to put any functions that are referred to in the "callables" section of LoganRef.yaml"""
 
+import attrs
 import os
 import os.path as op
-import attrs
 
 
 def glm_dir_default(inputs):
     return _gen_filename("glm_dir", inputs=inputs)
 
 
-def glm_dir_callable(output_dir, inputs, stdout, stderr):
+def beta_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["glm_dir"]
+    return outputs["beta_file"]
 
 
-def beta_file_callable(output_dir, inputs, stdout, stderr):
+def bp_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["beta_file"]
+    return outputs["bp_file"]
 
 
-def error_file_callable(output_dir, inputs, stdout, stderr):
+def dof_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["error_file"]
+    return outputs["dof_file"]
 
 
-def error_var_file_callable(output_dir, inputs, stdout, stderr):
+def error_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["error_var_file"]
+    return outputs["error_file"]
 
 
 def error_stddev_file_callable(output_dir, inputs, stdout, stderr):
@@ -44,6 +44,13 @@ def error_stddev_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["error_stddev_file"]
 
 
+def error_var_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["error_var_file"]
+
+
 def estimate_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
@@ -51,25 +58,25 @@ def estimate_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["estimate_file"]
 
 
-def mask_file_callable(output_dir, inputs, stdout, stderr):
+def frame_eigenvectors_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["mask_file"]
+    return outputs["frame_eigenvectors"]
 
 
-def fwhm_file_callable(output_dir, inputs, stdout, stderr):
+def ftest_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["fwhm_file"]
+    return outputs["ftest_file"]
 
 
-def dof_file_callable(output_dir, inputs, stdout, stderr):
+def fwhm_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["dof_file"]
+    return outputs["fwhm_file"]
 
 
 def gamma_file_callable(output_dir, inputs, stdout, stderr):
@@ -86,32 +93,32 @@ def gamma_var_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["gamma_var_file"]
 
 
-def sig_file_callable(output_dir, inputs, stdout, stderr):
+def glm_dir_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["sig_file"]
+    return outputs["glm_dir"]
 
 
-def ftest_file_callable(output_dir, inputs, stdout, stderr):
+def k2p_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["ftest_file"]
+    return outputs["k2p_file"]
 
 
-def spatial_eigenvectors_callable(output_dir, inputs, stdout, stderr):
+def mask_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["spatial_eigenvectors"]
+    return outputs["mask_file"]
 
 
-def frame_eigenvectors_callable(output_dir, inputs, stdout, stderr):
+def sig_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["frame_eigenvectors"]
+    return outputs["sig_file"]
 
 
 def singular_values_callable(output_dir, inputs, stdout, stderr):
@@ -121,76 +128,18 @@ def singular_values_callable(output_dir, inputs, stdout, stderr):
     return outputs["singular_values"]
 
 
-def svd_stats_file_callable(output_dir, inputs, stdout, stderr):
-    outputs = _list_outputs(
-        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
-    )
-    return outputs["svd_stats_file"]
-
-
-def k2p_file_callable(output_dir, inputs, stdout, stderr):
+def spatial_eigenvectors_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["k2p_file"]
+    return outputs["spatial_eigenvectors"]
 
 
-def bp_file_callable(output_dir, inputs, stdout, stderr):
+def svd_stats_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["bp_file"]
-
-
-# Original source at L58 of <nipype-install>/utils/filemanip.py
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
+    return outputs["svd_stats_file"]
 
 
 # Original source at L560 of <nipype-install>/interfaces/freesurfer/model.py
@@ -262,3 +211,54 @@ def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
         outputs["svd_stats_file"] = os.path.join(pcadir, "stats.dat")
 
     return outputs
+
+
+# Original source at L58 of <nipype-install>/utils/filemanip.py
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
diff --git a/example-specs/task/nipype/freesurfer/lta_convert_callables.py b/example-specs/task/nipype/freesurfer/lta_convert_callables.py
index 16f2180e..46eee18c 100644
--- a/example-specs/task/nipype/freesurfer/lta_convert_callables.py
+++ b/example-specs/task/nipype/freesurfer/lta_convert_callables.py
@@ -1,42 +1,41 @@
 """Module to put any functions that are referred to in the "callables" section of LTAConvert.yaml"""
 
 import os
-import attrs
 
 
-def out_lta_callable(output_dir, inputs, stdout, stderr):
+def out_fsl_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_lta"]
+    return outputs["out_fsl"]
 
 
-def out_fsl_callable(output_dir, inputs, stdout, stderr):
+def out_itk_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_fsl"]
+    return outputs["out_itk"]
 
 
-def out_mni_callable(output_dir, inputs, stdout, stderr):
+def out_lta_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_mni"]
+    return outputs["out_lta"]
 
 
-def out_reg_callable(output_dir, inputs, stdout, stderr):
+def out_mni_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_reg"]
+    return outputs["out_mni"]
 
 
-def out_itk_callable(output_dir, inputs, stdout, stderr):
+def out_reg_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_itk"]
+    return outputs["out_reg"]
 
 
 # Original source at L885 of <nipype-install>/interfaces/base/core.py
diff --git a/example-specs/task/nipype/freesurfer/make_average_subject_callables.py b/example-specs/task/nipype/freesurfer/make_average_subject_callables.py
index cf1e7e56..030f6a59 100644
--- a/example-specs/task/nipype/freesurfer/make_average_subject_callables.py
+++ b/example-specs/task/nipype/freesurfer/make_average_subject_callables.py
@@ -1,7 +1,5 @@
 """Module to put any functions that are referred to in the "callables" section of MakeAverageSubject.yaml"""
 
-import attrs
-
 
 def average_subject_name_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
diff --git a/example-specs/task/nipype/freesurfer/make_surfaces_callables.py b/example-specs/task/nipype/freesurfer/make_surfaces_callables.py
index 0a3b83f6..cdbbcb07 100644
--- a/example-specs/task/nipype/freesurfer/make_surfaces_callables.py
+++ b/example-specs/task/nipype/freesurfer/make_surfaces_callables.py
@@ -1,49 +1,49 @@
 """Module to put any functions that are referred to in the "callables" section of MakeSurfaces.yaml"""
 
-import os
 import attrs
+import os
 
 
-def out_white_callable(output_dir, inputs, stdout, stderr):
+def out_area_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_white"]
+    return outputs["out_area"]
 
 
-def out_curv_callable(output_dir, inputs, stdout, stderr):
+def out_cortex_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_curv"]
+    return outputs["out_cortex"]
 
 
-def out_area_callable(output_dir, inputs, stdout, stderr):
+def out_curv_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_area"]
+    return outputs["out_curv"]
 
 
-def out_cortex_callable(output_dir, inputs, stdout, stderr):
+def out_pial_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_cortex"]
+    return outputs["out_pial"]
 
 
-def out_pial_callable(output_dir, inputs, stdout, stderr):
+def out_thickness_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_pial"]
+    return outputs["out_thickness"]
 
 
-def out_thickness_callable(output_dir, inputs, stdout, stderr):
+def out_white_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_thickness"]
+    return outputs["out_white"]
 
 
 # Original source at L885 of <nipype-install>/interfaces/base/core.py
diff --git a/example-specs/task/nipype/freesurfer/mni_bias_correction_callables.py b/example-specs/task/nipype/freesurfer/mni_bias_correction_callables.py
index fc93ae5c..a1870c59 100644
--- a/example-specs/task/nipype/freesurfer/mni_bias_correction_callables.py
+++ b/example-specs/task/nipype/freesurfer/mni_bias_correction_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of MNIBiasCorrection.yaml"""
 
+import attrs
 import logging
 import os
 import os.path as op
-import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -16,75 +16,6 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
-# Original source at L58 of <nipype-install>/utils/filemanip.py
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
-# Original source at L888 of <nipype-install>/interfaces/base/core.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    return value
-
-
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
@@ -201,3 +132,72 @@ def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
             if fname is not attrs.NOTHING:
                 outputs[out_name] = os.path.abspath(fname)
         return outputs
+
+
+# Original source at L888 of <nipype-install>/interfaces/base/core.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value
+
+
+# Original source at L58 of <nipype-install>/utils/filemanip.py
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
diff --git a/example-specs/task/nipype/freesurfer/mp_rto_mni305_callables.py b/example-specs/task/nipype/freesurfer/mp_rto_mni305_callables.py
index 52319a85..946978bc 100644
--- a/example-specs/task/nipype/freesurfer/mp_rto_mni305_callables.py
+++ b/example-specs/task/nipype/freesurfer/mp_rto_mni305_callables.py
@@ -2,21 +2,52 @@
 
 import os
 import os.path as op
-import attrs
 
 
-def out_file_callable(output_dir, inputs, stdout, stderr):
+def log_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_file"]
+    return outputs["log_file"]
 
 
-def log_file_callable(output_dir, inputs, stdout, stderr):
+def out_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["log_file"]
+    return outputs["out_file"]
+
+
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+# Original source at L97 of <nipype-install>/interfaces/freesurfer/registration.py
+def _get_fname(fname, inputs=None, stdout=None, stderr=None, output_dir=None):
+    return split_filename(fname)[1]
+
+
+# Original source at L100 of <nipype-install>/interfaces/freesurfer/registration.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_freesurfer__FSScriptCommand___list_outputs()
+    fullname = "_".join(
+        [
+            _get_fname(
+                inputs.in_file,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            ),
+            "to",
+            inputs.target,
+            "t4",
+            "vox2vox.txt",
+        ]
+    )
+    outputs["out_file"] = os.path.abspath(fullname)
+    return outputs
 
 
 # Original source at L216 of <nipype-install>/interfaces/freesurfer/base.py
@@ -28,11 +59,6 @@ def nipype_interfaces_freesurfer__FSScriptCommand___list_outputs(
     return outputs
 
 
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
 # Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
@@ -82,30 +108,3 @@ def split_filename(fname):
         fname, ext = op.splitext(fname)
 
     return pth, fname, ext
-
-
-# Original source at L97 of <nipype-install>/interfaces/freesurfer/registration.py
-def _get_fname(fname, inputs=None, stdout=None, stderr=None, output_dir=None):
-    return split_filename(fname)[1]
-
-
-# Original source at L100 of <nipype-install>/interfaces/freesurfer/registration.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = nipype_interfaces_freesurfer__FSScriptCommand___list_outputs()
-    fullname = "_".join(
-        [
-            _get_fname(
-                inputs.in_file,
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            ),
-            "to",
-            inputs.target,
-            "t4",
-            "vox2vox.txt",
-        ]
-    )
-    outputs["out_file"] = os.path.abspath(fullname)
-    return outputs
diff --git a/example-specs/task/nipype/freesurfer/mr_is_ca_label_callables.py b/example-specs/task/nipype/freesurfer/mr_is_ca_label_callables.py
index f0990aea..961d1fc4 100644
--- a/example-specs/task/nipype/freesurfer/mr_is_ca_label_callables.py
+++ b/example-specs/task/nipype/freesurfer/mr_is_ca_label_callables.py
@@ -1,7 +1,6 @@
 """Module to put any functions that are referred to in the "callables" section of MRIsCALabel.yaml"""
 
 import os
-import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/freesurfer/mr_is_calc_callables.py b/example-specs/task/nipype/freesurfer/mr_is_calc_callables.py
index 667e9b4a..ebd51370 100644
--- a/example-specs/task/nipype/freesurfer/mr_is_calc_callables.py
+++ b/example-specs/task/nipype/freesurfer/mr_is_calc_callables.py
@@ -1,7 +1,6 @@
 """Module to put any functions that are referred to in the "callables" section of MRIsCalc.yaml"""
 
 import os
-import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/freesurfer/mr_is_combine_callables.py b/example-specs/task/nipype/freesurfer/mr_is_combine_callables.py
index 38db9962..2b8823e3 100644
--- a/example-specs/task/nipype/freesurfer/mr_is_combine_callables.py
+++ b/example-specs/task/nipype/freesurfer/mr_is_combine_callables.py
@@ -1,7 +1,6 @@
 """Module to put any functions that are referred to in the "callables" section of MRIsCombine.yaml"""
 
 import os
-import attrs
 
 
 def out_file_default(inputs):
diff --git a/example-specs/task/nipype/freesurfer/mr_is_convert_callables.py b/example-specs/task/nipype/freesurfer/mr_is_convert_callables.py
index 0a72d065..d8d4838f 100644
--- a/example-specs/task/nipype/freesurfer/mr_is_convert_callables.py
+++ b/example-specs/task/nipype/freesurfer/mr_is_convert_callables.py
@@ -1,8 +1,8 @@
 """Module to put any functions that are referred to in the "callables" section of MRIsConvert.yaml"""
 
+import attrs
 import os
 import os.path as op
-import attrs
 
 
 def out_file_default(inputs):
@@ -16,6 +16,49 @@ def converted_callable(output_dir, inputs, stdout, stderr):
     return outputs["converted"]
 
 
+# Original source at L1309 of <nipype-install>/interfaces/freesurfer/utils.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return os.path.abspath(
+            _gen_outfilename(
+                inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+        )
+    else:
+        return None
+
+
+# Original source at L1315 of <nipype-install>/interfaces/freesurfer/utils.py
+def _gen_outfilename(inputs=None, stdout=None, stderr=None, output_dir=None):
+    if inputs.out_file is not attrs.NOTHING:
+        return inputs.out_file
+    elif inputs.annot_file is not attrs.NOTHING:
+        _, name, ext = split_filename(inputs.annot_file)
+    elif inputs.parcstats_file is not attrs.NOTHING:
+        _, name, ext = split_filename(inputs.parcstats_file)
+    elif inputs.label_file is not attrs.NOTHING:
+        _, name, ext = split_filename(inputs.label_file)
+    elif inputs.scalarcurv_file is not attrs.NOTHING:
+        _, name, ext = split_filename(inputs.scalarcurv_file)
+    elif inputs.functional_file is not attrs.NOTHING:
+        _, name, ext = split_filename(inputs.functional_file)
+    elif inputs.in_file is not attrs.NOTHING:
+        _, name, ext = split_filename(inputs.in_file)
+
+    return name + ext + "_converted." + inputs.out_datatype
+
+
+# Original source at L1304 of <nipype-install>/interfaces/freesurfer/utils.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["converted"] = os.path.abspath(
+        _gen_outfilename(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )
+    )
+    return outputs
+
+
 # Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
@@ -65,46 +108,3 @@ def split_filename(fname):
         fname, ext = op.splitext(fname)
 
     return pth, fname, ext
-
-
-# Original source at L1315 of <nipype-install>/interfaces/freesurfer/utils.py
-def _gen_outfilename(inputs=None, stdout=None, stderr=None, output_dir=None):
-    if inputs.out_file is not attrs.NOTHING:
-        return inputs.out_file
-    elif inputs.annot_file is not attrs.NOTHING:
-        _, name, ext = split_filename(inputs.annot_file)
-    elif inputs.parcstats_file is not attrs.NOTHING:
-        _, name, ext = split_filename(inputs.parcstats_file)
-    elif inputs.label_file is not attrs.NOTHING:
-        _, name, ext = split_filename(inputs.label_file)
-    elif inputs.scalarcurv_file is not attrs.NOTHING:
-        _, name, ext = split_filename(inputs.scalarcurv_file)
-    elif inputs.functional_file is not attrs.NOTHING:
-        _, name, ext = split_filename(inputs.functional_file)
-    elif inputs.in_file is not attrs.NOTHING:
-        _, name, ext = split_filename(inputs.in_file)
-
-    return name + ext + "_converted." + inputs.out_datatype
-
-
-# Original source at L1309 of <nipype-install>/interfaces/freesurfer/utils.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "out_file":
-        return os.path.abspath(
-            _gen_outfilename(
-                inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-            )
-        )
-    else:
-        return None
-
-
-# Original source at L1304 of <nipype-install>/interfaces/freesurfer/utils.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    outputs["converted"] = os.path.abspath(
-        _gen_outfilename(
-            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-        )
-    )
-    return outputs
diff --git a/example-specs/task/nipype/freesurfer/mr_is_expand_callables.py b/example-specs/task/nipype/freesurfer/mr_is_expand_callables.py
index 3d8a156a..985f0588 100644
--- a/example-specs/task/nipype/freesurfer/mr_is_expand_callables.py
+++ b/example-specs/task/nipype/freesurfer/mr_is_expand_callables.py
@@ -1,7 +1,6 @@
 """Module to put any functions that are referred to in the "callables" section of MRIsExpand.yaml"""
 
 import os
-import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/freesurfer/mr_is_inflate_callables.py b/example-specs/task/nipype/freesurfer/mr_is_inflate_callables.py
index 865790a8..3770b83c 100644
--- a/example-specs/task/nipype/freesurfer/mr_is_inflate_callables.py
+++ b/example-specs/task/nipype/freesurfer/mr_is_inflate_callables.py
@@ -1,7 +1,6 @@
 """Module to put any functions that are referred to in the "callables" section of MRIsInflate.yaml"""
 
 import os
-import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/freesurfer/mri_convert_callables.py b/example-specs/task/nipype/freesurfer/mri_convert_callables.py
index cb7cec93..423079b3 100644
--- a/example-specs/task/nipype/freesurfer/mri_convert_callables.py
+++ b/example-specs/task/nipype/freesurfer/mri_convert_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of MRIConvert.yaml"""
 
-from nibabel import load
 import attrs
 import os
 import os.path as op
+from nibabel import load
 from pathlib import Path
 
 
@@ -18,6 +18,76 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_file"]
 
 
+# Original source at L603 of <nipype-install>/interfaces/freesurfer/preprocess.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _get_outfilename(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )
+    return None
+
+
+# Original source at L550 of <nipype-install>/interfaces/freesurfer/preprocess.py
+def _get_outfilename(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outfile = inputs.out_file
+    if outfile is attrs.NOTHING:
+        if inputs.out_type is not attrs.NOTHING:
+            suffix = "_out." + filemap[inputs.out_type]
+        else:
+            suffix = "_out.nii.gz"
+        outfile = fname_presuffix(
+            inputs.in_file, newpath=output_dir, suffix=suffix, use_ext=False
+        )
+    return os.path.abspath(outfile)
+
+
+# Original source at L562 of <nipype-install>/interfaces/freesurfer/preprocess.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outfile = _get_outfilename(
+        inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+    )
+    if (inputs.split is not attrs.NOTHING) and inputs.split:
+        size = load(inputs.in_file).shape
+        if len(size) == 3:
+            tp = 1
+        else:
+            tp = size[-1]
+        if outfile.endswith(".mgz"):
+            stem = outfile.split(".mgz")[0]
+            ext = ".mgz"
+        elif outfile.endswith(".nii.gz"):
+            stem = outfile.split(".nii.gz")[0]
+            ext = ".nii.gz"
+        else:
+            stem = ".".join(outfile.split(".")[:-1])
+            ext = "." + outfile.split(".")[-1]
+        outfile = []
+        for idx in range(0, tp):
+            outfile.append(stem + "%04d" % idx + ext)
+    if inputs.out_type is not attrs.NOTHING:
+        if inputs.out_type in ["spm", "analyze"]:
+            # generate all outputs
+            size = load(inputs.in_file).shape
+            if len(size) == 3:
+                tp = 1
+            else:
+                tp = size[-1]
+                # have to take care of all the frame manipulations
+                raise Exception(
+                    "Not taking frame manipulations into account- please warn the developers"
+                )
+            outfiles = []
+            outfile = _get_outfilename(
+                inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            for i in range(tp):
+                outfiles.append(fname_presuffix(outfile, suffix="%03d" % (i + 1)))
+            outfile = outfiles
+    outputs["out_file"] = outfile
+    return outputs
+
+
 # Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
@@ -110,73 +180,3 @@ def split_filename(fname):
         fname, ext = op.splitext(fname)
 
     return pth, fname, ext
-
-
-# Original source at L550 of <nipype-install>/interfaces/freesurfer/preprocess.py
-def _get_outfilename(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outfile = inputs.out_file
-    if outfile is attrs.NOTHING:
-        if inputs.out_type is not attrs.NOTHING:
-            suffix = "_out." + filemap[inputs.out_type]
-        else:
-            suffix = "_out.nii.gz"
-        outfile = fname_presuffix(
-            inputs.in_file, newpath=output_dir, suffix=suffix, use_ext=False
-        )
-    return os.path.abspath(outfile)
-
-
-# Original source at L603 of <nipype-install>/interfaces/freesurfer/preprocess.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "out_file":
-        return _get_outfilename(
-            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-        )
-    return None
-
-
-# Original source at L562 of <nipype-install>/interfaces/freesurfer/preprocess.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    outfile = _get_outfilename(
-        inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-    )
-    if (inputs.split is not attrs.NOTHING) and inputs.split:
-        size = load(inputs.in_file).shape
-        if len(size) == 3:
-            tp = 1
-        else:
-            tp = size[-1]
-        if outfile.endswith(".mgz"):
-            stem = outfile.split(".mgz")[0]
-            ext = ".mgz"
-        elif outfile.endswith(".nii.gz"):
-            stem = outfile.split(".nii.gz")[0]
-            ext = ".nii.gz"
-        else:
-            stem = ".".join(outfile.split(".")[:-1])
-            ext = "." + outfile.split(".")[-1]
-        outfile = []
-        for idx in range(0, tp):
-            outfile.append(stem + "%04d" % idx + ext)
-    if inputs.out_type is not attrs.NOTHING:
-        if inputs.out_type in ["spm", "analyze"]:
-            # generate all outputs
-            size = load(inputs.in_file).shape
-            if len(size) == 3:
-                tp = 1
-            else:
-                tp = size[-1]
-                # have to take care of all the frame manipulations
-                raise Exception(
-                    "Not taking frame manipulations into account- please warn the developers"
-                )
-            outfiles = []
-            outfile = _get_outfilename(
-                inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-            )
-            for i in range(tp):
-                outfiles.append(fname_presuffix(outfile, suffix="%03d" % (i + 1)))
-            outfile = outfiles
-    outputs["out_file"] = outfile
-    return outputs
diff --git a/example-specs/task/nipype/freesurfer/mri_coreg_callables.py b/example-specs/task/nipype/freesurfer/mri_coreg_callables.py
index 02dd828f..dcf8bab4 100644
--- a/example-specs/task/nipype/freesurfer/mri_coreg_callables.py
+++ b/example-specs/task/nipype/freesurfer/mri_coreg_callables.py
@@ -1,28 +1,28 @@
 """Module to put any functions that are referred to in the "callables" section of MRICoreg.yaml"""
 
-import os
 import attrs
+import os
 
 
-def out_reg_file_callable(output_dir, inputs, stdout, stderr):
+def out_lta_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_reg_file"]
+    return outputs["out_lta_file"]
 
 
-def out_lta_file_callable(output_dir, inputs, stdout, stderr):
+def out_params_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_lta_file"]
+    return outputs["out_params_file"]
 
 
-def out_params_file_callable(output_dir, inputs, stdout, stderr):
+def out_reg_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_params_file"]
+    return outputs["out_reg_file"]
 
 
 # Original source at L885 of <nipype-install>/interfaces/base/core.py
diff --git a/example-specs/task/nipype/freesurfer/mri_fill_callables.py b/example-specs/task/nipype/freesurfer/mri_fill_callables.py
index 92532698..7f4eb1c8 100644
--- a/example-specs/task/nipype/freesurfer/mri_fill_callables.py
+++ b/example-specs/task/nipype/freesurfer/mri_fill_callables.py
@@ -1,21 +1,21 @@
 """Module to put any functions that are referred to in the "callables" section of MRIFill.yaml"""
 
-import os
 import attrs
+import os
 
 
-def out_file_callable(output_dir, inputs, stdout, stderr):
+def log_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_file"]
+    return outputs["log_file"]
 
 
-def log_file_callable(output_dir, inputs, stdout, stderr):
+def out_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["log_file"]
+    return outputs["out_file"]
 
 
 # Original source at L885 of <nipype-install>/interfaces/base/core.py
diff --git a/example-specs/task/nipype/freesurfer/mri_marching_cubes_callables.py b/example-specs/task/nipype/freesurfer/mri_marching_cubes_callables.py
index 49b33fb6..b8093b6b 100644
--- a/example-specs/task/nipype/freesurfer/mri_marching_cubes_callables.py
+++ b/example-specs/task/nipype/freesurfer/mri_marching_cubes_callables.py
@@ -1,8 +1,8 @@
 """Module to put any functions that are referred to in the "callables" section of MRIMarchingCubes.yaml"""
 
+import attrs
 import os
 import os.path as op
-import attrs
 
 
 def out_file_default(inputs):
@@ -16,6 +16,34 @@ def surface_callable(output_dir, inputs, stdout, stderr):
     return outputs["surface"]
 
 
+# Original source at L1647 of <nipype-install>/interfaces/freesurfer/utils.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _gen_outfilename(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )
+    else:
+        return None
+
+
+# Original source at L1653 of <nipype-install>/interfaces/freesurfer/utils.py
+def _gen_outfilename(inputs=None, stdout=None, stderr=None, output_dir=None):
+    if inputs.out_file is not attrs.NOTHING:
+        return os.path.abspath(inputs.out_file)
+    else:
+        _, name, ext = split_filename(inputs.in_file)
+        return os.path.abspath(name + ext + "_" + str(inputs.label_value))
+
+
+# Original source at L1642 of <nipype-install>/interfaces/freesurfer/utils.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["surface"] = _gen_outfilename(
+        inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+    )
+    return outputs
+
+
 # Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
@@ -65,31 +93,3 @@ def split_filename(fname):
         fname, ext = op.splitext(fname)
 
     return pth, fname, ext
-
-
-# Original source at L1653 of <nipype-install>/interfaces/freesurfer/utils.py
-def _gen_outfilename(inputs=None, stdout=None, stderr=None, output_dir=None):
-    if inputs.out_file is not attrs.NOTHING:
-        return os.path.abspath(inputs.out_file)
-    else:
-        _, name, ext = split_filename(inputs.in_file)
-        return os.path.abspath(name + ext + "_" + str(inputs.label_value))
-
-
-# Original source at L1647 of <nipype-install>/interfaces/freesurfer/utils.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "out_file":
-        return _gen_outfilename(
-            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-        )
-    else:
-        return None
-
-
-# Original source at L1642 of <nipype-install>/interfaces/freesurfer/utils.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    outputs["surface"] = _gen_outfilename(
-        inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-    )
-    return outputs
diff --git a/example-specs/task/nipype/freesurfer/mri_pretess_callables.py b/example-specs/task/nipype/freesurfer/mri_pretess_callables.py
index ffcd2bdb..a331de29 100644
--- a/example-specs/task/nipype/freesurfer/mri_pretess_callables.py
+++ b/example-specs/task/nipype/freesurfer/mri_pretess_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of MRIPretess.yaml"""
 
+import attrs
 import logging
 import os
 import os.path as op
-import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -16,75 +16,6 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
-# Original source at L58 of <nipype-install>/utils/filemanip.py
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
-# Original source at L888 of <nipype-install>/interfaces/base/core.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    return value
-
-
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
@@ -201,3 +132,72 @@ def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
             if fname is not attrs.NOTHING:
                 outputs[out_name] = os.path.abspath(fname)
         return outputs
+
+
+# Original source at L888 of <nipype-install>/interfaces/base/core.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value
+
+
+# Original source at L58 of <nipype-install>/utils/filemanip.py
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
diff --git a/example-specs/task/nipype/freesurfer/mri_tessellate_callables.py b/example-specs/task/nipype/freesurfer/mri_tessellate_callables.py
index 95df8ef1..32c41f0c 100644
--- a/example-specs/task/nipype/freesurfer/mri_tessellate_callables.py
+++ b/example-specs/task/nipype/freesurfer/mri_tessellate_callables.py
@@ -1,8 +1,8 @@
 """Module to put any functions that are referred to in the "callables" section of MRITessellate.yaml"""
 
+import attrs
 import os
 import os.path as op
-import attrs
 
 
 def out_file_default(inputs):
@@ -16,6 +16,36 @@ def surface_callable(output_dir, inputs, stdout, stderr):
     return outputs["surface"]
 
 
+# Original source at L1484 of <nipype-install>/interfaces/freesurfer/utils.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _gen_outfilename(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )
+    else:
+        return None
+
+
+# Original source at L1490 of <nipype-install>/interfaces/freesurfer/utils.py
+def _gen_outfilename(inputs=None, stdout=None, stderr=None, output_dir=None):
+    if inputs.out_file is not attrs.NOTHING:
+        return inputs.out_file
+    else:
+        _, name, ext = split_filename(inputs.in_file)
+        return name + ext + "_" + str(inputs.label_value)
+
+
+# Original source at L1479 of <nipype-install>/interfaces/freesurfer/utils.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["surface"] = os.path.abspath(
+        _gen_outfilename(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )
+    )
+    return outputs
+
+
 # Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
@@ -65,33 +95,3 @@ def split_filename(fname):
         fname, ext = op.splitext(fname)
 
     return pth, fname, ext
-
-
-# Original source at L1490 of <nipype-install>/interfaces/freesurfer/utils.py
-def _gen_outfilename(inputs=None, stdout=None, stderr=None, output_dir=None):
-    if inputs.out_file is not attrs.NOTHING:
-        return inputs.out_file
-    else:
-        _, name, ext = split_filename(inputs.in_file)
-        return name + ext + "_" + str(inputs.label_value)
-
-
-# Original source at L1484 of <nipype-install>/interfaces/freesurfer/utils.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "out_file":
-        return _gen_outfilename(
-            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-        )
-    else:
-        return None
-
-
-# Original source at L1479 of <nipype-install>/interfaces/freesurfer/utils.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    outputs["surface"] = os.path.abspath(
-        _gen_outfilename(
-            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-        )
-    )
-    return outputs
diff --git a/example-specs/task/nipype/freesurfer/mris_preproc_callables.py b/example-specs/task/nipype/freesurfer/mris_preproc_callables.py
index f1eeda6d..7ff5e988 100644
--- a/example-specs/task/nipype/freesurfer/mris_preproc_callables.py
+++ b/example-specs/task/nipype/freesurfer/mris_preproc_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of MRISPreproc.yaml"""
 
-import os
 import attrs
+import os
 
 
 def out_file_default(inputs):
diff --git a/example-specs/task/nipype/freesurfer/mris_preproc_recon_all_callables.py b/example-specs/task/nipype/freesurfer/mris_preproc_recon_all_callables.py
index b6e54979..40fbf20f 100644
--- a/example-specs/task/nipype/freesurfer/mris_preproc_recon_all_callables.py
+++ b/example-specs/task/nipype/freesurfer/mris_preproc_recon_all_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of MRISPreprocReconAll.yaml"""
 
-import os
 import attrs
+import os
 
 
 def out_file_default(inputs):
diff --git a/example-specs/task/nipype/freesurfer/mrtm2_callables.py b/example-specs/task/nipype/freesurfer/mrtm2_callables.py
index 98b9c2ba..a4ca7bdc 100644
--- a/example-specs/task/nipype/freesurfer/mrtm2_callables.py
+++ b/example-specs/task/nipype/freesurfer/mrtm2_callables.py
@@ -1,40 +1,40 @@
 """Module to put any functions that are referred to in the "callables" section of MRTM2.yaml"""
 
+import attrs
 import os
 import os.path as op
-import attrs
 
 
 def glm_dir_default(inputs):
     return _gen_filename("glm_dir", inputs=inputs)
 
 
-def glm_dir_callable(output_dir, inputs, stdout, stderr):
+def beta_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["glm_dir"]
+    return outputs["beta_file"]
 
 
-def beta_file_callable(output_dir, inputs, stdout, stderr):
+def bp_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["beta_file"]
+    return outputs["bp_file"]
 
 
-def error_file_callable(output_dir, inputs, stdout, stderr):
+def dof_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["error_file"]
+    return outputs["dof_file"]
 
 
-def error_var_file_callable(output_dir, inputs, stdout, stderr):
+def error_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["error_var_file"]
+    return outputs["error_file"]
 
 
 def error_stddev_file_callable(output_dir, inputs, stdout, stderr):
@@ -44,6 +44,13 @@ def error_stddev_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["error_stddev_file"]
 
 
+def error_var_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["error_var_file"]
+
+
 def estimate_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
@@ -51,25 +58,25 @@ def estimate_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["estimate_file"]
 
 
-def mask_file_callable(output_dir, inputs, stdout, stderr):
+def frame_eigenvectors_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["mask_file"]
+    return outputs["frame_eigenvectors"]
 
 
-def fwhm_file_callable(output_dir, inputs, stdout, stderr):
+def ftest_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["fwhm_file"]
+    return outputs["ftest_file"]
 
 
-def dof_file_callable(output_dir, inputs, stdout, stderr):
+def fwhm_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["dof_file"]
+    return outputs["fwhm_file"]
 
 
 def gamma_file_callable(output_dir, inputs, stdout, stderr):
@@ -86,32 +93,32 @@ def gamma_var_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["gamma_var_file"]
 
 
-def sig_file_callable(output_dir, inputs, stdout, stderr):
+def glm_dir_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["sig_file"]
+    return outputs["glm_dir"]
 
 
-def ftest_file_callable(output_dir, inputs, stdout, stderr):
+def k2p_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["ftest_file"]
+    return outputs["k2p_file"]
 
 
-def spatial_eigenvectors_callable(output_dir, inputs, stdout, stderr):
+def mask_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["spatial_eigenvectors"]
+    return outputs["mask_file"]
 
 
-def frame_eigenvectors_callable(output_dir, inputs, stdout, stderr):
+def sig_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["frame_eigenvectors"]
+    return outputs["sig_file"]
 
 
 def singular_values_callable(output_dir, inputs, stdout, stderr):
@@ -121,76 +128,18 @@ def singular_values_callable(output_dir, inputs, stdout, stderr):
     return outputs["singular_values"]
 
 
-def svd_stats_file_callable(output_dir, inputs, stdout, stderr):
-    outputs = _list_outputs(
-        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
-    )
-    return outputs["svd_stats_file"]
-
-
-def k2p_file_callable(output_dir, inputs, stdout, stderr):
+def spatial_eigenvectors_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["k2p_file"]
+    return outputs["spatial_eigenvectors"]
 
 
-def bp_file_callable(output_dir, inputs, stdout, stderr):
+def svd_stats_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["bp_file"]
-
-
-# Original source at L58 of <nipype-install>/utils/filemanip.py
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
+    return outputs["svd_stats_file"]
 
 
 # Original source at L560 of <nipype-install>/interfaces/freesurfer/model.py
@@ -262,3 +211,54 @@ def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
         outputs["svd_stats_file"] = os.path.join(pcadir, "stats.dat")
 
     return outputs
+
+
+# Original source at L58 of <nipype-install>/utils/filemanip.py
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
diff --git a/example-specs/task/nipype/freesurfer/mrtm_callables.py b/example-specs/task/nipype/freesurfer/mrtm_callables.py
index efbae1a8..3201f31f 100644
--- a/example-specs/task/nipype/freesurfer/mrtm_callables.py
+++ b/example-specs/task/nipype/freesurfer/mrtm_callables.py
@@ -1,40 +1,40 @@
 """Module to put any functions that are referred to in the "callables" section of MRTM.yaml"""
 
+import attrs
 import os
 import os.path as op
-import attrs
 
 
 def glm_dir_default(inputs):
     return _gen_filename("glm_dir", inputs=inputs)
 
 
-def glm_dir_callable(output_dir, inputs, stdout, stderr):
+def beta_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["glm_dir"]
+    return outputs["beta_file"]
 
 
-def beta_file_callable(output_dir, inputs, stdout, stderr):
+def bp_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["beta_file"]
+    return outputs["bp_file"]
 
 
-def error_file_callable(output_dir, inputs, stdout, stderr):
+def dof_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["error_file"]
+    return outputs["dof_file"]
 
 
-def error_var_file_callable(output_dir, inputs, stdout, stderr):
+def error_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["error_var_file"]
+    return outputs["error_file"]
 
 
 def error_stddev_file_callable(output_dir, inputs, stdout, stderr):
@@ -44,6 +44,13 @@ def error_stddev_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["error_stddev_file"]
 
 
+def error_var_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["error_var_file"]
+
+
 def estimate_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
@@ -51,25 +58,25 @@ def estimate_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["estimate_file"]
 
 
-def mask_file_callable(output_dir, inputs, stdout, stderr):
+def frame_eigenvectors_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["mask_file"]
+    return outputs["frame_eigenvectors"]
 
 
-def fwhm_file_callable(output_dir, inputs, stdout, stderr):
+def ftest_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["fwhm_file"]
+    return outputs["ftest_file"]
 
 
-def dof_file_callable(output_dir, inputs, stdout, stderr):
+def fwhm_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["dof_file"]
+    return outputs["fwhm_file"]
 
 
 def gamma_file_callable(output_dir, inputs, stdout, stderr):
@@ -86,32 +93,32 @@ def gamma_var_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["gamma_var_file"]
 
 
-def sig_file_callable(output_dir, inputs, stdout, stderr):
+def glm_dir_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["sig_file"]
+    return outputs["glm_dir"]
 
 
-def ftest_file_callable(output_dir, inputs, stdout, stderr):
+def k2p_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["ftest_file"]
+    return outputs["k2p_file"]
 
 
-def spatial_eigenvectors_callable(output_dir, inputs, stdout, stderr):
+def mask_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["spatial_eigenvectors"]
+    return outputs["mask_file"]
 
 
-def frame_eigenvectors_callable(output_dir, inputs, stdout, stderr):
+def sig_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["frame_eigenvectors"]
+    return outputs["sig_file"]
 
 
 def singular_values_callable(output_dir, inputs, stdout, stderr):
@@ -121,76 +128,18 @@ def singular_values_callable(output_dir, inputs, stdout, stderr):
     return outputs["singular_values"]
 
 
-def svd_stats_file_callable(output_dir, inputs, stdout, stderr):
-    outputs = _list_outputs(
-        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
-    )
-    return outputs["svd_stats_file"]
-
-
-def k2p_file_callable(output_dir, inputs, stdout, stderr):
+def spatial_eigenvectors_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["k2p_file"]
+    return outputs["spatial_eigenvectors"]
 
 
-def bp_file_callable(output_dir, inputs, stdout, stderr):
+def svd_stats_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["bp_file"]
-
-
-# Original source at L58 of <nipype-install>/utils/filemanip.py
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
+    return outputs["svd_stats_file"]
 
 
 # Original source at L560 of <nipype-install>/interfaces/freesurfer/model.py
@@ -262,3 +211,54 @@ def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
         outputs["svd_stats_file"] = os.path.join(pcadir, "stats.dat")
 
     return outputs
+
+
+# Original source at L58 of <nipype-install>/utils/filemanip.py
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
diff --git a/example-specs/task/nipype/freesurfer/ms__lda_callables.py b/example-specs/task/nipype/freesurfer/ms__lda_callables.py
index 7edd8b2d..237f178a 100644
--- a/example-specs/task/nipype/freesurfer/ms__lda_callables.py
+++ b/example-specs/task/nipype/freesurfer/ms__lda_callables.py
@@ -1,21 +1,21 @@
 """Module to put any functions that are referred to in the "callables" section of MS_LDA.yaml"""
 
-import os
 import attrs
+import os
 
 
-def weight_file_callable(output_dir, inputs, stdout, stderr):
+def vol_synth_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["weight_file"]
+    return outputs["vol_synth_file"]
 
 
-def vol_synth_file_callable(output_dir, inputs, stdout, stderr):
+def weight_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["vol_synth_file"]
+    return outputs["weight_file"]
 
 
 # Original source at L1416 of <nipype-install>/interfaces/freesurfer/model.py
diff --git a/example-specs/task/nipype/freesurfer/normalize_callables.py b/example-specs/task/nipype/freesurfer/normalize_callables.py
index d44de81f..cb1a5a63 100644
--- a/example-specs/task/nipype/freesurfer/normalize_callables.py
+++ b/example-specs/task/nipype/freesurfer/normalize_callables.py
@@ -1,7 +1,6 @@
 """Module to put any functions that are referred to in the "callables" section of Normalize.yaml"""
 
 import os
-import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/freesurfer/one_sample_t_test_callables.py b/example-specs/task/nipype/freesurfer/one_sample_t_test_callables.py
index dae959f0..3825384d 100644
--- a/example-specs/task/nipype/freesurfer/one_sample_t_test_callables.py
+++ b/example-specs/task/nipype/freesurfer/one_sample_t_test_callables.py
@@ -1,40 +1,40 @@
 """Module to put any functions that are referred to in the "callables" section of OneSampleTTest.yaml"""
 
+import attrs
 import os
 import os.path as op
-import attrs
 
 
 def glm_dir_default(inputs):
     return _gen_filename("glm_dir", inputs=inputs)
 
 
-def glm_dir_callable(output_dir, inputs, stdout, stderr):
+def beta_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["glm_dir"]
+    return outputs["beta_file"]
 
 
-def beta_file_callable(output_dir, inputs, stdout, stderr):
+def bp_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["beta_file"]
+    return outputs["bp_file"]
 
 
-def error_file_callable(output_dir, inputs, stdout, stderr):
+def dof_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["error_file"]
+    return outputs["dof_file"]
 
 
-def error_var_file_callable(output_dir, inputs, stdout, stderr):
+def error_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["error_var_file"]
+    return outputs["error_file"]
 
 
 def error_stddev_file_callable(output_dir, inputs, stdout, stderr):
@@ -44,6 +44,13 @@ def error_stddev_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["error_stddev_file"]
 
 
+def error_var_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["error_var_file"]
+
+
 def estimate_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
@@ -51,25 +58,25 @@ def estimate_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["estimate_file"]
 
 
-def mask_file_callable(output_dir, inputs, stdout, stderr):
+def frame_eigenvectors_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["mask_file"]
+    return outputs["frame_eigenvectors"]
 
 
-def fwhm_file_callable(output_dir, inputs, stdout, stderr):
+def ftest_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["fwhm_file"]
+    return outputs["ftest_file"]
 
 
-def dof_file_callable(output_dir, inputs, stdout, stderr):
+def fwhm_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["dof_file"]
+    return outputs["fwhm_file"]
 
 
 def gamma_file_callable(output_dir, inputs, stdout, stderr):
@@ -86,32 +93,32 @@ def gamma_var_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["gamma_var_file"]
 
 
-def sig_file_callable(output_dir, inputs, stdout, stderr):
+def glm_dir_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["sig_file"]
+    return outputs["glm_dir"]
 
 
-def ftest_file_callable(output_dir, inputs, stdout, stderr):
+def k2p_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["ftest_file"]
+    return outputs["k2p_file"]
 
 
-def spatial_eigenvectors_callable(output_dir, inputs, stdout, stderr):
+def mask_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["spatial_eigenvectors"]
+    return outputs["mask_file"]
 
 
-def frame_eigenvectors_callable(output_dir, inputs, stdout, stderr):
+def sig_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["frame_eigenvectors"]
+    return outputs["sig_file"]
 
 
 def singular_values_callable(output_dir, inputs, stdout, stderr):
@@ -121,76 +128,18 @@ def singular_values_callable(output_dir, inputs, stdout, stderr):
     return outputs["singular_values"]
 
 
-def svd_stats_file_callable(output_dir, inputs, stdout, stderr):
-    outputs = _list_outputs(
-        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
-    )
-    return outputs["svd_stats_file"]
-
-
-def k2p_file_callable(output_dir, inputs, stdout, stderr):
+def spatial_eigenvectors_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["k2p_file"]
+    return outputs["spatial_eigenvectors"]
 
 
-def bp_file_callable(output_dir, inputs, stdout, stderr):
+def svd_stats_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["bp_file"]
-
-
-# Original source at L58 of <nipype-install>/utils/filemanip.py
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
+    return outputs["svd_stats_file"]
 
 
 # Original source at L560 of <nipype-install>/interfaces/freesurfer/model.py
@@ -262,3 +211,54 @@ def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
         outputs["svd_stats_file"] = os.path.join(pcadir, "stats.dat")
 
     return outputs
+
+
+# Original source at L58 of <nipype-install>/utils/filemanip.py
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
diff --git a/example-specs/task/nipype/freesurfer/paint_callables.py b/example-specs/task/nipype/freesurfer/paint_callables.py
index 10b251da..65be9f65 100644
--- a/example-specs/task/nipype/freesurfer/paint_callables.py
+++ b/example-specs/task/nipype/freesurfer/paint_callables.py
@@ -1,7 +1,6 @@
 """Module to put any functions that are referred to in the "callables" section of Paint.yaml"""
 
 import os
-import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/freesurfer/parcellation_stats_callables.py b/example-specs/task/nipype/freesurfer/parcellation_stats_callables.py
index d7de17e5..184cc567 100644
--- a/example-specs/task/nipype/freesurfer/parcellation_stats_callables.py
+++ b/example-specs/task/nipype/freesurfer/parcellation_stats_callables.py
@@ -1,29 +1,29 @@
 """Module to put any functions that are referred to in the "callables" section of ParcellationStats.yaml"""
 
-import os
 import attrs
-
-
-def out_table_default(inputs):
-    return _gen_filename("out_table", inputs=inputs)
+import os
 
 
 def out_color_default(inputs):
     return _gen_filename("out_color", inputs=inputs)
 
 
-def out_table_callable(output_dir, inputs, stdout, stderr):
+def out_table_default(inputs):
+    return _gen_filename("out_table", inputs=inputs)
+
+
+def out_color_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_table"]
+    return outputs["out_color"]
 
 
-def out_color_callable(output_dir, inputs, stdout, stderr):
+def out_table_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_color"]
+    return outputs["out_table"]
 
 
 # Original source at L3519 of <nipype-install>/interfaces/freesurfer/utils.py
diff --git a/example-specs/task/nipype/freesurfer/parse_dicom_dir_callables.py b/example-specs/task/nipype/freesurfer/parse_dicom_dir_callables.py
index 2001c30f..5b7a8799 100644
--- a/example-specs/task/nipype/freesurfer/parse_dicom_dir_callables.py
+++ b/example-specs/task/nipype/freesurfer/parse_dicom_dir_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of ParseDICOMDir.yaml"""
 
-import os
 import attrs
+import os
 
 
 def dicom_info_file_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/freesurfer/recon_all_callables.py b/example-specs/task/nipype/freesurfer/recon_all_callables.py
index bff05e41..6233b505 100644
--- a/example-specs/task/nipype/freesurfer/recon_all_callables.py
+++ b/example-specs/task/nipype/freesurfer/recon_all_callables.py
@@ -7,282 +7,277 @@ def subjects_dir_default(inputs):
     return _gen_filename("subjects_dir", inputs=inputs)
 
 
-def subjects_dir_callable(output_dir, inputs, stdout, stderr):
+def BA_stats_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["subjects_dir"]
+    return outputs["BA_stats"]
 
 
-def subject_id_callable(output_dir, inputs, stdout, stderr):
+def T1_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["subject_id"]
+    return outputs["T1"]
 
 
-def T1_callable(output_dir, inputs, stdout, stderr):
+def annot_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["T1"]
+    return outputs["annot"]
 
 
-def aseg_callable(output_dir, inputs, stdout, stderr):
+def aparc_a2009s_stats_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["aseg"]
+    return outputs["aparc_a2009s_stats"]
 
 
-def brain_callable(output_dir, inputs, stdout, stderr):
+def aparc_aseg_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["brain"]
+    return outputs["aparc_aseg"]
 
 
-def brainmask_callable(output_dir, inputs, stdout, stderr):
+def aparc_stats_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["brainmask"]
+    return outputs["aparc_stats"]
 
 
-def filled_callable(output_dir, inputs, stdout, stderr):
+def area_pial_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["filled"]
+    return outputs["area_pial"]
 
 
-def norm_callable(output_dir, inputs, stdout, stderr):
+def aseg_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["norm"]
+    return outputs["aseg"]
 
 
-def nu_callable(output_dir, inputs, stdout, stderr):
+def aseg_stats_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["nu"]
+    return outputs["aseg_stats"]
 
 
-def orig_callable(output_dir, inputs, stdout, stderr):
+def avg_curv_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["orig"]
+    return outputs["avg_curv"]
 
 
-def rawavg_callable(output_dir, inputs, stdout, stderr):
+def brain_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["rawavg"]
+    return outputs["brain"]
 
 
-def ribbon_callable(output_dir, inputs, stdout, stderr):
+def brainmask_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["ribbon"]
+    return outputs["brainmask"]
 
 
-def wm_callable(output_dir, inputs, stdout, stderr):
+def curv_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["wm"]
+    return outputs["curv"]
 
 
-def wmparc_callable(output_dir, inputs, stdout, stderr):
+def curv_pial_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["wmparc"]
+    return outputs["curv_pial"]
 
 
-def curv_callable(output_dir, inputs, stdout, stderr):
+def curv_stats_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["curv"]
+    return outputs["curv_stats"]
 
 
-def avg_curv_callable(output_dir, inputs, stdout, stderr):
+def entorhinal_exvivo_stats_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["avg_curv"]
+    return outputs["entorhinal_exvivo_stats"]
 
 
-def inflated_callable(output_dir, inputs, stdout, stderr):
+def filled_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["inflated"]
+    return outputs["filled"]
 
 
-def pial_callable(output_dir, inputs, stdout, stderr):
+def graymid_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["pial"]
+    return outputs["graymid"]
 
 
-def area_pial_callable(output_dir, inputs, stdout, stderr):
+def inflated_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["area_pial"]
+    return outputs["inflated"]
 
 
-def curv_pial_callable(output_dir, inputs, stdout, stderr):
+def jacobian_white_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["curv_pial"]
+    return outputs["jacobian_white"]
 
 
-def smoothwm_callable(output_dir, inputs, stdout, stderr):
+def label_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["smoothwm"]
+    return outputs["label"]
 
 
-def sphere_callable(output_dir, inputs, stdout, stderr):
+def norm_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["sphere"]
+    return outputs["norm"]
 
 
-def sulc_callable(output_dir, inputs, stdout, stderr):
+def nu_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["sulc"]
+    return outputs["nu"]
 
 
-def thickness_callable(output_dir, inputs, stdout, stderr):
+def orig_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["thickness"]
+    return outputs["orig"]
 
 
-def volume_callable(output_dir, inputs, stdout, stderr):
+def pial_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["volume"]
+    return outputs["pial"]
 
 
-def white_callable(output_dir, inputs, stdout, stderr):
+def rawavg_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["white"]
+    return outputs["rawavg"]
 
 
-def jacobian_white_callable(output_dir, inputs, stdout, stderr):
+def ribbon_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["jacobian_white"]
+    return outputs["ribbon"]
 
 
-def graymid_callable(output_dir, inputs, stdout, stderr):
+def smoothwm_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["graymid"]
+    return outputs["smoothwm"]
 
 
-def label_callable(output_dir, inputs, stdout, stderr):
+def sphere_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["label"]
+    return outputs["sphere"]
 
 
-def annot_callable(output_dir, inputs, stdout, stderr):
+def sphere_reg_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["annot"]
+    return outputs["sphere_reg"]
 
 
-def aparc_aseg_callable(output_dir, inputs, stdout, stderr):
+def subject_id_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["aparc_aseg"]
+    return outputs["subject_id"]
 
 
-def sphere_reg_callable(output_dir, inputs, stdout, stderr):
+def subjects_dir_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["sphere_reg"]
+    return outputs["subjects_dir"]
 
 
-def aseg_stats_callable(output_dir, inputs, stdout, stderr):
+def sulc_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["aseg_stats"]
+    return outputs["sulc"]
 
 
-def wmparc_stats_callable(output_dir, inputs, stdout, stderr):
+def thickness_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["wmparc_stats"]
+    return outputs["thickness"]
 
 
-def aparc_stats_callable(output_dir, inputs, stdout, stderr):
+def volume_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["aparc_stats"]
+    return outputs["volume"]
 
 
-def BA_stats_callable(output_dir, inputs, stdout, stderr):
+def white_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["BA_stats"]
+    return outputs["white"]
 
 
-def aparc_a2009s_stats_callable(output_dir, inputs, stdout, stderr):
+def wm_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["aparc_a2009s_stats"]
+    return outputs["wm"]
 
 
-def curv_stats_callable(output_dir, inputs, stdout, stderr):
+def wmparc_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["curv_stats"]
+    return outputs["wmparc"]
 
 
-def entorhinal_exvivo_stats_callable(output_dir, inputs, stdout, stderr):
+def wmparc_stats_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["entorhinal_exvivo_stats"]
-
-
-# Original source at L1502 of <nipype-install>/interfaces/freesurfer/preprocess.py
-def _gen_subjects_dir(inputs=None, stdout=None, stderr=None, output_dir=None):
-    return output_dir
+    return outputs["wmparc_stats"]
 
 
 # Original source at L1505 of <nipype-install>/interfaces/freesurfer/preprocess.py
@@ -294,6 +289,11 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     return None
 
 
+# Original source at L1502 of <nipype-install>/interfaces/freesurfer/preprocess.py
+def _gen_subjects_dir(inputs=None, stdout=None, stderr=None, output_dir=None):
+    return output_dir
+
+
 # Original source at L1510 of <nipype-install>/interfaces/freesurfer/preprocess.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     """
diff --git a/example-specs/task/nipype/freesurfer/register_av_ito_talairach_callables.py b/example-specs/task/nipype/freesurfer/register_av_ito_talairach_callables.py
index c931c743..9c0d1472 100644
--- a/example-specs/task/nipype/freesurfer/register_av_ito_talairach_callables.py
+++ b/example-specs/task/nipype/freesurfer/register_av_ito_talairach_callables.py
@@ -1,21 +1,20 @@
 """Module to put any functions that are referred to in the "callables" section of RegisterAVItoTalairach.yaml"""
 
 import os
-import attrs
 
 
-def out_file_callable(output_dir, inputs, stdout, stderr):
+def log_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_file"]
+    return outputs["log_file"]
 
 
-def log_file_callable(output_dir, inputs, stdout, stderr):
+def out_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["log_file"]
+    return outputs["out_file"]
 
 
 # Original source at L885 of <nipype-install>/interfaces/base/core.py
diff --git a/example-specs/task/nipype/freesurfer/register_callables.py b/example-specs/task/nipype/freesurfer/register_callables.py
index 22649f42..023a82c8 100644
--- a/example-specs/task/nipype/freesurfer/register_callables.py
+++ b/example-specs/task/nipype/freesurfer/register_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of Register.yaml"""
 
-import os
 import attrs
+import os
 
 
 def out_file_default(inputs):
diff --git a/example-specs/task/nipype/freesurfer/relabel_hypointensities_callables.py b/example-specs/task/nipype/freesurfer/relabel_hypointensities_callables.py
index 6e9bce30..21777bcf 100644
--- a/example-specs/task/nipype/freesurfer/relabel_hypointensities_callables.py
+++ b/example-specs/task/nipype/freesurfer/relabel_hypointensities_callables.py
@@ -1,7 +1,6 @@
 """Module to put any functions that are referred to in the "callables" section of RelabelHypointensities.yaml"""
 
 import os
-import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/freesurfer/remove_intersection_callables.py b/example-specs/task/nipype/freesurfer/remove_intersection_callables.py
index a53b979d..909a1ab0 100644
--- a/example-specs/task/nipype/freesurfer/remove_intersection_callables.py
+++ b/example-specs/task/nipype/freesurfer/remove_intersection_callables.py
@@ -1,7 +1,6 @@
 """Module to put any functions that are referred to in the "callables" section of RemoveIntersection.yaml"""
 
 import os
-import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/freesurfer/remove_neck_callables.py b/example-specs/task/nipype/freesurfer/remove_neck_callables.py
index 6e30bc13..5c3c3ee2 100644
--- a/example-specs/task/nipype/freesurfer/remove_neck_callables.py
+++ b/example-specs/task/nipype/freesurfer/remove_neck_callables.py
@@ -1,7 +1,6 @@
 """Module to put any functions that are referred to in the "callables" section of RemoveNeck.yaml"""
 
 import os
-import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/freesurfer/resample_callables.py b/example-specs/task/nipype/freesurfer/resample_callables.py
index 81f3fb9e..c5311398 100644
--- a/example-specs/task/nipype/freesurfer/resample_callables.py
+++ b/example-specs/task/nipype/freesurfer/resample_callables.py
@@ -1,8 +1,8 @@
 """Module to put any functions that are referred to in the "callables" section of Resample.yaml"""
 
+import attrs
 import os.path as op
 from pathlib import Path
-import attrs
 
 
 def resampled_file_default(inputs):
@@ -16,6 +16,35 @@ def resampled_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["resampled_file"]
 
 
+# Original source at L811 of <nipype-install>/interfaces/freesurfer/preprocess.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "resampled_file":
+        return _get_outfilename(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )
+    return None
+
+
+# Original source at L797 of <nipype-install>/interfaces/freesurfer/preprocess.py
+def _get_outfilename(inputs=None, stdout=None, stderr=None, output_dir=None):
+    if inputs.resampled_file is not attrs.NOTHING:
+        outfile = inputs.resampled_file
+    else:
+        outfile = fname_presuffix(
+            inputs.in_file, newpath=output_dir, suffix="_resample"
+        )
+    return outfile
+
+
+# Original source at L806 of <nipype-install>/interfaces/freesurfer/preprocess.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["resampled_file"] = _get_outfilename(
+        inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+    )
+    return outputs
+
+
 # Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
@@ -108,32 +137,3 @@ def split_filename(fname):
         fname, ext = op.splitext(fname)
 
     return pth, fname, ext
-
-
-# Original source at L797 of <nipype-install>/interfaces/freesurfer/preprocess.py
-def _get_outfilename(inputs=None, stdout=None, stderr=None, output_dir=None):
-    if inputs.resampled_file is not attrs.NOTHING:
-        outfile = inputs.resampled_file
-    else:
-        outfile = fname_presuffix(
-            inputs.in_file, newpath=output_dir, suffix="_resample"
-        )
-    return outfile
-
-
-# Original source at L811 of <nipype-install>/interfaces/freesurfer/preprocess.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "resampled_file":
-        return _get_outfilename(
-            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-        )
-    return None
-
-
-# Original source at L806 of <nipype-install>/interfaces/freesurfer/preprocess.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    outputs["resampled_file"] = _get_outfilename(
-        inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-    )
-    return outputs
diff --git a/example-specs/task/nipype/freesurfer/robust_register_callables.py b/example-specs/task/nipype/freesurfer/robust_register_callables.py
index 24c0edab..ff333d85 100644
--- a/example-specs/task/nipype/freesurfer/robust_register_callables.py
+++ b/example-specs/task/nipype/freesurfer/robust_register_callables.py
@@ -1,65 +1,64 @@
 """Module to put any functions that are referred to in the "callables" section of RobustRegister.yaml"""
 
-import attrs
 import os
 import os.path as op
 from pathlib import Path
 
 
-def out_reg_file_callable(output_dir, inputs, stdout, stderr):
+def half_source_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_reg_file"]
+    return outputs["half_source"]
 
 
-def registered_file_callable(output_dir, inputs, stdout, stderr):
+def half_source_xfm_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["registered_file"]
+    return outputs["half_source_xfm"]
 
 
-def weights_file_callable(output_dir, inputs, stdout, stderr):
+def half_targ_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["weights_file"]
+    return outputs["half_targ"]
 
 
-def half_source_callable(output_dir, inputs, stdout, stderr):
+def half_targ_xfm_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["half_source"]
+    return outputs["half_targ_xfm"]
 
 
-def half_targ_callable(output_dir, inputs, stdout, stderr):
+def half_weights_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["half_targ"]
+    return outputs["half_weights"]
 
 
-def half_weights_callable(output_dir, inputs, stdout, stderr):
+def out_reg_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["half_weights"]
+    return outputs["out_reg_file"]
 
 
-def half_source_xfm_callable(output_dir, inputs, stdout, stderr):
+def registered_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["half_source_xfm"]
+    return outputs["registered_file"]
 
 
-def half_targ_xfm_callable(output_dir, inputs, stdout, stderr):
+def weights_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["half_targ_xfm"]
+    return outputs["weights_file"]
 
 
 # Original source at L885 of <nipype-install>/interfaces/base/core.py
@@ -67,6 +66,36 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L2357 of <nipype-install>/interfaces/freesurfer/preprocess.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    cwd = output_dir
+    prefixes = dict(src=inputs.source_file, trg=inputs.target_file)
+    suffixes = dict(
+        out_reg_file=("src", "_robustreg.lta", False),
+        registered_file=("src", "_robustreg", True),
+        weights_file=("src", "_robustweights", True),
+        half_source=("src", "_halfway", True),
+        half_targ=("trg", "_halfway", True),
+        half_weights=("src", "_halfweights", True),
+        half_source_xfm=("src", "_robustxfm.lta", False),
+        half_targ_xfm=("trg", "_robustxfm.lta", False),
+    )
+    for name, sufftup in list(suffixes.items()):
+        value = getattr(inputs, name)
+        if value:
+            if value is True:
+                outputs[name] = fname_presuffix(
+                    prefixes[sufftup[0]],
+                    suffix=sufftup[1],
+                    newpath=cwd,
+                    use_ext=sufftup[2],
+                )
+            else:
+                outputs[name] = os.path.abspath(value)
+    return outputs
+
+
 # Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
@@ -159,33 +188,3 @@ def split_filename(fname):
         fname, ext = op.splitext(fname)
 
     return pth, fname, ext
-
-
-# Original source at L2357 of <nipype-install>/interfaces/freesurfer/preprocess.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    cwd = output_dir
-    prefixes = dict(src=inputs.source_file, trg=inputs.target_file)
-    suffixes = dict(
-        out_reg_file=("src", "_robustreg.lta", False),
-        registered_file=("src", "_robustreg", True),
-        weights_file=("src", "_robustweights", True),
-        half_source=("src", "_halfway", True),
-        half_targ=("trg", "_halfway", True),
-        half_weights=("src", "_halfweights", True),
-        half_source_xfm=("src", "_robustxfm.lta", False),
-        half_targ_xfm=("trg", "_robustxfm.lta", False),
-    )
-    for name, sufftup in list(suffixes.items()):
-        value = getattr(inputs, name)
-        if value:
-            if value is True:
-                outputs[name] = fname_presuffix(
-                    prefixes[sufftup[0]],
-                    suffix=sufftup[1],
-                    newpath=cwd,
-                    use_ext=sufftup[2],
-                )
-            else:
-                outputs[name] = os.path.abspath(value)
-    return outputs
diff --git a/example-specs/task/nipype/freesurfer/robust_template_callables.py b/example-specs/task/nipype/freesurfer/robust_template_callables.py
index 9e0f032a..c52ad559 100644
--- a/example-specs/task/nipype/freesurfer/robust_template_callables.py
+++ b/example-specs/task/nipype/freesurfer/robust_template_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of RobustTemplate.yaml"""
 
-import os
 import attrs
+import os
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -11,18 +11,18 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_file"]
 
 
-def transform_outputs_callable(output_dir, inputs, stdout, stderr):
+def scaled_intensity_outputs_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["transform_outputs"]
+    return outputs["scaled_intensity_outputs"]
 
 
-def scaled_intensity_outputs_callable(output_dir, inputs, stdout, stderr):
+def transform_outputs_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["scaled_intensity_outputs"]
+    return outputs["transform_outputs"]
 
 
 # Original source at L885 of <nipype-install>/interfaces/base/core.py
diff --git a/example-specs/task/nipype/freesurfer/sample_to_surface_callables.py b/example-specs/task/nipype/freesurfer/sample_to_surface_callables.py
index fbcb1623..28bbd86a 100644
--- a/example-specs/task/nipype/freesurfer/sample_to_surface_callables.py
+++ b/example-specs/task/nipype/freesurfer/sample_to_surface_callables.py
@@ -1,27 +1,27 @@
 """Module to put any functions that are referred to in the "callables" section of SampleToSurface.yaml"""
 
+import attrs
 import os
 import os.path as op
 from pathlib import Path
-import attrs
 
 
 def out_file_default(inputs):
     return _gen_filename("out_file", inputs=inputs)
 
 
-def out_file_callable(output_dir, inputs, stdout, stderr):
+def hits_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_file"]
+    return outputs["hits_file"]
 
 
-def hits_file_callable(output_dir, inputs, stdout, stderr):
+def out_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["hits_file"]
+    return outputs["out_file"]
 
 
 def vox_file_callable(output_dir, inputs, stdout, stderr):
@@ -50,6 +50,73 @@ def vox_file_callable(output_dir, inputs, stdout, stderr):
 )
 
 
+# Original source at L420 of <nipype-install>/interfaces/freesurfer/utils.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )[name]
+    return None
+
+
+# Original source at L378 of <nipype-install>/interfaces/freesurfer/utils.py
+def _get_outfilename(
+    opt="out_file", inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outfile = getattr(inputs, opt)
+    if (outfile is attrs.NOTHING) or isinstance(outfile, bool):
+        if inputs.out_type is not attrs.NOTHING:
+            if opt == "hits_file":
+                suffix = "_hits." + filemap[inputs.out_type]
+            else:
+                suffix = "." + filemap[inputs.out_type]
+        elif opt == "hits_file":
+            suffix = "_hits.mgz"
+        else:
+            suffix = ".mgz"
+        outfile = fname_presuffix(
+            inputs.source_file,
+            newpath=output_dir,
+            prefix=inputs.hemi + ".",
+            suffix=suffix,
+            use_ext=False,
+        )
+    return outfile
+
+
+# Original source at L399 of <nipype-install>/interfaces/freesurfer/utils.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = os.path.abspath(
+        _get_outfilename(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )
+    )
+    hitsfile = inputs.hits_file
+    if hitsfile is not attrs.NOTHING:
+        outputs["hits_file"] = hitsfile
+        if isinstance(hitsfile, bool):
+            hitsfile = _get_outfilename(
+                "hits_file",
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    voxfile = inputs.vox_file
+    if voxfile is not attrs.NOTHING:
+        if isinstance(voxfile, bool):
+            voxfile = fname_presuffix(
+                inputs.source_file,
+                newpath=output_dir,
+                prefix=inputs.hemi + ".",
+                suffix="_vox.txt",
+                use_ext=False,
+            )
+        outputs["vox_file"] = voxfile
+    return outputs
+
+
 # Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
@@ -142,70 +209,3 @@ def split_filename(fname):
         fname, ext = op.splitext(fname)
 
     return pth, fname, ext
-
-
-# Original source at L378 of <nipype-install>/interfaces/freesurfer/utils.py
-def _get_outfilename(
-    opt="out_file", inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    outfile = getattr(inputs, opt)
-    if (outfile is attrs.NOTHING) or isinstance(outfile, bool):
-        if inputs.out_type is not attrs.NOTHING:
-            if opt == "hits_file":
-                suffix = "_hits." + filemap[inputs.out_type]
-            else:
-                suffix = "." + filemap[inputs.out_type]
-        elif opt == "hits_file":
-            suffix = "_hits.mgz"
-        else:
-            suffix = ".mgz"
-        outfile = fname_presuffix(
-            inputs.source_file,
-            newpath=output_dir,
-            prefix=inputs.hemi + ".",
-            suffix=suffix,
-            use_ext=False,
-        )
-    return outfile
-
-
-# Original source at L420 of <nipype-install>/interfaces/freesurfer/utils.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "out_file":
-        return _list_outputs(
-            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-        )[name]
-    return None
-
-
-# Original source at L399 of <nipype-install>/interfaces/freesurfer/utils.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    outputs["out_file"] = os.path.abspath(
-        _get_outfilename(
-            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-        )
-    )
-    hitsfile = inputs.hits_file
-    if hitsfile is not attrs.NOTHING:
-        outputs["hits_file"] = hitsfile
-        if isinstance(hitsfile, bool):
-            hitsfile = _get_outfilename(
-                "hits_file",
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-    voxfile = inputs.vox_file
-    if voxfile is not attrs.NOTHING:
-        if isinstance(voxfile, bool):
-            voxfile = fname_presuffix(
-                inputs.source_file,
-                newpath=output_dir,
-                prefix=inputs.hemi + ".",
-                suffix="_vox.txt",
-                use_ext=False,
-            )
-        outputs["vox_file"] = voxfile
-    return outputs
diff --git a/example-specs/task/nipype/freesurfer/seg_stats_callables.py b/example-specs/task/nipype/freesurfer/seg_stats_callables.py
index 7e30a4fa..9976dad2 100644
--- a/example-specs/task/nipype/freesurfer/seg_stats_callables.py
+++ b/example-specs/task/nipype/freesurfer/seg_stats_callables.py
@@ -1,20 +1,20 @@
 """Module to put any functions that are referred to in the "callables" section of SegStats.yaml"""
 
+import attrs
 import os
 import os.path as op
 from pathlib import Path
-import attrs
 
 
 def summary_file_default(inputs):
     return _gen_filename("summary_file", inputs=inputs)
 
 
-def summary_file_callable(output_dir, inputs, stdout, stderr):
+def avgwf_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["summary_file"]
+    return outputs["avgwf_file"]
 
 
 def avgwf_txt_file_callable(output_dir, inputs, stdout, stderr):
@@ -24,18 +24,57 @@ def avgwf_txt_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["avgwf_txt_file"]
 
 
-def avgwf_file_callable(output_dir, inputs, stdout, stderr):
+def sf_avg_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["avgwf_file"]
+    return outputs["sf_avg_file"]
 
 
-def sf_avg_file_callable(output_dir, inputs, stdout, stderr):
+def summary_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["sf_avg_file"]
+    return outputs["summary_file"]
+
+
+# Original source at L1071 of <nipype-install>/interfaces/freesurfer/model.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "summary_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )[name]
+    return None
+
+
+# Original source at L1025 of <nipype-install>/interfaces/freesurfer/model.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    if inputs.summary_file is not attrs.NOTHING:
+        outputs["summary_file"] = os.path.abspath(inputs.summary_file)
+    else:
+        outputs["summary_file"] = os.path.join(output_dir, "summary.stats")
+    suffices = dict(
+        avgwf_txt_file="_avgwf.txt",
+        avgwf_file="_avgwf.nii.gz",
+        sf_avg_file="sfavg.txt",
+    )
+    if inputs.segmentation_file is not attrs.NOTHING:
+        _, src = os.path.split(inputs.segmentation_file)
+    if inputs.annot is not attrs.NOTHING:
+        src = "_".join(inputs.annot)
+    if inputs.surf_label is not attrs.NOTHING:
+        src = "_".join(inputs.surf_label)
+    for name, suffix in list(suffices.items()):
+        value = getattr(inputs, name)
+        if value is not attrs.NOTHING:
+            if isinstance(value, bool):
+                outputs[name] = fname_presuffix(
+                    src, suffix=suffix, newpath=output_dir, use_ext=False
+                )
+            else:
+                outputs[name] = os.path.abspath(value)
+    return outputs
 
 
 # Original source at L108 of <nipype-install>/utils/filemanip.py
@@ -130,42 +169,3 @@ def split_filename(fname):
         fname, ext = op.splitext(fname)
 
     return pth, fname, ext
-
-
-# Original source at L1071 of <nipype-install>/interfaces/freesurfer/model.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "summary_file":
-        return _list_outputs(
-            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-        )[name]
-    return None
-
-
-# Original source at L1025 of <nipype-install>/interfaces/freesurfer/model.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    if inputs.summary_file is not attrs.NOTHING:
-        outputs["summary_file"] = os.path.abspath(inputs.summary_file)
-    else:
-        outputs["summary_file"] = os.path.join(output_dir, "summary.stats")
-    suffices = dict(
-        avgwf_txt_file="_avgwf.txt",
-        avgwf_file="_avgwf.nii.gz",
-        sf_avg_file="sfavg.txt",
-    )
-    if inputs.segmentation_file is not attrs.NOTHING:
-        _, src = os.path.split(inputs.segmentation_file)
-    if inputs.annot is not attrs.NOTHING:
-        src = "_".join(inputs.annot)
-    if inputs.surf_label is not attrs.NOTHING:
-        src = "_".join(inputs.surf_label)
-    for name, suffix in list(suffices.items()):
-        value = getattr(inputs, name)
-        if value is not attrs.NOTHING:
-            if isinstance(value, bool):
-                outputs[name] = fname_presuffix(
-                    src, suffix=suffix, newpath=output_dir, use_ext=False
-                )
-            else:
-                outputs[name] = os.path.abspath(value)
-    return outputs
diff --git a/example-specs/task/nipype/freesurfer/seg_stats_recon_all_callables.py b/example-specs/task/nipype/freesurfer/seg_stats_recon_all_callables.py
index c39da23e..42dbfe62 100644
--- a/example-specs/task/nipype/freesurfer/seg_stats_recon_all_callables.py
+++ b/example-specs/task/nipype/freesurfer/seg_stats_recon_all_callables.py
@@ -1,20 +1,20 @@
 """Module to put any functions that are referred to in the "callables" section of SegStatsReconAll.yaml"""
 
+import attrs
 import os
 import os.path as op
 from pathlib import Path
-import attrs
 
 
 def summary_file_default(inputs):
     return _gen_filename("summary_file", inputs=inputs)
 
 
-def summary_file_callable(output_dir, inputs, stdout, stderr):
+def avgwf_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["summary_file"]
+    return outputs["avgwf_file"]
 
 
 def avgwf_txt_file_callable(output_dir, inputs, stdout, stderr):
@@ -24,18 +24,57 @@ def avgwf_txt_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["avgwf_txt_file"]
 
 
-def avgwf_file_callable(output_dir, inputs, stdout, stderr):
+def sf_avg_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["avgwf_file"]
+    return outputs["sf_avg_file"]
 
 
-def sf_avg_file_callable(output_dir, inputs, stdout, stderr):
+def summary_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["sf_avg_file"]
+    return outputs["summary_file"]
+
+
+# Original source at L1071 of <nipype-install>/interfaces/freesurfer/model.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "summary_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )[name]
+    return None
+
+
+# Original source at L1025 of <nipype-install>/interfaces/freesurfer/model.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    if inputs.summary_file is not attrs.NOTHING:
+        outputs["summary_file"] = os.path.abspath(inputs.summary_file)
+    else:
+        outputs["summary_file"] = os.path.join(output_dir, "summary.stats")
+    suffices = dict(
+        avgwf_txt_file="_avgwf.txt",
+        avgwf_file="_avgwf.nii.gz",
+        sf_avg_file="sfavg.txt",
+    )
+    if inputs.segmentation_file is not attrs.NOTHING:
+        _, src = os.path.split(inputs.segmentation_file)
+    if inputs.annot is not attrs.NOTHING:
+        src = "_".join(inputs.annot)
+    if inputs.surf_label is not attrs.NOTHING:
+        src = "_".join(inputs.surf_label)
+    for name, suffix in list(suffices.items()):
+        value = getattr(inputs, name)
+        if value is not attrs.NOTHING:
+            if isinstance(value, bool):
+                outputs[name] = fname_presuffix(
+                    src, suffix=suffix, newpath=output_dir, use_ext=False
+                )
+            else:
+                outputs[name] = os.path.abspath(value)
+    return outputs
 
 
 # Original source at L108 of <nipype-install>/utils/filemanip.py
@@ -130,42 +169,3 @@ def split_filename(fname):
         fname, ext = op.splitext(fname)
 
     return pth, fname, ext
-
-
-# Original source at L1071 of <nipype-install>/interfaces/freesurfer/model.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "summary_file":
-        return _list_outputs(
-            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-        )[name]
-    return None
-
-
-# Original source at L1025 of <nipype-install>/interfaces/freesurfer/model.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    if inputs.summary_file is not attrs.NOTHING:
-        outputs["summary_file"] = os.path.abspath(inputs.summary_file)
-    else:
-        outputs["summary_file"] = os.path.join(output_dir, "summary.stats")
-    suffices = dict(
-        avgwf_txt_file="_avgwf.txt",
-        avgwf_file="_avgwf.nii.gz",
-        sf_avg_file="sfavg.txt",
-    )
-    if inputs.segmentation_file is not attrs.NOTHING:
-        _, src = os.path.split(inputs.segmentation_file)
-    if inputs.annot is not attrs.NOTHING:
-        src = "_".join(inputs.annot)
-    if inputs.surf_label is not attrs.NOTHING:
-        src = "_".join(inputs.surf_label)
-    for name, suffix in list(suffices.items()):
-        value = getattr(inputs, name)
-        if value is not attrs.NOTHING:
-            if isinstance(value, bool):
-                outputs[name] = fname_presuffix(
-                    src, suffix=suffix, newpath=output_dir, use_ext=False
-                )
-            else:
-                outputs[name] = os.path.abspath(value)
-    return outputs
diff --git a/example-specs/task/nipype/freesurfer/segment_cc_callables.py b/example-specs/task/nipype/freesurfer/segment_cc_callables.py
index aa7f4f43..08ce99d7 100644
--- a/example-specs/task/nipype/freesurfer/segment_cc_callables.py
+++ b/example-specs/task/nipype/freesurfer/segment_cc_callables.py
@@ -1,7 +1,6 @@
 """Module to put any functions that are referred to in the "callables" section of SegmentCC.yaml"""
 
 import os
-import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/freesurfer/segment_wm_callables.py b/example-specs/task/nipype/freesurfer/segment_wm_callables.py
index 404d80c2..9652c4bb 100644
--- a/example-specs/task/nipype/freesurfer/segment_wm_callables.py
+++ b/example-specs/task/nipype/freesurfer/segment_wm_callables.py
@@ -1,7 +1,6 @@
 """Module to put any functions that are referred to in the "callables" section of SegmentWM.yaml"""
 
 import os
-import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/freesurfer/smooth_callables.py b/example-specs/task/nipype/freesurfer/smooth_callables.py
index 76413468..a6346cb1 100644
--- a/example-specs/task/nipype/freesurfer/smooth_callables.py
+++ b/example-specs/task/nipype/freesurfer/smooth_callables.py
@@ -1,8 +1,8 @@
 """Module to put any functions that are referred to in the "callables" section of Smooth.yaml"""
 
+import attrs
 import os.path as op
 from pathlib import Path
-import attrs
 
 
 def smoothed_file_default(inputs):
@@ -16,6 +16,69 @@ def smoothed_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["smoothed_file"]
 
 
+# Original source at L2174 of <nipype-install>/interfaces/freesurfer/preprocess.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "smoothed_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )[name]
+    return None
+
+
+# Original source at L151 of <nipype-install>/interfaces/freesurfer/base.py
+def _gen_fname(
+    basename,
+    fname=None,
+    cwd=None,
+    suffix="_fs",
+    use_ext=True,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Define a generic mapping for a single outfile
+
+    The filename is potentially autogenerated by suffixing inputs.infile
+
+    Parameters
+    ----------
+    basename : string (required)
+        filename to base the new filename on
+    fname : string
+        if not None, just use this fname
+    cwd : string
+        prefix paths with cwd, otherwise output_dir
+    suffix : string
+        default suffix
+    """
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "mris_volsmooth"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=use_ext, newpath=cwd)
+    return fname
+
+
+# Original source at L2166 of <nipype-install>/interfaces/freesurfer/preprocess.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outfile = inputs.smoothed_file
+    if outfile is attrs.NOTHING:
+        outfile = _gen_fname(
+            inputs.in_file,
+            suffix="_smooth",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    outputs["smoothed_file"] = outfile
+    return outputs
+
+
 # Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
@@ -108,66 +171,3 @@ def split_filename(fname):
         fname, ext = op.splitext(fname)
 
     return pth, fname, ext
-
-
-# Original source at L151 of <nipype-install>/interfaces/freesurfer/base.py
-def _gen_fname(
-    basename,
-    fname=None,
-    cwd=None,
-    suffix="_fs",
-    use_ext=True,
-    inputs=None,
-    stdout=None,
-    stderr=None,
-    output_dir=None,
-):
-    """Define a generic mapping for a single outfile
-
-    The filename is potentially autogenerated by suffixing inputs.infile
-
-    Parameters
-    ----------
-    basename : string (required)
-        filename to base the new filename on
-    fname : string
-        if not None, just use this fname
-    cwd : string
-        prefix paths with cwd, otherwise output_dir
-    suffix : string
-        default suffix
-    """
-    if basename == "":
-        msg = "Unable to generate filename for command %s. " % "mris_volsmooth"
-        msg += "basename is not set!"
-        raise ValueError(msg)
-    if cwd is None:
-        cwd = output_dir
-    fname = fname_presuffix(basename, suffix=suffix, use_ext=use_ext, newpath=cwd)
-    return fname
-
-
-# Original source at L2174 of <nipype-install>/interfaces/freesurfer/preprocess.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "smoothed_file":
-        return _list_outputs(
-            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-        )[name]
-    return None
-
-
-# Original source at L2166 of <nipype-install>/interfaces/freesurfer/preprocess.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    outfile = inputs.smoothed_file
-    if outfile is attrs.NOTHING:
-        outfile = _gen_fname(
-            inputs.in_file,
-            suffix="_smooth",
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-    outputs["smoothed_file"] = outfile
-    return outputs
diff --git a/example-specs/task/nipype/freesurfer/smooth_tessellation_callables.py b/example-specs/task/nipype/freesurfer/smooth_tessellation_callables.py
index fdd45bb1..e4ee4da8 100644
--- a/example-specs/task/nipype/freesurfer/smooth_tessellation_callables.py
+++ b/example-specs/task/nipype/freesurfer/smooth_tessellation_callables.py
@@ -1,8 +1,8 @@
 """Module to put any functions that are referred to in the "callables" section of SmoothTessellation.yaml"""
 
+import attrs
 import os
 import os.path as op
-import attrs
 
 
 def out_file_default(inputs):
@@ -16,6 +16,34 @@ def surface_callable(output_dir, inputs, stdout, stderr):
     return outputs["surface"]
 
 
+# Original source at L1750 of <nipype-install>/interfaces/freesurfer/utils.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _gen_outfilename(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )
+    else:
+        return None
+
+
+# Original source at L1756 of <nipype-install>/interfaces/freesurfer/utils.py
+def _gen_outfilename(inputs=None, stdout=None, stderr=None, output_dir=None):
+    if inputs.out_file is not attrs.NOTHING:
+        return os.path.abspath(inputs.out_file)
+    else:
+        _, name, ext = split_filename(inputs.in_file)
+        return os.path.abspath(name + "_smoothed" + ext)
+
+
+# Original source at L1745 of <nipype-install>/interfaces/freesurfer/utils.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["surface"] = _gen_outfilename(
+        inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+    )
+    return outputs
+
+
 # Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
@@ -65,31 +93,3 @@ def split_filename(fname):
         fname, ext = op.splitext(fname)
 
     return pth, fname, ext
-
-
-# Original source at L1756 of <nipype-install>/interfaces/freesurfer/utils.py
-def _gen_outfilename(inputs=None, stdout=None, stderr=None, output_dir=None):
-    if inputs.out_file is not attrs.NOTHING:
-        return os.path.abspath(inputs.out_file)
-    else:
-        _, name, ext = split_filename(inputs.in_file)
-        return os.path.abspath(name + "_smoothed" + ext)
-
-
-# Original source at L1750 of <nipype-install>/interfaces/freesurfer/utils.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "out_file":
-        return _gen_outfilename(
-            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-        )
-    else:
-        return None
-
-
-# Original source at L1745 of <nipype-install>/interfaces/freesurfer/utils.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    outputs["surface"] = _gen_outfilename(
-        inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-    )
-    return outputs
diff --git a/example-specs/task/nipype/freesurfer/sphere_callables.py b/example-specs/task/nipype/freesurfer/sphere_callables.py
index 123c8ea6..aebfb095 100644
--- a/example-specs/task/nipype/freesurfer/sphere_callables.py
+++ b/example-specs/task/nipype/freesurfer/sphere_callables.py
@@ -1,7 +1,6 @@
 """Module to put any functions that are referred to in the "callables" section of Sphere.yaml"""
 
 import os
-import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/freesurfer/spherical_average_callables.py b/example-specs/task/nipype/freesurfer/spherical_average_callables.py
index 6c8967cd..bcc1de1e 100644
--- a/example-specs/task/nipype/freesurfer/spherical_average_callables.py
+++ b/example-specs/task/nipype/freesurfer/spherical_average_callables.py
@@ -1,17 +1,17 @@
 """Module to put any functions that are referred to in the "callables" section of SphericalAverage.yaml"""
 
-import os
 import attrs
-
-
-def out_file_default(inputs):
-    return _gen_filename("out_file", inputs=inputs)
+import os
 
 
 def in_average_default(inputs):
     return _gen_filename("in_average", inputs=inputs)
 
 
+def out_file_default(inputs):
+    return _gen_filename("out_file", inputs=inputs)
+
+
 def out_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
diff --git a/example-specs/task/nipype/freesurfer/surface_2_vol_transform_callables.py b/example-specs/task/nipype/freesurfer/surface_2_vol_transform_callables.py
index 417ab246..ff76926e 100644
--- a/example-specs/task/nipype/freesurfer/surface_2_vol_transform_callables.py
+++ b/example-specs/task/nipype/freesurfer/surface_2_vol_transform_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of Surface2VolTransform.yaml"""
 
+import attrs
 import logging
 import os
 import os.path as op
-import attrs
 
 
 def transformed_file_callable(output_dir, inputs, stdout, stderr):
@@ -23,75 +23,6 @@ def vertexvol_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
-# Original source at L58 of <nipype-install>/utils/filemanip.py
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
-# Original source at L888 of <nipype-install>/interfaces/base/core.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    return value
-
-
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
@@ -208,3 +139,72 @@ def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
             if fname is not attrs.NOTHING:
                 outputs[out_name] = os.path.abspath(fname)
         return outputs
+
+
+# Original source at L888 of <nipype-install>/interfaces/base/core.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value
+
+
+# Original source at L58 of <nipype-install>/utils/filemanip.py
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
diff --git a/example-specs/task/nipype/freesurfer/surface_smooth_callables.py b/example-specs/task/nipype/freesurfer/surface_smooth_callables.py
index d28091ca..cbf1f52b 100644
--- a/example-specs/task/nipype/freesurfer/surface_smooth_callables.py
+++ b/example-specs/task/nipype/freesurfer/surface_smooth_callables.py
@@ -1,8 +1,8 @@
 """Module to put any functions that are referred to in the "callables" section of SurfaceSmooth.yaml"""
 
+import attrs
 import os.path as op
 from pathlib import Path
-import attrs
 
 
 def out_file_default(inputs):
@@ -16,6 +16,31 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_file"]
 
 
+# Original source at L504 of <nipype-install>/interfaces/freesurfer/utils.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )[name]
+    return None
+
+
+# Original source at L490 of <nipype-install>/interfaces/freesurfer/utils.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = inputs.out_file
+    if outputs["out_file"] is attrs.NOTHING:
+        in_file = inputs.in_file
+        if inputs.fwhm is not attrs.NOTHING:
+            kernel = inputs.fwhm
+        else:
+            kernel = inputs.smooth_iters
+        outputs["out_file"] = fname_presuffix(
+            in_file, suffix="_smooth%d" % kernel, newpath=output_dir
+        )
+    return outputs
+
+
 # Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
@@ -108,28 +133,3 @@ def split_filename(fname):
         fname, ext = op.splitext(fname)
 
     return pth, fname, ext
-
-
-# Original source at L504 of <nipype-install>/interfaces/freesurfer/utils.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "out_file":
-        return _list_outputs(
-            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-        )[name]
-    return None
-
-
-# Original source at L490 of <nipype-install>/interfaces/freesurfer/utils.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    outputs["out_file"] = inputs.out_file
-    if outputs["out_file"] is attrs.NOTHING:
-        in_file = inputs.in_file
-        if inputs.fwhm is not attrs.NOTHING:
-            kernel = inputs.fwhm
-        else:
-            kernel = inputs.smooth_iters
-        outputs["out_file"] = fname_presuffix(
-            in_file, suffix="_smooth%d" % kernel, newpath=output_dir
-        )
-    return outputs
diff --git a/example-specs/task/nipype/freesurfer/surface_snapshots_callables.py b/example-specs/task/nipype/freesurfer/surface_snapshots_callables.py
index e514023f..58048461 100644
--- a/example-specs/task/nipype/freesurfer/surface_snapshots_callables.py
+++ b/example-specs/task/nipype/freesurfer/surface_snapshots_callables.py
@@ -1,8 +1,8 @@
 """Module to put any functions that are referred to in the "callables" section of SurfaceSnapshots.yaml"""
 
+import attrs
 import os.path as op
 from pathlib import Path
-import attrs
 
 
 def tcl_script_default(inputs):
@@ -16,6 +16,83 @@ def snapshots_callable(output_dir, inputs, stdout, stderr):
     return outputs["snapshots"]
 
 
+# Original source at L1106 of <nipype-install>/interfaces/freesurfer/utils.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "tcl_script":
+        return "snapshots.tcl"
+    return None
+
+
+# Original source at L151 of <nipype-install>/interfaces/freesurfer/base.py
+def _gen_fname(
+    basename,
+    fname=None,
+    cwd=None,
+    suffix="_fs",
+    use_ext=True,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Define a generic mapping for a single outfile
+
+    The filename is potentially autogenerated by suffixing inputs.infile
+
+    Parameters
+    ----------
+    basename : string (required)
+        filename to base the new filename on
+    fname : string
+        if not None, just use this fname
+    cwd : string
+        prefix paths with cwd, otherwise output_dir
+    suffix : string
+        default suffix
+    """
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "tksurfer"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=use_ext, newpath=cwd)
+    return fname
+
+
+# Original source at L1085 of <nipype-install>/interfaces/freesurfer/utils.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    if inputs.screenshot_stem is attrs.NOTHING:
+        stem = "%s_%s_%s" % (
+            inputs.subject_id,
+            inputs.hemi,
+            inputs.surface,
+        )
+    else:
+        stem = inputs.screenshot_stem
+        stem_args = inputs.stem_template_args
+        if stem_args is not attrs.NOTHING:
+            args = tuple([getattr(inputs, arg) for arg in stem_args])
+            stem = stem % args
+    snapshots = ["%s-lat.tif", "%s-med.tif", "%s-dor.tif", "%s-ven.tif"]
+    if inputs.six_images:
+        snapshots.extend(["%s-pos.tif", "%s-ant.tif"])
+    snapshots = [
+        _gen_fname(
+            f % stem,
+            suffix="",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+        for f in snapshots
+    ]
+    outputs["snapshots"] = snapshots
+    return outputs
+
+
 # Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
@@ -108,80 +185,3 @@ def split_filename(fname):
         fname, ext = op.splitext(fname)
 
     return pth, fname, ext
-
-
-# Original source at L151 of <nipype-install>/interfaces/freesurfer/base.py
-def _gen_fname(
-    basename,
-    fname=None,
-    cwd=None,
-    suffix="_fs",
-    use_ext=True,
-    inputs=None,
-    stdout=None,
-    stderr=None,
-    output_dir=None,
-):
-    """Define a generic mapping for a single outfile
-
-    The filename is potentially autogenerated by suffixing inputs.infile
-
-    Parameters
-    ----------
-    basename : string (required)
-        filename to base the new filename on
-    fname : string
-        if not None, just use this fname
-    cwd : string
-        prefix paths with cwd, otherwise output_dir
-    suffix : string
-        default suffix
-    """
-    if basename == "":
-        msg = "Unable to generate filename for command %s. " % "tksurfer"
-        msg += "basename is not set!"
-        raise ValueError(msg)
-    if cwd is None:
-        cwd = output_dir
-    fname = fname_presuffix(basename, suffix=suffix, use_ext=use_ext, newpath=cwd)
-    return fname
-
-
-# Original source at L1106 of <nipype-install>/interfaces/freesurfer/utils.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "tcl_script":
-        return "snapshots.tcl"
-    return None
-
-
-# Original source at L1085 of <nipype-install>/interfaces/freesurfer/utils.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    if inputs.screenshot_stem is attrs.NOTHING:
-        stem = "%s_%s_%s" % (
-            inputs.subject_id,
-            inputs.hemi,
-            inputs.surface,
-        )
-    else:
-        stem = inputs.screenshot_stem
-        stem_args = inputs.stem_template_args
-        if stem_args is not attrs.NOTHING:
-            args = tuple([getattr(inputs, arg) for arg in stem_args])
-            stem = stem % args
-    snapshots = ["%s-lat.tif", "%s-med.tif", "%s-dor.tif", "%s-ven.tif"]
-    if inputs.six_images:
-        snapshots.extend(["%s-pos.tif", "%s-ant.tif"])
-    snapshots = [
-        _gen_fname(
-            f % stem,
-            suffix="",
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-        for f in snapshots
-    ]
-    outputs["snapshots"] = snapshots
-    return outputs
diff --git a/example-specs/task/nipype/freesurfer/surface_transform_callables.py b/example-specs/task/nipype/freesurfer/surface_transform_callables.py
index 20f73b1b..3b5ce568 100644
--- a/example-specs/task/nipype/freesurfer/surface_transform_callables.py
+++ b/example-specs/task/nipype/freesurfer/surface_transform_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of SurfaceTransform.yaml"""
 
+import attrs
 import os
 import os.path as op
 from pathlib import Path
-import attrs
 
 
 def out_file_default(inputs):
@@ -36,6 +36,67 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 )
 
 
+# Original source at L663 of <nipype-install>/interfaces/freesurfer/utils.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )[name]
+    return None
+
+
+# Original source at L613 of <nipype-install>/interfaces/freesurfer/utils.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = inputs.out_file
+    if outputs["out_file"] is attrs.NOTHING:
+        if inputs.source_file is not attrs.NOTHING:
+            source = inputs.source_file
+        else:
+            source = inputs.source_annot_file
+
+        # Some recon-all files don't have a proper extension (e.g. "lh.thickness")
+        # so we have to account for that here
+        bad_extensions = [
+            ".%s" % e
+            for e in [
+                "area",
+                "mid",
+                "pial",
+                "avg_curv",
+                "curv",
+                "inflated",
+                "jacobian_white",
+                "orig",
+                "nofix",
+                "smoothwm",
+                "crv",
+                "sphere",
+                "sulc",
+                "thickness",
+                "volume",
+                "white",
+            ]
+        ]
+        use_ext = True
+        if split_filename(source)[2] in bad_extensions:
+            source = source + ".stripme"
+            use_ext = False
+        ext = ""
+        if inputs.target_type is not attrs.NOTHING:
+            ext = "." + filemap[inputs.target_type]
+            use_ext = False
+        outputs["out_file"] = fname_presuffix(
+            source,
+            suffix=".%s%s" % (inputs.target_subject, ext),
+            newpath=output_dir,
+            use_ext=use_ext,
+        )
+    else:
+        outputs["out_file"] = os.path.abspath(inputs.out_file)
+    return outputs
+
+
 # Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
@@ -128,64 +189,3 @@ def split_filename(fname):
         fname, ext = op.splitext(fname)
 
     return pth, fname, ext
-
-
-# Original source at L663 of <nipype-install>/interfaces/freesurfer/utils.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "out_file":
-        return _list_outputs(
-            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-        )[name]
-    return None
-
-
-# Original source at L613 of <nipype-install>/interfaces/freesurfer/utils.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    outputs["out_file"] = inputs.out_file
-    if outputs["out_file"] is attrs.NOTHING:
-        if inputs.source_file is not attrs.NOTHING:
-            source = inputs.source_file
-        else:
-            source = inputs.source_annot_file
-
-        # Some recon-all files don't have a proper extension (e.g. "lh.thickness")
-        # so we have to account for that here
-        bad_extensions = [
-            ".%s" % e
-            for e in [
-                "area",
-                "mid",
-                "pial",
-                "avg_curv",
-                "curv",
-                "inflated",
-                "jacobian_white",
-                "orig",
-                "nofix",
-                "smoothwm",
-                "crv",
-                "sphere",
-                "sulc",
-                "thickness",
-                "volume",
-                "white",
-            ]
-        ]
-        use_ext = True
-        if split_filename(source)[2] in bad_extensions:
-            source = source + ".stripme"
-            use_ext = False
-        ext = ""
-        if inputs.target_type is not attrs.NOTHING:
-            ext = "." + filemap[inputs.target_type]
-            use_ext = False
-        outputs["out_file"] = fname_presuffix(
-            source,
-            suffix=".%s%s" % (inputs.target_subject, ext),
-            newpath=output_dir,
-            use_ext=use_ext,
-        )
-    else:
-        outputs["out_file"] = os.path.abspath(inputs.out_file)
-    return outputs
diff --git a/example-specs/task/nipype/freesurfer/synthesize_flash_callables.py b/example-specs/task/nipype/freesurfer/synthesize_flash_callables.py
index 9c1b5709..18c0f8fa 100644
--- a/example-specs/task/nipype/freesurfer/synthesize_flash_callables.py
+++ b/example-specs/task/nipype/freesurfer/synthesize_flash_callables.py
@@ -1,8 +1,8 @@
 """Module to put any functions that are referred to in the "callables" section of SynthesizeFLASH.yaml"""
 
+import attrs
 import os.path as op
 from pathlib import Path
-import attrs
 
 
 def out_file_default(inputs):
@@ -16,6 +16,69 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_file"]
 
 
+# Original source at L2523 of <nipype-install>/interfaces/freesurfer/preprocess.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )["out_file"]
+    return None
+
+
+# Original source at L151 of <nipype-install>/interfaces/freesurfer/base.py
+def _gen_fname(
+    basename,
+    fname=None,
+    cwd=None,
+    suffix="_fs",
+    use_ext=True,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Define a generic mapping for a single outfile
+
+    The filename is potentially autogenerated by suffixing inputs.infile
+
+    Parameters
+    ----------
+    basename : string (required)
+        filename to base the new filename on
+    fname : string
+        if not None, just use this fname
+    cwd : string
+        prefix paths with cwd, otherwise output_dir
+    suffix : string
+        default suffix
+    """
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "mri_synthesize"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=use_ext, newpath=cwd)
+    return fname
+
+
+# Original source at L2513 of <nipype-install>/interfaces/freesurfer/preprocess.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    if inputs.out_file is not attrs.NOTHING:
+        outputs["out_file"] = inputs.out_file
+    else:
+        outputs["out_file"] = _gen_fname(
+            "synth-flash_%02d.mgz" % inputs.flip_angle,
+            suffix="",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    return outputs
+
+
 # Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
@@ -108,66 +171,3 @@ def split_filename(fname):
         fname, ext = op.splitext(fname)
 
     return pth, fname, ext
-
-
-# Original source at L151 of <nipype-install>/interfaces/freesurfer/base.py
-def _gen_fname(
-    basename,
-    fname=None,
-    cwd=None,
-    suffix="_fs",
-    use_ext=True,
-    inputs=None,
-    stdout=None,
-    stderr=None,
-    output_dir=None,
-):
-    """Define a generic mapping for a single outfile
-
-    The filename is potentially autogenerated by suffixing inputs.infile
-
-    Parameters
-    ----------
-    basename : string (required)
-        filename to base the new filename on
-    fname : string
-        if not None, just use this fname
-    cwd : string
-        prefix paths with cwd, otherwise output_dir
-    suffix : string
-        default suffix
-    """
-    if basename == "":
-        msg = "Unable to generate filename for command %s. " % "mri_synthesize"
-        msg += "basename is not set!"
-        raise ValueError(msg)
-    if cwd is None:
-        cwd = output_dir
-    fname = fname_presuffix(basename, suffix=suffix, use_ext=use_ext, newpath=cwd)
-    return fname
-
-
-# Original source at L2523 of <nipype-install>/interfaces/freesurfer/preprocess.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "out_file":
-        return _list_outputs(
-            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-        )["out_file"]
-    return None
-
-
-# Original source at L2513 of <nipype-install>/interfaces/freesurfer/preprocess.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    if inputs.out_file is not attrs.NOTHING:
-        outputs["out_file"] = inputs.out_file
-    else:
-        outputs["out_file"] = _gen_fname(
-            "synth-flash_%02d.mgz" % inputs.flip_angle,
-            suffix="",
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-    return outputs
diff --git a/example-specs/task/nipype/freesurfer/talairach_avi_callables.py b/example-specs/task/nipype/freesurfer/talairach_avi_callables.py
index 5bb00a1d..407615b4 100644
--- a/example-specs/task/nipype/freesurfer/talairach_avi_callables.py
+++ b/example-specs/task/nipype/freesurfer/talairach_avi_callables.py
@@ -1,7 +1,6 @@
 """Module to put any functions that are referred to in the "callables" section of TalairachAVI.yaml"""
 
 import os
-import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/freesurfer/talairach_qc_callables.py b/example-specs/task/nipype/freesurfer/talairach_qc_callables.py
index 833876f7..aa450f88 100644
--- a/example-specs/task/nipype/freesurfer/talairach_qc_callables.py
+++ b/example-specs/task/nipype/freesurfer/talairach_qc_callables.py
@@ -1,7 +1,6 @@
 """Module to put any functions that are referred to in the "callables" section of TalairachQC.yaml"""
 
 import os
-import attrs
 
 
 def log_file_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/freesurfer/tkregister_2_callables.py b/example-specs/task/nipype/freesurfer/tkregister_2_callables.py
index c218e975..adb1def2 100644
--- a/example-specs/task/nipype/freesurfer/tkregister_2_callables.py
+++ b/example-specs/task/nipype/freesurfer/tkregister_2_callables.py
@@ -1,30 +1,30 @@
 """Module to put any functions that are referred to in the "callables" section of Tkregister2.yaml"""
 
+import attrs
 import os
 import os.path as op
 from pathlib import Path
-import attrs
 
 
-def reg_file_callable(output_dir, inputs, stdout, stderr):
+def fsl_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["reg_file"]
+    return outputs["fsl_file"]
 
 
-def fsl_file_callable(output_dir, inputs, stdout, stderr):
+def lta_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["fsl_file"]
+    return outputs["lta_file"]
 
 
-def lta_file_callable(output_dir, inputs, stdout, stderr):
+def reg_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["lta_file"]
+    return outputs["reg_file"]
 
 
 # Original source at L885 of <nipype-install>/interfaces/base/core.py
@@ -32,6 +32,33 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L1973 of <nipype-install>/interfaces/freesurfer/utils.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    reg_file = os.path.abspath(inputs.reg_file)
+    outputs["reg_file"] = reg_file
+
+    cwd = output_dir
+    fsl_out = inputs.fsl_out
+    if fsl_out is not attrs.NOTHING:
+        if fsl_out is True:
+            outputs["fsl_file"] = fname_presuffix(
+                reg_file, suffix=".mat", newpath=cwd, use_ext=False
+            )
+        else:
+            outputs["fsl_file"] = os.path.abspath(inputs.fsl_out)
+
+    lta_out = inputs.lta_out
+    if lta_out is not attrs.NOTHING:
+        if lta_out is True:
+            outputs["lta_file"] = fname_presuffix(
+                reg_file, suffix=".lta", newpath=cwd, use_ext=False
+            )
+        else:
+            outputs["lta_file"] = os.path.abspath(inputs.lta_out)
+    return outputs
+
+
 # Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
@@ -124,30 +151,3 @@ def split_filename(fname):
         fname, ext = op.splitext(fname)
 
     return pth, fname, ext
-
-
-# Original source at L1973 of <nipype-install>/interfaces/freesurfer/utils.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    reg_file = os.path.abspath(inputs.reg_file)
-    outputs["reg_file"] = reg_file
-
-    cwd = output_dir
-    fsl_out = inputs.fsl_out
-    if fsl_out is not attrs.NOTHING:
-        if fsl_out is True:
-            outputs["fsl_file"] = fname_presuffix(
-                reg_file, suffix=".mat", newpath=cwd, use_ext=False
-            )
-        else:
-            outputs["fsl_file"] = os.path.abspath(inputs.fsl_out)
-
-    lta_out = inputs.lta_out
-    if lta_out is not attrs.NOTHING:
-        if lta_out is True:
-            outputs["lta_file"] = fname_presuffix(
-                reg_file, suffix=".lta", newpath=cwd, use_ext=False
-            )
-        else:
-            outputs["lta_file"] = os.path.abspath(inputs.lta_out)
-    return outputs
diff --git a/example-specs/task/nipype/freesurfer/unpack_sdicom_dir_callables.py b/example-specs/task/nipype/freesurfer/unpack_sdicom_dir_callables.py
index c6db768b..2b2445e7 100644
--- a/example-specs/task/nipype/freesurfer/unpack_sdicom_dir_callables.py
+++ b/example-specs/task/nipype/freesurfer/unpack_sdicom_dir_callables.py
@@ -1,80 +1,12 @@
 """Module to put any functions that are referred to in the "callables" section of UnpackSDICOMDir.yaml"""
 
+import attrs
 import logging
 import os
 import os.path as op
-import attrs
-
-iflogger = logging.getLogger("nipype.interface")
-
-
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
-# Original source at L58 of <nipype-install>/utils/filemanip.py
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
 
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
 
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
-# Original source at L888 of <nipype-install>/interfaces/base/core.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    return value
+iflogger = logging.getLogger("nipype.interface")
 
 
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
@@ -193,3 +125,72 @@ def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
             if fname is not attrs.NOTHING:
                 outputs[out_name] = os.path.abspath(fname)
         return outputs
+
+
+# Original source at L888 of <nipype-install>/interfaces/base/core.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value
+
+
+# Original source at L58 of <nipype-install>/utils/filemanip.py
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
diff --git a/example-specs/task/nipype/freesurfer/volume_mask_callables.py b/example-specs/task/nipype/freesurfer/volume_mask_callables.py
index cb811151..372e4ff3 100644
--- a/example-specs/task/nipype/freesurfer/volume_mask_callables.py
+++ b/example-specs/task/nipype/freesurfer/volume_mask_callables.py
@@ -1,21 +1,20 @@
 """Module to put any functions that are referred to in the "callables" section of VolumeMask.yaml"""
 
 import os
-import attrs
 
 
-def out_ribbon_callable(output_dir, inputs, stdout, stderr):
+def lh_ribbon_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_ribbon"]
+    return outputs["lh_ribbon"]
 
 
-def lh_ribbon_callable(output_dir, inputs, stdout, stderr):
+def out_ribbon_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["lh_ribbon"]
+    return outputs["out_ribbon"]
 
 
 def rh_ribbon_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/freesurfer/watershed_skull_strip_callables.py b/example-specs/task/nipype/freesurfer/watershed_skull_strip_callables.py
index 4019b9af..777811cd 100644
--- a/example-specs/task/nipype/freesurfer/watershed_skull_strip_callables.py
+++ b/example-specs/task/nipype/freesurfer/watershed_skull_strip_callables.py
@@ -1,7 +1,6 @@
 """Module to put any functions that are referred to in the "callables" section of WatershedSkullStrip.yaml"""
 
 import os
-import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/fsl/accuracy_tester_callables.py b/example-specs/task/nipype/fsl/accuracy_tester_callables.py
index ff348117..d6e4893b 100644
--- a/example-specs/task/nipype/fsl/accuracy_tester_callables.py
+++ b/example-specs/task/nipype/fsl/accuracy_tester_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of AccuracyTester.yaml"""
 
-from fileformats.generic import Directory
 import attrs
+from fileformats.generic import Directory
 
 
 def output_directory_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/fsl/apply_mask_callables.py b/example-specs/task/nipype/fsl/apply_mask_callables.py
index 61903295..fcd5f27c 100644
--- a/example-specs/task/nipype/fsl/apply_mask_callables.py
+++ b/example-specs/task/nipype/fsl/apply_mask_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of ApplyMask.yaml"""
 
-from glob import glob
 import attrs
 import logging
 import os
 import os.path as op
+from glob import glob
 from pathlib import Path
 
 
@@ -22,42 +22,86 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
+# Original source at L61 of <nipype-install>/interfaces/fsl/maths.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )["out_file"]
+    return None
 
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
 
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
 
-            klass._version = klass.parse_version(raw_info)
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
 
-        return klass._version
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
 
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "fslmaths"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+# Original source at L51 of <nipype-install>/interfaces/fsl/maths.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = inputs.out_file
+    if inputs.out_file is attrs.NOTHING:
+        outputs["out_file"] = _gen_fname(
+            inputs.in_file,
+            suffix=_suffix,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    outputs["out_file"] = os.path.abspath(outputs["out_file"])
+    return outputs
 
 
 # Original source at L108 of <nipype-install>/utils/filemanip.py
@@ -154,6 +198,44 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
@@ -245,85 +327,3 @@ def standard_image(img_name=None):
                 for filename in glob(os.path.join(stdpath, "*nii*"))
             ]
         return os.path.join(stdpath, img_name)
-
-
-# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
-def _gen_fname(
-    basename,
-    cwd=None,
-    suffix=None,
-    change_ext=True,
-    ext=None,
-    inputs=None,
-    stdout=None,
-    stderr=None,
-    output_dir=None,
-):
-    """Generate a filename based on the given parameters.
-
-    The filename will take the form: cwd/basename<suffix><ext>.
-    If change_ext is True, it will use the extensions specified in
-    <instance>inputs.output_type.
-
-    Parameters
-    ----------
-    basename : str
-        Filename to base the new filename on.
-    cwd : str
-        Path to prefix to the new filename. (default is output_dir)
-    suffix : str
-        Suffix to add to the `basename`.  (defaults is '' )
-    change_ext : bool
-        Flag to change the filename extension to the FSL output type.
-        (default True)
-
-    Returns
-    -------
-    fname : str
-        New filename based on given parameters.
-
-    """
-
-    if basename == "":
-        msg = "Unable to generate filename for command %s. " % "fslmaths"
-        msg += "basename is not set!"
-        raise ValueError(msg)
-    if cwd is None:
-        cwd = output_dir
-    if ext is None:
-        ext = Info.output_type_to_ext(inputs.output_type)
-    if change_ext:
-        if suffix:
-            suffix = "".join((suffix, ext))
-        else:
-            suffix = ext
-    if suffix is None:
-        suffix = ""
-    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
-    return fname
-
-
-# Original source at L61 of <nipype-install>/interfaces/fsl/maths.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "out_file":
-        return _list_outputs(
-            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-        )["out_file"]
-    return None
-
-
-# Original source at L51 of <nipype-install>/interfaces/fsl/maths.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    outputs["out_file"] = inputs.out_file
-    if inputs.out_file is attrs.NOTHING:
-        outputs["out_file"] = _gen_fname(
-            inputs.in_file,
-            suffix=_suffix,
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-    outputs["out_file"] = os.path.abspath(outputs["out_file"])
-    return outputs
diff --git a/example-specs/task/nipype/fsl/apply_topup_callables.py b/example-specs/task/nipype/fsl/apply_topup_callables.py
index 8f59a046..6ae5fc5c 100644
--- a/example-specs/task/nipype/fsl/apply_topup_callables.py
+++ b/example-specs/task/nipype/fsl/apply_topup_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of ApplyTOPUP.yaml"""
 
-from glob import glob
 import attrs
 import logging
 import os
 import os.path as op
+from glob import glob
 
 
 def out_corrected_callable(output_dir, inputs, stdout, stderr):
@@ -20,6 +20,182 @@ def out_corrected_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+# Original source at L249 of <nipype-install>/interfaces/fsl/base.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value + Info.output_type_to_ext(inputs.output_type)
+
+
+# Original source at L58 of <nipype-install>/utils/filemanip.py
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
 # Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
@@ -151,13 +327,6 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
-# Original source at L249 of <nipype-install>/interfaces/fsl/base.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    return value + Info.output_type_to_ext(inputs.output_type)
-
-
 # Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
@@ -167,172 +336,3 @@ def __init__(self, value):
 
     def __str__(self):
         return "{}".format(self.value)
-
-
-# Original source at L58 of <nipype-install>/utils/filemanip.py
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
-# Original source at L809 of <nipype-install>/interfaces/base/core.py
-def _filename_from_source(
-    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    if chain is None:
-        chain = []
-
-    trait_spec = inputs.trait(name)
-    retval = getattr(inputs, name)
-    source_ext = None
-    if (retval is attrs.NOTHING) or "%s" in retval:
-        if not trait_spec.name_source:
-            return retval
-
-        # Do not generate filename when excluded by other inputs
-        if any(
-            (getattr(inputs, field) is not attrs.NOTHING)
-            for field in trait_spec.xor or ()
-        ):
-            return retval
-
-        # Do not generate filename when required fields are missing
-        if not all(
-            (getattr(inputs, field) is not attrs.NOTHING)
-            for field in trait_spec.requires or ()
-        ):
-            return retval
-
-        if (retval is not attrs.NOTHING) and "%s" in retval:
-            name_template = retval
-        else:
-            name_template = trait_spec.name_template
-        if not name_template:
-            name_template = "%s_generated"
-
-        ns = trait_spec.name_source
-        while isinstance(ns, (list, tuple)):
-            if len(ns) > 1:
-                iflogger.warning("Only one name_source per trait is allowed")
-            ns = ns[0]
-
-        if not isinstance(ns, (str, bytes)):
-            raise ValueError(
-                "name_source of '{}' trait should be an input trait "
-                "name, but a type {} object was found".format(name, type(ns))
-            )
-
-        if getattr(inputs, ns) is not attrs.NOTHING:
-            name_source = ns
-            source = getattr(inputs, name_source)
-            while isinstance(source, list):
-                source = source[0]
-
-            # special treatment for files
-            try:
-                _, base, source_ext = split_filename(source)
-            except (AttributeError, TypeError):
-                base = source
-        else:
-            if name in chain:
-                raise NipypeInterfaceError("Mutually pointing name_sources")
-
-            chain.append(name)
-            base = _filename_from_source(
-                ns,
-                chain,
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-            if base is not attrs.NOTHING:
-                _, _, source_ext = split_filename(base)
-            else:
-                # Do not generate filename when required fields are missing
-                return retval
-
-        chain = None
-        retval = name_template % base
-        _, _, ext = split_filename(retval)
-        if trait_spec.keep_extension and (ext or source_ext):
-            if (ext is None or not ext) and source_ext:
-                retval = retval + source_ext
-        else:
-            retval = _overload_extension(
-                retval,
-                name,
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-    return retval
-
-
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
-# Original source at L891 of <nipype-install>/interfaces/base/core.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    metadata = dict(name_source=lambda t: t is not None)
-    traits = inputs.traits(**metadata)
-    if traits:
-        outputs = {}
-        for name, trait_spec in list(traits.items()):
-            out_name = name
-            if trait_spec.output_name is not None:
-                out_name = trait_spec.output_name
-            fname = _filename_from_source(
-                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-            )
-            if fname is not attrs.NOTHING:
-                outputs[out_name] = os.path.abspath(fname)
-        return outputs
diff --git a/example-specs/task/nipype/fsl/apply_warp_callables.py b/example-specs/task/nipype/fsl/apply_warp_callables.py
index cff717fd..6d2586d7 100644
--- a/example-specs/task/nipype/fsl/apply_warp_callables.py
+++ b/example-specs/task/nipype/fsl/apply_warp_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of ApplyWarp.yaml"""
 
-from glob import glob
 import attrs
 import logging
 import os
 import os.path as op
+from glob import glob
 from pathlib import Path
 
 
@@ -22,42 +22,86 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
+# Original source at L1494 of <nipype-install>/interfaces/fsl/preprocess.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )[name]
+    return None
 
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
 
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
 
-            klass._version = klass.parse_version(raw_info)
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
 
-        return klass._version
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
 
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "applywarp"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+# Original source at L1486 of <nipype-install>/interfaces/fsl/preprocess.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    if inputs.out_file is attrs.NOTHING:
+        outputs["out_file"] = _gen_fname(
+            inputs.in_file,
+            suffix="_warp",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    else:
+        outputs["out_file"] = os.path.abspath(inputs.out_file)
+    return outputs
 
 
 # Original source at L108 of <nipype-install>/utils/filemanip.py
@@ -154,6 +198,44 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
@@ -245,85 +327,3 @@ def standard_image(img_name=None):
                 for filename in glob(os.path.join(stdpath, "*nii*"))
             ]
         return os.path.join(stdpath, img_name)
-
-
-# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
-def _gen_fname(
-    basename,
-    cwd=None,
-    suffix=None,
-    change_ext=True,
-    ext=None,
-    inputs=None,
-    stdout=None,
-    stderr=None,
-    output_dir=None,
-):
-    """Generate a filename based on the given parameters.
-
-    The filename will take the form: cwd/basename<suffix><ext>.
-    If change_ext is True, it will use the extensions specified in
-    <instance>inputs.output_type.
-
-    Parameters
-    ----------
-    basename : str
-        Filename to base the new filename on.
-    cwd : str
-        Path to prefix to the new filename. (default is output_dir)
-    suffix : str
-        Suffix to add to the `basename`.  (defaults is '' )
-    change_ext : bool
-        Flag to change the filename extension to the FSL output type.
-        (default True)
-
-    Returns
-    -------
-    fname : str
-        New filename based on given parameters.
-
-    """
-
-    if basename == "":
-        msg = "Unable to generate filename for command %s. " % "applywarp"
-        msg += "basename is not set!"
-        raise ValueError(msg)
-    if cwd is None:
-        cwd = output_dir
-    if ext is None:
-        ext = Info.output_type_to_ext(inputs.output_type)
-    if change_ext:
-        if suffix:
-            suffix = "".join((suffix, ext))
-        else:
-            suffix = ext
-    if suffix is None:
-        suffix = ""
-    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
-    return fname
-
-
-# Original source at L1494 of <nipype-install>/interfaces/fsl/preprocess.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "out_file":
-        return _list_outputs(
-            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-        )[name]
-    return None
-
-
-# Original source at L1486 of <nipype-install>/interfaces/fsl/preprocess.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    if inputs.out_file is attrs.NOTHING:
-        outputs["out_file"] = _gen_fname(
-            inputs.in_file,
-            suffix="_warp",
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-    else:
-        outputs["out_file"] = os.path.abspath(inputs.out_file)
-    return outputs
diff --git a/example-specs/task/nipype/fsl/apply_xfm_callables.py b/example-specs/task/nipype/fsl/apply_xfm_callables.py
index 5e7ef67b..6b019b95 100644
--- a/example-specs/task/nipype/fsl/apply_xfm_callables.py
+++ b/example-specs/task/nipype/fsl/apply_xfm_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of ApplyXFM.yaml"""
 
-from glob import glob
 import attrs
 import logging
 import os
 import os.path as op
+from glob import glob
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -14,18 +14,18 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_file"]
 
 
-def out_matrix_file_callable(output_dir, inputs, stdout, stderr):
+def out_log_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_matrix_file"]
+    return outputs["out_log"]
 
 
-def out_log_callable(output_dir, inputs, stdout, stderr):
+def out_matrix_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_log"]
+    return outputs["out_matrix_file"]
 
 
 IFLOGGER = logging.getLogger("nipype.interface")
@@ -34,6 +34,182 @@ def out_log_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+# Original source at L249 of <nipype-install>/interfaces/fsl/base.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value + Info.output_type_to_ext(inputs.output_type)
+
+
+# Original source at L58 of <nipype-install>/utils/filemanip.py
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
 # Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
@@ -165,13 +341,6 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
-# Original source at L249 of <nipype-install>/interfaces/fsl/base.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    return value + Info.output_type_to_ext(inputs.output_type)
-
-
 # Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
@@ -181,172 +350,3 @@ def __init__(self, value):
 
     def __str__(self):
         return "{}".format(self.value)
-
-
-# Original source at L58 of <nipype-install>/utils/filemanip.py
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
-# Original source at L809 of <nipype-install>/interfaces/base/core.py
-def _filename_from_source(
-    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    if chain is None:
-        chain = []
-
-    trait_spec = inputs.trait(name)
-    retval = getattr(inputs, name)
-    source_ext = None
-    if (retval is attrs.NOTHING) or "%s" in retval:
-        if not trait_spec.name_source:
-            return retval
-
-        # Do not generate filename when excluded by other inputs
-        if any(
-            (getattr(inputs, field) is not attrs.NOTHING)
-            for field in trait_spec.xor or ()
-        ):
-            return retval
-
-        # Do not generate filename when required fields are missing
-        if not all(
-            (getattr(inputs, field) is not attrs.NOTHING)
-            for field in trait_spec.requires or ()
-        ):
-            return retval
-
-        if (retval is not attrs.NOTHING) and "%s" in retval:
-            name_template = retval
-        else:
-            name_template = trait_spec.name_template
-        if not name_template:
-            name_template = "%s_generated"
-
-        ns = trait_spec.name_source
-        while isinstance(ns, (list, tuple)):
-            if len(ns) > 1:
-                iflogger.warning("Only one name_source per trait is allowed")
-            ns = ns[0]
-
-        if not isinstance(ns, (str, bytes)):
-            raise ValueError(
-                "name_source of '{}' trait should be an input trait "
-                "name, but a type {} object was found".format(name, type(ns))
-            )
-
-        if getattr(inputs, ns) is not attrs.NOTHING:
-            name_source = ns
-            source = getattr(inputs, name_source)
-            while isinstance(source, list):
-                source = source[0]
-
-            # special treatment for files
-            try:
-                _, base, source_ext = split_filename(source)
-            except (AttributeError, TypeError):
-                base = source
-        else:
-            if name in chain:
-                raise NipypeInterfaceError("Mutually pointing name_sources")
-
-            chain.append(name)
-            base = _filename_from_source(
-                ns,
-                chain,
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-            if base is not attrs.NOTHING:
-                _, _, source_ext = split_filename(base)
-            else:
-                # Do not generate filename when required fields are missing
-                return retval
-
-        chain = None
-        retval = name_template % base
-        _, _, ext = split_filename(retval)
-        if trait_spec.keep_extension and (ext or source_ext):
-            if (ext is None or not ext) and source_ext:
-                retval = retval + source_ext
-        else:
-            retval = _overload_extension(
-                retval,
-                name,
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-    return retval
-
-
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
-# Original source at L891 of <nipype-install>/interfaces/base/core.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    metadata = dict(name_source=lambda t: t is not None)
-    traits = inputs.traits(**metadata)
-    if traits:
-        outputs = {}
-        for name, trait_spec in list(traits.items()):
-            out_name = name
-            if trait_spec.output_name is not None:
-                out_name = trait_spec.output_name
-            fname = _filename_from_source(
-                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-            )
-            if fname is not attrs.NOTHING:
-                outputs[out_name] = os.path.abspath(fname)
-        return outputs
diff --git a/example-specs/task/nipype/fsl/ar1_image_callables.py b/example-specs/task/nipype/fsl/ar1_image_callables.py
index 147bb098..aee11088 100644
--- a/example-specs/task/nipype/fsl/ar1_image_callables.py
+++ b/example-specs/task/nipype/fsl/ar1_image_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of AR1Image.yaml"""
 
-from glob import glob
 import attrs
 import logging
 import os
 import os.path as op
+from glob import glob
 from pathlib import Path
 
 
@@ -22,42 +22,86 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
+# Original source at L61 of <nipype-install>/interfaces/fsl/maths.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )["out_file"]
+    return None
 
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
 
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
 
-            klass._version = klass.parse_version(raw_info)
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
 
-        return klass._version
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
 
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "fslmaths"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+# Original source at L51 of <nipype-install>/interfaces/fsl/maths.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = inputs.out_file
+    if inputs.out_file is attrs.NOTHING:
+        outputs["out_file"] = _gen_fname(
+            inputs.in_file,
+            suffix=_suffix,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    outputs["out_file"] = os.path.abspath(outputs["out_file"])
+    return outputs
 
 
 # Original source at L108 of <nipype-install>/utils/filemanip.py
@@ -154,6 +198,44 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
@@ -245,85 +327,3 @@ def standard_image(img_name=None):
                 for filename in glob(os.path.join(stdpath, "*nii*"))
             ]
         return os.path.join(stdpath, img_name)
-
-
-# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
-def _gen_fname(
-    basename,
-    cwd=None,
-    suffix=None,
-    change_ext=True,
-    ext=None,
-    inputs=None,
-    stdout=None,
-    stderr=None,
-    output_dir=None,
-):
-    """Generate a filename based on the given parameters.
-
-    The filename will take the form: cwd/basename<suffix><ext>.
-    If change_ext is True, it will use the extensions specified in
-    <instance>inputs.output_type.
-
-    Parameters
-    ----------
-    basename : str
-        Filename to base the new filename on.
-    cwd : str
-        Path to prefix to the new filename. (default is output_dir)
-    suffix : str
-        Suffix to add to the `basename`.  (defaults is '' )
-    change_ext : bool
-        Flag to change the filename extension to the FSL output type.
-        (default True)
-
-    Returns
-    -------
-    fname : str
-        New filename based on given parameters.
-
-    """
-
-    if basename == "":
-        msg = "Unable to generate filename for command %s. " % "fslmaths"
-        msg += "basename is not set!"
-        raise ValueError(msg)
-    if cwd is None:
-        cwd = output_dir
-    if ext is None:
-        ext = Info.output_type_to_ext(inputs.output_type)
-    if change_ext:
-        if suffix:
-            suffix = "".join((suffix, ext))
-        else:
-            suffix = ext
-    if suffix is None:
-        suffix = ""
-    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
-    return fname
-
-
-# Original source at L61 of <nipype-install>/interfaces/fsl/maths.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "out_file":
-        return _list_outputs(
-            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-        )["out_file"]
-    return None
-
-
-# Original source at L51 of <nipype-install>/interfaces/fsl/maths.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    outputs["out_file"] = inputs.out_file
-    if inputs.out_file is attrs.NOTHING:
-        outputs["out_file"] = _gen_fname(
-            inputs.in_file,
-            suffix=_suffix,
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-    outputs["out_file"] = os.path.abspath(outputs["out_file"])
-    return outputs
diff --git a/example-specs/task/nipype/fsl/av_scale_callables.py b/example-specs/task/nipype/fsl/av_scale_callables.py
index 6a870f78..a26202f3 100644
--- a/example-specs/task/nipype/fsl/av_scale_callables.py
+++ b/example-specs/task/nipype/fsl/av_scale_callables.py
@@ -1,69 +1,67 @@
 """Module to put any functions that are referred to in the "callables" section of AvScale.yaml"""
 
-import attrs
 
-
-def rotation_translation_matrix_callable(output_dir, inputs, stdout, stderr):
+def average_scaling_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["rotation_translation_matrix"]
+    return outputs["average_scaling"]
 
 
-def scales_callable(output_dir, inputs, stdout, stderr):
+def backward_half_transform_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["scales"]
+    return outputs["backward_half_transform"]
 
 
-def skews_callable(output_dir, inputs, stdout, stderr):
+def determinant_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["skews"]
+    return outputs["determinant"]
 
 
-def average_scaling_callable(output_dir, inputs, stdout, stderr):
+def forward_half_transform_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["average_scaling"]
+    return outputs["forward_half_transform"]
 
 
-def determinant_callable(output_dir, inputs, stdout, stderr):
+def left_right_orientation_preserved_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["determinant"]
+    return outputs["left_right_orientation_preserved"]
 
 
-def forward_half_transform_callable(output_dir, inputs, stdout, stderr):
+def rot_angles_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["forward_half_transform"]
+    return outputs["rot_angles"]
 
 
-def backward_half_transform_callable(output_dir, inputs, stdout, stderr):
+def rotation_translation_matrix_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["backward_half_transform"]
+    return outputs["rotation_translation_matrix"]
 
 
-def left_right_orientation_preserved_callable(output_dir, inputs, stdout, stderr):
+def scales_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["left_right_orientation_preserved"]
+    return outputs["scales"]
 
 
-def rot_angles_callable(output_dir, inputs, stdout, stderr):
+def skews_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["rot_angles"]
+    return outputs["skews"]
 
 
 def translations_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/fsl/b0_calc_callables.py b/example-specs/task/nipype/fsl/b0_calc_callables.py
index a925759c..1a08f4fd 100644
--- a/example-specs/task/nipype/fsl/b0_calc_callables.py
+++ b/example-specs/task/nipype/fsl/b0_calc_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of B0Calc.yaml"""
 
-from glob import glob
 import attrs
 import logging
 import os
 import os.path as op
+from glob import glob
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -20,6 +20,182 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+# Original source at L249 of <nipype-install>/interfaces/fsl/base.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value + Info.output_type_to_ext(inputs.output_type)
+
+
+# Original source at L58 of <nipype-install>/utils/filemanip.py
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
 # Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
@@ -151,13 +327,6 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
-# Original source at L249 of <nipype-install>/interfaces/fsl/base.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    return value + Info.output_type_to_ext(inputs.output_type)
-
-
 # Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
@@ -167,172 +336,3 @@ def __init__(self, value):
 
     def __str__(self):
         return "{}".format(self.value)
-
-
-# Original source at L58 of <nipype-install>/utils/filemanip.py
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
-# Original source at L809 of <nipype-install>/interfaces/base/core.py
-def _filename_from_source(
-    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    if chain is None:
-        chain = []
-
-    trait_spec = inputs.trait(name)
-    retval = getattr(inputs, name)
-    source_ext = None
-    if (retval is attrs.NOTHING) or "%s" in retval:
-        if not trait_spec.name_source:
-            return retval
-
-        # Do not generate filename when excluded by other inputs
-        if any(
-            (getattr(inputs, field) is not attrs.NOTHING)
-            for field in trait_spec.xor or ()
-        ):
-            return retval
-
-        # Do not generate filename when required fields are missing
-        if not all(
-            (getattr(inputs, field) is not attrs.NOTHING)
-            for field in trait_spec.requires or ()
-        ):
-            return retval
-
-        if (retval is not attrs.NOTHING) and "%s" in retval:
-            name_template = retval
-        else:
-            name_template = trait_spec.name_template
-        if not name_template:
-            name_template = "%s_generated"
-
-        ns = trait_spec.name_source
-        while isinstance(ns, (list, tuple)):
-            if len(ns) > 1:
-                iflogger.warning("Only one name_source per trait is allowed")
-            ns = ns[0]
-
-        if not isinstance(ns, (str, bytes)):
-            raise ValueError(
-                "name_source of '{}' trait should be an input trait "
-                "name, but a type {} object was found".format(name, type(ns))
-            )
-
-        if getattr(inputs, ns) is not attrs.NOTHING:
-            name_source = ns
-            source = getattr(inputs, name_source)
-            while isinstance(source, list):
-                source = source[0]
-
-            # special treatment for files
-            try:
-                _, base, source_ext = split_filename(source)
-            except (AttributeError, TypeError):
-                base = source
-        else:
-            if name in chain:
-                raise NipypeInterfaceError("Mutually pointing name_sources")
-
-            chain.append(name)
-            base = _filename_from_source(
-                ns,
-                chain,
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-            if base is not attrs.NOTHING:
-                _, _, source_ext = split_filename(base)
-            else:
-                # Do not generate filename when required fields are missing
-                return retval
-
-        chain = None
-        retval = name_template % base
-        _, _, ext = split_filename(retval)
-        if trait_spec.keep_extension and (ext or source_ext):
-            if (ext is None or not ext) and source_ext:
-                retval = retval + source_ext
-        else:
-            retval = _overload_extension(
-                retval,
-                name,
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-    return retval
-
-
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
-# Original source at L891 of <nipype-install>/interfaces/base/core.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    metadata = dict(name_source=lambda t: t is not None)
-    traits = inputs.traits(**metadata)
-    if traits:
-        outputs = {}
-        for name, trait_spec in list(traits.items()):
-            out_name = name
-            if trait_spec.output_name is not None:
-                out_name = trait_spec.output_name
-            fname = _filename_from_source(
-                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-            )
-            if fname is not attrs.NOTHING:
-                outputs[out_name] = os.path.abspath(fname)
-        return outputs
diff --git a/example-specs/task/nipype/fsl/bedpostx5_callables.py b/example-specs/task/nipype/fsl/bedpostx5_callables.py
index 9d320bbc..8525bc40 100644
--- a/example-specs/task/nipype/fsl/bedpostx5_callables.py
+++ b/example-specs/task/nipype/fsl/bedpostx5_callables.py
@@ -1,25 +1,24 @@
 """Module to put any functions that are referred to in the "callables" section of BEDPOSTX5.yaml"""
 
-import attrs
-from glob import glob
 import logging
 import os
 import os.path as op
+from glob import glob
 from pathlib import Path
 
 
-def mean_dsamples_callable(output_dir, inputs, stdout, stderr):
+def dyads_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["mean_dsamples"]
+    return outputs["dyads"]
 
 
-def mean_fsamples_callable(output_dir, inputs, stdout, stderr):
+def dyads_dispersion_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["mean_fsamples"]
+    return outputs["dyads_dispersion"]
 
 
 def mean_S0samples_callable(output_dir, inputs, stdout, stderr):
@@ -29,32 +28,32 @@ def mean_S0samples_callable(output_dir, inputs, stdout, stderr):
     return outputs["mean_S0samples"]
 
 
-def mean_phsamples_callable(output_dir, inputs, stdout, stderr):
+def mean_dsamples_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["mean_phsamples"]
+    return outputs["mean_dsamples"]
 
 
-def mean_thsamples_callable(output_dir, inputs, stdout, stderr):
+def mean_fsamples_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["mean_thsamples"]
+    return outputs["mean_fsamples"]
 
 
-def merged_thsamples_callable(output_dir, inputs, stdout, stderr):
+def mean_phsamples_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["merged_thsamples"]
+    return outputs["mean_phsamples"]
 
 
-def merged_phsamples_callable(output_dir, inputs, stdout, stderr):
+def mean_thsamples_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["merged_phsamples"]
+    return outputs["mean_thsamples"]
 
 
 def merged_fsamples_callable(output_dir, inputs, stdout, stderr):
@@ -64,59 +63,197 @@ def merged_fsamples_callable(output_dir, inputs, stdout, stderr):
     return outputs["merged_fsamples"]
 
 
-def dyads_callable(output_dir, inputs, stdout, stderr):
+def merged_phsamples_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["dyads"]
+    return outputs["merged_phsamples"]
 
 
-def dyads_dispersion_callable(output_dir, inputs, stdout, stderr):
+def merged_thsamples_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["dyads_dispersion"]
+    return outputs["merged_thsamples"]
 
 
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
 
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
 
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
 
-            klass._version = klass.parse_version(raw_info)
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
 
-        return klass._version
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
 
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "bedpostx"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+# Original source at L483 of <nipype-install>/interfaces/fsl/dti.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    n_fibres = inputs.n_fibres
+
+    multi_out = [
+        "merged_thsamples",
+        "merged_fsamples",
+        "merged_phsamples",
+        "mean_phsamples",
+        "mean_thsamples",
+        "mean_fsamples",
+        "dyads_dispersion",
+        "dyads",
+    ]
+
+    single_out = ["mean_dsamples", "mean_S0samples"]
+
+    for k in single_out:
+        outputs[k] = _gen_fname(
+            k,
+            cwd=_out_dir,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+
+    for k in multi_out:
+        outputs[k] = []
+
+    for i in range(1, n_fibres + 1):
+        outputs["merged_thsamples"].append(
+            _gen_fname(
+                "merged_th%dsamples" % i,
+                cwd=_out_dir,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+        )
+        outputs["merged_fsamples"].append(
+            _gen_fname(
+                "merged_f%dsamples" % i,
+                cwd=_out_dir,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+        )
+        outputs["merged_phsamples"].append(
+            _gen_fname(
+                "merged_ph%dsamples" % i,
+                cwd=_out_dir,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+        )
+        outputs["mean_thsamples"].append(
+            _gen_fname(
+                "mean_th%dsamples" % i,
+                cwd=_out_dir,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+        )
+        outputs["mean_phsamples"].append(
+            _gen_fname(
+                "mean_ph%dsamples" % i,
+                cwd=_out_dir,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+        )
+        outputs["mean_fsamples"].append(
+            _gen_fname(
+                "mean_f%dsamples" % i,
+                cwd=_out_dir,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+        )
+        outputs["dyads"].append(
+            _gen_fname(
+                "dyads%d" % i,
+                cwd=_out_dir,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+        )
+        outputs["dyads_dispersion"].append(
+            _gen_fname(
+                "dyads%d_dispersion" % i,
+                cwd=_out_dir,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+        )
+    return outputs
 
 
 # Original source at L108 of <nipype-install>/utils/filemanip.py
@@ -213,6 +350,44 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
@@ -304,179 +479,3 @@ def standard_image(img_name=None):
                 for filename in glob(os.path.join(stdpath, "*nii*"))
             ]
         return os.path.join(stdpath, img_name)
-
-
-# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
-def _gen_fname(
-    basename,
-    cwd=None,
-    suffix=None,
-    change_ext=True,
-    ext=None,
-    inputs=None,
-    stdout=None,
-    stderr=None,
-    output_dir=None,
-):
-    """Generate a filename based on the given parameters.
-
-    The filename will take the form: cwd/basename<suffix><ext>.
-    If change_ext is True, it will use the extensions specified in
-    <instance>inputs.output_type.
-
-    Parameters
-    ----------
-    basename : str
-        Filename to base the new filename on.
-    cwd : str
-        Path to prefix to the new filename. (default is output_dir)
-    suffix : str
-        Suffix to add to the `basename`.  (defaults is '' )
-    change_ext : bool
-        Flag to change the filename extension to the FSL output type.
-        (default True)
-
-    Returns
-    -------
-    fname : str
-        New filename based on given parameters.
-
-    """
-
-    if basename == "":
-        msg = "Unable to generate filename for command %s. " % "bedpostx"
-        msg += "basename is not set!"
-        raise ValueError(msg)
-    if cwd is None:
-        cwd = output_dir
-    if ext is None:
-        ext = Info.output_type_to_ext(inputs.output_type)
-    if change_ext:
-        if suffix:
-            suffix = "".join((suffix, ext))
-        else:
-            suffix = ext
-    if suffix is None:
-        suffix = ""
-    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
-    return fname
-
-
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
-# Original source at L483 of <nipype-install>/interfaces/fsl/dti.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    n_fibres = inputs.n_fibres
-
-    multi_out = [
-        "merged_thsamples",
-        "merged_fsamples",
-        "merged_phsamples",
-        "mean_phsamples",
-        "mean_thsamples",
-        "mean_fsamples",
-        "dyads_dispersion",
-        "dyads",
-    ]
-
-    single_out = ["mean_dsamples", "mean_S0samples"]
-
-    for k in single_out:
-        outputs[k] = _gen_fname(
-            k,
-            cwd=_out_dir,
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-
-    for k in multi_out:
-        outputs[k] = []
-
-    for i in range(1, n_fibres + 1):
-        outputs["merged_thsamples"].append(
-            _gen_fname(
-                "merged_th%dsamples" % i,
-                cwd=_out_dir,
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-        )
-        outputs["merged_fsamples"].append(
-            _gen_fname(
-                "merged_f%dsamples" % i,
-                cwd=_out_dir,
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-        )
-        outputs["merged_phsamples"].append(
-            _gen_fname(
-                "merged_ph%dsamples" % i,
-                cwd=_out_dir,
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-        )
-        outputs["mean_thsamples"].append(
-            _gen_fname(
-                "mean_th%dsamples" % i,
-                cwd=_out_dir,
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-        )
-        outputs["mean_phsamples"].append(
-            _gen_fname(
-                "mean_ph%dsamples" % i,
-                cwd=_out_dir,
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-        )
-        outputs["mean_fsamples"].append(
-            _gen_fname(
-                "mean_f%dsamples" % i,
-                cwd=_out_dir,
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-        )
-        outputs["dyads"].append(
-            _gen_fname(
-                "dyads%d" % i,
-                cwd=_out_dir,
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-        )
-        outputs["dyads_dispersion"].append(
-            _gen_fname(
-                "dyads%d_dispersion" % i,
-                cwd=_out_dir,
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-        )
-    return outputs
diff --git a/example-specs/task/nipype/fsl/bet_callables.py b/example-specs/task/nipype/fsl/bet_callables.py
index 35014b16..6163733a 100644
--- a/example-specs/task/nipype/fsl/bet_callables.py
+++ b/example-specs/task/nipype/fsl/bet_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of BET.yaml"""
 
 import attrs
+import logging
 import os
 import os.path as op
 from glob import glob
-import logging
 from pathlib import Path
 
 
@@ -12,25 +12,25 @@ def out_file_default(inputs):
     return _gen_filename("out_file", inputs=inputs)
 
 
-def out_file_callable(output_dir, inputs, stdout, stderr):
+def inskull_mask_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_file"]
+    return outputs["inskull_mask_file"]
 
 
-def mask_file_callable(output_dir, inputs, stdout, stderr):
+def inskull_mesh_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["mask_file"]
+    return outputs["inskull_mesh_file"]
 
 
-def outline_file_callable(output_dir, inputs, stdout, stderr):
+def mask_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["outline_file"]
+    return outputs["mask_file"]
 
 
 def meshfile_callable(output_dir, inputs, stdout, stderr):
@@ -40,101 +40,263 @@ def meshfile_callable(output_dir, inputs, stdout, stderr):
     return outputs["meshfile"]
 
 
-def inskull_mask_file_callable(output_dir, inputs, stdout, stderr):
+def out_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["inskull_mask_file"]
+    return outputs["out_file"]
 
 
-def inskull_mesh_file_callable(output_dir, inputs, stdout, stderr):
+def outline_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["inskull_mesh_file"]
+    return outputs["outline_file"]
 
 
-def outskull_mask_file_callable(output_dir, inputs, stdout, stderr):
+def outskin_mask_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["outskull_mask_file"]
+    return outputs["outskin_mask_file"]
 
 
-def outskull_mesh_file_callable(output_dir, inputs, stdout, stderr):
+def outskin_mesh_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["outskull_mesh_file"]
+    return outputs["outskin_mesh_file"]
 
 
-def outskin_mask_file_callable(output_dir, inputs, stdout, stderr):
+def outskull_mask_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["outskin_mask_file"]
+    return outputs["outskull_mask_file"]
 
 
-def outskin_mesh_file_callable(output_dir, inputs, stdout, stderr):
+def outskull_mesh_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["outskin_mesh_file"]
+    return outputs["outskull_mesh_file"]
 
 
-def skull_mask_file_callable(output_dir, inputs, stdout, stderr):
+def skull_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["skull_mask_file"]
+    return outputs["skull_file"]
 
 
-def skull_file_callable(output_dir, inputs, stdout, stderr):
+def skull_mask_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["skull_file"]
+    return outputs["skull_mask_file"]
 
 
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
+# Original source at L232 of <nipype-install>/interfaces/fsl/preprocess.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _gen_outfilename(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )
+    return None
 
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
 
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
 
-            klass._version = klass.parse_version(raw_info)
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
 
-        return klass._version
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
 
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "bet"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+# Original source at L176 of <nipype-install>/interfaces/fsl/preprocess.py
+def _gen_outfilename(inputs=None, stdout=None, stderr=None, output_dir=None):
+    out_file = inputs.out_file
+    # Generate default output filename if non specified.
+    if (out_file is attrs.NOTHING) and (inputs.in_file is not attrs.NOTHING):
+        out_file = _gen_fname(
+            inputs.in_file,
+            suffix="_brain",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+        # Convert to relative path to prevent BET failure
+        # with long paths.
+        return op.relpath(out_file, start=output_dir)
+    return out_file
+
+
+# Original source at L186 of <nipype-install>/interfaces/fsl/preprocess.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = os.path.abspath(
+        _gen_outfilename(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )
+    )
+
+    basename = os.path.basename(outputs["out_file"])
+    cwd = os.path.dirname(outputs["out_file"])
+    kwargs = {"basename": basename, "cwd": cwd}
+
+    if ((inputs.mesh is not attrs.NOTHING) and inputs.mesh) or (
+        (inputs.surfaces is not attrs.NOTHING) and inputs.surfaces
+    ):
+        outputs["meshfile"] = _gen_fname(
+            suffix="_mesh.vtk",
+            change_ext=False,
+            **kwargs,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir
+        )
+    if ((inputs.mask is not attrs.NOTHING) and inputs.mask) or (
+        (inputs.reduce_bias is not attrs.NOTHING) and inputs.reduce_bias
+    ):
+        outputs["mask_file"] = _gen_fname(
+            suffix="_mask",
+            **kwargs,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir
+        )
+    if (inputs.outline is not attrs.NOTHING) and inputs.outline:
+        outputs["outline_file"] = _gen_fname(
+            suffix="_overlay",
+            **kwargs,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir
+        )
+    if (inputs.surfaces is not attrs.NOTHING) and inputs.surfaces:
+        outputs["inskull_mask_file"] = _gen_fname(
+            suffix="_inskull_mask",
+            **kwargs,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir
+        )
+        outputs["inskull_mesh_file"] = _gen_fname(
+            suffix="_inskull_mesh",
+            **kwargs,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir
+        )
+        outputs["outskull_mask_file"] = _gen_fname(
+            suffix="_outskull_mask",
+            **kwargs,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir
+        )
+        outputs["outskull_mesh_file"] = _gen_fname(
+            suffix="_outskull_mesh",
+            **kwargs,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir
+        )
+        outputs["outskin_mask_file"] = _gen_fname(
+            suffix="_outskin_mask",
+            **kwargs,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir
+        )
+        outputs["outskin_mesh_file"] = _gen_fname(
+            suffix="_outskin_mesh",
+            **kwargs,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir
+        )
+        outputs["skull_mask_file"] = _gen_fname(
+            suffix="_skull_mask",
+            **kwargs,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir
+        )
+    if (inputs.skull is not attrs.NOTHING) and inputs.skull:
+        outputs["skull_file"] = _gen_fname(
+            suffix="_skull",
+            **kwargs,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir
+        )
+    if (inputs.no_output is not attrs.NOTHING) and inputs.no_output:
+        outputs["out_file"] = attrs.NOTHING
+    return outputs
 
 
 # Original source at L108 of <nipype-install>/utils/filemanip.py
@@ -231,6 +393,44 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
@@ -322,203 +522,3 @@ def standard_image(img_name=None):
                 for filename in glob(os.path.join(stdpath, "*nii*"))
             ]
         return os.path.join(stdpath, img_name)
-
-
-# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
-def _gen_fname(
-    basename,
-    cwd=None,
-    suffix=None,
-    change_ext=True,
-    ext=None,
-    inputs=None,
-    stdout=None,
-    stderr=None,
-    output_dir=None,
-):
-    """Generate a filename based on the given parameters.
-
-    The filename will take the form: cwd/basename<suffix><ext>.
-    If change_ext is True, it will use the extensions specified in
-    <instance>inputs.output_type.
-
-    Parameters
-    ----------
-    basename : str
-        Filename to base the new filename on.
-    cwd : str
-        Path to prefix to the new filename. (default is output_dir)
-    suffix : str
-        Suffix to add to the `basename`.  (defaults is '' )
-    change_ext : bool
-        Flag to change the filename extension to the FSL output type.
-        (default True)
-
-    Returns
-    -------
-    fname : str
-        New filename based on given parameters.
-
-    """
-
-    if basename == "":
-        msg = "Unable to generate filename for command %s. " % "bet"
-        msg += "basename is not set!"
-        raise ValueError(msg)
-    if cwd is None:
-        cwd = output_dir
-    if ext is None:
-        ext = Info.output_type_to_ext(inputs.output_type)
-    if change_ext:
-        if suffix:
-            suffix = "".join((suffix, ext))
-        else:
-            suffix = ext
-    if suffix is None:
-        suffix = ""
-    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
-    return fname
-
-
-# Original source at L176 of <nipype-install>/interfaces/fsl/preprocess.py
-def _gen_outfilename(inputs=None, stdout=None, stderr=None, output_dir=None):
-    out_file = inputs.out_file
-    # Generate default output filename if non specified.
-    if (out_file is attrs.NOTHING) and (inputs.in_file is not attrs.NOTHING):
-        out_file = _gen_fname(
-            inputs.in_file,
-            suffix="_brain",
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-        # Convert to relative path to prevent BET failure
-        # with long paths.
-        return op.relpath(out_file, start=output_dir)
-    return out_file
-
-
-# Original source at L232 of <nipype-install>/interfaces/fsl/preprocess.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "out_file":
-        return _gen_outfilename(
-            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-        )
-    return None
-
-
-# Original source at L186 of <nipype-install>/interfaces/fsl/preprocess.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    outputs["out_file"] = os.path.abspath(
-        _gen_outfilename(
-            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-        )
-    )
-
-    basename = os.path.basename(outputs["out_file"])
-    cwd = os.path.dirname(outputs["out_file"])
-    kwargs = {"basename": basename, "cwd": cwd}
-
-    if ((inputs.mesh is not attrs.NOTHING) and inputs.mesh) or (
-        (inputs.surfaces is not attrs.NOTHING) and inputs.surfaces
-    ):
-        outputs["meshfile"] = _gen_fname(
-            suffix="_mesh.vtk",
-            change_ext=False,
-            **kwargs,
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir
-        )
-    if ((inputs.mask is not attrs.NOTHING) and inputs.mask) or (
-        (inputs.reduce_bias is not attrs.NOTHING) and inputs.reduce_bias
-    ):
-        outputs["mask_file"] = _gen_fname(
-            suffix="_mask",
-            **kwargs,
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir
-        )
-    if (inputs.outline is not attrs.NOTHING) and inputs.outline:
-        outputs["outline_file"] = _gen_fname(
-            suffix="_overlay",
-            **kwargs,
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir
-        )
-    if (inputs.surfaces is not attrs.NOTHING) and inputs.surfaces:
-        outputs["inskull_mask_file"] = _gen_fname(
-            suffix="_inskull_mask",
-            **kwargs,
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir
-        )
-        outputs["inskull_mesh_file"] = _gen_fname(
-            suffix="_inskull_mesh",
-            **kwargs,
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir
-        )
-        outputs["outskull_mask_file"] = _gen_fname(
-            suffix="_outskull_mask",
-            **kwargs,
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir
-        )
-        outputs["outskull_mesh_file"] = _gen_fname(
-            suffix="_outskull_mesh",
-            **kwargs,
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir
-        )
-        outputs["outskin_mask_file"] = _gen_fname(
-            suffix="_outskin_mask",
-            **kwargs,
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir
-        )
-        outputs["outskin_mesh_file"] = _gen_fname(
-            suffix="_outskin_mesh",
-            **kwargs,
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir
-        )
-        outputs["skull_mask_file"] = _gen_fname(
-            suffix="_skull_mask",
-            **kwargs,
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir
-        )
-    if (inputs.skull is not attrs.NOTHING) and inputs.skull:
-        outputs["skull_file"] = _gen_fname(
-            suffix="_skull",
-            **kwargs,
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir
-        )
-    if (inputs.no_output is not attrs.NOTHING) and inputs.no_output:
-        outputs["out_file"] = attrs.NOTHING
-    return outputs
diff --git a/example-specs/task/nipype/fsl/binary_maths_callables.py b/example-specs/task/nipype/fsl/binary_maths_callables.py
index 0a6774f0..ac159de9 100644
--- a/example-specs/task/nipype/fsl/binary_maths_callables.py
+++ b/example-specs/task/nipype/fsl/binary_maths_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of BinaryMaths.yaml"""
 
-from glob import glob
 import attrs
 import logging
 import os
 import os.path as op
+from glob import glob
 from pathlib import Path
 
 
@@ -22,42 +22,86 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
+# Original source at L61 of <nipype-install>/interfaces/fsl/maths.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )["out_file"]
+    return None
 
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
 
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
 
-            klass._version = klass.parse_version(raw_info)
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
 
-        return klass._version
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
 
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "fslmaths"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+# Original source at L51 of <nipype-install>/interfaces/fsl/maths.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = inputs.out_file
+    if inputs.out_file is attrs.NOTHING:
+        outputs["out_file"] = _gen_fname(
+            inputs.in_file,
+            suffix=_suffix,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    outputs["out_file"] = os.path.abspath(outputs["out_file"])
+    return outputs
 
 
 # Original source at L108 of <nipype-install>/utils/filemanip.py
@@ -154,6 +198,44 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
@@ -245,85 +327,3 @@ def standard_image(img_name=None):
                 for filename in glob(os.path.join(stdpath, "*nii*"))
             ]
         return os.path.join(stdpath, img_name)
-
-
-# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
-def _gen_fname(
-    basename,
-    cwd=None,
-    suffix=None,
-    change_ext=True,
-    ext=None,
-    inputs=None,
-    stdout=None,
-    stderr=None,
-    output_dir=None,
-):
-    """Generate a filename based on the given parameters.
-
-    The filename will take the form: cwd/basename<suffix><ext>.
-    If change_ext is True, it will use the extensions specified in
-    <instance>inputs.output_type.
-
-    Parameters
-    ----------
-    basename : str
-        Filename to base the new filename on.
-    cwd : str
-        Path to prefix to the new filename. (default is output_dir)
-    suffix : str
-        Suffix to add to the `basename`.  (defaults is '' )
-    change_ext : bool
-        Flag to change the filename extension to the FSL output type.
-        (default True)
-
-    Returns
-    -------
-    fname : str
-        New filename based on given parameters.
-
-    """
-
-    if basename == "":
-        msg = "Unable to generate filename for command %s. " % "fslmaths"
-        msg += "basename is not set!"
-        raise ValueError(msg)
-    if cwd is None:
-        cwd = output_dir
-    if ext is None:
-        ext = Info.output_type_to_ext(inputs.output_type)
-    if change_ext:
-        if suffix:
-            suffix = "".join((suffix, ext))
-        else:
-            suffix = ext
-    if suffix is None:
-        suffix = ""
-    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
-    return fname
-
-
-# Original source at L61 of <nipype-install>/interfaces/fsl/maths.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "out_file":
-        return _list_outputs(
-            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-        )["out_file"]
-    return None
-
-
-# Original source at L51 of <nipype-install>/interfaces/fsl/maths.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    outputs["out_file"] = inputs.out_file
-    if inputs.out_file is attrs.NOTHING:
-        outputs["out_file"] = _gen_fname(
-            inputs.in_file,
-            suffix=_suffix,
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-    outputs["out_file"] = os.path.abspath(outputs["out_file"])
-    return outputs
diff --git a/example-specs/task/nipype/fsl/change_data_type_callables.py b/example-specs/task/nipype/fsl/change_data_type_callables.py
index bc224338..3af76c1f 100644
--- a/example-specs/task/nipype/fsl/change_data_type_callables.py
+++ b/example-specs/task/nipype/fsl/change_data_type_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of ChangeDataType.yaml"""
 
-from glob import glob
 import attrs
 import logging
 import os
 import os.path as op
+from glob import glob
 from pathlib import Path
 
 
@@ -22,42 +22,86 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
+# Original source at L61 of <nipype-install>/interfaces/fsl/maths.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )["out_file"]
+    return None
 
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
 
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
 
-            klass._version = klass.parse_version(raw_info)
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
 
-        return klass._version
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
 
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "fslmaths"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+# Original source at L51 of <nipype-install>/interfaces/fsl/maths.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = inputs.out_file
+    if inputs.out_file is attrs.NOTHING:
+        outputs["out_file"] = _gen_fname(
+            inputs.in_file,
+            suffix=_suffix,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    outputs["out_file"] = os.path.abspath(outputs["out_file"])
+    return outputs
 
 
 # Original source at L108 of <nipype-install>/utils/filemanip.py
@@ -154,6 +198,44 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
@@ -245,85 +327,3 @@ def standard_image(img_name=None):
                 for filename in glob(os.path.join(stdpath, "*nii*"))
             ]
         return os.path.join(stdpath, img_name)
-
-
-# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
-def _gen_fname(
-    basename,
-    cwd=None,
-    suffix=None,
-    change_ext=True,
-    ext=None,
-    inputs=None,
-    stdout=None,
-    stderr=None,
-    output_dir=None,
-):
-    """Generate a filename based on the given parameters.
-
-    The filename will take the form: cwd/basename<suffix><ext>.
-    If change_ext is True, it will use the extensions specified in
-    <instance>inputs.output_type.
-
-    Parameters
-    ----------
-    basename : str
-        Filename to base the new filename on.
-    cwd : str
-        Path to prefix to the new filename. (default is output_dir)
-    suffix : str
-        Suffix to add to the `basename`.  (defaults is '' )
-    change_ext : bool
-        Flag to change the filename extension to the FSL output type.
-        (default True)
-
-    Returns
-    -------
-    fname : str
-        New filename based on given parameters.
-
-    """
-
-    if basename == "":
-        msg = "Unable to generate filename for command %s. " % "fslmaths"
-        msg += "basename is not set!"
-        raise ValueError(msg)
-    if cwd is None:
-        cwd = output_dir
-    if ext is None:
-        ext = Info.output_type_to_ext(inputs.output_type)
-    if change_ext:
-        if suffix:
-            suffix = "".join((suffix, ext))
-        else:
-            suffix = ext
-    if suffix is None:
-        suffix = ""
-    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
-    return fname
-
-
-# Original source at L61 of <nipype-install>/interfaces/fsl/maths.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "out_file":
-        return _list_outputs(
-            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-        )["out_file"]
-    return None
-
-
-# Original source at L51 of <nipype-install>/interfaces/fsl/maths.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    outputs["out_file"] = inputs.out_file
-    if inputs.out_file is attrs.NOTHING:
-        outputs["out_file"] = _gen_fname(
-            inputs.in_file,
-            suffix=_suffix,
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-    outputs["out_file"] = os.path.abspath(outputs["out_file"])
-    return outputs
diff --git a/example-specs/task/nipype/fsl/classifier_callables.py b/example-specs/task/nipype/fsl/classifier_callables.py
index 10b1f450..49a89d38 100644
--- a/example-specs/task/nipype/fsl/classifier_callables.py
+++ b/example-specs/task/nipype/fsl/classifier_callables.py
@@ -1,7 +1,6 @@
 """Module to put any functions that are referred to in the "callables" section of Classifier.yaml"""
 
 import os
-import attrs
 
 
 def artifacts_list_file_callable(output_dir, inputs, stdout, stderr):
@@ -11,11 +10,6 @@ def artifacts_list_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["artifacts_list_file"]
 
 
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
 # Original source at L304 of <nipype-install>/interfaces/fsl/fix.py
 def _gen_artifacts_list_file(
     mel_ica, thresh, inputs=None, stdout=None, stderr=None, output_dir=None
@@ -28,6 +22,11 @@ def _gen_artifacts_list_file(
     return fname
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
 # Original source at L312 of <nipype-install>/interfaces/fsl/fix.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
diff --git a/example-specs/task/nipype/fsl/cleaner_callables.py b/example-specs/task/nipype/fsl/cleaner_callables.py
index 637b1842..8a8692c3 100644
--- a/example-specs/task/nipype/fsl/cleaner_callables.py
+++ b/example-specs/task/nipype/fsl/cleaner_callables.py
@@ -1,7 +1,6 @@
 """Module to put any functions that are referred to in the "callables" section of Cleaner.yaml"""
 
 import os
-import attrs
 
 
 def cleaned_functional_file_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/fsl/cluster_callables.py b/example-specs/task/nipype/fsl/cluster_callables.py
index 0a414387..c6a7247d 100644
--- a/example-specs/task/nipype/fsl/cluster_callables.py
+++ b/example-specs/task/nipype/fsl/cluster_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Cluster.yaml"""
 
-from glob import glob
 import attrs
 import logging
 import os
 import os.path as op
+from glob import glob
 from pathlib import Path
 
 
@@ -15,13 +15,6 @@ def index_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["index_file"]
 
 
-def threshold_file_callable(output_dir, inputs, stdout, stderr):
-    outputs = _list_outputs(
-        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
-    )
-    return outputs["threshold_file"]
-
-
 def localmax_txt_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
@@ -36,13 +29,6 @@ def localmax_vol_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["localmax_vol_file"]
 
 
-def size_file_callable(output_dir, inputs, stdout, stderr):
-    outputs = _list_outputs(
-        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
-    )
-    return outputs["size_file"]
-
-
 def max_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
@@ -64,45 +50,108 @@ def pval_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["pval_file"]
 
 
+def size_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["size_file"]
+
+
+def threshold_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["threshold_file"]
+
+
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
 
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
 
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
 
-            klass._version = klass.parse_version(raw_info)
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
 
-        return klass._version
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
 
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "cluster"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+# Original source at L2074 of <nipype-install>/interfaces/fsl/model.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    for key, suffix in list(filemap.items()):
+        outkey = key[4:]
+        inval = getattr(inputs, key)
+        if inval is not attrs.NOTHING:
+            if isinstance(inval, bool):
+                if inval:
+                    change_ext = True
+                    if suffix.endswith(".txt"):
+                        change_ext = False
+                    outputs[outkey] = _gen_fname(
+                        inputs.in_file,
+                        suffix="_" + suffix,
+                        change_ext=change_ext,
+                        inputs=inputs,
+                        stdout=stdout,
+                        stderr=stderr,
+                        output_dir=output_dir,
+                    )
+            else:
+                outputs[outkey] = os.path.abspath(inval)
+    return outputs
 
 
 # Original source at L108 of <nipype-install>/utils/filemanip.py
@@ -199,6 +248,44 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
@@ -290,90 +377,3 @@ def standard_image(img_name=None):
                 for filename in glob(os.path.join(stdpath, "*nii*"))
             ]
         return os.path.join(stdpath, img_name)
-
-
-# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
-def _gen_fname(
-    basename,
-    cwd=None,
-    suffix=None,
-    change_ext=True,
-    ext=None,
-    inputs=None,
-    stdout=None,
-    stderr=None,
-    output_dir=None,
-):
-    """Generate a filename based on the given parameters.
-
-    The filename will take the form: cwd/basename<suffix><ext>.
-    If change_ext is True, it will use the extensions specified in
-    <instance>inputs.output_type.
-
-    Parameters
-    ----------
-    basename : str
-        Filename to base the new filename on.
-    cwd : str
-        Path to prefix to the new filename. (default is output_dir)
-    suffix : str
-        Suffix to add to the `basename`.  (defaults is '' )
-    change_ext : bool
-        Flag to change the filename extension to the FSL output type.
-        (default True)
-
-    Returns
-    -------
-    fname : str
-        New filename based on given parameters.
-
-    """
-
-    if basename == "":
-        msg = "Unable to generate filename for command %s. " % "cluster"
-        msg += "basename is not set!"
-        raise ValueError(msg)
-    if cwd is None:
-        cwd = output_dir
-    if ext is None:
-        ext = Info.output_type_to_ext(inputs.output_type)
-    if change_ext:
-        if suffix:
-            suffix = "".join((suffix, ext))
-        else:
-            suffix = ext
-    if suffix is None:
-        suffix = ""
-    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
-    return fname
-
-
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
-# Original source at L2074 of <nipype-install>/interfaces/fsl/model.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    for key, suffix in list(filemap.items()):
-        outkey = key[4:]
-        inval = getattr(inputs, key)
-        if inval is not attrs.NOTHING:
-            if isinstance(inval, bool):
-                if inval:
-                    change_ext = True
-                    if suffix.endswith(".txt"):
-                        change_ext = False
-                    outputs[outkey] = _gen_fname(
-                        inputs.in_file,
-                        suffix="_" + suffix,
-                        change_ext=change_ext,
-                        inputs=inputs,
-                        stdout=stdout,
-                        stderr=stderr,
-                        output_dir=output_dir,
-                    )
-            else:
-                outputs[outkey] = os.path.abspath(inval)
-    return outputs
diff --git a/example-specs/task/nipype/fsl/complex_callables.py b/example-specs/task/nipype/fsl/complex_callables.py
index 36d6d67c..b8a505bf 100644
--- a/example-specs/task/nipype/fsl/complex_callables.py
+++ b/example-specs/task/nipype/fsl/complex_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Complex.yaml"""
 
-from glob import glob
 import attrs
 import logging
 import os
 import os.path as op
+from glob import glob
 from pathlib import Path
 
 
@@ -12,6 +12,10 @@ def complex_out_file_default(inputs):
     return _gen_filename("complex_out_file", inputs=inputs)
 
 
+def imaginary_out_file_default(inputs):
+    return _gen_filename("imaginary_out_file", inputs=inputs)
+
+
 def magnitude_out_file_default(inputs):
     return _gen_filename("magnitude_out_file", inputs=inputs)
 
@@ -24,8 +28,18 @@ def real_out_file_default(inputs):
     return _gen_filename("real_out_file", inputs=inputs)
 
 
-def imaginary_out_file_default(inputs):
-    return _gen_filename("imaginary_out_file", inputs=inputs)
+def complex_out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["complex_out_file"]
+
+
+def imaginary_out_file_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["imaginary_out_file"]
 
 
 def magnitude_out_file_callable(output_dir, inputs, stdout, stderr):
@@ -49,59 +63,180 @@ def real_out_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["real_out_file"]
 
 
-def imaginary_out_file_callable(output_dir, inputs, stdout, stderr):
-    outputs = _list_outputs(
-        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
-    )
-    return outputs["imaginary_out_file"]
+IFLOGGER = logging.getLogger("nipype.interface")
 
 
-def complex_out_file_callable(output_dir, inputs, stdout, stderr):
-    outputs = _list_outputs(
-        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
-    )
-    return outputs["complex_out_file"]
+# Original source at L2031 of <nipype-install>/interfaces/fsl/utils.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "complex_out_file":
+        if inputs.complex_cartesian:
+            in_file = inputs.real_in_file
+        elif inputs.complex_polar:
+            in_file = inputs.magnitude_in_file
+        elif inputs.complex_split or inputs.complex_merge:
+            in_file = inputs.complex_in_file
+        else:
+            return None
+        return _gen_fname(
+            in_file,
+            suffix="_cplx",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    elif name == "magnitude_out_file":
+        return _gen_fname(
+            inputs.complex_in_file,
+            suffix="_mag",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    elif name == "phase_out_file":
+        return _gen_fname(
+            inputs.complex_in_file,
+            suffix="_phase",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    elif name == "real_out_file":
+        return _gen_fname(
+            inputs.complex_in_file,
+            suffix="_real",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    elif name == "imaginary_out_file":
+        return _gen_fname(
+            inputs.complex_in_file,
+            suffix="_imag",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    return None
 
 
-IFLOGGER = logging.getLogger("nipype.interface")
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
 
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
 
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
 
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
 
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
+    """
 
-            klass._version = klass.parse_version(raw_info)
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "fslcomplex"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
 
-        return klass._version
 
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+# Original source at L2052 of <nipype-install>/interfaces/fsl/utils.py
+def _get_output(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    output = getattr(inputs, name)
+    if output is attrs.NOTHING:
+        output = _gen_filename(
+            name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )
+    return os.path.abspath(output)
+
+
+# Original source at L2058 of <nipype-install>/interfaces/fsl/utils.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    if (
+        inputs.complex_cartesian
+        or inputs.complex_polar
+        or inputs.complex_split
+        or inputs.complex_merge
+    ):
+        outputs["complex_out_file"] = _get_output(
+            "complex_out_file",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    elif inputs.real_cartesian:
+        outputs["real_out_file"] = _get_output(
+            "real_out_file",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+        outputs["imaginary_out_file"] = _get_output(
+            "imaginary_out_file",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    elif inputs.real_polar:
+        outputs["magnitude_out_file"] = _get_output(
+            "magnitude_out_file",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+        outputs["phase_out_file"] = _get_output(
+            "phase_out_file",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    return outputs
 
 
 # Original source at L108 of <nipype-install>/utils/filemanip.py
@@ -198,6 +333,44 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
@@ -289,176 +462,3 @@ def standard_image(img_name=None):
                 for filename in glob(os.path.join(stdpath, "*nii*"))
             ]
         return os.path.join(stdpath, img_name)
-
-
-# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
-def _gen_fname(
-    basename,
-    cwd=None,
-    suffix=None,
-    change_ext=True,
-    ext=None,
-    inputs=None,
-    stdout=None,
-    stderr=None,
-    output_dir=None,
-):
-    """Generate a filename based on the given parameters.
-
-    The filename will take the form: cwd/basename<suffix><ext>.
-    If change_ext is True, it will use the extensions specified in
-    <instance>inputs.output_type.
-
-    Parameters
-    ----------
-    basename : str
-        Filename to base the new filename on.
-    cwd : str
-        Path to prefix to the new filename. (default is output_dir)
-    suffix : str
-        Suffix to add to the `basename`.  (defaults is '' )
-    change_ext : bool
-        Flag to change the filename extension to the FSL output type.
-        (default True)
-
-    Returns
-    -------
-    fname : str
-        New filename based on given parameters.
-
-    """
-
-    if basename == "":
-        msg = "Unable to generate filename for command %s. " % "fslcomplex"
-        msg += "basename is not set!"
-        raise ValueError(msg)
-    if cwd is None:
-        cwd = output_dir
-    if ext is None:
-        ext = Info.output_type_to_ext(inputs.output_type)
-    if change_ext:
-        if suffix:
-            suffix = "".join((suffix, ext))
-        else:
-            suffix = ext
-    if suffix is None:
-        suffix = ""
-    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
-    return fname
-
-
-# Original source at L2052 of <nipype-install>/interfaces/fsl/utils.py
-def _get_output(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    output = getattr(inputs, name)
-    if output is attrs.NOTHING:
-        output = _gen_filename(
-            name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-        )
-    return os.path.abspath(output)
-
-
-# Original source at L2031 of <nipype-install>/interfaces/fsl/utils.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "complex_out_file":
-        if inputs.complex_cartesian:
-            in_file = inputs.real_in_file
-        elif inputs.complex_polar:
-            in_file = inputs.magnitude_in_file
-        elif inputs.complex_split or inputs.complex_merge:
-            in_file = inputs.complex_in_file
-        else:
-            return None
-        return _gen_fname(
-            in_file,
-            suffix="_cplx",
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-    elif name == "magnitude_out_file":
-        return _gen_fname(
-            inputs.complex_in_file,
-            suffix="_mag",
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-    elif name == "phase_out_file":
-        return _gen_fname(
-            inputs.complex_in_file,
-            suffix="_phase",
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-    elif name == "real_out_file":
-        return _gen_fname(
-            inputs.complex_in_file,
-            suffix="_real",
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-    elif name == "imaginary_out_file":
-        return _gen_fname(
-            inputs.complex_in_file,
-            suffix="_imag",
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-    return None
-
-
-# Original source at L2058 of <nipype-install>/interfaces/fsl/utils.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    if (
-        inputs.complex_cartesian
-        or inputs.complex_polar
-        or inputs.complex_split
-        or inputs.complex_merge
-    ):
-        outputs["complex_out_file"] = _get_output(
-            "complex_out_file",
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-    elif inputs.real_cartesian:
-        outputs["real_out_file"] = _get_output(
-            "real_out_file",
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-        outputs["imaginary_out_file"] = _get_output(
-            "imaginary_out_file",
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-    elif inputs.real_polar:
-        outputs["magnitude_out_file"] = _get_output(
-            "magnitude_out_file",
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-        outputs["phase_out_file"] = _get_output(
-            "phase_out_file",
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-    return outputs
diff --git a/example-specs/task/nipype/fsl/contrast_mgr_callables.py b/example-specs/task/nipype/fsl/contrast_mgr_callables.py
index 87f2bd88..a2849d0d 100644
--- a/example-specs/task/nipype/fsl/contrast_mgr_callables.py
+++ b/example-specs/task/nipype/fsl/contrast_mgr_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of ContrastMgr.yaml"""
 
-from glob import glob
 import attrs
 import logging
 import os
 import os.path as op
+from glob import glob
 from pathlib import Path
 
 
@@ -15,18 +15,18 @@ def copes_callable(output_dir, inputs, stdout, stderr):
     return outputs["copes"]
 
 
-def varcopes_callable(output_dir, inputs, stdout, stderr):
+def fstats_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["varcopes"]
+    return outputs["fstats"]
 
 
-def zstats_callable(output_dir, inputs, stdout, stderr):
+def neffs_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["zstats"]
+    return outputs["neffs"]
 
 
 def tstats_callable(output_dir, inputs, stdout, stderr):
@@ -36,11 +36,11 @@ def tstats_callable(output_dir, inputs, stdout, stderr):
     return outputs["tstats"]
 
 
-def fstats_callable(output_dir, inputs, stdout, stderr):
+def varcopes_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["fstats"]
+    return outputs["varcopes"]
 
 
 def zfstats_callable(output_dir, inputs, stdout, stderr):
@@ -50,52 +50,197 @@ def zfstats_callable(output_dir, inputs, stdout, stderr):
     return outputs["zfstats"]
 
 
-def neffs_callable(output_dir, inputs, stdout, stderr):
+def zstats_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["neffs"]
+    return outputs["zstats"]
 
 
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
 
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
 
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
 
-            klass._version = klass.parse_version(raw_info)
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
 
-        return klass._version
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
 
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "contrast_mgr"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+# Original source at L1301 of <nipype-install>/interfaces/fsl/model.py
+def _get_numcons(inputs=None, stdout=None, stderr=None, output_dir=None):
+    numtcons = 0
+    numfcons = 0
+    if inputs.tcon_file is not attrs.NOTHING:
+        fp = open(inputs.tcon_file, "rt")
+        for line in fp.readlines():
+            if line.startswith("/NumContrasts"):
+                numtcons = int(line.split()[-1])
+                break
+        fp.close()
+    if inputs.fcon_file is not attrs.NOTHING:
+        fp = open(inputs.fcon_file, "rt")
+        for line in fp.readlines():
+            if line.startswith("/NumContrasts"):
+                numfcons = int(line.split()[-1])
+                break
+        fp.close()
+    return numtcons, numfcons
+
+
+# Original source at L1320 of <nipype-install>/interfaces/fsl/model.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    pth, _ = os.path.split(inputs.sigmasquareds)
+    numtcons, numfcons = _get_numcons(
+        inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+    )
+    base_contrast = 1
+    if inputs.contrast_num is not attrs.NOTHING:
+        base_contrast = inputs.contrast_num
+    copes = []
+    varcopes = []
+    zstats = []
+    tstats = []
+    neffs = []
+    for i in range(numtcons):
+        copes.append(
+            _gen_fname(
+                "cope%d.nii" % (base_contrast + i),
+                cwd=pth,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+        )
+        varcopes.append(
+            _gen_fname(
+                "varcope%d.nii" % (base_contrast + i),
+                cwd=pth,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+        )
+        zstats.append(
+            _gen_fname(
+                "zstat%d.nii" % (base_contrast + i),
+                cwd=pth,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+        )
+        tstats.append(
+            _gen_fname(
+                "tstat%d.nii" % (base_contrast + i),
+                cwd=pth,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+        )
+        neffs.append(
+            _gen_fname(
+                "neff%d.nii" % (base_contrast + i),
+                cwd=pth,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+        )
+    if copes:
+        outputs["copes"] = copes
+        outputs["varcopes"] = varcopes
+        outputs["zstats"] = zstats
+        outputs["tstats"] = tstats
+        outputs["neffs"] = neffs
+    fstats = []
+    zfstats = []
+    for i in range(numfcons):
+        fstats.append(
+            _gen_fname(
+                "fstat%d.nii" % (base_contrast + i),
+                cwd=pth,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+        )
+        zfstats.append(
+            _gen_fname(
+                "zfstat%d.nii" % (base_contrast + i),
+                cwd=pth,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+        )
+    if fstats:
+        outputs["fstats"] = fstats
+        outputs["zfstats"] = zfstats
+    return outputs
 
 
 # Original source at L108 of <nipype-install>/utils/filemanip.py
@@ -192,6 +337,44 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
@@ -283,186 +466,3 @@ def standard_image(img_name=None):
                 for filename in glob(os.path.join(stdpath, "*nii*"))
             ]
         return os.path.join(stdpath, img_name)
-
-
-# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
-def _gen_fname(
-    basename,
-    cwd=None,
-    suffix=None,
-    change_ext=True,
-    ext=None,
-    inputs=None,
-    stdout=None,
-    stderr=None,
-    output_dir=None,
-):
-    """Generate a filename based on the given parameters.
-
-    The filename will take the form: cwd/basename<suffix><ext>.
-    If change_ext is True, it will use the extensions specified in
-    <instance>inputs.output_type.
-
-    Parameters
-    ----------
-    basename : str
-        Filename to base the new filename on.
-    cwd : str
-        Path to prefix to the new filename. (default is output_dir)
-    suffix : str
-        Suffix to add to the `basename`.  (defaults is '' )
-    change_ext : bool
-        Flag to change the filename extension to the FSL output type.
-        (default True)
-
-    Returns
-    -------
-    fname : str
-        New filename based on given parameters.
-
-    """
-
-    if basename == "":
-        msg = "Unable to generate filename for command %s. " % "contrast_mgr"
-        msg += "basename is not set!"
-        raise ValueError(msg)
-    if cwd is None:
-        cwd = output_dir
-    if ext is None:
-        ext = Info.output_type_to_ext(inputs.output_type)
-    if change_ext:
-        if suffix:
-            suffix = "".join((suffix, ext))
-        else:
-            suffix = ext
-    if suffix is None:
-        suffix = ""
-    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
-    return fname
-
-
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
-# Original source at L1301 of <nipype-install>/interfaces/fsl/model.py
-def _get_numcons(inputs=None, stdout=None, stderr=None, output_dir=None):
-    numtcons = 0
-    numfcons = 0
-    if inputs.tcon_file is not attrs.NOTHING:
-        fp = open(inputs.tcon_file, "rt")
-        for line in fp.readlines():
-            if line.startswith("/NumContrasts"):
-                numtcons = int(line.split()[-1])
-                break
-        fp.close()
-    if inputs.fcon_file is not attrs.NOTHING:
-        fp = open(inputs.fcon_file, "rt")
-        for line in fp.readlines():
-            if line.startswith("/NumContrasts"):
-                numfcons = int(line.split()[-1])
-                break
-        fp.close()
-    return numtcons, numfcons
-
-
-# Original source at L1320 of <nipype-install>/interfaces/fsl/model.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    pth, _ = os.path.split(inputs.sigmasquareds)
-    numtcons, numfcons = _get_numcons(
-        inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-    )
-    base_contrast = 1
-    if inputs.contrast_num is not attrs.NOTHING:
-        base_contrast = inputs.contrast_num
-    copes = []
-    varcopes = []
-    zstats = []
-    tstats = []
-    neffs = []
-    for i in range(numtcons):
-        copes.append(
-            _gen_fname(
-                "cope%d.nii" % (base_contrast + i),
-                cwd=pth,
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-        )
-        varcopes.append(
-            _gen_fname(
-                "varcope%d.nii" % (base_contrast + i),
-                cwd=pth,
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-        )
-        zstats.append(
-            _gen_fname(
-                "zstat%d.nii" % (base_contrast + i),
-                cwd=pth,
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-        )
-        tstats.append(
-            _gen_fname(
-                "tstat%d.nii" % (base_contrast + i),
-                cwd=pth,
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-        )
-        neffs.append(
-            _gen_fname(
-                "neff%d.nii" % (base_contrast + i),
-                cwd=pth,
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-        )
-    if copes:
-        outputs["copes"] = copes
-        outputs["varcopes"] = varcopes
-        outputs["zstats"] = zstats
-        outputs["tstats"] = tstats
-        outputs["neffs"] = neffs
-    fstats = []
-    zfstats = []
-    for i in range(numfcons):
-        fstats.append(
-            _gen_fname(
-                "fstat%d.nii" % (base_contrast + i),
-                cwd=pth,
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-        )
-        zfstats.append(
-            _gen_fname(
-                "zfstat%d.nii" % (base_contrast + i),
-                cwd=pth,
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-        )
-    if fstats:
-        outputs["fstats"] = fstats
-        outputs["zfstats"] = zfstats
-    return outputs
diff --git a/example-specs/task/nipype/fsl/convert_warp_callables.py b/example-specs/task/nipype/fsl/convert_warp_callables.py
index 58058e5b..bb15f5b8 100644
--- a/example-specs/task/nipype/fsl/convert_warp_callables.py
+++ b/example-specs/task/nipype/fsl/convert_warp_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of ConvertWarp.yaml"""
 
-from glob import glob
 import attrs
 import logging
 import os
 import os.path as op
+from glob import glob
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -20,6 +20,182 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+# Original source at L249 of <nipype-install>/interfaces/fsl/base.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value + Info.output_type_to_ext(inputs.output_type)
+
+
+# Original source at L58 of <nipype-install>/utils/filemanip.py
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
 # Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
@@ -151,13 +327,6 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
-# Original source at L249 of <nipype-install>/interfaces/fsl/base.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    return value + Info.output_type_to_ext(inputs.output_type)
-
-
 # Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
@@ -167,172 +336,3 @@ def __init__(self, value):
 
     def __str__(self):
         return "{}".format(self.value)
-
-
-# Original source at L58 of <nipype-install>/utils/filemanip.py
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
-# Original source at L809 of <nipype-install>/interfaces/base/core.py
-def _filename_from_source(
-    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    if chain is None:
-        chain = []
-
-    trait_spec = inputs.trait(name)
-    retval = getattr(inputs, name)
-    source_ext = None
-    if (retval is attrs.NOTHING) or "%s" in retval:
-        if not trait_spec.name_source:
-            return retval
-
-        # Do not generate filename when excluded by other inputs
-        if any(
-            (getattr(inputs, field) is not attrs.NOTHING)
-            for field in trait_spec.xor or ()
-        ):
-            return retval
-
-        # Do not generate filename when required fields are missing
-        if not all(
-            (getattr(inputs, field) is not attrs.NOTHING)
-            for field in trait_spec.requires or ()
-        ):
-            return retval
-
-        if (retval is not attrs.NOTHING) and "%s" in retval:
-            name_template = retval
-        else:
-            name_template = trait_spec.name_template
-        if not name_template:
-            name_template = "%s_generated"
-
-        ns = trait_spec.name_source
-        while isinstance(ns, (list, tuple)):
-            if len(ns) > 1:
-                iflogger.warning("Only one name_source per trait is allowed")
-            ns = ns[0]
-
-        if not isinstance(ns, (str, bytes)):
-            raise ValueError(
-                "name_source of '{}' trait should be an input trait "
-                "name, but a type {} object was found".format(name, type(ns))
-            )
-
-        if getattr(inputs, ns) is not attrs.NOTHING:
-            name_source = ns
-            source = getattr(inputs, name_source)
-            while isinstance(source, list):
-                source = source[0]
-
-            # special treatment for files
-            try:
-                _, base, source_ext = split_filename(source)
-            except (AttributeError, TypeError):
-                base = source
-        else:
-            if name in chain:
-                raise NipypeInterfaceError("Mutually pointing name_sources")
-
-            chain.append(name)
-            base = _filename_from_source(
-                ns,
-                chain,
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-            if base is not attrs.NOTHING:
-                _, _, source_ext = split_filename(base)
-            else:
-                # Do not generate filename when required fields are missing
-                return retval
-
-        chain = None
-        retval = name_template % base
-        _, _, ext = split_filename(retval)
-        if trait_spec.keep_extension and (ext or source_ext):
-            if (ext is None or not ext) and source_ext:
-                retval = retval + source_ext
-        else:
-            retval = _overload_extension(
-                retval,
-                name,
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-    return retval
-
-
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
-# Original source at L891 of <nipype-install>/interfaces/base/core.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    metadata = dict(name_source=lambda t: t is not None)
-    traits = inputs.traits(**metadata)
-    if traits:
-        outputs = {}
-        for name, trait_spec in list(traits.items()):
-            out_name = name
-            if trait_spec.output_name is not None:
-                out_name = trait_spec.output_name
-            fname = _filename_from_source(
-                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-            )
-            if fname is not attrs.NOTHING:
-                outputs[out_name] = os.path.abspath(fname)
-        return outputs
diff --git a/example-specs/task/nipype/fsl/convert_xfm_callables.py b/example-specs/task/nipype/fsl/convert_xfm_callables.py
index 840647a0..374e76f0 100644
--- a/example-specs/task/nipype/fsl/convert_xfm_callables.py
+++ b/example-specs/task/nipype/fsl/convert_xfm_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of ConvertXFM.yaml"""
 
+import attrs
 import os
 import os.path as op
 from pathlib import Path
-import attrs
 
 
 def out_file_default(inputs):
@@ -17,55 +17,40 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_file"]
 
 
-# Original source at L58 of <nipype-install>/utils/filemanip.py
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
+# Original source at L1592 of <nipype-install>/interfaces/fsl/utils.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )["out_file"]
+    return None
 
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
 
-    return pth, fname, ext
+# Original source at L1567 of <nipype-install>/interfaces/fsl/utils.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outfile = inputs.out_file
+    if outfile is attrs.NOTHING:
+        _, infile1, _ = split_filename(inputs.in_file)
+        if inputs.invert_xfm:
+            outfile = fname_presuffix(
+                infile1, suffix="_inv.mat", newpath=output_dir, use_ext=False
+            )
+        else:
+            if inputs.concat_xfm:
+                _, infile2, _ = split_filename(inputs.in_file2)
+                outfile = fname_presuffix(
+                    "%s_%s" % (infile1, infile2),
+                    suffix=".mat",
+                    newpath=output_dir,
+                    use_ext=False,
+                )
+            else:
+                outfile = fname_presuffix(
+                    infile1, suffix="_fix.mat", newpath=output_dir, use_ext=False
+                )
+    outputs["out_file"] = os.path.abspath(outfile)
+    return outputs
 
 
 # Original source at L108 of <nipype-install>/utils/filemanip.py
@@ -111,37 +96,52 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
-# Original source at L1592 of <nipype-install>/interfaces/fsl/utils.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "out_file":
-        return _list_outputs(
-            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-        )["out_file"]
-    return None
+# Original source at L58 of <nipype-install>/utils/filemanip.py
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
 
+    Parameters
+    ----------
+    fname : str
+        file or path name
 
-# Original source at L1567 of <nipype-install>/interfaces/fsl/utils.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    outfile = inputs.out_file
-    if outfile is attrs.NOTHING:
-        _, infile1, _ = split_filename(inputs.in_file)
-        if inputs.invert_xfm:
-            outfile = fname_presuffix(
-                infile1, suffix="_inv.mat", newpath=output_dir, use_ext=False
-            )
-        else:
-            if inputs.concat_xfm:
-                _, infile2, _ = split_filename(inputs.in_file2)
-                outfile = fname_presuffix(
-                    "%s_%s" % (infile1, infile2),
-                    suffix=".mat",
-                    newpath=output_dir,
-                    use_ext=False,
-                )
-            else:
-                outfile = fname_presuffix(
-                    infile1, suffix="_fix.mat", newpath=output_dir, use_ext=False
-                )
-    outputs["out_file"] = os.path.abspath(outfile)
-    return outputs
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
diff --git a/example-specs/task/nipype/fsl/copy_geom_callables.py b/example-specs/task/nipype/fsl/copy_geom_callables.py
index 1d7e8a6f..f1ae1c96 100644
--- a/example-specs/task/nipype/fsl/copy_geom_callables.py
+++ b/example-specs/task/nipype/fsl/copy_geom_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of CopyGeom.yaml"""
 
-from glob import glob
 import attrs
 import logging
 import os
 import os.path as op
+from glob import glob
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -20,6 +20,182 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+# Original source at L249 of <nipype-install>/interfaces/fsl/base.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value + Info.output_type_to_ext(inputs.output_type)
+
+
+# Original source at L58 of <nipype-install>/utils/filemanip.py
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
 # Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
@@ -151,13 +327,6 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
-# Original source at L249 of <nipype-install>/interfaces/fsl/base.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    return value + Info.output_type_to_ext(inputs.output_type)
-
-
 # Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
@@ -167,172 +336,3 @@ def __init__(self, value):
 
     def __str__(self):
         return "{}".format(self.value)
-
-
-# Original source at L58 of <nipype-install>/utils/filemanip.py
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
-# Original source at L809 of <nipype-install>/interfaces/base/core.py
-def _filename_from_source(
-    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    if chain is None:
-        chain = []
-
-    trait_spec = inputs.trait(name)
-    retval = getattr(inputs, name)
-    source_ext = None
-    if (retval is attrs.NOTHING) or "%s" in retval:
-        if not trait_spec.name_source:
-            return retval
-
-        # Do not generate filename when excluded by other inputs
-        if any(
-            (getattr(inputs, field) is not attrs.NOTHING)
-            for field in trait_spec.xor or ()
-        ):
-            return retval
-
-        # Do not generate filename when required fields are missing
-        if not all(
-            (getattr(inputs, field) is not attrs.NOTHING)
-            for field in trait_spec.requires or ()
-        ):
-            return retval
-
-        if (retval is not attrs.NOTHING) and "%s" in retval:
-            name_template = retval
-        else:
-            name_template = trait_spec.name_template
-        if not name_template:
-            name_template = "%s_generated"
-
-        ns = trait_spec.name_source
-        while isinstance(ns, (list, tuple)):
-            if len(ns) > 1:
-                iflogger.warning("Only one name_source per trait is allowed")
-            ns = ns[0]
-
-        if not isinstance(ns, (str, bytes)):
-            raise ValueError(
-                "name_source of '{}' trait should be an input trait "
-                "name, but a type {} object was found".format(name, type(ns))
-            )
-
-        if getattr(inputs, ns) is not attrs.NOTHING:
-            name_source = ns
-            source = getattr(inputs, name_source)
-            while isinstance(source, list):
-                source = source[0]
-
-            # special treatment for files
-            try:
-                _, base, source_ext = split_filename(source)
-            except (AttributeError, TypeError):
-                base = source
-        else:
-            if name in chain:
-                raise NipypeInterfaceError("Mutually pointing name_sources")
-
-            chain.append(name)
-            base = _filename_from_source(
-                ns,
-                chain,
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-            if base is not attrs.NOTHING:
-                _, _, source_ext = split_filename(base)
-            else:
-                # Do not generate filename when required fields are missing
-                return retval
-
-        chain = None
-        retval = name_template % base
-        _, _, ext = split_filename(retval)
-        if trait_spec.keep_extension and (ext or source_ext):
-            if (ext is None or not ext) and source_ext:
-                retval = retval + source_ext
-        else:
-            retval = _overload_extension(
-                retval,
-                name,
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-    return retval
-
-
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
-# Original source at L891 of <nipype-install>/interfaces/base/core.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    metadata = dict(name_source=lambda t: t is not None)
-    traits = inputs.traits(**metadata)
-    if traits:
-        outputs = {}
-        for name, trait_spec in list(traits.items()):
-            out_name = name
-            if trait_spec.output_name is not None:
-                out_name = trait_spec.output_name
-            fname = _filename_from_source(
-                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-            )
-            if fname is not attrs.NOTHING:
-                outputs[out_name] = os.path.abspath(fname)
-        return outputs
diff --git a/example-specs/task/nipype/fsl/dilate_image_callables.py b/example-specs/task/nipype/fsl/dilate_image_callables.py
index 319edd93..db0f502f 100644
--- a/example-specs/task/nipype/fsl/dilate_image_callables.py
+++ b/example-specs/task/nipype/fsl/dilate_image_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of DilateImage.yaml"""
 
-from glob import glob
 import attrs
 import logging
 import os
 import os.path as op
+from glob import glob
 from pathlib import Path
 
 
@@ -22,42 +22,86 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
+# Original source at L61 of <nipype-install>/interfaces/fsl/maths.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )["out_file"]
+    return None
 
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
 
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
 
-            klass._version = klass.parse_version(raw_info)
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
 
-        return klass._version
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
 
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "fslmaths"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+# Original source at L51 of <nipype-install>/interfaces/fsl/maths.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = inputs.out_file
+    if inputs.out_file is attrs.NOTHING:
+        outputs["out_file"] = _gen_fname(
+            inputs.in_file,
+            suffix=_suffix,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    outputs["out_file"] = os.path.abspath(outputs["out_file"])
+    return outputs
 
 
 # Original source at L108 of <nipype-install>/utils/filemanip.py
@@ -154,6 +198,44 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
@@ -245,85 +327,3 @@ def standard_image(img_name=None):
                 for filename in glob(os.path.join(stdpath, "*nii*"))
             ]
         return os.path.join(stdpath, img_name)
-
-
-# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
-def _gen_fname(
-    basename,
-    cwd=None,
-    suffix=None,
-    change_ext=True,
-    ext=None,
-    inputs=None,
-    stdout=None,
-    stderr=None,
-    output_dir=None,
-):
-    """Generate a filename based on the given parameters.
-
-    The filename will take the form: cwd/basename<suffix><ext>.
-    If change_ext is True, it will use the extensions specified in
-    <instance>inputs.output_type.
-
-    Parameters
-    ----------
-    basename : str
-        Filename to base the new filename on.
-    cwd : str
-        Path to prefix to the new filename. (default is output_dir)
-    suffix : str
-        Suffix to add to the `basename`.  (defaults is '' )
-    change_ext : bool
-        Flag to change the filename extension to the FSL output type.
-        (default True)
-
-    Returns
-    -------
-    fname : str
-        New filename based on given parameters.
-
-    """
-
-    if basename == "":
-        msg = "Unable to generate filename for command %s. " % "fslmaths"
-        msg += "basename is not set!"
-        raise ValueError(msg)
-    if cwd is None:
-        cwd = output_dir
-    if ext is None:
-        ext = Info.output_type_to_ext(inputs.output_type)
-    if change_ext:
-        if suffix:
-            suffix = "".join((suffix, ext))
-        else:
-            suffix = ext
-    if suffix is None:
-        suffix = ""
-    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
-    return fname
-
-
-# Original source at L61 of <nipype-install>/interfaces/fsl/maths.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "out_file":
-        return _list_outputs(
-            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-        )["out_file"]
-    return None
-
-
-# Original source at L51 of <nipype-install>/interfaces/fsl/maths.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    outputs["out_file"] = inputs.out_file
-    if inputs.out_file is attrs.NOTHING:
-        outputs["out_file"] = _gen_fname(
-            inputs.in_file,
-            suffix=_suffix,
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-    outputs["out_file"] = os.path.abspath(outputs["out_file"])
-    return outputs
diff --git a/example-specs/task/nipype/fsl/distance_map_callables.py b/example-specs/task/nipype/fsl/distance_map_callables.py
index 46ae75eb..f12fbb62 100644
--- a/example-specs/task/nipype/fsl/distance_map_callables.py
+++ b/example-specs/task/nipype/fsl/distance_map_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of DistanceMap.yaml"""
 
+import attrs
 import os
 import os.path as op
 from pathlib import Path
-import attrs
 
 
 def distance_map_default(inputs):
@@ -24,6 +24,35 @@ def local_max_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["local_max_file"]
 
 
+# Original source at L1537 of <nipype-install>/interfaces/fsl/dti.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "distance_map":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )["distance_map"]
+    return None
+
+
+# Original source at L1519 of <nipype-install>/interfaces/fsl/dti.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    _si = inputs
+    outputs["distance_map"] = _si.distance_map
+    if _si.distance_map is attrs.NOTHING:
+        outputs["distance_map"] = fname_presuffix(
+            _si.in_file, suffix="_dstmap", use_ext=True, newpath=output_dir
+        )
+    outputs["distance_map"] = os.path.abspath(outputs["distance_map"])
+    if _si.local_max_file is not attrs.NOTHING:
+        outputs["local_max_file"] = _si.local_max_file
+        if isinstance(_si.local_max_file, bool):
+            outputs["local_max_file"] = fname_presuffix(
+                _si.in_file, suffix="_lclmax", use_ext=True, newpath=output_dir
+            )
+        outputs["local_max_file"] = os.path.abspath(outputs["local_max_file"])
+    return outputs
+
+
 # Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
@@ -116,32 +145,3 @@ def split_filename(fname):
         fname, ext = op.splitext(fname)
 
     return pth, fname, ext
-
-
-# Original source at L1537 of <nipype-install>/interfaces/fsl/dti.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "distance_map":
-        return _list_outputs(
-            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-        )["distance_map"]
-    return None
-
-
-# Original source at L1519 of <nipype-install>/interfaces/fsl/dti.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    _si = inputs
-    outputs["distance_map"] = _si.distance_map
-    if _si.distance_map is attrs.NOTHING:
-        outputs["distance_map"] = fname_presuffix(
-            _si.in_file, suffix="_dstmap", use_ext=True, newpath=output_dir
-        )
-    outputs["distance_map"] = os.path.abspath(outputs["distance_map"])
-    if _si.local_max_file is not attrs.NOTHING:
-        outputs["local_max_file"] = _si.local_max_file
-        if isinstance(_si.local_max_file, bool):
-            outputs["local_max_file"] = fname_presuffix(
-                _si.in_file, suffix="_lclmax", use_ext=True, newpath=output_dir
-            )
-        outputs["local_max_file"] = os.path.abspath(outputs["local_max_file"])
-    return outputs
diff --git a/example-specs/task/nipype/fsl/dti_fit_callables.py b/example-specs/task/nipype/fsl/dti_fit_callables.py
index cd7f9ee6..70373229 100644
--- a/example-specs/task/nipype/fsl/dti_fit_callables.py
+++ b/example-specs/task/nipype/fsl/dti_fit_callables.py
@@ -1,32 +1,18 @@
 """Module to put any functions that are referred to in the "callables" section of DTIFit.yaml"""
 
-from glob import glob
 import attrs
 import logging
 import os
 import os.path as op
+from glob import glob
 from pathlib import Path
 
 
-def V1_callable(output_dir, inputs, stdout, stderr):
-    outputs = _list_outputs(
-        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
-    )
-    return outputs["V1"]
-
-
-def V2_callable(output_dir, inputs, stdout, stderr):
-    outputs = _list_outputs(
-        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
-    )
-    return outputs["V2"]
-
-
-def V3_callable(output_dir, inputs, stdout, stderr):
+def FA_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["V3"]
+    return outputs["FA"]
 
 
 def L1_callable(output_dir, inputs, stdout, stderr):
@@ -57,32 +43,39 @@ def MD_callable(output_dir, inputs, stdout, stderr):
     return outputs["MD"]
 
 
-def FA_callable(output_dir, inputs, stdout, stderr):
+def MO_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["FA"]
+    return outputs["MO"]
 
 
-def MO_callable(output_dir, inputs, stdout, stderr):
+def S0_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["MO"]
+    return outputs["S0"]
 
 
-def S0_callable(output_dir, inputs, stdout, stderr):
+def V1_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["S0"]
+    return outputs["V1"]
 
 
-def tensor_callable(output_dir, inputs, stdout, stderr):
+def V2_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["tensor"]
+    return outputs["V2"]
+
+
+def V3_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["V3"]
 
 
 def sse_callable(output_dir, inputs, stdout, stderr):
@@ -92,45 +85,101 @@ def sse_callable(output_dir, inputs, stdout, stderr):
     return outputs["sse"]
 
 
+def tensor_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["tensor"]
+
+
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
 
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
 
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
 
-            klass._version = klass.parse_version(raw_info)
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
 
-        return klass._version
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
 
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "dtifit"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+# Original source at L114 of <nipype-install>/interfaces/fsl/dti.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    keys_to_ignore = {"outputtype", "environ", "args"}
+    # Optional output: Map output name to input flag
+    opt_output = {"tensor": inputs.save_tensor, "sse": inputs.sse}
+    # Ignore optional output, whose corresponding input-flag is not defined
+    # or set to False
+    for output, input_flag in opt_output.items():
+        if (input_flag is not attrs.NOTHING) and input_flag:
+            # this is wanted output, do not ignore
+            continue
+        keys_to_ignore.add(output)
+
+    outputs = {}
+    for k in set(outputs.keys()) - keys_to_ignore:
+        outputs[k] = _gen_fname(
+            inputs.base_name,
+            suffix="_" + k,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    return outputs
 
 
 # Original source at L108 of <nipype-install>/utils/filemanip.py
@@ -227,6 +276,44 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
@@ -318,90 +405,3 @@ def standard_image(img_name=None):
                 for filename in glob(os.path.join(stdpath, "*nii*"))
             ]
         return os.path.join(stdpath, img_name)
-
-
-# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
-def _gen_fname(
-    basename,
-    cwd=None,
-    suffix=None,
-    change_ext=True,
-    ext=None,
-    inputs=None,
-    stdout=None,
-    stderr=None,
-    output_dir=None,
-):
-    """Generate a filename based on the given parameters.
-
-    The filename will take the form: cwd/basename<suffix><ext>.
-    If change_ext is True, it will use the extensions specified in
-    <instance>inputs.output_type.
-
-    Parameters
-    ----------
-    basename : str
-        Filename to base the new filename on.
-    cwd : str
-        Path to prefix to the new filename. (default is output_dir)
-    suffix : str
-        Suffix to add to the `basename`.  (defaults is '' )
-    change_ext : bool
-        Flag to change the filename extension to the FSL output type.
-        (default True)
-
-    Returns
-    -------
-    fname : str
-        New filename based on given parameters.
-
-    """
-
-    if basename == "":
-        msg = "Unable to generate filename for command %s. " % "dtifit"
-        msg += "basename is not set!"
-        raise ValueError(msg)
-    if cwd is None:
-        cwd = output_dir
-    if ext is None:
-        ext = Info.output_type_to_ext(inputs.output_type)
-    if change_ext:
-        if suffix:
-            suffix = "".join((suffix, ext))
-        else:
-            suffix = ext
-    if suffix is None:
-        suffix = ""
-    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
-    return fname
-
-
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
-# Original source at L114 of <nipype-install>/interfaces/fsl/dti.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    keys_to_ignore = {"outputtype", "environ", "args"}
-    # Optional output: Map output name to input flag
-    opt_output = {"tensor": inputs.save_tensor, "sse": inputs.sse}
-    # Ignore optional output, whose corresponding input-flag is not defined
-    # or set to False
-    for output, input_flag in opt_output.items():
-        if (input_flag is not attrs.NOTHING) and input_flag:
-            # this is wanted output, do not ignore
-            continue
-        keys_to_ignore.add(output)
-
-    outputs = {}
-    for k in set(outputs.keys()) - keys_to_ignore:
-        outputs[k] = _gen_fname(
-            inputs.base_name,
-            suffix="_" + k,
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-    return outputs
diff --git a/example-specs/task/nipype/fsl/dual_regression_callables.py b/example-specs/task/nipype/fsl/dual_regression_callables.py
index 341d74ec..55ed5581 100644
--- a/example-specs/task/nipype/fsl/dual_regression_callables.py
+++ b/example-specs/task/nipype/fsl/dual_regression_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of DualRegression.yaml"""
 
-import os
 import attrs
+import os
 
 
 def out_dir_default(inputs):
diff --git a/example-specs/task/nipype/fsl/eddy_callables.py b/example-specs/task/nipype/fsl/eddy_callables.py
index d38ccc25..1fc233fa 100644
--- a/example-specs/task/nipype/fsl/eddy_callables.py
+++ b/example-specs/task/nipype/fsl/eddy_callables.py
@@ -1,28 +1,28 @@
 """Module to put any functions that are referred to in the "callables" section of Eddy.yaml"""
 
-import os
 import attrs
+import os
 
 
-def out_corrected_callable(output_dir, inputs, stdout, stderr):
+def out_cnr_maps_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_corrected"]
+    return outputs["out_cnr_maps"]
 
 
-def out_parameter_callable(output_dir, inputs, stdout, stderr):
+def out_corrected_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_parameter"]
+    return outputs["out_corrected"]
 
 
-def out_rotated_bvecs_callable(output_dir, inputs, stdout, stderr):
+def out_movement_over_time_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_rotated_bvecs"]
+    return outputs["out_movement_over_time"]
 
 
 def out_movement_rms_callable(output_dir, inputs, stdout, stderr):
@@ -32,81 +32,81 @@ def out_movement_rms_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_movement_rms"]
 
 
-def out_restricted_movement_rms_callable(output_dir, inputs, stdout, stderr):
+def out_outlier_free_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_restricted_movement_rms"]
+    return outputs["out_outlier_free"]
 
 
-def out_shell_alignment_parameters_callable(output_dir, inputs, stdout, stderr):
+def out_outlier_map_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_shell_alignment_parameters"]
+    return outputs["out_outlier_map"]
 
 
-def out_shell_pe_translation_parameters_callable(output_dir, inputs, stdout, stderr):
+def out_outlier_n_sqr_stdev_map_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_shell_pe_translation_parameters"]
+    return outputs["out_outlier_n_sqr_stdev_map"]
 
 
-def out_outlier_map_callable(output_dir, inputs, stdout, stderr):
+def out_outlier_n_stdev_map_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_outlier_map"]
+    return outputs["out_outlier_n_stdev_map"]
 
 
-def out_outlier_n_stdev_map_callable(output_dir, inputs, stdout, stderr):
+def out_outlier_report_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_outlier_n_stdev_map"]
+    return outputs["out_outlier_report"]
 
 
-def out_outlier_n_sqr_stdev_map_callable(output_dir, inputs, stdout, stderr):
+def out_parameter_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_outlier_n_sqr_stdev_map"]
+    return outputs["out_parameter"]
 
 
-def out_outlier_report_callable(output_dir, inputs, stdout, stderr):
+def out_residuals_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_outlier_report"]
+    return outputs["out_residuals"]
 
 
-def out_outlier_free_callable(output_dir, inputs, stdout, stderr):
+def out_restricted_movement_rms_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_outlier_free"]
+    return outputs["out_restricted_movement_rms"]
 
 
-def out_movement_over_time_callable(output_dir, inputs, stdout, stderr):
+def out_rotated_bvecs_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_movement_over_time"]
+    return outputs["out_rotated_bvecs"]
 
 
-def out_cnr_maps_callable(output_dir, inputs, stdout, stderr):
+def out_shell_alignment_parameters_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_cnr_maps"]
+    return outputs["out_shell_alignment_parameters"]
 
 
-def out_residuals_callable(output_dir, inputs, stdout, stderr):
+def out_shell_pe_translation_parameters_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_residuals"]
+    return outputs["out_shell_pe_translation_parameters"]
 
 
 # Original source at L885 of <nipype-install>/interfaces/base/core.py
diff --git a/example-specs/task/nipype/fsl/eddy_correct_callables.py b/example-specs/task/nipype/fsl/eddy_correct_callables.py
index 965e4f1c..209f413b 100644
--- a/example-specs/task/nipype/fsl/eddy_correct_callables.py
+++ b/example-specs/task/nipype/fsl/eddy_correct_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of EddyCorrect.yaml"""
 
-from glob import glob
 import attrs
 import logging
 import os
 import os.path as op
+from glob import glob
 
 
 def eddy_corrected_callable(output_dir, inputs, stdout, stderr):
@@ -20,6 +20,182 @@ def eddy_corrected_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+# Original source at L249 of <nipype-install>/interfaces/fsl/base.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value + Info.output_type_to_ext(inputs.output_type)
+
+
+# Original source at L58 of <nipype-install>/utils/filemanip.py
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
 # Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
@@ -151,13 +327,6 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
-# Original source at L249 of <nipype-install>/interfaces/fsl/base.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    return value + Info.output_type_to_ext(inputs.output_type)
-
-
 # Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
@@ -167,172 +336,3 @@ def __init__(self, value):
 
     def __str__(self):
         return "{}".format(self.value)
-
-
-# Original source at L58 of <nipype-install>/utils/filemanip.py
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
-# Original source at L809 of <nipype-install>/interfaces/base/core.py
-def _filename_from_source(
-    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    if chain is None:
-        chain = []
-
-    trait_spec = inputs.trait(name)
-    retval = getattr(inputs, name)
-    source_ext = None
-    if (retval is attrs.NOTHING) or "%s" in retval:
-        if not trait_spec.name_source:
-            return retval
-
-        # Do not generate filename when excluded by other inputs
-        if any(
-            (getattr(inputs, field) is not attrs.NOTHING)
-            for field in trait_spec.xor or ()
-        ):
-            return retval
-
-        # Do not generate filename when required fields are missing
-        if not all(
-            (getattr(inputs, field) is not attrs.NOTHING)
-            for field in trait_spec.requires or ()
-        ):
-            return retval
-
-        if (retval is not attrs.NOTHING) and "%s" in retval:
-            name_template = retval
-        else:
-            name_template = trait_spec.name_template
-        if not name_template:
-            name_template = "%s_generated"
-
-        ns = trait_spec.name_source
-        while isinstance(ns, (list, tuple)):
-            if len(ns) > 1:
-                iflogger.warning("Only one name_source per trait is allowed")
-            ns = ns[0]
-
-        if not isinstance(ns, (str, bytes)):
-            raise ValueError(
-                "name_source of '{}' trait should be an input trait "
-                "name, but a type {} object was found".format(name, type(ns))
-            )
-
-        if getattr(inputs, ns) is not attrs.NOTHING:
-            name_source = ns
-            source = getattr(inputs, name_source)
-            while isinstance(source, list):
-                source = source[0]
-
-            # special treatment for files
-            try:
-                _, base, source_ext = split_filename(source)
-            except (AttributeError, TypeError):
-                base = source
-        else:
-            if name in chain:
-                raise NipypeInterfaceError("Mutually pointing name_sources")
-
-            chain.append(name)
-            base = _filename_from_source(
-                ns,
-                chain,
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-            if base is not attrs.NOTHING:
-                _, _, source_ext = split_filename(base)
-            else:
-                # Do not generate filename when required fields are missing
-                return retval
-
-        chain = None
-        retval = name_template % base
-        _, _, ext = split_filename(retval)
-        if trait_spec.keep_extension and (ext or source_ext):
-            if (ext is None or not ext) and source_ext:
-                retval = retval + source_ext
-        else:
-            retval = _overload_extension(
-                retval,
-                name,
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-    return retval
-
-
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
-# Original source at L891 of <nipype-install>/interfaces/base/core.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    metadata = dict(name_source=lambda t: t is not None)
-    traits = inputs.traits(**metadata)
-    if traits:
-        outputs = {}
-        for name, trait_spec in list(traits.items()):
-            out_name = name
-            if trait_spec.output_name is not None:
-                out_name = trait_spec.output_name
-            fname = _filename_from_source(
-                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-            )
-            if fname is not attrs.NOTHING:
-                outputs[out_name] = os.path.abspath(fname)
-        return outputs
diff --git a/example-specs/task/nipype/fsl/eddy_quad_callables.py b/example-specs/task/nipype/fsl/eddy_quad_callables.py
index de2f4937..daf563b7 100644
--- a/example-specs/task/nipype/fsl/eddy_quad_callables.py
+++ b/example-specs/task/nipype/fsl/eddy_quad_callables.py
@@ -1,50 +1,50 @@
 """Module to put any functions that are referred to in the "callables" section of EddyQuad.yaml"""
 
+import attrs
 import os
 from glob import glob
-import attrs
 
 
-def qc_json_callable(output_dir, inputs, stdout, stderr):
+def avg_b0_pe_png_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["qc_json"]
+    return outputs["avg_b0_pe_png"]
 
 
-def qc_pdf_callable(output_dir, inputs, stdout, stderr):
+def avg_b_png_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["qc_pdf"]
+    return outputs["avg_b_png"]
 
 
-def avg_b_png_callable(output_dir, inputs, stdout, stderr):
+def clean_volumes_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["avg_b_png"]
+    return outputs["clean_volumes"]
 
 
-def avg_b0_pe_png_callable(output_dir, inputs, stdout, stderr):
+def cnr_png_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["avg_b0_pe_png"]
+    return outputs["cnr_png"]
 
 
-def cnr_png_callable(output_dir, inputs, stdout, stderr):
+def qc_json_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["cnr_png"]
+    return outputs["qc_json"]
 
 
-def vdm_png_callable(output_dir, inputs, stdout, stderr):
+def qc_pdf_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["vdm_png"]
+    return outputs["qc_pdf"]
 
 
 def residuals_callable(output_dir, inputs, stdout, stderr):
@@ -54,11 +54,11 @@ def residuals_callable(output_dir, inputs, stdout, stderr):
     return outputs["residuals"]
 
 
-def clean_volumes_callable(output_dir, inputs, stdout, stderr):
+def vdm_png_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["clean_volumes"]
+    return outputs["vdm_png"]
 
 
 # Original source at L885 of <nipype-install>/interfaces/base/core.py
diff --git a/example-specs/task/nipype/fsl/epi_de_warp_callables.py b/example-specs/task/nipype/fsl/epi_de_warp_callables.py
index abd37be7..b121f9bf 100644
--- a/example-specs/task/nipype/fsl/epi_de_warp_callables.py
+++ b/example-specs/task/nipype/fsl/epi_de_warp_callables.py
@@ -1,17 +1,13 @@
 """Module to put any functions that are referred to in the "callables" section of EPIDeWarp.yaml"""
 
-from glob import glob
 import attrs
 import logging
 import os
 import os.path as op
+from glob import glob
 from pathlib import Path
 
 
-def vsm_default(inputs):
-    return _gen_filename("vsm", inputs=inputs)
-
-
 def exfdw_default(inputs):
     return _gen_filename("exfdw", inputs=inputs)
 
@@ -20,73 +16,187 @@ def tmpdir_default(inputs):
     return _gen_filename("tmpdir", inputs=inputs)
 
 
-def unwarped_file_callable(output_dir, inputs, stdout, stderr):
+def vsm_default(inputs):
+    return _gen_filename("vsm", inputs=inputs)
+
+
+def exf_mask_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["unwarped_file"]
+    return outputs["exf_mask"]
 
 
-def vsm_file_callable(output_dir, inputs, stdout, stderr):
+def exfdw_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["vsm_file"]
+    return outputs["exfdw"]
 
 
-def exfdw_callable(output_dir, inputs, stdout, stderr):
+def unwarped_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["exfdw"]
+    return outputs["unwarped_file"]
 
 
-def exf_mask_callable(output_dir, inputs, stdout, stderr):
+def vsm_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["exf_mask"]
+    return outputs["vsm_file"]
 
 
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
+# Original source at L1428 of <nipype-install>/interfaces/fsl/epi.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "exfdw":
+        if inputs.exf_file is not attrs.NOTHING:
+            return _gen_fname(
+                inputs.exf_file,
+                suffix="_exfdw",
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+        else:
+            return _gen_fname(
+                "exfdw",
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    if name == "epidw":
+        if inputs.epi_file is not attrs.NOTHING:
+            return _gen_fname(
+                inputs.epi_file,
+                suffix="_epidw",
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    if name == "vsm":
+        return _gen_fname(
+            "vsm", inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )
+    if name == "tmpdir":
+        return os.path.join(output_dir, "temp")
+    return None
 
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
 
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
 
-            klass._version = klass.parse_version(raw_info)
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
 
-        return klass._version
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
 
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "epidewarp.fsl"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+# Original source at L1443 of <nipype-install>/interfaces/fsl/epi.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    if inputs.exfdw is attrs.NOTHING:
+        outputs["exfdw"] = _gen_filename(
+            "exfdw", inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )
+    else:
+        outputs["exfdw"] = inputs.exfdw
+    if inputs.epi_file is not attrs.NOTHING:
+        if inputs.epidw is not attrs.NOTHING:
+            outputs["unwarped_file"] = inputs.epidw
+        else:
+            outputs["unwarped_file"] = _gen_filename(
+                "epidw",
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    if inputs.vsm is attrs.NOTHING:
+        outputs["vsm_file"] = _gen_filename(
+            "vsm", inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )
+    else:
+        outputs["vsm_file"] = _gen_fname(
+            inputs.vsm,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    if inputs.tmpdir is attrs.NOTHING:
+        outputs["exf_mask"] = _gen_fname(
+            cwd=_gen_filename("tmpdir"),
+            basename="maskexf",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    else:
+        outputs["exf_mask"] = _gen_fname(
+            cwd=inputs.tmpdir,
+            basename="maskexf",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    return outputs
 
 
 # Original source at L108 of <nipype-install>/utils/filemanip.py
@@ -183,6 +293,44 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
@@ -274,151 +422,3 @@ def standard_image(img_name=None):
                 for filename in glob(os.path.join(stdpath, "*nii*"))
             ]
         return os.path.join(stdpath, img_name)
-
-
-# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
-def _gen_fname(
-    basename,
-    cwd=None,
-    suffix=None,
-    change_ext=True,
-    ext=None,
-    inputs=None,
-    stdout=None,
-    stderr=None,
-    output_dir=None,
-):
-    """Generate a filename based on the given parameters.
-
-    The filename will take the form: cwd/basename<suffix><ext>.
-    If change_ext is True, it will use the extensions specified in
-    <instance>inputs.output_type.
-
-    Parameters
-    ----------
-    basename : str
-        Filename to base the new filename on.
-    cwd : str
-        Path to prefix to the new filename. (default is output_dir)
-    suffix : str
-        Suffix to add to the `basename`.  (defaults is '' )
-    change_ext : bool
-        Flag to change the filename extension to the FSL output type.
-        (default True)
-
-    Returns
-    -------
-    fname : str
-        New filename based on given parameters.
-
-    """
-
-    if basename == "":
-        msg = "Unable to generate filename for command %s. " % "epidewarp.fsl"
-        msg += "basename is not set!"
-        raise ValueError(msg)
-    if cwd is None:
-        cwd = output_dir
-    if ext is None:
-        ext = Info.output_type_to_ext(inputs.output_type)
-    if change_ext:
-        if suffix:
-            suffix = "".join((suffix, ext))
-        else:
-            suffix = ext
-    if suffix is None:
-        suffix = ""
-    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
-    return fname
-
-
-# Original source at L1428 of <nipype-install>/interfaces/fsl/epi.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "exfdw":
-        if inputs.exf_file is not attrs.NOTHING:
-            return _gen_fname(
-                inputs.exf_file,
-                suffix="_exfdw",
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-        else:
-            return _gen_fname(
-                "exfdw",
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-    if name == "epidw":
-        if inputs.epi_file is not attrs.NOTHING:
-            return _gen_fname(
-                inputs.epi_file,
-                suffix="_epidw",
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-    if name == "vsm":
-        return _gen_fname(
-            "vsm", inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-        )
-    if name == "tmpdir":
-        return os.path.join(output_dir, "temp")
-    return None
-
-
-# Original source at L1443 of <nipype-install>/interfaces/fsl/epi.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    if inputs.exfdw is attrs.NOTHING:
-        outputs["exfdw"] = _gen_filename(
-            "exfdw", inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-        )
-    else:
-        outputs["exfdw"] = inputs.exfdw
-    if inputs.epi_file is not attrs.NOTHING:
-        if inputs.epidw is not attrs.NOTHING:
-            outputs["unwarped_file"] = inputs.epidw
-        else:
-            outputs["unwarped_file"] = _gen_filename(
-                "epidw",
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-    if inputs.vsm is attrs.NOTHING:
-        outputs["vsm_file"] = _gen_filename(
-            "vsm", inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-        )
-    else:
-        outputs["vsm_file"] = _gen_fname(
-            inputs.vsm,
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-    if inputs.tmpdir is attrs.NOTHING:
-        outputs["exf_mask"] = _gen_fname(
-            cwd=_gen_filename("tmpdir"),
-            basename="maskexf",
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-    else:
-        outputs["exf_mask"] = _gen_fname(
-            cwd=inputs.tmpdir,
-            basename="maskexf",
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-    return outputs
diff --git a/example-specs/task/nipype/fsl/epi_reg_callables.py b/example-specs/task/nipype/fsl/epi_reg_callables.py
index c50c7e4b..9acf06ea 100644
--- a/example-specs/task/nipype/fsl/epi_reg_callables.py
+++ b/example-specs/task/nipype/fsl/epi_reg_callables.py
@@ -1,35 +1,35 @@
 """Module to put any functions that are referred to in the "callables" section of EpiReg.yaml"""
 
-import os
 import attrs
+import os
 
 
-def out_file_callable(output_dir, inputs, stdout, stderr):
+def epi2str_inv_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_file"]
+    return outputs["epi2str_inv"]
 
 
-def out_1vol_callable(output_dir, inputs, stdout, stderr):
+def epi2str_mat_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_1vol"]
+    return outputs["epi2str_mat"]
 
 
-def fmap2str_mat_callable(output_dir, inputs, stdout, stderr):
+def fmap2epi_mat_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["fmap2str_mat"]
+    return outputs["fmap2epi_mat"]
 
 
-def fmap2epi_mat_callable(output_dir, inputs, stdout, stderr):
+def fmap2str_mat_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["fmap2epi_mat"]
+    return outputs["fmap2str_mat"]
 
 
 def fmap_epi_callable(output_dir, inputs, stdout, stderr):
@@ -53,53 +53,53 @@ def fmapmag_str_callable(output_dir, inputs, stdout, stderr):
     return outputs["fmapmag_str"]
 
 
-def epi2str_inv_callable(output_dir, inputs, stdout, stderr):
+def fullwarp_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["epi2str_inv"]
+    return outputs["fullwarp"]
 
 
-def epi2str_mat_callable(output_dir, inputs, stdout, stderr):
+def out_1vol_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["epi2str_mat"]
+    return outputs["out_1vol"]
 
 
-def shiftmap_callable(output_dir, inputs, stdout, stderr):
+def out_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["shiftmap"]
+    return outputs["out_file"]
 
 
-def fullwarp_callable(output_dir, inputs, stdout, stderr):
+def seg_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["fullwarp"]
+    return outputs["seg"]
 
 
-def wmseg_callable(output_dir, inputs, stdout, stderr):
+def shiftmap_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["wmseg"]
+    return outputs["shiftmap"]
 
 
-def seg_callable(output_dir, inputs, stdout, stderr):
+def wmedge_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["seg"]
+    return outputs["wmedge"]
 
 
-def wmedge_callable(output_dir, inputs, stdout, stderr):
+def wmseg_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["wmedge"]
+    return outputs["wmseg"]
 
 
 # Original source at L885 of <nipype-install>/interfaces/base/core.py
diff --git a/example-specs/task/nipype/fsl/erode_image_callables.py b/example-specs/task/nipype/fsl/erode_image_callables.py
index bfefdc6d..da319d00 100644
--- a/example-specs/task/nipype/fsl/erode_image_callables.py
+++ b/example-specs/task/nipype/fsl/erode_image_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of ErodeImage.yaml"""
 
-from glob import glob
 import attrs
 import logging
 import os
 import os.path as op
+from glob import glob
 from pathlib import Path
 
 
@@ -22,42 +22,86 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
+# Original source at L61 of <nipype-install>/interfaces/fsl/maths.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )["out_file"]
+    return None
 
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
 
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
 
-            klass._version = klass.parse_version(raw_info)
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
 
-        return klass._version
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
 
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "fslmaths"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+# Original source at L51 of <nipype-install>/interfaces/fsl/maths.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = inputs.out_file
+    if inputs.out_file is attrs.NOTHING:
+        outputs["out_file"] = _gen_fname(
+            inputs.in_file,
+            suffix=_suffix,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    outputs["out_file"] = os.path.abspath(outputs["out_file"])
+    return outputs
 
 
 # Original source at L108 of <nipype-install>/utils/filemanip.py
@@ -154,6 +198,44 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
@@ -245,85 +327,3 @@ def standard_image(img_name=None):
                 for filename in glob(os.path.join(stdpath, "*nii*"))
             ]
         return os.path.join(stdpath, img_name)
-
-
-# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
-def _gen_fname(
-    basename,
-    cwd=None,
-    suffix=None,
-    change_ext=True,
-    ext=None,
-    inputs=None,
-    stdout=None,
-    stderr=None,
-    output_dir=None,
-):
-    """Generate a filename based on the given parameters.
-
-    The filename will take the form: cwd/basename<suffix><ext>.
-    If change_ext is True, it will use the extensions specified in
-    <instance>inputs.output_type.
-
-    Parameters
-    ----------
-    basename : str
-        Filename to base the new filename on.
-    cwd : str
-        Path to prefix to the new filename. (default is output_dir)
-    suffix : str
-        Suffix to add to the `basename`.  (defaults is '' )
-    change_ext : bool
-        Flag to change the filename extension to the FSL output type.
-        (default True)
-
-    Returns
-    -------
-    fname : str
-        New filename based on given parameters.
-
-    """
-
-    if basename == "":
-        msg = "Unable to generate filename for command %s. " % "fslmaths"
-        msg += "basename is not set!"
-        raise ValueError(msg)
-    if cwd is None:
-        cwd = output_dir
-    if ext is None:
-        ext = Info.output_type_to_ext(inputs.output_type)
-    if change_ext:
-        if suffix:
-            suffix = "".join((suffix, ext))
-        else:
-            suffix = ext
-    if suffix is None:
-        suffix = ""
-    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
-    return fname
-
-
-# Original source at L61 of <nipype-install>/interfaces/fsl/maths.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "out_file":
-        return _list_outputs(
-            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-        )["out_file"]
-    return None
-
-
-# Original source at L51 of <nipype-install>/interfaces/fsl/maths.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    outputs["out_file"] = inputs.out_file
-    if inputs.out_file is attrs.NOTHING:
-        outputs["out_file"] = _gen_fname(
-            inputs.in_file,
-            suffix=_suffix,
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-    outputs["out_file"] = os.path.abspath(outputs["out_file"])
-    return outputs
diff --git a/example-specs/task/nipype/fsl/extract_roi_callables.py b/example-specs/task/nipype/fsl/extract_roi_callables.py
index 136e8997..7ca660e2 100644
--- a/example-specs/task/nipype/fsl/extract_roi_callables.py
+++ b/example-specs/task/nipype/fsl/extract_roi_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of ExtractROI.yaml"""
 
-from glob import glob
 import attrs
 import logging
 import os
 import os.path as op
+from glob import glob
 from pathlib import Path
 
 
@@ -22,42 +22,102 @@ def roi_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
+# Original source at L513 of <nipype-install>/interfaces/fsl/utils.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "roi_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )[name]
+    return None
 
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
 
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
 
-            klass._version = klass.parse_version(raw_info)
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
 
-        return klass._version
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
 
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "fslroi"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+# Original source at L489 of <nipype-install>/interfaces/fsl/utils.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    """Create a Bunch which contains all possible files generated
+    by running the interface.  Some files are always generated, others
+    depending on which ``inputs`` options are set.
+
+
+    Returns
+    -------
+
+    outputs : Bunch object
+        Bunch object containing all possible files generated by
+        interface object.
+
+        If None, file was not generated
+        Else, contains path, filename of generated outputfile
+
+    """
+    outputs = {}
+    outputs["roi_file"] = inputs.roi_file
+    if outputs["roi_file"] is attrs.NOTHING:
+        outputs["roi_file"] = _gen_fname(
+            inputs.in_file,
+            suffix="_roi",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    outputs["roi_file"] = os.path.abspath(outputs["roi_file"])
+    return outputs
 
 
 # Original source at L108 of <nipype-install>/utils/filemanip.py
@@ -154,6 +214,44 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
@@ -245,101 +343,3 @@ def standard_image(img_name=None):
                 for filename in glob(os.path.join(stdpath, "*nii*"))
             ]
         return os.path.join(stdpath, img_name)
-
-
-# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
-def _gen_fname(
-    basename,
-    cwd=None,
-    suffix=None,
-    change_ext=True,
-    ext=None,
-    inputs=None,
-    stdout=None,
-    stderr=None,
-    output_dir=None,
-):
-    """Generate a filename based on the given parameters.
-
-    The filename will take the form: cwd/basename<suffix><ext>.
-    If change_ext is True, it will use the extensions specified in
-    <instance>inputs.output_type.
-
-    Parameters
-    ----------
-    basename : str
-        Filename to base the new filename on.
-    cwd : str
-        Path to prefix to the new filename. (default is output_dir)
-    suffix : str
-        Suffix to add to the `basename`.  (defaults is '' )
-    change_ext : bool
-        Flag to change the filename extension to the FSL output type.
-        (default True)
-
-    Returns
-    -------
-    fname : str
-        New filename based on given parameters.
-
-    """
-
-    if basename == "":
-        msg = "Unable to generate filename for command %s. " % "fslroi"
-        msg += "basename is not set!"
-        raise ValueError(msg)
-    if cwd is None:
-        cwd = output_dir
-    if ext is None:
-        ext = Info.output_type_to_ext(inputs.output_type)
-    if change_ext:
-        if suffix:
-            suffix = "".join((suffix, ext))
-        else:
-            suffix = ext
-    if suffix is None:
-        suffix = ""
-    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
-    return fname
-
-
-# Original source at L513 of <nipype-install>/interfaces/fsl/utils.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "roi_file":
-        return _list_outputs(
-            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-        )[name]
-    return None
-
-
-# Original source at L489 of <nipype-install>/interfaces/fsl/utils.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    """Create a Bunch which contains all possible files generated
-    by running the interface.  Some files are always generated, others
-    depending on which ``inputs`` options are set.
-
-
-    Returns
-    -------
-
-    outputs : Bunch object
-        Bunch object containing all possible files generated by
-        interface object.
-
-        If None, file was not generated
-        Else, contains path, filename of generated outputfile
-
-    """
-    outputs = {}
-    outputs["roi_file"] = inputs.roi_file
-    if outputs["roi_file"] is attrs.NOTHING:
-        outputs["roi_file"] = _gen_fname(
-            inputs.in_file,
-            suffix="_roi",
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-    outputs["roi_file"] = os.path.abspath(outputs["roi_file"])
-    return outputs
diff --git a/example-specs/task/nipype/fsl/fast_callables.py b/example-specs/task/nipype/fsl/fast_callables.py
index 95c21f76..b83ee373 100644
--- a/example-specs/task/nipype/fsl/fast_callables.py
+++ b/example-specs/task/nipype/fsl/fast_callables.py
@@ -1,244 +1,75 @@
 """Module to put any functions that are referred to in the "callables" section of FAST.yaml"""
 
-from glob import glob
 import attrs
 import logging
 import os
 import os.path as op
+from glob import glob
 from pathlib import Path
 
 
-def tissue_class_map_callable(output_dir, inputs, stdout, stderr):
+def bias_field_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["tissue_class_map"]
+    return outputs["bias_field"]
 
 
-def tissue_class_files_callable(output_dir, inputs, stdout, stderr):
+def mixeltype_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["tissue_class_files"]
+    return outputs["mixeltype"]
 
 
-def restored_image_callable(output_dir, inputs, stdout, stderr):
+def partial_volume_files_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["restored_image"]
+    return outputs["partial_volume_files"]
 
 
-def mixeltype_callable(output_dir, inputs, stdout, stderr):
+def partial_volume_map_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["mixeltype"]
+    return outputs["partial_volume_map"]
 
 
-def partial_volume_map_callable(output_dir, inputs, stdout, stderr):
+def probability_maps_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["partial_volume_map"]
+    return outputs["probability_maps"]
 
 
-def partial_volume_files_callable(output_dir, inputs, stdout, stderr):
+def restored_image_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["partial_volume_files"]
+    return outputs["restored_image"]
 
 
-def bias_field_callable(output_dir, inputs, stdout, stderr):
+def tissue_class_files_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["bias_field"]
+    return outputs["tissue_class_files"]
 
 
-def probability_maps_callable(output_dir, inputs, stdout, stderr):
+def tissue_class_map_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["probability_maps"]
+    return outputs["tissue_class_map"]
 
 
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
-
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
-
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
-
-            klass._version = klass.parse_version(raw_info)
-
-        return klass._version
-
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
-
-
-# Original source at L108 of <nipype-install>/utils/filemanip.py
-def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
-    """Manipulates path and name of input filename
-
-    Parameters
-    ----------
-    fname : string
-        A filename (may or may not include path)
-    prefix : string
-        Characters to prepend to the filename
-    suffix : string
-        Characters to append to the filename
-    newpath : string
-        Path to replace the path of the input fname
-    use_ext : boolean
-        If True (default), appends the extension of the original file
-        to the output name.
-
-    Returns
-    -------
-    Absolute path of the modified filename
-
-    >>> from nipype.utils.filemanip import fname_presuffix
-    >>> fname = 'foo.nii.gz'
-    >>> fname_presuffix(fname,'pre','post','/tmp')
-    '/tmp/prefoopost.nii.gz'
-
-    >>> from nipype.interfaces.base import attrs.NOTHING
-    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
-            fname_presuffix(fname, 'pre', 'post')
-    True
-
-    """
-    pth, fname, ext = split_filename(fname)
-    if not use_ext:
-        ext = ""
-
-    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
-    if newpath:
-        pth = op.abspath(newpath)
-    return op.join(pth, prefix + fname + suffix + ext)
-
-
-# Original source at L40 of <nipype-install>/interfaces/fsl/base.py
-class Info(PackageInfo):
-    """
-    Handle FSL ``output_type`` and version information.
-
-    output type refers to the type of file fsl defaults to writing
-    eg, NIFTI, NIFTI_GZ
-
-    Examples
-    --------
-
-    >>> from nipype.interfaces.fsl import Info
-    >>> Info.version()  # doctest: +SKIP
-    >>> Info.output_type()  # doctest: +SKIP
-
-    """
-
-    ftypes = {
-        "NIFTI": ".nii",
-        "NIFTI_PAIR": ".img",
-        "NIFTI_GZ": ".nii.gz",
-        "NIFTI_PAIR_GZ": ".img.gz",
-    }
-
-    if os.getenv("FSLDIR"):
-        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
-
-    @staticmethod
-    def parse_version(raw_info):
-        return raw_info.splitlines()[0]
-
-    @classmethod
-    def output_type_to_ext(cls, output_type):
-        """Get the file extension for the given output type.
-
-        Parameters
-        ----------
-        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
-            String specifying the output type.
-
-        Returns
-        -------
-        extension : str
-            The file extension for the output type.
-        """
-
-        try:
-            return cls.ftypes[output_type]
-        except KeyError:
-            msg = "Invalid FSLOUTPUTTYPE: ", output_type
-            raise KeyError(msg)
-
-    @classmethod
-    def output_type(cls):
-        """Get the global FSL output file type FSLOUTPUTTYPE.
-
-        This returns the value of the environment variable
-        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
-
-        Returns
-        -------
-        fsl_ftype : string
-            Represents the current environment setting of FSLOUTPUTTYPE
-        """
-        try:
-            return os.environ["FSLOUTPUTTYPE"]
-        except KeyError:
-            IFLOGGER.warning(
-                "FSLOUTPUTTYPE environment variable is not set. "
-                "Setting FSLOUTPUTTYPE=NIFTI"
-            )
-            return "NIFTI"
-
-    @staticmethod
-    def standard_image(img_name=None):
-        """Grab an image from the standard location.
-
-        Returns a list of standard images if called without arguments.
-
-        Could be made more fancy to allow for more relocatability"""
-        try:
-            fsldir = os.environ["FSLDIR"]
-        except KeyError:
-            raise Exception("FSL environment variables not set")
-        stdpath = os.path.join(fsldir, "data", "standard")
-        if img_name is None:
-            return [
-                filename.replace(stdpath + "/", "")
-                for filename in glob(os.path.join(stdpath, "*nii*"))
-            ]
-        return os.path.join(stdpath, img_name)
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
 
 
 # Original source at L205 of <nipype-install>/interfaces/fsl/base.py
@@ -297,62 +128,6 @@ def _gen_fname(
     return fname
 
 
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
-# Original source at L58 of <nipype-install>/utils/filemanip.py
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
 # Original source at L401 of <nipype-install>/interfaces/fsl/preprocess.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
@@ -494,3 +269,228 @@ def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
                 )
             )
     return outputs
+
+
+# Original source at L108 of <nipype-install>/utils/filemanip.py
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+# Original source at L58 of <nipype-install>/utils/filemanip.py
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
+# Original source at L40 of <nipype-install>/interfaces/fsl/base.py
+class Info(PackageInfo):
+    """
+    Handle FSL ``output_type`` and version information.
+
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
+
+    """
+
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
+
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
+
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
+
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
+
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
+
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
+
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
+
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
+
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
+
+        Returns a list of standard images if called without arguments.
+
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
diff --git a/example-specs/task/nipype/fsl/feat_callables.py b/example-specs/task/nipype/fsl/feat_callables.py
index f23bc0ca..a28955e3 100644
--- a/example-specs/task/nipype/fsl/feat_callables.py
+++ b/example-specs/task/nipype/fsl/feat_callables.py
@@ -1,6 +1,5 @@
 """Module to put any functions that are referred to in the "callables" section of FEAT.yaml"""
 
-import attrs
 import os
 from glob import glob
 
diff --git a/example-specs/task/nipype/fsl/feat_model_callables.py b/example-specs/task/nipype/fsl/feat_model_callables.py
index 14efa29c..bb0a4aac 100644
--- a/example-specs/task/nipype/fsl/feat_model_callables.py
+++ b/example-specs/task/nipype/fsl/feat_model_callables.py
@@ -1,36 +1,35 @@
 """Module to put any functions that are referred to in the "callables" section of FEATModel.yaml"""
 
-import attrs
 import os
 from glob import glob
 
 
-def design_file_callable(output_dir, inputs, stdout, stderr):
+def con_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["design_file"]
+    return outputs["con_file"]
 
 
-def design_image_callable(output_dir, inputs, stdout, stderr):
+def design_cov_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["design_image"]
+    return outputs["design_cov"]
 
 
-def design_cov_callable(output_dir, inputs, stdout, stderr):
+def design_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["design_cov"]
+    return outputs["design_file"]
 
 
-def con_file_callable(output_dir, inputs, stdout, stderr):
+def design_image_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["con_file"]
+    return outputs["design_image"]
 
 
 def fcon_file_callable(output_dir, inputs, stdout, stderr):
@@ -45,17 +44,6 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
-# Original source at L530 of <nipype-install>/utils/filemanip.py
-def simplify_list(filelist):
-    """Returns a list if filelist is a list of length greater than 1,
-    otherwise returns the first element
-    """
-    if len(filelist) > 1:
-        return filelist
-    else:
-        return filelist[0]
-
-
 # Original source at L534 of <nipype-install>/interfaces/fsl/model.py
 def _get_design_root(infile, inputs=None, stdout=None, stderr=None, output_dir=None):
     _, fname = os.path.split(infile)
@@ -90,3 +78,14 @@ def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
         assert len(fcon_file) == 1, "No fts file generated by FEAT Model"
         outputs["fcon_file"] = fcon_file[0]
     return outputs
+
+
+# Original source at L530 of <nipype-install>/utils/filemanip.py
+def simplify_list(filelist):
+    """Returns a list if filelist is a list of length greater than 1,
+    otherwise returns the first element
+    """
+    if len(filelist) > 1:
+        return filelist
+    else:
+        return filelist[0]
diff --git a/example-specs/task/nipype/fsl/feature_extractor_callables.py b/example-specs/task/nipype/fsl/feature_extractor_callables.py
index 6ec12b08..9a93d53c 100644
--- a/example-specs/task/nipype/fsl/feature_extractor_callables.py
+++ b/example-specs/task/nipype/fsl/feature_extractor_callables.py
@@ -1,7 +1,5 @@
 """Module to put any functions that are referred to in the "callables" section of FeatureExtractor.yaml"""
 
-import attrs
-
 
 def mel_ica_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
diff --git a/example-specs/task/nipype/fsl/filmgls_callables.py b/example-specs/task/nipype/fsl/filmgls_callables.py
index 8ca702d7..7d418024 100644
--- a/example-specs/task/nipype/fsl/filmgls_callables.py
+++ b/example-specs/task/nipype/fsl/filmgls_callables.py
@@ -1,26 +1,19 @@
 """Module to put any functions that are referred to in the "callables" section of FILMGLS.yaml"""
 
-from looseversion import LooseVersion
 import attrs
+import logging
 import os
 import os.path as op
 from glob import glob
-import logging
+from looseversion import LooseVersion
 from pathlib import Path
 
 
-def param_estimates_callable(output_dir, inputs, stdout, stderr):
-    outputs = _list_outputs(
-        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
-    )
-    return outputs["param_estimates"]
-
-
-def residual4d_callable(output_dir, inputs, stdout, stderr):
+def copes_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["residual4d"]
+    return outputs["copes"]
 
 
 def dof_file_callable(output_dir, inputs, stdout, stderr):
@@ -30,53 +23,53 @@ def dof_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["dof_file"]
 
 
-def sigmasquareds_callable(output_dir, inputs, stdout, stderr):
+def fstats_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["sigmasquareds"]
+    return outputs["fstats"]
 
 
-def results_dir_callable(output_dir, inputs, stdout, stderr):
+def logfile_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["results_dir"]
+    return outputs["logfile"]
 
 
-def thresholdac_callable(output_dir, inputs, stdout, stderr):
+def param_estimates_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["thresholdac"]
+    return outputs["param_estimates"]
 
 
-def logfile_callable(output_dir, inputs, stdout, stderr):
+def residual4d_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["logfile"]
+    return outputs["residual4d"]
 
 
-def copes_callable(output_dir, inputs, stdout, stderr):
+def results_dir_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["copes"]
+    return outputs["results_dir"]
 
 
-def varcopes_callable(output_dir, inputs, stdout, stderr):
+def sigmasquareds_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["varcopes"]
+    return outputs["sigmasquareds"]
 
 
-def zstats_callable(output_dir, inputs, stdout, stderr):
+def thresholdac_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["zstats"]
+    return outputs["thresholdac"]
 
 
 def tstats_callable(output_dir, inputs, stdout, stderr):
@@ -86,11 +79,11 @@ def tstats_callable(output_dir, inputs, stdout, stderr):
     return outputs["tstats"]
 
 
-def fstats_callable(output_dir, inputs, stdout, stderr):
+def varcopes_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["fstats"]
+    return outputs["varcopes"]
 
 
 def zfstats_callable(output_dir, inputs, stdout, stderr):
@@ -100,101 +93,19 @@ def zfstats_callable(output_dir, inputs, stdout, stderr):
     return outputs["zfstats"]
 
 
-IFLOGGER = logging.getLogger("nipype.interface")
-
-
-# Original source at L108 of <nipype-install>/utils/filemanip.py
-def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
-    """Manipulates path and name of input filename
-
-    Parameters
-    ----------
-    fname : string
-        A filename (may or may not include path)
-    prefix : string
-        Characters to prepend to the filename
-    suffix : string
-        Characters to append to the filename
-    newpath : string
-        Path to replace the path of the input fname
-    use_ext : boolean
-        If True (default), appends the extension of the original file
-        to the output name.
-
-    Returns
-    -------
-    Absolute path of the modified filename
-
-    >>> from nipype.utils.filemanip import fname_presuffix
-    >>> fname = 'foo.nii.gz'
-    >>> fname_presuffix(fname,'pre','post','/tmp')
-    '/tmp/prefoopost.nii.gz'
-
-    >>> from nipype.interfaces.base import attrs.NOTHING
-    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
-            fname_presuffix(fname, 'pre', 'post')
-    True
-
-    """
-    pth, fname, ext = split_filename(fname)
-    if not use_ext:
-        ext = ""
-
-    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
-    if newpath:
-        pth = op.abspath(newpath)
-    return op.join(pth, prefix + fname + suffix + ext)
-
-
-# Original source at L58 of <nipype-install>/utils/filemanip.py
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
+def zstats_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["zstats"]
 
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
 
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
+IFLOGGER = logging.getLogger("nipype.interface")
 
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
 
-    return pth, fname, ext
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
 
 
 # Original source at L205 of <nipype-install>/interfaces/fsl/base.py
@@ -253,142 +164,6 @@ def _gen_fname(
     return fname
 
 
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
-
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
-
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
-
-            klass._version = klass.parse_version(raw_info)
-
-        return klass._version
-
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
-
-
-# Original source at L40 of <nipype-install>/interfaces/fsl/base.py
-class Info(PackageInfo):
-    """
-    Handle FSL ``output_type`` and version information.
-
-    output type refers to the type of file fsl defaults to writing
-    eg, NIFTI, NIFTI_GZ
-
-    Examples
-    --------
-
-    >>> from nipype.interfaces.fsl import Info
-    >>> Info.version()  # doctest: +SKIP
-    >>> Info.output_type()  # doctest: +SKIP
-
-    """
-
-    ftypes = {
-        "NIFTI": ".nii",
-        "NIFTI_PAIR": ".img",
-        "NIFTI_GZ": ".nii.gz",
-        "NIFTI_PAIR_GZ": ".img.gz",
-    }
-
-    if os.getenv("FSLDIR"):
-        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
-
-    @staticmethod
-    def parse_version(raw_info):
-        return raw_info.splitlines()[0]
-
-    @classmethod
-    def output_type_to_ext(cls, output_type):
-        """Get the file extension for the given output type.
-
-        Parameters
-        ----------
-        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
-            String specifying the output type.
-
-        Returns
-        -------
-        extension : str
-            The file extension for the output type.
-        """
-
-        try:
-            return cls.ftypes[output_type]
-        except KeyError:
-            msg = "Invalid FSLOUTPUTTYPE: ", output_type
-            raise KeyError(msg)
-
-    @classmethod
-    def output_type(cls):
-        """Get the global FSL output file type FSLOUTPUTTYPE.
-
-        This returns the value of the environment variable
-        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
-
-        Returns
-        -------
-        fsl_ftype : string
-            Represents the current environment setting of FSLOUTPUTTYPE
-        """
-        try:
-            return os.environ["FSLOUTPUTTYPE"]
-        except KeyError:
-            IFLOGGER.warning(
-                "FSLOUTPUTTYPE environment variable is not set. "
-                "Setting FSLOUTPUTTYPE=NIFTI"
-            )
-            return "NIFTI"
-
-    @staticmethod
-    def standard_image(img_name=None):
-        """Grab an image from the standard location.
-
-        Returns a list of standard images if called without arguments.
-
-        Could be made more fancy to allow for more relocatability"""
-        try:
-            fsldir = os.environ["FSLDIR"]
-        except KeyError:
-            raise Exception("FSL environment variables not set")
-        stdpath = os.path.join(fsldir, "data", "standard")
-        if img_name is None:
-            return [
-                filename.replace(stdpath + "/", "")
-                for filename in glob(os.path.join(stdpath, "*nii*"))
-            ]
-        return os.path.join(stdpath, img_name)
-
-
 # Original source at L841 of <nipype-install>/interfaces/fsl/model.py
 def _get_numcons(inputs=None, stdout=None, stderr=None, output_dir=None):
     numtcons = 0
@@ -573,3 +348,228 @@ def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
             outputs["fstats"] = fstats
             outputs["zfstats"] = zfstats
     return outputs
+
+
+# Original source at L108 of <nipype-install>/utils/filemanip.py
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+# Original source at L58 of <nipype-install>/utils/filemanip.py
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
+# Original source at L40 of <nipype-install>/interfaces/fsl/base.py
+class Info(PackageInfo):
+    """
+    Handle FSL ``output_type`` and version information.
+
+    output type refers to the type of file fsl defaults to writing
+    eg, NIFTI, NIFTI_GZ
+
+    Examples
+    --------
+
+    >>> from nipype.interfaces.fsl import Info
+    >>> Info.version()  # doctest: +SKIP
+    >>> Info.output_type()  # doctest: +SKIP
+
+    """
+
+    ftypes = {
+        "NIFTI": ".nii",
+        "NIFTI_PAIR": ".img",
+        "NIFTI_GZ": ".nii.gz",
+        "NIFTI_PAIR_GZ": ".img.gz",
+    }
+
+    if os.getenv("FSLDIR"):
+        version_file = os.path.join(os.getenv("FSLDIR"), "etc", "fslversion")
+
+    @staticmethod
+    def parse_version(raw_info):
+        return raw_info.splitlines()[0]
+
+    @classmethod
+    def output_type_to_ext(cls, output_type):
+        """Get the file extension for the given output type.
+
+        Parameters
+        ----------
+        output_type : {'NIFTI', 'NIFTI_GZ', 'NIFTI_PAIR', 'NIFTI_PAIR_GZ'}
+            String specifying the output type.
+
+        Returns
+        -------
+        extension : str
+            The file extension for the output type.
+        """
+
+        try:
+            return cls.ftypes[output_type]
+        except KeyError:
+            msg = "Invalid FSLOUTPUTTYPE: ", output_type
+            raise KeyError(msg)
+
+    @classmethod
+    def output_type(cls):
+        """Get the global FSL output file type FSLOUTPUTTYPE.
+
+        This returns the value of the environment variable
+        FSLOUTPUTTYPE.  An exception is raised if it is not defined.
+
+        Returns
+        -------
+        fsl_ftype : string
+            Represents the current environment setting of FSLOUTPUTTYPE
+        """
+        try:
+            return os.environ["FSLOUTPUTTYPE"]
+        except KeyError:
+            IFLOGGER.warning(
+                "FSLOUTPUTTYPE environment variable is not set. "
+                "Setting FSLOUTPUTTYPE=NIFTI"
+            )
+            return "NIFTI"
+
+    @staticmethod
+    def standard_image(img_name=None):
+        """Grab an image from the standard location.
+
+        Returns a list of standard images if called without arguments.
+
+        Could be made more fancy to allow for more relocatability"""
+        try:
+            fsldir = os.environ["FSLDIR"]
+        except KeyError:
+            raise Exception("FSL environment variables not set")
+        stdpath = os.path.join(fsldir, "data", "standard")
+        if img_name is None:
+            return [
+                filename.replace(stdpath + "/", "")
+                for filename in glob(os.path.join(stdpath, "*nii*"))
+            ]
+        return os.path.join(stdpath, img_name)
diff --git a/example-specs/task/nipype/fsl/filter_regressor_callables.py b/example-specs/task/nipype/fsl/filter_regressor_callables.py
index e525052f..15ef6f28 100644
--- a/example-specs/task/nipype/fsl/filter_regressor_callables.py
+++ b/example-specs/task/nipype/fsl/filter_regressor_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of FilterRegressor.yaml"""
 
-from glob import glob
 import attrs
 import logging
 import os
 import os.path as op
+from glob import glob
 from pathlib import Path
 
 
@@ -22,42 +22,86 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
+# Original source at L731 of <nipype-install>/interfaces/fsl/utils.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )[name]
+    return None
 
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
 
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
 
-            klass._version = klass.parse_version(raw_info)
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
 
-        return klass._version
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
 
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "fsl_regfilt"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+# Original source at L721 of <nipype-install>/interfaces/fsl/utils.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = inputs.out_file
+    if outputs["out_file"] is attrs.NOTHING:
+        outputs["out_file"] = _gen_fname(
+            inputs.in_file,
+            suffix="_regfilt",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    outputs["out_file"] = os.path.abspath(outputs["out_file"])
+    return outputs
 
 
 # Original source at L108 of <nipype-install>/utils/filemanip.py
@@ -154,6 +198,44 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
@@ -245,85 +327,3 @@ def standard_image(img_name=None):
                 for filename in glob(os.path.join(stdpath, "*nii*"))
             ]
         return os.path.join(stdpath, img_name)
-
-
-# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
-def _gen_fname(
-    basename,
-    cwd=None,
-    suffix=None,
-    change_ext=True,
-    ext=None,
-    inputs=None,
-    stdout=None,
-    stderr=None,
-    output_dir=None,
-):
-    """Generate a filename based on the given parameters.
-
-    The filename will take the form: cwd/basename<suffix><ext>.
-    If change_ext is True, it will use the extensions specified in
-    <instance>inputs.output_type.
-
-    Parameters
-    ----------
-    basename : str
-        Filename to base the new filename on.
-    cwd : str
-        Path to prefix to the new filename. (default is output_dir)
-    suffix : str
-        Suffix to add to the `basename`.  (defaults is '' )
-    change_ext : bool
-        Flag to change the filename extension to the FSL output type.
-        (default True)
-
-    Returns
-    -------
-    fname : str
-        New filename based on given parameters.
-
-    """
-
-    if basename == "":
-        msg = "Unable to generate filename for command %s. " % "fsl_regfilt"
-        msg += "basename is not set!"
-        raise ValueError(msg)
-    if cwd is None:
-        cwd = output_dir
-    if ext is None:
-        ext = Info.output_type_to_ext(inputs.output_type)
-    if change_ext:
-        if suffix:
-            suffix = "".join((suffix, ext))
-        else:
-            suffix = ext
-    if suffix is None:
-        suffix = ""
-    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
-    return fname
-
-
-# Original source at L731 of <nipype-install>/interfaces/fsl/utils.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "out_file":
-        return _list_outputs(
-            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-        )[name]
-    return None
-
-
-# Original source at L721 of <nipype-install>/interfaces/fsl/utils.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    outputs["out_file"] = inputs.out_file
-    if outputs["out_file"] is attrs.NOTHING:
-        outputs["out_file"] = _gen_fname(
-            inputs.in_file,
-            suffix="_regfilt",
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-    outputs["out_file"] = os.path.abspath(outputs["out_file"])
-    return outputs
diff --git a/example-specs/task/nipype/fsl/find_the_biggest_callables.py b/example-specs/task/nipype/fsl/find_the_biggest_callables.py
index 87ccdee2..4bc9cf0b 100644
--- a/example-specs/task/nipype/fsl/find_the_biggest_callables.py
+++ b/example-specs/task/nipype/fsl/find_the_biggest_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of FindTheBiggest.yaml"""
 
-from glob import glob
 import attrs
 import logging
 import os
 import os.path as op
+from glob import glob
 from pathlib import Path
 
 
@@ -22,42 +22,87 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
+# Original source at L1341 of <nipype-install>/interfaces/fsl/dti.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )[name]
+    else:
+        return None
 
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
 
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
 
-            klass._version = klass.parse_version(raw_info)
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
 
-        return klass._version
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
 
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "find_the_biggest"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+# Original source at L1333 of <nipype-install>/interfaces/fsl/dti.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = inputs.out_file
+    if outputs["out_file"] is attrs.NOTHING:
+        outputs["out_file"] = _gen_fname(
+            "biggestSegmentation",
+            suffix="",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    outputs["out_file"] = os.path.abspath(outputs["out_file"])
+    return outputs
 
 
 # Original source at L108 of <nipype-install>/utils/filemanip.py
@@ -154,6 +199,44 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
@@ -245,86 +328,3 @@ def standard_image(img_name=None):
                 for filename in glob(os.path.join(stdpath, "*nii*"))
             ]
         return os.path.join(stdpath, img_name)
-
-
-# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
-def _gen_fname(
-    basename,
-    cwd=None,
-    suffix=None,
-    change_ext=True,
-    ext=None,
-    inputs=None,
-    stdout=None,
-    stderr=None,
-    output_dir=None,
-):
-    """Generate a filename based on the given parameters.
-
-    The filename will take the form: cwd/basename<suffix><ext>.
-    If change_ext is True, it will use the extensions specified in
-    <instance>inputs.output_type.
-
-    Parameters
-    ----------
-    basename : str
-        Filename to base the new filename on.
-    cwd : str
-        Path to prefix to the new filename. (default is output_dir)
-    suffix : str
-        Suffix to add to the `basename`.  (defaults is '' )
-    change_ext : bool
-        Flag to change the filename extension to the FSL output type.
-        (default True)
-
-    Returns
-    -------
-    fname : str
-        New filename based on given parameters.
-
-    """
-
-    if basename == "":
-        msg = "Unable to generate filename for command %s. " % "find_the_biggest"
-        msg += "basename is not set!"
-        raise ValueError(msg)
-    if cwd is None:
-        cwd = output_dir
-    if ext is None:
-        ext = Info.output_type_to_ext(inputs.output_type)
-    if change_ext:
-        if suffix:
-            suffix = "".join((suffix, ext))
-        else:
-            suffix = ext
-    if suffix is None:
-        suffix = ""
-    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
-    return fname
-
-
-# Original source at L1341 of <nipype-install>/interfaces/fsl/dti.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "out_file":
-        return _list_outputs(
-            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-        )[name]
-    else:
-        return None
-
-
-# Original source at L1333 of <nipype-install>/interfaces/fsl/dti.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    outputs["out_file"] = inputs.out_file
-    if outputs["out_file"] is attrs.NOTHING:
-        outputs["out_file"] = _gen_fname(
-            "biggestSegmentation",
-            suffix="",
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-    outputs["out_file"] = os.path.abspath(outputs["out_file"])
-    return outputs
diff --git a/example-specs/task/nipype/fsl/first_callables.py b/example-specs/task/nipype/fsl/first_callables.py
index 054d4f18..9f168a3c 100644
--- a/example-specs/task/nipype/fsl/first_callables.py
+++ b/example-specs/task/nipype/fsl/first_callables.py
@@ -1,14 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of FIRST.yaml"""
 
-import os.path as op
 import attrs
-
-
-def vtk_surfaces_callable(output_dir, inputs, stdout, stderr):
-    outputs = _list_outputs(
-        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
-    )
-    return outputs["vtk_surfaces"]
+import os.path as op
 
 
 def bvars_callable(output_dir, inputs, stdout, stderr):
@@ -32,60 +25,38 @@ def segmentation_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["segmentation_file"]
 
 
+def vtk_surfaces_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["vtk_surfaces"]
+
+
 # Original source at L885 of <nipype-install>/interfaces/base/core.py
 def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
-# Original source at L58 of <nipype-install>/utils/filemanip.py
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
+# Original source at L2259 of <nipype-install>/interfaces/fsl/preprocess.py
+def _gen_fname(basename, inputs=None, stdout=None, stderr=None, output_dir=None):
+    path, outname, ext = split_filename(inputs.out_file)
 
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+    method = "none"
+    if (inputs.method is not attrs.NOTHING) and inputs.method != "none":
+        method = "fast"
+        if inputs.list_of_specific_structures and inputs.method == "auto":
+            method = "none"
 
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
+    if inputs.method_as_numerical_threshold is not attrs.NOTHING:
+        thres = "%.4f" % inputs.method_as_numerical_threshold
+        method = thres.replace(".", "")
 
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
+    if basename == "original_segmentations":
+        return op.abspath("%s_all_%s_origsegs.nii.gz" % (outname, method))
+    if basename == "segmentation_file":
+        return op.abspath("%s_all_%s_firstseg.nii.gz" % (outname, method))
 
-    return pth, fname, ext
+    return None
 
 
 # Original source at L2279 of <nipype-install>/interfaces/fsl/preprocess.py
@@ -108,28 +79,6 @@ def _gen_mesh_names(
     return None
 
 
-# Original source at L2259 of <nipype-install>/interfaces/fsl/preprocess.py
-def _gen_fname(basename, inputs=None, stdout=None, stderr=None, output_dir=None):
-    path, outname, ext = split_filename(inputs.out_file)
-
-    method = "none"
-    if (inputs.method is not attrs.NOTHING) and inputs.method != "none":
-        method = "fast"
-        if inputs.list_of_specific_structures and inputs.method == "auto":
-            method = "none"
-
-    if inputs.method_as_numerical_threshold is not attrs.NOTHING:
-        thres = "%.4f" % inputs.method_as_numerical_threshold
-        method = thres.replace(".", "")
-
-    if basename == "original_segmentations":
-        return op.abspath("%s_all_%s_origsegs.nii.gz" % (outname, method))
-    if basename == "segmentation_file":
-        return op.abspath("%s_all_%s_firstseg.nii.gz" % (outname, method))
-
-    return None
-
-
 # Original source at L2230 of <nipype-install>/interfaces/fsl/preprocess.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
@@ -185,3 +134,54 @@ def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
         output_dir=output_dir,
     )
     return outputs
+
+
+# Original source at L58 of <nipype-install>/utils/filemanip.py
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
diff --git a/example-specs/task/nipype/fsl/flameo_callables.py b/example-specs/task/nipype/fsl/flameo_callables.py
index 8d57d62b..734d1ea4 100644
--- a/example-specs/task/nipype/fsl/flameo_callables.py
+++ b/example-specs/task/nipype/fsl/flameo_callables.py
@@ -1,93 +1,93 @@
 """Module to put any functions that are referred to in the "callables" section of FLAMEO.yaml"""
 
-import re
+import attrs
 import os
+import re
 from glob import glob
-import attrs
 
 
-def pes_callable(output_dir, inputs, stdout, stderr):
+def copes_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["pes"]
+    return outputs["copes"]
 
 
-def res4d_callable(output_dir, inputs, stdout, stderr):
+def fstats_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["res4d"]
+    return outputs["fstats"]
 
 
-def copes_callable(output_dir, inputs, stdout, stderr):
+def mrefvars_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["copes"]
+    return outputs["mrefvars"]
 
 
-def var_copes_callable(output_dir, inputs, stdout, stderr):
+def pes_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["var_copes"]
+    return outputs["pes"]
 
 
-def zstats_callable(output_dir, inputs, stdout, stderr):
+def res4d_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["zstats"]
+    return outputs["res4d"]
 
 
-def tstats_callable(output_dir, inputs, stdout, stderr):
+def stats_dir_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["tstats"]
+    return outputs["stats_dir"]
 
 
-def zfstats_callable(output_dir, inputs, stdout, stderr):
+def tdof_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["zfstats"]
+    return outputs["tdof"]
 
 
-def fstats_callable(output_dir, inputs, stdout, stderr):
+def tstats_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["fstats"]
+    return outputs["tstats"]
 
 
-def mrefvars_callable(output_dir, inputs, stdout, stderr):
+def var_copes_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["mrefvars"]
+    return outputs["var_copes"]
 
 
-def tdof_callable(output_dir, inputs, stdout, stderr):
+def weights_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["tdof"]
+    return outputs["weights"]
 
 
-def weights_callable(output_dir, inputs, stdout, stderr):
+def zfstats_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["weights"]
+    return outputs["zfstats"]
 
 
-def stats_dir_callable(output_dir, inputs, stdout, stderr):
+def zstats_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["stats_dir"]
+    return outputs["zstats"]
 
 
 # Original source at L885 of <nipype-install>/interfaces/base/core.py
@@ -95,21 +95,6 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
-# Original source at L19 of <nipype-install>/utils/misc.py
-def human_order_sorted(l):
-    """Sorts string in human order (i.e. 'stat10' will go after 'stat2')"""
-
-    def atoi(text):
-        return int(text) if text.isdigit() else text
-
-    def natural_keys(text):
-        if isinstance(text, tuple):
-            text = text[0]
-        return [atoi(c) for c in re.split(r"(\d+)", text)]
-
-    return sorted(l, key=natural_keys)
-
-
 # Original source at L1143 of <nipype-install>/interfaces/fsl/model.py
 def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs = {}
@@ -165,3 +150,18 @@ def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
     outputs["stats_dir"] = pth
 
     return outputs
+
+
+# Original source at L19 of <nipype-install>/utils/misc.py
+def human_order_sorted(l):
+    """Sorts string in human order (i.e. 'stat10' will go after 'stat2')"""
+
+    def atoi(text):
+        return int(text) if text.isdigit() else text
+
+    def natural_keys(text):
+        if isinstance(text, tuple):
+            text = text[0]
+        return [atoi(c) for c in re.split(r"(\d+)", text)]
+
+    return sorted(l, key=natural_keys)
diff --git a/example-specs/task/nipype/fsl/flirt_callables.py b/example-specs/task/nipype/fsl/flirt_callables.py
index 4304ab92..cf6386c8 100644
--- a/example-specs/task/nipype/fsl/flirt_callables.py
+++ b/example-specs/task/nipype/fsl/flirt_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of FLIRT.yaml"""
 
-from glob import glob
 import attrs
 import logging
 import os
 import os.path as op
+from glob import glob
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -14,18 +14,18 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_file"]
 
 
-def out_matrix_file_callable(output_dir, inputs, stdout, stderr):
+def out_log_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_matrix_file"]
+    return outputs["out_log"]
 
 
-def out_log_callable(output_dir, inputs, stdout, stderr):
+def out_matrix_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_log"]
+    return outputs["out_matrix_file"]
 
 
 IFLOGGER = logging.getLogger("nipype.interface")
@@ -34,6 +34,182 @@ def out_log_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+# Original source at L249 of <nipype-install>/interfaces/fsl/base.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value + Info.output_type_to_ext(inputs.output_type)
+
+
+# Original source at L58 of <nipype-install>/utils/filemanip.py
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
 # Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
@@ -165,13 +341,6 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
-# Original source at L249 of <nipype-install>/interfaces/fsl/base.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    return value + Info.output_type_to_ext(inputs.output_type)
-
-
 # Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
@@ -181,172 +350,3 @@ def __init__(self, value):
 
     def __str__(self):
         return "{}".format(self.value)
-
-
-# Original source at L58 of <nipype-install>/utils/filemanip.py
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
-# Original source at L809 of <nipype-install>/interfaces/base/core.py
-def _filename_from_source(
-    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    if chain is None:
-        chain = []
-
-    trait_spec = inputs.trait(name)
-    retval = getattr(inputs, name)
-    source_ext = None
-    if (retval is attrs.NOTHING) or "%s" in retval:
-        if not trait_spec.name_source:
-            return retval
-
-        # Do not generate filename when excluded by other inputs
-        if any(
-            (getattr(inputs, field) is not attrs.NOTHING)
-            for field in trait_spec.xor or ()
-        ):
-            return retval
-
-        # Do not generate filename when required fields are missing
-        if not all(
-            (getattr(inputs, field) is not attrs.NOTHING)
-            for field in trait_spec.requires or ()
-        ):
-            return retval
-
-        if (retval is not attrs.NOTHING) and "%s" in retval:
-            name_template = retval
-        else:
-            name_template = trait_spec.name_template
-        if not name_template:
-            name_template = "%s_generated"
-
-        ns = trait_spec.name_source
-        while isinstance(ns, (list, tuple)):
-            if len(ns) > 1:
-                iflogger.warning("Only one name_source per trait is allowed")
-            ns = ns[0]
-
-        if not isinstance(ns, (str, bytes)):
-            raise ValueError(
-                "name_source of '{}' trait should be an input trait "
-                "name, but a type {} object was found".format(name, type(ns))
-            )
-
-        if getattr(inputs, ns) is not attrs.NOTHING:
-            name_source = ns
-            source = getattr(inputs, name_source)
-            while isinstance(source, list):
-                source = source[0]
-
-            # special treatment for files
-            try:
-                _, base, source_ext = split_filename(source)
-            except (AttributeError, TypeError):
-                base = source
-        else:
-            if name in chain:
-                raise NipypeInterfaceError("Mutually pointing name_sources")
-
-            chain.append(name)
-            base = _filename_from_source(
-                ns,
-                chain,
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-            if base is not attrs.NOTHING:
-                _, _, source_ext = split_filename(base)
-            else:
-                # Do not generate filename when required fields are missing
-                return retval
-
-        chain = None
-        retval = name_template % base
-        _, _, ext = split_filename(retval)
-        if trait_spec.keep_extension and (ext or source_ext):
-            if (ext is None or not ext) and source_ext:
-                retval = retval + source_ext
-        else:
-            retval = _overload_extension(
-                retval,
-                name,
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-    return retval
-
-
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
-# Original source at L891 of <nipype-install>/interfaces/base/core.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    metadata = dict(name_source=lambda t: t is not None)
-    traits = inputs.traits(**metadata)
-    if traits:
-        outputs = {}
-        for name, trait_spec in list(traits.items()):
-            out_name = name
-            if trait_spec.output_name is not None:
-                out_name = trait_spec.output_name
-            fname = _filename_from_source(
-                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-            )
-            if fname is not attrs.NOTHING:
-                outputs[out_name] = os.path.abspath(fname)
-        return outputs
diff --git a/example-specs/task/nipype/fsl/fnirt_callables.py b/example-specs/task/nipype/fsl/fnirt_callables.py
index 76be5a6b..3d121a2a 100644
--- a/example-specs/task/nipype/fsl/fnirt_callables.py
+++ b/example-specs/task/nipype/fsl/fnirt_callables.py
@@ -1,47 +1,47 @@
 """Module to put any functions that are referred to in the "callables" section of FNIRT.yaml"""
 
 import attrs
+import logging
 import os
 import os.path as op
 from glob import glob
-import logging
 from pathlib import Path
 
 
-def warped_file_default(inputs):
-    return _gen_filename("warped_file", inputs=inputs)
-
-
 def log_file_default(inputs):
     return _gen_filename("log_file", inputs=inputs)
 
 
-def fieldcoeff_file_callable(output_dir, inputs, stdout, stderr):
+def warped_file_default(inputs):
+    return _gen_filename("warped_file", inputs=inputs)
+
+
+def field_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["fieldcoeff_file"]
+    return outputs["field_file"]
 
 
-def warped_file_callable(output_dir, inputs, stdout, stderr):
+def fieldcoeff_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["warped_file"]
+    return outputs["fieldcoeff_file"]
 
 
-def field_file_callable(output_dir, inputs, stdout, stderr):
+def jacobian_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["field_file"]
+    return outputs["jacobian_file"]
 
 
-def jacobian_file_callable(output_dir, inputs, stdout, stderr):
+def log_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["jacobian_file"]
+    return outputs["log_file"]
 
 
 def modulatedref_file_callable(output_dir, inputs, stdout, stderr):
@@ -58,16 +58,129 @@ def out_intensitymap_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_intensitymap_file"]
 
 
-def log_file_callable(output_dir, inputs, stdout, stderr):
+def warped_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["log_file"]
+    return outputs["warped_file"]
 
 
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+# Original source at L1341 of <nipype-install>/interfaces/fsl/preprocess.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name in ["warped_file", "log_file"]:
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )[name]
+    return None
+
+
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
+
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
+
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
+
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "fnirt"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+# Original source at L1298 of <nipype-install>/interfaces/fsl/preprocess.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    for key, suffix in list(filemap.items()):
+        inval = getattr(inputs, key)
+        change_ext = True
+        if key in ["warped_file", "log_file"]:
+            if suffix.endswith(".txt"):
+                change_ext = False
+            if inval is not attrs.NOTHING:
+                outputs[key] = os.path.abspath(inval)
+            else:
+                outputs[key] = _gen_fname(
+                    inputs.in_file,
+                    suffix="_" + suffix,
+                    change_ext=change_ext,
+                    inputs=inputs,
+                    stdout=stdout,
+                    stderr=stderr,
+                    output_dir=output_dir,
+                )
+        elif inval is not attrs.NOTHING:
+            if isinstance(inval, bool):
+                if inval:
+                    outputs[key] = _gen_fname(
+                        inputs.in_file,
+                        suffix="_" + suffix,
+                        change_ext=change_ext,
+                        inputs=inputs,
+                        stdout=stdout,
+                        stderr=stderr,
+                        output_dir=output_dir,
+                    )
+            else:
+                outputs[key] = os.path.abspath(inval)
+
+        if key == "out_intensitymap_file" and (outputs[key] is not attrs.NOTHING):
+            basename = intensitymap_file_basename(
+                outputs[key],
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            outputs[key] = [outputs[key], "%s.txt" % basename]
+    return outputs
+
+
 # Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
@@ -111,6 +224,20 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L1364 of <nipype-install>/interfaces/fsl/preprocess.py
+def intensitymap_file_basename(
+    f, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    """Removes valid intensitymap extensions from `f`, returning a basename
+    that can refer to both intensitymap files.
+    """
+    for ext in list(Info.ftypes.values()) + [".txt"]:
+        if f.endswith(ext):
+            return f[: -len(ext)]
+    # TODO consider warning for this case
+    return f
+
+
 # Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
@@ -162,62 +289,6 @@ def split_filename(fname):
     return pth, fname, ext
 
 
-# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
-def _gen_fname(
-    basename,
-    cwd=None,
-    suffix=None,
-    change_ext=True,
-    ext=None,
-    inputs=None,
-    stdout=None,
-    stderr=None,
-    output_dir=None,
-):
-    """Generate a filename based on the given parameters.
-
-    The filename will take the form: cwd/basename<suffix><ext>.
-    If change_ext is True, it will use the extensions specified in
-    <instance>inputs.output_type.
-
-    Parameters
-    ----------
-    basename : str
-        Filename to base the new filename on.
-    cwd : str
-        Path to prefix to the new filename. (default is output_dir)
-    suffix : str
-        Suffix to add to the `basename`.  (defaults is '' )
-    change_ext : bool
-        Flag to change the filename extension to the FSL output type.
-        (default True)
-
-    Returns
-    -------
-    fname : str
-        New filename based on given parameters.
-
-    """
-
-    if basename == "":
-        msg = "Unable to generate filename for command %s. " % "fnirt"
-        msg += "basename is not set!"
-        raise ValueError(msg)
-    if cwd is None:
-        cwd = output_dir
-    if ext is None:
-        ext = Info.output_type_to_ext(inputs.output_type)
-    if change_ext:
-        if suffix:
-            suffix = "".join((suffix, ext))
-        else:
-            suffix = ext
-    if suffix is None:
-        suffix = ""
-    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
-    return fname
-
-
 # Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
@@ -347,74 +418,3 @@ def standard_image(img_name=None):
                 for filename in glob(os.path.join(stdpath, "*nii*"))
             ]
         return os.path.join(stdpath, img_name)
-
-
-# Original source at L1364 of <nipype-install>/interfaces/fsl/preprocess.py
-def intensitymap_file_basename(
-    f, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    """Removes valid intensitymap extensions from `f`, returning a basename
-    that can refer to both intensitymap files.
-    """
-    for ext in list(Info.ftypes.values()) + [".txt"]:
-        if f.endswith(ext):
-            return f[: -len(ext)]
-    # TODO consider warning for this case
-    return f
-
-
-# Original source at L1341 of <nipype-install>/interfaces/fsl/preprocess.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name in ["warped_file", "log_file"]:
-        return _list_outputs(
-            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-        )[name]
-    return None
-
-
-# Original source at L1298 of <nipype-install>/interfaces/fsl/preprocess.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    for key, suffix in list(filemap.items()):
-        inval = getattr(inputs, key)
-        change_ext = True
-        if key in ["warped_file", "log_file"]:
-            if suffix.endswith(".txt"):
-                change_ext = False
-            if inval is not attrs.NOTHING:
-                outputs[key] = os.path.abspath(inval)
-            else:
-                outputs[key] = _gen_fname(
-                    inputs.in_file,
-                    suffix="_" + suffix,
-                    change_ext=change_ext,
-                    inputs=inputs,
-                    stdout=stdout,
-                    stderr=stderr,
-                    output_dir=output_dir,
-                )
-        elif inval is not attrs.NOTHING:
-            if isinstance(inval, bool):
-                if inval:
-                    outputs[key] = _gen_fname(
-                        inputs.in_file,
-                        suffix="_" + suffix,
-                        change_ext=change_ext,
-                        inputs=inputs,
-                        stdout=stdout,
-                        stderr=stderr,
-                        output_dir=output_dir,
-                    )
-            else:
-                outputs[key] = os.path.abspath(inval)
-
-        if key == "out_intensitymap_file" and (outputs[key] is not attrs.NOTHING):
-            basename = intensitymap_file_basename(
-                outputs[key],
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-            outputs[key] = [outputs[key], "%s.txt" % basename]
-    return outputs
diff --git a/example-specs/task/nipype/fsl/fugue_callables.py b/example-specs/task/nipype/fsl/fugue_callables.py
index 03d3a6fa..befea958 100644
--- a/example-specs/task/nipype/fsl/fugue_callables.py
+++ b/example-specs/task/nipype/fsl/fugue_callables.py
@@ -1,38 +1,38 @@
 """Module to put any functions that are referred to in the "callables" section of FUGUE.yaml"""
 
-from glob import glob
 import attrs
 import logging
 import os
 import os.path as op
+from glob import glob
 
 
-def unwarped_file_callable(output_dir, inputs, stdout, stderr):
+def fmap_out_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["unwarped_file"]
+    return outputs["fmap_out_file"]
 
 
-def warped_file_callable(output_dir, inputs, stdout, stderr):
+def shift_out_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["warped_file"]
+    return outputs["shift_out_file"]
 
 
-def shift_out_file_callable(output_dir, inputs, stdout, stderr):
+def unwarped_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["shift_out_file"]
+    return outputs["unwarped_file"]
 
 
-def fmap_out_file_callable(output_dir, inputs, stdout, stderr):
+def warped_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["fmap_out_file"]
+    return outputs["warped_file"]
 
 
 IFLOGGER = logging.getLogger("nipype.interface")
@@ -41,6 +41,182 @@ def fmap_out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+# Original source at L249 of <nipype-install>/interfaces/fsl/base.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value + Info.output_type_to_ext(inputs.output_type)
+
+
+# Original source at L58 of <nipype-install>/utils/filemanip.py
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
 # Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
@@ -172,13 +348,6 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
-# Original source at L249 of <nipype-install>/interfaces/fsl/base.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    return value + Info.output_type_to_ext(inputs.output_type)
-
-
 # Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
@@ -188,172 +357,3 @@ def __init__(self, value):
 
     def __str__(self):
         return "{}".format(self.value)
-
-
-# Original source at L58 of <nipype-install>/utils/filemanip.py
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
-# Original source at L809 of <nipype-install>/interfaces/base/core.py
-def _filename_from_source(
-    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    if chain is None:
-        chain = []
-
-    trait_spec = inputs.trait(name)
-    retval = getattr(inputs, name)
-    source_ext = None
-    if (retval is attrs.NOTHING) or "%s" in retval:
-        if not trait_spec.name_source:
-            return retval
-
-        # Do not generate filename when excluded by other inputs
-        if any(
-            (getattr(inputs, field) is not attrs.NOTHING)
-            for field in trait_spec.xor or ()
-        ):
-            return retval
-
-        # Do not generate filename when required fields are missing
-        if not all(
-            (getattr(inputs, field) is not attrs.NOTHING)
-            for field in trait_spec.requires or ()
-        ):
-            return retval
-
-        if (retval is not attrs.NOTHING) and "%s" in retval:
-            name_template = retval
-        else:
-            name_template = trait_spec.name_template
-        if not name_template:
-            name_template = "%s_generated"
-
-        ns = trait_spec.name_source
-        while isinstance(ns, (list, tuple)):
-            if len(ns) > 1:
-                iflogger.warning("Only one name_source per trait is allowed")
-            ns = ns[0]
-
-        if not isinstance(ns, (str, bytes)):
-            raise ValueError(
-                "name_source of '{}' trait should be an input trait "
-                "name, but a type {} object was found".format(name, type(ns))
-            )
-
-        if getattr(inputs, ns) is not attrs.NOTHING:
-            name_source = ns
-            source = getattr(inputs, name_source)
-            while isinstance(source, list):
-                source = source[0]
-
-            # special treatment for files
-            try:
-                _, base, source_ext = split_filename(source)
-            except (AttributeError, TypeError):
-                base = source
-        else:
-            if name in chain:
-                raise NipypeInterfaceError("Mutually pointing name_sources")
-
-            chain.append(name)
-            base = _filename_from_source(
-                ns,
-                chain,
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-            if base is not attrs.NOTHING:
-                _, _, source_ext = split_filename(base)
-            else:
-                # Do not generate filename when required fields are missing
-                return retval
-
-        chain = None
-        retval = name_template % base
-        _, _, ext = split_filename(retval)
-        if trait_spec.keep_extension and (ext or source_ext):
-            if (ext is None or not ext) and source_ext:
-                retval = retval + source_ext
-        else:
-            retval = _overload_extension(
-                retval,
-                name,
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-    return retval
-
-
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
-# Original source at L891 of <nipype-install>/interfaces/base/core.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    metadata = dict(name_source=lambda t: t is not None)
-    traits = inputs.traits(**metadata)
-    if traits:
-        outputs = {}
-        for name, trait_spec in list(traits.items()):
-            out_name = name
-            if trait_spec.output_name is not None:
-                out_name = trait_spec.output_name
-            fname = _filename_from_source(
-                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-            )
-            if fname is not attrs.NOTHING:
-                outputs[out_name] = os.path.abspath(fname)
-        return outputs
diff --git a/example-specs/task/nipype/fsl/glm_callables.py b/example-specs/task/nipype/fsl/glm_callables.py
index 90a73179..3f35c49b 100644
--- a/example-specs/task/nipype/fsl/glm_callables.py
+++ b/example-specs/task/nipype/fsl/glm_callables.py
@@ -1,17 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of GLM.yaml"""
 
-from glob import glob
 import attrs
 import logging
 import os
 import os.path as op
-
-
-def out_file_callable(output_dir, inputs, stdout, stderr):
-    outputs = _list_outputs(
-        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
-    )
-    return outputs["out_file"]
+from glob import glob
 
 
 def out_cope_callable(output_dir, inputs, stdout, stderr):
@@ -21,32 +14,32 @@ def out_cope_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_cope"]
 
 
-def out_z_callable(output_dir, inputs, stdout, stderr):
+def out_data_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_z"]
+    return outputs["out_data"]
 
 
-def out_t_callable(output_dir, inputs, stdout, stderr):
+def out_f_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_t"]
+    return outputs["out_f"]
 
 
-def out_p_callable(output_dir, inputs, stdout, stderr):
+def out_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_p"]
+    return outputs["out_file"]
 
 
-def out_f_callable(output_dir, inputs, stdout, stderr):
+def out_p_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_f"]
+    return outputs["out_p"]
 
 
 def out_pf_callable(output_dir, inputs, stdout, stderr):
@@ -63,25 +56,25 @@ def out_res_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_res"]
 
 
-def out_varcb_callable(output_dir, inputs, stdout, stderr):
+def out_sigsq_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_varcb"]
+    return outputs["out_sigsq"]
 
 
-def out_sigsq_callable(output_dir, inputs, stdout, stderr):
+def out_t_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_sigsq"]
+    return outputs["out_t"]
 
 
-def out_data_callable(output_dir, inputs, stdout, stderr):
+def out_varcb_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_data"]
+    return outputs["out_varcb"]
 
 
 def out_vnscales_callable(output_dir, inputs, stdout, stderr):
@@ -91,12 +84,237 @@ def out_vnscales_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_vnscales"]
 
 
+def out_z_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_z"]
+
+
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+# Original source at L2511 of <nipype-install>/interfaces/fsl/model.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_fsl__FSLCommand___list_outputs()
+
+    if inputs.out_cope is not attrs.NOTHING:
+        outputs["out_cope"] = os.path.abspath(inputs.out_cope)
+
+    if inputs.out_z_name is not attrs.NOTHING:
+        outputs["out_z"] = os.path.abspath(inputs.out_z_name)
+
+    if inputs.out_t_name is not attrs.NOTHING:
+        outputs["out_t"] = os.path.abspath(inputs.out_t_name)
+
+    if inputs.out_p_name is not attrs.NOTHING:
+        outputs["out_p"] = os.path.abspath(inputs.out_p_name)
+
+    if inputs.out_f_name is not attrs.NOTHING:
+        outputs["out_f"] = os.path.abspath(inputs.out_f_name)
+
+    if inputs.out_pf_name is not attrs.NOTHING:
+        outputs["out_pf"] = os.path.abspath(inputs.out_pf_name)
+
+    if inputs.out_res_name is not attrs.NOTHING:
+        outputs["out_res"] = os.path.abspath(inputs.out_res_name)
+
+    if inputs.out_varcb_name is not attrs.NOTHING:
+        outputs["out_varcb"] = os.path.abspath(inputs.out_varcb_name)
+
+    if inputs.out_sigsq_name is not attrs.NOTHING:
+        outputs["out_sigsq"] = os.path.abspath(inputs.out_sigsq_name)
+
+    if inputs.out_data_name is not attrs.NOTHING:
+        outputs["out_data"] = os.path.abspath(inputs.out_data_name)
+
+    if inputs.out_vnscales_name is not attrs.NOTHING:
+        outputs["out_vnscales"] = os.path.abspath(inputs.out_vnscales_name)
+
+    return outputs
+
+
+# Original source at L249 of <nipype-install>/interfaces/fsl/base.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value + Info.output_type_to_ext(inputs.output_type)
+
+
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
+def nipype_interfaces_fsl__FSLCommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+# Original source at L58 of <nipype-install>/utils/filemanip.py
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
 # Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
@@ -228,13 +446,6 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
-# Original source at L249 of <nipype-install>/interfaces/fsl/base.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    return value + Info.output_type_to_ext(inputs.output_type)
-
-
 # Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
@@ -244,214 +455,3 @@ def __init__(self, value):
 
     def __str__(self):
         return "{}".format(self.value)
-
-
-# Original source at L58 of <nipype-install>/utils/filemanip.py
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
-# Original source at L809 of <nipype-install>/interfaces/base/core.py
-def _filename_from_source(
-    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    if chain is None:
-        chain = []
-
-    trait_spec = inputs.trait(name)
-    retval = getattr(inputs, name)
-    source_ext = None
-    if (retval is attrs.NOTHING) or "%s" in retval:
-        if not trait_spec.name_source:
-            return retval
-
-        # Do not generate filename when excluded by other inputs
-        if any(
-            (getattr(inputs, field) is not attrs.NOTHING)
-            for field in trait_spec.xor or ()
-        ):
-            return retval
-
-        # Do not generate filename when required fields are missing
-        if not all(
-            (getattr(inputs, field) is not attrs.NOTHING)
-            for field in trait_spec.requires or ()
-        ):
-            return retval
-
-        if (retval is not attrs.NOTHING) and "%s" in retval:
-            name_template = retval
-        else:
-            name_template = trait_spec.name_template
-        if not name_template:
-            name_template = "%s_generated"
-
-        ns = trait_spec.name_source
-        while isinstance(ns, (list, tuple)):
-            if len(ns) > 1:
-                iflogger.warning("Only one name_source per trait is allowed")
-            ns = ns[0]
-
-        if not isinstance(ns, (str, bytes)):
-            raise ValueError(
-                "name_source of '{}' trait should be an input trait "
-                "name, but a type {} object was found".format(name, type(ns))
-            )
-
-        if getattr(inputs, ns) is not attrs.NOTHING:
-            name_source = ns
-            source = getattr(inputs, name_source)
-            while isinstance(source, list):
-                source = source[0]
-
-            # special treatment for files
-            try:
-                _, base, source_ext = split_filename(source)
-            except (AttributeError, TypeError):
-                base = source
-        else:
-            if name in chain:
-                raise NipypeInterfaceError("Mutually pointing name_sources")
-
-            chain.append(name)
-            base = _filename_from_source(
-                ns,
-                chain,
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-            if base is not attrs.NOTHING:
-                _, _, source_ext = split_filename(base)
-            else:
-                # Do not generate filename when required fields are missing
-                return retval
-
-        chain = None
-        retval = name_template % base
-        _, _, ext = split_filename(retval)
-        if trait_spec.keep_extension and (ext or source_ext):
-            if (ext is None or not ext) and source_ext:
-                retval = retval + source_ext
-        else:
-            retval = _overload_extension(
-                retval,
-                name,
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-    return retval
-
-
-# Original source at L891 of <nipype-install>/interfaces/base/core.py
-def nipype_interfaces_fsl__FSLCommand___list_outputs(
-    inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    metadata = dict(name_source=lambda t: t is not None)
-    traits = inputs.traits(**metadata)
-    if traits:
-        outputs = {}
-        for name, trait_spec in list(traits.items()):
-            out_name = name
-            if trait_spec.output_name is not None:
-                out_name = trait_spec.output_name
-            fname = _filename_from_source(
-                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-            )
-            if fname is not attrs.NOTHING:
-                outputs[out_name] = os.path.abspath(fname)
-        return outputs
-
-
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
-# Original source at L2511 of <nipype-install>/interfaces/fsl/model.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = nipype_interfaces_fsl__FSLCommand___list_outputs()
-
-    if inputs.out_cope is not attrs.NOTHING:
-        outputs["out_cope"] = os.path.abspath(inputs.out_cope)
-
-    if inputs.out_z_name is not attrs.NOTHING:
-        outputs["out_z"] = os.path.abspath(inputs.out_z_name)
-
-    if inputs.out_t_name is not attrs.NOTHING:
-        outputs["out_t"] = os.path.abspath(inputs.out_t_name)
-
-    if inputs.out_p_name is not attrs.NOTHING:
-        outputs["out_p"] = os.path.abspath(inputs.out_p_name)
-
-    if inputs.out_f_name is not attrs.NOTHING:
-        outputs["out_f"] = os.path.abspath(inputs.out_f_name)
-
-    if inputs.out_pf_name is not attrs.NOTHING:
-        outputs["out_pf"] = os.path.abspath(inputs.out_pf_name)
-
-    if inputs.out_res_name is not attrs.NOTHING:
-        outputs["out_res"] = os.path.abspath(inputs.out_res_name)
-
-    if inputs.out_varcb_name is not attrs.NOTHING:
-        outputs["out_varcb"] = os.path.abspath(inputs.out_varcb_name)
-
-    if inputs.out_sigsq_name is not attrs.NOTHING:
-        outputs["out_sigsq"] = os.path.abspath(inputs.out_sigsq_name)
-
-    if inputs.out_data_name is not attrs.NOTHING:
-        outputs["out_data"] = os.path.abspath(inputs.out_data_name)
-
-    if inputs.out_vnscales_name is not attrs.NOTHING:
-        outputs["out_vnscales"] = os.path.abspath(inputs.out_vnscales_name)
-
-    return outputs
diff --git a/example-specs/task/nipype/fsl/ica__aroma_callables.py b/example-specs/task/nipype/fsl/ica__aroma_callables.py
index 2a2c7157..2c256334 100644
--- a/example-specs/task/nipype/fsl/ica__aroma_callables.py
+++ b/example-specs/task/nipype/fsl/ica__aroma_callables.py
@@ -1,7 +1,6 @@
 """Module to put any functions that are referred to in the "callables" section of ICA_AROMA.yaml"""
 
 import os
-import attrs
 
 
 def aggr_denoised_file_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/fsl/image_maths_callables.py b/example-specs/task/nipype/fsl/image_maths_callables.py
index 370aa5c7..0689a1c3 100644
--- a/example-specs/task/nipype/fsl/image_maths_callables.py
+++ b/example-specs/task/nipype/fsl/image_maths_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of ImageMaths.yaml"""
 
-from glob import glob
 import attrs
 import logging
 import os
 import os.path as op
+from glob import glob
 from pathlib import Path
 
 
@@ -22,42 +22,89 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
+# Original source at L627 of <nipype-install>/interfaces/fsl/utils.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )[name]
+    return None
 
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
 
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
 
-            klass._version = klass.parse_version(raw_info)
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
 
-        return klass._version
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
 
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "fslmaths"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+# Original source at L635 of <nipype-install>/interfaces/fsl/utils.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    suffix = "_maths"  # ohinds: build suffix
+    if inputs.suffix is not attrs.NOTHING:
+        suffix = inputs.suffix
+    outputs = {}
+    outputs["out_file"] = inputs.out_file
+    if outputs["out_file"] is attrs.NOTHING:
+        outputs["out_file"] = _gen_fname(
+            inputs.in_file,
+            suffix=suffix,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    outputs["out_file"] = os.path.abspath(outputs["out_file"])
+    return outputs
 
 
 # Original source at L108 of <nipype-install>/utils/filemanip.py
@@ -154,6 +201,44 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
@@ -245,88 +330,3 @@ def standard_image(img_name=None):
                 for filename in glob(os.path.join(stdpath, "*nii*"))
             ]
         return os.path.join(stdpath, img_name)
-
-
-# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
-def _gen_fname(
-    basename,
-    cwd=None,
-    suffix=None,
-    change_ext=True,
-    ext=None,
-    inputs=None,
-    stdout=None,
-    stderr=None,
-    output_dir=None,
-):
-    """Generate a filename based on the given parameters.
-
-    The filename will take the form: cwd/basename<suffix><ext>.
-    If change_ext is True, it will use the extensions specified in
-    <instance>inputs.output_type.
-
-    Parameters
-    ----------
-    basename : str
-        Filename to base the new filename on.
-    cwd : str
-        Path to prefix to the new filename. (default is output_dir)
-    suffix : str
-        Suffix to add to the `basename`.  (defaults is '' )
-    change_ext : bool
-        Flag to change the filename extension to the FSL output type.
-        (default True)
-
-    Returns
-    -------
-    fname : str
-        New filename based on given parameters.
-
-    """
-
-    if basename == "":
-        msg = "Unable to generate filename for command %s. " % "fslmaths"
-        msg += "basename is not set!"
-        raise ValueError(msg)
-    if cwd is None:
-        cwd = output_dir
-    if ext is None:
-        ext = Info.output_type_to_ext(inputs.output_type)
-    if change_ext:
-        if suffix:
-            suffix = "".join((suffix, ext))
-        else:
-            suffix = ext
-    if suffix is None:
-        suffix = ""
-    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
-    return fname
-
-
-# Original source at L627 of <nipype-install>/interfaces/fsl/utils.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "out_file":
-        return _list_outputs(
-            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-        )[name]
-    return None
-
-
-# Original source at L635 of <nipype-install>/interfaces/fsl/utils.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    suffix = "_maths"  # ohinds: build suffix
-    if inputs.suffix is not attrs.NOTHING:
-        suffix = inputs.suffix
-    outputs = {}
-    outputs["out_file"] = inputs.out_file
-    if outputs["out_file"] is attrs.NOTHING:
-        outputs["out_file"] = _gen_fname(
-            inputs.in_file,
-            suffix=suffix,
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-    outputs["out_file"] = os.path.abspath(outputs["out_file"])
-    return outputs
diff --git a/example-specs/task/nipype/fsl/image_meants_callables.py b/example-specs/task/nipype/fsl/image_meants_callables.py
index a6d74733..b7eb8a56 100644
--- a/example-specs/task/nipype/fsl/image_meants_callables.py
+++ b/example-specs/task/nipype/fsl/image_meants_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of ImageMeants.yaml"""
 
-from glob import glob
 import attrs
 import logging
 import os
 import os.path as op
+from glob import glob
 from pathlib import Path
 
 
@@ -22,42 +22,88 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
+# Original source at L184 of <nipype-install>/interfaces/fsl/utils.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )[name]
+    return None
 
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
 
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
 
-            klass._version = klass.parse_version(raw_info)
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
 
-        return klass._version
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
 
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "fslmeants"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+# Original source at L174 of <nipype-install>/interfaces/fsl/utils.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = inputs.out_file
+    if outputs["out_file"] is attrs.NOTHING:
+        outputs["out_file"] = _gen_fname(
+            inputs.in_file,
+            suffix="_ts",
+            ext=".txt",
+            change_ext=True,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    outputs["out_file"] = os.path.abspath(outputs["out_file"])
+    return outputs
 
 
 # Original source at L108 of <nipype-install>/utils/filemanip.py
@@ -154,6 +200,44 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
@@ -245,87 +329,3 @@ def standard_image(img_name=None):
                 for filename in glob(os.path.join(stdpath, "*nii*"))
             ]
         return os.path.join(stdpath, img_name)
-
-
-# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
-def _gen_fname(
-    basename,
-    cwd=None,
-    suffix=None,
-    change_ext=True,
-    ext=None,
-    inputs=None,
-    stdout=None,
-    stderr=None,
-    output_dir=None,
-):
-    """Generate a filename based on the given parameters.
-
-    The filename will take the form: cwd/basename<suffix><ext>.
-    If change_ext is True, it will use the extensions specified in
-    <instance>inputs.output_type.
-
-    Parameters
-    ----------
-    basename : str
-        Filename to base the new filename on.
-    cwd : str
-        Path to prefix to the new filename. (default is output_dir)
-    suffix : str
-        Suffix to add to the `basename`.  (defaults is '' )
-    change_ext : bool
-        Flag to change the filename extension to the FSL output type.
-        (default True)
-
-    Returns
-    -------
-    fname : str
-        New filename based on given parameters.
-
-    """
-
-    if basename == "":
-        msg = "Unable to generate filename for command %s. " % "fslmeants"
-        msg += "basename is not set!"
-        raise ValueError(msg)
-    if cwd is None:
-        cwd = output_dir
-    if ext is None:
-        ext = Info.output_type_to_ext(inputs.output_type)
-    if change_ext:
-        if suffix:
-            suffix = "".join((suffix, ext))
-        else:
-            suffix = ext
-    if suffix is None:
-        suffix = ""
-    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
-    return fname
-
-
-# Original source at L184 of <nipype-install>/interfaces/fsl/utils.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "out_file":
-        return _list_outputs(
-            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-        )[name]
-    return None
-
-
-# Original source at L174 of <nipype-install>/interfaces/fsl/utils.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    outputs["out_file"] = inputs.out_file
-    if outputs["out_file"] is attrs.NOTHING:
-        outputs["out_file"] = _gen_fname(
-            inputs.in_file,
-            suffix="_ts",
-            ext=".txt",
-            change_ext=True,
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-    outputs["out_file"] = os.path.abspath(outputs["out_file"])
-    return outputs
diff --git a/example-specs/task/nipype/fsl/image_stats_callables.py b/example-specs/task/nipype/fsl/image_stats_callables.py
index 87578728..691ce5b9 100644
--- a/example-specs/task/nipype/fsl/image_stats_callables.py
+++ b/example-specs/task/nipype/fsl/image_stats_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of ImageStats.yaml"""
 
-from glob import glob
 import attrs
 import logging
 import os
 import os.path as op
+from glob import glob
 
 
 def out_stat_callable(output_dir, inputs, stdout, stderr):
@@ -20,6 +20,182 @@ def out_stat_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+# Original source at L249 of <nipype-install>/interfaces/fsl/base.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value + Info.output_type_to_ext(inputs.output_type)
+
+
+# Original source at L58 of <nipype-install>/utils/filemanip.py
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
 # Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
@@ -151,13 +327,6 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
-# Original source at L249 of <nipype-install>/interfaces/fsl/base.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    return value + Info.output_type_to_ext(inputs.output_type)
-
-
 # Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
@@ -167,172 +336,3 @@ def __init__(self, value):
 
     def __str__(self):
         return "{}".format(self.value)
-
-
-# Original source at L58 of <nipype-install>/utils/filemanip.py
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
-# Original source at L809 of <nipype-install>/interfaces/base/core.py
-def _filename_from_source(
-    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    if chain is None:
-        chain = []
-
-    trait_spec = inputs.trait(name)
-    retval = getattr(inputs, name)
-    source_ext = None
-    if (retval is attrs.NOTHING) or "%s" in retval:
-        if not trait_spec.name_source:
-            return retval
-
-        # Do not generate filename when excluded by other inputs
-        if any(
-            (getattr(inputs, field) is not attrs.NOTHING)
-            for field in trait_spec.xor or ()
-        ):
-            return retval
-
-        # Do not generate filename when required fields are missing
-        if not all(
-            (getattr(inputs, field) is not attrs.NOTHING)
-            for field in trait_spec.requires or ()
-        ):
-            return retval
-
-        if (retval is not attrs.NOTHING) and "%s" in retval:
-            name_template = retval
-        else:
-            name_template = trait_spec.name_template
-        if not name_template:
-            name_template = "%s_generated"
-
-        ns = trait_spec.name_source
-        while isinstance(ns, (list, tuple)):
-            if len(ns) > 1:
-                iflogger.warning("Only one name_source per trait is allowed")
-            ns = ns[0]
-
-        if not isinstance(ns, (str, bytes)):
-            raise ValueError(
-                "name_source of '{}' trait should be an input trait "
-                "name, but a type {} object was found".format(name, type(ns))
-            )
-
-        if getattr(inputs, ns) is not attrs.NOTHING:
-            name_source = ns
-            source = getattr(inputs, name_source)
-            while isinstance(source, list):
-                source = source[0]
-
-            # special treatment for files
-            try:
-                _, base, source_ext = split_filename(source)
-            except (AttributeError, TypeError):
-                base = source
-        else:
-            if name in chain:
-                raise NipypeInterfaceError("Mutually pointing name_sources")
-
-            chain.append(name)
-            base = _filename_from_source(
-                ns,
-                chain,
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-            if base is not attrs.NOTHING:
-                _, _, source_ext = split_filename(base)
-            else:
-                # Do not generate filename when required fields are missing
-                return retval
-
-        chain = None
-        retval = name_template % base
-        _, _, ext = split_filename(retval)
-        if trait_spec.keep_extension and (ext or source_ext):
-            if (ext is None or not ext) and source_ext:
-                retval = retval + source_ext
-        else:
-            retval = _overload_extension(
-                retval,
-                name,
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-    return retval
-
-
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
-# Original source at L891 of <nipype-install>/interfaces/base/core.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    metadata = dict(name_source=lambda t: t is not None)
-    traits = inputs.traits(**metadata)
-    if traits:
-        outputs = {}
-        for name, trait_spec in list(traits.items()):
-            out_name = name
-            if trait_spec.output_name is not None:
-                out_name = trait_spec.output_name
-            fname = _filename_from_source(
-                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-            )
-            if fname is not attrs.NOTHING:
-                outputs[out_name] = os.path.abspath(fname)
-        return outputs
diff --git a/example-specs/task/nipype/fsl/inv_warp_callables.py b/example-specs/task/nipype/fsl/inv_warp_callables.py
index 5d1296e9..f9af0453 100644
--- a/example-specs/task/nipype/fsl/inv_warp_callables.py
+++ b/example-specs/task/nipype/fsl/inv_warp_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of InvWarp.yaml"""
 
-from glob import glob
 import attrs
 import logging
 import os
 import os.path as op
+from glob import glob
 
 
 def inverse_warp_callable(output_dir, inputs, stdout, stderr):
@@ -20,6 +20,182 @@ def inverse_warp_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+# Original source at L249 of <nipype-install>/interfaces/fsl/base.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value + Info.output_type_to_ext(inputs.output_type)
+
+
+# Original source at L58 of <nipype-install>/utils/filemanip.py
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
 # Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
@@ -151,13 +327,6 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
-# Original source at L249 of <nipype-install>/interfaces/fsl/base.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    return value + Info.output_type_to_ext(inputs.output_type)
-
-
 # Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
@@ -167,172 +336,3 @@ def __init__(self, value):
 
     def __str__(self):
         return "{}".format(self.value)
-
-
-# Original source at L58 of <nipype-install>/utils/filemanip.py
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
-# Original source at L809 of <nipype-install>/interfaces/base/core.py
-def _filename_from_source(
-    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    if chain is None:
-        chain = []
-
-    trait_spec = inputs.trait(name)
-    retval = getattr(inputs, name)
-    source_ext = None
-    if (retval is attrs.NOTHING) or "%s" in retval:
-        if not trait_spec.name_source:
-            return retval
-
-        # Do not generate filename when excluded by other inputs
-        if any(
-            (getattr(inputs, field) is not attrs.NOTHING)
-            for field in trait_spec.xor or ()
-        ):
-            return retval
-
-        # Do not generate filename when required fields are missing
-        if not all(
-            (getattr(inputs, field) is not attrs.NOTHING)
-            for field in trait_spec.requires or ()
-        ):
-            return retval
-
-        if (retval is not attrs.NOTHING) and "%s" in retval:
-            name_template = retval
-        else:
-            name_template = trait_spec.name_template
-        if not name_template:
-            name_template = "%s_generated"
-
-        ns = trait_spec.name_source
-        while isinstance(ns, (list, tuple)):
-            if len(ns) > 1:
-                iflogger.warning("Only one name_source per trait is allowed")
-            ns = ns[0]
-
-        if not isinstance(ns, (str, bytes)):
-            raise ValueError(
-                "name_source of '{}' trait should be an input trait "
-                "name, but a type {} object was found".format(name, type(ns))
-            )
-
-        if getattr(inputs, ns) is not attrs.NOTHING:
-            name_source = ns
-            source = getattr(inputs, name_source)
-            while isinstance(source, list):
-                source = source[0]
-
-            # special treatment for files
-            try:
-                _, base, source_ext = split_filename(source)
-            except (AttributeError, TypeError):
-                base = source
-        else:
-            if name in chain:
-                raise NipypeInterfaceError("Mutually pointing name_sources")
-
-            chain.append(name)
-            base = _filename_from_source(
-                ns,
-                chain,
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-            if base is not attrs.NOTHING:
-                _, _, source_ext = split_filename(base)
-            else:
-                # Do not generate filename when required fields are missing
-                return retval
-
-        chain = None
-        retval = name_template % base
-        _, _, ext = split_filename(retval)
-        if trait_spec.keep_extension and (ext or source_ext):
-            if (ext is None or not ext) and source_ext:
-                retval = retval + source_ext
-        else:
-            retval = _overload_extension(
-                retval,
-                name,
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-    return retval
-
-
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
-# Original source at L891 of <nipype-install>/interfaces/base/core.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    metadata = dict(name_source=lambda t: t is not None)
-    traits = inputs.traits(**metadata)
-    if traits:
-        outputs = {}
-        for name, trait_spec in list(traits.items()):
-            out_name = name
-            if trait_spec.output_name is not None:
-                out_name = trait_spec.output_name
-            fname = _filename_from_source(
-                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-            )
-            if fname is not attrs.NOTHING:
-                outputs[out_name] = os.path.abspath(fname)
-        return outputs
diff --git a/example-specs/task/nipype/fsl/isotropic_smooth_callables.py b/example-specs/task/nipype/fsl/isotropic_smooth_callables.py
index d1737124..214d3740 100644
--- a/example-specs/task/nipype/fsl/isotropic_smooth_callables.py
+++ b/example-specs/task/nipype/fsl/isotropic_smooth_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of IsotropicSmooth.yaml"""
 
-from glob import glob
 import attrs
 import logging
 import os
 import os.path as op
+from glob import glob
 from pathlib import Path
 
 
@@ -22,42 +22,86 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
+# Original source at L61 of <nipype-install>/interfaces/fsl/maths.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )["out_file"]
+    return None
 
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
 
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
 
-            klass._version = klass.parse_version(raw_info)
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
 
-        return klass._version
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
 
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "fslmaths"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+# Original source at L51 of <nipype-install>/interfaces/fsl/maths.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = inputs.out_file
+    if inputs.out_file is attrs.NOTHING:
+        outputs["out_file"] = _gen_fname(
+            inputs.in_file,
+            suffix=_suffix,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    outputs["out_file"] = os.path.abspath(outputs["out_file"])
+    return outputs
 
 
 # Original source at L108 of <nipype-install>/utils/filemanip.py
@@ -154,6 +198,44 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
@@ -245,85 +327,3 @@ def standard_image(img_name=None):
                 for filename in glob(os.path.join(stdpath, "*nii*"))
             ]
         return os.path.join(stdpath, img_name)
-
-
-# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
-def _gen_fname(
-    basename,
-    cwd=None,
-    suffix=None,
-    change_ext=True,
-    ext=None,
-    inputs=None,
-    stdout=None,
-    stderr=None,
-    output_dir=None,
-):
-    """Generate a filename based on the given parameters.
-
-    The filename will take the form: cwd/basename<suffix><ext>.
-    If change_ext is True, it will use the extensions specified in
-    <instance>inputs.output_type.
-
-    Parameters
-    ----------
-    basename : str
-        Filename to base the new filename on.
-    cwd : str
-        Path to prefix to the new filename. (default is output_dir)
-    suffix : str
-        Suffix to add to the `basename`.  (defaults is '' )
-    change_ext : bool
-        Flag to change the filename extension to the FSL output type.
-        (default True)
-
-    Returns
-    -------
-    fname : str
-        New filename based on given parameters.
-
-    """
-
-    if basename == "":
-        msg = "Unable to generate filename for command %s. " % "fslmaths"
-        msg += "basename is not set!"
-        raise ValueError(msg)
-    if cwd is None:
-        cwd = output_dir
-    if ext is None:
-        ext = Info.output_type_to_ext(inputs.output_type)
-    if change_ext:
-        if suffix:
-            suffix = "".join((suffix, ext))
-        else:
-            suffix = ext
-    if suffix is None:
-        suffix = ""
-    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
-    return fname
-
-
-# Original source at L61 of <nipype-install>/interfaces/fsl/maths.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "out_file":
-        return _list_outputs(
-            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-        )["out_file"]
-    return None
-
-
-# Original source at L51 of <nipype-install>/interfaces/fsl/maths.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    outputs["out_file"] = inputs.out_file
-    if inputs.out_file is attrs.NOTHING:
-        outputs["out_file"] = _gen_fname(
-            inputs.in_file,
-            suffix=_suffix,
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-    outputs["out_file"] = os.path.abspath(outputs["out_file"])
-    return outputs
diff --git a/example-specs/task/nipype/fsl/l2_model_callables.py b/example-specs/task/nipype/fsl/l2_model_callables.py
index 1b32404c..faac4e18 100644
--- a/example-specs/task/nipype/fsl/l2_model_callables.py
+++ b/example-specs/task/nipype/fsl/l2_model_callables.py
@@ -1,13 +1,6 @@
 """Module to put any functions that are referred to in the "callables" section of L2Model.yaml"""
 
-import attrs
-
-
-def design_mat_callable(output_dir, inputs, stdout, stderr):
-    outputs = _list_outputs(
-        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
-    )
-    return outputs["design_mat"]
+import os
 
 
 def design_con_callable(output_dir, inputs, stdout, stderr):
@@ -24,7 +17,16 @@ def design_grp_callable(output_dir, inputs, stdout, stderr):
     return outputs["design_grp"]
 
 
-def _gen_filename(field, inputs, output_dir, stdout, stderr):
-    raise NotImplementedError(
-        "Could not find '_gen_filename' method in nipype.interfaces.fsl.model.L2Model"
+def design_mat_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
+    return outputs["design_mat"]
+
+
+# Original source at L1431 of <nipype-install>/interfaces/fsl/model.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    for field in list(outputs.keys()):
+        outputs[field] = os.path.join(output_dir, field.replace("_", "."))
+    return outputs
diff --git a/example-specs/task/nipype/fsl/level_1_design_callables.py b/example-specs/task/nipype/fsl/level_1_design_callables.py
index 97269631..ed9f7202 100644
--- a/example-specs/task/nipype/fsl/level_1_design_callables.py
+++ b/example-specs/task/nipype/fsl/level_1_design_callables.py
@@ -1,23 +1,63 @@
 """Module to put any functions that are referred to in the "callables" section of Level1Design.yaml"""
 
-import attrs
+import os
 
 
-def fsf_files_callable(output_dir, inputs, stdout, stderr):
+def ev_files_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["fsf_files"]
+    return outputs["ev_files"]
 
 
-def ev_files_callable(output_dir, inputs, stdout, stderr):
+def fsf_files_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["ev_files"]
+    return outputs["fsf_files"]
 
 
-def _gen_filename(field, inputs, output_dir, stdout, stderr):
-    raise NotImplementedError(
-        "Could not find '_gen_filename' method in nipype.interfaces.fsl.model.Level1Design"
-    )
+# Original source at L343 of <nipype-install>/interfaces/fsl/model.py
+def _format_session_info(
+    session_info, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if isinstance(session_info, dict):
+        session_info = [session_info]
+    return session_info
+
+
+# Original source at L414 of <nipype-install>/interfaces/fsl/model.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    cwd = output_dir
+    outputs["fsf_files"] = []
+    outputs["ev_files"] = []
+    basis_key = list(inputs.bases.keys())[0]
+    ev_parameters = dict(inputs.bases[basis_key])
+    for runno, runinfo in enumerate(
+        _format_session_info(
+            inputs.session_info,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    ):
+        outputs["fsf_files"].append(os.path.join(cwd, "run%d.fsf" % runno))
+        outputs["ev_files"].insert(runno, [])
+        evname = []
+        for field in ["cond", "regress"]:
+            for i, cond in enumerate(runinfo[field]):
+                name = cond["name"]
+                evname.append(name)
+                evfname = os.path.join(
+                    cwd, "ev_%s_%d_%d.txt" % (name, runno, len(evname))
+                )
+                if field == "cond":
+                    ev_parameters["temporalderiv"] = int(
+                        bool(ev_parameters.get("derivs", False))
+                    )
+                    if ev_parameters["temporalderiv"]:
+                        evname.append(name + "TD")
+                outputs["ev_files"][runno].append(os.path.join(cwd, evfname))
+    return outputs
diff --git a/example-specs/task/nipype/fsl/make_dyadic_vectors_callables.py b/example-specs/task/nipype/fsl/make_dyadic_vectors_callables.py
index a163cae0..8851bdee 100644
--- a/example-specs/task/nipype/fsl/make_dyadic_vectors_callables.py
+++ b/example-specs/task/nipype/fsl/make_dyadic_vectors_callables.py
@@ -1,66 +1,110 @@
 """Module to put any functions that are referred to in the "callables" section of MakeDyadicVectors.yaml"""
 
-import attrs
-from glob import glob
 import logging
 import os
 import os.path as op
+from glob import glob
 from pathlib import Path
 
 
-def dyads_callable(output_dir, inputs, stdout, stderr):
+def dispersion_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["dyads"]
+    return outputs["dispersion"]
 
 
-def dispersion_callable(output_dir, inputs, stdout, stderr):
+def dyads_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["dispersion"]
+    return outputs["dyads"]
 
 
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
 
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
 
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
 
-            klass._version = klass.parse_version(raw_info)
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
 
-        return klass._version
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
 
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "make_dyadic_vectors"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+# Original source at L1571 of <nipype-install>/interfaces/fsl/dti.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["dyads"] = _gen_fname(
+        inputs.output,
+        inputs=inputs,
+        stdout=stdout,
+        stderr=stderr,
+        output_dir=output_dir,
+    )
+    outputs["dispersion"] = _gen_fname(
+        inputs.output,
+        suffix="_dispersion",
+        inputs=inputs,
+        stdout=stdout,
+        stderr=stderr,
+        output_dir=output_dir,
+    )
+
+    return outputs
 
 
 # Original source at L108 of <nipype-install>/utils/filemanip.py
@@ -157,6 +201,44 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
@@ -248,86 +330,3 @@ def standard_image(img_name=None):
                 for filename in glob(os.path.join(stdpath, "*nii*"))
             ]
         return os.path.join(stdpath, img_name)
-
-
-# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
-def _gen_fname(
-    basename,
-    cwd=None,
-    suffix=None,
-    change_ext=True,
-    ext=None,
-    inputs=None,
-    stdout=None,
-    stderr=None,
-    output_dir=None,
-):
-    """Generate a filename based on the given parameters.
-
-    The filename will take the form: cwd/basename<suffix><ext>.
-    If change_ext is True, it will use the extensions specified in
-    <instance>inputs.output_type.
-
-    Parameters
-    ----------
-    basename : str
-        Filename to base the new filename on.
-    cwd : str
-        Path to prefix to the new filename. (default is output_dir)
-    suffix : str
-        Suffix to add to the `basename`.  (defaults is '' )
-    change_ext : bool
-        Flag to change the filename extension to the FSL output type.
-        (default True)
-
-    Returns
-    -------
-    fname : str
-        New filename based on given parameters.
-
-    """
-
-    if basename == "":
-        msg = "Unable to generate filename for command %s. " % "make_dyadic_vectors"
-        msg += "basename is not set!"
-        raise ValueError(msg)
-    if cwd is None:
-        cwd = output_dir
-    if ext is None:
-        ext = Info.output_type_to_ext(inputs.output_type)
-    if change_ext:
-        if suffix:
-            suffix = "".join((suffix, ext))
-        else:
-            suffix = ext
-    if suffix is None:
-        suffix = ""
-    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
-    return fname
-
-
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
-# Original source at L1571 of <nipype-install>/interfaces/fsl/dti.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    outputs["dyads"] = _gen_fname(
-        inputs.output,
-        inputs=inputs,
-        stdout=stdout,
-        stderr=stderr,
-        output_dir=output_dir,
-    )
-    outputs["dispersion"] = _gen_fname(
-        inputs.output,
-        suffix="_dispersion",
-        inputs=inputs,
-        stdout=stdout,
-        stderr=stderr,
-        output_dir=output_dir,
-    )
-
-    return outputs
diff --git a/example-specs/task/nipype/fsl/maths_command_callables.py b/example-specs/task/nipype/fsl/maths_command_callables.py
index 795f883c..c11baf29 100644
--- a/example-specs/task/nipype/fsl/maths_command_callables.py
+++ b/example-specs/task/nipype/fsl/maths_command_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of MathsCommand.yaml"""
 
-from glob import glob
 import attrs
 import logging
 import os
 import os.path as op
+from glob import glob
 from pathlib import Path
 
 
@@ -22,42 +22,86 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
+# Original source at L61 of <nipype-install>/interfaces/fsl/maths.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )["out_file"]
+    return None
 
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
 
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
 
-            klass._version = klass.parse_version(raw_info)
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
 
-        return klass._version
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
 
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "fslmaths"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+# Original source at L51 of <nipype-install>/interfaces/fsl/maths.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = inputs.out_file
+    if inputs.out_file is attrs.NOTHING:
+        outputs["out_file"] = _gen_fname(
+            inputs.in_file,
+            suffix=_suffix,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    outputs["out_file"] = os.path.abspath(outputs["out_file"])
+    return outputs
 
 
 # Original source at L108 of <nipype-install>/utils/filemanip.py
@@ -154,6 +198,44 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
@@ -245,85 +327,3 @@ def standard_image(img_name=None):
                 for filename in glob(os.path.join(stdpath, "*nii*"))
             ]
         return os.path.join(stdpath, img_name)
-
-
-# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
-def _gen_fname(
-    basename,
-    cwd=None,
-    suffix=None,
-    change_ext=True,
-    ext=None,
-    inputs=None,
-    stdout=None,
-    stderr=None,
-    output_dir=None,
-):
-    """Generate a filename based on the given parameters.
-
-    The filename will take the form: cwd/basename<suffix><ext>.
-    If change_ext is True, it will use the extensions specified in
-    <instance>inputs.output_type.
-
-    Parameters
-    ----------
-    basename : str
-        Filename to base the new filename on.
-    cwd : str
-        Path to prefix to the new filename. (default is output_dir)
-    suffix : str
-        Suffix to add to the `basename`.  (defaults is '' )
-    change_ext : bool
-        Flag to change the filename extension to the FSL output type.
-        (default True)
-
-    Returns
-    -------
-    fname : str
-        New filename based on given parameters.
-
-    """
-
-    if basename == "":
-        msg = "Unable to generate filename for command %s. " % "fslmaths"
-        msg += "basename is not set!"
-        raise ValueError(msg)
-    if cwd is None:
-        cwd = output_dir
-    if ext is None:
-        ext = Info.output_type_to_ext(inputs.output_type)
-    if change_ext:
-        if suffix:
-            suffix = "".join((suffix, ext))
-        else:
-            suffix = ext
-    if suffix is None:
-        suffix = ""
-    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
-    return fname
-
-
-# Original source at L61 of <nipype-install>/interfaces/fsl/maths.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "out_file":
-        return _list_outputs(
-            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-        )["out_file"]
-    return None
-
-
-# Original source at L51 of <nipype-install>/interfaces/fsl/maths.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    outputs["out_file"] = inputs.out_file
-    if inputs.out_file is attrs.NOTHING:
-        outputs["out_file"] = _gen_fname(
-            inputs.in_file,
-            suffix=_suffix,
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-    outputs["out_file"] = os.path.abspath(outputs["out_file"])
-    return outputs
diff --git a/example-specs/task/nipype/fsl/max_image_callables.py b/example-specs/task/nipype/fsl/max_image_callables.py
index 5ffcc131..61b6ae61 100644
--- a/example-specs/task/nipype/fsl/max_image_callables.py
+++ b/example-specs/task/nipype/fsl/max_image_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of MaxImage.yaml"""
 
-from glob import glob
 import attrs
 import logging
 import os
 import os.path as op
+from glob import glob
 from pathlib import Path
 
 
@@ -22,42 +22,86 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
+# Original source at L61 of <nipype-install>/interfaces/fsl/maths.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )["out_file"]
+    return None
 
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
 
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
 
-            klass._version = klass.parse_version(raw_info)
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
 
-        return klass._version
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
 
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "fslmaths"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+# Original source at L51 of <nipype-install>/interfaces/fsl/maths.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = inputs.out_file
+    if inputs.out_file is attrs.NOTHING:
+        outputs["out_file"] = _gen_fname(
+            inputs.in_file,
+            suffix=_suffix,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    outputs["out_file"] = os.path.abspath(outputs["out_file"])
+    return outputs
 
 
 # Original source at L108 of <nipype-install>/utils/filemanip.py
@@ -154,6 +198,44 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
@@ -245,85 +327,3 @@ def standard_image(img_name=None):
                 for filename in glob(os.path.join(stdpath, "*nii*"))
             ]
         return os.path.join(stdpath, img_name)
-
-
-# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
-def _gen_fname(
-    basename,
-    cwd=None,
-    suffix=None,
-    change_ext=True,
-    ext=None,
-    inputs=None,
-    stdout=None,
-    stderr=None,
-    output_dir=None,
-):
-    """Generate a filename based on the given parameters.
-
-    The filename will take the form: cwd/basename<suffix><ext>.
-    If change_ext is True, it will use the extensions specified in
-    <instance>inputs.output_type.
-
-    Parameters
-    ----------
-    basename : str
-        Filename to base the new filename on.
-    cwd : str
-        Path to prefix to the new filename. (default is output_dir)
-    suffix : str
-        Suffix to add to the `basename`.  (defaults is '' )
-    change_ext : bool
-        Flag to change the filename extension to the FSL output type.
-        (default True)
-
-    Returns
-    -------
-    fname : str
-        New filename based on given parameters.
-
-    """
-
-    if basename == "":
-        msg = "Unable to generate filename for command %s. " % "fslmaths"
-        msg += "basename is not set!"
-        raise ValueError(msg)
-    if cwd is None:
-        cwd = output_dir
-    if ext is None:
-        ext = Info.output_type_to_ext(inputs.output_type)
-    if change_ext:
-        if suffix:
-            suffix = "".join((suffix, ext))
-        else:
-            suffix = ext
-    if suffix is None:
-        suffix = ""
-    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
-    return fname
-
-
-# Original source at L61 of <nipype-install>/interfaces/fsl/maths.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "out_file":
-        return _list_outputs(
-            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-        )["out_file"]
-    return None
-
-
-# Original source at L51 of <nipype-install>/interfaces/fsl/maths.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    outputs["out_file"] = inputs.out_file
-    if inputs.out_file is attrs.NOTHING:
-        outputs["out_file"] = _gen_fname(
-            inputs.in_file,
-            suffix=_suffix,
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-    outputs["out_file"] = os.path.abspath(outputs["out_file"])
-    return outputs
diff --git a/example-specs/task/nipype/fsl/maxn_image_callables.py b/example-specs/task/nipype/fsl/maxn_image_callables.py
index 2c4431c3..87f0b52a 100644
--- a/example-specs/task/nipype/fsl/maxn_image_callables.py
+++ b/example-specs/task/nipype/fsl/maxn_image_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of MaxnImage.yaml"""
 
-from glob import glob
 import attrs
 import logging
 import os
 import os.path as op
+from glob import glob
 from pathlib import Path
 
 
@@ -22,42 +22,86 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
+# Original source at L61 of <nipype-install>/interfaces/fsl/maths.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )["out_file"]
+    return None
 
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
 
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
 
-            klass._version = klass.parse_version(raw_info)
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
 
-        return klass._version
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
 
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "fslmaths"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+# Original source at L51 of <nipype-install>/interfaces/fsl/maths.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = inputs.out_file
+    if inputs.out_file is attrs.NOTHING:
+        outputs["out_file"] = _gen_fname(
+            inputs.in_file,
+            suffix=_suffix,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    outputs["out_file"] = os.path.abspath(outputs["out_file"])
+    return outputs
 
 
 # Original source at L108 of <nipype-install>/utils/filemanip.py
@@ -154,6 +198,44 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
@@ -245,85 +327,3 @@ def standard_image(img_name=None):
                 for filename in glob(os.path.join(stdpath, "*nii*"))
             ]
         return os.path.join(stdpath, img_name)
-
-
-# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
-def _gen_fname(
-    basename,
-    cwd=None,
-    suffix=None,
-    change_ext=True,
-    ext=None,
-    inputs=None,
-    stdout=None,
-    stderr=None,
-    output_dir=None,
-):
-    """Generate a filename based on the given parameters.
-
-    The filename will take the form: cwd/basename<suffix><ext>.
-    If change_ext is True, it will use the extensions specified in
-    <instance>inputs.output_type.
-
-    Parameters
-    ----------
-    basename : str
-        Filename to base the new filename on.
-    cwd : str
-        Path to prefix to the new filename. (default is output_dir)
-    suffix : str
-        Suffix to add to the `basename`.  (defaults is '' )
-    change_ext : bool
-        Flag to change the filename extension to the FSL output type.
-        (default True)
-
-    Returns
-    -------
-    fname : str
-        New filename based on given parameters.
-
-    """
-
-    if basename == "":
-        msg = "Unable to generate filename for command %s. " % "fslmaths"
-        msg += "basename is not set!"
-        raise ValueError(msg)
-    if cwd is None:
-        cwd = output_dir
-    if ext is None:
-        ext = Info.output_type_to_ext(inputs.output_type)
-    if change_ext:
-        if suffix:
-            suffix = "".join((suffix, ext))
-        else:
-            suffix = ext
-    if suffix is None:
-        suffix = ""
-    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
-    return fname
-
-
-# Original source at L61 of <nipype-install>/interfaces/fsl/maths.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "out_file":
-        return _list_outputs(
-            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-        )["out_file"]
-    return None
-
-
-# Original source at L51 of <nipype-install>/interfaces/fsl/maths.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    outputs["out_file"] = inputs.out_file
-    if inputs.out_file is attrs.NOTHING:
-        outputs["out_file"] = _gen_fname(
-            inputs.in_file,
-            suffix=_suffix,
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-    outputs["out_file"] = os.path.abspath(outputs["out_file"])
-    return outputs
diff --git a/example-specs/task/nipype/fsl/mcflirt_callables.py b/example-specs/task/nipype/fsl/mcflirt_callables.py
index 699434a8..d6bc0a6c 100644
--- a/example-specs/task/nipype/fsl/mcflirt_callables.py
+++ b/example-specs/task/nipype/fsl/mcflirt_callables.py
@@ -1,12 +1,12 @@
 """Module to put any functions that are referred to in the "callables" section of MCFLIRT.yaml"""
 
-from looseversion import LooseVersion
 import attrs
+import logging
 import os
 import os.path as op
-from nibabel import load
 from glob import glob
-import logging
+from looseversion import LooseVersion
+from nibabel import load
 from pathlib import Path
 
 
@@ -14,58 +14,233 @@ def out_file_default(inputs):
     return _gen_filename("out_file", inputs=inputs)
 
 
-def out_file_callable(output_dir, inputs, stdout, stderr):
+def mat_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_file"]
+    return outputs["mat_file"]
 
 
-def variance_img_callable(output_dir, inputs, stdout, stderr):
+def mean_img_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["variance_img"]
+    return outputs["mean_img"]
 
 
-def std_img_callable(output_dir, inputs, stdout, stderr):
+def out_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["std_img"]
+    return outputs["out_file"]
 
 
-def mean_img_callable(output_dir, inputs, stdout, stderr):
+def par_file_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["mean_img"]
+    return outputs["par_file"]
 
 
-def par_file_callable(output_dir, inputs, stdout, stderr):
+def rms_files_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["par_file"]
+    return outputs["rms_files"]
 
 
-def mat_file_callable(output_dir, inputs, stdout, stderr):
+def std_img_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["mat_file"]
+    return outputs["std_img"]
 
 
-def rms_files_callable(output_dir, inputs, stdout, stderr):
+def variance_img_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["rms_files"]
+    return outputs["variance_img"]
 
 
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
+# Original source at L962 of <nipype-install>/interfaces/fsl/preprocess.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _gen_outfilename(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )
+    return None
+
+
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
+
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
+
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
+
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "mcflirt"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+# Original source at L967 of <nipype-install>/interfaces/fsl/preprocess.py
+def _gen_outfilename(inputs=None, stdout=None, stderr=None, output_dir=None):
+    out_file = inputs.out_file
+    if out_file is not attrs.NOTHING:
+        out_file = os.path.realpath(out_file)
+    if (out_file is attrs.NOTHING) and (inputs.in_file is not attrs.NOTHING):
+        out_file = _gen_fname(
+            inputs.in_file,
+            suffix="_mcf",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    return os.path.abspath(out_file)
+
+
+# Original source at L906 of <nipype-install>/interfaces/fsl/preprocess.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+
+    outputs["out_file"] = _gen_outfilename(
+        inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+    )
+    output_dir = os.path.dirname(outputs["out_file"])
+
+    if (inputs.stats_imgs is not attrs.NOTHING) and inputs.stats_imgs:
+        if LooseVersion(Info.version()) < LooseVersion("6.0.0"):
+            # FSL <6.0 outputs have .nii.gz_variance.nii.gz as extension
+            outputs["variance_img"] = _gen_fname(
+                outputs["out_file"] + "_variance.ext",
+                cwd=output_dir,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            outputs["std_img"] = _gen_fname(
+                outputs["out_file"] + "_sigma.ext",
+                cwd=output_dir,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+        else:
+            outputs["variance_img"] = _gen_fname(
+                outputs["out_file"],
+                suffix="_variance",
+                cwd=output_dir,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            outputs["std_img"] = _gen_fname(
+                outputs["out_file"],
+                suffix="_sigma",
+                cwd=output_dir,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+
+    # The mean image created if -stats option is specified ('meanvol')
+    # is missing the top and bottom slices. Therefore we only expose the
+    # mean image created by -meanvol option ('mean_reg') which isn't
+    # corrupted.
+    # Note that the same problem holds for the std and variance image.
+
+    if (inputs.mean_vol is not attrs.NOTHING) and inputs.mean_vol:
+        if LooseVersion(Info.version()) < LooseVersion("6.0.0"):
+            # FSL <6.0 outputs have .nii.gz_mean_img.nii.gz as extension
+            outputs["mean_img"] = _gen_fname(
+                outputs["out_file"] + "_mean_reg.ext",
+                cwd=output_dir,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+        else:
+            outputs["mean_img"] = _gen_fname(
+                outputs["out_file"],
+                suffix="_mean_reg",
+                cwd=output_dir,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+
+    if (inputs.save_mats is not attrs.NOTHING) and inputs.save_mats:
+        _, filename = os.path.split(outputs["out_file"])
+        matpathname = os.path.join(output_dir, filename + ".mat")
+        _, _, _, timepoints = load(inputs.in_file).shape
+        outputs["mat_file"] = []
+        for t in range(timepoints):
+            outputs["mat_file"].append(os.path.join(matpathname, "MAT_%04d" % t))
+    if (inputs.save_plots is not attrs.NOTHING) and inputs.save_plots:
+        # Note - if e.g. out_file has .nii.gz, you get .nii.gz.par,
+        # which is what mcflirt does!
+        outputs["par_file"] = outputs["out_file"] + ".par"
+    if (inputs.save_rms is not attrs.NOTHING) and inputs.save_rms:
+        outfile = outputs["out_file"]
+        outputs["rms_files"] = [outfile + "_abs.rms", outfile + "_rel.rms"]
+    return outputs
+
+
 # Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
@@ -160,62 +335,6 @@ def split_filename(fname):
     return pth, fname, ext
 
 
-# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
-def _gen_fname(
-    basename,
-    cwd=None,
-    suffix=None,
-    change_ext=True,
-    ext=None,
-    inputs=None,
-    stdout=None,
-    stderr=None,
-    output_dir=None,
-):
-    """Generate a filename based on the given parameters.
-
-    The filename will take the form: cwd/basename<suffix><ext>.
-    If change_ext is True, it will use the extensions specified in
-    <instance>inputs.output_type.
-
-    Parameters
-    ----------
-    basename : str
-        Filename to base the new filename on.
-    cwd : str
-        Path to prefix to the new filename. (default is output_dir)
-    suffix : str
-        Suffix to add to the `basename`.  (defaults is '' )
-    change_ext : bool
-        Flag to change the filename extension to the FSL output type.
-        (default True)
-
-    Returns
-    -------
-    fname : str
-        New filename based on given parameters.
-
-    """
-
-    if basename == "":
-        msg = "Unable to generate filename for command %s. " % "mcflirt"
-        msg += "basename is not set!"
-        raise ValueError(msg)
-    if cwd is None:
-        cwd = output_dir
-    if ext is None:
-        ext = Info.output_type_to_ext(inputs.output_type)
-    if change_ext:
-        if suffix:
-            suffix = "".join((suffix, ext))
-        else:
-            suffix = ext
-    if suffix is None:
-        suffix = ""
-    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
-    return fname
-
-
 # Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
@@ -345,122 +464,3 @@ def standard_image(img_name=None):
                 for filename in glob(os.path.join(stdpath, "*nii*"))
             ]
         return os.path.join(stdpath, img_name)
-
-
-# Original source at L967 of <nipype-install>/interfaces/fsl/preprocess.py
-def _gen_outfilename(inputs=None, stdout=None, stderr=None, output_dir=None):
-    out_file = inputs.out_file
-    if out_file is not attrs.NOTHING:
-        out_file = os.path.realpath(out_file)
-    if (out_file is attrs.NOTHING) and (inputs.in_file is not attrs.NOTHING):
-        out_file = _gen_fname(
-            inputs.in_file,
-            suffix="_mcf",
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-    return os.path.abspath(out_file)
-
-
-# Original source at L962 of <nipype-install>/interfaces/fsl/preprocess.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "out_file":
-        return _gen_outfilename(
-            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-        )
-    return None
-
-
-# Original source at L906 of <nipype-install>/interfaces/fsl/preprocess.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-
-    outputs["out_file"] = _gen_outfilename(
-        inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-    )
-    output_dir = os.path.dirname(outputs["out_file"])
-
-    if (inputs.stats_imgs is not attrs.NOTHING) and inputs.stats_imgs:
-        if LooseVersion(Info.version()) < LooseVersion("6.0.0"):
-            # FSL <6.0 outputs have .nii.gz_variance.nii.gz as extension
-            outputs["variance_img"] = _gen_fname(
-                outputs["out_file"] + "_variance.ext",
-                cwd=output_dir,
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-            outputs["std_img"] = _gen_fname(
-                outputs["out_file"] + "_sigma.ext",
-                cwd=output_dir,
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-        else:
-            outputs["variance_img"] = _gen_fname(
-                outputs["out_file"],
-                suffix="_variance",
-                cwd=output_dir,
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-            outputs["std_img"] = _gen_fname(
-                outputs["out_file"],
-                suffix="_sigma",
-                cwd=output_dir,
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-
-    # The mean image created if -stats option is specified ('meanvol')
-    # is missing the top and bottom slices. Therefore we only expose the
-    # mean image created by -meanvol option ('mean_reg') which isn't
-    # corrupted.
-    # Note that the same problem holds for the std and variance image.
-
-    if (inputs.mean_vol is not attrs.NOTHING) and inputs.mean_vol:
-        if LooseVersion(Info.version()) < LooseVersion("6.0.0"):
-            # FSL <6.0 outputs have .nii.gz_mean_img.nii.gz as extension
-            outputs["mean_img"] = _gen_fname(
-                outputs["out_file"] + "_mean_reg.ext",
-                cwd=output_dir,
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-        else:
-            outputs["mean_img"] = _gen_fname(
-                outputs["out_file"],
-                suffix="_mean_reg",
-                cwd=output_dir,
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-
-    if (inputs.save_mats is not attrs.NOTHING) and inputs.save_mats:
-        _, filename = os.path.split(outputs["out_file"])
-        matpathname = os.path.join(output_dir, filename + ".mat")
-        _, _, _, timepoints = load(inputs.in_file).shape
-        outputs["mat_file"] = []
-        for t in range(timepoints):
-            outputs["mat_file"].append(os.path.join(matpathname, "MAT_%04d" % t))
-    if (inputs.save_plots is not attrs.NOTHING) and inputs.save_plots:
-        # Note - if e.g. out_file has .nii.gz, you get .nii.gz.par,
-        # which is what mcflirt does!
-        outputs["par_file"] = outputs["out_file"] + ".par"
-    if (inputs.save_rms is not attrs.NOTHING) and inputs.save_rms:
-        outfile = outputs["out_file"]
-        outputs["rms_files"] = [outfile + "_abs.rms", outfile + "_rel.rms"]
-    return outputs
diff --git a/example-specs/task/nipype/fsl/mean_image_callables.py b/example-specs/task/nipype/fsl/mean_image_callables.py
index d7cc7a0f..5943cf31 100644
--- a/example-specs/task/nipype/fsl/mean_image_callables.py
+++ b/example-specs/task/nipype/fsl/mean_image_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of MeanImage.yaml"""
 
-from glob import glob
 import attrs
 import logging
 import os
 import os.path as op
+from glob import glob
 from pathlib import Path
 
 
@@ -22,42 +22,86 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
+# Original source at L61 of <nipype-install>/interfaces/fsl/maths.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )["out_file"]
+    return None
 
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
 
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
 
-            klass._version = klass.parse_version(raw_info)
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
 
-        return klass._version
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
 
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "fslmaths"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+# Original source at L51 of <nipype-install>/interfaces/fsl/maths.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = inputs.out_file
+    if inputs.out_file is attrs.NOTHING:
+        outputs["out_file"] = _gen_fname(
+            inputs.in_file,
+            suffix=_suffix,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    outputs["out_file"] = os.path.abspath(outputs["out_file"])
+    return outputs
 
 
 # Original source at L108 of <nipype-install>/utils/filemanip.py
@@ -154,6 +198,44 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
@@ -245,85 +327,3 @@ def standard_image(img_name=None):
                 for filename in glob(os.path.join(stdpath, "*nii*"))
             ]
         return os.path.join(stdpath, img_name)
-
-
-# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
-def _gen_fname(
-    basename,
-    cwd=None,
-    suffix=None,
-    change_ext=True,
-    ext=None,
-    inputs=None,
-    stdout=None,
-    stderr=None,
-    output_dir=None,
-):
-    """Generate a filename based on the given parameters.
-
-    The filename will take the form: cwd/basename<suffix><ext>.
-    If change_ext is True, it will use the extensions specified in
-    <instance>inputs.output_type.
-
-    Parameters
-    ----------
-    basename : str
-        Filename to base the new filename on.
-    cwd : str
-        Path to prefix to the new filename. (default is output_dir)
-    suffix : str
-        Suffix to add to the `basename`.  (defaults is '' )
-    change_ext : bool
-        Flag to change the filename extension to the FSL output type.
-        (default True)
-
-    Returns
-    -------
-    fname : str
-        New filename based on given parameters.
-
-    """
-
-    if basename == "":
-        msg = "Unable to generate filename for command %s. " % "fslmaths"
-        msg += "basename is not set!"
-        raise ValueError(msg)
-    if cwd is None:
-        cwd = output_dir
-    if ext is None:
-        ext = Info.output_type_to_ext(inputs.output_type)
-    if change_ext:
-        if suffix:
-            suffix = "".join((suffix, ext))
-        else:
-            suffix = ext
-    if suffix is None:
-        suffix = ""
-    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
-    return fname
-
-
-# Original source at L61 of <nipype-install>/interfaces/fsl/maths.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "out_file":
-        return _list_outputs(
-            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-        )["out_file"]
-    return None
-
-
-# Original source at L51 of <nipype-install>/interfaces/fsl/maths.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    outputs["out_file"] = inputs.out_file
-    if inputs.out_file is attrs.NOTHING:
-        outputs["out_file"] = _gen_fname(
-            inputs.in_file,
-            suffix=_suffix,
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-    outputs["out_file"] = os.path.abspath(outputs["out_file"])
-    return outputs
diff --git a/example-specs/task/nipype/fsl/median_image_callables.py b/example-specs/task/nipype/fsl/median_image_callables.py
index bb824477..ac60356b 100644
--- a/example-specs/task/nipype/fsl/median_image_callables.py
+++ b/example-specs/task/nipype/fsl/median_image_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of MedianImage.yaml"""
 
-from glob import glob
 import attrs
 import logging
 import os
 import os.path as op
+from glob import glob
 from pathlib import Path
 
 
@@ -22,42 +22,86 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
+# Original source at L61 of <nipype-install>/interfaces/fsl/maths.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )["out_file"]
+    return None
 
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
 
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
 
-            klass._version = klass.parse_version(raw_info)
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
 
-        return klass._version
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
 
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "fslmaths"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+# Original source at L51 of <nipype-install>/interfaces/fsl/maths.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = inputs.out_file
+    if inputs.out_file is attrs.NOTHING:
+        outputs["out_file"] = _gen_fname(
+            inputs.in_file,
+            suffix=_suffix,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    outputs["out_file"] = os.path.abspath(outputs["out_file"])
+    return outputs
 
 
 # Original source at L108 of <nipype-install>/utils/filemanip.py
@@ -154,6 +198,44 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
@@ -245,85 +327,3 @@ def standard_image(img_name=None):
                 for filename in glob(os.path.join(stdpath, "*nii*"))
             ]
         return os.path.join(stdpath, img_name)
-
-
-# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
-def _gen_fname(
-    basename,
-    cwd=None,
-    suffix=None,
-    change_ext=True,
-    ext=None,
-    inputs=None,
-    stdout=None,
-    stderr=None,
-    output_dir=None,
-):
-    """Generate a filename based on the given parameters.
-
-    The filename will take the form: cwd/basename<suffix><ext>.
-    If change_ext is True, it will use the extensions specified in
-    <instance>inputs.output_type.
-
-    Parameters
-    ----------
-    basename : str
-        Filename to base the new filename on.
-    cwd : str
-        Path to prefix to the new filename. (default is output_dir)
-    suffix : str
-        Suffix to add to the `basename`.  (defaults is '' )
-    change_ext : bool
-        Flag to change the filename extension to the FSL output type.
-        (default True)
-
-    Returns
-    -------
-    fname : str
-        New filename based on given parameters.
-
-    """
-
-    if basename == "":
-        msg = "Unable to generate filename for command %s. " % "fslmaths"
-        msg += "basename is not set!"
-        raise ValueError(msg)
-    if cwd is None:
-        cwd = output_dir
-    if ext is None:
-        ext = Info.output_type_to_ext(inputs.output_type)
-    if change_ext:
-        if suffix:
-            suffix = "".join((suffix, ext))
-        else:
-            suffix = ext
-    if suffix is None:
-        suffix = ""
-    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
-    return fname
-
-
-# Original source at L61 of <nipype-install>/interfaces/fsl/maths.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "out_file":
-        return _list_outputs(
-            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-        )["out_file"]
-    return None
-
-
-# Original source at L51 of <nipype-install>/interfaces/fsl/maths.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    outputs["out_file"] = inputs.out_file
-    if inputs.out_file is attrs.NOTHING:
-        outputs["out_file"] = _gen_fname(
-            inputs.in_file,
-            suffix=_suffix,
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-    outputs["out_file"] = os.path.abspath(outputs["out_file"])
-    return outputs
diff --git a/example-specs/task/nipype/fsl/melodic_callables.py b/example-specs/task/nipype/fsl/melodic_callables.py
index 291e99f7..9ab73a85 100644
--- a/example-specs/task/nipype/fsl/melodic_callables.py
+++ b/example-specs/task/nipype/fsl/melodic_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of MELODIC.yaml"""
 
-import os
 import attrs
+import os
 
 
 def out_dir_default(inputs):
diff --git a/example-specs/task/nipype/fsl/merge_callables.py b/example-specs/task/nipype/fsl/merge_callables.py
index 554cc805..efab9574 100644
--- a/example-specs/task/nipype/fsl/merge_callables.py
+++ b/example-specs/task/nipype/fsl/merge_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Merge.yaml"""
 
-from glob import glob
 import attrs
 import logging
 import os
 import os.path as op
+from glob import glob
 
 
 def merged_file_callable(output_dir, inputs, stdout, stderr):
@@ -20,6 +20,182 @@ def merged_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+# Original source at L249 of <nipype-install>/interfaces/fsl/base.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value + Info.output_type_to_ext(inputs.output_type)
+
+
+# Original source at L58 of <nipype-install>/utils/filemanip.py
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
 # Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
@@ -151,13 +327,6 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
-# Original source at L249 of <nipype-install>/interfaces/fsl/base.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    return value + Info.output_type_to_ext(inputs.output_type)
-
-
 # Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
@@ -167,172 +336,3 @@ def __init__(self, value):
 
     def __str__(self):
         return "{}".format(self.value)
-
-
-# Original source at L58 of <nipype-install>/utils/filemanip.py
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
-# Original source at L809 of <nipype-install>/interfaces/base/core.py
-def _filename_from_source(
-    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    if chain is None:
-        chain = []
-
-    trait_spec = inputs.trait(name)
-    retval = getattr(inputs, name)
-    source_ext = None
-    if (retval is attrs.NOTHING) or "%s" in retval:
-        if not trait_spec.name_source:
-            return retval
-
-        # Do not generate filename when excluded by other inputs
-        if any(
-            (getattr(inputs, field) is not attrs.NOTHING)
-            for field in trait_spec.xor or ()
-        ):
-            return retval
-
-        # Do not generate filename when required fields are missing
-        if not all(
-            (getattr(inputs, field) is not attrs.NOTHING)
-            for field in trait_spec.requires or ()
-        ):
-            return retval
-
-        if (retval is not attrs.NOTHING) and "%s" in retval:
-            name_template = retval
-        else:
-            name_template = trait_spec.name_template
-        if not name_template:
-            name_template = "%s_generated"
-
-        ns = trait_spec.name_source
-        while isinstance(ns, (list, tuple)):
-            if len(ns) > 1:
-                iflogger.warning("Only one name_source per trait is allowed")
-            ns = ns[0]
-
-        if not isinstance(ns, (str, bytes)):
-            raise ValueError(
-                "name_source of '{}' trait should be an input trait "
-                "name, but a type {} object was found".format(name, type(ns))
-            )
-
-        if getattr(inputs, ns) is not attrs.NOTHING:
-            name_source = ns
-            source = getattr(inputs, name_source)
-            while isinstance(source, list):
-                source = source[0]
-
-            # special treatment for files
-            try:
-                _, base, source_ext = split_filename(source)
-            except (AttributeError, TypeError):
-                base = source
-        else:
-            if name in chain:
-                raise NipypeInterfaceError("Mutually pointing name_sources")
-
-            chain.append(name)
-            base = _filename_from_source(
-                ns,
-                chain,
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-            if base is not attrs.NOTHING:
-                _, _, source_ext = split_filename(base)
-            else:
-                # Do not generate filename when required fields are missing
-                return retval
-
-        chain = None
-        retval = name_template % base
-        _, _, ext = split_filename(retval)
-        if trait_spec.keep_extension and (ext or source_ext):
-            if (ext is None or not ext) and source_ext:
-                retval = retval + source_ext
-        else:
-            retval = _overload_extension(
-                retval,
-                name,
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-    return retval
-
-
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
-# Original source at L891 of <nipype-install>/interfaces/base/core.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    metadata = dict(name_source=lambda t: t is not None)
-    traits = inputs.traits(**metadata)
-    if traits:
-        outputs = {}
-        for name, trait_spec in list(traits.items()):
-            out_name = name
-            if trait_spec.output_name is not None:
-                out_name = trait_spec.output_name
-            fname = _filename_from_source(
-                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-            )
-            if fname is not attrs.NOTHING:
-                outputs[out_name] = os.path.abspath(fname)
-        return outputs
diff --git a/example-specs/task/nipype/fsl/min_image_callables.py b/example-specs/task/nipype/fsl/min_image_callables.py
index c3ee5d58..9cde1b9e 100644
--- a/example-specs/task/nipype/fsl/min_image_callables.py
+++ b/example-specs/task/nipype/fsl/min_image_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of MinImage.yaml"""
 
-from glob import glob
 import attrs
 import logging
 import os
 import os.path as op
+from glob import glob
 from pathlib import Path
 
 
@@ -22,42 +22,86 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
+# Original source at L61 of <nipype-install>/interfaces/fsl/maths.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )["out_file"]
+    return None
 
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
 
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
 
-            klass._version = klass.parse_version(raw_info)
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
 
-        return klass._version
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
 
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "fslmaths"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+# Original source at L51 of <nipype-install>/interfaces/fsl/maths.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = inputs.out_file
+    if inputs.out_file is attrs.NOTHING:
+        outputs["out_file"] = _gen_fname(
+            inputs.in_file,
+            suffix=_suffix,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    outputs["out_file"] = os.path.abspath(outputs["out_file"])
+    return outputs
 
 
 # Original source at L108 of <nipype-install>/utils/filemanip.py
@@ -154,6 +198,44 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
@@ -245,85 +327,3 @@ def standard_image(img_name=None):
                 for filename in glob(os.path.join(stdpath, "*nii*"))
             ]
         return os.path.join(stdpath, img_name)
-
-
-# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
-def _gen_fname(
-    basename,
-    cwd=None,
-    suffix=None,
-    change_ext=True,
-    ext=None,
-    inputs=None,
-    stdout=None,
-    stderr=None,
-    output_dir=None,
-):
-    """Generate a filename based on the given parameters.
-
-    The filename will take the form: cwd/basename<suffix><ext>.
-    If change_ext is True, it will use the extensions specified in
-    <instance>inputs.output_type.
-
-    Parameters
-    ----------
-    basename : str
-        Filename to base the new filename on.
-    cwd : str
-        Path to prefix to the new filename. (default is output_dir)
-    suffix : str
-        Suffix to add to the `basename`.  (defaults is '' )
-    change_ext : bool
-        Flag to change the filename extension to the FSL output type.
-        (default True)
-
-    Returns
-    -------
-    fname : str
-        New filename based on given parameters.
-
-    """
-
-    if basename == "":
-        msg = "Unable to generate filename for command %s. " % "fslmaths"
-        msg += "basename is not set!"
-        raise ValueError(msg)
-    if cwd is None:
-        cwd = output_dir
-    if ext is None:
-        ext = Info.output_type_to_ext(inputs.output_type)
-    if change_ext:
-        if suffix:
-            suffix = "".join((suffix, ext))
-        else:
-            suffix = ext
-    if suffix is None:
-        suffix = ""
-    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
-    return fname
-
-
-# Original source at L61 of <nipype-install>/interfaces/fsl/maths.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "out_file":
-        return _list_outputs(
-            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-        )["out_file"]
-    return None
-
-
-# Original source at L51 of <nipype-install>/interfaces/fsl/maths.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    outputs["out_file"] = inputs.out_file
-    if inputs.out_file is attrs.NOTHING:
-        outputs["out_file"] = _gen_fname(
-            inputs.in_file,
-            suffix=_suffix,
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-    outputs["out_file"] = os.path.abspath(outputs["out_file"])
-    return outputs
diff --git a/example-specs/task/nipype/fsl/motion_outliers_callables.py b/example-specs/task/nipype/fsl/motion_outliers_callables.py
index d6436449..09bc820b 100644
--- a/example-specs/task/nipype/fsl/motion_outliers_callables.py
+++ b/example-specs/task/nipype/fsl/motion_outliers_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of MotionOutliers.yaml"""
 
-from glob import glob
 import attrs
 import logging
 import os
 import os.path as op
+from glob import glob
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -14,18 +14,18 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_file"]
 
 
-def out_metric_values_callable(output_dir, inputs, stdout, stderr):
+def out_metric_plot_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_metric_values"]
+    return outputs["out_metric_plot"]
 
 
-def out_metric_plot_callable(output_dir, inputs, stdout, stderr):
+def out_metric_values_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_metric_plot"]
+    return outputs["out_metric_values"]
 
 
 IFLOGGER = logging.getLogger("nipype.interface")
@@ -34,6 +34,182 @@ def out_metric_plot_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+# Original source at L249 of <nipype-install>/interfaces/fsl/base.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value + Info.output_type_to_ext(inputs.output_type)
+
+
+# Original source at L58 of <nipype-install>/utils/filemanip.py
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
 # Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
@@ -165,13 +341,6 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
-# Original source at L249 of <nipype-install>/interfaces/fsl/base.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    return value + Info.output_type_to_ext(inputs.output_type)
-
-
 # Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
@@ -181,172 +350,3 @@ def __init__(self, value):
 
     def __str__(self):
         return "{}".format(self.value)
-
-
-# Original source at L58 of <nipype-install>/utils/filemanip.py
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
-# Original source at L809 of <nipype-install>/interfaces/base/core.py
-def _filename_from_source(
-    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    if chain is None:
-        chain = []
-
-    trait_spec = inputs.trait(name)
-    retval = getattr(inputs, name)
-    source_ext = None
-    if (retval is attrs.NOTHING) or "%s" in retval:
-        if not trait_spec.name_source:
-            return retval
-
-        # Do not generate filename when excluded by other inputs
-        if any(
-            (getattr(inputs, field) is not attrs.NOTHING)
-            for field in trait_spec.xor or ()
-        ):
-            return retval
-
-        # Do not generate filename when required fields are missing
-        if not all(
-            (getattr(inputs, field) is not attrs.NOTHING)
-            for field in trait_spec.requires or ()
-        ):
-            return retval
-
-        if (retval is not attrs.NOTHING) and "%s" in retval:
-            name_template = retval
-        else:
-            name_template = trait_spec.name_template
-        if not name_template:
-            name_template = "%s_generated"
-
-        ns = trait_spec.name_source
-        while isinstance(ns, (list, tuple)):
-            if len(ns) > 1:
-                iflogger.warning("Only one name_source per trait is allowed")
-            ns = ns[0]
-
-        if not isinstance(ns, (str, bytes)):
-            raise ValueError(
-                "name_source of '{}' trait should be an input trait "
-                "name, but a type {} object was found".format(name, type(ns))
-            )
-
-        if getattr(inputs, ns) is not attrs.NOTHING:
-            name_source = ns
-            source = getattr(inputs, name_source)
-            while isinstance(source, list):
-                source = source[0]
-
-            # special treatment for files
-            try:
-                _, base, source_ext = split_filename(source)
-            except (AttributeError, TypeError):
-                base = source
-        else:
-            if name in chain:
-                raise NipypeInterfaceError("Mutually pointing name_sources")
-
-            chain.append(name)
-            base = _filename_from_source(
-                ns,
-                chain,
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-            if base is not attrs.NOTHING:
-                _, _, source_ext = split_filename(base)
-            else:
-                # Do not generate filename when required fields are missing
-                return retval
-
-        chain = None
-        retval = name_template % base
-        _, _, ext = split_filename(retval)
-        if trait_spec.keep_extension and (ext or source_ext):
-            if (ext is None or not ext) and source_ext:
-                retval = retval + source_ext
-        else:
-            retval = _overload_extension(
-                retval,
-                name,
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-    return retval
-
-
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
-# Original source at L891 of <nipype-install>/interfaces/base/core.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    metadata = dict(name_source=lambda t: t is not None)
-    traits = inputs.traits(**metadata)
-    if traits:
-        outputs = {}
-        for name, trait_spec in list(traits.items()):
-            out_name = name
-            if trait_spec.output_name is not None:
-                out_name = trait_spec.output_name
-            fname = _filename_from_source(
-                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-            )
-            if fname is not attrs.NOTHING:
-                outputs[out_name] = os.path.abspath(fname)
-        return outputs
diff --git a/example-specs/task/nipype/fsl/multi_image_maths_callables.py b/example-specs/task/nipype/fsl/multi_image_maths_callables.py
index db7e96d9..9b5eedbb 100644
--- a/example-specs/task/nipype/fsl/multi_image_maths_callables.py
+++ b/example-specs/task/nipype/fsl/multi_image_maths_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of MultiImageMaths.yaml"""
 
-from glob import glob
 import attrs
 import logging
 import os
 import os.path as op
+from glob import glob
 from pathlib import Path
 
 
@@ -22,42 +22,86 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
+# Original source at L61 of <nipype-install>/interfaces/fsl/maths.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )["out_file"]
+    return None
 
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
 
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
 
-            klass._version = klass.parse_version(raw_info)
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
 
-        return klass._version
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
 
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "fslmaths"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+# Original source at L51 of <nipype-install>/interfaces/fsl/maths.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = inputs.out_file
+    if inputs.out_file is attrs.NOTHING:
+        outputs["out_file"] = _gen_fname(
+            inputs.in_file,
+            suffix=_suffix,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    outputs["out_file"] = os.path.abspath(outputs["out_file"])
+    return outputs
 
 
 # Original source at L108 of <nipype-install>/utils/filemanip.py
@@ -154,6 +198,44 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
@@ -245,85 +327,3 @@ def standard_image(img_name=None):
                 for filename in glob(os.path.join(stdpath, "*nii*"))
             ]
         return os.path.join(stdpath, img_name)
-
-
-# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
-def _gen_fname(
-    basename,
-    cwd=None,
-    suffix=None,
-    change_ext=True,
-    ext=None,
-    inputs=None,
-    stdout=None,
-    stderr=None,
-    output_dir=None,
-):
-    """Generate a filename based on the given parameters.
-
-    The filename will take the form: cwd/basename<suffix><ext>.
-    If change_ext is True, it will use the extensions specified in
-    <instance>inputs.output_type.
-
-    Parameters
-    ----------
-    basename : str
-        Filename to base the new filename on.
-    cwd : str
-        Path to prefix to the new filename. (default is output_dir)
-    suffix : str
-        Suffix to add to the `basename`.  (defaults is '' )
-    change_ext : bool
-        Flag to change the filename extension to the FSL output type.
-        (default True)
-
-    Returns
-    -------
-    fname : str
-        New filename based on given parameters.
-
-    """
-
-    if basename == "":
-        msg = "Unable to generate filename for command %s. " % "fslmaths"
-        msg += "basename is not set!"
-        raise ValueError(msg)
-    if cwd is None:
-        cwd = output_dir
-    if ext is None:
-        ext = Info.output_type_to_ext(inputs.output_type)
-    if change_ext:
-        if suffix:
-            suffix = "".join((suffix, ext))
-        else:
-            suffix = ext
-    if suffix is None:
-        suffix = ""
-    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
-    return fname
-
-
-# Original source at L61 of <nipype-install>/interfaces/fsl/maths.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "out_file":
-        return _list_outputs(
-            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-        )["out_file"]
-    return None
-
-
-# Original source at L51 of <nipype-install>/interfaces/fsl/maths.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    outputs["out_file"] = inputs.out_file
-    if inputs.out_file is attrs.NOTHING:
-        outputs["out_file"] = _gen_fname(
-            inputs.in_file,
-            suffix=_suffix,
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-    outputs["out_file"] = os.path.abspath(outputs["out_file"])
-    return outputs
diff --git a/example-specs/task/nipype/fsl/multiple_regress_design_callables.py b/example-specs/task/nipype/fsl/multiple_regress_design_callables.py
index 44eeffe9..a2957096 100644
--- a/example-specs/task/nipype/fsl/multiple_regress_design_callables.py
+++ b/example-specs/task/nipype/fsl/multiple_regress_design_callables.py
@@ -1,13 +1,6 @@
 """Module to put any functions that are referred to in the "callables" section of MultipleRegressDesign.yaml"""
 
-import attrs
-
-
-def design_mat_callable(output_dir, inputs, stdout, stderr):
-    outputs = _list_outputs(
-        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
-    )
-    return outputs["design_mat"]
+import os
 
 
 def design_con_callable(output_dir, inputs, stdout, stderr):
@@ -31,7 +24,19 @@ def design_grp_callable(output_dir, inputs, stdout, stderr):
     return outputs["design_grp"]
 
 
-def _gen_filename(field, inputs, output_dir, stdout, stderr):
-    raise NotImplementedError(
-        "Could not find '_gen_filename' method in nipype.interfaces.fsl.model.MultipleRegressDesign"
+def design_mat_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
+    return outputs["design_mat"]
+
+
+# Original source at L1600 of <nipype-install>/interfaces/fsl/model.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    nfcons = sum([1 for con in inputs.contrasts if con[1] == "F"])
+    for field in list(outputs.keys()):
+        if ("fts" in field) and (nfcons == 0):
+            continue
+        outputs[field] = os.path.join(output_dir, field.replace("_", "."))
+    return outputs
diff --git a/example-specs/task/nipype/fsl/overlay_callables.py b/example-specs/task/nipype/fsl/overlay_callables.py
index f0b205ba..a56187ca 100644
--- a/example-specs/task/nipype/fsl/overlay_callables.py
+++ b/example-specs/task/nipype/fsl/overlay_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Overlay.yaml"""
 
 import attrs
+import logging
 import os
 import os.path as op
 from glob import glob
-import logging
 from pathlib import Path
 
 
@@ -22,42 +22,96 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
+# Original source at L1098 of <nipype-install>/interfaces/fsl/utils.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )["out_file"]
+    return None
 
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
 
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
 
-            klass._version = klass.parse_version(raw_info)
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
 
-        return klass._version
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
 
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "overlay"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+# Original source at L1080 of <nipype-install>/interfaces/fsl/utils.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    out_file = inputs.out_file
+    if out_file is attrs.NOTHING:
+        if (inputs.stat_image2 is not attrs.NOTHING) and (
+            (inputs.show_negative_stats is attrs.NOTHING)
+            or not inputs.show_negative_stats
+        ):
+            stem = "%s_and_%s" % (
+                split_filename(inputs.stat_image)[1],
+                split_filename(inputs.stat_image2)[1],
+            )
+        else:
+            stem = split_filename(inputs.stat_image)[1]
+        out_file = _gen_fname(
+            stem,
+            suffix="_overlay",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    outputs["out_file"] = os.path.abspath(out_file)
+    return outputs
 
 
 # Original source at L108 of <nipype-install>/utils/filemanip.py
@@ -103,6 +157,95 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L58 of <nipype-install>/utils/filemanip.py
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
@@ -194,146 +337,3 @@ def standard_image(img_name=None):
                 for filename in glob(os.path.join(stdpath, "*nii*"))
             ]
         return os.path.join(stdpath, img_name)
-
-
-# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
-def _gen_fname(
-    basename,
-    cwd=None,
-    suffix=None,
-    change_ext=True,
-    ext=None,
-    inputs=None,
-    stdout=None,
-    stderr=None,
-    output_dir=None,
-):
-    """Generate a filename based on the given parameters.
-
-    The filename will take the form: cwd/basename<suffix><ext>.
-    If change_ext is True, it will use the extensions specified in
-    <instance>inputs.output_type.
-
-    Parameters
-    ----------
-    basename : str
-        Filename to base the new filename on.
-    cwd : str
-        Path to prefix to the new filename. (default is output_dir)
-    suffix : str
-        Suffix to add to the `basename`.  (defaults is '' )
-    change_ext : bool
-        Flag to change the filename extension to the FSL output type.
-        (default True)
-
-    Returns
-    -------
-    fname : str
-        New filename based on given parameters.
-
-    """
-
-    if basename == "":
-        msg = "Unable to generate filename for command %s. " % "overlay"
-        msg += "basename is not set!"
-        raise ValueError(msg)
-    if cwd is None:
-        cwd = output_dir
-    if ext is None:
-        ext = Info.output_type_to_ext(inputs.output_type)
-    if change_ext:
-        if suffix:
-            suffix = "".join((suffix, ext))
-        else:
-            suffix = ext
-    if suffix is None:
-        suffix = ""
-    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
-    return fname
-
-
-# Original source at L58 of <nipype-install>/utils/filemanip.py
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
-# Original source at L1098 of <nipype-install>/interfaces/fsl/utils.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "out_file":
-        return _list_outputs(
-            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-        )["out_file"]
-    return None
-
-
-# Original source at L1080 of <nipype-install>/interfaces/fsl/utils.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    out_file = inputs.out_file
-    if out_file is attrs.NOTHING:
-        if (inputs.stat_image2 is not attrs.NOTHING) and (
-            (inputs.show_negative_stats is attrs.NOTHING)
-            or not inputs.show_negative_stats
-        ):
-            stem = "%s_and_%s" % (
-                split_filename(inputs.stat_image)[1],
-                split_filename(inputs.stat_image2)[1],
-            )
-        else:
-            stem = split_filename(inputs.stat_image)[1]
-        out_file = _gen_fname(
-            stem,
-            suffix="_overlay",
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-    outputs["out_file"] = os.path.abspath(out_file)
-    return outputs
diff --git a/example-specs/task/nipype/fsl/percentile_image_callables.py b/example-specs/task/nipype/fsl/percentile_image_callables.py
index f7ffb0eb..a86a925b 100644
--- a/example-specs/task/nipype/fsl/percentile_image_callables.py
+++ b/example-specs/task/nipype/fsl/percentile_image_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of PercentileImage.yaml"""
 
-from glob import glob
 import attrs
 import logging
 import os
 import os.path as op
+from glob import glob
 from pathlib import Path
 
 
@@ -22,42 +22,86 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
+# Original source at L61 of <nipype-install>/interfaces/fsl/maths.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )["out_file"]
+    return None
 
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
 
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
 
-            klass._version = klass.parse_version(raw_info)
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
 
-        return klass._version
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
 
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "fslmaths"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+# Original source at L51 of <nipype-install>/interfaces/fsl/maths.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = inputs.out_file
+    if inputs.out_file is attrs.NOTHING:
+        outputs["out_file"] = _gen_fname(
+            inputs.in_file,
+            suffix=_suffix,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    outputs["out_file"] = os.path.abspath(outputs["out_file"])
+    return outputs
 
 
 # Original source at L108 of <nipype-install>/utils/filemanip.py
@@ -154,6 +198,44 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
@@ -245,85 +327,3 @@ def standard_image(img_name=None):
                 for filename in glob(os.path.join(stdpath, "*nii*"))
             ]
         return os.path.join(stdpath, img_name)
-
-
-# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
-def _gen_fname(
-    basename,
-    cwd=None,
-    suffix=None,
-    change_ext=True,
-    ext=None,
-    inputs=None,
-    stdout=None,
-    stderr=None,
-    output_dir=None,
-):
-    """Generate a filename based on the given parameters.
-
-    The filename will take the form: cwd/basename<suffix><ext>.
-    If change_ext is True, it will use the extensions specified in
-    <instance>inputs.output_type.
-
-    Parameters
-    ----------
-    basename : str
-        Filename to base the new filename on.
-    cwd : str
-        Path to prefix to the new filename. (default is output_dir)
-    suffix : str
-        Suffix to add to the `basename`.  (defaults is '' )
-    change_ext : bool
-        Flag to change the filename extension to the FSL output type.
-        (default True)
-
-    Returns
-    -------
-    fname : str
-        New filename based on given parameters.
-
-    """
-
-    if basename == "":
-        msg = "Unable to generate filename for command %s. " % "fslmaths"
-        msg += "basename is not set!"
-        raise ValueError(msg)
-    if cwd is None:
-        cwd = output_dir
-    if ext is None:
-        ext = Info.output_type_to_ext(inputs.output_type)
-    if change_ext:
-        if suffix:
-            suffix = "".join((suffix, ext))
-        else:
-            suffix = ext
-    if suffix is None:
-        suffix = ""
-    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
-    return fname
-
-
-# Original source at L61 of <nipype-install>/interfaces/fsl/maths.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "out_file":
-        return _list_outputs(
-            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-        )["out_file"]
-    return None
-
-
-# Original source at L51 of <nipype-install>/interfaces/fsl/maths.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    outputs["out_file"] = inputs.out_file
-    if inputs.out_file is attrs.NOTHING:
-        outputs["out_file"] = _gen_fname(
-            inputs.in_file,
-            suffix=_suffix,
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-    outputs["out_file"] = os.path.abspath(outputs["out_file"])
-    return outputs
diff --git a/example-specs/task/nipype/fsl/plot_motion_params_callables.py b/example-specs/task/nipype/fsl/plot_motion_params_callables.py
index f83baec1..d632bf6d 100644
--- a/example-specs/task/nipype/fsl/plot_motion_params_callables.py
+++ b/example-specs/task/nipype/fsl/plot_motion_params_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of PlotMotionParams.yaml"""
 
+import attrs
 import os
 import os.path as op
 from pathlib import Path
-import attrs
 
 
 def out_file_default(inputs):
@@ -17,6 +17,30 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_file"]
 
 
+# Original source at L1495 of <nipype-install>/interfaces/fsl/utils.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )["out_file"]
+    return None
+
+
+# Original source at L1478 of <nipype-install>/interfaces/fsl/utils.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    out_file = inputs.out_file
+    if out_file is attrs.NOTHING:
+        if isinstance(inputs.in_file, list):
+            infile = inputs.in_file[0]
+        else:
+            infile = inputs.in_file
+        plttype = dict(rot="rot", tra="trans", dis="disp")[inputs.plot_type[:3]]
+        out_file = fname_presuffix(infile, suffix="_%s.png" % plttype, use_ext=False)
+    outputs["out_file"] = os.path.abspath(out_file)
+    return outputs
+
+
 # Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
@@ -109,27 +133,3 @@ def split_filename(fname):
         fname, ext = op.splitext(fname)
 
     return pth, fname, ext
-
-
-# Original source at L1495 of <nipype-install>/interfaces/fsl/utils.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "out_file":
-        return _list_outputs(
-            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-        )["out_file"]
-    return None
-
-
-# Original source at L1478 of <nipype-install>/interfaces/fsl/utils.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    out_file = inputs.out_file
-    if out_file is attrs.NOTHING:
-        if isinstance(inputs.in_file, list):
-            infile = inputs.in_file[0]
-        else:
-            infile = inputs.in_file
-        plttype = dict(rot="rot", tra="trans", dis="disp")[inputs.plot_type[:3]]
-        out_file = fname_presuffix(infile, suffix="_%s.png" % plttype, use_ext=False)
-    outputs["out_file"] = os.path.abspath(out_file)
-    return outputs
diff --git a/example-specs/task/nipype/fsl/plot_time_series_callables.py b/example-specs/task/nipype/fsl/plot_time_series_callables.py
index b5f405be..bd4ce1ea 100644
--- a/example-specs/task/nipype/fsl/plot_time_series_callables.py
+++ b/example-specs/task/nipype/fsl/plot_time_series_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of PlotTimeSeries.yaml"""
 
-from glob import glob
 import attrs
 import logging
 import os
 import os.path as op
+from glob import glob
 from pathlib import Path
 
 
@@ -22,42 +22,90 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
+# Original source at L1367 of <nipype-install>/interfaces/fsl/utils.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )["out_file"]
+    return None
 
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
 
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
 
-            klass._version = klass.parse_version(raw_info)
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
 
-        return klass._version
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
 
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "fsl_tsplot"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+# Original source at L1355 of <nipype-install>/interfaces/fsl/utils.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    out_file = inputs.out_file
+    if out_file is attrs.NOTHING:
+        if isinstance(inputs.in_file, list):
+            infile = inputs.in_file[0]
+        else:
+            infile = inputs.in_file
+        out_file = _gen_fname(
+            infile,
+            ext=".png",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    outputs["out_file"] = os.path.abspath(out_file)
+    return outputs
 
 
 # Original source at L108 of <nipype-install>/utils/filemanip.py
@@ -154,6 +202,44 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
@@ -245,89 +331,3 @@ def standard_image(img_name=None):
                 for filename in glob(os.path.join(stdpath, "*nii*"))
             ]
         return os.path.join(stdpath, img_name)
-
-
-# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
-def _gen_fname(
-    basename,
-    cwd=None,
-    suffix=None,
-    change_ext=True,
-    ext=None,
-    inputs=None,
-    stdout=None,
-    stderr=None,
-    output_dir=None,
-):
-    """Generate a filename based on the given parameters.
-
-    The filename will take the form: cwd/basename<suffix><ext>.
-    If change_ext is True, it will use the extensions specified in
-    <instance>inputs.output_type.
-
-    Parameters
-    ----------
-    basename : str
-        Filename to base the new filename on.
-    cwd : str
-        Path to prefix to the new filename. (default is output_dir)
-    suffix : str
-        Suffix to add to the `basename`.  (defaults is '' )
-    change_ext : bool
-        Flag to change the filename extension to the FSL output type.
-        (default True)
-
-    Returns
-    -------
-    fname : str
-        New filename based on given parameters.
-
-    """
-
-    if basename == "":
-        msg = "Unable to generate filename for command %s. " % "fsl_tsplot"
-        msg += "basename is not set!"
-        raise ValueError(msg)
-    if cwd is None:
-        cwd = output_dir
-    if ext is None:
-        ext = Info.output_type_to_ext(inputs.output_type)
-    if change_ext:
-        if suffix:
-            suffix = "".join((suffix, ext))
-        else:
-            suffix = ext
-    if suffix is None:
-        suffix = ""
-    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
-    return fname
-
-
-# Original source at L1367 of <nipype-install>/interfaces/fsl/utils.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "out_file":
-        return _list_outputs(
-            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-        )["out_file"]
-    return None
-
-
-# Original source at L1355 of <nipype-install>/interfaces/fsl/utils.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    out_file = inputs.out_file
-    if out_file is attrs.NOTHING:
-        if isinstance(inputs.in_file, list):
-            infile = inputs.in_file[0]
-        else:
-            infile = inputs.in_file
-        out_file = _gen_fname(
-            infile,
-            ext=".png",
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-    outputs["out_file"] = os.path.abspath(out_file)
-    return outputs
diff --git a/example-specs/task/nipype/fsl/power_spectrum_callables.py b/example-specs/task/nipype/fsl/power_spectrum_callables.py
index 2ab10810..126f6e6f 100644
--- a/example-specs/task/nipype/fsl/power_spectrum_callables.py
+++ b/example-specs/task/nipype/fsl/power_spectrum_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of PowerSpectrum.yaml"""
 
-from glob import glob
 import attrs
 import logging
 import os
 import os.path as op
+from glob import glob
 from pathlib import Path
 
 
@@ -22,42 +22,95 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
+# Original source at L1700 of <nipype-install>/interfaces/fsl/utils.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _gen_outfilename(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )
+    return None
 
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
 
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
 
-            klass._version = klass.parse_version(raw_info)
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
 
-        return klass._version
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
 
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "fslpspec"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+# Original source at L1689 of <nipype-install>/interfaces/fsl/utils.py
+def _gen_outfilename(inputs=None, stdout=None, stderr=None, output_dir=None):
+    out_file = inputs.out_file
+    if (out_file is attrs.NOTHING) and (inputs.in_file is not attrs.NOTHING):
+        out_file = _gen_fname(
+            inputs.in_file,
+            suffix="_ps",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    return out_file
+
+
+# Original source at L1695 of <nipype-install>/interfaces/fsl/utils.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = os.path.abspath(
+        _gen_outfilename(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )
+    )
+    return outputs
 
 
 # Original source at L108 of <nipype-install>/utils/filemanip.py
@@ -154,6 +207,44 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
@@ -245,94 +336,3 @@ def standard_image(img_name=None):
                 for filename in glob(os.path.join(stdpath, "*nii*"))
             ]
         return os.path.join(stdpath, img_name)
-
-
-# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
-def _gen_fname(
-    basename,
-    cwd=None,
-    suffix=None,
-    change_ext=True,
-    ext=None,
-    inputs=None,
-    stdout=None,
-    stderr=None,
-    output_dir=None,
-):
-    """Generate a filename based on the given parameters.
-
-    The filename will take the form: cwd/basename<suffix><ext>.
-    If change_ext is True, it will use the extensions specified in
-    <instance>inputs.output_type.
-
-    Parameters
-    ----------
-    basename : str
-        Filename to base the new filename on.
-    cwd : str
-        Path to prefix to the new filename. (default is output_dir)
-    suffix : str
-        Suffix to add to the `basename`.  (defaults is '' )
-    change_ext : bool
-        Flag to change the filename extension to the FSL output type.
-        (default True)
-
-    Returns
-    -------
-    fname : str
-        New filename based on given parameters.
-
-    """
-
-    if basename == "":
-        msg = "Unable to generate filename for command %s. " % "fslpspec"
-        msg += "basename is not set!"
-        raise ValueError(msg)
-    if cwd is None:
-        cwd = output_dir
-    if ext is None:
-        ext = Info.output_type_to_ext(inputs.output_type)
-    if change_ext:
-        if suffix:
-            suffix = "".join((suffix, ext))
-        else:
-            suffix = ext
-    if suffix is None:
-        suffix = ""
-    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
-    return fname
-
-
-# Original source at L1689 of <nipype-install>/interfaces/fsl/utils.py
-def _gen_outfilename(inputs=None, stdout=None, stderr=None, output_dir=None):
-    out_file = inputs.out_file
-    if (out_file is attrs.NOTHING) and (inputs.in_file is not attrs.NOTHING):
-        out_file = _gen_fname(
-            inputs.in_file,
-            suffix="_ps",
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-    return out_file
-
-
-# Original source at L1700 of <nipype-install>/interfaces/fsl/utils.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "out_file":
-        return _gen_outfilename(
-            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-        )
-    return None
-
-
-# Original source at L1695 of <nipype-install>/interfaces/fsl/utils.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    outputs["out_file"] = os.path.abspath(
-        _gen_outfilename(
-            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-        )
-    )
-    return outputs
diff --git a/example-specs/task/nipype/fsl/prelude_callables.py b/example-specs/task/nipype/fsl/prelude_callables.py
index 9ac5f3bb..3104d4a6 100644
--- a/example-specs/task/nipype/fsl/prelude_callables.py
+++ b/example-specs/task/nipype/fsl/prelude_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of PRELUDE.yaml"""
 
-from glob import glob
 import attrs
 import logging
 import os
 import os.path as op
+from glob import glob
 from pathlib import Path
 
 
@@ -22,42 +22,96 @@ def unwrapped_phase_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
+# Original source at L2115 of <nipype-install>/interfaces/fsl/preprocess.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "unwrapped_phase_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )["unwrapped_phase_file"]
+    return None
 
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
 
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
 
-            klass._version = klass.parse_version(raw_info)
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
 
-        return klass._version
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
 
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "prelude"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+# Original source at L2102 of <nipype-install>/interfaces/fsl/preprocess.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    out_file = inputs.unwrapped_phase_file
+    if out_file is attrs.NOTHING:
+        if inputs.phase_file is not attrs.NOTHING:
+            out_file = _gen_fname(
+                inputs.phase_file,
+                suffix="_unwrapped",
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+        elif inputs.complex_phase_file is not attrs.NOTHING:
+            out_file = _gen_fname(
+                inputs.complex_phase_file,
+                suffix="_phase_unwrapped",
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    outputs["unwrapped_phase_file"] = os.path.abspath(out_file)
+    return outputs
 
 
 # Original source at L108 of <nipype-install>/utils/filemanip.py
@@ -154,6 +208,44 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
@@ -245,95 +337,3 @@ def standard_image(img_name=None):
                 for filename in glob(os.path.join(stdpath, "*nii*"))
             ]
         return os.path.join(stdpath, img_name)
-
-
-# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
-def _gen_fname(
-    basename,
-    cwd=None,
-    suffix=None,
-    change_ext=True,
-    ext=None,
-    inputs=None,
-    stdout=None,
-    stderr=None,
-    output_dir=None,
-):
-    """Generate a filename based on the given parameters.
-
-    The filename will take the form: cwd/basename<suffix><ext>.
-    If change_ext is True, it will use the extensions specified in
-    <instance>inputs.output_type.
-
-    Parameters
-    ----------
-    basename : str
-        Filename to base the new filename on.
-    cwd : str
-        Path to prefix to the new filename. (default is output_dir)
-    suffix : str
-        Suffix to add to the `basename`.  (defaults is '' )
-    change_ext : bool
-        Flag to change the filename extension to the FSL output type.
-        (default True)
-
-    Returns
-    -------
-    fname : str
-        New filename based on given parameters.
-
-    """
-
-    if basename == "":
-        msg = "Unable to generate filename for command %s. " % "prelude"
-        msg += "basename is not set!"
-        raise ValueError(msg)
-    if cwd is None:
-        cwd = output_dir
-    if ext is None:
-        ext = Info.output_type_to_ext(inputs.output_type)
-    if change_ext:
-        if suffix:
-            suffix = "".join((suffix, ext))
-        else:
-            suffix = ext
-    if suffix is None:
-        suffix = ""
-    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
-    return fname
-
-
-# Original source at L2115 of <nipype-install>/interfaces/fsl/preprocess.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "unwrapped_phase_file":
-        return _list_outputs(
-            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-        )["unwrapped_phase_file"]
-    return None
-
-
-# Original source at L2102 of <nipype-install>/interfaces/fsl/preprocess.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    out_file = inputs.unwrapped_phase_file
-    if out_file is attrs.NOTHING:
-        if inputs.phase_file is not attrs.NOTHING:
-            out_file = _gen_fname(
-                inputs.phase_file,
-                suffix="_unwrapped",
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-        elif inputs.complex_phase_file is not attrs.NOTHING:
-            out_file = _gen_fname(
-                inputs.complex_phase_file,
-                suffix="_phase_unwrapped",
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-    outputs["unwrapped_phase_file"] = os.path.abspath(out_file)
-    return outputs
diff --git a/example-specs/task/nipype/fsl/prepare_fieldmap_callables.py b/example-specs/task/nipype/fsl/prepare_fieldmap_callables.py
index b9827e22..9b4e146c 100644
--- a/example-specs/task/nipype/fsl/prepare_fieldmap_callables.py
+++ b/example-specs/task/nipype/fsl/prepare_fieldmap_callables.py
@@ -1,7 +1,5 @@
 """Module to put any functions that are referred to in the "callables" section of PrepareFieldmap.yaml"""
 
-import attrs
-
 
 def out_fieldmap_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
diff --git a/example-specs/task/nipype/fsl/prob_track_x2_callables.py b/example-specs/task/nipype/fsl/prob_track_x2_callables.py
index fc6670b2..8d008b42 100644
--- a/example-specs/task/nipype/fsl/prob_track_x2_callables.py
+++ b/example-specs/task/nipype/fsl/prob_track_x2_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of ProbTrackX2.yaml"""
 
-from glob import glob
 import attrs
 import logging
 import os
 import os.path as op
+from glob import glob
 from pathlib import Path
 
 
@@ -12,18 +12,18 @@ def out_dir_default(inputs):
     return _gen_filename("out_dir", inputs=inputs)
 
 
-def network_matrix_callable(output_dir, inputs, stdout, stderr):
+def fdt_paths_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["network_matrix"]
+    return outputs["fdt_paths"]
 
 
-def matrix1_dot_callable(output_dir, inputs, stdout, stderr):
+def log_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["matrix1_dot"]
+    return outputs["log"]
 
 
 def lookup_tractspace_callable(output_dir, inputs, stdout, stderr):
@@ -33,39 +33,39 @@ def lookup_tractspace_callable(output_dir, inputs, stdout, stderr):
     return outputs["lookup_tractspace"]
 
 
-def matrix2_dot_callable(output_dir, inputs, stdout, stderr):
+def matrix1_dot_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["matrix2_dot"]
+    return outputs["matrix1_dot"]
 
 
-def matrix3_dot_callable(output_dir, inputs, stdout, stderr):
+def matrix2_dot_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["matrix3_dot"]
+    return outputs["matrix2_dot"]
 
 
-def log_callable(output_dir, inputs, stdout, stderr):
+def matrix3_dot_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["log"]
+    return outputs["matrix3_dot"]
 
 
-def fdt_paths_callable(output_dir, inputs, stdout, stderr):
+def network_matrix_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["fdt_paths"]
+    return outputs["network_matrix"]
 
 
-def way_total_callable(output_dir, inputs, stdout, stderr):
+def particle_files_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["way_total"]
+    return outputs["particle_files"]
 
 
 def targets_callable(output_dir, inputs, stdout, stderr):
@@ -75,52 +75,115 @@ def targets_callable(output_dir, inputs, stdout, stderr):
     return outputs["targets"]
 
 
-def particle_files_callable(output_dir, inputs, stdout, stderr):
+def way_total_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["particle_files"]
+    return outputs["way_total"]
 
 
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
+# Original source at L921 of <nipype-install>/interfaces/fsl/dti.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_dir":
+        return output_dir
+    elif name == "mode":
+        if isinstance(inputs.seed, list) and isinstance(inputs.seed[0], list):
+            return "simple"
+        else:
+            return "seedmask"
 
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
 
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
 
-            klass._version = klass.parse_version(raw_info)
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
 
-        return klass._version
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
 
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "probtrackx2"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+# Original source at L1070 of <nipype-install>/interfaces/fsl/dti.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_fsl_dti__ProbTrackX___list_outputs()
+
+    if inputs.out_dir is attrs.NOTHING:
+        out_dir = output_dir
+    else:
+        out_dir = inputs.out_dir
+
+    outputs["way_total"] = os.path.abspath(os.path.join(out_dir, "waytotal"))
+
+    if inputs.omatrix1 is not attrs.NOTHING:
+        outputs["network_matrix"] = os.path.abspath(
+            os.path.join(out_dir, "matrix_seeds_to_all_targets")
+        )
+        outputs["matrix1_dot"] = os.path.abspath(
+            os.path.join(out_dir, "fdt_matrix1.dot")
+        )
+
+    if inputs.omatrix2 is not attrs.NOTHING:
+        outputs["lookup_tractspace"] = os.path.abspath(
+            os.path.join(out_dir, "lookup_tractspace_fdt_matrix2.nii.gz")
+        )
+        outputs["matrix2_dot"] = os.path.abspath(
+            os.path.join(out_dir, "fdt_matrix2.dot")
+        )
+
+    if inputs.omatrix3 is not attrs.NOTHING:
+        outputs["matrix3_dot"] = os.path.abspath(
+            os.path.join(out_dir, "fdt_matrix3.dot")
+        )
+    return outputs
 
 
 # Original source at L108 of <nipype-install>/utils/filemanip.py
@@ -166,6 +229,80 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L871 of <nipype-install>/interfaces/fsl/dti.py
+def nipype_interfaces_fsl_dti__ProbTrackX___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = {}
+    if inputs.out_dir is attrs.NOTHING:
+        out_dir = _gen_filename(
+            "out_dir",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    else:
+        out_dir = inputs.out_dir
+
+    outputs["log"] = os.path.abspath(os.path.join(out_dir, "probtrackx.log"))
+    # outputs['way_total'] = os.path.abspath(os.path.join(out_dir,
+    #                                                    'waytotal'))
+    if inputs.opd is True is not attrs.NOTHING:
+        if isinstance(inputs.seed, list) and isinstance(inputs.seed[0], list):
+            outputs["fdt_paths"] = []
+            for seed in inputs.seed:
+                outputs["fdt_paths"].append(
+                    os.path.abspath(
+                        _gen_fname(
+                            ("fdt_paths_%s" % ("_".join([str(s) for s in seed]))),
+                            cwd=out_dir,
+                            suffix="",
+                            inputs=inputs,
+                            stdout=stdout,
+                            stderr=stderr,
+                            output_dir=output_dir,
+                        )
+                    )
+                )
+        else:
+            outputs["fdt_paths"] = os.path.abspath(
+                _gen_fname(
+                    "fdt_paths",
+                    cwd=out_dir,
+                    suffix="",
+                    inputs=inputs,
+                    stdout=stdout,
+                    stderr=stderr,
+                    output_dir=output_dir,
+                )
+            )
+
+    # handle seeds-to-target output files
+    if inputs.target_masks is not attrs.NOTHING:
+        outputs["targets"] = []
+        for target in inputs.target_masks:
+            outputs["targets"].append(
+                os.path.abspath(
+                    _gen_fname(
+                        "seeds_to_" + os.path.split(target)[1],
+                        cwd=out_dir,
+                        suffix="",
+                        inputs=inputs,
+                        stdout=stdout,
+                        stderr=stderr,
+                        output_dir=output_dir,
+                    )
+                )
+            )
+    if (inputs.verbose is not attrs.NOTHING) and inputs.verbose == 2:
+        outputs["particle_files"] = [
+            os.path.abspath(os.path.join(out_dir, "particle%d" % i))
+            for i in range(inputs.n_samples)
+        ]
+    return outputs
+
+
 # Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
@@ -217,6 +354,44 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
@@ -308,178 +483,3 @@ def standard_image(img_name=None):
                 for filename in glob(os.path.join(stdpath, "*nii*"))
             ]
         return os.path.join(stdpath, img_name)
-
-
-# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
-def _gen_fname(
-    basename,
-    cwd=None,
-    suffix=None,
-    change_ext=True,
-    ext=None,
-    inputs=None,
-    stdout=None,
-    stderr=None,
-    output_dir=None,
-):
-    """Generate a filename based on the given parameters.
-
-    The filename will take the form: cwd/basename<suffix><ext>.
-    If change_ext is True, it will use the extensions specified in
-    <instance>inputs.output_type.
-
-    Parameters
-    ----------
-    basename : str
-        Filename to base the new filename on.
-    cwd : str
-        Path to prefix to the new filename. (default is output_dir)
-    suffix : str
-        Suffix to add to the `basename`.  (defaults is '' )
-    change_ext : bool
-        Flag to change the filename extension to the FSL output type.
-        (default True)
-
-    Returns
-    -------
-    fname : str
-        New filename based on given parameters.
-
-    """
-
-    if basename == "":
-        msg = "Unable to generate filename for command %s. " % "probtrackx2"
-        msg += "basename is not set!"
-        raise ValueError(msg)
-    if cwd is None:
-        cwd = output_dir
-    if ext is None:
-        ext = Info.output_type_to_ext(inputs.output_type)
-    if change_ext:
-        if suffix:
-            suffix = "".join((suffix, ext))
-        else:
-            suffix = ext
-    if suffix is None:
-        suffix = ""
-    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
-    return fname
-
-
-# Original source at L871 of <nipype-install>/interfaces/fsl/dti.py
-def nipype_interfaces_fsl_dti__ProbTrackX___list_outputs(
-    inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    outputs = {}
-    if inputs.out_dir is attrs.NOTHING:
-        out_dir = _gen_filename(
-            "out_dir",
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-    else:
-        out_dir = inputs.out_dir
-
-    outputs["log"] = os.path.abspath(os.path.join(out_dir, "probtrackx.log"))
-    # outputs['way_total'] = os.path.abspath(os.path.join(out_dir,
-    #                                                    'waytotal'))
-    if inputs.opd is True is not attrs.NOTHING:
-        if isinstance(inputs.seed, list) and isinstance(inputs.seed[0], list):
-            outputs["fdt_paths"] = []
-            for seed in inputs.seed:
-                outputs["fdt_paths"].append(
-                    os.path.abspath(
-                        _gen_fname(
-                            ("fdt_paths_%s" % ("_".join([str(s) for s in seed]))),
-                            cwd=out_dir,
-                            suffix="",
-                            inputs=inputs,
-                            stdout=stdout,
-                            stderr=stderr,
-                            output_dir=output_dir,
-                        )
-                    )
-                )
-        else:
-            outputs["fdt_paths"] = os.path.abspath(
-                _gen_fname(
-                    "fdt_paths",
-                    cwd=out_dir,
-                    suffix="",
-                    inputs=inputs,
-                    stdout=stdout,
-                    stderr=stderr,
-                    output_dir=output_dir,
-                )
-            )
-
-    # handle seeds-to-target output files
-    if inputs.target_masks is not attrs.NOTHING:
-        outputs["targets"] = []
-        for target in inputs.target_masks:
-            outputs["targets"].append(
-                os.path.abspath(
-                    _gen_fname(
-                        "seeds_to_" + os.path.split(target)[1],
-                        cwd=out_dir,
-                        suffix="",
-                        inputs=inputs,
-                        stdout=stdout,
-                        stderr=stderr,
-                        output_dir=output_dir,
-                    )
-                )
-            )
-    if (inputs.verbose is not attrs.NOTHING) and inputs.verbose == 2:
-        outputs["particle_files"] = [
-            os.path.abspath(os.path.join(out_dir, "particle%d" % i))
-            for i in range(inputs.n_samples)
-        ]
-    return outputs
-
-
-# Original source at L921 of <nipype-install>/interfaces/fsl/dti.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "out_dir":
-        return output_dir
-    elif name == "mode":
-        if isinstance(inputs.seed, list) and isinstance(inputs.seed[0], list):
-            return "simple"
-        else:
-            return "seedmask"
-
-
-# Original source at L1070 of <nipype-install>/interfaces/fsl/dti.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = nipype_interfaces_fsl_dti__ProbTrackX___list_outputs()
-
-    if inputs.out_dir is attrs.NOTHING:
-        out_dir = output_dir
-    else:
-        out_dir = inputs.out_dir
-
-    outputs["way_total"] = os.path.abspath(os.path.join(out_dir, "waytotal"))
-
-    if inputs.omatrix1 is not attrs.NOTHING:
-        outputs["network_matrix"] = os.path.abspath(
-            os.path.join(out_dir, "matrix_seeds_to_all_targets")
-        )
-        outputs["matrix1_dot"] = os.path.abspath(
-            os.path.join(out_dir, "fdt_matrix1.dot")
-        )
-
-    if inputs.omatrix2 is not attrs.NOTHING:
-        outputs["lookup_tractspace"] = os.path.abspath(
-            os.path.join(out_dir, "lookup_tractspace_fdt_matrix2.nii.gz")
-        )
-        outputs["matrix2_dot"] = os.path.abspath(
-            os.path.join(out_dir, "fdt_matrix2.dot")
-        )
-
-    if inputs.omatrix3 is not attrs.NOTHING:
-        outputs["matrix3_dot"] = os.path.abspath(
-            os.path.join(out_dir, "fdt_matrix3.dot")
-        )
-    return outputs
diff --git a/example-specs/task/nipype/fsl/prob_track_x_callables.py b/example-specs/task/nipype/fsl/prob_track_x_callables.py
index 62a05006..7c8c61f3 100644
--- a/example-specs/task/nipype/fsl/prob_track_x_callables.py
+++ b/example-specs/task/nipype/fsl/prob_track_x_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of ProbTrackX.yaml"""
 
-from glob import glob
 import attrs
 import logging
 import os
 import os.path as op
+from glob import glob
 from pathlib import Path
 
 
@@ -16,25 +16,25 @@ def out_dir_default(inputs):
     return _gen_filename("out_dir", inputs=inputs)
 
 
-def log_callable(output_dir, inputs, stdout, stderr):
+def fdt_paths_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["log"]
+    return outputs["fdt_paths"]
 
 
-def fdt_paths_callable(output_dir, inputs, stdout, stderr):
+def log_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["fdt_paths"]
+    return outputs["log"]
 
 
-def way_total_callable(output_dir, inputs, stdout, stderr):
+def particle_files_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["way_total"]
+    return outputs["particle_files"]
 
 
 def targets_callable(output_dir, inputs, stdout, stderr):
@@ -44,52 +44,153 @@ def targets_callable(output_dir, inputs, stdout, stderr):
     return outputs["targets"]
 
 
-def particle_files_callable(output_dir, inputs, stdout, stderr):
+def way_total_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["particle_files"]
+    return outputs["way_total"]
 
 
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
+# Original source at L921 of <nipype-install>/interfaces/fsl/dti.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_dir":
+        return output_dir
+    elif name == "mode":
+        if isinstance(inputs.seed, list) and isinstance(inputs.seed[0], list):
+            return "simple"
+        else:
+            return "seedmask"
 
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
 
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
 
-            klass._version = klass.parse_version(raw_info)
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
 
-        return klass._version
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
 
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "probtrackx"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+# Original source at L871 of <nipype-install>/interfaces/fsl/dti.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    if inputs.out_dir is attrs.NOTHING:
+        out_dir = _gen_filename(
+            "out_dir",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    else:
+        out_dir = inputs.out_dir
+
+    outputs["log"] = os.path.abspath(os.path.join(out_dir, "probtrackx.log"))
+    # outputs['way_total'] = os.path.abspath(os.path.join(out_dir,
+    #                                                    'waytotal'))
+    if inputs.opd is True is not attrs.NOTHING:
+        if isinstance(inputs.seed, list) and isinstance(inputs.seed[0], list):
+            outputs["fdt_paths"] = []
+            for seed in inputs.seed:
+                outputs["fdt_paths"].append(
+                    os.path.abspath(
+                        _gen_fname(
+                            ("fdt_paths_%s" % ("_".join([str(s) for s in seed]))),
+                            cwd=out_dir,
+                            suffix="",
+                            inputs=inputs,
+                            stdout=stdout,
+                            stderr=stderr,
+                            output_dir=output_dir,
+                        )
+                    )
+                )
+        else:
+            outputs["fdt_paths"] = os.path.abspath(
+                _gen_fname(
+                    "fdt_paths",
+                    cwd=out_dir,
+                    suffix="",
+                    inputs=inputs,
+                    stdout=stdout,
+                    stderr=stderr,
+                    output_dir=output_dir,
+                )
+            )
+
+    # handle seeds-to-target output files
+    if inputs.target_masks is not attrs.NOTHING:
+        outputs["targets"] = []
+        for target in inputs.target_masks:
+            outputs["targets"].append(
+                os.path.abspath(
+                    _gen_fname(
+                        "seeds_to_" + os.path.split(target)[1],
+                        cwd=out_dir,
+                        suffix="",
+                        inputs=inputs,
+                        stdout=stdout,
+                        stderr=stderr,
+                        output_dir=output_dir,
+                    )
+                )
+            )
+    if (inputs.verbose is not attrs.NOTHING) and inputs.verbose == 2:
+        outputs["particle_files"] = [
+            os.path.abspath(os.path.join(out_dir, "particle%d" % i))
+            for i in range(inputs.n_samples)
+        ]
+    return outputs
 
 
 # Original source at L108 of <nipype-install>/utils/filemanip.py
@@ -186,6 +287,44 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
@@ -277,142 +416,3 @@ def standard_image(img_name=None):
                 for filename in glob(os.path.join(stdpath, "*nii*"))
             ]
         return os.path.join(stdpath, img_name)
-
-
-# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
-def _gen_fname(
-    basename,
-    cwd=None,
-    suffix=None,
-    change_ext=True,
-    ext=None,
-    inputs=None,
-    stdout=None,
-    stderr=None,
-    output_dir=None,
-):
-    """Generate a filename based on the given parameters.
-
-    The filename will take the form: cwd/basename<suffix><ext>.
-    If change_ext is True, it will use the extensions specified in
-    <instance>inputs.output_type.
-
-    Parameters
-    ----------
-    basename : str
-        Filename to base the new filename on.
-    cwd : str
-        Path to prefix to the new filename. (default is output_dir)
-    suffix : str
-        Suffix to add to the `basename`.  (defaults is '' )
-    change_ext : bool
-        Flag to change the filename extension to the FSL output type.
-        (default True)
-
-    Returns
-    -------
-    fname : str
-        New filename based on given parameters.
-
-    """
-
-    if basename == "":
-        msg = "Unable to generate filename for command %s. " % "probtrackx"
-        msg += "basename is not set!"
-        raise ValueError(msg)
-    if cwd is None:
-        cwd = output_dir
-    if ext is None:
-        ext = Info.output_type_to_ext(inputs.output_type)
-    if change_ext:
-        if suffix:
-            suffix = "".join((suffix, ext))
-        else:
-            suffix = ext
-    if suffix is None:
-        suffix = ""
-    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
-    return fname
-
-
-# Original source at L921 of <nipype-install>/interfaces/fsl/dti.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "out_dir":
-        return output_dir
-    elif name == "mode":
-        if isinstance(inputs.seed, list) and isinstance(inputs.seed[0], list):
-            return "simple"
-        else:
-            return "seedmask"
-
-
-# Original source at L871 of <nipype-install>/interfaces/fsl/dti.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    if inputs.out_dir is attrs.NOTHING:
-        out_dir = _gen_filename(
-            "out_dir",
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-    else:
-        out_dir = inputs.out_dir
-
-    outputs["log"] = os.path.abspath(os.path.join(out_dir, "probtrackx.log"))
-    # outputs['way_total'] = os.path.abspath(os.path.join(out_dir,
-    #                                                    'waytotal'))
-    if inputs.opd is True is not attrs.NOTHING:
-        if isinstance(inputs.seed, list) and isinstance(inputs.seed[0], list):
-            outputs["fdt_paths"] = []
-            for seed in inputs.seed:
-                outputs["fdt_paths"].append(
-                    os.path.abspath(
-                        _gen_fname(
-                            ("fdt_paths_%s" % ("_".join([str(s) for s in seed]))),
-                            cwd=out_dir,
-                            suffix="",
-                            inputs=inputs,
-                            stdout=stdout,
-                            stderr=stderr,
-                            output_dir=output_dir,
-                        )
-                    )
-                )
-        else:
-            outputs["fdt_paths"] = os.path.abspath(
-                _gen_fname(
-                    "fdt_paths",
-                    cwd=out_dir,
-                    suffix="",
-                    inputs=inputs,
-                    stdout=stdout,
-                    stderr=stderr,
-                    output_dir=output_dir,
-                )
-            )
-
-    # handle seeds-to-target output files
-    if inputs.target_masks is not attrs.NOTHING:
-        outputs["targets"] = []
-        for target in inputs.target_masks:
-            outputs["targets"].append(
-                os.path.abspath(
-                    _gen_fname(
-                        "seeds_to_" + os.path.split(target)[1],
-                        cwd=out_dir,
-                        suffix="",
-                        inputs=inputs,
-                        stdout=stdout,
-                        stderr=stderr,
-                        output_dir=output_dir,
-                    )
-                )
-            )
-    if (inputs.verbose is not attrs.NOTHING) and inputs.verbose == 2:
-        outputs["particle_files"] = [
-            os.path.abspath(os.path.join(out_dir, "particle%d" % i))
-            for i in range(inputs.n_samples)
-        ]
-    return outputs
diff --git a/example-specs/task/nipype/fsl/proj_thresh_callables.py b/example-specs/task/nipype/fsl/proj_thresh_callables.py
index cdede2b6..40ea989d 100644
--- a/example-specs/task/nipype/fsl/proj_thresh_callables.py
+++ b/example-specs/task/nipype/fsl/proj_thresh_callables.py
@@ -1,10 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of ProjThresh.yaml"""
 
-import attrs
-from glob import glob
 import logging
 import os
 import os.path as op
+from glob import glob
 from pathlib import Path
 
 
@@ -18,42 +17,85 @@ def out_files_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
 
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
 
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
 
-            klass._version = klass.parse_version(raw_info)
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
 
-        return klass._version
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
 
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "proj_thresh"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+# Original source at L1268 of <nipype-install>/interfaces/fsl/dti.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_files"] = []
+    for name in inputs.in_files:
+        cwd, base_name = os.path.split(name)
+        outputs["out_files"].append(
+            _gen_fname(
+                base_name,
+                cwd=cwd,
+                suffix="_proj_seg_thr_{}".format(inputs.threshold),
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+        )
+    return outputs
 
 
 # Original source at L108 of <nipype-install>/utils/filemanip.py
@@ -150,6 +192,44 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
@@ -241,84 +321,3 @@ def standard_image(img_name=None):
                 for filename in glob(os.path.join(stdpath, "*nii*"))
             ]
         return os.path.join(stdpath, img_name)
-
-
-# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
-def _gen_fname(
-    basename,
-    cwd=None,
-    suffix=None,
-    change_ext=True,
-    ext=None,
-    inputs=None,
-    stdout=None,
-    stderr=None,
-    output_dir=None,
-):
-    """Generate a filename based on the given parameters.
-
-    The filename will take the form: cwd/basename<suffix><ext>.
-    If change_ext is True, it will use the extensions specified in
-    <instance>inputs.output_type.
-
-    Parameters
-    ----------
-    basename : str
-        Filename to base the new filename on.
-    cwd : str
-        Path to prefix to the new filename. (default is output_dir)
-    suffix : str
-        Suffix to add to the `basename`.  (defaults is '' )
-    change_ext : bool
-        Flag to change the filename extension to the FSL output type.
-        (default True)
-
-    Returns
-    -------
-    fname : str
-        New filename based on given parameters.
-
-    """
-
-    if basename == "":
-        msg = "Unable to generate filename for command %s. " % "proj_thresh"
-        msg += "basename is not set!"
-        raise ValueError(msg)
-    if cwd is None:
-        cwd = output_dir
-    if ext is None:
-        ext = Info.output_type_to_ext(inputs.output_type)
-    if change_ext:
-        if suffix:
-            suffix = "".join((suffix, ext))
-        else:
-            suffix = ext
-    if suffix is None:
-        suffix = ""
-    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
-    return fname
-
-
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
-# Original source at L1268 of <nipype-install>/interfaces/fsl/dti.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    outputs["out_files"] = []
-    for name in inputs.in_files:
-        cwd, base_name = os.path.split(name)
-        outputs["out_files"].append(
-            _gen_fname(
-                base_name,
-                cwd=cwd,
-                suffix="_proj_seg_thr_{}".format(inputs.threshold),
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-        )
-    return outputs
diff --git a/example-specs/task/nipype/fsl/randomise_callables.py b/example-specs/task/nipype/fsl/randomise_callables.py
index 65a93db7..635bd2c6 100644
--- a/example-specs/task/nipype/fsl/randomise_callables.py
+++ b/example-specs/task/nipype/fsl/randomise_callables.py
@@ -1,94 +1,187 @@
 """Module to put any functions that are referred to in the "callables" section of Randomise.yaml"""
 
-import attrs
-from glob import glob
 import logging
 import os
 import os.path as op
+from glob import glob
 from pathlib import Path
 
 
-def tstat_files_callable(output_dir, inputs, stdout, stderr):
+def f_corrected_p_files_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["tstat_files"]
+    return outputs["f_corrected_p_files"]
 
 
-def fstat_files_callable(output_dir, inputs, stdout, stderr):
+def f_p_files_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["fstat_files"]
+    return outputs["f_p_files"]
 
 
-def t_p_files_callable(output_dir, inputs, stdout, stderr):
+def fstat_files_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["t_p_files"]
+    return outputs["fstat_files"]
 
 
-def f_p_files_callable(output_dir, inputs, stdout, stderr):
+def t_corrected_p_files_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["f_p_files"]
+    return outputs["t_corrected_p_files"]
 
 
-def t_corrected_p_files_callable(output_dir, inputs, stdout, stderr):
+def t_p_files_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["t_corrected_p_files"]
+    return outputs["t_p_files"]
 
 
-def f_corrected_p_files_callable(output_dir, inputs, stdout, stderr):
+def tstat_files_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["f_corrected_p_files"]
+    return outputs["tstat_files"]
 
 
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
 
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
 
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
 
-            klass._version = klass.parse_version(raw_info)
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
 
-        return klass._version
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
 
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "randomise"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+# Original source at L2322 of <nipype-install>/interfaces/fsl/model.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["tstat_files"] = glob(
+        _gen_fname(
+            "%s_tstat*.nii" % inputs.base_name,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    )
+    outputs["fstat_files"] = glob(
+        _gen_fname(
+            "%s_fstat*.nii" % inputs.base_name,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    )
+    prefix = False
+    if inputs.tfce or inputs.tfce2D:
+        prefix = "tfce"
+    elif inputs.vox_p_values:
+        prefix = "vox"
+    elif inputs.c_thresh or inputs.f_c_thresh:
+        prefix = "clustere"
+    elif inputs.cm_thresh or inputs.f_cm_thresh:
+        prefix = "clusterm"
+    if prefix:
+        outputs["t_p_files"] = glob(
+            _gen_fname(
+                "%s_%s_p_tstat*" % (inputs.base_name, prefix),
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+        )
+        outputs["t_corrected_p_files"] = glob(
+            _gen_fname(
+                "%s_%s_corrp_tstat*.nii" % (inputs.base_name, prefix),
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+        )
+
+        outputs["f_p_files"] = glob(
+            _gen_fname(
+                "%s_%s_p_fstat*.nii" % (inputs.base_name, prefix),
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+        )
+        outputs["f_corrected_p_files"] = glob(
+            _gen_fname(
+                "%s_%s_corrp_fstat*.nii" % (inputs.base_name, prefix),
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+        )
+    return outputs
 
 
 # Original source at L108 of <nipype-install>/utils/filemanip.py
@@ -185,6 +278,44 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
@@ -276,135 +407,3 @@ def standard_image(img_name=None):
                 for filename in glob(os.path.join(stdpath, "*nii*"))
             ]
         return os.path.join(stdpath, img_name)
-
-
-# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
-def _gen_fname(
-    basename,
-    cwd=None,
-    suffix=None,
-    change_ext=True,
-    ext=None,
-    inputs=None,
-    stdout=None,
-    stderr=None,
-    output_dir=None,
-):
-    """Generate a filename based on the given parameters.
-
-    The filename will take the form: cwd/basename<suffix><ext>.
-    If change_ext is True, it will use the extensions specified in
-    <instance>inputs.output_type.
-
-    Parameters
-    ----------
-    basename : str
-        Filename to base the new filename on.
-    cwd : str
-        Path to prefix to the new filename. (default is output_dir)
-    suffix : str
-        Suffix to add to the `basename`.  (defaults is '' )
-    change_ext : bool
-        Flag to change the filename extension to the FSL output type.
-        (default True)
-
-    Returns
-    -------
-    fname : str
-        New filename based on given parameters.
-
-    """
-
-    if basename == "":
-        msg = "Unable to generate filename for command %s. " % "randomise"
-        msg += "basename is not set!"
-        raise ValueError(msg)
-    if cwd is None:
-        cwd = output_dir
-    if ext is None:
-        ext = Info.output_type_to_ext(inputs.output_type)
-    if change_ext:
-        if suffix:
-            suffix = "".join((suffix, ext))
-        else:
-            suffix = ext
-    if suffix is None:
-        suffix = ""
-    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
-    return fname
-
-
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
-# Original source at L2322 of <nipype-install>/interfaces/fsl/model.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    outputs["tstat_files"] = glob(
-        _gen_fname(
-            "%s_tstat*.nii" % inputs.base_name,
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-    )
-    outputs["fstat_files"] = glob(
-        _gen_fname(
-            "%s_fstat*.nii" % inputs.base_name,
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-    )
-    prefix = False
-    if inputs.tfce or inputs.tfce2D:
-        prefix = "tfce"
-    elif inputs.vox_p_values:
-        prefix = "vox"
-    elif inputs.c_thresh or inputs.f_c_thresh:
-        prefix = "clustere"
-    elif inputs.cm_thresh or inputs.f_cm_thresh:
-        prefix = "clusterm"
-    if prefix:
-        outputs["t_p_files"] = glob(
-            _gen_fname(
-                "%s_%s_p_tstat*" % (inputs.base_name, prefix),
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-        )
-        outputs["t_corrected_p_files"] = glob(
-            _gen_fname(
-                "%s_%s_corrp_tstat*.nii" % (inputs.base_name, prefix),
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-        )
-
-        outputs["f_p_files"] = glob(
-            _gen_fname(
-                "%s_%s_p_fstat*.nii" % (inputs.base_name, prefix),
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-        )
-        outputs["f_corrected_p_files"] = glob(
-            _gen_fname(
-                "%s_%s_corrp_fstat*.nii" % (inputs.base_name, prefix),
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-        )
-    return outputs
diff --git a/example-specs/task/nipype/fsl/reorient_2_std_callables.py b/example-specs/task/nipype/fsl/reorient_2_std_callables.py
index 85773a63..dcfa528e 100644
--- a/example-specs/task/nipype/fsl/reorient_2_std_callables.py
+++ b/example-specs/task/nipype/fsl/reorient_2_std_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Reorient2Std.yaml"""
 
-from glob import glob
 import attrs
 import logging
 import os
 import os.path as op
+from glob import glob
 from pathlib import Path
 
 
@@ -22,42 +22,90 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
+# Original source at L1784 of <nipype-install>/interfaces/fsl/utils.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _gen_fname(
+            inputs.in_file,
+            suffix="_reoriented",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    return None
 
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
 
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
 
-            klass._version = klass.parse_version(raw_info)
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
 
-        return klass._version
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
 
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "fslreorient2std"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+# Original source at L1789 of <nipype-install>/interfaces/fsl/utils.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    if inputs.out_file is attrs.NOTHING:
+        outputs["out_file"] = _gen_filename(
+            "out_file",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    else:
+        outputs["out_file"] = os.path.abspath(inputs.out_file)
+    return outputs
 
 
 # Original source at L108 of <nipype-install>/utils/filemanip.py
@@ -154,6 +202,44 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
@@ -245,89 +331,3 @@ def standard_image(img_name=None):
                 for filename in glob(os.path.join(stdpath, "*nii*"))
             ]
         return os.path.join(stdpath, img_name)
-
-
-# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
-def _gen_fname(
-    basename,
-    cwd=None,
-    suffix=None,
-    change_ext=True,
-    ext=None,
-    inputs=None,
-    stdout=None,
-    stderr=None,
-    output_dir=None,
-):
-    """Generate a filename based on the given parameters.
-
-    The filename will take the form: cwd/basename<suffix><ext>.
-    If change_ext is True, it will use the extensions specified in
-    <instance>inputs.output_type.
-
-    Parameters
-    ----------
-    basename : str
-        Filename to base the new filename on.
-    cwd : str
-        Path to prefix to the new filename. (default is output_dir)
-    suffix : str
-        Suffix to add to the `basename`.  (defaults is '' )
-    change_ext : bool
-        Flag to change the filename extension to the FSL output type.
-        (default True)
-
-    Returns
-    -------
-    fname : str
-        New filename based on given parameters.
-
-    """
-
-    if basename == "":
-        msg = "Unable to generate filename for command %s. " % "fslreorient2std"
-        msg += "basename is not set!"
-        raise ValueError(msg)
-    if cwd is None:
-        cwd = output_dir
-    if ext is None:
-        ext = Info.output_type_to_ext(inputs.output_type)
-    if change_ext:
-        if suffix:
-            suffix = "".join((suffix, ext))
-        else:
-            suffix = ext
-    if suffix is None:
-        suffix = ""
-    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
-    return fname
-
-
-# Original source at L1784 of <nipype-install>/interfaces/fsl/utils.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "out_file":
-        return _gen_fname(
-            inputs.in_file,
-            suffix="_reoriented",
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-    return None
-
-
-# Original source at L1789 of <nipype-install>/interfaces/fsl/utils.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    if inputs.out_file is attrs.NOTHING:
-        outputs["out_file"] = _gen_filename(
-            "out_file",
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-    else:
-        outputs["out_file"] = os.path.abspath(inputs.out_file)
-    return outputs
diff --git a/example-specs/task/nipype/fsl/robust_fov_callables.py b/example-specs/task/nipype/fsl/robust_fov_callables.py
index 0c62186e..f9cce332 100644
--- a/example-specs/task/nipype/fsl/robust_fov_callables.py
+++ b/example-specs/task/nipype/fsl/robust_fov_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of RobustFOV.yaml"""
 
-from glob import glob
 import attrs
 import logging
 import os
 import os.path as op
+from glob import glob
 
 
 def out_roi_callable(output_dir, inputs, stdout, stderr):
@@ -27,6 +27,182 @@ def out_transform_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+# Original source at L249 of <nipype-install>/interfaces/fsl/base.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value + Info.output_type_to_ext(inputs.output_type)
+
+
+# Original source at L58 of <nipype-install>/utils/filemanip.py
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
 # Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
@@ -158,13 +334,6 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
-# Original source at L249 of <nipype-install>/interfaces/fsl/base.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    return value + Info.output_type_to_ext(inputs.output_type)
-
-
 # Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
@@ -174,172 +343,3 @@ def __init__(self, value):
 
     def __str__(self):
         return "{}".format(self.value)
-
-
-# Original source at L58 of <nipype-install>/utils/filemanip.py
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
-# Original source at L809 of <nipype-install>/interfaces/base/core.py
-def _filename_from_source(
-    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    if chain is None:
-        chain = []
-
-    trait_spec = inputs.trait(name)
-    retval = getattr(inputs, name)
-    source_ext = None
-    if (retval is attrs.NOTHING) or "%s" in retval:
-        if not trait_spec.name_source:
-            return retval
-
-        # Do not generate filename when excluded by other inputs
-        if any(
-            (getattr(inputs, field) is not attrs.NOTHING)
-            for field in trait_spec.xor or ()
-        ):
-            return retval
-
-        # Do not generate filename when required fields are missing
-        if not all(
-            (getattr(inputs, field) is not attrs.NOTHING)
-            for field in trait_spec.requires or ()
-        ):
-            return retval
-
-        if (retval is not attrs.NOTHING) and "%s" in retval:
-            name_template = retval
-        else:
-            name_template = trait_spec.name_template
-        if not name_template:
-            name_template = "%s_generated"
-
-        ns = trait_spec.name_source
-        while isinstance(ns, (list, tuple)):
-            if len(ns) > 1:
-                iflogger.warning("Only one name_source per trait is allowed")
-            ns = ns[0]
-
-        if not isinstance(ns, (str, bytes)):
-            raise ValueError(
-                "name_source of '{}' trait should be an input trait "
-                "name, but a type {} object was found".format(name, type(ns))
-            )
-
-        if getattr(inputs, ns) is not attrs.NOTHING:
-            name_source = ns
-            source = getattr(inputs, name_source)
-            while isinstance(source, list):
-                source = source[0]
-
-            # special treatment for files
-            try:
-                _, base, source_ext = split_filename(source)
-            except (AttributeError, TypeError):
-                base = source
-        else:
-            if name in chain:
-                raise NipypeInterfaceError("Mutually pointing name_sources")
-
-            chain.append(name)
-            base = _filename_from_source(
-                ns,
-                chain,
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-            if base is not attrs.NOTHING:
-                _, _, source_ext = split_filename(base)
-            else:
-                # Do not generate filename when required fields are missing
-                return retval
-
-        chain = None
-        retval = name_template % base
-        _, _, ext = split_filename(retval)
-        if trait_spec.keep_extension and (ext or source_ext):
-            if (ext is None or not ext) and source_ext:
-                retval = retval + source_ext
-        else:
-            retval = _overload_extension(
-                retval,
-                name,
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-    return retval
-
-
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
-# Original source at L891 of <nipype-install>/interfaces/base/core.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    metadata = dict(name_source=lambda t: t is not None)
-    traits = inputs.traits(**metadata)
-    if traits:
-        outputs = {}
-        for name, trait_spec in list(traits.items()):
-            out_name = name
-            if trait_spec.output_name is not None:
-                out_name = trait_spec.output_name
-            fname = _filename_from_source(
-                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-            )
-            if fname is not attrs.NOTHING:
-                outputs[out_name] = os.path.abspath(fname)
-        return outputs
diff --git a/example-specs/task/nipype/fsl/sig_loss_callables.py b/example-specs/task/nipype/fsl/sig_loss_callables.py
index 35783a3f..18d0a40d 100644
--- a/example-specs/task/nipype/fsl/sig_loss_callables.py
+++ b/example-specs/task/nipype/fsl/sig_loss_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of SigLoss.yaml"""
 
-from glob import glob
 import attrs
 import logging
 import os
 import os.path as op
+from glob import glob
 from pathlib import Path
 
 
@@ -22,42 +22,85 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
+# Original source at L1750 of <nipype-install>/interfaces/fsl/utils.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )["out_file"]
+    return None
 
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
 
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
 
-            klass._version = klass.parse_version(raw_info)
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
 
-        return klass._version
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
 
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "sigloss"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+# Original source at L1741 of <nipype-install>/interfaces/fsl/utils.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = inputs.out_file
+    if (outputs["out_file"] is attrs.NOTHING) and (inputs.in_file is not attrs.NOTHING):
+        outputs["out_file"] = _gen_fname(
+            inputs.in_file,
+            suffix="_sigloss",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    return outputs
 
 
 # Original source at L108 of <nipype-install>/utils/filemanip.py
@@ -154,6 +197,44 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
@@ -245,84 +326,3 @@ def standard_image(img_name=None):
                 for filename in glob(os.path.join(stdpath, "*nii*"))
             ]
         return os.path.join(stdpath, img_name)
-
-
-# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
-def _gen_fname(
-    basename,
-    cwd=None,
-    suffix=None,
-    change_ext=True,
-    ext=None,
-    inputs=None,
-    stdout=None,
-    stderr=None,
-    output_dir=None,
-):
-    """Generate a filename based on the given parameters.
-
-    The filename will take the form: cwd/basename<suffix><ext>.
-    If change_ext is True, it will use the extensions specified in
-    <instance>inputs.output_type.
-
-    Parameters
-    ----------
-    basename : str
-        Filename to base the new filename on.
-    cwd : str
-        Path to prefix to the new filename. (default is output_dir)
-    suffix : str
-        Suffix to add to the `basename`.  (defaults is '' )
-    change_ext : bool
-        Flag to change the filename extension to the FSL output type.
-        (default True)
-
-    Returns
-    -------
-    fname : str
-        New filename based on given parameters.
-
-    """
-
-    if basename == "":
-        msg = "Unable to generate filename for command %s. " % "sigloss"
-        msg += "basename is not set!"
-        raise ValueError(msg)
-    if cwd is None:
-        cwd = output_dir
-    if ext is None:
-        ext = Info.output_type_to_ext(inputs.output_type)
-    if change_ext:
-        if suffix:
-            suffix = "".join((suffix, ext))
-        else:
-            suffix = ext
-    if suffix is None:
-        suffix = ""
-    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
-    return fname
-
-
-# Original source at L1750 of <nipype-install>/interfaces/fsl/utils.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "out_file":
-        return _list_outputs(
-            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-        )["out_file"]
-    return None
-
-
-# Original source at L1741 of <nipype-install>/interfaces/fsl/utils.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    outputs["out_file"] = inputs.out_file
-    if (outputs["out_file"] is attrs.NOTHING) and (inputs.in_file is not attrs.NOTHING):
-        outputs["out_file"] = _gen_fname(
-            inputs.in_file,
-            suffix="_sigloss",
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-    return outputs
diff --git a/example-specs/task/nipype/fsl/slice_callables.py b/example-specs/task/nipype/fsl/slice_callables.py
index 1bf6c5ac..d6fc97ac 100644
--- a/example-specs/task/nipype/fsl/slice_callables.py
+++ b/example-specs/task/nipype/fsl/slice_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Slice.yaml"""
 
 import attrs
-from glob import glob
 import logging
 import os
 import os.path as op
+from glob import glob
 from pathlib import Path
 
 
@@ -23,6 +23,130 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L305 of <nipype-install>/interfaces/fsl/utils.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    """Create a Bunch which contains all possible files generated
+    by running the interface.  Some files are always generated, others
+    depending on which ``inputs`` options are set.
+
+    Returns
+    -------
+
+    outputs : Bunch object
+        Bunch object containing all possible files generated by
+        interface object.
+
+        If None, file was not generated
+        Else, contains path, filename of generated outputfile
+
+    """
+    outputs = {}
+    ext = Info.output_type_to_ext(inputs.output_type)
+    suffix = "_slice_*" + ext
+    if inputs.out_base_name is not attrs.NOTHING:
+        fname_template = os.path.abspath(inputs.out_base_name + suffix)
+    else:
+        fname_template = fname_presuffix(inputs.in_file, suffix=suffix, use_ext=False)
+
+    outputs["out_files"] = sorted(glob(fname_template))
+
+    return outputs
+
+
+# Original source at L108 of <nipype-install>/utils/filemanip.py
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
+# Original source at L58 of <nipype-install>/utils/filemanip.py
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
 # Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
@@ -152,127 +276,3 @@ def standard_image(img_name=None):
                 for filename in glob(os.path.join(stdpath, "*nii*"))
             ]
         return os.path.join(stdpath, img_name)
-
-
-# Original source at L108 of <nipype-install>/utils/filemanip.py
-def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
-    """Manipulates path and name of input filename
-
-    Parameters
-    ----------
-    fname : string
-        A filename (may or may not include path)
-    prefix : string
-        Characters to prepend to the filename
-    suffix : string
-        Characters to append to the filename
-    newpath : string
-        Path to replace the path of the input fname
-    use_ext : boolean
-        If True (default), appends the extension of the original file
-        to the output name.
-
-    Returns
-    -------
-    Absolute path of the modified filename
-
-    >>> from nipype.utils.filemanip import fname_presuffix
-    >>> fname = 'foo.nii.gz'
-    >>> fname_presuffix(fname,'pre','post','/tmp')
-    '/tmp/prefoopost.nii.gz'
-
-    >>> from nipype.interfaces.base import attrs.NOTHING
-    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
-            fname_presuffix(fname, 'pre', 'post')
-    True
-
-    """
-    pth, fname, ext = split_filename(fname)
-    if not use_ext:
-        ext = ""
-
-    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
-    if newpath:
-        pth = op.abspath(newpath)
-    return op.join(pth, prefix + fname + suffix + ext)
-
-
-# Original source at L58 of <nipype-install>/utils/filemanip.py
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
-# Original source at L305 of <nipype-install>/interfaces/fsl/utils.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    """Create a Bunch which contains all possible files generated
-    by running the interface.  Some files are always generated, others
-    depending on which ``inputs`` options are set.
-
-    Returns
-    -------
-
-    outputs : Bunch object
-        Bunch object containing all possible files generated by
-        interface object.
-
-        If None, file was not generated
-        Else, contains path, filename of generated outputfile
-
-    """
-    outputs = {}
-    ext = Info.output_type_to_ext(inputs.output_type)
-    suffix = "_slice_*" + ext
-    if inputs.out_base_name is not attrs.NOTHING:
-        fname_template = os.path.abspath(inputs.out_base_name + suffix)
-    else:
-        fname_template = fname_presuffix(inputs.in_file, suffix=suffix, use_ext=False)
-
-    outputs["out_files"] = sorted(glob(fname_template))
-
-    return outputs
diff --git a/example-specs/task/nipype/fsl/slice_timer_callables.py b/example-specs/task/nipype/fsl/slice_timer_callables.py
index 763745b3..4e3d44c5 100644
--- a/example-specs/task/nipype/fsl/slice_timer_callables.py
+++ b/example-specs/task/nipype/fsl/slice_timer_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of SliceTimer.yaml"""
 
-from glob import glob
 import attrs
 import logging
 import os
 import os.path as op
+from glob import glob
 from pathlib import Path
 
 
@@ -22,42 +22,86 @@ def slice_time_corrected_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
+# Original source at L1578 of <nipype-install>/interfaces/fsl/preprocess.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )["slice_time_corrected_file"]
+    return None
 
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
 
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
 
-            klass._version = klass.parse_version(raw_info)
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
 
-        return klass._version
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
 
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "slicetimer"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+# Original source at L1570 of <nipype-install>/interfaces/fsl/preprocess.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    out_file = inputs.out_file
+    if out_file is attrs.NOTHING:
+        out_file = _gen_fname(
+            inputs.in_file,
+            suffix="_st",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    outputs["slice_time_corrected_file"] = os.path.abspath(out_file)
+    return outputs
 
 
 # Original source at L108 of <nipype-install>/utils/filemanip.py
@@ -154,6 +198,44 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
@@ -245,85 +327,3 @@ def standard_image(img_name=None):
                 for filename in glob(os.path.join(stdpath, "*nii*"))
             ]
         return os.path.join(stdpath, img_name)
-
-
-# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
-def _gen_fname(
-    basename,
-    cwd=None,
-    suffix=None,
-    change_ext=True,
-    ext=None,
-    inputs=None,
-    stdout=None,
-    stderr=None,
-    output_dir=None,
-):
-    """Generate a filename based on the given parameters.
-
-    The filename will take the form: cwd/basename<suffix><ext>.
-    If change_ext is True, it will use the extensions specified in
-    <instance>inputs.output_type.
-
-    Parameters
-    ----------
-    basename : str
-        Filename to base the new filename on.
-    cwd : str
-        Path to prefix to the new filename. (default is output_dir)
-    suffix : str
-        Suffix to add to the `basename`.  (defaults is '' )
-    change_ext : bool
-        Flag to change the filename extension to the FSL output type.
-        (default True)
-
-    Returns
-    -------
-    fname : str
-        New filename based on given parameters.
-
-    """
-
-    if basename == "":
-        msg = "Unable to generate filename for command %s. " % "slicetimer"
-        msg += "basename is not set!"
-        raise ValueError(msg)
-    if cwd is None:
-        cwd = output_dir
-    if ext is None:
-        ext = Info.output_type_to_ext(inputs.output_type)
-    if change_ext:
-        if suffix:
-            suffix = "".join((suffix, ext))
-        else:
-            suffix = ext
-    if suffix is None:
-        suffix = ""
-    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
-    return fname
-
-
-# Original source at L1578 of <nipype-install>/interfaces/fsl/preprocess.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "out_file":
-        return _list_outputs(
-            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-        )["slice_time_corrected_file"]
-    return None
-
-
-# Original source at L1570 of <nipype-install>/interfaces/fsl/preprocess.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    out_file = inputs.out_file
-    if out_file is attrs.NOTHING:
-        out_file = _gen_fname(
-            inputs.in_file,
-            suffix="_st",
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-    outputs["slice_time_corrected_file"] = os.path.abspath(out_file)
-    return outputs
diff --git a/example-specs/task/nipype/fsl/slicer_callables.py b/example-specs/task/nipype/fsl/slicer_callables.py
index 24ec841d..f7ee3c2e 100644
--- a/example-specs/task/nipype/fsl/slicer_callables.py
+++ b/example-specs/task/nipype/fsl/slicer_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Slicer.yaml"""
 
-from glob import glob
 import attrs
 import logging
 import os
 import os.path as op
+from glob import glob
 from pathlib import Path
 
 
@@ -22,42 +22,86 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
+# Original source at L1246 of <nipype-install>/interfaces/fsl/utils.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )["out_file"]
+    return None
 
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
 
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
 
-            klass._version = klass.parse_version(raw_info)
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
 
-        return klass._version
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
 
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "slicer"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+# Original source at L1238 of <nipype-install>/interfaces/fsl/utils.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    out_file = inputs.out_file
+    if out_file is attrs.NOTHING:
+        out_file = _gen_fname(
+            inputs.in_file,
+            ext=".png",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    outputs["out_file"] = os.path.abspath(out_file)
+    return outputs
 
 
 # Original source at L108 of <nipype-install>/utils/filemanip.py
@@ -154,6 +198,44 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
@@ -245,85 +327,3 @@ def standard_image(img_name=None):
                 for filename in glob(os.path.join(stdpath, "*nii*"))
             ]
         return os.path.join(stdpath, img_name)
-
-
-# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
-def _gen_fname(
-    basename,
-    cwd=None,
-    suffix=None,
-    change_ext=True,
-    ext=None,
-    inputs=None,
-    stdout=None,
-    stderr=None,
-    output_dir=None,
-):
-    """Generate a filename based on the given parameters.
-
-    The filename will take the form: cwd/basename<suffix><ext>.
-    If change_ext is True, it will use the extensions specified in
-    <instance>inputs.output_type.
-
-    Parameters
-    ----------
-    basename : str
-        Filename to base the new filename on.
-    cwd : str
-        Path to prefix to the new filename. (default is output_dir)
-    suffix : str
-        Suffix to add to the `basename`.  (defaults is '' )
-    change_ext : bool
-        Flag to change the filename extension to the FSL output type.
-        (default True)
-
-    Returns
-    -------
-    fname : str
-        New filename based on given parameters.
-
-    """
-
-    if basename == "":
-        msg = "Unable to generate filename for command %s. " % "slicer"
-        msg += "basename is not set!"
-        raise ValueError(msg)
-    if cwd is None:
-        cwd = output_dir
-    if ext is None:
-        ext = Info.output_type_to_ext(inputs.output_type)
-    if change_ext:
-        if suffix:
-            suffix = "".join((suffix, ext))
-        else:
-            suffix = ext
-    if suffix is None:
-        suffix = ""
-    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
-    return fname
-
-
-# Original source at L1246 of <nipype-install>/interfaces/fsl/utils.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "out_file":
-        return _list_outputs(
-            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-        )["out_file"]
-    return None
-
-
-# Original source at L1238 of <nipype-install>/interfaces/fsl/utils.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    out_file = inputs.out_file
-    if out_file is attrs.NOTHING:
-        out_file = _gen_fname(
-            inputs.in_file,
-            ext=".png",
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-    outputs["out_file"] = os.path.abspath(out_file)
-    return outputs
diff --git a/example-specs/task/nipype/fsl/smm_callables.py b/example-specs/task/nipype/fsl/smm_callables.py
index d8088423..c3df01d8 100644
--- a/example-specs/task/nipype/fsl/smm_callables.py
+++ b/example-specs/task/nipype/fsl/smm_callables.py
@@ -1,73 +1,130 @@
 """Module to put any functions that are referred to in the "callables" section of SMM.yaml"""
 
-from glob import glob
 import attrs
 import logging
 import os
 import os.path as op
+from glob import glob
 from pathlib import Path
 
 
-def null_p_map_callable(output_dir, inputs, stdout, stderr):
+def activation_p_map_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["null_p_map"]
+    return outputs["activation_p_map"]
 
 
-def activation_p_map_callable(output_dir, inputs, stdout, stderr):
+def deactivation_p_map_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["activation_p_map"]
+    return outputs["deactivation_p_map"]
 
 
-def deactivation_p_map_callable(output_dir, inputs, stdout, stderr):
+def null_p_map_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["deactivation_p_map"]
+    return outputs["null_p_map"]
 
 
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
 
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
 
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
 
-            klass._version = klass.parse_version(raw_info)
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
 
-        return klass._version
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
 
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "mm --ld=logdir"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+# Original source at L1650 of <nipype-install>/interfaces/fsl/model.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    # TODO get the true logdir from the stdout
+    outputs["null_p_map"] = _gen_fname(
+        basename="w1_mean",
+        cwd="logdir",
+        inputs=inputs,
+        stdout=stdout,
+        stderr=stderr,
+        output_dir=output_dir,
+    )
+    outputs["activation_p_map"] = _gen_fname(
+        basename="w2_mean",
+        cwd="logdir",
+        inputs=inputs,
+        stdout=stdout,
+        stderr=stderr,
+        output_dir=output_dir,
+    )
+    if (
+        inputs.no_deactivation_class is attrs.NOTHING
+    ) or not inputs.no_deactivation_class:
+        outputs["deactivation_p_map"] = _gen_fname(
+            basename="w3_mean",
+            cwd="logdir",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    return outputs
 
 
 # Original source at L108 of <nipype-install>/utils/filemanip.py
@@ -164,6 +221,44 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
@@ -255,98 +350,3 @@ def standard_image(img_name=None):
                 for filename in glob(os.path.join(stdpath, "*nii*"))
             ]
         return os.path.join(stdpath, img_name)
-
-
-# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
-def _gen_fname(
-    basename,
-    cwd=None,
-    suffix=None,
-    change_ext=True,
-    ext=None,
-    inputs=None,
-    stdout=None,
-    stderr=None,
-    output_dir=None,
-):
-    """Generate a filename based on the given parameters.
-
-    The filename will take the form: cwd/basename<suffix><ext>.
-    If change_ext is True, it will use the extensions specified in
-    <instance>inputs.output_type.
-
-    Parameters
-    ----------
-    basename : str
-        Filename to base the new filename on.
-    cwd : str
-        Path to prefix to the new filename. (default is output_dir)
-    suffix : str
-        Suffix to add to the `basename`.  (defaults is '' )
-    change_ext : bool
-        Flag to change the filename extension to the FSL output type.
-        (default True)
-
-    Returns
-    -------
-    fname : str
-        New filename based on given parameters.
-
-    """
-
-    if basename == "":
-        msg = "Unable to generate filename for command %s. " % "mm --ld=logdir"
-        msg += "basename is not set!"
-        raise ValueError(msg)
-    if cwd is None:
-        cwd = output_dir
-    if ext is None:
-        ext = Info.output_type_to_ext(inputs.output_type)
-    if change_ext:
-        if suffix:
-            suffix = "".join((suffix, ext))
-        else:
-            suffix = ext
-    if suffix is None:
-        suffix = ""
-    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
-    return fname
-
-
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
-# Original source at L1650 of <nipype-install>/interfaces/fsl/model.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    # TODO get the true logdir from the stdout
-    outputs["null_p_map"] = _gen_fname(
-        basename="w1_mean",
-        cwd="logdir",
-        inputs=inputs,
-        stdout=stdout,
-        stderr=stderr,
-        output_dir=output_dir,
-    )
-    outputs["activation_p_map"] = _gen_fname(
-        basename="w2_mean",
-        cwd="logdir",
-        inputs=inputs,
-        stdout=stdout,
-        stderr=stderr,
-        output_dir=output_dir,
-    )
-    if (
-        inputs.no_deactivation_class is attrs.NOTHING
-    ) or not inputs.no_deactivation_class:
-        outputs["deactivation_p_map"] = _gen_fname(
-            basename="w3_mean",
-            cwd="logdir",
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-    return outputs
diff --git a/example-specs/task/nipype/fsl/smooth_callables.py b/example-specs/task/nipype/fsl/smooth_callables.py
index 02d927d5..6854c24d 100644
--- a/example-specs/task/nipype/fsl/smooth_callables.py
+++ b/example-specs/task/nipype/fsl/smooth_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Smooth.yaml"""
 
-from glob import glob
 import attrs
 import logging
 import os
 import os.path as op
+from glob import glob
 
 
 def smoothed_file_callable(output_dir, inputs, stdout, stderr):
@@ -20,6 +20,182 @@ def smoothed_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+# Original source at L249 of <nipype-install>/interfaces/fsl/base.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value + Info.output_type_to_ext(inputs.output_type)
+
+
+# Original source at L58 of <nipype-install>/utils/filemanip.py
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
 # Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
@@ -151,13 +327,6 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
-# Original source at L249 of <nipype-install>/interfaces/fsl/base.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    return value + Info.output_type_to_ext(inputs.output_type)
-
-
 # Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
@@ -167,172 +336,3 @@ def __init__(self, value):
 
     def __str__(self):
         return "{}".format(self.value)
-
-
-# Original source at L58 of <nipype-install>/utils/filemanip.py
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
-# Original source at L809 of <nipype-install>/interfaces/base/core.py
-def _filename_from_source(
-    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    if chain is None:
-        chain = []
-
-    trait_spec = inputs.trait(name)
-    retval = getattr(inputs, name)
-    source_ext = None
-    if (retval is attrs.NOTHING) or "%s" in retval:
-        if not trait_spec.name_source:
-            return retval
-
-        # Do not generate filename when excluded by other inputs
-        if any(
-            (getattr(inputs, field) is not attrs.NOTHING)
-            for field in trait_spec.xor or ()
-        ):
-            return retval
-
-        # Do not generate filename when required fields are missing
-        if not all(
-            (getattr(inputs, field) is not attrs.NOTHING)
-            for field in trait_spec.requires or ()
-        ):
-            return retval
-
-        if (retval is not attrs.NOTHING) and "%s" in retval:
-            name_template = retval
-        else:
-            name_template = trait_spec.name_template
-        if not name_template:
-            name_template = "%s_generated"
-
-        ns = trait_spec.name_source
-        while isinstance(ns, (list, tuple)):
-            if len(ns) > 1:
-                iflogger.warning("Only one name_source per trait is allowed")
-            ns = ns[0]
-
-        if not isinstance(ns, (str, bytes)):
-            raise ValueError(
-                "name_source of '{}' trait should be an input trait "
-                "name, but a type {} object was found".format(name, type(ns))
-            )
-
-        if getattr(inputs, ns) is not attrs.NOTHING:
-            name_source = ns
-            source = getattr(inputs, name_source)
-            while isinstance(source, list):
-                source = source[0]
-
-            # special treatment for files
-            try:
-                _, base, source_ext = split_filename(source)
-            except (AttributeError, TypeError):
-                base = source
-        else:
-            if name in chain:
-                raise NipypeInterfaceError("Mutually pointing name_sources")
-
-            chain.append(name)
-            base = _filename_from_source(
-                ns,
-                chain,
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-            if base is not attrs.NOTHING:
-                _, _, source_ext = split_filename(base)
-            else:
-                # Do not generate filename when required fields are missing
-                return retval
-
-        chain = None
-        retval = name_template % base
-        _, _, ext = split_filename(retval)
-        if trait_spec.keep_extension and (ext or source_ext):
-            if (ext is None or not ext) and source_ext:
-                retval = retval + source_ext
-        else:
-            retval = _overload_extension(
-                retval,
-                name,
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-    return retval
-
-
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
-# Original source at L891 of <nipype-install>/interfaces/base/core.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    metadata = dict(name_source=lambda t: t is not None)
-    traits = inputs.traits(**metadata)
-    if traits:
-        outputs = {}
-        for name, trait_spec in list(traits.items()):
-            out_name = name
-            if trait_spec.output_name is not None:
-                out_name = trait_spec.output_name
-            fname = _filename_from_source(
-                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-            )
-            if fname is not attrs.NOTHING:
-                outputs[out_name] = os.path.abspath(fname)
-        return outputs
diff --git a/example-specs/task/nipype/fsl/smooth_estimate_callables.py b/example-specs/task/nipype/fsl/smooth_estimate_callables.py
index 028d9e1e..967d1601 100644
--- a/example-specs/task/nipype/fsl/smooth_estimate_callables.py
+++ b/example-specs/task/nipype/fsl/smooth_estimate_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of SmoothEstimate.yaml"""
 
-from glob import glob
 import attrs
 import logging
 import os
 import os.path as op
+from glob import glob
 
 
 def dlh_callable(output_dir, inputs, stdout, stderr):
@@ -14,18 +14,18 @@ def dlh_callable(output_dir, inputs, stdout, stderr):
     return outputs["dlh"]
 
 
-def volume_callable(output_dir, inputs, stdout, stderr):
+def resels_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["volume"]
+    return outputs["resels"]
 
 
-def resels_callable(output_dir, inputs, stdout, stderr):
+def volume_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["resels"]
+    return outputs["volume"]
 
 
 IFLOGGER = logging.getLogger("nipype.interface")
@@ -34,6 +34,182 @@ def resels_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+# Original source at L249 of <nipype-install>/interfaces/fsl/base.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value + Info.output_type_to_ext(inputs.output_type)
+
+
+# Original source at L58 of <nipype-install>/utils/filemanip.py
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
 # Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
@@ -165,13 +341,6 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
-# Original source at L249 of <nipype-install>/interfaces/fsl/base.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    return value + Info.output_type_to_ext(inputs.output_type)
-
-
 # Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
@@ -181,172 +350,3 @@ def __init__(self, value):
 
     def __str__(self):
         return "{}".format(self.value)
-
-
-# Original source at L58 of <nipype-install>/utils/filemanip.py
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
-# Original source at L809 of <nipype-install>/interfaces/base/core.py
-def _filename_from_source(
-    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    if chain is None:
-        chain = []
-
-    trait_spec = inputs.trait(name)
-    retval = getattr(inputs, name)
-    source_ext = None
-    if (retval is attrs.NOTHING) or "%s" in retval:
-        if not trait_spec.name_source:
-            return retval
-
-        # Do not generate filename when excluded by other inputs
-        if any(
-            (getattr(inputs, field) is not attrs.NOTHING)
-            for field in trait_spec.xor or ()
-        ):
-            return retval
-
-        # Do not generate filename when required fields are missing
-        if not all(
-            (getattr(inputs, field) is not attrs.NOTHING)
-            for field in trait_spec.requires or ()
-        ):
-            return retval
-
-        if (retval is not attrs.NOTHING) and "%s" in retval:
-            name_template = retval
-        else:
-            name_template = trait_spec.name_template
-        if not name_template:
-            name_template = "%s_generated"
-
-        ns = trait_spec.name_source
-        while isinstance(ns, (list, tuple)):
-            if len(ns) > 1:
-                iflogger.warning("Only one name_source per trait is allowed")
-            ns = ns[0]
-
-        if not isinstance(ns, (str, bytes)):
-            raise ValueError(
-                "name_source of '{}' trait should be an input trait "
-                "name, but a type {} object was found".format(name, type(ns))
-            )
-
-        if getattr(inputs, ns) is not attrs.NOTHING:
-            name_source = ns
-            source = getattr(inputs, name_source)
-            while isinstance(source, list):
-                source = source[0]
-
-            # special treatment for files
-            try:
-                _, base, source_ext = split_filename(source)
-            except (AttributeError, TypeError):
-                base = source
-        else:
-            if name in chain:
-                raise NipypeInterfaceError("Mutually pointing name_sources")
-
-            chain.append(name)
-            base = _filename_from_source(
-                ns,
-                chain,
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-            if base is not attrs.NOTHING:
-                _, _, source_ext = split_filename(base)
-            else:
-                # Do not generate filename when required fields are missing
-                return retval
-
-        chain = None
-        retval = name_template % base
-        _, _, ext = split_filename(retval)
-        if trait_spec.keep_extension and (ext or source_ext):
-            if (ext is None or not ext) and source_ext:
-                retval = retval + source_ext
-        else:
-            retval = _overload_extension(
-                retval,
-                name,
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-    return retval
-
-
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
-# Original source at L891 of <nipype-install>/interfaces/base/core.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    metadata = dict(name_source=lambda t: t is not None)
-    traits = inputs.traits(**metadata)
-    if traits:
-        outputs = {}
-        for name, trait_spec in list(traits.items()):
-            out_name = name
-            if trait_spec.output_name is not None:
-                out_name = trait_spec.output_name
-            fname = _filename_from_source(
-                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-            )
-            if fname is not attrs.NOTHING:
-                outputs[out_name] = os.path.abspath(fname)
-        return outputs
diff --git a/example-specs/task/nipype/fsl/spatial_filter_callables.py b/example-specs/task/nipype/fsl/spatial_filter_callables.py
index 7dd09c7a..87995013 100644
--- a/example-specs/task/nipype/fsl/spatial_filter_callables.py
+++ b/example-specs/task/nipype/fsl/spatial_filter_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of SpatialFilter.yaml"""
 
-from glob import glob
 import attrs
 import logging
 import os
 import os.path as op
+from glob import glob
 from pathlib import Path
 
 
@@ -22,42 +22,86 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
+# Original source at L61 of <nipype-install>/interfaces/fsl/maths.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )["out_file"]
+    return None
 
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
 
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
 
-            klass._version = klass.parse_version(raw_info)
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
 
-        return klass._version
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
 
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "fslmaths"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+# Original source at L51 of <nipype-install>/interfaces/fsl/maths.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = inputs.out_file
+    if inputs.out_file is attrs.NOTHING:
+        outputs["out_file"] = _gen_fname(
+            inputs.in_file,
+            suffix=_suffix,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    outputs["out_file"] = os.path.abspath(outputs["out_file"])
+    return outputs
 
 
 # Original source at L108 of <nipype-install>/utils/filemanip.py
@@ -154,6 +198,44 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
@@ -245,85 +327,3 @@ def standard_image(img_name=None):
                 for filename in glob(os.path.join(stdpath, "*nii*"))
             ]
         return os.path.join(stdpath, img_name)
-
-
-# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
-def _gen_fname(
-    basename,
-    cwd=None,
-    suffix=None,
-    change_ext=True,
-    ext=None,
-    inputs=None,
-    stdout=None,
-    stderr=None,
-    output_dir=None,
-):
-    """Generate a filename based on the given parameters.
-
-    The filename will take the form: cwd/basename<suffix><ext>.
-    If change_ext is True, it will use the extensions specified in
-    <instance>inputs.output_type.
-
-    Parameters
-    ----------
-    basename : str
-        Filename to base the new filename on.
-    cwd : str
-        Path to prefix to the new filename. (default is output_dir)
-    suffix : str
-        Suffix to add to the `basename`.  (defaults is '' )
-    change_ext : bool
-        Flag to change the filename extension to the FSL output type.
-        (default True)
-
-    Returns
-    -------
-    fname : str
-        New filename based on given parameters.
-
-    """
-
-    if basename == "":
-        msg = "Unable to generate filename for command %s. " % "fslmaths"
-        msg += "basename is not set!"
-        raise ValueError(msg)
-    if cwd is None:
-        cwd = output_dir
-    if ext is None:
-        ext = Info.output_type_to_ext(inputs.output_type)
-    if change_ext:
-        if suffix:
-            suffix = "".join((suffix, ext))
-        else:
-            suffix = ext
-    if suffix is None:
-        suffix = ""
-    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
-    return fname
-
-
-# Original source at L61 of <nipype-install>/interfaces/fsl/maths.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "out_file":
-        return _list_outputs(
-            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-        )["out_file"]
-    return None
-
-
-# Original source at L51 of <nipype-install>/interfaces/fsl/maths.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    outputs["out_file"] = inputs.out_file
-    if inputs.out_file is attrs.NOTHING:
-        outputs["out_file"] = _gen_fname(
-            inputs.in_file,
-            suffix=_suffix,
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-    outputs["out_file"] = os.path.abspath(outputs["out_file"])
-    return outputs
diff --git a/example-specs/task/nipype/fsl/split_callables.py b/example-specs/task/nipype/fsl/split_callables.py
index 2bf84e3b..28b93973 100644
--- a/example-specs/task/nipype/fsl/split_callables.py
+++ b/example-specs/task/nipype/fsl/split_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of Split.yaml"""
 
+import attrs
 import logging
 import os
 from glob import glob
-import attrs
 
 
 def out_files_callable(output_dir, inputs, stdout, stderr):
@@ -21,6 +21,32 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L549 of <nipype-install>/interfaces/fsl/utils.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    """Create a Bunch which contains all possible files generated
+    by running the interface.  Some files are always generated, others
+    depending on which ``inputs`` options are set.
+
+    Returns
+    -------
+
+    outputs : Bunch object
+        Bunch object containing all possible files generated by
+        interface object.
+
+        If None, file was not generated
+        Else, contains path, filename of generated outputfile
+
+    """
+    outputs = {}
+    ext = Info.output_type_to_ext(inputs.output_type)
+    outbase = "vol[0-9]*"
+    if inputs.out_base_name is not attrs.NOTHING:
+        outbase = "%s[0-9]*" % inputs.out_base_name
+    outputs["out_files"] = sorted(glob(os.path.join(output_dir, outbase + ext)))
+    return outputs
+
+
 # Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
@@ -150,29 +176,3 @@ def standard_image(img_name=None):
                 for filename in glob(os.path.join(stdpath, "*nii*"))
             ]
         return os.path.join(stdpath, img_name)
-
-
-# Original source at L549 of <nipype-install>/interfaces/fsl/utils.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    """Create a Bunch which contains all possible files generated
-    by running the interface.  Some files are always generated, others
-    depending on which ``inputs`` options are set.
-
-    Returns
-    -------
-
-    outputs : Bunch object
-        Bunch object containing all possible files generated by
-        interface object.
-
-        If None, file was not generated
-        Else, contains path, filename of generated outputfile
-
-    """
-    outputs = {}
-    ext = Info.output_type_to_ext(inputs.output_type)
-    outbase = "vol[0-9]*"
-    if inputs.out_base_name is not attrs.NOTHING:
-        outbase = "%s[0-9]*" % inputs.out_base_name
-    outputs["out_files"] = sorted(glob(os.path.join(output_dir, outbase + ext)))
-    return outputs
diff --git a/example-specs/task/nipype/fsl/std_image_callables.py b/example-specs/task/nipype/fsl/std_image_callables.py
index 706702bb..d9e00725 100644
--- a/example-specs/task/nipype/fsl/std_image_callables.py
+++ b/example-specs/task/nipype/fsl/std_image_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of StdImage.yaml"""
 
-from glob import glob
 import attrs
 import logging
 import os
 import os.path as op
+from glob import glob
 from pathlib import Path
 
 
@@ -22,42 +22,86 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
+# Original source at L61 of <nipype-install>/interfaces/fsl/maths.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )["out_file"]
+    return None
 
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
 
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
 
-            klass._version = klass.parse_version(raw_info)
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
 
-        return klass._version
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
 
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "fslmaths"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+# Original source at L51 of <nipype-install>/interfaces/fsl/maths.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = inputs.out_file
+    if inputs.out_file is attrs.NOTHING:
+        outputs["out_file"] = _gen_fname(
+            inputs.in_file,
+            suffix=_suffix,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    outputs["out_file"] = os.path.abspath(outputs["out_file"])
+    return outputs
 
 
 # Original source at L108 of <nipype-install>/utils/filemanip.py
@@ -154,6 +198,44 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
@@ -245,85 +327,3 @@ def standard_image(img_name=None):
                 for filename in glob(os.path.join(stdpath, "*nii*"))
             ]
         return os.path.join(stdpath, img_name)
-
-
-# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
-def _gen_fname(
-    basename,
-    cwd=None,
-    suffix=None,
-    change_ext=True,
-    ext=None,
-    inputs=None,
-    stdout=None,
-    stderr=None,
-    output_dir=None,
-):
-    """Generate a filename based on the given parameters.
-
-    The filename will take the form: cwd/basename<suffix><ext>.
-    If change_ext is True, it will use the extensions specified in
-    <instance>inputs.output_type.
-
-    Parameters
-    ----------
-    basename : str
-        Filename to base the new filename on.
-    cwd : str
-        Path to prefix to the new filename. (default is output_dir)
-    suffix : str
-        Suffix to add to the `basename`.  (defaults is '' )
-    change_ext : bool
-        Flag to change the filename extension to the FSL output type.
-        (default True)
-
-    Returns
-    -------
-    fname : str
-        New filename based on given parameters.
-
-    """
-
-    if basename == "":
-        msg = "Unable to generate filename for command %s. " % "fslmaths"
-        msg += "basename is not set!"
-        raise ValueError(msg)
-    if cwd is None:
-        cwd = output_dir
-    if ext is None:
-        ext = Info.output_type_to_ext(inputs.output_type)
-    if change_ext:
-        if suffix:
-            suffix = "".join((suffix, ext))
-        else:
-            suffix = ext
-    if suffix is None:
-        suffix = ""
-    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
-    return fname
-
-
-# Original source at L61 of <nipype-install>/interfaces/fsl/maths.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "out_file":
-        return _list_outputs(
-            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-        )["out_file"]
-    return None
-
-
-# Original source at L51 of <nipype-install>/interfaces/fsl/maths.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    outputs["out_file"] = inputs.out_file
-    if inputs.out_file is attrs.NOTHING:
-        outputs["out_file"] = _gen_fname(
-            inputs.in_file,
-            suffix=_suffix,
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-    outputs["out_file"] = os.path.abspath(outputs["out_file"])
-    return outputs
diff --git a/example-specs/task/nipype/fsl/susan_callables.py b/example-specs/task/nipype/fsl/susan_callables.py
index c741f8e1..859ed75d 100644
--- a/example-specs/task/nipype/fsl/susan_callables.py
+++ b/example-specs/task/nipype/fsl/susan_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of SUSAN.yaml"""
 
-from glob import glob
 import attrs
 import logging
 import os
 import os.path as op
+from glob import glob
 from pathlib import Path
 
 
@@ -22,42 +22,86 @@ def smoothed_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
+# Original source at L1694 of <nipype-install>/interfaces/fsl/preprocess.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )["smoothed_file"]
+    return None
 
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
 
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
 
-            klass._version = klass.parse_version(raw_info)
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
 
-        return klass._version
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
 
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "susan"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+# Original source at L1686 of <nipype-install>/interfaces/fsl/preprocess.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    out_file = inputs.out_file
+    if out_file is attrs.NOTHING:
+        out_file = _gen_fname(
+            inputs.in_file,
+            suffix="_smooth",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    outputs["smoothed_file"] = os.path.abspath(out_file)
+    return outputs
 
 
 # Original source at L108 of <nipype-install>/utils/filemanip.py
@@ -154,6 +198,44 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
@@ -245,85 +327,3 @@ def standard_image(img_name=None):
                 for filename in glob(os.path.join(stdpath, "*nii*"))
             ]
         return os.path.join(stdpath, img_name)
-
-
-# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
-def _gen_fname(
-    basename,
-    cwd=None,
-    suffix=None,
-    change_ext=True,
-    ext=None,
-    inputs=None,
-    stdout=None,
-    stderr=None,
-    output_dir=None,
-):
-    """Generate a filename based on the given parameters.
-
-    The filename will take the form: cwd/basename<suffix><ext>.
-    If change_ext is True, it will use the extensions specified in
-    <instance>inputs.output_type.
-
-    Parameters
-    ----------
-    basename : str
-        Filename to base the new filename on.
-    cwd : str
-        Path to prefix to the new filename. (default is output_dir)
-    suffix : str
-        Suffix to add to the `basename`.  (defaults is '' )
-    change_ext : bool
-        Flag to change the filename extension to the FSL output type.
-        (default True)
-
-    Returns
-    -------
-    fname : str
-        New filename based on given parameters.
-
-    """
-
-    if basename == "":
-        msg = "Unable to generate filename for command %s. " % "susan"
-        msg += "basename is not set!"
-        raise ValueError(msg)
-    if cwd is None:
-        cwd = output_dir
-    if ext is None:
-        ext = Info.output_type_to_ext(inputs.output_type)
-    if change_ext:
-        if suffix:
-            suffix = "".join((suffix, ext))
-        else:
-            suffix = ext
-    if suffix is None:
-        suffix = ""
-    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
-    return fname
-
-
-# Original source at L1694 of <nipype-install>/interfaces/fsl/preprocess.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "out_file":
-        return _list_outputs(
-            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-        )["smoothed_file"]
-    return None
-
-
-# Original source at L1686 of <nipype-install>/interfaces/fsl/preprocess.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    out_file = inputs.out_file
-    if out_file is attrs.NOTHING:
-        out_file = _gen_fname(
-            inputs.in_file,
-            suffix="_smooth",
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-    outputs["smoothed_file"] = os.path.abspath(out_file)
-    return outputs
diff --git a/example-specs/task/nipype/fsl/swap_dimensions_callables.py b/example-specs/task/nipype/fsl/swap_dimensions_callables.py
index 6eba554c..055aff11 100644
--- a/example-specs/task/nipype/fsl/swap_dimensions_callables.py
+++ b/example-specs/task/nipype/fsl/swap_dimensions_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of SwapDimensions.yaml"""
 
-from glob import glob
 import attrs
 import logging
 import os
 import os.path as op
+from glob import glob
 from pathlib import Path
 
 
@@ -22,42 +22,86 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
+# Original source at L1642 of <nipype-install>/interfaces/fsl/utils.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )["out_file"]
+    return None
 
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
 
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
 
-            klass._version = klass.parse_version(raw_info)
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
 
-        return klass._version
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
 
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "fslswapdim"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+# Original source at L1632 of <nipype-install>/interfaces/fsl/utils.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = inputs.out_file
+    if inputs.out_file is attrs.NOTHING:
+        outputs["out_file"] = _gen_fname(
+            inputs.in_file,
+            suffix="_newdims",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    outputs["out_file"] = os.path.abspath(outputs["out_file"])
+    return outputs
 
 
 # Original source at L108 of <nipype-install>/utils/filemanip.py
@@ -154,6 +198,44 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
@@ -245,85 +327,3 @@ def standard_image(img_name=None):
                 for filename in glob(os.path.join(stdpath, "*nii*"))
             ]
         return os.path.join(stdpath, img_name)
-
-
-# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
-def _gen_fname(
-    basename,
-    cwd=None,
-    suffix=None,
-    change_ext=True,
-    ext=None,
-    inputs=None,
-    stdout=None,
-    stderr=None,
-    output_dir=None,
-):
-    """Generate a filename based on the given parameters.
-
-    The filename will take the form: cwd/basename<suffix><ext>.
-    If change_ext is True, it will use the extensions specified in
-    <instance>inputs.output_type.
-
-    Parameters
-    ----------
-    basename : str
-        Filename to base the new filename on.
-    cwd : str
-        Path to prefix to the new filename. (default is output_dir)
-    suffix : str
-        Suffix to add to the `basename`.  (defaults is '' )
-    change_ext : bool
-        Flag to change the filename extension to the FSL output type.
-        (default True)
-
-    Returns
-    -------
-    fname : str
-        New filename based on given parameters.
-
-    """
-
-    if basename == "":
-        msg = "Unable to generate filename for command %s. " % "fslswapdim"
-        msg += "basename is not set!"
-        raise ValueError(msg)
-    if cwd is None:
-        cwd = output_dir
-    if ext is None:
-        ext = Info.output_type_to_ext(inputs.output_type)
-    if change_ext:
-        if suffix:
-            suffix = "".join((suffix, ext))
-        else:
-            suffix = ext
-    if suffix is None:
-        suffix = ""
-    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
-    return fname
-
-
-# Original source at L1642 of <nipype-install>/interfaces/fsl/utils.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "out_file":
-        return _list_outputs(
-            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-        )["out_file"]
-    return None
-
-
-# Original source at L1632 of <nipype-install>/interfaces/fsl/utils.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    outputs["out_file"] = inputs.out_file
-    if inputs.out_file is attrs.NOTHING:
-        outputs["out_file"] = _gen_fname(
-            inputs.in_file,
-            suffix="_newdims",
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-    outputs["out_file"] = os.path.abspath(outputs["out_file"])
-    return outputs
diff --git a/example-specs/task/nipype/fsl/temporal_filter_callables.py b/example-specs/task/nipype/fsl/temporal_filter_callables.py
index b5d9389d..8da590f0 100644
--- a/example-specs/task/nipype/fsl/temporal_filter_callables.py
+++ b/example-specs/task/nipype/fsl/temporal_filter_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of TemporalFilter.yaml"""
 
-from glob import glob
 import attrs
 import logging
 import os
 import os.path as op
+from glob import glob
 from pathlib import Path
 
 
@@ -22,42 +22,86 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
+# Original source at L61 of <nipype-install>/interfaces/fsl/maths.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )["out_file"]
+    return None
 
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
 
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
 
-            klass._version = klass.parse_version(raw_info)
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
 
-        return klass._version
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
 
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "fslmaths"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+# Original source at L51 of <nipype-install>/interfaces/fsl/maths.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = inputs.out_file
+    if inputs.out_file is attrs.NOTHING:
+        outputs["out_file"] = _gen_fname(
+            inputs.in_file,
+            suffix=_suffix,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    outputs["out_file"] = os.path.abspath(outputs["out_file"])
+    return outputs
 
 
 # Original source at L108 of <nipype-install>/utils/filemanip.py
@@ -154,6 +198,44 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
@@ -245,85 +327,3 @@ def standard_image(img_name=None):
                 for filename in glob(os.path.join(stdpath, "*nii*"))
             ]
         return os.path.join(stdpath, img_name)
-
-
-# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
-def _gen_fname(
-    basename,
-    cwd=None,
-    suffix=None,
-    change_ext=True,
-    ext=None,
-    inputs=None,
-    stdout=None,
-    stderr=None,
-    output_dir=None,
-):
-    """Generate a filename based on the given parameters.
-
-    The filename will take the form: cwd/basename<suffix><ext>.
-    If change_ext is True, it will use the extensions specified in
-    <instance>inputs.output_type.
-
-    Parameters
-    ----------
-    basename : str
-        Filename to base the new filename on.
-    cwd : str
-        Path to prefix to the new filename. (default is output_dir)
-    suffix : str
-        Suffix to add to the `basename`.  (defaults is '' )
-    change_ext : bool
-        Flag to change the filename extension to the FSL output type.
-        (default True)
-
-    Returns
-    -------
-    fname : str
-        New filename based on given parameters.
-
-    """
-
-    if basename == "":
-        msg = "Unable to generate filename for command %s. " % "fslmaths"
-        msg += "basename is not set!"
-        raise ValueError(msg)
-    if cwd is None:
-        cwd = output_dir
-    if ext is None:
-        ext = Info.output_type_to_ext(inputs.output_type)
-    if change_ext:
-        if suffix:
-            suffix = "".join((suffix, ext))
-        else:
-            suffix = ext
-    if suffix is None:
-        suffix = ""
-    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
-    return fname
-
-
-# Original source at L61 of <nipype-install>/interfaces/fsl/maths.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "out_file":
-        return _list_outputs(
-            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-        )["out_file"]
-    return None
-
-
-# Original source at L51 of <nipype-install>/interfaces/fsl/maths.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    outputs["out_file"] = inputs.out_file
-    if inputs.out_file is attrs.NOTHING:
-        outputs["out_file"] = _gen_fname(
-            inputs.in_file,
-            suffix=_suffix,
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-    outputs["out_file"] = os.path.abspath(outputs["out_file"])
-    return outputs
diff --git a/example-specs/task/nipype/fsl/text_2_vest_callables.py b/example-specs/task/nipype/fsl/text_2_vest_callables.py
index 48aca8b6..f8c73e2f 100644
--- a/example-specs/task/nipype/fsl/text_2_vest_callables.py
+++ b/example-specs/task/nipype/fsl/text_2_vest_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Text2Vest.yaml"""
 
-from glob import glob
 import attrs
 import logging
 import os
 import os.path as op
+from glob import glob
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -20,6 +20,182 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+# Original source at L249 of <nipype-install>/interfaces/fsl/base.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value + Info.output_type_to_ext(inputs.output_type)
+
+
+# Original source at L58 of <nipype-install>/utils/filemanip.py
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
 # Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
@@ -151,13 +327,6 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
-# Original source at L249 of <nipype-install>/interfaces/fsl/base.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    return value + Info.output_type_to_ext(inputs.output_type)
-
-
 # Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
@@ -167,172 +336,3 @@ def __init__(self, value):
 
     def __str__(self):
         return "{}".format(self.value)
-
-
-# Original source at L58 of <nipype-install>/utils/filemanip.py
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
-# Original source at L809 of <nipype-install>/interfaces/base/core.py
-def _filename_from_source(
-    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    if chain is None:
-        chain = []
-
-    trait_spec = inputs.trait(name)
-    retval = getattr(inputs, name)
-    source_ext = None
-    if (retval is attrs.NOTHING) or "%s" in retval:
-        if not trait_spec.name_source:
-            return retval
-
-        # Do not generate filename when excluded by other inputs
-        if any(
-            (getattr(inputs, field) is not attrs.NOTHING)
-            for field in trait_spec.xor or ()
-        ):
-            return retval
-
-        # Do not generate filename when required fields are missing
-        if not all(
-            (getattr(inputs, field) is not attrs.NOTHING)
-            for field in trait_spec.requires or ()
-        ):
-            return retval
-
-        if (retval is not attrs.NOTHING) and "%s" in retval:
-            name_template = retval
-        else:
-            name_template = trait_spec.name_template
-        if not name_template:
-            name_template = "%s_generated"
-
-        ns = trait_spec.name_source
-        while isinstance(ns, (list, tuple)):
-            if len(ns) > 1:
-                iflogger.warning("Only one name_source per trait is allowed")
-            ns = ns[0]
-
-        if not isinstance(ns, (str, bytes)):
-            raise ValueError(
-                "name_source of '{}' trait should be an input trait "
-                "name, but a type {} object was found".format(name, type(ns))
-            )
-
-        if getattr(inputs, ns) is not attrs.NOTHING:
-            name_source = ns
-            source = getattr(inputs, name_source)
-            while isinstance(source, list):
-                source = source[0]
-
-            # special treatment for files
-            try:
-                _, base, source_ext = split_filename(source)
-            except (AttributeError, TypeError):
-                base = source
-        else:
-            if name in chain:
-                raise NipypeInterfaceError("Mutually pointing name_sources")
-
-            chain.append(name)
-            base = _filename_from_source(
-                ns,
-                chain,
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-            if base is not attrs.NOTHING:
-                _, _, source_ext = split_filename(base)
-            else:
-                # Do not generate filename when required fields are missing
-                return retval
-
-        chain = None
-        retval = name_template % base
-        _, _, ext = split_filename(retval)
-        if trait_spec.keep_extension and (ext or source_ext):
-            if (ext is None or not ext) and source_ext:
-                retval = retval + source_ext
-        else:
-            retval = _overload_extension(
-                retval,
-                name,
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-    return retval
-
-
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
-# Original source at L891 of <nipype-install>/interfaces/base/core.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    metadata = dict(name_source=lambda t: t is not None)
-    traits = inputs.traits(**metadata)
-    if traits:
-        outputs = {}
-        for name, trait_spec in list(traits.items()):
-            out_name = name
-            if trait_spec.output_name is not None:
-                out_name = trait_spec.output_name
-            fname = _filename_from_source(
-                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-            )
-            if fname is not attrs.NOTHING:
-                outputs[out_name] = os.path.abspath(fname)
-        return outputs
diff --git a/example-specs/task/nipype/fsl/threshold_callables.py b/example-specs/task/nipype/fsl/threshold_callables.py
index dddc8229..5f6a8480 100644
--- a/example-specs/task/nipype/fsl/threshold_callables.py
+++ b/example-specs/task/nipype/fsl/threshold_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Threshold.yaml"""
 
-from glob import glob
 import attrs
 import logging
 import os
 import os.path as op
+from glob import glob
 from pathlib import Path
 
 
@@ -22,42 +22,86 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
+# Original source at L61 of <nipype-install>/interfaces/fsl/maths.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )["out_file"]
+    return None
 
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
 
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
 
-            klass._version = klass.parse_version(raw_info)
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
 
-        return klass._version
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
 
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "fslmaths"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+# Original source at L51 of <nipype-install>/interfaces/fsl/maths.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = inputs.out_file
+    if inputs.out_file is attrs.NOTHING:
+        outputs["out_file"] = _gen_fname(
+            inputs.in_file,
+            suffix=_suffix,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    outputs["out_file"] = os.path.abspath(outputs["out_file"])
+    return outputs
 
 
 # Original source at L108 of <nipype-install>/utils/filemanip.py
@@ -154,6 +198,44 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
@@ -245,85 +327,3 @@ def standard_image(img_name=None):
                 for filename in glob(os.path.join(stdpath, "*nii*"))
             ]
         return os.path.join(stdpath, img_name)
-
-
-# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
-def _gen_fname(
-    basename,
-    cwd=None,
-    suffix=None,
-    change_ext=True,
-    ext=None,
-    inputs=None,
-    stdout=None,
-    stderr=None,
-    output_dir=None,
-):
-    """Generate a filename based on the given parameters.
-
-    The filename will take the form: cwd/basename<suffix><ext>.
-    If change_ext is True, it will use the extensions specified in
-    <instance>inputs.output_type.
-
-    Parameters
-    ----------
-    basename : str
-        Filename to base the new filename on.
-    cwd : str
-        Path to prefix to the new filename. (default is output_dir)
-    suffix : str
-        Suffix to add to the `basename`.  (defaults is '' )
-    change_ext : bool
-        Flag to change the filename extension to the FSL output type.
-        (default True)
-
-    Returns
-    -------
-    fname : str
-        New filename based on given parameters.
-
-    """
-
-    if basename == "":
-        msg = "Unable to generate filename for command %s. " % "fslmaths"
-        msg += "basename is not set!"
-        raise ValueError(msg)
-    if cwd is None:
-        cwd = output_dir
-    if ext is None:
-        ext = Info.output_type_to_ext(inputs.output_type)
-    if change_ext:
-        if suffix:
-            suffix = "".join((suffix, ext))
-        else:
-            suffix = ext
-    if suffix is None:
-        suffix = ""
-    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
-    return fname
-
-
-# Original source at L61 of <nipype-install>/interfaces/fsl/maths.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "out_file":
-        return _list_outputs(
-            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-        )["out_file"]
-    return None
-
-
-# Original source at L51 of <nipype-install>/interfaces/fsl/maths.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    outputs["out_file"] = inputs.out_file
-    if inputs.out_file is attrs.NOTHING:
-        outputs["out_file"] = _gen_fname(
-            inputs.in_file,
-            suffix=_suffix,
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-    outputs["out_file"] = os.path.abspath(outputs["out_file"])
-    return outputs
diff --git a/example-specs/task/nipype/fsl/topup_callables.py b/example-specs/task/nipype/fsl/topup_callables.py
index 2893bd61..93a20737 100644
--- a/example-specs/task/nipype/fsl/topup_callables.py
+++ b/example-specs/task/nipype/fsl/topup_callables.py
@@ -1,26 +1,19 @@
 """Module to put any functions that are referred to in the "callables" section of TOPUP.yaml"""
 
-import nibabel as nb
 import attrs
+import logging
+import nibabel as nb
 import os
 import os.path as op
 from glob import glob
-import logging
 from pathlib import Path
 
 
-def out_fieldcoef_callable(output_dir, inputs, stdout, stderr):
-    outputs = _list_outputs(
-        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
-    )
-    return outputs["out_fieldcoef"]
-
-
-def out_movpar_callable(output_dir, inputs, stdout, stderr):
+def out_corrected_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_movpar"]
+    return outputs["out_corrected"]
 
 
 def out_enc_file_callable(output_dir, inputs, stdout, stderr):
@@ -37,11 +30,11 @@ def out_field_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_field"]
 
 
-def out_warps_callable(output_dir, inputs, stdout, stderr):
+def out_fieldcoef_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_warps"]
+    return outputs["out_fieldcoef"]
 
 
 def out_jacs_callable(output_dir, inputs, stdout, stderr):
@@ -51,6 +44,13 @@ def out_jacs_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_jacs"]
 
 
+def out_logfile_callable(output_dir, inputs, stdout, stderr):
+    outputs = _list_outputs(
+        output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
+    )
+    return outputs["out_logfile"]
+
+
 def out_mats_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
@@ -58,18 +58,18 @@ def out_mats_callable(output_dir, inputs, stdout, stderr):
     return outputs["out_mats"]
 
 
-def out_corrected_callable(output_dir, inputs, stdout, stderr):
+def out_movpar_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_corrected"]
+    return outputs["out_movpar"]
 
 
-def out_logfile_callable(output_dir, inputs, stdout, stderr):
+def out_warps_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["out_logfile"]
+    return outputs["out_warps"]
 
 
 IFLOGGER = logging.getLogger("nipype.interface")
@@ -78,123 +78,6 @@ def out_logfile_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
-# Original source at L108 of <nipype-install>/utils/filemanip.py
-def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
-    """Manipulates path and name of input filename
-
-    Parameters
-    ----------
-    fname : string
-        A filename (may or may not include path)
-    prefix : string
-        Characters to prepend to the filename
-    suffix : string
-        Characters to append to the filename
-    newpath : string
-        Path to replace the path of the input fname
-    use_ext : boolean
-        If True (default), appends the extension of the original file
-        to the output name.
-
-    Returns
-    -------
-    Absolute path of the modified filename
-
-    >>> from nipype.utils.filemanip import fname_presuffix
-    >>> fname = 'foo.nii.gz'
-    >>> fname_presuffix(fname,'pre','post','/tmp')
-    '/tmp/prefoopost.nii.gz'
-
-    >>> from nipype.interfaces.base import attrs.NOTHING
-    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
-            fname_presuffix(fname, 'pre', 'post')
-    True
-
-    """
-    pth, fname, ext = split_filename(fname)
-    if not use_ext:
-        ext = ""
-
-    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
-    if newpath:
-        pth = op.abspath(newpath)
-    return op.join(pth, prefix + fname + suffix + ext)
-
-
-# Original source at L249 of <nipype-install>/interfaces/fsl/base.py
-def nipype_interfaces_fsl__FSLCommand___overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    return value + Info.output_type_to_ext(inputs.output_type)
-
-
-# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
-def _gen_fname(
-    basename,
-    cwd=None,
-    suffix=None,
-    change_ext=True,
-    ext=None,
-    inputs=None,
-    stdout=None,
-    stderr=None,
-    output_dir=None,
-):
-    """Generate a filename based on the given parameters.
-
-    The filename will take the form: cwd/basename<suffix><ext>.
-    If change_ext is True, it will use the extensions specified in
-    <instance>inputs.output_type.
-
-    Parameters
-    ----------
-    basename : str
-        Filename to base the new filename on.
-    cwd : str
-        Path to prefix to the new filename. (default is output_dir)
-    suffix : str
-        Suffix to add to the `basename`.  (defaults is '' )
-    change_ext : bool
-        Flag to change the filename extension to the FSL output type.
-        (default True)
-
-    Returns
-    -------
-    fname : str
-        New filename based on given parameters.
-
-    """
-
-    if basename == "":
-        msg = "Unable to generate filename for command %s. " % "topup"
-        msg += "basename is not set!"
-        raise ValueError(msg)
-    if cwd is None:
-        cwd = output_dir
-    if ext is None:
-        ext = Info.output_type_to_ext(inputs.output_type)
-    if change_ext:
-        if suffix:
-            suffix = "".join((suffix, ext))
-        else:
-            suffix = ext
-    if suffix is None:
-        suffix = ""
-    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
-    return fname
-
-
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
@@ -290,6 +173,178 @@ def _filename_from_source(
     return retval
 
 
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
+
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
+
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
+
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "topup"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+# Original source at L398 of <nipype-install>/interfaces/fsl/epi.py
+def _get_encfilename(inputs=None, stdout=None, stderr=None, output_dir=None):
+    out_file = os.path.join(
+        output_dir, ("%s_encfile.txt" % split_filename(inputs.in_file)[1])
+    )
+    return out_file
+
+
+# Original source at L361 of <nipype-install>/interfaces/fsl/epi.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = nipype_interfaces_fsl__FSLCommand___list_outputs()
+    del outputs["out_base"]
+    base_path = None
+    if inputs.out_base is not attrs.NOTHING:
+        base_path, base, _ = split_filename(inputs.out_base)
+        if base_path == "":
+            base_path = None
+    else:
+        base = split_filename(inputs.in_file)[1] + "_base"
+    outputs["out_fieldcoef"] = _gen_fname(
+        base,
+        suffix="_fieldcoef",
+        cwd=base_path,
+        inputs=inputs,
+        stdout=stdout,
+        stderr=stderr,
+        output_dir=output_dir,
+    )
+    outputs["out_movpar"] = _gen_fname(
+        base,
+        suffix="_movpar",
+        ext=".txt",
+        cwd=base_path,
+        inputs=inputs,
+        stdout=stdout,
+        stderr=stderr,
+        output_dir=output_dir,
+    )
+
+    n_vols = nb.load(inputs.in_file).shape[-1]
+    ext = Info.output_type_to_ext(inputs.output_type)
+    fmt = os.path.abspath("{prefix}_{i:02d}{ext}").format
+    outputs["out_warps"] = [
+        fmt(prefix=inputs.out_warp_prefix, i=i, ext=ext) for i in range(1, n_vols + 1)
+    ]
+    outputs["out_jacs"] = [
+        fmt(prefix=inputs.out_jac_prefix, i=i, ext=ext) for i in range(1, n_vols + 1)
+    ]
+    outputs["out_mats"] = [
+        fmt(prefix=inputs.out_mat_prefix, i=i, ext=".mat") for i in range(1, n_vols + 1)
+    ]
+
+    if inputs.encoding_direction is not attrs.NOTHING:
+        outputs["out_enc_file"] = _get_encfilename(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )
+    return outputs
+
+
+# Original source at L430 of <nipype-install>/interfaces/fsl/epi.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if name == "out_base":
+        return value
+    return nipype_interfaces_fsl__FSLCommand___overload_extension(value, name)
+
+
+# Original source at L108 of <nipype-install>/utils/filemanip.py
+def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
+    """Manipulates path and name of input filename
+
+    Parameters
+    ----------
+    fname : string
+        A filename (may or may not include path)
+    prefix : string
+        Characters to prepend to the filename
+    suffix : string
+        Characters to append to the filename
+    newpath : string
+        Path to replace the path of the input fname
+    use_ext : boolean
+        If True (default), appends the extension of the original file
+        to the output name.
+
+    Returns
+    -------
+    Absolute path of the modified filename
+
+    >>> from nipype.utils.filemanip import fname_presuffix
+    >>> fname = 'foo.nii.gz'
+    >>> fname_presuffix(fname,'pre','post','/tmp')
+    '/tmp/prefoopost.nii.gz'
+
+    >>> from nipype.interfaces.base import attrs.NOTHING
+    >>> fname_presuffix(fname, 'pre', 'post', attrs.NOTHING) == \
+            fname_presuffix(fname, 'pre', 'post')
+    True
+
+    """
+    pth, fname, ext = split_filename(fname)
+    if not use_ext:
+        ext = ""
+
+    # No need for : bool(attrs.NOTHING is not attrs.NOTHING) evaluates to False
+    if newpath:
+        pth = op.abspath(newpath)
+    return op.join(pth, prefix + fname + suffix + ext)
+
+
 # Original source at L891 of <nipype-install>/interfaces/base/core.py
 def nipype_interfaces_fsl__FSLCommand___list_outputs(
     inputs=None, stdout=None, stderr=None, output_dir=None
@@ -310,9 +365,73 @@ def nipype_interfaces_fsl__FSLCommand___list_outputs(
         return outputs
 
 
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
+# Original source at L249 of <nipype-install>/interfaces/fsl/base.py
+def nipype_interfaces_fsl__FSLCommand___overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value + Info.output_type_to_ext(inputs.output_type)
+
+
+# Original source at L58 of <nipype-install>/utils/filemanip.py
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
 
 
 # Original source at L1069 of <nipype-install>/interfaces/base/core.py
@@ -444,122 +563,3 @@ def standard_image(img_name=None):
                 for filename in glob(os.path.join(stdpath, "*nii*"))
             ]
         return os.path.join(stdpath, img_name)
-
-
-# Original source at L58 of <nipype-install>/utils/filemanip.py
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
-# Original source at L430 of <nipype-install>/interfaces/fsl/epi.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    if name == "out_base":
-        return value
-    return nipype_interfaces_fsl__FSLCommand___overload_extension(value, name)
-
-
-# Original source at L398 of <nipype-install>/interfaces/fsl/epi.py
-def _get_encfilename(inputs=None, stdout=None, stderr=None, output_dir=None):
-    out_file = os.path.join(
-        output_dir, ("%s_encfile.txt" % split_filename(inputs.in_file)[1])
-    )
-    return out_file
-
-
-# Original source at L361 of <nipype-install>/interfaces/fsl/epi.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = nipype_interfaces_fsl__FSLCommand___list_outputs()
-    del outputs["out_base"]
-    base_path = None
-    if inputs.out_base is not attrs.NOTHING:
-        base_path, base, _ = split_filename(inputs.out_base)
-        if base_path == "":
-            base_path = None
-    else:
-        base = split_filename(inputs.in_file)[1] + "_base"
-    outputs["out_fieldcoef"] = _gen_fname(
-        base,
-        suffix="_fieldcoef",
-        cwd=base_path,
-        inputs=inputs,
-        stdout=stdout,
-        stderr=stderr,
-        output_dir=output_dir,
-    )
-    outputs["out_movpar"] = _gen_fname(
-        base,
-        suffix="_movpar",
-        ext=".txt",
-        cwd=base_path,
-        inputs=inputs,
-        stdout=stdout,
-        stderr=stderr,
-        output_dir=output_dir,
-    )
-
-    n_vols = nb.load(inputs.in_file).shape[-1]
-    ext = Info.output_type_to_ext(inputs.output_type)
-    fmt = os.path.abspath("{prefix}_{i:02d}{ext}").format
-    outputs["out_warps"] = [
-        fmt(prefix=inputs.out_warp_prefix, i=i, ext=ext) for i in range(1, n_vols + 1)
-    ]
-    outputs["out_jacs"] = [
-        fmt(prefix=inputs.out_jac_prefix, i=i, ext=ext) for i in range(1, n_vols + 1)
-    ]
-    outputs["out_mats"] = [
-        fmt(prefix=inputs.out_mat_prefix, i=i, ext=".mat") for i in range(1, n_vols + 1)
-    ]
-
-    if inputs.encoding_direction is not attrs.NOTHING:
-        outputs["out_enc_file"] = _get_encfilename(
-            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-        )
-    return outputs
diff --git a/example-specs/task/nipype/fsl/tract_skeleton_callables.py b/example-specs/task/nipype/fsl/tract_skeleton_callables.py
index dd060e92..98337267 100644
--- a/example-specs/task/nipype/fsl/tract_skeleton_callables.py
+++ b/example-specs/task/nipype/fsl/tract_skeleton_callables.py
@@ -1,8 +1,8 @@
 """Module to put any functions that are referred to in the "callables" section of TractSkeleton.yaml"""
 
+import attrs
 import os.path as op
 from pathlib import Path
-import attrs
 
 
 def projected_data_callable(output_dir, inputs, stdout, stderr):
@@ -24,6 +24,29 @@ def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
     raise NotImplementedError
 
 
+# Original source at L1445 of <nipype-install>/interfaces/fsl/dti.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    _si = inputs
+    if (_si.project_data is not attrs.NOTHING) and _si.project_data:
+        proj_data = _si.projected_data
+        outputs["projected_data"] = proj_data
+        if proj_data is attrs.NOTHING:
+            stem = _si.data_file
+            if _si.alt_data_file is not attrs.NOTHING:
+                stem = _si.alt_data_file
+            outputs["projected_data"] = fname_presuffix(
+                stem, suffix="_skeletonised", newpath=output_dir, use_ext=True
+            )
+    if (_si.skeleton_file is not attrs.NOTHING) and _si.skeleton_file:
+        outputs["skeleton_file"] = _si.skeleton_file
+        if isinstance(_si.skeleton_file, bool):
+            outputs["skeleton_file"] = fname_presuffix(
+                _si.in_file, suffix="_skeleton", newpath=output_dir, use_ext=True
+            )
+    return outputs
+
+
 # Original source at L108 of <nipype-install>/utils/filemanip.py
 def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     """Manipulates path and name of input filename
@@ -116,26 +139,3 @@ def split_filename(fname):
         fname, ext = op.splitext(fname)
 
     return pth, fname, ext
-
-
-# Original source at L1445 of <nipype-install>/interfaces/fsl/dti.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    _si = inputs
-    if (_si.project_data is not attrs.NOTHING) and _si.project_data:
-        proj_data = _si.projected_data
-        outputs["projected_data"] = proj_data
-        if proj_data is attrs.NOTHING:
-            stem = _si.data_file
-            if _si.alt_data_file is not attrs.NOTHING:
-                stem = _si.alt_data_file
-            outputs["projected_data"] = fname_presuffix(
-                stem, suffix="_skeletonised", newpath=output_dir, use_ext=True
-            )
-    if (_si.skeleton_file is not attrs.NOTHING) and _si.skeleton_file:
-        outputs["skeleton_file"] = _si.skeleton_file
-        if isinstance(_si.skeleton_file, bool):
-            outputs["skeleton_file"] = fname_presuffix(
-                _si.in_file, suffix="_skeleton", newpath=output_dir, use_ext=True
-            )
-    return outputs
diff --git a/example-specs/task/nipype/fsl/training_callables.py b/example-specs/task/nipype/fsl/training_callables.py
index 05782ab1..b1625300 100644
--- a/example-specs/task/nipype/fsl/training_callables.py
+++ b/example-specs/task/nipype/fsl/training_callables.py
@@ -1,7 +1,7 @@
 """Module to put any functions that are referred to in the "callables" section of Training.yaml"""
 
-import os
 import attrs
+import os
 
 
 def trained_wts_file_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/fsl/training_set_creator_callables.py b/example-specs/task/nipype/fsl/training_set_creator_callables.py
index 9358836b..02bfada2 100644
--- a/example-specs/task/nipype/fsl/training_set_creator_callables.py
+++ b/example-specs/task/nipype/fsl/training_set_creator_callables.py
@@ -1,6 +1,6 @@
 """Module to put any functions that are referred to in the "callables" section of TrainingSetCreator.yaml"""
 
-import attrs
+import os
 
 
 def mel_icas_out_callable(output_dir, inputs, stdout, stderr):
@@ -10,7 +10,12 @@ def mel_icas_out_callable(output_dir, inputs, stdout, stderr):
     return outputs["mel_icas_out"]
 
 
-def _gen_filename(field, inputs, output_dir, stdout, stderr):
-    raise NotImplementedError(
-        "Could not find '_gen_filename' method in nipype.interfaces.fsl.fix.TrainingSetCreator"
-    )
+# Original source at L122 of <nipype-install>/interfaces/fsl/fix.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    mel_icas = []
+    for item in inputs.mel_icas_in:
+        if os.path.exists(os.path.join(item, "hand_labels_noise.txt")):
+            mel_icas.append(item)
+    outputs = {}
+    outputs["mel_icas_out"] = mel_icas
+    return outputs
diff --git a/example-specs/task/nipype/fsl/unary_maths_callables.py b/example-specs/task/nipype/fsl/unary_maths_callables.py
index 46994d20..62b82c11 100644
--- a/example-specs/task/nipype/fsl/unary_maths_callables.py
+++ b/example-specs/task/nipype/fsl/unary_maths_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of UnaryMaths.yaml"""
 
-from glob import glob
 import attrs
 import logging
 import os
 import os.path as op
+from glob import glob
 from pathlib import Path
 
 
@@ -22,42 +22,75 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
+# Original source at L61 of <nipype-install>/interfaces/fsl/maths.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return nipype_interfaces_fsl_maths__MathsCommand___list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )["out_file"]
+    return None
 
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
 
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
 
-            klass._version = klass.parse_version(raw_info)
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
 
-        return klass._version
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
 
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "fslmaths"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+# Original source at L502 of <nipype-install>/interfaces/fsl/maths.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    _suffix = "_" + inputs.operation
+    return nipype_interfaces_fsl_maths__MathsCommand___list_outputs()
 
 
 # Original source at L108 of <nipype-install>/utils/filemanip.py
@@ -103,6 +136,25 @@ def fname_presuffix(fname, prefix="", suffix="", newpath=None, use_ext=True):
     return op.join(pth, prefix + fname + suffix + ext)
 
 
+# Original source at L51 of <nipype-install>/interfaces/fsl/maths.py
+def nipype_interfaces_fsl_maths__MathsCommand___list_outputs(
+    inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    outputs = {}
+    outputs["out_file"] = inputs.out_file
+    if inputs.out_file is attrs.NOTHING:
+        outputs["out_file"] = _gen_fname(
+            inputs.in_file,
+            suffix=_suffix,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    outputs["out_file"] = os.path.abspath(outputs["out_file"])
+    return outputs
+
+
 # Original source at L58 of <nipype-install>/utils/filemanip.py
 def split_filename(fname):
     """Split a filename into parts: path, base filename and extension.
@@ -154,6 +206,44 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
@@ -245,93 +335,3 @@ def standard_image(img_name=None):
                 for filename in glob(os.path.join(stdpath, "*nii*"))
             ]
         return os.path.join(stdpath, img_name)
-
-
-# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
-def _gen_fname(
-    basename,
-    cwd=None,
-    suffix=None,
-    change_ext=True,
-    ext=None,
-    inputs=None,
-    stdout=None,
-    stderr=None,
-    output_dir=None,
-):
-    """Generate a filename based on the given parameters.
-
-    The filename will take the form: cwd/basename<suffix><ext>.
-    If change_ext is True, it will use the extensions specified in
-    <instance>inputs.output_type.
-
-    Parameters
-    ----------
-    basename : str
-        Filename to base the new filename on.
-    cwd : str
-        Path to prefix to the new filename. (default is output_dir)
-    suffix : str
-        Suffix to add to the `basename`.  (defaults is '' )
-    change_ext : bool
-        Flag to change the filename extension to the FSL output type.
-        (default True)
-
-    Returns
-    -------
-    fname : str
-        New filename based on given parameters.
-
-    """
-
-    if basename == "":
-        msg = "Unable to generate filename for command %s. " % "fslmaths"
-        msg += "basename is not set!"
-        raise ValueError(msg)
-    if cwd is None:
-        cwd = output_dir
-    if ext is None:
-        ext = Info.output_type_to_ext(inputs.output_type)
-    if change_ext:
-        if suffix:
-            suffix = "".join((suffix, ext))
-        else:
-            suffix = ext
-    if suffix is None:
-        suffix = ""
-    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
-    return fname
-
-
-# Original source at L51 of <nipype-install>/interfaces/fsl/maths.py
-def nipype_interfaces_fsl_maths__MathsCommand___list_outputs(
-    inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    outputs = {}
-    outputs["out_file"] = inputs.out_file
-    if inputs.out_file is attrs.NOTHING:
-        outputs["out_file"] = _gen_fname(
-            inputs.in_file,
-            suffix=_suffix,
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-    outputs["out_file"] = os.path.abspath(outputs["out_file"])
-    return outputs
-
-
-# Original source at L61 of <nipype-install>/interfaces/fsl/maths.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "out_file":
-        return nipype_interfaces_fsl_maths__MathsCommand___list_outputs(
-            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-        )["out_file"]
-    return None
-
-
-# Original source at L502 of <nipype-install>/interfaces/fsl/maths.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    _suffix = "_" + inputs.operation
-    return nipype_interfaces_fsl_maths__MathsCommand___list_outputs()
diff --git a/example-specs/task/nipype/fsl/vec_reg_callables.py b/example-specs/task/nipype/fsl/vec_reg_callables.py
index 4fe66d32..1a7b2009 100644
--- a/example-specs/task/nipype/fsl/vec_reg_callables.py
+++ b/example-specs/task/nipype/fsl/vec_reg_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of VecReg.yaml"""
 
-from glob import glob
 import attrs
 import logging
 import os
 import os.path as op
+from glob import glob
 from pathlib import Path
 
 
@@ -22,42 +22,89 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
+# Original source at L1216 of <nipype-install>/interfaces/fsl/dti.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    if name == "out_file":
+        return _list_outputs(
+            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+        )[name]
+    else:
+        return None
 
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
 
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
 
-            klass._version = klass.parse_version(raw_info)
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
 
-        return klass._version
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
 
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "vecreg"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+# Original source at L1205 of <nipype-install>/interfaces/fsl/dti.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    outputs["out_file"] = inputs.out_file
+    if (outputs["out_file"] is attrs.NOTHING) and (inputs.in_file is not attrs.NOTHING):
+        pth, base_name = os.path.split(inputs.in_file)
+        outputs["out_file"] = _gen_fname(
+            base_name,
+            cwd=os.path.abspath(pth),
+            suffix="_vreg",
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+    outputs["out_file"] = os.path.abspath(outputs["out_file"])
+    return outputs
 
 
 # Original source at L108 of <nipype-install>/utils/filemanip.py
@@ -154,6 +201,44 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
@@ -245,88 +330,3 @@ def standard_image(img_name=None):
                 for filename in glob(os.path.join(stdpath, "*nii*"))
             ]
         return os.path.join(stdpath, img_name)
-
-
-# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
-def _gen_fname(
-    basename,
-    cwd=None,
-    suffix=None,
-    change_ext=True,
-    ext=None,
-    inputs=None,
-    stdout=None,
-    stderr=None,
-    output_dir=None,
-):
-    """Generate a filename based on the given parameters.
-
-    The filename will take the form: cwd/basename<suffix><ext>.
-    If change_ext is True, it will use the extensions specified in
-    <instance>inputs.output_type.
-
-    Parameters
-    ----------
-    basename : str
-        Filename to base the new filename on.
-    cwd : str
-        Path to prefix to the new filename. (default is output_dir)
-    suffix : str
-        Suffix to add to the `basename`.  (defaults is '' )
-    change_ext : bool
-        Flag to change the filename extension to the FSL output type.
-        (default True)
-
-    Returns
-    -------
-    fname : str
-        New filename based on given parameters.
-
-    """
-
-    if basename == "":
-        msg = "Unable to generate filename for command %s. " % "vecreg"
-        msg += "basename is not set!"
-        raise ValueError(msg)
-    if cwd is None:
-        cwd = output_dir
-    if ext is None:
-        ext = Info.output_type_to_ext(inputs.output_type)
-    if change_ext:
-        if suffix:
-            suffix = "".join((suffix, ext))
-        else:
-            suffix = ext
-    if suffix is None:
-        suffix = ""
-    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
-    return fname
-
-
-# Original source at L1216 of <nipype-install>/interfaces/fsl/dti.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    if name == "out_file":
-        return _list_outputs(
-            inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-        )[name]
-    else:
-        return None
-
-
-# Original source at L1205 of <nipype-install>/interfaces/fsl/dti.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    outputs["out_file"] = inputs.out_file
-    if (outputs["out_file"] is attrs.NOTHING) and (inputs.in_file is not attrs.NOTHING):
-        pth, base_name = os.path.split(inputs.in_file)
-        outputs["out_file"] = _gen_fname(
-            base_name,
-            cwd=os.path.abspath(pth),
-            suffix="_vreg",
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-    outputs["out_file"] = os.path.abspath(outputs["out_file"])
-    return outputs
diff --git a/example-specs/task/nipype/fsl/vest_2_text_callables.py b/example-specs/task/nipype/fsl/vest_2_text_callables.py
index 2853cff2..2b602433 100644
--- a/example-specs/task/nipype/fsl/vest_2_text_callables.py
+++ b/example-specs/task/nipype/fsl/vest_2_text_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of Vest2Text.yaml"""
 
-from glob import glob
 import attrs
 import logging
 import os
 import os.path as op
+from glob import glob
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -20,6 +20,182 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+# Original source at L249 of <nipype-install>/interfaces/fsl/base.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value + Info.output_type_to_ext(inputs.output_type)
+
+
+# Original source at L58 of <nipype-install>/utils/filemanip.py
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
 # Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
@@ -151,13 +327,6 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
-# Original source at L249 of <nipype-install>/interfaces/fsl/base.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    return value + Info.output_type_to_ext(inputs.output_type)
-
-
 # Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
@@ -167,172 +336,3 @@ def __init__(self, value):
 
     def __str__(self):
         return "{}".format(self.value)
-
-
-# Original source at L58 of <nipype-install>/utils/filemanip.py
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
-# Original source at L809 of <nipype-install>/interfaces/base/core.py
-def _filename_from_source(
-    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    if chain is None:
-        chain = []
-
-    trait_spec = inputs.trait(name)
-    retval = getattr(inputs, name)
-    source_ext = None
-    if (retval is attrs.NOTHING) or "%s" in retval:
-        if not trait_spec.name_source:
-            return retval
-
-        # Do not generate filename when excluded by other inputs
-        if any(
-            (getattr(inputs, field) is not attrs.NOTHING)
-            for field in trait_spec.xor or ()
-        ):
-            return retval
-
-        # Do not generate filename when required fields are missing
-        if not all(
-            (getattr(inputs, field) is not attrs.NOTHING)
-            for field in trait_spec.requires or ()
-        ):
-            return retval
-
-        if (retval is not attrs.NOTHING) and "%s" in retval:
-            name_template = retval
-        else:
-            name_template = trait_spec.name_template
-        if not name_template:
-            name_template = "%s_generated"
-
-        ns = trait_spec.name_source
-        while isinstance(ns, (list, tuple)):
-            if len(ns) > 1:
-                iflogger.warning("Only one name_source per trait is allowed")
-            ns = ns[0]
-
-        if not isinstance(ns, (str, bytes)):
-            raise ValueError(
-                "name_source of '{}' trait should be an input trait "
-                "name, but a type {} object was found".format(name, type(ns))
-            )
-
-        if getattr(inputs, ns) is not attrs.NOTHING:
-            name_source = ns
-            source = getattr(inputs, name_source)
-            while isinstance(source, list):
-                source = source[0]
-
-            # special treatment for files
-            try:
-                _, base, source_ext = split_filename(source)
-            except (AttributeError, TypeError):
-                base = source
-        else:
-            if name in chain:
-                raise NipypeInterfaceError("Mutually pointing name_sources")
-
-            chain.append(name)
-            base = _filename_from_source(
-                ns,
-                chain,
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-            if base is not attrs.NOTHING:
-                _, _, source_ext = split_filename(base)
-            else:
-                # Do not generate filename when required fields are missing
-                return retval
-
-        chain = None
-        retval = name_template % base
-        _, _, ext = split_filename(retval)
-        if trait_spec.keep_extension and (ext or source_ext):
-            if (ext is None or not ext) and source_ext:
-                retval = retval + source_ext
-        else:
-            retval = _overload_extension(
-                retval,
-                name,
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-    return retval
-
-
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
-# Original source at L891 of <nipype-install>/interfaces/base/core.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    metadata = dict(name_source=lambda t: t is not None)
-    traits = inputs.traits(**metadata)
-    if traits:
-        outputs = {}
-        for name, trait_spec in list(traits.items()):
-            out_name = name
-            if trait_spec.output_name is not None:
-                out_name = trait_spec.output_name
-            fname = _filename_from_source(
-                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-            )
-            if fname is not attrs.NOTHING:
-                outputs[out_name] = os.path.abspath(fname)
-        return outputs
diff --git a/example-specs/task/nipype/fsl/warp_points_callables.py b/example-specs/task/nipype/fsl/warp_points_callables.py
index 19b91215..1962865c 100644
--- a/example-specs/task/nipype/fsl/warp_points_callables.py
+++ b/example-specs/task/nipype/fsl/warp_points_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of WarpPoints.yaml"""
 
+import attrs
 import logging
 import os
 import os.path as op
-import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -16,76 +16,6 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
-# Original source at L2585 of <nipype-install>/interfaces/fsl/utils.py
-def _overload_extension(
-    value, name, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    if name == "out_file":
-        return "%s.%s" % (value, getattr(self, "_outformat"))
-
-
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
-# Original source at L58 of <nipype-install>/utils/filemanip.py
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
@@ -202,3 +132,73 @@ def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
             if fname is not attrs.NOTHING:
                 outputs[out_name] = os.path.abspath(fname)
         return outputs
+
+
+# Original source at L2585 of <nipype-install>/interfaces/fsl/utils.py
+def _overload_extension(
+    value, name, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if name == "out_file":
+        return "%s.%s" % (value, getattr(self, "_outformat"))
+
+
+# Original source at L58 of <nipype-install>/utils/filemanip.py
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
diff --git a/example-specs/task/nipype/fsl/warp_points_from_std_callables.py b/example-specs/task/nipype/fsl/warp_points_from_std_callables.py
index be28f3f6..0bd158be 100644
--- a/example-specs/task/nipype/fsl/warp_points_from_std_callables.py
+++ b/example-specs/task/nipype/fsl/warp_points_from_std_callables.py
@@ -1,7 +1,6 @@
 """Module to put any functions that are referred to in the "callables" section of WarpPointsFromStd.yaml"""
 
 import os.path as op
-import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
diff --git a/example-specs/task/nipype/fsl/warp_points_to_std_callables.py b/example-specs/task/nipype/fsl/warp_points_to_std_callables.py
index 7b622b8b..078867be 100644
--- a/example-specs/task/nipype/fsl/warp_points_to_std_callables.py
+++ b/example-specs/task/nipype/fsl/warp_points_to_std_callables.py
@@ -1,9 +1,9 @@
 """Module to put any functions that are referred to in the "callables" section of WarpPointsToStd.yaml"""
 
+import attrs
 import logging
 import os
 import os.path as op
-import attrs
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -16,76 +16,6 @@ def out_file_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
-# Original source at L2585 of <nipype-install>/interfaces/fsl/utils.py
-def _overload_extension(
-    value, name, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    if name == "out_file":
-        return "%s.%s" % (value, getattr(self, "_outformat"))
-
-
-# Original source at L125 of <nipype-install>/interfaces/base/support.py
-class NipypeInterfaceError(Exception):
-    """Custom error for interfaces"""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return "{}".format(self.value)
-
-
-# Original source at L58 of <nipype-install>/utils/filemanip.py
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
 # Original source at L809 of <nipype-install>/interfaces/base/core.py
 def _filename_from_source(
     name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
@@ -202,3 +132,73 @@ def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
             if fname is not attrs.NOTHING:
                 outputs[out_name] = os.path.abspath(fname)
         return outputs
+
+
+# Original source at L2585 of <nipype-install>/interfaces/fsl/utils.py
+def _overload_extension(
+    value, name, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if name == "out_file":
+        return "%s.%s" % (value, getattr(self, "_outformat"))
+
+
+# Original source at L58 of <nipype-install>/utils/filemanip.py
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
+# Original source at L125 of <nipype-install>/interfaces/base/support.py
+class NipypeInterfaceError(Exception):
+    """Custom error for interfaces"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
diff --git a/example-specs/task/nipype/fsl/warp_utils_callables.py b/example-specs/task/nipype/fsl/warp_utils_callables.py
index b684143d..25df0875 100644
--- a/example-specs/task/nipype/fsl/warp_utils_callables.py
+++ b/example-specs/task/nipype/fsl/warp_utils_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of WarpUtils.yaml"""
 
-from glob import glob
 import attrs
 import logging
 import os
 import os.path as op
+from glob import glob
 
 
 def out_file_callable(output_dir, inputs, stdout, stderr):
@@ -27,6 +27,182 @@ def out_jacobian_callable(output_dir, inputs, stdout, stderr):
 iflogger = logging.getLogger("nipype.interface")
 
 
+# Original source at L809 of <nipype-install>/interfaces/base/core.py
+def _filename_from_source(
+    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    if chain is None:
+        chain = []
+
+    trait_spec = inputs.trait(name)
+    retval = getattr(inputs, name)
+    source_ext = None
+    if (retval is attrs.NOTHING) or "%s" in retval:
+        if not trait_spec.name_source:
+            return retval
+
+        # Do not generate filename when excluded by other inputs
+        if any(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.xor or ()
+        ):
+            return retval
+
+        # Do not generate filename when required fields are missing
+        if not all(
+            (getattr(inputs, field) is not attrs.NOTHING)
+            for field in trait_spec.requires or ()
+        ):
+            return retval
+
+        if (retval is not attrs.NOTHING) and "%s" in retval:
+            name_template = retval
+        else:
+            name_template = trait_spec.name_template
+        if not name_template:
+            name_template = "%s_generated"
+
+        ns = trait_spec.name_source
+        while isinstance(ns, (list, tuple)):
+            if len(ns) > 1:
+                iflogger.warning("Only one name_source per trait is allowed")
+            ns = ns[0]
+
+        if not isinstance(ns, (str, bytes)):
+            raise ValueError(
+                "name_source of '{}' trait should be an input trait "
+                "name, but a type {} object was found".format(name, type(ns))
+            )
+
+        if getattr(inputs, ns) is not attrs.NOTHING:
+            name_source = ns
+            source = getattr(inputs, name_source)
+            while isinstance(source, list):
+                source = source[0]
+
+            # special treatment for files
+            try:
+                _, base, source_ext = split_filename(source)
+            except (AttributeError, TypeError):
+                base = source
+        else:
+            if name in chain:
+                raise NipypeInterfaceError("Mutually pointing name_sources")
+
+            chain.append(name)
+            base = _filename_from_source(
+                ns,
+                chain,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+            if base is not attrs.NOTHING:
+                _, _, source_ext = split_filename(base)
+            else:
+                # Do not generate filename when required fields are missing
+                return retval
+
+        chain = None
+        retval = name_template % base
+        _, _, ext = split_filename(retval)
+        if trait_spec.keep_extension and (ext or source_ext):
+            if (ext is None or not ext) and source_ext:
+                retval = retval + source_ext
+        else:
+            retval = _overload_extension(
+                retval,
+                name,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+    return retval
+
+
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
+
+
+# Original source at L891 of <nipype-install>/interfaces/base/core.py
+def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
+    metadata = dict(name_source=lambda t: t is not None)
+    traits = inputs.traits(**metadata)
+    if traits:
+        outputs = {}
+        for name, trait_spec in list(traits.items()):
+            out_name = name
+            if trait_spec.output_name is not None:
+                out_name = trait_spec.output_name
+            fname = _filename_from_source(
+                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
+            )
+            if fname is not attrs.NOTHING:
+                outputs[out_name] = os.path.abspath(fname)
+        return outputs
+
+
+# Original source at L249 of <nipype-install>/interfaces/fsl/base.py
+def _overload_extension(
+    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
+):
+    return value + Info.output_type_to_ext(inputs.output_type)
+
+
+# Original source at L58 of <nipype-install>/utils/filemanip.py
+def split_filename(fname):
+    """Split a filename into parts: path, base filename and extension.
+
+    Parameters
+    ----------
+    fname : str
+        file or path name
+
+    Returns
+    -------
+    pth : str
+        base path from fname
+    fname : str
+        filename from fname, without extension
+    ext : str
+        file extension from fname
+
+    Examples
+    --------
+    >>> from nipype.utils.filemanip import split_filename
+    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
+    >>> pth
+    '/home/data'
+
+    >>> fname
+    'subject'
+
+    >>> ext
+    '.nii.gz'
+
+    """
+
+    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
+
+    pth = op.dirname(fname)
+    fname = op.basename(fname)
+
+    ext = None
+    for special_ext in special_extensions:
+        ext_len = len(special_ext)
+        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
+            ext = fname[-ext_len:]
+            fname = fname[:-ext_len]
+            break
+    if not ext:
+        fname, ext = op.splitext(fname)
+
+    return pth, fname, ext
+
+
 # Original source at L1069 of <nipype-install>/interfaces/base/core.py
 class PackageInfo(object):
     _version = None
@@ -158,13 +334,6 @@ def standard_image(img_name=None):
         return os.path.join(stdpath, img_name)
 
 
-# Original source at L249 of <nipype-install>/interfaces/fsl/base.py
-def _overload_extension(
-    value, name=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    return value + Info.output_type_to_ext(inputs.output_type)
-
-
 # Original source at L125 of <nipype-install>/interfaces/base/support.py
 class NipypeInterfaceError(Exception):
     """Custom error for interfaces"""
@@ -174,172 +343,3 @@ def __init__(self, value):
 
     def __str__(self):
         return "{}".format(self.value)
-
-
-# Original source at L58 of <nipype-install>/utils/filemanip.py
-def split_filename(fname):
-    """Split a filename into parts: path, base filename and extension.
-
-    Parameters
-    ----------
-    fname : str
-        file or path name
-
-    Returns
-    -------
-    pth : str
-        base path from fname
-    fname : str
-        filename from fname, without extension
-    ext : str
-        file extension from fname
-
-    Examples
-    --------
-    >>> from nipype.utils.filemanip import split_filename
-    >>> pth, fname, ext = split_filename('/home/data/subject.nii.gz')
-    >>> pth
-    '/home/data'
-
-    >>> fname
-    'subject'
-
-    >>> ext
-    '.nii.gz'
-
-    """
-
-    special_extensions = [".nii.gz", ".tar.gz", ".niml.dset"]
-
-    pth = op.dirname(fname)
-    fname = op.basename(fname)
-
-    ext = None
-    for special_ext in special_extensions:
-        ext_len = len(special_ext)
-        if (len(fname) > ext_len) and (fname[-ext_len:].lower() == special_ext.lower()):
-            ext = fname[-ext_len:]
-            fname = fname[:-ext_len]
-            break
-    if not ext:
-        fname, ext = op.splitext(fname)
-
-    return pth, fname, ext
-
-
-# Original source at L809 of <nipype-install>/interfaces/base/core.py
-def _filename_from_source(
-    name, chain=None, inputs=None, stdout=None, stderr=None, output_dir=None
-):
-    if chain is None:
-        chain = []
-
-    trait_spec = inputs.trait(name)
-    retval = getattr(inputs, name)
-    source_ext = None
-    if (retval is attrs.NOTHING) or "%s" in retval:
-        if not trait_spec.name_source:
-            return retval
-
-        # Do not generate filename when excluded by other inputs
-        if any(
-            (getattr(inputs, field) is not attrs.NOTHING)
-            for field in trait_spec.xor or ()
-        ):
-            return retval
-
-        # Do not generate filename when required fields are missing
-        if not all(
-            (getattr(inputs, field) is not attrs.NOTHING)
-            for field in trait_spec.requires or ()
-        ):
-            return retval
-
-        if (retval is not attrs.NOTHING) and "%s" in retval:
-            name_template = retval
-        else:
-            name_template = trait_spec.name_template
-        if not name_template:
-            name_template = "%s_generated"
-
-        ns = trait_spec.name_source
-        while isinstance(ns, (list, tuple)):
-            if len(ns) > 1:
-                iflogger.warning("Only one name_source per trait is allowed")
-            ns = ns[0]
-
-        if not isinstance(ns, (str, bytes)):
-            raise ValueError(
-                "name_source of '{}' trait should be an input trait "
-                "name, but a type {} object was found".format(name, type(ns))
-            )
-
-        if getattr(inputs, ns) is not attrs.NOTHING:
-            name_source = ns
-            source = getattr(inputs, name_source)
-            while isinstance(source, list):
-                source = source[0]
-
-            # special treatment for files
-            try:
-                _, base, source_ext = split_filename(source)
-            except (AttributeError, TypeError):
-                base = source
-        else:
-            if name in chain:
-                raise NipypeInterfaceError("Mutually pointing name_sources")
-
-            chain.append(name)
-            base = _filename_from_source(
-                ns,
-                chain,
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-            if base is not attrs.NOTHING:
-                _, _, source_ext = split_filename(base)
-            else:
-                # Do not generate filename when required fields are missing
-                return retval
-
-        chain = None
-        retval = name_template % base
-        _, _, ext = split_filename(retval)
-        if trait_spec.keep_extension and (ext or source_ext):
-            if (ext is None or not ext) and source_ext:
-                retval = retval + source_ext
-        else:
-            retval = _overload_extension(
-                retval,
-                name,
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-    return retval
-
-
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
-# Original source at L891 of <nipype-install>/interfaces/base/core.py
-def _list_outputs(inputs=None, stdout=None, stderr=None, output_dir=None):
-    metadata = dict(name_source=lambda t: t is not None)
-    traits = inputs.traits(**metadata)
-    if traits:
-        outputs = {}
-        for name, trait_spec in list(traits.items()):
-            out_name = name
-            if trait_spec.output_name is not None:
-                out_name = trait_spec.output_name
-            fname = _filename_from_source(
-                name, inputs=inputs, stdout=stdout, stderr=stderr, output_dir=output_dir
-            )
-            if fname is not attrs.NOTHING:
-                outputs[out_name] = os.path.abspath(fname)
-        return outputs
diff --git a/example-specs/task/nipype/fsl/x_fibres_5_callables.py b/example-specs/task/nipype/fsl/x_fibres_5_callables.py
index 50c01fec..8b82c68d 100644
--- a/example-specs/task/nipype/fsl/x_fibres_5_callables.py
+++ b/example-specs/task/nipype/fsl/x_fibres_5_callables.py
@@ -1,10 +1,10 @@
 """Module to put any functions that are referred to in the "callables" section of XFibres5.yaml"""
 
-from glob import glob
 import attrs
 import logging
 import os
 import os.path as op
+from glob import glob
 from pathlib import Path
 
 
@@ -22,25 +22,25 @@ def fsamples_callable(output_dir, inputs, stdout, stderr):
     return outputs["fsamples"]
 
 
-def mean_dsamples_callable(output_dir, inputs, stdout, stderr):
+def mean_S0samples_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["mean_dsamples"]
+    return outputs["mean_S0samples"]
 
 
-def mean_fsamples_callable(output_dir, inputs, stdout, stderr):
+def mean_dsamples_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["mean_fsamples"]
+    return outputs["mean_dsamples"]
 
 
-def mean_S0samples_callable(output_dir, inputs, stdout, stderr):
+def mean_fsamples_callable(output_dir, inputs, stdout, stderr):
     outputs = _list_outputs(
         output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr
     )
-    return outputs["mean_S0samples"]
+    return outputs["mean_fsamples"]
 
 
 def mean_tausamples_callable(output_dir, inputs, stdout, stderr):
@@ -67,42 +67,158 @@ def thsamples_callable(output_dir, inputs, stdout, stderr):
 IFLOGGER = logging.getLogger("nipype.interface")
 
 
-# Original source at L1069 of <nipype-install>/interfaces/base/core.py
-class PackageInfo(object):
-    _version = None
-    version_cmd = None
-    version_file = None
+# Original source at L885 of <nipype-install>/interfaces/base/core.py
+def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
+    raise NotImplementedError
 
-    @classmethod
-    def version(klass):
-        if klass._version is None:
-            if klass.version_cmd is not None:
-                try:
-                    clout = CommandLine(
-                        command=klass.version_cmd,
-                        resource_monitor=False,
-                        terminal_output="allatonce",
-                    ).run()
-                except IOError:
-                    return None
 
-                raw_info = clout.runtime.stdout
-            elif klass.version_file is not None:
-                try:
-                    with open(klass.version_file, "rt") as fobj:
-                        raw_info = fobj.read()
-                except OSError:
-                    return None
-            else:
-                return None
+# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
+def _gen_fname(
+    basename,
+    cwd=None,
+    suffix=None,
+    change_ext=True,
+    ext=None,
+    inputs=None,
+    stdout=None,
+    stderr=None,
+    output_dir=None,
+):
+    """Generate a filename based on the given parameters.
 
-            klass._version = klass.parse_version(raw_info)
+    The filename will take the form: cwd/basename<suffix><ext>.
+    If change_ext is True, it will use the extensions specified in
+    <instance>inputs.output_type.
 
-        return klass._version
+    Parameters
+    ----------
+    basename : str
+        Filename to base the new filename on.
+    cwd : str
+        Path to prefix to the new filename. (default is output_dir)
+    suffix : str
+        Suffix to add to the `basename`.  (defaults is '' )
+    change_ext : bool
+        Flag to change the filename extension to the FSL output type.
+        (default True)
 
-    @staticmethod
-    def parse_version(raw_info):
-        raise NotImplementedError
+    Returns
+    -------
+    fname : str
+        New filename based on given parameters.
+
+    """
+
+    if basename == "":
+        msg = "Unable to generate filename for command %s. " % "xfibres"
+        msg += "basename is not set!"
+        raise ValueError(msg)
+    if cwd is None:
+        cwd = output_dir
+    if ext is None:
+        ext = Info.output_type_to_ext(inputs.output_type)
+    if change_ext:
+        if suffix:
+            suffix = "".join((suffix, ext))
+        else:
+            suffix = ext
+    if suffix is None:
+        suffix = ""
+    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
+    return fname
+
+
+# Original source at L298 of <nipype-install>/interfaces/fsl/dti.py
+def _list_outputs(out_dir=None, inputs=None, stdout=None, stderr=None, output_dir=None):
+    outputs = {}
+    n_fibres = inputs.n_fibres
+    if not out_dir:
+        if inputs.logdir is not attrs.NOTHING:
+            out_dir = os.path.abspath(inputs.logdir)
+        else:
+            out_dir = os.path.abspath("logdir")
+
+    multi_out = ["dyads", "fsamples", "mean_fsamples", "phsamples", "thsamples"]
+    single_out = ["mean_dsamples", "mean_S0samples"]
+
+    for k in single_out:
+        outputs[k] = _gen_fname(
+            k,
+            cwd=out_dir,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+
+    if (inputs.rician is not attrs.NOTHING) and inputs.rician:
+        outputs["mean_tausamples"] = _gen_fname(
+            "mean_tausamples",
+            cwd=out_dir,
+            inputs=inputs,
+            stdout=stdout,
+            stderr=stderr,
+            output_dir=output_dir,
+        )
+
+    for k in multi_out:
+        outputs[k] = []
+
+    for i in range(1, n_fibres + 1):
+        outputs["fsamples"].append(
+            _gen_fname(
+                "f%dsamples" % i,
+                cwd=out_dir,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+        )
+        outputs["mean_fsamples"].append(
+            _gen_fname(
+                "mean_f%dsamples" % i,
+                cwd=out_dir,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+        )
+
+    for i in range(1, n_fibres + 1):
+        outputs["dyads"].append(
+            _gen_fname(
+                "dyads%d" % i,
+                cwd=out_dir,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+        )
+        outputs["phsamples"].append(
+            _gen_fname(
+                "ph%dsamples" % i,
+                cwd=out_dir,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+        )
+        outputs["thsamples"].append(
+            _gen_fname(
+                "th%dsamples" % i,
+                cwd=out_dir,
+                inputs=inputs,
+                stdout=stdout,
+                stderr=stderr,
+                output_dir=output_dir,
+            )
+        )
+
+    return outputs
 
 
 # Original source at L108 of <nipype-install>/utils/filemanip.py
@@ -199,6 +315,44 @@ def split_filename(fname):
     return pth, fname, ext
 
 
+# Original source at L1069 of <nipype-install>/interfaces/base/core.py
+class PackageInfo(object):
+    _version = None
+    version_cmd = None
+    version_file = None
+
+    @classmethod
+    def version(klass):
+        if klass._version is None:
+            if klass.version_cmd is not None:
+                try:
+                    clout = CommandLine(
+                        command=klass.version_cmd,
+                        resource_monitor=False,
+                        terminal_output="allatonce",
+                    ).run()
+                except IOError:
+                    return None
+
+                raw_info = clout.runtime.stdout
+            elif klass.version_file is not None:
+                try:
+                    with open(klass.version_file, "rt") as fobj:
+                        raw_info = fobj.read()
+                except OSError:
+                    return None
+            else:
+                return None
+
+            klass._version = klass.parse_version(raw_info)
+
+        return klass._version
+
+    @staticmethod
+    def parse_version(raw_info):
+        raise NotImplementedError
+
+
 # Original source at L40 of <nipype-install>/interfaces/fsl/base.py
 class Info(PackageInfo):
     """
@@ -290,157 +444,3 @@ def standard_image(img_name=None):
                 for filename in glob(os.path.join(stdpath, "*nii*"))
             ]
         return os.path.join(stdpath, img_name)
-
-
-# Original source at L205 of <nipype-install>/interfaces/fsl/base.py
-def _gen_fname(
-    basename,
-    cwd=None,
-    suffix=None,
-    change_ext=True,
-    ext=None,
-    inputs=None,
-    stdout=None,
-    stderr=None,
-    output_dir=None,
-):
-    """Generate a filename based on the given parameters.
-
-    The filename will take the form: cwd/basename<suffix><ext>.
-    If change_ext is True, it will use the extensions specified in
-    <instance>inputs.output_type.
-
-    Parameters
-    ----------
-    basename : str
-        Filename to base the new filename on.
-    cwd : str
-        Path to prefix to the new filename. (default is output_dir)
-    suffix : str
-        Suffix to add to the `basename`.  (defaults is '' )
-    change_ext : bool
-        Flag to change the filename extension to the FSL output type.
-        (default True)
-
-    Returns
-    -------
-    fname : str
-        New filename based on given parameters.
-
-    """
-
-    if basename == "":
-        msg = "Unable to generate filename for command %s. " % "xfibres"
-        msg += "basename is not set!"
-        raise ValueError(msg)
-    if cwd is None:
-        cwd = output_dir
-    if ext is None:
-        ext = Info.output_type_to_ext(inputs.output_type)
-    if change_ext:
-        if suffix:
-            suffix = "".join((suffix, ext))
-        else:
-            suffix = ext
-    if suffix is None:
-        suffix = ""
-    fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)
-    return fname
-
-
-# Original source at L885 of <nipype-install>/interfaces/base/core.py
-def _gen_filename(name, inputs=None, stdout=None, stderr=None, output_dir=None):
-    raise NotImplementedError
-
-
-# Original source at L298 of <nipype-install>/interfaces/fsl/dti.py
-def _list_outputs(out_dir=None, inputs=None, stdout=None, stderr=None, output_dir=None):
-    outputs = {}
-    n_fibres = inputs.n_fibres
-    if not out_dir:
-        if inputs.logdir is not attrs.NOTHING:
-            out_dir = os.path.abspath(inputs.logdir)
-        else:
-            out_dir = os.path.abspath("logdir")
-
-    multi_out = ["dyads", "fsamples", "mean_fsamples", "phsamples", "thsamples"]
-    single_out = ["mean_dsamples", "mean_S0samples"]
-
-    for k in single_out:
-        outputs[k] = _gen_fname(
-            k,
-            cwd=out_dir,
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-
-    if (inputs.rician is not attrs.NOTHING) and inputs.rician:
-        outputs["mean_tausamples"] = _gen_fname(
-            "mean_tausamples",
-            cwd=out_dir,
-            inputs=inputs,
-            stdout=stdout,
-            stderr=stderr,
-            output_dir=output_dir,
-        )
-
-    for k in multi_out:
-        outputs[k] = []
-
-    for i in range(1, n_fibres + 1):
-        outputs["fsamples"].append(
-            _gen_fname(
-                "f%dsamples" % i,
-                cwd=out_dir,
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-        )
-        outputs["mean_fsamples"].append(
-            _gen_fname(
-                "mean_f%dsamples" % i,
-                cwd=out_dir,
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-        )
-
-    for i in range(1, n_fibres + 1):
-        outputs["dyads"].append(
-            _gen_fname(
-                "dyads%d" % i,
-                cwd=out_dir,
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-        )
-        outputs["phsamples"].append(
-            _gen_fname(
-                "ph%dsamples" % i,
-                cwd=out_dir,
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-        )
-        outputs["thsamples"].append(
-            _gen_fname(
-                "th%dsamples" % i,
-                cwd=out_dir,
-                inputs=inputs,
-                stdout=stdout,
-                stderr=stderr,
-                output_dir=output_dir,
-            )
-        )
-
-    return outputs
diff --git a/nipype2pydra/pkg_gen/__init__.py b/nipype2pydra/pkg_gen/__init__.py
index da15d135..b1ef9305 100644
--- a/nipype2pydra/pkg_gen/__init__.py
+++ b/nipype2pydra/pkg_gen/__init__.py
@@ -347,30 +347,46 @@ def generate_callables(self, nipype_interface) -> str:
         )
         # Convert the "_gen_filename" method into a function with any referenced
         # methods, functions and constants included in the module
-        funcs, imports, consts = get_callable_sources(nipype_interface)
-        imports.add("import attrs")
-        callables_str += "\n".join(imports) + "\n\n"
+        funcs, classes, imports, consts = get_callable_sources(nipype_interface)
+
+        # Write imports to file
+        if any(
+            re.match(r"\battrs\b", s, flags=re.MULTILINE)
+            for s in (list(funcs) + classes)
+        ):
+            imports.add("import attrs")
+        obj_imports = set(i for i in imports if i.startswith("from"))
+        mod_imports = imports - obj_imports
+        callables_str += "\n".join(sorted(mod_imports)) + "\n"
+        callables_str += "\n".join(sorted(obj_imports)) + "\n\n"
+
         # Create separate default function for each input field with genfile, which
         # reference the magic "_gen_filename" method
-        for inpt_name, inpt in nipype_interface.input_spec().traits().items():
+        for inpt_name, inpt in sorted(nipype_interface.input_spec().traits().items()):
             if inpt.genfile:
                 callables_str += (
                     f"def {inpt_name}_default(inputs):\n"
                     f'    return _gen_filename("{inpt_name}", inputs=inputs)\n\n'
                 )
+
         # Create separate function for each output field in the "callables" section
         if nipype_interface.output_spec:
-            for output_name in nipype_interface.output_spec().traits().keys():
+            for output_name in sorted(nipype_interface.output_spec().traits().keys()):
                 if output_name not in INBUILT_NIPYPE_TRAIT_NAMES:
                     callables_str += (
                         f"def {output_name}_callable(output_dir, inputs, stdout, stderr):\n"
                         "    outputs = _list_outputs(output_dir=output_dir, inputs=inputs, stdout=stdout, stderr=stderr)\n"
                         '    return outputs["' + output_name + '"]\n\n'
                     )
-        # Add any constants to the module
-        for const in consts:
+
+        # Add any constants to the file
+        for const in sorted(consts):
             callables_str += f"{const[0]} = {const[1]}\n" + "\n\n"
+
+        # Write functions and classes to the file
         callables_str += "\n\n".join(funcs) + "\n\n"
+        callables_str += "\n\n".join(classes) + "\n\n"
+
         # Format the generated code with black
         try:
             callables_str = black.format_file_contents(
@@ -793,7 +809,7 @@ def gen_sample_{frmt.lower()}_data({frmt.lower()}: {frmt}, dest_dir: Path, seed:
 
 def get_callable_sources(
     nipype_interface,
-) -> ty.Tuple[ty.List[str], ty.Set[str], ty.Set[ty.Tuple[str, str]]]:
+) -> ty.Tuple[ty.Set[str], ty.List[str], ty.Set[str], ty.Set[ty.Tuple[str, str]]]:
     """
     Convert the _gen_filename method of a nipype interface into a function that can be
     imported and used by the auto-convert scripts
@@ -805,24 +821,16 @@ def get_callable_sources(
 
     Returns
     -------
+    set[str]
+        the source code of functions to be added to the callables module
     list[str]
-        the source code of functions to be added to the callables
+        the source code of classes to be added to the callables module
     set[str]
-        the imports required for the function
+        the imports required for the functions and classes
     set[tuple[str, str]]
-        the external constants required by the function, as (name, value) tuples
+        the external constants required by the functions and classes in (name, value) tuples
     """
 
-    if not hasattr(nipype_interface, "_gen_filename"):
-        func_src = f"""
-def _gen_filename(field, inputs, output_dir, stdout, stderr):
-    raise NotImplementedError(
-        "Could not find '_gen_filename' method in {nipype_interface.__module__}.{nipype_interface.__name__}"
-    )
-"""
-        warn(f"Could not find '_gen_filename' method in {nipype_interface}")
-        return [func_src], set(), set()
-
     IMPLICIT_ARGS = ["inputs", "stdout", "stderr", "output_dir"]
 
     def common_parent_pkg_prefix(mod_name: str) -> str:
@@ -985,21 +993,20 @@ def insert_args_in_method_calls(
             process_method(method, method_name, name_map, nipype_interface.__name__)
         )
     # Initialise the source code, imports and constants
-    all_funcs = []
+    all_funcs = set()
+    all_classes = []
     all_imports = set()
     all_constants = set()
     for mod_name, methods in grouped_methods.items():
         mod = import_module(mod_name)
         used = UsedSymbols.find(mod, methods)
-        all_funcs.extend(methods)
+        all_funcs.update(methods)
         for func in used.local_functions:
-            func_src = cleanup_function_body(get_source_code(func))
-            if func_src not in all_funcs:
-                all_funcs.append(func_src)
+            all_funcs.add(cleanup_function_body(get_source_code(func)))
         for klass in used.local_classes:
             klass_src = cleanup_function_body(get_source_code(klass))
-            if klass_src not in all_funcs:
-                all_funcs.append(klass_src)
+            if klass_src not in all_classes:
+                all_classes.append(klass_src)
         for new_func_name, func in used.funcs_to_include:
             func_src = get_source_code(func)
             location_comment, func_src = func_src.split("\n", 1)
@@ -1016,9 +1023,7 @@ def insert_args_in_method_calls(
                 + new_func_name
                 + match.group(2)
             )
-            func_src = cleanup_function_body(func_src)
-            if func_src not in all_funcs:
-                all_funcs.append(func_src)
+            all_funcs.add(cleanup_function_body(func_src))
         for new_klass_name, klass in used.classes_to_include:
             klass_src = get_source_code(klass)
             location_comment, klass_src = klass_src.split("\n", 1)
@@ -1036,12 +1041,16 @@ def insert_args_in_method_calls(
                 + match.group(2)
             )
             klass_src = cleanup_function_body(klass_src)
-            if klass_src not in all_funcs:
-                all_funcs.append(klass_src)
+            if klass_src not in all_classes:
+                all_classes.append(klass_src)
         all_imports.update(used.imports)
         all_constants.update(used.constants)
     return (
-        reversed(all_funcs),  # Ensure base classes are defined first
+        sorted(
+            all_funcs,
+            key=lambda s: next(s for s in s.splitlines() if s.startswith("def")),
+        ),
+        list(reversed(all_classes)),  # Ensure base classes are defined first
         all_imports,
         all_constants,
     )

From c29d821b41de12fe4744ca087a7c707ae5339f4a Mon Sep 17 00:00:00 2001
From: Tom Close <tom.g.close@gmail.com>
Date: Thu, 14 Mar 2024 17:42:36 +1100
Subject: [PATCH 65/78] updated pyproject to only include selected fileformats
 packagse

---
 pyproject.toml | 66 ++++++--------------------------------------------
 1 file changed, 8 insertions(+), 58 deletions(-)

diff --git a/pyproject.toml b/pyproject.toml
index d8c278fe..6d435b55 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -19,20 +19,10 @@ dependencies = [
     "requests>=2.31.0",
     "traits",
 ]
-license = {file = "LICENSE"}
-authors = [
-    {name = "Thomas G. Close", email = "tom.g.close@gmail.com"},
-]
-maintainers = [
-    {name = "Thomas G. Close", email = "tom.g.close@gmail.com"},
-]
-keywords = [
-    "nipype",
-    "data",
-    "pydra",
-    "workflows",
-    "converters",
-]
+license = { file = "LICENSE" }
+authors = [{ name = "Thomas G. Close", email = "tom.g.close@gmail.com" }]
+maintainers = [{ name = "Thomas G. Close", email = "tom.g.close@gmail.com" }]
+keywords = ["nipype", "data", "pydra", "workflows", "converters"]
 classifiers = [
     "Development Status :: 3 - Alpha",
     "Environment :: Console",
@@ -50,12 +40,7 @@ classifiers = [
 dynamic = ["version"]
 
 [project.optional-dependencies]
-dev = [
-    "pre-commit",
-    "codespell",
-    "flake8",
-    "flake8-pyproject",
-]
+dev = ["pre-commit", "codespell", "flake8", "flake8-pyproject"]
 test = [
     "pytest >=6.2.5",
     "pytest-env>=0.6.2",
@@ -63,37 +48,8 @@ test = [
     "fileformats-medimage-extras",
     "fileformats-medimage-afni",
     "fileformats-medimage-ants",
-    "fileformats-medimage-brainsuite",
-    "fileformats-medimage-bru2nii",
-    "fileformats-medimage-c3",
-    "fileformats-medimage-camino",
-    "fileformats-medimage-camino2trackvis",
-    "fileformats-medimage-cat12",
-    "fileformats-medimage-cmtk",
-    "fileformats-medimage-dcmstack",
-    "fileformats-medimage-diffusion_toolkit",
-    "fileformats-medimage-dipy",
-    "fileformats-medimage-dtitk",
-    "fileformats-medimage-dynamic_slicer",
-    "fileformats-medimage-elastix",
     "fileformats-medimage-freesurfer",
     "fileformats-medimage-fsl",
-    "fileformats-medimage-meshfix",
-    "fileformats-medimage-minc",
-    "fileformats-medimage-mipav",
-    "fileformats-medimage-niftyfit",
-    "fileformats-medimage-niftyreg",
-    "fileformats-medimage-niftyseg",
-    "fileformats-medimage-nilearn",
-    "fileformats-medimage-nitime",
-    "fileformats-medimage-petpvc",
-    "fileformats-medimage-quickshear",
-    "fileformats-medimage-robex",
-    "fileformats-medimage-semtools",
-    "fileformats-medimage-slicer",
-    "fileformats-medimage-spm",
-    "fileformats-medimage-vista",
-    "fileformats-medimage-workbench",
     "qsiprep",
 ]
 docs = [
@@ -123,12 +79,8 @@ version-file = "nipype2pydra/_version.py"
 allow-direct-references = true
 
 [tool.hatch.build]
-packages = [
-    "nipype2pydra",
-]
-exclude = [
-    "/tests",
-]
+packages = ["nipype2pydra"]
+exclude = ["/tests"]
 
 [tool.black]
 line-length = 88
@@ -140,9 +92,7 @@ ignore-words = ".codespell-ignorewords"
 
 [tool.flake8]
 doctests = true
-per-file-ignores = [
-    "__init__.py:F401"
-]
+per-file-ignores = ["__init__.py:F401"]
 max-line-length = 88
 select = "C,E,F,W,B,B950"
 extend-ignore = ['E203', 'E501', 'E129', 'W503']

From 4f4cb7059f464c0aeed369bce0b2c68d8ae292e0 Mon Sep 17 00:00:00 2001
From: Tom Close <tom.g.close@gmail.com>
Date: Thu, 14 Mar 2024 21:02:00 +1100
Subject: [PATCH 66/78] explicitly use python3

---
 .github/workflows/tests.yml | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
index 5b2e47fb..3dd0d923 100644
--- a/.github/workflows/tests.yml
+++ b/.github/workflows/tests.yml
@@ -33,16 +33,16 @@ jobs:
         python-version: ${{ matrix.python-version }}
 
     - name: Update build tools
-      run: python -m pip install --upgrade pip
+      run: python3 -m pip install --upgrade pip
 
     - name: Install required file-formats packages
       run: |
         pushd required-fileformats
-        python -m pip install -r requirements.txt
+        python3 -m pip install -r requirements.txt
         popd
 
     - name: Install Package
-      run: python -m pip install -e .[test]
+      run: python3 -m pip install -e .[test]
 
     - name: Pytest
       run: pytest -vvs --cov nipype2pydra --cov-config .coveragerc --cov-report xml

From f6ca0a106957444d46d1a68654983a7464540b26 Mon Sep 17 00:00:00 2001
From: Tom Close <tom.g.close@gmail.com>
Date: Thu, 14 Mar 2024 21:09:19 +1100
Subject: [PATCH 67/78] added python3-packaging to gh action

---
 .github/workflows/tests.yml | 15 ++++++++++++---
 1 file changed, 12 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
index 3dd0d923..711ab729 100644
--- a/.github/workflows/tests.yml
+++ b/.github/workflows/tests.yml
@@ -23,9 +23,18 @@ jobs:
       run:
         shell: bash -l {0}
     steps:
+    - name: Install Ubuntu packaging
+      run: sudo apt update && sudo apt install -y python3-packaging
+
     - uses: actions/checkout@v2
-    - name: Disable etelemetry
-      run:  echo "NO_ET=TRUE" >> $GITHUB_ENV
+
+    - name: Unset header
+      # checkout@v2 adds a header that makes branch protection report errors
+      # because the Github action bot is not a collaborator on the repo
+      run: git config --local --unset http.https://github.com/.extraheader
+
+    - name: Fetch tags
+      run: git fetch --prune --unshallow
 
     - name: Set up Python ${{ matrix.python-version }} on ${{ matrix.os }}
       uses: actions/setup-python@v2
@@ -33,7 +42,7 @@ jobs:
         python-version: ${{ matrix.python-version }}
 
     - name: Update build tools
-      run: python3 -m pip install --upgrade pip
+      run: python3 -m pip install --upgrade pip build
 
     - name: Install required file-formats packages
       run: |

From fc1a10b5955f938cfbae3cb0e4e1a41da67f0d2c Mon Sep 17 00:00:00 2001
From: Tom Close <tom.g.close@gmail.com>
Date: Thu, 14 Mar 2024 21:16:09 +1100
Subject: [PATCH 68/78] added packaging dependency

---
 .github/workflows/tests.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
index 711ab729..e26900b4 100644
--- a/.github/workflows/tests.yml
+++ b/.github/workflows/tests.yml
@@ -42,7 +42,7 @@ jobs:
         python-version: ${{ matrix.python-version }}
 
     - name: Update build tools
-      run: python3 -m pip install --upgrade pip build
+      run: python3 -m pip install --upgrade pip build packaging
 
     - name: Install required file-formats packages
       run: |

From 002069604973827af4d86ce13b532bddb55c3817 Mon Sep 17 00:00:00 2001
From: Tom Close <tom.g.close@gmail.com>
Date: Fri, 15 Mar 2024 11:00:26 +1100
Subject: [PATCH 69/78] fixed up unittests

---
 nipype2pydra/pkg_gen/__init__.py |  1 -
 nipype2pydra/testing.py          | 13 +++++++++----
 nipype2pydra/tests/test_utils.py | 11 +++++------
 3 files changed, 14 insertions(+), 11 deletions(-)

diff --git a/nipype2pydra/pkg_gen/__init__.py b/nipype2pydra/pkg_gen/__init__.py
index b1ef9305..8bcb2fcf 100644
--- a/nipype2pydra/pkg_gen/__init__.py
+++ b/nipype2pydra/pkg_gen/__init__.py
@@ -1,7 +1,6 @@
 import os
 import typing as ty
 import re
-import inspect
 from importlib import import_module
 from copy import copy
 from collections import defaultdict
diff --git a/nipype2pydra/testing.py b/nipype2pydra/testing.py
index d718dcf2..c28d9ca3 100644
--- a/nipype2pydra/testing.py
+++ b/nipype2pydra/testing.py
@@ -1,7 +1,12 @@
-import logging
-import asyncio
-from pydra.engine.core import Result, TaskBase
-from pydra.engine.workers import ConcurrentFuturesWorker
+def test_line_number_of_function():
+    """Test function used to test the detection of a line number of a function."""
+    return 1
+
+
+import logging  # noqa: E402
+import asyncio  # noqa: E402
+from pydra.engine.core import Result, TaskBase  # noqa: E402
+from pydra.engine.workers import ConcurrentFuturesWorker  # noqa: E402
 
 
 logger = logging.getLogger("pydra")
diff --git a/nipype2pydra/tests/test_utils.py b/nipype2pydra/tests/test_utils.py
index 8d208edd..56486866 100644
--- a/nipype2pydra/tests/test_utils.py
+++ b/nipype2pydra/tests/test_utils.py
@@ -1,4 +1,5 @@
 from nipype2pydra.utils import extract_args, get_source_code
+from nipype2pydra.testing import test_line_number_of_function
 
 
 def test_split_parens_contents1():
@@ -76,9 +77,7 @@ def test_split_parens_contents8():
 
 
 def test_split_parens_contents9():
-    assert extract_args(
-        'foo(cwd=bar("tmpdir"), basename="maskexf")'
-    ) == (
+    assert extract_args('foo(cwd=bar("tmpdir"), basename="maskexf")') == (
         "foo(",
         ['cwd=bar("tmpdir")', 'basename="maskexf"'],
         ")",
@@ -86,7 +85,7 @@ def test_split_parens_contents9():
 
 
 def test_source_code():
-    assert get_source_code(extract_args).splitlines()[:2] == [
-        "# Original source at L153 of <nipype2pydra-install>/utils.py",
-        "def extract_args(snippet: str) -> ty.Tuple[str, ty.List[str], str]:"
+    assert get_source_code(test_line_number_of_function).splitlines()[:2] == [
+        "# Original source at L1 of <nipype2pydra-install>/testing.py",
+        "def test_line_number_of_function():",
     ]

From 6dc4e9f316ac6ffe69caf31153bb3098783e8c83 Mon Sep 17 00:00:00 2001
From: Tom Close <tom.g.close@gmail.com>
Date: Fri, 15 Mar 2024 17:23:29 +1100
Subject: [PATCH 70/78] added packaging dependency to pyproject.toml

---
 pyproject.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pyproject.toml b/pyproject.toml
index 6d435b55..be6b1b48 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,5 +1,5 @@
 [build-system]
-requires = ["hatchling", "hatch-vcs"]
+requires = ["hatchling", "hatch-vcs", "packaging"]
 build-backend = "hatchling.build"
 
 [project]

From 741e54ecad520040a8dd2df60f7a072adb626600 Mon Sep 17 00:00:00 2001
From: Tom Close <tom.g.close@gmail.com>
Date: Sat, 16 Mar 2024 09:35:59 +1100
Subject: [PATCH 71/78] combined test and  publish github actions

---
 .github/workflows/ci-cd.yml   | 108 ++++++++++++++++++++++++++++++++++
 .github/workflows/publish.yml |  36 ------------
 .github/workflows/tests.yml   |  63 --------------------
 pyproject.toml                |   2 +-
 4 files changed, 109 insertions(+), 100 deletions(-)
 create mode 100644 .github/workflows/ci-cd.yml
 delete mode 100644 .github/workflows/publish.yml
 delete mode 100644 .github/workflows/tests.yml

diff --git a/.github/workflows/ci-cd.yml b/.github/workflows/ci-cd.yml
new file mode 100644
index 00000000..90169ad5
--- /dev/null
+++ b/.github/workflows/ci-cd.yml
@@ -0,0 +1,108 @@
+name: CI/CD
+
+on:
+  push:
+    branches: [ main, develop ]
+  pull_request:
+    branches: [ main, develop ]
+  release:
+    types: [published]
+
+defaults:
+  run:
+    shell: bash
+
+jobs:
+  test:
+    strategy:
+      matrix:
+        os: [macos-latest, ubuntu-latest]
+        python-version: ["3.8", "3.11"]
+      fail-fast: false
+    runs-on: ${{ matrix.os }}
+    defaults:
+      run:
+        shell: bash -l {0}
+
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v2
+
+    - name: Unset header
+      # checkout@v2 adds a header that makes branch protection report errors
+      # because the Github action bot is not a collaborator on the repo
+      run: git config --local --unset http.https://github.com/.extraheader
+
+    - name: Fetch tags
+      run: git fetch --prune --unshallow
+
+    - name: Disable etelemetry
+      run:  echo "NO_ET=TRUE" >> $GITHUB_ENV
+
+    - name: Set up Python ${{ matrix.python-version }} on ${{ matrix.os }}
+      uses: actions/setup-python@v2
+      with:
+        python-version: ${{ matrix.python-version }}
+
+    - name: Update build tools
+      run: python3 -m pip install --upgrade pip setuptools wheel
+
+    - name: Install required file-formats packages
+      run: |
+        pushd required-fileformats
+        python3 -m pip install -r requirements.txt
+        popd
+
+    - name: Install Package
+      run: python3 -m pip install -e .[test]
+
+    - name: Pytest
+      run: pytest -vvs --cov nipype2pydra --cov-config .coveragerc --cov-report xml
+
+    - name: Upload coverage to Codecov
+      uses: codecov/codecov-action@v2
+      with:
+        fail_ci_if_error: true
+        token: ${{ secrets.CODECOV_TOKEN }}
+
+  deploy:
+    needs: [test]
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v3
+      with:
+        submodules: recursive
+        fetch-depth: 0
+
+    - name: Unset header
+      # checkout@v2 adds a header that makes branch protection report errors
+      # because the Github action bot is not a collaborator on the repo
+      run: git config --local --unset http.https://github.com/.extraheader
+
+    - name: Set up Python
+      uses: actions/setup-python@v4
+      with:
+        python-version: '3.11'
+
+    - name: Install build tools
+      run: python3 -m pip install build twine
+
+    - name: Build source and wheel distributions
+      run: python3 -m build .
+
+    - name: Check distributions
+      run: twine check dist/*
+
+    - name: Check for PyPI token on tag
+      id: deployable
+      if: github.event_name == 'release'
+      env:
+        PYPI_API_TOKEN: "${{ secrets.PYPI_API_TOKEN }}"
+      run: if [ -n "$PYPI_API_TOKEN" ]; then echo "DEPLOY=true" >> $GITHUB_OUTPUT; fi
+
+    - name: Upload to PyPI
+      if: steps.deployable.outputs.DEPLOY
+      uses: pypa/gh-action-pypi-publish@release/v1
+      with:
+        user: __token__
+        password: ${{ secrets.PYPI_API_TOKEN }}
diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml
deleted file mode 100644
index ec4aea63..00000000
--- a/.github/workflows/publish.yml
+++ /dev/null
@@ -1,36 +0,0 @@
-# This workflows will upload a Python Package using Twine when a release is created
-# For more information see: https://help.github.com/en/actions/language-and-framework-guides/using-python-with-github-actions#publishing-to-package-registries
-
-name: Upload to PyPI
-
-on:
-  release:
-    types: [published]
-
-jobs:
-  deploy:
-    runs-on: ubuntu-latest
-
-    steps:
-    - name: Checkout
-      uses: actions/checkout@v2
-    - name: Unset header
-        # checkout@v2 adds a header that makes branch protection report errors
-        # because the Github action bot is not a collaborator on the repo
-      run: git config --local --unset http.https://github.com/.extraheader
-    - name: Set up Python
-      uses: actions/setup-python@v2
-      with:
-        python-version: '3.x'
-    - name: Install dependencies
-      run: |
-        python -m pip install --upgrade pip
-        python -m pip install twine build
-
-    - name: Build and publish
-      env:
-        TWINE_USERNAME: __token__
-        TWINE_PASSWORD: ${{ secrets.PYPI_TOKEN }}
-      run: |
-        python -m build
-        twine upload dist/*
diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
deleted file mode 100644
index e26900b4..00000000
--- a/.github/workflows/tests.yml
+++ /dev/null
@@ -1,63 +0,0 @@
-name: Tests
-
-on:
-  push:
-    branches:
-      - main
-      - develop
-  pull_request:
-
-defaults:
-  run:
-    shell: bash
-
-jobs:
-  build:
-    strategy:
-      matrix:
-        os: [ubuntu-latest]
-        python-version: ["3.8", "3.11"]
-      fail-fast: false
-    runs-on: ${{ matrix.os }}
-    defaults:
-      run:
-        shell: bash -l {0}
-    steps:
-    - name: Install Ubuntu packaging
-      run: sudo apt update && sudo apt install -y python3-packaging
-
-    - uses: actions/checkout@v2
-
-    - name: Unset header
-      # checkout@v2 adds a header that makes branch protection report errors
-      # because the Github action bot is not a collaborator on the repo
-      run: git config --local --unset http.https://github.com/.extraheader
-
-    - name: Fetch tags
-      run: git fetch --prune --unshallow
-
-    - name: Set up Python ${{ matrix.python-version }} on ${{ matrix.os }}
-      uses: actions/setup-python@v2
-      with:
-        python-version: ${{ matrix.python-version }}
-
-    - name: Update build tools
-      run: python3 -m pip install --upgrade pip build packaging
-
-    - name: Install required file-formats packages
-      run: |
-        pushd required-fileformats
-        python3 -m pip install -r requirements.txt
-        popd
-
-    - name: Install Package
-      run: python3 -m pip install -e .[test]
-
-    - name: Pytest
-      run: pytest -vvs --cov nipype2pydra --cov-config .coveragerc --cov-report xml
-
-    - name: Upload coverage to Codecov
-      uses: codecov/codecov-action@v2
-      with:
-        fail_ci_if_error: true
-        token: ${{ secrets.CODECOV_TOKEN }}
diff --git a/pyproject.toml b/pyproject.toml
index be6b1b48..6d435b55 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,5 +1,5 @@
 [build-system]
-requires = ["hatchling", "hatch-vcs", "packaging"]
+requires = ["hatchling", "hatch-vcs"]
 build-backend = "hatchling.build"
 
 [project]

From daa5268e3278e2ddad8ef7a2df4254d9ec7dcc83 Mon Sep 17 00:00:00 2001
From: Tom Close <tom.g.close@gmail.com>
Date: Sat, 16 Mar 2024 09:42:55 +1100
Subject: [PATCH 72/78] added setuptools and packaging to build-system requires

---
 pyproject.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pyproject.toml b/pyproject.toml
index 6d435b55..f57cd1b8 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,5 +1,5 @@
 [build-system]
-requires = ["hatchling", "hatch-vcs"]
+requires = ["hatchling", "hatch-vcs", "setuptools", "packaging"]
 build-backend = "hatchling.build"
 
 [project]

From b622398959597892a2487956402ca3e8610bedfb Mon Sep 17 00:00:00 2001
From: Tom Close <tom.g.close@gmail.com>
Date: Sat, 16 Mar 2024 09:45:09 +1100
Subject: [PATCH 73/78] separate install of dipy

---
 .github/workflows/ci-cd.yml | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/ci-cd.yml b/.github/workflows/ci-cd.yml
index 90169ad5..b508d6f8 100644
--- a/.github/workflows/ci-cd.yml
+++ b/.github/workflows/ci-cd.yml
@@ -53,8 +53,11 @@ jobs:
         python3 -m pip install -r requirements.txt
         popd
 
+    - name: Install Dipy separately as it was causing trouble
+      run: python3 -m pip install dipy
+
     - name: Install Package
-      run: python3 -m pip install -e .[test]
+      run: python3 -m pip install .[test]
 
     - name: Pytest
       run: pytest -vvs --cov nipype2pydra --cov-config .coveragerc --cov-report xml

From 547cd95dc90ffeaaba4045196c6599bb008dd4d5 Mon Sep 17 00:00:00 2001
From: Tom Close <tom.g.close@gmail.com>
Date: Sat, 16 Mar 2024 09:47:10 +1100
Subject: [PATCH 74/78] dropped qsiprep from tests config

---
 pyproject.toml | 1 -
 1 file changed, 1 deletion(-)

diff --git a/pyproject.toml b/pyproject.toml
index f57cd1b8..81762be8 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -50,7 +50,6 @@ test = [
     "fileformats-medimage-ants",
     "fileformats-medimage-freesurfer",
     "fileformats-medimage-fsl",
-    "qsiprep",
 ]
 docs = [
     "packaging",

From fa09577045efb00fe65958d103112081af5b1844 Mon Sep 17 00:00:00 2001
From: Tom Close <tom.g.close@gmail.com>
Date: Sat, 16 Mar 2024 12:08:49 +1100
Subject: [PATCH 75/78] marked EPI de warp as xfail due to 'exfdw' being marked
 as a string rather than a file

---
 nipype2pydra/task/tests/test_task.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/nipype2pydra/task/tests/test_task.py b/nipype2pydra/task/tests/test_task.py
index b79b68df..04d8c1b4 100644
--- a/nipype2pydra/task/tests/test_task.py
+++ b/nipype2pydra/task/tests/test_task.py
@@ -17,6 +17,7 @@
     "fsl-flameo",
     "fsl-make_dyadic_vectors",
     "fsl-dual_regression",
+    "fsl-epi_de_warp",
 ]
 
 XFAIL_INTERFACES_IN_COMBINED = [

From 1a703a3c3697909af58dd7323a9ef982031221d4 Mon Sep 17 00:00:00 2001
From: Tom Close <tom.g.close@gmail.com>
Date: Sat, 16 Mar 2024 12:37:31 +1100
Subject: [PATCH 76/78] added sanity check to test task

---
 nipype2pydra/task/tests/test_task.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/nipype2pydra/task/tests/test_task.py b/nipype2pydra/task/tests/test_task.py
index 04d8c1b4..4025a8d8 100644
--- a/nipype2pydra/task/tests/test_task.py
+++ b/nipype2pydra/task/tests/test_task.py
@@ -76,6 +76,7 @@ def test_task_conversion(task_spec_file, cli_runner, work_dir, gen_test_conftest
         nipype_interface = getattr(
             import_module(task_spec["nipype_module"]), task_spec["nipype_name"]
         )
+        assert nipype_interface.__name__ == task_spec["nipype_name"]  # sanity check
 
         nipype_input_names = nipype_interface.input_spec().all_trait_names()
         inputs_omit = task_spec["inputs"]["omit"] if task_spec["inputs"]["omit"] else []

From b5442471eaf4a597cc9422b1bcfd802136e21f7b Mon Sep 17 00:00:00 2001
From: Tom Close <tom.g.close@gmail.com>
Date: Sat, 16 Mar 2024 12:50:41 +1100
Subject: [PATCH 77/78] added more xfails for combined tests

---
 nipype2pydra/task/tests/test_task.py | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/nipype2pydra/task/tests/test_task.py b/nipype2pydra/task/tests/test_task.py
index 4025a8d8..3b7b5518 100644
--- a/nipype2pydra/task/tests/test_task.py
+++ b/nipype2pydra/task/tests/test_task.py
@@ -25,6 +25,9 @@
     "freesurfer-apply_mask",
     "afni-merge",
     "afni-resample",
+    "fsl-level_1_design",
+    "fsl-apply_mask",
+    "fsl-smooth",
 ]
 
 

From 6c76ea61ced27285ebe5632a8c83722352f3c65e Mon Sep 17 00:00:00 2001
From: Tom Close <tom.g.close@gmail.com>
Date: Sat, 16 Mar 2024 12:58:05 +1100
Subject: [PATCH 78/78] added another of the mixed up interfaces

---
 nipype2pydra/task/tests/test_task.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/nipype2pydra/task/tests/test_task.py b/nipype2pydra/task/tests/test_task.py
index 3b7b5518..a2ff8e1f 100644
--- a/nipype2pydra/task/tests/test_task.py
+++ b/nipype2pydra/task/tests/test_task.py
@@ -28,6 +28,7 @@
     "fsl-level_1_design",
     "fsl-apply_mask",
     "fsl-smooth",
+    "fsl-merge",
 ]